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

maleo_foundation/authentication.py

@@ -2,17 +2,21 @@ from pydantic import BaseModel, ConfigDict, Field, model_validator
 from starlette.authentication import AuthCredentials, BaseUser
 from typing import Optional, Self, Sequence
 from maleo_foundation.enums import BaseEnums
-from maleo_foundation.models.transfers.general.token import MaleoFoundationTokenGeneralTransfers
+from maleo_foundation.models.transfers.general.token import (
+    MaleoFoundationTokenGeneralTransfers,
+)
+
 
 class Token(BaseModel):
     type: BaseEnums.TokenType = Field(..., description="Token's type")
-    payload: MaleoFoundationTokenGeneralTransfers.DecodePayload = Field(..., description="Token's payload")
+    payload: MaleoFoundationTokenGeneralTransfers.DecodePayload = Field(
+        ..., description="Token's payload"
+    )
+
 
 class Credentials(AuthCredentials):
     def __init__(
-        self,
-        token: Optional[Token] = None,
-        scopes: Optional[Sequence[str]] = None
+        self, token: Optional[Token] = None, scopes: Optional[Sequence[str]] = None
     ) -> None:
         self._token = token
         super().__init__(scopes)
@@ -21,16 +25,15 @@ class Credentials(AuthCredentials):
     def token(self) -> Optional[Token]:
         return self._token
 
+
 class CredentialsModel(BaseModel):
     token: Optional[Token] = Field(None, description="Token")
     scopes: Optional[Sequence[str]] = Field(None, description="Scopes")
 
+
 class User(BaseUser):
     def __init__(
-        self,
-        authenticated: bool = True,
-        username: str = "",
-        email: str = ""
+        self, authenticated: bool = True, username: str = "", email: str = ""
     ) -> None:
         self._authenticated = authenticated
         self._username = username
@@ -48,18 +51,26 @@ class User(BaseUser):
     def identity(self) -> str:
         return self._email
 
+
 class UserModel(BaseModel):
     is_authenticated: bool = Field(True, description="Authenticated")
     display_name: str = Field("", description="Username")
     identity: str = Field("", description="Email")
 
+
 class Authentication(BaseModel):
     model_config = ConfigDict(arbitrary_types_allowed=True)
 
-    credentials: Credentials = Field(..., description="Credentials's information", exclude=True)
-    credentials_model: CredentialsModel = Field(default_factory=CredentialsModel, description="Credential's model", serialization_alias="credentials")
+    credentials: Credentials = Field(
+        ..., description="Credentials's information", exclude=True
+    )
+    credentials_model: CredentialsModel = Field(
+        default_factory=CredentialsModel,  # type: ignore
+        description="Credential's model",
+        serialization_alias="credentials",
+    )
     user: User = Field(..., description="User's information", exclude=True)
-    user_model: UserModel = Field(default_factory=UserModel, description="User's model", serialization_alias="user")
+    user_model: UserModel = Field(default_factory=UserModel, description="User's model", serialization_alias="user")  # type: ignore
 
     @model_validator(mode="after")
     def define_models(self) -> Self:
@@ -68,4 +79,4 @@ class Authentication(BaseModel):
         self.user_model.is_authenticated = self.user.is_authenticated
         self.user_model.display_name = self.user.display_name
         self.user_model.identity = self.user.identity
-        return self
+        return self

maleo_foundation/authorization.py

@@ -3,6 +3,7 @@ from pydantic import BaseModel, Field
 
 TOKEN_SCHEME = HTTPBearer()
 
+
 class Authorization(BaseModel):
     scheme: str = Field(..., description="Authorization's scheme")
-    credentials: str = Field(..., description="Authorization's credentials")
+    credentials: str = Field(..., description="Authorization's credentials")

maleo_foundation/client/manager.py

