upgini 1.2.20a3657.dev1__py3-none-any.whl → 1.2.22__py3-none-any.whl

upgini/__about__.py

@@ -1 +1 @@
-__version__ = "1.2.20a3657.dev1"
+__version__ = "1.2.22"

upgini/__init__.py

@@ -2,7 +2,6 @@ import os
 
 from upgini.features_enricher import FeaturesEnricher  # noqa: F401
 from upgini.metadata import SearchKey, CVType, RuntimeParameters, ModelTaskType  # noqa: F401
-
 # from .lazy_import import LazyImport
 
 os.environ["SETUPTOOLS_USE_DISTUTILS"] = "stdlib"

upgini/autofe/all_operands.py

@@ -1,5 +1,87 @@
-from upgini.autofe.operand import OperandRegistry
+from copy import deepcopy
+from typing import Dict
+
+from upgini.autofe.binary import (
+    Add,
+    Combine,
+    CombineThenFreq,
+    Distance,
+    Divide,
+    JaroWinklerSim1,
+    JaroWinklerSim2,
+    LevenshteinSim,
+    Max,
+    Min,
+    Multiply,
+    Sim,
+    Subtract,
+)
+from upgini.autofe.date import (
+    DateDiff,
+    DateDiffType2,
+    DateListDiff,
+    DateListDiffBounded,
+    DatePercentile,
+    DatePercentileMethod2,
+)
+from upgini.autofe.groupby import GroupByThenAgg, GroupByThenFreq, GroupByThenNUnique, GroupByThenRank
+from upgini.autofe.operand import Operand
+from upgini.autofe.unary import Abs, Embeddings, Floor, Freq, Log, Residual, Norm, Sigmoid, Sqrt, Square
+from upgini.autofe.vector import Mean, Sum
+
+ALL_OPERANDS: Dict[str, Operand] = {
+    op.name: op
+    for op in [
+        Freq(),
+        Mean(),
+        Sum(),
+        Abs(),
+        Log(),
+        Sqrt(),
+        Square(),
+        Sigmoid(),
+        Floor(),
+        Residual(),
+        Min(),
+        Max(),
+        Add(),
+        Subtract(),
+        Multiply(),
+        Divide(),
+        GroupByThenAgg(name="GroupByThenMin", agg="min"),
+        GroupByThenAgg(name="GroupByThenMax", agg="max"),
+        GroupByThenAgg(name="GroupByThenMean", agg="mean"),
+        GroupByThenAgg(name="GroupByThenMedian", agg="median"),
+        GroupByThenAgg(name="GroupByThenStd", output_type="float", agg="std"),
+        GroupByThenRank(),
+        Combine(),
+        CombineThenFreq(),
+        GroupByThenNUnique(),
+        GroupByThenFreq(),
+        Sim(),
+        DateDiff(),
+        DateDiffType2(),
+        DateListDiff(aggregation="min"),
+        DateListDiff(aggregation="max"),
+        DateListDiff(aggregation="mean"),
+        DateListDiff(aggregation="nunique"),
+        DateListDiffBounded(diff_unit="Y", aggregation="count", lower_bound=0, upper_bound=18),
+        DateListDiffBounded(diff_unit="Y", aggregation="count", lower_bound=18, upper_bound=23),
+        DateListDiffBounded(diff_unit="Y", aggregation="count", lower_bound=23, upper_bound=30),
+        DateListDiffBounded(diff_unit="Y", aggregation="count", lower_bound=30, upper_bound=45),
+        DateListDiffBounded(diff_unit="Y", aggregation="count", lower_bound=45, upper_bound=60),
+        DateListDiffBounded(diff_unit="Y", aggregation="count", lower_bound=60),
+        DatePercentile(),
+        DatePercentileMethod2(),
+        Norm(),
+        JaroWinklerSim1(),
+        JaroWinklerSim2(),
+        LevenshteinSim(),
+        Distance(),
+        Embeddings(),
+    ]
+}
 
 
 def find_op(name):
-    return OperandRegistry.get_operand(name)
+    return deepcopy(ALL_OPERANDS.get(name))

upgini/autofe/date.py

@@ -7,11 +7,11 @@ import pandas as pd
 from pandas.core.arrays.timedeltas import TimedeltaArray
 from pydantic import BaseModel, __version__ as pydantic_version
 
