wedata-feature-engineering 0.1.2__py3-none-any.whl → 0.1.4__py3-none-any.whl

feature_store/utils/uc_utils.py

@@ -0,0 +1,281 @@
+import copy
+import re
+from typing import Optional, Set
+
+from feature_store.entities.feature_spec import FeatureSpec
+
+SINGLE_LEVEL_NAMESPACE_REGEX = r"^[^\. \/\x00-\x1F\x7F]+$"
+TWO_LEVEL_NAMESPACE_REGEX = r"^[^\. \/\x00-\x1F\x7F]+(\.[^\. \/\x00-\x1F\x7F]+)$"
+THREE_LEVEL_NAMESPACE_REGEX = (
+    r"^[^\. \/\x00-\x1F\x7F]+(\.[^\. \/\x00-\x1F\x7F]+)(\.[^\. \/\x00-\x1F\x7F]+)$"
+)
+
+HIVE_METASTORE_NAME = "hive_metastore"
+# these two catalog names both points to the workspace local default HMS (hive metastore).
+LOCAL_METASTORE_NAMES = [HIVE_METASTORE_NAME, "spark_catalog"]
+
+
+# Get full table name in the form of <catalog_name>.<schema_name>.<table_name>
+# given user specified table name, current catalog and schema.
+def get_full_table_name(
+    table_name: str,
+    current_catalog: str,
+    current_schema: str,
+) -> str:
+    _check_qualified_table_names({table_name})
+    return _get_full_name_for_entity(
+        name=table_name,
+        current_catalog=current_catalog,
+        current_schema=current_schema,
+        entity_type="table",
+    )
+
+
+# Get full UDF name in the form of <catalog_name>.<schema_name>.<udf_name>
+# given user specified UDF name, current catalog and schema.
+def get_full_udf_name(
+    udf_name: str,
+    current_catalog: str,
+    current_schema: str,
+) -> str:
+    _check_qualified_udf_names({udf_name})
+    return _get_full_name_for_entity(
+        name=udf_name,
+        current_catalog=current_catalog,
+        current_schema=current_schema,
+        entity_type="UDF",
+    )
+
+
+def _get_full_name_for_entity(
+    name: str,
+    current_catalog: str,
+    current_schema: str,
+    entity_type: str,
+) -> str:
+    if not _is_single_level_name(current_catalog) or not _is_single_level_name(
+        current_schema
+    ):
+        raise ValueError(
+            f"Invalid catalog '{current_catalog}' or "
+            f"schema '{current_schema}' name for {entity_type} '{name}'."
+        )
+    if _is_single_level_name(name):
+        full_name = f"{current_catalog}.{current_schema}.{name}"
+    elif _is_two_level_name(name):
+        full_name = f"{current_catalog}.{name}"
+    elif _is_three_level_name(name):
+        full_name = name
+    else:
+        raise _invalid_names_error({name}, entity_type)
+
+    catalog, schema, name = full_name.split(".")
+    if catalog in LOCAL_METASTORE_NAMES:
+        return f"{HIVE_METASTORE_NAME}.{schema}.{name}"
+    return full_name
+
+
+def _replace_catalog_name(full_name: str, catalog: Optional[str]) -> str:
+    if catalog is None:
+        return full_name
+    name_sec = full_name.split(".")
+    name_sec[0] = catalog
+    return ".".join(name_sec)
+
+
+# Local metastore tables in feature_spec.yaml are all stored in 2L.
+# Standardize table names to be all in 3L to avoid erroneously reading data from UC tables.
+def get_feature_spec_with_full_table_names(
+    feature_spec: FeatureSpec, catalog_name_override: Optional[str] = None
+) -> FeatureSpec:
+    column_info_table_names = [
+        column_info.table_name for column_info in feature_spec.feature_column_infos
+    ]
+    table_info_table_names = [
+        table_info.table_name for table_info in feature_spec.table_infos
+    ]
+    _check_qualified_table_names(set(column_info_table_names))
+    _check_qualified_table_names(set(table_info_table_names))
+    invalid_table_names = list(
+        filter(_is_single_level_name, column_info_table_names)
+    ) + list(filter(_is_single_level_name, table_info_table_names))
+    if len(invalid_table_names) > 0:
+        raise _invalid_names_error(set(invalid_table_names), "table")
+    standardized_feature_spec = copy.deepcopy(feature_spec)
+    for column_info in standardized_feature_spec.feature_column_infos:
+        if _is_two_level_name(column_info.table_name):
+            column_info._table_name = f"{HIVE_METASTORE_NAME}.{column_info.table_name}"
+        column_info._table_name = _replace_catalog_name(
+            column_info.table_name, catalog_name_override
+        )
+    for column_info in standardized_feature_spec.on_demand_column_infos:
+        if _is_two_level_name(column_info.udf_name):
+            column_info._udf_name = f"{HIVE_METASTORE_NAME}.{column_info.udf_name}"
+        column_info._udf_name = _replace_catalog_name(
+            column_info.udf_name, catalog_name_override
+        )
+    for table_info in standardized_feature_spec.table_infos:
+        if _is_two_level_name(table_info.table_name):
+            table_info._table_name = f"{HIVE_METASTORE_NAME}.{table_info.table_name}"
+        table_info._table_name = _replace_catalog_name(
+            table_info.table_name, catalog_name_override
+        )
+    for udf_info in standardized_feature_spec.function_infos:
+        udf_info._udf_name = _replace_catalog_name(
+            udf_info.udf_name, catalog_name_override
+        )
+    return standardized_feature_spec
+
+
+# Reformat 3L table name for tables in local metastore to 2L. This is used when interacting with catalog client
+# and serializing workspace local feature spec for scoring.
+def reformat_full_table_name(full_table_name: str) -> str:
+    if not _is_three_level_name(full_table_name):
+        raise _invalid_names_error({full_table_name}, "table")
+    catalog, schema, table = full_table_name.split(".")
+    if catalog in LOCAL_METASTORE_NAMES:
+        return f"{schema}.{table}"
+    return full_table_name
+
+
+# Reformat table names in feature_spec with reformat_full_table_name
+def get_feature_spec_with_reformat_full_table_names(
+    feature_spec: FeatureSpec,
+) -> FeatureSpec:
+    column_info_table_names = [
+        column_info.table_name for column_info in feature_spec.feature_column_infos
+    ]
+    table_info_table_names = [
+        table_info.table_name for table_info in feature_spec.table_infos
+    ]
+    _check_qualified_table_names(set(column_info_table_names))
+    _check_qualified_table_names(set(table_info_table_names))
+    invalid_table_names = list(
+        filter(lambda name: not _is_three_level_name(name), column_info_table_names)
+    ) + list(
+        filter(lambda name: not _is_three_level_name(name), table_info_table_names)
+    )
+    if len(invalid_table_names) > 0:
+        raise _invalid_names_error(set(invalid_table_names), "table")
+    standardized_feature_spec = copy.deepcopy(feature_spec)
+    for column_info in standardized_feature_spec.feature_column_infos:
+        column_info._table_name = reformat_full_table_name(column_info.table_name)
+    for table_info in standardized_feature_spec.table_infos:
+        table_info._table_name = reformat_full_table_name(table_info.table_name)
+    return standardized_feature_spec
+
+
+def _invalid_names_error(invalid_names: Set[str], entity_type: str) -> ValueError:
+    return ValueError(
+        f"Invalid {entity_type} name{'s' if len(invalid_names) > 1 else ''} '{', '.join(invalid_names)}'."
+    )
+
+
+def _is_qualified_entity_name(name) -> bool:
+    return isinstance(name, str) and (
+        _is_single_level_name(name)
+        or _is_two_level_name(name)
+        or _is_three_level_name(name)
+    )
+
+
+def _is_single_level_name(name) -> bool:
+    return (
+        isinstance(name, str)
+        and re.match(SINGLE_LEVEL_NAMESPACE_REGEX, name) is not None
+    )
+
+
+def _is_two_level_name(name) -> bool:
+    return (
+        isinstance(name, str) and re.match(TWO_LEVEL_NAMESPACE_REGEX, name) is not None
+    )
+
+
+def _is_three_level_name(name) -> bool:
+    return (
+        isinstance(name, str)
+        and re.match(THREE_LEVEL_NAMESPACE_REGEX, name) is not None
+    )
+
+
+def unsupported_api_error_uc(api_name):
+    return ValueError(f"{api_name} is not supported for Unity Catalog tables.")
+
+
+# check if entity is in UC
+def is_uc_entity(full_entity_name) -> bool:
+    catalog_name, schema_name, table_name = full_entity_name.split(".")
+    return not is_default_hms_table(full_entity_name)
+
+
+def is_default_hms_table(full_table_name) -> bool:
+    catalog_name, schema_name, table_name = full_table_name.split(".")
+    return catalog_name in LOCAL_METASTORE_NAMES
+
+
+# check if UDF names are in the correct format - 1L, 2L or 3L
+def _check_qualified_udf_names(udf_names: Set[str]):
+    unqualified_udf_names = [
+        udf_name for udf_name in udf_names if not _is_qualified_entity_name(udf_name)
+    ]
+    if len(unqualified_udf_names) > 0:
+        raise ValueError(
+            f"UDF name{'s' if len(unqualified_udf_names) > 1 else ''} "
+            f"'{', '.join(map(str, unqualified_udf_names))}' must have the form "
+            f"<catalog_name>.<schema_name>.<udf_name>, <schema_name>.<udf_name>, "
+            f"or <udf_name> and cannot include space or forward-slash."
+        )
+
+
+# check if table names are in the correct format - 1L, 2L or 3L
+def _check_qualified_table_names(feature_table_names: Set[str]):
+    unqualified_table_names = list(
+        filter(
+            lambda table_name: not _is_qualified_entity_name(table_name),
+            feature_table_names,
+        )
+    )
+    if len(unqualified_table_names) > 0:
+        raise ValueError(
+            f"Feature table name{'s' if len(unqualified_table_names) > 1 else ''} "
+            f"'{', '.join(map(str, unqualified_table_names))}' must have the form "
+            f"<catalog_name>.<schema_name>.<table_name>, <database_name>.<table_name>, "
+            f"or <table_name> and cannot include space or forward-slash."
+        )
+
+
+# For APIs like create_training_set and score_batch, all tables must all be in
+# UC catalog (shareable cross-workspaces) or default HMS (intended to only be used in the current workspace)
+# check if all tables are either in UC or default HMS.
+def _verify_all_tables_are_either_in_uc_or_in_hms(
+    table_names: Set[str], current_catalog: str, current_schema: str
+):
+    full_table_names = [
+        get_full_table_name(table_name, current_catalog, current_schema)
+        for table_name in table_names
+    ]
+    is_valid = all(
+        [is_uc_entity(full_table_name) for full_table_name in full_table_names]
+    ) or all(
+        [is_default_hms_table(full_table_name) for full_table_name in full_table_names]
+    )
+    if not is_valid:
+        raise ValueError(
+            f"Feature table names '{', '.join(table_names)}' "
+            f"must all be in UC or the local default hive metastore. "
+            f"Mixing feature tables from two different storage locations is not allowed."
+        )
+
+
+# For APIs like create_training_set with FeatureFunctions, only UC UDFs are supported.
+def _verify_all_udfs_in_uc(
+    udf_names: Set[str], current_catalog: str, current_schema: str
+):
+    full_udf_names = [
+        get_full_udf_name(udf_name, current_catalog, current_schema)
+        for udf_name in udf_names
+    ]
+    is_valid = all([is_uc_entity(full_udf_name) for full_udf_name in full_udf_names])
+    if not is_valid:
+        raise ValueError(f"UDFs must all be in Unity Catalog.")

