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

wedata/feature_store/utils/on_demand_utils.py

@@ -0,0 +1,107 @@
+import copy
+from typing import Dict, List
+
+from pyspark.sql import DataFrame
+from pyspark.sql.functions import expr
+
+from wedata.feature_store.entities.feature_function import FeatureFunction
+from wedata.feature_store.entities.function_info import FunctionInfo
+from wedata.feature_store.entities.on_demand_column_info import OnDemandColumnInfo
+from wedata.feature_store.utils import common_utils, uc_utils
+
+
+def _udf_expr(udf_name: str, arguments: List[str]) -> expr:
+    """
+    Generate a Spark SQL expression, e.g. expr("udf_name(col1, col2)")
+    """
+    arguments_str = ", ".join(common_utils.sanitize_identifiers(arguments))
+    return expr(f"{udf_name}({arguments_str})")
+
+
+def _validate_apply_functions_df(
+    df: DataFrame,
+    functions_to_apply: List[OnDemandColumnInfo],
+    uc_function_infos: Dict[str, FunctionInfo],
+):
+    """
+    Validate the following:
+    1. On-demand input columns specified by functions_to_apply exist in the DataFrame.
+    2. On-demand input columns have data types that match those of UDF parameters.
+    """
+    for odci in functions_to_apply:
+        function_info = uc_function_infos[odci.udf_name]
+        types_dict = dict(df.dtypes)
+
+        for p in function_info.input_params:
+            arg_column = odci.input_bindings[p.name]
+            if arg_column not in df.columns:
+                raise ValueError(
+                    f"FeatureFunction argument column '{arg_column}' for UDF '{odci.udf_name}' parameter '{p.name}' "
+                    f"does not exist in provided DataFrame with schema '{df.schema}'."
+                )
+            if types_dict[arg_column] != p.type_text:
+                raise ValueError(
+                    f"FeatureFunction argument column '{arg_column}' for UDF '{odci.udf_name}' parameter '{p.name}' "
+                    f"does not have the expected type. Argument column '{arg_column}' has type "
+                    f"'{types_dict[arg_column]}' and parameter '{p.name}' has type '{p.type_text}'."
+                )
+
+
+def apply_functions_if_not_overridden(
+    df: DataFrame,
+    functions_to_apply: List[OnDemandColumnInfo],
+    uc_function_infos: Dict[str, FunctionInfo],
+) -> DataFrame:
+    """
+    For all on-demand features, in the order defined by the FeatureSpec:
+    If the feature does not already exist, append the evaluated UDF expression.
+    Existing column values or column positions are not modified.
+
+    `_validate_apply_functions_df` validates UDFs can be applied on `df` schema.
+
+    The caller should validate:
+    1. FeatureFunction bound argument columns for UDF parameters exist in FeatureSpec defined features.
+    2. FeatureFunction output feature names are unique.
+    """
+    _validate_apply_functions_df(
+        df=df,
+        functions_to_apply=functions_to_apply,
+        uc_function_infos=uc_function_infos,
+    )
+
+    columns = {}
+    for odci in functions_to_apply:
+        if odci.output_name not in df.columns:
+            function_info = uc_function_infos[odci.udf_name]
+            # Resolve the bound arguments in the UDF parameter order
+            udf_arguments = [
+                odci.input_bindings[p.name] for p in function_info.input_params
+            ]
+            columns[odci.output_name] = _udf_expr(odci.udf_name, udf_arguments)
+    return df.withColumns(columns)
+
+
+def get_feature_functions_with_full_udf_names(
+    feature_functions: List[FeatureFunction], current_catalog: str, current_schema: str
+):
+    """
+    Takes in a list of FeatureFunctions, and returns copies with:
+    1. Fully qualified UDF names.
+    2. If output_name is empty, fully qualified UDF names as output_name.
+    """
+    udf_names = {ff.udf_name for ff in feature_functions}
+    uc_utils._check_qualified_udf_names(udf_names)
+    uc_utils._verify_all_udfs_in_uc(udf_names, current_catalog, current_schema)
+
+    standardized_feature_functions = []
+    for ff in feature_functions:
+        ff_copy = copy.deepcopy(ff)
+        del ff
+
+        ff_copy._udf_name = uc_utils.get_full_udf_name(
+            ff_copy.udf_name, current_catalog, current_schema
+        )
+        if not ff_copy.output_name:
+            ff_copy._output_name = ff_copy.udf_name
+        standardized_feature_functions.append(ff_copy)
+    return standardized_feature_functions

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

