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

maleo_foundation/models/transfers/results/__init__.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 from .service import BaseServiceResultsTransfers
 from .client import BaseClientResultsTransfers
 
+
 class BaseResultsTransfers:
     Service = BaseServiceResultsTransfers
-    Client = BaseClientResultsTransfers
+    Client = BaseClientResultsTransfers

maleo_foundation/models/transfers/results/client/__init__.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 from .service import BaseClientServiceResultsTransfers
 from .controllers import BaseClientControllersResultsTransfers
 
+
 class BaseClientResultsTransfers:
     Service = BaseClientServiceResultsTransfers
-    Controller = BaseClientControllersResultsTransfers
+    Controller = BaseClientControllersResultsTransfers

maleo_foundation/models/transfers/results/client/controllers/__init__.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 from .http import BaseClientHTTPControllerResults
 
+
 class BaseClientControllersResultsTransfers:
-    HTTP = BaseClientHTTPControllerResults
+    HTTP = BaseClientHTTPControllerResults

maleo_foundation/models/transfers/results/client/controllers/http.py

@@ -3,32 +3,35 @@ from httpx import Response
 from pydantic import BaseModel, ConfigDict, Field, model_validator
 from typing import Any
 
+
 class BaseClientHTTPControllerResults(BaseModel):
     model_config = ConfigDict(arbitrary_types_allowed=True)
 
     response: Response = Field(..., description="Client's HTTP Controller response")
-    status_code: int = Field(..., description="Client's HTTP Controller response status code")
+    status_code: int = Field(
+        ..., description="Client's HTTP Controller response status code"
+    )
     content: Any = Field(..., description="Client's HTTP Controller response content")
     success: bool = Field(..., description="Client's HTTP Controller success status")
 
     @model_validator(mode="before")
     @classmethod
-    def process_response(cls, values:dict) -> dict:
+    def process_response(cls, values: dict) -> dict:
         """Process the response to set status_code, content, and success."""
-        response:Response = values.get("response")
+        response: Response = values.get("response")
 
         if response:
             values["status_code"] = response.status_code
             values["success"] = response.is_success
 
-            #* Determine content type and parse accordingly
-            content_type:str = response.headers.get("content-type", "")
+            # * Determine content type and parse accordingly
+            content_type: str = response.headers.get("content-type", "")
             content_type = content_type.lower()
             if "application/json" in content_type:
                 values["content"] = response.json()
             elif "text/" in content_type or "application/xml" in content_type:
                 values["content"] = response.text
             else:
-                values["content"] = response.content  #* Raw bytes for unknown types
+                values["content"] = response.content  # * Raw bytes for unknown types
 
-        return values
+        return values

maleo_foundation/models/transfers/results/client/service.py

@@ -2,16 +2,22 @@ from __future__ import annotations
 from pydantic import model_validator
 from maleo_foundation.models.schemas.result import BaseResultSchemas
 
+
 class BaseClientServiceResultsTransfers:
-    class Fail(BaseResultSchemas.Fail): pass
+    class Fail(BaseResultSchemas.Fail):
+        pass
 
-    class NotFound(BaseResultSchemas.NotFound): pass
+    class NotFound(BaseResultSchemas.NotFound):
+        pass
 
-    class NoData(BaseResultSchemas.NoData): pass
+    class NoData(BaseResultSchemas.NoData):
+        pass
 
-    class SingleData(BaseResultSchemas.SingleData): pass
+    class SingleData(BaseResultSchemas.SingleData):
+        pass
 
-    class UnpaginatedMultipleData(BaseResultSchemas.UnpaginatedMultipleData): pass
+    class UnpaginatedMultipleData(BaseResultSchemas.UnpaginatedMultipleData):
+        pass
 
     class PaginatedMultipleData(BaseResultSchemas.PaginatedMultipleData):
         @model_validator(mode="before")
@@ -26,4 +32,4 @@ class BaseClientServiceResultsTransfers:
             values["limit"] = pagination.limit
             values["total_data"] = pagination.total_data
 
-            return values
+            return values

maleo_foundation/models/transfers/results/encryption/__init__.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 from .aes import MaleoFoundationAESEncryptionResultsTransfers
 from .rsa import MaleoFoundationRSAEncryptionResultsTransfers
 
+
 class BaseEncryptionResultsTransfers:
     AES = MaleoFoundationAESEncryptionResultsTransfers
