maleo-foundation 0.3.45__py3-none-any.whl → 0.3.47__py3-none-any.whl

maleo_foundation/client/services/hash/hmac.py

@@ -1,55 +1,58 @@
 from Crypto.Hash import HMAC, SHA256
-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.hmac \
-    import MaleoFoundationHMACHashParametersTransfers
-from maleo_foundation.models.transfers.results.hash \
-    import MaleoFoundationHashResultsTransfers
+from maleo_foundation.models.schemas.hash import MaleoFoundationHashSchemas
+from maleo_foundation.models.transfers.parameters.hash.hmac import (
+    MaleoFoundationHMACHashParametersTransfers,
+)
+from maleo_foundation.models.transfers.results.hash import (
+    MaleoFoundationHashResultsTransfers,
+)
 from maleo_foundation.utils.exceptions import BaseExceptions
 
+
 class MaleoFoundationHMACHashClientService(ClientService):
     def hash(
-        self,
-        parameters:MaleoFoundationHMACHashParametersTransfers.Hash
+        self, parameters: MaleoFoundationHMACHashParametersTransfers.Hash
     ) -> MaleoFoundationHashResultsTypes.Hash:
         """Generate a hmac 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 = HMAC.new(
                 key=parameters.key.encode(),
                 msg=parameters.message.encode(),
-                digestmod=SHA256
+                digestmod=SHA256,
             ).hexdigest()
             data = MaleoFoundationHashSchemas.Hash(hash=hash)
             self._logger.info("Message successfully hashed")
             return MaleoFoundationHashResultsTransfers.Hash(data=data)
+
         return _impl()
 
     def verify(
-        self,
-        parameters:MaleoFoundationHMACHashParametersTransfers.Verify
+        self, parameters: MaleoFoundationHMACHashParametersTransfers.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():
             computed_hash = HMAC.new(
                 key=parameters.key.encode(),
                 msg=parameters.message.encode(),
-                digestmod=SHA256
+                digestmod=SHA256,
             ).hexdigest()
             is_valid = computed_hash == parameters.hash
             data = MaleoFoundationHashSchemas.IsValid(is_valid=is_valid)
             self._logger.info("Hash successfully verified")
             return MaleoFoundationHashResultsTransfers.Verify(data=data)
-        return _impl()
+
+        return _impl()

maleo_foundation/client/services/hash/sha256.py

@@ -1,42 +1,44 @@
 from Crypto.Hash import SHA256
-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.sha256 \
-    import MaleoFoundationSHA256HashParametersTransfers
-from maleo_foundation.models.transfers.results.hash \
-    import MaleoFoundationHashResultsTransfers
+from maleo_foundation.models.schemas.hash import MaleoFoundationHashSchemas
+from maleo_foundation.models.transfers.parameters.hash.sha256 import (
+    MaleoFoundationSHA256HashParametersTransfers,
+)
+from maleo_foundation.models.transfers.results.hash import (
+    MaleoFoundationHashResultsTransfers,
+)
 from maleo_foundation.utils.exceptions import BaseExceptions
 
+
 class MaleoFoundationSHA256HashClientService(ClientService):
     def hash(
-        self,
-        parameters:MaleoFoundationSHA256HashParametersTransfers.Hash
+        self, parameters: MaleoFoundationSHA256HashParametersTransfers.Hash
     ) -> MaleoFoundationHashResultsTypes.Hash:
         """Generate a sha256 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 = SHA256.new(parameters.message.encode()).hexdigest()
             data = MaleoFoundationHashSchemas.Hash(hash=hash)
             self._logger.info("Message successfully hashed")
             return MaleoFoundationHashResultsTransfers.Hash(data=data)
