frogml-core 0.0.1__py3-none-any.whl

frogml/model/decorators/api.py

@@ -0,0 +1,62 @@
+from typing import Callable
+
+from dependency_injector.wiring import Provide, inject
+
+from frogml.exceptions import FrogmlException
+from frogml.inner.runtime_di.containers import FrogmlRuntimeContainer
+from frogml.model.adapters.input_adapters.base_input_adapter import BaseInputAdapter
+from frogml.model.adapters.input_adapters.dataframe_input_adapter import (
+    DataFrameInputAdapter,
+)
+from frogml.model.adapters.output_adapters.base_output_adapter import BaseOutputAdapter
+from frogml.model.adapters.output_adapters.dataframe_output_adapter import (
+    DataFrameOutputAdapter,
+)
+
+API_NOT_CONFIGURED_ERROR_MESSAGE = (
+    "There has been an error configuring the Frogml model. When testing locally, "
+    "please use 'run_local' as described in our docs: "
+    "https://docs-saas.qwak.com/docs/testing-locally#running-local-inference"
+)
+
+
+@inject
+def api_decorator(
+    analytics: bool = True,
+    analytics_sample_ratio: float = 1.0,
+    analytics_exclude_columns: list = [],
+    feature_extraction: bool = False,
+    input_adapter: BaseInputAdapter = DataFrameInputAdapter(),
+    output_adapter: BaseOutputAdapter = DataFrameOutputAdapter(),
+    api_decorator_function_creator=Provide[
+        FrogmlRuntimeContainer.api_decorator_function_creator
+    ],
+) -> Callable:
+    if callable(analytics):
+        raise TypeError(
+            """
+        You forgot to call the `@api` decorator.
+
+        Correct way -
+        @api()
+        def function():
+            pass
+
+        Wrong way -
+        @api
+        def function():
+            pass
+        """
+        )
+    try:
+        return api_decorator_function_creator(
+            analytics,
+            feature_extraction,
+            input_adapter,
+            output_adapter,
+            analytics_sample_ratio,
+            analytics_exclude_columns,
+        )
+    except TypeError as e:
+        if "__call__() takes 1" in str(e):
+            raise FrogmlException(API_NOT_CONFIGURED_ERROR_MESSAGE)

frogml/model/decorators/impl/api_implementation.py

@@ -0,0 +1,29 @@
+from functools import wraps
+from typing import Any, Callable
+
+from frogml.model.adapters import BaseInputAdapter, BaseOutputAdapter
+from frogml.model.utils.extract_wrapped_function import extract_wrapped
+
+
+def create_decorator_function(
+    analytics: bool,
+    feature_extraction: bool,
+    input_adapter: BaseInputAdapter,
+    output_adapter: BaseOutputAdapter,
+    analytics_sample_ratio: float,
+    analytics_exclude_columns: list,
+) -> Callable:
+    def api_decorator_function_load_logic(func: Callable[..., Any]):
+        func = extract_wrapped(func)
+        setattr(func, "_input_adapter", input_adapter)
+        setattr(func, "_output_adapter", output_adapter)
+        setattr(func, "_fs_extraction", feature_extraction)
+
+        @wraps(func)
+        def api_decorator_function_execution_logic(*args, **kwargs) -> Any:
+            output = func(*args, **kwargs)
+            return output
+
+        return api_decorator_function_execution_logic
+
+    return api_decorator_function_load_logic

frogml/model/decorators/impl/timer_implementation.py

@@ -0,0 +1,10 @@
+import time
+
+
+def create_frogml_timer(name):
+    try:
+        start_time = time.time()
+        yield
+    finally:
+        elapsed_secs = time.time() - start_time
+        print(f"elapsed time: {elapsed_secs} seconds")

frogml/model/decorators/timer.py

@@ -0,0 +1,20 @@
+import contextlib
+
+from dependency_injector.wiring import Provide, inject
+
+from frogml.inner.runtime_di.containers import FrogmlRuntimeContainer
+
+
+@inject
+@contextlib.contextmanager
+def frogml_timer(
+    name, create_timer_function=Provide[FrogmlRuntimeContainer.timer_function_creator]
+):
+    """
+    The Frogml timer is a utility for measuring the runtime of ML models, specifically for visibility and latency evaluation.
+    It provides a convenient way to measure the time it takes for models to perform predictions
+    and to provide a breakdown of the different parts in the production process
+    Args:
+        name (str): The Frogml timer name. Users may define multiple impl with different names
+    """
+    return create_timer_function(name)

frogml/model/fs_info_mapping_retriever.py

