upgini 1.2.62a3818.dev2__py3-none-any.whl → 1.2.62a3818.dev4__py3-none-any.whl

upgini/__about__.py

@@ -1 +1 @@
-__version__ = "1.2.62a3818.dev2"
+__version__ = "1.2.62a3818.dev4"

upgini/autofe/all_operands.py

@@ -7,4 +7,4 @@ from upgini.autofe.vector import *  # noqa
 
 
 def find_op(name):
-    return OperatorRegistry.get_operand(name)
+    return OperatorRegistry.get_operator(name)

upgini/autofe/operator.py

@@ -20,23 +20,25 @@ class OperatorRegistry(type(BaseModel)):
             base_names.update(b.__name__ for b in base.__bases__)
             base_classes.extend(base.__bases__)
 
-        if "Operand" in base_names:
+        if "Operator" in base_names:
             # Track parametrized operands separately
-            if "ParametrizedOperand" in base_names:
+            if "ParametrizedOperator" in base_names:
                 cls._parametrized_registry.append(new_class)
             else:
                 try:
                     instance = new_class()
                     cls._registry[instance.name] = new_class
+                    if instance.alias:
+                        cls._registry[instance.alias] = new_class
                 except Exception:
                     pass
         return new_class
 
     @classmethod
-    def get_operand(cls, name: str) -> Optional["Operator"]:
+    def get_operator(cls, name: str) -> Optional["Operator"]:
         # First try to resolve as a parametrized operand formula
-        for operand_cls in cls._parametrized_registry:
-            resolved = operand_cls.from_formula(name)
+        for operator_cls in cls._parametrized_registry:
+            resolved = operator_cls.from_formula(name)
             if resolved is not None:
                 return resolved
         # Fall back to direct registry lookup

upgini/autofe/timeseries/__init__.py

@@ -0,0 +1,23 @@
+"""Time series feature engineering operators."""
+
+from upgini.autofe.timeseries.base import TimeSeriesBase
+from upgini.autofe.timeseries.roll import Roll
+from upgini.autofe.timeseries.lag import Lag
+from upgini.autofe.timeseries.delta import Delta, Delta2
+from upgini.autofe.timeseries.trend import TrendCoefficient
+from upgini.autofe.timeseries.volatility import EWMAVolatility, RollingVolatility, RollingVolatility2, VolatilityRatio
+from upgini.autofe.timeseries.cross import CrossSeriesInteraction
+
+__all__ = [
+    "TimeSeriesBase",
+    "Roll",
+    "Lag",
+    "Delta",
+    "Delta2",
+    "TrendCoefficient",
+    "EWMAVolatility",
+    "RollingVolatility",
+    "RollingVolatility2",
+    "VolatilityRatio",
+    "CrossSeriesInteraction",
+]

upgini/autofe/timeseries/base.py

@@ -0,0 +1,105 @@
+import abc
+from typing import Dict, List, Optional
+
+import pandas as pd
+from upgini.autofe.operator import PandasOperator
+
+# Used in derived classes
+try:
+    from pydantic import field_validator as validator  # V2
+except ImportError:
+    from pydantic import validator  # V1
+
+
+class TimeSeriesBase(PandasOperator, abc.ABC):
+    is_vector: bool = True
+    date_unit: Optional[str] = None
+    offset_size: int = 0
+    offset_unit: str = "D"
+
+    def get_params(self) -> Dict[str, Optional[str]]:
+        res = super().get_params()
+        res.update(
+            {
+                "date_unit": self.date_unit,
+                "offset_size": self.offset_size,
+                "offset_unit": self.offset_unit,
+            }
+        )
+        return res
+
+    def calculate_vector(self, data: List[pd.Series]) -> pd.Series:
+        # assuming first is date, last is value, rest is group columns
+        date = pd.to_datetime(data[0], unit=self.date_unit, errors="coerce")
+        ts = pd.concat([date] + data[1:], axis=1)
+        ts.drop_duplicates(subset=ts.columns[:-1], keep="first", inplace=True)
+        ts.set_index(date.name, inplace=True)
+        ts = ts[ts.index.notna()].sort_index()
+        ts = (
+            ts.groupby([c.name for c in data[1:-1]], group_keys=True)
+            .apply(self._shift)[data[-1].name]
+            .to_frame()
+            .reset_index()
+            .set_index(date.name)
+            .groupby([c.name for c in data[1:-1]], group_keys=True)
+            if len(data) > 2
+            else self._shift(ts)
+        )
+        ts = self._aggregate(ts)
+        ts = ts.reindex(data[1:-1] + [date] if len(data) > 2 else date).reset_index()
+        ts.index = date.index
+
+        return ts.iloc[:, -1]
+
+    def _shift(self, ts: pd.DataFrame) -> pd.DataFrame:
+        if self.offset_size > 0:
+            return ts.iloc[:, :-1].merge(
+                ts.iloc[:, -1].shift(freq=f"{self.offset_size}{self.offset_unit}"),
+                left_index=True,
+                right_index=True,
+            )
+        return ts
+
+    @abc.abstractmethod
+    def _aggregate(self, ts: pd.DataFrame) -> pd.DataFrame:
+        pass
+
+    def _add_offset_to_formula(self, base_formula: str) -> str:
+        if self.offset_size > 0:
+            return f"{base_formula}_offset_{self.offset_size}{self.offset_unit}"
+        return base_formula
+
+    @classmethod
+    def _parse_offset_from_formula(cls, formula: str, base_regex: str) -> tuple[Optional[dict], Optional[str]]:
+        """
+        Parse the offset component from a formula.
+
+        Args:
+            formula: The formula to parse
+            base_regex: The regex pattern for the base formula (without offset)
+
+        Returns:
+            A tuple with:
+            - Dictionary with offset parameters if found, None otherwise
+            - Remaining part of the formula after removing offset component (for further parsing)
+        """
+        import re
+
+        offset_regex = f"{base_regex}_offset_(\\d+)([a-zA-Z])"
+        match = re.match(offset_regex, formula)
+
+        if match:
+            # Get groups from the offset part
+            offset_size = int(match.group(match.lastindex - 1))
+            offset_unit = match.group(match.lastindex)
+
+            # Return the parameters and the base formula for further parsing if needed
+            # Extract the base formula by using the match object
+            base_formula = formula[: match.start(match.lastindex - 1) - len("_offset_")]
+            return {"offset_size": offset_size, "offset_unit": offset_unit}, base_formula
+
+        # Check if it matches the base regex (no offset)
+        if re.match(f"^{base_regex}$", formula) or re.match(f"^{base_regex}_", formula):
+            return None, formula
+
+        return None, None

