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

wedata/feature_store/training_set_client/training_set_client.py

@@ -0,0 +1,367 @@
+import logging
+import os
+from types import ModuleType
+from typing import Any, List, Optional, Set, Union
+
+import mlflow
+from mlflow.models import Model
+from mlflow.utils.file_utils import TempDir, read_yaml
+from pyspark.sql import DataFrame
+
+from wedata.feature_store.constants import constants
+from wedata.feature_store.entities.feature_function import FeatureFunction
+from wedata.feature_store.entities.feature_lookup import FeatureLookup
+from wedata.feature_store.entities.feature_spec import FeatureSpec
+from wedata.feature_store.entities.training_set import TrainingSet
+from wedata.feature_store.spark_client.spark_client import SparkClient
+
+from wedata.feature_store.constants.constants import (
+    _NO_RESULT_TYPE_PASSED,
+    _USE_SPARK_NATIVE_JOIN
+)
+
+from wedata.feature_store.utils import common_utils, training_set_utils, uc_utils
+from wedata.feature_store.utils.signature_utils import get_mlflow_signature_from_feature_spec, \
+    drop_signature_inputs_and_invalid_params
+
+_logger = logging.getLogger(__name__)
+
+FEATURE_SPEC_GRAPH_MAX_COLUMN_INFO = 1000
+
+
+class TrainingSetClient:
+    def __init__(
+        self,
+        spark_client: SparkClient
+    ):
+        self._spark_client = spark_client
+
+    def create_training_set(
+        self,
+        feature_spec: FeatureSpec,
+        label_names: List[str],
+        df: DataFrame,
+        ft_metadata: training_set_utils._FeatureTableMetadata,
+        kwargs,
+    ):
+        uc_function_infos = training_set_utils.get_uc_function_infos(
+            self._spark_client,
+            {odci.udf_name for odci in feature_spec.on_demand_column_infos},
+        )
+
+        training_set_utils.warn_if_non_photon_for_native_spark(
+            kwargs.get(_USE_SPARK_NATIVE_JOIN, False), self._spark_client
+        )
+        return TrainingSet(
+            feature_spec,
+            df,
+            label_names,
+            ft_metadata.feature_table_metadata_map,
+            ft_metadata.feature_table_data_map,
+            uc_function_infos,
+            kwargs.get(_USE_SPARK_NATIVE_JOIN, False),
+        )
+
+    def create_training_set_from_feature_lookups(
+        self,
+        df: DataFrame,
+        feature_lookups: List[Union[FeatureLookup, FeatureFunction]],
+        label: Union[str, List[str], None],
+        exclude_columns: List[str],
+        **kwargs,
+    ) -> TrainingSet:
+
+        # 获取特征查找列表和特征函数列表
+        features = feature_lookups
+        feature_lookups = [f for f in features if isinstance(f, FeatureLookup)]
+        feature_functions = [f for f in features if isinstance(f, FeatureFunction)]
+
+        # 最多支持100个FeatureFunctions
+        if len(feature_functions) > training_set_utils.MAX_FEATURE_FUNCTIONS:
+            raise ValueError(
+                f"A maximum of {training_set_utils.MAX_FEATURE_FUNCTIONS} FeatureFunctions are supported."
+            )
+
+        # 如果未提供标签，则用空列表初始化label_names
+        label_names = common_utils.as_list(label, [])
+        del label
+
+        # 校验数据集和标签
+        training_set_utils.verify_df_and_labels(df, label_names, exclude_columns)
+
+        # 获取特征表元数据
+        ft_metadata = training_set_utils.get_table_metadata(
+            self._spark_client,
+            {fl.table_name for fl in feature_lookups}
+        )
+
+        column_infos = training_set_utils.get_column_infos(
+            feature_lookups,
+            feature_functions,
+            ft_metadata,
+            df_columns=df.columns,
+            label_names=label_names,
+        )
+
+        training_set_utils.validate_column_infos(
+            self._spark_client,
+            ft_metadata,
+            column_infos.source_data_column_infos,
+            column_infos.feature_column_infos,
+            column_infos.on_demand_column_infos,
+            label_names,
+        )
+
+        # Build feature_spec locally for comparison with the feature spec yaml generated by the
+        # FeatureStore backend. This will be removed once the migration is validated.
+        feature_spec = training_set_utils.build_feature_spec(
+            feature_lookups,
+            ft_metadata,
+            column_infos,
+            exclude_columns
+        )
+
+        return self.create_training_set(
+            feature_spec,
+            label_names,
+            df,
+            ft_metadata,
+            kwargs=kwargs,
+        )
+
+
+    def create_feature_spec(
+        self,
+        name: str,
+        features: List[Union[FeatureLookup, FeatureFunction]],
+        sparkClient: SparkClient,
+        exclude_columns: List[str] = [],
+    ) -> FeatureSpec:
+
+        feature_lookups = [f for f in features if isinstance(f, FeatureLookup)]
+        feature_functions = [f for f in features if isinstance(f, FeatureFunction)]
+
+        # Maximum of 100 FeatureFunctions is supported
+        if len(feature_functions) > training_set_utils.MAX_FEATURE_FUNCTIONS:
+            raise ValueError(
+                f"A maximum of {training_set_utils.MAX_FEATURE_FUNCTIONS} FeatureFunctions are supported."
+            )
+
+        # Get feature table metadata and column infos
+        ft_metadata = training_set_utils.get_table_metadata(
+            self._spark_client,
+            {fl.table_name for fl in feature_lookups}
+        )
+        column_infos = training_set_utils.get_column_infos(
+            feature_lookups,
+            feature_functions,
+            ft_metadata,
+        )
+
+        column_infos = training_set_utils.add_inferred_source_columns(column_infos)
+
+        training_set_utils.validate_column_infos(
+            self._spark_client,
+            ft_metadata,
+            column_infos.source_data_column_infos,
+            column_infos.feature_column_infos,
+            column_infos.on_demand_column_infos,
+        )
+
+        feature_spec = training_set_utils.build_feature_spec(
+            feature_lookups,
+            ft_metadata,
+            column_infos,
+            exclude_columns
+        )
+
+        return feature_spec
+
+
+    def log_model(
+            self,
+            model: Any,
+            artifact_path: str,
+            *,
+            flavor: ModuleType,
+            training_set: Optional[TrainingSet],
+            registered_model_name: Optional[str],
+            await_registration_for: int,
+            infer_input_example: bool,
+            **kwargs,
+    ):
+        # Validate only one of the training_set, feature_spec_path arguments is provided.
+        # Retrieve the FeatureSpec, then remove training_set, feature_spec_path from local scope.
+        feature_spec_path = kwargs.pop("feature_spec_path", None)
+        if (training_set is None) == (feature_spec_path is None):
+            raise ValueError(
+                "Either 'training_set' or 'feature_spec_path' must be provided, but not both."
+            )
+        # Retrieve the FeatureSpec and then reformat tables in local metastore to 2L before serialization.
+        # This will make sure the format of the feature spec with local metastore tables is always consistent.
+        if training_set:
+            all_uc_tables = all(
+                [
+                    uc_utils.is_uc_entity(table_info.table_name)
+                    for table_info in training_set.feature_spec.table_infos
+                ]
+            )
+            # training_set.feature_spec is guaranteed to be 3L from FeatureStoreClient.create_training_set.
+            feature_spec = uc_utils.get_feature_spec_with_reformat_full_table_names(
+                training_set.feature_spec
+            )
+            label_type_map = training_set._label_data_types
+
+            labels = training_set._labels
+            df_head = training_set._df.drop(*labels).head()
+        else:
+            # FeatureSpec.load expects the root directory of feature_spec.yaml
+            root_dir, file_name = os.path.split(feature_spec_path)
+            if file_name != FeatureSpec.FEATURE_ARTIFACT_FILE:
+                raise ValueError(
+                    f"'feature_spec_path' must be a path to {FeatureSpec.FEATURE_ARTIFACT_FILE}."
+                )
+            feature_spec = FeatureSpec.load(root_dir)
+
+            # The loaded FeatureSpec is not guaranteed to be 3L.
+            # First call get_feature_spec_with_full_table_names to append the default metastore to 2L names,
+            # as get_feature_spec_with_reformat_full_table_names expects full 3L table names and throws otherwise.
+            # TODO (ML-26593): Consolidate this into a single function that allows either 2L/3L names.
+            feature_spec_with_full_table_names = (
+                uc_utils.get_feature_spec_with_full_table_names(feature_spec)
+            )
+            all_uc_tables = all(
+                [
+                    uc_utils.is_uc_entity(table_info.table_name)
+                    for table_info in feature_spec_with_full_table_names.table_infos
+                ]
+            )
+            feature_spec = uc_utils.get_feature_spec_with_reformat_full_table_names(
+                feature_spec_with_full_table_names
+            )
+            label_type_map = None
+            df_head = None
+        del training_set, feature_spec_path
+
+        override_output_schema = kwargs.pop("output_schema", None)
+        params = kwargs.pop("params", {})
+        params["result_type"] = params.get("result_type", _NO_RESULT_TYPE_PASSED)
+        # Signatures will ony be supported for UC-table-only models to
+        # mitigate new online scoring behavior from being a breaking regression for older
+        # models.
+        # See https://docs.google.com/document/d/1L5tLY-kRreRefDfuAM3crXvYlirkcPuUUppU8uIMVM0/edit#
+        try:
+            if all_uc_tables:
+                signature = get_mlflow_signature_from_feature_spec(
+                    feature_spec, label_type_map, override_output_schema, params
+                )
+            else:
+                _logger.warning(
+                    "Model could not be logged with a signature because the training set uses feature tables in "
+                    "Hive Metastore. Migrate the feature tables to Unity Catalog for model to be logged "
+                    "with a signature. "
+                    "See https://docs.databricks.com/en/machine-learning/feature-store/uc/upgrade-feature-table-to-uc.html for more details."
+                )
+                signature = None
+        except Exception as e:
+            _logger.warning(f"Model could not be logged with a signature: {e}")
+            signature = None
+
+        with TempDir() as tmp_location:
+            data_path = os.path.join(tmp_location.path(), "feature_store")
+            raw_mlflow_model = Model(
+                signature=drop_signature_inputs_and_invalid_params(signature)
+            )
+            raw_model_path = os.path.join(
+                data_path, constants.RAW_MODEL_FOLDER
+            )
+            if flavor.FLAVOR_NAME != mlflow.pyfunc.FLAVOR_NAME:
+                flavor.save_model(
+                    model, raw_model_path, mlflow_model=raw_mlflow_model, **kwargs
+                )
+            else:
+                flavor.save_model(
+                    raw_model_path,
+                    mlflow_model=raw_mlflow_model,
+                    python_model=model,
+                    **kwargs,
+                )
+            if not "python_function" in raw_mlflow_model.flavors:
+                raise ValueError(
+                    f"FeatureStoreClient.log_model does not support '{flavor.__name__}' "
+                    f"since it does not have a python_function model flavor."
+                )
+
+            # Re-use the conda environment from the raw model for the packaged model. Later, we may
+            # add an additional requirement for the Feature Store library. At the moment, however,
+            # the databricks-feature-store package is not available via conda or pip.
+            model_env = raw_mlflow_model.flavors["python_function"][mlflow.pyfunc.ENV]
+            if isinstance(model_env, dict):
+                # mlflow 2.0 has multiple supported environments
+                conda_file = model_env[mlflow.pyfunc.EnvType.CONDA]
+            else:
+                conda_file = model_env
+
+            conda_env = read_yaml(raw_model_path, conda_file)
+
+            # Check if databricks-feature-lookup version is specified in conda_env
+            lookup_client_version_specified = False
+            for dependency in conda_env.get("dependencies", []):
+                if isinstance(dependency, dict):
+                    for pip_dep in dependency.get("pip", []):
+                        if pip_dep.startswith(
+                                constants.FEATURE_LOOKUP_CLIENT_PIP_PACKAGE
+                        ):
+                            lookup_client_version_specified = True
+                            break
+
+            # If databricks-feature-lookup version is not specified, add default version
+            if not lookup_client_version_specified:
+                # Get the pip package string for the databricks-feature-lookup client
+                default_databricks_feature_lookup_pip_package = common_utils.pip_depependency_pinned_major_version(
+                    pip_package_name=constants.FEATURE_LOOKUP_CLIENT_PIP_PACKAGE,
+                    major_version=constants.FEATURE_LOOKUP_CLIENT_MAJOR_VERSION,
+                )
+                common_utils.add_mlflow_pip_depependency(
+                    conda_env, default_databricks_feature_lookup_pip_package
+                )
+
+            try:
+                if df_head is not None and infer_input_example:
+                    input_example = df_head.asDict()
+                else:
+                    input_example = None
+            except Exception:
+                input_example = None
+
+            # todo:
+            #feature_spec.save(data_path)
+
+            # Log the packaged model. If no run is active, this call will create an active run.
+            mlflow.pyfunc.log_model(
+                artifact_path=artifact_path,
+                loader_module=constants.MLFLOW_MODEL_NAME,
+                data_path=data_path,
+                code_path=None,
+                conda_env=conda_env,
+                signature=signature,
+                input_example=input_example,
+            )
+        if registered_model_name is not None:
+            # The call to mlflow.pyfunc.log_model will create an active run, so it is safe to
+            # obtain the run_id for the active run.
+            run_id = mlflow.tracking.fluent.active_run().info.run_id
+
+            # If the user provided an explicit model_registry_uri when constructing the FeatureStoreClient,
+            # we respect this by setting the registry URI prior to reading the model from Model
+            # Registry.
+            # todo:
+            # if self._model_registry_uri:
+            #     # This command will override any previously set registry_uri.
+            #     mlflow.set_registry_uri(self._model_registry_uri)
+
+            mlflow.register_model(
+                "runs:/%s/%s" % (run_id, artifact_path),
+                registered_model_name,
+                await_registration_for=await_registration_for,
+                )

