Fix ruff errors

Author: Ludecan

Diff for: .vscode/settings.json

@@ -26,7 +26,6 @@
     "files.trimTrailingWhitespace": true,
     "jupyter.notebookFileRoot": "${workspaceFolder}",
     "jupyter.interactiveWindow.textEditor.executeSelection": true,
-    "jupyter.generateSVGPlots": true,
     "autoDocstring.docstringFormat": "numpy",
     "python.testing.pytestArgs": [
         "tests"
@@ -39,7 +38,5 @@
     "ruff.organizeImports": true,
     "ruff.fixAll": true,
     "ruff.importStrategy": "fromEnvironment",
-    "ruff.lint.run": "onSave",
-    "python.linting.enabled": false,
-    "python.linting.pylintEnabled": false
+    "ruff.lint.run": "onSave"
 }

Diff for: ml_garden/core/data_container.py

@@ -721,7 +721,7 @@ def predict_proba(self) -> pd.DataFrame:
         return self["predict_proba"]
 
     @predict_proba.setter
-    def predict_proba(self, value: pd.DataFrame):
+    def predict_proba(self, value: pd.DataFrame) -> None:
         """
         Set the prediction probabilities in the DataContainer.
 

Diff for: ml_garden/core/model.py

@@ -1,5 +1,5 @@
 from abc import ABC, abstractmethod
-from typing import List, Optional, Tuple
+from typing import Optional
 
 import pandas as pd
 
@@ -11,14 +11,14 @@
 class Model(ABC):
     """Base class for models."""
 
-    TASKS: List[Task] = []
+    TASKS: list[Task] = []
 
     @abstractmethod
     def fit(
         self,
         X: pd.DataFrame,
         y: pd.Series,
-        eval_set: Optional[List[Tuple[pd.DataFrame, pd.Series]]] = None,
+        eval_set: Optional[list[tuple[pd.DataFrame, pd.Series]]] = None,
         *,
         verbose: Optional[bool] = True,
     ) -> None:
@@ -28,6 +28,7 @@ def fit(
     def predict(self, X: pd.DataFrame) -> pd.Series:
         """Abstract method for making predictions."""
 
+    @abstractmethod
     def predict_proba(self, X: pd.DataFrame) -> pd.DataFrame:
         """
         Predict class probabilities with the trained model.
@@ -42,4 +43,3 @@ def predict_proba(self, X: pd.DataFrame) -> pd.DataFrame:
         pd.DataFrame
             Predicted class probabilities for the input features.
         """
-        pass

Diff for: ml_garden/core/model_registry.py

@@ -1,7 +1,6 @@
 import importlib
 import logging
 import pkgutil
-from typing import Dict, Type
 
 from ml_garden.core.model import Model
 
@@ -13,7 +12,7 @@ class ModelClassNotFoundError(Exception):
 
 
 class ModelRegistry:
-    def __init__(self):
+    def __init__(self) -> None:
         """
         Initialize a new ModelRegistry instance.
 
@@ -24,16 +23,16 @@ def __init__(self):
         logger : logging.Logger
             Logger for the class.
         """
-        self._model_registry: Dict[str, Type[Model]] = {}
+        self._model_registry: dict[str, type[Model]] = {}
         self.logger = logging.getLogger(__name__)
 
-    def register_model(self, model_class: Type[Model]) -> None:
+    def register_model(self, model_class: type[Model]) -> None:
         """
         Register a model class in the registry.
 
         Parameters
         ----------
-        model_class : Type[Model]
+        model_class : type[Model]
             The model class to be registered.
 
         Raises
@@ -48,7 +47,7 @@ def register_model(self, model_class: Type[Model]) -> None:
             raise TypeError(error_message)
         self._model_registry[model_name] = model_class
 
