mobius-error-py 1.0.0__py3-none-any.whl

mobius_error/__init__.py

@@ -0,0 +1,60 @@
+"""
+Mobius Error Services - FastAPI Port
+A comprehensive error handling library ported from the Spring Boot Java library.
+"""
+
+from mobius_error.config import App
+from mobius_error.errors.error import Error
+from mobius_error.errors.common_errors import CommonErrors
+from mobius_error.errors.error_message import ErrorMessage
+from mobius_error.exceptions.application_exception import ApplicationException
+from mobius_error.exceptions.api_exception import ApiException
+from mobius_error.exceptions.validation_exception import ValidationException
+from mobius_error.exceptions.access_violation_exception import AccessViolationException
+from mobius_error.exceptions.token_exception import TokenException
+from mobius_error.exceptions.rest_exception import RestException
+from mobius_error.exceptions.rest_get_exception import RestGetException
+from mobius_error.exceptions.rest_post_exception import RestPostException
+from mobius_error.exceptions.kafka_exception import KafkaException
+from mobius_error.exceptions.kafka_consumption_exception import KafkaConsumptionException
+from mobius_error.exceptions.object_mapping_exception import ObjectMappingException
+from mobius_error.exceptions.invalid_name_exception import InvalidNameException
+from mobius_error.exceptions.invalid_tenant_exception import InvalidTenantException
+from mobius_error.exceptions.unsupported_operation_exception import UnsupportedOperationException
+from mobius_error.exceptions.data_type_mismatch_exception import DataTypeMismatchException
+from mobius_error.exceptions.group_data_retrieval_exception import GroupDataRetrievalException
+from mobius_error.responses.error_response import ErrorResponse
+from mobius_error.responses.api_error_response import ApiErrorResponse
+from mobius_error.handlers.exception_handler import register_exception_handlers
+from mobius_error.kafka.producer import KafkaErrorProducer, LogEventSender, PyKafkaProducerClientSender, set_error_producer, get_error_producer
+
+__all__ = [
+    "App",
+    "Error",
+    "CommonErrors",
+    "ErrorMessage",
+    "ApplicationException",
+    "ApiException",
+    "ValidationException",
+    "AccessViolationException",
+    "TokenException",
+    "RestException",
+    "RestGetException",
+    "RestPostException",
+    "KafkaException",
+    "KafkaConsumptionException",
+    "ObjectMappingException",
+    "InvalidNameException",
+    "InvalidTenantException",
+    "UnsupportedOperationException",
+    "DataTypeMismatchException",
+    "GroupDataRetrievalException",
+    "ErrorResponse",
+    "ApiErrorResponse",
+    "register_exception_handlers",
+    "KafkaErrorProducer",
+    "LogEventSender",
+    "PyKafkaProducerClientSender",
+    "set_error_producer",
+    "get_error_producer",
+]

mobius_error/config.py

@@ -0,0 +1,13 @@
+"""Application configuration — mirrors com.aidtaas.mobius.error.services.config.App"""
+
+
+class App:
+    _app_name: str = ""
+
+    @classmethod
+    def get_app_name(cls) -> str:
+        return cls._app_name
+
+    @classmethod
+    def set_app_name(cls, name: str) -> None:
+        cls._app_name = name

mobius_error/errors/common_errors.py