upgini/autofe/timeseries/cross.py

@@ -0,0 +1,130 @@
+from typing import Dict, List, Optional
+
+import numpy as np
+import pandas as pd
+
+try:
+    from pydantic import field_validator as validator  # V2
+except ImportError:
+    from pydantic import validator  # V1
+
+from upgini.autofe.all_operands import find_op
+from upgini.autofe.operator import PandasOperator, ParametrizedOperator
+from upgini.autofe.timeseries.base import TimeSeriesBase
+
+
+class CrossSeriesInteraction(TimeSeriesBase, ParametrizedOperator):
+    base_name: str = "cross"
+    interaction_op: PandasOperator
+    descriptor_indices: List[int] = []
+    left_descriptor: List[str] = []
+    right_descriptor: List[str] = []
+
+    @validator("descriptor_indices")
+    @classmethod
+    def validate_descriptor_indices(cls, v):
+        if not v:
+            raise ValueError("descriptor_indices cannot be empty for CrossSeriesInteraction")
+        return v
+
+    def __init__(self, **data):
+        super().__init__(**data)
+        indices = self.descriptor_indices
+        left = self.left_descriptor
+        right = self.right_descriptor
+
+        if len(left) != len(indices):
+            raise ValueError(
+                f"left_descriptor length ({len(left)}) " f"must match descriptor_indices length ({len(indices)})"
+            )
+
+        if len(right) != len(indices):
+            raise ValueError(
+                f"right_descriptor length ({len(right)}) " f"must match descriptor_indices length ({len(indices)})"
+            )
+
+    def to_formula(self) -> str:
+        base_formula = f"{self.base_name}_{self._get_interaction_op_name()}"
+        return self._add_offset_to_formula(base_formula)
+
+    @classmethod
+    def from_formula(cls, formula: str) -> Optional["CrossSeriesInteraction"]:
+        base_regex = r"cross_(.+)"
+
+        offset_params, remaining_formula = cls._parse_offset_from_formula(formula, base_regex)
+
+        if remaining_formula is None:
+            return None
+
+        import re
+
+        match = re.match(f"^{base_regex}$", remaining_formula)
+
+        if not match:
+            return None
+
+        # Extract the operator formula
+        op_formula = match.group(1)
+
+        op = find_op(op_formula)
+        if op is None or not op.is_binary:
+            return None
+
+        # Include default values to pass validation
+        params = {
+            "interaction_op": op,
+            "descriptor_indices": [0],  # Default index
+            "left_descriptor": ["default"],  # Default left descriptor
+            "right_descriptor": ["default"],  # Default right descriptor
+        }
+
+        if offset_params:
+            params.update(offset_params)
+
+        return cls(**params)
+
+    def get_params(self) -> Dict[str, str | None]:
+        res = super().get_params()
+        res.update(
+            {
+                "interaction_op": self._get_interaction_op_name(),
+                "descriptor_indices": self.descriptor_indices,
+                "left_descriptor": self.left_descriptor,
+                "right_descriptor": self.right_descriptor,
+            }
+        )
+        return res
+
+    def _get_interaction_op_name(self) -> str:
+        return self.interaction_op.alias or self.interaction_op.to_formula()
+
+    def calculate_vector(self, data: List[pd.Series]) -> pd.Series:
+        left_mask = self._get_mask(data, self.left_descriptor)
+        left = self._extract_series(data, left_mask)
+
+        right_mask = self._get_mask(data, self.right_descriptor)
+        right = self._extract_series(data, right_mask)
+
+        interaction: pd.Series = self.interaction_op.calculate_binary(left, right)
+        interaction = interaction.reindex(self._get_index(data))
+        res = pd.Series(np.nan, index=data[-1].index, name=data[-1].name)
+        res.loc[left_mask] = interaction[left_mask].values
+        res.loc[right_mask] = interaction[right_mask].values
+        return res
+
+    def _get_mask(self, data: List[pd.Series], descriptor: List[str]) -> pd.Series:
+        mask = np.logical_and.reduce([data[i] == v for i, v in zip(self.descriptor_indices, descriptor)])
+        return mask
+
+    def _extract_series(self, data: List[pd.Series], mask: pd.Series) -> pd.Series:
+        masked_data = [d[mask] for d in data]
+        shifted = super().calculate_vector(masked_data)
+        shifted.index = self._get_index(masked_data)
+        return shifted
+
+    def _get_index(self, data: List[pd.Series]) -> pd.Series:
+        index = [d for i, d in enumerate(data[:-1]) if i not in self.descriptor_indices]
+        return index if len(index) > 1 else index[0]
+
+    def _aggregate(self, ts: pd.DataFrame) -> pd.DataFrame:
+        return ts.apply(lambda x: x).iloc[:, [-1]]

upgini/autofe/timeseries/delta.py