-    def get_model_class(self, model_name: str) -> Type[Model]:
+    def get_model_class(self, model_name: str) -> type[Model]:
         """
         Retrieve a model class from the registry.
 
@@ -59,7 +58,7 @@ def get_model_class(self, model_name: str) -> Type[Model]:
 
         Returns
         -------
-        Type[Model]
+        type[Model]
             The model class.
 
         Raises
@@ -78,7 +77,7 @@ def get_model_class(self, model_name: str) -> Type[Model]:
             self.logger.exception(error_message)
             raise ModelClassNotFoundError(error_message)
 
-    def get_all_model_classes(self) -> Dict[str, Type[Model]]:
+    def get_all_model_classes(self) -> dict[str, type[Model]]:
         """
         Get all registered model classes.
 
@@ -106,7 +105,7 @@ def auto_register_models_from_package(self, package_name: str) -> None:
         try:
             package = importlib.import_module(package_name)
             prefix = package.__name__ + "."
-            for importer, modname, ispkg in pkgutil.walk_packages(package.__path__, prefix):
+            for _importer, modname, _ispkg in pkgutil.walk_packages(package.__path__, prefix):
                 module = importlib.import_module(modname)
                 for name in dir(module):
                     attribute = getattr(module, name)

Diff for: ml_garden/core/steps/calculate_features.py

@@ -1,6 +1,6 @@
 """Calculate datetime-related features from specified columns."""
 
-from typing import List, Optional, Union
+from typing import Optional, Union
 
 import pandas as pd
 from pandas.api.types import is_datetime64_any_dtype
@@ -21,8 +21,8 @@ class CalculateFeaturesStep(PipelineStep):
 
     def __init__(
         self,
-        datetime_columns: Optional[Union[List[str], str]] = None,
-        features: Optional[List[str]] = None,
+        datetime_columns: Optional[Union[list[str], str]] = None,
+        features: Optional[list[str]] = None,
     ) -> None:
         """Initialize CalculateFeaturesStep.
 
@@ -93,10 +93,10 @@ def _convert_column_to_datetime(self, df: pd.DataFrame, column: str, log: bool)
                 )
                 if log:
                     self.logger.info(f"Column '{column}' automatically converted to datetime.")
-            except ValueError as e:
-                self.logger.error(f"Error converting column '{column}' to datetime: {e}")
-            except Exception as e:
-                self.logger.error(f"Unexpected error converting column '{column}' to datetime: {e}")
+            except ValueError:
+                self.logger.exception(f"Error converting column '{column}' to datetime")
+            except Exception:
+                self.logger.exception(f"Unexpected error converting column '{column}' to datetime")
         elif log:
             self.logger.debug(f"Column '{column}' is already a datetime type.")
         return df
@@ -162,9 +162,9 @@ def execute(self, data: DataContainer) -> DataContainer:
 
         for attr_name, dataset, should_log in datasets:
             if dataset is not None:
-                dataset = self._create_datetime_features(dataset, log=should_log)
-                dataset = self._drop_datetime_columns(dataset, log=should_log)
-                setattr(data, attr_name, dataset)
+                ds = self._create_datetime_features(dataset, log=should_log)
+                ds = self._drop_datetime_columns(ds, log=should_log)
+                setattr(data, attr_name, ds)
 
         return data
 

Diff for: ml_garden/core/steps/calculate_metrics.py

@@ -1,7 +1,7 @@
 """Calculate metrics for regression and classification tasks."""
 
 import json
-from typing import Dict, List, TypedDict, Union
+from typing import TypedDict, Union
 
 import numpy as np
 import pandas as pd
@@ -55,16 +55,16 @@ class ClassificationMetrics(TypedDict):
     """Classification metrics."""
 
     Overall: ClassificationOverallMetrics
-    Per_Class: Dict[str, ClassMetrics]
-    Confusion_Matrix: List[List[int]]
+    Per_Class: dict[str, ClassMetrics]
+    Confusion_Matrix: list[list[int]]
 
 
 class DatasetMetrics(TypedDict):
     """Dataset metrics."""
 
-    train: Dict[str, Union[RegressionMetrics, ClassificationMetrics]]
-    validation: Dict[str, Union[RegressionMetrics, ClassificationMetrics]]
-    test: Dict[str, Union[RegressionMetrics, ClassificationMetrics]]
+    train: dict[str, Union[RegressionMetrics, ClassificationMetrics]]
+    validation: dict[str, Union[RegressionMetrics, ClassificationMetrics]]
+    test: dict[str, Union[RegressionMetrics, ClassificationMetrics]]
 
 
 class CalculateMetricsStep(PipelineStep):
@@ -213,7 +213,7 @@ def execute(self, data: DataContainer) -> DataContainer:
         """
         self.logger.debug("Starting metric calculation")
 
