upgini 1.1.244a24__py3-none-any.whl → 1.1.245a1__py3-none-any.whl

upgini/features_enricher.py

@@ -50,7 +50,7 @@ from upgini.metadata import (
     SearchKey,
 )
 from upgini.metrics import EstimatorWrapper, validate_scoring_argument
-from upgini.resource_bundle import bundle
+from upgini.resource_bundle import ResourceBundle, get_custom_bundle, bundle
 from upgini.search_task import SearchTask
 from upgini.spinner import Spinner
 from upgini.utils import combine_search_keys
@@ -186,8 +186,10 @@ class FeaturesEnricher(TransformerMixin):
         baseline_score_column: Optional[Any] = None,
         client_ip: Optional[str] = None,
         client_visitorid: Optional[str] = None,
+        custom_bundle_config: Optional[str] = None,
         **kwargs,
     ):
+        self.bundle = get_custom_bundle(custom_bundle_config)
         self._api_key = api_key or os.environ.get(UPGINI_API_KEY)
         if api_key is not None and not isinstance(api_key, str):
             raise ValidationError(f"api_key should be `string`, but passed: `{api_key}`")
@@ -240,23 +242,23 @@ class FeaturesEnricher(TransformerMixin):
         if search_id:
             search_task = SearchTask(search_id, rest_client=self.rest_client, logger=self.logger)
 
-            print(bundle.get("search_by_task_id_start"))
+            print(self.bundle.get("search_by_task_id_start"))
             trace_id = str(uuid.uuid4())
             with MDC(trace_id=trace_id):
                 try:
-                    self.logger.info(f"FeaturesEnricher created from existing search: {search_id}")
+                    self.logger.debug(f"FeaturesEnricher created from existing search: {search_id}")
                     self._search_task = search_task.poll_result(trace_id, quiet=True, check_fit=True)
                     file_metadata = self._search_task.get_file_metadata(trace_id)
                     x_columns = [c.originalName or c.name for c in file_metadata.columns]
                     self.__prepare_feature_importances(trace_id, x_columns)
                     # TODO validate search_keys with search_keys from file_metadata
-                    print(bundle.get("search_by_task_id_finish"))
-                    self.logger.info(f"Successfully initialized with search_id: {search_id}")
+                    print(self.bundle.get("search_by_task_id_finish"))
+                    self.logger.debug(f"Successfully initialized with search_id: {search_id}")
                 except HttpError as e:
                     if "Interrupted by client" in e.args[0]:
                         raise ValidationError("Search was cancelled")
                 except Exception as e:
-                    print(bundle.get("failed_search_by_task_id"))
+                    print(self.bundle.get("failed_search_by_task_id"))
                     self.logger.exception(f"Failed to find search_id: {search_id}")
                     raise e
 
@@ -277,13 +279,13 @@ class FeaturesEnricher(TransformerMixin):
         self.round_embeddings = round_embeddings
         if generate_features is not None:
             if len(generate_features) > self.GENERATE_FEATURES_LIMIT:
-                msg = bundle.get("too_many_generate_features").format(self.GENERATE_FEATURES_LIMIT)
+                msg = self.bundle.get("too_many_generate_features").format(self.GENERATE_FEATURES_LIMIT)
                 self.logger.error(msg)
                 raise ValidationError(msg)
             self.runtime_parameters.properties["generate_features"] = ",".join(generate_features)
             if round_embeddings is not None:
                 if not isinstance(round_embeddings, int) or round_embeddings < 0:
-                    msg = bundle.get("invalid_round_embeddings")
+                    msg = self.bundle.get("invalid_round_embeddings")
                     self.logger.error(msg)
                     raise ValidationError(msg)
                 self.runtime_parameters.properties["round_embeddings"] = round_embeddings
@@ -309,7 +311,7 @@ class FeaturesEnricher(TransformerMixin):
     api_key = property(_get_api_key, _set_api_key)
 
     @staticmethod
-    def _check_eval_set(eval_set, X):
+    def _check_eval_set(eval_set, X, bundle: ResourceBundle):
         checked_eval_set = []
         if eval_set is not None and isinstance(eval_set, tuple):
             eval_set = [eval_set]
@@ -318,7 +320,7 @@ class FeaturesEnricher(TransformerMixin):
         for eval_pair in eval_set or []:
             if not isinstance(eval_pair, tuple) or len(eval_pair) != 2:
                 raise ValidationError(bundle.get("eval_set_invalid_tuple_size").format(len(eval_pair)))
-            if not is_frames_equal(X, eval_pair[0]):
+            if not is_frames_equal(X, eval_pair[0], bundle):
                 checked_eval_set.append(eval_pair)
         return checked_eval_set
 
@@ -401,7 +403,7 @@ class FeaturesEnricher(TransformerMixin):
             try:
                 self.X = X
                 self.y = y