-from upgini.autofe.operand import PandasOperand, ParametrizedOperand
+from upgini.autofe.operand import PandasOperand
 
 
 def get_pydantic_version():
-    major_version = int(pydantic_version.split(".")[0])
+    major_version = int(pydantic_version.split('.')[0])
     return major_version
 
 
@@ -109,7 +109,7 @@ _ext_aggregations = {"nunique": (lambda x: len(np.unique(x)), 0), "count": (len,
 _count_aggregations = ["nunique", "count"]
 
 
-class DateListDiff(PandasOperand, DateDiffMixin, ParametrizedOperand):
+class DateListDiff(PandasOperand, DateDiffMixin):
     is_binary: bool = True
     has_symmetry_importance: bool = True
 
@@ -134,15 +134,6 @@ class DateListDiff(PandasOperand, DateDiffMixin, ParametrizedOperand):
             data["name"] = f"date_diff_{data.get('aggregation')}"
         super().__init__(**data)
 
-    @classmethod
-    def from_formula(cls, formula: str) -> Optional["DateListDiff"]:
-        if not formula.startswith("date_diff_"):
-            return None
-        aggregation = formula.replace("date_diff_", "")
-        if "_" in aggregation:
-            return None
-        return cls(aggregation=aggregation)
-
     def calculate_binary(self, left: pd.Series, right: pd.Series) -> pd.Series:
         left = self._convert_to_date(left, self.left_unit)
         right_mask = right.apply(lambda x: len(x) > 0)
@@ -179,7 +170,7 @@ class DateListDiff(PandasOperand, DateDiffMixin, ParametrizedOperand):
         return method(x) if len(x) > 0 else default
 
 
-class DateListDiffBounded(DateListDiff, ParametrizedOperand):
+class DateListDiffBounded(DateListDiff):
     lower_bound: Optional[int] = None
     upper_bound: Optional[int] = None
 
@@ -197,23 +188,6 @@ class DateListDiffBounded(DateListDiff, ParametrizedOperand):
             data["name"] = "_".join(components)
         super().__init__(**data)
 
-    @classmethod
-    def from_formula(cls, formula: str) -> Optional["DateListDiffBounded"]:
-        import re
-
-        pattern = r"^date_diff_([^_]+)_((minusinf|\d+))_((plusinf|\d+))_(\w+)$"
-        match = re.match(pattern, formula)
-
-        if not match:
-            return None
-
-        diff_unit = match.group(1)
-        lower_bound = None if match.group(2) == "minusinf" else int(match.group(2))
-        upper_bound = None if match.group(4) == "plusinf" else int(match.group(4))
-        aggregation = match.group(6)
-
-        return cls(diff_unit=diff_unit, lower_bound=lower_bound, upper_bound=upper_bound, aggregation=aggregation)
-
     def _agg(self, x):
         x = x[
             (x >= (self.lower_bound if self.lower_bound is not None else -np.inf))
@@ -283,17 +257,16 @@ class DatePercentile(DatePercentileBase):
         # Use @field_validator for Pydantic 2.x
         from pydantic import field_validator
 
-        @field_validator("zero_bounds", mode="before")
+        @field_validator('zero_bounds', mode='before')
         def parse_zero_bounds(cls, value):
             if isinstance(value, str):
                 return json.loads(value)
             return value
-
     else:
         # Use @validator for Pydantic 1.x
         from pydantic import validator
 
-        @validator("zero_bounds", pre=True)
+        @validator('zero_bounds', pre=True)
         def parse_zero_bounds(cls, value):
             if isinstance(value, str):
                 return json.loads(value)

upgini/autofe/operand.py

@@ -6,47 +6,7 @@ import pandas as pd
 from pydantic import BaseModel
 
 
-class OperandRegistry(type(BaseModel)):
-    _registry = {}
-    _parametrized_registry = []
-
-    def __new__(cls, name, bases, attrs):
-        new_class = super().__new__(cls, name, bases, attrs)
-        # Only register if it's a concrete class that inherits from Operand
-        base_classes = [b for b in bases]
-        base_names = {b.__name__ for b in bases}
-        while base_classes:
-            base = base_classes.pop()
-            base_names.update(b.__name__ for b in base.__bases__)
-            base_classes.extend(base.__bases__)
-
-        if "Operand" in base_names:
-            # Track parametrized operands separately
-            if "ParametrizedOperand" in base_names:
-                cls._parametrized_registry.append(new_class)
-            else:
-                try:
-                    instance = new_class()
-                    cls._registry[instance.name] = new_class
-                except Exception:
-                    pass
-        return new_class
-
-    @classmethod
-    def get_operand(cls, name: str) -> Optional["Operand"]:
-        # First try to resolve as a parametrized operand formula
-        for operand_cls in cls._parametrized_registry:
-            resolved = operand_cls.from_formula(name)
-            if resolved is not None:
-                return resolved
-        # Fall back to direct registry lookup
-        non_parametrized = cls._registry.get(name)
-        if non_parametrized is not None:
-            return non_parametrized()
-        return None
-
-
-class Operand(BaseModel, metaclass=OperandRegistry):
+class Operand(BaseModel):
     name: str
     alias: Optional[str] = None
     is_unary: bool = False
@@ -72,12 +32,6 @@ class Operand(BaseModel, metaclass=OperandRegistry):
         return res
 
 
-class ParametrizedOperand(Operand):
-    @classmethod
-    def from_formula(cls, formula: str) -> Optional["Operand"]:
-        pass
-
-
 MAIN_COLUMN = "main_column"
 
 

upgini/autofe/vector.py

@@ -1,10 +1,8 @@
-import abc
-from typing import Any, Dict, List, Optional
+from typing import List, Optional
 
 import pandas as pd
-from pydantic import validator
 
-from upgini.autofe.operand import PandasOperand, ParametrizedOperand, VectorizableMixin
+from upgini.autofe.operand import PandasOperand, VectorizableMixin
 
 
 class Mean(PandasOperand, VectorizableMixin):
@@ -24,132 +22,3 @@ class Sum(PandasOperand, VectorizableMixin):
 
     def calculate_vector(self, data: List[pd.Series]) -> pd.Series:
         return pd.DataFrame(data).T.fillna(0).sum(axis=1)
-
-
-class TimeSeriesBase(PandasOperand, abc.ABC):
-    is_vector: bool = True
-    date_unit: Optional[str] = None
-
-    def get_params(self) -> Dict[str, Optional[str]]:
-        res = super().get_params()
-        res.update(
-            {
-                "date_unit": self.date_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]]) if len(data) > 2 else ts
-        ts = self._aggregate(ts)
-        ts = ts.reindex(data[1:-1] + [date] if len(data) > 2 else date).reset_index()
-
-        return ts.iloc[:, -1]
-
-    @abc.abstractmethod
-    def _aggregate(self, ts: pd.DataFrame) -> pd.DataFrame:
-        pass
-
-
-_roll_aggregations = {"norm_mean": lambda x: x[-1] / x.mean()}
-
-
-class Roll(TimeSeriesBase, ParametrizedOperand):
-    aggregation: str
-    window_size: int = 1
-    window_unit: str = "D"
-
-    @validator("window_unit")
-    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 __init__(self, **data: Any) -> None:
-        if "name" not in data:
-            components = [
-                "roll",
-                str(data.get("window_size") or 1) + str(data.get("window_unit") or "D"),
-                data.get("aggregation"),
-            ]
-            data["name"] = "_".join(components).lower()
-        super().__init__(**data)
-
-    @classmethod
-    def from_formula(cls, formula: str) -> Optional["Roll"]:
-        import re
-
-        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=self.window_size).agg(
-            _roll_aggregations.get(self.aggregation, self.aggregation)
-        )
-
-
-class Lag(TimeSeriesBase, ParametrizedOperand):
-    lag_size: int
-    lag_unit: str = "D"
-
-    def __init__(self, **data: Any) -> None:
-        if "name" not in data:
-            components = [
-                "lag",
-                str(data.get("lag_size") or 1) + str(data.get("lag_unit") or "D"),
-            ]
-            data["name"] = "_".join(components).lower()
-        super().__init__(**data)
-
-    @classmethod
-    def from_formula(cls, formula: str) -> Optional["Lag"]:
-        import re
-
-        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()
-        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])