-        metrics: Dict[str, Union[RegressionMetrics, ClassificationMetrics]] = {}
+        metrics: dict[str, Union[RegressionMetrics, ClassificationMetrics]] = {}
 
         if data.is_train:
             for dataset_name in ["train", "validation", "test"]:

Diff for: ml_garden/core/steps/encode.py

@@ -1,5 +1,5 @@
 import json
-from typing import Any, Dict, List, Optional, Tuple, Type, Union
+from typing import Any, Optional, Union
 
 import numpy as np
 import pandas as pd
@@ -102,13 +102,13 @@ def _apply_encoding(
         self,
         X: pd.DataFrame,
         y: Optional[pd.Series],
-        categorical_features: List[str],
-        numeric_features: List[str],
+        categorical_features: list[str],
+        numeric_features: list[str],
         saved_encoder: Optional[ColumnTransformer] = None,
         *,
         fit_encoders: bool = False,
         log: Optional[bool] = False,
-    ) -> Tuple[pd.DataFrame, Optional[pd.Series], Optional[ColumnTransformer]]:
+    ) -> tuple[pd.DataFrame, Optional[pd.Series], Optional[ColumnTransformer]]:
         """Apply the encoding to the data.
 
         Parameters
@@ -117,9 +117,9 @@ def _apply_encoding(
             The DataFrame with features to encode
         y : pd.Series, optional
             The target series. If provided, the target column will be encoded, by default None
-        categorical_features : List[str]
+        categorical_features : list[str]
             Categorical features
-        numeric_features : List[str]
+        numeric_features : list[str]
             Numeric features
         fit_encoders : bool, optional
             Whether to fit the encoders, by default False
@@ -130,7 +130,7 @@ def _apply_encoding(
 
         Returns
         -------
-        Tuple[pd.DataFrame, Optional[pd.Series], Optional[ColumnTransformer]]
+        tuple[pd.DataFrame, Optional[pd.Series], Optional[ColumnTransformer]]
             The encoded data, the target column, and the encoder
         """
         if not fit_encoders and not saved_encoder:
