upgini 1.1.317__tar.gz → 1.2.0a1__tar.gz

{upgini-1.1.317 → upgini-1.2.0a1}/PKG-INFO

@@ -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 → upgini-1.2.0a1}/pyproject.toml

@@ -39,9 +39,9 @@ dependencies = [
     "fastparquet>=0.8.1",
     "ipywidgets>=8.1.0",
     "lightgbm>=3.3.2",
-    "numpy>=1.19.0",
+    "numpy>=1.19.0,<=1.26.4",
     "pandas>=1.1.0,<3.0.0",
-    "pydantic>=1.8.2,<2.0.0",
+    "pydantic>1.0.0,<3.0.0",
     "pyjwt>=2.8.0",
     "python-dateutil>=2.8.0",
     "python-json-logger>=2.0.2",
@@ -79,7 +79,7 @@ python = "3.10"
 cov = 'pytest --cov-report=term-missing --cov-config=pyproject.toml --cov=upgini --cov=tests'
 format = "black {args}"
 lint = "ruff check {args}"
-test_binary = 'pytest -s -vv tests/test_binary_dataset.py'
+test_all = 'pytest -s -vv tests'
 
 [[tool.hatch.envs.test.matrix]]
 python = ["3.8"]
@@ -103,7 +103,8 @@ dependencies = [
 #  "pytest-timeout",
   "requests-mock",
   "pytest-datafiles",
-  "pandas~={matrix:pandas}.0",
+  "pytest-xdist",
+  "pandas~={matrix:pandas}",
 ]
 
 [tool.black]
@@ -115,4 +116,5 @@ profile = "black"
 [tool.pytest.ini_options]
 pythonpath = [
   "./src"
-]
+]
+addopts="-n 4"

upgini-1.2.0a1/src/upgini/__about__.py

@@ -0,0 +1 @@
+__version__ = "1.2.0a1"

{upgini-1.1.317 → upgini-1.2.0a1}/src/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-1.1.317 → upgini-1.2.0a1}/src/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-1.1.317 → upgini-1.2.0a1}/src/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-1.1.317 → upgini-1.2.0a1}/src/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