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

frogml/core/exceptions/frogml_exception.py

@@ -1,7 +1,37 @@
-from .quiet_error import QuietError
+from http import HTTPStatus
 
 
-class FrogmlException(QuietError):
-    def __init__(self, message, status_code=None):
-        self.message = message
-        self.status_code = status_code
+class FrogmlException(Exception):
+    """
+    Base exception for FrogML SDK errors.
+
+    Displays errors in JF CLI format without tracebacks:
+        Error: {operation}
+        -----------------------------
+        Status:  {status_code} {status_phrase}
+        Message: {error_message}
+    """
+
+    def __init__(
+        self,
+        error_message: str,
+        status_code: int = HTTPStatus.INTERNAL_SERVER_ERROR,
+        operation: str = "FrogML Operation",
+    ) -> None:
+        super().__init__(error_message)
+        self.error_message: str = error_message
+        self.status_code: int = status_code
+        self.operation: str = operation
+
+    def __str__(self) -> str:
+        try:
+            status_text = f"{self.status_code} {HTTPStatus(self.status_code).phrase}"
+        except ValueError:
+            status_text = str(self.status_code)
+        lines = [
+            f"Error: {self.operation.title()} Failed",
+            "-----------------------------",
+            f"Status:  {status_text}",
+            f"Message: {self.error_message}",
+        ]
+        return "\n".join(lines)

frogml/core/exceptions/frogml_general_build_exception.py

@@ -1,13 +1,21 @@
-class FrogmlGeneralBuildException(Exception):
-    def __init__(self, message: str, src_exception: Exception = None):
-        self._message = message
-        self._exception_msg = str(src_exception) if src_exception else ""
+from http import HTTPStatus
+from typing import Optional
 
-    @property
-    def message(self) -> str:
-        msg = f"""Message: {self._message}
-Exception message: {self._exception_msg}"""
-        return msg
+from frogml.core.exceptions.frogml_exception import FrogmlException
 
-    def __str__(self):
-        return self.message
+
+class FrogmlGeneralBuildException(FrogmlException):
+    def __init__(
+        self,
+        error_message: str,
+        src_exception: Optional[Exception] = None,
+        status_code: int = HTTPStatus.INTERNAL_SERVER_ERROR,
+    ) -> None:
+        full_message: str = error_message
+        if src_exception:
+            full_message = f"{error_message}: {src_exception}"
+        super().__init__(
+            error_message=full_message,
+            status_code=status_code,
+            operation="Build",
+        )

frogml/core/exceptions/frogml_grpc_address_exception.py

@@ -1,9 +1,20 @@
-from typing import Union
-from urllib.parse import ParseResult
+from http import HTTPStatus
 
 from frogml.core.exceptions import FrogmlException
 
 
 class FrogmlGrpcAddressException(FrogmlException):
-    def __init__(self, details: str, grpc_address: Union[str, ParseResult]):
-        self.message = f"Not a valid gRPC address: '{grpc_address}'. Details: {details}"
+    """Exception for invalid gRPC address configuration."""
+
+    def __init__(
+        self,
+        details: str,
+        grpc_address: str,
+        status_code: int = HTTPStatus.BAD_REQUEST,
+        operation: str = "Configure gRPC Address",
+    ) -> None:
+        super().__init__(
+            error_message=f"Not a valid gRPC address: '{grpc_address}'. Details: {details}",
+            status_code=status_code,
+            operation=operation,
+        )

frogml/core/exceptions/frogml_http_exception.py

@@ -3,7 +3,9 @@ from typing import Dict, Optional, Union
 try:
     from bentoml.exceptions import InferenceException
 except ImportError:
-    from .frogml_mock_http_exception import MockHttpException as InferenceException
+    from frogml.core.exceptions.frogml_mock_http_exception import (
+        MockHttpException as InferenceException,
+    )
 
 
 class FrogmlHTTPException(InferenceException):

frogml/core/exceptions/frogml_login_exception.py

@@ -1,8 +1,19 @@
-from .quiet_error import QuietError
+from http import HTTPStatus
 
+from frogml.core.exceptions.frogml_exception import FrogmlException
+
+
+class FrogmlLoginException(FrogmlException):
+    """Exception for login failures."""
 
-class FrogmlLoginException(QuietError):
     def __init__(
-        self, message="Failed to login to Frogml. Please check your credentials"
-    ):
-        self.message = message
+        self,
+        error_message: str = "Failed to login to FrogML. Please check your credentials",
+        status_code: int = HTTPStatus.UNAUTHORIZED,
+        operation: str = "Login",
+    ) -> None:
+        super().__init__(
+            error_message=error_message,
+            status_code=status_code,
+            operation=operation,
+        )