@@ -1,6 +1,6 @@
 import logging
 
-from feature_store.constants.constants import _ERROR, _WARN
+from wedata.feature_store.constants.constants import _ERROR, _WARN
 
 _logger = logging.getLogger(__name__)
 

wedata/feature_store/utils/signature_utils.py

@@ -0,0 +1,205 @@
+import logging
+from typing import Any, Dict, Optional
+
+import mlflow
+from mlflow.models import ModelSignature
+from mlflow.types import ColSpec
+from mlflow.types import DataType as MlflowDataType
+from mlflow.types import ParamSchema, Schema
+
+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
+
+_logger = logging.getLogger(__name__)
+
+# Some types (array, map, decimal, timestamp_ntz) are unsupported due to MLflow signatures
+# lacking any equivalent types. We thus cannot construct a ColSpec for any column
+# that uses these types.
+SUPPORTED_TYPE_MAP = {
+    "smallint": MlflowDataType.integer,  # Upcast to integer
+    "int": MlflowDataType.integer,
+    "bigint": MlflowDataType.long,
+    "float": MlflowDataType.float,
+    "double": MlflowDataType.double,
+    "boolean": MlflowDataType.boolean,
+    "date": MlflowDataType.datetime,
+    "timestamp": MlflowDataType.datetime,
+    "string": MlflowDataType.string,
+    "binary": MlflowDataType.binary,
+}
+
+
+def is_unsupported_type(type_str: str):
+    return type_str not in SUPPORTED_TYPE_MAP
+
+
+def convert_spark_data_type_to_mlflow_signature_type(spark_type):
+    """
+    Maps Databricks SQL types to MLflow signature types.
+    docs.databricks.com/sql/language-manual/sql-ref-datatypes.html#language-mappings
+    """
+    return SUPPORTED_TYPE_MAP.get(spark_type)
+
+
+def get_input_schema_from_feature_spec(feature_spec: FeatureSpec) -> Schema:
+    """
+    Produces an MLflow signature schema from a feature spec.
+    Source data columns are marked as required inputs and feature columns
+    (both lookups and on-demand features) are marked as optional inputs.
+
+    :param feature_spec: FeatureSpec object with datatypes for each column.
+    """
+    # If we're missing any data types for any column, we are likely dealing with a
+    # malformed feature spec and should halt signature construction.
+    if any([ci.data_type is None for ci in feature_spec.column_infos]):
+        raise Exception("Training set does not contain column data types.")
+
+    source_data_cols = [
+        ci
+        for ci in feature_spec.column_infos
+        if isinstance(ci.info, SourceDataColumnInfo)
+    ]
+    # Don't create signature if any source data columns (required) are of complex types.
+    if any(
+        [
+            ci.data_type is None or is_unsupported_type(ci.data_type)
+            for ci in source_data_cols
+        ]
+    ):
+        raise Exception(
+            "Input DataFrame contains column data types not supported by "
+            "MLflow model signatures."
+        )
+    required_input_colspecs = [
+        ColSpec(
+            convert_spark_data_type_to_mlflow_signature_type(ci.data_type),
+            ci.info.output_name,
+            required=True,
+        )
+        for ci in source_data_cols
+    ]
+    feature_cols = [
+        ci
+        for ci in feature_spec.column_infos
+        if isinstance(ci.info, (FeatureColumnInfo, OnDemandColumnInfo))
+    ]
+    unsupported_feature_cols = [
+        ci for ci in feature_cols if is_unsupported_type(ci.data_type)
+    ]
+    optional_input_colspecs = [
+        ColSpec(
+            convert_spark_data_type_to_mlflow_signature_type(ci.data_type),
+            ci.output_name,
+            required=False,
+        )
+        for ci in feature_cols
+        if not is_unsupported_type(ci.data_type)
+    ]
+    if unsupported_feature_cols:
+        feat_string = ", ".join(
+            [f"{ci.output_name} ({ci.data_type})" for ci in unsupported_feature_cols]
+        )
+        _logger.warning(
+            f"The following features will not be included in the input schema because their"
+            f" data types are not supported by MLflow model signatures: {feat_string}. "
+            f"These features cannot be overridden during model serving."
+        )
+    return Schema(required_input_colspecs + optional_input_colspecs)
+
+
+def get_output_schema_from_labels(label_type_map: Optional[Dict[str, str]]) -> Schema:
+    """
+    Produces an MLflow signature schema from the provided label type map.
+    :param label_type_map: Map label column name -> data type
+    """
+    if not label_type_map:
+        raise Exception("Training set does not contain a label.")
+    if any([is_unsupported_type(dtype) for dtype in label_type_map.values()]):
+        raise Exception(
+            "Labels are of data types not supported by MLflow model signatures."
+        )
+    else:
+        output_colspecs = [
+            ColSpec(
+                convert_spark_data_type_to_mlflow_signature_type(spark_type),
+                col_name,
+                required=True,
+            )
+            for col_name, spark_type in label_type_map.items()
+        ]
+        return Schema(output_colspecs)
+
+
+def get_mlflow_signature_from_feature_spec(
+    feature_spec: FeatureSpec,
+    label_type_map: Optional[Dict[str, str]],
+    override_output_schema: Optional[Schema],
+    params: Optional[Dict[str, Any]] = None,
+) -> Optional[ModelSignature]:
+    """
+    Produce an MLflow signature from a feature spec and label type map.
+    Source data columns are marked as required inputs and feature columns
+    (both lookups and on-demand features) are marked as optional inputs.
+
+    Reads output types from the cached label -> datatype map in the training set.
+    If override_output_schema is provided, it will always be used as the output schema.
+
+    :param feature_spec: FeatureSpec object with datatypes for each column.
+    :param label_type_map: Map of label column name -> datatype
+    :param override_output_schema: User-provided output schema to use if provided.
+    """
+    kwargs = {}
+    kwargs["inputs"] = get_input_schema_from_feature_spec(feature_spec)
+    try:
+        output_schema = override_output_schema or get_output_schema_from_labels(
+            label_type_map
+        )
+        kwargs["outputs"] = output_schema
+    except Exception as e:
+        _logger.warning(f"Could not infer an output schema: {e}")
+
+    if params:
+        try:
+            from mlflow.types.utils import _infer_param_schema
+
+            kwargs["params"] = _infer_param_schema(params)
+        except Exception as e:
+            _logger.warning(f"Could not infer params schema: {e}")
+
+    return mlflow.models.ModelSignature(**kwargs)
+
+
+def drop_signature_inputs_and_invalid_params(signature):
+    """
+    Drop ModelSignature inputs field and invalid params from params field.
+    This is useful for feature store model's raw_model.
+    Feature store model's input schema does not apply to raw_model's input,
+    so we drop the inputs field of raw_model's signature.
+    Feature store model's result_type param enables setting and overriding
+    a default result_type for predictions, but this interferes with params
+    passed to MLflow's predict function, so we drop result_type from
+    the params field of raw_model's signature.
+
+    :param signature: ModelSignature object.
+    """
+    if signature:
+        outputs_schema = signature.outputs
+        params_schema = signature.params if hasattr(signature, "params") else None
+        try:
+            # Only for mlflow>=2.6.0 ModelSignature contains params attribute
+            if params_schema:
+                updated_params_schema = ParamSchema(
+                    [param for param in params_schema if param.name != "result_type"]
+                )
+                return ModelSignature(
+                    outputs=outputs_schema, params=updated_params_schema
+                )
+            if outputs_schema:
+                return ModelSignature(outputs=outputs_schema)
+        except TypeError:
+            _logger.warning(
+                "ModelSignature without inputs is not supported, please upgrade "
+                "mlflow >= 2.7.0 to use the feature."
+            )

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