+
         return _impl()
 
     def verify(
-        self,
-        parameters:MaleoFoundationSHA256HashParametersTransfers.Verify
+        self, parameters: MaleoFoundationSHA256HashParametersTransfers.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():
             computed_hash = SHA256.new(parameters.message.encode()).hexdigest()
@@ -44,4 +46,5 @@ class MaleoFoundationSHA256HashClientService(ClientService):
             data = MaleoFoundationHashSchemas.IsValid(is_valid=is_valid)
             self._logger.info("Hash successfully verified")
             return MaleoFoundationHashResultsTransfers.Verify(data=data)
-        return _impl()
+
+        return _impl()

maleo_foundation/client/services/key.py

@@ -1,34 +1,37 @@
 from cryptography.hazmat.backends import default_backend
 from cryptography.hazmat.primitives.asymmetric import rsa
 from cryptography.hazmat.primitives import serialization
-from maleo_foundation.expanded_types.key \
-    import MaleoFoundationKeyResultsTypes
+from maleo_foundation.expanded_types.key import MaleoFoundationKeyResultsTypes
 from maleo_foundation.managers.client.base import ClientService
-from maleo_foundation.models.transfers.general.key \
-    import MaleoFoundationKeyGeneralTransfers
-from maleo_foundation.models.transfers.parameters.key \
-    import MaleoFoundationKeyParametersTransfers
-from maleo_foundation.models.transfers.results.key \
-    import MaleoFoundationKeyResultsTransfers
+from maleo_foundation.models.transfers.general.key import (
+    MaleoFoundationKeyGeneralTransfers,
+)
+from maleo_foundation.models.transfers.parameters.key import (
+    MaleoFoundationKeyParametersTransfers,
+)
+from maleo_foundation.models.transfers.results.key import (
+    MaleoFoundationKeyResultsTransfers,
+)
 from maleo_foundation.utils.exceptions import BaseExceptions
 
+
 class MaleoFoundationKeyClientService(ClientService):
     def create_private(
-        self,
-        parameters: MaleoFoundationKeyParametersTransfers.CreatePrivateOrPair
+        self, parameters: MaleoFoundationKeyParametersTransfers.CreatePrivateOrPair
     ) -> MaleoFoundationKeyResultsTypes.CreatePrivate:
         """Create an RSA private key with X.509 encoding in .pem format."""
+
         @BaseExceptions.service_exception_handler(
             operation="creating private key",
             logger=self._logger,
-            fail_result_class=MaleoFoundationKeyResultsTransfers.Fail
+            fail_result_class=MaleoFoundationKeyResultsTransfers.Fail,
         )
         def _impl():
-            #* Create private key
+            # * Create private key
             private_key = rsa.generate_private_key(
                 public_exponent=65537,
                 key_size=parameters.key_size,
-                backend=default_backend()
+                backend=default_backend(),
             )
 
             if parameters.password is None:
@@ -38,70 +41,72 @@ class MaleoFoundationKeyClientService(ClientService):
                     parameters.password.encode()
                 )
 
-            #* Serialize private key to PEM format
+            # * Serialize private key to PEM format
             private_key_bytes = private_key.private_bytes(
                 encoding=serialization.Encoding.PEM,
                 format=serialization.PrivateFormat.PKCS8,
-                encryption_algorithm=encryption_algorithm
+                encryption_algorithm=encryption_algorithm,
             )
 
             self._logger.info("Successfully created private key")
             data = MaleoFoundationKeyGeneralTransfers.PrivateKey(
                 value=private_key_bytes.decode()
-            )
-            return MaleoFoundationKeyResultsTransfers.CreatePrivate(data=data)
+            )  # type: ignore
+            return MaleoFoundationKeyResultsTransfers.CreatePrivate(data=data)  # type: ignore
+
         return _impl()
 
     def create_public(
-        self,
-        parameters: MaleoFoundationKeyParametersTransfers.CreatePublic
+        self, parameters: MaleoFoundationKeyParametersTransfers.CreatePublic
     ) -> MaleoFoundationKeyResultsTypes.CreatePublic:
         """Create an RSA public key with X.509 encoding in .pem format."""
+
         @BaseExceptions.service_exception_handler(
             operation="creating public key",
             logger=self._logger,
-            fail_result_class=MaleoFoundationKeyResultsTransfers.Fail
+            fail_result_class=MaleoFoundationKeyResultsTransfers.Fail,
         )
         def _impl():
-            #* Serialize private key
+            # * Serialize private key
             private_key_bytes = parameters.value.encode()
             private_key = serialization.load_pem_private_key(
                 private_key_bytes,
                 password=parameters.password.encode() if parameters.password else None,
-                backend=default_backend()
+                backend=default_backend(),
             )
 
-            public_key = private_key.public_key() #* Create public key
+            public_key = private_key.public_key()  # * Create public key
 
