DynaSlum/satsense

View on GitHub

Showing 31 of 31 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 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

    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

    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/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 __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 __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 __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

              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

              Headers should be surrounded by blank lines
              Open

              ## Performance
              Severity: Info
              Found in notebooks/README.md by markdownlint

              MD022 - Headers should be surrounded by blank lines

              Tags: headers, blank_lines

              Aliases: blanks-around-headers

              This rule is triggered when headers (any style) are either not preceded or not followed by a blank line:

              # Header 1
              Some text
              
              Some more text
              ## Header 2

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

              # Header 1
              
              Some text
              
              Some more text
              
              ## Header 2

              Rationale: Aside from aesthetic reasons, some parsers, including kramdown, will not parse headers that don't have a blank line before, and will parse them as regular text.

              Bare URL used
              Open

                - Available at https://satsense.readthedocs.io/en/latest/
              Severity: Info
              Found in CHANGELOG.md by markdownlint

              MD034 - Bare URL used

              Tags: links, url

              Aliases: no-bare-urls

              This rule is triggered whenever a URL is given that isn't surrounded by angle brackets:

              For more information, see http://www.example.com/.

              To fix this, add angle brackets around the URL:

              For more information, see <http:></http:>.

              Rationale: Without angle brackets, the URL isn't converted into a link in many markdown parsers.

              Note: if you do want a bare URL without it being converted into a link, enclose it in a code block, otherwise in some markdown parsers it will be converted:

              `http://www.example.com`
              Severity
              Category
              Status
              Source
              Language