oracle-ads 2.13.9rc0__py3-none-any.whl → 2.13.9rc1__py3-none-any.whl

ads/feature_engineering/utils.py

@@ -0,0 +1,245 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*--
+
+# Copyright (c) 2021, 2022 Oracle and/or its affiliates.
+# Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl/
+
+"""
+The module that represents utility functions.
+
+Functions:
+    is_boolean(value: Any) -> bool
+        Checks if value type is boolean.
+"""
+import numpy as np
+import matplotlib.pyplot as plt
+import pandas as pd
+import re
+from ads.common.card_identifier import card_identify
+from ads.common.decorator.runtime_dependency import (
+    runtime_dependency,
+    OptionalDependency,
+)
+from ads.feature_engineering.dataset.zip_code_data import zip_code_dict
+from functools import lru_cache
+from typing import Any
+
+
+class SchemeNeutral(str):
+    BACKGROUND_LIGHT = "#F5F4F2"
+    BACKGROUND_DARK = "#E4E1DD"
+    AREA_LIGHT = "#BCB6B1"
+    AREA_DARK = "#9E9892"
+    LINE_LIGHT = "#665F5B"
+    LINE_DARK = "#47423E"
+
+
+class SchemeTeal(str):
+    BACKGROUND_LIGHT = "#F0f6f5"
+    BACKGROUND_DARK = "#D6E5E5"
+    AREA_LIGHT = "#9ABFBF"
+    AREA_DARK = "#76A2A0"
+    LINE_LIGHT = "#3E686C"
+    LINE_DARK = "#2B484B"
+
+
+def _tag_to_snake(name: str) -> str:
+    """Conversts string to snake representation.
+    1. Converts the string to the lower case.
+    2. Converts all spaces to underscore.
+
+    Parameters
+    ----------
+    name: string
+        The name to convert.
+
+    Returns
+    -------
+    str: The name converted to the snake representation.
+    """
+    _name = name.strip().lower()
+    if len(_name.split()) > 1:
+        _name = "_".join(_name.split())
+    return _name
+
+
+def _add_missing(x, df):
+    """
+    Adds count of missing values.
+    """
+    n_missing = pd.isnull(x.replace(r"", np.NaN)).sum()
+    if n_missing > 0:
+        df.loc["missing"] = n_missing
+    return df
+
+
+def _count_unique_missing(x):
+    """
+    Returns the total count, unique count and count of missing values of a series.
+    """
+    df_stat = pd.Series(
+        {"count": len(x), "unique": len(x.replace(r"", np.NaN).dropna().unique())},
+        name=x.name,
+    ).to_frame()
+    return _add_missing(x, df_stat)
+
+
+def is_boolean(value: Any) -> bool:
+    """Checks if value type is boolean.
+
+    Parameters
+    ----------
+    value: Any
+        The value to check.
+
+    Returns
+    -------
+    bool: True if value is boolean, False otherwise.
+    """
+    bool_values = ("yes", "y", "true", "t", "1", "no", "n", "false", "f", "0", "")
+    return isinstance(value, bool) or str(value).lower() in bool_values
+
+
+def assign_issuer(cardnumber):
+    if pd.isnull(cardnumber):
+        return "missing"
+    else:
+        return card_identify().identify_issue_network(cardnumber)
+
+
+def random_color_func(
+    z,
+    word=None,
+    font_size=None,
+    position=None,
+    orientation=None,
+    font_path=None,
+    random_state=None,
+):
+    """
+    Returns random color function use for color_func in creating WordCloud
+    """
+    h = 179
+    s = 23
+    l = int(100.0 * float(random_state.randint(60, 120)) / 255.0)
+    return "hsl({}, {}%, {}%)".format(h, s, l)
+
+
+def _is_float(s: str):
+    """
+    Checks if given string can convert to float
+    """
+    return re.match(r"^-?\d+(?:\.\d+)$", s) != None
+
+
+def _str_lat_long_to_point(s):
+    """
+    Converts input data into formated geometry point
+    Return formated geometry point string or np.NaN if input string is not valid
+    """
+    if isinstance(s, str):
+        coords = s.split(",")
+        if len(coords) == 2:
+            lat, long = coords[0].lstrip(), coords[1].lstrip()
+            if lat.startswith("("):
+                lat = lat[1:]
+            if long.endswith(")"):
+                long = long[:-1]
+            if _is_float(lat) and _is_float(long):
+                return "POINT(" + long + " " + lat + ")"
+    return np.NaN
+
+
+@runtime_dependency(module="geopandas", install_from=OptionalDependency.GEO)
+def _plot_gis_scatter(df: pd.DataFrame, lon: str, lat: str):
+    """
+    Parameters
+    ----------
+    df : pd.DataFrame
+        dataframe contains gis data
+    lon: str
+        column name mapping to longitude
+    lat: str
+        column name mapping to latitude
+    Returns
+    -------
+        matplotlib.axes._subplots.AxesSubplot present location of given data on world map
+    """
+    if len(df.index):
+        if lon in df.columns and lat in df.columns:
+            fig, ax = plt.subplots(facecolor=SchemeNeutral.BACKGROUND_LIGHT)
+            gdf = geopandas.GeoDataFrame(
+                df, geometry=geopandas.points_from_xy(df[lon], df[lat])
+            )
+            world = geopandas.read_file(
+                geopandas.datasets.get_path("naturalearth_lowres")
+            )
+            world = world[world["name"] == "United States of America"]
+            ax1 = world.plot(
+                ax=ax, color=SchemeNeutral.AREA_LIGHT, linewidth=0.5, edgecolor="white"
+            )
+            gdf.plot(ax=ax1, color=SchemeTeal.LINE_LIGHT, markersize=10)
+            plt.axis("off")
+            return ax1
+
+
+def _to_lat_long(x: pd.Series, zipcode: pd.DataFrame):
+    """
+    Parameters
+    ----------
+    x: pd.Series
+        pandas series contains zip code data
+    zipcode : pd.DataFrame
+        dataframe contains gis data of zip code
+    Returns
+    -------
+    pd.DataFrame
+        dataframe with 2 columes including latitude and longitude data
+    """
+    lats = []
+    longs = []
+    for s in x:
+        if s in zipcode.index:
+            lats.append(np.float64(zipcode.loc[s]["latitude"]))
+            longs.append(np.float64(zipcode.loc[s]["longitude"]))
+    df = pd.DataFrame(list(zip(lats, longs)), columns=["latitude", "longitude"])
+    return df
+
+
+@runtime_dependency(module="seaborn", install_from=OptionalDependency.VIZ)
+def _set_seaborn_theme():
+    """
+    Sets seaborn figure & axes facecolor
+    """
+    plt.figure(facecolor=SchemeNeutral.BACKGROUND_LIGHT)
+    seaborn.set(
+        rc={
+            "axes.facecolor": SchemeNeutral.BACKGROUND_LIGHT,
+            "figure.facecolor": SchemeNeutral.BACKGROUND_LIGHT,
+        }
+    )
+
+
+def _format_stat(stat: pd.Series):
+    """
+    Formats statistics row index.
+    """
+    stat.rename(
+        {
+            "std": "standard deviation",
+            "min": "sample minimum",
+            "25%": "lower quartile",
+            "50%": "median",
+            "75%": "upper quartile",
+            "max": "sample maximum",
+        },
+        inplace=True,
+    )
+
+
+@lru_cache(maxsize=1)
+def _zip_code():
+    """Returns dataframe contain zip code, latitude and longitude data."""
+    return pd.DataFrame.from_dict(
+        zip_code_dict, orient="index", columns=["longitude", "latitude"]
+    )