-                self.eval_set = self._check_eval_set(eval_set, X)
+                self.eval_set = self._check_eval_set(eval_set, X, self.bundle)
                 self.dump_input(trace_id, X, y, eval_set)
                 self.__inner_fit(
                     trace_id,
@@ -439,7 +441,7 @@ class FeaturesEnricher(TransformerMixin):
                 if len(e.args) > 0 and (
                     "File doesn't intersect with any ADS" in str(e.args[0]) or "Empty intersection" in str(e.args[0])
                 ):
-                    self.__display_support_link(bundle.get("features_info_zero_important_features"))
+                    self.__display_support_link(self.bundle.get("features_info_zero_important_features"))
                 elif isinstance(e, ValidationError):
                     self._dump_python_libs()
                     self._show_error(str(e))
@@ -540,11 +542,13 @@ class FeaturesEnricher(TransformerMixin):
             try:
                 self.X = X
                 self.y = y
-                self.eval_set = self._check_eval_set(eval_set, X)
+                self.eval_set = self._check_eval_set(eval_set, X, self.bundle)
                 self.dump_input(trace_id, X, y, eval_set)
 
                 if _num_samples(drop_duplicates(X)) > Dataset.MAX_ROWS:
-                    raise ValidationError(bundle.get("dataset_too_many_rows_registered").format(Dataset.MAX_ROWS))
+                    raise ValidationError(
+                        self.bundle.get("dataset_too_many_rows_registered").format(Dataset.MAX_ROWS)
+                    )
 
                 self.__inner_fit(
                     trace_id,
@@ -581,7 +585,7 @@ class FeaturesEnricher(TransformerMixin):
                 if len(e.args) > 0 and (
                     "File doesn't intersect with any ADS" in str(e.args[0]) or "Empty intersection" in str(e.args[0])
                 ):
-                    self.__display_support_link(bundle.get("features_info_zero_important_features"))
+                    self.__display_support_link(self.bundle.get("features_info_zero_important_features"))
                     return None
                 elif isinstance(e, ValidationError):
                     self._dump_python_libs()
@@ -677,11 +681,11 @@ class FeaturesEnricher(TransformerMixin):
             self.__validate_search_keys(self.search_keys, self.search_id)
             try:
                 if len(self.feature_names_) == 0:
-                    self.logger.warning(bundle.get("no_important_features_for_transform"))
+                    self.logger.warning(self.bundle.get("no_important_features_for_transform"))
                     return X
 
                 if self._has_paid_features(exclude_features_sources):
-                    msg = bundle.get("transform_with_paid_features")
+                    msg = self.bundle.get("transform_with_paid_features")
                     self.logger.warning(msg)
                     self.__display_support_link(msg)
                     return None
@@ -691,13 +695,15 @@ class FeaturesEnricher(TransformerMixin):
                     self.logger.info(f"Current transform usage: {transform_usage}. Transforming {len(X)} rows")
                     if transform_usage.has_limit:
                         if len(X) > transform_usage.rest_rows:
-                            msg = bundle.get("transform_usage_warning").format(len(X), transform_usage.rest_rows)
+                            msg = self.bundle.get("transform_usage_warning").format(
+                                len(X), transform_usage.rest_rows
+                            )
                             self.logger.warning(msg)
                             print(msg)
                             show_request_quote_button()
                             return None
                         else:
-                            msg = bundle.get("transform_usage_info").format(
+                            msg = self.bundle.get("transform_usage_info").format(
                                 transform_usage.limit, transform_usage.transformed_rows
                             )
                             self.logger.info("transform_usage_warning")
@@ -735,13 +741,13 @@ class FeaturesEnricher(TransformerMixin):
                 if len(e.args) > 0 and (
                     "File doesn't intersect with any ADS" in str(e.args[0]) or "Empty intersection" in str(e.args[0])
                 ):
-                    self.__display_support_link(bundle.get("features_info_zero_important_features"))
+                    self.__display_support_link(self.bundle.get("features_info_zero_important_features"))
                     return None
                 elif len(e.args) > 0 and (
                     "You have reached the quota limit of trial data usage" in str(e.args[0])
                     or "Current user hasn't access to trial features" in str(e.args[0])
                 ):
-                    self.__display_support_link(bundle.get("trial_quota_limit_riched"))
+                    self.__display_support_link(self.bundle.get("trial_quota_limit_riched"))
                     return None
                 elif isinstance(e, ValidationError):
                     self._dump_python_libs()
@@ -858,7 +864,7 @@ class FeaturesEnricher(TransformerMixin):
                     or (self.X is None and X is None)
                     or (self.y is None and y is None)
                 ):
-                    raise ValidationError(bundle.get("metrics_unfitted_enricher"))
+                    raise ValidationError(self.bundle.get("metrics_unfitted_enricher"))
 
                 if X is not None and y is None:
                     raise ValidationError("X passed without y")
@@ -866,18 +872,12 @@ class FeaturesEnricher(TransformerMixin):
                 effective_X = X if X is not None else self.X
                 effective_eval_set = eval_set if eval_set is not None else self.eval_set
 
-                effective_X = X if X is not None else self.X
-                effective_eval_set = eval_set if eval_set is not None else self.eval_set
-
-                effective_X = X if X is not None else self.X
-                effective_eval_set = eval_set if eval_set is not None else self.eval_set
-
                 validate_scoring_argument(scoring)
 
                 self._validate_baseline_score(effective_X, effective_eval_set)
 
                 if self._has_paid_features(exclude_features_sources):
-                    msg = bundle.get("metrics_with_paid_features")
+                    msg = self.bundle.get("metrics_with_paid_features")
                     self.logger.warning(msg)
                     self.__display_support_link(msg)
                     return None
@@ -898,7 +898,7 @@ class FeaturesEnricher(TransformerMixin):
                                 if self.search_keys[cat_feature] in [SearchKey.COUNTRY, SearchKey.POSTAL_CODE]:
                                     search_keys_for_metrics.append(cat_feature)
                                 else:
-                                    raise ValidationError(bundle.get("cat_feature_search_key").format(cat_feature))
+                                    raise ValidationError(self.bundle.get("cat_feature_search_key").format(cat_feature))
 
                 prepared_data = self._prepare_data_for_metrics(
                     trace_id=trace_id,
@@ -928,10 +928,10 @@ class FeaturesEnricher(TransformerMixin):
 
                 gc.collect()
 
-                print(bundle.get("metrics_start"))
+                print(self.bundle.get("metrics_start"))
                 with Spinner():
                     if fitting_X.shape[1] == 0 and fitting_enriched_X.shape[1] == 0:
-                        print(bundle.get("metrics_no_important_free_features"))
+                        print(self.bundle.get("metrics_no_important_free_features"))
                         self.logger.warning("No client or free relevant ADS features found to calculate metrics")
                         self.warning_counter.increment()
                         return None
@@ -1025,20 +1025,25 @@ class FeaturesEnricher(TransformerMixin):
                     effective_X = X if X is not None else self.X
                     effective_y = y if y is not None else self.y
                     train_metrics = {
-                        bundle.get("quality_metrics_segment_header"): bundle.get("quality_metrics_train_segment"),
-                        bundle.get("quality_metrics_rows_header"): _num_samples(effective_X),
-                        # bundle.get("quality_metrics_match_rate_header"): self._search_task.initial_max_hit_rate_v2(),
+                        self.bundle.get("quality_metrics_segment_header"): self.bundle.get(
+                            "quality_metrics_train_segment"
+                        ),
+                        self.bundle.get("quality_metrics_rows_header"): _num_samples(effective_X),
                     }
                     if model_task_type in [ModelTaskType.BINARY, ModelTaskType.REGRESSION] and is_numeric_dtype(
                         y_sorted
                     ):
-                        train_metrics[bundle.get("quality_metrics_mean_target_header")] = round(np.mean(effective_y), 4)
+                        train_metrics[self.bundle.get("quality_metrics_mean_target_header")] = round(
+                            np.mean(effective_y), 4
+                        )
                     if etalon_metric is not None:
-                        train_metrics[bundle.get("quality_metrics_baseline_header").format(metric)] = etalon_metric
+                        train_metrics[self.bundle.get("quality_metrics_baseline_header").format(metric)] = etalon_metric
                     if enriched_metric is not None:
-                        train_metrics[bundle.get("quality_metrics_enriched_header").format(metric)] = enriched_metric
+                        train_metrics[
+                            self.bundle.get("quality_metrics_enriched_header").format(metric)
+                        ] = enriched_metric
                     if uplift is not None:
-                        train_metrics[bundle.get("quality_metrics_uplift_header")] = uplift
+                        train_metrics[self.bundle.get("quality_metrics_uplift_header")] = uplift
                     metrics = [train_metrics]
 
                     # 3 If eval_set is presented - fit final model on train enriched data and score each
@@ -1090,40 +1095,42 @@ class FeaturesEnricher(TransformerMixin):
 
                             effective_eval_set = eval_set if eval_set is not None else self.eval_set
                             eval_metrics = {
-                                bundle.get("quality_metrics_segment_header"): bundle.get(
+                                self.bundle.get("quality_metrics_segment_header"): self.bundle.get(
                                     "quality_metrics_eval_segment"
                                 ).format(idx + 1),
-                                bundle.get("quality_metrics_rows_header"): _num_samples(effective_eval_set[idx][0]),
-                                # bundle.get("quality_metrics_match_rate_header"): eval_hit_rate,
+                                self.bundle.get("quality_metrics_rows_header"): _num_samples(
+                                    effective_eval_set[idx][0]
+                                ),
+                                # self.bundle.get("quality_metrics_match_rate_header"): eval_hit_rate,
                             }
                             if model_task_type in [ModelTaskType.BINARY, ModelTaskType.REGRESSION] and is_numeric_dtype(
                                 eval_y_sorted
                             ):
-                                eval_metrics[bundle.get("quality_metrics_mean_target_header")] = round(
+                                eval_metrics[self.bundle.get("quality_metrics_mean_target_header")] = round(
                                     np.mean(effective_eval_set[idx][1]), 4
                                 )
                             if etalon_eval_metric is not None:
                                 eval_metrics[
-                                    bundle.get("quality_metrics_baseline_header").format(metric)
+                                    self.bundle.get("quality_metrics_baseline_header").format(metric)
                                 ] = etalon_eval_metric
                             if enriched_eval_metric is not None:
                                 eval_metrics[
-                                    bundle.get("quality_metrics_enriched_header").format(metric)
+                                    self.bundle.get("quality_metrics_enriched_header").format(metric)
                                 ] = enriched_eval_metric
                             if eval_uplift is not None:
-                                eval_metrics[bundle.get("quality_metrics_uplift_header")] = eval_uplift
+                                eval_metrics[self.bundle.get("quality_metrics_uplift_header")] = eval_uplift
 
                             metrics.append(eval_metrics)
 
                     metrics_df = pd.DataFrame(metrics)
-                    mean_target_hdr = bundle.get("quality_metrics_mean_target_header")
+                    mean_target_hdr = self.bundle.get("quality_metrics_mean_target_header")
                     if mean_target_hdr in metrics_df.columns:
                         metrics_df[mean_target_hdr] = metrics_df[mean_target_hdr].astype("float64")
                     do_without_pandas_limits(
                         lambda: self.logger.info(f"Metrics calculation finished successfully:\n{metrics_df}")
                     )
 
-                    uplift_col = bundle.get("quality_metrics_uplift_header")
+                    uplift_col = self.bundle.get("quality_metrics_uplift_header")
                     date_column = self._get_date_column(search_keys)
                     if (
                         uplift_col in metrics_df.columns
@@ -1133,7 +1140,7 @@ class FeaturesEnricher(TransformerMixin):
                         and date_column is not None
                         and is_time_series(validated_X, date_column)
                     ):
-                        msg = bundle.get("metrics_negative_uplift_without_cv")
+                        msg = self.bundle.get("metrics_negative_uplift_without_cv")
                         self.logger.warning(msg)
                         self.__display_support_link(msg)
                     elif uplift_col in metrics_df.columns and (metrics_df[uplift_col] < 0).any():
@@ -1149,7 +1156,7 @@ class FeaturesEnricher(TransformerMixin):
                     "You have reached the quota limit of trial data usage" in str(e.args[0])
                     or "Current user hasn't access to trial features" in str(e.args[0])
                 ):
-                    self.__display_support_link(bundle.get("trial_quota_limit_riched"))
+                    self.__display_support_link(self.bundle.get("trial_quota_limit_riched"))
                 elif isinstance(e, ValidationError):
                     self._dump_python_libs()
                     self._show_error(str(e))
@@ -1171,7 +1178,7 @@ class FeaturesEnricher(TransformerMixin):
             if res[1] < 0.05:
                 uneven_distribution = True
         if uneven_distribution:
-            msg = bundle.get("uneven_eval_target_distribution")
+            msg = self.bundle.get("uneven_eval_target_distribution")
             print(msg)
             self.logger.warning(msg)
 
@@ -1185,14 +1192,14 @@ class FeaturesEnricher(TransformerMixin):
     ) -> List[str]:
         if exclude_features_sources:
             filtered_features_info = self.features_info[
-                ~self.features_info[bundle.get("features_info_name")].isin(exclude_features_sources)
+                ~self.features_info[self.bundle.get("features_info_name")].isin(exclude_features_sources)
             ]
         else:
             filtered_features_info = self.features_info
         return list(
             filtered_features_info.loc[
-                filtered_features_info[bundle.get("features_info_commercial_schema")] == commercial_schema,
-                bundle.get("features_info_name"),
+                filtered_features_info[self.bundle.get("features_info_commercial_schema")] == commercial_schema,
+                self.bundle.get("features_info_name"),
             ].values
         )
 
@@ -1239,7 +1246,7 @@ class FeaturesEnricher(TransformerMixin):
         if X is None:
             return True, self.X, self.y, self.eval_set
 
-        checked_eval_set = self._check_eval_set(eval_set, X)
+        checked_eval_set = self._check_eval_set(eval_set, X, self.bundle)
 
         if (
             X is self.X
@@ -1280,7 +1287,7 @@ class FeaturesEnricher(TransformerMixin):
         is_demo_dataset = hash_input(X, y, eval_set) in DEMO_DATASET_HASHES
         validated_X = self._validate_X(X)
         validated_y = self._validate_y(validated_X, y)
-        checked_eval_set = self._check_eval_set(eval_set, X)
+        checked_eval_set = self._check_eval_set(eval_set, X, self.bundle)
         validated_eval_set = (
             [self._validate_eval_set_pair(validated_X, eval_set_pair) for eval_set_pair in checked_eval_set]
             if checked_eval_set
@@ -1409,7 +1416,7 @@ class FeaturesEnricher(TransformerMixin):
             return self.__sample_balanced(eval_set, trace_id, remove_outliers_calc_metrics)
         else:
             self.logger.info("Dataset is imbalanced or exclude_features_sources or X was passed. Run transform")
-            print(bundle.get("prepare_data_for_metrics"))
+            print(self.bundle.get("prepare_data_for_metrics"))
             return self.__sample_imbalanced(
                 validated_X,
                 validated_y,
@@ -1503,7 +1510,7 @@ class FeaturesEnricher(TransformerMixin):
                     not_msg = ""
                 else:
                     not_msg = "not "
-                msg = bundle.get("target_outliers_warning").format(len(target_outliers_df), top_outliers, not_msg)
+                msg = self.bundle.get("target_outliers_warning").format(len(target_outliers_df), top_outliers, not_msg)
                 print(msg)
                 self.logger.warning(msg)
 
@@ -1529,7 +1536,7 @@ class FeaturesEnricher(TransformerMixin):
         if eval_set is not None:
             if len(enriched_eval_sets) != len(eval_set):
                 raise ValidationError(
-                    bundle.get("metrics_eval_set_count_diff").format(len(enriched_eval_sets), len(eval_set))
+                    self.bundle.get("metrics_eval_set_count_diff").format(len(enriched_eval_sets), len(eval_set))
                 )
 
             for idx in range(len(eval_set)):
@@ -1680,7 +1687,7 @@ class FeaturesEnricher(TransformerMixin):
     def get_features_info(self) -> pd.DataFrame:
         """Returns pandas.DataFrame with SHAP values and other info for each feature."""
         if self._search_task is None or self._search_task.summary is None:
-            msg = bundle.get("features_unfitted_enricher")
+            msg = self.bundle.get("features_unfitted_enricher")
             self.logger.warning(msg)
             raise NotFittedError(msg)
 
@@ -1694,9 +1701,9 @@ class FeaturesEnricher(TransformerMixin):
 
     def get_transactional_transform_api(self):
         if self.api_key is None:
-            raise ValidationError(bundle.get("transactional_transform_unregistered"))
+            raise ValidationError(self.bundle.get("transactional_transform_unregistered"))
         if self._search_task is None:
-            raise ValidationError(bundle.get("transactional_transform_unfited"))
+            raise ValidationError(self.bundle.get("transactional_transform_unfited"))
 
         def key_example(key: SearchKey):
             if key == SearchKey.COUNTRY:
@@ -1761,7 +1768,7 @@ class FeaturesEnricher(TransformerMixin):
     ) -> pd.DataFrame:
         with MDC(trace_id=trace_id):
             if self._search_task is None:
-                raise NotFittedError(bundle.get("transform_unfitted_enricher"))
+                raise NotFittedError(self.bundle.get("transform_unfitted_enricher"))
 
             validated_X = self._validate_X(X, is_transform=True)
 
@@ -1773,13 +1780,13 @@ class FeaturesEnricher(TransformerMixin):
                 and not self.__is_registered
                 and not is_demo_dataset
             ):
-                msg = bundle.get("transform_with_trial_features")
+                msg = self.bundle.get("transform_with_trial_features")
                 self.logger.warning(msg)
                 print(msg)
 
             columns_to_drop = [c for c in validated_X.columns if c in self.feature_names_]
             if len(columns_to_drop) > 0:
-                msg = bundle.get("x_contains_enriching_columns").format(columns_to_drop)
+                msg = self.bundle.get("x_contains_enriching_columns").format(columns_to_drop)
                 self.logger.warning(msg)
                 print(msg)
                 validated_X = validated_X.drop(columns=columns_to_drop)
@@ -1796,7 +1803,7 @@ class FeaturesEnricher(TransformerMixin):
             df = self.__handle_index_search_keys(df, search_keys)
 
             if DEFAULT_INDEX in df.columns:
-                msg = bundle.get("unsupported_index_column")
+                msg = self.bundle.get("unsupported_index_column")
                 self.logger.info(msg)
                 print(msg)
                 df.drop(columns=DEFAULT_INDEX, inplace=True)
@@ -1909,9 +1916,9 @@ class FeaturesEnricher(TransformerMixin):
             gc.collect()
 
             if not silent_mode:
-                print(bundle.get("polling_search_task").format(validation_task.search_task_id))
+                print(self.bundle.get("polling_search_task").format(validation_task.search_task_id))
                 if not self.__is_registered:
-                    print(bundle.get("polling_unregister_information"))
+                    print(self.bundle.get("polling_unregister_information"))
 
             progress = self.get_progress(trace_id, validation_task)
             progress.recalculate_eta(time.time() - start_time)
@@ -1937,10 +1944,10 @@ class FeaturesEnricher(TransformerMixin):
                     time.sleep(polling_period_seconds)
                     progress = self.get_progress(trace_id, validation_task)
             except KeyboardInterrupt as e:
-                print(bundle.get("search_stopping"))
+                print(self.bundle.get("search_stopping"))
                 self.rest_client.stop_search_task_v2(trace_id, validation_task.search_task_id)
                 self.logger.warning(f"Search {validation_task.search_task_id} stopped by user")
-                print(bundle.get("search_stopped"))
+                print(self.bundle.get("search_stopped"))
                 raise e
 
             validation_task.poll_result(trace_id, quiet=True)
@@ -1962,7 +1969,7 @@ class FeaturesEnricher(TransformerMixin):
                 return res
 
             if not silent_mode:
-                print(bundle.get("transform_start"))
+                print(self.bundle.get("transform_start"))
                 # with Spinner():
                 result = enrich()
             else:
@@ -1976,9 +1983,9 @@ class FeaturesEnricher(TransformerMixin):
 
     def _get_excluded_features(self, max_features: Optional[int], importance_threshold: Optional[float]) -> List[str]:
         features_info = self._internal_features_info
-        comm_schema_header = bundle.get("features_info_commercial_schema")
-        shap_value_header = bundle.get("features_info_shap")
-        feature_name_header = bundle.get("features_info_name")
+        comm_schema_header = self.bundle.get("features_info_commercial_schema")
+        shap_value_header = self.bundle.get("features_info_shap")
+        feature_name_header = self.bundle.get("features_info_name")
         external_features = features_info[features_info[comm_schema_header].str.len() > 0]
         filtered_features = external_features
         if importance_threshold is not None:
@@ -2009,28 +2016,28 @@ class FeaturesEnricher(TransformerMixin):
                 return
             else:
                 self.logger.warning("search_keys not provided")
-                raise ValidationError(bundle.get("empty_search_keys"))
+                raise ValidationError(self.bundle.get("empty_search_keys"))
 
         key_types = search_keys.values()
 
         if SearchKey.DATE in key_types and SearchKey.DATETIME in key_types:
-            msg = bundle.get("date_and_datetime_simultanious")
+            msg = self.bundle.get("date_and_datetime_simultanious")
             self.logger.warning(msg)
             raise ValidationError(msg)
 
         if SearchKey.EMAIL in key_types and SearchKey.HEM in key_types:
-            msg = bundle.get("email_and_hem_simultanious")
+            msg = self.bundle.get("email_and_hem_simultanious")
             self.logger.warning(msg)
             raise ValidationError(msg)
 
         if SearchKey.POSTAL_CODE in key_types and SearchKey.COUNTRY not in key_types and self.country_code is None:
-            msg = bundle.get("postal_code_without_country")
+            msg = self.bundle.get("postal_code_without_country")
             self.logger.warning(msg)
             raise ValidationError(msg)
 
         for key_type in SearchKey.__members__.values():
             if key_type != SearchKey.CUSTOM_KEY and list(key_types).count(key_type) > 1:
-                msg = bundle.get("multiple_search_key").format(key_type)
+                msg = self.bundle.get("multiple_search_key").format(key_type)
                 self.logger.warning(msg)
                 raise ValidationError(msg)
 
@@ -2040,7 +2047,7 @@ class FeaturesEnricher(TransformerMixin):
         #     and not is_demo_dataset
         #     and len(set(key_types).intersection(non_personal_keys)) == 0
         # ):
-        #     msg = bundle.get("unregistered_only_personal_keys")
+        #     msg = self.bundle.get("unregistered_only_personal_keys")
         #     self.logger.warning(msg + f" Provided search keys: {key_types}")
         #     raise ValidationError(msg)
 
@@ -2081,19 +2088,22 @@ class FeaturesEnricher(TransformerMixin):
         )
         is_demo_dataset = hash_input(validated_X, validated_y, validated_eval_set) in DEMO_DATASET_HASHES
         if is_demo_dataset:
-            msg = bundle.get("demo_dataset_info")
+            msg = self.bundle.get("demo_dataset_info")
             self.logger.info(msg)
             if not self.__is_registered:
                 print(msg)
 
         if self.generate_features is not None and len(self.generate_features) > 0:
             x_columns = list(validated_X.columns)
+            checked_generate_features = []
             for gen_feature in self.generate_features:
                 if gen_feature not in x_columns:
-                    self.generate_features.remove(gen_feature)
-                    msg = bundle.get("missing_generate_feature").format(gen_feature, x_columns)
+                    msg = self.bundle.get("missing_generate_feature").format(gen_feature, x_columns)
                     print(msg)
                     self.logger.warning(msg)
+                else:
+                    checked_generate_features.append(gen_feature)
+            self.generate_features = checked_generate_features
             self.runtime_parameters.properties["generate_features"] = ",".join(self.generate_features)
 
         validate_scoring_argument(scoring)
@@ -2134,7 +2144,7 @@ class FeaturesEnricher(TransformerMixin):
                 df = pd.concat([df, eval_df])
 
         if DEFAULT_INDEX in df.columns:
-            msg = bundle.get("unsupported_index_column")
+            msg = self.bundle.get("unsupported_index_column")
             self.logger.info(msg)
             print(msg)
             self.fit_dropped_features.add(DEFAULT_INDEX)
@@ -2237,9 +2247,9 @@ class FeaturesEnricher(TransformerMixin):
         if search_id_callback is not None:
             search_id_callback(self._search_task.search_task_id)
 
-        print(bundle.get("polling_search_task").format(self._search_task.search_task_id))
+        print(self.bundle.get("polling_search_task").format(self._search_task.search_task_id))
         if not self.__is_registered:
-            print(bundle.get("polling_unregister_information"))
+            print(self.bundle.get("polling_unregister_information"))
 
         progress = self.get_progress(trace_id)
         prev_progress = None
@@ -2265,14 +2275,14 @@ class FeaturesEnricher(TransformerMixin):
                         f"Search {self._search_task.search_task_id} failed with error {progress.error}"
                         f" and message {progress.error_message}"
                     )
-                    raise RuntimeError(bundle.get("search_task_failed_status"))
+                    raise RuntimeError(self.bundle.get("search_task_failed_status"))
                 time.sleep(poll_period_seconds)
                 progress = self.get_progress(trace_id)
         except KeyboardInterrupt as e:
-            print(bundle.get("search_stopping"))
+            print(self.bundle.get("search_stopping"))
             self.rest_client.stop_search_task_v2(trace_id, self._search_task.search_task_id)
             self.logger.warning(f"Search {self._search_task.search_task_id} stopped by user")
-            print(bundle.get("search_stopped"))
+            print(self.bundle.get("search_stopped"))
             raise e
 
         self._search_task.poll_result(trace_id, quiet=True)
@@ -2293,7 +2303,7 @@ class FeaturesEnricher(TransformerMixin):
             )
             zero_hit_columns = self.get_columns_by_search_keys(zero_hit_search_keys)
             if zero_hit_columns:
-                msg = bundle.get("features_info_zero_hit_rate_search_keys").format(zero_hit_columns)
+                msg = self.bundle.get("features_info_zero_hit_rate_search_keys").format(zero_hit_columns)
                 self.logger.warning(msg)
                 self.__display_support_link(msg)
                 self.warning_counter.increment()
@@ -2305,7 +2315,7 @@ class FeaturesEnricher(TransformerMixin):
             unused_features_for_generation = [
                 dataset.columns_renaming.get(col) or col for col in self._search_task.unused_features_for_generation
             ]
-            msg = bundle.get("features_not_generated").format(unused_features_for_generation)
+            msg = self.bundle.get("features_not_generated").format(unused_features_for_generation)
             self.logger.warning(msg)
             print(msg)
             self.warning_counter.increment()
@@ -2320,7 +2330,7 @@ class FeaturesEnricher(TransformerMixin):
 
         if self._has_paid_features(exclude_features_sources):
             if calculate_metrics is not None and calculate_metrics:
-                msg = bundle.get("metrics_with_paid_features")
+                msg = self.bundle.get("metrics_with_paid_features")
                 self.logger.warning(msg)
                 self.__display_support_link(msg)
         else:
@@ -2331,7 +2341,7 @@ class FeaturesEnricher(TransformerMixin):
                 if len(validated_X) < self.CALCULATE_METRICS_MIN_THRESHOLD or any(
                     [len(eval_X) < self.CALCULATE_METRICS_MIN_THRESHOLD for eval_X, _ in validated_eval_set]
                 ):
-                    msg = bundle.get("too_small_for_metrics")
+                    msg = self.bundle.get("too_small_for_metrics")
                     self.logger.warning(msg)
                     calculate_metrics = False
                 elif len(dataset) * len(dataset.columns) > self.CALCULATE_METRICS_THRESHOLD:
@@ -2362,7 +2372,7 @@ class FeaturesEnricher(TransformerMixin):
         self.__show_report_button()
 
         if not self.warning_counter.has_warnings():
-            self.__display_support_link(bundle.get("all_ok_community_invite"))
+            self.__display_support_link(self.bundle.get("all_ok_community_invite"))
 
     def __adjust_cv(self, df: pd.DataFrame, date_column: pd.Series, model_task_type: ModelTaskType):
         # Check Multivariate time series
@@ -2373,14 +2383,14 @@ class FeaturesEnricher(TransformerMixin):
             and len({SearchKey.PHONE, SearchKey.EMAIL, SearchKey.HEM}.intersection(self.fit_search_keys.keys())) == 0
             and is_blocked_time_series(df, date_column, list(self.fit_search_keys.keys()) + [TARGET])
         ):