@@ -0,0 +1,33 @@
+"""Mirrors com.aidtaas.mobius.error.services.error.CommonErrors"""
+
+from mobius_error.errors.error import Error
+
+_VERIFY_REQUEST = "Kindly verify your request or contact the support team"
+_TRY_AGAIN = "Kindly try again after some time or contact the support team"
+
+
+class CommonErrors:
+    # 403 Forbidden
+    INVALID_TENANT_ID = Error(
+        403, 403002,
+        "You're not registered as a tenant yet",
+        "Kindly get yourself registered first",
+    )
+
+    # 500 Internal Server Error
+    UNEXPECTED_ERROR = Error(500, 500000, "Encountered an unexpected error", _TRY_AGAIN)
+    SERVICE_UNAVAILABLE = Error(500, 500001, "One or more service(s) are not up and running", _TRY_AGAIN)
+    OBJECT_MAPPING_FAILURE = Error(500, 500002, "Failed to convert json to object/map or vice versa", _VERIFY_REQUEST)
+    GROUP_DATA_RETRIEVAL_FAILURE = Error(500, 500003, "Failed to get group data from data lake", "Kindly verify if the group contains data")
+    GET_API_FAILURE = Error(500, 500004, "Failed to GET data from the URL", "Kindly verify if the URL is working")
+    POST_API_FAILURE = Error(500, 500005, "Failed to make POST call to an api", "Kindly verify if the POST API service is up and running")
+    REST_API_FAILURE = Error(500, 500006, "Failed to make REST call to an api", "Kindly verify if the POST API service is up and running")
+
+    # 401 Unauthorized
+    TENANT_NOT_AUTHORIZED = Error(401, 401000, "You're not authorized to access the resource", "Kindly request appropriate access required for your needs to its owner")
+
+    # 400 Bad Request
+    KAFKA_ERROR = Error(400, 400000, "An error occurred in kafka", "Kindly contact the support team")
+    KAFKA_CONSUMPTION_ERROR = Error(400, 400001, "An error occurred while consuming a message from kafka", "Kindly contact the support team")
+    INVALID_NAME = Error(400, 400002, "The name provided is invalid", "Kindly try with another name")
+    UNSUPPORTED_OPERATION = Error(400, 400003, "This operation is not yet supported", "Kindly try another operation")

mobius_error/errors/error.py

@@ -0,0 +1,17 @@
+"""Mirrors com.aidtaas.mobius.error.services.error.Error"""
+
+from __future__ import annotations
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Optional
+
+if TYPE_CHECKING:
+    from mobius_error.errors.error_message import ErrorMessage
+
+
+@dataclass(frozen=True)
+class Error:
+    http_status_code: int
+    error_code: int
+    error_message: str
+    action_required: str
+    error_message_description: Optional["ErrorMessage"] = field(default=None)

mobius_error/errors/error_message.py

@@ -0,0 +1,37 @@
+"""Mirrors com.aidtaas.mobius.error.services.error.ErrorMessage"""
+
+from __future__ import annotations
+import time
+from dataclasses import dataclass, field
+from typing import Any, Optional
+
+
+@dataclass
+class ErrorMessage:
+    message: Optional[str] = None
+    root_origin: Optional[str] = None
+    root_message: Optional[str] = None
+    action_required: Optional[str] = None
+    cause: Optional["ErrorMessage"] = None
+    origin: Optional[str] = None
+    http_status_code: Optional[int] = None
+    timestamp: int = field(default_factory=lambda: int(time.time()))
+
+    def to_dict(self) -> dict[str, Any]:
+        result: dict[str, Any] = {}
+        if self.root_origin is not None:
+            result["rootOrigin"] = self.root_origin
+        if self.root_message is not None:
+            result["rootMessage"] = self.root_message
+        if self.message is not None:
+            result["message"] = self.message
+        if self.action_required is not None:
+            result["actionRequired"] = self.action_required
+        if self.cause is not None:
+            result["cause"] = self.cause.to_dict()
+        if self.origin is not None:
+            result["origin"] = self.origin
+        if self.http_status_code is not None:
+            result["httpStatusCode"] = self.http_status_code
+        result["timestamp"] = self.timestamp
+        return result

mobius_error/exceptions/access_violation_exception.py

@@ -0,0 +1,24 @@
+"""Mirrors com.aidtaas.mobius.error.services.exception.AccessViolationException"""
+
+from __future__ import annotations
+from typing import Any, Optional
+from mobius_error.errors.error import Error
+from mobius_error.exceptions.validation_exception import ValidationException
+
+
+class AccessViolationException(ValidationException):
+
+    def __init__(
+        self,
+        error: Error,
+        detailed_error_message: Optional[str] = None,
+        error_object: Any = None,
+        cause: Optional[Exception] = None,
+    ) -> None:
+        super().__init__(
+            error=error,
+            detailed_error_message=detailed_error_message,
+            error_object=error_object,
+            cause=cause,
+        )
+        self.http_status_code = 403

