Sign upLogin

pygae/galgebra

View on GitHub
Star
galgebra/printer.py

Summary

Maintainability
F
1 wk
Test Coverage

Starting a process with a shell, possible injection detected, security issue.
Open

            os.system(pdfprog + ' ' + filename[:-4])
Severity: Major
Found in galgebra/printer.py by bandit

Starting a process with a shell, possible injection detected, security issue.
Open

            os.system('Pdf2Png ' + filename[:-4])
Severity: Major
Found in galgebra/printer.py by bandit

The input method in Python 2 will read from standard input, evaluate and run the resulting string as python source code. This is similar, though in many ways worse, then using eval. On Python 2, use raw_input instead, input is safe in Python 3.
Open

        eval(input('!!!!Return to continue!!!!\n'))
Severity: Major
Found in galgebra/printer.py by bandit

Use of possibly insecure function - consider using safer ast.literal_eval.
Open

        eval(input('!!!!Return to continue!!!!\n'))
Severity: Minor
Found in galgebra/printer.py by bandit

Use of possibly insecure function - consider using safer ast.literal_eval.
Open

    return eval(seval, _eval_global_dict)
Severity: Minor
Found in galgebra/printer.py by bandit

Starting a process with a shell, possible injection detected, security issue.
Open

            os.system('pdfcrop ' + filename[:-4] + '.pdf')
Severity: Major
Found in galgebra/printer.py by bandit

Starting a process with a shell, possible injection detected, security issue.
Open

        os.system(print_cmd)
Severity: Major
Found in galgebra/printer.py by bandit

Starting a process with a shell, possible injection detected, security issue.
Open

            os.system(sys_cmd['rm'] + ' ' + filename[:-4] + '.aux ' + filename[:-4] + '.log')
Severity: Major
Found in galgebra/printer.py by bandit

Starting a process with a shell, possible injection detected, security issue.
Open

            os.system(sys_cmd['rm'] + ' ' + filename[:-4] + '.aux ' + filename[:-4] + '.log ' + filename[:-4] + '.tex')
Severity: Major
Found in galgebra/printer.py by bandit

Starting a process with a shell, possible injection detected, security issue.
Open

            os.system(pdfprog + ' ' + filename[:-4] + sys_cmd['null'])
Severity: Major
Found in galgebra/printer.py by bandit

File printer.py has 950 lines of code (exceeds 250 allowed). Consider refactoring.
Open

