upgini 1.2.81a3832.dev9__py3-none-any.whl → 1.2.81a3832.dev11__py3-none-any.whl

upgini/__about__.py

@@ -1 +1 @@
-__version__ = "1.2.81a3832.dev9"
+__version__ = "1.2.81a3832.dev11"

upgini/features_enricher.py

@@ -4245,7 +4245,7 @@ if response.status_code == 200:
     def __show_selected_features(self, search_keys: Dict[str, SearchKey]):
         search_key_names = [col for col, tpe in search_keys.items() if tpe != SearchKey.CUSTOM_KEY]
         if self.fit_columns_renaming:
-            search_key_names = [self.fit_columns_renaming.get(col, col) for col in search_key_names]
+            search_key_names = sorted(set([self.fit_columns_renaming.get(col, col) for col in search_key_names]))
         msg = self.bundle.get("features_info_header").format(len(self.feature_names_), search_key_names)
 
         try:

upgini/metrics.py

@@ -15,7 +15,7 @@ from catboost import CatBoostClassifier, CatBoostRegressor
 from category_encoders.cat_boost import CatBoostEncoder
 from lightgbm import LGBMClassifier, LGBMRegressor
 from numpy import log1p
-from pandas.api.types import is_numeric_dtype
+from pandas.api.types import is_numeric_dtype, is_integer_dtype, is_float_dtype
 from sklearn.metrics import check_scoring, get_scorer, make_scorer, roc_auc_score
 
 from upgini.utils.blocked_time_series import BlockedTimeSeriesSplit
@@ -32,7 +32,10 @@ except ImportError:
     available_scorers = SCORERS
 from sklearn.metrics import mean_squared_error
 from sklearn.metrics._regression import _check_reg_targets, check_consistent_length
-from sklearn.model_selection import BaseCrossValidator, TimeSeriesSplit  # , TimeSeriesSplit
+from sklearn.model_selection import (  # , TimeSeriesSplit
+    BaseCrossValidator,
+    TimeSeriesSplit,
+)
 
 from upgini.errors import ValidationError
 from upgini.metadata import ModelTaskType
@@ -250,6 +253,47 @@ class _CrossValResults:
             return f"{self.metric:.3f} ± {self.metric_std:.3f}"
 
 
+def is_numeric_object(x: pd.Series) -> bool:
+    try:
+        pd.to_numeric(x, errors="raise")
+        return True
+    except (ValueError, TypeError):
+        return False
+
+
+def is_valid_numeric_array_data(data: pd.Series) -> bool:
+    data_without_na = data.dropna()
+    if data_without_na.empty:
+        return False
+
+    first_element = data_without_na.iloc[0]
+
+    # numpy.ndarray with numeric types
+    if isinstance(first_element, np.ndarray):
+        return np.issubdtype(first_element.dtype, np.number)
+
+    # DataFrame with all numeric columns
+    elif isinstance(first_element, pd.DataFrame):
+        return all(np.issubdtype(dtype, np.number) for dtype in first_element.dtypes)
+
+    # list or list of lists with numeric types
+    elif isinstance(first_element, list):
+        try:
+            # flat list
+            if all(isinstance(x, (int, float, np.number)) or pd.isna(x) for x in first_element):
+                return True
+            # list of lists
+            elif all(
+                isinstance(x, list) and all(isinstance(y, (int, float, np.number)) or pd.isna(y) for y in x)
+                for x in first_element
+            ):
+                return True
+        except Exception:
+            return False
+
+    return False
+
+
 class EstimatorWrapper:
     default_estimator: Literal["catboost", "lightgbm"] = "catboost"
 
@@ -279,6 +323,10 @@ class EstimatorWrapper:
         self.groups = groups
         self.text_features = text_features
         self.logger = logger or logging.getLogger()
+        self.droped_features = []
+        self.converted_to_int = []
+        self.converted_to_str = []
+        self.converted_to_numeric = []
 
     def fit(self, x: pd.DataFrame, y: np.ndarray, **kwargs):
         x, y, _, fit_params = self._prepare_to_fit(x, y)
