some linting improvements

Author: gykovacs

docs/conf.py

@@ -1,4 +1,3 @@
-# -*- coding: utf-8 -*-
 #
 # Configuration file for the Sphinx documentation builder.
 #

legacy/_check_1_dataset_unknown_folds_mos_acc_score.py

@@ -5,8 +5,8 @@
 
 import itertools
 
-from ...core import NUMERICAL_TOLERANCE
 from ...aggregated import Evaluation
+from ...core import NUMERICAL_TOLERANCE
 
 __all__ = ['check_1_dataset_unknown_folds_mos_acc_score']
 

legacy/test_1_dataset_unknown_folds_mos_acc_score.py

@@ -3,13 +3,12 @@
 with unknown folds (only k and the number of repetitions known)
 """
 
-import pytest
-
 import numpy as np
+import pytest
 
+from mlscorecheck.aggregated import Evaluation, Folding, generate_dataset
 from mlscorecheck.check.binary import check_1_dataset_unknown_folds_mos_acc_score
-from mlscorecheck.aggregated import (generate_dataset,
-                                        Evaluation, Folding)
+
 
 @pytest.mark.parametrize('random_seed', range(20))
 def test_consistency(random_seed: int):

mlscorecheck/__init__.py

@@ -3,4 +3,4 @@
 """
 
 from . import aggregated, check, core, experiments, individual, symbolic
-from ._version import *
+from ._version import __version__

mlscorecheck/aggregated/_fold_enumeration.py

@@ -22,7 +22,7 @@
     "_check_specification_and_determine_p_n",
     "multiclass_fold_partitioning_generator_22",
     "multiclass_fold_partitioning_generator_2n",
-    "multiclass_fold_partitioning_generator_kn"
+    "multiclass_fold_partitioning_generator_kn",
 ]
 
 
@@ -75,9 +75,7 @@ def integer_partitioning_generator(n: int, m: int):  # pylint: disable=invalid-n
         x[m] = n - s[m - 1]
 
 
-def all_integer_partitioning_generator(
-    n, k, non_zero, max_count
-):  # pylint: disable=invalid-name
+def all_integer_partitioning_generator(n, k, non_zero, max_count):  # pylint: disable=invalid-name
     """
     Generate all integer partitioning of n to k parts (including 0 parts)
 
@@ -114,8 +112,7 @@ def not_enough_diverse_folds(p_values, n_values):
     """
 
     return len(p_values) > 1 and (
-        sum(p_tmp > 0 for p_tmp in p_values) < 2
-        or sum(n_tmp > 0 for n_tmp in n_values) < 2
+        sum(p_tmp > 0 for p_tmp in p_values) < 2 or sum(n_tmp > 0 for n_tmp in n_values) < 2
     )
 
 
