maleo-foundation 0.3.46__py3-none-any.whl → 0.3.48__py3-none-any.whl

maleo_foundation/utils/client.py

@@ -3,8 +3,10 @@ from functools import wraps
 from pydantic import ValidationError
 from typing import Optional, Type, Union
 from maleo_foundation.types import BaseTypes
-from maleo_foundation.models.transfers.results.client.service import \
-    BaseClientServiceResultsTransfers
+from maleo_foundation.models.transfers.results.client.service import (
+    BaseClientServiceResultsTransfers,
+)
+
 
 class BaseClientUtils:
     @staticmethod
@@ -13,49 +15,60 @@ class BaseClientUtils:
         data_found_class: Union[
             Type[BaseClientServiceResultsTransfers.SingleData],
             Type[BaseClientServiceResultsTransfers.UnpaginatedMultipleData],
-            Type[BaseClientServiceResultsTransfers.PaginatedMultipleData]
+            Type[BaseClientServiceResultsTransfers.PaginatedMultipleData],
         ],
         no_data_class: Optional[Type[BaseClientServiceResultsTransfers.NoData]] = None,
     ):
         """Decorator to handle repository-related exceptions consistently."""
+
         def decorator(func):
             def _processor(result: BaseTypes.StringToAnyDict):
                 if "success" not in result and "data" not in result:
-                    raise ValueError("Result did not have both 'success' and 'data' field")
-                success:bool = result.get("success")
-                data:BaseTypes.StringToAnyDict = result.get("data")
+                    raise ValueError(
+                        "Result did not have both 'success' and 'data' field"
+                    )
+                success: bool = result.get("success", False)
+                data: BaseTypes.StringToAnyDict = result.get("data", {})
                 if not success:
                     validated_result = fail_class.model_validate(result)
                     return validated_result
                 else:
                     if data is None:
                         if no_data_class is None:
-                            raise ValueError("'no_data_class' must be given to validate No Data")
+                            raise ValueError(
+                                "'no_data_class' must be given to validate No Data"
+                            )
                         validated_result = no_data_class.model_validate(result)
                         return validated_result
                     else:
                         validated_result = data_found_class.model_validate(result)
                         return validated_result
+
             if asyncio.iscoroutinefunction(func):
+
                 @wraps(func)
                 async def async_wrapper(*args, **kwargs):
                     try:
                         result: BaseTypes.StringToAnyDict = await func(*args, **kwargs)
                         return _processor(result=result)
-                    except ValidationError as e:
+                    except ValidationError:
                         raise
-                    except Exception as e:
+                    except Exception:
                         raise
+
                 return async_wrapper
             else:
+
                 @wraps(func)
                 def sync_wrapper(*args, **kwargs):
                     try:
                         result: BaseTypes.StringToAnyDict = func(*args, **kwargs)
                         return _processor(result=result)
-                    except ValidationError as e:
+                    except ValidationError:
                         raise
-                    except Exception as e:
+                    except Exception:
                         raise
+
                 return sync_wrapper
-        return decorator
+
+        return decorator

maleo_foundation/utils/controller.py

@@ -1,28 +1,32 @@
 import inspect
 from fastapi import status
 from functools import wraps
-from typing import Awaitable, Callable, Dict, List, Union
+from typing import Awaitable, Callable, Dict, List, cast
 from maleo_foundation.types import BaseTypes
 from maleo_foundation.models.responses import BaseResponses
-from maleo_foundation.models.transfers.parameters.general \
-    import BaseGeneralParametersTransfers
-from maleo_foundation.models.transfers.results.service.controllers.rest \
-    import BaseServiceRESTControllerResults
+from maleo_foundation.models.transfers.parameters.general import (
+    BaseGeneralParametersTransfers,
+)
+from maleo_foundation.models.transfers.results.service.controllers.rest import (
+    BaseServiceRESTControllerResults,
+)
 from maleo_foundation.expanded_types.general import BaseGeneralExpandedTypes
 
