upgini 1.1.317__py3-none-any.whl → 1.2.0a1__py3-none-any.whl

upgini/__about__.py

@@ -1 +1 @@
-__version__ = "1.1.317"
+__version__ = "1.2.0a1"

upgini/autofe/binary.py

@@ -9,32 +9,32 @@ from upgini.autofe.operand import PandasOperand, VectorizableMixin
 
 
 class Min(PandasOperand):
-    name = "min"
-    is_binary = True
-    is_symmetrical = True
-    has_symmetry_importance = True
+    name: str = "min"
+    is_binary: bool = True
+    is_symmetrical: bool = True
+    has_symmetry_importance: bool = True
 
     def calculate_binary(self, left: pd.Series, right: pd.Series) -> pd.Series:
         return np.minimum(left, right)
 
 
 class Max(PandasOperand):
-    name = "max"
-    is_binary = True
-    is_symmetrical = True
-    has_symmetry_importance = True
+    name: str = "max"
+    is_binary: bool = True
+    is_symmetrical: bool = True
+    has_symmetry_importance: bool = True
 
     def calculate_binary(self, left: pd.Series, right: pd.Series) -> pd.Series:
         return np.maximum(left, right)
 
 
 class Add(PandasOperand, VectorizableMixin):
-    name = "+"
-    alias = "add"
-    is_binary = True
-    is_symmetrical = True
-    has_symmetry_importance = True
-    is_vectorizable = True
+    name: str = "+"
+    alias: str = "add"
+    is_binary: bool = True
+    is_symmetrical: bool = True
+    has_symmetry_importance: bool = True
+    is_vectorizable: bool = True
 
     def calculate_binary(self, left: pd.Series, right: pd.Series) -> pd.Series:
         return left + right
@@ -48,12 +48,12 @@ class Add(PandasOperand, VectorizableMixin):
 
 
 class Subtract(PandasOperand, VectorizableMixin):
-    name = "-"
-    alias = "sub"
-    is_binary = True
-    is_symmetrical = True
-    has_symmetry_importance = True
-    is_vectorizable = True
+    name: str = "-"
+    alias: str = "sub"
+    is_binary: bool = True
+    is_symmetrical: bool = True
+    has_symmetry_importance: bool = True
+    is_vectorizable: bool = True
 
     def calculate_binary(self, left: pd.Series, right: pd.Series) -> pd.Series:
         return left - right
@@ -67,12 +67,12 @@ class Subtract(PandasOperand, VectorizableMixin):
 
 
 class Multiply(PandasOperand, VectorizableMixin):
-    name = "*"
-    alias = "mul"
-    is_binary = True
-    is_symmetrical = True
-    has_symmetry_importance = True
-    is_vectorizable = True
+    name: str = "*"
+    alias: str = "mul"
+    is_binary: bool = True
+    is_symmetrical: bool = True
+    has_symmetry_importance: bool = True
+    is_vectorizable: bool = True
 
     def calculate_binary(self, left: pd.Series, right: pd.Series) -> pd.Series:
         return left * right
@@ -86,12 +86,12 @@ class Multiply(PandasOperand, VectorizableMixin):
 
 
 class Divide(PandasOperand, VectorizableMixin):
-    name = "/"
-    alias = "div"
-    is_binary = True
-    has_symmetry_importance = True
-    is_vectorizable = True
-    output_type = "float"
+    name: str = "/"
+    alias: str = "div"
+    is_binary: bool = True
+    has_symmetry_importance: bool = True
+    is_vectorizable: bool = True
+    output_type: Optional[str] = "float"
 
     def calculate_binary(self, left: pd.Series, right: pd.Series) -> pd.Series:
         return left / right.replace(0, np.nan)
@@ -105,10 +105,10 @@ class Divide(PandasOperand, VectorizableMixin):
 
 
 class Combine(PandasOperand):
-    name = "Combine"
-    is_binary = True
-    has_symmetry_importance = True
-    output_type = "object"
+    name: str = "Combine"
+    is_binary: bool = True
+    has_symmetry_importance: bool = True
+    output_type: Optional[str] = "object"
 
     def calculate_binary(self, left: pd.Series, right: pd.Series) -> pd.Series:
         temp = left.astype(str) + "_" + right.astype(str)
@@ -117,13 +117,13 @@ class Combine(PandasOperand):
 
 
 class CombineThenFreq(PandasOperand):
-    name = "CombineThenFreq"
-    is_binary = True
-    is_symmetrical = True
-    has_symmetry_importance = True
-    output_type = "float"
-    is_distribution_dependent = True
-    input_type = "discrete"
+    name: str = "CombineThenFreq"
+    is_binary: bool = True
+    is_symmetrical: bool = True
+    has_symmetry_importance: bool = True
+    output_type: Optional[str] = "float"
+    is_distribution_dependent: bool = True
+    input_type: Optional[str] = "discrete"
 
     def calculate_binary(self, left: pd.Series, right: pd.Series) -> pd.Series:
         temp = left.astype(str) + "_" + right.astype(str)
@@ -133,11 +133,11 @@ class CombineThenFreq(PandasOperand):
 
 
 class Distance(PandasOperand):