@@ -286,28 +334,13 @@ class EstimatorWrapper:
         self.estimator.fit(x, y, **kwargs)
         return self
 
-    def predict(self, **kwargs):
-        return self.estimator.predict(**kwargs)
-
-    def _prepare_to_fit(self, x: pd.DataFrame, y: pd.Series) -> Tuple[pd.DataFrame, np.ndarray, np.ndarray, dict]:
-        x, y, groups = self._prepare_data(x, y, groups=self.groups)
-        return x, y, groups, {}
+    def predict(self, x: pd.DataFrame, **kwargs):
+        x, _, _ = self._prepare_to_calculate(x, None)
+        return self.estimator.predict(x, **kwargs)
 
     def _prepare_data(
         self, x: pd.DataFrame, y: pd.Series, groups: Optional[np.ndarray] = None
     ) -> Tuple[pd.DataFrame, np.ndarray, np.ndarray]:
-        self.logger.info(f"Before preparing data columns: {x.columns.to_list()}")
-        for c in x.columns:
-            if c not in self.cat_features:
-                if is_numeric_dtype(x[c]):
-                    x[c] = x[c].astype(float)
-                elif not x[c].dtype == "category":
-                    x[c] = x[c].astype(str)
-            else:
-                if x[c].dtype == "category" and x[c].cat.categories.dtype == np.int64:
-                    x[c] = x[c].astype(np.int64)
-                elif not is_numeric_dtype(x[c]):
-                    x[c] = x[c].astype(str).astype("category")
 
         if not isinstance(y, pd.Series):
             raise Exception(bundle.get("metrics_unsupported_target_type").format(type(y)))
@@ -335,8 +368,83 @@ class EstimatorWrapper:
 
         return x, y
 
+    def _prepare_to_fit(self, x: pd.DataFrame, y: pd.Series) -> Tuple[pd.DataFrame, np.ndarray, np.ndarray, dict]:
+        x, y, groups = self._prepare_data(x, y, groups=self.groups)
+
+        self.logger.info(f"Before preparing data columns: {x.columns.to_list()}")
+        self.droped_features = []
+        self.converted_to_int = []
+        self.converted_to_str = []
+        self.converted_to_numeric = []
+        for c in x.columns:
+            if _get_unique_count(x[c]) < 2:
+                self.logger.warning(f"Remove feature {c} because it has less than 2 unique values")
+                if c in self.cat_features:
+                    self.cat_features.remove(c)
+                x.drop(columns=[c], inplace=True)
+                self.droped_features.append(c)
+            elif self.text_features is not None and c in self.text_features:
+                x[c] = x[c].astype(str)
+                self.converted_to_str.append(c)
+            elif c in self.cat_features:
+                if x[c].dtype == "bool" or (x[c].dtype == "category" and x[c].cat.categories.dtype == "bool"):
+                    x[c] = x[c].astype(np.int64)
+                    self.converted_to_int.append(c)
+                elif x[c].dtype == "category" and is_integer_dtype(x[c].cat.categories):
+                    self.logger.info(
+                        f"Convert categorical feature {c} with integer categories"
+                        " to int64 and remove from cat_features"
+                    )
+                    x[c] = x[c].astype(np.int64)
+                    self.converted_to_int.append(c)
+                    self.cat_features.remove(c)
+                elif is_float_dtype(x[c]) or (x[c].dtype == "category" and is_float_dtype(x[c].cat.categories)):
+                    self.logger.info(
+                        f"Convert float cat feature {c} to string"
+                    )
+                    x[c] = x[c].astype(str)
+                    self.converted_to_str.append(c)
+                elif x[c].dtype not in ["category", "int64"]:
+                    x[c] = x[c].astype(str)
+                    self.converted_to_str.append(c)
+            else:
+                if x[c].dtype == "bool" or (x[c].dtype == "category" and x[c].cat.categories.dtype == "bool"):
+                    self.logger.info(f"Convert bool feature {c} to int64")
+                    x[c] = x[c].astype(np.int64)
+                    self.converted_to_int.append(c)
+                elif not is_valid_numeric_array_data(x[c]):
+                    try:
+                        x[c] = pd.to_numeric(x[c], errors="raise")
+                        self.converted_to_numeric.append(c)
+                    except (ValueError, TypeError):
+                        self.logger.warning(f"Remove feature {c} because it is not numeric and not in cat_features")
+                        x.drop(columns=[c], inplace=True)
+                        self.droped_features.append(c)
+
+        return x, y, groups, {}
+
     def _prepare_to_calculate(self, x: pd.DataFrame, y: pd.Series) -> Tuple[pd.DataFrame, np.ndarray, dict]:
         x, y, _ = self._prepare_data(x, y)