feature_store/utils/utils.py

@@ -0,0 +1,252 @@
+import os
+from datetime import datetime, timezone
+from functools import wraps
+from typing import Any, Dict, List, Optional
+from urllib.parse import urlparse
+
+import mlflow
+from mlflow.exceptions import RestException
+from mlflow.store.artifact.artifact_repository_registry import get_artifact_repository
+from mlflow.utils import databricks_utils
+
+
+
+def enable_if(condition):
+    """
+    A decorator that conditionally enables a function based on a condition.
+    If the condition is not truthy, calling the function raises a NotImplementedError.
+
+    :param condition: A callable that returns a truthy or falsy value.
+    """
+
+    def decorator(func):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            if not condition():
+                raise NotImplementedError
+            return func(*args, **kwargs)
+
+        return wrapper
+
+    return decorator
+
+
+def as_list(obj, default=None):
+    if not obj:
+        return default
+    elif isinstance(obj, list):
+        return obj
+    else:
+        return [obj]
+
+
+def as_directory(path):
+    if path.endswith("/"):
+        return path
+    return f"{path}/"
+
+
+def is_empty(target: str):
+    return target is None or len(target.strip()) == 0
+
+
+class _NoDbutilsError(Exception):
+    pass
+
+
+def _get_dbutils():
+    try:
+        import IPython
+
+        ip_shell = IPython.get_ipython()
+        if ip_shell is None:
+            raise _NoDbutilsError
+        return ip_shell.ns_table["user_global"]["dbutils"]
+    except ImportError:
+        raise _NoDbutilsError
+    except KeyError:
+        raise _NoDbutilsError
+
+
+
+def utc_timestamp_ms_from_iso_datetime_string(date_string: str) -> int:
+    # Python uses seconds for its time granularity, so we multiply by 1000 to convert to milliseconds.
+    # The Feature Store backend returns timestamps in milliseconds, so this allows for direct comparisons.
+    dt = datetime.fromisoformat(date_string)
+    utc_dt = dt.replace(tzinfo=timezone.utc)
+    return 1000 * utc_dt.timestamp()
+
+
+def pip_depependency_pinned_major_version(pip_package_name, major_version):
+    """
+    Generate a pip dependency string that is pinned to a major version, for example: "databricks-feature-lookup==0.*"
+    """
+    return f"{pip_package_name}=={major_version}.*"
+
+
+def add_mlflow_pip_depependency(conda_env, pip_package_name):
+    """
+    Add a new pip dependency to the conda environment taken from the raw MLflow model.  This method should only be
+    called for conda environments created by MLflow rather than for generic conda environments, because it assumes
+    the conda environment already contains pip as a dependency.  In the case of MLflow models, this is a safe
+    assumption because MLflow always needs to add "mlflow" to the conda environment's pip dependencies.
+
+    This is idempotent and will not add a pip package that is already present in the list of pip packages.
+    """
+    if pip_package_name is None or len(pip_package_name) == 0:
+        raise ValueError(
+            "Unexpected input: missing or empty pip_package_name parameter"
+        )
+
+    found_pip_dependency = False
+    if conda_env is not None:
+        for dep in conda_env["dependencies"]:
+            if isinstance(dep, dict) and "pip" in dep:
+                found_pip_dependency = True
+                pip_deps = dep["pip"]
+                if pip_package_name not in pip_deps:
+                    pip_deps.append(pip_package_name)
+        # Fail early rather than at model inference time
+        if "dependencies" in conda_env and not found_pip_dependency:
+            raise ValueError(
+                "Unexpected input: mlflow conda_env did not contain pip as a dependency"
+            )
+
+
+def download_model_artifacts(model_uri, dir):
+    """
+    Downloads model artifacts from model_uri to dir. Intended for use only with Feature Store packaged models.
+
+    :param model_uri: The location, in URI format, of a model. Must be either in the model registry
+      (``models:/<model_name>/<model_version>``, ``models:/<model_name>/<stage>``) or the MLflow
+      artifact store (``runs:/<mlflow_run_id>/run-relative/path/to/model``).
+    :param dir: Location to place downloaded model artifacts.
+    """
+    if not is_artifact_uri(model_uri):
+        raise ValueError(
+            f"Invalid model URI '{model_uri}'."
+            f"Use ``models:/model_name>/<version_number>`` or "
+            f"``runs:/<mlflow_run_id>/run-relative/path/to/model``."
+        )
+
+    try:
+        repo = get_artifact_repository(model_uri)
+    except RestException as e:
+        raise ValueError(f"The model at '{model_uri}' does not exist.", e)
+
+    artifact_path = os.path.join(mlflow.pyfunc.DATA, MODEL_DATA_PATH_ROOT)
+    if len(repo.list_artifacts(artifact_path)) == 0:
+        raise ValueError(
+            f"No suitable model found at '{model_uri}'. Either no model exists in this "
+            f"artifact location or an existing model was not packaged with Feature Store metadata. "
+            f"Only models logged by FeatureStoreClient.log_model can be used in inference."
+        )
+
+    return repo.download_artifacts(artifact_path="", dst_path=dir)
+
+
+def validate_params_non_empty(params: Dict[str, Any], expected_params: List[str]):
+    """
+    Validate that none of the expected parameters are empty, otherwise raise a Value error
+    for the first encountered empty parameter.
+
+    Tested with the following param types:
+
+    - str
+    - Dict
+    - List
+
+    :param params: A dictionary of param names -> param values, for example as returned by locals()
+    :param expected_params: List of params to check as non_empty
+    """
+    for expected_param in expected_params:
+        if expected_param not in params:
+            raise ValueError(
+                f'Internal error: expected parameter "{expected_param}" not found in params dictionary'
+            )
+        param_value = params[expected_param]
+        if not param_value:
+            raise ValueError(f'Parameter "{expected_param}" cannot be empty')
+
+
+def is_in_databricks_job():
+    """
+    Overrides the behavior of the mlflow databricks_utils.is_in_databricks_job() to account for the fact that
+    some jobs have job_id but no run_id, for example one-time job runs.
+    """
+    try:
+        return databricks_utils.get_job_id() is not None
+    except Exception:
+        return False
+
+
+def get_workspace_url() -> Optional[str]:
+    """
+    Overrides the behavior of the mlflow.utils.databricks_utils.get_workspace_url(),
+    as get_workspace_url does not always return URLs with defined schemes.
+
+    TODO (ML-32050): Refactor this implementation to mlflow, and bump minimum required mlflow version.
+    """
+    workspace_url = databricks_utils.get_workspace_url()
+    if workspace_url and not urlparse(workspace_url).scheme:
+        workspace_url = "https://" + workspace_url
+    return workspace_url
+
+
+def is_in_databricks_env():
+    """
+    Determine if we are running in a Databricks environment (DBR, MLR, DLT, DCS, Mlflow Projects, Run Cmd 1.2 API, etc)
+
+    If any invoked methods raise an exception, swallow the exception and return False out of an abundance of caution.
+    """
+    try:
+        return (
+            is_in_databricks_job()
+            or databricks_utils.is_in_databricks_notebook()
+            or databricks_utils.is_in_databricks_runtime()
+        )
+    except Exception:
+        return False
+
+
+def sanitize_identifier(identifier: str):
+    """
+    Sanitize and wrap an identifier with backquotes. For example, "a`b" becomes "`a``b`".
+    Use this function to sanitize identifiers such as column names in SQL and PySpark.
+    """
+    return f"`{identifier.replace('`', '``')}`"
+
+
+def sanitize_identifiers(identifiers: List[str]):
+    """
+    Sanitize and wrap the identifiers in a list with backquotes.
+    """
+    return [sanitize_identifier(i) for i in identifiers]
+
+
+def sanitize_multi_level_name(multi_level_name: str):
+    """
+    Sanitize a multi-level name (such as an Unity Catalog table name) by sanitizing each segment
+    and joining the results. For example, "ca+t.fo`o.ba$r" becomes "`ca+t`.`fo``o`.`ba$r`".
+    """
+    segments = multi_level_name.split(".")
+    return ".".join(sanitize_identifiers(segments))
+
+
+def unsanitize_identifier(identifier: str):
+    """
+    Unsanitize an identifier. Useful when we get a possibly sanitized identifier from Spark or
+    somewhere else, but we need an unsanitized one.
+    Note: This function does not check the correctness of the identifier passed in. e.g. `foo``
+    is not a valid sanitized identifier. When given such invalid input, this function returns
+    invalid output.
+    """
+    if len(identifier) >= 2 and identifier[0] == "`" and identifier[-1] == "`":
+        return identifier[1:-1].replace("``", "`")
+    else:
+        return identifier
+
+
+# strings containing \ or ' can break sql statements, so escape them.
+def escape_sql_string(input_str: str) -> str:
+    return input_str.replace("\\", "\\\\").replace("'", "\\'")