r"""
ANSI Enhanced Text Printing, Text Printer and LaTeX Printer for all Geometric Algebra classes

:math:`\LaTeX` printing
-----------------------
Severity: Major
Found in galgebra/printer.py - About 2 days to fix

    Function _print_Function has a Cognitive Complexity of 70 (exceeds 5 allowed). Consider refactoring.
    Open

        def _print_Function(self, expr, exp=None):

        func = expr.func.__name__
        name = func
        if hasattr(self, '_print_' + func):
    Severity: Minor
    Found in galgebra/printer.py - About 1 day 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 _print_Function. (30)
    Open

        def _print_Function(self, expr, exp=None):

        func = expr.func.__name__
        name = func
        if hasattr(self, '_print_' + func):
    Severity: Minor
    Found in galgebra/printer.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 _print_Pow has a Cognitive Complexity of 37 (exceeds 5 allowed). Consider refactoring.
    Open

        def _print_Pow(self, expr):
        base = self._print(expr.base)
        if ('_' in base or '^' in base) and 'cdot' not in base:
            mode = True
        else:
    Severity: Minor
    Found in galgebra/printer.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

    Function _print_Derivative has a Cognitive Complexity of 33 (exceeds 5 allowed). Consider refactoring.
    Open

        def _print_Derivative(self, expr):
        dim = len(expr.variables)
        imax = 1
        if dim == 1:
            if self._settings["omit_partial_derivative_fraction"]:
    Severity: Minor
    Found in galgebra/printer.py - About 4 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 _print_Pow. (23)
    Open

        def _print_Pow(self, expr):
        base = self._print(expr.base)
        if ('_' in base or '^' in base) and 'cdot' not in base:
            mode = True
        else:
    Severity: Minor
    Found in galgebra/printer.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 Fmt has a Cognitive Complexity of 30 (exceeds 5 allowed). Consider refactoring.
    Open

    def Fmt(obj, fmt=0):
    if isinstance(obj, (list, tuple, dict)):
        n = len(obj)
        if isinstance(obj, list):
            ldelim = '['
    Severity: Minor
    Found in galgebra/printer.py - About 4 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 _print_Symbol has a Cognitive Complexity of 29 (exceeds 5 allowed). Consider refactoring.
    Open

        def _print_Symbol(self, expr, style='plain'):

        def str_symbol(name_str):

            def translate(s):
    Severity: Minor
    Found in galgebra/printer.py - About 4 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 function tex. (16)
    Open

    def tex(paper=(14, 11), debug=False, prog=False, pt='10pt'):
    r"""
    Post processes LaTeX output (see comments below), adds preamble and
    postscript.
    Severity: Minor
    Found in galgebra/printer.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 tex has a Cognitive Complexity of 23 (exceeds 5 allowed). Consider refactoring.
    Open

    def tex(paper=(14, 11), debug=False, prog=False, pt='10pt'):
    r"""
    Post processes LaTeX output (see comments below), adds preamble and
    postscript.
    Severity: Minor
    Found in galgebra/printer.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 function Fmt. (12)
    Open

    def Fmt(obj, fmt=0):
    if isinstance(obj, (list, tuple, dict)):
        n = len(obj)
        if isinstance(obj, list):
            ldelim = '['
    Severity: Minor
    Found in galgebra/printer.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 _print_Derivative. (12)
    Open

        def _print_Derivative(self, expr):
        dim = len(expr.variables)
        imax = 1
        if dim == 1:
            if self._settings["omit_partial_derivative_fraction"]:
    Severity: Minor
    Found in galgebra/printer.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 function oprint. (12)
    Open

    def oprint(*args, dict_mode=False):
    """
    Debug printing for iterated (list/tuple/dict/set) objects. args is
    of form ``(title1, object1, title2, object2, ...)`` and prints::
    Severity: Minor
    Found in galgebra/printer.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 oprint has a Cognitive Complexity of 19 (exceeds 5 allowed). Consider refactoring.
    Open

    def oprint(*args, dict_mode=False):
    """
    Debug printing for iterated (list/tuple/dict/set) objects. args is
    of form ``(title1, object1, title2, object2, ...)`` and prints::
    Severity: Minor
    Found in galgebra/printer.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 function xpdf. (10)
    Open

    def xpdf(filename=None, paper=(14, 11), crop=False, png=False, prog=False, debug=False, pt='10pt', pdfprog='pdflatex'):

    """
    Post processes LaTeX output (see comments below), adds preamble and
    postscript, generates tex file, inputs file to latex, displays resulting
    Severity: Minor
    Found in galgebra/printer.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 GaLatexPrinter. (9)
    Open

    class GaLatexPrinter(LatexPrinter):
    r"""
    This subclass of the builtin string printer makes some customizations which
    make output a little more readable for GA usage.
    Severity: Minor
    Found in galgebra/printer.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 xpdf has a Cognitive Complexity of 15 (exceeds 5 allowed). Consider refactoring.
    Open

    def xpdf(filename=None, paper=(14, 11), crop=False, png=False, prog=False, debug=False, pt='10pt', pdfprog='pdflatex'):

    """
    Post processes LaTeX output (see comments below), adds preamble and
    postscript, generates tex file, inputs file to latex, displays resulting
    Severity: Minor
    Found in galgebra/printer.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 xpdf has 8 arguments (exceeds 4 allowed). Consider refactoring.
    Open

    def xpdf(filename=None, paper=(14, 11), crop=False, png=False, prog=False, debug=False, pt='10pt', pdfprog='pdflatex'):
    Severity: Major
    Found in galgebra/printer.py - About 1 hr to fix

      Consider simplifying this complex logical expression.
      Open

              if expr.exp.is_Rational and abs(expr.exp.p) == 1 and expr.exp.q != 1:
            #base = self._print(expr.base)
            expq = expr.exp.q

            if expq == 2:
      Severity: Major
      Found in galgebra/printer.py - About 1 hr to fix

        Avoid deeply nested control flow statements.
        Open

                                if '_' in name or '^' in name:
                            name = r'\left ( ' + name + r'\right )^{' + exp + '}'
                        else:
                            name += '^{' + exp + '}'
        Severity: Major
        Found in galgebra/printer.py - About 45 mins to fix

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

              def _print_Derivative(self, expr):
        # Break the following to support both py 2 & 3
        # function, *diff_args = expr.args
        function = expr.args[0]
        diff_args = expr.args[1:]
          Severity: Minor
          Found in galgebra/printer.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

          Avoid too many return statements within this function.
          Open

                          return tex % (self._print(expr.base),
          Severity: Major
          Found in galgebra/printer.py - About 30 mins to fix

            Avoid too many return statements within this function.
            Open

                        return r"\frac{%s}{%s}" % \
            Severity: Major
            Found in galgebra/printer.py - About 30 mins to fix

              Avoid too many return statements within this function.
              Open

                              return r"{%s}^{%s}" % (self._print(expr.base), self._print(expr.exp))
              Severity: Major
              Found in galgebra/printer.py - About 30 mins to fix

                Avoid too many return statements within this function.
                Open

                                        return tex[1:].strip()
                Severity: Major
                Found in galgebra/printer.py - About 30 mins to fix

                  Function "xpdf" has 8 parameters, which is greater than the 7 authorized.
                  Open

                  def xpdf(filename=None, paper=(14, 11), crop=False, png=False, prog=False, debug=False, pt='10pt', pdfprog='pdflatex'):
                  Severity: Major
                  Found in galgebra/printer.py by sonar-python

                  A long parameter list can indicate that a new structure should be created to wrap the numerous parameters or that the function is doing too many things.

                  Noncompliant Code Example

                  With a maximum number of 4 parameters:

                  def do_something(param1, param2, param3, param4, param5):
    ...

                  Compliant Solution

                  def do_something(param1, param2, param3, param4):
    ...

                  Refactor this function to reduce its Cognitive Complexity from 29 to the 15 allowed.
                  Open

                      def _print_Symbol(self, expr, style='plain'):
                  Severity: Critical
                  Found in galgebra/printer.py by sonar-python

                  Cognitive Complexity is a measure of how hard the control flow of a function is to understand. Functions with high Cognitive Complexity will be difficult to maintain.

                  See

                  Refactor this function to reduce its Cognitive Complexity from 19 to the 15 allowed.
                  Open

                  def oprint(*args, dict_mode=False):
                  Severity: Critical
                  Found in galgebra/printer.py by sonar-python

                  Cognitive Complexity is a measure of how hard the control flow of a function is to understand. Functions with high Cognitive Complexity will be difficult to maintain.

                  See

                  Refactor this function to reduce its Cognitive Complexity from 33 to the 15 allowed.
                  Open

                      def _print_Derivative(self, expr):
                  Severity: Critical
                  Found in galgebra/printer.py by sonar-python

                  Cognitive Complexity is a measure of how hard the control flow of a function is to understand. Functions with high Cognitive Complexity will be difficult to maintain.

                  See

                  Refactor this function to reduce its Cognitive Complexity from 30 to the 15 allowed.
                  Open

                  def Fmt(obj, fmt=0):
                  Severity: Critical
                  Found in galgebra/printer.py by sonar-python

                  Cognitive Complexity is a measure of how hard the control flow of a function is to understand. Functions with high Cognitive Complexity will be difficult to maintain.

                  See

                  Refactor this function to reduce its Cognitive Complexity from 41 to the 15 allowed.
                  Open

                      def _print_Pow(self, expr):
                  Severity: Critical
                  Found in galgebra/printer.py by sonar-python

                  Cognitive Complexity is a measure of how hard the control flow of a function is to understand. Functions with high Cognitive Complexity will be difficult to maintain.

                  See

                  Refactor this function to reduce its Cognitive Complexity from 23 to the 15 allowed.
                  Open

                  def tex(paper=(14, 11), debug=False, prog=False, pt='10pt'):
                  Severity: Critical
                  Found in galgebra/printer.py by sonar-python

                  Cognitive Complexity is a measure of how hard the control flow of a function is to understand. Functions with high Cognitive Complexity will be difficult to maintain.

                  See

                  Refactor this function to reduce its Cognitive Complexity from 72 to the 15 allowed.
                  Open

                      def _print_Function(self, expr, exp=None):
                  Severity: Critical
                  Found in galgebra/printer.py by sonar-python

                  Cognitive Complexity is a measure of how hard the control flow of a function is to understand. Functions with high Cognitive Complexity will be difficult to maintain.

                  See

                  Remove this commented out code.
                  Open

                                      #cell.title = None
                  Severity: Major
                  Found in galgebra/printer.py by sonar-python

                  Programmers should not comment out code as it bloats programs and reduces readability.

                  Unused code should be deleted and can be retrieved from source control history if required.

                  See

                  • MISRA C:2004, 2.4 - Sections of code should not be "commented out".
                  • MISRA C++:2008, 2-7-2 - Sections of code shall not be "commented out" using C-style comments.
                  • MISRA C++:2008, 2-7-3 - Sections of code should not be "commented out" using C++ comments.
                  • MISRA C:2012, Dir. 4.4 - Sections of code should not be "commented out"

                  Remove this commented out code.
                  Open

                              #base = self._print(expr.base)
                  Severity: Major
                  Found in galgebra/printer.py by sonar-python

                  Programmers should not comment out code as it bloats programs and reduces readability.

                  Unused code should be deleted and can be retrieved from source control history if required.

                  See

                  • MISRA C:2004, 2.4 - Sections of code should not be "commented out".
                  • MISRA C++:2008, 2-7-2 - Sections of code shall not be "commented out" using C-style comments.
                  • MISRA C++:2008, 2-7-3 - Sections of code should not be "commented out" using C++ comments.
                  • MISRA C:2012, Dir. 4.4 - Sections of code should not be "commented out"

                  Remove this commented out code.
                  Open

                      # fcts = find_functions(expr)
                  Severity: Major
                  Found in galgebra/printer.py by sonar-python

                  Programmers should not comment out code as it bloats programs and reduces readability.

                  Unused code should be deleted and can be retrieved from source control history if required.

                  See

                  • MISRA C:2004, 2.4 - Sections of code should not be "commented out".
                  • MISRA C++:2008, 2-7-2 - Sections of code shall not be "commented out" using C-style comments.
                  • MISRA C++:2008, 2-7-3 - Sections of code should not be "commented out" using C++ comments.
                  • MISRA C:2012, Dir. 4.4 - Sections of code should not be "commented out"

                  Remove this commented out code.
                  Open

                                      #title = cell.title
                  Severity: Major
                  Found in galgebra/printer.py by sonar-python

                  Programmers should not comment out code as it bloats programs and reduces readability.

                  Unused code should be deleted and can be retrieved from source control history if required.

                  See

                  • MISRA C:2004, 2.4 - Sections of code should not be "commented out".
                  • MISRA C++:2008, 2-7-2 - Sections of code shall not be "commented out" using C-style comments.
                  • MISRA C++:2008, 2-7-3 - Sections of code should not be "commented out" using C++ comments.
                  • MISRA C:2012, Dir. 4.4 - Sections of code should not be "commented out"

                  Merge this if statement with the enclosing one.
                  Open

                              if name in GaPrinter.function_names:
                  Severity: Major
                  Found in galgebra/printer.py by sonar-python

                  Merging collapsible if statements increases the code's readability.

                  Noncompliant Code Example

                  if condition1:
    if condition2:
        # ...

                  Compliant Solution

                  if condition1 and condition2:
    # ...

                  Remove this commented out code.
                  Open

                                  #cell.title = title
                  Severity: Major
                  Found in galgebra/printer.py by sonar-python

                  Programmers should not comment out code as it bloats programs and reduces readability.

                  Unused code should be deleted and can be retrieved from source control history if required.

                  See

                  • MISRA C:2004, 2.4 - Sections of code should not be "commented out".
                  • MISRA C++:2008, 2-7-2 - Sections of code shall not be "commented out" using C-style comments.
                  • MISRA C++:2008, 2-7-3 - Sections of code should not be "commented out" using C++ comments.
                  • MISRA C:2012, Dir. 4.4 - Sections of code should not be "commented out"

                  Remove this commented out code.
                  Open

                          #print '\nCode for '+fct_name
                  Severity: Major
                  Found in galgebra/printer.py by sonar-python

                  Programmers should not comment out code as it bloats programs and reduces readability.

                  Unused code should be deleted and can be retrieved from source control history if required.

                  See

                  • MISRA C:2004, 2.4 - Sections of code should not be "commented out".
                  • MISRA C++:2008, 2-7-2 - Sections of code shall not be "commented out" using C-style comments.
                  • MISRA C++:2008, 2-7-3 - Sections of code should not be "commented out" using C++ comments.
                  • MISRA C:2012, Dir. 4.4 - Sections of code should not be "commented out"

                  Remove this commented out code.
                  Open

                                  #title = cell.title
                  Severity: Major
                  Found in galgebra/printer.py by sonar-python

                  Programmers should not comment out code as it bloats programs and reduces readability.

                  Unused code should be deleted and can be retrieved from source control history if required.

                  See

                  • MISRA C:2004, 2.4 - Sections of code should not be "commented out".
                  • MISRA C++:2008, 2-7-2 - Sections of code shall not be "commented out" using C-style comments.
                  • MISRA C++:2008, 2-7-3 - Sections of code should not be "commented out" using C++ comments.
                  • MISRA C:2012, Dir. 4.4 - Sections of code should not be "commented out"

                  Remove this commented out code.
                  Open

                          #print '#Code for '+fct_name
                  Severity: Major
                  Found in galgebra/printer.py by sonar-python

                  Programmers should not comment out code as it bloats programs and reduces readability.

                  Unused code should be deleted and can be retrieved from source control history if required.

                  See

                  • MISRA C:2004, 2.4 - Sections of code should not be "commented out".
                  • MISRA C++:2008, 2-7-2 - Sections of code shall not be "commented out" using C-style comments.
                  • MISRA C++:2008, 2-7-3 - Sections of code should not be "commented out" using C++ comments.
                  • MISRA C:2012, Dir. 4.4 - Sections of code should not be "commented out"

                  Remove this commented out code.
                  Open

                                  #cell.title = title
                  Severity: Major
                  Found in galgebra/printer.py by sonar-python

                  Programmers should not comment out code as it bloats programs and reduces readability.

                  Unused code should be deleted and can be retrieved from source control history if required.

                  See

                  • MISRA C:2004, 2.4 - Sections of code should not be "commented out".
                  • MISRA C++:2008, 2-7-2 - Sections of code shall not be "commented out" using C-style comments.
                  • MISRA C++:2008, 2-7-3 - Sections of code should not be "commented out" using C++ comments.
                  • MISRA C:2012, Dir. 4.4 - Sections of code should not be "commented out"

                  Either merge this branch with the identical one on line "919" or change one of the implementations.
                  Open

                              pass
                  Severity: Major
                  Found in galgebra/printer.py by sonar-python

                  Having two branches in the same if structure with the same implementation is at best duplicate code, and at worst a coding error. If the same logic is truly needed for both instances, then they should be combined.

                  Noncompliant Code Example

                  if 0 <= a < 10:
    do_the_thing()
elif 10 <= a < 20:
    do_the_other_thing()
elif 20 <= a < 50:
    do_the_thing()  # Noncompliant; duplicates first condition
else:
    do_the_rest()

b = 4 if a > 12 else 4

                  Compliant Solution

                  if (0 <= a < 10) or (20 <= a < 50):
    do_the_thing()
elif 10 <= a < 20:
    do_the_other_thing()
else:
    do_the_rest()

b = 4

                  or 

                  if 0 <= a < 10:
    do_the_thing()
elif 10 <= a < 20:
    do_the_other_thing()
elif 20 <= a < 50:
    do_the_third_thing()
else:
    do_the_rest()

b = 8 if a > 12 else 4

                  Remove or correct this useless self-assignment.
                  Open

                                      func = func
                  Severity: Major
                  Found in galgebra/printer.py by sonar-python

                  There is no reason to re-assign a variable to itself. Either this statement is redundant and should be removed, or the re-assignment is a mistake and some other value or variable was intended for the assignment instead.

                  Noncompliant Code Example

                  name = name

                  Compliant Solution

                  name = other.name

                  See

                  Either remove or fill this block of code.
                  Open

                              pass
                  Severity: Major
                  Found in galgebra/printer.py by sonar-python

                  Most of the time a block of code is empty when a piece of code is really missing. So such empty block must be either filled or removed.

                  Noncompliant Code Example

                  for i in range(3):
    pass

                  Exceptions

                  When a block contains a comment, this block is not considered to be empty.

                  Either remove or fill this block of code.
                  Open

                              pass
                  Severity: Major
                  Found in galgebra/printer.py by sonar-python

                  Most of the time a block of code is empty when a piece of code is really missing. So such empty block must be either filled or removed.

                  Noncompliant Code Example

                  for i in range(3):
    pass

                  Exceptions

                  When a block contains a comment, this block is not considered to be empty.

                  Either remove or fill this block of code.
                  Open

                              pass
                  Severity: Major
                  Found in galgebra/printer.py by sonar-python

                  Most of the time a block of code is empty when a piece of code is really missing. So such empty block must be either filled or removed.

                  Noncompliant Code Example

                  for i in range(3):
    pass

                  Exceptions

                  When a block contains a comment, this block is not considered to be empty.

                  Line too long (80 > 79 characters)
                  Open

                        * ``basis_vector_color``, for adjusting the color of basis vector symbols.
                  Severity: Minor
                  Found in galgebra/printer.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 (96 > 79 characters)
                  Open

                                  if func in accepted_latex_functions or not self._settings["omit_function_args"]:
                  Severity: Minor
                  Found in galgebra/printer.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

                          elif expr.exp.is_Rational and expr.exp.is_negative and expr.base.is_Function:
                  Severity: Minor
                  Found in galgebra/printer.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

                  where ``Fmode`` is the function printing mode that suppresses printing arguments,
                  Severity: Minor
                  Found in galgebra/printer.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.

                  Block comment should start with '# '
                  Open

                                      #solves issue 1030
                  Severity: Minor
                  Found in galgebra/printer.py by pep8

                  Separate inline comments by at least two spaces.

                  An inline comment is a comment on the same line as a statement.
Inline comments should be separated by at least two spaces from the
statement. They should start with a # and a single space.

Each line of a block comment starts with a # and a single space
(unless it is indented text inside the comment).

Okay: x = x + 1  # Increment x
Okay: x = x + 1    # Increment x
Okay: # Block comment
E261: x = x + 1 # Increment x
E262: x = x + 1  #Increment x
E262: x = x + 1  #  Increment x
E265: #Block comment
E266: ### Block comment

                  Block comment should start with '# '
                  Open

                                      #first we get the latex for -1 * expr,
                  Severity: Minor
                  Found in galgebra/printer.py by pep8

                  Separate inline comments by at least two spaces.

                  An inline comment is a comment on the same line as a statement.
Inline comments should be separated by at least two spaces from the
statement. They should start with a # and a single space.

Each line of a block comment starts with a # and a single space
(unless it is indented text inside the comment).

Okay: x = x + 1  # Increment x
Okay: x = x + 1    # Increment x
Okay: # Block comment
E261: x = x + 1 # Increment x
E262: x = x + 1  #Increment x
E262: x = x + 1  #  Increment x
E265: #Block comment
E266: ### Block comment

                  Line too long (86 > 79 characters)
                  Open

                             'darwin': {'rm': 'rm', 'evince': 'open', 'null': ' > /dev/null', '&': '&'}}
                  Severity: Minor
                  Found in galgebra/printer.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

                                              name = r'\left ( ' + name + r'\right )^{' + exp + '}'
                  Severity: Minor
                  Found in galgebra/printer.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.

                  Inline comment should start with '# '
                  Open

                  def isinteractive():  #Is ipython running
                  Severity: Minor
                  Found in galgebra/printer.py by pep8

                  Separate inline comments by at least two spaces.

                  An inline comment is a comment on the same line as a statement.