@@ -182,7 +182,7 @@ def _apply_encoding(
 
         return encoded_data, targets, encoder
 
-    def _get_feature_types(self, X: pd.DataFrame) -> Tuple[List[str], List[str]]:
+    def _get_feature_types(self, X: pd.DataFrame) -> tuple[list[str], list[str]]:
         """Get categorical and numeric feature lists.
 
         Parameters
@@ -192,7 +192,7 @@ def _get_feature_types(self, X: pd.DataFrame) -> Tuple[List[str], List[str]]:
 
         Returns
         -------
-        Tuple[List[str], List[str]]
+        tuple[list[str], list[str]]
             Categorical and numeric features
         """
         categorical_features = [col for col in X.columns if X[col].dtype in ["object", "category"]]
@@ -201,8 +201,8 @@ def _get_feature_types(self, X: pd.DataFrame) -> Tuple[List[str], List[str]]:
         return categorical_features, numeric_features
 
     def _split_categorical_features(
-        self, df: pd.DataFrame, categorical_features: List[str]
-    ) -> Tuple[List[str], List[str]]:
+        self, df: pd.DataFrame, categorical_features: list[str]
+    ) -> tuple[list[str], list[str]]:
         """Split categorical features into low and high cardinality features."""
         low_cardinality_features = [
             col for col in categorical_features if df[col].nunique() <= self.cardinality_threshold
@@ -214,7 +214,7 @@ def _split_categorical_features(
 
     def _get_encoder_class_and_params(
         self, encoder_name: str
-    ) -> Tuple[Union[Type[OrdinalEncoder], Type[TargetEncoder]], dict[str, Any]]:
+    ) -> tuple[Union[type[OrdinalEncoder], type[TargetEncoder]], dict[str, Any]]:
         """Map encoder name to the corresponding encoder class."""
         encoder = self.ENCODER_MAP.get(encoder_name)
         encoder_params = self.ENCODER_MAP_PARAMS.get(encoder_name)
@@ -230,9 +230,9 @@ def _get_encoder_class_and_params(
     def _log_encoder_override(
         self,
         feature: str,
-        encoder_class: Type[Union[OrdinalEncoder, TargetEncoder]],
-        high_cardinality_features: List[str],
-        low_cardinality_features: List[str],
+        encoder_class: type[Union[OrdinalEncoder, TargetEncoder]],
+        high_cardinality_features: list[str],
+        low_cardinality_features: list[str],
     ) -> None:
         if feature in high_cardinality_features:
             self.logger.info(
@@ -257,9 +257,9 @@ def _log_encoder_override(
 
     def _create_column_transformer(
         self,
-        high_cardinality_features: List[str],
-        low_cardinality_features: List[str],
-        numeric_features: List[str],
+        high_cardinality_features: list[str],
+        low_cardinality_features: list[str],
+        numeric_features: list[str],
     ) -> ColumnTransformer:
         """Create a ColumnTransformer for encoding."""
         transformers = []
@@ -345,7 +345,7 @@ def _restore_column_order(self, df: pd.DataFrame, encoded_data: pd.DataFrame) ->
         return encoded_data[new_column_order]
 
     def _convert_ordinal_encoded_columns_to_int(
-        self, encoded_data: pd.DataFrame, encoded_feature_map: Dict[str, str]
+        self, encoded_data: pd.DataFrame, encoded_feature_map: dict[str, str]
     ) -> pd.DataFrame:
         """Convert ordinal encoded columns to the smallest possible integer dtype."""
         ordinal_encoded_features = [
@@ -361,7 +361,7 @@ def _convert_ordinal_encoded_columns_to_int(
                     # since instead of raising the error and being converted to "integer" in the
                     # except, it will remain as a float64 silenty.
                     if (encoded_data[col] <= 0).any():
-                        raise ValueError("Column contains negative values.")
+                        raise ValueError("Column contains negative values.")  # noqa: TRY301, EM101
                     encoded_data[col] = pd.to_numeric(encoded_data[col].values, downcast="unsigned")
                 except ValueError:
                     try:
@@ -401,7 +401,7 @@ def _convert_float64_to_float32(self, encoded_data: pd.DataFrame) -> pd.DataFram
             encoded_data[col] = encoded_data[col].astype(np.float32)
         return encoded_data
 
-    def _create_feature_encoder_map(self, column_transformer: ColumnTransformer) -> Dict[str, str]:
+    def _create_feature_encoder_map(self, column_transformer: ColumnTransformer) -> dict[str, str]:
         """Create a dictionary to store the encoder used for each feature."""
         feature_encoder_map = {}
         transformed_features = column_transformer.get_feature_names_out()
@@ -419,11 +419,11 @@ def _create_feature_encoder_map(self, column_transformer: ColumnTransformer) ->
 
     def _log_feature_info(
         self,
-        categorical_features: List[str],
-        numeric_features: List[str],
-        low_cardinality_features: List[str],
-        high_cardinality_features: List[str],
-        feature_encoder_map: Dict[str, str],
+        categorical_features: list[str],
+        numeric_features: list[str],
+        low_cardinality_features: list[str],
+        high_cardinality_features: list[str],
+        feature_encoder_map: dict[str, str],
     ) -> None:
         """Log information about the features."""
         self.logger.info(