feature_store/utils/validation_utils.py

@@ -0,0 +1,55 @@
+import logging
+from typing import List, Union
+
+from pyspark.sql import DataFrame
+
+_logger = logging.getLogger(__name__)
+
+
+def standardize_checkpoint_location(checkpoint_location):
+    if checkpoint_location is None:
+        return checkpoint_location
+    checkpoint_location = checkpoint_location.strip()
+    if checkpoint_location == "":
+        checkpoint_location = None
+    return checkpoint_location
+
+
+def _is_spark_connect_data_frame(df):
+    # We cannot directly pyspark.sql.connect.dataframe.DataFrame as it requires Spark 3.4, which
+    # is not installed on DBR 12.2 and earlier. Instead, we string match on the type.
+    return (
+        type(df).__name__ == "DataFrame"
+        and type(df).__module__ == "pyspark.sql.connect.dataframe"
+    )
+
+
+def check_dataframe_type(df):
+    """
+    Check if df is a PySpark DataFrame, otherwise raise an error.
+    """
+    if not (isinstance(df, DataFrame) or _is_spark_connect_data_frame(df)):
+        raise ValueError(
+            f"Unsupported DataFrame type: {type(df)}. DataFrame must be a PySpark DataFrame."
+        )
+
+
+def check_kwargs_empty(the_kwargs, method_name):
+    if len(the_kwargs) != 0:
+        raise TypeError(
+            f"{method_name}() got unexpected keyword argument(s): {list(the_kwargs.keys())}"
+        )
+
+
+def check_duplicate_keys(keys: Union[str, List[str]], key_name: str) -> None:
+    """
+    Check if there are duplicate keys. Raise an error if there is duplicates.
+    """
+    if keys and isinstance(keys, list):
+        seen = set()
+        for k in keys:
+            if k in seen:
+                raise ValueError(
+                    f"Found duplicated key '{k}' in {key_name}. {key_name} must be unique."
+                )
+            seen.add(k)