+
 class BaseControllerUtils:
     @staticmethod
     def field_expansion_handler(
         expandable_fields_dependencies_map: BaseTypes.OptionalStringToListOfStringDict = None,
-        field_expansion_processors: BaseGeneralExpandedTypes.OptionalListOfFieldExpansionProcessor = None
+        field_expansion_processors: BaseGeneralExpandedTypes.OptionalListOfFieldExpansionProcessor = None,
     ):
         """
         Decorator to handle expandable fields validation and processing.
-        
+
         Args:
             expandable_fields_dependencies_map: Dictionary where keys are dependency fields and values are lists of dependent fields
             field_expansion_processors: List of processor functions that handle that field's data
         """
+
         def decorator(func: Callable[..., Awaitable[BaseServiceRESTControllerResults]]):
             @wraps(func)
             async def wrapper(*args, **kwargs):
@@ -31,53 +35,64 @@ class BaseControllerUtils:
                 bound.apply_defaults()
 
                 parameters = bound.arguments.get("parameters")
-                expand: BaseTypes.OptionalListOfStrings = getattr(parameters, 'expand', None)
+                expand: BaseTypes.OptionalListOfStrings = getattr(
+                    parameters, "expand", None
+                )
 
-                #* Validate expandable fields dependencies
-                if expand is not None and expandable_fields_dependencies_map is not None:
-                    for dependency, dependents in expandable_fields_dependencies_map.items():
+                # * Validate expandable fields dependencies
+                if (
+                    expand is not None
+                    and expandable_fields_dependencies_map is not None
+                ):
+                    for (
+                        dependency,
+                        dependents,
+                    ) in expandable_fields_dependencies_map.items():
                         if dependency not in expand:
                             for dependent in dependents:
                                 if dependent in expand:
                                     other = f"'{dependency}' must also be expanded if '{dependent}' is expanded"
-                                    content = BaseResponses.InvalidExpand(other=other).model_dump()
+                                    content = BaseResponses.InvalidExpand(other=other).model_dump()  # type: ignore
                                     return BaseServiceRESTControllerResults(
                                         success=False,
                                         content=content,
-                                        status_code=status.HTTP_400_BAD_REQUEST
-                                    )
+                                        status_code=status.HTTP_400_BAD_REQUEST,
+                                    )  # type: ignore
 
-                #* Call the original function
+                # * Call the original function
                 result = await func(*args, **kwargs)
 
                 if not isinstance(result.content, Dict):
                     return result
 
-                #* Recursive function to apply expansion processors
-                def recursive_expand(data: Union[Dict, List], expand: BaseTypes.OptionalListOfStrings):
+                # * Recursive function to apply expansion processors
+                def recursive_expand(
+                    data: BaseTypes.ListOrDictOfAny,
+                    expand: BaseTypes.OptionalListOfStrings,
+                ) -> BaseTypes.ListOrDictOfAny:
                     if isinstance(data, list):
                         for idx, item in enumerate(data):
                             data[idx] = recursive_expand(item, expand)
                         return data
