frogml 1.2.49__py3-none-any.whl → 2.0.0__py3-none-any.whl

frogml/core/inner/tool/grpc/grpc_try_wrapping.py

@@ -1,34 +1,32 @@
 import functools
 import inspect
+from http import HTTPStatus
 from inspect import BoundArguments, Signature
 from typing import Any, Callable, Optional
 
 import grpc
 from frogml.core.exceptions import FrogmlException
+from frogml.core.exceptions.grpc_status_mapping import grpc_to_http_status
 from frogml.storage.logging import logger
 
 
 def grpc_try_catch_wrapper(
-    exception_message: str,
-    reraise_non_grpc_error_original_exception: Optional[bool] = False,
+    error_message: str, operation: str = "FrogML Operation"
 ) -> Callable:
     """A decorator for handling exceptions in client methods.
 
     This decorator wraps a function, catching any `grpc.RpcError` or other
-    `Exception`. it re-raises them as a `FrogmlException`. The error message can be a
-    static string or a template formatted with the decorated function's
-    runtime arguments.
+    `Exception` and re-raises them as a `FrogmlException` with consistent formatting.
 
     Parameters
     ----------
-    exception_message : str
+    error_message : str
         The error message template. This can be a static string or a format
         string using placeholders that match the decorated function's
         parameter names (e.g., "Failed on item {item_id}").
-    reraise_non_grpc_error_original_exception : bool, optional
-        If `True`, any exception that is *not* a `grpc.RpcError` will be
-        re-raised in its original form. If `False` (the default), all
-        exceptions are wrapped in `FrogmlException`.
+    operation : str, optional
+        The operation name for error display (e.g., "Delete Model").
+        Defaults to "FrogML Operation".
 
     Returns
     -------
@@ -38,40 +36,16 @@ def grpc_try_catch_wrapper(
     Raises
     ------
     FrogmlException
-        Raised when the decorated function encounters any exception, unless
-        `reraise_non_grpc_error_original_exception` is `True` and the error
-        is not a `grpc.RpcError`. The new exception's message is formatted
-        and includes details from the original error.
-    Exception
-        The original non-gRPC exception is re-raised if
-        `reraise_non_grpc_error_original_exception` is set to `True`.
+        Raised when the decorated function encounters any exception.
 
     Usage
     -----
-    The decorator can be used with static strings and formatted strings
-
-    **1. Formatted Error Messages**
-
-    Use placeholders matching the function's parameter names to create
-    context-specific error messages.
-
-        @grpc_try_catch_wrapper("Failed to delete version {version_number} for FeatureSet {featureset_name}")
+        @grpc_try_catch_wrapper(
+            error_message="Failed to delete version {version_number} for FeatureSet {featureset_name}",
+            operation="Delete FeatureSet Version"
+        )
         def delete_featureset_version(self, featureset_name: str, version_number: int):
             # ... gRPC call ...
-
-    If this function fails with a gRPC error, a `FrogmlException` is raised with a message like:
-    `"Failed to delete version 2 for FeatureSet customer_churn - <original gRPC error code> - <original gRPC error details>."`
-
-    **2. Static Error Messages**
-
-    When no dynamic context is needed, a simple string is sufficient.
-
-        @grpc_try_catch_wrapper("Failed to retrieve featuresets mapping")
-        def get_featuresets_mapping(self):
-            # ... gRPC call ...
-
-    If this fails, the `FrogmlException` message will be:
-    `"Failed to retrieve featuresets mapping - <original gRPC error code> - <original gRPC error details>."`
     """
 
     def decorator(function: Callable):