@@ -185,17 +182,13 @@ def fold_partitioning_generator(
     for p_a in range(min_p_a, max_p_a + 1):
         p_b = p - p_a
 
-        for ps_a in all_integer_partitioning_generator(
-            p_a, k_a, p_non_zero, c_a - n_non_zero
-        ):
+        for ps_a in all_integer_partitioning_generator(p_a, k_a, p_non_zero, c_a - n_non_zero):
             if any(p_tmp < p_min for p_tmp in ps_a):
                 continue
 
             ns_a = [c_a - tmp for tmp in ps_a]
 
-            for ps_b in all_integer_partitioning_generator(
-                p_b, k_b, p_non_zero, c_b - n_non_zero
-            ):
+            for ps_b in all_integer_partitioning_generator(p_b, k_b, p_non_zero, c_b - n_non_zero):
                 if any(p_tmp < p_min for p_tmp in ps_b):
                     continue
 
@@ -210,7 +203,7 @@ def fold_partitioning_generator(
                 yield ps_all, ns_all
 
 
-def _check_specification_and_determine_p_n(dataset: dict, folding: dict) -> (int, int):
+def _check_specification_and_determine_p_n(dataset: dict, folding: dict) -> tuple[int, int]:
     """
     Checking if the dataset specification is correct and determining the p and n values
 
@@ -271,14 +264,10 @@ def kfolds_generator(evaluation: dict, available_scores: list, repeat_idx=0):
 
     if "sens" not in available_scores and "bacc" not in available_scores:
         p_zero = True
-        logger.info(
-            "sens and bacc not among the reported scores, p=0 folds are also considered"
-        )
+        logger.info("sens and bacc not among the reported scores, p=0 folds are also considered")
     if "spec" not in available_scores and "bacc" not in available_scores:
         n_zero = True
-        logger.info(
-            "spec and bacc not among the reported scores, n=0 folds are also considered"
-        )
+        logger.info("spec and bacc not among the reported scores, n=0 folds are also considered")
 
     if evaluation["dataset"].get("dataset_name") is not None:
         evaluation["dataset"][
@@ -321,17 +310,13 @@ def repeated_kfolds_generator(evaluation: dict, available_scores: list):
         dict: one evaluation
     """
     n_repeats = evaluation["folding"].get("n_repeats", 1)
-    generators = [
-        kfolds_generator(evaluation, available_scores, idx) for idx in range(n_repeats)
-    ]
+    generators = [kfolds_generator(evaluation, available_scores, idx) for idx in range(n_repeats)]
 
     if n_repeats > 1:
         for folds in itertools.product(*generators):
             yield {
                 "dataset": copy.deepcopy(evaluation["dataset"]),
-                "folding": {
-                    "folds": [fold for fold_list in folds for fold in fold_list]
-                },
+                "folding": {"folds": [fold for fold_list in folds for fold in fold_list]},
                 "fold_score_bounds": copy.deepcopy(evaluation.get("fold_score_bounds")),
                 "aggregation": evaluation.get("aggregation"),
             }
@@ -370,6 +355,7 @@ def experiment_kfolds_generator(experiment: dict, available_scores: list):
             "aggregation": experiment["aggregation"],
         }
 
+
 def multiclass_fold_partitioning_generator_22(n0: int, n1: int, c0: int):
     """
     Generates the configurations for two folds of cardinalities n0 and n1 and two
@@ -387,10 +373,8 @@ def multiclass_fold_partitioning_generator_22(n0: int, n1: int, c0: int):
     lower_bound = max(c0 - n1, 0)
 
     for c_00 in range(lower_bound, upper_bound + 1):
-        yield {
-            0: (c_00, n0 - c_00),
-            1: (c0 - c_00, n1 - c0 + c_00)
-        }
+        yield {0: (c_00, n0 - c_00), 1: (c0 - c_00, n1 - c0 + c_00)}
+
 
 def multiclass_fold_partitioning_generator_2n(n0: int, n1: int, cs: list):
     """
@@ -410,14 +394,10 @@ def multiclass_fold_partitioning_generator_2n(n0: int, n1: int, cs: list):
             yield part
         else:
             for part_deep in multiclass_fold_partitioning_generator_2n(
-                part[0][1],
-                part[1][1],
-                cs[1:]
-                ):
-                yield {
-                    0: (part[0][0], *(part_deep[0])),
-                    1: (part[1][0], *(part_deep[1]))
-                }
+                part[0][1], part[1][1], cs[1:]
+            ):
+                yield {0: (part[0][0], *(part_deep[0])), 1: (part[1][0], *(part_deep[1]))}
+
 
 def multiclass_fold_partitioning_generator_kn(ns: list, cs: list):
     """

mlscorecheck/check/binary/_check_1_dataset_unknown_folds_mos.py

@@ -48,7 +48,7 @@ def check_1_dataset_unknown_folds_mos(
     solver_name: str = None,
     timeout: int = None,
     verbosity: int = 1,
-    numerical_tolerance: float = NUMERICAL_TOLERANCE
+    numerical_tolerance: float = NUMERICAL_TOLERANCE,
 ) -> dict:
     """
     Checking the consistency of scores calculated in a k-fold cross validation on a single