feature_store/utils/utils.py → wedata/feature_store/utils/common_utils.py

@@ -1,4 +1,8 @@
+"""
+通用工具函数
+"""
 import os
+from collections import Counter
 from datetime import datetime, timezone
 from functools import wraps
 from typing import Any, Dict, List, Optional
@@ -7,8 +11,54 @@ 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.store.artifact.models_artifact_repo import ModelsArtifactRepository
+from mlflow.store.artifact.runs_artifact_repo import RunsArtifactRepository
 from mlflow.utils import databricks_utils
 
+from wedata.feature_store.constants.constants import MODEL_DATA_PATH_ROOT
+
+
+def validate_table_name(name: str):
+    """
+    验证特征表名规范，仅支持单表名，不能包含点（如<catalog>.<schema>.<table>）
+
+    参数:
+        name: 要验证的表名
+
+    异常:
+        ValueError: 如果表名包含点或不符合规范
+    """
+    if not name or not isinstance(name, str):
+        raise ValueError("Table name must be a non-empty string")
+    if name.count('.') > 0:
+        raise ValueError("Feature table name only supports single table name, cannot contain dots (e.g. <catalog>.<schema>.<table>)")
+    if not name[0].isalpha():
+        raise ValueError("Table name must start with a letter")
+    if not all(c.isalnum() or c == '_' for c in name):
+        raise ValueError("Table name can only contain letters, numbers and underscores")
+
+
+def build_full_table_name(table_name: str) -> str:
+    """
+    构建完整的表名，格式化为`<database>.<table>`形式。
+
+    Args:
+        table_name: 输入的表名（可以是简化的表名或完整表名）。
+
+    Returns:
+        完整表名（`<database>.<table>`）。
+    """
+
+    # 从环境变量中获取当前主账户名称
+    owner_uin = os.environ.get("WEDATA_OWNER_UIN", "default")
+
+    # 如果owner_uin为空，则报错
+    if not owner_uin:
+        raise ValueError("WEDATA_OWNER_UIN environment variable is not set")
+
+    feature_store_database = f"{owner_uin}.{table_name}"
+
+    return feature_store_database
 
 
 def enable_if(condition):
