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

frogml/core/clients/feature_store/management_client.py

@@ -1,3 +1,5 @@
+from typing import Any, Callable
+
 from dependency_injector.wiring import Provide
 from frogml._proto.qwak.feature_store.entities.entity_pb2 import EntitySpec
 from frogml._proto.qwak.feature_store.entities.entity_service_pb2 import (
@@ -93,7 +95,8 @@ class FeatureRegistryClient:
         )
 
     @grpc_try_catch_wrapper(
-        "Failed to get a presigned url", reraise_non_grpc_error_original_exception=True
+        error_message="Failed to get a presigned url",
+        operation="Get Feature Store Presigned URL",
     )
     def get_datasource_source_code_presign_url(
         self, ds_name: str, repository_name: str
@@ -105,7 +108,8 @@ class FeatureRegistryClient:
         )
 
     @grpc_try_catch_wrapper(
-        "Failed to list features", reraise_non_grpc_error_original_exception=True
+        error_message="Failed to list features",
+        operation="List Feature Store Feature Sets",
     )
     def list_feature_sets(self) -> ListFeatureSetsResponse:
         """
@@ -130,7 +134,8 @@ class FeatureRegistryClient:
         )
 
     @grpc_try_catch_wrapper(
-        "Failed to delete feature", reraise_non_grpc_error_original_exception=True
+        error_message="Failed to delete feature",
+        operation="Delete Feature Store Feature Set",
     )
     def delete_feature_set(self, feature_set_id: str) -> DeleteFeatureSetResponse:
         """
@@ -144,7 +149,7 @@ class FeatureRegistryClient:
         )
 
     @grpc_try_catch_wrapper(
-        "Failed to delete entity", reraise_non_grpc_error_original_exception=True
+        error_message="Failed to delete entity", operation="Delete Feature Store Entity"
     )
     def delete_entity(self, entity_id: str) -> DeleteEntityResponse:
         """
@@ -158,7 +163,8 @@ class FeatureRegistryClient:
         )
 
     @grpc_try_catch_wrapper(
-        "Failed to delete data source", reraise_non_grpc_error_original_exception=True
+        error_message="Failed to delete data source",
+        operation="Delete Feature Store Data Source",
     )
     def delete_data_source(self, data_source_id: str) -> DeleteDataSourceResponse:
         """
@@ -172,7 +178,7 @@ class FeatureRegistryClient:
         )
 
     @grpc_try_catch_wrapper(
-        "Failed to run feature", reraise_non_grpc_error_original_exception=True
+        error_message="Failed to run feature", operation="Run Feature Store Feature Set"
     )
     def run_feature_set(self, feature_set_name: str) -> RunBatchFeatureSetResponse:
         """
@@ -187,7 +193,8 @@ class FeatureRegistryClient:
         )
 
     @grpc_try_catch_wrapper(
-        "Failed to run feature", reraise_non_grpc_error_original_exception=True
+        error_message="Failed to run feature",
+        operation="Run Feature Store Parquet Batch Feature Set",
     )
     def run_parquet_batch_feature_set(
         self, feature_set_name: str, parquet_location: str, timestamp_column: str
@@ -210,7 +217,7 @@ class FeatureRegistryClient:
         )
 
     @grpc_try_catch_wrapper(
-        "Failed to update entity", reraise_non_grpc_error_original_exception=True
+        error_message="Failed to update entity", operation="Update Feature Store Entity"
     )
     def update_entity(
         self, entity_id: str, proto_entity_spec: EntitySpec
@@ -227,7 +234,7 @@ class FeatureRegistryClient:
         )
 
     @grpc_try_catch_wrapper(
-        "Failed to create entity", reraise_non_grpc_error_original_exception=True
+        error_message="Failed to create entity", operation="Create Feature Store Entity"
     )
     def create_entity(self, proto_entity_spec: EntitySpec) -> CreateEntityResponse:
         """
@@ -241,7 +248,7 @@ class FeatureRegistryClient:
         )
 
     @grpc_try_catch_wrapper(
-        "Failed to list entities", reraise_non_grpc_error_original_exception=True
+        error_message="Failed to list entities", operation="List Feature Store Entities"
     )
     def list_entities(self) -> ListEntitiesResponse:
         """
@@ -251,7 +258,8 @@ class FeatureRegistryClient:
         return self._entity_service.ListEntities(ListEntitiesRequest())
 
     @grpc_try_catch_wrapper(
-        "Failed to list data sources", reraise_non_grpc_error_original_exception=True
+        error_message="Failed to list data sources",
+        operation="List Feature Store Data Sources",
     )
     def list_data_sources(self) -> ListDataSourcesResponse:
         """
