DynaSlum/satsense

View on GitHub

Showing 28 of 28 total issues

File image.py has 624 lines of code (exceeds 250 allowed). Consider refactoring.
Open

"""Methods for loading images."""

import logging
import os
import time
Severity: Major
Found in satsense/image.py - About 1 day to fix

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

        def _get_normalization_limits(self, band, image=None):
            """
            Return normalization limits for band.
    
            Parameters
    Severity: Minor
    Found in satsense/image.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 from_file. (10)
    Open

        @classmethod
        def from_file(cls, feature, filename_prefix):
            """
            Restore saved features.
    
    
    Severity: Minor
    Found in satsense/image.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 _get_normalization_limits has a Cognitive Complexity of 16 (exceeds 5 allowed). Consider refactoring.
    Open

        def _get_normalization_limits(self, band, image=None):
            """
            Return normalization limits for band.
    
            Parameters
    Severity: Minor
    Found in satsense/image.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 extract_feature. (7)
    Open

    def extract_feature(feature, generator):
        """Compute a single feature vector.
    
        Parameters
        ----------
    Severity: Minor
    Found in satsense/extract.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 __getitem__. (6)
    Open

        def __getitem__(self, itype):
            """
            Get image of a type registered using the `register` method.
            The following itypes are available to facilitate creating
            new features:
    Severity: Minor
    Found in satsense/image.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 from_file has a Cognitive Complexity of 14 (exceeds 5 allowed). Consider refactoring.
    Open

        def from_file(cls, feature, filename_prefix):
            """
            Restore saved features.
    
            Parameters
    Severity: Minor
    Found in satsense/image.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 extract_feature has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.
    Open

    def extract_feature(feature, generator):
        """Compute a single feature vector.
    
        Parameters
        ----------
    Severity: Minor
    Found in satsense/extract.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 show_multipolygon has 7 arguments (exceeds 4 allowed). Consider refactoring.
    Open

    def show_multipolygon(multipolygon, axis, show_coords, extent, color, alpha,
    Severity: Major
    Found in satsense/util/shapefile.py - About 50 mins to fix

      Function from_images has 6 arguments (exceeds 4 allowed). Consider refactoring.
      Open

          def from_images(cls,
      Severity: Minor
      Found in satsense/features/sift.py - About 45 mins to fix

        Function __init__ has 6 arguments (exceeds 4 allowed). Consider refactoring.
        Open

            def __init__(self,
        Severity: Minor
        Found in satsense/image.py - About 45 mins to fix

          Function __init__ has 6 arguments (exceeds 4 allowed). Consider refactoring.
          Open

              def __init__(self,
          Severity: Minor
          Found in satsense/generators.py - About 45 mins to fix

            Function from_images has 6 arguments (exceeds 4 allowed). Consider refactoring.
            Open

                def from_images(cls,
            Severity: Minor
            Found in satsense/features/texton.py - About 45 mins to fix

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

                  def __iter__(self):
                      """
                      Iterate over the x and y coordinates of the generator and windows
              
                      While iterating it will return for each x and y coordinate as defined
              Severity: Minor
              Found in satsense/generators.py - About 35 mins to fix

              Cognitive Complexity

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

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

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

              Further reading

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

                  def __init__(self, windows=((25, 25), ), box_sizes=(10, 20, 30)):
                      # Check input
                      for window in windows:
                          for box_size in box_sizes:
                              if window[0] <= box_size or window[1] <= box_size:
              Severity: Minor
              Found in satsense/features/lacunarity.py - About 35 mins to fix

              Cognitive Complexity

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

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

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

              Further reading

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

              def texton_cluster(images: Iterator[Image],
                                 n_clusters=32,
                                 max_samples=100000,
                                 sample_window=(8192, 8192)) -> MiniBatchKMeans:
                  """Compute texton clusters."""
              Severity: Minor
              Found in satsense/features/texton.py - About 25 mins to fix

              Cognitive Complexity

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

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

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

              Further reading

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

              def create_texton_kernels():
                  """Create filter bank kernels."""
                  kernels = []
                  angles = 8
                  thetas = np.linspace(0, np.pi, angles)
              Severity: Minor
              Found in satsense/features/texton.py - About 25 mins to fix

              Cognitive Complexity

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

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

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

              Further reading

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

                  def __getitem__(self, itype):
                      """
                      Get image of a type registered using the `register` method.
                      The following itypes are available to facilitate creating
                      new features:
              Severity: Minor
              Found in satsense/image.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

              Fenced code blocks should be surrounded by blank lines
              Open

              ```bash
              Severity: Info
              Found in CONTRIBUTING.md by markdownlint

              MD031 - Fenced code blocks should be surrounded by blank lines

              Tags: code, blank_lines

              Aliases: blanks-around-fences

              This rule is triggered when fenced code blocks are either not preceded or not followed by a blank line:

              Some text
              ```
              Code block
              ```
              
              ```
              Another code block
              ```
              Some more text

              To fix this, ensure that all fenced code blocks have a blank line both before and after (except where the block is at the beginning or end of the document):

              Some text
              
              ```
              Code block
              ```
              
              ```
              Another code block
              ```
              
              Some more text

              Rationale: Aside from aesthetic reasons, some parsers, including kramdown, will not parse fenced code blocks that don't have blank lines before and after them.

              Line length
              Open

              Please create a pull request early, to keep other developers informed of what you're doing.
              Severity: Info
              Found in CONTRIBUTING.md by markdownlint

              MD013 - Line length

              Tags: line_length

              Aliases: line-length Parameters: linelength, codeblocks, tables (number; default 80, boolean; default true)

              This rule is triggered when there are lines that are longer than the configured line length (default: 80 characters). To fix this, split the line up into multiple lines.

              This rule has an exception where there is no whitespace beyond the configured line length. This allows you to still include items such as long URLs without being forced to break them in the middle.

              You also have the option to exclude this rule for code blocks and tables. To do this, set the code_blocks and/or tables parameters to false.

              Code blocks are included in this rule by default since it is often a requirement for document readability, and tentatively compatible with code rules. Still, some languages do not lend themselves to short lines.

              Severity
              Category
              Status
              Source
              Language