-            msg = bundle.get("multivariate_timeseries_detected")
+            msg = self.bundle.get("multivariate_timeseries_detected")
             self.__override_cv(CVType.blocked_time_series, msg, print_warning=False)
         elif (
             self.cv is None
             and model_task_type != ModelTaskType.REGRESSION
             and self._get_group_columns(df, self.fit_search_keys)
         ):
-            msg = bundle.get("group_k_fold_in_classification")
+            msg = self.bundle.get("group_k_fold_in_classification")
             self.__override_cv(CVType.group_k_fold, msg, print_warning=self.cv is not None)
 
     def __override_cv(self, cv: CVType, msg: str, print_warning: bool = True):
@@ -2400,11 +2410,11 @@ class FeaturesEnricher(TransformerMixin):
 
     def _validate_X(self, X, is_transform=False) -> pd.DataFrame:
         if _num_samples(X) == 0:
-            raise ValidationError(bundle.get("x_is_empty"))
+            raise ValidationError(self.bundle.get("x_is_empty"))
 
         if isinstance(X, pd.DataFrame):
             if isinstance(X.columns, pd.MultiIndex) or isinstance(X.index, pd.MultiIndex):
-                raise ValidationError(bundle.get("x_multiindex_unsupported"))
+                raise ValidationError(self.bundle.get("x_multiindex_unsupported"))
             validated_X = X.copy()
         elif isinstance(X, pd.Series):
             validated_X = X.to_frame()