upgini/features_enricher.py

@@ -228,7 +228,7 @@ class FeaturesEnricher(TransformerMixin):
     ):
         self.bundle = get_custom_bundle(custom_bundle_config)
         self._api_key = api_key or os.environ.get(UPGINI_API_KEY)
-        if api_key is not None and not isinstance(api_key, str):
+        if self._api_key is not None and not isinstance(self._api_key, str):
             raise ValidationError(f"api_key should be `string`, but passed: `{api_key}`")
         self.rest_client = get_rest_client(endpoint, self._api_key, client_ip, client_visitorid)
         self.client_ip = client_ip
@@ -259,7 +259,9 @@ class FeaturesEnricher(TransformerMixin):
         self.eval_set: Optional[List[Tuple]] = None
         self.autodetected_search_keys: Dict[str, SearchKey] = {}
         self.imbalanced = False
-        self.__cached_sampled_datasets: Optional[Tuple[pd.DataFrame, pd.DataFrame, pd.Series, Dict, Dict, Dict]] = None
+        self.__cached_sampled_datasets: Dict[str, Tuple[pd.DataFrame, pd.DataFrame, pd.Series, Dict, Dict, Dict]] = (
+            dict()
+        )
 
         validate_version(self.logger)
         self.search_keys = search_keys or {}