@@ -4,12 +4,12 @@ from maleo_foundation.types import BaseTypes
 from maleo_foundation.utils.logging import SimpleConfig
 from maleo_foundation.client.services.encryption import (
     MaleoFoundationAESEncryptionClientService,
-    MaleoFoundationRSAEncryptionClientService
+    MaleoFoundationRSAEncryptionClientService,
 )
 from maleo_foundation.client.services.hash import (
     MaleoFoundationSHA256HashClientService,
     MaleoFoundationHMACHashClientService,
-    MaleoFoundationBcryptHashClientService
+    MaleoFoundationBcryptHashClientService,
 )
 from maleo_foundation.client.services import (
     MaleoFoundationEncryptionServices,
@@ -17,42 +17,43 @@ from maleo_foundation.client.services import (
     MaleoFoundationKeyClientService,
     MaleoFoundationSignatureClientService,
     MaleoFoundationTokenClientService,
-    MaleoFoundationServices
+    MaleoFoundationServices,
 )
 
+
 class MaleoFoundationClientManager(ClientManager):
     def __init__(
-        self,
-        log_config: SimpleConfig,
-        service_key: BaseTypes.OptionalString = None
+        self, log_config: SimpleConfig, service_key: BaseTypes.OptionalString = None
     ) -> None:
         key = "maleo-foundation"
         name = "MaleoFoundation"
-        super().__init__(
-            key,
-            name,
-            log_config,
-            service_key
-        )
+        super().__init__(key, name, log_config, service_key)
         self._initialize_services()
         self._logger.info("Client manager initialized successfully")
 
     def _initialize_services(self):
         super()._initialize_services()
-        aes_encryption_service = MaleoFoundationAESEncryptionClientService(logger=self._logger)
-        rsa_encryption_service = MaleoFoundationRSAEncryptionClientService(logger=self._logger)
+        aes_encryption_service = MaleoFoundationAESEncryptionClientService(
+            logger=self._logger
+        )
+        rsa_encryption_service = MaleoFoundationRSAEncryptionClientService(
+            logger=self._logger
+        )
         encryption_services = MaleoFoundationEncryptionServices(
-            aes=aes_encryption_service,
-            rsa=rsa_encryption_service
+            aes=aes_encryption_service, rsa=rsa_encryption_service
         )
         key_service = MaleoFoundationKeyClientService(logger=self._logger)
-        bcrypt_hash_service = MaleoFoundationBcryptHashClientService(logger=self._logger)
+        bcrypt_hash_service = MaleoFoundationBcryptHashClientService(
+            logger=self._logger
+        )
         hmac_hash_service = MaleoFoundationHMACHashClientService(logger=self._logger)
-        sha256_hash_service = MaleoFoundationSHA256HashClientService(logger=self._logger)
+        sha256_hash_service = MaleoFoundationSHA256HashClientService(
+            logger=self._logger
+        )
         hash_services = MaleoFoundationHashServices(
             bcrypt=bcrypt_hash_service,
             hmac=hmac_hash_service,
-            sha256=sha256_hash_service
+            sha256=sha256_hash_service,
         )
         signature_service = MaleoFoundationSignatureClientService(logger=self._logger)
         token_service = MaleoFoundationTokenClientService(logger=self._logger)
@@ -61,9 +62,9 @@ class MaleoFoundationClientManager(ClientManager):
             hash=hash_services,
             key=key_service,
             signature=signature_service,
-            token=token_service
+            token=token_service,
         )
 
     @property
     def services(self) -> MaleoFoundationServices:
-        return self._services
+        return self._services

maleo_foundation/client/services/__init__.py

@@ -1,15 +1,24 @@
 from __future__ import annotations
 from pydantic import Field
 from maleo_foundation.managers.client.base import ClientServices
-from maleo_foundation.client.services.encryption import MaleoFoundationEncryptionServices
+from maleo_foundation.client.services.encryption import (
+    MaleoFoundationEncryptionServices,
+)
 from maleo_foundation.client.services.hash import MaleoFoundationHashServices
 from maleo_foundation.client.services.key import MaleoFoundationKeyClientService
-from maleo_foundation.client.services.signature import MaleoFoundationSignatureClientService
+from maleo_foundation.client.services.signature import (
+    MaleoFoundationSignatureClientService,
+)
 from maleo_foundation.client.services.token import MaleoFoundationTokenClientService
 