@@ -0,0 +1,125 @@
+import pandas as pd
+from typing import Dict, Optional
+
+from upgini.autofe.operator import ParametrizedOperator
+from upgini.autofe.timeseries.base import TimeSeriesBase
+from upgini.autofe.timeseries.lag import Lag
+
+
+class Delta(TimeSeriesBase, ParametrizedOperator):
+    delta_size: int
+    delta_unit: str = "D"
+
+    def to_formula(self) -> str:
+        base_formula = f"delta_{self.delta_size}{self.delta_unit}"
+        return self._add_offset_to_formula(base_formula)
+
+    @classmethod
+    def from_formula(cls, formula: str) -> Optional["Delta"]:
+        # Base regex for Delta class
+        base_regex = r"delta_(\d+)([a-zA-Z])"
+
+        # Parse offset first
+        offset_params, remaining_formula = cls._parse_offset_from_formula(formula, base_regex)
+
+        if remaining_formula is None:
+            return None
+
+        # Now parse the delta part
+        import re
+
+        match = re.match(f"^{base_regex}$", remaining_formula)
+
+        if not match:
+            return None
+
+        delta_size = int(match.group(1))
+        delta_unit = match.group(2)
+
+        # Create instance with appropriate parameters
+        params = {
+            "delta_size": delta_size,
+            "delta_unit": delta_unit,
+        }
+
+        if offset_params:
+            params.update(offset_params)
+
+        return cls(**params)
+
+    def get_params(self) -> Dict[str, Optional[str]]:
+        res = super().get_params()
+        res.update(
+            {
+                "delta_size": self.delta_size,
+                "delta_unit": self.delta_unit,
+                "offset_size": self.offset_size,
+                "offset_unit": self.offset_unit,
+            }
+        )
+        return res
+
+    def _aggregate(self, ts: pd.DataFrame) -> pd.DataFrame:
+        lag0 = Lag(lag_size=0, lag_unit=self.delta_unit)
+        lag = Lag(lag_size=self.delta_size, lag_unit=self.delta_unit)
+        return lag0._aggregate(ts) - lag._aggregate(ts)
+
+
+class Delta2(TimeSeriesBase, ParametrizedOperator):
+    delta_size: int
+    delta_unit: str = "D"
+
+    def to_formula(self) -> str:
+        base_formula = f"delta2_{self.delta_size}{self.delta_unit}"
+        return self._add_offset_to_formula(base_formula)
+
+    @classmethod
+    def from_formula(cls, formula: str) -> Optional["Delta2"]:
+        # Base regex for Delta2 class
+        base_regex = r"delta2_(\d+)([a-zA-Z])"
+
+        # Parse offset first
+        offset_params, remaining_formula = cls._parse_offset_from_formula(formula, base_regex)
+
+        if remaining_formula is None:
+            return None
+
+        # Now parse the delta part
+        import re
+
+        match = re.match(f"^{base_regex}$", remaining_formula)
+
+        if not match:
+            return None
+
+        delta_size = int(match.group(1))
+        delta_unit = match.group(2)
+
+        # Create instance with appropriate parameters
+        params = {
+            "delta_size": delta_size,
+            "delta_unit": delta_unit,
+        }
+
+        if offset_params:
+            params.update(offset_params)
+
+        return cls(**params)
+
+    def get_params(self) -> Dict[str, Optional[str]]:
+        res = super().get_params()
+        res.update(
+            {
+                "delta_size": self.delta_size,
+                "delta_unit": self.delta_unit,
+            }
+        )
+        return res
+
+    def _aggregate(self, ts: pd.DataFrame) -> pd.DataFrame:
+        # Calculate first delta
+        delta1 = Delta(delta_size=self.delta_size, delta_unit=self.delta_unit)
+        first_delta = delta1._aggregate(ts)
+
+        # Calculate delta of delta (second derivative)
+        return delta1._aggregate(first_delta)

upgini/autofe/timeseries/lag.py

@@ -0,0 +1,68 @@
+import numpy as np
+import pandas as pd
+from typing import Dict, Optional
+
+from upgini.autofe.operator import ParametrizedOperator
+from upgini.autofe.timeseries.base import TimeSeriesBase
+
+
+class Lag(TimeSeriesBase, ParametrizedOperator):
+    lag_size: int
+    lag_unit: str = "D"
+
+    def to_formula(self) -> str:
+        base_formula = f"lag_{self.lag_size}{self.lag_unit}"
+        return self._add_offset_to_formula(base_formula)
+
+    @classmethod
+    def from_formula(cls, formula: str) -> Optional["Lag"]:
+        # Base regex for Lag class
+        base_regex = r"lag_(\d+)([a-zA-Z])"
+
+        # Parse offset first
+        offset_params, remaining_formula = cls._parse_offset_from_formula(formula, base_regex)
+
+        if remaining_formula is None:
+            return None
+
+        # Now parse the lag part
+        import re
+
+        match = re.match(f"^{base_regex}$", remaining_formula)
+
+        if not match:
+            return None
+
+        lag_size = int(match.group(1))
+        lag_unit = match.group(2)
+
+        # Create instance with appropriate parameters
+        params = {
+            "lag_size": lag_size,
+            "lag_unit": lag_unit,
+        }
+
+        if offset_params:
+            params.update(offset_params)
+
+        return cls(**params)
+
+    def get_params(self) -> Dict[str, Optional[str]]:
+        res = super().get_params()
+        res.update(
+            {
+                "lag_size": self.lag_size,
+                "lag_unit": self.lag_unit,
+            }
+        )
+        return res
+
+    def _aggregate(self, ts: pd.DataFrame) -> pd.DataFrame:
+        lag_window = self.lag_size + 1
+        return ts.rolling(f"{lag_window}{self.lag_unit}", min_periods=1).agg(self._lag)
+
+    def _lag(self, x):
+        if x.index.min() > (x.index.max() - pd.Timedelta(self.lag_size, self.lag_unit)):
+            return np.nan
+        else:
+            return x[0]