-    RSA = MaleoFoundationRSAEncryptionResultsTransfers
+    RSA = MaleoFoundationRSAEncryptionResultsTransfers

maleo_foundation/models/transfers/results/encryption/aes.py

@@ -1,18 +1,26 @@
 from pydantic import Field
-from maleo_foundation.models.transfers.results.service.general import BaseServiceGeneralResultsTransfers
+from maleo_foundation.models.transfers.results.service.general import (
+    BaseServiceGeneralResultsTransfers,
+)
 from maleo_foundation.models.schemas.encryption import MaleoFoundationEncryptionSchemas
 
+
 class EncryptData(
     MaleoFoundationEncryptionSchemas.Ciphertext,
     MaleoFoundationEncryptionSchemas.InitializationVector,
-    MaleoFoundationEncryptionSchemas.Key
-): pass
+    MaleoFoundationEncryptionSchemas.Key,
+):
+    pass
+
 
 class MaleoFoundationAESEncryptionResultsTransfers:
-    class Fail(BaseServiceGeneralResultsTransfers.Fail): pass
+    class Fail(BaseServiceGeneralResultsTransfers.Fail):
+        pass
 
     class Encrypt(BaseServiceGeneralResultsTransfers.SingleData):
         data: EncryptData = Field(..., description="Single encryption data")
 
     class Decrypt(BaseServiceGeneralResultsTransfers.SingleData):
-        data: MaleoFoundationEncryptionSchemas.Plaintext = Field(..., description="Single decryption data")
+        data: MaleoFoundationEncryptionSchemas.Plaintext = Field(
+            ..., description="Single decryption data"
+        )

maleo_foundation/models/transfers/results/encryption/rsa.py

@@ -1,12 +1,20 @@
 from pydantic import Field
-from maleo_foundation.models.transfers.results.service.general import BaseServiceGeneralResultsTransfers
+from maleo_foundation.models.transfers.results.service.general import (
+    BaseServiceGeneralResultsTransfers,
+)
 from maleo_foundation.models.schemas.encryption import MaleoFoundationEncryptionSchemas
 
+
 class MaleoFoundationRSAEncryptionResultsTransfers:
-    class Fail(BaseServiceGeneralResultsTransfers.Fail): pass
+    class Fail(BaseServiceGeneralResultsTransfers.Fail):
+        pass
 
     class Encrypt(BaseServiceGeneralResultsTransfers.SingleData):
-        data: MaleoFoundationEncryptionSchemas.Ciphertext = Field(..., description="Single encryption data")
+        data: MaleoFoundationEncryptionSchemas.Ciphertext = Field(
+            ..., description="Single encryption data"
+        )
 
     class Decrypt(BaseServiceGeneralResultsTransfers.SingleData):
-        data: MaleoFoundationEncryptionSchemas.Plaintext = Field(..., description="Single decryption data")
+        data: MaleoFoundationEncryptionSchemas.Plaintext = Field(
+            ..., description="Single decryption data"
+        )

maleo_foundation/models/transfers/results/hash.py

@@ -1,13 +1,17 @@
 from __future__ import annotations
 from pydantic import Field
-from maleo_foundation.models.transfers.results.service.general import BaseServiceGeneralResultsTransfers
+from maleo_foundation.models.transfers.results.service.general import (
+    BaseServiceGeneralResultsTransfers,
+)
 from maleo_foundation.models.schemas.hash import MaleoFoundationHashSchemas
 
+
 class MaleoFoundationHashResultsTransfers:
-    class Fail(BaseServiceGeneralResultsTransfers.Fail): pass
+    class Fail(BaseServiceGeneralResultsTransfers.Fail):
+        pass
 
     class Hash(BaseServiceGeneralResultsTransfers.SingleData):
         data: MaleoFoundationHashSchemas.Hash = Field(..., description="Hash data")
 
     class Verify(BaseServiceGeneralResultsTransfers.SingleData):
-        data: MaleoFoundationHashSchemas.IsValid = Field(..., description="Verify data")
+        data: MaleoFoundationHashSchemas.IsValid = Field(..., description="Verify data")

maleo_foundation/models/transfers/results/key.py

@@ -1,16 +1,28 @@
 from __future__ import annotations
 from pydantic import Field