+
 class MaleoFoundationServices(ClientServices):
-    encryption:MaleoFoundationEncryptionServices = Field(..., description="Encryption's services")
-    hash:MaleoFoundationHashServices = Field(..., description="Hash's services")
-    key:MaleoFoundationKeyClientService = Field(..., description="Key's service")
-    signature:MaleoFoundationSignatureClientService = Field(..., description="Signature's service")
-    token:MaleoFoundationTokenClientService = Field(..., description="Token's service")
+    encryption: MaleoFoundationEncryptionServices = Field(
+        ..., description="Encryption's services"
+    )
+    hash: MaleoFoundationHashServices = Field(..., description="Hash's services")
+    key: MaleoFoundationKeyClientService = Field(..., description="Key's service")
+    signature: MaleoFoundationSignatureClientService = Field(
+        ..., description="Signature's service"
+    )
+    token: MaleoFoundationTokenClientService = Field(..., description="Token's service")

maleo_foundation/client/services/encryption/__init__.py

@@ -1,9 +1,18 @@
 from __future__ import annotations
 from pydantic import Field
 from maleo_foundation.managers.client.base import ClientServices
-from maleo_foundation.client.services.encryption.aes import MaleoFoundationAESEncryptionClientService
-from maleo_foundation.client.services.encryption.rsa import MaleoFoundationRSAEncryptionClientService
+from maleo_foundation.client.services.encryption.aes import (
+    MaleoFoundationAESEncryptionClientService,
+)
+from maleo_foundation.client.services.encryption.rsa import (
+    MaleoFoundationRSAEncryptionClientService,
+)
+
 
 class MaleoFoundationEncryptionServices(ClientServices):
-    aes:MaleoFoundationAESEncryptionClientService = Field(..., description="AES encryption's service")
-    rsa:MaleoFoundationRSAEncryptionClientService = Field(..., description="RSA encryption's service")
+    aes: MaleoFoundationAESEncryptionClientService = Field(
+        ..., description="AES encryption's service"
+    )
+    rsa: MaleoFoundationRSAEncryptionClientService = Field(
+        ..., description="RSA encryption's service"
+    )

maleo_foundation/client/services/encryption/aes.py

@@ -2,83 +2,88 @@ import os
 from base64 import b64decode, b64encode
 from cryptography.hazmat.backends import default_backend
 from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
-from maleo_foundation.expanded_types.encryption.aes \
-    import MaleoFoundationAESEncryptionResultsTypes
+from maleo_foundation.expanded_types.encryption.aes import (
+    MaleoFoundationAESEncryptionResultsTypes,
+)
 from maleo_foundation.managers.client.base import ClientService
-from maleo_foundation.models.schemas.encryption \
-    import MaleoFoundationEncryptionSchemas
-from maleo_foundation.models.transfers.parameters.encryption.aes \
-    import MaleoFoundationAESEncryptionParametersTransfers
-from maleo_foundation.models.transfers.results.encryption.aes \
-    import EncryptData, MaleoFoundationAESEncryptionResultsTransfers
+from maleo_foundation.models.schemas.encryption import MaleoFoundationEncryptionSchemas
+from maleo_foundation.models.transfers.parameters.encryption.aes import (
+    MaleoFoundationAESEncryptionParametersTransfers,
+)
+from maleo_foundation.models.transfers.results.encryption.aes import (
+    EncryptData,
+    MaleoFoundationAESEncryptionResultsTransfers,
+)
 from maleo_foundation.utils.exceptions import BaseExceptions
 
+
 class MaleoFoundationAESEncryptionClientService(ClientService):
     def encrypt(
-        self,
-        parameters: MaleoFoundationAESEncryptionParametersTransfers.Encrypt
+        self, parameters: MaleoFoundationAESEncryptionParametersTransfers.Encrypt
     ) -> MaleoFoundationAESEncryptionResultsTypes.Encrypt:
         """Encrypt a plaintext using AES algorithm."""