Inline comments should be separated by at least two spaces from the
statement. They should start with a # and a single space.

Each line of a block comment starts with a # and a single space
(unless it is indented text inside the comment).

Okay: x = x + 1  # Increment x
Okay: x = x + 1    # Increment x
Okay: # Block comment
E261: x = x + 1 # Increment x
E262: x = x + 1  #Increment x
E262: x = x + 1  #  Increment x
E265: #Block comment
E266: ### Block comment

                  Line too long (84 > 79 characters)
                  Open

                                  return expr.func.__name__ + "(%s)" % self.stringify(expr.args, ", ")
                  Severity: Minor
                  Found in galgebra/printer.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.

                  Block comment should start with '# '
                  Open

                                      #As Mul always simplify 1/x to x**-1
                  Severity: Minor
                  Found in galgebra/printer.py by pep8

                  Separate inline comments by at least two spaces.

                  An inline comment is a comment on the same line as a statement.
Inline comments should be separated by at least two spaces from the
statement. They should start with a # and a single space.

Each line of a block comment starts with a # and a single space
(unless it is indented text inside the comment).

Okay: x = x + 1  # Increment x
Okay: x = x + 1    # Increment x
Okay: # Block comment
E261: x = x + 1 # Increment x
E262: x = x + 1  #Increment x
E262: x = x + 1  #  Increment x
E265: #Block comment
E266: ### Block comment

                  Line too long (82 > 79 characters)
                  Open

                                        'root', 'sin', 'sinh', 'sqrt', 'sign', 'tan', 'tanh', 'Abs')
                  Severity: Minor
                  Found in galgebra/printer.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 (80 > 79 characters)
                  Open

                                          name = r'{\left ( ' + name + r'\right ) }^{' + exp + '}'
                  Severity: Minor
                  Found in galgebra/printer.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 (80 > 79 characters)
                  Open

                             'win32': {'rm': 'del', 'evince': 'start', 'null': ' > NUL', '&': ''},
                  Severity: Minor
                  Found in galgebra/printer.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.

                  Block comment should start with '# '
                  Open

                                      #which is a Mul expression
                  Severity: Minor
                  Found in galgebra/printer.py by pep8

                  Separate inline comments by at least two spaces.

                  An inline comment is a comment on the same line as a statement.