{wedata_feature_engineering-0.1.2.dist-info → wedata_feature_engineering-0.1.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: wedata-feature-engineering
-Version: 0.1.2
+Version: 0.1.4
 Summary: Wedata Feature Engineering Library
 Home-page: 
 Author: meahqian

{wedata_feature_engineering-0.1.2.dist-info → wedata_feature_engineering-0.1.4.dist-info}/RECORD

@@ -24,7 +24,18 @@ feature_store/spark_client/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJ
 feature_store/spark_client/spark_client.py,sha256=vd-NCE9IGC0Ygqr-QSVY0teuWsQSkq_BFV4Mn6xMMNU,11578
 feature_store/training_set_client/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 feature_store/training_set_client/training_set_client.py,sha256=Aa80xVXVE1KBdgplL9qqR8ftD5A5r2pfBttAhmySrB0,6696
-wedata_feature_engineering-0.1.2.dist-info/METADATA,sha256=IALf_mmflM-eRTOIOqVDJg5OoVVfLXBUHofIdC1T_wI,493
-wedata_feature_engineering-0.1.2.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-wedata_feature_engineering-0.1.2.dist-info/top_level.txt,sha256=15761LgVdJ7tJWbdlYk0EZ560G9k6C4TE42dfLx8d0I,14
-wedata_feature_engineering-0.1.2.dist-info/RECORD,,
+feature_store/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+feature_store/utils/common_utils.py,sha256=ck8pJYeN6vrcZmTrcnmIOOJWzYZaY3ZjvRSVme4tplo,3314
+feature_store/utils/feature_lookup_utils.py,sha256=iILSP4AFHXrjNTuId6mT7wtMFAsZejyxThr_mZHPRF4,22330
+feature_store/utils/feature_spec_utils.py,sha256=jeWzEhmkVW-bMRySMx_5grepHAlLquMhYxpbbiaJR-g,11582
+feature_store/utils/feature_utils.py,sha256=8KhlkWax3KAi_xRnStVPlhCxeUHO08VW2fmT9jN8QUs,2761
+feature_store/utils/schema_utils.py,sha256=8NhNUsF4Z6UtmzFeaVBnmb7xut0LqZepK3M27PSEpfE,4484
+feature_store/utils/topological_sort.py,sha256=ebzKxmxeCLk9seB1zR0ASCGXsZsa-DjxJeTc4KUadtg,6475
+feature_store/utils/training_set_utils.py,sha256=V5yW-XQ9in7gNOo4xsWy7txnSw_Z9Zxm4mV7MQmrWnk,22466
+feature_store/utils/uc_utils.py,sha256=ets7YlrAtkhW9kKyYajDNo6iZasBIhFyxUT2MOyLuV8,10767
+feature_store/utils/utils.py,sha256=T6dOUX3oOYRsbvXyTIElFZ20kNO92KMYPUCrqY5eomE,8953
+feature_store/utils/validation_utils.py,sha256=FslvrNs3kstqvM6THScLOluEE6O9RWlDrD9xiihTzlw,1735
+wedata_feature_engineering-0.1.4.dist-info/METADATA,sha256=uwmHZ4fVVcncF5YH_p3kUG24D377eKLraAcOlx-KU5o,493
+wedata_feature_engineering-0.1.4.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+wedata_feature_engineering-0.1.4.dist-info/top_level.txt,sha256=15761LgVdJ7tJWbdlYk0EZ560G9k6C4TE42dfLx8d0I,14
+wedata_feature_engineering-0.1.4.dist-info/RECORD,,