upgini/autofe/timeseries/roll.py

@@ -0,0 +1,92 @@
+import pandas as pd
+from typing import Dict, Optional
+
+from upgini.autofe.operator import ParametrizedOperator
+from upgini.autofe.timeseries.base import TimeSeriesBase
+
+# Roll aggregation functions
+roll_aggregations = {
+    "norm_mean": lambda x: x[-1] / x.mean(),
+    "q25": lambda x: x.quantile(0.25),
+    "q75": lambda x: x.quantile(0.75),
+    "iqr": lambda x: x.quantile(0.75) - x.quantile(0.25),
+}
+
+try:
+    from pydantic import field_validator as validator  # V2
+except ImportError:
+    from pydantic import validator  # V1
+
+
+class Roll(TimeSeriesBase, ParametrizedOperator):
+    aggregation: str
+    window_size: int = 1
+    window_unit: str = "D"
+
+    @validator("window_unit")
+    @classmethod
+    def validate_window_unit(cls, v: str) -> str:
+        try:
+            pd.tseries.frequencies.to_offset(v)
+            return v
+        except ValueError:
+            raise ValueError(
+                f"Invalid window_unit: {v}. Must be a valid pandas frequency string (e.g. 'D', 'H', 'T', etc)"
+            )
+
+    def to_formula(self) -> str:
+        # First add window size and unit, then add aggregation, then add offset
+        base_formula = f"roll_{self.window_size}{self.window_unit}"
+        formula_with_agg = f"{base_formula}_{self.aggregation}"
+        return self._add_offset_to_formula(formula_with_agg)
+
+    @classmethod
+    def from_formula(cls, formula: str) -> Optional["Roll"]:
+        import re
+
+        # Base regex for Roll class (with aggregation)
+        base_regex = r"roll_(\d+)([a-zA-Z])_(\w+)"
+
+        # Parse offset first - this removes the offset part if present
+        offset_params, remaining_formula = cls._parse_offset_from_formula(formula, base_regex)
+
+        if remaining_formula is None:
+            return None
+
+        # Parse the window part and aggregation
+        match = re.match(f"^{base_regex}$", remaining_formula)
+
+        if not match:
+            return None
+
+        window_size = int(match.group(1))
+        window_unit = match.group(2)
+        aggregation = match.group(3)
+
+        # Create instance with appropriate parameters
+        params = {
+            "window_size": window_size,
+            "window_unit": window_unit,
+            "aggregation": aggregation,
+        }
+
+        if offset_params:
+            params.update(offset_params)
+
+        return cls(**params)
+
+    def get_params(self) -> Dict[str, Optional[str]]:
+        res = super().get_params()
+        res.update(
+            {
+                "window_size": self.window_size,
+                "window_unit": self.window_unit,
+                "aggregation": self.aggregation,
+            }
+        )
+        return res
+
+    def _aggregate(self, ts: pd.DataFrame) -> pd.DataFrame:
+        return ts.rolling(f"{self.window_size}{self.window_unit}", min_periods=1).agg(
+            roll_aggregations.get(self.aggregation, self.aggregation)
+        )

upgini/autofe/timeseries/trend.py

@@ -0,0 +1,61 @@
+from typing import Dict, Optional, Union
+import numpy as np
+import pandas as pd
+
+from upgini.autofe.timeseries.base import TimeSeriesBase
+
+
+class TrendCoefficient(TimeSeriesBase):
+    name: str = "trend_coef"
+    step_size: int = 1
+    step_unit: str = "D"
+
+    def to_formula(self) -> str:
+        base_formula = "trend_coef"
+        return self._add_offset_to_formula(base_formula)
+
+    @classmethod
+    def from_formula(cls, formula: str) -> Optional["TrendCoefficient"]:
+        # Base regex for TrendCoefficient class
+        base_regex = r"trend_coef"
+
+        # Parse offset first
+        offset_params, remaining_formula = cls._parse_offset_from_formula(formula, base_regex)
+
+        if remaining_formula is None:
+            return None
+
+        # Basic pattern (no offset)
+        if remaining_formula == "trend_coef":
+            params = {}
+            if offset_params:
+                params.update(offset_params)
+            return cls(**params)
+
+        return None
+
+    def get_params(self) -> Dict[str, Optional[str]]:
+        res = super().get_params()
+        res.update(
+            {
+                "step_size": self.step_size,
+                "step_unit": self.step_unit,
+                "offset_size": self.offset_size,
+                "offset_unit": self.offset_unit,
+            }
+        )
+        return res
+
+    def _aggregate(self, ts: pd.DataFrame) -> pd.DataFrame:
+        return ts.apply(self._trend_coef).iloc[:, [-1]].fillna(0)
+
+    def _trend_coef(self, x: Union[pd.DataFrame, pd.Series]) -> Union[pd.DataFrame, pd.Series]:
+        return_series = isinstance(x, pd.Series)
+        x = pd.DataFrame(x)
+        resampled = (
+            x.iloc[:, -1].resample(f"{self.step_size}{self.step_unit}").fillna(method="ffill").fillna(method="bfill")
+        )
+        idx = np.arange(len(resampled))
+        coeffs = np.polyfit(idx, resampled, 1)
+        x.iloc[:, -1] = coeffs[0]
+        return x.iloc[:, -1] if return_series else x

upgini/autofe/timeseries/volatility.py

