upgini 1.2.27__py3-none-any.whl → 1.2.29__py3-none-any.whl

upgini/__about__.py

@@ -1 +1 @@
-__version__ = "1.2.27"
+__version__ = "1.2.29"

upgini/features_enricher.py

@@ -54,6 +54,7 @@ from upgini.metadata import (
     SYSTEM_RECORD_ID,
     TARGET,
     CVType,
+    FeaturesMetadataV2,
     FileColumnMeaningType,
     ModelTaskType,
     RuntimeParameters,
@@ -95,6 +96,7 @@ from upgini.utils.email_utils import (
     EmailSearchKeyConverter,
     EmailSearchKeyDetector,
 )
+from upgini.utils.feature_info import FeatureInfo, _round_shap_value
 from upgini.utils.features_validator import FeaturesValidator
 from upgini.utils.format import Format
 from upgini.utils.ip_utils import IpSearchKeyConverter
@@ -158,6 +160,10 @@ class FeaturesEnricher(TransformerMixin):
 
     shared_datasets: list of str, optional (default=None)
         List of private shared dataset ids for custom search
+
+    select_features: bool, optional (default=False)
+        If True, return only selected features both from input and data sources.
+        Otherwise, return all features from input and only selected features from data sources.
     """
 
     TARGET_NAME = "target"
@@ -224,6 +230,7 @@ class FeaturesEnricher(TransformerMixin):
         client_visitorid: Optional[str] = None,
         custom_bundle_config: Optional[str] = None,
         add_date_if_missing: bool = True,
+        select_features: bool = False,
         **kwargs,
     ):
         self.bundle = get_custom_bundle(custom_bundle_config)
@@ -277,8 +284,11 @@ class FeaturesEnricher(TransformerMixin):
         self._relevant_data_sources_wo_links: pd.DataFrame = self.EMPTY_DATA_SOURCES
         self.metrics: Optional[pd.DataFrame] = None
         self.feature_names_ = []
+        self.dropped_client_feature_names_ = []
         self.feature_importances_ = []
         self.search_id = search_id
+        self.select_features = select_features
+
         if search_id:
             search_task = SearchTask(search_id, rest_client=self.rest_client, logger=self.logger)
 
@@ -999,9 +1009,10 @@ class FeaturesEnricher(TransformerMixin):
                             text_features=self.generate_features,
                             has_date=has_date,
                         )
-                        etalon_metric, _ = baseline_estimator.cross_val_predict(
+                        etalon_cv_result = baseline_estimator.cross_val_predict(
                             fitting_X, y_sorted, self.baseline_score_column
                         )
+                        etalon_metric = etalon_cv_result.get_display_metric()
                         if etalon_metric is None:
                             self.logger.info(
                                 f"Baseline {metric} on train client features is None (maybe all features was removed)"
@@ -1033,9 +1044,9 @@ class FeaturesEnricher(TransformerMixin):
                             text_features=self.generate_features,
                             has_date=has_date,
                         )
-                        enriched_metric, enriched_shaps = enriched_estimator.cross_val_predict(
-                            fitting_enriched_X, enriched_y_sorted
-                        )
+                        enriched_cv_result = enriched_estimator.cross_val_predict(fitting_enriched_X, enriched_y_sorted)
+                        enriched_metric = enriched_cv_result.get_display_metric()
+                        enriched_shaps = enriched_cv_result.shap_values
 
                         if enriched_shaps is not None:
                             self._update_shap_values(enriched_shaps)
@@ -1048,7 +1059,7 @@ class FeaturesEnricher(TransformerMixin):
                         else:
                             self.logger.info(f"Enriched {metric} on train combined features: {enriched_metric}")
                         if etalon_metric is not None and enriched_metric is not None:
-                            uplift = (enriched_metric - etalon_metric) * multiplier
+                            uplift = (enriched_cv_result.metric - etalon_cv_result.metric) * multiplier
 
                     train_metrics = {
                         self.bundle.get("quality_metrics_segment_header"): self.bundle.get(
@@ -1091,9 +1102,10 @@ class FeaturesEnricher(TransformerMixin):
                                     f"Calculate baseline {metric} on eval set {idx + 1} "
                                     f"on client features: {eval_X_sorted.columns.to_list()}"
                                 )
-                                etalon_eval_metric = baseline_estimator.calculate_metric(
+                                etalon_eval_results = baseline_estimator.calculate_metric(
                                     eval_X_sorted, eval_y_sorted, self.baseline_score_column
                                 )
+                                etalon_eval_metric = etalon_eval_results.get_display_metric()
                                 self.logger.info(
                                     f"Baseline {metric} on eval set {idx + 1} client features: {etalon_eval_metric}"
                                 )
@@ -1105,9 +1117,10 @@ class FeaturesEnricher(TransformerMixin):
                                     f"Calculate enriched {metric} on eval set {idx + 1} "
                                     f"on combined features: {enriched_eval_X_sorted.columns.to_list()}"
                                 )
-                                enriched_eval_metric = enriched_estimator.calculate_metric(
+                                enriched_eval_results = enriched_estimator.calculate_metric(
                                     enriched_eval_X_sorted, enriched_eval_y_sorted
                                 )
+                                enriched_eval_metric = enriched_eval_results.get_display_metric()
                                 self.logger.info(
                                     f"Enriched {metric} on eval set {idx + 1} combined features: {enriched_eval_metric}"
                                 )
@@ -1115,7 +1128,7 @@ class FeaturesEnricher(TransformerMixin):
                                 enriched_eval_metric = None
 
                             if etalon_eval_metric is not None and enriched_eval_metric is not None:
-                                eval_uplift = (enriched_eval_metric - etalon_eval_metric) * multiplier
+                                eval_uplift = (enriched_eval_results.metric - etalon_eval_results.metric) * multiplier
                             else:
                                 eval_uplift = None
 
@@ -1198,9 +1211,7 @@ class FeaturesEnricher(TransformerMixin):
 
     def _update_shap_values(self, new_shaps: Dict[str, float]):
         new_shaps = {
-            feature: self._round_shap_value(shap)
-            for feature, shap in new_shaps.items()
-            if feature in self.feature_names_
+            feature: _round_shap_value(shap) for feature, shap in new_shaps.items() if feature in self.feature_names_
         }
         features_importances = list(new_shaps.items())
         features_importances.sort(key=lambda m: (-m[1], m[0]))
@@ -1249,7 +1260,7 @@ class FeaturesEnricher(TransformerMixin):
                 display_html_dataframe(
                     self.relevant_data_sources,
                     self._relevant_data_sources_wo_links,
-                    self.bundle.get("relevant_features_header"),
+                    self.bundle.get("relevant_data_sources_header"),
                     display_handle=self.data_sources_display_handle,
                 )
             except (ImportError, NameError):
@@ -1437,7 +1448,12 @@ class FeaturesEnricher(TransformerMixin):
         client_features = [
             c
             for c in X_sampled.columns.to_list()
-            if c
+            if (
+                not self.select_features
+                or c in self.feature_names_
+                or (self.fit_columns_renaming is not None and self.fit_columns_renaming.get(c) in self.feature_names_)
+            )
+            and c
             not in (
                 excluding_search_keys
                 + list(self.fit_dropped_features)
@@ -1653,7 +1669,10 @@ class FeaturesEnricher(TransformerMixin):
         generated_features = []
         if date_column is not None:
             converter = DateTimeSearchKeyConverter(date_column, self.date_format, self.logger, self.bundle)
-            df = converter.convert(df, keep_time=True)
+            # Leave original date column values
+            df_with_date_features = converter.convert(df, keep_time=True)
+            df_with_date_features[date_column] = df[date_column]
+            df = df_with_date_features
             generated_features = converter.generated_features
 
         email_columns = SearchKey.find_all_keys(search_keys, SearchKey.EMAIL)
@@ -1662,9 +1681,10 @@ class FeaturesEnricher(TransformerMixin):
             df = generator.generate(df)
             generated_features.extend(generator.generated_features)
 
-        normalizer = Normalizer(self.bundle, self.logger)
-        df, search_keys, generated_features = normalizer.normalize(df, search_keys, generated_features)
-        columns_renaming = normalizer.columns_renaming
+        # normalizer = Normalizer(self.bundle, self.logger)
+        # df, search_keys, generated_features = normalizer.normalize(df, search_keys, generated_features)
+        # columns_renaming = normalizer.columns_renaming
+        columns_renaming = {c: c for c in df.columns}
 
         df, _ = clean_full_duplicates(df, logger=self.logger, bundle=self.bundle)
 
@@ -1980,9 +2000,19 @@ class FeaturesEnricher(TransformerMixin):
         file_metadata = self._search_task.get_file_metadata(str(uuid.uuid4()))
         search_keys = file_metadata.search_types()
         if SearchKey.IPV6_ADDRESS in search_keys:
-            search_keys.remove(SearchKey.IPV6_ADDRESS)
+            # search_keys.remove(SearchKey.IPV6_ADDRESS)
+            search_keys.pop(SearchKey.IPV6_ADDRESS, None)
 
-        keys = "{" + ", ".join([f'"{key.name}": "{key_example(key)}"' for key in search_keys]) + "}"
+        keys = (
+            "{"
+            + ", ".join(
+                [
+                    f'"{key.name}": {{"name": "{name}", "value": "{key_example(key)}"}}'
+                    for key, name in search_keys.items()
+                ]
+            )
+            + "}"
+        )
         features_for_transform = self._search_task.get_features_for_transform()
         if features_for_transform:
             original_features_for_transform = [
@@ -2026,7 +2056,10 @@ class FeaturesEnricher(TransformerMixin):
         start_time = time.time()
         with MDC(trace_id=trace_id):
             self.logger.info("Start transform")
-            self.__log_debug_information(X, exclude_features_sources=exclude_features_sources)
+
+            validated_X = self._validate_X(X, is_transform=True)
+
+            self.__log_debug_information(validated_X, exclude_features_sources=exclude_features_sources)
 
             self.__validate_search_keys(self.search_keys, self.search_id)
 
@@ -2058,11 +2091,11 @@ class FeaturesEnricher(TransformerMixin):
                         self.logger.info(msg)
                         print(msg)
 
-            validated_X = self._validate_X(X, is_transform=True)
-
             is_demo_dataset = hash_input(validated_X) in DEMO_DATASET_HASHES
 
-            columns_to_drop = [c for c in validated_X.columns if c in self.feature_names_]
+            columns_to_drop = [
+                c for c in validated_X.columns if c in self.feature_names_ and c in self.dropped_client_feature_names_
+            ]
             if len(columns_to_drop) > 0:
                 msg = self.bundle.get("x_contains_enriching_columns").format(columns_to_drop)
                 self.logger.warning(msg)
@@ -2091,7 +2124,7 @@ class FeaturesEnricher(TransformerMixin):
             date_column = SearchKey.find_key(search_keys, [SearchKey.DATE, SearchKey.DATETIME])
             if date_column is not None:
                 converter = DateTimeSearchKeyConverter(date_column, self.date_format, self.logger, bundle=self.bundle)
-                df = converter.convert(df)
+                df = converter.convert(df, keep_time=True)
                 self.logger.info(f"Date column after convertion: {df[date_column]}")
                 generated_features.extend(converter.generated_features)
             else:
@@ -2186,11 +2219,12 @@ class FeaturesEnricher(TransformerMixin):
 
             if add_fit_system_record_id:
                 df = self.__add_fit_system_record_id(df, search_keys, SYSTEM_RECORD_ID)
-                if DateTimeSearchKeyConverter.DATETIME_COL in df.columns:
-                    df = df.drop(columns=DateTimeSearchKeyConverter.DATETIME_COL)
                 df = df.rename(columns={SYSTEM_RECORD_ID: SORT_ID})
                 features_not_to_pass.append(SORT_ID)
 
+            if DateTimeSearchKeyConverter.DATETIME_COL in df.columns:
+                df = df.drop(columns=DateTimeSearchKeyConverter.DATETIME_COL)
+
             # 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(
@@ -2209,7 +2243,7 @@ class FeaturesEnricher(TransformerMixin):
 
             combined_search_keys = combine_search_keys(search_keys.keys())
 
-            df_without_features = df.drop(columns=features_not_to_pass)
+            df_without_features = df.drop(columns=features_not_to_pass, errors="ignore")
 
             df_without_features, full_duplicates_warning = clean_full_duplicates(
                 df_without_features, self.logger, bundle=self.bundle
@@ -2318,11 +2352,15 @@ class FeaturesEnricher(TransformerMixin):
             else:
                 result = enrich()
 
+            selecting_columns = [
+                c
+                for c in itertools.chain(validated_X.columns.tolist(), generated_features)
+                if c not in self.dropped_client_feature_names_
+            ]
             filtered_columns = self.__filtered_enriched_features(importance_threshold, max_features)
-            existing_filtered_columns = [
+            selecting_columns.extend(
                 c for c in filtered_columns if c in result.columns and c not in validated_X.columns
-            ]
-            selecting_columns = validated_X.columns.tolist() + generated_features + existing_filtered_columns
+            )
             if add_fit_system_record_id:
                 selecting_columns.append(SORT_ID)
 
@@ -2476,9 +2514,9 @@ class FeaturesEnricher(TransformerMixin):
         validate_scoring_argument(scoring)
 
         self.__log_debug_information(
-            X,
-            y,
-            eval_set,
+            validated_X,
+            validated_y,
+            validated_eval_set,
             exclude_features_sources=exclude_features_sources,
             calculate_metrics=calculate_metrics,
             scoring=scoring,
@@ -3489,15 +3527,7 @@ class FeaturesEnricher(TransformerMixin):
 
         return result_train, result_eval_sets
 
-    @staticmethod
-    def _round_shap_value(shap: float) -> float:
-        if shap > 0.0 and shap < 0.0001:
-            return 0.0001
-        else:
-            return round(shap, 4)
-
     def __prepare_feature_importances(self, trace_id: str, x_columns: List[str], silent=False):
-        llm_source = "LLM with external data augmentation"
         if self._search_task is None:
             raise NotFittedError(self.bundle.get("transform_unfitted_enricher"))
         features_meta = self._search_task.get_all_features_metadata_v2()
@@ -3508,116 +3538,40 @@ class FeaturesEnricher(TransformerMixin):
         features_df = self._search_task.get_all_initial_raw_features(trace_id, metrics_calculation=True)
 
         self.feature_names_ = []
+        self.dropped_client_feature_names_ = []
         self.feature_importances_ = []
         features_info = []
         features_info_without_links = []
         internal_features_info = []
 
-        def list_or_single(lst: List[str], single: str):
-            return lst or ([single] if single else [])
-
-        def to_anchor(link: str, value: str) -> str:
-            if not value:
-                return ""
-            elif not link:
-                return value
-            elif value == llm_source:
-                return value
-            else:
-                return f"<a href='{link}' target='_blank' rel='noopener noreferrer'>{value}</a>"
-
-        def make_links(names: List[str], links: List[str]):
-            all_links = [to_anchor(link, name) for name, link in itertools.zip_longest(names, links)]
-            return ",".join(all_links)
-
         features_meta.sort(key=lambda m: (-m.shap_value, m.name))
         for feature_meta in features_meta:
             if feature_meta.name in original_names_dict.keys():
                 feature_meta.name = original_names_dict[feature_meta.name]
-            # Use only enriched features
+
+            is_client_feature = feature_meta.name in x_columns
+
+            if feature_meta.shap_value == 0.0:
+                if self.select_features:
+                    self.dropped_client_feature_names_.append(feature_meta.name)
+                continue
+
+            # Use only important features
             if (
-                feature_meta.name in x_columns
+                feature_meta.name in self.fit_generated_features
                 or feature_meta.name == COUNTRY
-                or feature_meta.shap_value == 0.0
-                or feature_meta.name in self.fit_generated_features
+                # In select_features mode we select also from etalon features and need to show them
+                or (not self.select_features and is_client_feature)
             ):
                 continue
 
-            feature_sample = []
             self.feature_names_.append(feature_meta.name)
-            self.feature_importances_.append(self._round_shap_value(feature_meta.shap_value))
-            if feature_meta.name in features_df.columns:
-                feature_sample = np.random.choice(features_df[feature_meta.name].dropna().unique(), 3).tolist()
-                if len(feature_sample) > 0 and isinstance(feature_sample[0], float):
-                    feature_sample = [round(f, 4) for f in feature_sample]
-                feature_sample = [str(f) for f in feature_sample]
-                feature_sample = ", ".join(feature_sample)
-                if len(feature_sample) > 30:
-                    feature_sample = feature_sample[:30] + "..."
-
-            internal_provider = feature_meta.data_provider or "Upgini"
-            providers = list_or_single(feature_meta.data_providers, feature_meta.data_provider)
-            provider_links = list_or_single(feature_meta.data_provider_links, feature_meta.data_provider_link)
-            if providers:
-                provider = make_links(providers, provider_links)
-            else:
-                provider = to_anchor("https://upgini.com", "Upgini")
-
-            internal_source = feature_meta.data_source or (
-                llm_source
-                if not feature_meta.name.endswith("_country") and not feature_meta.name.endswith("_postal_code")
-                else ""
-            )
-            sources = list_or_single(feature_meta.data_sources, feature_meta.data_source)
-            source_links = list_or_single(feature_meta.data_source_links, feature_meta.data_source_link)
-            if sources:
-                source = make_links(sources, source_links)
-            else:
-                source = internal_source
+            self.feature_importances_.append(_round_shap_value(feature_meta.shap_value))
 
-            internal_feature_name = feature_meta.name
-            if feature_meta.doc_link:
-                feature_name = to_anchor(feature_meta.doc_link, feature_meta.name)
-            else:
-                feature_name = internal_feature_name
-
-            features_info.append(
-                {
-                    self.bundle.get("features_info_name"): feature_name,
-                    self.bundle.get("features_info_shap"): self._round_shap_value(feature_meta.shap_value),
-                    self.bundle.get("features_info_hitrate"): feature_meta.hit_rate,
-                    self.bundle.get("features_info_value_preview"): feature_sample,
-                    self.bundle.get("features_info_provider"): provider,
-                    self.bundle.get("features_info_source"): source,
-                    self.bundle.get("features_info_update_frequency"): feature_meta.update_frequency,
-                }
-            )
-            features_info_without_links.append(
-                {
-                    self.bundle.get("features_info_name"): internal_feature_name,
-                    self.bundle.get("features_info_shap"): self._round_shap_value(feature_meta.shap_value),
-                    self.bundle.get("features_info_hitrate"): feature_meta.hit_rate,
-                    self.bundle.get("features_info_value_preview"): feature_sample,
-                    self.bundle.get("features_info_provider"): internal_provider,
-                    self.bundle.get("features_info_source"): internal_source,
-                    self.bundle.get("features_info_update_frequency"): feature_meta.update_frequency,
-                }
-            )
-            internal_features_info.append(
-                {
-                    self.bundle.get("features_info_name"): internal_feature_name,
-                    "feature_link": feature_meta.doc_link,
-                    self.bundle.get("features_info_shap"): self._round_shap_value(feature_meta.shap_value),
-                    self.bundle.get("features_info_hitrate"): feature_meta.hit_rate,
-                    self.bundle.get("features_info_value_preview"): feature_sample,
-                    self.bundle.get("features_info_provider"): internal_provider,
-                    "provider_link": feature_meta.data_provider_link,
-                    self.bundle.get("features_info_source"): internal_source,
-                    "source_link": feature_meta.data_source_link,
-                    self.bundle.get("features_info_commercial_schema"): feature_meta.commercial_schema or "",
-                    self.bundle.get("features_info_update_frequency"): feature_meta.update_frequency,
-                }
-            )
+            feature_info = FeatureInfo.from_metadata(feature_meta, features_df, is_client_feature)
+            features_info.append(feature_info.to_row(self.bundle))
+            features_info_without_links.append(feature_info.to_row_without_links(self.bundle))
+            internal_features_info.append(feature_info.to_internal_row(self.bundle))
 
         if len(features_info) > 0:
             self.features_info = pd.DataFrame(features_info)
@@ -3642,7 +3596,22 @@ class FeaturesEnricher(TransformerMixin):
             autofe_meta = self._search_task.get_autofe_metadata()
             if autofe_meta is None:
                 return None
-            features_meta = self._search_task.get_all_features_metadata_v2()
+            if len(self._internal_features_info) != 0:
+
+                def to_feature_meta(row):
+                    fm = FeaturesMetadataV2(
+                        name=row[bundle.get("features_info_name")],
+                        type="",
+                        source="",
+                        hit_rate=bundle.get("features_info_hitrate"),
+                        shap_value=bundle.get("features_info_shap"),
+                        data_source=bundle.get("features_info_source"),
+                    )
+                    return fm
+
+                features_meta = self._internal_features_info.apply(to_feature_meta).to_list()
+            else:
+                features_meta = self._search_task.get_all_features_metadata_v2()
 
             def get_feature_by_name(name: str):
                 for m in features_meta:
@@ -3762,11 +3731,17 @@ class FeaturesEnricher(TransformerMixin):
         if len(passed_unsupported_search_keys) > 0:
             raise ValidationError(self.bundle.get("unsupported_search_key").format(passed_unsupported_search_keys))
 
+        x_columns = [
+            c
+            for c in x.columns
+            if c not in [TARGET, EVAL_SET_INDEX, SYSTEM_RECORD_ID, ENTITY_SYSTEM_RECORD_ID, SEARCH_KEY_UNNEST]
+        ]
+
         for column_id, meaning_type in search_keys.items():
             column_name = None
             if isinstance(column_id, str):
                 if column_id not in x.columns:
-                    raise ValidationError(self.bundle.get("search_key_not_found").format(column_id, list(x.columns)))
+                    raise ValidationError(self.bundle.get("search_key_not_found").format(column_id, x_columns))
                 column_name = column_id
                 valid_search_keys[column_name] = meaning_type
             elif isinstance(column_id, int):

upgini/http.py

@@ -882,7 +882,7 @@ class _RestClient:
         if content_type:
             headers[_RestClient.CONTENT_TYPE_HEADER_NAME] = content_type
         if trace_id:
-            headers[_RestClient.TRACE_ID_HEADER_NAME] = trace_id
+            headers[_RestClient.TRACE_ID_HEADER_NAME] = str(trace_id)
         for header_key, header_value in additional_headers.items():
             headers[header_key] = header_value
         return headers

upgini/metadata.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from enum import Enum
-from typing import Any, Dict, List, Optional, Set, Union
+from typing import Any, Dict, List, Optional, Union
 
 from pydantic import BaseModel
 
@@ -228,13 +228,13 @@ class FileMetadata(BaseModel):
                 return c
         return None
 
-    def search_types(self) -> Set[SearchKey]:
-        search_keys = set()
+    def search_types(self) -> Dict[SearchKey, str]:
+        search_keys = dict()
         for keys_group in self.searchKeys:
             for key in keys_group:
                 column = self.column_by_name(key)
                 if column:
-                    search_keys.add(SearchKey.from_meaning_type(column.meaningType))
+                    search_keys[SearchKey.from_meaning_type(column.meaningType)] = column.name
         return search_keys
 
 

upgini/metrics.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from dataclasses import dataclass
 import inspect
 import logging
 import re
@@ -210,6 +211,21 @@ SUPPORTED_CATBOOST_METRICS = {
 }
 
 
+@dataclass
+class _CrossValResults:
+    metric: Optional[float]
+    metric_std: Optional[float]
+    shap_values: Optional[Dict[str, float]]
+
+    def get_display_metric(self) -> Optional[str]:
+        if self.metric is None:
+            return None
+        elif self.metric_std is None:
+            return f"{self.metric:.3f}"
+        else:
+            return f"{self.metric:.3f} ± {self.metric_std:.3f}"
+
+
 class EstimatorWrapper:
     def __init__(
         self,
@@ -297,11 +313,11 @@ class EstimatorWrapper:
 
     def cross_val_predict(
         self, x: pd.DataFrame, y: np.ndarray, baseline_score_column: Optional[Any] = None
-    ) -> Tuple[Optional[float], Optional[Dict[str, float]]]:
+    ) -> _CrossValResults:
         x, y, groups, fit_params = self._prepare_to_fit(x, y)
 
         if x.shape[1] == 0:
-            return None
+            return _CrossValResults(metric=None, metric_std=None, shap_values=None)
 
         scorer = check_scoring(self.estimator, scoring=self.scorer)
 
@@ -326,7 +342,7 @@ class EstimatorWrapper:
 
             self.check_fold_metrics(metrics_by_fold)
 
-            metric = np.mean(metrics_by_fold) * self.multiplier
+            metric, metric_std = self._calculate_metric_from_folds(metrics_by_fold)
 
             splits = self.cv.split(x, y, groups)
 
@@ -351,7 +367,7 @@ class EstimatorWrapper:
         else:
             average_shap_values = None
 
-        return self.post_process_metric(metric), average_shap_values
+        return _CrossValResults(metric=metric, metric_std=metric_std, shap_values=average_shap_values)
 
     def process_shap_values(self, shap_values: Dict[str, float]) -> Dict[str, float]:
         return shap_values
@@ -367,17 +383,25 @@ class EstimatorWrapper:
             metric = 2 * metric - 1
         return metric
 
-    def calculate_metric(self, x: pd.DataFrame, y: np.ndarray, baseline_score_column: Optional[Any] = None) -> float:
+    def calculate_metric(
+        self, x: pd.DataFrame, y: np.ndarray, baseline_score_column: Optional[Any] = None
+    ) -> _CrossValResults:
         x, y, _ = self._prepare_to_calculate(x, y)
         if baseline_score_column is not None and self.metric_name == "GINI":
-            metric = roc_auc_score(y, x[baseline_score_column])
+            metric, metric_std = roc_auc_score(y, x[baseline_score_column]), None
         else:
             metrics = []
             for est in self.cv_estimators:
                 metrics.append(self.scorer(est, x, y))
 
-            metric = np.mean(metrics) * self.multiplier
-        return self.post_process_metric(metric)
+            metric, metric_std = self._calculate_metric_from_folds(metrics)
+        return _CrossValResults(metric=metric, metric_std=metric_std, shap_values=None)
+
+    def _calculate_metric_from_folds(self, metrics_by_fold: List[float]) -> Tuple[float, float]:
+        metrics_by_fold = [self.post_process_metric(m) for m in metrics_by_fold]
+        metric = np.mean(metrics_by_fold) * self.multiplier
+        metric_std = np.std(metrics_by_fold) * np.abs(self.multiplier)
+        return metric, metric_std
 
     @staticmethod
     def create(
@@ -591,7 +615,7 @@ class CatBoostWrapper(EstimatorWrapper):
 
     def cross_val_predict(
         self, x: pd.DataFrame, y: np.ndarray, baseline_score_column: Optional[Any] = None
-    ) -> Tuple[Optional[float], Optional[Dict[str, float]]]:
+    ) -> _CrossValResults:
         try:
             return super().cross_val_predict(x, y, baseline_score_column)
         except Exception as e:

upgini/resource_bundle/strings.properties

@@ -82,7 +82,7 @@ unregistered_only_personal_keys=Only personal search keys used. Api_key from pro
 search_key_not_found=Column `{}` from search_keys was not found in X dataframe: {}
 numeric_search_key_not_found=Index {} in search_keys is out of bounds for {} columns of X dataframe
 unsupported_search_key_type=Unsupported type of key in search_keys: {}
-unsupported_type_of_search_key=Unsupported type of search key: {}. It should be a member of SearcKey
+unsupported_type_of_search_key=Unsupported type of search key: {}. It should be a member of SearchKey
 search_key_country_and_country_code=SearchKey.COUNTRY and country_code parameter were passed simultaniously. Parameter country_code will be ignored
 empty_search_key=Search key {} is empty. Please fill values or remove this search key
 single_constant_search_key=Constant value detected for the {} search key in the X dataframe: {}.\nThat search key will add constant features for different y values.\nPlease add extra search keys with non constant values, like the COUNTRY, POSTAL_CODE, DATE, PHONE NUMBER, EMAIL/HEM or IPv4
@@ -201,7 +201,7 @@ email_detected=Emails detected in column `{}`. It will be used as a search key\n
 email_detected_not_registered=Emails detected in column `{}`. It can be used only with api_key from profile.upgini.com\nSee docs to turn off the automatic detection: https://github.com/upgini/upgini/blob/main/README.md#turn-off-autodetection-for-search-key-columns
 phone_detected=Phone numbers detected in column `{}`. It can be used only with api_key from profile.upgini.com\nSee docs to turn off the automatic detection: https://github.com/upgini/upgini/blob/main/README.md#turn-off-autodetection-for-search-key-columns
 phone_detected_not_registered=Phone numbers detected in column `{}`. It can be used only with api_key from profile.upgini.com\nSee docs to turn off the automatic detection: https://github.com/upgini/upgini/blob/main/README.md#turn-off-autodetection-for-search-key-columns
-target_type_detected=Detected task type: {}. Reason: {}\nYou can set task type manually with argument `model_task_type` of FeaturesEnricher constructor if task type detected incorrectly\n
+target_type_detected=\nDetected task type: {}. Reason: {}\nYou can set task type manually with argument `model_task_type` of FeaturesEnricher constructor if task type detected incorrectly\n
 binary_target_reason=only two unique label-values observed
 non_numeric_multiclass_reason=non-numeric label values observed
 few_unique_label_multiclass_reason=few unique label-values observed and can be considered as categorical
@@ -212,7 +212,7 @@ limited_int_multiclass_reason=integer-like values with limited unique values obs
 all_ok_community_invite=❓ Support request 
 too_small_for_metrics=Your train dataset or one of eval datasets contains less than 500 rows. For such dataset Upgini will not calculate accuracy metrics. Please increase the number of rows in the training dataset to calculate accuracy metrics
 imbalance_multiclass=Class {0} is on 25% quantile of classes distribution ({1} records in train dataset). \nDownsample classes with records more than {1}.
-imbalanced_target=Target is imbalanced and will be undersampled. Frequency of the rarest class `{}` is {}
+imbalanced_target=\nTarget is imbalanced and will be undersampled. Frequency of the rarest class `{}` is {}
 loss_selection_info=Using loss `{}` for feature selection
 loss_calc_metrics_info=Using loss `{}` for metrics calculation with default estimator
 

upgini/utils/datetime_utils.py

@@ -109,20 +109,63 @@ class DateTimeSearchKeyConverter:
 
         df = self.clean_old_dates(df)
 
+        # Define function to apply sine and cosine transformations
+        def add_cyclical_features(df, column, period):
+            period_suffix = f"_{period}" if column != "day_in_quarter" else ""
+            sin_feature = f"datetime_{column}_sin{period_suffix}"
+            cos_feature = f"datetime_{column}_cos{period_suffix}"
+            if sin_feature not in df.columns:
+                df[sin_feature] = np.sin(2 * np.pi * df[column] / period)
+                self.generated_features.append(sin_feature)
+            if cos_feature not in df.columns:
+                df[cos_feature] = np.cos(2 * np.pi * df[column] / period)
+                self.generated_features.append(cos_feature)
+
+        df["quarter"] = df[self.date_column].dt.quarter
+
+        # Calculate the start date of the quarter for each timestamp
+        df["quarter_start"] = df[self.date_column].dt.to_period("Q").dt.start_time
+
+        # Calculate the day in the quarter
+        df["day_in_quarter"] = (df[self.date_column] - df["quarter_start"]).dt.days + 1
+
+        # Vectorized calculation of days_in_quarter
+        quarter = df["quarter"]
+        start = df["quarter_start"]
+        year = start.dt.year
+        month = start.dt.month
+
+        quarter_end_year = np.where(quarter == 4, year + 1, year)
+        quarter_end_month = np.where(quarter == 4, 1, month + 3)
+
+        end = pd.to_datetime({"year": quarter_end_year, "month": quarter_end_month, "day": 1})
+        end.index = df.index
+
+        df["days_in_quarter"] = (end - start).dt.days
+
+        add_cyclical_features(df, "day_in_quarter", df["days_in_quarter"])  # Days in the quarter
+
+        df.drop(columns=["quarter", "quarter_start", "day_in_quarter", "days_in_quarter"], inplace=True)
+
         df[seconds] = (df[self.date_column] - df[self.date_column].dt.floor("D")).dt.seconds
 
         seconds_without_na = df[seconds].dropna()
         if (seconds_without_na != 0).any() and seconds_without_na.nunique() > 1:
             self.logger.info("Time found in date search key. Add extra features based on time")
-            seconds_in_day = 60 * 60 * 24
-            orders = [1, 2, 24, 48]
-            for order in orders:
-                sin_feature = f"datetime_time_sin_{order}"
-                cos_feature = f"datetime_time_cos_{order}"
-                df[sin_feature] = np.round(np.sin(2 * np.pi * order * df[seconds] / seconds_in_day), 10)
-                df[cos_feature] = np.round(np.cos(2 * np.pi * order * df[seconds] / seconds_in_day), 10)
-                self.generated_features.append(sin_feature)
-                self.generated_features.append(cos_feature)
+
+            # Extract basic components
+            df["second"] = df[self.date_column].dt.second
+            df["minute"] = df[self.date_column].dt.minute
+            df["hour"] = df[self.date_column].dt.hour
+
+            # Apply cyclical transformations
+            add_cyclical_features(df, "second", 60)  # Seconds in a minute
+            add_cyclical_features(df, "minute", 60)  # Minutes in an hour
+            add_cyclical_features(df, "minute", 30)  # Minutes in half an hour
+            add_cyclical_features(df, "hour", 24)  # Hours in a day
+
+            # Drop intermediate columns if not needed
+            df.drop(columns=["second", "minute", "hour"], inplace=True)
 
         df.drop(columns=seconds, inplace=True)
 

upgini/utils/email_utils.py

@@ -38,8 +38,9 @@ class EmailDomainGenerator:
     def generate(self, df: pd.DataFrame) -> pd.DataFrame:
         for email_col in self.email_columns:
             domain_feature = email_col + self.DOMAIN_SUFFIX
-            df[domain_feature] = df[email_col].apply(self._email_to_domain)
-            self.generated_features.append(domain_feature)
+            if domain_feature not in df.columns:
+                df[domain_feature] = df[email_col].apply(self._email_to_domain).astype("string")
+                self.generated_features.append(domain_feature)
         return df
 
     @staticmethod

upgini/utils/feature_info.py

@@ -0,0 +1,172 @@
+from dataclasses import dataclass
+import itertools
+from typing import Dict, List
+
+import numpy as np
+import pandas as pd
+
+from upgini.metadata import FeaturesMetadataV2
+from upgini.resource_bundle import ResourceBundle
+
+
+LLM_SOURCE = "LLM with external data augmentation"
+
+
+@dataclass
+class FeatureInfo:
+    name: str
+    internal_name: str
+    rounded_shap: float
+    hitrate: float
+    value_preview: str
+    provider: str
+    internal_provider: str
+    source: str
+    internal_source: str
+    update_frequency: str
+    commercial_schema: str
+    doc_link: str
+    data_provider_link: str
+    data_source_link: str
+
+    @staticmethod
+    def from_metadata(feature_meta: FeaturesMetadataV2, data: pd.DataFrame, is_client_feature: bool) -> "FeatureInfo":
+        return FeatureInfo(
+            name=_get_name(feature_meta),
+            internal_name=_get_internal_name(feature_meta),
+            rounded_shap=_round_shap_value(feature_meta.shap_value),
+            hitrate=feature_meta.hit_rate,
+            value_preview=_get_feature_sample(feature_meta, data),
+            provider=_get_provider(feature_meta, is_client_feature),
+            internal_provider=_get_internal_provider(feature_meta, is_client_feature),
+            source=_get_source(feature_meta, is_client_feature),
+            internal_source=_get_internal_source(feature_meta, is_client_feature),
+            update_frequency=feature_meta.update_frequency,
+            commercial_schema=feature_meta.commercial_schema,
+            doc_link=feature_meta.doc_link,
+            data_provider_link=feature_meta.data_provider_link,
+            data_source_link=feature_meta.data_source_link,
+        )
+
+    def to_row(self, bundle: ResourceBundle) -> Dict[str, str]:
+        return {
+            bundle.get("features_info_name"): self.name,
+            bundle.get("features_info_shap"): self.rounded_shap,
+            bundle.get("features_info_hitrate"): self.hitrate,
+            bundle.get("features_info_value_preview"): self.value_preview,
+            bundle.get("features_info_provider"): self.provider,
+            bundle.get("features_info_source"): self.source,
+            bundle.get("features_info_update_frequency"): self.update_frequency,
+        }
+
+    def to_row_without_links(self, bundle: ResourceBundle) -> Dict[str, str]:
+        return {
+            bundle.get("features_info_name"): self.internal_name,
+            bundle.get("features_info_shap"): self.rounded_shap,
+            bundle.get("features_info_hitrate"): self.hitrate,
+            bundle.get("features_info_value_preview"): self.value_preview,
+            bundle.get("features_info_provider"): self.internal_provider,
+            bundle.get("features_info_source"): self.internal_source,
+            bundle.get("features_info_update_frequency"): self.update_frequency,
+        }
+
+    def to_internal_row(self, bundle: ResourceBundle) -> Dict[str, str]:
+        return {
+            bundle.get("features_info_name"): self.internal_name,
+            "feature_link": self.doc_link,
+            bundle.get("features_info_shap"): self.rounded_shap,
+            bundle.get("features_info_hitrate"): self.hitrate,
+            bundle.get("features_info_value_preview"): self.value_preview,
+            bundle.get("features_info_provider"): self.internal_provider,
+            "provider_link": self.data_provider_link,
+            bundle.get("features_info_source"): self.internal_source,
+            "source_link": self.data_source_link,
+            bundle.get("features_info_commercial_schema"): self.commercial_schema or "",
+            bundle.get("features_info_update_frequency"): self.update_frequency,
+        }
+
+
+def _get_feature_sample(feature_meta: FeaturesMetadataV2, data: pd.DataFrame) -> str:
+    if feature_meta.name in data.columns:
+        feature_sample = np.random.choice(data[feature_meta.name].dropna().unique(), 3).tolist()
+        if len(feature_sample) > 0 and isinstance(feature_sample[0], float):
+            feature_sample = [round(f, 4) for f in feature_sample]
+        feature_sample = [str(f) for f in feature_sample]
+        feature_sample = ", ".join(feature_sample)
+        if len(feature_sample) > 30:
+            feature_sample = feature_sample[:30] + "..."
+    else:
+        feature_sample = ""
+    return feature_sample
+
+
+def _get_name(feature_meta: FeaturesMetadataV2) -> str:
+    if feature_meta.doc_link:
+        return _to_anchor(feature_meta.doc_link, feature_meta.name)
+    else:
+        return feature_meta.name
+
+
+def _get_internal_name(feature_meta: FeaturesMetadataV2) -> str:
+    return feature_meta.name
+
+
+def _get_provider(feature_meta: FeaturesMetadataV2, is_client_feature: bool) -> str:
+    providers = _list_or_single(feature_meta.data_providers, feature_meta.data_provider)
+    provider_links = _list_or_single(feature_meta.data_provider_links, feature_meta.data_provider_link)
+    if providers:
+        provider = _make_links(providers, provider_links)
+    else:
+        provider = "" if is_client_feature else _to_anchor("https://upgini.com", "Upgini")
+    return provider
+
+
+def _get_internal_provider(feature_meta: FeaturesMetadataV2, is_client_feature: bool) -> str:
+    return "" if is_client_feature else (feature_meta.data_provider or "Upgini")
+
+
+def _get_source(feature_meta: FeaturesMetadataV2, is_client_feature: bool) -> str:
+    sources = _list_or_single(feature_meta.data_sources, feature_meta.data_source)
+    source_links = _list_or_single(feature_meta.data_source_links, feature_meta.data_source_link)
+    if sources:
+        source = _make_links(sources, source_links)
+    else:
+        source = _get_internal_source(feature_meta, is_client_feature)
+    return source
+
+
+def _get_internal_source(feature_meta: FeaturesMetadataV2, is_client_feature: bool) -> str:
+    return feature_meta.data_source or (
+        LLM_SOURCE
+        if not feature_meta.name.endswith("_country")
+        and not feature_meta.name.endswith("_postal_code")
+        and not is_client_feature
+        else ""
+    )
+
+
+def _list_or_single(lst: List[str], single: str):
+    return lst or ([single] if single else [])
+
+
+def _to_anchor(link: str, value: str) -> str:
+    if not value:
+        return ""
+    elif not link:
+        return value
+    elif value == LLM_SOURCE:
+        return value
+    else:
+        return f"<a href='{link}' target='_blank' rel='noopener noreferrer'>{value}</a>"
+
+
+def _make_links(names: List[str], links: List[str]):
+    all_links = [_to_anchor(link, name) for name, link in itertools.zip_longest(names, links)]
+    return ",".join(all_links)
+
+
+def _round_shap_value(shap: float) -> float:
+    if shap > 0.0 and shap < 0.0001:
+        return 0.0001
+    else:
+        return round(shap, 4)

upgini/utils/features_validator.py

@@ -2,6 +2,7 @@ import logging
 from logging import Logger
 from typing import Dict, List, Optional, Tuple
 
+import numpy as np
 import pandas as pd
 from pandas.api.types import is_integer_dtype, is_object_dtype, is_string_dtype
 
@@ -83,10 +84,21 @@ class FeaturesValidator:
         return [
             i
             for i in df
-            if (is_object_dtype(df[i]) or is_string_dtype(df[i]) or is_integer_dtype(df[i]))
+            if (is_object_dtype(df[i]) or is_string_dtype(df[i]) or FeaturesValidator.__is_integer(df[i]))
             and (df[i].nunique(dropna=False) / row_count >= 0.85)
         ]
 
+    @staticmethod
+    def __is_integer(series: pd.Series) -> bool:
+        return (
+            is_integer_dtype(series)
+            or series.dropna()
+            .apply(
+                lambda f: (float.is_integer(f) and abs(f) < np.iinfo(np.int64).max) if isinstance(f, float) else False
+            )
+            .all()
+        )
+
     @staticmethod
     def find_constant_features(df: pd.DataFrame) -> List[str]:
         return [i for i in df if df[i].nunique() <= 1]

{upgini-1.2.27.dist-info → upgini-1.2.29.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: upgini
-Version: 1.2.27
+Version: 1.2.29
 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.27.dist-info → upgini-1.2.29.dist-info}/RECORD

@@ -1,13 +1,13 @@
-upgini/__about__.py,sha256=JKArgvnX6ljUI_WxYnXTejXGdjsA4KJ3Cy2xBcK4vh4,23
+upgini/__about__.py,sha256=kkc0PkaP1QFrTEPI8N5OtZ0p2wkfpteTOMyPLNGAXgk,23
 upgini/__init__.py,sha256=LXSfTNU0HnlOkE69VCxkgIKDhWP-JFo_eBQ71OxTr5Y,261
 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=7xYxcLvxQgDX7vE2gWEbBPceAVeEgBVpu9xtBJvXpoQ,194078
-upgini/http.py,sha256=21asexflvavydzCOONJDGQBtQanCElrbnqLXakJ9Cu8,42880
+upgini/features_enricher.py,sha256=zcIEKzgiUX46KdtWlMl-15Dz32shXVgscvsQkULusoU,192228
+upgini/http.py,sha256=plZGTGoi1h2edd8Cnjt4eYB8t4NbBGnZz7DtPTByiNc,42885
 upgini/lazy_import.py,sha256=74gQ8JuA48BGRLxAo7lNHNKY2D2emMxrUxKGdxVGhuY,1012
-upgini/metadata.py,sha256=osmzdNESeh7yP3BZday6N9Q3eaIHfzhhRM1d6NSgcf0,11223
-upgini/metrics.py,sha256=PoY1fq6XYAHNzn-rmnwRQZjCoVYP5bJNmKhR0ST2Txk,34588
+upgini/metadata.py,sha256=lUa2xYhBhnCeTqNt6lWc9iP_YuikYGIsDSn8Vwyjv1I,11235
+upgini/metrics.py,sha256=hr7UwLphbZ_FEglLuO2lzr_pFgxOJ4c3WBeg7H-fNqY,35521
 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=h1GViOWzULy5vf6M4dpTJuIk-4V38UCrTY1sb9yLa5I,1594
@@ -30,7 +30,7 @@ upgini/normalizer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU
 upgini/normalizer/normalize_utils.py,sha256=Ft2MwSgVoBilXAORAOYAuwPD79GOLfwn4qQE3IUFzzg,7218
 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=l3yg9H17NwCwvfZQyOYTvXbPP6mwdXH_CGlqyxOQVFY,26669
+upgini/resource_bundle/strings.properties,sha256=fOAeLTsnx8xvJK-7RPFXprATG0n56jeCdse8sQTuVX8,26674
 upgini/resource_bundle/strings_widget.properties,sha256=gOdqvZWntP2LCza_tyVk1_yRYcG4c04K9sQOAVhF_gw,1577
 upgini/sampler/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 upgini/sampler/base.py,sha256=7GpjYqjOp58vYcJLiX__1R5wjUlyQbxvHJ2klFnup_M,6389
@@ -43,12 +43,13 @@ 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=a8X4jX2y3-6E7ZNZIG5z61qfzCvsvaNEjR1Bi5KUqfM,11279
+upgini/utils/datetime_utils.py,sha256=F61i2vZCB6eUy4WwodDyPi50XKPbhOHsxDrU6tGa6CM,13133
 upgini/utils/deduplicate_utils.py,sha256=SMZx9IKIhWI5HqXepfKiQb3uDJrogQZtG6jcWuMo5Z4,8855
 upgini/utils/display_utils.py,sha256=DsBjJ8jEYAh8BPgfAbzq5imoGFV6IACP20PQ78BQCX0,11964
-upgini/utils/email_utils.py,sha256=j0Ug1R_0AnCg1Y92zIZ4XMwvKo3G5_pcOlBN1OH_gZs,5191
+upgini/utils/email_utils.py,sha256=GbnhHJn1nhUBytmK6PophYqaoq4t7Lp6i0-O0Gd3RV8,5265
 upgini/utils/fallback_progress_bar.py,sha256=PDaKb8dYpVZaWMroNcOHsTc3pSjgi9mOm0--cOFTwJ0,1074
-upgini/utils/features_validator.py,sha256=1Xj2ir5LzzYiX3NH8o88c2J6RTTetaTwu0MhjLTyuvM,3378
+upgini/utils/feature_info.py,sha256=Tp_2g5-rCjY4NpzKhzxwNxuqH5FFL8vG94OU5kH6wzk,6702
+upgini/utils/features_validator.py,sha256=lEfmk4DoxZ4ooOE1HC0ZXtUb_lFKRFHIrnFULZ4_rL8,3746
 upgini/utils/format.py,sha256=Yv5cvvSs2bOLUzzNu96Pu33VMDNbabio92QepUj41jU,243
 upgini/utils/ip_utils.py,sha256=Q6vb7Sr5Khx3Sq3eENjW2qCXKej_S5jZbneH6zEOkzQ,5171
 upgini/utils/phone_utils.py,sha256=IrbztLuOJBiePqqxllfABWfYlfAjYevPhXKipl95wUI,10432
@@ -58,7 +59,7 @@ upgini/utils/sklearn_ext.py,sha256=13jQS_k7v0aUtudXV6nGUEWjttPQzAW9AFYL5wgEz9k,4
 upgini/utils/target_utils.py,sha256=PU77nIhTz7IHbC4rpTpxrVxib6cdpRL9F1dhkjIffLY,10225
 upgini/utils/track_info.py,sha256=G5Lu1xxakg2_TQjKZk4b5SvrHsATTXNVV3NbvWtT8k8,5663
 upgini/utils/warning_counter.py,sha256=-GRY8EUggEBKODPSuXAkHn9KnEQwAORC0mmz_tim-PM,254
-upgini-1.2.27.dist-info/METADATA,sha256=iSB1iB7EwBugIUf8DYOz9mEFqGewDAS49-hgYuhtrtU,48578
-upgini-1.2.27.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
-upgini-1.2.27.dist-info/licenses/LICENSE,sha256=5RRzgvdJUu3BUDfv4bzVU6FqKgwHlIay63pPCSmSgzw,1514
-upgini-1.2.27.dist-info/RECORD,,
+upgini-1.2.29.dist-info/METADATA,sha256=i3crJ_plUCfgF91rGJXv_slwHAANMRUps6kRrNjIIso,48578
+upgini-1.2.29.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
+upgini-1.2.29.dist-info/licenses/LICENSE,sha256=5RRzgvdJUu3BUDfv4bzVU6FqKgwHlIay63pPCSmSgzw,1514
+upgini-1.2.29.dist-info/RECORD,,