@@ -278,7 +286,8 @@ class FeatureRegistryClient:
         )
 
     @grpc_try_catch_wrapper(
-        "Failed to update data source", reraise_non_grpc_error_original_exception=True
+        error_message="Failed to update data source",
+        operation="Update Feature Store Data Source",
     )
     def update_data_source(
         self,
@@ -300,7 +309,8 @@ class FeatureRegistryClient:
         )
 
     @grpc_try_catch_wrapper(
-        "Failed to create data source", reraise_non_grpc_error_original_exception=True
+        error_message="Failed to create data source",
+        operation="Create Feature Store Data Source",
     )
     def create_data_source(
         self, proto_data_source: FeatureSetSpec
@@ -331,7 +341,8 @@ class FeatureRegistryClient:
         )
 
     @grpc_try_catch_wrapper(
-        "Failed to update feature set", reraise_non_grpc_error_original_exception=True
+        error_message="Failed to update feature set",
+        operation="Update Feature Store Feature Set",
     )
     def update_feature_set(
         self,
@@ -352,7 +363,8 @@ class FeatureRegistryClient:
         )
 
     @grpc_try_catch_wrapper(
-        "Failed to create feature set", reraise_non_grpc_error_original_exception=True
+        error_message="Failed to create feature set",
+        operation="Create Feature Store Feature Set",
     )
     def create_feature_set(
         self, proto_feature_set: FeatureSetSpec
@@ -368,7 +380,9 @@ class FeatureRegistryClient:
         )
 
     @staticmethod