+
         @BaseExceptions.service_exception_handler(
             operation="encrypting plaintext",
             logger=self._logger,
-            fail_result_class=MaleoFoundationAESEncryptionResultsTransfers.Fail
+            fail_result_class=MaleoFoundationAESEncryptionResultsTransfers.Fail,
         )
         def _impl():
-            #* Define random key and initialization vector bytes
+            # * Define random key and initialization vector bytes
             key_bytes = os.urandom(32)
             initialization_vector_bytes = os.urandom(16)
-            #* Encrypt message with encryptor instance
+            # * Encrypt message with encryptor instance
             cipher = Cipher(
                 algorithm=algorithms.AES(key_bytes),
                 mode=modes.CFB(initialization_vector_bytes),
-                backend=default_backend()
+                backend=default_backend(),
             )
             encryptor = cipher.encryptor()
-            ciphertext = (
-                b64encode(
-                    encryptor
-                    .update(parameters.plaintext.encode()) + encryptor.finalize()
-                )
-                .decode('utf-8'))
-            #* Encode the results to base64 strings
-            key = b64encode(key_bytes).decode('utf-8')
-            initialization_vector = b64encode(initialization_vector_bytes).decode('utf-8')
+            ciphertext = b64encode(
+                encryptor.update(parameters.plaintext.encode()) + encryptor.finalize()
+            ).decode("utf-8")
+            # * Encode the results to base64 strings
+            key = b64encode(key_bytes).decode("utf-8")
+            initialization_vector = b64encode(initialization_vector_bytes).decode(
+                "utf-8"
+            )
             data = EncryptData(
                 key=key,
                 initialization_vector=initialization_vector,
-                ciphertext=ciphertext
+                ciphertext=ciphertext,
             )
             self._logger.info("Plaintext successfully encrypted")
-            return MaleoFoundationAESEncryptionResultsTransfers.Encrypt(data=data)
+            return MaleoFoundationAESEncryptionResultsTransfers.Encrypt(data=data)  # type: ignore
+
         return _impl()
 
     def decrypt(
-        self,
-        parameters: MaleoFoundationAESEncryptionParametersTransfers.Decrypt
+        self, parameters: MaleoFoundationAESEncryptionParametersTransfers.Decrypt
     ) -> MaleoFoundationAESEncryptionResultsTypes.Decrypt:
         """Decrypt a ciphertext using AES algorithm."""
+
         @BaseExceptions.service_exception_handler(
             operation="verify single encryption",
             logger=self._logger,
-            fail_result_class=MaleoFoundationAESEncryptionResultsTransfers.Fail
+            fail_result_class=MaleoFoundationAESEncryptionResultsTransfers.Fail,
         )
         def _impl():
-            #* Decode base64-encoded AES key, IV, and encrypted message
+            # * Decode base64-encoded AES key, IV, and encrypted message
             key_bytes = b64decode(parameters.key)
             initialization_vector_bytes = b64decode(parameters.initialization_vector)
-            #* Decrypt message with decryptor instance
+            # * Decrypt message with decryptor instance
             cipher = Cipher(
                 algorithm=algorithms.AES(key_bytes),
                 mode=modes.CFB(initialization_vector_bytes),
-                backend=default_backend()
+                backend=default_backend(),
             )
             decryptor = cipher.decryptor()
             plaintext = (
-                decryptor
-                .update(b64decode(parameters.ciphertext)) + decryptor.finalize()
-            )
+                decryptor.update(b64decode(parameters.ciphertext))
+                + decryptor.finalize()
+            ).decode()
             data = MaleoFoundationEncryptionSchemas.Plaintext(plaintext=plaintext)
             self._logger.info("Ciphertext successfully decrypted")
-            return MaleoFoundationAESEncryptionResultsTransfers.Decrypt(data=data)
-        return _impl()
+            return MaleoFoundationAESEncryptionResultsTransfers.Decrypt(data=data)  # type: ignore
+
+        return _impl()

maleo_foundation/client/services/encryption/rsa.py

@@ -2,110 +2,110 @@ from base64 import b64decode, b64encode
 from Crypto.Cipher import PKCS1_OAEP
 from Crypto.Hash import SHA256
 from maleo_foundation.enums import BaseEnums