Inline comments should be separated by at least two spaces from the
statement. They should start with a # and a single space.

Each line of a block comment starts with a # and a single space
(unless it is indented text inside the comment).

Okay: x = x + 1  # Increment x
Okay: x = x + 1    # Increment x
Okay: # Block comment
E261: x = x + 1 # Increment x
E262: x = x + 1  #Increment x
E262: x = x + 1  #  Increment x
E265: #Block comment
E266: ### Block comment

                  Line too long (88 > 79 characters)
                  Open

                                          tmp = tmp.replace(glyph, GaLatexPrinter.greek_translated[glyph])
                  Severity: Minor
                  Found in galgebra/printer.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

                                  len(args) == 1 and not self._needs_function_brackets(expr.args[0])
                  Severity: Minor
                  Found in galgebra/printer.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

                  ``ipy=True`` is the IPython notebook mode that does not redirect the print output.
                  Severity: Minor
                  Found in galgebra/printer.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

                             'linux': {'rm': 'rm', 'evince': 'evince', 'null': ' > /dev/null', '&': '&'},
                  Severity: Minor
                  Found in galgebra/printer.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.

                  Block comment should start with '# '
                  Open

                              #base = self._print(expr.base)
                  Severity: Minor
                  Found in galgebra/printer.py by pep8

                  Separate inline comments by at least two spaces.

                  An inline comment is a comment on the same line as a statement.