+
+        if self.droped_features:
+            self.logger.info(f"Drop features on calculate metrics: {self.droped_features}")
+            x = x.drop(columns=self.droped_features)
+
+        if self.converted_to_int:
+            self.logger.info(f"Convert to int features on calculate metrics: {self.converted_to_int}")
+            for c in self.converted_to_int:
+                x[c] = x[c].astype(np.int64)
+
+        if self.converted_to_str:
+            self.logger.info(f"Convert to str features on calculate metrics: {self.converted_to_str}")
+            for c in self.converted_to_str:
+                x[c] = x[c].astype(str)
+
+        if self.converted_to_numeric:
+            self.logger.info(f"Convert to numeric features on calculate metrics: {self.converted_to_numeric}")
+            for c in self.converted_to_numeric:
+                x[c] = pd.to_numeric(x[c], errors="coerce")
+
         return x, y, {}
 
     def calculate_shap(self, x: pd.DataFrame, y: pd.Series, estimator) -> Optional[Dict[str, float]]:
@@ -552,8 +660,6 @@ class CatBoostWrapper(EstimatorWrapper):
         )
         self.emb_features = None
         self.grouped_embedding_features = None
-        self.drop_cat_features = []
-        self.features_to_encode = []
 
     def _prepare_to_fit(self, x: pd.DataFrame, y: pd.Series) -> Tuple[pd.DataFrame, np.ndarray, np.ndarray, dict]:
         x, y, groups, params = super()._prepare_to_fit(x, y)
@@ -562,55 +668,60 @@ class CatBoostWrapper(EstimatorWrapper):
         import catboost
         from catboost import CatBoostClassifier
 
-        if hasattr(CatBoostClassifier, "get_embedding_feature_indices"):
+        if not hasattr(CatBoostClassifier, "get_embedding_feature_indices"):
+            self.logger.warning(f"Embedding features are not supported by Catboost version {catboost.__version__}")
+        else:
             emb_pattern = r"(.+)_emb\d+"
             self.emb_features = [c for c in x.columns if re.match(emb_pattern, c) and is_numeric_dtype(x[c])]
-            if len(self.emb_features) > 3:  # There is no reason to reduce embeddings dimension with less than 4
-                self.logger.info(
-                    "Embedding features count more than 3, so group them into one vector for CatBoost: "
-                    f"{self.emb_features}"
-                )
-                x, self.grouped_embedding_features = self.group_embeddings(x)
+            x, self.grouped_embedding_features = self.group_embeddings(x)
+            if len(self.grouped_embedding_features) > 0:
                 params["embedding_features"] = self.grouped_embedding_features
-            else:
-                self.logger.info(f"Embedding features count less than 3, so use them separately: {self.emb_features}")
-                self.grouped_embedding_features = None
-        else:
-            self.logger.warning(f"Embedding features are not supported by Catboost version {catboost.__version__}")
 
         # Find text features from passed in generate_features
-        if hasattr(CatBoostClassifier, "get_text_feature_indices"):
+        if not hasattr(CatBoostClassifier, "get_text_feature_indices"):
+            self.text_features = None
+            self.logger.warning(f"Text features are not supported by this Catboost version {catboost.__version__}")
+        else:
             if self.text_features is not None:
                 self.logger.info(f"Passed text features for CatBoost: {self.text_features}")
                 self.text_features = [f for f in self.text_features if f in x.columns and not is_numeric_dtype(x[f])]
                 self.logger.info(f"Rest text features after checks: {self.text_features}")
                 params["text_features"] = self.text_features