-from maleo_foundation.expanded_types.encryption.rsa \
-    import MaleoFoundationRSAEncryptionResultsTypes
+from maleo_foundation.expanded_types.encryption.rsa import (
+    MaleoFoundationRSAEncryptionResultsTypes,
+)
 from maleo_foundation.managers.client.base import ClientService
-from maleo_foundation.models.schemas.encryption \
-    import MaleoFoundationEncryptionSchemas
-from maleo_foundation.models.transfers.parameters.encryption.rsa \
-    import MaleoFoundationRSAEncryptionParametersTransfers
-from maleo_foundation.models.transfers.results.encryption.rsa \
-    import MaleoFoundationRSAEncryptionResultsTransfers
+from maleo_foundation.models.schemas.encryption import MaleoFoundationEncryptionSchemas
+from maleo_foundation.models.transfers.parameters.encryption.rsa import (
+    MaleoFoundationRSAEncryptionParametersTransfers,
+)
+from maleo_foundation.models.transfers.results.encryption.rsa import (
+    MaleoFoundationRSAEncryptionResultsTransfers,
+)
 from maleo_foundation.utils.exceptions import BaseExceptions
 from maleo_foundation.utils.loaders.key.rsa import RSAKeyLoader
 
+
 class MaleoFoundationRSAEncryptionClientService(ClientService):
     def encrypt(
-        self,
-        parameters: MaleoFoundationRSAEncryptionParametersTransfers.Encrypt
+        self, parameters: MaleoFoundationRSAEncryptionParametersTransfers.Encrypt
     ) -> MaleoFoundationRSAEncryptionResultsTypes.Encrypt:
         """Encrypt a plaintext using RSA algorithm."""
+
         @BaseExceptions.service_exception_handler(
             operation="encrypting plaintext",
             logger=self._logger,
-            fail_result_class=MaleoFoundationRSAEncryptionResultsTransfers.Fail
+            fail_result_class=MaleoFoundationRSAEncryptionResultsTransfers.Fail,
         )
         def _impl():
             try:
                 public_key = RSAKeyLoader.load_with_pycryptodome(
-                    type=BaseEnums.KeyType.PUBLIC,
-                    extern_key=parameters.key
+                    type=BaseEnums.KeyType.PUBLIC, extern_key=parameters.key
                 )
             except TypeError:
                 message = "Invalid key type"
                 description = "A public key must be used for encrypting a plaintext"
                 other = "Ensure the given key is of type public key"
                 return MaleoFoundationRSAEncryptionResultsTransfers.Fail(
-                    message=message,
-                    description=description,
-                    other=other
-                )
+                    message=message, description=description, other=other
+                )  # type: ignore
             except Exception as e:
-                self._logger.error("Unexpected error occured while trying to import key:\n'%s'", str(e), exc_info=True)
+                self._logger.error(
+                    "Unexpected error occured while trying to import key:\n'%s'",
+                    str(e),
+                    exc_info=True,
+                )
                 message = "Invalid key"
                 description = "Unexpected error occured while trying to import key"
                 other = "Ensure given key is valid"
                 return MaleoFoundationRSAEncryptionResultsTransfers.Fail(
-                    message=message,
-                    description=description,
-                    other=other
-                )
-            #* Initialize cipher with OAEP padding and SHA-256
+                    message=message, description=description, other=other
+                )  # type: ignore
+            # * Initialize cipher with OAEP padding and SHA-256
             cipher = PKCS1_OAEP.new(public_key, hashAlgo=SHA256)
-            #* Encrypt the plaintext and return as base64-encoded string
-            ciphertext = (
-                b64encode(
-                    cipher
-                    .encrypt(parameters.plaintext.encode('utf-8'))
-                )
-                .decode('utf-8')
-            )
+            # * Encrypt the plaintext and return as base64-encoded string
+            ciphertext = b64encode(
+                cipher.encrypt(parameters.plaintext.encode("utf-8"))
+            ).decode("utf-8")
             data = MaleoFoundationEncryptionSchemas.Ciphertext(ciphertext=ciphertext)
             self._logger.info("Plaintext successfully encrypted")