ads/feature_store/.readthedocs.yaml

@@ -0,0 +1,19 @@
+# Read the Docs configuration file
+
+# Required
+version: 2
+
+# Set the version of Python and other tools you might need
+build:
+  os: ubuntu-22.04
+  tools:
+    python: "3.9"
+
+# Build documentation in the docs/ directory with Sphinx
+sphinx:
+   configuration: ads/feature_store/docs/source/conf.py
+
+# Optionally declare the Python requirements required to build your docs
+python:
+   install:
+   - requirements: ads/feature_store/docs/requirements.txt

ads/feature_store/README.md

@@ -0,0 +1,65 @@
+# Oracle Feature Store (ADS)
+
+[![Python](https://img.shields.io/badge/python-3.8-blue?style=for-the-badge&logo=pypi&logoColor=white)](https://pypi.org/project/oracle-ads/) [![PysparkConda](https://img.shields.io/badge/fspyspark32_p38_cpu_v2-1.0-blue?style=for-the-badge&logo=pypi&logoColor=white)](https://docs.oracle.com/en-us/iaas/data-science/using/conda-pyspark-fam.htm) [![Notebook Examples](https://img.shields.io/badge/docs-notebook--examples-blue?style=for-the-badge&logo=pypi&logoColor=white)](https://github.com/oracle-samples/oci-data-science-ai-samples/tree/master/notebook_examples) [![Delta](https://img.shields.io/badge/delta-2.0.1-blue?style=for-the-badge&logo=pypi&logoColor=white)](https://delta.io/) [![PySpark](https://img.shields.io/badge/pyspark-3.2.1-blue?style=for-the-badge&logo=pypi&logoColor=white)](https://spark.apache.org/docs/3.2.1/api/python/index.html) [![Great Expectations](https://img.shields.io/badge/greatexpectations-0.17.19-blue?style=for-the-badge&logo=pypi&logoColor=white)](https://greatexpectations.io/) [![Pandas](https://img.shields.io/badge/pandas-1.5.3-blue?style=for-the-badge&logo=pypi&logoColor=white)](https://pandas.pydata.org/) [![PyArrow](https://img.shields.io/badge/pyarrow-11.0.0-blue?style=for-the-badge&logo=pypi&logoColor=white)](https://arrow.apache.org/docs/python/index.html)
+
+Managing many datasets, data sources, and transformations for machine learning is complex and costly. Poorly cleaned data, data issues, bugs in transformations, data drift, and training serving skew all lead to increased model development time and poor model performance. Feature store solves many of the problems because it is a centralized way to transform and access data for training and serving time, Feature stores help define a standardised pipeline for ingestion of data and querying of data.
+
+ADS feature store is a stack-based solution that is deployed in your tenancy using OCI Resource Manager.
+
+Following are brief descriptions of key concepts and the main components of ADS feature store.
+
+- ``Feature Vector``:  Set of feature values for any one primary and identifier key. For example, all and a subset of features of customer ID 2536 can be called as one feature vector .
+- ``Feature``: A feature is an individual measurable property or characteristic of an event being observed.
+- ``Entity``: An entity is a group of semantically related features. The first step a consumer of features would typically do when accessing the feature store service is to list the entities and the entities associated with features. Another way to look at it is that an entity is an object or concept that's described by its features. Examples of entities are customer, product, transaction, review, image, document, and so on.
+- ``Feature Group``: A feature group in a feature store is a collection of related features that are often used together in ML models. It serves as an organizational unit within the feature store for users to manage, version, and share features across different ML projects. By organizing features into groups, data scientists and ML engineers can efficiently discover, reuse, and collaborate on features reducing the redundant work and ensuring consistency in feature engineering.
+- ``Feature Group Job``: Feature group jobs are the processing instance of a feature group. Each feature group job includes validation results and statistics results.
+- ``Dataset``: 	A dataset is a collection of features that are used together to either train a model or perform model inference.
+- ``Dataset Job``: A dataset job is the processing instance of a dataset. Each dataset job includes validation results and statistics results.
+
+## Documentation
+
+  - [Oracle Feature Store SDK (ADS) Documentation](https://feature-store-accelerated-data-science.readthedocs.io/en/latest/)
+  - [OCI Data Science and AI services Examples](https://github.com/oracle/oci-data-science-ai-samples)
+  - [Oracle AI & Data Science Blog](https://blogs.oracle.com/ai-and-datascience/)
+  - [OCI Documentation](https://docs.oracle.com/en-us/iaas/data-science/using/data-science.htm)
+
+## Examples
+
+### Quick start examples
+
+| Jupyter Notebook                                                                                                                                                          | Description                                                                                                                                                                                                                                                                                                 |
+|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| [Feature store querying](https://github.com/oracle-samples/oci-data-science-ai-samples/blob/main/notebook_examples/feature_store_querying.ipynb)                          | - Ingestion, querying and exploration of data.                                                                                                                                                                                                                                                              |
+| [Feature store quickstart](https://github.com/oracle-samples/oci-data-science-ai-samples/blob/main/notebook_examples/feature_store_quickstart.ipynb)                      | - Ingestion, querying and exploration of data.                                                                                                                                                                                                                                                              |
+| [Schema enforcement and schema evolution](https://github.com/oracle-samples/oci-data-science-ai-samples/blob/main/notebook_examples/feature_store_schema_evolution.ipynb) | - `Schema evolution` allows you to easily change a table's current schema to accommodate data that is changing over time. `Schema enforcement`, also known as schema validation, is a safeguard in Delta Lake that ensures data quality by rejecting writes to a table that don't match the table's schema. |
+| [Storage of medical records in feature store](https://github.com/oracle-samples/oci-data-science-ai-samples/blob/main/notebook_examples/feature_store_ehr_data.ipynb)     | Example to demonstrate storage of medical records in feature store                                                                                                                                                                                                                                          |
+
+### Big data operations using OCI DataFlow
+
+| Jupyter Notebook                                                                                                                                                    | Description                                                                                |
+|---------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------|
+| [Big data operations with feature store](https://github.com/oracle-samples/oci-data-science-ai-samples/blob/main/notebook_examples/feature_store_spark_magic.ipynb) | - Ingestion of data using Spark Magic, querying and exploration of data using Spark Magic. |
+
+### LLM Use cases
+
+| Jupyter Notebook                                                                                                                                                                                                                        | Description                                                                                                                                                                                                                                                                                                              |
+|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| [Embeddings in Feature Store](https://github.com/oracle-samples/oci-data-science-ai-samples/blob/main/notebook_examples/feature_store_embeddings.ipynb)                                                                                 | - `Embedding feature stores` are optimized for fast and efficient retrieval of embeddings. This is important because embeddings can be high-dimensional and computationally expensive to calculate. By storing them in a dedicated store, you can avoid the need to recalculate embeddings for the same data repeatedly. |
+| [Synthetic data generation in feature store using OpenAI and FewShotPromptTemplate](https://github.com/oracle-samples/oci-data-science-ai-samples/blob/main/notebook_examples/feature_store_medical_synthetic_data_openai.ipynb)        | - `Synthetic data` is artificially generated data, rather than data collected from real-world events. It's used to simulate real data without compromising privacy or encountering real-world limitations.                                                                                                               |
+| [PII Data redaction, Summarise Content and Translate content using doctran and open AI](https://github.com/oracle-samples/oci-data-science-ai-samples/blob/main/notebook_examples/feature_store_pii_redaction_and_transformation.ipynb) | - One way to think of Doctran is a LLM-powered black box where messy strings go in and nice, clean, labelled strings come out. Another way to think about it is a modular, declarative wrapper over OpenAI's functional calling feature that significantly improves the developer experience.                            |
+| [OpenAI embeddings in feature store](https://github.com/oracle-samples/oci-data-science-ai-samples/blob/main/notebook_examples/feature_store_embeddings_openai.ipynb)                                                                   | - `Embedding feature stores` are optimized for fast and efficient retrieval of embeddings. This is important because embeddings can be high-dimensional and computationally expensive to calculate. By storing them in a dedicated store, you can avoid the need to recalculate embeddings for the same data repeatedly. |
+
+
+## Contributing
+
+This project welcomes contributions from the community. Before submitting a pull request, please [review our contribution guide](./../../CONTRIBUTING.md)
+
+Find Getting Started instructions for developers in [README-development.md](https://github.com/oracle/accelerated-data-science/blob/main/README-development.md)
+
+## Security
+
+Consult the security guide [SECURITY.md](https://github.com/oracle/accelerated-data-science/blob/main/SECURITY.md) for our responsible security vulnerability disclosure process.
+
+## License
+
+Copyright (c) 2020, 2022 Oracle and/or its affiliates. Licensed under the [Universal Permissive License v1.0](https://oss.oracle.com/licenses/upl/)

ads/feature_store/__init__.py

@@ -0,0 +1,9 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*--
+
+# Copyright (c) 2023 Oracle and/or its affiliates.
+# Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl/
+
+import logging
+
+logger = logging.getLogger(__name__)

ads/feature_store/common/enums.py

@@ -0,0 +1,339 @@
+#!/usr/bin/env python
+# -*- coding: utf-8; -*-
+
+# Copyright (c) 2023 Oracle and/or its affiliates.
+# Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl/
+
+from enum import Enum
+
+
+class JobStatus(Enum):
+    """
+    An enumeration that represents the supported Job status.
+
+    Attributes:
+        SUCCEEDED (str): A string representation of the state of Succeeded job.
+        FAILED (str): A string representation of the state of Failed job.
+        CODE_EXECUTION (str): A string representation of the state of CodeExecution job.
+
+    Methods:
+        None
+    """
+
+    SUCCEEDED = "SUCCEEDED"
+    FAILED = "FAILED"
+    CODE_EXECUTION = "CODE_EXECUTION"
+
+
+class LevelType(Enum):
+    """
+    An enumeration defining the different types of logging levels.
+
+    Attributes:
+        ERROR (str): A string representing the highest logging level, indicating an error in the program.
+        WARNING (str): A string representing a lower logging level, indicating a potential issue or warning in the program.
+    """
+
+    ERROR = "ERROR"
+    WARNING = "WARNING"
+
+
+class DatasetIngestionMode(Enum):
+    """
+    An enumeration defining the possible modes for ingesting datasets.
+
+    Attributes:
+        SQL (str): A string representing the SQL mode, which is used to ingest datasets using SQL.
+    """
+
+    SQL = "SQL"
+
+
+class IngestionType(Enum):
+    """
+    The type of ingestion that can be performed.
+
+    Possible values:
+        * STREAMING: The data is ingested in real time.
+        * BATCH: The data is ingested in batches.
+    """
+
+    STREAMING = "STREAMING"
+    BATCH = "BATCH"
+
+
+class BatchIngestionMode(Enum):
+    """
+    An enumeration that represents the supported Ingestion Mode in feature store.
+
+    Attributes:
+        OVERWRITE (str): Ingestion mode to overwrite the data in the system.
+        APPEND (str): Ingestion mode to append the data in the system.
+        UPSERT (str): Ingestion mode to insert and update the data in the system.
+
+    Methods:
+        None
+    """
+
+    OVERWRITE = "OVERWRITE"
+    APPEND = "APPEND"
+    DEFAULT = "DEFAULT"
+    UPSERT = "UPSERT"
+
+
+class StreamingIngestionMode(Enum):
+    """
+    Enumeration for stream ingestion modes.
+
+    - `COMPLETE`: Represents complete stream ingestion where the entire dataset is replaced.
+    - `APPEND`: Represents appending new data to the existing dataset.
+    - `UPDATE`: Represents updating existing data in the dataset.
+    """
+
+    COMPLETE = "COMPLETE"
+    APPEND = "APPEND"
+    UPDATE = "UPDATE"
+
+
+class JoinType(Enum):
+    """Enumeration of supported SQL join types.
+
+    Attributes:
+        INNER: Inner join.
+        LEFT: Left join.
+        RIGHT: Right join.
+        FULL: Full outer join.
+        CROSS: Cross join.
+        LEFT_SEMI_JOIN: Left semi join.
+    """
+
+    INNER = "INNER"
+    LEFT = "LEFT"
+    RIGHT = "RIGHT"
+    FULL = "FULL"
+    CROSS = "CROSS"
+    LEFT_SEMI_JOIN = "LEFT_SEMI_JOIN"
+
+
+class ExecutionEngine(Enum):
+    """
+    An enumeration that represents the supported execution engines.
+
+    Attributes:
+        SPARK (str): A string representation of the Apache Spark execution engine.
+        PANDAS (str): A string representation of the Pandas execution engine.
+
+    Methods:
+        None
+    """
+
+    SPARK = "SPARK"
+    PANDAS = "PANDAS"
+
+
+class DataFrameType(Enum):
+    """
+    An enumeration that represents the supported DataFrame types.
+
+    Attributes:
+        SPARK (str): A string representation for spark Data frame type.
+        PANDAS (str): A string representation for pandas Data frame type.
+
+    Methods:
+        None
+    """
+
+    SPARK = "SPARK"
+    PANDAS = "PANDAS"
+
+
+class ValidationEngineType(Enum):
+    """
+    An enumeration that represents the supported validation engines.
+
+    Attributes:
+        GREAT_EXPECTATIONS (str): A string representation of the great expectation execution engine.
+
+    Methods:
+        None
+    """
+
+    GREAT_EXPECTATIONS = "GREAT_EXPECTATIONS"
+
+
+class FeatureStoreJobType(Enum):
+    """
+    An enumeration that represents the Job type.
+
+    Attributes:
+        FEATURE_GROUP_INGESTION (str): A string representing that job is feature group ingestion.
+        DATASET_INGESTION (str): A string representing that job is dataset ingestion.
+        FEATURE_GROUP_DELETION (str): A string representing that job is feature group deletion.
+        DATASET_DELETION (str): A string representing that job is dataset deletion.
+
+    Methods:
+        None
+    """
+
+    FEATURE_GROUP_INGESTION = "FEATURE_GROUP_INGESTION"
+    DATASET_INGESTION = "DATASET_INGESTION"
+    FEATURE_GROUP_DELETION = "FEATURE_GROUP_DELETION"
+    DATASET_DELETION = "DATASET_DELETION"
+
+
+class LifecycleState(Enum):
+    """
+    An enumeration that represents the lifecycle state of feature store resources.
+
+    Attributes:
+        ACTIVE (str): A string representing Active resource.
+        FAILED (str): A string representing Failed resource.
+        NEEDS_ATTENTION (str): A string representing needs_attention resource.
+
+    Methods:
+        None
+    """
+
+    ACTIVE = "ACTIVE"
+    FAILED = "FAILED"
+    NEEDS_ATTENTION = "NEEDS_ATTENTION"
+
+
+class JobConfigurationType(Enum):
+    """
+    An enumeration defining the different types of job configuration modes for Spark.
+
+    Attributes:
+        SPARK_BATCH_AUTOMATIC (str): A string representing automatic job configuration mode for Spark Batch jobs.
+        SPARK_BATCH_MANUAL (str): A string representing manual job configuration mode for Spark Batch jobs.
+    """
+
+    SPARK_BATCH_AUTOMATIC = "SPARK_BATCH_AUTOMATIC"
+    SPARK_BATCH_MANUAL = "SPARK_BATCH_MANUAL"
+
+
+class ExpectationType(Enum):
+    """
+    An enumeration of the available expectation types for a feature store.
+
+    Attributes:
+        STRICT (str): A strict expectation type.
+        LENIENT (str): A lenient expectation type.
+        NO_EXPECTATION (str): A no expectation type.
+
+    Methods:
+        None
+    """
+
+    STRICT = "STRICT"
+    LENIENT = "LENIENT"
+    NO_EXPECTATION = "NO_EXPECTATION"
+
+
+class TransformationMode(Enum):
+    """
+    An enumeration defining the different modes for data transformation.
+
+    Attributes:
+        SQL (str): A string representing the SQL mode, which is used to transform data using SQL queries.
+        PANDAS (str): A string representing the Pandas mode, which is used to transform data using the Pandas library.
+    """
+
+    SQL = "sql"
+    PANDAS = "pandas"
+    SPARK = "spark"
+
+
+class FilterOperators(Enum):
+    """
+    An enumeration defining the different comparison operators for data filtering.
+
+    Attributes:
+        GE (str): A string representing the greater than or equal to operator.
+        GT (str): A string representing the greater than operator.
+        NE (str): A string representing the not equals operator.
+        EQ (str): A string representing the equals operator.
+        LE (str): A string representing the less than or equal to operator.
+        LT (str): A string representing the less than operator.
+        IN (str): A string representing the in operator.
+        LK (str): A string representing the like operator.
+    """
+
+    GE = "GREATER_THAN_OR_EQUAL"
+    GT = "GREATER_THAN"
+    NE = "NOT_EQUALS"
+    EQ = "EQUALS"
+    LE = "LESS_THAN_OR_EQUAL"
+    LT = "LESS_THAN"
+    IN = "IN"
+    LK = "LIKE"
+
+
+class FeatureType(Enum):
+    """
+    An enumeration of the available feature types for a feature store.
+
+    Attributes:
+        STRING (str): A string feature type.
+        INTEGER (str): An integer feature type.
+        FLOAT (str): A float feature type.
+        DOUBLE (str): A double feature type.
+        BOOLEAN (str): A boolean feature type.
+        DATE (str): A date feature type.
+        TIMESTAMP (str): A timestamp feature type.
+        DECIMAL (str): A decimal feature type.
+        BINARY (str): A binary feature type.
+        ARRAY (str): An array feature type.
+        MAP (str): A map feature type.
+        STRUCT (str): A struct feature type.
+    """
+
+    STRING = "STRING"
+    SHORT = "SHORT"
+    INTEGER = "INTEGER"
+    LONG = "LONG"
+    FLOAT = "FLOAT"
+    DOUBLE = "DOUBLE"
+    BOOLEAN = "BOOLEAN"
+    DATE = "DATE"
+    TIMESTAMP = "TIMESTAMP"
+    DECIMAL = "DECIMAL"
+    BINARY = "BINARY"
+    BYTE = "BYTE"
+    STRING_ARRAY = "STRING_ARRAY"
+    INTEGER_ARRAY = "INTEGER_ARRAY"
+    SHORT_ARRAY = "SHORT_ARRAY"
+    LONG_ARRAY = "LONG_ARRAY"
+    FLOAT_ARRAY = "FLOAT_ARRAY"
+    DOUBLE_ARRAY = "DOUBLE_ARRAY"
+    BINARY_ARRAY = "BINARY_ARRAY"
+    DATE_ARRAY = "DATE_ARRAY"
+    TIMESTAMP_ARRAY = "TIMESTAMP_ARRAY"
+    BYTE_ARRAY = "BYTE_ARRAY"
+    BOOLEAN_ARRAY = "BOOLEAN_ARRAY"
+    STRING_STRING_MAP = "STRING_STRING_MAP"
+    STRING_INTEGER_MAP = "STRING_INTEGER_MAP"
+    STRING_SHORT_MAP = "STRING_SHORT_MAP"
+    STRING_LONG_MAP = "STRING_LONG_MAP"
+    STRING_FLOAT_MAP = "STRING_FLOAT_MAP"
+    STRING_DOUBLE_MAP = "STRING_DOUBLE_MAP"
+    STRING_TIMESTAMP_MAP = "STRING_TIMESTAMP_MAP"
+    STRING_DATE_MAP = "STRING_DATE_MAP"
+    STRING_BYTE_MAP = "STRING_BYTE_MAP"
+    STRING_BINARY_MAP = "STRING_BINARY_MAP"
+    STRING_BOOLEAN_MAP = "STRING_BOOLEAN_MAP"
+    UNKNOWN = "UNKNOWN"
+    COMPLEX = "COMPLEX"
+
+
+class EntityType(Enum):
+    """
+    An enumeration of the supported entity types.
+
+    Attributes:
+        FEATURE_GROUP (str): A string representing the feature group.
+        DATASET (str): An string representing the dataset.
+    """
+
+    FEATURE_GROUP = "FEATURE_GROUP"
+    DATASET = "DATASET"