@@ -4,21 +4,19 @@ from typing import Dict, List, Optional, Set
 
 from pyspark.sql import DataFrame
 
-from feature_store.entities.column_info import ColumnInfo
-from feature_store.entities.feature import Feature
-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 feature_store.entities.feature_table_info import FeatureTableInfo
-from feature_store.entities.function_info import FunctionInfo
-from feature_store.entities.on_demand_column_info import OnDemandColumnInfo
-from feature_store.entities.source_data_column_info import SourceDataColumnInfo
-
-from feature_store.constants.constants import _ERROR, _WARN
-
-from feature_store.utils import common_utils, validation_utils, uc_utils, schema_utils, utils
-from feature_store.utils.feature_spec_utils import assign_topological_ordering
+from wedata.feature_store.entities.column_info import ColumnInfo
+from wedata.feature_store.entities.feature import Feature
+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 wedata.feature_store.entities.feature_table_info import FeatureTableInfo
+from wedata.feature_store.entities.function_info import FunctionInfo
+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 import common_utils, validation_utils, uc_utils, schema_utils
+from wedata.feature_store.utils.feature_spec_utils import assign_topological_ordering
 
 _logger = logging.getLogger(__name__)
 
@@ -99,9 +97,9 @@ def _explode_feature_lookup(
         FeatureColumnInfo(
             table_name=feature_lookup.table_name,
             feature_name=feature_name,
-            lookup_key=utils.as_list(feature_lookup.lookup_key),
+            lookup_key=common_utils.as_list(feature_lookup.lookup_key),
             output_name=(feature_lookup._get_output_name(feature_name)),
-            timestamp_lookup_key=utils.as_list(
+            timestamp_lookup_key=common_utils.as_list(
                 feature_lookup.timestamp_lookup_key, default=[]
             ),
         )
@@ -280,13 +278,14 @@ def get_table_metadata(
     feature_table_metadata_map = get_feature_table_metadata_for_tables(
         spark_client, table_names=table_names
     )
+
     feature_table_data_map = load_feature_data_for_tables(
         spark_client, table_names=table_names
     )
     return _FeatureTableMetadata(
         feature_table_features_map,
         feature_table_metadata_map,
-        feature_table_data_map,
+        feature_table_data_map
     )
 
 
@@ -515,7 +514,7 @@ def build_feature_spec(
         for table_name in consumed_table_names
     ]
     function_infos = [
-        FunctionInfo(udf_name=udf_name) for udf_name in consumed_udf_names
+        FunctionInfo(full_name=udf_name) for udf_name in consumed_udf_names
     ]
 
     # Build FeatureSpec

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

@@ -2,7 +2,7 @@ import copy
 import re
 from typing import Optional, Set
 
-from feature_store.entities.feature_spec import FeatureSpec
+from wedata.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]+)$"

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

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

wedata_feature_engineering-0.1.6.dist-info/RECORD

@@ -0,0 +1,43 @@
+wedata/__init__.py,sha256=26GwucASB9KsmU109sN-VKotEKp1WZYQDGP0wgWZrzY,101
+wedata/feature_store/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+wedata/feature_store/client.py,sha256=7a-9C8HIBHnQNQD6I4W3UtBQwkJE8G-Q7N24zydjpkY,8100
+wedata/feature_store/constants/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+wedata/feature_store/constants/constants.py,sha256=b4tgcSt66YIq0Fg7pMbqvbqPOI77Cz8znLVZ4ihUKss,1479
+wedata/feature_store/entities/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+wedata/feature_store/entities/column_info.py,sha256=sU_WD9U0qse0M2speowLY30qSE6j4_57PuvtdPkwiFY,4192
+wedata/feature_store/entities/data_type.py,sha256=VpHS6Fr3TphQQ8NbAcEnDJ-8eOZV6ivYuWxv3pAM2RM,3394
+wedata/feature_store/entities/environment_variables.py,sha256=ZEFml5H9MQuzBKM074mUrFYu-Sga4Knmxqiwpke2WGc,1679
+wedata/feature_store/entities/feature.py,sha256=wX8fTBlJq3GYdj9rrBDCY3kFgcVBBAiOOZdxEhnQkNQ,1241
+wedata/feature_store/entities/feature_column_info.py,sha256=-TGxRafYUaNKe0YzHus2XbfRaVrMv7pcffMdbtTT4nA,2031
+wedata/feature_store/entities/feature_function.py,sha256=R17INrCE-U_Uj9KLbFz69aYlOkTETTwQHMMo470F4lQ,1865
+wedata/feature_store/entities/feature_lookup.py,sha256=YjYz8kLq42doFbgPzpmm1r3GPhPYkLsIss4H71x-KAo,8009
+wedata/feature_store/entities/feature_spec.py,sha256=60RUOOe9y_Xsd1I3xqq4NZYnaox4_jjwSyGRTKXLiIw,20041
+wedata/feature_store/entities/feature_spec_constants.py,sha256=YWDBfRiNDe6fUJFUBo3V4WYg2xsljoPAE-ZejfFZCgM,785
+wedata/feature_store/entities/feature_table.py,sha256=dHZHSDPD4HJ2XanLVIrVTkaCYUeqZ6eWEpA0d3YO71g,4010
+wedata/feature_store/entities/feature_table_info.py,sha256=2vUaVdW_jw1dRAlmJWvBRueuMeuqWu_NYB9SlxLI7Uw,1126
+wedata/feature_store/entities/function_info.py,sha256=l0kmiq2R_QNfSMJ7y0xZohlMiemgYSr1dN5vzV8ijIs,7314
+wedata/feature_store/entities/on_demand_column_info.py,sha256=Eh5ieaj1TxC7DG6ipBZzH2ZyY0bwkLrDOkuZjgYr4gY,1297
+wedata/feature_store/entities/source_data_column_info.py,sha256=a9jQOJvehwDIrKPwsP6W9YRBSPNK2nZYypE6-p80CwA,542
+wedata/feature_store/entities/training_set.py,sha256=ylt1h6Z_xU8hKYvnvd80CeewTGSN68-_kvFpoliwH7s,5679
+wedata/feature_store/feature_table_client/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+wedata/feature_store/feature_table_client/feature_table_client.py,sha256=nrnY3FLQnMhW1BzByDjjfU89hirgaKlg2l2tAfcjvyM,12138
+wedata/feature_store/spark_client/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+wedata/feature_store/spark_client/spark_client.py,sha256=DBCYjLsFrIVRvLErTNyfLIHRul3v0y9uZIY2JR1N92s,10323
+wedata/feature_store/training_set_client/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+wedata/feature_store/training_set_client/training_set_client.py,sha256=gHeZU0rvvUcyNTfroXD3LAinFPdhDpnwTOIWj6z84Tc,15102
+wedata/feature_store/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+wedata/feature_store/utils/common_utils.py,sha256=rmGXfBoEyDMlfqd7lxpEmKJaLoQ-d-ufWpAcE8nSHqA,10009
+wedata/feature_store/utils/feature_lookup_utils.py,sha256=da6ULwf5D-FRVpZoNyag1rroBfq_XPSH4a3uEMB_8io,22372
+wedata/feature_store/utils/feature_spec_utils.py,sha256=GFwc-WT6nN1tnal5F2c0bgVDRhH-YW58S0GaHBPZEsQ,11624
+wedata/feature_store/utils/feature_utils.py,sha256=KKq28bVB_lCuhnR9Hk6JegJBOVgcelWlvrRM-F9onkA,2796
+wedata/feature_store/utils/on_demand_utils.py,sha256=pazZRG5c0Se08MV_inBddIeX4Q9xlVN_H9SC_WK3xzs,4260
+wedata/feature_store/utils/schema_utils.py,sha256=y6EYY1pUxjVg6MP4C7avdW8ZEBBaDo1YTV2CmPF4i8o,4491
+wedata/feature_store/utils/signature_utils.py,sha256=_4_mo1Qlzklp-JrISMS3Jv89MPbaH6rz_cRDvJqFNXM,7957
+wedata/feature_store/utils/topological_sort.py,sha256=ebzKxmxeCLk9seB1zR0ASCGXsZsa-DjxJeTc4KUadtg,6475
+wedata/feature_store/utils/training_set_utils.py,sha256=MYsPZS1d9HKswHgjgxD8K7H9N3dWPyyTTx20Mkp4PVU,22497
+wedata/feature_store/utils/uc_utils.py,sha256=A-W8Cd8yvTmAMEWaHeWmGmcIDMvUtjAfx2G2x_di1QE,10774
+wedata/feature_store/utils/validation_utils.py,sha256=FslvrNs3kstqvM6THScLOluEE6O9RWlDrD9xiihTzlw,1735
+wedata_feature_engineering-0.1.6.dist-info/METADATA,sha256=orxNq_A9F8FcSWYn6wTY1pQ2KtqNVIREvGziUnNa1ys,493
+wedata_feature_engineering-0.1.6.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+wedata_feature_engineering-0.1.6.dist-info/top_level.txt,sha256=Xa0v1rh__RvfVTVDirW5r5UBKg7ZO_iuTeXfp8MNo2A,7
+wedata_feature_engineering-0.1.6.dist-info/RECORD,,

wedata_feature_engineering-0.1.6.dist-info/top_level.txt

@@ -0,0 +1 @@
+wedata

feature_store/entities/feature_table.py

@@ -1,164 +0,0 @@
-from typing import Dict
-
-
-
-class FeatureTable:
-    """
-    .. note::
-
-       Aliases:`!databricks.feature_engineering.entities.feature_table.FeatureTable`, `!databricks.feature_store.entities.feature_table.FeatureTable`
-
-    Value class describing one feature table.
-
-    This will typically not be instantiated directly, instead the
-    :meth:`create_table() <databricks.feature_engineering.client.FeatureEngineeringClient.create_table>`
-    will create :class:`.FeatureTable` objects.
-    """
-
-    def __init__(
-        self,
-        name,
-        table_id,
-        description,
-        primary_keys,
-        partition_columns,
-        features,
-        creation_timestamp=None,
-        online_stores=None,
-        notebook_producers=None,
-        job_producers=None,
-        table_data_sources=None,
-        path_data_sources=None,
-        custom_data_sources=None,
-        timestamp_keys=None,
-        tags=None,
-    ):
-        """Initialize a FeatureTable object."""
-        self.name = name
-        self.table_id = table_id
-        self.description = description
-        self.primary_keys = primary_keys
-        self.partition_columns = partition_columns
-        self.features = features
-        self.creation_timestamp = creation_timestamp
-        self.online_stores = online_stores if online_stores is not None else []
-        self.notebook_producers = (
-            notebook_producers if notebook_producers is not None else []
-        )
-        self.job_producers = job_producers if job_producers is not None else []
-        self.table_data_sources = (
-            table_data_sources if table_data_sources is not None else []
-        )
-        self.path_data_sources = (
-            path_data_sources if path_data_sources is not None else []
-        )
-        self.custom_data_sources = (
-            custom_data_sources if custom_data_sources is not None else []
-        )
-        self.timestamp_keys = timestamp_keys if timestamp_keys is not None else []
-        self._tags = tags
-
-    # @property
-    # @deprecated("FeatureTable.primary_keys", since="v0.3.6")
-    # def keys(self):
-    #     return self.primary_keys
-
-    @property
-    def tags(self) -> Dict[str, str]:
-        """
-        Get the tags associated with the feature table.
-
-        :return a Dictionary of all tags associated with the feature table as key/value pairs
-        """
-        if self._tags is None:
-            # If no tags are set, self._tags is expected an empty dictionary.
-            raise ValueError(
-                "Internal error: tags have not been fetched for this FeatureTable instance"
-            )
-        return self._tags
-
-
-    @classmethod
-    def from_uc_get_table_response(cls, uc_get_table_response: Dict[str, object]):
-        """Return a FeatureStore object from a UC get_table response. Note: UC does not return online_stores or tags.
-
-        :param dict uc_get_table_response: A dictionary representing a UC get_table response.
-        :return FeatureTable: a FeatureStore object from the UC response.
-        """
-        table_name = uc_get_table_response["full_name"]
-
-        if uc_get_table_response["securable_kind"] == "TABLE_ONLINE_VIEW":
-            source_table = uc_get_table_response["properties_pairs"]["properties"][
-                "source_table"
-            ]
-            raise ValueError(
-                f"Table '{table_name}' is an online view. Online Views are not feature tables. Please use the source table '{source_table}' instead."
-            )
-
-        if (
-            "table_type" in uc_get_table_response
-            and uc_get_table_response["table_type"] == "VIEW"
-        ):
-            return cls(
-                name=table_name,
-                table_id=uc_get_table_response["table_id"],
-                description=uc_get_table_response["comment"]
-                if "comment" in uc_get_table_response
-                else "",
-                primary_keys=[],
-                partition_columns=[],
-                features=[],
-                creation_timestamp=uc_get_table_response["created_at"],
-                timestamp_keys=[],
-            )
-
-        table_constraints = (
-            uc_get_table_response["table_constraints"]
-            if "table_constraints" in uc_get_table_response
-            else []
-        )
-        primary_key_constraints = [
-            c for c in table_constraints if "primary_key_constraint" in c
-        ]
-        if len(primary_key_constraints) == 0:
-            raise ValueError(
-                "Table can't be used as a feature table because it has no primary key constraint defined."
-                + " Use 'ALTER TABLE table_name ADD CONSTRAINT table_name_pk PRIMARY KEY( key_column [,...] )'"
-                + " to add a primary key constraint on the table."
-            )
-        primary_key_constraint = primary_key_constraint = primary_key_constraints[0][
-            "primary_key_constraint"
-        ]
-        timestamp_keys = (
-            primary_key_constraint["timeseries_columns"]
-            if "timeseries_columns" in primary_key_constraint
-            else []
-        )
-        primary_keys = [
-            c
-            for c in primary_key_constraint["child_columns"]
-            if c not in timestamp_keys
-        ]
-
-        columns = uc_get_table_response["columns"]
-        features = [c["name"] for c in columns]
-        partition_columns_unordered = [c for c in columns if "partition_index" in c]
-        partition_columns = [
-            c["name"]
-            for c in sorted(
-                partition_columns_unordered, key=lambda x: x["partition_index"]
-            )
-        ]
-
-        return cls(
-            name=table_name,
-            table_id=uc_get_table_response["table_id"],
-            description=uc_get_table_response["comment"]
-            if "comment" in uc_get_table_response
-            else "",
-            primary_keys=primary_keys,
-            partition_columns=partition_columns,
-            features=features,
-            creation_timestamp=uc_get_table_response["created_at"],
-            timestamp_keys=timestamp_keys,
-        )