@@ -79,51 +53,56 @@ def grpc_try_catch_wrapper(
         def _inner_wrapper(*args, **kwargs):
             try:
                 return function(*args, **kwargs)
-            except grpc.RpcError as e:
-                error_message: str = __get_error_msg(
-                    exception_message=exception_message, e=e
-                )
-
-                formatted_message: str = __get_formatted_error_message(
-                    exception_message=error_message,
-                    function=function,
-                    args=args,
-                    kwargs=kwargs,
-                )
-
-                raise FrogmlException(formatted_message) from e
-
             except Exception as e:
-                if reraise_non_grpc_error_original_exception:
-                    raise e
-
-                formatted_message = __get_formatted_error_message(
-                    exception_message=exception_message,
-                    function=function,
-                    args=args,
-                    kwargs=kwargs,
-                )
-                raise FrogmlException(f"{formatted_message}. Error is: {e}.") from e
+                raise _build_exception(
+                    e, error_message, operation, function, args, kwargs
+                ) from e
 
         return _inner_wrapper
 
     return decorator
 
 
-def __get_error_msg(exception_message: str, e: grpc.RpcError) -> str:
-    err_msg: str = (
-        f"{exception_message} - {e.code() if hasattr(e, 'code') else 'UNKNOWN'}"
+def _build_exception(
+    e: Exception,
+    error_message: str,
+    operation: str,
+    function: Callable,
+    args: tuple,
+    kwargs: dict,
+) -> FrogmlException:
+    """Build a FrogmlException from the caught exception."""
+    if isinstance(e, grpc.RpcError):
+        message: str = __get_error_msg(error_message, e)
+        grpc_code: Optional[grpc.StatusCode] = e.code() if hasattr(e, "code") else None
+        status_code: int = grpc_to_http_status(grpc_code)
+    else:
+        exception_type: str = type(e).__name__  # e.g., "ValueError", "TypeError"
+        message = f"{error_message}: {exception_type}: {e}"
+        status_code = HTTPStatus.INTERNAL_SERVER_ERROR
+
+    formatted_message: str = __get_formatted_error_message(
+        message, function, args, kwargs
+    )
+    return FrogmlException(
+        error_message=formatted_message,
+        status_code=status_code,
+        operation=operation,
     )
+
+
+def __get_error_msg(error_message: str, e: grpc.RpcError) -> str:
+    err_msg: str = error_message
     if hasattr(e, "details") and e.details() is not None:
-        err_msg: str = f"{err_msg} - {e.details()}"
+        err_msg = f"{err_msg}: {e.details()}"
     elif hasattr(e, "debug_error_string"):
-        err_msg: str = f"{err_msg} - {e.debug_error_string()}"
+        err_msg = f"{err_msg}: {e.debug_error_string()}"
     logger.debug(f"{err_msg}: {e}")
     return err_msg
 
 
 def __get_formatted_error_message(
-    exception_message: str, function: Callable, args: tuple[Any], kwargs: dict[str, Any]
+    error_message: str, function: Callable, args: tuple[Any], kwargs: dict[str, Any]
 ) -> str:
     """Formats an error message string with the runtime arguments of a function.
 
@@ -131,7 +110,7 @@ def __get_formatted_error_message(
     to their parameter names, then uses them to format the message string.
 
     Args:
-        exception_message (str): The error message template with placeholders.
+        error_message (str): The error message template with placeholders.
         function (Callable): The decorated function.
         args (tuple[Any]): The positional arguments passed to the function.
         kwargs (dict[str, Any]): The keyword arguments passed to the function.
@@ -144,7 +123,7 @@ def __get_formatted_error_message(
         bound_args: BoundArguments = sig.bind(*args, **kwargs)
         bound_args.apply_defaults()
 
-        return exception_message.format(**bound_args.arguments)
+        return error_message.format(**bound_args.arguments)
     except (ValueError, KeyError, TypeError):
         # Fallback if formatting fails (e.g., missing key in template)
-        return exception_message
+        return error_message

frogml/core/inner/tool/protobuf_factory.py

@@ -1,4 +1,5 @@
 from frogml.core.exceptions import FrogmlException
+from http import HTTPStatus
 
 
 def protobuf_factory(
@@ -12,13 +13,18 @@ def protobuf_factory(
         unrecognized_fields = included_fields.difference(all_field_names)
         if unrecognized_fields:
             raise FrogmlException(
-                f"Unknown fields were included: {list(unrecognized_fields)}"
+                error_message=f"Unknown fields were included: {list(unrecognized_fields)}",
+                operation="Convert to Protobuf",
             )
         return included_fields.difference(excluded_fields)
 
     def protofy_decorator(cls):
         if not hasattr(cls, "__dataclass_fields__"):
-            raise FrogmlException("Protofy must receive a dataclass")
+            raise FrogmlException(
+                error_message="Protofy must receive a dataclass",
+                status_code=HTTPStatus.BAD_REQUEST,
+                operation="Convert to Protobuf",
+            )
 
         fields_mapping = mapping if mapping else {}
         final_field_names = get_final_field_names(cls)

frogml/sdk/frogml_client/client.py

@@ -3,6 +3,7 @@ from functools import lru_cache
 from pathlib import Path
 from tempfile import TemporaryDirectory
 from typing import TYPE_CHECKING, Dict, List, Optional, Union, Iterable
+from http import HTTPStatus
 
 import requests
 from requests import Response
@@ -146,12 +147,14 @@ class FrogMLClient:
              str: The build ID of the latest build according to the build status. None if no builds match the filter.
 
         """
-        if (
-            build_status
-            not in DESCRIPTOR.enum_types_by_name["BuildStatus"].values_by_name
-        ):
+        valid_statuses = set(
+            DESCRIPTOR.enum_types_by_name["BuildStatus"].values_by_name.keys()
+        )
+        if build_status not in valid_statuses:
             raise FrogmlException(
-                f"Invalid build status {build_status}. Valid options are 'SUCCESSFUL', 'IN_PROGRESS', 'FAILED'"
+                error_message=f"Invalid build status '{build_status}'. Valid options are: {valid_statuses}",
+                status_code=HTTPStatus.BAD_REQUEST,
+                operation="Get Latest Build",
             )
 
         model = self._get_model_management().get_model(model_id=model_id)
@@ -601,7 +604,9 @@ class FrogMLClient:
             import pandas as pd
         except ImportError:
             raise FrogmlException(
-                "Missing Pandas dependency required for running an analytics query."
+                error_message="Missing Pandas dependency required for running an analytics query",
+                status_code=HTTPStatus.BAD_REQUEST,
+                operation="Run Analytics Query",
             )
         client = self._get_analytics_engine()
         url = client.get_analytics_data(query=query, timeout=timeout)
@@ -640,7 +645,11 @@ class FrogMLClient:
                 feature_set_def.feature_set.feature_set_definition.feature_set_id
             )
         else:
-            raise FrogmlException(f"Feature set named '{feature_set_name}' not found")
+            raise FrogmlException(
+                error_message=f"Feature set '{feature_set_name}' not found",
+                status_code=HTTPStatus.NOT_FOUND,
+                operation="Delete Feature Set",
+            )
 
     def delete_featureset_version(self, featureset_name: str, version_number: int):
         """
@@ -686,7 +695,11 @@ class FrogMLClient:
                 data_source_def.data_source.data_source_definition.data_source_id
             )
         else:
-            raise FrogmlException(f"Data source named '{data_source_name}' not found")
+            raise FrogmlException(
+                error_message=f"Data source '{data_source_name}' not found",
+                status_code=HTTPStatus.NOT_FOUND,
+                operation="Delete Feature Store Data Source",
+            )
 
     def delete_entity(self, entity_name: str):
         """
@@ -700,7 +713,11 @@ class FrogMLClient:
         if entity_def:
             client.delete_entity(entity_def.entity.entity_definition.entity_id)
         else:
-            raise FrogmlException(f"Entity named '{entity_name}' not found")
+            raise FrogmlException(
+                error_message=f"Entity '{entity_name}' not found",
+                status_code=HTTPStatus.NOT_FOUND,
+                operation="Delete Feature Store Entity",
+            )
 
     def trigger_batch_feature_set(self, feature_set_name):
         """
@@ -723,7 +740,9 @@ class FrogMLClient:
         automation = client.get_automation_by_name(automation_name=automation_name)
         if not automation:
             raise FrogmlException(
-                f"Could not find automation with given name '{automation_name}'"
+                error_message=f"Could not find automation with given name '{automation_name}'",
+                status_code=HTTPStatus.NOT_FOUND,
+                operation="Trigger Automation",
             )
         client.run_automation(automation_id=automation.id)
 

frogml/sdk/model/adapters/input_adapters/numpy_input_adapter.py

@@ -1,5 +1,6 @@
 import json
 import typing as t
+from http import HTTPStatus
 
 from frogml.core.exceptions import FrogmlException
 
@@ -47,7 +48,11 @@ class NumpyInputAdapter(BaseInputAdapter):
             try:
                 dtype = np.dtype(dtype)
             except TypeError as e:
-                raise FrogmlException(f'NumpyNdarray: Invalid dtype "{dtype}": {e}')
+                raise FrogmlException(
+                    error_message=f'NumpyNdarray: Invalid dtype "{dtype}": {e}',
+                    status_code=HTTPStatus.BAD_REQUEST,
+                    operation="Initialize Model Input Adapter",
+                )
 
         self._dtype = dtype
         self._shape = shape

frogml/sdk/model/adapters/output_adapters/numpy_output_adapter.py

@@ -1,4 +1,5 @@
 import io
+from http import HTTPStatus
 
 from frogml.core.exceptions import FrogmlException
 
@@ -21,7 +22,9 @@ class NumpyOutputAdapter(BaseOutputAdapter):
     def pack_user_func_return_value(return_result) -> bytes:
         if not isinstance(return_result, np.ndarray):
             raise FrogmlException(
-                "XNpyOutputAdapter can only work with numpy.ndarray type"
+                error_message="NumpyOutputAdapter can only work with numpy.ndarray type",
+                status_code=HTTPStatus.BAD_REQUEST,
+                operation="Pack Model Output",
             )
         try:
             results_buffer = io.BytesIO()

frogml/sdk/model/decorators/api.py

@@ -1,4 +1,5 @@
 from typing import Callable
+from http import HTTPStatus
 
 from dependency_injector.wiring import Provide, inject
 
@@ -63,4 +64,8 @@ def api_decorator(
         )
     except TypeError as e:
         if "__call__() takes 1" in str(e):
-            raise FrogmlException(API_NOT_CONFIGURED_ERROR_MESSAGE)
+            raise FrogmlException(
+                error_message=API_NOT_CONFIGURED_ERROR_MESSAGE,
+                status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
+                operation="Configure API",
+            )

frogml/sdk/model/tools/adapters/output.py

@@ -1,4 +1,5 @@
 from typing import Any
+from http import HTTPStatus
 
 from frogml.core.exceptions import FrogmlException, FrogmlHTTPException
 from frogml.sdk.model.adapters import (
@@ -71,5 +72,8 @@ def get_output_adapter(
             ):
                 return runtime_impl(output_orient=adapter.output_orient)
             return runtime_impl()
-
-    raise FrogmlException("No Adapter selected for output")
+    raise FrogmlException(
+        error_message="No output adapter selected",
+        status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
+        operation="Get Output Adapter",
+    )

frogml/sdk/model_version/catboost/__init__.py

@@ -113,4 +113,7 @@ def load_model(repository: str, model_name: str, version: str):
             logging.error(
                 f"Failed to load Model. Model was serialized with Catboost version: {framework_runtime_version}"
             )
-            raise FrogmlException(f"Failed to deserialized model: {e}")
+            raise FrogmlException(
+                error_message=f"Failed to deserialize model: {e}",
+                operation="Load Model Version",
+            )

frogml/sdk/model_version/huggingface/__init__.py

@@ -214,4 +214,7 @@ def load_model(repository: str, model_name: str, version: str):
             logging.error(
                 f"Failed to load Model. Model was serialized with transformers using DistilBert version: {framework_runtime_version}"
             )
-            raise FrogmlException(f"Failed to deserialized model: {e}")
+            raise FrogmlException(
+                error_message=f"Failed to deserialize model: {e}",
+                operation="Load Model Version",
+            )

frogml/sdk/model_version/model_loggers/catboost_model_version_manager.py

@@ -28,7 +28,10 @@ class CatboostModelVersionManager(BaseModelVersionManager):
 
             return catboost.__version__
         except Exception as e:
-            raise FrogmlException(f"Failed to get catboost version: {e}")
+            raise FrogmlException(
+                error_message=f"Failed to get catboost version: {e}",
+                operation="Get Model Version Framework Version",
+            )
 
     @override
     def _save_model(self: Self, model: Any, config: ModelLogConfig):

frogml/sdk/model_version/model_loggers/huggingface_model_version_manager.py

@@ -1,3 +1,4 @@
+from http import HTTPStatus
 from typing import Any
 
 from typing_extensions import Self, override
@@ -31,12 +32,19 @@ class HuggingfaceModelVersionManager(BaseModelVersionManager):
 
             return transformers.__version__
         except Exception as e:
-            raise FrogmlException(f"Failed to get transformers version: {e}")
+            raise FrogmlException(
+                error_message=f"Failed to get transformers version: {e}",
+                operation="Get Model Version Framework Version",
+            )
 
     @override
     def _save_model(self: Self, model: Any, config: ModelLogConfig):
         if not isinstance(model, tuple):
-            raise FrogmlException("Model must be a tuple containing (model, tokenizer)")
+            raise FrogmlException(
+                error_message="Model must be a tuple containing (model, tokenizer)",
+                status_code=HTTPStatus.BAD_REQUEST,
+                operation="Save Model Version",
+            )
 
         model_obj, tokenizer = model  # Assuming model is a tuple of (model, tokenizer)
         model_obj.save_pretrained(config.full_model_path)

frogml/sdk/model_version/model_loggers/onnx_model_version_manager.py

@@ -28,7 +28,10 @@ class OnnxModelVersionManager(BaseModelVersionManager):
 
             return onnx.__version__
         except Exception as e:
-            raise FrogmlException(f"Failed to get onnx version: {e}")
+            raise FrogmlException(
+                error_message=f"Failed to get onnx version: {e}",
+                operation="Get Model Version Framework Version",
+            )
 
     @override
     def _save_model(self: Self, model: Any, config: ModelLogConfig):

frogml/sdk/model_version/model_loggers/pytorch_model_version_manager.py

@@ -28,7 +28,10 @@ class PytorchModelVersionManager(BaseModelVersionManager):
 
             return torch.__version__
         except Exception as e:
-            raise FrogmlException(f"Failed to get torch version: {e}")
+            raise FrogmlException(
+                error_message=f"Failed to get torch version: {e}",
+                operation="Get Model Version Framework Version",
+            )
 
     @override
     def _save_model(self: Self, model: Any, config: ModelLogConfig):

frogml/sdk/model_version/model_loggers/scikit_learn_model_version_manager.py

@@ -32,7 +32,10 @@ class ScikitLearnModelVersionManager(BaseModelVersionManager):
 
             return sklearn.__version__
         except Exception as e:
-            raise FrogmlException(f"Failed to get sklearn version: {e}")
+            raise FrogmlException(
+                error_message=f"Failed to get sklearn version: {e}",
+                operation="Get Model Version Framework Version",
+            )
 
     @override
     def _save_model(self: Self, model: Any, config: ModelLogConfig):

frogml/sdk/model_version/onnx/__init__.py

@@ -121,4 +121,7 @@ def load_model(repository: str, model_name: str, version: str):
             logging.error(
                 f"Failed to load Model. Model was serialized with onnx version: {framework_runtime_version}"
             )
-            raise FrogmlException(f"Failed to deserialized model: {e}")
+            raise FrogmlException(
+                error_message=f"Failed to deserialize model: {e}",
+                operation="Load Model Version",
+            )

frogml/sdk/model_version/pytorch/__init__.py

@@ -113,4 +113,7 @@ def load_model(repository: str, model_name: str, version: str):
             logging.error(
                 f"Failed to load Model. Model was serialized with Pytorch version: {framework_runtime_version}"
             )
-            raise FrogmlException(f"Failed to deserialized model: {e}")
+            raise FrogmlException(
+                error_message=f"Failed to deserialize model: {e}",
+                operation="Load Model Version",
+            )

frogml/sdk/model_version/scikit_learn/__init__.py

@@ -126,4 +126,7 @@ def load_model(repository: str, model_name: str, version: str):
             logging.error(
                 f"Failed to load Model. Model was serialized with scikit-learn version: {framework_runtime_version}"
             )
-            raise FrogmlException(f"Failed to deserialized model: {e}")
+            raise FrogmlException(
+                error_message=f"Failed to deserialize model: {e}",
+                operation="Load Model Version",
+            )

frogml/sdk/model_version/utils/jml/customer_client.py

@@ -130,6 +130,6 @@ class JmlCustomerClient:
                 "Failed to create model version %s in JFML due to this following error: '%s'\n\n"
                 "Before retrying, please delete the uploaded artifact from Artifactory",
                 model_version_name,
-                e.message,
+                e.error_message,
             )
             raise e

frogml/sdk/model_version/utils/storage.py

@@ -214,7 +214,10 @@ def build_zip_code_path(
             root_dir=parent_dir_path, dir_to_zip=filtered_copied_dir_path
         )
     except Exception as e:
-        raise FrogmlException(f"Failed to zip code directory: {e}") from e
+        raise FrogmlException(
+            error_message=f"Failed to zip code directory: {e}",
+            operation="Prepare Model Version Code Package",
+        ) from e
     finally:
         _remove_dir(filtered_copied_dir_path)
         _remove_dir(template_file_dir)

frogml/sdk/model_version/utils/validations.py

@@ -1,3 +1,5 @@
+from http import HTTPStatus
+
 from frogml.core.exceptions import FrogmlException
 from frogml.sdk.model_version.constants import ModelFramework
 
@@ -9,7 +11,11 @@ def _validate_string(s: str) -> None:
     :return: None if validation pass successfully else raise error
     """
     if not s:
-        raise FrogmlException("String is empty")
+        raise FrogmlException(
+            error_message="String cannot be empty",
+            status_code=HTTPStatus.BAD_REQUEST,
+            operation="Validate Model Version Input",
+        )
 
 
 def _validate_load_model(
@@ -35,5 +41,7 @@ def _validate_load_model(
     _validate_string(version)
     if model_framework_stored != model_framework.value:
         raise FrogmlException(
-            f"The Model: {model_name} in Repository: {repository} - is not a {model_framework} model"
+            error_message=f"Model '{model_name}' in repository '{repository}' is not a {model_framework} model",
+            status_code=HTTPStatus.BAD_REQUEST,
+            operation="Load Model Version",
         )

{frogml-1.2.49.dist-info → frogml-2.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: frogml
-Version: 1.2.49
+Version: 2.0.0
 Summary: frogml contains the necessary objects and communication tools for using the JFrog ml Platform
 License: Apache-2.0
 Keywords: mlops,ml,deployment,serving,model