-                    elif isinstance(data, Dict):
-                        #* Apply each processor to current dict
+                    elif isinstance(data, dict):
+                        # * If no expand is provided
+                        # * Apply each processor to current dict
                         parameters = (
-                            BaseGeneralParametersTransfers
-                            .FieldExpansionProcessor(
-                                data=data,
-                                expand=expand
+                            BaseGeneralParametersTransfers.FieldExpansionProcessor(
+                                data=data, expand=expand
                             )
                         )
                         for processor in field_expansion_processors or []:
                             data = processor(parameters)
+                        data = cast(BaseTypes.StringToAnyDict, data)
                         for key in data.keys():
-                            if isinstance(data[key], (Dict, List)):
+                            if isinstance(data[key], (dict, list)):
                                 data[key] = recursive_expand(data[key], expand)
                         return data
                     else:
                         return data
 
-                #* Process expansions recursively if needed
+                # * Process expansions recursively if needed
                 if (
                     result.success
                     and result.content.get("data", None) is not None
@@ -85,46 +100,51 @@ class BaseControllerUtils:
                 ):
                     data = result.content["data"]
                     result.content["data"] = recursive_expand(data, expand)
-                    result.process_response()
+                    result.response
 
                 return result
+
             return wrapper
+
         return decorator
 
     @staticmethod
     def field_modification_handler(
-        field_modification_processors: BaseGeneralExpandedTypes.OptionalListOfFieldModificationProcessor = None
+        field_modification_processors: BaseGeneralExpandedTypes.OptionalListOfFieldModificationProcessor = None,
     ):
         """
         Decorator to handle expandable fields validation and processing.
-        
+
         Args:
             expandable_fields_dependencies_map: Dictionary where keys are dependency fields and values are lists of dependent fields
             field_modification_processors: List of processor functions that handle that field's data
         """
+
         def decorator(func: Callable[..., Awaitable[BaseServiceRESTControllerResults]]):
             @wraps(func)
             async def wrapper(*args, **kwargs):
-                #* Call the original function
+                # * Call the original function
                 result = await func(*args, **kwargs)
 
                 if not isinstance(result.content, Dict):
                     return result
 
-                #* Recursive function to apply modification processors
-                def recursive_modify(data: Union[Dict, List]):
+                # * Recursive function to apply modification processors
+                def recursive_modify(data: BaseTypes.ListOrDictOfAny):
                     if isinstance(data, list):
                         for idx, item in enumerate(data):
                             data[idx] = recursive_modify(item)
                         return data
                     elif isinstance(data, Dict):
-                        #* Apply each processor to current dict
+                        # * Apply each processor to current dict
                         parameters = (
-                            BaseGeneralParametersTransfers
-                            .FieldModificationProcessor(data=data)
+                            BaseGeneralParametersTransfers.FieldModificationProcessor(
+                                data=data
+                            )
                         )
                         for processor in field_modification_processors or []:
                             data = processor(parameters)
+                        data = cast(BaseTypes.StringToAnyDict, data)
                         for key in data.keys():
                             if isinstance(data[key], (Dict, List)):
                                 data[key] = recursive_modify(data[key])
@@ -132,7 +152,7 @@ class BaseControllerUtils:
                     else:
                         return data
 
-                #* Process modifications recursively if needed
+                # * Process modifications recursively if needed
                 if (
                     result.success
                     and result.content.get("data", None) is not None
@@ -140,8 +160,10 @@ class BaseControllerUtils:
                 ):
                     data = result.content["data"]
                     result.content["data"] = recursive_modify(data)
-                    result.process_response()
+                    result.response
 
                 return result
+
             return wrapper
-        return decorator
+
+        return decorator

maleo_foundation/utils/dependencies/__init__.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 from .auth import AuthDependencies
 
+
 class BaseDependencies:
-    Auth = AuthDependencies
+    Auth = AuthDependencies

maleo_foundation/utils/dependencies/auth.py

@@ -4,21 +4,14 @@ from fastapi.security import HTTPAuthorizationCredentials
 from maleo_foundation.authentication import Authentication
 from maleo_foundation.authorization import TOKEN_SCHEME, Authorization
 
+
 class AuthDependencies:
     @staticmethod
-    def authentication(
-        request: Request
-    ) -> Authentication:
-        return Authentication(
-            credentials=request.auth,
-            user=request.user
-        )
+    def authentication(request: Request) -> Authentication:
+        return Authentication(credentials=request.auth, user=request.user)
 
     @staticmethod
     def authorization(
-        token: HTTPAuthorizationCredentials = Security(TOKEN_SCHEME)
+        token: HTTPAuthorizationCredentials = Security(TOKEN_SCHEME),
     ) -> Authorization:
-        return Authorization(
-            scheme=token.scheme,
-            credentials=token.credentials
-        )
+        return Authorization(scheme=token.scheme, credentials=token.credentials)

maleo_foundation/utils/dependencies/context.py

@@ -1,9 +1,8 @@
 from fastapi.requests import Request
 from maleo_foundation.models.transfers.general.request import RequestContext
 
+
 class ContextDependencies:
     @staticmethod
-    def get_request_context(
-        request: Request
-    ) -> RequestContext:
-        return request.state.request_context
+    def get_request_context(request: Request) -> RequestContext:
+        return request.state.request_context

maleo_foundation/utils/exceptions.py

@@ -9,61 +9,68 @@ from starlette.exceptions import HTTPException as StarletteHTTPException
 from sqlalchemy.exc import SQLAlchemyError
 from typing import Optional
 from maleo_foundation.models.responses import BaseResponses
-from maleo_foundation.models.transfers.results.service.general \
-    import BaseServiceGeneralResultsTransfers
-from maleo_foundation.models.transfers.results.service.repository \
-    import BaseServiceRepositoryResultsTransfers
+from maleo_foundation.models.transfers.results.service.general import (
+    BaseServiceGeneralResultsTransfers,
+)
 from maleo_foundation.utils.logging import BaseLogger
 
+
 class BaseExceptions:
     @staticmethod
     def authentication_error_handler(request: Request, exc: Exception):
         return JSONResponse(
-            content=BaseResponses.Unauthorized(other=str(exc)).model_dump(mode="json"),
-            status_code=status.HTTP_401_UNAUTHORIZED
+            content=BaseResponses.Unauthorized(other=str(exc)).model_dump(mode="json"),  # type: ignore
+            status_code=status.HTTP_401_UNAUTHORIZED,
         )
 
     @staticmethod
-    async def validation_exception_handler(request: Request, exc: RequestValidationError):
+    async def validation_exception_handler(
+        request: Request, exc: RequestValidationError
+    ):
         serialized_error = jsonable_encoder(exc.errors())
         return JSONResponse(
-            content=BaseResponses.ValidationError(other=serialized_error).model_dump(mode="json"),
-            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY
+            content=BaseResponses.ValidationError(other=serialized_error).model_dump(mode="json"),  # type: ignore
+            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
         )
 
     @staticmethod
     async def http_exception_handler(request: Request, exc: StarletteHTTPException):
         if exc.status_code in BaseResponses.other_responses:
             return JSONResponse(
-                content=BaseResponses.other_responses[exc.status_code]["model"]().model_dump(mode="json"),
-                status_code=exc.status_code
+                content=BaseResponses.other_responses[exc.status_code]["model"]().model_dump(mode="json"),  # type: ignore
+                status_code=exc.status_code,
             )
 
         return JSONResponse(
-            content=BaseResponses.ServerError().model_dump(mode="json"),
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR
+            content=BaseResponses.ServerError().model_dump(mode="json"),  # type: ignore
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
         )
 
     @staticmethod
     def repository_exception_handler(
         operation: str,
         logger: Optional[BaseLogger] = None,
-        fail_result_class: type[BaseServiceRepositoryResultsTransfers.Fail] = BaseServiceRepositoryResultsTransfers.Fail
+        fail_result_class: type[
+            BaseServiceGeneralResultsTransfers.Fail
+        ] = BaseServiceGeneralResultsTransfers.Fail,
     ):
         """Decorator to handle repository-related exceptions consistently for sync and async functions."""
+
         def decorator(func):
             def _handler(e: Exception, category: str, description: str):
                 if logger:
                     logger.error(
                         f"{category} occurred while {operation}: '{str(e)}'",
-                        exc_info=True
+                        exc_info=True,
                     )
                 return fail_result_class(
                     message=f"Failed {operation}",
                     description=description,
-                    other=category
-                )
+                    other=category,
+                )  # type: ignore
+
             if asyncio.iscoroutinefunction(func):