@@ -0,0 +1,58 @@
+from typing import Dict, List
+
+from frogml.clients.administration.eco_system.eco_system_utils import EcosystemUtils
+from frogml.clients.feature_store import FeatureRegistryClient
+from frogml.feature_store._common.feature_set_utils import (
+    FeatureSetInfo,
+    get_env_to_featuresets_mapping,
+    get_feature_set_info,
+)
+from frogml.model.schema_entities import BaseFeature, FeatureStoreInput
+from frogml.model.utils.feature_utils import extract_env_name, extract_featureset_name
+
+
+def retrieve_fs_mapping(
+    features: List[BaseFeature],
+) -> Dict[str, Dict[str, FeatureSetInfo]]:
+    """
+    Retrieve the feature set info mapping.
+    If one of the features is a FeatureStoreInput and is in a different environment from the current one, populate it using a single API call.
+    Otherwise, retrieve each feature set info individually.
+    The reasoning behind this logic is that if all required features are in the same environment, it's more efficient to retrieve only the necessary feature set, rather than all feature sets.
+    * Assuming the feature name is fully qualified with the environment name
+    :param features:
+    :return: dict of environment name to dict of feature set name to FeatureSetInfo
+    """
+    current_env_name = EcosystemUtils().get_current_environment_name()
+    features_manager_client = FeatureRegistryClient()
+
+    if any(
+        [
+            feature
+            for feature in features
+            if isinstance(feature, FeatureStoreInput)
+            and extract_env_name(feature.name) != current_env_name
+        ]
+    ):
+        return get_env_to_featuresets_mapping(features_manager_client)
+    else:
+        return _retrieve_fs_info_one_by_one(
+            features_manager_client, current_env_name, features
+        )
+
+
+def _retrieve_fs_info_one_by_one(
+    features_manager_client: FeatureRegistryClient,
+    current_env_name: str,
+    features: List[BaseFeature],
+) -> Dict[str, Dict[str, FeatureSetInfo]]:
+    fs_info_cache: Dict[str, FeatureSetInfo] = dict()
+
+    for feature in features:
+        if isinstance(feature, FeatureStoreInput):
+            feature_set_name = extract_featureset_name(feature.name).lower()
+            if feature_set_name not in fs_info_cache:
+                fs_info_cache[feature_set_name] = get_feature_set_info(
+                    features_manager_client, feature_set_name
+                )
+    return {current_env_name: fs_info_cache}

frogml/model/model_version_tracking.py

@@ -0,0 +1,57 @@
+from typing import Dict, Union
+
+from frogml.inner.singleton_meta import SingletonMeta
+
+
+class FrogmlModelVersionTracking(metaclass=SingletonMeta):
+    def __init__(self):
+        self.metric: Dict[str, Union[int, str]] = {}
+        self.param: Dict[str, Union[int, str]] = {}
+
+    def log_param(self, params: Dict[str, Union[int, str]]):
+        self.param = {**self.param, **params}
+
+    def log_params(self, params: Dict[str, Union[int, str]]):
+        self.log_param(params)
+
+    def log_metric(self, metrics: Dict[str, Union[int, str]]):
+        self.metric = {**self.metric, **metrics}
+
+    def log_metrics(self, metrics: Dict[str, Union[int, str]]):
+        self.log_metric(metrics)
+
+    def get_metrics(self) -> Dict[str, Union[int, str]]:
+        return self.metric
+
+    def get_params(self) -> Dict[str, Union[int, str]]:
+        return self.param
+
+
+def log_metric(metrics):
+    client = FrogmlModelVersionTracking()
+    client.log_metric(metrics)
+
+
+def log_param(params):
+    client = FrogmlModelVersionTracking()
+    client.log_param(params)
+
+
+def log_metrics(metrics):
+    client = FrogmlModelVersionTracking()
+    client.log_metric(metrics)
+
+
+def log_params(params):
+    client = FrogmlModelVersionTracking()
+    client.log_param(params)
+
+
+def get_params():
+    client = FrogmlModelVersionTracking()
+    return client.get_params()
+
+
+def get_metrics():
+    client = FrogmlModelVersionTracking()
+    return client.get_metrics()

frogml/model/schema.py