@@ -2413,12 +2423,12 @@ class FeaturesEnricher(TransformerMixin):
             renaming = {c: str(c) for c in validated_X.columns}
             validated_X = validated_X.rename(columns=renaming)
         else:
-            raise ValidationError(bundle.get("unsupported_x_type").format(type(X)))
+            raise ValidationError(self.bundle.get("unsupported_x_type").format(type(X)))
 
         if len(set(validated_X.columns)) != len(validated_X.columns):
-            raise ValidationError(bundle.get("x_contains_dup_columns"))
+            raise ValidationError(self.bundle.get("x_contains_dup_columns"))
         if not is_transform and not validated_X.index.is_unique:
-            raise ValidationError(bundle.get("x_non_unique_index"))
+            raise ValidationError(self.bundle.get("x_non_unique_index"))
 
         if self.exclude_columns is not None:
             validated_X = validated_X.drop(columns=self.exclude_columns, errors="ignore")
@@ -2429,17 +2439,17 @@ class FeaturesEnricher(TransformerMixin):
             )
 
         if TARGET in validated_X.columns:
-            raise ValidationError(bundle.get("x_contains_reserved_column_name").format(TARGET))
+            raise ValidationError(self.bundle.get("x_contains_reserved_column_name").format(TARGET))
         if not is_transform and EVAL_SET_INDEX in validated_X.columns:
-            raise ValidationError(bundle.get("x_contains_reserved_column_name").format(EVAL_SET_INDEX))
+            raise ValidationError(self.bundle.get("x_contains_reserved_column_name").format(EVAL_SET_INDEX))
         if SYSTEM_RECORD_ID in validated_X.columns:
-            raise ValidationError(bundle.get("x_contains_reserved_column_name").format(SYSTEM_RECORD_ID))
+            raise ValidationError(self.bundle.get("x_contains_reserved_column_name").format(SYSTEM_RECORD_ID))
 
         return validated_X
 
     def _validate_y(self, X: pd.DataFrame, y) -> pd.Series:
         if _num_samples(y) == 0:
-            raise ValidationError(bundle.get("y_is_empty"))
+            raise ValidationError(self.bundle.get("y_is_empty"))
 
         if (
             not isinstance(y, pd.Series)
@@ -2447,26 +2457,26 @@ class FeaturesEnricher(TransformerMixin):
             and not isinstance(y, np.ndarray)
             and not isinstance(y, list)
         ):
-            raise ValidationError(bundle.get("unsupported_y_type").format(type(y)))
+            raise ValidationError(self.bundle.get("unsupported_y_type").format(type(y)))
 
         if _num_samples(X) != _num_samples(y):
-            raise ValidationError(bundle.get("x_and_y_diff_size").format(_num_samples(X), _num_samples(y)))
+            raise ValidationError(self.bundle.get("x_and_y_diff_size").format(_num_samples(X), _num_samples(y)))
 
         if isinstance(y, pd.DataFrame):
             if len(y.columns) != 1:
-                raise ValidationError(bundle.get("y_invalid_dimension_dataframe"))
+                raise ValidationError(self.bundle.get("y_invalid_dimension_dataframe"))
             if isinstance(y.columns, pd.MultiIndex) or isinstance(y.index, pd.MultiIndex):
-                raise ValidationError(bundle.get("y_multiindex_unsupported"))
+                raise ValidationError(self.bundle.get("y_multiindex_unsupported"))
             y = y[y.columns[0]]
 
         if isinstance(y, pd.Series):
             if (y.index != X.index).any():
-                raise ValidationError(bundle.get("x_and_y_diff_index"))
+                raise ValidationError(self.bundle.get("x_and_y_diff_index"))
             validated_y = y.copy()
             validated_y.rename(TARGET, inplace=True)
         elif isinstance(y, np.ndarray):
             if y.ndim != 1:
-                raise ValidationError(bundle.get("y_invalid_dimension_array"))
+                raise ValidationError(self.bundle.get("y_invalid_dimension_array"))
             Xy = X.copy()
             Xy[TARGET] = y
             validated_y = Xy[TARGET].copy()
@@ -2476,24 +2486,24 @@ class FeaturesEnricher(TransformerMixin):
             validated_y = Xy[TARGET].copy()
 
         if validated_y.nunique() < 2:
-            raise ValidationError(bundle.get("y_is_constant"))
+            raise ValidationError(self.bundle.get("y_is_constant"))
 
         return validated_y
 
     def _validate_eval_set_pair(self, X: pd.DataFrame, eval_pair: Tuple) -> Tuple[pd.DataFrame, pd.Series]:
         if len(eval_pair) != 2:
-            raise ValidationError(bundle.get("eval_set_invalid_tuple_size").format(len(eval_pair)))
+            raise ValidationError(self.bundle.get("eval_set_invalid_tuple_size").format(len(eval_pair)))
         eval_X = eval_pair[0]
         eval_y = eval_pair[1]
 
         if _num_samples(eval_X) == 0:
-            raise ValidationError(bundle.get("eval_x_is_empty"))
+            raise ValidationError(self.bundle.get("eval_x_is_empty"))
         if _num_samples(eval_y) == 0:
-            raise ValidationError(bundle.get("eval_y_is_empty"))
+            raise ValidationError(self.bundle.get("eval_y_is_empty"))
 
         if isinstance(eval_X, pd.DataFrame):
             if isinstance(eval_X.columns, pd.MultiIndex) or isinstance(eval_X.index, pd.MultiIndex):
-                raise ValidationError(bundle.get("eval_x_multiindex_unsupported"))
+                raise ValidationError(self.bundle.get("eval_x_multiindex_unsupported"))
             validated_eval_X = eval_X.copy()
         elif isinstance(eval_X, pd.Series):
             validated_eval_X = eval_X.to_frame()
@@ -2502,10 +2512,10 @@ class FeaturesEnricher(TransformerMixin):
             renaming = {c: str(c) for c in validated_eval_X.columns}
             validated_eval_X = validated_eval_X.rename(columns=renaming)
         else:
-            raise ValidationError(bundle.get("unsupported_x_type_eval_set").format(type(eval_X)))
+            raise ValidationError(self.bundle.get("unsupported_x_type_eval_set").format(type(eval_X)))
 
         if not validated_eval_X.index.is_unique:
-            raise ValidationError(bundle.get("x_non_unique_index_eval_set"))
+            raise ValidationError(self.bundle.get("x_non_unique_index_eval_set"))
 
         if self.exclude_columns is not None:
             validated_eval_X = validated_eval_X.drop(columns=self.exclude_columns, errors="ignore")
@@ -2519,28 +2529,30 @@ class FeaturesEnricher(TransformerMixin):
             if set(validated_eval_X.columns.to_list()) == set(X.columns.to_list()):
                 validated_eval_X = validated_eval_X[X.columns.to_list()]
             else:
-                raise ValidationError(bundle.get("eval_x_and_x_diff_shape"))
+                raise ValidationError(self.bundle.get("eval_x_and_x_diff_shape"))
 
         if _num_samples(validated_eval_X) != _num_samples(eval_y):
             raise ValidationError(
-                bundle.get("x_and_y_diff_size_eval_set").format(_num_samples(validated_eval_X), _num_samples(eval_y))
+                self.bundle.get("x_and_y_diff_size_eval_set").format(
+                    _num_samples(validated_eval_X), _num_samples(eval_y)
+                )
             )
 
         if isinstance(eval_y, pd.DataFrame):
             if len(eval_y.columns) != 1:
-                raise ValidationError(bundle.get("y_invalid_dimension_dataframe_eval_set"))
+                raise ValidationError(self.bundle.get("y_invalid_dimension_dataframe_eval_set"))
             if isinstance(eval_y.columns, pd.MultiIndex) or isinstance(eval_y.index, pd.MultiIndex):
-                raise ValidationError(bundle.get("eval_y_multiindex_unsupported"))
+                raise ValidationError(self.bundle.get("eval_y_multiindex_unsupported"))
             eval_y = eval_y[eval_y.columns[0]]
 
         if isinstance(eval_y, pd.Series):
             if (eval_y.index != validated_eval_X.index).any():
-                raise ValidationError(bundle.get("x_and_y_diff_index_eval_set"))
+                raise ValidationError(self.bundle.get("x_and_y_diff_index_eval_set"))
             validated_eval_y = eval_y.copy()
             validated_eval_y.rename(TARGET, inplace=True)
         elif isinstance(eval_y, np.ndarray):
             if eval_y.ndim != 1:
-                raise ValidationError(bundle.get("y_invalid_dimension_array_eval_set"))
+                raise ValidationError(self.bundle.get("y_invalid_dimension_array_eval_set"))
             Xy = validated_eval_X.copy()
             Xy[TARGET] = eval_y
             validated_eval_y = Xy[TARGET].copy()
@@ -2549,27 +2561,29 @@ class FeaturesEnricher(TransformerMixin):
             Xy[TARGET] = eval_y
             validated_eval_y = Xy[TARGET].copy()
         else:
-            raise ValidationError(bundle.get("unsupported_y_type_eval_set").format(type(eval_y)))
+            raise ValidationError(self.bundle.get("unsupported_y_type_eval_set").format(type(eval_y)))
 
         if validated_eval_y.nunique() < 2:
-            raise ValidationError(bundle.get("y_is_constant_eval_set"))
+            raise ValidationError(self.bundle.get("y_is_constant_eval_set"))
 
         return validated_eval_X, validated_eval_y
 
     def _validate_baseline_score(self, X: pd.DataFrame, eval_set: Optional[List[Tuple]]):
         if self.baseline_score_column is not None:
             if self.baseline_score_column not in X.columns:
-                raise ValidationError(bundle.get("baseline_score_column_not_exists").format(self.baseline_score_column))
+                raise ValidationError(
+                    self.bundle.get("baseline_score_column_not_exists").format(self.baseline_score_column)
+                )
             if X[self.baseline_score_column].isna().any():
-                raise ValidationError(bundle.get("baseline_score_column_has_na"))
+                raise ValidationError(self.bundle.get("baseline_score_column_has_na"))
             if eval_set is not None:
                 if isinstance(eval_set, tuple):
                     eval_set = [eval_set]
                 for eval in eval_set:
                     if self.baseline_score_column not in eval[0].columns:
-                        raise ValidationError(bundle.get("baseline_score_column_not_exists"))
+                        raise ValidationError(self.bundle.get("baseline_score_column_not_exists"))
                     if eval[0][self.baseline_score_column].isna().any():
-                        raise ValidationError(bundle.get("baseline_score_column_has_na"))
+                        raise ValidationError(self.bundle.get("baseline_score_column_has_na"))
 
     @staticmethod
     def _sample_X_and_y(X: pd.DataFrame, y: pd.Series, enriched_X: pd.DataFrame) -> Tuple[pd.DataFrame, pd.Series]:
@@ -2853,7 +2867,7 @@ class FeaturesEnricher(TransformerMixin):
     ) -> Tuple[pd.DataFrame, Dict[int, pd.DataFrame]]:
         if result_features is None:
             self.logger.error(f"result features not found by search_task_id: {self.get_search_id()}")