+
                 @wraps(func)
                 async def async_wrapper(*args, **kwargs):
                     try:
@@ -72,22 +79,24 @@ class BaseExceptions:
                         return _handler(
                             e,
                             category="Validation error",
-                            description=f"A validation error occurred while {operation}. Please try again later or contact administrator."
+                            description=f"A validation error occurred while {operation}. Please try again later or contact administrator.",
                         )
                     except SQLAlchemyError as e:
                         return _handler(
                             e,
                             category="Database operation failed",
-                            description=f"A database error occurred while {operation}. Please try again later or contact administrator."
+                            description=f"A database error occurred while {operation}. Please try again later or contact administrator.",
                         )
                     except Exception as e:
                         return _handler(
                             e,
                             category="Internal processing error",
-                            description=f"An unexpected error occurred while {operation}. Please try again later or contact administrator."
+                            description=f"An unexpected error occurred while {operation}. Please try again later or contact administrator.",
                         )
+
                 return async_wrapper
             else:
+
                 @wraps(func)
                 def sync_wrapper(*args, **kwargs):
                     try:
@@ -96,41 +105,54 @@ class BaseExceptions:
                         return _handler(
                             e,
                             category="Validation error",
-                            description=f"A validation error occurred while {operation}. Please try again later or contact administrator."
+                            description=f"A validation error occurred while {operation}. Please try again later or contact administrator.",
                         )
                     except SQLAlchemyError as e:
                         return _handler(
                             e,
                             category="Database operation failed",
-                            description=f"A database error occurred while {operation}. Please try again later or contact administrator."
+                            description=f"A database error occurred while {operation}. Please try again later or contact administrator.",
                         )
                     except Exception as e:
                         return _handler(
                             e,
                             category="Internal processing error",
-                            description=f"An unexpected error occurred while {operation}. Please try again later or contact administrator."
+                            description=f"An unexpected error occurred while {operation}. Please try again later or contact administrator.",
                         )