-    name = "dist"
-    is_binary = True
-    output_type = "float"
-    is_symmetrical = True
-    has_symmetry_importance = True
+    name: str = "dist"
+    is_binary: bool = True
+    output_type: Optional[str] = "float"
+    is_symmetrical: bool = True
+    has_symmetry_importance: bool = True
 
     def calculate_binary(self, left: pd.Series, right: pd.Series) -> pd.Series:
         return pd.Series(
@@ -158,11 +158,11 @@ class Distance(PandasOperand):
 
 # Left for backward compatibility
 class Sim(Distance):
-    name = "sim"
-    is_binary = True
-    output_type = "float"
-    is_symmetrical = True
-    has_symmetry_importance = True
+    name: str = "sim"
+    is_binary: bool = True
+    output_type: Optional[str] = "float"
+    is_symmetrical: bool = True
+    has_symmetry_importance: bool = True
 
     def calculate_binary(self, left: pd.Series, right: pd.Series) -> pd.Series:
         return 1 - super().calculate_binary(left, right)
@@ -191,12 +191,12 @@ class StringSim(PandasOperand, abc.ABC):
 
 
 class JaroWinklerSim1(StringSim):
-    name = "sim_jw1"
-    is_binary = True
-    input_type = "string"
-    output_type = "float"
-    is_symmetrical = True
-    has_symmetry_importance = True
+    name: str = "sim_jw1"
+    is_binary: bool = True
+    input_type: Optional[str] = "string"
+    output_type: Optional[str] = "float"
+    is_symmetrical: bool = True
+    has_symmetry_importance: bool = True
 
     def _prepare_value(self, value: Optional[str]) -> Optional[str]:
         return value
@@ -206,12 +206,12 @@ class JaroWinklerSim1(StringSim):
 
 
 class JaroWinklerSim2(StringSim):
-    name = "sim_jw2"
-    is_binary = True
-    input_type = "string"
-    output_type = "float"
-    is_symmetrical = True
-    has_symmetry_importance = True
+    name: str = "sim_jw2"
+    is_binary: bool = True
+    input_type: Optional[str] = "string"
+    output_type: Optional[str] = "float"
+    is_symmetrical: bool = True
+    has_symmetry_importance: bool = True
 
     def _prepare_value(self, value: Optional[str]) -> Optional[str]:
         return value[::-1] if value is not None else None
@@ -221,12 +221,12 @@ class JaroWinklerSim2(StringSim):
 
 
 class LevenshteinSim(StringSim):
-    name = "sim_lv"
-    is_binary = True
-    input_type = "string"
-    output_type = "float"
-    is_symmetrical = True
-    has_symmetry_importance = True
+    name: str = "sim_lv"
+    is_binary: bool = True
+    input_type: Optional[str] = "string"
+    output_type: Optional[str] = "float"
+    is_symmetrical: bool = True
+    has_symmetry_importance: bool = True
 
     def _prepare_value(self, value: Optional[str]) -> Optional[str]:
         return value

upgini/autofe/date.py

@@ -5,11 +5,16 @@ from typing import Any, Dict, List, Optional, Union
 import numpy as np
 import pandas as pd
 from pandas.core.arrays.timedeltas import TimedeltaArray
-from pydantic import BaseModel, validator
+from pydantic import BaseModel, __version__ as pydantic_version
 
 from upgini.autofe.operand import PandasOperand
 
 
+def get_pydantic_version():
+    major_version = int(pydantic_version.split('.')[0])
+    return major_version
+
+
 class DateDiffMixin(BaseModel):
     diff_unit: str = "D"
     left_unit: Optional[str] = None
@@ -39,10 +44,10 @@ class DateDiffMixin(BaseModel):
 
 
 class DateDiff(PandasOperand, DateDiffMixin):
-    name = "date_diff"
-    alias = "date_diff_type1"
-    is_binary = True
-    has_symmetry_importance = True
+    name: str = "date_diff"
+    alias: Optional[str] = "date_diff_type1"
+    is_binary: bool = True
+    has_symmetry_importance: bool = True
 
     replace_negative: bool = False
 
@@ -71,9 +76,9 @@ class DateDiff(PandasOperand, DateDiffMixin):
 
 
 class DateDiffType2(PandasOperand, DateDiffMixin):
-    name = "date_diff_type2"
-    is_binary = True
-    has_symmetry_importance = True
+    name: str = "date_diff_type2"
+    is_binary: bool = True
+    has_symmetry_importance: bool = True
 
     def get_params(self) -> Dict[str, Optional[str]]:
         res = super().get_params()
@@ -105,8 +110,8 @@ _count_aggregations = ["nunique", "count"]
 
 
 class DateListDiff(PandasOperand, DateDiffMixin):
-    is_binary = True
-    has_symmetry_importance = True
+    is_binary: bool = True
+    has_symmetry_importance: bool = True
 
     aggregation: str
     replace_negative: bool = False
@@ -166,8 +171,8 @@ class DateListDiff(PandasOperand, DateDiffMixin):
 
 
 class DateListDiffBounded(DateListDiff):
-    lower_bound: Optional[int]
-    upper_bound: Optional[int]
+    lower_bound: Optional[int] = None
+    upper_bound: Optional[int] = None
 
     def __init__(self, **data: Any) -> None:
         if "name" not in data:
@@ -192,8 +197,8 @@ class DateListDiffBounded(DateListDiff):
 
 
 class DatePercentileBase(PandasOperand, abc.ABC):
-    is_binary = True
-    output_type = "float"
+    is_binary: bool = True
+    output_type: Optional[str] = "float"
 
     date_unit: Optional[str] = None
 
@@ -227,12 +232,12 @@ class DatePercentileBase(PandasOperand, abc.ABC):
 
 
 class DatePercentile(DatePercentileBase):
-    name = "date_per"
-    alias = "date_per_method1"
+    name: str = "date_per"
+    alias: Optional[str] = "date_per_method1"
 
-    zero_month: Optional[int]
-    zero_year: Optional[int]
-    zero_bounds: Optional[List[float]]
+    zero_month: Optional[int] = None
+    zero_year: Optional[int] = None
+    zero_bounds: Optional[List[float]] = None
     step: int = 30
 
     def get_params(self) -> Dict[str, Optional[str]]:
@@ -247,12 +252,25 @@ class DatePercentile(DatePercentileBase):
         )
         return res
 
-    @validator("zero_bounds", pre=True)
-    def validate_bounds(cls, value):
-        if value is None or isinstance(value, list):
+    # Check Pydantic version
+    if get_pydantic_version() >= 2:
+        # Use @field_validator for Pydantic 2.x
+        from pydantic import field_validator
+
+        @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)
+        def parse_zero_bounds(cls, value):
+            if isinstance(value, str):
+                return json.loads(value)
             return value
-        elif isinstance(value, str):
-            return json.loads(value)
 
     def _get_bounds(self, date_col: pd.Series) -> pd.Series:
         months = date_col.dt.month
@@ -265,7 +283,7 @@ class DatePercentile(DatePercentileBase):
 
 
 class DatePercentileMethod2(DatePercentileBase):
-    name = "date_per_method2"
+    name: str = "date_per_method2"
 
     def _get_bounds(self, date_col: pd.Series) -> pd.Series:
         pass

upgini/autofe/groupby.py

@@ -7,9 +7,9 @@ from upgini.autofe.operand import PandasOperand, VectorizableMixin
 
 class GroupByThenAgg(PandasOperand, VectorizableMixin):
     agg: Optional[str]
-    is_vectorizable = True
-    is_grouping = True
-    is_distribution_dependent = True
+    is_vectorizable: bool = True
+    is_grouping: bool = True
+    is_distribution_dependent: bool = True
 
     def calculate_binary(self, left: pd.Series, right: pd.Series) -> pd.Series:
         temp = left.groupby(right).agg(self.agg)
@@ -24,17 +24,17 @@ class GroupByThenAgg(PandasOperand, VectorizableMixin):
 
 
 class GroupByThenMedian(GroupByThenAgg):
-    name = "GroupByThenMedian"
-    pandas_agg = "median"
-    is_distribution_dependent = True
+    name: str = "GroupByThenMedian"
+    pandas_agg: str = "median"
+    is_distribution_dependent: bool = True
 
 
 class GroupByThenRank(PandasOperand, VectorizableMixin):
-    name = "GroupByThenRank"
-    is_vectorizable = True
-    is_grouping = True
-    output_type = "float"
-    is_distribution_dependent = True
+    name: str = "GroupByThenRank"
+    is_vectorizable: bool = True
+    is_grouping: bool = True
+    output_type: Optional[str] = "float"
+    is_distribution_dependent: bool = True
 
     def calculate_binary(self, left: pd.Series, right: pd.Series) -> pd.Series:
         temp = pd.DataFrame(left[~right.isna()].groupby(right).rank(ascending=True, pct=True)).reset_index()
