betteridiot/bamnostic

View on GitHub
bamnostic/bam.py

Summary

Maintainability
F
4 days
Test Coverage

Function count_coverage has a Cognitive Complexity of 55 (exceeds 5 allowed). Consider refactoring.
Open

    def count_coverage(self, contig=None, start=None, stop=None, region=None,
                       quality_threshold=15, read_callback='all',
                       reference=None, end=None, base_quality_threshold=0):
        """ Counts the coverage of each base supported by a read the given interval.

Severity: Minor
Found in bamnostic/bam.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

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

    def fetch(self, contig=None, start=None, stop=None, region=None,
              tid=None, until_eof=False, multiple_iterators=False,
              reference=None, end=None):
        """Creates a generator that returns all reads within the given region. (inclusive, exclusive)

Severity: Minor
Found in bamnostic/bam.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 __init__ has a Cognitive Complexity of 24 (exceeds 5 allowed). Consider refactoring.
Open

    def __init__(self, _io):
        """ Initialize the header

        Args:
            _io (:py:obj:`file`): opened BAM file object
Severity: Minor
Found in bamnostic/bam.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

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

    def __init__(self, filepath_or_object, mode = 'xb', compresslevel = 6, ignore_overwrite = False,
                copy_header = None, header = b'', reference_names = None, reference_lengths = None):
        """Useful class for writing BAM files. 

        Note:
Severity: Minor
Found in bamnostic/bam.py - About 2 hrs to fix

Cognitive Complexity

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

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

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

Further reading

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

    def check_index(self, index_filename=None, req_idx=False):
        """ Checks to make sure index file is available. If not, it disables random access.

        Args:
            index_filename (str): path to index file (BAI) if it does not fit naming convention (default: None).
Severity: Minor
Found in bamnostic/bam.py - About 2 hrs to fix

Cognitive Complexity

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

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

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

Further reading

Function _sam_header_to_ref_list has a Cognitive Complexity of 15 (exceeds 5 allowed). Consider refactoring.
Open

def _sam_header_to_ref_list(header):
    """Modified code from Peter Cock's [BamWriter](https://github.com/peterjc/biopython/blob/SamBam2015/Bio/Sequencing/SamBam/__init__.py#L1714)

    Removes blank lines, ensures trailing newlines, spots some errors.

Severity: Minor
Found in bamnostic/bam.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 write_header has a Cognitive Complexity of 12 (exceeds 5 allowed). Consider refactoring.
Open

    def write_header(self, copy_header = None, header = b'', reference_names = None, reference_lengths = None):
        """Modified code from Peter Cock's [BamWriter](https://github.com/peterjc/biopython/blob/SamBam2015/Bio/Sequencing/SamBam/__init__.py#L1714)

        Writes the header into a BAM file

Severity: Minor
Found in bamnostic/bam.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 mate has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.
Open

    def mate(self, AlignedSegment):
        """ Gets the mate to a given AlignedSegment.

        Note:
            Slow, when compared to the C-API. Not meant for high-throughput analysis.
Severity: Minor
Found in bamnostic/bam.py - About 55 mins to fix

Cognitive Complexity

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

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

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