-from maleo_foundation.models.transfers.results.service.general import BaseServiceGeneralResultsTransfers
-from maleo_foundation.models.transfers.general.key import MaleoFoundationKeyGeneralTransfers
+from maleo_foundation.models.transfers.results.service.general import (
+    BaseServiceGeneralResultsTransfers,
+)
+from maleo_foundation.models.transfers.general.key import (
+    MaleoFoundationKeyGeneralTransfers,
+)
+
 
 class MaleoFoundationKeyResultsTransfers:
-    class Fail(BaseServiceGeneralResultsTransfers.Fail): pass
+    class Fail(BaseServiceGeneralResultsTransfers.Fail):
+        pass
 
     class CreatePrivate(BaseServiceGeneralResultsTransfers.SingleData):
-        data: MaleoFoundationKeyGeneralTransfers.PrivateKey = Field(..., description="Private key data")
+        data: MaleoFoundationKeyGeneralTransfers.PrivateKey = Field(
+            ..., description="Private key data"
+        )
 
     class CreatePublic(BaseServiceGeneralResultsTransfers.SingleData):
-        data: MaleoFoundationKeyGeneralTransfers.PublicKey = Field(..., description="Private key data")
+        data: MaleoFoundationKeyGeneralTransfers.PublicKey = Field(
+            ..., description="Private key data"
+        )
 
     class CreatePair(BaseServiceGeneralResultsTransfers.SingleData):
-        data: MaleoFoundationKeyGeneralTransfers.KeyPair = Field(..., description="Key pair data")
+        data: MaleoFoundationKeyGeneralTransfers.KeyPair = Field(
+            ..., description="Key pair data"
+        )

maleo_foundation/models/transfers/results/service/__init__.py

@@ -1,9 +1,8 @@
 from __future__ import annotations
 from .general import BaseServiceGeneralResultsTransfers
-from .repository import BaseServiceRepositoryResultsTransfers
 from .controllers import BaseServiceControllerResultsTransfers
 
+
 class BaseServiceResultsTransfers:
     General = BaseServiceGeneralResultsTransfers
-    Repository = BaseServiceRepositoryResultsTransfers
-    Controller = BaseServiceControllerResultsTransfers
+    Controller = BaseServiceControllerResultsTransfers

maleo_foundation/models/transfers/results/service/controllers/__init__.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 from .rest import BaseServiceRESTControllerResults
 
+
 class BaseServiceControllerResultsTransfers:
-    REST = BaseServiceRESTControllerResults
+    REST = BaseServiceRESTControllerResults

maleo_foundation/models/transfers/results/service/controllers/rest.py

@@ -1,21 +1,24 @@
 from __future__ import annotations
 from fastapi import status, Response
 from typing import Any
-from pydantic import BaseModel, ConfigDict, Field, model_validator
+from pydantic import BaseModel, ConfigDict, Field
 from maleo_foundation.enums import BaseEnums
 
+
 class BaseServiceRESTControllerResults(BaseModel):
     model_config = ConfigDict(arbitrary_types_allowed=True)
 
-    success:bool = Field(..., description="REST Controller's success status")
-    response_type:BaseEnums.RESTControllerResponseType = Field(BaseEnums.RESTControllerResponseType.JSON, description="REST Controller's response class")
-    content:Any = Field(..., description="REST Controller's response content")
-    status_code:int = Field(status.HTTP_200_OK, description="REST Controller's response status code")
-    response:Response = Field(Response(), description="REST Controller's Response")
+    success: bool = Field(..., description="REST Controller's success status")
+    response_type: BaseEnums.RESTControllerResponseType = Field(
+        BaseEnums.RESTControllerResponseType.JSON,
+        description="REST Controller's response class",
+    )
+    content: Any = Field(..., description="REST Controller's response content")
+    status_code: int = Field(
+        status.HTTP_200_OK, description="REST Controller's response status code"
+    )
 
-    @model_validator(mode="after")
-    def process_response(self):
-        """Dynamically creates a response based on response_type."""
+    @property
+    def response(self) -> Response:
         response_cls = self.response_type.get_response_type()
-        self.response = response_cls(content=self.content, status_code=self.status_code)
-        return self
+        return response_cls(content=self.content, status_code=self.status_code)

maleo_foundation/models/transfers/results/service/general.py

@@ -2,16 +2,22 @@ from __future__ import annotations
 from pydantic import model_validator
 from maleo_foundation.models.schemas.result import BaseResultSchemas
 
+
 class BaseServiceGeneralResultsTransfers:
-    class Fail(BaseResultSchemas.Fail): pass
+    class Fail(BaseResultSchemas.Fail):
+        pass
 
-    class NotFound(BaseResultSchemas.NotFound): pass
+    class NotFound(BaseResultSchemas.NotFound):
+        pass
 
-    class NoData(BaseResultSchemas.NoData): pass
+    class NoData(BaseResultSchemas.NoData):
+        pass
 
-    class SingleData(BaseResultSchemas.SingleData): pass
+    class SingleData(BaseResultSchemas.SingleData):
+        pass
 
-    class UnpaginatedMultipleData(BaseResultSchemas.UnpaginatedMultipleData): pass
+    class UnpaginatedMultipleData(BaseResultSchemas.UnpaginatedMultipleData):
+        pass
 
     class PaginatedMultipleData(BaseResultSchemas.PaginatedMultipleData):
         @model_validator(mode="before")
@@ -21,19 +27,19 @@ class BaseServiceGeneralResultsTransfers:
             total_data = values.get("total_data", 0)
             data = values.get("data", [])
 
-            #* Get pagination values from inherited SimplePagination
+            # * Get pagination values from inherited SimplePagination
             page = values.get("page", 1)
             limit = values.get("limit", 10)
 
-            #* Calculate total pages
+            # * Calculate total pages
             total_pages = (total_data // limit) + (1 if total_data % limit > 0 else 0)
 
-            #* Assign computed pagination object before validation
+            # * Assign computed pagination object before validation
             values["pagination"] = BaseResultSchemas.ExtendedPagination(
                 page=page,
                 limit=limit,
                 data_count=len(data),
                 total_data=total_data,
-                total_pages=total_pages
+                total_pages=total_pages,
             )
-            return values
+            return values

maleo_foundation/models/transfers/results/signature.py

@@ -1,12 +1,20 @@
 from pydantic import Field
-from maleo_foundation.models.transfers.results.service.general import BaseServiceGeneralResultsTransfers
+from maleo_foundation.models.transfers.results.service.general import (
+    BaseServiceGeneralResultsTransfers,
+)
 from maleo_foundation.models.schemas.signature import MaleoFoundationSignatureSchemas
 
+
 class MaleoFoundationSignatureResultsTransfers:
-    class Fail(BaseServiceGeneralResultsTransfers.Fail): pass
+    class Fail(BaseServiceGeneralResultsTransfers.Fail):
+        pass
 
     class Sign(BaseServiceGeneralResultsTransfers.SingleData):
-        data: MaleoFoundationSignatureSchemas.Signature = Field(..., description="Single signature data")
+        data: MaleoFoundationSignatureSchemas.Signature = Field(
+            ..., description="Single signature data"
+        )
 
     class Verify(BaseServiceGeneralResultsTransfers.SingleData):
-        data: MaleoFoundationSignatureSchemas.IsValid = Field(..., description="Single verify data")
+        data: MaleoFoundationSignatureSchemas.IsValid = Field(
+            ..., description="Single verify data"
+        )

maleo_foundation/models/transfers/results/token.py

@@ -1,12 +1,18 @@
-from maleo_foundation.models.transfers.results.service.general import BaseServiceGeneralResultsTransfers
+from maleo_foundation.models.transfers.results.service.general import (
+    BaseServiceGeneralResultsTransfers,
+)
 from maleo_foundation.models.schemas.token import MaleoFoundationTokenSchemas
-from maleo_foundation.models.transfers.general.token import MaleoFoundationTokenGeneralTransfers
+from maleo_foundation.models.transfers.general.token import (
+    MaleoFoundationTokenGeneralTransfers,
+)
+
 
 class MaleoFoundationTokenResultsTransfers:
-    class Fail(BaseServiceGeneralResultsTransfers.Fail): pass
+    class Fail(BaseServiceGeneralResultsTransfers.Fail):
+        pass
 
     class Encode(BaseServiceGeneralResultsTransfers.SingleData):
         data: MaleoFoundationTokenSchemas.Token
 
     class Decode(BaseServiceGeneralResultsTransfers.SingleData):
-        data: MaleoFoundationTokenGeneralTransfers.DecodePayload
+        data: MaleoFoundationTokenGeneralTransfers.DecodePayload

maleo_foundation/rest_controller_result.py

@@ -1,59 +1,61 @@
 from fastapi import status
-from maleo_foundation.models.transfers.results.service.controllers.rest \
-    import BaseServiceRESTControllerResults
+from maleo_foundation.models.transfers.results.service.controllers.rest import (
+    BaseServiceRESTControllerResults,
+)
 from maleo_foundation.models.responses import BaseResponses
 
+
 class RESTControllerResultsConstants:
     BAD_REQUEST = BaseServiceRESTControllerResults(
         success=False,
-        content=BaseResponses.BadRequest().model_dump(),
-        status_code=status.HTTP_400_BAD_REQUEST
+        content=BaseResponses.BadRequest().model_dump(),  # type: ignore
+        status_code=status.HTTP_400_BAD_REQUEST,
     )
 
     INVALID_EXPAND = BaseServiceRESTControllerResults(
         success=False,
-        content=BaseResponses.InvalidExpand().model_dump(),
-        status_code=status.HTTP_400_BAD_REQUEST
+        content=BaseResponses.InvalidExpand().model_dump(),  # type: ignore
+        status_code=status.HTTP_400_BAD_REQUEST,
     )
 
     UNAUTHORIZED = BaseServiceRESTControllerResults(
         success=False,
-        content=BaseResponses.Unauthorized().model_dump(),
-        status_code=status.HTTP_401_UNAUTHORIZED
+        content=BaseResponses.Unauthorized().model_dump(),  # type: ignore
+        status_code=status.HTTP_401_UNAUTHORIZED,
     )
 
     FORBIDDEN = BaseServiceRESTControllerResults(
         success=False,
-        content=BaseResponses.Forbidden().model_dump(),
-        status_code=status.HTTP_403_FORBIDDEN
+        content=BaseResponses.Forbidden().model_dump(),  # type: ignore
+        status_code=status.HTTP_403_FORBIDDEN,
     )
 
     METHOD_NOT_ALLOWED = BaseServiceRESTControllerResults(
         success=False,
-        content=BaseResponses.MethodNotAllowed().model_dump(),
-        status_code=status.HTTP_405_METHOD_NOT_ALLOWED
+        content=BaseResponses.MethodNotAllowed().model_dump(),  # type: ignore
+        status_code=status.HTTP_405_METHOD_NOT_ALLOWED,
     )
 
     VALIDATION_ERROR = BaseServiceRESTControllerResults(
         success=False,
-        content=BaseResponses.ValidationError().model_dump(),
-        status_code=status.HTTP_422_UNPROCESSABLE_ENTITY
+        content=BaseResponses.ValidationError().model_dump(),  # type: ignore
+        status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
     )
 
     RATE_LIMIT_EXCEEDED = BaseServiceRESTControllerResults(
         success=False,
-        content=BaseResponses.RateLimitExceeded().model_dump(),
-        status_code=status.HTTP_429_TOO_MANY_REQUESTS
+        content=BaseResponses.RateLimitExceeded().model_dump(),  # type: ignore
+        status_code=status.HTTP_429_TOO_MANY_REQUESTS,
     )
 
     SERVER_ERROR = BaseServiceRESTControllerResults(
         success=False,
-        content=BaseResponses.ServerError().model_dump(),
-        status_code=status.HTTP_500_INTERNAL_SERVER_ERROR
+        content=BaseResponses.ServerError().model_dump(),  # type: ignore
+        status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
     )
 
     NOT_IMPLEMENTED = BaseServiceRESTControllerResults(
         success=False,
-        content=BaseResponses.NotImplemented().model_dump(),
-        status_code=status.HTTP_501_NOT_IMPLEMENTED
-    )
+        content=BaseResponses.NotImplemented().model_dump(),  # type: ignore
+        status_code=status.HTTP_501_NOT_IMPLEMENTED,
+    )

