some linting updates

Author: gykovacs

mlscorecheck/aggregated/_check_aggregated_scores.py

@@ -71,10 +71,10 @@ def check_aggregated_scores(
             "message": "no scores suitable for aggregated consistency checks",
         }
 
-    experiment = Experiment(**experiment) if isinstance(experiment, dict) else experiment
+    experiment_obj = Experiment(**experiment) if isinstance(experiment, dict) else experiment
 
-    if experiment.aggregation == "som" and any(
-        evaluation.aggregation == "mos" for evaluation in experiment.evaluations
+    if experiment_obj.aggregation == "som" and any(
+        evaluation.aggregation == "mos" for evaluation in experiment_obj.evaluations
     ):
         raise ValueError(
             "experiment level MoS aggregation with dataset level SoM "
@@ -95,7 +95,7 @@ def check_aggregated_scores(
 
     result = solve(experiment, scores, eps, solver)
 
-    populated = experiment.populate(result)
+    populated = experiment_obj.populate(result)
     populated.calculate_scores(score_subset=list(scores.keys()))
     configuration_details = populated.check_bounds()
 

mlscorecheck/aggregated/_evaluation.py

@@ -54,7 +54,7 @@ def __init__(
             "n": sum(fold.n for fold in self.folds),
         }
 
-        self.scores = None
+        self.scores: dict | None = None
 
     def to_dict(self) -> dict:
         """
@@ -120,6 +120,9 @@ def calculate_scores(
         elif self.aggregation == "mos":
             self.scores = dict_mean([fold.scores for fold in self.folds])
 
+        if self.scores is None:
+            return {}
+
         return (
             self.scores
             if rounding_decimals is None
@@ -148,7 +151,8 @@ def init_lp(self, lp_problem: pl.LpProblem, scores: dict | None = None) -> pl.Lp
         self.calculate_scores(score_subset=score_subset)
 
         for fold in self.folds:
-            add_bounds(lp_problem, fold.scores, self.fold_score_bounds, fold.identifier)
+            if self.fold_score_bounds is not None:
+                add_bounds(lp_problem, fold.scores, self.fold_score_bounds, fold.identifier)
 
         return lp_problem
 

mlscorecheck/aggregated/_experiment.py

@@ -46,7 +46,7 @@ def __init__(
             "n": sum(evaluation.figures["n"] for evaluation in self.evaluations),
         }
 
-        self.scores = None
+        self.scores: dict | None = None
 
     def to_dict(self) -> dict:
         """
@@ -115,6 +115,9 @@ def calculate_scores(
         elif self.aggregation == "mos":
             self.scores = dict_mean([evaluation.scores for evaluation in self.evaluations])
 
+        if self.scores is None:
+            return {}
+
         return (
             self.scores
             if rounding_decimals is None
@@ -143,12 +146,13 @@ def init_lp(self, lp_problem: pl.LpProblem, scores: dict | None = None) -> pl.Lp
         self.calculate_scores(score_subset=score_subset)
 
         for evaluation in self.evaluations:
-            add_bounds(
-                lp_problem,
-                evaluation.scores,
-                self.dataset_score_bounds,
-                evaluation.dataset.identifier,
-            )
+            if evaluation.scores is not None and self.dataset_score_bounds is not None:
+                add_bounds(
+                    lp_problem,
+                    evaluation.scores,
+                    self.dataset_score_bounds,
+                    evaluation.dataset.identifier,
+                )
 
         return lp_problem
 
@@ -186,11 +190,14 @@ def check_bounds(self, numerical_tolerance: float = NUMERICAL_TOLERANCE) -> dict
                 "scores": evaluation.scores,
                 "score_bounds": self.dataset_score_bounds,
             }
-            if self.dataset_score_bounds is not None:
+            if self.dataset_score_bounds is not None and evaluation.scores is not None:
                 tmp["bounds_flag"] = check_bounds(
                     evaluation.scores, self.dataset_score_bounds, numerical_tolerance
                 )
-                tmp["bounds_flag"] = tmp["bounds_flag"] and tmp["folds"]["bounds_flag"]
+                if tmp["folds"] is not None and isinstance(tmp["folds"], dict):
+                    tmp["bounds_flag"] = tmp["bounds_flag"] and tmp["folds"].get(
+                        "bounds_flag", True
+                    )
             else:
                 tmp["bounds_flag"] = tmp["folds"]
             results["evaluations"].append(tmp)

mlscorecheck/aggregated/_fold_enumeration.py

@@ -116,7 +116,9 @@ def not_enough_diverse_folds(p_values, n_values):
     )
 
 
-def determine_min_max_p(*, p, n, k_a, k_b, c_a, p_non_zero, n_non_zero):  # pylint: disable=too-many-locals
+def determine_min_max_p(
+    *, p, n, k_a, k_b, c_a, p_non_zero, n_non_zero
+):  # pylint: disable=too-many-locals
     """
     Determines the minimum and maximum number of positives that can appear in folds
     of type A
@@ -143,7 +145,9 @@ def determine_min_max_p(*, p, n, k_a, k_b, c_a, p_non_zero, n_non_zero):  # pyli
     return min_p_a, max_p_a
 
 
-def fold_partitioning_generator(*, p, n, k, p_non_zero=True, n_non_zero=True, p_min=-1):  # pylint: disable=invalid-name,too-many-locals
+def fold_partitioning_generator(
+    *, p, n, k, p_non_zero=True, n_non_zero=True, p_min=-1
+):  # pylint: disable=invalid-name,too-many-locals
     """
     Generates the fold partitioning
 
@@ -251,9 +255,13 @@ def kfolds_generator(evaluation: dict, available_scores: list, repeat_idx=0):
     Yields:
         list(dict): the list of fold specifications
     """
-    p, n = _check_specification_and_determine_p_n(
-        evaluation.get("dataset"), evaluation.get("folding")
-    )
+    dataset = evaluation.get("dataset")
+    folding = evaluation.get("folding")
+
+    if dataset is None or folding is None:
+        raise ValueError("Evaluation must have dataset and folding specifications")
+
+    p, n = _check_specification_and_determine_p_n(dataset, folding)
 
     p_zero = False
     n_zero = False
@@ -266,9 +274,9 @@ def kfolds_generator(evaluation: dict, available_scores: list, repeat_idx=0):
         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"]["identifier"] = (
-            f"{evaluation['dataset']['dataset_name']}_{random_identifier(3)}"
-        )
+        evaluation["dataset"][
+            "identifier"
+        ] = f"{evaluation['dataset']['dataset_name']}_{random_identifier(3)}"
     else:
         evaluation["dataset"]["identifier"] = random_identifier(6)
 

mlscorecheck/aggregated/_folding.py

@@ -38,7 +38,7 @@ def __init__(
             raise ValueError("specify strategy if folds are not set explicitly")
 
         self.n_folds = n_folds
-        self.n_repeats = n_repeats if n_repeats is not None else 1
+        self.n_repeats: int = n_repeats if n_repeats is not None else 1
         self.folds = folds
         self.strategy = strategy
 
@@ -77,9 +77,21 @@ def generate_folds(self, dataset: Dataset, aggregation: str) -> list:
                 p += fold["p"]
                 n += fold["n"]
 
-            term_a = (dataset.p != p) and (p % dataset.p != 0)
-            term_b = (dataset.n != n) and (n % dataset.n != 0)
-            term_c = dataset.p > 0 and dataset.n > 0 and (p // dataset.p != n // dataset.n)
+            term_a = (dataset.p is not None and dataset.p != p) and (
+                dataset.p != 0 and p % dataset.p != 0
+            )
+            term_b = (dataset.n is not None and dataset.n != n) and (
+                dataset.n != 0 and n % dataset.n != 0
+            )
+            term_c = (
+                dataset.p is not None
+                and dataset.n is not None
+                and dataset.p > 0
+                and dataset.n > 0
+                and dataset.p != 0
+                and dataset.n != 0
+                and (p // dataset.p != n // dataset.n)
+            )
 
             if term_a or term_b or term_c:
                 raise ValueError(

mlscorecheck/aggregated/_generate_problems.py

@@ -80,8 +80,13 @@ def generate_folding(
 
     strategies = ["stratified_sklearn"] if strategies is None else strategies
 
-    dataset = Dataset(**dataset)
-    p, n = dataset.p, dataset.n
+    dataset_obj = Dataset(**dataset)
+    p, n = dataset_obj.p, dataset_obj.n
+
+    # Ensure p and n are valid integers
+    if p is None or n is None:
+        raise ValueError("Dataset must have valid p and n values")
+
     max_folds = min(p, n, max_folds)
 
     n_folds = random_state.randint(1, max_folds + 1)
@@ -93,7 +98,7 @@ def generate_folding(
 
     folding = Folding(n_folds=n_folds, n_repeats=n_repeats, strategy=strategy)
 
-    return {"folds": [fold.to_dict() for fold in folding.generate_folds(dataset, "mos")]}
+    return {"folds": [fold.to_dict() for fold in folding.generate_folds(dataset_obj, "mos")]}
 
 
 def generate_evaluation(  # pylint: disable=too-many-locals
@@ -111,7 +116,7 @@ def generate_evaluation(  # pylint: disable=too-many-locals
     no_name: bool = False,
     no_folds: bool = False,
     score_subset: list | None = None,
-) -> dict:
+) -> dict | tuple[dict, dict]:
     """
     Generate a random evaluation specification
 
@@ -212,7 +217,7 @@ def generate_experiment(
     *,
     max_evaluations: int = 5,
     evaluation_params: dict | None = None,
-    feasible_dataset_score_bounds: bool = None,
+    feasible_dataset_score_bounds: bool | None = None,
     aggregation: str | None = None,
     random_state=None,
     return_scores: bool = False,

mlscorecheck/aggregated/_utils.py

@@ -26,7 +26,7 @@ def random_identifier(length: int):
     return "".join(random.choice(letters) for _ in range(length))
 
 
-def check_bounds(scores: dict, bounds: dict | None = None, tolerance: float = 1e-5) -> bool:
+def check_bounds(scores: dict, bounds: dict | None = None, tolerance: float = 1e-5) -> bool | None:
     """
     Checks the bounds for the scores
 

mlscorecheck/check/binary/_check_1_dataset_unknown_folds_mos.py

@@ -25,15 +25,15 @@ def estimate_n_evaluations(
     Returns:
         int: the estimated number of different fold configurations.
     """
-    dataset = Dataset(**dataset)
+    dataset_obj = Dataset(**dataset)
     n_repeats = folding.get("n_repeats", 1)
 
     available_scores = [] if available_scores is None else available_scores
 
     count = sum(
         1
         for _ in kfolds_generator(
-            {"dataset": dataset.to_dict(), "folding": folding}, available_scores
+            {"dataset": dataset_obj.to_dict(), "folding": folding}, available_scores
         )
     )
 

mlscorecheck/check/binary/_check_1_testset_no_kfold.py

@@ -118,6 +118,9 @@ def check_1_testset_no_kfold(
         p = dataset_statistics[testset["name"]]["p"]
         n = dataset_statistics[testset["name"]]["n"]
 
+    if p is None or n is None:
+        raise ValueError("Testset must have valid p and n values")
+
     logger.info(
         "calling the score check with scores %s, uncertainty %s, p %d and n %d",
         str(scores),

mlscorecheck/check/binary/_check_n_datasets_mos_unknown_folds_mos.py

@@ -41,7 +41,7 @@ def estimate_n_experiments(evaluations: list, available_scores: list | None = No
         )
         for evaluation in evaluations
     ]
-    return np.prod(counts)
+    return int(np.prod(counts))
 
 
 def check_n_datasets_mos_unknown_folds_mos(