@@ -0,0 +1,52 @@
+from dataclasses import dataclass
+from typing import List
+
+from _frogml_proto.qwak.build.v1.build_pb2 import ModelSchema as ProtoModelSchema
+from frogml.model._entity_extraction import enrich_schema
+from frogml.model.schema_entities import (
+    BaseFeature,
+    Entity,
+    ExplicitFeature,
+    FeatureStoreInput,
+    InferenceOutput,
+)
+
+__all__ = ["ModelSchema", "ExplicitFeature", "InferenceOutput", "FeatureStoreInput"]
+
+
+@dataclass
+class ModelSchema:
+    """
+    The ModelSchema class provides a structured representation of a Machine Learning (ML) model's schema.
+     It captures the details such as input features, output predictions, and entities, providing a standard way to
+    communicate these details between different components of an ML system.
+    """
+
+    def __init__(
+        self,
+        entities: List[Entity] = None,
+        inputs: List[BaseFeature] = None,
+        outputs: List[InferenceOutput] = None,
+    ):
+        """
+        Initializes the ModelSchema object with entities, inputs, and outputs.
+
+        Args:
+            entities (List[Entity], optional): A list of Entity objects. Defaults to None.
+            inputs (List[BaseFeature], optional): A list of BaseFeature objects. Defaults to None.
+            outputs (List[InferenceOutput], optional): A list of InferenceOutput objects. Defaults to None.
+
+        Raises:
+            TypeError: If entities, inputs, or outputs are not provided in the correct format.
+        """
+        raw_entities = entities if entities else []
+        raw_inputs = inputs if inputs else []
+        self._inputs, self._entities = enrich_schema(raw_inputs, raw_entities)
+        self._outputs = outputs if outputs else []
+
+    def to_proto(self):
+        return ProtoModelSchema(
+            entities=[entity.to_proto() for entity in self._entities],
+            features=[feature.to_proto() for feature in self._inputs],
+            inference_output=[inference.to_proto() for inference in self._outputs],
+        )

frogml/model/schema_entities.py

@@ -0,0 +1,107 @@
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from typing import Optional, Type
+
+from _frogml_proto.qwak.build.v1.build_pb2 import BatchFeatureV1 as ProtoBatchFeatureV1
+from _frogml_proto.qwak.build.v1.build_pb2 import Entity as ProtoEntity
+from _frogml_proto.qwak.build.v1.build_pb2 import (
+    ExplicitFeature as ProtoExplicitFeature,
+)
+from _frogml_proto.qwak.build.v1.build_pb2 import Feature as ProtoFeature
+from _frogml_proto.qwak.build.v1.build_pb2 import (
+    InferenceOutput as ProtoInferenceOutput,
+)
+from _frogml_proto.qwak.build.v1.build_pb2 import Prediction as ProtoPrediction
+from _frogml_proto.qwak.build.v1.build_pb2 import RequestInput as ProtoRequestInput
+from _frogml_proto.qwak.build.v1.build_pb2 import ValueType
+
+
+@dataclass(unsafe_hash=True)
+class Entity:
+    name: str
+    type: Type = str
+
+    def to_proto(self):
+        return ProtoEntity(
+            name=self.name, type=ValueType(type=_type_conversion(self.type))
+        )
+
+
+@dataclass
+class BaseFeature(ABC):
+    name: str
+
+    @abstractmethod
+    def to_proto(self):
+        pass
+
+
+@dataclass(unsafe_hash=True)
+class ExplicitFeature(BaseFeature):
+    type: Type
+
+    def to_proto(self):
+        return ProtoFeature(
+            explicit_feature=ProtoExplicitFeature(
+                name=self.name, type=ValueType(type=_type_conversion(self.type))
+            )
+        )
+
+
+@dataclass(unsafe_hash=True)
+class RequestInput(BaseFeature):
+    type: Type
+
+    def to_proto(self):
+        return ProtoFeature(
+            request_input=ProtoRequestInput(
+                name=self.name, type=ValueType(type=_type_conversion(self.type))
+            )
+        )
+
+
+@dataclass(unsafe_hash=True)
+class FeatureStoreInput(BaseFeature):
+    entity: Optional[Entity] = None
+
+    def to_proto(self):
+        return ProtoFeature(
+            batch_feature_v1=ProtoBatchFeatureV1(
+                name=self.name, entity=self.entity.to_proto() if self.entity else None
+            )
+        )
+
+
+@dataclass(unsafe_hash=True)
+class InferenceOutput:
+    name: str
+    type: type
+
+    def to_proto(self):
+        return ProtoInferenceOutput(
+            name=self.name, type=ValueType(type=_type_conversion(self.type))
+        )
+
+
+@dataclass(unsafe_hash=True)
+class Prediction:
+    name: str
+    type: type
+
+    def to_proto(self):
+        return ProtoPrediction(
+            name=self.name, type=ValueType(type=_type_conversion(self.type))
+        )
+
+
+def _type_conversion(type):
+    if type == int:
+        return ValueType.INT32
+    elif type == str:
+        return ValueType.STRING
+    elif type == bytes:
+        return ValueType.BYTES
+    elif type == bool:
+        return ValueType.BOOL
+    elif type == float:
+        return ValueType.FLOAT