+
                 return sync_wrapper
+
         return decorator
 
     @staticmethod
     def service_exception_handler(
         operation: str,
         logger: Optional[BaseLogger] = None,
-        fail_result_class: type[BaseServiceGeneralResultsTransfers.Fail] = BaseServiceGeneralResultsTransfers.Fail
+        fail_result_class: type[
+            BaseServiceGeneralResultsTransfers.Fail
+        ] = BaseServiceGeneralResultsTransfers.Fail,
     ):
         """Decorator to handle service-related exceptions consistently."""
+
         def decorator(func):
             @wraps(func)
             def wrapper(*args, **kwargs):
                 try:
                     return func(*args, **kwargs)
                 except Exception as e:
-                    logger.error("Unexpected error occurred while %s: '%s'", operation, str(e), exc_info=True)
+                    if logger:
+                        logger.error(
+                            "Unexpected error occurred while %s: '%s'",
+                            operation,
+                            str(e),
+                            exc_info=True,
+                        )
                     return fail_result_class(
                         message=f"Failed {operation}",
                         description=f"An unexpected error occurred while {operation}. Please try again later or contact administrator.",
-                        other="Internal processing error"
-                    )
+                        other="Internal processing error",
+                    )  # type: ignore
+
             return wrapper
-        return decorator
+
+        return decorator

maleo_foundation/utils/extractor.py

@@ -1,32 +1,36 @@
 from datetime import datetime, timezone
 from fastapi import Request
 from starlette.requests import HTTPConnection
-from uuid import uuid4
+from uuid import UUID, uuid4
 from maleo_foundation.models.transfers.general.request import RequestContext
 
+
 def extract_client_ip(conn: HTTPConnection) -> str:
     """Extract client IP with more robust handling of proxies"""
-    #* Check for X-Forwarded-For header (common when behind proxy/load balancer)
+    # * Check for X-Forwarded-For header (common when behind proxy/load balancer)
     x_forwarded_for = conn.headers.get("X-Forwarded-For")
     if x_forwarded_for:
-        #* The client's IP is the first one in the list
+        # * The client's IP is the first one in the list
         ips = [ip.strip() for ip in x_forwarded_for.split(",")]
         return ips[0]
 
