maleo-foundation 0.1.59__py3-none-any.whl → 0.1.61__py3-none-any.whl

maleo_foundation/client/services/__init__.py

@@ -1,7 +1,9 @@
 from __future__ import annotations
 from pydantic import Field
 from maleo_foundation.managers.client.base import ClientServices
+from maleo_foundation.client.services.signature import MaleoFoundationSignatureClientService
 from maleo_foundation.client.services.token import MaleoFoundationTokenClientService
 
 class MaleoFoundationServices(ClientServices):
+    signature:MaleoFoundationSignatureClientService = Field(..., description="Signature's service")
     token:MaleoFoundationTokenClientService = Field(..., description="Token's service")

maleo_foundation/client/services/signature.py

@@ -0,0 +1,74 @@
+from base64 import b64decode, b64encode
+from Crypto.PublicKey import RSA
+from Crypto.Hash import SHA256
+from Crypto.Signature import pkcs1_15
+from maleo_foundation.models.schemas.signature import BaseSignatureSchemas
+from maleo_foundation.models.transfers.parameters.signature import BaseSignatureParametersTransfers
+from maleo_foundation.models.transfers.results.signature import BaseSignatureResultsTransfers
+from maleo_foundation.expanded_types.signature import BaseSignatureResultsTypes
+from maleo_foundation.managers.client.base import ClientService
+from maleo_foundation.utils.exceptions import BaseExceptions
+
+class MaleoFoundationSignatureClientService(ClientService):
+    def sign(self, parameters:BaseSignatureParametersTransfers.Sign) -> BaseSignatureResultsTypes.Sign:
+        @BaseExceptions.service_exception_handler(
+            operation="signing single message",
+            logger=self._logger,
+            fail_result_class=BaseSignatureResultsTransfers.Fail
+        )
+        def _impl():
+            try:
+                #* Load RSA key using PyCryptodome's RSA.import_key
+                private_key = RSA.import_key(extern_key=parameters.key, passphrase=parameters.password)
+                #* Validate the key type
+                if not private_key.has_private():
+                    message = "Invalid key type"
+                    description = "A private key must be used for RSA Verify"
+                    other = "Ensure the given key is of type private key"
+                    return BaseSignatureResultsTransfers.Fail(message=message, description=description, other=other)
+            except Exception as e:
+                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 BaseSignatureResultsTransfers.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
+            data = BaseSignatureSchemas.Signature(signature=signature)
+            self._logger.info("Message successfully signed")
+            return BaseSignatureResultsTransfers.Sign(data=data)
+        return _impl()
+
+    def verify(self, parameters:BaseSignatureParametersTransfers.Verify) -> BaseSignatureResultsTypes.Verify:
+        @BaseExceptions.service_exception_handler(
+            operation="verify single signature",
+            logger=self._logger,
+            fail_result_class=BaseSignatureResultsTransfers.Fail
+        )
+        def _impl():
+            try:
+                #* Load RSA key using PyCryptodome's RSA.import_key
+                public_key = RSA.import_key(parameters.key)
+                #* Validate the key type
+                if public_key.has_private():
+                    message = "Invalid key type"
+                    description = "A public key must be used for RSA Sign"
+                    other = "Ensure the given key is of type public key"
+                    return BaseSignatureResultsTransfers.Fail(message=message, description=description, other=other)
+            except Exception as e:
+                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 BaseSignatureResultsTransfers.Fail(message=message, description=description, other=other)
+            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
+            except (TypeError, ValueError):
+                is_valid = False
+            data = BaseSignatureSchemas.IsValid(is_valid=is_valid)
+            self._logger.info("Signature successfully verified")
+            return BaseSignatureResultsTransfers.Verify(data=data)
+        return _impl()

maleo_foundation/expanded_types/signature.py

@@ -0,0 +1,13 @@
+from typing import Union
+from maleo_foundation.models.transfers.results.signature import BaseSignatureResultsTransfers
+
+class BaseSignatureResultsTypes:
+    Sign = Union[
+        BaseSignatureResultsTransfers.Fail,
+        BaseSignatureResultsTransfers.Sign
+    ]
+
+    Verify = Union[
+        BaseSignatureResultsTransfers.Fail,
+        BaseSignatureResultsTransfers.Verify
+    ]