@@ -49,12 +49,12 @@ class GroupByThenRank(PandasOperand, VectorizableMixin):
 
 
 class GroupByThenNUnique(PandasOperand, VectorizableMixin):
-    name = "GroupByThenNUnique"
-    is_vectorizable = True
-    is_grouping = True
-    output_type = "int"
-    is_distribution_dependent = True
-    input_type = "discrete"
+    name: str = "GroupByThenNUnique"
+    is_vectorizable: bool = True
+    is_grouping: bool = True
+    output_type: Optional[str] = "int"
+    is_distribution_dependent: bool = True
+    input_type: Optional[str] = "discrete"
 
     def calculate_binary(self, left: pd.Series, right: pd.Series) -> pd.Series:
         nunique = left.groupby(right).nunique()
@@ -69,11 +69,11 @@ class GroupByThenNUnique(PandasOperand, VectorizableMixin):
 
 
 class GroupByThenFreq(PandasOperand):
-    name = "GroupByThenFreq"
-    is_grouping = True
-    output_type = "float"
-    is_distribution_dependent = True
-    input_type = "discrete"
+    name: str = "GroupByThenFreq"
+    is_grouping: bool = True
+    output_type: Optional[str] = "float"
+    is_distribution_dependent: bool = True
+    input_type: Optional[str] = "discrete"
 
     def calculate_binary(self, left: pd.Series, right: pd.Series) -> pd.Series:
         def _f(x):

upgini/autofe/operand.py

@@ -8,19 +8,19 @@ from pydantic import BaseModel
 
 class Operand(BaseModel):
     name: str
-    alias: Optional[str]
+    alias: Optional[str] = None
     is_unary: bool = False
     is_symmetrical: bool = False
     has_symmetry_importance: bool = False
-    input_type: Optional[str]
-    output_type: Optional[str]
+    input_type: Optional[str] = None
+    output_type: Optional[str] = None
     is_categorical: bool = False
     is_vectorizable: bool = False
     is_grouping: bool = False
     is_binary: bool = False
     is_vector: bool = False
     is_distribution_dependent: bool = False
-    params: Optional[Dict[str, str]]
+    params: Optional[Dict[str, str]] = None
 
     def set_params(self, params: Dict[str, str]):
         self.params = params

upgini/autofe/unary.py

@@ -1,3 +1,4 @@
+from typing import Optional
 import numpy as np
 import pandas as pd
 from sklearn.preprocessing import Normalizer
@@ -6,10 +7,10 @@ from upgini.autofe.operand import PandasOperand, VectorizableMixin
 
 
 class Abs(PandasOperand, VectorizableMixin):
-    name = "abs"
-    is_unary = True
-    is_vectorizable = True
-    group_index = 0
+    name: str = "abs"
+    is_unary: bool = True
+    is_vectorizable: bool = True
+    group_index: int = 0
 
     def calculate_unary(self, data: pd.Series) -> pd.Series:
         return data.abs()
@@ -19,11 +20,11 @@ class Abs(PandasOperand, VectorizableMixin):
 
 
 class Log(PandasOperand, VectorizableMixin):
-    name = "log"
-    is_unary = True
-    is_vectorizable = True
-    output_type = "float"
-    group_index = 0
+    name: str = "log"
+    is_unary: bool = True
+    is_vectorizable: bool = True
+    output_type: Optional[str] = "float"
+    group_index: int = 0
 
     def calculate_unary(self, data: pd.Series) -> pd.Series:
         return self._round_value(np.log(np.abs(data.replace(0, np.nan))), 10)
@@ -33,11 +34,11 @@ class Log(PandasOperand, VectorizableMixin):
 
 
 class Sqrt(PandasOperand, VectorizableMixin):
-    name = "sqrt"
-    is_unary = True
-    is_vectorizable = True
-    output_type = "float"
-    group_index = 0
+    name: str = "sqrt"
+    is_unary: bool = True
+    is_vectorizable: bool = True
+    output_type: Optional[str] = "float"
+    group_index: int = 0
 
     def calculate_unary(self, data: pd.Series) -> pd.Series:
         return self._round_value(np.sqrt(np.abs(data)))
@@ -47,10 +48,10 @@ class Sqrt(PandasOperand, VectorizableMixin):
 
 
 class Square(PandasOperand, VectorizableMixin):
-    name = "square"
-    is_unary = True
-    is_vectorizable = True
-    group_index = 0
+    name: str = "square"
+    is_unary: bool = True
+    is_vectorizable: bool = True
+    group_index: int = 0
 
     def calculate_unary(self, data: pd.Series) -> pd.Series:
         return np.square(data)
@@ -60,11 +61,11 @@ class Square(PandasOperand, VectorizableMixin):
 
 
 class Sigmoid(PandasOperand, VectorizableMixin):
-    name = "sigmoid"
-    is_unary = True
-    is_vectorizable = True
-    output_type = "float"
-    group_index = 0
+    name: str = "sigmoid"
+    is_unary: bool = True
+    is_vectorizable: bool = True
+    output_type: Optional[str] = "float"
+    group_index: int = 0
 
     def calculate_unary(self, data: pd.Series) -> pd.Series:
         return self._round_value(1 / (1 + np.exp(-data)))
@@ -74,12 +75,12 @@ class Sigmoid(PandasOperand, VectorizableMixin):
 
 
 class Floor(PandasOperand, VectorizableMixin):
-    name = "floor"
-    is_unary = True
-    is_vectorizable = True
-    output_type = "int"
-    input_type = "continuous"
-    group_index = 0
+    name: str = "floor"
+    is_unary: bool = True
+    is_vectorizable: bool = True
+    output_type: Optional[str] = "int"
+    input_type: Optional[str] = "continuous"
+    group_index: int = 0
 
     def calculate_unary(self, data: pd.Series) -> pd.Series:
         return np.floor(data)
@@ -89,11 +90,11 @@ class Floor(PandasOperand, VectorizableMixin):
 
 
 class Residual(PandasOperand, VectorizableMixin):
-    name = "residual"
-    is_unary = True
-    is_vectorizable = True
-    input_type = "continuous"
-    group_index = 0
+    name: str = "residual"
+    is_unary: bool = True
+    is_vectorizable: bool = True
+    input_type: Optional[str] = "continuous"
+    group_index: int = 0
 
     def calculate_unary(self, data: pd.Series) -> pd.Series:
         return data - np.floor(data)
@@ -103,11 +104,11 @@ class Residual(PandasOperand, VectorizableMixin):
 
 
 class Freq(PandasOperand):
-    name = "freq"
-    is_unary = True
-    output_type = "float"
-    is_distribution_dependent = True
-    input_type = "discrete"
+    name: str = "freq"
+    is_unary: bool = True
+    output_type: Optional[str] = "float"
+    is_distribution_dependent: bool = True
+    input_type: Optional[str] = "discrete"
 
     def calculate_unary(self, data: pd.Series) -> pd.Series:
         value_counts = data.value_counts(normalize=True)
@@ -115,9 +116,9 @@ class Freq(PandasOperand):
 
 
 class Norm(PandasOperand):