-            raise RuntimeError(bundle.get("features_wasnt_returned"))
+            raise RuntimeError(self.bundle.get("features_wasnt_returned"))
         result_features = (
             result_features.drop(columns=EVAL_SET_INDEX)
             if EVAL_SET_INDEX in result_features.columns
@@ -2864,7 +2878,7 @@ class FeaturesEnricher(TransformerMixin):
         dup_features = [c for c in comparing_columns if c in result_features.columns and c != SYSTEM_RECORD_ID]
         if len(dup_features) > 0:
             self.logger.warning(f"X contain columns with same name as returned from backend: {dup_features}")
-            raise ValidationError(bundle.get("returned_features_same_as_passed").format(dup_features))
+            raise ValidationError(self.bundle.get("returned_features_same_as_passed").format(dup_features))
 
         # index overrites from result_features
         original_index_name = df_with_original_index.index.name
@@ -2924,10 +2938,10 @@ class FeaturesEnricher(TransformerMixin):
 
     def __prepare_feature_importances(self, trace_id: str, x_columns: List[str]):
         if self._search_task is None:
-            raise NotFittedError(bundle.get("transform_unfitted_enricher"))
+            raise NotFittedError(self.bundle.get("transform_unfitted_enricher"))
         features_meta = self._search_task.get_all_features_metadata_v2()
         if features_meta is None:
-            raise Exception(bundle.get("missing_features_meta"))
+            raise Exception(self.bundle.get("missing_features_meta"))
 
         original_names_dict = {c.name: c.originalName for c in self._search_task.get_file_metadata(trace_id).columns}
         features_df = self._search_task.get_all_initial_raw_features(trace_id, metrics_calculation=True)
@@ -3017,38 +3031,38 @@ class FeaturesEnricher(TransformerMixin):
             )
             features_info.append(
                 {
-                    bundle.get("features_info_name"): feature_name,
-                    bundle.get("features_info_shap"): round_shap_value(feature_meta.shap_value),
-                    bundle.get("features_info_hitrate"): feature_meta.hit_rate,
-                    bundle.get("features_info_value_preview"): feature_sample,
-                    bundle.get("features_info_provider"): provider,
-                    bundle.get("features_info_source"): source,
-                    bundle.get("features_info_commercial_schema"): commercial_schema,
+                    self.bundle.get("features_info_name"): feature_name,
+                    self.bundle.get("features_info_shap"): 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_commercial_schema"): commercial_schema,
                 }
             )
             features_info_without_links.append(
                 {
-                    bundle.get("features_info_name"): internal_feature_name,
-                    bundle.get("features_info_shap"): round_shap_value(feature_meta.shap_value),
-                    bundle.get("features_info_hitrate"): feature_meta.hit_rate,
-                    bundle.get("features_info_value_preview"): feature_sample,
-                    bundle.get("features_info_provider"): internal_provider,
-                    bundle.get("features_info_source"): internal_source,
-                    bundle.get("features_info_commercial_schema"): commercial_schema,
+                    self.bundle.get("features_info_name"): internal_feature_name,
+                    self.bundle.get("features_info_shap"): 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_commercial_schema"): commercial_schema,
                 }
             )
             internal_features_info.append(
                 {
-                    bundle.get("features_info_name"): internal_feature_name,
+                    self.bundle.get("features_info_name"): internal_feature_name,
                     "feature_link": feature_meta.doc_link,
-                    bundle.get("features_info_shap"): round_shap_value(feature_meta.shap_value),
-                    bundle.get("features_info_hitrate"): feature_meta.hit_rate,
-                    bundle.get("features_info_value_preview"): feature_sample,
-                    bundle.get("features_info_provider"): internal_provider,
+                    self.bundle.get("features_info_shap"): 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,
-                    bundle.get("features_info_source"): internal_source,
+                    self.bundle.get("features_info_source"): internal_source,
                     "source_link": feature_meta.data_source_link,
-                    bundle.get("features_info_commercial_schema"): feature_meta.commercial_schema or "",
+                    self.bundle.get("features_info_commercial_schema"): feature_meta.commercial_schema or "",
                 }
             )
 
@@ -3058,8 +3072,10 @@ class FeaturesEnricher(TransformerMixin):
             self._internal_features_info = pd.DataFrame(internal_features_info)
             do_without_pandas_limits(lambda: self.logger.info(f"Features info:\n{self._internal_features_info}"))
 
-            self.relevant_data_sources = self._group_relevant_data_sources(self.features_info)
-            self._relevant_data_sources_wo_links = self._group_relevant_data_sources(self._features_info_without_links)
+            self.relevant_data_sources = self._group_relevant_data_sources(self.features_info, self.bundle)
+            self._relevant_data_sources_wo_links = self._group_relevant_data_sources(
+                self._features_info_without_links, self.bundle
+            )
             do_without_pandas_limits(
                 lambda: self.logger.info(f"Relevant data sources:\n{self._relevant_data_sources_wo_links}")
             )
@@ -3119,7 +3135,7 @@ class FeaturesEnricher(TransformerMixin):
             return None
 
     @staticmethod
-    def _group_relevant_data_sources(df: pd.DataFrame) -> pd.DataFrame:
+    def _group_relevant_data_sources(df: pd.DataFrame, bundle: ResourceBundle) -> pd.DataFrame:
         return (
             df.query(f"{bundle.get('features_info_provider')} != ''")
             .groupby([bundle.get("features_info_provider"), bundle.get("features_info_source")])
@@ -3174,31 +3190,31 @@ class FeaturesEnricher(TransformerMixin):
         }
         passed_unsupported_search_keys = unsupported_search_keys.intersection(search_keys.values())
         if len(passed_unsupported_search_keys) > 0:
-            raise ValidationError(bundle.get("unsupported_search_key").format(passed_unsupported_search_keys))
+            raise ValidationError(self.bundle.get("unsupported_search_key").format(passed_unsupported_search_keys))
 
         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(bundle.get("search_key_not_found").format(column_id, list(x.columns)))
+                    raise ValidationError(self.bundle.get("search_key_not_found").format(column_id, list(x.columns)))
                 column_name = column_id
                 valid_search_keys[column_name] = meaning_type
             elif isinstance(column_id, int):
                 if column_id >= x.shape[1]:
-                    raise ValidationError(bundle.get("numeric_search_key_not_found").format(column_id, x.shape[1]))
+                    raise ValidationError(self.bundle.get("numeric_search_key_not_found").format(column_id, x.shape[1]))
                 column_name = x.columns[column_id]
                 valid_search_keys[column_name] = meaning_type
             else:
-                raise ValidationError(bundle.get("unsupported_search_key_type").format(type(column_id)))
+                raise ValidationError(self.bundle.get("unsupported_search_key_type").format(type(column_id)))
 
             if meaning_type == SearchKey.COUNTRY and self.country_code is not None:
-                msg = bundle.get("search_key_country_and_country_code")
+                msg = self.bundle.get("search_key_country_and_country_code")
                 self.logger.warning(msg)
                 print(msg)
                 self.country_code = None
 
             if not self.__is_registered and not is_demo_dataset and meaning_type in SearchKey.personal_keys():
-                msg = bundle.get("unregistered_with_personal_keys").format(meaning_type)
+                msg = self.bundle.get("unregistered_with_personal_keys").format(meaning_type)
                 self.logger.warning(msg)
                 if not silent_mode:
                     self.warning_counter.increment()
@@ -3209,7 +3225,7 @@ class FeaturesEnricher(TransformerMixin):
                 if x[column_name].isnull().all() or (
                     is_string_dtype(x[column_name]) and (x[column_name].astype("string").str.strip() == "").all()
                 ):
-                    raise ValidationError(bundle.get("empty_search_key").format(column_name))
+                    raise ValidationError(self.bundle.get("empty_search_key").format(column_name))
 
         if self.detect_missing_search_keys and (
             not is_transform or set(valid_search_keys.values()) != set(self.fit_search_keys.values())
@@ -3219,7 +3235,7 @@ class FeaturesEnricher(TransformerMixin):
             )
 
         if all(k == SearchKey.CUSTOM_KEY for k in valid_search_keys.values()):