@@ -0,0 +1,259 @@
+from typing import Dict, Optional, Union
+
+import numpy as np
+import pandas as pd
+from upgini.autofe.operator import ParametrizedOperator
+from upgini.autofe.timeseries.base import TimeSeriesBase
+
+
+class VolatilityBase(TimeSeriesBase):
+    @staticmethod
+    def _get_returns(ts: pd.Series, freq: str) -> pd.Series:
+        return ts.pct_change(freq=freq).fillna(0)
+
+
+class EWMAVolatility(VolatilityBase, ParametrizedOperator):
+    step_size: int = 1
+    step_unit: str = "D"
+    window_size: int
+
+    def to_formula(self) -> str:
+        base_formula = f"ewma_vol_{self.window_size}"
+        return self._add_offset_to_formula(base_formula)
+
+    @classmethod
+    def from_formula(cls, formula: str) -> Optional["EWMAVolatility"]:
+        base_regex = r"ewma_vol_(\d+)"
+
+        offset_params, remaining_formula = cls._parse_offset_from_formula(formula, base_regex)
+
+        if remaining_formula is None:
+            return None
+
+        import re
+
+        match = re.match(f"^{base_regex}$", remaining_formula)
+
+        if not match:
+            return None
+
+        window_size = int(match.group(1))
+
+        params = {
+            "window_size": window_size,
+        }
+
+        if offset_params:
+            params.update(offset_params)
+
+        return cls(**params)
+
+    def get_params(self) -> Dict[str, Optional[str]]:
+        res = super().get_params()
+        res.update(
+            {
+                "step_size": self.step_size,
+                "step_unit": self.step_unit,
+                "window_size": self.window_size,
+            }
+        )
+        return res
+
+    def _aggregate(self, ts: pd.DataFrame) -> pd.DataFrame:
+        return ts.apply(self._ewma_vol)
+
+    def _ewma_vol(self, x):
+        x = pd.DataFrame(x).iloc[:, -1]
+        returns = self._get_returns(x, f"{self.step_size}{self.step_unit}")
+        return returns.ewm(span=self.window_size).std()
+
+
+class RollingVolBase(VolatilityBase):
+    step_size: int = 1
+    step_unit: str = "D"
+    window_size: int
+    window_unit: str = "D"
+
+    def get_params(self) -> Dict[str, Optional[str]]:
+        res = super().get_params()
+        res.update(
+            {
+                "step_size": self.step_size,
+                "step_unit": self.step_unit,
+                "window_size": self.window_size,
+                "window_unit": self.window_unit,
+            }
+        )
+        return res
+
+    def _rolling_vol(
+        self, x: Union[pd.DataFrame, pd.Series], window_size: int, window_unit: str, abs_returns: bool = False
+    ) -> Union[pd.DataFrame, pd.Series]:
+        return_series = isinstance(x, pd.Series)
+        x = pd.DataFrame(x)
+        returns = self._get_returns(x.iloc[:, -1], f"{self.step_size}{self.step_unit}")
+        if abs_returns:
+            returns = returns.abs()
+        x.iloc[:, -1] = returns.rolling(f"{window_size}{window_unit}", min_periods=1).std()
+        return x.iloc[:, -1] if return_series else x
+
+
+class RollingVolatility(RollingVolBase, ParametrizedOperator):
+    abs_returns: bool = False
+
+    def to_formula(self) -> str:
+        base_formula = f"roll_vol_{self.window_size}{self.window_unit}"
+        return self._add_offset_to_formula(base_formula)
+
+    @classmethod
+    def from_formula(cls, formula: str) -> Optional["RollingVolatility"]:
+        base_regex = r"roll_vol_(\d+)([a-zA-Z])"
+
+        offset_params, remaining_formula = cls._parse_offset_from_formula(formula, base_regex)
+
+        if remaining_formula is None:
+            return None
+
+        import re
+
+        match = re.match(f"^{base_regex}$", remaining_formula)
+
+        if not match:
+            return None
+
+        window_size = int(match.group(1))
+        window_unit = match.group(2)
+
+        params = {
+            "window_size": window_size,
+            "window_unit": window_unit,
+        }
+
+        if offset_params:
+            params.update(offset_params)
+
+        return cls(**params)
+
+    def _aggregate(self, ts: pd.DataFrame) -> pd.DataFrame:
+        return ts.apply(
+            self._rolling_vol, window_size=self.window_size, window_unit=self.window_unit, abs_returns=self.abs_returns
+        ).iloc[:, [-1]]
+
+
+class RollingVolatility2(RollingVolBase, ParametrizedOperator):
+    """
+    Computes the volatility on volatility of a time series. Volatility is computed using the RollingVolatility.
+    """
+
+    def to_formula(self) -> str:
+        base_formula = f"roll_vol2_{self.window_size}{self.window_unit}"
+        return self._add_offset_to_formula(base_formula)
+
+    @classmethod
+    def from_formula(cls, formula: str) -> Optional["RollingVolatility2"]:
+        base_regex = r"roll_vol2_(\d+)([a-zA-Z])"
+
+        offset_params, remaining_formula = cls._parse_offset_from_formula(formula, base_regex)
+
+        if remaining_formula is None:
+            return None
+
+        import re
+
+        match = re.match(f"^{base_regex}$", remaining_formula)
+
+        if not match:
+            return None
+
+        window_size = int(match.group(1))
+        window_unit = match.group(2)
+
+        params = {
+            "window_size": window_size,
+            "window_unit": window_unit,
+        }
+
+        if offset_params:
+            params.update(offset_params)
+
+        return cls(**params)
+
+    def _aggregate(self, ts: pd.DataFrame) -> pd.DataFrame:
+        return ts.apply(self._vol_on_vol).iloc[:, [-1]]
+
+    def _vol_on_vol(self, x: Union[pd.DataFrame, pd.Series]) -> Union[pd.DataFrame, pd.Series]:
+        vol1 = self._rolling_vol(x, self.window_size, self.window_unit, abs_returns=True)
+        vol2 = self._rolling_vol(vol1, self.window_size, self.window_unit, abs_returns=False)
+        return vol2
+
+
+class VolatilityRatio(RollingVolBase, ParametrizedOperator):
+    """
+    Computes the ratio of short-term volatility to long-term volatility.
+    Both volatilities are computed using RollingVolatility.
+    """
+
+    short_window_size: int
+    short_window_unit: str = "D"
+
+    def to_formula(self) -> str:
+        base_formula = (
+            f"vol_ratio_{self.short_window_size}{self.short_window_unit}_to_{self.window_size}{self.window_unit}"
+        )
+        return self._add_offset_to_formula(base_formula)
+
+    @classmethod
+    def from_formula(cls, formula: str) -> Optional["VolatilityRatio"]:
+        base_regex = r"vol_ratio_(\d+)([a-zA-Z])_to_(\d+)([a-zA-Z])"
+
+        offset_params, remaining_formula = cls._parse_offset_from_formula(formula, base_regex)
+
+        if remaining_formula is None:
+            return None
+
+        import re
+
+        match = re.match(f"^{base_regex}$", remaining_formula)
+
+        if not match:
+            return None
+
+        short_window_size = int(match.group(1))
+        short_window_unit = match.group(2)
+        window_size = int(match.group(3))
+        window_unit = match.group(4)
+
+        params = {
+            "short_window_size": short_window_size,
+            "short_window_unit": short_window_unit,
+            "window_size": window_size,
+            "window_unit": window_unit,
+        }
+
+        if offset_params:
+            params.update(offset_params)
+
+        return cls(**params)
+
+    def get_params(self) -> Dict[str, Optional[str]]:
+        res = super().get_params()
+        res.update(
+            {
+                "short_window_size": self.short_window_size,
+                "short_window_unit": self.short_window_unit,
+            }
+        )
+        return res
+
+    def _aggregate(self, ts: pd.DataFrame) -> pd.DataFrame:
+        return ts.apply(self._vol_ratio).iloc[:, [-1]]
+
+    def _vol_ratio(self, x: Union[pd.DataFrame, pd.Series]) -> Union[pd.DataFrame, pd.Series]:
+        short_vol = self._rolling_vol(x, self.short_window_size, self.short_window_unit)
+        long_vol = self._rolling_vol(x, self.window_size, self.window_unit)
+        ratio = VolatilityRatio._handle_div_errors(short_vol / long_vol)
+        return ratio
+
+    @staticmethod
+    def _handle_div_errors(x: pd.Series) -> pd.Series:
+        return x.replace([np.inf, -np.inf], np.nan).fillna(1)