maleo_foundation/types.py

@@ -3,39 +3,40 @@ from typing import Dict, Optional, Union, Literal, List, Any
 from uuid import UUID
 from maleo_foundation.enums import BaseEnums
 
+
 class BaseTypes:
-    #* Any-related types
+    # * Any-related types
     ListOfAny = List[Any]
     OptionalAny = Optional[Any]
 
-    #* Boolean-related types
+    # * Boolean-related types
     LiteralFalse = Literal[False]
     LiteralTrue = Literal[True]
     ListOfBools = List[bool]
     OptionalBoolean = Optional[bool]
 
-    #* Float-related types
+    # * Float-related types
     ListOfFloats = List[float]
     OptionalFloat = Optional[float]
     OptionalListOfFloats = Optional[List[float]]
 
-    #* Integer-related types
+    # * Integer-related types
     ListOfIntegers = List[int]
     OptionalInteger = Optional[int]
     OptionalListOfIntegers = Optional[List[int]]
 
-    #* String-related types
+    # * String-related types
     ListOfStrings = List[str]
     OptionalString = Optional[str]
     OptionalListOfStrings = Optional[List[str]]
 
-    #* Date-related types
+    # * Date-related types
     OptionalDate = Optional[date]
 
-    #* Datetime-related types
+    # * Datetime-related types
     OptionalDatetime = Optional[datetime]
 
