HunterMcGushion/hyperparameter_hunter

View on GitHub

Showing 89 of 104 total issues

Function format_fold_run has a Cognitive Complexity of 42 (exceeds 5 allowed). Consider refactoring.
Open

def format_fold_run(rep=None, fold=None, run=None, mode="concise"):
    """Construct a string to display the repetition, fold, and run currently being executed

    Parameters
    ----------
Severity: Minor
Found in hyperparameter_hunter/i_o/reporting.py - About 6 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 ask has a Cognitive Complexity of 33 (exceeds 5 allowed). Consider refactoring.
Open

    def ask(self, n_points=None, strategy="cl_min"):  # TODO: Try `n_points` default=1
        """Request point (or points) at which objective should be evaluated next

        Parameters
        ----------
Severity: Minor
Found in hyperparameter_hunter/optimization/backends/skopt/engine.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

Environment has 37 functions (exceeds 20 allowed). Consider refactoring.
Open

class Environment:
    DEFAULT_PARAMS = dict(
        environment_params_path=None,
        results_path=None,
        target_column="target",
Severity: Minor
Found in hyperparameter_hunter/environment.py - About 4 hrs to fix

    Function lambda_callback has a Cognitive Complexity of 31 (exceeds 5 allowed). Consider refactoring.
    Open

    def lambda_callback(
        on_exp_start=None,
        on_exp_end=None,
        on_rep_start=None,
        on_rep_end=None,
    Severity: Minor
    Found in hyperparameter_hunter/callbacks/bases.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 _tell has a Cognitive Complexity of 24 (exceeds 5 allowed). Consider refactoring.
    Open

        def _tell(self, x, y, fit=True):
            """Perform the actual work of incorporating one or more new points. See :meth:`tell` for
            the full description. This method exists to give access to the internals of adding points
            by side-stepping all input validation and transformation"""
            #################### Collect Search Points and Evaluations ####################
    Severity: Minor
    Found in hyperparameter_hunter/optimization/backends/skopt/engine.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 handle_complex_types has a Cognitive Complexity of 23 (exceeds 5 allowed). Consider refactoring.
    Open

        def handle_complex_types(self):
            """Locate complex types in :attr:`parameters`, create hashes for them, add lookup entries
            linking their original values to their hashes, then update their values in
            :attr:`parameters` to their hashes to facilitate Description saving"""
            dataframe_hashes = {}
    Severity: Minor
    Found in hyperparameter_hunter/keys/makers.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 validate_fe_steps has a Cognitive Complexity of 22 (exceeds 5 allowed). Consider refactoring.
    Open

    def validate_fe_steps(
        candidate: Union[list, FeatureEngineer], template: Union[list, FeatureEngineer]
    ) -> list:
        """Check `candidate` "feature_engineer" `steps` compatibility with `template` and sanitize
        `candidate`
    Severity: Minor
    Found in hyperparameter_hunter/i_o/result_reader.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 _check_y_is_valid has a Cognitive Complexity of 22 (exceeds 5 allowed). Consider refactoring.
    Open

        def _check_y_is_valid(self, x, y):
            """Check if the shapes and types of `x` and `y` are consistent. Complains if anything
            is weird about `y`"""
            #################### Per-Second Acquisition Function ####################
            if self.acq_func.endswith("ps"):
    Severity: Minor
    Found in hyperparameter_hunter/optimization/backends/skopt/engine.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 link_choice_ids has a Cognitive Complexity of 19 (exceeds 5 allowed). Consider refactoring.
    Open

    def link_choice_ids(layers, compile_params, extra_params, dimensions):
        """Update `extra_params` to include a "location" attribute on any descendants of
        :class:`space.Dimension`, specifying its position among all hyperparameters
    
        Parameters
    Severity: Minor
    Found in hyperparameter_hunter/compat/keras_optimization_helper.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 print_tree has a Cognitive Complexity of 17 (exceeds 5 allowed). Consider refactoring.
    Open

    def print_tree(start_path, depth=-1, pretty=True):
        """Print directory/file tree structure
    
        Parameters
        ----------
    Severity: Minor
    Found in hyperparameter_hunter/utils/file_utils.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 consolidate_layers has a Cognitive Complexity of 17 (exceeds 5 allowed). Consider refactoring.
    Open

    def consolidate_layers(layers, class_name_key=True, split_args=False):
        """For each of the layer dicts in `layers`, merge the dict's keys to reflect the end value of
        the key, rather than its default value, and whether a value was explicitly given
    
        Parameters
    Severity: Minor
    Found in hyperparameter_hunter/compat/keras_optimization_helper.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

    BaseOptPro has 21 functions (exceeds 20 allowed). Consider refactoring.
    Open

    class BaseOptPro(metaclass=MergedOptProMeta):
        source_script: str
    
        def __init__(
            self,
    Severity: Minor
    Found in hyperparameter_hunter/optimization/protocol_core.py - About 2 hrs to fix

      Dimension has 21 functions (exceeds 20 allowed). Consider refactoring.
      Open

      class Dimension(ABC):
          prior = None  # Prevent plotting from breaking on `Integer`, which has no `prior`
      
          def __init__(self, **kwargs):
              """Abstract base class for hyperparameter search space dimensions
      Severity: Minor
      Found in hyperparameter_hunter/space/dimensions.py - About 2 hrs to fix

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

        def has_experiment_result_file(results_dir, experiment_id, result_type=None):
            """Check if the specified result files exist in `results_dir` for Experiment `experiment_id`
        
            Parameters
            ----------
        Severity: Minor
        Found in hyperparameter_hunter/i_o/result_reader.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 get_concise_params_dict has a Cognitive Complexity of 16 (exceeds 5 allowed). Consider refactoring.
        Open

        def get_concise_params_dict(params, split_args=False):
            # TODO: Add docstring
            new_params = subdict(params, drop=HH_ARG_ATTRS)
            arg_vals = {}
        
        
        Severity: Minor
        Found in hyperparameter_hunter/compat/keras_helper.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 format_metrics has a Cognitive Complexity of 16 (exceeds 5 allowed). Consider refactoring.
        Open

        def format_metrics(metrics: Union[Dict, List]) -> Dict[str, Metric]:
            """Properly format iterable `metrics` to contain instances of :class:`Metric`
        
            Parameters
            ----------
        Severity: Minor
        Found in hyperparameter_hunter/metrics.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 _validate_metrics_list_parameters has a Cognitive Complexity of 16 (exceeds 5 allowed). Consider refactoring.
        Open

            def _validate_metrics_list_parameters(self):
                """Ensure metrics lists input parameters are correct types and compatible with each other"""
                for (_d_type, _m_val) in [(_, getattr(self, f"_ScoringMixIn{_}")) for _ in data_types]:
                    if _m_val == "all":
                        setattr(self, f"_ScoringMixIn{_d_type}", list(self.metrics.keys()))
        Severity: Minor
        Found in hyperparameter_hunter/metrics.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_dimension has a Cognitive Complexity of 16 (exceeds 5 allowed). Consider refactoring.
        Open

        def check_dimension(dimension, transform=None):
            """Turn a provided dimension description into a dimension object. Checks that the provided
            dimension falls into one of the supported types, listed below in the description of `dimension`
        
            Parameters
        Severity: Minor
        Found in hyperparameter_hunter/space/space_core.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 lambda_check_train_targets has a Cognitive Complexity of 16 (exceeds 5 allowed). Consider refactoring.
        Open

        def lambda_check_train_targets(
            on_exp_start: Optional[List[TrainTargetChunk]] = None,
            on_rep_start: Optional[List[TrainTargetChunk]] = None,
            on_fold_start: Optional[List[TrainTargetChunk]] = None,
            on_run_start: Optional[List[TrainTargetChunk]] = None,
        Severity: Minor
        Found in hyperparameter_hunter/callbacks/recipes.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 normalize_dimensions has a Cognitive Complexity of 15 (exceeds 5 allowed). Consider refactoring.
        Open

        def normalize_dimensions(dimensions):
            """Create a `Space` where all dimensions are instructed to be normalized to unit range. Note
            that this doesn't *really* return normalized `dimensions`. It just returns the given
            `dimensions`, with each one's `transform` set to the appropriate value, so that when each
            dimension's :meth:`transform` is called, the dimensions are actually normalized
        Severity: Minor
        Found in hyperparameter_hunter/space/space_core.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

        Severity
        Category
        Status
        Source
        Language