-    name = "norm"
-    is_unary = True
-    output_type = "float"
+    name: str = "norm"
+    is_unary: bool = True
+    output_type: Optional[str] = "float"
 
     def calculate_unary(self, data: pd.Series) -> pd.Series:
         data_dropna = data.dropna()
@@ -131,7 +132,7 @@ class Norm(PandasOperand):
 
 
 class Embeddings(PandasOperand):
-    name = "emb"
-    is_unary = True
-    input_type = "string"
-    output_type = "vector"
+    name: str = "emb"
+    is_unary: bool = True
+    input_type: Optional[str] = "string"
+    output_type: Optional[str] = "vector"

upgini/autofe/vector.py

@@ -1,4 +1,4 @@
-from typing import List
+from typing import List, Optional
 
 import pandas as pd
 
@@ -6,19 +6,19 @@ from upgini.autofe.operand import PandasOperand, VectorizableMixin
 
 
 class Mean(PandasOperand, VectorizableMixin):
-    name = "mean"
-    output_type = "float"
-    is_vector = True
-    group_index = 0
+    name: str = "mean"
+    output_type: Optional[str] = "float"
+    is_vector: bool = True
+    group_index: int = 0
 
     def calculate_vector(self, data: List[pd.Series]) -> pd.Series:
         return pd.DataFrame(data).T.fillna(0).mean(axis=1)
 
 
 class Sum(PandasOperand, VectorizableMixin):
-    name = "sum"
-    is_vector = True
-    group_index = 0
+    name: str = "sum"
+    is_vector: bool = True
+    group_index: int = 0
 
     def calculate_vector(self, data: List[pd.Series]) -> pd.Series:
         return pd.DataFrame(data).T.fillna(0).sum(axis=1)

upgini/dataset.py

@@ -18,6 +18,7 @@ from pandas.api.types import (
 from upgini.errors import ValidationError
 from upgini.http import ProgressStage, SearchProgress, _RestClient
 from upgini.metadata import (
+    ENTITY_SYSTEM_RECORD_ID,
     EVAL_SET_INDEX,
     SYSTEM_RECORD_ID,
     TARGET,
@@ -157,7 +158,11 @@ class Dataset:  # (pd.DataFrame):
             raise ValidationError(self.bundle.get("dataset_too_few_rows").format(self.MIN_ROWS_COUNT))
 
     def __validate_max_row_count(self):
-        if len(self.data) > self.MAX_ROWS:
+        if ENTITY_SYSTEM_RECORD_ID in self.data.columns:
+            rows_count = self.data[ENTITY_SYSTEM_RECORD_ID].nunique()
+        else:
+            rows_count = len(self.data)
+        if rows_count > self.MAX_ROWS:
             raise ValidationError(self.bundle.get("dataset_too_many_rows_registered").format(self.MAX_ROWS))
 
     def __target_value(self) -> pd.Series:
@@ -199,14 +204,14 @@ class Dataset:  # (pd.DataFrame):
         elif self.task_type == ModelTaskType.REGRESSION:
             if not is_float_dtype(target):
                 try:
-                    self.data[target_column] = self.data[target_column].astype("float")
+                    self.data[target_column] = self.data[target_column].astype("float64")
                 except ValueError:
                     self.logger.exception("Failed to cast target to float for regression task type")
                     raise ValidationError(self.bundle.get("dataset_invalid_regression_target").format(target.dtype))
         elif self.task_type == ModelTaskType.TIMESERIES:
             if not is_float_dtype(target):
                 try:
-                    self.data[target_column] = self.data[target_column].astype("float")
+                    self.data[target_column] = self.data[target_column].astype("float64")
                 except ValueError:
                     self.logger.exception("Failed to cast target to float for timeseries task type")
                     raise ValidationError(self.bundle.get("dataset_invalid_timeseries_target").format(target.dtype))

upgini/features_enricher.py

@@ -23,7 +23,6 @@ from pandas.api.types import (
     is_datetime64_any_dtype,
     is_numeric_dtype,
     is_object_dtype,
-    is_period_dtype,
     is_string_dtype,
 )
 from scipy.stats import ks_2samp
@@ -1408,7 +1407,9 @@ class FeaturesEnricher(TransformerMixin):
         # TODO maybe there is no more need for these convertions
         # Remove datetime features
         datetime_features = [
-            f for f in fitting_X.columns if is_datetime64_any_dtype(fitting_X[f]) or is_period_dtype(fitting_X[f])
+            f
+            for f in fitting_X.columns
+            if is_datetime64_any_dtype(fitting_X[f]) or isinstance(fitting_X[f].dtype, pd.PeriodDtype)
         ]
         if len(datetime_features) > 0:
             self.logger.warning(self.bundle.get("dataset_date_features").format(datetime_features))
@@ -2041,7 +2042,7 @@ class FeaturesEnricher(TransformerMixin):
 
             df[ENTITY_SYSTEM_RECORD_ID] = pd.util.hash_pandas_object(
                 df[columns_for_system_record_id], index=False
-            ).astype("Float64")
+            ).astype("float64")
 
             # Explode multiple search keys
             df, unnest_search_keys = self._explode_multiple_search_keys(df, search_keys, columns_renaming)
@@ -2107,7 +2108,7 @@ class FeaturesEnricher(TransformerMixin):
             # search keys might be changed after explode
             columns_for_system_record_id = sorted(list(search_keys.keys()) + features_for_transform)
             df[SYSTEM_RECORD_ID] = pd.util.hash_pandas_object(df[columns_for_system_record_id], index=False).astype(
-                "Float64"
+                "float64"
             )
             meaning_types[SYSTEM_RECORD_ID] = FileColumnMeaningType.SYSTEM_RECORD_ID
             meaning_types[ENTITY_SYSTEM_RECORD_ID] = FileColumnMeaningType.ENTITY_SYSTEM_RECORD_ID
@@ -2667,6 +2668,7 @@ class FeaturesEnricher(TransformerMixin):
 
         autofe_description = self.get_autofe_features_description()
         if autofe_description is not None:
+            self.logger.info(f"AutoFE descriptions: {autofe_description}")
             display_html_dataframe(autofe_description, autofe_description, "*Description of AutoFE feature names")
 
         if self._has_paid_features(exclude_features_sources):

upgini/http.py

@@ -39,18 +39,6 @@ from upgini.metadata import (
 from upgini.resource_bundle import bundle
 from upgini.utils.track_info import get_track_metrics
 
-# try:
-#     from importlib.metadata import version  # type: ignore
-
-#     __version__ = version("upgini")
-# except ImportError:
-#     try:
-#         from importlib_metadata import version  # type: ignore
-
-#         __version__ = version("upgini")
-#     except ImportError:
-#         __version__ = "Upgini wasn't installed"
-
 UPGINI_URL: str = "UPGINI_URL"
 UPGINI_API_KEY: str = "UPGINI_API_KEY"
 DEMO_API_KEY: str = "Aa4BPwGFbn1zNEXIkZ-NbhsRk0ricN6puKuga1-O5lM"
@@ -471,7 +459,11 @@ class _RestClient:
                         dumps(track_metrics).encode(),
                         "application/json",
                     ),
-                    "metrics": ("metrics.json", metrics.json(exclude_none=True).encode(), "application/json"),
+                    "metrics": (
+                        "metrics.json",
+                        metrics.json(exclude_none=True).encode(),
+                        "application/json",
+                    ),
                     "file": (metadata_with_md5.name, file, "application/octet-stream"),
                 }
                 if search_customization is not None:
@@ -555,7 +547,11 @@ class _RestClient:
                         dumps(get_track_metrics(self.client_ip, self.client_visitorid)).encode(),
                         "application/json",
                     ),
-                    "metrics": ("metrics.json", metrics.json(exclude_none=True).encode(), "application/json"),
+                    "metrics": (
+                        "metrics.json",
+                        metrics.json(exclude_none=True).encode(),
+                        "application/json",
+                    ),
                     "file": (metadata_with_md5.name, file, "application/octet-stream"),
                 }
                 if search_customization is not None:
@@ -651,7 +647,11 @@ class _RestClient:
             with open(file_path, "rb") as file:
                 files = {
                     "file": (metadata.name, file, "application/octet-stream"),
-                    "metadata": ("metadata.json", metadata.json(exclude_none=True).encode(), "application/json"),
+                    "metadata": (
+                        "metadata.json",
+                        metadata.json(exclude_none=True).encode(),
+                        "application/json",
+                    ),
                 }
 
                 return self._send_post_file_req_v2(api_path, files)

upgini/lazy_import.py

@@ -1,4 +1,6 @@
 import importlib
+import importlib.util
+import importlib.machinery
 
 
 class LazyImport:
@@ -10,7 +12,18 @@ class LazyImport:
 
     def _load(self):
         if self._module is None:
-            self._module = importlib.import_module(self.module_name)
+            # Load module and save link to it
+            spec = importlib.util.find_spec(self.module_name)
+            if spec is None:
+                raise ImportError(f"Module {self.module_name} not found")
+
+            # Create module
+            self._module = importlib.util.module_from_spec(spec)
+
+            # Execute module
+            spec.loader.exec_module(self._module)
+
+            # Get class from module
             self._class = getattr(self._module, self.class_name)
 
     def __call__(self, *args, **kwargs):

upgini/metadata.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from enum import Enum
-from typing import Dict, List, Optional, Set, Union
+from typing import Any, Dict, List, Optional, Set, Union
 
 from pydantic import BaseModel
 
@@ -172,23 +172,23 @@ class FileMetricsInterval(BaseModel):
     date_cut: float
     count: float
     valid_count: float
-    avg_target: Optional[float]  # not for multiclass
-    avg_score_etalon: Optional[float]
+    avg_target: Optional[float] = None  # not for multiclass
+    avg_score_etalon: Optional[float] = None
 
 
 class FileMetrics(BaseModel):
     # etalon metadata
-    task_type: Optional[ModelTaskType]
-    label: Optional[ModelLabelType]
-    count: Optional[int]
-    valid_count: Optional[int]
-    valid_rate: Optional[float]
-    avg_target: Optional[float]
-    metrics_binary_etalon: Optional[BinaryTask]
-    metrics_regression_etalon: Optional[RegressionTask]
-    metrics_multiclass_etalon: Optional[MulticlassTask]
-    cuts: Optional[List[float]]
-    interval: Optional[List[FileMetricsInterval]]
+    task_type: Optional[ModelTaskType] = None
+    label: Optional[ModelLabelType] = None
+    count: Optional[int] = None
+    valid_count: Optional[int] = None
+    valid_rate: Optional[float] = None
+    avg_target: Optional[float] = None
+    metrics_binary_etalon: Optional[BinaryTask] = None
+    metrics_regression_etalon: Optional[RegressionTask] = None
+    metrics_multiclass_etalon: Optional[MulticlassTask] = None
+    cuts: Optional[List[float]] = None
+    interval: Optional[List[FileMetricsInterval]] = None
 
 
 class NumericInterval(BaseModel):
@@ -202,25 +202,25 @@ class FileColumnMetadata(BaseModel):
     dataType: DataType
     meaningType: FileColumnMeaningType
     minMaxValues: Optional[NumericInterval] = None
-    originalName: Optional[str]
+    originalName: Optional[str] = None
     # is this column contains keys from multiple key columns like msisdn1, msisdn2
     isUnnest: bool = False
     # list of original etalon key column names like msisdn1, msisdn2
-    unnestKeyNames: Optional[List[str]]
+    unnestKeyNames: Optional[List[str]] = None
 
 
 class FileMetadata(BaseModel):
     name: str
-    description: Optional[str]
+    description: Optional[str] = None
     columns: List[FileColumnMetadata]
     searchKeys: List[List[str]]
-    excludeFeaturesSources: Optional[List[str]]
-    hierarchicalGroupKeys: Optional[List[str]]
-    hierarchicalSubgroupKeys: Optional[List[str]]
-    taskType: Optional[ModelTaskType]
-    rowsCount: Optional[int]
-    checksumMD5: Optional[str]
-    digest: Optional[str]
+    excludeFeaturesSources: Optional[List[str]] = None
+    hierarchicalGroupKeys: Optional[List[str]] = None
+    hierarchicalSubgroupKeys: Optional[List[str]] = None
+    taskType: Optional[ModelTaskType] = None
+    rowsCount: Optional[int] = None
+    checksumMD5: Optional[str] = None
+    digest: Optional[str] = None
 
     def column_by_name(self, name: str) -> Optional[FileColumnMetadata]:
         for c in self.columns:
@@ -244,17 +244,17 @@ class FeaturesMetadataV2(BaseModel):
     source: str
     hit_rate: float
     shap_value: float
-    commercial_schema: Optional[str]
-    data_provider: Optional[str]
-    data_providers: Optional[List[str]]
-    data_provider_link: Optional[str]
-    data_provider_links: Optional[List[str]]
-    data_source: Optional[str]
-    data_sources: Optional[List[str]]
-    data_source_link: Optional[str]
-    data_source_links: Optional[List[str]]
-    doc_link: Optional[str]
-    update_frequency: Optional[str]
+    commercial_schema: Optional[str] = None
+    data_provider: Optional[str] = None
+    data_providers: Optional[List[str]] = None
+    data_provider_link: Optional[str] = None
+    data_provider_links: Optional[List[str]] = None
+    data_source: Optional[str] = None
+    data_sources: Optional[List[str]] = None
+    data_source_link: Optional[str] = None
+    data_source_links: Optional[List[str]] = None
+    doc_link: Optional[str] = None
+    update_frequency: Optional[str] = None
 
 
 class HitRateMetrics(BaseModel):
@@ -274,48 +274,48 @@ class ModelEvalSet(BaseModel):
 class BaseColumnMetadata(BaseModel):
     original_name: str
     hashed_name: str
-    ads_definition_id: Optional[str]
+    ads_definition_id: Optional[str] = None
     is_augmented: bool
 
 
 class GeneratedFeatureMetadata(BaseModel):