maleo_foundation/middlewares/authentication.py

@@ -4,16 +4,18 @@ from starlette.middleware.authentication import AuthenticationMiddleware
 from starlette.requests import HTTPConnection
 from typing import Tuple
 from maleo_foundation.authentication import Credentials, User
+from maleo_foundation.client.manager import MaleoFoundationClientManager
+from maleo_foundation.managers.service import Keys
 from maleo_foundation.models.transfers.parameters.token import BaseTokenParametersTransfers
-from maleo_foundation.services.token import BaseTokenService
 from maleo_foundation.utils.extractor import BaseExtractors
 from maleo_foundation.utils.logging import MiddlewareLogger
 
 class Backend(AuthenticationBackend):
-    def __init__(self, logger:MiddlewareLogger, key:str):
+    def __init__(self, logger:MiddlewareLogger, keys:Keys, maleo_foundation:MaleoFoundationClientManager):
         super().__init__()
         self._logger = logger
-        self._key = key
+        self._keys = keys
+        self._maleo_foundation = maleo_foundation
 
     async def authenticate(self, conn:HTTPConnection) -> Tuple[Credentials, User]:
         client_ip = BaseExtractors.extract_client_ip(conn)
@@ -27,8 +29,8 @@ class Backend(AuthenticationBackend):
             self._logger.info(f"Request | IP: {client_ip} | URL: {conn.url.path} - Result | General: Authorization scheme is not Bearer")
             return Credentials(), User(authenticated=False)
 
-        decode_token_parameters = BaseTokenParametersTransfers.Decode(key=self._key, token=token)
-        decode_token_result = BaseTokenService.decode(parameters=decode_token_parameters)
+        decode_token_parameters = BaseTokenParametersTransfers.Decode(key=self._keys.public, token=token)
+        decode_token_result = self._maleo_foundation.services.token.decode(parameters=decode_token_parameters)
         if not decode_token_result.success:
             self._logger.error(f"Request | IP: {client_ip} | URL: {conn.url.path} - Result | General: Failed decoding authorization token")
             return Credentials(token=token), User(authenticated=False)
@@ -36,7 +38,7 @@ class Backend(AuthenticationBackend):
         self._logger.info(f"Request | IP: {client_ip} | URL: {conn.url.path} - Result | Username: {decode_token_result.data.u_u} | Email: {decode_token_result.data.u_e}")
         return Credentials(token=token), User(authenticated=True, username=decode_token_result.data.u_u, email=decode_token_result.data.u_e)
 
-def add_authentication_middleware(app:FastAPI, logger:MiddlewareLogger, key:str) -> None:
+def add_authentication_middleware(app:FastAPI, logger:MiddlewareLogger, keys:Keys) -> None:
     """
     Adds Authentication middleware to the FastAPI application.
 
@@ -62,4 +64,4 @@ def add_authentication_middleware(app:FastAPI, logger:MiddlewareLogger, key:str)
     add_authentication_middleware(app=app, limit=10, window=1, cleanup_interval=60, ip_timeout=300)
     ```
     """
-    app.add_middleware(AuthenticationMiddleware, backend=Backend(logger=logger, key=key))
+    app.add_middleware(AuthenticationMiddleware, backend=Backend(logger=logger, keys=keys))

maleo_foundation/middlewares/base.py

@@ -8,7 +8,10 @@ from fastapi import FastAPI, Request, Response, status
 from fastapi.responses import JSONResponse
 from starlette.middleware.base import BaseHTTPMiddleware, RequestResponseEndpoint
 from typing import Awaitable, Callable, Optional, Sequence
+from maleo_foundation.client.manager import MaleoFoundationClientManager
+from maleo_foundation.managers.service import Keys
 from maleo_foundation.models.responses import BaseResponses
+from maleo_foundation.models.transfers.parameters.signature import BaseSignatureParametersTransfers
 from maleo_foundation.utils.extractor import BaseExtractors
 from maleo_foundation.utils.logging import MiddlewareLogger
 
