frogml-core 0.0.115__py3-none-any.whl → 0.0.117__py3-none-any.whl

frogml_core/model/model_version_tracking.py

@@ -1,57 +0,0 @@
-from typing import Dict, Union
-
-from frogml_core.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_core/model/schema.py

@@ -1,52 +0,0 @@
-from dataclasses import dataclass
-from typing import List
-
-from frogml_proto.qwak.build.v1.build_pb2 import ModelSchema as ProtoModelSchema
-from frogml_core.model._entity_extraction import enrich_schema
-from frogml_core.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_core/model/schema_entities.py

@@ -1,107 +0,0 @@
-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_core/model/tools/__init__.py

@@ -1,24 +0,0 @@
-from frogml_core.inner.runtime_di import ContainerLock, FrogmlRuntimeContainer
-
-from .run_model_locally import run_local
-
-
-def wire_runtime_with_run_local():
-    container = FrogmlRuntimeContainer()
-    from frogml_core.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_core/model/tools/adapters/input.py

@@ -1,66 +0,0 @@
-from typing import Any, Union
-
-from frogml_core.exceptions import FrogmlHTTPException
-from frogml_core.model.adapters import (
-    DataFrameInputAdapter,
-    FileInputAdapter,
-    ImageInputAdapter,
-    JsonInputAdapter,
-    MultiInputAdapter,
-    NumpyInputAdapter,
-    ProtoInputAdapter,
-    StringInputAdapter,
-    TfTensorInputAdapter,
-)
-from frogml_core.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 FrogMLInput(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(FrogMLInput):
-        pass
-
-    mapping = {
-        JsonInputAdapter: JsonInput,
-        DataFrameInputAdapter: DataframeInput,
-        StringInputAdapter: StringInput,
-        ProtoInputAdapter: FrogMLInput,
-        NumpyInputAdapter: FrogMLInput,
-        MultiInputAdapter: MultiFormatInput,
-        TfTensorInputAdapter: TfTensorInput,
-        ImageInputAdapter: ImageInput,
-        FileInputAdapter: FileInput,
-    }
-
-    if adapter:
-        adapter.mappings = mapping
-        for frogml_impl, runtime_impl in mapping.items():
-            if isinstance(adapter, frogml_impl):
-                if isinstance(adapter, DataFrameInputAdapter) and hasattr(
-                    adapter, "input_orient"
-                ):
-                    return runtime_impl(input_orient=adapter.input_orient)
-                return runtime_impl()
-
-    return DataframeInput()

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

@@ -1,48 +0,0 @@
-import json
-from typing import List, Optional, Union
-
-from frogml_core.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_core/model/tools/adapters/input_adapters/image_input.py

@@ -1,45 +0,0 @@
-import os
-from typing import BinaryIO
-
-from frogml_core.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 [])

frogml_core/model/tools/adapters/input_adapters/json_input.py

@@ -1,20 +0,0 @@
-import json
-import traceback
-from typing import Dict, List, Union
-
-from frogml_core.exceptions import FrogmlHTTPException
-
-from .string_input import StringInput
-
-
-class JsonInput(StringInput):
-    def extract_user_func_args(
-        self, data: str
-    ) -> Union[bool, None, Dict, List, int, float, str]:
-        try:
-            return json.loads(data)
-        except json.JSONDecodeError:
-            raise FrogmlHTTPException(400, message="Not a valid JSON format")
-        except Exception:
-            err = traceback.format_exc()
-            raise FrogmlHTTPException(500, message=f"Internal Server Error: {err}")

frogml_core/model/tools/adapters/input_adapters/tf_tensor_input.py

@@ -1,44 +0,0 @@
-import base64
-import json
-import traceback
-
-from frogml_core.exceptions import FrogmlHTTPException
-from frogml_core.model.tools.adapters.encoders import TF_B64_KEY
-
-from .string_input import StringInput
-
-
-def b64_hook(o):
-    if isinstance(o, dict) and TF_B64_KEY in o:
-        return base64.b64decode(o[TF_B64_KEY])
-    return o
-
-
-class TfTensorInput(StringInput):
-    def extract_user_func_args(self, data: str) -> "tensorflow.Tensor":  # noqa F401
-        try:
-            import tensorflow as tf
-        except ImportError:
-            raise ImportError(
-                "tensorflow package is required to use TfTensorInput adapter"
-            )
-
-        try:
-            parsed_json = json.loads(data, object_hook=b64_hook)
-            if parsed_json.get("instances") is None:
-                raise FrogmlHTTPException(
-                    status_code=400,
-                    message="input format is not implemented",
-                )
-            else:
-                instances = parsed_json.get("instances")
-                return tf.constant(instances)
-        except json.JSONDecodeError:
-            raise FrogmlHTTPException(
-                status_code=400, message="Not a valid JSON format"
-            )
-        except Exception:
-            err = traceback.format_exc()
-            raise FrogmlHTTPException(
-                status_code=500, message=f"Internal Server Error: {err}"
-            )

frogml_core/model/tools/adapters/output.py