-            msg = bundle.get("unregistered_only_personal_keys")
+            msg = self.bundle.get("unregistered_only_personal_keys")
             self.logger.warning(msg + f" Provided search keys: {search_keys}")
             raise ValidationError(msg)
 
@@ -3234,7 +3250,7 @@ class FeaturesEnricher(TransformerMixin):
             and next(iter(valid_search_keys.values())) == SearchKey.DATE
             and not silent_mode
         ):
-            msg = bundle.get("date_only_search")
+            msg = self.bundle.get("date_only_search")
             print(msg)
             self.logger.warning(msg)
             self.warning_counter.increment()
@@ -3243,7 +3259,7 @@ class FeaturesEnricher(TransformerMixin):
         if (self.cv is None or self.cv == CVType.k_fold) and len(maybe_date) > 0 and not silent_mode:
             date_column = next(iter(maybe_date))
             if x[date_column].nunique() > 0.9 * _num_samples(x):
-                msg = bundle.get("date_search_without_time_series")
+                msg = self.bundle.get("date_search_without_time_series")
                 print(msg)
                 self.logger.warning(msg)
                 self.warning_counter.increment()
@@ -3252,7 +3268,7 @@ class FeaturesEnricher(TransformerMixin):
             for k, v in valid_search_keys.items():
                 # Show warning for country only if country is the only key
                 if x[k].nunique() == 1 and (v != SearchKey.COUNTRY or len(valid_search_keys) == 1):
-                    msg = bundle.get("single_constant_search_key").format(v, x[k].values[0])
+                    msg = self.bundle.get("single_constant_search_key").format(v, x[k].values[0])
                     print(msg)
                     self.logger.warning(msg)
                     self.warning_counter.increment()
@@ -3284,11 +3300,11 @@ class FeaturesEnricher(TransformerMixin):
             progress_callback=progress_callback,
         )
         if self.metrics is not None:
-            msg = bundle.get("quality_metrics_header")
+            msg = self.bundle.get("quality_metrics_header")
             display_html_dataframe(self.metrics, self.metrics, msg)
 
     def __show_selected_features(self, search_keys: Dict[str, SearchKey]):
-        msg = bundle.get("features_info_header").format(len(self.feature_names_), list(search_keys.keys()))
+        msg = self.bundle.get("features_info_header").format(len(self.feature_names_), list(search_keys.keys()))
 
         try:
             _ = get_ipython()  # type: ignore
@@ -3297,16 +3313,16 @@ class FeaturesEnricher(TransformerMixin):
             self.logger.info(msg)
             if len(self.feature_names_) > 0:
                 display_html_dataframe(
-                    self.features_info, self._features_info_without_links, bundle.get("relevant_features_header")
+                    self.features_info, self._features_info_without_links, self.bundle.get("relevant_features_header")
                 )
 
                 display_html_dataframe(
                     self.relevant_data_sources,
                     self._relevant_data_sources_wo_links,
-                    bundle.get("relevant_data_sources_header"),
+                    self.bundle.get("relevant_data_sources_header"),
                 )
             else:
-                msg = bundle.get("features_info_zero_important_features")
+                msg = self.bundle.get("features_info_zero_important_features")
                 self.logger.warning(msg)
                 self.__display_support_link(msg)
                 self.warning_counter.increment()
@@ -3333,14 +3349,14 @@ class FeaturesEnricher(TransformerMixin):
             return float(importance_threshold) if importance_threshold is not None else 0.0
         except ValueError:
             self.logger.exception(f"Invalid importance_threshold provided: {importance_threshold}")
-            raise ValidationError(bundle.get("invalid_importance_threshold"))
+            raise ValidationError(self.bundle.get("invalid_importance_threshold"))
 
     def __validate_max_features(self, max_features: Optional[int]) -> int:
         try:
             return int(max_features) if max_features is not None else 400
         except ValueError:
             self.logger.exception(f"Invalid max_features provided: {max_features}")
-            raise ValidationError(bundle.get("invalid_max_features"))
+            raise ValidationError(self.bundle.get("invalid_max_features"))
 
     def __filtered_enriched_features(
         self,
@@ -3372,7 +3388,7 @@ class FeaturesEnricher(TransformerMixin):
                 self.autodetected_search_keys[maybe_key] = SearchKey.POSTAL_CODE
                 self.logger.info(f"Autodetected search key POSTAL_CODE in column {maybe_key}")
                 if not silent_mode:
-                    print(bundle.get("postal_code_detected").format(maybe_key))
+                    print(self.bundle.get("postal_code_detected").format(maybe_key))
 
         if (
             SearchKey.COUNTRY not in search_keys.values()
@@ -3385,7 +3401,7 @@ class FeaturesEnricher(TransformerMixin):
                 self.autodetected_search_keys[maybe_key] = SearchKey.COUNTRY
                 self.logger.info(f"Autodetected search key COUNTRY in column {maybe_key}")
                 if not silent_mode:
-                    print(bundle.get("country_detected").format(maybe_key))
+                    print(self.bundle.get("country_detected").format(maybe_key))
 
         if (
             SearchKey.EMAIL not in search_keys.values()
@@ -3399,13 +3415,13 @@ class FeaturesEnricher(TransformerMixin):
                     self.autodetected_search_keys[maybe_key] = SearchKey.EMAIL
                     self.logger.info(f"Autodetected search key EMAIL in column {maybe_key}")
                     if not silent_mode:
-                        print(bundle.get("email_detected").format(maybe_key))
+                        print(self.bundle.get("email_detected").format(maybe_key))
                 else:
                     self.logger.warning(
                         f"Autodetected search key EMAIL in column {maybe_key}. But not used because not registered user"
                     )
                     if not silent_mode:
-                        print(bundle.get("email_detected_not_registered").format(maybe_key))
+                        print(self.bundle.get("email_detected_not_registered").format(maybe_key))
                     self.warning_counter.increment()
 
         if SearchKey.PHONE not in search_keys.values() and check_need_detect(SearchKey.PHONE):
@@ -3416,20 +3432,20 @@ class FeaturesEnricher(TransformerMixin):
                     self.autodetected_search_keys[maybe_key] = SearchKey.PHONE
                     self.logger.info(f"Autodetected search key PHONE in column {maybe_key}")
                     if not silent_mode:
-                        print(bundle.get("phone_detected").format(maybe_key))
+                        print(self.bundle.get("phone_detected").format(maybe_key))
                 else:
                     self.logger.warning(
                         f"Autodetected search key PHONE in column {maybe_key}. But not used because not registered user"
                     )
                     if not silent_mode:
-                        print(bundle.get("phone_detected_not_registered"))
+                        print(self.bundle.get("phone_detected_not_registered"))
                     self.warning_counter.increment()
 
         return search_keys
 
     def _validate_binary_observations(self, y, task_type: ModelTaskType):
         if task_type == ModelTaskType.BINARY and (y.value_counts() < 1000).any():
-            msg = bundle.get("binary_small_dataset")
+            msg = self.bundle.get("binary_small_dataset")
             self.logger.warning(msg)
             print(msg)
 
@@ -3444,8 +3460,8 @@ class FeaturesEnricher(TransformerMixin):
             self.logger.exception("Failed to dump python libs")
 
     def __display_support_link(self, link_text: Optional[str] = None):
-        support_link = bundle.get("support_link")
-        link_text = link_text or bundle.get("support_text")
+        support_link = self.bundle.get("support_link")
+        link_text = link_text or self.bundle.get("support_text")
         try:
             from IPython.display import HTML, display
 
@@ -3561,7 +3577,7 @@ def _num_samples(x):
         raise TypeError(message) from type_error
 
 
-def is_frames_equal(first, second) -> bool:
+def is_frames_equal(first, second, bundle: ResourceBundle) -> bool:
     if (isinstance(first, pd.DataFrame) and isinstance(second, pd.DataFrame)) or (
         isinstance(first, pd.Series) and isinstance(second, pd.Series)
     ):