Inline comments should be separated by at least two spaces from the
statement. They should start with a # and a single space.

Each line of a block comment starts with a # and a single space
(unless it is indented text inside the comment).

Okay: x = x + 1  # Increment x
Okay: x = x + 1    # Increment x
Okay: # Block comment
E261: x = x + 1 # Increment x
E262: x = x + 1  #Increment x
E262: x = x + 1  #  Increment x
E265: #Block comment
E266: ### Block comment

                  Block comment should start with '# '
                  Open

                                      #The objective is achieved with this hack
                  Severity: Minor
                  Found in galgebra/printer.py by pep8

                  Separate inline comments by at least two spaces.

                  An inline comment is a comment on the same line as a statement.
Inline comments should be separated by at least two spaces from the
statement. They should start with a # and a single space.

Each line of a block comment starts with a # and a single space
(unless it is indented text inside the comment).

Okay: x = x + 1  # Increment x
Okay: x = x + 1    # Increment x
Okay: # Block comment
E261: x = x + 1 # Increment x
E262: x = x + 1  #Increment x
E262: x = x + 1  #  Increment x
E265: #Block comment
E266: ### Block comment

                  Line too long (92 > 79 characters)
                  Open

                              if func in accepted_latex_functions or not self._settings["omit_function_args"]:
                  Severity: Minor
                  Found in galgebra/printer.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

                  SYS_CMD = {'linux2': {'rm': 'rm', 'evince': 'evince', 'null': ' > /dev/null', '&': '&'},
                  Severity: Minor
                  Found in galgebra/printer.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

                      special_alphabet = list(reversed(sorted(list(greeks) + list(other), key=len)))
                  Severity: Minor
                  Found in galgebra/printer.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

                              inv_trig_table = ["asin", "acos", "atan", "acot", "acosh", "asinh", "atanh"]
                  Severity: Minor
                  Found in galgebra/printer.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 (86 > 79 characters)
                  Open

                                  tex = r"\frac{\partial}{\partial %s}" % self._print(expr.variables[0])
                  Severity: Minor
                  Found in galgebra/printer.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

                                  return r"{%s}^{%s}" % (self._print(expr.base), self._print(expr.exp))
                  Severity: Minor
                  Found in galgebra/printer.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 (80 > 79 characters)
                  Open

                                          # If this glyph is already escaped, avoid escaping again
                  Severity: Minor
                  Found in galgebra/printer.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.

                  Continuation line under-indented for visual indent
                  Open

                  """
                  Severity: Minor
                  Found in galgebra/printer.py by pep8

                  Continuation lines indentation.

                  Continuation lines should align wrapped elements either vertically
using Python's implicit line joining inside parentheses, brackets
and braces, or using a hanging indent.

When using a hanging indent these considerations should be applied:
- there should be no arguments on the first line, and
- further indentation should be used to clearly distinguish itself
  as a continuation line.

Okay: a = (\n)
E123: a = (\n    )

Okay: a = (\n    42)
E121: a = (\n   42)
E122: a = (\n42)
E123: a = (\n    42\n    )
E124: a = (24,\n     42\n)
E125: if (\n    b):\n    pass
E126: a = (\n        42)
E127: a = (24,\n      42)
E128: a = (24,\n    42)
E129: if (a or\n    b):\n    pass
E131: a = (\n    42\n 24)

                  Block comment should start with '# '
                  Open

                                      #the result comes with a minus and a space, so we remove
                  Severity: Minor
                  Found in galgebra/printer.py by pep8

                  Separate inline comments by at least two spaces.

                  An inline comment is a comment on the same line as a statement.
Inline comments should be separated by at least two spaces from the
statement. They should start with a # and a single space.

Each line of a block comment starts with a # and a single space
(unless it is indented text inside the comment).

Okay: x = x + 1  # Increment x
Okay: x = x + 1    # Increment x
Okay: # Block comment
E261: x = x + 1 # Increment x
E262: x = x + 1  #Increment x
E262: x = x + 1  #  Increment x
E265: #Block comment
E266: ### Block comment

                  Line too long (93 > 79 characters)
                  Open

                  ANSI Enhanced Text Printing, Text Printer and LaTeX Printer for all Geometric Algebra classes
                  Severity: Minor
                  Found in galgebra/printer.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 (103 > 79 characters)
                  Open

                                          translated_glyph = (escaped_glyph + ' ') if escaped_glyph not in tmp else glyph
                  Severity: Minor
                  Found in galgebra/printer.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 (101 > 79 characters)
                  Open

                      We assume that if xpdf() is called then Format() has been called at the beginning of the program.
                  Severity: Minor
                  Found in galgebra/printer.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 (103 > 79 characters)
                  Open

                                  latex_line = r'\begin{align*} ' + latex_line.replace(r'\begin{align*}', '', 1).lstrip()
                  Severity: Minor
                  Found in galgebra/printer.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 (100 > 79 characters)
                  Open

                      pdfprog    'pdflatex'   Use pdfprog to generate pdf output, only generate tex if pdfprog is None
                  Severity: Minor
                  Found in galgebra/printer.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 (84 > 79 characters)
                  Open

                          print_cmd = sys_cmd['evince'] + ' ' + filename[:-4] + '.pdf ' + sys_cmd['&']
                  Severity: Minor
                  Found in galgebra/printer.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 (101 > 79 characters)
                  Open

                      crop        True        Use "pdfcrop" to crop output file (pdfcrop must be installed, linux only)
                  Severity: Minor
                  Found in galgebra/printer.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 (83 > 79 characters)
                  Open

                                r'showstringspaces=false,backgroundcolor=\color{gray},frame=single]')
                  Severity: Minor
                  Found in galgebra/printer.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 (93 > 79 characters)
                  Open

                                  latex_line = r'\begin{equation*} ' + latex_line.strip() + r' \end{equation*}'
                  Severity: Minor
                  Found in galgebra/printer.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 (93 > 79 characters)
                  Open

                              os.system(sys_cmd['rm'] + ' ' + filename[:-4] + '.aux ' + filename[:-4] + '.log')
                  Severity: Minor
                  Found in galgebra/printer.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 (80 > 79 characters)
                  Open

                      For example consider where ``X``, ``Y``, ``Z``, and ``W`` are multivectors::
                  Severity: Minor
                  Found in galgebra/printer.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.

                  Block comment should start with '# '
                  Open

                                      #cell.title = None
                  Severity: Minor
                  Found in galgebra/printer.py by pep8

                  Separate inline comments by at least two spaces.

                  An inline comment is a comment on the same line as a statement.
Inline comments should be separated by at least two spaces from the
statement. They should start with a # and a single space.

Each line of a block comment starts with a # and a single space
(unless it is indented text inside the comment).

Okay: x = x + 1  # Increment x
Okay: x = x + 1    # Increment x
Okay: # Block comment
E261: x = x + 1 # Increment x
E262: x = x + 1  #Increment x
E262: x = x + 1  #  Increment x
E265: #Block comment
E266: ### Block comment

                  Line too long (115 > 79 characters)
                  Open

                          The default precedence, ``'<>|,^,*'``, is that used by Hestenes (:cite:`Hestenes`, p7, :cite:`Doran`, p38).
                  Severity: Minor
                  Found in galgebra/printer.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.

                  Block comment should start with '# '
                  Open

                                      #cell.title = None
                  Severity: Minor
                  Found in galgebra/printer.py by pep8

                  Separate inline comments by at least two spaces.

                  An inline comment is a comment on the same line as a statement.
Inline comments should be separated by at least two spaces from the
statement. They should start with a # and a single space.

Each line of a block comment starts with a # and a single space
(unless it is indented text inside the comment).

Okay: x = x + 1  # Increment x
Okay: x = x + 1    # Increment x
Okay: # Block comment
E261: x = x + 1 # Increment x
E262: x = x + 1  #Increment x
E262: x = x + 1  #  Increment x
E265: #Block comment
E266: ### Block comment

                  Block comment should start with '# '
                  Open

                                  #cell.title = title
                  Severity: Minor
                  Found in galgebra/printer.py by pep8

                  Separate inline comments by at least two spaces.

                  An inline comment is a comment on the same line as a statement.
Inline comments should be separated by at least two spaces from the
statement. They should start with a # and a single space.

Each line of a block comment starts with a # and a single space
(unless it is indented text inside the comment).

Okay: x = x + 1  # Increment x
Okay: x = x + 1    # Increment x
Okay: # Block comment
E261: x = x + 1 # Increment x
E262: x = x + 1  #Increment x
E262: x = x + 1  #  Increment x
E265: #Block comment
E266: ### Block comment

                  Line too long (141 > 79 characters)
                  Open

                      ``Format()`` is also required for printing from *ipython notebook* (note that ``xpdf()`` is not needed to print from *ipython notebook*).
                  Severity: Minor
                  Found in galgebra/printer.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.

                  Block comment should start with '# '
                  Open

                          #print '\nCode for '+fct_name
                  Severity: Minor
                  Found in galgebra/printer.py by pep8

                  Separate inline comments by at least two spaces.

                  An inline comment is a comment on the same line as a statement.
Inline comments should be separated by at least two spaces from the
statement. They should start with a # and a single space.

Each line of a block comment starts with a # and a single space
(unless it is indented text inside the comment).

Okay: x = x + 1  # Increment x
Okay: x = x + 1    # Increment x
Okay: # Block comment
E261: x = x + 1 # Increment x
E262: x = x + 1  #Increment x
E262: x = x + 1  #  Increment x
E265: #Block comment
E266: ### Block comment

                  Line too long (119 > 79 characters)
                  Open

                  def xpdf(filename=None, paper=(14, 11), crop=False, png=False, prog=False, debug=False, pt='10pt', pdfprog='pdflatex'):
                  Severity: Minor
                  Found in galgebra/printer.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 (107 > 79 characters)
                  Open

                      png         True        Use "convert" to produce png output (imagemagick must be installed, linux only)
                  Severity: Minor
                  Found in galgebra/printer.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 (80 > 79 characters)
                  Open

                      We assume that if :func:`tex` is called, then :func:`Format` has been called
                  Severity: Minor
                  Found in galgebra/printer.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.

                  Continuation line missing indentation or outdented
                  Open

                  """
                  Severity: Minor
                  Found in galgebra/printer.py by pep8

                  Continuation lines indentation.

                  Continuation lines should align wrapped elements either vertically
using Python's implicit line joining inside parentheses, brackets
and braces, or using a hanging indent.

When using a hanging indent these considerations should be applied:
- there should be no arguments on the first line, and
- further indentation should be used to clearly distinguish itself
  as a continuation line.

Okay: a = (\n)
E123: a = (\n    )

Okay: a = (\n    42)
E121: a = (\n   42)
E122: a = (\n42)
E123: a = (\n    42\n    )
E124: a = (24,\n     42\n)
E125: if (\n    b):\n    pass
E126: a = (\n        42)
E127: a = (24,\n      42)
E128: a = (24,\n    42)
E129: if (a or\n    b):\n    pass
E131: a = (\n    42\n 24)

                  Continuation line missing indentation or outdented
                  Open

                  """
                  Severity: Minor
                  Found in galgebra/printer.py by pep8

                  Continuation lines indentation.

                  Continuation lines should align wrapped elements either vertically
using Python's implicit line joining inside parentheses, brackets
and braces, or using a hanging indent.

When using a hanging indent these considerations should be applied:
- there should be no arguments on the first line, and
- further indentation should be used to clearly distinguish itself
  as a continuation line.

Okay: a = (\n)
E123: a = (\n    )

Okay: a = (\n    42)
E121: a = (\n   42)
E122: a = (\n42)
E123: a = (\n    42\n    )
E124: a = (24,\n     42\n)
E125: if (\n    b):\n    pass
E126: a = (\n        42)
E127: a = (24,\n      42)
E128: a = (24,\n    42)
E129: if (a or\n    b):\n    pass
E131: a = (\n    42\n 24)

                  Line too long (92 > 79 characters)
                  Open

                      latex_str = paper_size + GaLatexPrinter.preamble + latex_str + GaLatexPrinter.postscript
                  Severity: Minor
                  Found in galgebra/printer.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 (99 > 79 characters)
                  Open

                      xpdf(filename=filename, paper=paper, crop=False, png=False, prog=False, debug=debug, pt='10pt')
                  Severity: Minor
                  Found in galgebra/printer.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 (107 > 79 characters)
                  Open

                                      latex_str += r'\begin{array}{c} \left ' + ldelim + r' ' + latex_cell + r', \right. \\ '
                  Severity: Minor
                  Found in galgebra/printer.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 (83 > 79 characters)
                  Open

                                        'in,' + str(paper[1]) + 'in},total={' + str(paper[0] - 1) + \
                  Severity: Minor
                  Found in galgebra/printer.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.

                  Block comment should start with '# '
                  Open

                                      #title = cell.title
                  Severity: Minor
                  Found in galgebra/printer.py by pep8

                  Separate inline comments by at least two spaces.

                  An inline comment is a comment on the same line as a statement.
Inline comments should be separated by at least two spaces from the
statement. They should start with a # and a single space.

Each line of a block comment starts with a # and a single space
(unless it is indented text inside the comment).

Okay: x = x + 1  # Increment x
Okay: x = x + 1    # Increment x
Okay: # Block comment
E261: x = x + 1 # Increment x
E262: x = x + 1  #Increment x
E262: x = x + 1  #  Increment x
E265: #Block comment
E266: ### Block comment

                  Block comment should start with '# '
                  Open

                                  #cell.title = title
                  Severity: Minor
                  Found in galgebra/printer.py by pep8

                  Separate inline comments by at least two spaces.

                  An inline comment is a comment on the same line as a statement.
Inline comments should be separated by at least two spaces from the
statement. They should start with a # and a single space.

Each line of a block comment starts with a # and a single space
(unless it is indented text inside the comment).

Okay: x = x + 1  # Increment x
Okay: x = x + 1    # Increment x
Okay: # Block comment
E261: x = x + 1 # Increment x
E262: x = x + 1  #Increment x
E262: x = x + 1  #  Increment x
E265: #Block comment
E266: ### Block comment

                  Block comment should start with '# '
                  Open

                          #print '#Code for '+fct_name
                  Severity: Minor
                  Found in galgebra/printer.py by pep8

                  Separate inline comments by at least two spaces.

                  An inline comment is a comment on the same line as a statement.
Inline comments should be separated by at least two spaces from the
statement. They should start with a # and a single space.

Each line of a block comment starts with a # and a single space
(unless it is indented text inside the comment).

Okay: x = x + 1  # Increment x
Okay: x = x + 1    # Increment x
Okay: # Block comment
E261: x = x + 1 # Increment x
E262: x = x + 1  #Increment x
E262: x = x + 1  #  Increment x
E265: #Block comment
E266: ### Block comment

                  Block comment should start with '# '
                  Open

                                  #cell.title = None
                  Severity: Minor
                  Found in galgebra/printer.py by pep8

                  Separate inline comments by at least two spaces.

                  An inline comment is a comment on the same line as a statement.
Inline comments should be separated by at least two spaces from the
statement. They should start with a # and a single space.

Each line of a block comment starts with a # and a single space
(unless it is indented text inside the comment).

Okay: x = x + 1  # Increment x
Okay: x = x + 1    # Increment x
Okay: # Block comment
E261: x = x + 1 # Increment x
E262: x = x + 1  #Increment x
E262: x = x + 1  #  Increment x
E265: #Block comment
E266: ### Block comment

                  Line too long (101 > 79 characters)
                  Open

                          prog_str = '{\\Large \\bf Program:}\\begin{lstlisting}[language=Python,showspaces=false,' + \
                  Severity: Minor
                  Found in galgebra/printer.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 (84 > 79 characters)
                  Open

                                     prog_str + '\n\\end{lstlisting}\n {\\Large \\bf Code Output:} \n'
                  Severity: Minor
                  Found in galgebra/printer.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

                              os.system(sys_cmd['rm'] + ' ' + filename[:-4] + '.aux ' + filename[:-4] + '.log ' + filename[:-4] + '.tex')
                  Severity: Minor
                  Found in galgebra/printer.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

                          "want to turn off program printing, then just don't call Print_Function!",
                  Severity: Minor
                  Found in galgebra/printer.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 (142 > 79 characters)
                  Open

                      This is used with the ``GAeval()`` function to evaluate a string representing a multivector expression with a revised operator precedence.
                  Severity: Minor
                  Found in galgebra/printer.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 (110 > 79 characters)
                  Open

                          The order of operator precedence from high to low with groups of equal precedence separated by commas.
                  Severity: Minor
                  Found in galgebra/printer.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.

                  Block comment should start with '# '
                  Open

                                  #title = cell.title
                  Severity: Minor
                  Found in galgebra/printer.py by pep8

                  Separate inline comments by at least two spaces.

                  An inline comment is a comment on the same line as a statement.
Inline comments should be separated by at least two spaces from the
statement. They should start with a # and a single space.

Each line of a block comment starts with a # and a single space
(unless it is indented text inside the comment).

Okay: x = x + 1  # Increment x
Okay: x = x + 1    # Increment x
Okay: # Block comment
E261: x = x + 1 # Increment x
E262: x = x + 1  #Increment x
E262: x = x + 1  #  Increment x
E265: #Block comment
E266: ### Block comment

                  Line too long (100 > 79 characters)
                  Open

                                      latex_str += r' \left. ' + latex_cell + r'\right ' + rdelim + r' \\ \end{array}'
                  Severity: Minor
                  Found in galgebra/printer.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.

                  Rename function "Print_Function" to match the regular expression ^[a-z_][a-z0-9_]{2,}$.
                  Open

                  def Print_Function():
                  Severity: Major
                  Found in galgebra/printer.py by sonar-python

                  Shared coding conventions allow teams to collaborate efficiently. This rule checks that all function names match a provided regular expression.

                  Noncompliant Code Example

                  With the default provided regular expression: ^[a-z_][a-z0-9_]{2,30}$

                  def MyFunction(a,b):
    ...

                  Compliant Solution

                  def my_function(a,b):
    ...

                  Rename function "Format" to match the regular expression ^[a-z_][a-z0-9_]{2,}$.
                  Open

                  def Format(Fmode: bool = True, Dmode: bool = True, inverse='full'):
                  Severity: Major
                  Found in galgebra/printer.py by sonar-python

                  Shared coding conventions allow teams to collaborate efficiently. This rule checks that all function names match a provided regular expression.

                  Noncompliant Code Example

                  With the default provided regular expression: ^[a-z_][a-z0-9_]{2,30}$

                  def MyFunction(a,b):
    ...

                  Compliant Solution

                  def my_function(a,b):
    ...

                  Rename function "GAeval" to match the regular expression ^[a-z_][a-z0-9_]{2,}$.
                  Open

                  def GAeval(s: str, pstr: bool = False):
                  Severity: Major
                  Found in galgebra/printer.py by sonar-python

                  Shared coding conventions allow teams to collaborate efficiently. This rule checks that all function names match a provided regular expression.

                  Noncompliant Code Example

                  With the default provided regular expression: ^[a-z_][a-z0-9_]{2,30}$

                  def MyFunction(a,b):
    ...

                  Compliant Solution

                  def my_function(a,b):
    ...

                  Rename function "Fmt" to match the regular expression ^[a-z_][a-z0-9_]{2,}$.
                  Open

                  def Fmt(obj, fmt=0):
                  Severity: Major
                  Found in galgebra/printer.py by sonar-python

                  Shared coding conventions allow teams to collaborate efficiently. This rule checks that all function names match a provided regular expression.

                  Noncompliant Code Example

                  With the default provided regular expression: ^[a-z_][a-z0-9_]{2,30}$

                  def MyFunction(a,b):
    ...

                  Compliant Solution

                  def my_function(a,b):
    ...

                  Rename function "LatexFormat" to match the regular expression ^[a-z_][a-z0-9_]{2,}$.
                  Open

                  def LatexFormat(Fmode=True, Dmode=True, ipy=False):
                  Severity: Major
                  Found in galgebra/printer.py by sonar-python

                  Shared coding conventions allow teams to collaborate efficiently. This rule checks that all function names match a provided regular expression.

                  Noncompliant Code Example

                  With the default provided regular expression: ^[a-z_][a-z0-9_]{2,30}$

                  def MyFunction(a,b):
    ...

                  Compliant Solution

                  def my_function(a,b):
    ...

                  Rename function "Get_Program" to match the regular expression ^[a-z_][a-z0-9_]{2,}$.
                  Open

                  def Get_Program(off=False):
                  Severity: Major
                  Found in galgebra/printer.py by sonar-python

                  Shared coding conventions allow teams to collaborate efficiently. This rule checks that all function names match a provided regular expression.

                  Noncompliant Code Example

                  With the default provided regular expression: ^[a-z_][a-z0-9_]{2,30}$

                  def MyFunction(a,b):
    ...

                  Compliant Solution

                  def my_function(a,b):
    ...

                  Rename function "Eprint" to match the regular expression ^[a-z_][a-z0-9_]{2,}$.
                  Open

                  def Eprint(*args, **kwargs):
                  Severity: Major
                  Found in galgebra/printer.py by sonar-python

                  Shared coding conventions allow teams to collaborate efficiently. This rule checks that all function names match a provided regular expression.

                  Noncompliant Code Example

                  With the default provided regular expression: ^[a-z_][a-z0-9_]{2,30}$

                  def MyFunction(a,b):
    ...

                  Compliant Solution

                  def my_function(a,b):
    ...

                  There are no issues that match your filters.

                  Category
                  Status