-            #* Serialize public key to PEM format
+            # * Serialize public key to PEM format
             public_key_bytes = public_key.public_bytes(
                 encoding=serialization.Encoding.PEM,
-                format=serialization.PublicFormat.SubjectPublicKeyInfo
+                format=serialization.PublicFormat.SubjectPublicKeyInfo,
             )
 
             self._logger.info("Successfully created public key")
             data = MaleoFoundationKeyGeneralTransfers.PublicKey(
                 value=public_key_bytes.decode()
-            )
-            return MaleoFoundationKeyResultsTransfers.CreatePublic(data=data)
+            )  # type: ignore
+            return MaleoFoundationKeyResultsTransfers.CreatePublic(data=data)  # type: ignore
+
         return _impl()
 
     def create_pair(
-        self,
-        parameters: MaleoFoundationKeyParametersTransfers.CreatePrivateOrPair
+        self, parameters: MaleoFoundationKeyParametersTransfers.CreatePrivateOrPair
     ) -> MaleoFoundationKeyResultsTypes.CreatePair:
         """Create an RSA key pair with X.509 encoding in .pem format."""
+
         @BaseExceptions.service_exception_handler(
             operation="creating key pair",
             logger=self._logger,
-            fail_result_class=MaleoFoundationKeyResultsTransfers.Fail
+            fail_result_class=MaleoFoundationKeyResultsTransfers.Fail,
         )
         def _impl():
-            #* Create private key
+            # * Create private key
             private_key = rsa.generate_private_key(
                 public_exponent=65537,
                 key_size=parameters.key_size,
-                backend=default_backend()
+                backend=default_backend(),
             )
 
             if parameters.password is None:
@@ -111,28 +116,31 @@ class MaleoFoundationKeyClientService(ClientService):
                     parameters.password.encode()
                 )
 
-            #* Serialize private key to PEM format
+            # * Serialize private key to PEM format
             private_key_bytes = private_key.private_bytes(
                 encoding=serialization.Encoding.PEM,
                 format=serialization.PrivateFormat.PKCS8,
-                encryption_algorithm=encryption_algorithm
+                encryption_algorithm=encryption_algorithm,
             )
             private = MaleoFoundationKeyGeneralTransfers.PrivateKey(
                 value=private_key_bytes.decode()
-            )
+            )  # type: ignore
 
-            public_key = private_key.public_key() #* Create public key
+            public_key = private_key.public_key()  # * Create public key
 
-            #* Serialize public key to PEM format
+            # * Serialize public key to PEM format
             public_key_bytes = public_key.public_bytes(
                 encoding=serialization.Encoding.PEM,
-                format=serialization.PublicFormat.SubjectPublicKeyInfo
+                format=serialization.PublicFormat.SubjectPublicKeyInfo,
             )
             public = MaleoFoundationKeyGeneralTransfers.PublicKey(
                 value=public_key_bytes.decode()
-            )
+            )  # type: ignore
 
             self._logger.info("Successfully created key pair")
-            data = MaleoFoundationKeyGeneralTransfers.KeyPair(private=private, public=public)
-            return MaleoFoundationKeyResultsTransfers.CreatePair(data=data)
-        return _impl()
+            data = MaleoFoundationKeyGeneralTransfers.KeyPair(
+                private=private, public=public
+            )
+            return MaleoFoundationKeyResultsTransfers.CreatePair(data=data)  # type: ignore
+
+        return _impl()

maleo_foundation/client/services/signature.py

@@ -2,97 +2,100 @@ from base64 import b64decode, b64encode
 from Crypto.Hash import SHA256
 from Crypto.Signature import pkcs1_15
 from maleo_foundation.enums import BaseEnums
-from maleo_foundation.expanded_types.signature \
-    import MaleoFoundationSignatureResultsTypes
+from maleo_foundation.expanded_types.signature import (
+    MaleoFoundationSignatureResultsTypes,
+)
 from maleo_foundation.managers.client.base import ClientService