@@ -1,75 +0,0 @@
-from typing import Any
-
-from frogml_core.exceptions import FrogmlException, FrogmlHTTPException
-from frogml_core.model.adapters import (
-    AutodetectOutputAdapter,
-    DataFrameOutputAdapter,
-    DefaultOutputAdapter,
-    JsonOutputAdapter,
-    NumpyOutputAdapter,
-    ProtoOutputAdapter,
-    TfTensorOutputAdapter,
-)
-from frogml_core.model.base import BaseModel
-
-from .output_adapters.dataframe_output import DataFrameOutput
-from .output_adapters.default_output import DefaultOutput
-from .output_adapters.json_output import JsonOutput
-from .output_adapters.tf_tensor_output import TfTensorOutput
-
-
-def get_output_adapter(
-    model: BaseModel,
-):
-    adapter = getattr(model.predict, "_output_adapter", "")
-
-    class FrogMLOutput(JsonOutput):
-        def __init__(self, **kwargs):
-            super().__init__(**kwargs)
-
-        def pack_user_func_return_value(self, return_result: Any) -> Any:
-            try:
-                return adapter.pack_user_func_return_value(return_result)
-            except Exception as e:
-                raise FrogmlHTTPException(
-                    message=f"Failed to serialize model output. Error is: {e}. For more "
-                    f"information please check model logs.",
-                    status_code=500,
-                )
-
-    class FrogMLOutputWithDefaultFallbackOutput(FrogMLOutput):
-        def __init__(self, **kwargs):
-            super().__init__(**kwargs)
-
-        def pack_user_func_return_value(self, return_result: Any) -> Any:
-            from google.protobuf.message import Message
-
-            first_result = (
-                return_result[0]
-                if isinstance(return_result, list) and len(return_result) > 0
-                else return_result
-            )
-            if issubclass(type(first_result), Message):
-                response = FrogMLOutput().pack_user_func_return_value(return_result)
-                return response
-            else:
-                return DefaultOutput().pack_user_func_return_value(return_result)
-
-    mapping = {
-        JsonOutputAdapter: JsonOutput,
-        DataFrameOutputAdapter: DataFrameOutput,
-        DefaultOutputAdapter: DefaultOutput,
-        AutodetectOutputAdapter: FrogMLOutputWithDefaultFallbackOutput,
-        ProtoOutputAdapter: FrogMLOutput,
-        NumpyOutputAdapter: FrogMLOutput,
-        TfTensorOutputAdapter: TfTensorOutput,
-    }
-    for frogml_impl, runtime_impl in mapping.items():
-        if isinstance(adapter, frogml_impl):
-            if isinstance(adapter, DataFrameOutputAdapter) and hasattr(
-                adapter, "output_orient"
-            ):
-                return runtime_impl(output_orient=adapter.output_orient)
-            return runtime_impl()
-
-    raise FrogmlException("No Adapter selected for output")

frogml_core/model/tools/adapters/output_adapters/dataframe_output.py

@@ -1,30 +0,0 @@
-import json
-
-from frogml_core.exceptions import FrogmlHTTPException
-
-from .json_output import JsonOutput
-
-
-def df_to_json(result, output_orient: str):
-    import pandas as pd
-
-    if isinstance(result, pd.DataFrame):
-        return result.to_json(orient=output_orient)
-
-    if isinstance(result, pd.Series):
-        return pd.DataFrame(result).to_json(orient=output_orient)
-    return json.dumps(result)
-
-
-class DataFrameOutput(JsonOutput):
-    def __init__(self, output_orient: str = "records"):
-        self.output_orient = output_orient
-
-    def pack_user_func_return_value(
-        self,
-        return_result,
-    ) -> str:
-        try:
-            return df_to_json(return_result, self.output_orient)
-        except Exception as e:
-            raise FrogmlHTTPException(message=str(e), status_code=500)

frogml_core/model/tools/adapters/output_adapters/json_output.py

@@ -1,17 +0,0 @@
-import json
-from typing import Any
-
-from frogml_core.exceptions import FrogmlHTTPException
-from frogml_core.model.tools.adapters.encoders import NumpyJsonEncoder
-
-from .base_output import BaseOutputAdapter
-
-
-class JsonOutput(BaseOutputAdapter):
-    def pack_user_func_return_value(self, return_result: Any) -> str:
-        try:
-            return json.dumps(return_result, cls=NumpyJsonEncoder, ensure_ascii=False)
-        except AssertionError as e:
-            FrogmlHTTPException(400, message=str(e))
-        except Exception as e:
-            FrogmlHTTPException(500, message=str(e))

frogml_core/model/tools/adapters/output_adapters/tf_tensor_output.py

@@ -1,41 +0,0 @@
-import json
-
-from frogml_core.exceptions import FrogmlHTTPException
-from frogml_core.model.tools.adapters.encoders import TfTensorJsonEncoder
-
-from .json_output import JsonOutput
-
-
-def tf_to_numpy(tensor):
-    """
-    Tensor -> ndarray
-    List[Tensor] -> tuple[ndarray]
-    """
-    try:
-        import numpy as np  # noqa F401
-        import tensorflow as tf
-    except ImportError:
-        raise ImportError(
-            "Tensorflow and numpy packages are required to use TfTensorOutput"
-        )
-
-    if isinstance(tensor, (list, tuple)):
-        return tuple(tf_to_numpy(t) for t in tensor)
-
-    if tf.__version__.startswith("1."):
-        with tf.compat.v1.Session():
-            return tensor.numpy()
-    else:
-        return tensor.numpy()
-
-
-class TfTensorOutput(JsonOutput):
-    def pack_user_func_return_value(
-        self,
-        return_result,
-    ) -> str:
-        result = tf_to_numpy(return_result)
-        try:
-            return json.dumps(result, cls=TfTensorJsonEncoder)
-        except Exception as e:
-            raise FrogmlHTTPException(message=str(e), status_code=500)