deps: bump the python-dependencies group with 23 updates

src/ml4t/engineer/config/base.py

@@ -190,9 +190,10 @@ def validate_fully(self) -> list[str]:
             return []
         except Exception as e:
             # Parse validation errors from Pydantic
-            if hasattr(e, "errors") and callable(getattr(e, "errors", None)):
+            errors_method = getattr(e, "errors", None)
+            if callable(errors_method):
                 errors = []
-                for error in e.errors():  # type: ignore[operator]
+                for error in errors_method():
                     loc = ".".join(str(x) for x in error["loc"])
                     msg = error["msg"]
                     errors.append(f"{loc}: {msg}")

src/ml4t/engineer/dataset.py

@@ -47,7 +47,7 @@
 
 from collections.abc import Generator, Iterator
 from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Any, Protocol
+from typing import TYPE_CHECKING, Any, Protocol, cast
 
 import numpy as np
 import polars as pl
@@ -274,8 +274,9 @@ def set_scaler(self, scaler: BaseScaler | PreprocessingConfig | None) -> MLDatas
         >>> builder.set_scaler(PreprocessingConfig.robust())
         """
         # Handle PreprocessingConfig by creating the scaler
-        if hasattr(scaler, "create_scaler"):
-            self._scaler = scaler.create_scaler()  # type: ignore[union-attr]
+        create_scaler = getattr(scaler, "create_scaler", None)
+        if callable(create_scaler):
+            self._scaler = cast("BaseScaler | None", create_scaler())
         else:
             self._scaler = scaler
         return self

src/ml4t/engineer/features/ml/percentile_rank_features.py

@@ -72,9 +72,11 @@ def percentile_rank_features(
         # Count how many close in the window are less than or equal to current value
         # This properly calculates percentile rank within each rolling window
         rank = feature.rolling_map(
-            lambda x: ((x[-1] > x[:-1]).sum() + 0.5 * (x[-1] == x[:-1]).sum()) / len(x) * 100
-            if len(x) > 0
-            else None,
+            lambda x: (
+                ((x[-1] > x[:-1]).sum() + 0.5 * (x[-1] == x[:-1]).sum()) / len(x) * 100
+                if len(x) > 0
+                else None
+            ),
             window_size=window,
         )
         ranks[f"rank_{window}"] = rank

src/ml4t/engineer/features/utils/ma_types.py

@@ -4,8 +4,6 @@
 Maps TA-Lib MA type codes to ml4t.engineer implementations.
 """
 
-from typing import cast
-
 import numpy as np
 import numpy.typing as npt
 
@@ -64,27 +62,27 @@ def apply_ma(
     beyond period. Use KAMA (matype=6) as an adaptive alternative.
     """
     if matype == 0:
-        return cast(NDArrayFloat, sma_numba(close, period))
+        return sma_numba(close, period)
     elif matype == 1:
-        return cast(NDArrayFloat, ema_numba(close, period))
+        return ema_numba(close, period)
     elif matype == 2:
-        return cast(NDArrayFloat, wma_numba(close, period))
+        return wma_numba(close, period)
     elif matype == 3:
-        return cast(NDArrayFloat, dema_numba(close, period))
+        return dema_numba(close, period)
     elif matype == 4:
-        return cast(NDArrayFloat, tema_numba(close, period))
+        return tema_numba(close, period)
     elif matype == 5:
-        return cast(NDArrayFloat, trima_numba(close, period))
+        return trima_numba(close, period)
     elif matype == 6:
-        return cast(NDArrayFloat, kama_numba(close, timeperiod=period))
+        return kama_numba(close, timeperiod=period)
     elif matype == 7:
         raise ValueError(
             "MAMA (matype=7) is not supported. "
             "MAMA requires additional parameters (fastlimit, slowlimit). "
             "Use KAMA (matype=6) as an adaptive alternative."
         )
     elif matype == 8:
-        return cast(NDArrayFloat, t3_numba(close, period))
+        return t3_numba(close, period)
     else:
         raise ValueError(
             f"Invalid matype={matype}. Must be 0-8 (excluding 7). See docstring for valid MA types."

src/ml4t/engineer/features/volatility/volatility_percentile_rank.py

@@ -64,9 +64,11 @@ def volatility_percentile_rank(
     # Calculate rolling percentile rank
     # Use rolling_map to properly calculate percentile rank within each lookback window
     rank = vol.rolling_map(
-        lambda x: ((x[-1] > x[:-1]).sum() + 0.5 * (x[-1] == x[:-1]).sum()) / len(x) * 100
-        if len(x) > 0
-        else None,
+        lambda x: (
+            ((x[-1] > x[:-1]).sum() + 0.5 * (x[-1] == x[:-1]).sum()) / len(x) * 100
+            if len(x) > 0
+            else None
+        ),
         window_size=lookback,
     )
 

src/ml4t/engineer/preprocessing.py

@@ -29,13 +29,13 @@
 from __future__ import annotations
 
 from abc import ABC, abstractmethod
-from enum import Enum
+from enum import StrEnum
 from typing import Any
 
 import polars as pl
 
 
-class ScalerMethod(str, Enum):
+class ScalerMethod(StrEnum):
     """Scaling method options."""
 
     STANDARD = "standard"  # Z-score: (x - mean) / std
@@ -489,7 +489,7 @@ def _apply_transform(self, X: pl.DataFrame) -> pl.DataFrame:
 # =============================================================================
 
 
-class TransformType(str, Enum):
+class TransformType(StrEnum):
     """Transform types supported by PreprocessingPipeline.
 
     These align with ml4t.diagnostic.integration.engineer_contract.TransformType.