-from maleo_foundation.models.schemas.signature \
-    import MaleoFoundationSignatureSchemas
-from maleo_foundation.models.transfers.parameters.signature \
-    import MaleoFoundationSignatureParametersTransfers
-from maleo_foundation.models.transfers.results.signature \
-    import MaleoFoundationSignatureResultsTransfers
+from maleo_foundation.models.schemas.signature import MaleoFoundationSignatureSchemas
+from maleo_foundation.models.transfers.parameters.signature import (
+    MaleoFoundationSignatureParametersTransfers,
+)
+from maleo_foundation.models.transfers.results.signature import (
+    MaleoFoundationSignatureResultsTransfers,
+)
 from maleo_foundation.utils.exceptions import BaseExceptions
 from maleo_foundation.utils.loaders.key.rsa import RSAKeyLoader
 
+
 class MaleoFoundationSignatureClientService(ClientService):
     def sign(
-        self,
-        parameters: MaleoFoundationSignatureParametersTransfers.Sign
+        self, parameters: MaleoFoundationSignatureParametersTransfers.Sign
     ) -> MaleoFoundationSignatureResultsTypes.Sign:
         @BaseExceptions.service_exception_handler(
             operation="signing single message",
             logger=self._logger,
-            fail_result_class=MaleoFoundationSignatureResultsTransfers.Fail
+            fail_result_class=MaleoFoundationSignatureResultsTransfers.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 signing a message"
                 other = "Ensure the given key is of type private key"
                 return MaleoFoundationSignatureResultsTransfers.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 MaleoFoundationSignatureResultsTransfers.Fail(
-                    message=message,
-                    description=description,
-                    other=other
-                )
-            hash = SHA256.new(parameters.message.encode()) #* Generate message hash
-            signature = b64encode(pkcs1_15.new(private_key).sign(hash)).decode() #* Sign the hashed message
+                    message=message, description=description, other=other
+                )  # type: ignore
+            hash = SHA256.new(parameters.message.encode())  # * Generate message hash
+            signature = b64encode(
+                pkcs1_15.new(private_key).sign(hash)
+            ).decode()  # * Sign the hashed message
             data = MaleoFoundationSignatureSchemas.Signature(signature=signature)
             self._logger.info("Message successfully signed")
-            return MaleoFoundationSignatureResultsTransfers.Sign(data=data)
+            return MaleoFoundationSignatureResultsTransfers.Sign(data=data)  # type: ignore
+
         return _impl()
 
     def verify(
-        self,
-        parameters: MaleoFoundationSignatureParametersTransfers.Verify
+        self, parameters: MaleoFoundationSignatureParametersTransfers.Verify
     ) -> MaleoFoundationSignatureResultsTypes.Verify:
         @BaseExceptions.service_exception_handler(
             operation="verify single signature",
             logger=self._logger,
-            fail_result_class=MaleoFoundationSignatureResultsTransfers.Fail
+            fail_result_class=MaleoFoundationSignatureResultsTransfers.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 verifying a signature"
                 other = "Ensure the given key is of type public key"
                 return MaleoFoundationSignatureResultsTransfers.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 MaleoFoundationSignatureResultsTransfers.Fail(
-                    message=message,
-                    description=description,
-                    other=other
-                )
-            hash = SHA256.new(parameters.message.encode()) #* Generate message hash
-            #* Verify the hashed message and decoded signature
+                    message=message, description=description, other=other
+                )  # type: ignore
+            hash = SHA256.new(parameters.message.encode())  # * Generate message hash
+            # * Verify the hashed message and decoded signature
             try:
                 pkcs1_15.new(public_key).verify(hash, b64decode(parameters.signature))
                 is_valid = True
@@ -100,5 +103,6 @@ class MaleoFoundationSignatureClientService(ClientService):
                 is_valid = False
             data = MaleoFoundationSignatureSchemas.IsValid(is_valid=is_valid)
             self._logger.info("Signature successfully verified")
-            return MaleoFoundationSignatureResultsTransfers.Verify(data=data)
-        return _impl()
+            return MaleoFoundationSignatureResultsTransfers.Verify(data=data)  # type: ignore
+
+        return _impl()

maleo_foundation/client/services/token.py

@@ -1,114 +1,105 @@
 import jwt
 from maleo_foundation.enums import BaseEnums
-from maleo_foundation.expanded_types.token \
-    import MaleoFoundationTokenResultsTypes
+from maleo_foundation.expanded_types.token import MaleoFoundationTokenResultsTypes
 from maleo_foundation.managers.client.base import ClientService
