frogml-core 0.0.72__py3-none-any.whl → 0.0.74__py3-none-any.whl

frogml_core/feature_store/offline/client.py

@@ -1,721 +0,0 @@
-from collections import defaultdict
-from datetime import date, datetime
-from functools import reduce
-from typing import DefaultDict, Dict, List, Tuple, Union
-
-from frogml_core.clients.administration.eco_system.client import EcosystemClient
-
-try:
-    import pandas as pd
-except ImportError:
-    pass
-
-from warnings import warn
-
-from dateutil.parser import ParserError
-
-from frogml_core.exceptions import FrogmlException
-from frogml_core.feature_store._common.functions import normalize_cols
-from frogml_core.feature_store.offline.athena.athena_query_engine import (
-    AthenaQueryEngine,
-)
-
-
-class OfflineClient:
-    """
-    A class used to retrieve data from the offline store - mainly used to get train data for models.
-    It requires frogml configure and aws access.
-    @deprecated
-    """
-
-    # Default SCD parameters of the feature store etl
-    ANALYTICS_DB_PREFIX = "qwak_analytics_feature_store"
-    FS_DB_PREFIX = "qwak_feature_store"
-    FS_TABLE_NAME_PREFIX = "offline_feature_store"
-    FS_START_TIME_COLUMN = "start_timestamp"
-    FS_END_TIME_COLUMN = "end_timestamp"
-    FEATURE_STORE_PREFIX = "feature_store"
-
-    DEFAULT_NUMBER_OF_SAMPLE_DATA_ROWS = "100"
-
-    def __init__(
-        self,
-        query_engine=None,
-        environment_id=None,
-    ):
-        warn(
-            "This Client will be deprecated soon, Please use OfflineClientV2 Instead",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-        self.query_engine = (
-            query_engine if query_engine is not None else AthenaQueryEngine()
-        )
-        self.quotes = self.query_engine.get_quotes()
-        if environment_id is None:
-            user_context = EcosystemClient().get_authenticated_user_context().user
-            environment_id = (
-                user_context.account_details.default_environment_id.replace("-", "_")
-            )
-
-        self.environment_id = environment_id.replace("-", "_")
-        self.FS_DB_NAME = self.FS_DB_PREFIX + "_" + self.environment_id
-        self.FS_ANALYTICS_DB_NAME = self.ANALYTICS_DB_PREFIX + "_" + self.environment_id
-
-    def get_feature_range_values(
-        self,
-        entity_key_to_features: dict,
-        start_date: Union[datetime, date],
-        end_date: Union[datetime, date],
-    ):
-        """
-        :param entity_key_to_features: a dictionary { entity_key(s) -> features list }.
-        :param start_date: the column name of the point in time column (default - timestamp)
-        :param end_date: the column name of the point in time column (default - timestamp)
-        :return: a pandas dataframe or a list of dataframes (a dataframe for every entity_key) - all feature values for
-         all entites under the given date range
-        @depracted
-
-        each row in the returned data-frame is constructed by retrieving the requested features of the entity
-         key(s) for all entity values in within the defined date tange.
-
-        Feature sets should be named [Feature Set Name].[Feature Name],
-        i.e: user_purchases.number_of_purchases.
-
-        Examples:
-        >>> from datetime import datetime
-        >>> from frogml_core.feature_store.offline import OfflineClient
-        >>>
-        >>> start_date = datetime(year=2021, month=1, day=1)
-        >>> end_date = datetime(year=2021, month=1, day=3)
-        >>>
-        >>> key_to_features = {'uuid': ['user_purchases.number_of_purchases',
-        >>>                             'user_purchases.avg_purchase_amount']}
-        >>>
-        >>> offline_feature_store = OfflineClient()
-        >>>
-        >>> train_df = offline_feature_store.get_feature_range_values(
-        >>>                entity_key_to_features=key_to_features,
-        >>>                start_date=start_date,
-        >>>                end_date=end_date)
-        >>>
-        >>> print(train_df.head())
-        >>> #	     uuid	         timestamp	      user_purchases.number_of_purchases	user_purchases.avg_purchase_amount
-        >>> # 0	      1	        2021-01-02 17:00:00	                 76	                                4.796842
-        >>> # 1	      1	        2021-01-01 12:00:00	                 5	                                1.548000
-        >>> # 2	      2	        2021-01-02 12:00:00	                 5	                                5.548000
-        >>> # 3	      2	        2021-01-01 18:00:00	                 5	                                2.788000
-        """
-        warn(
-            "This method will be deprecated soon, Please use OfflineClientV2: get_feature_values() Instead",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-        try:
-            from frogml_core.feature_store._common.featureset_asterisk_handler import (
-                unpack_asterisk_features_from_key_mapping,
-            )
-
-            entity_key_to_features = unpack_asterisk_features_from_key_mapping(
-                entity_key_to_features, lambda: self
-            )
-            self._validate_range_query_inputs(
-                entity_key_to_features, start_date, end_date
-            )
-
-            feature_set_name_to_feature_list = (
-                self._partition_feature_set_by_entity_feature(entity_key_to_features)
-            )
-            feature_set_to_dtypes = self._validate_database_and_get_feature_set_dtypes(
-                feature_set_name_to_feature_list
-            )
-            self._validate_features_exist(
-                feature_set_name_to_feature_list, feature_set_to_dtypes
-            )
-
-            df = self._run_ranges_query(
-                feature_set_name_to_feature_list, start_date, end_date
-            )
-
-            return self._normalize_df(df)
-
-        except FrogmlException as qwak_exception:
-            raise FrogmlException(
-                f"Got the following Qwak generated exception: {qwak_exception}"
-            )
-        except Exception as e:
-            raise FrogmlException(f"Got the following run-time exception: {e}")
-        finally:
-            try:
-                self.query_engine.cleanup()
-            except Exception as e:
-                print(f"Got the following run-time exception during cleanup: {e}")
-
-    def get_feature_values(
-        self,
-        entity_key_to_features: dict,
-        population: "pd.DataFrame",
-        point_in_time_column_name: str = "timestamp",
-    ):
-        """
-        :param entity_key_to_features: a dictionary { entity_key(s) -> features list }.
-        :param population: a pandas data-frame with a point in time column
-                           and a column for each entity key defined at entity_key_to_features.
-        :param point_in_time_column_name: the column name of the point in time column (default - timestamp)
-        :return: a pandas data-frame - the population joined with the feature values for all
-                                       the requested entities and features.
-        @deprecated
-
-        each row in the returned data-frame is constructed by retrieving the requested features of the entity key(s) for
-        the specific entity value(s) in the population and on the specific point in time defined.
-
-        Feature sets should be named [Feature Set Name].[Feature Name],
-        i.e: user_purchases.number_of_purchases.
-
-        Examples:
-        >>> import pandas as pd
-        >>> from frogml_core.feature_store.offline import OfflineClient
-        >>>
-        >>> population_df = pd.DataFrame(
-        >>>     columns= ['uuid',       'timestamp'     ],
-        >>>     data   =[[ '1'  , '2021-01-02 17:00:00' ],
-        >>>              [ '2'  , '2021-01-01 12:00:00' ]])
-        >>>
-        >>> key_to_features = {'uuid': ['user_purchases.number_of_purchases',
-        >>>                             'user_purchases.avg_purchase_amount']}
-        >>>
-        >>> offline_feature_store = OfflineClient()
-        >>>
-        >>> train_df = offline_feature_store.get_feature_values(
-        >>>                entity_key_to_features=key_to_features,
-        >>>                population=population_df,
-        >>>                point_in_time_column_name='timestamp')
-        >>>
-        >>> print(train_df.head())
-        >>> #	     uuid	         timestamp	      user_purchases.number_of_purchases	user_purchases.avg_purchase_amount
-        >>> # 0	      1	        2021-04-24 17:00:00	                 76	                                4.796842
-        >>> # 1	      2	        2021-04-24 12:00:00	                 5	                                1.548000
-        """
-        warn(
-            "This method will be deprecated soon, Please use OfflineClientV2: get_feature_range_values() Instead",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-        import pandas as pd
-
-        try:
-            from frogml_core.feature_store._common.featureset_asterisk_handler import (
-                unpack_asterisk_features_from_key_mapping,
-            )
-
-            population = population.copy()
-
-            entity_key_to_features = unpack_asterisk_features_from_key_mapping(
-                entity_key_to_features, lambda: self
-            )
-
-            self._validate_point_in_time_query_inputs(
-                entity_key_to_features, population, point_in_time_column_name
-            )
-
-            feature_set_name_to_feature_dict = (
-                self._partition_feature_set_by_entity_feature(entity_key_to_features)
-            )
-
-            feature_set_to_dtypes = self._validate_database_and_get_feature_set_dtypes(
-                feature_set_name_to_feature_dict
-            )
-
-            self._validate_features_exist(
-                feature_set_name_to_feature_dict,
-                feature_set_to_dtypes,
-            )
-
-            population = self._align_entity_key_dtype(
-                feature_set_to_dtypes, entity_key_to_features, population
-            )
-
-            uploaded_population_path = self.query_engine.upload_table(population)
-
-            df = pd.DataFrame()
-
-            if feature_set_name_to_feature_dict:
-                df = self._run_point_in_time_query(
-                    feature_set_name_to_feature_dict,
-                    uploaded_population_path,
-                    point_in_time_column_name,
-                    [column.lower() for column in population.columns],
-                )
-
-            return self._normalize_df(df)
-
-        except FrogmlException as qwak_exception:
-            raise FrogmlException(
-                f"Got the following Qwak generated exception: {qwak_exception}"
-            )
-        except Exception as e:
-            raise FrogmlException(f"Got the following run-time exception: {e}")
-        finally:
-            try:
-                self.query_engine.cleanup()
-            except Exception as e:
-                print(f"Got the following run-time exception during cleanup: {e}")
-
-    @staticmethod
-    def _normalize_df(df: "pd.DataFrame") -> "pd.DataFrame":
-        columns = df.columns.values.tolist()
-        new_columns = normalize_cols(columns)
-        df.columns = new_columns
-        return df
-
-    @staticmethod
-    def _validate_range_query_inputs(
-        entity_key_to_features: dict, start_date: datetime, end_date: datetime
-    ):
-        missing_features_entity_keys = [
-            entity_key
-            for entity_key, features in entity_key_to_features.items()
-            if not features
-        ]
-
-        if missing_features_entity_keys:
-            raise FrogmlException(
-                f"Features of an entity key must exist, missing features for: [{missing_features_entity_keys}]"
-            )
-
-        if (end_date - start_date).total_seconds() < 0:
-            raise FrogmlException("Invalid date range - end date is before start date")
-
-    @staticmethod
-    def _validate_point_in_time_query_inputs(
-        entity_key_to_features: dict,
-        population: "pd.DataFrame",
-        point_in_time_column_name: str,
-    ):
-        """
-        Validates that the entity keys, timestamp cols and features exist in DB
-        """
-        missing_keys = [
-            entity_key
-            for entity_key in entity_key_to_features.keys()
-            if entity_key not in population
-        ]
-        if missing_keys:
-            raise FrogmlException(
-                f"The entity keys must be in population_df columns, missing: [{missing_keys}]"
-            )
-
-        missing_features_entity_keys = [
-            entity_key
-            for entity_key, features in entity_key_to_features.items()
-            if not features
-        ]
-
-        if missing_features_entity_keys:
-            raise FrogmlException(
-                f"Features of an entity key must exist, missing features for: [{missing_features_entity_keys}]"
-            )
-
-        if point_in_time_column_name not in population:
-            raise FrogmlException(
-                "The point in time column must be part of the population dataframe"
-            )
-
-        from pandas.api.types import is_datetime64_any_dtype
-
-        if not is_datetime64_any_dtype(population[point_in_time_column_name]):
-            try:
-                population[point_in_time_column_name] = pd.to_datetime(
-                    population[point_in_time_column_name]
-                )
-            except ParserError as e:
-                raise FrogmlException(
-                    f"It was not possible to cast provided point in time column to datetime"
-                    f"\nError message: {e}"
-                )
-
-    @staticmethod
-    def _partition_feature_set_by_entity_feature(
-        entity_key_to_features,
-    ) -> DefaultDict[Tuple[str, str], List[str]]:
-        """
-        Partition feature by entity key and featureset name
-        Args:
-            entity_key_to_features: dict of entity_key -> full feature name
-        Returns:
-            dict of (entity_key,featureset_name) -> list of feature names
-        """
-        feature_name_to_feature_list = defaultdict(list)
-
-        for entity_key, feature_list in entity_key_to_features.items():
-            for feature in feature_list:
-                split_feature_set_and_feature = feature.lower().split(".")
-                if len(split_feature_set_and_feature) != 2:
-                    raise FrogmlException(
-                        f"Failed to verify features. Name should be: <feature set name>.<feature name>. "
-                        f"Current name is: {feature}"
-                    )
-                feature_set_name = split_feature_set_and_feature[0]
-                feature_name_to_feature_list[(entity_key, feature_set_name)].append(
-                    feature
-                )
-
-        return feature_name_to_feature_list
-
-    def _validate_database_and_get_feature_set_dtypes(
-        self, feature_name_to_feature_list: DefaultDict[Tuple[str, str], List[str]]
-    ) -> Dict[Tuple[str, str], List[Tuple[str, str]]]:
-        """
-        Args:
-            feature_name_to_feature_list:  dictionary from feature set name to its' features
-
-        Returns
-            dictionary from feature set name and entity key to a list of feature name, feature type
-        """
-        if self.FS_DB_NAME not in self._fs_db_names():
-            raise FrogmlException("Offline feature store does not contain any data")
-
-        feature_set_to_dtypes = {}
-        for (
-            entity_key,
-            feature_set_name,
-        ), feature_list in feature_name_to_feature_list.items():
-            table_name = self._get_offline_feature_store_full_name(feature_set_name)
-            if table_name not in self._fs_tables_names():
-                raise FrogmlException(
-                    f"[{feature_set_name}] feature set does not contain any data"
-                )
-
-            columns_query_result = self.query_engine.run_query(
-                f"SELECT * FROM INFORMATION_SCHEMA.COLUMNS "  # nosec B608
-                f"WHERE TABLE_SCHEMA = '{self.FS_DB_NAME}' "
-                f"AND TABLE_NAME = '{table_name}'"
-            )
-
-            feature_set_to_dtypes[(entity_key, feature_set_name)] = [
-                (column_tup[3], column_tup[7]) for column_tup in columns_query_result
-            ]
-        return feature_set_to_dtypes
-
-    @staticmethod
-    def _validate_features_exist(
-        feature_name_to_feature_list: defaultdict,
-        feature_set_to_dtypes: Dict[Tuple[str, str], List[Tuple[str, str]]],
-    ):
-        """
-        Args:
-            feature_name_to_feature_list: dictionary from feature set name to its' features
-            feature_set_to_dtypes: dictionary from feature set name and entity key
-                                   to a list of feature name, feature type
-        """
-        for (
-            entity_key,
-            feature_set_name,
-        ), feature_list in feature_name_to_feature_list.items():
-            columns = [
-                column_tuple[0].lower()
-                for column_tuple in feature_set_to_dtypes[
-                    (entity_key, feature_set_name)
-                ]
-            ]
-            absent_features = [
-                feature for feature in feature_list if feature not in columns
-            ]
-            if absent_features:
-                raise FrogmlException(
-                    f"Missing the following features for the feature set "
-                    f"[{feature_set_name}]:"
-                    f"\n{absent_features}"
-                )
-
-    def _align_entity_key_dtype(
-        self,
-        feature_set_to_dtypes: Dict[Tuple[str, str], List[Tuple[str, str]]],
-        entity_key_to_features: Dict[str, List[str]],
-        population: "pd.DataFrame",
-    ) -> "pd.DataFrame":
-        """
-        Args:
-            feature_set_to_dtypes: dictionary from feature set name and entity key
-                                   to a list of feature name, feature type
-            entity_key_to_features: a dictionary { entity_key(s) -> features list }.
-            population: a pandas data-frame with a point in time column
-                           and a column for each entity key defined at entity_key_to_features.
-        Returns:
-            entity type aligned population df
-        """
-        sql_type_to_pandas = {
-            "string": "string",
-            "integer": "int",
-            "varchar": "string",
-            "text": "string",
-            "bigint": "int",
-        }
-
-        entity_key_to_dtype = self._validate_and_get_entity_keys_dtypes(
-            entity_key_to_features, population
-        )
-
-        for (
-            entity_key,
-            feature_set_name,
-        ), feature_dtypes_list in feature_set_to_dtypes.items():
-            given_entity_key_dtype = entity_key_to_dtype[entity_key]
-            entity_column_tuple = [
-                column_tuple
-                for column_tuple in feature_dtypes_list
-                if column_tuple[0] == entity_key
-            ]
-            if not entity_column_tuple:
-                raise FrogmlException(
-                    f"Did not find entity key [{entity_key}] in the table of [{feature_set_name}] "
-                    f"- existing columns are: "
-                    f"{[column_tuple[0] for column_tuple in feature_dtypes_list]}"
-                )
-            actual_entity_type = entity_column_tuple[0][1]
-            if actual_entity_type == given_entity_key_dtype:
-                continue
-            else:
-                try:
-                    population[entity_key] = population[entity_key].astype(
-                        sql_type_to_pandas[actual_entity_type]
-                    )
-                    print(
-                        f"Entity [{entity_key}] given type [{given_entity_key_dtype}] "
-                        f"was not aligned with actual type [{actual_entity_type}] - casted to correct type"
-                    )
-                except ValueError as e:
-                    raise FrogmlException(
-                        f"Mismatched entity type for [{entity_key}] - [{given_entity_key_dtype}] "
-                        f"- failed to cast to actual type [{actual_entity_type}], Error: {e}"
-                    )
-
-        return population
-
-    def _validate_and_get_entity_keys_dtypes(
-        self,
-        entity_key_to_features: Dict[str, List[str]],
-        population_df: "pd.DataFrame",
-    ) -> Dict[str, str]:
-        """
-        Args:
-            entity_key_to_features: a dictionary { entity_key(s) -> features list }.
-            population_df: a pandas data-frame with a point in time column
-                           and a column for each entity key defined at entity_key_to_features.
-
-        Returns:
-            dictionary of entity key to it's dtype
-        """
-        supported_dtypes_to_actual_type = {
-            "object": "string",
-            "int32": "integer",
-            "int64": "integer",
-        }
-        entity_key_to_dtype = {}
-        for entity_key in entity_key_to_features.keys():
-            entity_pandas_dtype = population_df.dtypes[entity_key].name
-            if entity_pandas_dtype not in supported_dtypes_to_actual_type:
-                raise FrogmlException(
-                    f"Got an unsupported dtype for the entity key "
-                    f"[{entity_key}] - [{entity_pandas_dtype}]"
-                )
-            entity_key_to_dtype[entity_key] = supported_dtypes_to_actual_type[
-                entity_pandas_dtype
-            ]
-        return entity_key_to_dtype
-
-    def _run_ranges_query(
-        self,
-        feature_name_to_feature_list: defaultdict,
-        start_date: datetime,
-        end_date: datetime,
-    ):
-        result_dfs = []
-        features_set_by_entity = defaultdict(lambda: defaultdict(set))
-        for (
-            (entity_key, feature_set_name),
-            feature_list,
-        ) in feature_name_to_feature_list.items():
-            for feature in feature_list:
-                feature_set_name = feature.split(".")[0]
-                features_set_by_entity[entity_key][feature_set_name].add(feature)
-
-        for entity_key, features_dict in features_set_by_entity.items():
-            entity_dfs = []
-            for feature_set_name, feature_list in features_dict.items():
-                offline_feature_store_full_path, table_path = self.get_fs_full_path(
-                    feature_set_name
-                )
-
-                features = ", ".join(
-                    [
-                        f"{offline_feature_store_full_path}.{self.quotes}{feature}{self.quotes}"
-                        for feature in feature_list
-                    ]
-                )
-
-                where_part = (
-                    "WHERE "
-                    f"{table_path}.{self.FS_START_TIME_COLUMN} >= timestamp '{start_date}' "
-                    f"AND ({self.FS_END_TIME_COLUMN} <= "
-                    f"timestamp '{end_date}' OR {table_path}.{self.FS_END_TIME_COLUMN} IS NULL) "
-                    f"AND {table_path}.{self.FS_START_TIME_COLUMN} < timestamp '{end_date}'"
-                )
-
-                full_sql = (
-                    f"SELECT {offline_feature_store_full_path}.{self.quotes}{entity_key}{self.quotes}, "  # nosec B608
-                    f"{offline_feature_store_full_path}.{self.quotes}{self.FS_START_TIME_COLUMN}{self.quotes}, "
-                    f"{features} "
-                    f"FROM {offline_feature_store_full_path} "
-                    f"{where_part}"
-                )
-
-                entity_dfs.append(self.query_engine.read_pandas_from_query(full_sql))
-
-            entity_final_df = reduce(
-                lambda left, right: pd.merge(
-                    left, right, on=[entity_key, self.FS_START_TIME_COLUMN], how="outer"
-                ),
-                entity_dfs,
-            )
-            result_dfs.append(entity_final_df.reset_index(drop=True))
-
-        return result_dfs[0] if len(result_dfs) == 1 else result_dfs
-
-    def _run_point_in_time_query(
-        self,
-        feature_name_to_feature_list: defaultdict,
-        uploaded_population_path: str,
-        point_in_time_column_name: str,
-        population_list: list,
-    ) -> "pd.DataFrame":
-        """
-        creates SQL query for pint in time feature fetching based on population and requested features
-        """
-        dfs = []
-
-        for index, ((entity_key, feature_set_name), feature_list) in enumerate(
-            feature_name_to_feature_list.items()
-        ):
-            offline_feature_store_full_path, table_path = self.get_fs_full_path(
-                feature_set_name
-            )
-
-            join_part = self._get_join_population_sql(
-                entity_key, offline_feature_store_full_path, uploaded_population_path
-            )
-
-            point_in_time_column_full_path = (
-                f"{uploaded_population_path}.{point_in_time_column_name}"
-            )
-
-            where_part = (
-                "WHERE "
-                f"{point_in_time_column_full_path} >= "
-                f"{table_path}.{self.FS_START_TIME_COLUMN} "
-                f"AND ({point_in_time_column_full_path} < "
-                f"{table_path}.{self.FS_END_TIME_COLUMN} OR "
-                f"{table_path}.{self.FS_END_TIME_COLUMN} IS NULL)"
-            )
-
-            features = ", ".join(
-                [
-                    f"{offline_feature_store_full_path}.{self.quotes}{feature}{self.quotes} as {self.quotes}{feature}{self.quotes}"
-                    for feature in feature_list
-                ]
-            )
-
-            final_query_features = ", ".join(
-                [
-                    f"filtered_features.{self.quotes}{feature}{self.quotes} as {self.quotes}{feature}{self.quotes}"
-                    for feature in feature_list
-                ]
-            )
-
-            full_sql = (
-                f"WITH "  # nosec B608
-                "filtered_features AS ( "
-                f"SELECT {uploaded_population_path}.*, {features} "
-                f"FROM {uploaded_population_path} "
-                f"{join_part} "
-                f"{where_part} "
-                ") "
-                f"SELECT population.*, {final_query_features} "
-                f"FROM {uploaded_population_path} population "
-                f"LEFT JOIN filtered_features "
-                f"ON population.{entity_key} = filtered_features.{entity_key} "
-                f"AND population.{point_in_time_column_name} = filtered_features.{point_in_time_column_name}"
-            )
-
-            dfs.append(
-                self.query_engine.read_pandas_from_query(
-                    full_sql, [point_in_time_column_name]
-                )
-            )
-        return self._merge_query_dataframes_results(dfs, population_list)
-
-    @staticmethod
-    def _merge_query_dataframes_results(
-        dfs: List["pd.DataFrame"], population_list
-    ) -> "pd.DataFrame":
-        """
-        merges query result dataframes according to population list cols
-        """
-        if dfs:
-            df_final = reduce(
-                lambda left, right: pd.merge(
-                    left, right, on=population_list, how="outer"
-                ),
-                dfs,
-            )
-
-            ordered_cols = population_list + (
-                df_final.columns.drop(population_list).tolist()
-            )
-
-            return df_final[ordered_cols].reset_index(drop=True)
-        else:
-            return pd.DataFrame()
-
-    def _get_join_population_sql(
-        self, entity_key, offline_feature_store_full_path, uploaded_population_path
-    ):
-        """
-        return a join sql query for uploaded population table
-        """
-        join_part = (
-            f"LEFT JOIN {offline_feature_store_full_path} ON "
-            f"{offline_feature_store_full_path}.{entity_key} = "
-            f"{uploaded_population_path}.{entity_key} "
-        )
-        return join_part
-
-    def get_fs_full_path(self, feature_set_name: str) -> Tuple[str, str]:
-        offline_feature_store_table_name = self._get_offline_feature_store_full_name(
-            feature_set_name
-        )
-        table_path = f"{self.quotes}{offline_feature_store_table_name}{self.quotes}"
-        offline_feature_store_full_path = (
-            f"{self.quotes}{self.FS_DB_NAME}{self.quotes}."
-            f"{self.quotes}{offline_feature_store_table_name}{self.quotes}"
-        )
-        return offline_feature_store_full_path, table_path
-
-    def _fs_db_names(self) -> List[str]:
-        return [
-            database_tuple[0]
-            for database_tuple in self.query_engine.run_query("SHOW SCHEMAS")
-        ]
-
-    def _fs_tables_names(self) -> List[str]:
-        return [
-            table_tuple[0]
-            for table_tuple in self.query_engine.run_query(
-                f"SHOW TABLES IN {self.FS_DB_NAME}"
-            )
-        ]
-
-    def _get_offline_feature_store_full_name(self, feature_set_name: str) -> str:
-        return f"{self.FS_TABLE_NAME_PREFIX}_{feature_set_name}".lower().replace(
-            "-", "_"
-        )