frogml/core/exceptions/frogml_not_found_exception.py

@@ -1,6 +1,19 @@
-from .frogml_exception import FrogmlException
+from http import HTTPStatus
+
+from frogml.core.exceptions.frogml_exception import FrogmlException
 
 
 class FrogmlNotFoundException(FrogmlException):
-    def __init__(self, message):
-        self.message = message
+    """Exception for resource not found errors."""
+
+    def __init__(
+        self,
+        error_message: str,
+        status_code: int = HTTPStatus.NOT_FOUND,
+        operation: str = "FrogML Operation",
+    ) -> None:
+        super().__init__(
+            error_message=error_message,
+            status_code=status_code,
+            operation=operation,
+        )

frogml/core/exceptions/frogml_remote_build_failed.py

@@ -1,4 +1,4 @@
-from .frogml_suggestion_exception import FrogmlSuggestionException
+from frogml.core.exceptions.frogml_suggestion_exception import FrogmlSuggestionException
 
 
 class FrogmlRemoteBuildFailedException(FrogmlSuggestionException):

frogml/core/exceptions/frogml_token_exception.py

@@ -1,7 +1,19 @@
-from .quiet_error import QuietError
+from http import HTTPStatus
 
+from frogml.core.exceptions.frogml_exception import FrogmlException
 
-class FrogMLTokenException(QuietError):
-    def __init__(self, message: str):
-        super().__init__(message)
-        self.message: str = message
+
+class FrogMLTokenException(FrogmlException):
+    """Exception for token-related errors."""
+
+    def __init__(
+        self,
+        error_message: str,
+        status_code: int = HTTPStatus.UNAUTHORIZED,
+        operation: str = "Authenticate",
+    ) -> None:
+        super().__init__(
+            error_message=error_message,
+            status_code=status_code,
+            operation=operation,
+        )

frogml/core/exceptions/grpc_status_mapping.py

@@ -0,0 +1,43 @@
+"""Mapping between gRPC status codes and HTTP status codes."""
+
+from http import HTTPStatus
+from typing import Final, Optional
+
+import grpc
+
+# Standard gRPC to HTTP status code mapping
+# Reference: https://cloud.google.com/apis/design/errors#handling_errors
+GRPC_TO_HTTP_STATUS: Final[dict[grpc.StatusCode, int]] = {
+    grpc.StatusCode.OK: HTTPStatus.OK,
+    grpc.StatusCode.CANCELLED: 499,  # Client Closed Request (non-standard)
+    grpc.StatusCode.UNKNOWN: HTTPStatus.INTERNAL_SERVER_ERROR,
+    grpc.StatusCode.INVALID_ARGUMENT: HTTPStatus.BAD_REQUEST,
+    grpc.StatusCode.DEADLINE_EXCEEDED: HTTPStatus.GATEWAY_TIMEOUT,
+    grpc.StatusCode.NOT_FOUND: HTTPStatus.NOT_FOUND,
+    grpc.StatusCode.ALREADY_EXISTS: HTTPStatus.CONFLICT,
+    grpc.StatusCode.PERMISSION_DENIED: HTTPStatus.FORBIDDEN,
+    grpc.StatusCode.RESOURCE_EXHAUSTED: HTTPStatus.TOO_MANY_REQUESTS,
+    grpc.StatusCode.FAILED_PRECONDITION: HTTPStatus.BAD_REQUEST,
+    grpc.StatusCode.ABORTED: HTTPStatus.CONFLICT,
+    grpc.StatusCode.OUT_OF_RANGE: HTTPStatus.BAD_REQUEST,
+    grpc.StatusCode.UNIMPLEMENTED: HTTPStatus.NOT_IMPLEMENTED,
+    grpc.StatusCode.INTERNAL: HTTPStatus.INTERNAL_SERVER_ERROR,
+    grpc.StatusCode.UNAVAILABLE: HTTPStatus.SERVICE_UNAVAILABLE,
+    grpc.StatusCode.DATA_LOSS: HTTPStatus.INTERNAL_SERVER_ERROR,
+    grpc.StatusCode.UNAUTHENTICATED: HTTPStatus.UNAUTHORIZED,
+}
+
+
+def grpc_to_http_status(grpc_code: Optional[grpc.StatusCode]) -> int:
+    """
+    Convert gRPC status code to HTTP status code.
+
+    Args:
+        grpc_code: The gRPC status code to convert.
+
+    Returns:
+        The corresponding HTTP status code. Defaults to 500 if grpc_code is None or unknown.
+    """
+    if grpc_code is None:
+        return HTTPStatus.INTERNAL_SERVER_ERROR
+    return GRPC_TO_HTTP_STATUS.get(grpc_code, HTTPStatus.INTERNAL_SERVER_ERROR)