-    alias: Optional[str]
+    alias: Optional[str] = None
     formula: str
     display_index: str
     base_columns: List[BaseColumnMetadata]
-    operator_params: Optional[Dict[str, str]]
+    operator_params: Optional[Dict[str, str]] = None
 
 
 class ProviderTaskMetadataV2(BaseModel):
     features: List[FeaturesMetadataV2]
-    hit_rate_metrics: Optional[HitRateMetrics]
-    eval_set_metrics: Optional[List[ModelEvalSet]]
-    zero_hit_rate_search_keys: Optional[List[str]]
-    features_used_for_embeddings: Optional[List[str]]
-    shuffle_kfold: Optional[bool]
-    generated_features: Optional[List[GeneratedFeatureMetadata]]
+    hit_rate_metrics: Optional[HitRateMetrics] = None
+    eval_set_metrics: Optional[List[ModelEvalSet]] = None
+    zero_hit_rate_search_keys: Optional[List[str]] = None
+    features_used_for_embeddings: Optional[List[str]] = None
+    shuffle_kfold: Optional[bool] = None
+    generated_features: Optional[List[GeneratedFeatureMetadata]] = None
 
 
 class FeaturesFilter(BaseModel):
-    minImportance: Optional[float]
-    maxPSI: Optional[float]
-    maxCount: Optional[int]
-    selectedFeatures: Optional[List[str]]
+    minImportance: Optional[float] = None
+    maxPSI: Optional[float] = None
+    maxCount: Optional[int] = None
+    selectedFeatures: Optional[List[str]] = None
 
 
 class RuntimeParameters(BaseModel):
-    properties: Dict[str, str] = {}
+    properties: Dict[str, Any] = {}
 
 
 class SearchCustomization(BaseModel):