-    #* Check for X-Real-IP header (used by some proxies)
+    # * Check for X-Real-IP header (used by some proxies)
     x_real_ip = conn.headers.get("X-Real-IP")
     if x_real_ip:
         return x_real_ip
 
-    #* Fall back to direct client connection
+    # * Fall back to direct client connection
     return conn.client.host if conn.client else "unknown"
 
+
 def extract_request_context(request: Request) -> RequestContext:
     headers = request.headers
 
     request_id = headers.get("x-request-id")
     if request_id is None:
         request_id = uuid4()
+    else:
+        request_id = UUID(request_id)
 
     ip_address = extract_client_ip(request)
 
@@ -42,7 +46,15 @@ def extract_request_context(request: Request) -> RequestContext:
         path_params=None if not request.path_params else request.path_params,
         query_params=None if not request.query_params else str(request.query_params),
         ip_address=ip_address,
-        is_internal=None if ip_address=="unknown" else (ip_address.startswith("10.") or ip_address.startswith("192.168.") or ip_address.startswith("172.")),
+        is_internal=(
+            None
+            if ip_address == "unknown"
+            else (
+                ip_address.startswith("10.")
+                or ip_address.startswith("192.168.")
+                or ip_address.startswith("172.")
+            )
+        ),
         user_agent=headers.get("user-agent"),
         ua_browser=ua_browser,
         ua_mobile=headers.get("sec-ch-ua-mobile"),

maleo_foundation/utils/formatter/__init__.py

@@ -1,4 +1,5 @@
 from .case import CaseFormatter
 
+
 class BaseFormatter:
-    Case = CaseFormatter
+    Case = CaseFormatter

maleo_foundation/utils/formatter/case.py

@@ -1,6 +1,7 @@
 import re
 from enum import StrEnum
 
+
 class CaseFormatter:
     class Case(StrEnum):
         CAMEL = "camel"
@@ -10,19 +11,19 @@ class CaseFormatter:
     @staticmethod
     def to_camel_case(text: str) -> str:
         """Converts snake_case or PascalCase to camelCase."""
-        words = re.split(r'[_\s]', text)  # Handle snake_case and spaces
+        words = re.split(r"[_\s]", text)  # Handle snake_case and spaces
         return words[0].lower() + "".join(word.capitalize() for word in words[1:])
 
     @staticmethod
     def to_pascal_case(text: str) -> str:
         """Converts snake_case or camelCase to PascalCase."""
-        words = re.split(r'[_\s]', text)
+        words = re.split(r"[_\s]", text)
         return "".join(word.capitalize() for word in words)
 
     @staticmethod
     def to_snake_case(text: str) -> str:
         """Converts camelCase or PascalCase to snake_case."""
-        return re.sub(r'([a-z0-9])([A-Z])', r'\1_\2', text).lower()
+        return re.sub(r"([a-z0-9])([A-Z])", r"\1_\2", text).lower()
 
     @staticmethod
     def convert(text: str, target: Case) -> str:
@@ -34,4 +35,4 @@ class CaseFormatter:
         elif target == CaseFormatter.Case.SNAKE:
             return CaseFormatter.to_snake_case(text)
         else:
-            raise ValueError(f"Invalid target case: {target}.")
+            raise ValueError(f"Invalid target case: {target}.")

maleo_foundation/utils/loaders/__init__.py

@@ -4,8 +4,9 @@ from .json import JSONLoader
 from .key import KeyLoaders
 from .yaml import YAMLLoader
 
+
 class BaseLoaders:
     Credential = CredentialLoaders
     JSON = JSONLoader
     Key = KeyLoaders
-    YAML = YAMLLoader
+    YAML = YAMLLoader

maleo_foundation/utils/loaders/credential/__init__.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 from .google import GoogleCredentialsLoader
 
+
 class CredentialLoaders:
-    Google = GoogleCredentialsLoader
+    Google = GoogleCredentialsLoader