frogml/core/inner/build_logic/phases/phase_010_fetch_model/fetch_strategy_manager/strategy/git/git_strategy.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
+from http import HTTPStatus
 
 import os
 import shutil
@@ -119,7 +120,11 @@ def split_git_url_and_subdirectory(uri):
         subdirectory = uri[uri.find("#") + 1 :]
         parsed_uri = uri[: uri.find("#")]
     if subdirectory and "." in subdirectory:
-        raise FrogmlException("'.' is not allowed in project subdirectory paths.")
+        raise FrogmlException(
+            error_message="'.' is not allowed in project subdirectory paths",
+            status_code=HTTPStatus.BAD_REQUEST,
+            operation="Validate Build Git Path",
+        )
     return parsed_uri, subdirectory
 
 
@@ -148,7 +153,10 @@ def ssh_key_context(git_ssh_key: str):
             try:
                 os.remove(ssh_key_path)
             except OSError as e:
-                FrogmlException(f"Failed to delete ssh key temp key file: {e}")
+                FrogmlException(
+                    error_message=f"Failed to delete ssh key temp key file: {e}",
+                    operation="Build Cleanup",
+                )
 
 
 def make_ssh_key_file(git_ssh_key: str) -> str:

frogml/core/inner/build_logic/phases/phase_010_fetch_model/pre_fetch_validation_step.py

@@ -241,10 +241,11 @@ class PreFetchValidationStep(Step):
             )
             if not isinstance(self.config.pre_built_model, base_model_class):
                 raise FrogmlException(
-                    self.INVALID_FROGML_MODEL_MSG_FORMAT.format(
+                    error_message=self.INVALID_FROGML_MODEL_MSG_FORMAT.format(
                         expected_class=base_model_class.__name__,
                         passed_class=self.config.pre_built_model.__class__,
-                    )
+                    ),
+                    operation="Validate Model",
                 )
 
     def validate_gcp_service_account_secret(self):

frogml/core/inner/build_logic/phases/phase_020_remote_register_frogml_build/upload_step.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import re
+from http import HTTPStatus
 from pathlib import Path
 from typing import Optional
 
@@ -44,7 +45,7 @@ _MAX_FILE_SIZE_BYTES = 10000000
 
 def should_retry(frogml_exception: FrogmlException) -> bool:
     # when Got 403 from Jfrog it means that the reposity doesn't exist. It may happen when in the first build in the project
-    return "403" in str(frogml_exception.message)
+    return "403" in str(frogml_exception.error_message)
 
 
 class UploadStep(Step):
@@ -67,7 +68,9 @@ class UploadStep(Step):
         for tag, upload_info in upload_urls_response.upload_url_infos.items():
             file: Optional[Path] = files_by_tags.get(tag, None)
             if file is None:
-                raise FrogmlGeneralBuildException(f"No file found for tag {tag}")
+                raise FrogmlGeneralBuildException(
+                    error_message=f"No file found for tag {tag}"
+                )
 
             self.upload_file(
                 file=file,
@@ -111,7 +114,7 @@ class UploadStep(Step):
 
         if tags_with_no_url:
             raise FrogmlGeneralBuildException(
-                f"Missing upload url for tags: {tags_with_no_url!r}"
+                error_message=f"Missing upload url for tags: {tags_with_no_url!r}"
             )
 
         expected_keys: set[str] = set(files_by_tags.keys())
@@ -119,7 +122,7 @@ class UploadStep(Step):
 
         if expected_keys != actual_keys:
             raise FrogmlGeneralBuildException(
-                f"Mismatch between requested tags {expected_keys} and response tags {actual_keys}"
+                error_message=f"Mismatch between requested tags {expected_keys} and response tags {actual_keys}"
             )
 
         return upload_urls_response
@@ -246,7 +249,7 @@ class UploadStep(Step):
             return pre_signed_url_response
         except FrogmlException as e:
             raise FrogmlGeneralBuildException(
-                message="Unable to get pre-signed url for uploading model",
+                error_message="Unable to get pre-signed url for uploading model",
                 src_exception=e,
             )
 
@@ -272,7 +275,7 @@ class UploadStep(Step):
             )
         except Exception as e:
             raise FrogmlGeneralBuildException(
-                message="Fail uploading model to remote storage.",
+                error_message="Failed uploading model to remote storage",
                 src_exception=e,
             )
 