-    featuresFilter: Optional[FeaturesFilter]
-    extractFeatures: Optional[bool]
-    accurateModel: Optional[bool]
-    importanceThreshold: Optional[float]
-    maxFeatures: Optional[int]
-    returnScores: Optional[bool]
-    runtimeParameters: Optional[RuntimeParameters]
-    metricsCalculation: Optional[bool]
+    featuresFilter: Optional[FeaturesFilter] = None
+    extractFeatures: Optional[bool] = None
+    accurateModel: Optional[bool] = None
+    importanceThreshold: Optional[float] = None
+    maxFeatures: Optional[int] = None
+    returnScores: Optional[bool] = None
+    runtimeParameters: Optional[RuntimeParameters] = None
+    metricsCalculation: Optional[bool] = None
 
     def __repr__(self):
         return (

upgini/normalizer/normalize_utils.py

@@ -10,7 +10,6 @@ from pandas.api.types import (
     is_float_dtype,
     is_numeric_dtype,
     is_object_dtype,
-    is_period_dtype,
     is_string_dtype,
 )
 
@@ -135,7 +134,7 @@ class Normalizer:
 
         removed_features = []
         for f in features:
-            if is_datetime(df[f]) or is_period_dtype(df[f]):
+            if is_datetime(df[f]) or isinstance(df[f].dtype, pd.PeriodDtype):
                 removed_features.append(f)
                 df.drop(columns=f, inplace=True)
 

upgini/search_task.py

@@ -3,6 +3,7 @@ import tempfile
 import time
 from functools import lru_cache
 from typing import Dict, List, Optional
+import uuid
 
 import pandas as pd
 
@@ -97,10 +98,7 @@ class SearchTask:
                     time.sleep(self.POLLING_DELAY_SECONDS)
         except KeyboardInterrupt as e:
             if not check_fit:
-                print(bundle.get("search_stopping"))
-                self.rest_client.stop_search_task_v2(trace_id, search_task_id)
-                self.logger.warning(f"Search {search_task_id} stopped by user")
-                print(bundle.get("search_stopped"))
+                self._stop(trace_id)
             raise e
         print()
 
@@ -133,6 +131,14 @@ class SearchTask:
 
         return self
 
+    def _stop(self, trace_id: Optional[str] = None):
+        trace_id = trace_id or uuid.uuid4()
+        search_task_id = self.initial_search_task_id if self.initial_search_task_id is not None else self.search_task_id
+        print(bundle.get("search_stopping"))
+        self.rest_client.stop_search_task_v2(trace_id, search_task_id)
+        self.logger.warning(f"Search {search_task_id} stopped by user")
+        print(bundle.get("search_stopped"))
+
     def get_all_features_metadata_v2(self) -> Optional[List[FeaturesMetadataV2]]:
         if self.provider_metadata_v2 is None:
             return None

upgini/utils/datetime_utils.py

@@ -6,7 +6,7 @@ from typing import Dict, List, Optional
 import numpy as np
 import pandas as pd
 from dateutil.relativedelta import relativedelta
-from pandas.api.types import is_numeric_dtype, is_period_dtype
+from pandas.api.types import is_numeric_dtype
 
 from upgini.errors import ValidationError
 from upgini.metadata import EVAL_SET_INDEX, SearchKey
@@ -84,7 +84,7 @@ class DateTimeSearchKeyConverter:
             df[self.date_column] = df[self.date_column].apply(lambda x: x.replace(tzinfo=None))
         elif isinstance(df[self.date_column].values[0], datetime.date):
             df[self.date_column] = pd.to_datetime(df[self.date_column], errors="coerce")
-        elif is_period_dtype(df[self.date_column]):
+        elif isinstance(df[self.date_column].dtype, pd.PeriodDtype):
             df[self.date_column] = df[self.date_column].dt.to_timestamp()
         elif is_numeric_dtype(df[self.date_column]):
             # 315532801 - 2524608001    - seconds
@@ -207,7 +207,7 @@ def is_time_series(df: pd.DataFrame, date_col: str) -> bool:
 def is_blocked_time_series(df: pd.DataFrame, date_col: str, search_keys: List[str]) -> bool:
     df = df.copy()
     seconds = "datetime_seconds"
-    if is_period_dtype(df[date_col]):
+    if isinstance(df[date_col].dtype, pd.PeriodDtype):
         df[date_col] = df[date_col].dt.to_timestamp()
     else:
         df[date_col] = pd.to_datetime(df[date_col])
@@ -275,7 +275,7 @@ def validate_dates_distribution(
             if col in search_keys:
                 continue
             try:
-                if is_period_dtype(X[col]):
+                if isinstance(X[col].dtype, pd.PeriodDtype):
                     pass
                 elif pd.__version__ >= "2.0.0":
                     # Format mixed to avoid massive warnings
@@ -290,7 +290,7 @@ def validate_dates_distribution(
     if maybe_date_col is None:
         return
 
-    if is_period_dtype(X[maybe_date_col]):
+    if isinstance(X[maybe_date_col].dtype, pd.PeriodDtype):
         dates = X[maybe_date_col].dt.to_timestamp().dt.date
     elif pd.__version__ >= "2.0.0":
         dates = pd.to_datetime(X[maybe_date_col], format="mixed").dt.date

upgini/utils/phone_utils.py

@@ -1,12 +1,8 @@
 from typing import Optional
 
+import numpy as np
 import pandas as pd
-from pandas.api.types import (
-    is_float_dtype,
-    is_int64_dtype,
-    is_object_dtype,
-    is_string_dtype,
-)
+from pandas.api.types import is_float_dtype, is_object_dtype, is_string_dtype
 
 from upgini.errors import ValidationError
 from upgini.utils.base_search_key_detector import BaseSearchKeyDetector
@@ -63,7 +59,9 @@ class PhoneSearchKeyConverter:
             convert_func = self.phone_str_to_int_safe
         elif is_float_dtype(df[self.phone_column]):
             convert_func = self.phone_float_to_int_safe
-        elif is_int64_dtype(df[self.phone_column]):
+        elif df[self.phone_column].dtype == np.int64 or isinstance(
+            df[self.phone_column].dtype, pd.Int64Dtype
+        ):
             convert_func = self.phone_int_to_int_safe
         else:
             raise ValidationError(

upgini/utils/postal_code_utils.py

@@ -25,7 +25,7 @@ class PostalCodeSearchKeyConverter:
         if is_string_dtype(df[self.postal_code_column]) or is_object_dtype(df[self.postal_code_column]):
             try:
                 df[self.postal_code_column] = (
-                    df[self.postal_code_column].astype("string").astype("Float64").astype("Int64").astype("string")
+                    df[self.postal_code_column].astype("string").astype("float64").astype("Int64").astype("string")
                 )
             except Exception:
                 pass

upgini/utils/target_utils.py

@@ -194,4 +194,7 @@ def calculate_psi(expected: pd.Series, actual: pd.Series) -> float:
     test_distribution = actual.value_counts(bins=bins, normalize=True).sort_index().values
 
     # Calculate the PSI
-    return np.sum((train_distribution - test_distribution) * np.log(train_distribution / test_distribution))
+    try:
+        return np.sum((train_distribution - test_distribution) * np.log(train_distribution / test_distribution))
+    except Exception:
+        return np.nan

{upgini-1.1.317.dist-info → upgini-1.2.0a1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: upgini
-Version: 1.1.317
+Version: 1.2.0a1
 Summary: Intelligent data search & enrichment for Machine Learning
 Project-URL: Bug Reports, https://github.com/upgini/upgini/issues
 Project-URL: Homepage, https://upgini.com/
@@ -29,9 +29,9 @@ Requires-Dist: ipywidgets>=8.1.0
 Requires-Dist: jarowinkler>=2.0.0
 Requires-Dist: levenshtein>=0.25.1
 Requires-Dist: lightgbm>=3.3.2
-Requires-Dist: numpy>=1.19.0
+Requires-Dist: numpy<=1.26.4,>=1.19.0
 Requires-Dist: pandas<3.0.0,>=1.1.0
-Requires-Dist: pydantic<2.0.0,>=1.8.2
+Requires-Dist: pydantic<3.0.0,>1.0.0
 Requires-Dist: pyjwt>=2.8.0
 Requires-Dist: python-bidi==0.4.2
 Requires-Dist: python-dateutil>=2.8.0

{upgini-1.1.317.dist-info → upgini-1.2.0a1.dist-info}/RECORD

@@ -1,33 +1,33 @@
-upgini/__about__.py,sha256=7A4Mpkf8cSUSzwIJzMaQ6hlkjN2sldlyOHl5dtLNJkE,24
+upgini/__about__.py,sha256=dMk28IuEJr_qWW7xH2uH2BnZ8G_djCORGGd6opmGetw,24
 upgini/__init__.py,sha256=Xs0YFVBu1KUdtZzbStGRPQtLt3YLzJnjx5nIUBlX8BE,415
 upgini/ads.py,sha256=nvuRxRx5MHDMgPr9SiU-fsqRdFaBv8p4_v1oqiysKpc,2714
-upgini/dataset.py,sha256=yAWIygHejxdKXOA4g3QjtCu0VRa9at-4nPPuugCr77U,30857
+upgini/dataset.py,sha256=olZ-OHSfBNoBSCo7R5t7uCLukI2nO7afpx_A-HCiJLk,31067
 upgini/errors.py,sha256=2b_Wbo0OYhLUbrZqdLIx5jBnAsiD1Mcenh-VjR4HCTw,950
-upgini/features_enricher.py,sha256=Gu4gsnMVjcsfWnJlu4Np3jpE9Au1UywhuHQb0Xv5YNg,187982
-upgini/http.py,sha256=a4Epc9YLIJBuYk4t8E_2-QDLBtJFqKO35jn2SnYQZCg,42920
-upgini/lazy_import.py,sha256=EwoM0msNGbSmWBhGbrLDny1DSnOlvTxCjmMKPxYlDms,610
-upgini/metadata.py,sha256=YQ-1HZGyPOksP2iM50ff_pMHXLyzvpChqSfNh8Z0ke4,10833
+upgini/features_enricher.py,sha256=twH4qdl91iHZF_AraLk0aIbRDw61S_DYtCWCZ34Yjjg,188077
+upgini/http.py,sha256=21asexflvavydzCOONJDGQBtQanCElrbnqLXakJ9Cu8,42880
+upgini/lazy_import.py,sha256=74gQ8JuA48BGRLxAo7lNHNKY2D2emMxrUxKGdxVGhuY,1012
+upgini/metadata.py,sha256=osmzdNESeh7yP3BZday6N9Q3eaIHfzhhRM1d6NSgcf0,11223
 upgini/metrics.py,sha256=Tu5cN8RlhOSSMWUTXRSkdl8SWBqR1N_2eJpBum9pZxc,30926
-upgini/search_task.py,sha256=LtRJ9bCPjMo1gJ-sUDKERhDwGcWKImrzwVFHjkMSQHQ,17071
+upgini/search_task.py,sha256=qxUxAD-bed-FpZYmTB_4orW7YJsW_O6a1TcgnZIRFr4,17307
 upgini/spinner.py,sha256=4iMd-eIe_BnkqFEMIliULTbj6rNI2HkN_VJ4qYe0cUc,1118
 upgini/version_validator.py,sha256=ddSKUK_-eGJB3NgrqOMoWJU-OxQ253WsNLp8aqJkaIM,1389
 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=3LiH9iU-ArGmYpS8FHWH7yCFx40ILfvlSXJlKIa75BQ,2542
-upgini/autofe/binary.py,sha256=2Z5FrfdCtesKEHBuabEBiRvwOAzcRoFKAX1wvGpHL0I,7003
-upgini/autofe/date.py,sha256=ijB9RCh5wBwl03Nl8zDYA50gpL4sqmAkYVYzVPm1bn0,9070
+upgini/autofe/binary.py,sha256=TRjEdxsfyPY5E8ksYfdKMmU6GtvALfGFPNVIG7DBhzM,7520
+upgini/autofe/date.py,sha256=OpFc3Al0xO3qlESn2Uokfxw51ArVqmh3xngWwdrsaqE,9762
 upgini/autofe/feature.py,sha256=gwGWY2UcX_0wHAvfEiu1rRU7GFZyzMWZIaPVcf6kD80,14223
-upgini/autofe/groupby.py,sha256=4WjDzQxqpZxB79Ih4ihMMI5GDxaFqiH6ZelfV82ClT4,3091
-upgini/autofe/operand.py,sha256=MKEsl3zxpWzRDpTkE0sNJxTu62U20sWOvEKhPjUWS6s,2915
-upgini/autofe/unary.py,sha256=oIMf-IVy7L7GkzxMmQyExX0tOH9RhWeQh7cGxxMDiPk,3832
-upgini/autofe/vector.py,sha256=dLxfAstJs-gw_OQ1xxoxcM6pVzORlV0HVzdzt7cLXVQ,606
+upgini/autofe/groupby.py,sha256=r-xl_keZZgm_tpiEoDhjYSkT6NHv7a4cRQR4wJ4uCp8,3263
+upgini/autofe/operand.py,sha256=uk883RaNqgXqtkaRqA1re1d9OFnnpv0JVvelYx09Yw0,2943
+upgini/autofe/unary.py,sha256=RiK-Fz3fgjPlqWWfro6x7qChjEZ8W8RTnl5-MT1kaQA,4218
+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=Vg0biG86YB0OEaoxbK9YYrr4yARm11_h3bTWIBgoScA,22115
 upgini/mdc/__init__.py,sha256=aM08nIWFc2gWdWUa3_IuEnNND0cQPkBGnYpRMnfFN8k,1019
 upgini/mdc/context.py,sha256=3u1B-jXt7tXEvNcV3qmR9SDCseudnY7KYsLclBdwVLk,1405
 upgini/normalizer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-upgini/normalizer/normalize_utils.py,sha256=8gH1oabPNZrC1kHSRFxGGcO0o6yNDlOJXCLzzExq-3s,7451
+upgini/normalizer/normalize_utils.py,sha256=bHRPWCNrUvt2R9qMX6dZFCJ0i8ENVCQ2Rw3dHH9IJEg,7447
 upgini/resource_bundle/__init__.py,sha256=S5F2G47pnJd2LDpmFsjDqEwiKkP8Hm-hcseDbMka6Ko,8345
 upgini/resource_bundle/exceptions.py,sha256=5fRvx0_vWdE1-7HcSgF0tckB4A9AKyf5RiinZkInTsI,621
 upgini/resource_bundle/strings.properties,sha256=WZAuYPX2Dpn6BHoA3RX8uvMNMr-yJE2fF7Gz0i24x2s,26459
@@ -42,7 +42,7 @@ upgini/utils/blocked_time_series.py,sha256=Uqr3vp4YqNclj2-PzEYqVy763GSXHn86sbpIl
 upgini/utils/country_utils.py,sha256=lY-eXWwFVegdVENFttbvLcgGDjFO17Sex8hd2PyJaRk,6937
 upgini/utils/custom_loss_utils.py,sha256=kieNZYBYZm5ZGBltF1F_jOSF4ea6C29rYuCyiDcqVNY,3857
 upgini/utils/cv_utils.py,sha256=w6FQb9nO8BWDx88EF83NpjPLarK4eR4ia0Wg0kLBJC4,3525
-upgini/utils/datetime_utils.py,sha256=niZcf2YqAwokUFUW474zajlzv9HAMf7nv9v_WPJHpyc,12123
+upgini/utils/datetime_utils.py,sha256=4tsGeehU0KS6wqNsc9gEEWZ9s6T9E0UReUIO3rSuXNU,12174
 upgini/utils/deduplicate_utils.py,sha256=Zvs7zW4QzaERQmJNPrTVf2ZTVBkBLOycFCzyMwtXuV8,8770
 upgini/utils/display_utils.py,sha256=A2ouB5eiZ-Kyt9ykYxkLQwyoRPrdYeJymwNTiajtFXs,10990
 upgini/utils/email_utils.py,sha256=j0Ug1R_0AnCg1Y92zIZ4XMwvKo3G5_pcOlBN1OH_gZs,5191
@@ -50,14 +50,14 @@ upgini/utils/fallback_progress_bar.py,sha256=PDaKb8dYpVZaWMroNcOHsTc3pSjgi9mOm0-
 upgini/utils/features_validator.py,sha256=PgKNt5dyqfErTvjtRNNUS9g7GFqHBtAtnsfA-V5UO1A,3307
 upgini/utils/format.py,sha256=Yv5cvvSs2bOLUzzNu96Pu33VMDNbabio92QepUj41jU,243
 upgini/utils/ip_utils.py,sha256=ZZj_uQFTHhagzt-MRew__ZBOp2DdnkMrachS7PElkSE,5143
-upgini/utils/phone_utils.py,sha256=PTSRfGAWCuLy8R6I8X6clcc1K7bZXIIrZ_alIB8irC8,10368
-upgini/utils/postal_code_utils.py,sha256=C899tJS8qM_ps4I3g-Ve6qzIa22O_UqwNmGFoyy9sO8,1716
+upgini/utils/phone_utils.py,sha256=IrbztLuOJBiePqqxllfABWfYlfAjYevPhXKipl95wUI,10432
+upgini/utils/postal_code_utils.py,sha256=5M0sUqH2DAr33kARWCTXR-ACyzWbjDq_-0mmEml6ZcU,1716
 upgini/utils/progress_bar.py,sha256=N-Sfdah2Hg8lXP_fV9EfUTXz_PyRt4lo9fAHoUDOoLc,1550
 upgini/utils/sklearn_ext.py,sha256=13jQS_k7v0aUtudXV6nGUEWjttPQzAW9AFYL5wgEz9k,44511
-upgini/utils/target_utils.py,sha256=Y96_PJ5cC-WsEbeqg20v9uqywDQobLoTb-xoP7S3o4E,7807
+upgini/utils/target_utils.py,sha256=BVtDmrmFMKerSUWaNOIEdzsYHIFiODdpnWbE50QDPDc,7864
 upgini/utils/track_info.py,sha256=G5Lu1xxakg2_TQjKZk4b5SvrHsATTXNVV3NbvWtT8k8,5663
 upgini/utils/warning_counter.py,sha256=dIWBB4dI5XRRJZudvIlqlIYKEiwLLPcXarsZuYRt338,227
-upgini-1.1.317.dist-info/METADATA,sha256=MAx5zlya3JBerLBEmC9me552zgexw4gy4Cfc2VuNzSg,48222
-upgini-1.1.317.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
-upgini-1.1.317.dist-info/licenses/LICENSE,sha256=5RRzgvdJUu3BUDfv4bzVU6FqKgwHlIay63pPCSmSgzw,1514
-upgini-1.1.317.dist-info/RECORD,,
+upgini-1.2.0a1.dist-info/METADATA,sha256=568JisotupYzFolx0QDyv_qN5CtSIEuHuium23_SDp8,48230
+upgini-1.2.0a1.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
+upgini-1.2.0a1.dist-info/licenses/LICENSE,sha256=5RRzgvdJUu3BUDfv4bzVU6FqKgwHlIay63pPCSmSgzw,1514
+upgini-1.2.0a1.dist-info/RECORD,,