eb-features 0.2.4__tar.gz → 0.2.7__tar.gz

{eb_features-0.2.4 → eb_features-0.2.7}/LICENSE

@@ -1,6 +1,6 @@
 BSD 3-Clause License
 
-Copyright (c) 2025, Kyle Corrie
+Copyright (c) 2026, Kyle Corrie
 
 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions are met:

{eb_features-0.2.4/src/eb_features.egg-info → eb_features-0.2.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: eb-features
-Version: 0.2.4
+Version: 0.2.7
 Summary: Feature engineering utilities for panel time-series data in the Electric Barometer ecosystem.
 Author-email: "Kyle Corrie (Economistician)" <kcorrie@economistician.com>
 License-Expression: BSD-3-Clause
@@ -9,25 +9,29 @@ Project-URL: Repository, https://github.com/Economistician/eb-features
 Project-URL: Issues, https://github.com/Economistician/eb-features/issues
 Project-URL: Documentation, https://economistician.github.io/eb-docs/
 Keywords: forecasting,features,feature-engineering,time-series,panel-data,operations-research
-Classifier: Development Status :: 3 - Alpha
+Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Science/Research
 Classifier: Intended Audience :: Developers
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Operating System :: OS Independent
 Classifier: Topic :: Scientific/Engineering
-Requires-Python: >=3.10
+Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: numpy>=1.24
 Requires-Dist: pandas>=2.0
+Provides-Extra: test
+Requires-Dist: pytest>=8.0; extra == "test"
 Provides-Extra: dev
 Requires-Dist: pytest>=8.0; extra == "dev"
 Requires-Dist: pytest-cov>=5.0; extra == "dev"
+Provides-Extra: all
+Requires-Dist: pytest>=8.0; extra == "all"
+Requires-Dist: pytest-cov>=5.0; extra == "all"
 Dynamic: license-file
 
 # Electric Barometer · Features (`eb-features`)
@@ -43,19 +47,7 @@ Feature engineering primitives for panel-based forecasting systems, designed to
 
 ## Overview
 
-`eb-features` is a modular feature engineering library for panel-based forecasting systems. It provides reusable, deterministic transformations for constructing time-aware features across entities observed over time.
-
-Within the Electric Barometer ecosystem, `eb-features` serves as the upstream feature construction layer, producing standardized inputs for downstream evaluation and metric components. While designed to integrate seamlessly with Electric Barometer, the package remains framework-agnostic and can be used independently in other forecasting workflows.
-
----
-
-## Role in the Electric Barometer Ecosystem
-
-`eb-features` defines the feature engineering primitives used throughout the Electric Barometer ecosystem. It is responsible for constructing deterministic, panel-aware input features—such as lags, rolling aggregations, and calendar encodings—that serve as the foundational inputs to forecasting and evaluation workflows.
-
-This package focuses exclusively on feature construction and validation. It does not perform model training, forecast generation, metric evaluation, or decision logic. Those responsibilities are handled by downstream layers in the ecosystem that consume engineered features for modeling, selection, and operational assessment.
-
-By separating feature semantics from modeling and evaluation concerns, `eb-features` provides a stable, reusable foundation that ensures consistency and reproducibility across forecasting pipelines operating on heterogeneous panel data.
+`eb-features` builds deterministic, panel-aware forecasting features (lags, rolling aggregates, calendar encodings) with explicit entity and time boundaries. It does not train models or evaluate forecasts.
 
 ---
 
@@ -67,7 +59,7 @@ By separating feature semantics from modeling and evaluation concerns, `eb-featu
 pip install eb-features
 ```
 
-The package supports Python 3.10 and later.
+The package supports Python 3.11 and later.
 
 ---
 
@@ -87,34 +79,33 @@ The example below shows how to construct lagged and rolling features for panel d
 
 ```python
 import pandas as pd
-from eb_features.panel.lags import add_lag_features
-from eb_features.panel.rolling import add_rolling_features
+from eb_features import add_lag_features, add_rolling_features
 
-# Example panel data
 df = pd.DataFrame({
-    "entity_id": ["A", "A", "A", "B", "B"],
-    "date": pd.date_range("2024-01-01", periods=5, freq="D"),
-    "y": [10, 12, 11, 7, 9],
+    "entity_id": ["A", "A", "A", "A", "B", "B", "B", "B"],
+    "date": pd.to_datetime(
+        ["2024-01-01", "2024-01-02", "2024-01-03", "2024-01-04"] * 2
+    ),
+    "y": [10, 12, 11, 13, 7, 9, 8, 10],
 })
+df = df.sort_values(["entity_id", "date"], kind="mergesort")
 
-# Add lagged features
-df = add_lag_features(
+df, lag_cols = add_lag_features(
     df,
-    value_col="y",
-    lags=[1, 2],
     entity_col="entity_id",
-    time_col="date",
+    target_col="y",
+    lag_steps=[1, 2],
 )
 
-# Add rolling features
-df = add_rolling_features(
+df, roll_cols = add_rolling_features(
     df,
-    value_col="y",
-    windows=[3],
     entity_col="entity_id",
-    time_col="date",
+    target_col="y",
+    rolling_windows=[3],
+    rolling_stats=["mean"],
 )
 
+print(lag_cols, roll_cols)
 print(df)
 ```
 
@@ -122,7 +113,7 @@ print(df)
 
 ## License
 
-BSD 3-Clause License.  
-© 2025 Kyle Corrie.
+BSD 3-Clause License.
+© 2026 Kyle Corrie.
 
 <!-- Trusted publishing verification -->

eb_features-0.2.7/README.md

@@ -0,0 +1,83 @@
+# Electric Barometer · Features (`eb-features`)
+
+[![CI](https://github.com/Economistician/eb-features/actions/workflows/ci.yml/badge.svg)](https://github.com/Economistician/eb-features/actions/workflows/ci.yml)
+![License: BSD-3-Clause](https://img.shields.io/badge/License-BSD_3--Clause-blue.svg)
+![Python Versions](https://img.shields.io/pypi/pyversions/eb-features)
+![PyPI](https://img.shields.io/pypi/v/eb-features)
+
+Feature engineering primitives for panel-based forecasting systems, designed to integrate seamlessly with the Electric Barometer ecosystem.
+
+---
+
+## Overview
+
+`eb-features` builds deterministic, panel-aware forecasting features (lags, rolling aggregates, calendar encodings) with explicit entity and time boundaries. It does not train models or evaluate forecasts.
+
+---
+
+## Installation
+
+`eb-features` is distributed as a standard Python package.
+
+```bash
+pip install eb-features
+```
+
+The package supports Python 3.11 and later.
+
+---
+
+## Core Concepts
+
+- **Panel-aware feature construction** — Features are constructed with explicit awareness of entity boundaries and temporal ordering, ensuring correctness in multi-entity forecasting settings.
+- **Deterministic transformations** — Feature generation is designed to be reproducible and free of stochastic behavior, supporting auditability and consistent downstream evaluation.
+- **Temporal causality** — All features respect time directionality, preventing information leakage from future observations into historical feature sets.
+- **Rolling and lag semantics** — Common forecasting features such as lags and rolling aggregates are treated as first-class primitives with clear, well-defined behavior.
+- **Validation by construction** — Feature pipelines include explicit checks and constraints to ensure structural validity before model training or evaluation.
+
+---
+
+## Minimal Example
+
+The example below shows how to construct lagged and rolling features for panel data while preserving entity boundaries and temporal ordering.
+
+```python
+import pandas as pd
+from eb_features import add_lag_features, add_rolling_features
+
+df = pd.DataFrame({
+    "entity_id": ["A", "A", "A", "A", "B", "B", "B", "B"],
+    "date": pd.to_datetime(
+        ["2024-01-01", "2024-01-02", "2024-01-03", "2024-01-04"] * 2
+    ),
+    "y": [10, 12, 11, 13, 7, 9, 8, 10],
+})
+df = df.sort_values(["entity_id", "date"], kind="mergesort")
+
+df, lag_cols = add_lag_features(
+    df,
+    entity_col="entity_id",
+    target_col="y",
+    lag_steps=[1, 2],
+)
+
+df, roll_cols = add_rolling_features(
+    df,
+    entity_col="entity_id",
+    target_col="y",
+    rolling_windows=[3],
+    rolling_stats=["mean"],
+)
+
+print(lag_cols, roll_cols)
+print(df)
+```
+
+---
+
+## License
+
+BSD 3-Clause License.
+© 2026 Kyle Corrie.
+
+<!-- Trusted publishing verification -->

{eb_features-0.2.4 → eb_features-0.2.7}/pyproject.toml

@@ -3,10 +3,10 @@
 ######################################
 [project]
 name = "eb-features"
-version = "0.2.4"
+version = "0.2.7"
 description = "Feature engineering utilities for panel time-series data in the Electric Barometer ecosystem."
 readme = "README.md"
-requires-python = ">=3.10"
+requires-python = ">=3.11"
 license = "BSD-3-Clause"
 license-files = ["LICENSE*"]
 
@@ -17,12 +17,11 @@ authors = [
 keywords = ["forecasting", "features", "feature-engineering", "time-series", "panel-data", "operations-research"]
 
 classifiers = [
-  "Development Status :: 3 - Alpha",
+  "Development Status :: 5 - Production/Stable",
   "Intended Audience :: Science/Research",
   "Intended Audience :: Developers",
   "Programming Language :: Python :: 3",
   "Programming Language :: Python :: 3 :: Only",
-  "Programming Language :: Python :: 3.10",
   "Programming Language :: Python :: 3.11",
   "Programming Language :: Python :: 3.12",
   "Programming Language :: Python :: 3.13",
@@ -52,11 +51,22 @@ Documentation = "https://economistician.github.io/eb-docs/"
 ######################################
 [project.optional-dependencies]
 
+test = [
+  "pytest>=8.0",
+]
+
 dev = [
   "pytest>=8.0",
   "pytest-cov>=5.0",
 ]
 
+# Standardized anchor to satisfy the "extras: all" CI contract.
+# Aggregates dev and test dependencies for the Hub runner.
+all = [
+  "pytest>=8.0",
+  "pytest-cov>=5.0",
+]
+
 ######################################
 # Build system
 ######################################
@@ -73,10 +83,13 @@ package-dir = {"" = "src"}
 [tool.setuptools.packages.find]
 where = ["src"]
 
+[tool.setuptools.package-data]
+eb_features = ["py.typed"]
+
 ######################################
 # Pytest configuration
 ######################################
 [tool.pytest.ini_options]
 pythonpath = ["src"]
 addopts = "-ra"
-testpaths = ["tests"]
+testpaths = ["tests"]

eb_features-0.2.7/src/eb_features/__init__.py

@@ -0,0 +1,46 @@
+"""
+Feature engineering utilities for the Electric Barometer ecosystem.
+
+This package provides modular, domain-agnostic feature engineering components
+used across forecasting, evaluation, and operational modeling workflows.
+
+The recommended import path is the package root, for example
+``from eb_features import FeatureConfig, FeatureEngineer, add_lag_features``.
+"""
+
+from __future__ import annotations
+
+from importlib.metadata import PackageNotFoundError, version
+
+from eb_features.panel.calendar import add_calendar_features
+from eb_features.panel.engineering import FeatureConfig, FeatureEngineer
+from eb_features.panel.lags import add_lag_features
+from eb_features.panel.rolling import add_rolling_features
+
+
+def _resolve_version() -> str:
+    """
+    Resolve the installed package version.
+
+    Returns
+    -------
+    str
+        Installed version string. If the package is not installed (e.g., running
+        from source without installation), returns ``"0.0.0"``.
+    """
+    try:
+        return version("eb-features")
+    except PackageNotFoundError:
+        return "0.0.0"
+
+
+__version__ = _resolve_version()
+
+__all__ = [
+    "FeatureConfig",
+    "FeatureEngineer",
+    "__version__",
+    "add_calendar_features",
+    "add_lag_features",
+    "add_rolling_features",
+]

{eb_features-0.2.4 → eb_features-0.2.7}/src/eb_features/panel/__init__.py

@@ -1,5 +1,3 @@
-from __future__ import annotations
-
 """
 Panel time-series feature engineering.
 
@@ -34,9 +32,33 @@ See Also
 - [`eb_features.panel.engineering.FeatureConfig`][eb_features.panel.engineering.FeatureConfig]
 """
 
+from __future__ import annotations
+
+from eb_features.panel.calendar import add_calendar_features
+from eb_features.panel.constants import (
+    ALLOWED_CALENDAR_FEATURES,
+    ALLOWED_ROLLING_STATS,
+    DEFAULT_CALENDAR_FEATURES,
+    DEFAULT_LAG_STEPS,
+    DEFAULT_ROLLING_STATS,
+    DEFAULT_ROLLING_WINDOWS,
+)
+from eb_features.panel.encoders import encode_non_numeric_as_category_codes
 from eb_features.panel.engineering import FeatureConfig, FeatureEngineer
+from eb_features.panel.lags import add_lag_features
+from eb_features.panel.rolling import add_rolling_features
 
 __all__ = [
+    "ALLOWED_CALENDAR_FEATURES",
+    "ALLOWED_ROLLING_STATS",
+    "DEFAULT_CALENDAR_FEATURES",
+    "DEFAULT_LAG_STEPS",
+    "DEFAULT_ROLLING_STATS",
+    "DEFAULT_ROLLING_WINDOWS",
     "FeatureConfig",
     "FeatureEngineer",
-]
+    "add_calendar_features",
+    "add_lag_features",
+    "add_rolling_features",
+    "encode_non_numeric_as_category_codes",
+]

{eb_features-0.2.4 → eb_features-0.2.7}/src/eb_features/panel/calendar.py

@@ -1,10 +1,8 @@
-from __future__ import annotations
-
 r"""
 Calendar and time-derived features for panel time series.
 
 This module provides utilities to derive calendar/time features from a timestamp column.
-It is designed for *panel* time-series data (entity × timestamp) and is typically used
+It is designed for *panel* time-series data (entity-by-timestamp) and is typically used
 as part of a broader feature engineering pipeline.
 
 Supported base calendar features
@@ -47,7 +45,9 @@ Notes
   representation as stored in the column.
 """
 
-from typing import Iterable, List, Sequence, Tuple
+from __future__ import annotations
+
+from collections.abc import Iterable, Sequence
 
 import numpy as np
 import pandas as pd
@@ -58,6 +58,7 @@ from eb_features.panel.constants import (
     HOUR_PERIOD,
     WEEKEND_DAYS,
 )
+from eb_features.panel.validation import ensure_entity_time_order, infer_panel_entity_col
 
 
 def add_calendar_features(
@@ -66,7 +67,7 @@ def add_calendar_features(
     timestamp_col: str,
     calendar_features: Sequence[str],
     use_cyclical_time: bool = True,
-) -> Tuple[pd.DataFrame, List[str], List[str]]:
+) -> tuple[pd.DataFrame, list[str], list[str]]:
     r"""
     Add calendar/time-derived features to a DataFrame.
 
@@ -114,34 +115,55 @@ def add_calendar_features(
     if timestamp_col not in df.columns:
         raise KeyError(f"Timestamp column {timestamp_col!r} not found in DataFrame.")
 
+    df_out = ensure_entity_time_order(
+        df.copy(),
+        entity_col=infer_panel_entity_col(df, timestamp_col=timestamp_col),
+        timestamp_col=timestamp_col,
+    )
+    feature_cols, calendar_cols = _assign_calendar_features(
+        df_out,
+        timestamp_col=timestamp_col,
+        calendar_features=calendar_features,
+        use_cyclical_time=use_cyclical_time,
+    )
+    return df_out, feature_cols, calendar_cols
+
+
+def _assign_calendar_features(
+    df: pd.DataFrame,
+    *,
+    timestamp_col: str,
+    calendar_features: Sequence[str],
+    use_cyclical_time: bool,
+) -> tuple[list[str], list[str]]:
+    """Mutate ``df`` by adding calendar (and optional cyclical) columns."""
     _validate_calendar_features(calendar_features)
 
-    df_out = df.copy()
-    ts = pd.to_datetime(df_out[timestamp_col])
+    ts = pd.to_datetime(df[timestamp_col])
 
-    calendar_cols: List[str] = []
-    feature_cols: List[str] = []
+    calendar_cols: list[str] = []
+    feature_cols: list[str] = []
 
     for name in calendar_features:
         if name == "hour":
             col = "hour"
-            df_out[col] = ts.dt.hour.astype("int16")
+            df[col] = ts.dt.hour.astype("int16")
             calendar_cols.append(col)
         elif name == "dow":
             col = "dayofweek"
-            df_out[col] = ts.dt.dayofweek.astype("int16")
+            df[col] = ts.dt.dayofweek.astype("int16")
             calendar_cols.append(col)
         elif name == "dom":
             col = "dayofmonth"
-            df_out[col] = ts.dt.day.astype("int16")
+            df[col] = ts.dt.day.astype("int16")
             calendar_cols.append(col)
         elif name == "month":
             col = "month"
-            df_out[col] = ts.dt.month.astype("int16")
+            df[col] = ts.dt.month.astype("int16")
             calendar_cols.append(col)
         elif name == "is_weekend":
             col = "is_weekend"
-            df_out[col] = ts.dt.dayofweek.isin(WEEKEND_DAYS).astype("int8")
+            df[col] = ts.dt.dayofweek.isin(WEEKEND_DAYS).astype("int8")
             calendar_cols.append(col)
         else:  # pragma: no cover
             # Guarded by _validate_calendar_features, but keep a defensive fallback.
@@ -151,23 +173,20 @@ def add_calendar_features(
 
     feature_cols.extend(calendar_cols)
 
-    # ---------------------------------------------------------------------
-    # Optional cyclical encodings
-    # ---------------------------------------------------------------------
     if use_cyclical_time:
         if "hour" in calendar_cols:
-            hour = df_out["hour"].astype(float)
-            df_out["hour_sin"] = np.sin(2.0 * np.pi * hour / float(HOUR_PERIOD))
-            df_out["hour_cos"] = np.cos(2.0 * np.pi * hour / float(HOUR_PERIOD))
+            hour = df["hour"].astype(float)
+            df["hour_sin"] = np.sin(2.0 * np.pi * hour / float(HOUR_PERIOD))
+            df["hour_cos"] = np.cos(2.0 * np.pi * hour / float(HOUR_PERIOD))
             feature_cols.extend(["hour_sin", "hour_cos"])
 
         if "dayofweek" in calendar_cols:
-            dow = df_out["dayofweek"].astype(float)
-            df_out["dow_sin"] = np.sin(2.0 * np.pi * dow / float(DOW_PERIOD))
-            df_out["dow_cos"] = np.cos(2.0 * np.pi * dow / float(DOW_PERIOD))
+            dow = df["dayofweek"].astype(float)
+            df["dow_sin"] = np.sin(2.0 * np.pi * dow / float(DOW_PERIOD))
+            df["dow_cos"] = np.cos(2.0 * np.pi * dow / float(DOW_PERIOD))
             feature_cols.extend(["dow_sin", "dow_cos"])
 
-    return df_out, feature_cols, calendar_cols
+    return feature_cols, calendar_cols
 
 
 def _validate_calendar_features(calendar_features: Iterable[str]) -> None:
@@ -190,4 +209,4 @@ def _validate_calendar_features(calendar_features: Iterable[str]) -> None:
         raise ValueError(
             "Unsupported calendar feature(s) requested: "
             f"{invalid}. Allowed: {sorted(ALLOWED_CALENDAR_FEATURES)}."
-        )
+        )

{eb_features-0.2.4 → eb_features-0.2.7}/src/eb_features/panel/config.py

@@ -1,5 +1,3 @@
-from __future__ import annotations
-
 """
 Configuration objects for panel time-series feature engineering.
 
@@ -12,27 +10,36 @@ pipeline. The configuration is designed to be:
 
 Notes
 -----
-This configuration is consumed by [`FeatureEngineer`][eb_features.panel.engineer.FeatureEngineer]
-and related helper modules (lags, rolling, calendar, encoders).
+This configuration is consumed by
+[`FeatureEngineer`][eb_features.panel.engineering.FeatureEngineer] and related helper
+modules (lags, rolling, calendar, encoders).
 """
 
+from __future__ import annotations
+
+from collections.abc import Sequence
 from dataclasses import dataclass, field
-from typing import Optional, Sequence, Tuple
 
 # -------------------------------------------------------------------------
 # Public constants (useful for validation, docs, and IDE discoverability)
 # -------------------------------------------------------------------------
 
 #: Allowed rolling statistics for rolling window features.
-ALLOWED_ROLLING_STATS: Tuple[str, ...] = ("mean", "std", "min", "max", "sum", "median")
+ALLOWED_ROLLING_STATS: tuple[str, ...] = ("mean", "std", "min", "max", "sum", "median")
 
 #: Allowed calendar feature keys derived from timestamps.
-ALLOWED_CALENDAR_FEATURES: Tuple[str, ...] = ("hour", "dow", "dom", "month", "is_weekend")
+ALLOWED_CALENDAR_FEATURES: tuple[str, ...] = (
+    "hour",
+    "dow",
+    "dom",
+    "month",
+    "is_weekend",
+)
 
 
 @dataclass(frozen=True)
 class FeatureConfig:
-    r"""
+    """
     Configuration for panel time-series feature engineering.
 
     The feature engineering pipeline assumes a long-form panel DataFrame with an entity
@@ -77,9 +84,9 @@ class FeatureConfig:
         by lags and rolling windows).
     """
 
-    lag_steps: Optional[Sequence[int]] = field(default_factory=lambda: (1, 2, 24))
+    lag_steps: Sequence[int] | None = field(default_factory=lambda: (1, 2, 24))
 
-    rolling_windows: Optional[Sequence[int]] = field(default_factory=lambda: (3, 24))
+    rolling_windows: Sequence[int] | None = field(default_factory=lambda: (3, 24))
     rolling_stats: Sequence[str] = field(
         default_factory=lambda: ("mean", "std", "min", "max", "sum")
     )
@@ -89,7 +96,7 @@ class FeatureConfig:
     )
     use_cyclical_time: bool = True
 
-    regressor_cols: Optional[Sequence[str]] = None
-    static_cols: Optional[Sequence[str]] = None
+    regressor_cols: Sequence[str] | None = None
+    static_cols: Sequence[str] | None = None
 
-    dropna: bool = True
+    dropna: bool = True

{eb_features-0.2.4 → eb_features-0.2.7}/src/eb_features/panel/constants.py

@@ -1,5 +1,3 @@
-from __future__ import annotations
-
 r"""
 Shared constants for panel feature engineering.
 
@@ -15,14 +13,14 @@ Notes
   used consistently across feature builders.
 """
 
-from typing import Final, FrozenSet, Tuple
+from __future__ import annotations
+
+from typing import Final
 
 # -----------------------------------------------------------------------------
 # Allowed feature keys
 # -----------------------------------------------------------------------------
-ALLOWED_ROLLING_STATS: FrozenSet[str] = frozenset(
-    {"mean", "std", "min", "max", "sum", "median"}
-)
+ALLOWED_ROLLING_STATS: frozenset[str] = frozenset({"mean", "std", "min", "max", "sum", "median"})
 r"""
 Allowed rolling-window summary statistics.
 
@@ -36,9 +34,7 @@ where ``w`` is the window length (in index steps) and ``stat`` is one of the all
 """
 
 
-ALLOWED_CALENDAR_FEATURES: FrozenSet[str] = frozenset(
-    {"hour", "dow", "dom", "month", "is_weekend"}
-)
+ALLOWED_CALENDAR_FEATURES: frozenset[str] = frozenset({"hour", "dow", "dom", "month", "is_weekend"})
 r"""
 Allowed calendar features derived from the timestamp column.
 
@@ -49,12 +45,12 @@ cyclical encodings (sine/cosine) for periodic components.
 # -----------------------------------------------------------------------------
 # Default configuration values (used by FeatureConfig)
 # -----------------------------------------------------------------------------
-DEFAULT_LAG_STEPS: Final[Tuple[int, ...]] = (1, 2, 24)
+DEFAULT_LAG_STEPS: Final[tuple[int, ...]] = (1, 2, 24)
 
-DEFAULT_ROLLING_WINDOWS: Final[Tuple[int, ...]] = (3, 24)
-DEFAULT_ROLLING_STATS: Final[Tuple[str, ...]] = ("mean", "std", "min", "max", "sum")
+DEFAULT_ROLLING_WINDOWS: Final[tuple[int, ...]] = (3, 24)
+DEFAULT_ROLLING_STATS: Final[tuple[str, ...]] = ("mean", "std", "min", "max", "sum")
 
-DEFAULT_CALENDAR_FEATURES: Final[Tuple[str, ...]] = (
+DEFAULT_CALENDAR_FEATURES: Final[tuple[str, ...]] = (
     "hour",
     "dow",
     "month",
@@ -71,5 +67,5 @@ DOW_PERIOD: Final[int] = 7
 """Period used for cyclical day-of-week encodings."""
 
 # pandas dt.dayofweek convention: Monday=0 ... Sunday=6
-WEEKEND_DAYS: Final[Tuple[int, int]] = (5, 6)
-"""Day-of-week values corresponding to Saturday and Sunday."""
+WEEKEND_DAYS: Final[tuple[int, int]] = (5, 6)
+"""Day-of-week values corresponding to Saturday and Sunday."""

{eb_features-0.2.4 → eb_features-0.2.7}/src/eb_features/panel/encoders.py

@@ -1,5 +1,3 @@
-from __future__ import annotations
-
 """
 Encoding utilities for panel feature engineering.
 
@@ -24,7 +22,9 @@ consider:
 - introducing a fitted encoder with persisted category mappings.
 """
 
-from typing import Iterable
+from __future__ import annotations
+
+from collections.abc import Iterable
 
 import pandas as pd
 from pandas.api.types import is_bool_dtype, is_numeric_dtype
@@ -53,7 +53,7 @@ def encode_non_numeric_as_category_codes(
     -------
     pandas.DataFrame
         Copy of ``feature_frame`` where:
-        - boolean columns are converted to {0,1}
+        - boolean columns are converted to {0, 1}
         - non-numeric, non-boolean columns are replaced by categorical integer codes
 
     Notes
@@ -88,4 +88,4 @@ def encode_non_numeric_as_category_codes(
         cat = pd.Categorical(s, categories=categories, ordered=False)
         df[col] = cat.codes.astype(dtype)
 
-    return df
+    return df