frogml/model/tools/__init__.py

@@ -0,0 +1,24 @@
+from frogml.inner.runtime_di import ContainerLock, FrogmlRuntimeContainer
+
+from .run_model_locally import run_local
+
+
+def wire_runtime_with_run_local():
+    container = FrogmlRuntimeContainer()
+    from frogml.model import decorators
+
+    container.wire(
+        packages=[
+            decorators,
+        ]
+    )
+    return container
+
+
+# Since DI allows overriding containers that are already injected, and there isn't a built-in mechanism to prevent this
+# we've added a lock class (singleton) that operates as a lock. Now the production override can lock the container, and
+# it will prevent issues where the container is redefined with the basic non production container
+if not ContainerLock.locked:
+    wire_runtime_with_run_local()
+
+__all__ = ["run_local", "wire_runtime_with_run_local"]

frogml/model/tools/adapters/encoders.py

@@ -0,0 +1,46 @@
+import json
+
+TF_B64_KEY = "b64"
+
+
+class B64JsonEncoder(json.JSONEncoder):
+    def default(self, o):
+        import base64
+
+        if isinstance(o, bytes):
+            try:
+                return o.decode("utf-8")
+            except UnicodeDecodeError:
+                return {TF_B64_KEY: base64.b64encode(o).decode("utf-8")}
+
+        try:
+            return super(B64JsonEncoder, self).default(o)
+        except (TypeError, OverflowError):
+            return {"unknown_obj": str(o)}
+
+
+class NumpyJsonEncoder(B64JsonEncoder):
+    def default(self, o):
+        import numpy as np
+
+        if isinstance(o, np.generic):
+            return o.item()
+
+        if isinstance(o, np.ndarray):
+            return o.tolist()
+
+        return super(NumpyJsonEncoder, self).default(o)
+
+
+class TfTensorJsonEncoder(NumpyJsonEncoder):
+    def default(self, o):
+        import tensorflow as tf
+
+        # Tensor -> ndarray or object
+        if isinstance(o, tf.Tensor):
+            if tf.__version__.startswith("1."):
+                with tf.compat.v1.Session():
+                    return o.numpy()
+            else:
+                return o.numpy()
+        return super(TfTensorJsonEncoder, self).default(o)

frogml/model/tools/adapters/input.py

@@ -0,0 +1,66 @@
+from typing import Any, Union
+
+from frogml.exceptions import FrogmlHTTPException
+from frogml.model.adapters import (
+    DataFrameInputAdapter,
+    FileInputAdapter,
+    ImageInputAdapter,
+    JsonInputAdapter,
+    MultiInputAdapter,
+    NumpyInputAdapter,
+    ProtoInputAdapter,
+    StringInputAdapter,
+    TfTensorInputAdapter,
+)
+from frogml.model.base import BaseModel
+
+from .input_adapters.dataframe_input import DataframeInput
+from .input_adapters.file_input import FileInput
+from .input_adapters.image_input import ImageInput
+from .input_adapters.json_input import JsonInput
+from .input_adapters.string_input import StringInput
+from .input_adapters.tf_tensor_input import TfTensorInput
+
+
+def get_input_adapter(
+    model: BaseModel,
+) -> Union[JsonInput, DataframeInput, StringInput]:
+    adapter = getattr(model.predict, "_input_adapter", "")
+
+    class QwakInput(StringInput):
+        def extract_user_func_args(self, data: str) -> Any:
+            try:
+                return adapter.extract_user_func_arg(data)
+            except Exception as e:
+                raise FrogmlHTTPException(
+                    status_code=500,
+                    message=f"Failed to deserialize input message. Error is: {e}. For more information "
+                    f"please check model logs.",
+                )
+
+    class MultiFormatInput(QwakInput):
+        pass
+
+    mapping = {
+        JsonInputAdapter: JsonInput,
+        DataFrameInputAdapter: DataframeInput,
+        StringInputAdapter: StringInput,
+        ProtoInputAdapter: QwakInput,
+        NumpyInputAdapter: QwakInput,
+        MultiInputAdapter: MultiFormatInput,
+        TfTensorInputAdapter: TfTensorInput,
+        ImageInputAdapter: ImageInput,
+        FileInputAdapter: FileInput,
+    }
+
+    if adapter:
+        adapter.mappings = mapping
+        for qwak_impl, runtime_impl in mapping.items():
+            if isinstance(adapter, qwak_impl):
+                if isinstance(adapter, DataFrameInputAdapter) and hasattr(
+                    adapter, "input_orient"
+                ):
+                    return runtime_impl(input_orient=adapter.input_orient)
+                return runtime_impl()
+
+    return DataframeInput()

