upgini 1.2.56a3818.dev1__tar.gz → 1.2.56a3818.dev2__tar.gz

{upgini-1.2.56a3818.dev1 → upgini-1.2.56a3818.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: upgini
-Version: 1.2.56a3818.dev1
+Version: 1.2.56a3818.dev2
 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.56a3818.dev2/src/upgini/__about__.py

@@ -0,0 +1 @@
+__version__ = "1.2.56a3818.dev2"

{upgini-1.2.56a3818.dev1 → upgini-1.2.56a3818.dev2}/src/upgini/autofe/vector.py

@@ -54,20 +54,31 @@ class TimeSeriesBase(PandasOperand, abc.ABC):
         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()
-        if self.offset_size > 0:
-            ts = ts.iloc[:, :-1].merge(
-                ts.iloc[:, -1].shift(freq=f"{self.offset_size}{self.offset_unit}"),
-                left_index=True,
-                right_index=True,
-                how="left",
-            )
-        ts = ts.groupby([c.name for c in data[1:-1]]) if len(data) > 2 else ts
+        ts = (
+            ts.groupby([c.name for c in data[1:-1]])
+            .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
@@ -93,12 +104,35 @@ class Roll(TimeSeriesBase, ParametrizedOperand):
             )
 
     def to_formula(self) -> str:
-        return f"roll_{self.window_size}{self.window_unit}_{self.aggregation}"
+        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)
 
@@ -133,12 +167,33 @@ class Lag(TimeSeriesBase, ParametrizedOperand):
     lag_unit: str = "D"
 
     def to_formula(self) -> str:
-        return f"lag_{self.lag_size}{self.lag_unit}"
+        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)
 
@@ -152,6 +207,12 @@ class Lag(TimeSeriesBase, ParametrizedOperand):
 
     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:

upgini-1.2.56a3818.dev1/src/upgini/__about__.py

@@ -1 +0,0 @@
-__version__ = "1.2.56a3818.dev1"