@@ -1583,9 +1585,11 @@ class FeaturesEnricher(TransformerMixin):
         progress_bar: Optional[ProgressBar],
         progress_callback: Optional[Callable[[SearchProgress], Any]],
     ) -> _SampledDataForMetrics:
-        if self.__cached_sampled_datasets is not None and is_input_same_as_fit and remove_outliers_calc_metrics is None:
+        datasets_hash = hash_input(validated_X, validated_y, eval_set)
+        cached_sampled_datasets = self.__cached_sampled_datasets.get(datasets_hash)
+        if cached_sampled_datasets is not None and is_input_same_as_fit and remove_outliers_calc_metrics is None:
             self.logger.info("Cached enriched dataset found - use it")
-            return self.__get_sampled_cached_enriched(exclude_features_sources)
+            return self.__get_sampled_cached_enriched(datasets_hash, exclude_features_sources)
         elif len(self.feature_importances_) == 0:
             self.logger.info("No external features selected. So use only input datasets for metrics calculation")
             return self.__sample_only_input(validated_X, validated_y, eval_set, is_demo_dataset)
@@ -1615,9 +1619,11 @@ class FeaturesEnricher(TransformerMixin):
                 progress_callback,
             )
 
-    def __get_sampled_cached_enriched(self, exclude_features_sources: Optional[List[str]]) -> _SampledDataForMetrics:
+    def __get_sampled_cached_enriched(
+        self, datasets_hash: str, exclude_features_sources: Optional[List[str]]
+    ) -> _SampledDataForMetrics:
         X_sampled, y_sampled, enriched_X, eval_set_sampled_dict, search_keys, columns_renaming = (
-            self.__cached_sampled_datasets
+            self.__cached_sampled_datasets[datasets_hash]
         )
         if exclude_features_sources:
             enriched_X = enriched_X.drop(columns=exclude_features_sources, errors="ignore")
@@ -1692,7 +1698,9 @@ class FeaturesEnricher(TransformerMixin):
                 eval_y_sampled = eval_xy_sampled[TARGET].copy()
                 enriched_eval_X = eval_X_sampled
                 eval_set_sampled_dict[idx] = (eval_X_sampled, enriched_eval_X, eval_y_sampled)