@@ -31,21 +81,6 @@ def enable_if(condition):
     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
 
@@ -68,10 +103,7 @@ def _get_dbutils():
         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()
@@ -86,12 +118,7 @@ def pip_depependency_pinned_major_version(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.
+    Add a new pip dependency to the conda environment taken from the raw MLflow model.
     """
     if pip_package_name is None or len(pip_package_name) == 0:
         raise ValueError(
@@ -106,7 +133,6 @@ def add_mlflow_pip_depependency(conda_env, pip_package_name):
                 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"
@@ -115,12 +141,7 @@ def add_mlflow_pip_depependency(conda_env, pip_package_name):
 
 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.
+    Downloads model artifacts from model_uri to dir.
     """
     if not is_artifact_uri(model_uri):
         raise ValueError(
@@ -147,17 +168,7 @@ def download_model_artifacts(model_uri, 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
+    Validate that none of the expected parameters are empty.
     """
     for expected_param in expected_params:
         if expected_param not in params:
@@ -171,8 +182,7 @@ def validate_params_non_empty(params: Dict[str, Any], expected_params: List[str]
 
 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.
+    Overrides the behavior of the mlflow databricks_utils.is_in_databricks_job().
     """
     try:
         return databricks_utils.get_job_id() is not None
@@ -182,10 +192,7 @@ def is_in_databricks_job():
 
 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.
+    Overrides the behavior of the mlflow.utils.databricks_utils.get_workspace_url().
     """
     workspace_url = databricks_utils.get_workspace_url()
     if workspace_url and not urlparse(workspace_url).scheme:
@@ -195,20 +202,60 @@ def get_workspace_url() -> Optional[str]:
 
 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.
+    Determine if we are running in a Databricks environment.
     """
     try:
         return (
-            is_in_databricks_job()
-            or databricks_utils.is_in_databricks_notebook()
-            or databricks_utils.is_in_databricks_runtime()
+                is_in_databricks_job()
+                or databricks_utils.is_in_databricks_notebook()
+                or databricks_utils.is_in_databricks_runtime()
         )
     except Exception:
         return False
 
 
+def is_artifact_uri(uri):
+    """
+    Checks the artifact URI is associated with a MLflow model or run.
+    The actual URI can be a model URI, model URI + subdirectory, or model URI + path to artifact file.
+    """
+    return ModelsArtifactRepository.is_models_uri(
+        uri
+    ) or RunsArtifactRepository.is_runs_uri(uri)
+
+
+def as_list(obj, default=None):
+    if not obj:
+        return default
+    elif isinstance(obj, list):
+        return obj
+    else:
+        return [obj]
+
+
+def get_duplicates(elements: List[Any]) -> List[Any]:
+    """
+    Returns duplicate elements in the order they first appear.
+    """
+    element_counts = Counter(elements)
+    duplicates = []
+    for e in element_counts.keys():
+        if element_counts[e] > 1:
+            duplicates.append(e)
+    return duplicates
+
+
+def validate_strings_unique(strings: List[str], error_template: str):
+    """
+    Validates all strings are unique, otherwise raise ValueError with the error template and duplicates.
+    Passes single-quoted, comma delimited duplicates to the error template.
+    """
+    duplicate_strings = get_duplicates(strings)
+    if duplicate_strings:
+        duplicates_formatted = ", ".join([f"'{s}'" for s in duplicate_strings])
+        raise ValueError(error_template.format(duplicates_formatted))
+
+
 def sanitize_identifier(identifier: str):
     """
     Sanitize and wrap an identifier with backquotes. For example, "a`b" becomes "`a``b`".
@@ -250,3 +297,10 @@ def unsanitize_identifier(identifier: str):
 # strings containing \ or ' can break sql statements, so escape them.
 def escape_sql_string(input_str: str) -> str:
     return input_str.replace("\\", "\\\\").replace("'", "\\'")
+
+
+def get_unique_list_order(elements: List[Any]) -> List[Any]:
+    """
+    Returns unique elements in the order they first appear.
+    """
+    return list(dict.fromkeys(elements))

{feature_store → wedata/feature_store}/utils/feature_lookup_utils.py

@@ -10,13 +10,13 @@ from pyspark.sql import DataFrame, Window
 from pyspark.sql import functions as F
 from pyspark.sql.functions import sum, unix_timestamp
 
-from feature_store.entities.environment_variables import BROADCAST_JOIN_THRESHOLD
-from feature_store.entities.feature_column_info import FeatureColumnInfo
-from feature_store.entities.feature_lookup import FeatureLookup
-from feature_store.entities.feature_spec import FeatureSpec
-from feature_store.entities.feature_table import FeatureTable
+from wedata.feature_store.entities.environment_variables import BROADCAST_JOIN_THRESHOLD
+from wedata.feature_store.entities.feature_column_info import FeatureColumnInfo
+from wedata.feature_store.entities.feature_lookup import FeatureLookup
+from wedata.feature_store.entities.feature_spec import FeatureSpec
+from wedata.feature_store.entities.feature_table import FeatureTable
 
-from feature_store.utils import common_utils, validation_utils, uc_utils
+from wedata.feature_store.utils import common_utils, validation_utils, uc_utils
 
 _logger = logging.getLogger(__name__)
 

{feature_store → wedata/feature_store}/utils/feature_spec_utils.py

@@ -6,12 +6,12 @@ from typing import Dict, List, Set, Tuple, Type, Union
 import yaml
 from mlflow.utils.file_utils import YamlSafeDumper
 
-from feature_store.entities.column_info import ColumnInfo
-from feature_store.entities.feature_column_info import FeatureColumnInfo
-from feature_store.entities.feature_spec import FeatureSpec
-from feature_store.entities.on_demand_column_info import OnDemandColumnInfo
-from feature_store.entities.source_data_column_info import SourceDataColumnInfo
-from feature_store.utils.topological_sort import topological_sort
+from wedata.feature_store.entities.column_info import ColumnInfo
+from wedata.feature_store.entities.feature_column_info import FeatureColumnInfo
+from wedata.feature_store.entities.feature_spec import FeatureSpec
+from wedata.feature_store.entities.on_demand_column_info import OnDemandColumnInfo
+from wedata.feature_store.entities.source_data_column_info import SourceDataColumnInfo
+from wedata.feature_store.utils.topological_sort import topological_sort
 
 DEFAULT_GRAPH_DEPTH_LIMIT = 5
 

{feature_store → wedata/feature_store}/utils/feature_utils.py

@@ -1,11 +1,11 @@
 import copy
 from typing import List, Union
 
-from feature_store.entities.feature_function import FeatureFunction
-from feature_store.entities.feature_lookup import FeatureLookup
-from feature_store.spark_client.spark_client import SparkClient
-from feature_store.utils import uc_utils
-from feature_store.utils.feature_lookup_utils import get_feature_lookups_with_full_table_names
+from wedata.feature_store.entities.feature_function import FeatureFunction
+from wedata.feature_store.entities.feature_lookup import FeatureLookup
+from wedata.feature_store.spark_client.spark_client import SparkClient
+from wedata.feature_store.utils import uc_utils
+from wedata.feature_store.utils.feature_lookup_utils import get_feature_lookups_with_full_table_names
 
 
 def format_feature_lookups_and_functions(