frogml/model/tools/adapters/input_adapters/base_input.py

@@ -0,0 +1,21 @@
+from typing import Any
+
+
+class BaseInputAdapter:
+    """
+    BaseInputAdapter is an abstraction layer between user defined API callback function
+    and prediction request input in a variety of different forms.
+    """
+
+    def __init__(self, **kwargs):
+        """
+        BaseInputAdapter constructor - accept all keyword arguments as configuration (only in runtime)
+        :param kwargs:
+        """
+        pass
+
+    def extract_user_func_args(self, data: Any) -> Any:
+        """
+        Extract args that user API function is expecting from Inference
+        """
+        raise NotImplementedError()

frogml/model/tools/adapters/input_adapters/dataframe_input.py

@@ -0,0 +1,48 @@
+import json
+from typing import List, Optional, Union
+
+from frogml.exceptions import FrogmlHTTPException
+
+from .string_input import StringInput
+
+try:
+    import pandas
+    from bentoml.adapters import DataframeInput as BentoMLDataframeInput
+except ImportError:
+    pass
+
+
+class DataframeInput(StringInput):
+    def __init__(
+        self,
+        input_orient: Optional[str] = None,
+        **base_kwargs,
+    ):
+        self.input_orient = input_orient
+        super().__init__(**base_kwargs)
+
+        # Verify pandas imported properly and retry import if it has failed initially
+        try:
+            import pandas  # noqa: F401
+        except ImportError:
+            raise ImportError("Pandas package is required to use DataframeInput.")
+
+    def extract_user_func_args(
+        self,
+        data: Union[
+            str, List
+        ],  # it's a list of InferenceTasks, but we don't want to fail when bentoml is not installed
+    ) -> "pandas.DataFrame":
+        try:
+            if isinstance(data, list):
+                adapter = BentoMLDataframeInput(orient=self.input_orient)
+                # because parsing is deferred to bentoml, it will also set the batch property of a task
+                (df,) = adapter.extract_user_func_args(data)
+                return df
+            else:
+                return pandas.DataFrame.from_dict(json.loads(data), orient="columns")
+        except Exception as e:
+            raise FrogmlHTTPException(
+                status_code=400,
+                message=f"Error loading DataFrame input: {e}.",
+            )

frogml/model/tools/adapters/input_adapters/file_input.py

@@ -0,0 +1,8 @@
+from typing import Any
+
+from .base_input import BaseInputAdapter
+
+
+class FileInput(BaseInputAdapter):
+    def extract_user_func_args(self, data: Any) -> Any:
+        return data

frogml/model/tools/adapters/input_adapters/image_input.py

@@ -0,0 +1,45 @@
+import os
+from typing import BinaryIO
+
+from frogml.exceptions import FrogmlHTTPException
+
+from .file_input import FileInput
+
+
+class ImageInput(FileInput):
+    def __init__(
+        self,
+        **base_kwargs,
+    ):
+        try:
+            import imageio  # noqa: F401
+        except ImportError:
+            raise ImportError("imageio package is required to use ImageInput adapter")
+
+        super().__init__(**base_kwargs)
+        self.accept_image_formats = {".jpg", ".png", ".jpeg", ".tiff", ".webp", ".bmp"}
+
+    def extract_user_func_args(self, data: BinaryIO) -> "numpy.ndarray":  # noqa F821
+        try:
+            import imageio
+        except ImportError:
+            raise ImportError("imageio package is required to use ImageInput adapter")
+
+        if getattr(data, "name", None) and not self.check_file_extension(
+            data.name, self.accept_image_formats
+        ):
+            raise FrogmlHTTPException(
+                400,
+                message=f"Current service only accepts {self.accept_image_formats} formats",
+            )
+        try:
+            return imageio.v2.imread(data, mode="RGB")
+        except ValueError as e:
+            raise FrogmlHTTPException(400, message=str(e))
+
+    @staticmethod
+    def check_file_extension(file_name, supported_types):
+        if not file_name:
+            return False
+        _, extension = os.path.splitext(file_name)
+        return extension.lower() in (supported_types or [])