mobius_error/exceptions/api_exception.py

@@ -0,0 +1,28 @@
+"""Mirrors com.aidtaas.mobius.error.services.exception.ApiException"""
+
+from __future__ import annotations
+from typing import Any, Optional
+
+from mobius_error.errors.error import Error
+from mobius_error.errors.error_message import ErrorMessage
+from mobius_error.exceptions.application_exception import ApplicationException
+
+
+class ApiException(ApplicationException):
+
+    def __init__(
+        self,
+        error: Error,
+        detailed_error_message: Optional[str] = None,
+        error_object: Any = None,
+        nested_error_message: Optional[ErrorMessage] = None,
+        cause: Optional[Exception] = None,
+    ) -> None:
+        super().__init__(
+            error=error,
+            detailed_error_message=detailed_error_message,
+            error_object=error_object,
+            nested_error_message=nested_error_message,
+            cause=cause,
+        )
+        self.http_status_code: int = error.http_status_code if error else 500

mobius_error/exceptions/application_exception.py

@@ -0,0 +1,71 @@
+"""Mirrors com.aidtaas.mobius.error.services.exception.ApplicationException"""
+
+from __future__ import annotations
+from typing import Any, Optional
+
+from mobius_error.config import App
+from mobius_error.errors.common_errors import CommonErrors
+from mobius_error.errors.error import Error
+from mobius_error.errors.error_message import ErrorMessage
+import time
+
+
+class ApplicationException(Exception):
+
+    def __init__(
+        self,
+        error: Optional[Error] = None,
+        detailed_error_message: Optional[str] = None,
+        error_object: Any = None,
+        nested_error_message: Optional[ErrorMessage] = None,
+        cause: Optional[Exception] = None,
+        sub_errors: Optional[list[ErrorMessage]] = None,
+        actions_required: Optional[list[str]] = None,
+    ) -> None:
+        self.error: Error = error or CommonErrors.UNEXPECTED_ERROR
+        self.detailed_error_message = detailed_error_message
+        self.error_object = error_object
+        self.origin: str = App.get_app_name()
+        self.sub_errors: list[ErrorMessage] = list(sub_errors) if sub_errors else []
+        self.actions_required: list[str] = list(actions_required) if actions_required else []
+        self.__cause__ = cause
+
+        # Build nested error message
+        if nested_error_message is not None:
+            self.nested_error_message = nested_error_message
+        elif detailed_error_message and cause is None:
+            self.nested_error_message = ErrorMessage(
+                root_origin=App.get_app_name(),
+                root_message=detailed_error_message,
+            )
+        elif cause is not None:
+            self.nested_error_message = ErrorMessage(
+                message=str(cause),
+                origin=App.get_app_name(),
+                http_status_code=500,
+                timestamp=int(time.time()),
+            )
+        else:
+            self.nested_error_message = None
+
+        msg = detailed_error_message or self.error.error_message
+        super().__init__(msg)
+
+    # ---- fluent helpers (mirror the Java builder pattern) ----
+
+    def add_action_required(self, action: str) -> "ApplicationException":
+        if action:
+            self.actions_required.append(action)
+        return self
+
+    def add_sub_error(self, message: str) -> "ApplicationException":
+        if message:
+            self.sub_errors.append(ErrorMessage(message=message))
+        return self
+
+    def add_nested_error_message(self, message: str) -> "ApplicationException":
+        if message:
+            new_msg = ErrorMessage(message=message)
+            new_msg.cause = self.nested_error_message
+            self.nested_error_message = new_msg
+        return self

mobius_error/exceptions/data_type_mismatch_exception.py