Further reading

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

    def __init__(self, filepath_or_object, mode="rb", max_cache=128, index_filename=None,
                 filename=None, check_header=False, check_sq=True, reference_filename=None,
                 filepath_index=None, require_index=False, duplicate_filehandle=None,
                 ignore_truncation=False):
        """Initialize the class.
Severity: Minor
Found in bamnostic/bam.py - About 55 mins to fix

Cognitive Complexity

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

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

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

Further reading

Avoid deeply nested control flow statements.
Open

                        if len(split_field) > 2:
                            tag = split_field[0]
                            value = split_field[2]
                        else:
                            tag, value = split_field
Severity: Major
Found in bamnostic/bam.py - About 45 mins to fix

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

    def _cross_check_header_refs(reads, header="", referencenames = None, referencelengths = None):
        """Modified code from Peter Cock's [BamWriter](https://github.com/peterjc/biopython/blob/SamBam2015/Bio/Sequencing/SamBam/__init__.py#L1714)
        """
        if not header:
            # If the reads argument is a SamIterator or BamIterator this works:
    Severity: Minor
    Found in bamnostic/bam.py - About 45 mins to fix

    Cognitive Complexity

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

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

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

    Further reading

    Avoid deeply nested control flow statements.
    Open

                            if start <= index < stop:
                                if base == 'A':
                                    adenine[index - start if index-start > 0 else 0] += 1
                                elif base == 'G':
                                    guanine[index - start if index-start > 0 else 0] += 1
    Severity: Major
    Found in bamnostic/bam.py - About 45 mins to fix

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

          def _init_index(self):
              """Initialize the index file (BAI)"""
      
              if self._check_idx:
                  # self._index = bamnostic.bai.Bai(self._index_path)
      Severity: Minor
      Found in bamnostic/bam.py - About 45 mins to fix

      Cognitive Complexity

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

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

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

      Further reading

      Avoid too many return statements within this function.
      Open

                          return
      Severity: Major
      Found in bamnostic/bam.py - About 30 mins to fix

        Avoid too many return statements within this function.
        Open

                    return
        Severity: Major
        Found in bamnostic/bam.py - About 30 mins to fix

          Avoid too many return statements within this function.
          Open

                              return
          Severity: Major
          Found in bamnostic/bam.py - About 30 mins to fix

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

                def _check_sq(self):
                    """ Inspect BAM file for @SQ entries within the header
            
                    The implementation of this check is for BAM files specifically. I inspects
                    the SAM header (if present) for the `@SQ` entires. However, if the SAM header
            Severity: Minor
            Found in bamnostic/bam.py - About 25 mins to fix

            Cognitive Complexity

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

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

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

            Further reading

            Continuation line under-indented for visual indent
            Open

                                'mode': locals()['mode'], 'max_cache': locals()['max_cache'],
            Severity: Minor
            Found in bamnostic/bam.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)

            Unexpected spaces around keyword / parameter equals
            Open

                            super(BamWriter, self).__init__(filepath_or_object, mode=mode, compresslevel = compresslevel)
            Severity: Minor
            Found in bamnostic/bam.py by pep8

            Don't use spaces around the '=' sign in function arguments.

            Don't use spaces around the '=' sign when used to indicate a
            keyword argument or a default parameter value, except when
            using a type annotation.
            
            Okay: def complex(real, imag=0.0):
            Okay: return magic(r=real, i=imag)
            Okay: boolean(a == b)
            Okay: boolean(a != b)
            Okay: boolean(a <= b)
            Okay: boolean(a >= b)
            Okay: def foo(arg: int = 42):
            Okay: async def foo(arg: int = 42):
            
            E251: def complex(real, imag = 0.0):
            E251: return magic(r = real, i = imag)
            E252: def complex(real, image: float=0.0):

            Unexpected spaces around keyword / parameter equals
            Open

                            super(BamWriter, self).__init__(filepath_or_object, mode=mode, compresslevel = compresslevel)
            Severity: Minor
            Found in bamnostic/bam.py by pep8

            Don't use spaces around the '=' sign in function arguments.

            Don't use spaces around the '=' sign when used to indicate a
            keyword argument or a default parameter value, except when
            using a type annotation.
            
            Okay: def complex(real, imag=0.0):
            Okay: return magic(r=real, i=imag)
            Okay: boolean(a == b)
            Okay: boolean(a != b)
            Okay: boolean(a <= b)
            Okay: boolean(a >= b)
            Okay: def foo(arg: int = 42):
            Okay: async def foo(arg: int = 42):
            
            E251: def complex(real, imag = 0.0):
            E251: return magic(r = real, i = imag)
            E252: def complex(real, image: float=0.0):

            Missing whitespace around arithmetic operator
            Open

                                            thymine[index - start if index-start > 0 else 0] += 1
            Severity: Minor
            Found in bamnostic/bam.py by pep8

            Surround operators with a single space on either side.

            - Always surround these binary operators with a single space on
              either side: assignment (=), augmented assignment (+=, -= etc.),
              comparisons (==, <, >, !=, <=, >=, in, not in, is, is not),
              Booleans (and, or, not).
            
            - If operators with different priorities are used, consider adding
              whitespace around the operators with the lowest priorities.
            
            Okay: i = i + 1
            Okay: submitted += 1
            Okay: x = x * 2 - 1
            Okay: hypot2 = x * x + y * y
            Okay: c = (a + b) * (a - b)
            Okay: foo(bar, key='word', *args, **kwargs)
            Okay: alpha[:-i]
            
            E225: i=i+1
            E225: submitted +=1
            E225: x = x /2 - 1
            E225: z = x **y
            E225: z = 1and 1
            E226: c = (a+b) * (a-b)
            E226: hypot2 = x*x + y*y
            E227: c = a|b
            E228: msg = fmt%(errno, errmsg)

            Unexpected spaces around keyword / parameter equals
            Open

                def __init__(self, filepath_or_object, mode = 'xb', compresslevel = 6, ignore_overwrite = False,
            Severity: Minor
            Found in bamnostic/bam.py by pep8

            Don't use spaces around the '=' sign in function arguments.

            Don't use spaces around the '=' sign when used to indicate a
            keyword argument or a default parameter value, except when
            using a type annotation.
            
            Okay: def complex(real, imag=0.0):
            Okay: return magic(r=real, i=imag)
            Okay: boolean(a == b)
            Okay: boolean(a != b)
            Okay: boolean(a <= b)
            Okay: boolean(a >= b)
            Okay: def foo(arg: int = 42):
            Okay: async def foo(arg: int = 42):
            
            E251: def complex(real, imag = 0.0):
            E251: return magic(r = real, i = imag)
            E252: def complex(real, image: float=0.0):

            Unexpected spaces around keyword / parameter equals
            Open

                            copy_header = None, header = b'', reference_names = None, reference_lengths = None):
            Severity: Minor
            Found in bamnostic/bam.py by pep8

            Don't use spaces around the '=' sign in function arguments.

            Don't use spaces around the '=' sign when used to indicate a
            keyword argument or a default parameter value, except when
            using a type annotation.
            
            Okay: def complex(real, imag=0.0):
            Okay: return magic(r=real, i=imag)
            Okay: boolean(a == b)
            Okay: boolean(a != b)
            Okay: boolean(a <= b)
            Okay: boolean(a >= b)
            Okay: def foo(arg: int = 42):
            Okay: async def foo(arg: int = 42):
            
            E251: def complex(real, imag = 0.0):
            E251: return magic(r = real, i = imag)
            E252: def complex(real, image: float=0.0):

            Trailing whitespace
            Open

                        As of right now, it is tuned for working within a pipeline where reads 
            Severity: Minor
            Found in bamnostic/bam.py by pep8

            Trailing whitespace is superfluous.

            The warning returned varies on whether the line itself is blank,
            for easier filtering for those who want to indent their blank lines.
            
            Okay: spam(1)\n#
            W291: spam(1) \n#
            W293: class Foo(object):\n    \n    bang = 12

            Unexpected spaces around keyword / parameter equals
            Open

                            super(BamWriter, self).__init__(filepath_or_object, mode=mode, compresslevel = compresslevel)
            Severity: Minor
            Found in bamnostic/bam.py by pep8

            Don't use spaces around the '=' sign in function arguments.

            Don't use spaces around the '=' sign when used to indicate a
            keyword argument or a default parameter value, except when
            using a type annotation.
            
            Okay: def complex(real, imag=0.0):
            Okay: return magic(r=real, i=imag)
            Okay: boolean(a == b)
            Okay: boolean(a != b)
            Okay: boolean(a <= b)
            Okay: boolean(a >= b)
            Okay: def foo(arg: int = 42):
            Okay: async def foo(arg: int = 42):
            
            E251: def complex(real, imag = 0.0):
            E251: return magic(r = real, i = imag)
            E252: def complex(real, image: float=0.0):

            Unexpected spaces around keyword / parameter equals
            Open

                                    reference_names = reference_names, 
            Severity: Minor
            Found in bamnostic/bam.py by pep8

            Don't use spaces around the '=' sign in function arguments.

            Don't use spaces around the '=' sign when used to indicate a
            keyword argument or a default parameter value, except when
            using a type annotation.
            
            Okay: def complex(real, imag=0.0):
            Okay: return magic(r=real, i=imag)
            Okay: boolean(a == b)
            Okay: boolean(a != b)
            Okay: boolean(a <= b)
            Okay: boolean(a >= b)
            Okay: def foo(arg: int = 42):
            Okay: async def foo(arg: int = 42):
            
            E251: def complex(real, imag = 0.0):
            E251: return magic(r = real, i = imag)
            E252: def complex(real, image: float=0.0):

            Missing whitespace around arithmetic operator
            Open

                                            adenine[index - start if index-start > 0 else 0] += 1
            Severity: Minor
            Found in bamnostic/bam.py by pep8

            Surround operators with a single space on either side.

            - Always surround these binary operators with a single space on
              either side: assignment (=), augmented assignment (+=, -= etc.),
              comparisons (==, <, >, !=, <=, >=, in, not in, is, is not),
              Booleans (and, or, not).
            
            - If operators with different priorities are used, consider adding
              whitespace around the operators with the lowest priorities.
            
            Okay: i = i + 1
            Okay: submitted += 1
            Okay: x = x * 2 - 1
            Okay: hypot2 = x * x + y * y
            Okay: c = (a + b) * (a - b)
            Okay: foo(bar, key='word', *args, **kwargs)
            Okay: alpha[:-i]
            
            E225: i=i+1
            E225: submitted +=1
            E225: x = x /2 - 1
            E225: z = x **y
            E225: z = 1and 1
            E226: c = (a+b) * (a-b)
            E226: hypot2 = x*x + y*y
            E227: c = a|b
            E228: msg = fmt%(errno, errmsg)

            Unexpected spaces around keyword / parameter equals
            Open

                            super(BamWriter, self).__init__(filepath_or_object, mode=mode, compresslevel = compresslevel)
            Severity: Minor
            Found in bamnostic/bam.py by pep8

            Don't use spaces around the '=' sign in function arguments.

            Don't use spaces around the '=' sign when used to indicate a
            keyword argument or a default parameter value, except when
            using a type annotation.
            
            Okay: def complex(real, imag=0.0):
            Okay: return magic(r=real, i=imag)
            Okay: boolean(a == b)
            Okay: boolean(a != b)
            Okay: boolean(a <= b)
            Okay: boolean(a >= b)
            Okay: def foo(arg: int = 42):
            Okay: async def foo(arg: int = 42):
            
            E251: def complex(real, imag = 0.0):
            E251: return magic(r = real, i = imag)
            E252: def complex(real, image: float=0.0):

            Unexpected spaces around keyword / parameter equals
            Open

                def write_header(self, copy_header = None, header = b'', reference_names = None, reference_lengths = None):
            Severity: Minor
            Found in bamnostic/bam.py by pep8

            Don't use spaces around the '=' sign in function arguments.

            Don't use spaces around the '=' sign when used to indicate a
            keyword argument or a default parameter value, except when
            using a type annotation.
            
            Okay: def complex(real, imag=0.0):
            Okay: return magic(r=real, i=imag)
            Okay: boolean(a == b)
            Okay: boolean(a != b)
            Okay: boolean(a <= b)
            Okay: boolean(a >= b)
            Okay: def foo(arg: int = 42):
            Okay: async def foo(arg: int = 42):
            
            E251: def complex(real, imag = 0.0):
            E251: return magic(r = real, i = imag)
            E252: def complex(real, image: float=0.0):

            Trailing whitespace
            Open

                    super_args = {'filepath_or_object': locals()['filepath_or_object'], 
            Severity: Minor
            Found in bamnostic/bam.py by pep8

            Trailing whitespace is superfluous.

            The warning returned varies on whether the line itself is blank,
            for easier filtering for those who want to indent their blank lines.
            
            Okay: spam(1)\n#
            W291: spam(1) \n#
            W293: class Foo(object):\n    \n    bang = 12

            Unexpected spaces around keyword / parameter equals
            Open

                def __init__(self, filepath_or_object, mode = 'xb', compresslevel = 6, ignore_overwrite = False,
            Severity: Minor
            Found in bamnostic/bam.py by pep8

            Don't use spaces around the '=' sign in function arguments.

            Don't use spaces around the '=' sign when used to indicate a
            keyword argument or a default parameter value, except when
            using a type annotation.
            
            Okay: def complex(real, imag=0.0):
            Okay: return magic(r=real, i=imag)
            Okay: boolean(a == b)
            Okay: boolean(a != b)
            Okay: boolean(a <= b)
            Okay: boolean(a >= b)
            Okay: def foo(arg: int = 42):
            Okay: async def foo(arg: int = 42):
            
            E251: def complex(real, imag = 0.0):
            E251: return magic(r = real, i = imag)
            E252: def complex(real, image: float=0.0):

            Continuation line under-indented for visual indent
            Open

                                    reference_lengths = reference_lengths)
            Severity: Minor
            Found in bamnostic/bam.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)

            Unexpected spaces around keyword / parameter equals
            Open

                    self.write_header(copy_header = copy_header, header = header, 
            Severity: Minor
            Found in bamnostic/bam.py by pep8

            Don't use spaces around the '=' sign in function arguments.

            Don't use spaces around the '=' sign when used to indicate a
            keyword argument or a default parameter value, except when
            using a type annotation.
            
            Okay: def complex(real, imag=0.0):
            Okay: return magic(r=real, i=imag)
            Okay: boolean(a == b)
            Okay: boolean(a != b)
            Okay: boolean(a <= b)
            Okay: boolean(a >= b)
            Okay: def foo(arg: int = 42):
            Okay: async def foo(arg: int = 42):
            
            E251: def complex(real, imag = 0.0):
            E251: return magic(r = real, i = imag)
            E252: def complex(real, image: float=0.0):

            Unexpected spaces around keyword / parameter equals
            Open

                    self.write_header(copy_header = copy_header, header = header, 
            Severity: Minor
            Found in bamnostic/bam.py by pep8

            Don't use spaces around the '=' sign in function arguments.

            Don't use spaces around the '=' sign when used to indicate a
            keyword argument or a default parameter value, except when
            using a type annotation.
            
            Okay: def complex(real, imag=0.0):
            Okay: return magic(r=real, i=imag)
            Okay: boolean(a == b)
            Okay: boolean(a != b)
            Okay: boolean(a <= b)
            Okay: boolean(a >= b)
            Okay: def foo(arg: int = 42):
            Okay: async def foo(arg: int = 42):
            
            E251: def complex(real, imag = 0.0):
            E251: return magic(r = real, i = imag)
            E252: def complex(real, image: float=0.0):

            Blank line contains whitespace
            Open

                            
            Severity: Minor
            Found in bamnostic/bam.py by pep8

            Trailing whitespace is superfluous.

            The warning returned varies on whether the line itself is blank,
            for easier filtering for those who want to indent their blank lines.
            
            Okay: spam(1)\n#
            W291: spam(1) \n#
            W293: class Foo(object):\n    \n    bang = 12

            Trailing whitespace
            Open

                        else: 
            Severity: Minor
            Found in bamnostic/bam.py by pep8

            Trailing whitespace is superfluous.

            The warning returned varies on whether the line itself is blank,
            for easier filtering for those who want to indent their blank lines.
            
            Okay: spam(1)\n#
            W291: spam(1) \n#
            W293: class Foo(object):\n    \n    bang = 12

            Unexpected spaces around keyword / parameter equals
            Open

            def _cross_check_header_refs(reads, header="", referencenames = None, referencelengths = None):
            Severity: Minor
            Found in bamnostic/bam.py by pep8

            Don't use spaces around the '=' sign in function arguments.

            Don't use spaces around the '=' sign when used to indicate a
            keyword argument or a default parameter value, except when
            using a type annotation.
            
            Okay: def complex(real, imag=0.0):
            Okay: return magic(r=real, i=imag)
            Okay: boolean(a == b)
            Okay: boolean(a != b)
            Okay: boolean(a <= b)
            Okay: boolean(a >= b)
            Okay: def foo(arg: int = 42):
            Okay: async def foo(arg: int = 42):
            
            E251: def complex(real, imag = 0.0):
            E251: return magic(r = real, i = imag)
            E252: def complex(real, image: float=0.0):

            Unexpected spaces around keyword / parameter equals
            Open

                            super(BamWriter, self).__init__(filepath_or_object, mode=mode, compresslevel = compresslevel)
            Severity: Minor
            Found in bamnostic/bam.py by pep8

            Don't use spaces around the '=' sign in function arguments.

            Don't use spaces around the '=' sign when used to indicate a
            keyword argument or a default parameter value, except when
            using a type annotation.
            
            Okay: def complex(real, imag=0.0):
            Okay: return magic(r=real, i=imag)
            Okay: boolean(a == b)
            Okay: boolean(a != b)
            Okay: boolean(a <= b)
            Okay: boolean(a >= b)
            Okay: def foo(arg: int = 42):
            Okay: async def foo(arg: int = 42):
            
            E251: def complex(real, imag = 0.0):
            E251: return magic(r = real, i = imag)
            E252: def complex(real, image: float=0.0):

            Unexpected spaces around keyword / parameter equals
            Open

                            super(BamWriter, self).__init__(filepath_or_object, mode=mode, compresslevel = compresslevel)
            Severity: Minor
            Found in bamnostic/bam.py by pep8

            Don't use spaces around the '=' sign in function arguments.

            Don't use spaces around the '=' sign when used to indicate a
            keyword argument or a default parameter value, except when
            using a type annotation.
            
            Okay: def complex(real, imag=0.0):
            Okay: return magic(r=real, i=imag)
            Okay: boolean(a == b)
            Okay: boolean(a != b)
            Okay: boolean(a <= b)
            Okay: boolean(a >= b)
            Okay: def foo(arg: int = 42):
            Okay: async def foo(arg: int = 42):
            
            E251: def complex(real, imag = 0.0):
            E251: return magic(r = real, i = imag)
            E252: def complex(real, image: float=0.0):

            Trailing whitespace
            Open

             module. BioPython BGZF is now under a 3-clause BSD license. The same license 
            Severity: Minor
            Found in bamnostic/bam.py by pep8

            Trailing whitespace is superfluous.

            The warning returned varies on whether the line itself is blank,
            for easier filtering for those who want to indent their blank lines.
            
            Okay: spam(1)\n#
            W291: spam(1) \n#
            W293: class Foo(object):\n    \n    bang = 12

            Blank line contains whitespace
            Open

                    
            Severity: Minor
            Found in bamnostic/bam.py by pep8

            Trailing whitespace is superfluous.

            The warning returned varies on whether the line itself is blank,
            for easier filtering for those who want to indent their blank lines.
            
            Okay: spam(1)\n#
            W291: spam(1) \n#
            W293: class Foo(object):\n    \n    bang = 12

            Missing whitespace around arithmetic operator
            Open

                                            guanine[index - start if index-start > 0 else 0] += 1
            Severity: Minor
            Found in bamnostic/bam.py by pep8

            Surround operators with a single space on either side.

            - Always surround these binary operators with a single space on
              either side: assignment (=), augmented assignment (+=, -= etc.),
              comparisons (==, <, >, !=, <=, >=, in, not in, is, is not),
              Booleans (and, or, not).
            
            - If operators with different priorities are used, consider adding
              whitespace around the operators with the lowest priorities.
            
            Okay: i = i + 1
            Okay: submitted += 1
            Okay: x = x * 2 - 1
            Okay: hypot2 = x * x + y * y
            Okay: c = (a + b) * (a - b)
            Okay: foo(bar, key='word', *args, **kwargs)
            Okay: alpha[:-i]
            
            E225: i=i+1
            E225: submitted +=1
            E225: x = x /2 - 1
            E225: z = x **y
            E225: z = 1and 1
            E226: c = (a+b) * (a-b)
            E226: hypot2 = x*x + y*y
            E227: c = a|b
            E228: msg = fmt%(errno, errmsg)

            Blank line contains whitespace
            Open

                    
            Severity: Minor
            Found in bamnostic/bam.py by pep8

            Trailing whitespace is superfluous.

            The warning returned varies on whether the line itself is blank,
            for easier filtering for those who want to indent their blank lines.
            
            Okay: spam(1)\n#
            W291: spam(1) \n#
            W293: class Foo(object):\n    \n    bang = 12

            Trailing whitespace
            Open

                    self.write_header(copy_header = copy_header, header = header, 
            Severity: Minor
            Found in bamnostic/bam.py by pep8

            Trailing whitespace is superfluous.

            The warning returned varies on whether the line itself is blank,
            for easier filtering for those who want to indent their blank lines.
            
            Okay: spam(1)\n#
            W291: spam(1) \n#
            W293: class Foo(object):\n    \n    bang = 12

            Unexpected spaces around keyword / parameter equals
            Open

                                    reference_lengths = reference_lengths)
            Severity: Minor
            Found in bamnostic/bam.py by pep8

            Don't use spaces around the '=' sign in function arguments.

            Don't use spaces around the '=' sign when used to indicate a
            keyword argument or a default parameter value, except when
            using a type annotation.
            
            Okay: def complex(real, imag=0.0):
            Okay: return magic(r=real, i=imag)
            Okay: boolean(a == b)
            Okay: boolean(a != b)
            Okay: boolean(a <= b)
            Okay: boolean(a >= b)
            Okay: def foo(arg: int = 42):
            Okay: async def foo(arg: int = 42):
            
            E251: def complex(real, imag = 0.0):
            E251: return magic(r = real, i = imag)
            E252: def complex(real, image: float=0.0):

            Unexpected spaces around keyword / parameter equals
            Open

                def write_header(self, copy_header = None, header = b'', reference_names = None, reference_lengths = None):
            Severity: Minor
            Found in bamnostic/bam.py by pep8

            Don't use spaces around the '=' sign in function arguments.

            Don't use spaces around the '=' sign when used to indicate a
            keyword argument or a default parameter value, except when
            using a type annotation.
            
            Okay: def complex(real, imag=0.0):
            Okay: return magic(r=real, i=imag)
            Okay: boolean(a == b)
            Okay: boolean(a != b)
            Okay: boolean(a <= b)
            Okay: boolean(a >= b)
            Okay: def foo(arg: int = 42):
            Okay: async def foo(arg: int = 42):
            
            E251: def complex(real, imag = 0.0):
            E251: return magic(r = real, i = imag)
            E252: def complex(real, image: float=0.0):

            Continuation line under-indented for visual indent
            Open

                                                                    header,
            Severity: Minor
            Found in bamnostic/bam.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)

            Ambiguous variable name 'l'
            Open

                        l = None
            Severity: Minor
            Found in bamnostic/bam.py by pep8

            Never use the characters 'l', 'O', or 'I' as variable names.

            In some fonts, these characters are indistinguishable from the
            numerals one and zero. When tempted to use 'l', use 'L' instead.
            
            Okay: L = 0
            Okay: o = 123
            Okay: i = 42
            E741: l = 0
            E741: O = 123
            E741: I = 42
            
            Variables can be bound in several other contexts, including class
            and function definitions, 'global' and 'nonlocal' statements,
            exception handlers, and 'with' and 'for' statements.
            In addition, we have a special handling for function parameters.
            
            Okay: except AttributeError as o:
            Okay: with lock as L:
            Okay: foo(l=12)
            Okay: for a in foo(l=12):
            E741: except AttributeError as O:
            E741: with lock as l:
            E741: global I
            E741: nonlocal l
            E741: def foo(l):
            E741: def foo(l=12):
            E741: l = foo(l=12)
            E741: for l in range(10):
            E742: class I(object):
            E743: def l(x):

            Unexpected spaces around keyword / parameter equals
            Open

                                super(BamWriter, self).__init__(filepath_or_object, mode=mode, compresslevel = compresslevel)
            Severity: Minor
            Found in bamnostic/bam.py by pep8

            Don't use spaces around the '=' sign in function arguments.

            Don't use spaces around the '=' sign when used to indicate a
            keyword argument or a default parameter value, except when
            using a type annotation.
            
            Okay: def complex(real, imag=0.0):
            Okay: return magic(r=real, i=imag)
            Okay: boolean(a == b)
            Okay: boolean(a != b)
            Okay: boolean(a <= b)
            Okay: boolean(a >= b)
            Okay: def foo(arg: int = 42):
            Okay: async def foo(arg: int = 42):
            
            E251: def complex(real, imag = 0.0):
            E251: return magic(r = real, i = imag)
            E252: def complex(real, image: float=0.0):

            Trailing whitespace
            Open

                                    reference_names = reference_names, 
            Severity: Minor
            Found in bamnostic/bam.py by pep8

            Trailing whitespace is superfluous.

            The warning returned varies on whether the line itself is blank,
            for easier filtering for those who want to indent their blank lines.
            
            Okay: spam(1)\n#
            W291: spam(1) \n#
            W293: class Foo(object):\n    \n    bang = 12

            Unexpected spaces around keyword / parameter equals
            Open

                    self.write_header(copy_header = copy_header, header = header, 
            Severity: Minor
            Found in bamnostic/bam.py by pep8

            Don't use spaces around the '=' sign in function arguments.

            Don't use spaces around the '=' sign when used to indicate a
            keyword argument or a default parameter value, except when
            using a type annotation.
            
            Okay: def complex(real, imag=0.0):
            Okay: return magic(r=real, i=imag)
            Okay: boolean(a == b)
            Okay: boolean(a != b)
            Okay: boolean(a <= b)
            Okay: boolean(a >= b)
            Okay: def foo(arg: int = 42):
            Okay: async def foo(arg: int = 42):
            
            E251: def complex(real, imag = 0.0):
            E251: return magic(r = real, i = imag)
            E252: def complex(real, image: float=0.0):

            Unexpected spaces around keyword / parameter equals
            Open

                def write_header(self, copy_header = None, header = b'', reference_names = None, reference_lengths = None):
            Severity: Minor
            Found in bamnostic/bam.py by pep8

            Don't use spaces around the '=' sign in function arguments.

            Don't use spaces around the '=' sign when used to indicate a
            keyword argument or a default parameter value, except when
            using a type annotation.
            
            Okay: def complex(real, imag=0.0):
            Okay: return magic(r=real, i=imag)
            Okay: boolean(a == b)
            Okay: boolean(a != b)
            Okay: boolean(a <= b)
            Okay: boolean(a >= b)
            Okay: def foo(arg: int = 42):
            Okay: async def foo(arg: int = 42):
            
            E251: def complex(real, imag = 0.0):
            E251: return magic(r = real, i = imag)
            E252: def complex(real, image: float=0.0):

            Unexpected spaces around keyword / parameter equals
            Open

                def write_header(self, copy_header = None, header = b'', reference_names = None, reference_lengths = None):
            Severity: Minor
            Found in bamnostic/bam.py by pep8

            Don't use spaces around the '=' sign in function arguments.

            Don't use spaces around the '=' sign when used to indicate a
            keyword argument or a default parameter value, except when
            using a type annotation.
            
            Okay: def complex(real, imag=0.0):
            Okay: return magic(r=real, i=imag)
            Okay: boolean(a == b)
            Okay: boolean(a != b)
            Okay: boolean(a <= b)
            Okay: boolean(a >= b)
            Okay: def foo(arg: int = 42):
            Okay: async def foo(arg: int = 42):
            
            E251: def complex(real, imag = 0.0):
            E251: return magic(r = real, i = imag)
            E252: def complex(real, image: float=0.0):

            Blank line contains whitespace
            Open

                        
            Severity: Minor
            Found in bamnostic/bam.py by pep8

            Trailing whitespace is superfluous.

            The warning returned varies on whether the line itself is blank,
            for easier filtering for those who want to indent their blank lines.
            
            Okay: spam(1)\n#
            W291: spam(1) \n#
            W293: class Foo(object):\n    \n    bang = 12

            Missing whitespace around arithmetic operator
            Open

                                            cytosine[index - start if index-start > 0 else 0] += 1
            Severity: Minor
            Found in bamnostic/bam.py by pep8

            Surround operators with a single space on either side.

            - Always surround these binary operators with a single space on
              either side: assignment (=), augmented assignment (+=, -= etc.),
              comparisons (==, <, >, !=, <=, >=, in, not in, is, is not),
              Booleans (and, or, not).
            
            - If operators with different priorities are used, consider adding
              whitespace around the operators with the lowest priorities.
            
            Okay: i = i + 1
            Okay: submitted += 1
            Okay: x = x * 2 - 1
            Okay: hypot2 = x * x + y * y
            Okay: c = (a + b) * (a - b)
            Okay: foo(bar, key='word', *args, **kwargs)
            Okay: alpha[:-i]
            
            E225: i=i+1
            E225: submitted +=1
            E225: x = x /2 - 1
            E225: z = x **y
            E225: z = 1and 1
            E226: c = (a+b) * (a-b)
            E226: hypot2 = x*x + y*y
            E227: c = a|b
            E228: msg = fmt%(errno, errmsg)

            Unexpected spaces around keyword / parameter equals
            Open

                def __init__(self, filepath_or_object, mode = 'xb', compresslevel = 6, ignore_overwrite = False,
            Severity: Minor
            Found in bamnostic/bam.py by pep8

            Don't use spaces around the '=' sign in function arguments.

            Don't use spaces around the '=' sign when used to indicate a
            keyword argument or a default parameter value, except when
            using a type annotation.
            
            Okay: def complex(real, imag=0.0):
            Okay: return magic(r=real, i=imag)
            Okay: boolean(a == b)
            Okay: boolean(a != b)
            Okay: boolean(a <= b)
            Okay: boolean(a >= b)
            Okay: def foo(arg: int = 42):
            Okay: async def foo(arg: int = 42):
            
            E251: def complex(real, imag = 0.0):
            E251: return magic(r = real, i = imag)
            E252: def complex(real, image: float=0.0):

            Unexpected spaces around keyword / parameter equals
            Open

                            copy_header = None, header = b'', reference_names = None, reference_lengths = None):
            Severity: Minor
            Found in bamnostic/bam.py by pep8

            Don't use spaces around the '=' sign in function arguments.

            Don't use spaces around the '=' sign when used to indicate a
            keyword argument or a default parameter value, except when
            using a type annotation.
            
            Okay: def complex(real, imag=0.0):
            Okay: return magic(r=real, i=imag)
            Okay: boolean(a == b)
            Okay: boolean(a != b)
            Okay: boolean(a <= b)
            Okay: boolean(a >= b)
            Okay: def foo(arg: int = 42):
            Okay: async def foo(arg: int = 42):
            
            E251: def complex(real, imag = 0.0):
            E251: return magic(r = real, i = imag)
            E252: def complex(real, image: float=0.0):

            Trailing whitespace
            Open

                    """Useful class for writing BAM files. 
            Severity: Minor
            Found in bamnostic/bam.py by pep8

            Trailing whitespace is superfluous.

            The warning returned varies on whether the line itself is blank,
            for easier filtering for those who want to indent their blank lines.
            
            Okay: spam(1)\n#
            W291: spam(1) \n#
            W293: class Foo(object):\n    \n    bang = 12

            Unexpected spaces around keyword / parameter equals
            Open

                                super(BamWriter, self).__init__(filepath_or_object, mode=mode, compresslevel = compresslevel)
            Severity: Minor
            Found in bamnostic/bam.py by pep8

            Don't use spaces around the '=' sign in function arguments.

            Don't use spaces around the '=' sign when used to indicate a
            keyword argument or a default parameter value, except when
            using a type annotation.
            
            Okay: def complex(real, imag=0.0):
            Okay: return magic(r=real, i=imag)
            Okay: boolean(a == b)
            Okay: boolean(a != b)
            Okay: boolean(a <= b)
            Okay: boolean(a >= b)
            Okay: def foo(arg: int = 42):
            Okay: async def foo(arg: int = 42):
            
            E251: def complex(real, imag = 0.0):
            E251: return magic(r = real, i = imag)
            E252: def complex(real, image: float=0.0):

            Unexpected spaces around keyword / parameter equals
            Open

                            super(BamWriter, self).__init__(filepath_or_object, mode=mode, compresslevel = compresslevel)
            Severity: Minor
            Found in bamnostic/bam.py by pep8

            Don't use spaces around the '=' sign in function arguments.

            Don't use spaces around the '=' sign when used to indicate a
            keyword argument or a default parameter value, except when
            using a type annotation.
            
            Okay: def complex(real, imag=0.0):
            Okay: return magic(r=real, i=imag)
            Okay: boolean(a == b)
            Okay: boolean(a != b)
            Okay: boolean(a <= b)
            Okay: boolean(a >= b)
            Okay: def foo(arg: int = 42):
            Okay: async def foo(arg: int = 42):
            
            E251: def complex(real, imag = 0.0):
            E251: return magic(r = real, i = imag)
            E252: def complex(real, image: float=0.0):

            Unexpected spaces around keyword / parameter equals
            Open

                def write_header(self, copy_header = None, header = b'', reference_names = None, reference_lengths = None):
            Severity: Minor
            Found in bamnostic/bam.py by pep8

            Don't use spaces around the '=' sign in function arguments.

            Don't use spaces around the '=' sign when used to indicate a
            keyword argument or a default parameter value, except when
            using a type annotation.
            
            Okay: def complex(real, imag=0.0):
            Okay: return magic(r=real, i=imag)
            Okay: boolean(a == b)
            Okay: boolean(a != b)
            Okay: boolean(a <= b)
            Okay: boolean(a >= b)
            Okay: def foo(arg: int = 42):
            Okay: async def foo(arg: int = 42):
            
            E251: def complex(real, imag = 0.0):
            E251: return magic(r = real, i = imag)
            E252: def complex(real, image: float=0.0):

            Trailing whitespace
            Open

                                'filename': locals()['filename'], 'ignore_truncation': locals()['ignore_truncation'], 
            Severity: Minor
            Found in bamnostic/bam.py by pep8

            Trailing whitespace is superfluous.

            The warning returned varies on whether the line itself is blank,
            for easier filtering for those who want to indent their blank lines.
            
            Okay: spam(1)\n#
            W291: spam(1) \n#
            W293: class Foo(object):\n    \n    bang = 12

            Unexpected spaces around keyword / parameter equals
            Open

                            copy_header = None, header = b'', reference_names = None, reference_lengths = None):
            Severity: Minor
            Found in bamnostic/bam.py by pep8

            Don't use spaces around the '=' sign in function arguments.

            Don't use spaces around the '=' sign when used to indicate a
            keyword argument or a default parameter value, except when
            using a type annotation.
            
            Okay: def complex(real, imag=0.0):
            Okay: return magic(r=real, i=imag)
            Okay: boolean(a == b)
            Okay: boolean(a != b)
            Okay: boolean(a <= b)
            Okay: boolean(a >= b)
            Okay: def foo(arg: int = 42):
            Okay: async def foo(arg: int = 42):
            
            E251: def complex(real, imag = 0.0):
            E251: return magic(r = real, i = imag)
            E252: def complex(real, image: float=0.0):

            Test for membership should be 'not in'
            Open

                    if 'r' in mode and not '+' in mode:
            Severity: Minor
            Found in bamnostic/bam.py by pep8

            Negative comparison should be done using "not in" and "is not".

            Okay: if x not in y:\n    pass
            Okay: assert (X in Y or X is Z)
            Okay: if not (X in Y):\n    pass
            Okay: zz = x is not y
            E713: Z = not X in Y
            E713: if not X.B in Y:\n    pass
            E714: if not X is Y:\n    pass
            E714: Z = not X.B is Y

            Unexpected spaces around keyword / parameter equals
            Open

                            super(BamWriter, self).__init__(filepath_or_object, mode=mode, compresslevel = compresslevel)
            Severity: Minor
            Found in bamnostic/bam.py by pep8

            Don't use spaces around the '=' sign in function arguments.

            Don't use spaces around the '=' sign when used to indicate a
            keyword argument or a default parameter value, except when
            using a type annotation.
            
            Okay: def complex(real, imag=0.0):
            Okay: return magic(r=real, i=imag)
            Okay: boolean(a == b)
            Okay: boolean(a != b)
            Okay: boolean(a <= b)
            Okay: boolean(a >= b)
            Okay: def foo(arg: int = 42):
            Okay: async def foo(arg: int = 42):
            
            E251: def complex(real, imag = 0.0):
            E251: return magic(r = real, i = imag)
            E252: def complex(real, image: float=0.0):

            Unexpected spaces around keyword / parameter equals
            Open

                def write_header(self, copy_header = None, header = b'', reference_names = None, reference_lengths = None):
            Severity: Minor
            Found in bamnostic/bam.py by pep8

            Don't use spaces around the '=' sign in function arguments.

            Don't use spaces around the '=' sign when used to indicate a
            keyword argument or a default parameter value, except when
            using a type annotation.
            
            Okay: def complex(real, imag=0.0):
            Okay: return magic(r=real, i=imag)
            Okay: boolean(a == b)
            Okay: boolean(a != b)
            Okay: boolean(a <= b)
            Okay: boolean(a >= b)
            Okay: def foo(arg: int = 42):
            Okay: async def foo(arg: int = 42):
            
            E251: def complex(real, imag = 0.0):
            E251: return magic(r = real, i = imag)
            E252: def complex(real, image: float=0.0):

            Continuation line under-indented for visual indent
            Open

                                                                    reference_lengths)
            Severity: Minor
            Found in bamnostic/bam.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 under-indented for visual indent
            Open

                                'filename': locals()['filename'], 'ignore_truncation': locals()['ignore_truncation'], 
            Severity: Minor
            Found in bamnostic/bam.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)

            Trailing whitespace
            Open

                            if next_read.reference_name != query.contig: 
            Severity: Minor
            Found in bamnostic/bam.py by pep8

            Trailing whitespace is superfluous.

            The warning returned varies on whether the line itself is blank,
            for easier filtering for those who want to indent their blank lines.
            
            Okay: spam(1)\n#
            W291: spam(1) \n#
            W293: class Foo(object):\n    \n    bang = 12

            Continuation line under-indented for visual indent
            Open

                            copy_header = None, header = b'', reference_names = None, reference_lengths = None):
            Severity: Minor
            Found in bamnostic/bam.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)

            Unexpected spaces around keyword / parameter equals
            Open

                            copy_header = None, header = b'', reference_names = None, reference_lengths = None):
            Severity: Minor
            Found in bamnostic/bam.py by pep8

            Don't use spaces around the '=' sign in function arguments.

            Don't use spaces around the '=' sign when used to indicate a
            keyword argument or a default parameter value, except when
            using a type annotation.
            
            Okay: def complex(real, imag=0.0):
            Okay: return magic(r=real, i=imag)
            Okay: boolean(a == b)
            Okay: boolean(a != b)
            Okay: boolean(a <= b)
            Okay: boolean(a >= b)
            Okay: def foo(arg: int = 42):
            Okay: async def foo(arg: int = 42):
            
            E251: def complex(real, imag = 0.0):
            E251: return magic(r = real, i = imag)
            E252: def complex(real, image: float=0.0):

            Continuation line under-indented for visual indent
            Open

                                    reference_names = reference_names, 
            Severity: Minor
            Found in bamnostic/bam.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)

            Unexpected spaces around keyword / parameter equals
            Open

                    self.write_header(copy_header = copy_header, header = header, 
            Severity: Minor
            Found in bamnostic/bam.py by pep8

            Don't use spaces around the '=' sign in function arguments.

            Don't use spaces around the '=' sign when used to indicate a
            keyword argument or a default parameter value, except when
            using a type annotation.
            
            Okay: def complex(real, imag=0.0):
            Okay: return magic(r=real, i=imag)
            Okay: boolean(a == b)
            Okay: boolean(a != b)
            Okay: boolean(a <= b)
            Okay: boolean(a >= b)
            Okay: def foo(arg: int = 42):
            Okay: async def foo(arg: int = 42):
            
            E251: def complex(real, imag = 0.0):
            E251: return magic(r = real, i = imag)
            E252: def complex(real, image: float=0.0):

            Unexpected spaces around keyword / parameter equals
            Open

                                    reference_lengths = reference_lengths)
            Severity: Minor
            Found in bamnostic/bam.py by pep8

            Don't use spaces around the '=' sign in function arguments.

            Don't use spaces around the '=' sign when used to indicate a
            keyword argument or a default parameter value, except when
            using a type annotation.
            
            Okay: def complex(real, imag=0.0):
            Okay: return magic(r=real, i=imag)
            Okay: boolean(a == b)
            Okay: boolean(a != b)
            Okay: boolean(a <= b)
            Okay: boolean(a >= b)
            Okay: def foo(arg: int = 42):
            Okay: async def foo(arg: int = 42):
            
            E251: def complex(real, imag = 0.0):
            E251: return magic(r = real, i = imag)
            E252: def complex(real, image: float=0.0):

            Unexpected spaces around keyword / parameter equals
            Open

                def write_header(self, copy_header = None, header = b'', reference_names = None, reference_lengths = None):
            Severity: Minor
            Found in bamnostic/bam.py by pep8

            Don't use spaces around the '=' sign in function arguments.

            Don't use spaces around the '=' sign when used to indicate a
            keyword argument or a default parameter value, except when
            using a type annotation.
            
            Okay: def complex(real, imag=0.0):
            Okay: return magic(r=real, i=imag)
            Okay: boolean(a == b)
            Okay: boolean(a != b)
            Okay: boolean(a <= b)
            Okay: boolean(a >= b)
            Okay: def foo(arg: int = 42):
            Okay: async def foo(arg: int = 42):
            
            E251: def complex(real, imag = 0.0):
            E251: return magic(r = real, i = imag)
            E252: def complex(real, image: float=0.0):

            Unexpected spaces around keyword / parameter equals
            Open

                def write_header(self, copy_header = None, header = b'', reference_names = None, reference_lengths = None):
            Severity: Minor
            Found in bamnostic/bam.py by pep8

            Don't use spaces around the '=' sign in function arguments.

            Don't use spaces around the '=' sign when used to indicate a
            keyword argument or a default parameter value, except when
            using a type annotation.
            
            Okay: def complex(real, imag=0.0):
            Okay: return magic(r=real, i=imag)
            Okay: boolean(a == b)
            Okay: boolean(a != b)
            Okay: boolean(a <= b)
            Okay: boolean(a >= b)
            Okay: def foo(arg: int = 42):
            Okay: async def foo(arg: int = 42):
            
            E251: def complex(real, imag = 0.0):
            E251: return magic(r = real, i = imag)
            E252: def complex(real, image: float=0.0):

            Unexpected spaces around keyword / parameter equals
            Open

            def _cross_check_header_refs(reads, header="", referencenames = None, referencelengths = None):
            Severity: Minor
            Found in bamnostic/bam.py by pep8

            Don't use spaces around the '=' sign in function arguments.

            Don't use spaces around the '=' sign when used to indicate a
            keyword argument or a default parameter value, except when
            using a type annotation.
            
            Okay: def complex(real, imag=0.0):
            Okay: return magic(r=real, i=imag)
            Okay: boolean(a == b)
            Okay: boolean(a != b)
            Okay: boolean(a <= b)
            Okay: boolean(a >= b)
            Okay: def foo(arg: int = 42):
            Okay: async def foo(arg: int = 42):
            
            E251: def complex(real, imag = 0.0):
            E251: return magic(r = real, i = imag)
            E252: def complex(real, image: float=0.0):

            Do not use bare 'except'
            Open

                            except:
            Severity: Minor
            Found in bamnostic/bam.py by pep8

            When catching exceptions, mention specific exceptions when possible.

            Okay: except Exception:
            Okay: except BaseException:
            E722: except:

            Ambiguous variable name 'l'
            Open

                                l = int(part[3:])
            Severity: Minor
            Found in bamnostic/bam.py by pep8

            Never use the characters 'l', 'O', or 'I' as variable names.

            In some fonts, these characters are indistinguishable from the
            numerals one and zero. When tempted to use 'l', use 'L' instead.
            
            Okay: L = 0
            Okay: o = 123
            Okay: i = 42
            E741: l = 0
            E741: O = 123
            E741: I = 42
            
            Variables can be bound in several other contexts, including class
            and function definitions, 'global' and 'nonlocal' statements,
            exception handlers, and 'with' and 'for' statements.
            In addition, we have a special handling for function parameters.
            
            Okay: except AttributeError as o:
            Okay: with lock as L:
            Okay: foo(l=12)
            Okay: for a in foo(l=12):
            E741: except AttributeError as O:
            E741: with lock as l:
            E741: global I
            E741: nonlocal l
            E741: def foo(l):
            E741: def foo(l=12):
            E741: l = foo(l=12)
            E741: for l in range(10):
            E742: class I(object):
            E743: def l(x):

            Unexpected spaces around keyword / parameter equals
            Open

                def __init__(self, filepath_or_object, mode = 'xb', compresslevel = 6, ignore_overwrite = False,
            Severity: Minor
            Found in bamnostic/bam.py by pep8

            Don't use spaces around the '=' sign in function arguments.

            Don't use spaces around the '=' sign when used to indicate a
            keyword argument or a default parameter value, except when
            using a type annotation.
            
            Okay: def complex(real, imag=0.0):
            Okay: return magic(r=real, i=imag)
            Okay: boolean(a == b)
            Okay: boolean(a != b)
            Okay: boolean(a <= b)
            Okay: boolean(a >= b)
            Okay: def foo(arg: int = 42):
            Okay: async def foo(arg: int = 42):
            
            E251: def complex(real, imag = 0.0):
            E251: return magic(r = real, i = imag)
            E252: def complex(real, image: float=0.0):

            Continuation line under-indented for visual indent
            Open

                                'duplicate_filehandle': locals()['duplicate_filehandle']}
            Severity: Minor
            Found in bamnostic/bam.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)

            Unexpected spaces around keyword / parameter equals
            Open

            def _cross_check_header_refs(reads, header="", referencenames = None, referencelengths = None):
            Severity: Minor
            Found in bamnostic/bam.py by pep8

            Don't use spaces around the '=' sign in function arguments.

            Don't use spaces around the '=' sign when used to indicate a
            keyword argument or a default parameter value, except when
            using a type annotation.
            
            Okay: def complex(real, imag=0.0):
            Okay: return magic(r=real, i=imag)
            Okay: boolean(a == b)
            Okay: boolean(a != b)
            Okay: boolean(a <= b)
            Okay: boolean(a >= b)
            Okay: def foo(arg: int = 42):
            Okay: async def foo(arg: int = 42):
            
            E251: def complex(real, imag = 0.0):
            E251: return magic(r = real, i = imag)
            E252: def complex(real, image: float=0.0):

            Unexpected spaces around keyword / parameter equals
            Open

                            copy_header = None, header = b'', reference_names = None, reference_lengths = None):
            Severity: Minor
            Found in bamnostic/bam.py by pep8

            Don't use spaces around the '=' sign in function arguments.

            Don't use spaces around the '=' sign when used to indicate a
            keyword argument or a default parameter value, except when
            using a type annotation.
            
            Okay: def complex(real, imag=0.0):
            Okay: return magic(r=real, i=imag)
            Okay: boolean(a == b)
            Okay: boolean(a != b)
            Okay: boolean(a <= b)
            Okay: boolean(a >= b)
            Okay: def foo(arg: int = 42):
            Okay: async def foo(arg: int = 42):
            
            E251: def complex(real, imag = 0.0):
            E251: return magic(r = real, i = imag)
            E252: def complex(real, image: float=0.0):

            Unexpected spaces around keyword / parameter equals
            Open

            def _cross_check_header_refs(reads, header="", referencenames = None, referencelengths = None):
            Severity: Minor
            Found in bamnostic/bam.py by pep8

            Don't use spaces around the '=' sign in function arguments.

            Don't use spaces around the '=' sign when used to indicate a
            keyword argument or a default parameter value, except when
            using a type annotation.
            
            Okay: def complex(real, imag=0.0):
            Okay: return magic(r=real, i=imag)
            Okay: boolean(a == b)
            Okay: boolean(a != b)
            Okay: boolean(a <= b)
            Okay: boolean(a >= b)
            Okay: def foo(arg: int = 42):
            Okay: async def foo(arg: int = 42):
            
            E251: def complex(real, imag = 0.0):
            E251: return magic(r = real, i = imag)
            E252: def complex(real, image: float=0.0):

            Unexpected spaces around keyword / parameter equals
            Open

                def __init__(self, filepath_or_object, mode = 'xb', compresslevel = 6, ignore_overwrite = False,
            Severity: Minor
            Found in bamnostic/bam.py by pep8

            Don't use spaces around the '=' sign in function arguments.

            Don't use spaces around the '=' sign when used to indicate a
            keyword argument or a default parameter value, except when
            using a type annotation.
            
            Okay: def complex(real, imag=0.0):
            Okay: return magic(r=real, i=imag)
            Okay: boolean(a == b)
            Okay: boolean(a != b)
            Okay: boolean(a <= b)
            Okay: boolean(a >= b)
            Okay: def foo(arg: int = 42):
            Okay: async def foo(arg: int = 42):
            
            E251: def complex(real, imag = 0.0):
            E251: return magic(r = real, i = imag)
            E252: def complex(real, image: float=0.0):

            Unexpected spaces around keyword / parameter equals
            Open

                def __init__(self, filepath_or_object, mode = 'xb', compresslevel = 6, ignore_overwrite = False,
            Severity: Minor
            Found in bamnostic/bam.py by pep8

            Don't use spaces around the '=' sign in function arguments.

            Don't use spaces around the '=' sign when used to indicate a
            keyword argument or a default parameter value, except when
            using a type annotation.
            
            Okay: def complex(real, imag=0.0):
            Okay: return magic(r=real, i=imag)
            Okay: boolean(a == b)
            Okay: boolean(a != b)
            Okay: boolean(a <= b)
            Okay: boolean(a >= b)
            Okay: def foo(arg: int = 42):
            Okay: async def foo(arg: int = 42):
            
            E251: def complex(real, imag = 0.0):
            E251: return magic(r = real, i = imag)
            E252: def complex(real, image: float=0.0):

            Unexpected spaces around keyword / parameter equals
            Open

                            copy_header = None, header = b'', reference_names = None, reference_lengths = None):
            Severity: Minor
            Found in bamnostic/bam.py by pep8

            Don't use spaces around the '=' sign in function arguments.

            Don't use spaces around the '=' sign when used to indicate a
            keyword argument or a default parameter value, except when
            using a type annotation.
            
            Okay: def complex(real, imag=0.0):
            Okay: return magic(r=real, i=imag)
            Okay: boolean(a == b)
            Okay: boolean(a != b)
            Okay: boolean(a <= b)
            Okay: boolean(a >= b)
            Okay: def foo(arg: int = 42):
            Okay: async def foo(arg: int = 42):
            
            E251: def complex(real, imag = 0.0):
            E251: return magic(r = real, i = imag)
            E252: def complex(real, image: float=0.0):

            Unexpected spaces around keyword / parameter equals
            Open

                            copy_header = None, header = b'', reference_names = None, reference_lengths = None):
            Severity: Minor
            Found in bamnostic/bam.py by pep8

            Don't use spaces around the '=' sign in function arguments.

            Don't use spaces around the '=' sign when used to indicate a
            keyword argument or a default parameter value, except when
            using a type annotation.
            
            Okay: def complex(real, imag=0.0):
            Okay: return magic(r=real, i=imag)
            Okay: boolean(a == b)
            Okay: boolean(a != b)
            Okay: boolean(a <= b)
            Okay: boolean(a >= b)
            Okay: def foo(arg: int = 42):
            Okay: async def foo(arg: int = 42):
            
            E251: def complex(real, imag = 0.0):
            E251: return magic(r = real, i = imag)
            E252: def complex(real, image: float=0.0):

            Unexpected spaces around keyword / parameter equals
            Open

                            copy_header = None, header = b'', reference_names = None, reference_lengths = None):
            Severity: Minor
            Found in bamnostic/bam.py by pep8

            Don't use spaces around the '=' sign in function arguments.

            Don't use spaces around the '=' sign when used to indicate a
            keyword argument or a default parameter value, except when
            using a type annotation.
            
            Okay: def complex(real, imag=0.0):
            Okay: return magic(r=real, i=imag)
            Okay: boolean(a == b)
            Okay: boolean(a != b)
            Okay: boolean(a <= b)
            Okay: boolean(a >= b)
            Okay: def foo(arg: int = 42):
            Okay: async def foo(arg: int = 42):
            
            E251: def complex(real, imag = 0.0):
            E251: return magic(r = real, i = imag)
            E252: def complex(real, image: float=0.0):

            Unexpected spaces around keyword / parameter equals
            Open

                                    reference_names = reference_names, 
            Severity: Minor
            Found in bamnostic/bam.py by pep8

            Don't use spaces around the '=' sign in function arguments.

            Don't use spaces around the '=' sign when used to indicate a
            keyword argument or a default parameter value, except when
            using a type annotation.
            
            Okay: def complex(real, imag=0.0):
            Okay: return magic(r=real, i=imag)
            Okay: boolean(a == b)
            Okay: boolean(a != b)
            Okay: boolean(a <= b)
            Okay: boolean(a >= b)
            Okay: def foo(arg: int = 42):
            Okay: async def foo(arg: int = 42):
            
            E251: def complex(real, imag = 0.0):
            E251: return magic(r = real, i = imag)
            E252: def complex(real, image: float=0.0):

            Continuation line under-indented for visual indent
            Open

                                                                    reference_names,
            Severity: Minor
            Found in bamnostic/bam.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)

            There are no issues that match your filters.

            Category
            Status