{upgini-1.2.62a3818.dev2.dist-info → upgini-1.2.62a3818.dev4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: upgini
-Version: 1.2.62a3818.dev2
+Version: 1.2.62a3818.dev4
 Summary: Intelligent data search & enrichment for Machine Learning
 Project-URL: Bug Reports, https://github.com/upgini/upgini/issues
 Project-URL: Homepage, https://upgini.com/

{upgini-1.2.62a3818.dev2.dist-info → upgini-1.2.62a3818.dev4.dist-info}/RECORD

@@ -1,4 +1,4 @@
-upgini/__about__.py,sha256=OLozvzWRYF8QVe08Gh2xAIzV-SPbWN9X8WcPvXKgTuU,33
+upgini/__about__.py,sha256=DRRGQ9hjWuzUUDq0H9hZpymmoGVeS9BXeeOQ2XoHmjc,33
 upgini/__init__.py,sha256=LXSfTNU0HnlOkE69VCxkgIKDhWP-JFo_eBQ71OxTr5Y,261
 upgini/ads.py,sha256=nvuRxRx5MHDMgPr9SiU-fsqRdFaBv8p4_v1oqiysKpc,2714
 upgini/dataset.py,sha256=OGjpeFHbj3lWiZTOHTpWEoMMDmFY1FlNC44FKktoZvU,34956
@@ -14,15 +14,22 @@ upgini/version_validator.py,sha256=DvbaAvuYFoJqYt0fitpsk6Xcv-H1BYDJYHUMxaKSH_Y,1
 upgini/ads_management/__init__.py,sha256=qzyisOToVRP-tquAJD1PblZhNtMrOB8FiyF9JvfkvgE,50
 upgini/ads_management/ads_manager.py,sha256=igVbN2jz80Umb2BUJixmJVj-zx8unoKpecVo-R-nGdw,2648
 upgini/autofe/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-upgini/autofe/all_operands.py,sha256=VIT5jCq5U-qypdNz1MIQ_hlIAs0ujJgRfKRUkU24nFs,332
+upgini/autofe/all_operands.py,sha256=rdjF5eaE4bC6Q4eu_el5Z7ekYt8DjOFermz2bePPbUc,333
 upgini/autofe/binary.py,sha256=MnQuFiERpocjCPQUjOljlsq5FE-04GPfwtNjzvfNMyU,7671
 upgini/autofe/date.py,sha256=I07psJerrxOcHao91PdSCk9X6KWu61IBVyFRLjGNgK8,10730
 upgini/autofe/feature.py,sha256=Xto7FHH1JG-5QvkfTPNWKtV9GAzPviTNPKFZOUN7RQA,14757
 upgini/autofe/groupby.py,sha256=IYmQV9uoCdRcpkeWZj_kI3ObzoNCNx3ff3h8sTL01tk,3603
-upgini/autofe/operator.py,sha256=RSJWoKB2pIZ5xToVuk_T0ec7QRx-duxYEEGJ5oealaM,4784
-upgini/autofe/timeseries.py,sha256=-BnDp0z_Hv6Vol1Vov6QC_82U8XPV3pfIPFspK2aTCE,6598
+upgini/autofe/operator.py,sha256=KKLFixtEFq-qP6WVks19F0AY2iOnB8_g8uYpbrC8USM,4894
 upgini/autofe/unary.py,sha256=yVgPvtfnPSOhrii0YgezddmgWPwyOBCR0JutaIkdTTc,4658
 upgini/autofe/vector.py,sha256=l0KdKg-txlZxDSE4hPPfCtfGQofYbl7oaABPr830sPI,667
+upgini/autofe/timeseries/__init__.py,sha256=PGwwDAMwvkXl3el12tXVEmZUgDUvlmIPlXtROm6bD18,738
+upgini/autofe/timeseries/base.py,sha256=T9Ec8LKJbiwTUGGsd_xhM0U0NUJblqmKchkzUI1sK88,3755
+upgini/autofe/timeseries/cross.py,sha256=8ggDhsvwdxHkrWKRPl2fcFt7wamTYhkVzQcOWvIIyvU,4612
+upgini/autofe/timeseries/delta.py,sha256=hXEiFWHdZndz8I7Ef5zhTHLJac9illhZOZITwpL9ppw,3618
+upgini/autofe/timeseries/lag.py,sha256=LfQtg484vuqM0mgY4Wft1swHX_Srq7OKKgZswCXoiXI,1882
+upgini/autofe/timeseries/roll.py,sha256=bNFMDszSYTWvB7EyhHbRY1DJqzSURvHlPAcBebt0y0Y,2878
+upgini/autofe/timeseries/trend.py,sha256=eP0q1fBW4MYPrjfy7vr88tTG8qk0xypClaGHaVv1hAs,1962
+upgini/autofe/timeseries/volatility.py,sha256=9shUmIKjpWTHVYjj80YBsk0XheBJ9uBuLv5NW9Mchnk,7953
 upgini/data_source/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 upgini/data_source/data_source_publisher.py,sha256=4S9qwlAklD8vg9tUU_c1pHE2_glUHAh15-wr5hMwKFw,22879
 upgini/mdc/__init__.py,sha256=aM08nIWFc2gWdWUa3_IuEnNND0cQPkBGnYpRMnfFN8k,1019
@@ -63,7 +70,7 @@ upgini/utils/target_utils.py,sha256=b1GzO8_gMcwXSZ2v98CY50MJJBzKbWHId_BJGybXfkM,
 upgini/utils/track_info.py,sha256=G5Lu1xxakg2_TQjKZk4b5SvrHsATTXNVV3NbvWtT8k8,5663
 upgini/utils/ts_utils.py,sha256=26vhC0pN7vLXK6R09EEkMK3Lwb9IVPH7LRdqFIQ3kPs,1383
 upgini/utils/warning_counter.py,sha256=-GRY8EUggEBKODPSuXAkHn9KnEQwAORC0mmz_tim-PM,254
-upgini-1.2.62a3818.dev2.dist-info/METADATA,sha256=VEJPjgu8A5gOrr4WPbk6DYHt8BNxoqUq9rsl967GQMU,49094
-upgini-1.2.62a3818.dev2.dist-info/WHEEL,sha256=zEMcRr9Kr03x1ozGwg5v9NQBKn3kndp6LSoSlVg-jhU,87
-upgini-1.2.62a3818.dev2.dist-info/licenses/LICENSE,sha256=5RRzgvdJUu3BUDfv4bzVU6FqKgwHlIay63pPCSmSgzw,1514
-upgini-1.2.62a3818.dev2.dist-info/RECORD,,
+upgini-1.2.62a3818.dev4.dist-info/METADATA,sha256=_sL9eQLnB5X1kyhbUiMzXIB5HUgK0KFfmuwgp3Su59c,49094
+upgini-1.2.62a3818.dev4.dist-info/WHEEL,sha256=zEMcRr9Kr03x1ozGwg5v9NQBKn3kndp6LSoSlVg-jhU,87
+upgini-1.2.62a3818.dev4.dist-info/licenses/LICENSE,sha256=5RRzgvdJUu3BUDfv4bzVU6FqKgwHlIay63pPCSmSgzw,1514
+upgini-1.2.62a3818.dev4.dist-info/RECORD,,

upgini/autofe/timeseries.py

@@ -1,200 +0,0 @@
-import abc
-from typing import Dict, List, Optional
-
-import pandas as pd
-from upgini.autofe.operator import PandasOperator, ParametrizedOperator
-
-try:
-    from pydantic import field_validator as validator  # V2
-except ImportError:
-    from pydantic import validator  # V1
-
-
-class TimeSeriesBase(PandasOperator, abc.ABC):
-    is_vector: bool = True
-    date_unit: Optional[str] = None
-    offset_size: int = 0
-    offset_unit: str = "D"
-
-    def get_params(self) -> Dict[str, Optional[str]]:
-        res = super().get_params()
-        res.update(
-            {
-                "date_unit": self.date_unit,
-                "offset_size": self.offset_size,
-                "offset_unit": self.offset_unit,
-            }
-        )
-        return res
-
-    def calculate_vector(self, data: List[pd.Series]) -> pd.Series:
-        # assuming first is date, last is value, rest is group columns
-        date = pd.to_datetime(data[0], unit=self.date_unit, errors="coerce")
-        ts = pd.concat([date] + data[1:], axis=1)
-        ts.drop_duplicates(subset=ts.columns[:-1], keep="first", inplace=True)
-        ts.set_index(date.name, inplace=True)
-        ts = ts[ts.index.notna()].sort_index()
-        ts = (
-            ts.groupby([c.name for c in data[1:-1]], group_keys=True)
-            .apply(self._shift)[data[-1].name]
-            .to_frame()
-            .reset_index()
-            .set_index(date.name)
-            .groupby([c.name for c in data[1:-1]])
-            if len(data) > 2
-            else self._shift(ts)
-        )
-        ts = self._aggregate(ts)
-        ts = ts.reindex(data[1:-1] + [date] if len(data) > 2 else date).reset_index()
-        ts.index = date.index
-
-        return ts.iloc[:, -1]
-
-    def _shift(self, ts: pd.DataFrame) -> pd.DataFrame:
-        if self.offset_size > 0:
-            return ts.iloc[:, :-1].merge(
-                ts.iloc[:, -1].shift(freq=f"{self.offset_size}{self.offset_unit}"),
-                left_index=True,
-                right_index=True,
-            )
-        return ts
-
-    @abc.abstractmethod
-    def _aggregate(self, ts: pd.DataFrame) -> pd.DataFrame:
-        pass
-
-
-_roll_aggregations = {"norm_mean": lambda x: x[-1] / x.mean(), "last": lambda x: x[-1]}
-
-
-class Roll(TimeSeriesBase, ParametrizedOperator):
-    aggregation: str
-    window_size: int = 1
-    window_unit: str = "D"
-
-    @validator("window_unit")
-    @classmethod
-    def validate_window_unit(cls, v: str) -> str:
-        try:
-            pd.tseries.frequencies.to_offset(v)
-            return v
-        except ValueError:
-            raise ValueError(
-                f"Invalid window_unit: {v}. Must be a valid pandas frequency string (e.g. 'D', 'H', 'T', etc)"
-            )
-
-    def to_formula(self) -> str:
-        roll_component = f"roll_{self.window_size}{self.window_unit}"
-        if self.offset_size > 0:
-            roll_component += f"_offset_{self.offset_size}{self.offset_unit}"
-        return f"{roll_component}_{self.aggregation}"
-
-    @classmethod
-    def from_formula(cls, formula: str) -> Optional["Roll"]:
-        import re
-
-        # Try matching pattern with offset first
-        pattern_with_offset = r"^roll_(\d+)([a-zA-Z])_offset_(\d+)([a-zA-Z])_(\w+)$"
-        match_with_offset = re.match(pattern_with_offset, formula)
-
-        if match_with_offset:
-            window_size = int(match_with_offset.group(1))
-            window_unit = match_with_offset.group(2)
-            offset_size = int(match_with_offset.group(3))
-            offset_unit = match_with_offset.group(4)
-            aggregation = match_with_offset.group(5)
-
-            return cls(
-                window_size=window_size,
-                window_unit=window_unit,
-                offset_size=offset_size,
-                offset_unit=offset_unit,
-                aggregation=aggregation,
-            )
-
-        # If no offset pattern found, try basic pattern
-        pattern = r"^roll_(\d+)([a-zA-Z])_(\w+)$"
-        match = re.match(pattern, formula)
-
-        if not match:
-            return None
-
-        window_size = int(match.group(1))
-        window_unit = match.group(2)
-        aggregation = match.group(3)
-
-        return cls(window_size=window_size, window_unit=window_unit, aggregation=aggregation)
-
-    def get_params(self) -> Dict[str, Optional[str]]:
-        res = super().get_params()
-        res.update(
-            {
-                "window_size": self.window_size,
-                "window_unit": self.window_unit,
-                "aggregation": self.aggregation,
-            }
-        )
-        return res
-
-    def _aggregate(self, ts: pd.DataFrame) -> pd.DataFrame:
-        return ts.rolling(f"{self.window_size}{self.window_unit}", min_periods=1).agg(
-            _roll_aggregations.get(self.aggregation, self.aggregation)
-        )
-
-
-class Lag(TimeSeriesBase, ParametrizedOperator):
-    lag_size: int
-    lag_unit: str = "D"
-
-    def to_formula(self) -> str:
-        lag_component = f"lag_{self.lag_size}{self.lag_unit}"
-        if self.offset_size > 0:
-            lag_component += f"_offset_{self.offset_size}{self.offset_unit}"
-        return lag_component
-
-    @classmethod
-    def from_formula(cls, formula: str) -> Optional["Lag"]:
-        import re
-
-        # Try matching pattern with offset first
-        pattern_with_offset = r"^lag_(\d+)([a-zA-Z])_offset_(\d+)([a-zA-Z])$"
-        match_with_offset = re.match(pattern_with_offset, formula)
-
-        if match_with_offset:
-            lag_size = int(match_with_offset.group(1))
-            lag_unit = match_with_offset.group(2)
-            offset_size = int(match_with_offset.group(3))
-            offset_unit = match_with_offset.group(4)
-
-            return cls(
-                lag_size=lag_size,
-                lag_unit=lag_unit,
-                offset_size=offset_size,
-                offset_unit=offset_unit,
-            )
-
-        # If no offset pattern found, try basic pattern
-        pattern = r"^lag_(\d+)([a-zA-Z])$"
-        match = re.match(pattern, formula)
-
-        if not match:
-            return None
-
-        lag_size = int(match.group(1))
-        lag_unit = match.group(2)
-
-        return cls(lag_size=lag_size, lag_unit=lag_unit)
-
-    def get_params(self) -> Dict[str, Optional[str]]:
-        res = super().get_params()
-        res.update(
-            {
-                "lag_size": self.lag_size,
-                "lag_unit": self.lag_unit,
-            }
-        )
-        return res
-
-    def _aggregate(self, ts: pd.DataFrame) -> pd.DataFrame:
-        lag_window = self.lag_size + 1
-        return ts.rolling(f"{lag_window}{self.lag_unit}", min_periods=lag_window).agg(lambda x: x[0])