-            return MaleoFoundationRSAEncryptionResultsTransfers.Encrypt(data=data)
+            return MaleoFoundationRSAEncryptionResultsTransfers.Encrypt(data=data)  # type: ignore
+
         return _impl()
 
     def decrypt(
-        self,
-        parameters: MaleoFoundationRSAEncryptionParametersTransfers.Decrypt
+        self, parameters: MaleoFoundationRSAEncryptionParametersTransfers.Decrypt
     ) -> MaleoFoundationRSAEncryptionResultsTypes.Decrypt:
         """Decrypt a ciphertext using RSA algorithm."""
+
         @BaseExceptions.service_exception_handler(
             operation="verify single encryption",
             logger=self._logger,
-            fail_result_class=MaleoFoundationRSAEncryptionResultsTransfers.Fail
+            fail_result_class=MaleoFoundationRSAEncryptionResultsTransfers.Fail,
         )
         def _impl():
             try:
                 private_key = RSAKeyLoader.load_with_pycryptodome(
                     type=BaseEnums.KeyType.PRIVATE,
                     extern_key=parameters.key,
-                    passphrase=parameters.password
+                    passphrase=parameters.password,
                 )
             except TypeError:
                 message = "Invalid key type"
                 description = "A private key must be used for decrypting a ciphertext"
                 other = "Ensure the given key is of type private key"
                 return MaleoFoundationRSAEncryptionResultsTransfers.Fail(
-                    message=message,
-                    description=description,
-                    other=other
-                )
+                    message=message, description=description, other=other
+                )  # type: ignore
             except Exception as e:
-                self._logger.error("Unexpected error occured while trying to import key:\n'%s'", str(e), exc_info=True)
+                self._logger.error(
+                    "Unexpected error occured while trying to import key:\n'%s'",
+                    str(e),
+                    exc_info=True,
+                )
                 message = "Invalid key"
                 description = "Unexpected error occured while trying to import key"
                 other = "Ensure given key is valid"
                 return MaleoFoundationRSAEncryptionResultsTransfers.Fail(
-                    message=message,
-                    description=description,
-                    other=other
-                )
-            #* Initialize cipher with OAEP padding and SHA-256
+                    message=message, description=description, other=other
+                )  # type: ignore
+            # * Initialize cipher with OAEP padding and SHA-256
             cipher = PKCS1_OAEP.new(private_key, hashAlgo=SHA256)
-            #* Decode the base64-encoded ciphertext and then decrypt
-            plaintext = cipher.decrypt(b64decode(parameters.ciphertext))
+            # * Decode the base64-encoded ciphertext and then decrypt
+            plaintext = cipher.decrypt(b64decode(parameters.ciphertext)).decode()
             data = MaleoFoundationEncryptionSchemas.Plaintext(plaintext=plaintext)
             self._logger.info("Ciphertext successfully decrypted")
-            return MaleoFoundationRSAEncryptionResultsTransfers.Decrypt(data=data)
-        return _impl()
+            return MaleoFoundationRSAEncryptionResultsTransfers.Decrypt(data=data)  # type: ignore
+
+        return _impl()

maleo_foundation/client/services/hash/__init__.py

@@ -1,11 +1,24 @@
 from __future__ import annotations
 from pydantic import Field
 from maleo_foundation.managers.client.base import ClientServices
-from maleo_foundation.client.services.hash.bcrypt import MaleoFoundationBcryptHashClientService
-from maleo_foundation.client.services.hash.hmac import MaleoFoundationHMACHashClientService
-from maleo_foundation.client.services.hash.sha256 import MaleoFoundationSHA256HashClientService
+from maleo_foundation.client.services.hash.bcrypt import (
+    MaleoFoundationBcryptHashClientService,
+)
+from maleo_foundation.client.services.hash.hmac import (
+    MaleoFoundationHMACHashClientService,
+)
+from maleo_foundation.client.services.hash.sha256 import (
+    MaleoFoundationSHA256HashClientService,
+)
+
 
 class MaleoFoundationHashServices(ClientServices):