@@ -0,0 +1,11 @@
+"""Mirrors com.aidtaas.mobius.error.services.exception.DataTypeMismatchException"""
+
+from typing import Any
+from mobius_error.errors.error import Error
+from mobius_error.exceptions.api_exception import ApiException
+
+
+class DataTypeMismatchException(ApiException):
+
+    def __init__(self, error: Error, detailed_error_message: str, error_object: Any = None) -> None:
+        super().__init__(error=error, detailed_error_message=detailed_error_message, error_object=error_object)

mobius_error/exceptions/group_data_retrieval_exception.py

@@ -0,0 +1,8 @@
+"""Mirrors GroupDataRetrievalException"""
+from typing import Optional
+from mobius_error.errors.common_errors import CommonErrors
+from mobius_error.exceptions.application_exception import ApplicationException
+
+class GroupDataRetrievalException(ApplicationException):
+    def __init__(self, error_message: str, cause: Optional[Exception] = None) -> None:
+        super().__init__(error=CommonErrors.GROUP_DATA_RETRIEVAL_FAILURE, detailed_error_message=error_message, cause=cause)

mobius_error/exceptions/invalid_name_exception.py

@@ -0,0 +1,8 @@
+"""Mirrors InvalidNameException"""
+from typing import Optional
+from mobius_error.errors.common_errors import CommonErrors
+from mobius_error.exceptions.validation_exception import ValidationException
+
+class InvalidNameException(ValidationException):
+    def __init__(self, error_message: str, cause: Optional[Exception] = None) -> None:
+        super().__init__(error=CommonErrors.INVALID_NAME, detailed_error_message=error_message, cause=cause)

mobius_error/exceptions/invalid_tenant_exception.py

@@ -0,0 +1,8 @@
+"""Mirrors InvalidTenantException"""
+from typing import Optional
+from mobius_error.errors.common_errors import CommonErrors
+from mobius_error.exceptions.validation_exception import ValidationException
+
+class InvalidTenantException(ValidationException):
+    def __init__(self, error_message: Optional[str] = None) -> None:
+        super().__init__(error=CommonErrors.INVALID_TENANT_ID, detailed_error_message=error_message)

mobius_error/exceptions/kafka_consumption_exception.py

@@ -0,0 +1,8 @@
+"""Mirrors KafkaConsumptionException"""
+from typing import Optional
+from mobius_error.errors.common_errors import CommonErrors
+from mobius_error.exceptions.application_exception import ApplicationException
+
+class KafkaConsumptionException(ApplicationException):
+    def __init__(self, error_message: str, cause: Optional[Exception] = None) -> None:
+        super().__init__(error=CommonErrors.KAFKA_CONSUMPTION_ERROR, detailed_error_message=error_message, cause=cause)

mobius_error/exceptions/kafka_exception.py

@@ -0,0 +1,8 @@
+"""Mirrors KafkaException"""
+from typing import Optional
+from mobius_error.errors.common_errors import CommonErrors
+from mobius_error.exceptions.application_exception import ApplicationException
+
+class KafkaException(ApplicationException):
+    def __init__(self, error_message: str, cause: Optional[Exception] = None) -> None:
+        super().__init__(error=CommonErrors.KAFKA_ERROR, detailed_error_message=error_message, cause=cause)

mobius_error/exceptions/object_mapping_exception.py

@@ -0,0 +1,8 @@
+"""Mirrors ObjectMappingException"""
+from typing import Optional
+from mobius_error.errors.common_errors import CommonErrors
+from mobius_error.exceptions.application_exception import ApplicationException
+
+class ObjectMappingException(ApplicationException):
+    def __init__(self, error_message: str, cause: Optional[Exception] = None) -> None:
+        super().__init__(error=CommonErrors.OBJECT_MAPPING_FAILURE, detailed_error_message=error_message, cause=cause)

mobius_error/exceptions/rest_exception.py

@@ -0,0 +1,11 @@
+"""Mirrors RestException"""
+from typing import Optional
+from mobius_error.errors.common_errors import CommonErrors
+from mobius_error.exceptions.application_exception import ApplicationException
+
+
+class RestException(ApplicationException):
+    def __init__(self, error_message: str, cause: Optional[Exception] = None, detailed: Optional[str] = None) -> None:
+        super().__init__(error=CommonErrors.REST_API_FAILURE, detailed_error_message=error_message, cause=cause)
+        if detailed:
+            self.detailed_error_message = detailed