-        self.__cached_sampled_datasets = (
+
+        datasets_hash = hash_input(X_sampled, y_sampled, eval_set_sampled_dict)
+        self.__cached_sampled_datasets[datasets_hash] = (
             X_sampled,
             y_sampled,
             enriched_X,
@@ -1770,7 +1778,8 @@ class FeaturesEnricher(TransformerMixin):
                 enriched_eval_X = enriched_eval_sets[idx + 1][enriched_X_columns].copy()
                 eval_set_sampled_dict[idx] = (eval_X_sampled, enriched_eval_X, eval_y_sampled)
 
-        self.__cached_sampled_datasets = (
+        datasets_hash = hash_input(self.X, self.y, self.eval_set)
+        self.__cached_sampled_datasets[datasets_hash] = (
             X_sampled,
             y_sampled,
             enriched_X,
@@ -1895,7 +1904,8 @@ class FeaturesEnricher(TransformerMixin):
             y_sampled = enriched_Xy[TARGET].copy()
             enriched_X = enriched_Xy.drop(columns=TARGET)
 
-        self.__cached_sampled_datasets = (
+        datasets_hash = hash_input(X_sampled, y_sampled, eval_set_sampled_dict)
+        self.__cached_sampled_datasets[datasets_hash] = (
             X_sampled,
             y_sampled,
             enriched_X,
@@ -2426,7 +2436,7 @@ class FeaturesEnricher(TransformerMixin):
     ):
         self.warning_counter.reset()
         self.df_with_original_index = None
-        self.__cached_sampled_datasets = None
+        self.__cached_sampled_datasets = dict()
         self.metrics = None
         self.fit_columns_renaming = None
         self.fit_dropped_features = set()
@@ -2533,7 +2543,11 @@ class FeaturesEnricher(TransformerMixin):
         # Checks that need validated date
         validate_dates_distribution(df, self.fit_search_keys, self.logger, self.bundle, self.warning_counter)
 
-        if is_numeric_dtype(df[self.TARGET_NAME]) and has_date:
+        if (
+            is_numeric_dtype(df[self.TARGET_NAME])
+            and self.model_task_type in [ModelTaskType.BINARY, ModelTaskType.MULTICLASS]
+            and has_date
+        ):
             self._validate_PSI(df.sort_values(by=maybe_date_column))
 
         normalizer = Normalizer(self.bundle, self.logger, self.warning_counter)
@@ -4196,6 +4210,8 @@ def hash_input(X: pd.DataFrame, y: Optional[pd.Series] = None, eval_set: Optiona
         if y is not None:
             hashed_objects.append(pd.util.hash_pandas_object(y, index=False).values)
         if eval_set is not None:
+            if isinstance(eval_set, tuple):
+                eval_set = [eval_set]
             for eval_X, eval_y in eval_set:
                 hashed_objects.append(pd.util.hash_pandas_object(eval_X, index=False).values)
                 hashed_objects.append(pd.util.hash_pandas_object(eval_y, index=False).values)

{upgini-1.2.20a3657.dev1.dist-info → upgini-1.2.22.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: upgini
-Version: 1.2.20a3657.dev1
+Version: 1.2.22
 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.20a3657.dev1.dist-info → upgini-1.2.22.dist-info}/RECORD

@@ -1,9 +1,9 @@
-upgini/__about__.py,sha256=YkZ_uLYHtqgChcjML_VbuHRPzZ0weOtfhilztAaEx10,33
-upgini/__init__.py,sha256=Mb_sTh-IiGiyQLExOF226RsqnpVH8u1ozaCSW3Scdx4,590
+upgini/__about__.py,sha256=P6UdnfqZMN8bM1yBQGaUu5LMabVISCCurCBNtZJOvTE,23
+upgini/__init__.py,sha256=M64LwQTBa-5Jz24Zm2h8rWwlKQQ1J8nP7gGgIciS0WU,589
 upgini/ads.py,sha256=nvuRxRx5MHDMgPr9SiU-fsqRdFaBv8p4_v1oqiysKpc,2714
 upgini/dataset.py,sha256=iPFiMJtk4HF1ytw9wCQr8H9RfoOKj_TIo8XYZKWgcMc,31331
 upgini/errors.py,sha256=2b_Wbo0OYhLUbrZqdLIx5jBnAsiD1Mcenh-VjR4HCTw,950
-upgini/features_enricher.py,sha256=RAeZFb_0VA23rHjWXo2hKEhoTxp0z9PdFD3KhCSOS_0,192779
+upgini/features_enricher.py,sha256=CK_ymyXeS0JxzBxy2y2UJ7miwy0DUcwdJdJBoFNY0IE,193511
 upgini/http.py,sha256=21asexflvavydzCOONJDGQBtQanCElrbnqLXakJ9Cu8,42880
 upgini/lazy_import.py,sha256=74gQ8JuA48BGRLxAo7lNHNKY2D2emMxrUxKGdxVGhuY,1012
 upgini/metadata.py,sha256=osmzdNESeh7yP3BZday6N9Q3eaIHfzhhRM1d6NSgcf0,11223
@@ -14,14 +14,14 @@ upgini/version_validator.py,sha256=ddSKUK_-eGJB3NgrqOMoWJU-OxQ253WsNLp8aqJkaIM,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=z3RSj98mkIXOkkmXHVCV7ese6V6rgD4uXyHge65HMVA,116
+upgini/autofe/all_operands.py,sha256=cCCB44qvkmuWyiRM5Xykx8tkHPIjQthrWyj67STWN80,2578
 upgini/autofe/binary.py,sha256=zMhtHVuGUAFLUqem-XiXqJj-GRXxS88tdz8tFuDfSNM,7659
-upgini/autofe/date.py,sha256=kC1oQ_LKaqq-JTiqzIbUti-JB3bWizaB5nvXQ_BoD6Y,10780
+upgini/autofe/date.py,sha256=OpFc3Al0xO3qlESn2Uokfxw51ArVqmh3xngWwdrsaqE,9762
 upgini/autofe/feature.py,sha256=eL7wABUhDKZzv3E-RPJNcyGwSfB0UptcfU2RbvsOks4,15082
 upgini/autofe/groupby.py,sha256=r-xl_keZZgm_tpiEoDhjYSkT6NHv7a4cRQR4wJ4uCp8,3263
-upgini/autofe/operand.py,sha256=sEyFD_SdQ5tqJ5yGUZlXSqUnQb6WxOqZ0bMS6oKDjdU,4593
+upgini/autofe/operand.py,sha256=uk883RaNqgXqtkaRqA1re1d9OFnnpv0JVvelYx09Yw0,2943
 upgini/autofe/unary.py,sha256=T3E7F3dA_7o_rkdCFq7JV6nHLzcoHLHQTcxO7y5Opa4,4646
-upgini/autofe/vector.py,sha256=KBoEcRywc1xdgYLCPlkUnKi5w0wCF0j3IYQP5eSmmgY,4807
+upgini/autofe/vector.py,sha256=ehcZUDqV71TfbU8EmKfdYp603gS2dJY_-fpr10ho5sI,663
 upgini/data_source/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 upgini/data_source/data_source_publisher.py,sha256=X-8aGtVgzGmxyXkMVBoBLIGDMb4lYQaGZbxDnOd4A3Q,22516
 upgini/mdc/__init__.py,sha256=aM08nIWFc2gWdWUa3_IuEnNND0cQPkBGnYpRMnfFN8k,1019
@@ -57,7 +57,7 @@ upgini/utils/sklearn_ext.py,sha256=13jQS_k7v0aUtudXV6nGUEWjttPQzAW9AFYL5wgEz9k,4
 upgini/utils/target_utils.py,sha256=qHzZRmICFbLNCrmVqGkaBcjm91L2ERRZMppci36acV4,10085
 upgini/utils/track_info.py,sha256=G5Lu1xxakg2_TQjKZk4b5SvrHsATTXNVV3NbvWtT8k8,5663
 upgini/utils/warning_counter.py,sha256=dIWBB4dI5XRRJZudvIlqlIYKEiwLLPcXarsZuYRt338,227
-upgini-1.2.20a3657.dev1.dist-info/METADATA,sha256=bgrk-SB81K0mrOkFRfrSl04-TuA2wxZWIbYdQOJePKA,48588
-upgini-1.2.20a3657.dev1.dist-info/WHEEL,sha256=zEMcRr9Kr03x1ozGwg5v9NQBKn3kndp6LSoSlVg-jhU,87
-upgini-1.2.20a3657.dev1.dist-info/licenses/LICENSE,sha256=5RRzgvdJUu3BUDfv4bzVU6FqKgwHlIay63pPCSmSgzw,1514
-upgini-1.2.20a3657.dev1.dist-info/RECORD,,
+upgini-1.2.22.dist-info/METADATA,sha256=xz213bCp7FlucAgHEqT8KlX7G0E_BMwP3wN444cz3QU,48578
+upgini-1.2.22.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
+upgini-1.2.22.dist-info/licenses/LICENSE,sha256=5RRzgvdJUu3BUDfv4bzVU6FqKgwHlIay63pPCSmSgzw,1514
+upgini-1.2.22.dist-info/RECORD,,

{upgini-1.2.20a3657.dev1.dist-info → upgini-1.2.22.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.24.2
+Generator: hatchling 1.25.0
 Root-Is-Purelib: true
 Tag: py3-none-any