-    bcrypt:MaleoFoundationBcryptHashClientService = Field(..., description="Bcrypt hash's service")
-    hmac:MaleoFoundationHMACHashClientService = Field(..., description="HMAC hash's service")
-    sha256:MaleoFoundationSHA256HashClientService = Field(..., description="SHA256 hash's service")
+    bcrypt: MaleoFoundationBcryptHashClientService = Field(
+        ..., description="Bcrypt hash's service"
+    )
+    hmac: MaleoFoundationHMACHashClientService = Field(
+        ..., description="HMAC hash's service"
+    )
+    sha256: MaleoFoundationSHA256HashClientService = Field(
+        ..., description="SHA256 hash's service"
+    )

maleo_foundation/client/services/hash/bcrypt.py

@@ -1,52 +1,54 @@
 import bcrypt
-from maleo_foundation.expanded_types.hash \
-    import MaleoFoundationHashResultsTypes
+from maleo_foundation.expanded_types.hash import MaleoFoundationHashResultsTypes
 from maleo_foundation.managers.client.base import ClientService
-from maleo_foundation.models.schemas.hash import \
-    MaleoFoundationHashSchemas
-from maleo_foundation.models.transfers.parameters.hash.bcrypt \
-    import MaleoFoundationBcryptHashParametersTransfers
-from maleo_foundation.models.transfers.results.hash \
-    import MaleoFoundationHashResultsTransfers
+from maleo_foundation.models.schemas.hash import MaleoFoundationHashSchemas
+from maleo_foundation.models.transfers.parameters.hash.bcrypt import (
+    MaleoFoundationBcryptHashParametersTransfers,
+)
+from maleo_foundation.models.transfers.results.hash import (
+    MaleoFoundationHashResultsTransfers,
+)
 from maleo_foundation.utils.exceptions import BaseExceptions
 
+
 class MaleoFoundationBcryptHashClientService(ClientService):
     def hash(
-        self,
-        parameters:MaleoFoundationBcryptHashParametersTransfers.Hash
+        self, parameters: MaleoFoundationBcryptHashParametersTransfers.Hash
     ) -> MaleoFoundationHashResultsTypes.Hash:
         """Generate a bcrypt hash for the given message."""
+
         @BaseExceptions.service_exception_handler(
             operation="hashing single message",
             logger=self._logger,
-            fail_result_class=MaleoFoundationHashResultsTransfers.Fail
+            fail_result_class=MaleoFoundationHashResultsTransfers.Fail,
         )
         def _impl():
             hash = bcrypt.hashpw(
-                password=parameters.message.encode(),
-                salt=bcrypt.gensalt()
+                password=parameters.message.encode(), salt=bcrypt.gensalt()
             ).decode()
             data = MaleoFoundationHashSchemas.Hash(hash=hash)
             self._logger.info("Message successfully hashed")
             return MaleoFoundationHashResultsTransfers.Hash(data=data)
+
         return _impl()
 
     def verify(
-        self,
-        parameters:MaleoFoundationBcryptHashParametersTransfers.Verify
+        self, parameters: MaleoFoundationBcryptHashParametersTransfers.Verify
     ) -> MaleoFoundationHashResultsTypes.Verify:
         """Verify a message against the given message hash."""
+
         @BaseExceptions.service_exception_handler(
             operation="verify single hash",
             logger=self._logger,
-            fail_result_class=MaleoFoundationHashResultsTransfers.Fail
+            fail_result_class=MaleoFoundationHashResultsTransfers.Fail,
         )
         def _impl():
             is_valid = bcrypt.checkpw(
                 password=parameters.message.encode(),
-                hashed_password=parameters.hash.encode()
+                hashed_password=parameters.hash.encode(),
             )
             data = MaleoFoundationHashSchemas.IsValid(is_valid=is_valid)
             self._logger.info("Hash successfully verified")
             return MaleoFoundationHashResultsTransfers.Verify(data=data)
-        return _impl()
+
+        return _impl()