-from maleo_foundation.models.schemas.token \
-    import MaleoFoundationTokenSchemas
-from maleo_foundation.models.transfers.general.token \
-    import MaleoFoundationTokenGeneralTransfers
-from maleo_foundation.models.transfers.parameters.token \
-    import MaleoFoundationTokenParametersTransfers
-from maleo_foundation.models.transfers.results.token \
-    import MaleoFoundationTokenResultsTransfers
+from maleo_foundation.models.schemas.token import MaleoFoundationTokenSchemas
+from maleo_foundation.models.transfers.general.token import (
+    MaleoFoundationTokenGeneralTransfers,
+)
+from maleo_foundation.models.transfers.parameters.token import (
+    MaleoFoundationTokenParametersTransfers,
+)
+from maleo_foundation.models.transfers.results.token import (
+    MaleoFoundationTokenResultsTransfers,
+)
 from maleo_foundation.utils.exceptions import BaseExceptions
 from maleo_foundation.utils.loaders.key.rsa import RSAKeyLoader
 
+
 class MaleoFoundationTokenClientService(ClientService):
     def encode(
-        self,
-        parameters: MaleoFoundationTokenParametersTransfers.Encode
+        self, parameters: MaleoFoundationTokenParametersTransfers.Encode
     ) -> MaleoFoundationTokenResultsTypes.Encode:
         @BaseExceptions.service_exception_handler(
             operation="encoding a payload into a token",
             logger=self._logger,
-            fail_result_class=MaleoFoundationTokenResultsTransfers.Fail
+            fail_result_class=MaleoFoundationTokenResultsTransfers.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 payload encoding"
                 other = "Ensure the given key is of type private key"
                 return MaleoFoundationTokenResultsTransfers.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 MaleoFoundationTokenResultsTransfers.Fail(
-                    message=message,
-                    description=description,
-                    other=other
-                )
-            payload = (
-                MaleoFoundationTokenGeneralTransfers
-                .EncodePayload
-                .model_validate(
-                    parameters.payload.model_dump()
-                )
-                .model_dump(
-                    mode="json",
-                    exclude_none=True
-                )
-            )
+                    message=message, description=description, other=other
+                )  # type: ignore
+            payload = MaleoFoundationTokenGeneralTransfers.EncodePayload.model_validate(
+                parameters.payload.model_dump()
+            ).model_dump(mode="json", exclude_none=True)
             token = jwt.encode(
-                payload=payload,
-                key=private_key.export_key(),
-                algorithm="RS256"
+                payload=payload, key=private_key.export_key(), algorithm="RS256"
             )
             data = MaleoFoundationTokenSchemas.Token(token=token)
-            return MaleoFoundationTokenResultsTransfers.Encode(data=data)
+            return MaleoFoundationTokenResultsTransfers.Encode(data=data)  # type: ignore
+
         return _impl()
 
     def decode(
-        self,
-        parameters: MaleoFoundationTokenParametersTransfers.Decode
+        self, parameters: MaleoFoundationTokenParametersTransfers.Decode
     ) -> MaleoFoundationTokenResultsTypes.Decode:
         @BaseExceptions.service_exception_handler(
             operation="decoding a token into a payload",
             logger=self._logger,
-            fail_result_class=MaleoFoundationTokenResultsTransfers.Fail
+            fail_result_class=MaleoFoundationTokenResultsTransfers.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 token decoding"
                 other = "Ensure the given key is of type public key"
                 return MaleoFoundationTokenResultsTransfers.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 MaleoFoundationTokenResultsTransfers.Fail(
-                    message=message,
-                    description=description,
-                    other=other
-                )
+                    message=message, description=description, other=other
+                )  # type: ignore
             payload = jwt.decode(
-                jwt=parameters.token,
-                key=public_key.export_key(),
-                algorithms=["RS256"]
+                jwt=parameters.token, key=public_key.export_key(), algorithms=["RS256"]
             )
-            data = MaleoFoundationTokenGeneralTransfers.DecodePayload.model_validate(payload)
-            return MaleoFoundationTokenResultsTransfers.Decode(data=data)
-        return _impl()
+            data = MaleoFoundationTokenGeneralTransfers.DecodePayload.model_validate(
+                payload
+            )
+            return MaleoFoundationTokenResultsTransfers.Decode(data=data)  # type: ignore
+
+        return _impl()