maleo-foundation 0.1.58__tar.gz → 0.1.60__tar.gz

{maleo_foundation-0.1.58 → maleo_foundation-0.1.60}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maleo_foundation
-Version: 0.1.58
+Version: 0.1.60
 Summary: Foundation package for Maleo
 Author-email: Agra Bima Yuda <agra@nexmedis.com>
 License: MIT

{maleo_foundation-0.1.58 → maleo_foundation-0.1.60}/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-0.1.60/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-0.1.60/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-0.1.58 → maleo_foundation-0.1.60}/maleo_foundation/managers/client/maleo.py

@@ -26,8 +26,13 @@ class MaleoClientManager(ClientManager):
         service_manager:ServiceManager
     ):
         self._url = url
+        self._service_manager = service_manager
         super().__init__(key, name, service_manager.log_config, service_manager.configs.service.key)
 
+    @property
+    def service_manager(self) -> ServiceManager:
+        return self._service_manager
+
     def _initialize_controllers(self) -> None:
         #* Initialize managers
         http_controller_manager = ClientHTTPControllerManager(url=self._url)

{maleo_foundation-0.1.58 → maleo_foundation-0.1.60}/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-0.1.58 → maleo_foundation-0.1.60}/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-0.1.58 → maleo_foundation-0.1.60}/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-0.1.60/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-0.1.60/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-0.1.60/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.58 → maleo_foundation-0.1.60}/maleo_foundation.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maleo_foundation
-Version: 0.1.58
+Version: 0.1.60
 Summary: Foundation package for Maleo
 Author-email: Agra Bima Yuda <agra@nexmedis.com>
 License: MIT

{maleo_foundation-0.1.58 → maleo_foundation-0.1.60}/maleo_foundation.egg-info/SOURCES.txt

@@ -14,12 +14,14 @@ maleo_foundation.egg-info/top_level.txt
 maleo_foundation/client/__init__.py
 maleo_foundation/client/manager.py
 maleo_foundation/client/services/__init__.py
+maleo_foundation/client/services/signature.py
 maleo_foundation/client/services/token.py
 maleo_foundation/expanded_types/__init__.py
 maleo_foundation/expanded_types/client.py
 maleo_foundation/expanded_types/general.py
 maleo_foundation/expanded_types/query.py
 maleo_foundation/expanded_types/service.py
+maleo_foundation/expanded_types/signature.py
 maleo_foundation/expanded_types/token.py
 maleo_foundation/managers/__init__.py
 maleo_foundation/managers/db.py
@@ -47,13 +49,16 @@ maleo_foundation/models/schemas/signature.py
 maleo_foundation/models/schemas/token.py
 maleo_foundation/models/transfers/__init__.py
 maleo_foundation/models/transfers/general/__init__.py
+maleo_foundation/models/transfers/general/signature.py
 maleo_foundation/models/transfers/general/token.py
 maleo_foundation/models/transfers/parameters/__init__.py
 maleo_foundation/models/transfers/parameters/client.py
 maleo_foundation/models/transfers/parameters/general.py
 maleo_foundation/models/transfers/parameters/service.py
+maleo_foundation/models/transfers/parameters/signature.py
 maleo_foundation/models/transfers/parameters/token.py
 maleo_foundation/models/transfers/results/__init__.py
+maleo_foundation/models/transfers/results/signature.py
 maleo_foundation/models/transfers/results/token.py
 maleo_foundation/models/transfers/results/client/__init__.py
 maleo_foundation/models/transfers/results/client/service.py
@@ -64,8 +69,6 @@ maleo_foundation/models/transfers/results/service/general.py
 maleo_foundation/models/transfers/results/service/query.py
 maleo_foundation/models/transfers/results/service/controllers/__init__.py
 maleo_foundation/models/transfers/results/service/controllers/rest.py
-maleo_foundation/services/__init__.py
-maleo_foundation/services/token.py
 maleo_foundation/utils/__init__.py
 maleo_foundation/utils/controller.py
 maleo_foundation/utils/exceptions.py

{maleo_foundation-0.1.58 → maleo_foundation-0.1.60}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "maleo_foundation"
-version = "0.1.58"
+version = "0.1.60"
 description = "Foundation package for Maleo"
 authors = [
     { name = "Agra Bima Yuda", email = "agra@nexmedis.com" }

maleo_foundation-0.1.58/maleo_foundation/services/__init__.py

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

maleo_foundation-0.1.58/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)