-        else:
-            self.text_features = None
-            self.logger.warning(f"Text features are not supported by this Catboost version {catboost.__version__}")
 
         # Find rest categorical features
-        self.cat_features, self.features_to_encode, self.exclude_features = _get_cat_features(
-            self.logger, x, self.cat_features, self.text_features, self.grouped_embedding_features
-        )
-        if self.features_to_encode:
-            for c in self.features_to_encode:
+        self.cat_features = [
+            f
+            for f in self.cat_features
+            if f not in (self.text_features or []) and f not in (self.grouped_embedding_features or [])
+        ]
+        if self.cat_features:
+            for c in self.cat_features:
                 if is_numeric_dtype(x[c]):
                     x[c] = x[c].fillna(np.nan)
-                else:
+                elif x[c].dtype != "category":
                     x[c] = x[c].fillna("NA")
-            params["cat_features"] = self.features_to_encode
+            params["cat_features"] = self.cat_features
 
         return x, y, groups, params
 
     def group_embeddings(self, df: pd.DataFrame):
-        emb_name = "__grouped_embeddings"
-        df = df.copy()
-        df[self.emb_features] = df[self.emb_features].fillna(0.0)
-        embeddings_series = pd.Series(df[self.emb_features].values.tolist(), index=df.index)
-        df = pd.concat([df.drop(columns=self.emb_features), pd.DataFrame({emb_name: embeddings_series})], axis=1)
-
-        return df, [emb_name]
+        embeddings_columns = []
+        if len(self.emb_features) > 3:
+            self.logger.info(
+                "Embedding features count more than 3, so group them into one vector for CatBoost: "
+                f"{self.emb_features}"
+            )
+            emb_name = "__grouped_embeddings"
+            df = df.copy()
+            df[self.emb_features] = df[self.emb_features].fillna(0.0)
+            embeddings_series = pd.Series(df[self.emb_features].values.tolist(), index=df.index)
+            df = pd.concat([df.drop(columns=self.emb_features), pd.DataFrame({emb_name: embeddings_series})], axis=1)
+            embeddings_columns.append(emb_name)
+        for c in df.columns:
+            if is_valid_numeric_array_data(df[c]):
+                embeddings_columns.append(c)
+
+        return df, embeddings_columns
 
     def process_shap_values(self, shap_values: Dict[str, float]) -> Dict[str, float]:
         if "__grouped_embeddings" in shap_values:
@@ -620,8 +731,6 @@ class CatBoostWrapper(EstimatorWrapper):
         return shap_values
 
     def _prepare_to_calculate(self, x: pd.DataFrame, y: pd.Series) -> Tuple[pd.DataFrame, np.ndarray, dict]:
-        if self.exclude_features:
-            x = x.drop(columns=self.exclude_features)
         x, y, params = super()._prepare_to_calculate(x, y)
         if self.text_features:
             params["text_features"] = self.text_features
@@ -629,13 +738,13 @@ class CatBoostWrapper(EstimatorWrapper):
             x, emb_columns = self.group_embeddings(x)
             params["embedding_features"] = emb_columns
 
-        if self.features_to_encode:
-            for c in self.features_to_encode:
+        if self.cat_features:
+            for c in self.cat_features:
                 if is_numeric_dtype(x[c]):
                     x[c] = x[c].fillna(np.nan)
-                else:
+                elif x[c].dtype != "category":
                     x[c] = x[c].fillna("NA")
-            params["cat_features"] = self.features_to_encode
+            params["cat_features"] = self.cat_features
 
         return x, y, params
 
@@ -660,7 +769,7 @@ class CatBoostWrapper(EstimatorWrapper):
                     )
                 for f in high_cardinality_features:
                     self.text_features.remove(f)
-                    self.exclude_features.append(f)
+                    self.droped_features.append(f)
                     x = x.drop(columns=f, errors="ignore")
                 return super().cross_val_predict(x, y, baseline_score_column)
             else:
@@ -733,8 +842,6 @@ class LightGBMWrapper(EstimatorWrapper):
         )
         self.cat_encoder = None
         self.n_classes = None
-        self.exclude_features = []
-        self.features_to_encode = []
 
     def _prepare_to_fit(self, x: pd.DataFrame, y: pd.Series) -> Tuple[pd.DataFrame, pd.Series, np.ndarray, dict]:
         x, y_numpy, groups, params = super()._prepare_to_fit(x, y)
@@ -744,25 +851,23 @@ class LightGBMWrapper(EstimatorWrapper):
             if self.target_type == ModelTaskType.BINARY:
                 params["eval_metric"] = "auc"
             params["callbacks"] = [lgb.early_stopping(stopping_rounds=LIGHTGBM_EARLY_STOPPING_ROUNDS, verbose=False)]
-        self.cat_features, self.features_to_encode, self.exclude_features = _get_cat_features(
-            self.logger, x, self.cat_features
-        )
-        if self.features_to_encode:
-            encoder = CatBoostEncoder(random_state=DEFAULT_RANDOM_STATE, return_df=True)
-            encoded = encoder.fit_transform(x[self.features_to_encode].astype("object"), y_numpy).astype("category")
-            x[self.features_to_encode] = encoded
+        if self.cat_features:
+            encoder = CatBoostEncoder(random_state=DEFAULT_RANDOM_STATE, cols=self.cat_features, return_df=True)
+            encoded = encoder.fit_transform(x[self.cat_features].astype("object"), y_numpy).astype("category")
+            x[self.cat_features] = encoded
             self.cat_encoder = encoder
-
+        for c in x.columns:
+            if x[c].dtype not in ["category", "int64", "float64", "bool"]:
+                self.logger.warning(f"Feature {c} is not numeric and will be dropped")
+                self.droped_features.append(c)
+                x = x.drop(columns=c, errors="ignore")
         return x, y_numpy, groups, params
 
     def _prepare_to_calculate(self, x: pd.DataFrame, y: pd.Series) -> Tuple[pd.DataFrame, np.ndarray, dict]:
-        if self.exclude_features:
-            x = x.drop(columns=self.exclude_features)
         x, y_numpy, params = super()._prepare_to_calculate(x, y)
-        if self.features_to_encode is not None and self.cat_encoder is not None:
-            x[self.features_to_encode] = self.cat_encoder.transform(x[self.features_to_encode].astype("object")).astype(
-                "category"
-            )
+        if self.cat_features is not None and self.cat_encoder is not None:
+            encoded = self.cat_encoder.transform(x[self.cat_features].astype("object"), y_numpy).astype("category")
+            x[self.cat_features] = encoded
         return x, y_numpy, params
 
     def calculate_shap(self, x: pd.DataFrame, y: pd.Series, estimator) -> Optional[Dict[str, float]]:
@@ -824,9 +929,6 @@ class OtherEstimatorWrapper(EstimatorWrapper):
 
     def _prepare_to_fit(self, x: pd.DataFrame, y: np.ndarray) -> Tuple[pd.DataFrame, np.ndarray, np.ndarray, dict]:
         x, y_numpy, groups, params = super()._prepare_to_fit(x, y)
-        self.cat_features, self.features_to_encode, self.exclude_features = _get_cat_features(
-            self.logger, x, self.cat_features
-        )
         num_features = [col for col in x.columns if col not in self.cat_features]
         x[num_features] = x[num_features].fillna(-999)
         if self.cat_features:
@@ -834,20 +936,23 @@ class OtherEstimatorWrapper(EstimatorWrapper):
             encoded = encoder.fit_transform(x[self.cat_features].astype("object"), y_numpy).astype("category")
             x[self.cat_features] = encoded
             self.cat_encoder = encoder
+        for c in x.columns:
+            if x[c].dtype not in ["category", "int64", "float64", "bool"]:
+                self.logger.warning(f"Feature {c} is not numeric and will be dropped")
+                self.droped_features.append(c)
+                x = x.drop(columns=c, errors="ignore")
         return x, y_numpy, groups, params
 
     def _prepare_to_calculate(self, x: pd.DataFrame, y: pd.Series) -> Tuple[pd.DataFrame, np.ndarray, dict]:
-        if self.exclude_features:
-            x = x.drop(columns=self.exclude_features)
-        x, y, params = super()._prepare_to_calculate(x, y)
+        x, y_numpy, params = super()._prepare_to_calculate(x, y)
         if self.cat_features is not None:
             num_features = [col for col in x.columns if col not in self.cat_features]
             x[num_features] = x[num_features].fillna(-999)
-            if self.features_to_encode and self.cat_encoder is not None:
-                x[self.features_to_encode] = self.cat_encoder.transform(
-                    x[self.features_to_encode].astype("object")
+            if self.cat_features and self.cat_encoder is not None:
+                x[self.cat_features] = self.cat_encoder.transform(
+                    x[self.cat_features].astype("object"), y_numpy
                 ).astype("category")
-        return x, y, params
+        return x, y_numpy, params
 
 
 def validate_scoring_argument(scoring: Union[Callable, str, None]):
@@ -933,40 +1038,6 @@ def define_scorer(target_type: ModelTaskType, scoring: Union[Callable, str, None
     return scoring, metric_name, multiplier
 
 
-def _get_cat_features(
-    logger: logging.Logger,
-    x: pd.DataFrame,
-    cat_features: Optional[List[str]],
-    text_features: Optional[List[str]] = None,
-    emb_features: Optional[List[str]] = None,
-) -> List[str]:
-    cat_features = cat_features or []
-    text_features = text_features or []
-    emb_features = emb_features or []
-    exclude_features = text_features + emb_features
-    cat_features = [c for c in cat_features if c not in exclude_features]
-    unique_cat_features = []
-    drop_cat_features = []
-    for name in cat_features:
-        # Remove constant categorical features
-        if x[name].nunique(dropna=False) > 1:
-            unique_cat_features.append(name)
-        else:
-            logger.warning(f"Drop column {name} on preparing data for fit")
-            x.drop(columns=name, inplace=True)
-            drop_cat_features.append(name)
-    cat_features = unique_cat_features
-
-    logger.info(f"Selected categorical features: {cat_features}")
-
-    features_to_encode = list(set(x.select_dtypes(exclude=[np.number, np.datetime64, pd.CategoricalDtype()]).columns))
-    features_to_encode = [f for f in cat_features if f in features_to_encode]
-
-    logger.info(f"Features to encode: {features_to_encode}")
-
-    return cat_features, features_to_encode, drop_cat_features
-
-
 def _get_add_params(input_params, add_params):
     output_params = dict(input_params)
     if add_params is not None:
@@ -1052,3 +1123,10 @@ def _ext_mean_squared_log_error(y_true, y_pred, *, sample_weight=None, multioutp
         multioutput=multioutput,
     )
     return mse if squared else np.sqrt(mse)
+
+
+def _get_unique_count(series: pd.Series) -> int:
+    try:
+        return series.nunique(dropna=False)
+    except TypeError:
+        return series.astype(str).nunique(dropna=False)

upgini/search_task.py

@@ -179,6 +179,7 @@ class SearchTask:
                     for f in meta.generated_features
                     for c in f.base_columns
                     if c.ads_definition_id is None
+                    and not c.original_name.endswith("_emb")  # embeddings already added
                 )
         return list(features_for_transform)
 

{upgini-1.2.81a3832.dev9.dist-info → upgini-1.2.81a3832.dev11.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: upgini
-Version: 1.2.81a3832.dev9
+Version: 1.2.81a3832.dev11
 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.81a3832.dev9.dist-info → upgini-1.2.81a3832.dev11.dist-info}/RECORD

@@ -1,13 +1,13 @@
-upgini/__about__.py,sha256=wEcwloV3XNyxWA40HLqEb4PIXttvc8pREucBfzAKW0c,33
+upgini/__about__.py,sha256=aMsoGp7JafbllKBjbZ_9sxh2xfd5oZMdcOt6Id_WaBU,34
 upgini/__init__.py,sha256=LXSfTNU0HnlOkE69VCxkgIKDhWP-JFo_eBQ71OxTr5Y,261
 upgini/ads.py,sha256=nvuRxRx5MHDMgPr9SiU-fsqRdFaBv8p4_v1oqiysKpc,2714
 upgini/dataset.py,sha256=aspri7ZAgwkNNUiIgQ1GRXvw8XQii3F4RfNXSrF4wrw,35365
 upgini/errors.py,sha256=2b_Wbo0OYhLUbrZqdLIx5jBnAsiD1Mcenh-VjR4HCTw,950
-upgini/features_enricher.py,sha256=ZSSukaq4_mngCkJyQe-XCssXbH8nOD7ByWfSHi9nypc,210847
+upgini/features_enricher.py,sha256=aIG16mpdUZqV0GLMoDA4LiXMPbu3a-m72mhVqGnIww4,210860
 upgini/http.py,sha256=AfaJ3c8z_tK2hZFEehNybDKE0mp1tYcyAP_l0_p8bLQ,43933
 upgini/metadata.py,sha256=Yd6iW2f7Wz6vUkg5uvR4xylN16ANnCKVKqAsAkap7p8,12354
-upgini/metrics.py,sha256=4ehQO8VEebKLiCuBq2LRqC2QbPIqswoe7b1pnR_-zQA,39985
-upgini/search_task.py,sha256=RcvAE785yksWTsTNWuZFVNlk32jHElMoEna1T_C5N8Q,17823
+upgini/metrics.py,sha256=Zb-AwpstEKWaIuLqfIWLF--UGQwIoLbGYnHRlyPQ_cY,43304
+upgini/search_task.py,sha256=Q5HjBpLIB3OCxAD1zNv5yQ3ZNJx696WCK_-H35_y7Rs,17912
 upgini/spinner.py,sha256=4iMd-eIe_BnkqFEMIliULTbj6rNI2HkN_VJ4qYe0cUc,1118
 upgini/version_validator.py,sha256=DvbaAvuYFoJqYt0fitpsk6Xcv-H1BYDJYHUMxaKSH_Y,1509
 upgini/ads_management/__init__.py,sha256=qzyisOToVRP-tquAJD1PblZhNtMrOB8FiyF9JvfkvgE,50
@@ -70,7 +70,7 @@ upgini/utils/target_utils.py,sha256=LRN840dzx78-wg7ftdxAkp2c1eu8-JDvkACiRThm4HE,
 upgini/utils/track_info.py,sha256=G5Lu1xxakg2_TQjKZk4b5SvrHsATTXNVV3NbvWtT8k8,5663
 upgini/utils/ts_utils.py,sha256=26vhC0pN7vLXK6R09EEkMK3Lwb9IVPH7LRdqFIQ3kPs,1383
 upgini/utils/warning_counter.py,sha256=-GRY8EUggEBKODPSuXAkHn9KnEQwAORC0mmz_tim-PM,254
-upgini-1.2.81a3832.dev9.dist-info/METADATA,sha256=6jP4TJl2tN98P8wuWIBARzrPtZVRT48uPukgTvZOvlA,49172
-upgini-1.2.81a3832.dev9.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
-upgini-1.2.81a3832.dev9.dist-info/licenses/LICENSE,sha256=5RRzgvdJUu3BUDfv4bzVU6FqKgwHlIay63pPCSmSgzw,1514
-upgini-1.2.81a3832.dev9.dist-info/RECORD,,
+upgini-1.2.81a3832.dev11.dist-info/METADATA,sha256=h9Tlze7oWU3tEfYMuF9BYZTD7hlFeZM-zjrkIzMml4k,49173
+upgini-1.2.81a3832.dev11.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
+upgini-1.2.81a3832.dev11.dist-info/licenses/LICENSE,sha256=5RRzgvdJUu3BUDfv4bzVU6FqKgwHlIay63pPCSmSgzw,1514
+upgini-1.2.81a3832.dev11.dist-info/RECORD,,