@@ -18,8 +21,10 @@ ResponseProcessor = Callable[[Response], Awaitable[Response]]
 class BaseMiddleware(BaseHTTPMiddleware):
     def __init__(
         self,
-        app,
+        app:FastAPI,
         logger:MiddlewareLogger,
+        keys:Keys,
+        maleo_foundation:MaleoFoundationClientManager,
         allow_origins:Sequence[str] = (),
         allow_methods:Sequence[str] = ("GET",),
         allow_headers:Sequence[str] = (),
@@ -27,23 +32,23 @@ class BaseMiddleware(BaseHTTPMiddleware):
         limit:int = 10,
         window:int = 1,
         cleanup_interval:int = 60,
-        ip_timeout:int = 300,
-        request_processor:Optional[RequestProcessor] = None
+        ip_timeout:int = 300
     ):
         super().__init__(app)
-        self.logger = logger
-        self.allow_origins = allow_origins
-        self.allow_methods = allow_methods
-        self.allow_headers = allow_headers
-        self.allow_credentials = allow_credentials
-        self.limit = limit
-        self.window = timedelta(seconds=window)
-        self.cleanup_interval = timedelta(seconds=cleanup_interval)
-        self.ip_timeout = timedelta(seconds=ip_timeout)
-        self.requests:dict[str, list[datetime]] = defaultdict(list)
-        self.last_seen: dict[str, datetime] = {}
-        self.last_cleanup = datetime.now()
-        self.request_processor = request_processor if request_processor is not None else self._request_processor
+        self._logger = logger
+        self._keys = keys
+        self._maleo_foundation = maleo_foundation
+        self._allow_origins = allow_origins
+        self._allow_methods = allow_methods
+        self._allow_headers = allow_headers
+        self._allow_credentials = allow_credentials
+        self._limit = limit
+        self._window = timedelta(seconds=window)
+        self._cleanup_interval = timedelta(seconds=cleanup_interval)
+        self._ip_timeout = timedelta(seconds=ip_timeout)
+        self._requests:dict[str, list[datetime]] = defaultdict(list)
+        self._last_seen: dict[str, datetime] = {}
+        self._last_cleanup = datetime.now()
         self._lock = threading.RLock()  #* Use RLock for thread safety
 
     def _cleanup_old_data(self) -> None:
@@ -54,64 +59,72 @@ class BaseMiddleware(BaseHTTPMiddleware):
         2. IPs that haven't been seen in ip_timeout period
         """
         now = datetime.now()
-        if now - self.last_cleanup > self.cleanup_interval:
+        if now - self._last_cleanup > self._cleanup_interval:
             with self._lock:
                 #* Remove inactive IPs (not seen recently) and empty lists
                 inactive_ips = []
-                for ip in list(self.requests.keys()):
+                for ip in list(self._requests.keys()):
                     #* Remove IPs with empty timestamp lists
-                    if not self.requests[ip]:
+                    if not self._requests[ip]:
                         inactive_ips.append(ip)
                         continue
                         
                     #* Remove IPs that haven't been active recently
-                    last_active = self.last_seen.get(ip, datetime.min)
-                    if now - last_active > self.ip_timeout:
+                    last_active = self._last_seen.get(ip, datetime.min)
+                    if now - last_active > self._ip_timeout:
                         inactive_ips.append(ip)
                 
                 #* Remove the inactive IPs
                 for ip in inactive_ips:
-                    if ip in self.requests:
-                        del self.requests[ip]
-                    if ip in self.last_seen:
-                        del self.last_seen[ip]
+                    if ip in self._requests:
+                        del self._requests[ip]
+                    if ip in self._last_seen:
+                        del self._last_seen[ip]
                 
                 # Update last cleanup time
-                self.last_cleanup = now
-                self.logger.debug(f"Cleaned up request cache. Removed {len(inactive_ips)} inactive IPs. Current tracked IPs: {len(self.requests)}")
+                self._last_cleanup = now
+                self._logger.debug(f"Cleaned up request cache. Removed {len(inactive_ips)} inactive IPs. Current tracked IPs: {len(self._requests)}")
 
     def _check_rate_limit(self, client_ip:str) -> bool:
         """Check if the client has exceeded their rate limit"""
         with self._lock:
             now = datetime.now() #* Define current timestamp
-            self.last_seen[client_ip] = now #* Update last seen timestamp for this IP
+            self._last_seen[client_ip] = now #* Update last seen timestamp for this IP
 
             #* Filter requests within the window
-            self.requests[client_ip] = [timestamp for timestamp in self.requests[client_ip] if now - timestamp <= self.window]
+            self._requests[client_ip] = [timestamp for timestamp in self._requests[client_ip] if now - timestamp <= self._window]
 
             #* Check if the request count exceeds the limit
-            if len(self.requests[client_ip]) >= self.limit:
+            if len(self._requests[client_ip]) >= self._limit:
                 return True
 
             #* Add the current request timestamp
-            self.requests[client_ip].append(now)
+            self._requests[client_ip].append(now)
             return False
 
     def _append_cors_headers(self, request:Request, response:Response) -> Response:
         origin = request.headers.get("Origin")
 
-        if origin in self.allow_origins:
+        if origin in self._allow_origins:
             response.headers["Access-Control-Allow-Origin"] = origin
-            response.headers["Access-Control-Allow-Methods"] = ", ".join(self.allow_methods)
-            response.headers["Access-Control-Allow-Headers"] = ", ".join(self.allow_headers)
-            response.headers["Access-Control-Allow-Credentials"] = "true" if self.allow_credentials else "false"
+            response.headers["Access-Control-Allow-Methods"] = ", ".join(self._allow_methods)
+            response.headers["Access-Control-Allow-Headers"] = ", ".join(self._allow_headers)
+            response.headers["Access-Control-Allow-Credentials"] = "true" if self._allow_credentials else "false"
 
         return response
 
     def _add_response_headers(self, request:Request, response:Response, request_timestamp:datetime, process_time:int) -> Response:
         response.headers["X-Process-Time"] = str(process_time) #* Add Process Time Header
         response.headers["X-Request-Timestamp"] = request_timestamp.isoformat() #* Add request timestamp header
-        response.headers["X-Response-Timestamp"] = datetime.now(tz=timezone.utc).isoformat() #* Add response timestamp header
+        #* Define and add response timestamp header
+        response_timestamp = datetime.now(tz=timezone.utc)
+        response.headers["X-Response-Timestamp"] = response_timestamp.isoformat()
+        #* Generate signature header
+        message = f"{request.method}|{request.url.path}|{request_timestamp.isoformat()}|{response_timestamp.isoformat()}|{str(process_time)}"
+        sign_parameters = BaseSignatureParametersTransfers.Sign(key=self._keys.private, password=self._keys.password, message=message)
+        sign_result = self._maleo_foundation.services.signature.sign(parameters=sign_parameters)
+        if sign_result.success:
+            response.headers["X-Signature"] = sign_result.data.signature
         response = self._append_cors_headers(request=request, response=response) #* Re-append CORS headers
         return response
 
@@ -125,7 +138,7 @@ class BaseMiddleware(BaseHTTPMiddleware):
         client_ip:str = "unknown"
     ) -> Response:
         response = self._add_response_headers(request, response, request_timestamp, process_time)
-        log_func = getattr(self.logger, log_level)
+        log_func = getattr(self._logger, log_level)
         log_func(
             f"Request | IP: {client_ip} | Method: {request.method} | URL: {request.url.path} | "
             f"Headers: {dict(request.headers)} - Response | Status: {response.status_code} | "
@@ -148,7 +161,7 @@ class BaseMiddleware(BaseHTTPMiddleware):
             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
         )
 
-        self.logger.error(
+        self._logger.error(
             f"Request | IP: {client_ip} | Method: {request.method} | URL: {request.url.path} | "
             f"Headers: {dict(request.headers)} - Response | Status: 500 | Exception:\n{json.dumps(error_details, indent=4)}"
         )
@@ -180,7 +193,7 @@ class BaseMiddleware(BaseHTTPMiddleware):
                 )
 
             #* 2. Optional preprocessing
-            pre_response = await self.request_processor(request)
+            pre_response = await self._request_processor(request)
             if pre_response is not None:
                 return self._build_response(
                     request=request,

maleo_foundation/models/schemas/signature.py

@@ -1,9 +1,13 @@
 from pydantic import BaseModel, Field
+from maleo_foundation.types import BaseTypes
 
 class BaseSignatureSchemas:
     class Key(BaseModel):
         key:str = Field(..., description="Key")
 
+    class Password(BaseModel):
+        password:BaseTypes.OptionalString = Field(None, min_length=32, max_length=1024, description="password")
+
     class Message(BaseModel):
         message:str = Field(..., description="Message")
 

maleo_foundation/models/transfers/general/signature.py

@@ -0,0 +1,8 @@
+from __future__ import annotations
+from maleo_foundation.models.schemas.signature import BaseSignatureSchemas
+
+class BaseSignatureGeneralTransfers:
+    class SignaturePackage(
+        BaseSignatureSchemas.Message,
+        BaseSignatureSchemas.Signature
+    ): pass

maleo_foundation/models/transfers/parameters/signature.py

@@ -0,0 +1,14 @@
+from maleo_foundation.models.schemas.signature import BaseSignatureSchemas
+
+class BaseSignatureParametersTransfers:
+    class Sign(
+        BaseSignatureSchemas.Message,
+        BaseSignatureSchemas.Password,
+        BaseSignatureSchemas.Key
+    ): pass
+
+    class Verify(
+        BaseSignatureSchemas.Signature,
+        BaseSignatureSchemas.Message,
+        BaseSignatureSchemas.Key
+    ): pass

maleo_foundation/models/transfers/results/signature.py

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

{maleo_foundation-0.1.59.dist-info → maleo_foundation-0.1.61.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maleo_foundation
-Version: 0.1.59
+Version: 0.1.61
 Summary: Foundation package for Maleo
 Author-email: Agra Bima Yuda <agra@nexmedis.com>
 License: MIT
@@ -55,6 +55,7 @@ Requires-Dist: protobuf>=5.29.4
 Requires-Dist: pyasn1>=0.6.1
 Requires-Dist: pyasn1_modules>=0.4.2
 Requires-Dist: pycparser>=2.22
+Requires-Dist: pycryptodome>=3.22.0
 Requires-Dist: pydantic>=2.11.3
 Requires-Dist: pydantic-settings>=2.9.1
 Requires-Dist: pydantic_core>=2.33.1

{maleo_foundation-0.1.59.dist-info → maleo_foundation-0.1.61.dist-info}/RECORD

@@ -6,13 +6,15 @@ maleo_foundation/extended_types.py,sha256=pIKt-_9tby4rmune3fmWcCW_mohaNRh_1lywBm
 maleo_foundation/types.py,sha256=aKXnIgEhYGSfFqNMGLc4qIKGkINBRpkOo9R9cb2CbwI,2414
 maleo_foundation/client/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 maleo_foundation/client/manager.py,sha256=hF5Uiv93yHmno8ec4ukCDrpTh2apUabMeYZNVgSbxZM,1035
-maleo_foundation/client/services/__init__.py,sha256=ur502vxzT2FxhkZ7F0c7RjOGYAYEqmwRzz3pQsrAM8M,347
+maleo_foundation/client/services/__init__.py,sha256=SUGBVhs_Zu9rNUxWIxcjGmi54W6RRlwSTqW4h8E0vW0,540
+maleo_foundation/client/services/signature.py,sha256=W9ZF_FGGOMXw03jaRlZJPkakCw0grZk52P8IAkOxYLs,4373
 maleo_foundation/client/services/token.py,sha256=KJcA6aTW12JovrbBf0KoKMDgOopz-mZ_SmCRHhWLS_k,1894
 maleo_foundation/expanded_types/__init__.py,sha256=lm_r7rxlLA0sgSTGQBMR9ZbZbVDpD7Te-UYb3oRVi1g,364
 maleo_foundation/expanded_types/client.py,sha256=To0kRXp3QTmuSu5rWKaCiTsMK9qkYiyYKYbHfw-y1fY,2396
 maleo_foundation/expanded_types/general.py,sha256=bjIBREYTS73tvS-Key7P7db82a2HHlSJ1XBAvKuYmT0,826
 maleo_foundation/expanded_types/query.py,sha256=0yUG-JIVsanzB7KAkrRz_OsrhP6J0bRqD9Q3l3atQnk,2384
 maleo_foundation/expanded_types/service.py,sha256=q8jpKdbCbLWwH1UPQavKpVE14rC5rveduk2cFWzuhGw,2416
+maleo_foundation/expanded_types/signature.py,sha256=zNgXRrxVCfEIGXsRANIa1Ljj-ebHjC2pWOTtw_ABJlQ,379
 maleo_foundation/expanded_types/token.py,sha256=4fRTJw6W5MYq71NksNrWNi7qYHQ4_lQwfu9WxwrMipc,355
 maleo_foundation/managers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 maleo_foundation/managers/db.py,sha256=Pn5EZ-c1Hy6-BihN7KokHJWmBIt3Ty96fZ0zF-srtF4,5208
@@ -26,8 +28,8 @@ maleo_foundation/managers/client/google/base.py,sha256=j3W18Pmcu9jJ5wK12bbWBI6r8
 maleo_foundation/managers/client/google/secret.py,sha256=Uh01RoOp8QOIvu8X4AGJzOJRlrfAeXHO8ZFvmKo7A-E,3114
 maleo_foundation/managers/client/google/storage.py,sha256=MPuVpLTl0QJhlBOqpxv5UtD3ANO1WCCE1sRrfHnlCZM,2355
 maleo_foundation/middlewares/__init__.py,sha256=bqE2EIFC3rWcR2AwFPR0fk2kSFfeTRzgA24GbnuT5RA,3697
-maleo_foundation/middlewares/authentication.py,sha256=mpJ4WJ25zw4SGvgpeJE9eSV3-AtK5IJtN2U8Dh9rmMk,3132
-maleo_foundation/middlewares/base.py,sha256=iGc_4JZYxE0k47Dty4aFOvpgXjQY_W_4tgqYndhq3V8,10991
+maleo_foundation/middlewares/authentication.py,sha256=SC9p_7lCcGYbO9GedOKiPDF12KaGFbv1OypJsnRzLww,3329
+maleo_foundation/middlewares/base.py,sha256=-tpnutxov5UxrKjWMxktpsZ0JqXYLQCkD3x2B3F3OCI,11821
 maleo_foundation/middlewares/cors.py,sha256=9uvBvY2N6Vxa9RP_YtESxcWo6Doi6uS0lzAG9iLY7Uc,2288
 maleo_foundation/models/__init__.py,sha256=AaKehO7c1HyKhoTGRmNHDddSeBXkW-_YNrpOGBu8Ms8,246
 maleo_foundation/models/responses.py,sha256=Ka9Peb1fVuQKaxyy11FVkUPtGtzyEm_9Xfe8Vla3ml0,4764
@@ -36,17 +38,20 @@ maleo_foundation/models/schemas/__init__.py,sha256=Xj8Ahsqyra-fmEaVcGPok5GOOsPQl
 maleo_foundation/models/schemas/general.py,sha256=hEQQPcddxMsJXMb36nqItIAfp3pqUyJOlaD7nXkNM2I,3609
 maleo_foundation/models/schemas/parameter.py,sha256=K47z2NzmTEhUiOfRiRLyRPXoQurbWsKBL7ObXAxIWRY,2100
 maleo_foundation/models/schemas/result.py,sha256=V3dljS2AdtWW4Pf8YsnQuiCylN1bZtEY1AtYC7okWuI,1747
-maleo_foundation/models/schemas/signature.py,sha256=32ECoksXCVRloTFNcb9ne3IAi5F6e6MuDniCj76ppmQ,420
+maleo_foundation/models/schemas/signature.py,sha256=4DVcsBR9TnxD2R28oWk51jMtF1j5ylmorVM3jDNVlrU,609
 maleo_foundation/models/schemas/token.py,sha256=u71kPXJyCxqn_INK05MSNFhQr9MaLfQM-icYc536xik,551
 maleo_foundation/models/transfers/__init__.py,sha256=oJLJ3Geeme6vBw7R2Dhvdvg4ziVvzEYAGJaP-tm_90w,299
 maleo_foundation/models/transfers/general/__init__.py,sha256=0yW67vJvKgJmZ9htteOVatG7mb-YEpHF62dpwH2g_Bk,146
+maleo_foundation/models/transfers/general/signature.py,sha256=EFcr-QC3QcDLZivkmL89ERVc5ZDGe_SYH5dMItll5Bs,264
 maleo_foundation/models/transfers/general/token.py,sha256=QZNGG5DdmQDTYIqNFMqBQDJoeahIHgzBzyXiMoTS-JA,2414
 maleo_foundation/models/transfers/parameters/__init__.py,sha256=oKW4RPIEISISRjsJzD8lsCGY1HhZRTzshPpWHcJu86k,353
 maleo_foundation/models/transfers/parameters/client.py,sha256=tn_Hwa-k-Utp5rODe7GylqZB8djIKKupgkUFscYCyLc,4059
 maleo_foundation/models/transfers/parameters/general.py,sha256=WoekZJCIoAllhXdRIJkNRdNq0QEIn0bteiHJLtzkCxU,579
 maleo_foundation/models/transfers/parameters/service.py,sha256=d7Xy_R-DtLBRozyD6r8YnTiuKlE3sb9HMDCCq9WmUbY,6757
+maleo_foundation/models/transfers/parameters/signature.py,sha256=Kn6gJrQUHyn2uG6LyYnhbUEMfXJVTLgMG6n3CXZ4hu8,395
 maleo_foundation/models/transfers/parameters/token.py,sha256=WTmCKoP-KJLqZjdwr__BeVnBrnRrsxzHSQ0IBaOKvqw,535
 maleo_foundation/models/transfers/results/__init__.py,sha256=0_8uJ1IQW87RZ4nIxzWkQVi3Fxb7B8myZTngXfoxgNc,241
+maleo_foundation/models/transfers/results/signature.py,sha256=md3tBOfjJlg-35ICSt8h_EZZett_x7obdlx_GQ3lB00,619
 maleo_foundation/models/transfers/results/token.py,sha256=4zDgj8FWGK6Rcz_pprwnLcpRyyXKRBPbrCl3IOrRvVg,574
 maleo_foundation/models/transfers/results/client/__init__.py,sha256=xBRuY0NUIPpQEGQ2qoBnqLZGX4W1YSrQ0VnDf5OYJBo,290
 maleo_foundation/models/transfers/results/client/service.py,sha256=TO_U53vmUEnFWiiyuu33ao3BUidt6KFxvk3GC9uo8JE,1108
@@ -57,8 +62,6 @@ maleo_foundation/models/transfers/results/service/general.py,sha256=G4x-MhQI7Km9
 maleo_foundation/models/transfers/results/service/query.py,sha256=G5A4FRkHyRRlpuGWrPV5-vqgyyBjMqu8f-Ka9BjD0lA,1828
 maleo_foundation/models/transfers/results/service/controllers/__init__.py,sha256=HZJWMy2dskzOCzLmp_UaL9rjbQ-sDMI7sd2bXb-4QOU,175
 maleo_foundation/models/transfers/results/service/controllers/rest.py,sha256=wCuFyOTQkuBs2cqjPsWnPy0XIsCfMqGByhrSy57qp7Y,1107
-maleo_foundation/services/__init__.py,sha256=Ho5zJSA89xdGFKIwOdzjmd8sm23cIuwrqYAxCEBBTIU,120
-maleo_foundation/services/token.py,sha256=QkiMBTe4aol2uDBfFP2MFa58j-yevr8HtBjenifElR0,1230
 maleo_foundation/utils/__init__.py,sha256=SRPEVoqjZoO6W8rtF_Ti8VIangg6Auwm6eHbZMdOthY,520
 maleo_foundation/utils/controller.py,sha256=ECzPzpw36zBAjKcWcDbUAhIJGbc6UpeypdUUX6ipXBg,6396
 maleo_foundation/utils/exceptions.py,sha256=LPPcU-6_3NbRIBZg2Nr2Ac5HF1qZJbHbMVnwfIfZg6g,3702
@@ -72,7 +75,7 @@ maleo_foundation/utils/loaders/__init__.py,sha256=Dnuv7BWyglSddnbsFb96s-b3KaW7UK
 maleo_foundation/utils/loaders/json.py,sha256=NsXLq3VZSgzmEf99tV1VtrmiudWdQ8Pzh_hI4Rm0cM8,397
 maleo_foundation/utils/loaders/key.py,sha256=GZ4h1ONfp6Xx8-E8AWoGP4ajAZrwPhZRtidjn_u82Qg,2562
 maleo_foundation/utils/loaders/yaml.py,sha256=jr8v3BlgmRCMTzdNgKhIYt1tnubaJXcDSSGkKVR8pbw,362
-maleo_foundation-0.1.59.dist-info/METADATA,sha256=QLCBip2ZVnMUnDfoTPgae6BxoaOFpQkbsLH_G46hufA,3354
-maleo_foundation-0.1.59.dist-info/WHEEL,sha256=0CuiUZ_p9E4cD6NyLD6UG80LBXYyiSYZOKDm5lp32xk,91
-maleo_foundation-0.1.59.dist-info/top_level.txt,sha256=_iBos3F_bhEOdjOnzeiEYSrCucasc810xXtLBXI8cQc,17
-maleo_foundation-0.1.59.dist-info/RECORD,,
+maleo_foundation-0.1.61.dist-info/METADATA,sha256=hK2ChHmwvrqLf-cO6UwXWoGSsusrU2UCjkuAhx02nsg,3390
+maleo_foundation-0.1.61.dist-info/WHEEL,sha256=0CuiUZ_p9E4cD6NyLD6UG80LBXYyiSYZOKDm5lp32xk,91
+maleo_foundation-0.1.61.dist-info/top_level.txt,sha256=_iBos3F_bhEOdjOnzeiEYSrCucasc810xXtLBXI8cQc,17
+maleo_foundation-0.1.61.dist-info/RECORD,,

maleo_foundation/services/__init__.py

@@ -1,5 +0,0 @@
-from __future__ import annotations
-from .token import BaseTokenService
-
-class BaseServices:
-    Token = BaseTokenService

maleo_foundation/services/token.py

@@ -1,20 +0,0 @@
-import jwt
-from maleo_foundation.models.transfers.general.token import BaseTokenGeneralTransfers
-from maleo_foundation.models.schemas.token import BaseTokenSchemas
-from maleo_foundation.models.transfers.parameters.token import BaseTokenParametersTransfers
-from maleo_foundation.models.transfers.results.token import BaseTokenResultsTransfers
-from maleo_foundation.expanded_types.token import BaseTokenResultsTypes
-
-class BaseTokenService:
-    @staticmethod
-    def encode(parameters:BaseTokenParametersTransfers.Encode) -> BaseTokenResultsTypes.Encode:
-        payload = BaseTokenGeneralTransfers.EncodePayload.model_validate(parameters.payload.model_dump()).model_dump(mode="json")
-        token = jwt.encode(payload=payload, key=parameters.key.encode(), algorithm="RS256")
-        data = BaseTokenSchemas.Token(token=token)
-        return BaseTokenResultsTransfers.Encode(data=data)
-
-    @staticmethod
-    def decode(parameters:BaseTokenParametersTransfers.Decode) -> BaseTokenResultsTypes.Decode:
-        payload = jwt.decode(jwt=parameters.token, key=parameters.key, algorithms=["RS256"])
-        data = BaseTokenGeneralTransfers.DecodePayload.model_validate(payload)
-        return BaseTokenResultsTransfers.Decode(data=data)