mobius_error/exceptions/rest_get_exception.py

@@ -0,0 +1,11 @@
+"""Mirrors RestGetException"""
+from typing import Optional
+from mobius_error.errors.common_errors import CommonErrors
+from mobius_error.exceptions.application_exception import ApplicationException
+
+
+class RestGetException(ApplicationException):
+    def __init__(self, error_message: str, cause: Optional[Exception] = None, url: Optional[str] = None, status_code: Optional[int] = None, response_body: Optional[str] = None) -> None:
+        super().__init__(error=CommonErrors.GET_API_FAILURE, detailed_error_message=error_message, cause=cause)
+        if url and status_code is not None:
+            self.detailed_error_message = f"Error on GET {url} : {status_code} - {response_body or ''}"

mobius_error/exceptions/rest_post_exception.py

@@ -0,0 +1,11 @@
+"""Mirrors RestPostException"""
+from typing import Any, Optional
+from mobius_error.errors.common_errors import CommonErrors
+from mobius_error.exceptions.application_exception import ApplicationException
+
+
+class RestPostException(ApplicationException):
+    def __init__(self, error_message: str, cause: Optional[Exception] = None, url: Optional[str] = None, payload: Any = None, status_code: Optional[int] = None, response_body: Optional[str] = None) -> None:
+        super().__init__(error=CommonErrors.POST_API_FAILURE, detailed_error_message=error_message, cause=cause)
+        if url and status_code is not None:
+            self.detailed_error_message = f"Error on POST {url} with payload {payload} : {status_code} - {response_body or ''}"

mobius_error/exceptions/token_exception.py

@@ -0,0 +1,26 @@
+"""Mirrors com.aidtaas.mobius.error.services.exception.TokenException"""
+
+from __future__ import annotations
+from typing import Any, Optional
+from mobius_error.errors.error import Error
+from mobius_error.errors.error_message import ErrorMessage
+from mobius_error.exceptions.api_exception import ApiException
+
+
+class TokenException(ApiException):
+
+    def __init__(
+        self,
+        error: Error,
+        detailed_error_message: Optional[str] = None,
+        error_object: Any = None,
+        nested_error_message: Optional[ErrorMessage] = None,
+        cause: Optional[Exception] = None,
+    ) -> None:
+        super().__init__(
+            error=error,
+            detailed_error_message=detailed_error_message,
+            error_object=error_object,
+            nested_error_message=nested_error_message,
+            cause=cause,
+        )

mobius_error/exceptions/unsupported_operation_exception.py

@@ -0,0 +1,8 @@
+"""Mirrors UnsupportedOperationException"""
+from typing import Optional
+from mobius_error.errors.common_errors import CommonErrors
+from mobius_error.exceptions.application_exception import ApplicationException
+
+class UnsupportedOperationException(ApplicationException):
+    def __init__(self, error_message: str, cause: Optional[Exception] = None) -> None:
+        super().__init__(error=CommonErrors.UNSUPPORTED_OPERATION, detailed_error_message=error_message, cause=cause)

mobius_error/exceptions/validation_exception.py

@@ -0,0 +1,23 @@
+"""Mirrors com.aidtaas.mobius.error.services.exception.ValidationException"""
+
+from __future__ import annotations
+from typing import Any, Optional
+from mobius_error.errors.error import Error
+from mobius_error.exceptions.api_exception import ApiException
+
+
+class ValidationException(ApiException):
+
+    def __init__(
+        self,
+        error: Error,
+        detailed_error_message: Optional[str] = None,
+        error_object: Any = None,
+        cause: Optional[Exception] = None,
+    ) -> None:
+        super().__init__(
+            error=error,
+            detailed_error_message=detailed_error_message,
+            error_object=error_object,
+            cause=cause,
+        )