-    #* Any Dict-related types
+    # * Any Dict-related types
     StringToAnyDict = Dict[str, Any]
     OptionalStringToAnyDict = Optional[Dict[str, Any]]
     ListOfStringToAnyDict = List[Dict[str, Any]]
@@ -45,7 +46,7 @@ class BaseTypes:
     ListOfIntToAnyDict = List[Dict[int, Any]]
     OptionalListOfIntToAnyDict = Optional[List[Dict[int, Any]]]
 
-    #* String Dict-related types
+    # * String Dict-related types
     StringToStringDict = Dict[str, str]
     OptionalStringToStringDict = Optional[Dict[str, str]]
     ListOfStringToStringDict = List[Dict[str, str]]
@@ -55,19 +56,19 @@ class BaseTypes:
     ListOfIntToStringDict = List[Dict[int, str]]
     OptionalListOfIntToStringDict = Optional[List[Dict[int, str]]]
 
-    #* List Dict-related types
+    # * List Dict-related types
     StringToListOfStringDict = Dict[str, List[str]]
     OptionalStringToListOfStringDict = Optional[Dict[str, List[str]]]
 
-    #* UUID-related types
+    # * UUID-related types
     ListOfUUIDs = List[UUID]
     OptionalUUID = Optional[UUID]
     OptionalListOfUUIDs = Optional[List[UUID]]
 
-    #* Statuses-related types
+    # * Statuses-related types
     ListOfStatuses = List[BaseEnums.StatusType]
     OptionalListOfStatuses = Optional[List[BaseEnums.StatusType]]
 
-    #* Miscellanous types
+    # * Miscellanous types
     IdentifierValue = Union[int, UUID, str]
-    ListOrDictOfAny = Union[List[Any], Dict[str, Any]]
+    ListOrDictOfAny = Union[List[Any], Dict[str, Any]]

maleo_foundation/utils/__init__.py

@@ -5,9 +5,10 @@ from .loaders import BaseLoaders
 from .controller import BaseControllerUtils
 from .query import BaseQueryUtils
 
+
 class BaseUtils:
     Formatter = BaseFormatter
     Exceptions = BaseExceptions
     Loaders = BaseLoaders
     Controller = BaseControllerUtils
-    Query = BaseQueryUtils
+    Query = BaseQueryUtils

maleo_foundation/utils/cache.py

@@ -3,11 +3,8 @@ from fastapi.encoders import jsonable_encoder
 from pydantic import BaseModel
 from typing import Callable
 
-def key_builder(
-    func: Callable,
-    *args,
-    **kwargs
-) -> str:
+
+def key_builder(func: Callable, *args, **kwargs) -> str:
     arg_values = []
     for arg in args:
         try:
@@ -21,7 +18,7 @@ def key_builder(
     kwarg_values = {}
     for k, v in kwargs.items():
         try:
-            if isinstance(v, BaseModel) and hasattr(arg, "model_dump"):
+            if isinstance(v, BaseModel) and hasattr(v, "model_dump"):
                 kwarg_values[k] = v.model_dump(mode="json")
             else:
                 kwarg_values[k] = jsonable_encoder(v)
@@ -30,11 +27,11 @@ def key_builder(
 
     serialized_args = json.dumps(arg_values, sort_keys=True)
     serialized_kwargs = json.dumps(kwarg_values, sort_keys=True)
-    
-    return f"{func.__module__}:{func.__qualname__}({serialized_args}|{serialized_kwargs})"
 
-def build_key(
-    *ext: str,
-    namespace: str
-):
-    return ":".join([namespace, *ext])
+    return (
+        f"{func.__module__}:{func.__qualname__}({serialized_args}|{serialized_kwargs})"
+    )
+
+
+def build_key(*ext: str, namespace: str):
+    return ":".join([namespace, *ext])