@@ -303,8 +306,8 @@ class UploadStep(Step):
             headers=headers,
         )
 
-        if http_response.status_code not in [200, 201]:
-            raise FrogmlException(
-                f"Status: [{http_response.status_code}], "
-                f"reason: [{http_response.reason}]"
+        if http_response.status_code not in {HTTPStatus.OK, HTTPStatus.CREATED}:
+            raise FrogmlGeneralBuildException(
+                error_message=f"Failed to upload file to remote storage: {http_response.reason}",
+                status_code=http_response.status_code,
             )

frogml/core/inner/build_logic/run_handlers/programmatic_phase_run_handler.py

@@ -1,5 +1,6 @@
 from contextlib import contextmanager
 from logging import Logger
+from http import HTTPStatus
 
 from frogml.core.exceptions import FrogmlException
 from frogml.core.inner.build_logic.build_loggers.trigger_build_logger import (
@@ -64,13 +65,17 @@ class ProgrammaticPhaseRunHandler(PhaseRunHandler):
             )
         )
         self._report_failure(build_phase, duration_in_seconds)
-        raise FrogmlException(str(ex))
+        raise FrogmlException(error_message=str(ex))
 
     def handle_keyboard_interrupt(
         self, build_id: str, build_phase: BuildPhase, duration_in_seconds: int
     ):
         self._report_failure(build_phase, duration_in_seconds)
-        raise FrogmlException("KeyboardInterrupt")
+        raise FrogmlException(
+            error_message="Build interrupted by user",
+            status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
+            operation="Run Build Phase",
+        )
 
     def handle_pipeline_exception(
         self,
@@ -80,7 +85,7 @@ class ProgrammaticPhaseRunHandler(PhaseRunHandler):
         duration_in_seconds: int,
     ):
         self._report_failure(build_phase, duration_in_seconds)
-        raise FrogmlException(str(ex))
+        raise FrogmlException(error_message=str(ex))
 
     def handle_pipeline_quiet_exception(
         self,

frogml/core/inner/build_logic/tools/files.py

@@ -185,8 +185,7 @@ def zip_model(
 
     except Exception as e:
         raise FrogmlGeneralBuildException(
-            message="Unable to zip model before upload",
-            src_exception=e,
+            error_message="Unable to zip model before upload", src_exception=e
         )
 
 

frogml/core/inner/model_loggers_utils.py

@@ -1,6 +1,7 @@
 import os
 import re
 from typing import Optional
+from http import HTTPStatus
 
 import requests
 
@@ -42,12 +43,20 @@ def validate_model(model_id: str) -> str:
     if not model_id:
         model_id = fetch_model_id()
         if not model_id:
-            raise FrogmlException("Failed to determined model ID.")
+            raise FrogmlException(
+                error_message="Failed to determine model ID",
+                status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
+                operation="Get Model ID",
+            )
 
     try:
         ModelsManagementClient().get_model(model_id=model_id)
     except Exception:
-        raise FrogmlException("Failed to find model.")
+        raise FrogmlException(
+            error_message="Failed to find model",
+            status_code=HTTPStatus.NOT_FOUND,
+            operation="Find Model",
+        )
 
     return model_id
 
@@ -80,17 +89,21 @@ def upload_data(
     """
     try:
         headers["Content-Type"] = content_type
-        http_response = requests.put(  # nosec B113
+        http_response: requests.Response = requests.put(  # nosec B113
             upload_url,
             data=data,
             headers=headers,
         )
 
-        if http_response.status_code not in [200, 201]:
+        if http_response.status_code not in {HTTPStatus.OK, HTTPStatus.CREATED}:
             raise FrogmlException(
-                f"Failed to upload data. "
-                f"Status: [{http_response.status_code}], "
-                f"reason: [{http_response.reason}]"
+                error_message=f"Failed to upload data: {http_response.reason}",
+                status_code=http_response.status_code,
+                operation="Upload Model Data",
             )
     except Exception as e:
-        raise FrogmlException(f"Failed to upload data. Error is {e}")
+        raise FrogmlException(
+            error_message=f"Failed to upload data: {e}",
+            status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
+            operation="Upload Model Data",
+        )

frogml/core/inner/tool/auth/auth_client.py

@@ -104,7 +104,7 @@ class FrogMLAuthClient:
 
         else:
             raise FrogMLTokenException(
-                message="Token not found in the authentication configurations."
+                error_message="Token not found in the authentication configurations."
             )
 
         return self.__token