-    def _fetch_by_name(extract_function, name, fs_object_type):
+    def _fetch_by_name(
+        extract_function: Callable[[str], Any], name: str, fs_object_type: str
+    ) -> Any:
         """
         Args:
             extract_function: function to run on name param
@@ -384,7 +398,8 @@ class FeatureRegistryClient:
                 return None
             else:
                 raise FrogmlException(
-                    f"Failed to fetch {fs_object_type} by name [{name}], error code: [{e.details()}]"
+                    error_message=f"Failed to fetch {fs_object_type} by name {name}: {e.details()}",
+                    operation=f"Get Feature Store {fs_object_type.title()}",
                 )
 
     def get_presigned_url_v1(
@@ -408,13 +423,13 @@ class FeatureRegistryClient:
             ).upload_url
         except RpcError as e:
             raise FrogmlException(
-                f"Failed to get presigned url for featureset name {feature_set_name} and transformation type "
-                f"{type(transformation)}, error code: [{e.details()}]"
+                error_message=f"Failed to get presigned url for featureset name {feature_set_name}: {e.details()}",
+                operation="Get Feature Store Presigned URL",
             )
 
     @grpc_try_catch_wrapper(
-        "Failed to get presigned url for data source: {data_source_name}, object name: {object_name}",
-        reraise_non_grpc_error_original_exception=True,
+        error_message="Failed to get presigned url for data source: {data_source_name}, object name: {object_name}",
+        operation="Get Feature Store Data Source Presigned URL",
     )
     def get_data_source_presigned_url_v1(
         self, data_source_name: str, object_name: str
@@ -436,8 +451,8 @@ class FeatureRegistryClient:
         ).upload_url
 
     @grpc_try_catch_wrapper(
-        "Failed to query scheduling state for Featureset {feature_set_name}",
-        reraise_non_grpc_error_original_exception=True,
+        error_message="Failed to query scheduling state for Featureset {feature_set_name}",
+        operation="Get Feature Store FeatureSet Scheduling State",
     )
     def get_feature_set_scheduling_state(
         self, feature_set_name: str
@@ -447,26 +462,26 @@ class FeatureRegistryClient:
         )
 
     @grpc_try_catch_wrapper(
-        "Failed to pause Featureset {feature_set_name}",
-        reraise_non_grpc_error_original_exception=True,
+        error_message="Failed to pause Featureset {feature_set_name}",
+        operation="Pause Feature Store FeatureSet",
     )
-    def pause_feature_set(self, feature_set_name: str):
+    def pause_feature_set(self, feature_set_name: str) -> None:
         self._features_service.PauseFeatureset(
             PauseFeaturesetRequest(featureset_name=feature_set_name)
         )
 
     @grpc_try_catch_wrapper(
-        "Failed to resume Featureset {feature_set_name}",
-        reraise_non_grpc_error_original_exception=True,
+        error_message="Failed to resume Featureset {feature_set_name}",
+        operation="Resume Feature Store FeatureSet",
     )
-    def resume_feature_set(self, feature_set_name: str):
+    def resume_feature_set(self, feature_set_name: str) -> None:
         self._features_service.ResumeFeatureset(
             ResumeFeaturesetRequest(featureset_name=feature_set_name)
         )
 
     @grpc_try_catch_wrapper(
-        "Failed list Featureset versions for Featureset: {featureset_name}",
-        reraise_non_grpc_error_original_exception=True,
+        error_message="Failed list Featureset versions for Featureset: {featureset_name}",
+        operation="List Feature Store FeatureSet Versions",
     )
     def list_featureset_versions(
         self, featureset_name: str
@@ -476,10 +491,12 @@ class FeatureRegistryClient:
         )
 
     @grpc_try_catch_wrapper(
-        "Failed to set active version: {version_number} for Featureset: {featureset_name}",
-        reraise_non_grpc_error_original_exception=True,
+        error_message="Failed to set active version: {version_number} for Featureset: {featureset_name}",
+        operation="Set Feature Store Active FeatureSet Version",
     )
-    def set_active_featureset_version(self, featureset_name: str, version_number: int):
+    def set_active_featureset_version(
+        self, featureset_name: str, version_number: int
+    ) -> None:
         self._features_service.SetActiveFeaturesetVersion(
             SetActiveFeaturesetVersionRequest(
                 featureset_name=featureset_name,
@@ -488,10 +505,12 @@ class FeatureRegistryClient:
         )
 
     @grpc_try_catch_wrapper(
-        "Failed to delete version: {version_number} for Featureset: {featureset_name}",
-        reraise_non_grpc_error_original_exception=True,
+        error_message="Failed to delete version: {version_number} for Featureset: {featureset_name}",
+        operation="Delete Feature Store FeatureSet Version",
     )
-    def delete_featureset_version(self, featureset_name: str, version_number: int):
+    def delete_featureset_version(
+        self, featureset_name: str, version_number: int
+    ) -> None:
         self._features_service.DeleteFeaturesetVersion(
             DeleteFeaturesetVersionRequest(
                 featureset_name=featureset_name,
@@ -500,8 +519,8 @@ class FeatureRegistryClient:
         )
 
     @grpc_try_catch_wrapper(
-        "Failed to get env to featuresets mapping",
-        reraise_non_grpc_error_original_exception=True,
+        error_message="Failed to get env to featuresets mapping",
+        operation="Get Feature Store Env To FeatureSets Mapping",
     )
     def get_env_to_featuresets_mapping(self) -> GetEnvToFeatureSetsMappingResponse:
         return self._features_service.GetEnvToFeatureSetsMapping(

frogml/core/clients/feature_store/operator_client.py

@@ -42,7 +42,8 @@ class FeaturesOperatorClient:
         self._v3_client = FeaturesOperatorAsyncServiceStub(grpc_channel)
 
     @grpc_try_catch_wrapper(
-        "Failed to validate DataSource", reraise_non_grpc_error_original_exception=True
+        error_message="Failed to validate DataSource",
+        operation="Validate Feature Store DataSource",
     )
     def validate_data_source(
         self,
@@ -63,7 +64,8 @@ class FeaturesOperatorClient:
         return response.request_id
 
     @grpc_try_catch_wrapper(
-        "Failed to validate FeatureSet", reraise_non_grpc_error_original_exception=True
+        error_message="Failed to validate FeatureSet",
+        operation="Validate Feature Store FeatureSet",
     )
     def validate_featureset(
         self,
@@ -87,8 +89,8 @@ class FeaturesOperatorClient:
         return response.request_id
 
     @grpc_try_catch_wrapper(
-        "Failed to fetch validation result",
-        reraise_non_grpc_error_original_exception=True,
+        error_message="Failed to fetch validation result",
+        operation="Get Feature Store Validation Result",
     )
     def get_result(self, request_handle: str) -> GetValidationResultResponse:
         """

frogml/core/clients/model_group_management/client.py

@@ -29,7 +29,9 @@ class ModelGroupManagementClient:
             ProjectsManagementServiceStub(grpc_channel)
         )
 