@@ -141,8 +141,7 @@ def check_1_dataset_unknown_folds_mos(
 
     results = {"details": []}
 
-    idx = 0
-    for evaluation_0 in repeated_kfolds_generator(evaluation, list(scores.keys())):
+    for idx, evaluation_0 in enumerate(repeated_kfolds_generator(evaluation, list(scores.keys()))):
         tmp = {
             "folds": evaluation_0["folding"]["folds"],
             "details": check_1_dataset_known_folds_mos(
@@ -161,7 +160,6 @@ def check_1_dataset_unknown_folds_mos(
         results["details"].append(tmp)
         if not tmp["details"]["inconsistency"]:
             break
-        idx += 1
 
     results["inconsistency"] = all(tmp["details"]["inconsistency"] for tmp in results["details"])
 

mlscorecheck/check/regression/_check_regression.py

@@ -87,9 +87,7 @@ def r_squared(y_true: np.array, y_pred: np.array) -> float:
 }
 
 
-def calculate_regression_scores(
-    y_true: np.array, y_pred: np.array, subset=None
-) -> dict:
+def calculate_regression_scores(y_true: np.array, y_pred: np.array, subset=None) -> dict:
     """
     Calculate the performance scores for a regression problem
 
@@ -112,7 +110,7 @@ def calculate_regression_scores(
 
 def generate_regression_problem_and_scores(
     random_state=None, max_n_samples=1000, subset=None, rounding_decimals=None
-) -> (float, int, dict):
+) -> tuple[float, int, dict]:
     """
     Generate a regression problem and corresponding scores
 
@@ -165,9 +163,7 @@ def expand_regression_scores(
         dict: the extended set of score intervals
     """
     scores = {
-        key: Interval(
-            value - eps - numerical_tolerance, value + eps + numerical_tolerance
-        )
+        key: Interval(value - eps - numerical_tolerance, value + eps + numerical_tolerance)
         for key, value in scores.items()
     }
 
@@ -176,9 +172,7 @@ def expand_regression_scores(
         if key not in scores:
             for sol, formula in value.items():
                 if sol in scores:
-                    to_add[key] = safe_eval(
-                        formula, scores | {"var": var, "n_samples": n_samples}
-                    )
+                    to_add[key] = safe_eval(formula, scores | {"var": var, "n_samples": n_samples})
                     break
 
     return scores | to_add
@@ -256,8 +250,6 @@ def check_1_testset_no_kfold(
         >>> result['inconsistency']
         # True
     """
-    intervals = expand_regression_scores(
-        var, n_samples, scores, eps, numerical_tolerance
-    )
+    intervals = expand_regression_scores(var, n_samples, scores, eps, numerical_tolerance)
 
     return check_relations(intervals)

mlscorecheck/core/_rounding.py

@@ -7,7 +7,7 @@
 __all__ = ["round_scores"]
 
 
-def round_scores(to_round: dict, rounding_decimals: int = None):
+def round_scores(to_round: dict, rounding_decimals: int | None = None):
     """
     Rounds the scores
 
@@ -24,7 +24,4 @@ def round_scores(to_round: dict, rounding_decimals: int = None):
     if not isinstance(to_round, dict):
         return float(np.round(to_round, rounding_decimals))
 
-    return {
-        key: float(np.round(value, rounding_decimals))
-        for key, value in to_round.items()
-    }
+    return {key: float(np.round(value, rounding_decimals)) for key, value in to_round.items()}

mlscorecheck/core/_safe_eval.py

@@ -21,7 +21,7 @@ def safe_eval(expression: str, subs: dict):
     return eval(expression, subs)  # pylint: disable=eval-used
 
 
-def check_applicability(params: dict, non_applicable: list = None) -> bool:
+def check_applicability(params: dict, non_applicable: list | None = None) -> bool:
     """
     Checks if a parameter configuration is applicable according to the
     non-applicability configurations
@@ -50,7 +50,7 @@ def check_applicability(params: dict, non_applicable: list = None) -> bool:
     return True
 
 
-def safe_call(function, params: dict, non_applicable: list = None):
+def safe_call(function, params: dict, non_applicable: list | None = None):
     """
     Safe call to a function
 

mlscorecheck/experiments/_load_datasets.py

@@ -8,7 +8,7 @@
 
 from ..core import load_json
 
-dataset_statistics = {}
+dataset_statistics: dict = {}
 
 
 def resolve_pn(dataset_conf):
@@ -65,9 +65,7 @@ def load_ml_datasets():
             "n": entry["n"],
         }
 
-    data = load_json(
-        os.path.join("experiments", "machine_learning"), "common_datasets.json"
-    )
+    data = load_json(os.path.join("experiments", "machine_learning"), "common_datasets.json")
 
     for entry in data["datasets"]:
         dataset_statistics["common_datasets." + entry["name"]] = {