Sign upLogin

Godley/MuseParse

View on GitHub
Star
MuseParse/classes/ObjectHierarchy/ItemClasses/Note.py

Summary

Maintainability
F
5 days
Test Coverage

File Note.py has 686 lines of code (exceeds 250 allowed). Consider refactoring.
Open

import math

from MuseParse.classes.ObjectHierarchy.ItemClasses import BaseClass, Mark, Ornaments
Severity: Major
Found in MuseParse/classes/ObjectHierarchy/ItemClasses/Note.py - About 1 day to fix

    Function getLilyDuration has a Cognitive Complexity of 35 (exceeds 5 allowed). Consider refactoring.
    Open

        def getLilyDuration(self):
        """
        method to calculate duration of note in lilypond duration style
        :return:
        """
    Severity: Minor
    Found in MuseParse/classes/ObjectHierarchy/ItemClasses/Note.py - About 5 hrs to fix

    Cognitive Complexity

    Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

    A method's cognitive complexity is based on a few simple rules:

    • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
    • Code is considered more complex for each "break in the linear flow of the code"
    • Code is considered more complex when "flow breaking structures are nested"

    Further reading

    Cyclomatic complexity is too high in method addNotation. (20)
    Open

        def addNotation(self, obj):
        '''
        Method to add new notation. Use this rather than adding directly so new classes can be added automatically
        without needing to know which list to add it to in the main code.
        :param obj: the object to add
    Severity: Minor
    Found in MuseParse/classes/ObjectHierarchy/ItemClasses/Note.py by radon

    Cyclomatic Complexity

    Cyclomatic Complexity corresponds to the number of decisions a block of code contains plus 1. This number (also called McCabe number) is equal to the number of linearly independent paths through the code. This number can be used as a guide when testing conditional logic in blocks.

    Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

    Construct Effect on CC Reasoning
    if +1 An if statement is a single decision.
    elif +1 The elif statement adds another decision.
    else +0 The else statement does not cause a new decision. The decision is at the if.
    for +1 There is a decision at the start of the loop.
    while +1 There is a decision at the while statement.
    except +1 Each except branch adds a new conditional path of execution.
    finally +0 The finally block is unconditionally executed.
    with +1 The with statement roughly corresponds to a try/except block (see PEP 343 for details).
    assert +1 The assert statement internally roughly equals a conditional statement.
    Comprehension +1 A list/set/dict comprehension of generator expression is equivalent to a for loop.
    Boolean Operator +1 Every boolean operator (and, or) adds a decision point.

    Source: http://radon.readthedocs.org/en/latest/intro.html

    Function addNotation has a Cognitive Complexity of 27 (exceeds 5 allowed). Consider refactoring.
    Open

        def addNotation(self, obj):
        '''
        Method to add new notation. Use this rather than adding directly so new classes can be added automatically
        without needing to know which list to add it to in the main code.
        :param obj: the object to add
    Severity: Minor
    Found in MuseParse/classes/ObjectHierarchy/ItemClasses/Note.py - About 3 hrs to fix

    Cognitive Complexity

    Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

    A method's cognitive complexity is based on a few simple rules:

    • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
    • Code is considered more complex for each "break in the linear flow of the code"
    • Code is considered more complex when "flow breaking structures are nested"

    Further reading

    Cyclomatic complexity is too high in method handlePostLilies. (18)
    Open

        def handlePostLilies(self):
        val = ""
        if hasattr(self, "chord") and self.chord == "stop":
            val += ">"
            val += self.getLilyDuration()
    Severity: Minor
    Found in MuseParse/classes/ObjectHierarchy/ItemClasses/Note.py by radon

    Cyclomatic Complexity

    Cyclomatic Complexity corresponds to the number of decisions a block of code contains plus 1. This number (also called McCabe number) is equal to the number of linearly independent paths through the code. This number can be used as a guide when testing conditional logic in blocks.

    Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

    Construct Effect on CC Reasoning
    if +1 An if statement is a single decision.
    elif +1 The elif statement adds another decision.
    else +0 The else statement does not cause a new decision. The decision is at the if.
    for +1 There is a decision at the start of the loop.
    while +1 There is a decision at the while statement.
    except +1 Each except branch adds a new conditional path of execution.
    finally +0 The finally block is unconditionally executed.
    with +1 The with statement roughly corresponds to a try/except block (see PEP 343 for details).
    assert +1 The assert statement internally roughly equals a conditional statement.
    Comprehension +1 A list/set/dict comprehension of generator expression is equivalent to a for loop.
    Boolean Operator +1 Every boolean operator (and, or) adds a decision point.

    Source: http://radon.readthedocs.org/en/latest/intro.html

    Cyclomatic complexity is too high in method toLily. (16)
    Open

        def toLily(self):
        val = ""
        value = ""
        if hasattr(self, "print") and not self.print:
            val += "\n\\hideNotes\n"
    Severity: Minor
    Found in MuseParse/classes/ObjectHierarchy/ItemClasses/Note.py by radon

    Cyclomatic Complexity

    Cyclomatic Complexity corresponds to the number of decisions a block of code contains plus 1. This number (also called McCabe number) is equal to the number of linearly independent paths through the code. This number can be used as a guide when testing conditional logic in blocks.

    Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

    Construct Effect on CC Reasoning
    if +1 An if statement is a single decision.
    elif +1 The elif statement adds another decision.
    else +0 The else statement does not cause a new decision. The decision is at the if.
    for +1 There is a decision at the start of the loop.
    while +1 There is a decision at the while statement.
    except +1 Each except branch adds a new conditional path of execution.
    finally +0 The finally block is unconditionally executed.
    with +1 The with statement roughly corresponds to a try/except block (see PEP 343 for details).
    assert +1 The assert statement internally roughly equals a conditional statement.
    Comprehension +1 A list/set/dict comprehension of generator expression is equivalent to a for loop.
    Boolean Operator +1 Every boolean operator (and, or) adds a decision point.

    Source: http://radon.readthedocs.org/en/latest/intro.html

    Cyclomatic complexity is too high in method GetNotation. (16)
    Open

        def GetNotation(self, id, type):
        '''
        method which searches for notation from <type> list at position <id>
        :param id: the number to look for - i.e if you're looking for the first one in wrap notation, id will be 0
        :param type: post, pre or wrap
    Severity: Minor
    Found in MuseParse/classes/ObjectHierarchy/ItemClasses/Note.py by radon

    Cyclomatic Complexity

    Cyclomatic Complexity corresponds to the number of decisions a block of code contains plus 1. This number (also called McCabe number) is equal to the number of linearly independent paths through the code. This number can be used as a guide when testing conditional logic in blocks.

    Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

    Construct Effect on CC Reasoning
    if +1 An if statement is a single decision.
    elif +1 The elif statement adds another decision.
    else +0 The else statement does not cause a new decision. The decision is at the if.
    for +1 There is a decision at the start of the loop.
    while +1 There is a decision at the while statement.
    except +1 Each except branch adds a new conditional path of execution.
    finally +0 The finally block is unconditionally executed.
    with +1 The with statement roughly corresponds to a try/except block (see PEP 343 for details).
    assert +1 The assert statement internally roughly equals a conditional statement.
    Comprehension +1 A list/set/dict comprehension of generator expression is equivalent to a for loop.
    Boolean Operator +1 Every boolean operator (and, or) adds a decision point.

    Source: http://radon.readthedocs.org/en/latest/intro.html

    Function Search has a Cognitive Complexity of 23 (exceeds 5 allowed). Consider refactoring.
    Open

        def Search(self, cls_type, list_id=-1):
        '''
        Method which looks for a particular class type in a particular list
        :param cls_type: the type of object to find
        :param list_id: the list it resides in
    Severity: Minor
    Found in MuseParse/classes/ObjectHierarchy/ItemClasses/Note.py - About 3 hrs to fix

    Cognitive Complexity

    Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

    A method's cognitive complexity is based on a few simple rules:

    • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
    • Code is considered more complex for each "break in the linear flow of the code"
    • Code is considered more complex when "flow breaking structures are nested"

    Further reading

    Cyclomatic complexity is too high in method getLilyDuration. (13)
    Open

        def getLilyDuration(self):
        """
        method to calculate duration of note in lilypond duration style
        :return:
        """
    Severity: Minor
    Found in MuseParse/classes/ObjectHierarchy/ItemClasses/Note.py by radon

    Cyclomatic Complexity

    Cyclomatic Complexity corresponds to the number of decisions a block of code contains plus 1. This number (also called McCabe number) is equal to the number of linearly independent paths through the code. This number can be used as a guide when testing conditional logic in blocks.

    Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

    Construct Effect on CC Reasoning
    if +1 An if statement is a single decision.
    elif +1 The elif statement adds another decision.
    else +0 The else statement does not cause a new decision. The decision is at the if.
    for +1 There is a decision at the start of the loop.
    while +1 There is a decision at the while statement.
    except +1 Each except branch adds a new conditional path of execution.
    finally +0 The finally block is unconditionally executed.
    with +1 The with statement roughly corresponds to a try/except block (see PEP 343 for details).
    assert +1 The assert statement internally roughly equals a conditional statement.
    Comprehension +1 A list/set/dict comprehension of generator expression is equivalent to a for loop.
    Boolean Operator +1 Every boolean operator (and, or) adds a decision point.

    Source: http://radon.readthedocs.org/en/latest/intro.html

    Cyclomatic complexity is too high in method handlePreLilies. (12)
    Open

        def handlePreLilies(self):
        '''
        Fetches all notation to come before the note as a lilypond string
        :return: str
        '''
    Severity: Minor
    Found in MuseParse/classes/ObjectHierarchy/ItemClasses/Note.py by radon

    Cyclomatic Complexity

    Cyclomatic Complexity corresponds to the number of decisions a block of code contains plus 1. This number (also called McCabe number) is equal to the number of linearly independent paths through the code. This number can be used as a guide when testing conditional logic in blocks.

    Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

    Construct Effect on CC Reasoning
    if +1 An if statement is a single decision.
    elif +1 The elif statement adds another decision.
    else +0 The else statement does not cause a new decision. The decision is at the if.
    for +1 There is a decision at the start of the loop.
    while +1 There is a decision at the while statement.
    except +1 Each except branch adds a new conditional path of execution.
    finally +0 The finally block is unconditionally executed.
    with +1 The with statement roughly corresponds to a try/except block (see PEP 343 for details).
    assert +1 The assert statement internally roughly equals a conditional statement.
    Comprehension +1 A list/set/dict comprehension of generator expression is equivalent to a for loop.
    Boolean Operator +1 Every boolean operator (and, or) adds a decision point.

    Source: http://radon.readthedocs.org/en/latest/intro.html

    Cyclomatic complexity is too high in method toLily. (12)
    Open

        def toLily(self):
        val = ""
        if not hasattr(self, "step"):
            val += "c"
        else:
    Severity: Minor
    Found in MuseParse/classes/ObjectHierarchy/ItemClasses/Note.py by radon

    Cyclomatic Complexity

    Cyclomatic Complexity corresponds to the number of decisions a block of code contains plus 1. This number (also called McCabe number) is equal to the number of linearly independent paths through the code. This number can be used as a guide when testing conditional logic in blocks.

    Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

    Construct Effect on CC Reasoning
    if +1 An if statement is a single decision.
    elif +1 The elif statement adds another decision.
    else +0 The else statement does not cause a new decision. The decision is at the if.
    for +1 There is a decision at the start of the loop.
    while +1 There is a decision at the while statement.
    except +1 Each except branch adds a new conditional path of execution.
    finally +0 The finally block is unconditionally executed.
    with +1 The with statement roughly corresponds to a try/except block (see PEP 343 for details).
    assert +1 The assert statement internally roughly equals a conditional statement.
    Comprehension +1 A list/set/dict comprehension of generator expression is equivalent to a for loop.
    Boolean Operator +1 Every boolean operator (and, or) adds a decision point.

    Source: http://radon.readthedocs.org/en/latest/intro.html

    Function toLily has a Cognitive Complexity of 20 (exceeds 5 allowed). Consider refactoring.
    Open

        def toLily(self):
        val = ""
        if not hasattr(self, "step"):
            val += "c"
        else:
    Severity: Minor
    Found in MuseParse/classes/ObjectHierarchy/ItemClasses/Note.py - About 2 hrs to fix

    Cognitive Complexity

    Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

    A method's cognitive complexity is based on a few simple rules:

    • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
    • Code is considered more complex for each "break in the linear flow of the code"
    • Code is considered more complex when "flow breaking structures are nested"

    Further reading

    Cyclomatic complexity is too high in method __init__. (11)
    Open

        def __init__(self, **kwargs):
        BaseClass.Base.__init__(self)
        self.ties = []
        self.beams = {}
        if "rest" in kwargs:
    Severity: Minor
    Found in MuseParse/classes/ObjectHierarchy/ItemClasses/Note.py by radon

    Cyclomatic Complexity

    Cyclomatic Complexity corresponds to the number of decisions a block of code contains plus 1. This number (also called McCabe number) is equal to the number of linearly independent paths through the code. This number can be used as a guide when testing conditional logic in blocks.

    Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

    Construct Effect on CC Reasoning
    if +1 An if statement is a single decision.
    elif +1 The elif statement adds another decision.
    else +0 The else statement does not cause a new decision. The decision is at the if.
    for +1 There is a decision at the start of the loop.
    while +1 There is a decision at the while statement.
    except +1 Each except branch adds a new conditional path of execution.
    finally +0 The finally block is unconditionally executed.
    with +1 The with statement roughly corresponds to a try/except block (see PEP 343 for details).
    assert +1 The assert statement internally roughly equals a conditional statement.
    Comprehension +1 A list/set/dict comprehension of generator expression is equivalent to a for loop.
    Boolean Operator +1 Every boolean operator (and, or) adds a decision point.

    Source: http://radon.readthedocs.org/en/latest/intro.html

    Cyclomatic complexity is too high in method Search. (10)
    Open

        def Search(self, cls_type, list_id=-1):
        '''
        Method which looks for a particular class type in a particular list
        :param cls_type: the type of object to find
        :param list_id: the list it resides in
    Severity: Minor
    Found in MuseParse/classes/ObjectHierarchy/ItemClasses/Note.py by radon

    Cyclomatic Complexity

    Cyclomatic Complexity corresponds to the number of decisions a block of code contains plus 1. This number (also called McCabe number) is equal to the number of linearly independent paths through the code. This number can be used as a guide when testing conditional logic in blocks.

    Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

    Construct Effect on CC Reasoning
    if +1 An if statement is a single decision.
    elif +1 The elif statement adds another decision.
    else +0 The else statement does not cause a new decision. The decision is at the if.
    for +1 There is a decision at the start of the loop.
    while +1 There is a decision at the while statement.
    except +1 Each except branch adds a new conditional path of execution.
    finally +0 The finally block is unconditionally executed.
    with +1 The with statement roughly corresponds to a try/except block (see PEP 343 for details).
    assert +1 The assert statement internally roughly equals a conditional statement.
    Comprehension +1 A list/set/dict comprehension of generator expression is equivalent to a for loop.
    Boolean Operator +1 Every boolean operator (and, or) adds a decision point.

    Source: http://radon.readthedocs.org/en/latest/intro.html

    Function GetNotation has a Cognitive Complexity of 18 (exceeds 5 allowed). Consider refactoring.
    Open

        def GetNotation(self, id, type):
        '''
        method which searches for notation from <type> list at position <id>
        :param id: the number to look for - i.e if you're looking for the first one in wrap notation, id will be 0
        :param type: post, pre or wrap
    Severity: Minor
    Found in MuseParse/classes/ObjectHierarchy/ItemClasses/Note.py - About 2 hrs to fix

    Cognitive Complexity

    Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

    A method's cognitive complexity is based on a few simple rules:

    • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
    • Code is considered more complex for each "break in the linear flow of the code"
    • Code is considered more complex when "flow breaking structures are nested"

    Further reading

    Function toLily has a Cognitive Complexity of 18 (exceeds 5 allowed). Consider refactoring.
    Open

        def toLily(self):
        val = ""
        value = ""
        if hasattr(self, "print") and not self.print:
            val += "\n\\hideNotes\n"
    Severity: Minor
    Found in MuseParse/classes/ObjectHierarchy/ItemClasses/Note.py - About 2 hrs to fix

    Cognitive Complexity

    Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

    A method's cognitive complexity is based on a few simple rules:

    • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
    • Code is considered more complex for each "break in the linear flow of the code"
    • Code is considered more complex when "flow breaking structures are nested"

    Further reading

    Cyclomatic complexity is too high in method toLily. (9)
    Open

        def toLily(self):
        val = "\grace"
        ending = ""
        if hasattr(self, "slash") and self.slash:
            val = "\slashedGrace"
    Severity: Minor
    Found in MuseParse/classes/ObjectHierarchy/ItemClasses/Note.py by radon

    Cyclomatic Complexity

    Cyclomatic Complexity corresponds to the number of decisions a block of code contains plus 1. This number (also called McCabe number) is equal to the number of linearly independent paths through the code. This number can be used as a guide when testing conditional logic in blocks.

    Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

    Construct Effect on CC Reasoning
    if +1 An if statement is a single decision.
    elif +1 The elif statement adds another decision.
    else +0 The else statement does not cause a new decision. The decision is at the if.
    for +1 There is a decision at the start of the loop.
    while +1 There is a decision at the while statement.
    except +1 Each except branch adds a new conditional path of execution.
    finally +0 The finally block is unconditionally executed.
    with +1 The with statement roughly corresponds to a try/except block (see PEP 343 for details).
    assert +1 The assert statement internally roughly equals a conditional statement.
    Comprehension +1 A list/set/dict comprehension of generator expression is equivalent to a for loop.
    Boolean Operator +1 Every boolean operator (and, or) adds a decision point.

    Source: http://radon.readthedocs.org/en/latest/intro.html

    Cyclomatic complexity is too high in method LilyWrap. (9)
    Open

        def LilyWrap(self, value):
        '''
        Method to fetch lilypond representation of wrap_notation
        :param value: current lilypond string to wrap
        :return: updated lilypond string
    Severity: Minor
    Found in MuseParse/classes/ObjectHierarchy/ItemClasses/Note.py by radon

    Cyclomatic Complexity

    Cyclomatic Complexity corresponds to the number of decisions a block of code contains plus 1. This number (also called McCabe number) is equal to the number of linearly independent paths through the code. This number can be used as a guide when testing conditional logic in blocks.

    Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

    Construct Effect on CC Reasoning
    if +1 An if statement is a single decision.
    elif +1 The elif statement adds another decision.
    else +0 The else statement does not cause a new decision. The decision is at the if.
    for +1 There is a decision at the start of the loop.
    while +1 There is a decision at the while statement.
    except +1 Each except branch adds a new conditional path of execution.
    finally +0 The finally block is unconditionally executed.
    with +1 The with statement roughly corresponds to a try/except block (see PEP 343 for details).
    assert +1 The assert statement internally roughly equals a conditional statement.
    Comprehension +1 A list/set/dict comprehension of generator expression is equivalent to a for loop.
    Boolean Operator +1 Every boolean operator (and, or) adds a decision point.

    Source: http://radon.readthedocs.org/en/latest/intro.html

    Cyclomatic complexity is too high in class Pitch. (8)
    Open

    class Pitch(BaseClass.Base):

    """
    Class representing the pitch of the note
    Severity: Minor
    Found in MuseParse/classes/ObjectHierarchy/ItemClasses/Note.py by radon

    Cyclomatic Complexity

    Cyclomatic Complexity corresponds to the number of decisions a block of code contains plus 1. This number (also called McCabe number) is equal to the number of linearly independent paths through the code. This number can be used as a guide when testing conditional logic in blocks.

    Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

    Construct Effect on CC Reasoning
    if +1 An if statement is a single decision.
    elif +1 The elif statement adds another decision.
    else +0 The else statement does not cause a new decision. The decision is at the if.
    for +1 There is a decision at the start of the loop.
    while +1 There is a decision at the while statement.
    except +1 Each except branch adds a new conditional path of execution.
    finally +0 The finally block is unconditionally executed.
    with +1 The with statement roughly corresponds to a try/except block (see PEP 343 for details).
    assert +1 The assert statement internally roughly equals a conditional statement.
    Comprehension +1 A list/set/dict comprehension of generator expression is equivalent to a for loop.
    Boolean Operator +1 Every boolean operator (and, or) adds a decision point.

    Source: http://radon.readthedocs.org/en/latest/intro.html

    Function handlePreLilies has a Cognitive Complexity of 16 (exceeds 5 allowed). Consider refactoring.
    Open

        def handlePreLilies(self):
        '''
        Fetches all notation to come before the note as a lilypond string
        :return: str
        '''
    Severity: Minor
    Found in MuseParse/classes/ObjectHierarchy/ItemClasses/Note.py - About 2 hrs to fix

    Cognitive Complexity

    Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

    A method's cognitive complexity is based on a few simple rules:

    • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
    • Code is considered more complex for each "break in the linear flow of the code"
    • Code is considered more complex when "flow breaking structures are nested"

    Further reading

    Cyclomatic complexity is too high in class GraceNote. (7)
    Open

    class GraceNote(BaseClass.Base):

    """
    Gracenotes.
    Severity: Minor
    Found in MuseParse/classes/ObjectHierarchy/ItemClasses/Note.py by radon

    Cyclomatic Complexity

    Cyclomatic Complexity corresponds to the number of decisions a block of code contains plus 1. This number (also called McCabe number) is equal to the number of linearly independent paths through the code. This number can be used as a guide when testing conditional logic in blocks.

    Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

    Construct Effect on CC Reasoning
    if +1 An if statement is a single decision.
    elif +1 The elif statement adds another decision.
    else +0 The else statement does not cause a new decision. The decision is at the if.
    for +1 There is a decision at the start of the loop.
    while +1 There is a decision at the while statement.
    except +1 Each except branch adds a new conditional path of execution.
    finally +0 The finally block is unconditionally executed.
    with +1 The with statement roughly corresponds to a try/except block (see PEP 343 for details).
    assert +1 The assert statement internally roughly equals a conditional statement.
    Comprehension +1 A list/set/dict comprehension of generator expression is equivalent to a for loop.
    Boolean Operator +1 Every boolean operator (and, or) adds a decision point.

    Source: http://radon.readthedocs.org/en/latest/intro.html

    Cyclomatic complexity is too high in method toLily. (7)
    Open

        def toLily(self):
        pre_note = "\n\\tweak #'style #'"
        if self.type != "":
            ignore = [
                "slashed",
    Severity: Minor
    Found in MuseParse/classes/ObjectHierarchy/ItemClasses/Note.py by radon

    Cyclomatic Complexity

    Cyclomatic Complexity corresponds to the number of decisions a block of code contains plus 1. This number (also called McCabe number) is equal to the number of linearly independent paths through the code. This number can be used as a guide when testing conditional logic in blocks.

    Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

    Construct Effect on CC Reasoning
    if +1 An if statement is a single decision.
    elif +1 The elif statement adds another decision.
    else +0 The else statement does not cause a new decision. The decision is at the if.
    for +1 There is a decision at the start of the loop.
    while +1 There is a decision at the while statement.
    except +1 Each except branch adds a new conditional path of execution.
    finally +0 The finally block is unconditionally executed.
    with +1 The with statement roughly corresponds to a try/except block (see PEP 343 for details).
    assert +1 The assert statement internally roughly equals a conditional statement.
    Comprehension +1 A list/set/dict comprehension of generator expression is equivalent to a for loop.
    Boolean Operator +1 Every boolean operator (and, or) adds a decision point.

    Source: http://radon.readthedocs.org/en/latest/intro.html

    Cyclomatic complexity is too high in method __init__. (7)
    Open

        def __init__(self, **kwargs):
        self.wrapped = True
        BaseClass.Base.__init__(self)
        if "type" in kwargs:
            if kwargs["type"] is not None:
    Severity: Minor
    Found in MuseParse/classes/ObjectHierarchy/ItemClasses/Note.py by radon

    Cyclomatic Complexity

    Cyclomatic Complexity corresponds to the number of decisions a block of code contains plus 1. This number (also called McCabe number) is equal to the number of linearly independent paths through the code. This number can be used as a guide when testing conditional logic in blocks.

    Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

    Construct Effect on CC Reasoning
    if +1 An if statement is a single decision.
    elif +1 The elif statement adds another decision.
    else +0 The else statement does not cause a new decision. The decision is at the if.
    for +1 There is a decision at the start of the loop.
    while +1 There is a decision at the while statement.
    except +1 Each except branch adds a new conditional path of execution.
    finally +0 The finally block is unconditionally executed.
    with +1 The with statement roughly corresponds to a try/except block (see PEP 343 for details).
    assert +1 The assert statement internally roughly equals a conditional statement.
    Comprehension +1 A list/set/dict comprehension of generator expression is equivalent to a for loop.
    Boolean Operator +1 Every boolean operator (and, or) adds a decision point.

    Source: http://radon.readthedocs.org/en/latest/intro.html

    Cyclomatic complexity is too high in class Note. (7)
    Open

    class Note(BaseClass.Base):

    """
    Big class representing a note.
    Severity: Minor
    Found in MuseParse/classes/ObjectHierarchy/ItemClasses/Note.py by radon

    Cyclomatic Complexity

    Cyclomatic Complexity corresponds to the number of decisions a block of code contains plus 1. This number (also called McCabe number) is equal to the number of linearly independent paths through the code. This number can be used as a guide when testing conditional logic in blocks.

    Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

    Construct Effect on CC Reasoning
    if +1 An if statement is a single decision.
    elif +1 The elif statement adds another decision.
    else +0 The else statement does not cause a new decision. The decision is at the if.
    for +1 There is a decision at the start of the loop.
    while +1 There is a decision at the while statement.
    except +1 Each except branch adds a new conditional path of execution.
    finally +0 The finally block is unconditionally executed.
    with +1 The with statement roughly corresponds to a try/except block (see PEP 343 for details).
    assert +1 The assert statement internally roughly equals a conditional statement.
    Comprehension +1 A list/set/dict comprehension of generator expression is equivalent to a for loop.
    Boolean Operator +1 Every boolean operator (and, or) adds a decision point.

    Source: http://radon.readthedocs.org/en/latest/intro.html

    Cyclomatic complexity is too high in method __str__. (6)
    Open

        def __str__(self):
        st = ""
        alter = {1: "sharp", -
                 1: "flat", 0: "", 2: "double-sharp", -
                 2: "double-flat"}
    Severity: Minor
    Found in MuseParse/classes/ObjectHierarchy/ItemClasses/Note.py by radon

    Cyclomatic Complexity

    Cyclomatic Complexity corresponds to the number of decisions a block of code contains plus 1. This number (also called McCabe number) is equal to the number of linearly independent paths through the code. This number can be used as a guide when testing conditional logic in blocks.

    Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

    Construct Effect on CC Reasoning
    if +1 An if statement is a single decision.
    elif +1 The elif statement adds another decision.
    else +0 The else statement does not cause a new decision. The decision is at the if.
    for +1 There is a decision at the start of the loop.
    while +1 There is a decision at the while statement.
    except +1 Each except branch adds a new conditional path of execution.
    finally +0 The finally block is unconditionally executed.
    with +1 The with statement roughly corresponds to a try/except block (see PEP 343 for details).
    assert +1 The assert statement internally roughly equals a conditional statement.
    Comprehension +1 A list/set/dict comprehension of generator expression is equivalent to a for loop.
    Boolean Operator +1 Every boolean operator (and, or) adds a decision point.

    Source: http://radon.readthedocs.org/en/latest/intro.html

    Cyclomatic complexity is too high in method toLily. (6)
    Open

        def toLily(self):
        var = "\\arpeggio"
        if not hasattr(self, "direction") or self.direction is None:
            var += "Normal"
        else:
    Severity: Minor
    Found in MuseParse/classes/ObjectHierarchy/ItemClasses/Note.py by radon

    Cyclomatic Complexity

    Cyclomatic Complexity corresponds to the number of decisions a block of code contains plus 1. This number (also called McCabe number) is equal to the number of linearly independent paths through the code. This number can be used as a guide when testing conditional logic in blocks.

    Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

    Construct Effect on CC Reasoning
    if +1 An if statement is a single decision.
    elif +1 The elif statement adds another decision.
    else +0 The else statement does not cause a new decision. The decision is at the if.
    for +1 There is a decision at the start of the loop.
    while +1 There is a decision at the while statement.
    except +1 Each except branch adds a new conditional path of execution.
    finally +0 The finally block is unconditionally executed.
    with +1 The with statement roughly corresponds to a try/except block (see PEP 343 for details).
    assert +1 The assert statement internally roughly equals a conditional statement.
    Comprehension +1 A list/set/dict comprehension of generator expression is equivalent to a for loop.
    Boolean Operator +1 Every boolean operator (and, or) adds a decision point.

    Source: http://radon.readthedocs.org/en/latest/intro.html

    Cyclomatic complexity is too high in method __init__. (6)
    Open

        def __init__(self, **kwargs):
        if "alter" in kwargs:
            self.alter = kwargs["alter"]
        if "octave" in kwargs:
            self.octave = int(kwargs["octave"])
    Severity: Minor
    Found in MuseParse/classes/ObjectHierarchy/ItemClasses/Note.py by radon

    Cyclomatic Complexity

    Cyclomatic Complexity corresponds to the number of decisions a block of code contains plus 1. This number (also called McCabe number) is equal to the number of linearly independent paths through the code. This number can be used as a guide when testing conditional logic in blocks.

    Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

    Construct Effect on CC Reasoning
    if +1 An if statement is a single decision.
    elif +1 The elif statement adds another decision.
    else +0 The else statement does not cause a new decision. The decision is at the if.
    for +1 There is a decision at the start of the loop.
    while +1 There is a decision at the while statement.
    except +1 Each except branch adds a new conditional path of execution.
    finally +0 The finally block is unconditionally executed.
    with +1 The with statement roughly corresponds to a try/except block (see PEP 343 for details).
    assert +1 The assert statement internally roughly equals a conditional statement.
    Comprehension +1 A list/set/dict comprehension of generator expression is equivalent to a for loop.
    Boolean Operator +1 Every boolean operator (and, or) adds a decision point.

    Source: http://radon.readthedocs.org/en/latest/intro.html

    Cyclomatic complexity is too high in class Slide. (6)
    Open

    class Slide(BaseClass.Base):

    """
    Optional Inputs:
        type: the type of gliss, i.e start or stop
    Severity: Minor
    Found in MuseParse/classes/ObjectHierarchy/ItemClasses/Note.py by radon

    Cyclomatic Complexity

    Cyclomatic Complexity corresponds to the number of decisions a block of code contains plus 1. This number (also called McCabe number) is equal to the number of linearly independent paths through the code. This number can be used as a guide when testing conditional logic in blocks.

    Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

    Construct Effect on CC Reasoning
    if +1 An if statement is a single decision.
    elif +1 The elif statement adds another decision.
    else +0 The else statement does not cause a new decision. The decision is at the if.
    for +1 There is a decision at the start of the loop.
    while +1 There is a decision at the while statement.
    except +1 Each except branch adds a new conditional path of execution.
    finally +0 The finally block is unconditionally executed.
    with +1 The with statement roughly corresponds to a try/except block (see PEP 343 for details).
    assert +1 The assert statement internally roughly equals a conditional statement.
    Comprehension +1 A list/set/dict comprehension of generator expression is equivalent to a for loop.
    Boolean Operator +1 Every boolean operator (and, or) adds a decision point.

    Source: http://radon.readthedocs.org/en/latest/intro.html

    Function handlePostLilies has a Cognitive Complexity of 12 (exceeds 5 allowed). Consider refactoring.
    Open

        def handlePostLilies(self):
        val = ""
        if hasattr(self, "chord") and self.chord == "stop":
            val += ">"
            val += self.getLilyDuration()
    Severity: Minor
    Found in MuseParse/classes/ObjectHierarchy/ItemClasses/Note.py - About 1 hr to fix

    Cognitive Complexity

    Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

    A method's cognitive complexity is based on a few simple rules:

    • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
    • Code is considered more complex for each "break in the linear flow of the code"
    • Code is considered more complex when "flow breaking structures are nested"

    Further reading

    Function toLily has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring.
    Open

        def toLily(self):
        pre_note = "\n\\tweak #'style #'"
        if self.type != "":
            ignore = [
                "slashed",
    Severity: Minor
    Found in MuseParse/classes/ObjectHierarchy/ItemClasses/Note.py - About 1 hr to fix

    Cognitive Complexity

    Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

    A method's cognitive complexity is based on a few simple rules:

    • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
    • Code is considered more complex for each "break in the linear flow of the code"
    • Code is considered more complex when "flow breaking structures are nested"

    Further reading

    Function __init__ has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.
    Open

        def __init__(self, **kwargs):
        BaseClass.Base.__init__(self)
        self.ties = []
        self.beams = {}
        if "rest" in kwargs:
    Severity: Minor
    Found in MuseParse/classes/ObjectHierarchy/ItemClasses/Note.py - About 1 hr to fix

    Cognitive Complexity

    Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

    A method's cognitive complexity is based on a few simple rules:

    • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
    • Code is considered more complex for each "break in the linear flow of the code"
    • Code is considered more complex when "flow breaking structures are nested"

    Further reading

    Function __init__ has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.
    Open

        def __init__(self, **kwargs):
        self.wrapped = True
        BaseClass.Base.__init__(self)
        if "type" in kwargs:
            if kwargs["type"] is not None:
    Severity: Minor
    Found in MuseParse/classes/ObjectHierarchy/ItemClasses/Note.py - About 55 mins to fix

    Cognitive Complexity

    Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

    A method's cognitive complexity is based on a few simple rules:

    • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
    • Code is considered more complex for each "break in the linear flow of the code"
    • Code is considered more complex when "flow breaking structures are nested"

    Further reading

    Avoid deeply nested control flow statements.
    Open

                            if hasattr(self, "trem_length"):
                            value *= self.trem_length
                        value = int(value)
    Severity: Major
    Found in MuseParse/classes/ObjectHierarchy/ItemClasses/Note.py - About 45 mins to fix

      Avoid deeply nested control flow statements.
      Open

                              if hasattr(self, "trem_length"):
                            rounded *= self.trem_length
                        value = int(rounded)
      Severity: Major
      Found in MuseParse/classes/ObjectHierarchy/ItemClasses/Note.py - About 45 mins to fix

        Function toLily has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.
        Open

            def toLily(self):
        val = ""
        gliss = "\glissando"
        values = []
        if hasattr(self, "lineType"):
        Severity: Minor
        Found in MuseParse/classes/ObjectHierarchy/ItemClasses/Note.py - About 45 mins to fix

        Cognitive Complexity

        Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

        A method's cognitive complexity is based on a few simple rules:

        • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
        • Code is considered more complex for each "break in the linear flow of the code"
        • Code is considered more complex when "flow breaking structures are nested"

        Further reading

        Function toLily has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.
        Open

            def toLily(self):
        val = ""
        if hasattr(self, "bracket"):
            if self.bracket:
                val += "\once \override TupletBracket.bracket-visibility = ##t\n"
        Severity: Minor
        Found in MuseParse/classes/ObjectHierarchy/ItemClasses/Note.py - About 35 mins to fix

        Cognitive Complexity

        Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

        A method's cognitive complexity is based on a few simple rules:

        • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
        • Code is considered more complex for each "break in the linear flow of the code"
        • Code is considered more complex when "flow breaking structures are nested"

        Further reading

        Function toLily has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.
        Open

            def toLily(self):
        val = "\grace"
        ending = ""
        if hasattr(self, "slash") and self.slash:
            val = "\slashedGrace"
        Severity: Minor
        Found in MuseParse/classes/ObjectHierarchy/ItemClasses/Note.py - About 35 mins to fix

        Cognitive Complexity

        Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

        A method's cognitive complexity is based on a few simple rules:

        • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
        • Code is considered more complex for each "break in the linear flow of the code"
        • Code is considered more complex when "flow breaking structures are nested"

        Further reading

        Function __init__ has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.
        Open

            def __init__(self, **kwargs):
        if "type" in kwargs:
            if kwargs["type"] is not None:
                self.type = kwargs["type"]
        if "bracket" in kwargs:
        Severity: Minor
        Found in MuseParse/classes/ObjectHierarchy/ItemClasses/Note.py - About 25 mins to fix

        Cognitive Complexity

        Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

        A method's cognitive complexity is based on a few simple rules:

        • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
        • Code is considered more complex for each "break in the linear flow of the code"
        • Code is considered more complex when "flow breaking structures are nested"

        Further reading

        Function toLily has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.
        Open

            def toLily(self):
        var = "\\arpeggio"
        if not hasattr(self, "direction") or self.direction is None:
            var += "Normal"
        else:
        Severity: Minor
        Found in MuseParse/classes/ObjectHierarchy/ItemClasses/Note.py - About 25 mins to fix

        Cognitive Complexity

        Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

        A method's cognitive complexity is based on a few simple rules:

        • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
        • Code is considered more complex for each "break in the linear flow of the code"
        • Code is considered more complex when "flow breaking structures are nested"

        Further reading

        Line too long (107 > 79 characters)
        Open

                Method which is called from voice/measure to update the divisions for each note which are stored at
        Severity: Minor
        Found in MuseParse/classes/ObjectHierarchy/ItemClasses/Note.py by pep8

        Limit all lines to a maximum of 79 characters.

        There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

        Invalid escape sequence '\o'
        Open

                    val += "\omit TupletNumber\n"
        Severity: Minor
        Found in MuseParse/classes/ObjectHierarchy/ItemClasses/Note.py by pep8

        Invalid escape sequences are deprecated in Python 3.6.

        Okay: regex = r'\.png$'
W605: regex = '\.png$'

        Line too long (84 > 79 characters)
        Open

        from MuseParse.classes.ObjectHierarchy.ItemClasses import BaseClass, Mark, Ornaments
        Severity: Minor
        Found in MuseParse/classes/ObjectHierarchy/ItemClasses/Note.py by pep8

        Limit all lines to a maximum of 79 characters.

        There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

        Line too long (114 > 79 characters)
        Open

                :param id: the number to look for - i.e if you're looking for the first one in wrap notation, id will be 0
        Severity: Minor
        Found in MuseParse/classes/ObjectHierarchy/ItemClasses/Note.py by pep8

        Limit all lines to a maximum of 79 characters.

        There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

        Invalid escape sequence '\l'
        Open

                                value = "\longa"
        Severity: Minor
        Found in MuseParse/classes/ObjectHierarchy/ItemClasses/Note.py by pep8

        Invalid escape sequences are deprecated in Python 3.6.

        Okay: regex = r'\.png$'
W605: regex = '\.png$'

        Line too long (105 > 79 characters)
        Open

                :param measure_div: number of divisions per note. Indicator of how big or small a quarter note is
        Severity: Minor
        Found in MuseParse/classes/ObjectHierarchy/ItemClasses/Note.py by pep8

        Limit all lines to a maximum of 79 characters.

        There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

        Line too long (95 > 79 characters)
        Open

            Class representing a time mod: these sometimes appear in music xml where there are tuplets.
        Severity: Minor
        Found in MuseParse/classes/ObjectHierarchy/ItemClasses/Note.py by pep8

        Limit all lines to a maximum of 79 characters.

        There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

        Invalid escape sequence '\s'
        Open

                val = "\n\stem"
        Severity: Minor
        Found in MuseParse/classes/ObjectHierarchy/ItemClasses/Note.py by pep8

        Invalid escape sequences are deprecated in Python 3.6.

        Okay: regex = r'\.png$'
W605: regex = '\.png$'

        Line too long (130 > 79 characters)
        Open

                unpitched: bool representation of unpitchedness, aka a pitch which is like a clap or something rather than an actual note.
        Severity: Minor
        Found in MuseParse/classes/ObjectHierarchy/ItemClasses/Note.py by pep8

        Limit all lines to a maximum of 79 characters.

        There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

        Line too long (88 > 79 characters)
        Open

                                                             1 and len(self.postnotation) > id):
        Severity: Minor
        Found in MuseParse/classes/ObjectHierarchy/ItemClasses/Note.py by pep8

        Limit all lines to a maximum of 79 characters.

        There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

        Line too long (102 > 79 characters)
        Open

                direction: direction the arrow head of the arpeggiate should put. Generally up or down I think
        Severity: Minor
        Found in MuseParse/classes/ObjectHierarchy/ItemClasses/Note.py by pep8

        Limit all lines to a maximum of 79 characters.

        There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

        Invalid escape sequence '\g'
        Open

                gliss = "\glissando"
        Severity: Minor
        Found in MuseParse/classes/ObjectHierarchy/ItemClasses/Note.py by pep8

        Invalid escape sequences are deprecated in Python 3.6.

        Okay: regex = r'\.png$'
W605: regex = '\.png$'

        Line too long (137 > 79 characters)
        Open

                type: string indicator of the length of note, like "quarter" or "half". Alternatively, duration may be given along with divisions
        Severity: Minor
        Found in MuseParse/classes/ObjectHierarchy/ItemClasses/Note.py by pep8

        Limit all lines to a maximum of 79 characters.

        There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

        Invalid escape sequence '\o'
        Open

                        val += "\once \override TupletBracket.bracket-visibility = ##f\n"
        Severity: Minor
        Found in MuseParse/classes/ObjectHierarchy/ItemClasses/Note.py by pep8

        Invalid escape sequences are deprecated in Python 3.6.

        Okay: regex = r'\.png$'
W605: regex = '\.png$'

        Line too long (101 > 79 characters)
        Open

                last: bool - indicates whether or not this is the last gracenote in a sequence of gracenotes.
        Severity: Minor
        Found in MuseParse/classes/ObjectHierarchy/ItemClasses/Note.py by pep8

        Limit all lines to a maximum of 79 characters.

        There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

        Line too long (81 > 79 characters)
        Open

                - type - indicates whether this is a starting, continuing or ending beam.
        Severity: Minor
        Found in MuseParse/classes/ObjectHierarchy/ItemClasses/Note.py by pep8

        Limit all lines to a maximum of 79 characters.

        There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

        Line too long (82 > 79 characters)
        Open

                measure level, but needed at lilypond time to figure out lilypond notation
        Severity: Minor
        Found in MuseParse/classes/ObjectHierarchy/ItemClasses/Note.py by pep8

        Limit all lines to a maximum of 79 characters.

        There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

        Line too long (85 > 79 characters)
        Open

                number: something that comes in from MusicXML but isn't actually used at min.
        Severity: Minor
        Found in MuseParse/classes/ObjectHierarchy/ItemClasses/Note.py by pep8

        Limit all lines to a maximum of 79 characters.

        There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

        Line too long (105 > 79 characters)
        Open

                type: either start or stop. Represents that this is either the first or last tuplet in the group.
        Severity: Minor
        Found in MuseParse/classes/ObjectHierarchy/ItemClasses/Note.py by pep8

        Limit all lines to a maximum of 79 characters.

        There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

        Line too long (91 > 79 characters)
        Open

                type: whether this is start/stop/none. None indicates it's somewhere in the middle.
        Severity: Minor
        Found in MuseParse/classes/ObjectHierarchy/ItemClasses/Note.py by pep8

        Limit all lines to a maximum of 79 characters.

        There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

        Line too long (81 > 79 characters)
        Open

                '''any notation classes which come before the note is displayed - list'''
        Severity: Minor
        Found in MuseParse/classes/ObjectHierarchy/ItemClasses/Note.py by pep8

        Limit all lines to a maximum of 79 characters.

        There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

        Invalid escape sequence '\g'
        Open

                val = "\grace"
        Severity: Minor
        Found in MuseParse/classes/ObjectHierarchy/ItemClasses/Note.py by pep8

        Invalid escape sequences are deprecated in Python 3.6.

        Okay: regex = r'\.png$'
W605: regex = '\.png$'

        Line too long (119 > 79 characters)
        Open

                '''any notation classes which have something to come before and something after the note is displayed - list'''
        Severity: Minor
        Found in MuseParse/classes/ObjectHierarchy/ItemClasses/Note.py by pep8

        Limit all lines to a maximum of 79 characters.

        There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

        Line too long (87 > 79 characters)
        Open

                Sets the type, i.e duration of the note. Types are given as keys inside options
        Severity: Minor
        Found in MuseParse/classes/ObjectHierarchy/ItemClasses/Note.py by pep8

        Limit all lines to a maximum of 79 characters.

        There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

        Line too long (122 > 79 characters)
        Open

                                     " " for wrapper in wrapped_notation_lilystrings if wrapper is not None and len(wrapper) > 1])
        Severity: Minor
        Found in MuseParse/classes/ObjectHierarchy/ItemClasses/Note.py by pep8

        Limit all lines to a maximum of 79 characters.

        There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

        Line too long (87 > 79 characters)
        Open

                                for value in self.postnotation if type(value.toLily()) is str])
        Severity: Minor
        Found in MuseParse/classes/ObjectHierarchy/ItemClasses/Note.py by pep8

        Limit all lines to a maximum of 79 characters.

        There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

        Line too long (126 > 79 characters)
        Open

                accidental: accidental to show. Used where alter is not accurate enough, may indicate any range of accidentals such as
        Severity: Minor
        Found in MuseParse/classes/ObjectHierarchy/ItemClasses/Note.py by pep8

        Limit all lines to a maximum of 79 characters.

        There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

        Line too long (137 > 79 characters)
        Open

                duration: length of note. Where musicXML is concerned, divisions should also be known, indicating how many divisions there are in
        Severity: Minor
        Found in MuseParse/classes/ObjectHierarchy/ItemClasses/Note.py by pep8

        Limit all lines to a maximum of 79 characters.

        There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

        Line too long (114 > 79 characters)
        Open

                Method to add new notation. Use this rather than adding directly so new classes can be added automatically
        Severity: Minor
        Found in MuseParse/classes/ObjectHierarchy/ItemClasses/Note.py by pep8

        Limit all lines to a maximum of 79 characters.

        There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

        Invalid escape sequence '\o'
        Open

                    val += "\once \override TupletBracket.bracket-visibility = ##f\n"
        Severity: Minor
        Found in MuseParse/classes/ObjectHierarchy/ItemClasses/Note.py by pep8

        Invalid escape sequences are deprecated in Python 3.6.

        Okay: regex = r'\.png$'
W605: regex = '\.png$'

        Line too long (81 > 79 characters)
        Open

                val += "".join([value.toLily()[0] for value in self.postnotation if type(
        Severity: Minor
        Found in MuseParse/classes/ObjectHierarchy/ItemClasses/Note.py by pep8

        Limit all lines to a maximum of 79 characters.

        There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

        Invalid escape sequence '\o'
        Open

                        val += "\once \override TupletBracket.bracket-visibility = ##t\n"
        Severity: Minor
        Found in MuseParse/classes/ObjectHierarchy/ItemClasses/Note.py by pep8

        Invalid escape sequences are deprecated in Python 3.6.

        Okay: regex = r'\.png$'
W605: regex = '\.png$'

        Line too long (96 > 79 characters)
        Open

                alter: how many semi tones to raise or lower the pitch. Generally either 1 or -1, float.
        Severity: Minor
        Found in MuseParse/classes/ObjectHierarchy/ItemClasses/Note.py by pep8

        Limit all lines to a maximum of 79 characters.

        There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

        Invalid escape sequence '\s'
        Open

                    val = "\slashedGrace"
        Severity: Minor
        Found in MuseParse/classes/ObjectHierarchy/ItemClasses/Note.py by pep8

        Invalid escape sequences are deprecated in Python 3.6.

        Okay: regex = r'\.png$'
W605: regex = '\.png$'

        Line too long (89 > 79 characters)
        Open

                                                              1 and len(self.postnotation) > id):
        Severity: Minor
        Found in MuseParse/classes/ObjectHierarchy/ItemClasses/Note.py by pep8

        Limit all lines to a maximum of 79 characters.

        There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

        Line too long (114 > 79 characters)
        Open

                    [wrapper[-1] for wrapper in wrapped_notation_lilystrings if wrapper is not None and len(wrapper) > 0])
        Severity: Minor
        Found in MuseParse/classes/ObjectHierarchy/ItemClasses/Note.py by pep8

        Limit all lines to a maximum of 79 characters.

        There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

        Line too long (81 > 79 characters)
        Open

                        val += "\once \override TupletBracket.bracket-visibility = ##t\n"
        Severity: Minor
        Found in MuseParse/classes/ObjectHierarchy/ItemClasses/Note.py by pep8

        Limit all lines to a maximum of 79 characters.

        There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

        Invalid escape sequence '\o'
        Open

                        val += "\once \override TupletBracket.bracket-visibility = ##t\n"
        Severity: Minor
        Found in MuseParse/classes/ObjectHierarchy/ItemClasses/Note.py by pep8

        Invalid escape sequences are deprecated in Python 3.6.

        Okay: regex = r'\.png$'
W605: regex = '\.png$'

        Invalid escape sequence '\o'
        Open

                        val += "\once \override TupletBracket.bracket-visibility = ##f\n"
        Severity: Minor
        Found in MuseParse/classes/ObjectHierarchy/ItemClasses/Note.py by pep8

        Invalid escape sequences are deprecated in Python 3.6.

        Okay: regex = r'\.png$'
W605: regex = '\.png$'

        Line too long (105 > 79 characters)
        Open

            Class representing beam information. Normally this is automatic, but it comes in from MusicXML anyway
        Severity: Minor
        Found in MuseParse/classes/ObjectHierarchy/ItemClasses/Note.py by pep8

        Limit all lines to a maximum of 79 characters.

        There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

        Line too long (90 > 79 characters)
        Open

                                                               1 and len(self.postnotation) > id):
        Severity: Minor
        Found in MuseParse/classes/ObjectHierarchy/ItemClasses/Note.py by pep8

        Limit all lines to a maximum of 79 characters.

        There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

        Line too long (81 > 79 characters)
        Open

                        val += "\once \override TupletBracket.bracket-visibility = ##f\n"
        Severity: Minor
        Found in MuseParse/classes/ObjectHierarchy/ItemClasses/Note.py by pep8

        Limit all lines to a maximum of 79 characters.

        There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

        Line too long (106 > 79 characters)
        Open

            A glissando - like a slide, but it really only comes in "wavy" type so lineType is completely ignored.
        Severity: Minor
        Found in MuseParse/classes/ObjectHierarchy/ItemClasses/Note.py by pep8

        Limit all lines to a maximum of 79 characters.

        There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

        Line too long (119 > 79 characters)
        Open

                type: either start or stop. Stop isn't particularly useful to lilypond but may be used in other output formats.
        Severity: Minor
        Found in MuseParse/classes/ObjectHierarchy/ItemClasses/Note.py by pep8

        Limit all lines to a maximum of 79 characters.

        There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

        Invalid escape sequence '\o'
        Open

                    val += "\once \override TupletBracket.bracket-visibility = ##f\n"
        Severity: Minor
        Found in MuseParse/classes/ObjectHierarchy/ItemClasses/Note.py by pep8

        Invalid escape sequences are deprecated in Python 3.6.

        Okay: regex = r'\.png$'
W605: regex = '\.png$'

        Invalid escape sequence '\o'
        Open

                        val += "\override Glissando.style = #'zigzag"
        Severity: Minor
        Found in MuseParse/classes/ObjectHierarchy/ItemClasses/Note.py by pep8

        Invalid escape sequences are deprecated in Python 3.6.

        Okay: regex = r'\.png$'
W605: regex = '\.png$'

        There are no issues that match your filters.

        Category
        Status