-    @grpc_try_catch_wrapper("Failed to create model")
+    @grpc_try_catch_wrapper(
+        error_message="Failed to create model group", operation="Create Model Group"
+    )
     def create_if_not_exists_model_group(
         self: Self, project_key: str
     ) -> ModelGroupBriefInfoResponse:
@@ -43,7 +45,8 @@ class ModelGroupManagementClient:
         )
 
     @grpc_try_catch_wrapper(
-        "Failed to get model group with model_group_id '{model_group_id}' and model_group_name '{model_group_name}'"
+        error_message="Failed to get model group with model_group_id '{model_group_id}' and model_group_name '{model_group_name}'",
+        operation="Get Model Group",
     )
     def get_model_group(
         self, model_group_id: str = "", model_group_name: str = ""

frogml/core/clients/model_management/client.py

@@ -46,7 +46,10 @@ class ModelsManagementClient:
         except grpc.RpcError as e:
             if e.code() == grpc.StatusCode.NOT_FOUND and not exception_on_missing:
                 return None
-            raise FrogmlException(f"Failed to get model, error is {e.details()}")
+            raise FrogmlException(
+                error_message=f"Failed to get model: {e.details()}",
+                operation="Get Model",
+            )
 
     def get_model_by_uuid(
         self, model_uuid, exception_on_missing: bool = True
@@ -59,13 +62,18 @@ class ModelsManagementClient:
         except grpc.RpcError as e:
             if e.code() == grpc.StatusCode.NOT_FOUND and not exception_on_missing:
                 return None
-            raise FrogmlException(f"Failed to get model, error is {e.details()}")
+            raise FrogmlException(
+                error_message=f"Failed to get model: {e.details()}",
+                operation="Get Model",
+            )
 
     def get_model_uuid(self, model_id: str) -> str:
         model: Optional[Model] = self.get_model(model_id)
         return model.uuid
 
-    @grpc_try_catch_wrapper("Failed to create model")
+    @grpc_try_catch_wrapper(
+        error_message="Failed to create model", operation="Create Model"
+    )
     def create_model(
         self,
         project_id: str,
@@ -87,7 +95,9 @@ class ModelsManagementClient:
             )
         )
 
-    @grpc_try_catch_wrapper("Failed to delete model")
+    @grpc_try_catch_wrapper(
+        error_message="Failed to delete model", operation="Delete Model"
+    )
     def delete_model(self, project_id: str, model_id: str) -> DeleteModelResponse:
         return self._models_management_service.DeleteModel(
             DeleteModelRequest(model_id=model_id, project_id=project_id)
@@ -111,22 +121,29 @@ class ModelsManagementClient:
             if e.code() == grpc.StatusCode.NOT_FOUND:
                 return False
             raise FrogmlException(
-                f"Failed to check if model {model_id} is exists, error is {e.details()}"
+                error_message=f"Failed to check if model {model_id} exists: {e.details()}",
+                operation="Check Model Exists",
             )
 
-    @grpc_try_catch_wrapper("Failed to list models metadata")
+    @grpc_try_catch_wrapper(
+        error_message="Failed to list models metadata", operation="List Models Metadata"
+    )
     def list_models_metadata(self, project_id: str) -> ListModelsMetadataResponse:
         return self._models_management_service.ListModelsMetadata(
             ListModelsMetadataRequest(project_id=project_id)
         )
 
-    @grpc_try_catch_wrapper("Failed to list models")
+    @grpc_try_catch_wrapper(
+        error_message="Failed to list models", operation="List Models"
+    )
     def list_models(self, project_id: str) -> ListModelsResponse:
         return self._models_management_service.ListModels(
             ListModelsRequest(project_id=project_id)
         )
 
-    @grpc_try_catch_wrapper("Failed to get model metadata")
+    @grpc_try_catch_wrapper(
+        error_message="Failed to get model metadata", operation="Get Model Metadata"
+    )
     def get_model_metadata(self, model_id: str) -> GetModelMetadataResponse:
         return self._models_management_service.GetModelMetadata(
             GetModelMetadataRequest(model_id=model_id)

frogml/core/clients/model_version_manager/build_model_version_dto.py

@@ -1,3 +1,4 @@
+from http import HTTPStatus
 from typing import Optional, List
 from pydantic import BaseModel, model_validator
 from typing_extensions import Self
@@ -61,7 +62,9 @@ class PodResourcesDTO(BaseModel):
 
         if fields_set != 1:
             raise FrogmlException(
-                "Exactly one of template_spec, cpu_resources, or gpu_resources must be set"
+                error_message="Exactly one of template_spec, cpu_resources, or gpu_resources must be set",
+                status_code=HTTPStatus.BAD_REQUEST,
+                operation="Validate Model Version Pod Resources",
             )
 
         return self

frogml/core/clients/model_version_manager/client.py

@@ -1,9 +1,9 @@
 import logging
+from http import HTTPStatus
 from platform import python_version
 from typing import List, Optional, Dict, Union, Tuple
 
 from dependency_injector.wiring import Provide
-from grpc import RpcError
 from typing_extensions import Self
 
 from frogml._proto.jfml.model_version.v1.artifact_pb2 import Artifact as ArtifactProto
@@ -116,6 +116,10 @@ class ModelVersionManagerClient:
             ml_bom_data=MlBomData(**kwargs),
         )
 
+    @grpc_try_catch_wrapper(
+        error_message="Failed to validate model version '{model_version_name}' for model '{model_name}'",
+        operation="Validate Model Version",
+    )
     def validate_create_model_version(
         self,
         repository_key: str,
@@ -128,36 +132,30 @@ class ModelVersionManagerClient:
         parameters: Optional[Dict[str, str]] = None,
         metrics: Optional[Dict[str, str]] = None,
     ):
-        try:
-            (
-                code_artifacts_proto,
-                dependency_artifacts_proto,
-                model_artifact_proto,
-            ) = self.convert_artifacts(
-                model_artifact, dependency_artifacts, code_artifacts
-            )
-
-            create_model_request = self.__build_create_model_version_request(
-                repository_key=repository_key,
-                model_name=model_name,
-                model_version_name=model_version_name,
-                model_version_framework=model_version_framework,
-                dry_run=True,
-                model_artifacts=model_artifact_proto,
-                dependency_artifacts=dependency_artifacts_proto,
-                code_artifacts=code_artifacts_proto,
-                parameters=parameters,
-                metrics=metrics,
-            )
-            self.__model_version_manager_stub.CreateModelVersion(create_model_request)
-        except RpcError as e:
-            message = f"Failed to validate model version, details [{e.details()}]"
-            raise FrogmlException(message)
+        (
+            code_artifacts_proto,
+            dependency_artifacts_proto,
+            model_artifact_proto,
+        ) = self.convert_artifacts(model_artifact, dependency_artifacts, code_artifacts)
 
-        except Exception as e:
-            message = f"Failed to validate model version, details [{e}]"
-            raise FrogmlException(message)
+        create_model_request = self.__build_create_model_version_request(
+            repository_key=repository_key,
+            model_name=model_name,
+            model_version_name=model_version_name,
+            model_version_framework=model_version_framework,
+            dry_run=True,
+            model_artifacts=model_artifact_proto,
+            dependency_artifacts=dependency_artifacts_proto,
+            code_artifacts=code_artifacts_proto,
+            parameters=parameters,
+            metrics=metrics,
+        )
+        self.__model_version_manager_stub.CreateModelVersion(create_model_request)
 
+    @grpc_try_catch_wrapper(
+        error_message="Failed to create model version '{model_version_name}' for model '{model_name}'",
+        operation="Create Model Version",
+    )
     def create_model_version(
         self,
         repository_key: str,
@@ -170,41 +168,27 @@ class ModelVersionManagerClient:
         parameters: Optional[Dict[str, str]] = None,
         metrics: Optional[Dict[str, str]] = None,
     ) -> CreateModelVersionResponse:
-        try:
-            (
-                code_artifacts_proto,
-                dependency_artifacts_proto,
-                model_artifact_proto,
-            ) = self.convert_artifacts(
-                model_artifact, dependency_artifacts, code_artifacts
-            )
-
-            create_model_request = self.__build_create_model_version_request(
-                repository_key=repository_key,
-                model_name=model_name,
-                model_version_name=model_version_name,
-                model_version_framework=model_version_framework,
-                dry_run=False,
-                model_artifacts=model_artifact_proto,
-                dependency_artifacts=dependency_artifacts_proto,
-                code_artifacts=code_artifacts_proto,
-                parameters=parameters,
-                metrics=metrics,
-            )
-            create_model_version_response: CreateModelVersionResponse = (
-                self.__model_version_manager_stub.CreateModelVersion(
-                    create_model_request
-                )
-            )
-
-            return create_model_version_response
-        except RpcError as e:
-            message = f"Failed to validate model version, details [{e.details()}]"
-            raise FrogmlException(message)
+        (
+            code_artifacts_proto,
+            dependency_artifacts_proto,
+            model_artifact_proto,
+        ) = self.convert_artifacts(model_artifact, dependency_artifacts, code_artifacts)
 
-        except Exception as e:
-            message = f"Failed to validate model version, details [{e}]"
-            raise FrogmlException(message)
+        create_model_request = self.__build_create_model_version_request(
+            repository_key=repository_key,
+            model_name=model_name,
+            model_version_name=model_version_name,
+            model_version_framework=model_version_framework,
+            dry_run=False,
+            model_artifacts=model_artifact_proto,
+            dependency_artifacts=dependency_artifacts_proto,
+            code_artifacts=code_artifacts_proto,
+            parameters=parameters,
+            metrics=metrics,
+        )
+        return self.__model_version_manager_stub.CreateModelVersion(
+            create_model_request
+        )
 
     @staticmethod
     def convert_artifacts(
@@ -231,7 +215,6 @@ class ModelVersionManagerClient:
         )
         return code_artifacts_proto, dependency_artifacts_proto, model_artifact_proto
 
-    @grpc_try_catch_wrapper("Failed to promote model version to build")
     def promote_to_build(
         self: Self,
         build_config: BuildConfigDTO,
@@ -248,15 +231,31 @@ class ModelVersionManagerClient:
         :return The build ID of the promoted model version
         :raises FrogmlException: If the promotion fails or parameters are invalid
         """
-        logger.info("Promote model version to build %s", build_config)
-        is_missing_required_model_version_params: bool = not model_version_id and (
+        is_missing_required_params = not model_version_id and (
             not model_id or not model_version_name
         )
-        if is_missing_required_model_version_params:
+        if is_missing_required_params:
             raise FrogmlException(
-                "Either model_version_id must be provided, or both model_id and model_version_name must be provided"
+                error_message="Either model_version_id must be provided, or both model_id and model_version_name must be provided",
+                status_code=HTTPStatus.BAD_REQUEST,
+                operation="Promote Model Version",
             )
+        return self._promote_to_build_grpc(
+            build_config, model_version_id, model_id, model_version_name
+        )
 
+    @grpc_try_catch_wrapper(
+        error_message="Failed to promote model version '{model_version_name}' (id: {model_version_id}) to build",
+        operation="Promote Model Version",
+    )
+    def _promote_to_build_grpc(
+        self: Self,
+        build_config: BuildConfigDTO,
+        model_version_id: Optional[str],
+        model_id: Optional[str],
+        model_version_name: Optional[str],
+    ) -> str:
+        logger.info("Promote model version to build %s", build_config)
         build_spec: BuildSpec = map_build_conf_to_build_spec(build_config)
         logger.debug("build_spec = %s", build_spec)
 

frogml/core/exceptions/__init__.py

@@ -1,14 +1,32 @@
+import sys
+from types import TracebackType
+from typing import Optional
+
 from .frogml_exception import FrogmlException
 from .frogml_general_build_exception import FrogmlGeneralBuildException
 from .frogml_grpc_address_exception import FrogmlGrpcAddressException
 from .frogml_http_exception import FrogmlHTTPException
 from .frogml_inference_exception import FrogmlInferenceException
 from .frogml_load_configuration_exception import LoadConfigurationException
-from .frogml_load_model_failed_exception import FrogmlLoadModelFailedException
 from .frogml_login_exception import FrogmlLoginException
 from .frogml_mock_http_exception import MockHttpException
 from .frogml_model_initialization_exception import FrogmlModelInitializationException
 from .frogml_not_found_exception import FrogmlNotFoundException
 from .frogml_remote_build_failed import FrogmlRemoteBuildFailedException
 from .frogml_suggestion_exception import FrogmlSuggestionException
-from .quiet_error import QuietError
+from .grpc_status_mapping import grpc_to_http_status
+
+
+def _quiet_hook(
+    kind: type[BaseException],
+    message: BaseException,
+    traceback: Optional[TracebackType],
+) -> None:
+    """Custom exception hook that suppresses tracebacks for FrogmlException."""
+    if issubclass(kind, FrogmlException):
+        print(f"{message}")
+    else:
+        sys.__excepthook__(kind, message, traceback)
+
+
+sys.excepthook = _quiet_hook