maleo-foundation 0.2.80__py3-none-any.whl → 0.2.81__py3-none-any.whl

maleo_foundation/managers/service.py

@@ -416,7 +416,7 @@ class ServiceManager:
             maleo_foundation=self._foundation
         )
         self._middleware.add_all()
-        self._loggers.application.info("Middlewares addedd successfully")
+        self._loggers.application.info("Middlewares added successfully")
 
         #* Add exception handler(s)
         self._loggers.application.info("Adding exception handlers")
@@ -428,7 +428,7 @@ class ServiceManager:
             exc_class_or_status_code=HTTPException,
             handler=BaseExceptions.http_exception_handler
         )
-        self._loggers.application.info("Exception handlers addedd successfully")
+        self._loggers.application.info("Exception handlers added successfully")
 
         #* Include router
         self._loggers.application.info("Including routers")

maleo_foundation/middlewares/base.py

@@ -5,7 +5,6 @@ import traceback
 from collections import defaultdict
 from datetime import datetime, timedelta, timezone
 from typing import Awaitable, Callable, Optional, Sequence, Dict, List
-from uuid import UUID, uuid4
 
 from fastapi import FastAPI, Request, Response, status
 from fastapi.responses import JSONResponse
@@ -19,7 +18,8 @@ from maleo_foundation.models.responses import BaseResponses
 from maleo_foundation.models.transfers.general.token import MaleoFoundationTokenGeneralTransfers
 from maleo_foundation.models.transfers.parameters.token import MaleoFoundationTokenParametersTransfers
 from maleo_foundation.models.transfers.parameters.signature import MaleoFoundationSignatureParametersTransfers
-from maleo_foundation.utils.extractor import BaseExtractors
+from maleo_foundation.models.transfers.general import RequestContextTransfers
+from maleo_foundation.utils.extractor import extract_request_context
 from maleo_foundation.utils.logging import MiddlewareLogger
 
 RequestProcessor = Callable[[Request], Awaitable[Optional[Response]]]
@@ -46,11 +46,12 @@ class RateLimiter:
 
     def is_rate_limited(
         self,
-        client_ip:str
+        request_context:RequestContextTransfers
     ) -> bool:
         """Check if client IP is rate limited and record the request."""
         with self._lock:
             now = datetime.now()
+            client_ip = request_context.ip_address
             self._last_seen[client_ip] = now
 
             # Remove old requests outside the window
@@ -101,7 +102,6 @@ class RateLimiter:
                 f"Current tracked IPs: {len(self._requests)}"
             )
 
-
 class ResponseBuilder:
     """Handles response building and header management."""
 
@@ -115,42 +115,38 @@ class ResponseBuilder:
 
     def add_response_headers(
         self,
-        request:Request,
         authentication:Authentication,
         response:Response,
-        request_timestamp:datetime,
-        response_timestamp:datetime,
-        process_time:float,
-        request_id:UUID
+        request_context:RequestContextTransfers,
+        responded_at:datetime,
+        process_time:float
     ) -> Response:
         """Add custom headers to response."""
         # Basic headers
-        response.headers["X-Request-ID"] = str(request_id)
+        response.headers["X-Request-ID"] = str(request_context.request_id)
         response.headers["X-Process-Time"] = str(process_time)
-        response.headers["X-Request-Timestamp"] = request_timestamp.isoformat()
-        response.headers["X-Response-Timestamp"] = response_timestamp.isoformat()
+        response.headers["X-Requested-At"] = request_context.requested_at.isoformat()
+        response.headers["X-Responded-At"] = responded_at.isoformat()
 
         # Add signature header
-        self._add_signature_header(request, response, request_timestamp, response_timestamp, process_time, request_id)
+        self._add_signature_header(response, request_context, responded_at, process_time)
 
         # Add new authorization header if needed
-        self._add_new_authorization_header(request, authentication, response)
+        self._add_new_authorization_header(request_context, authentication, response)
 
         return response
 
     def _add_signature_header(
         self,
-        request:Request,
         response:Response,
-        request_timestamp:datetime,
-        response_timestamp:datetime,
-        process_time:float,
-        request_id:UUID
+        request_context:RequestContextTransfers,
+        responded_at:datetime,
+        process_time:float
     ) -> None:
         """Generate and add signature header."""
         message = (
-            f"{request.method}|{request.url.path}|{request_timestamp.isoformat()}|"
-            f"{response_timestamp.isoformat()}|{str(process_time)}|{str(request_id)}"
+            f"{request_context.method}|{request_context.url}|{request_context.requested_at.isoformat()}|"
+            f"{responded_at.isoformat()}|{str(process_time)}|{str(request_context.request_id)}"
         )
 
         sign_parameters = MaleoFoundationSignatureParametersTransfers.Sign(
@@ -165,12 +161,12 @@ class ResponseBuilder:
 
     def _add_new_authorization_header(
         self,
-        request:Request,
+        request_context:RequestContextTransfers,
         authentication:Authentication,
         response:Response
     ) -> None:
         """Add new authorization header for refresh tokens."""
-        if not self._should_regenerate_auth(request, authentication, response):
+        if not self._should_regenerate_auth(request_context, authentication, response):
             return
 
         payload = MaleoFoundationTokenGeneralTransfers.BaseEncodePayload.model_validate(
@@ -189,7 +185,7 @@ class ResponseBuilder:
 
     def _should_regenerate_auth(
         self,
-        request:Request,
+        request_context:RequestContextTransfers,
         authentication:Authentication,
         response:Response
     ) -> bool:
@@ -198,26 +194,20 @@ class ResponseBuilder:
             authentication.user.is_authenticated
             and authentication.credentials.token.type == BaseEnums.TokenType.REFRESH
             and 200 <= response.status_code < 300
-            and "logout" not in request.url.path
+            and "logout" not in request_context.url
         )
 
-
 class RequestLogger:
     """Handles request/response logging."""
 
-    def __init__(
-        self,
-        logger:MiddlewareLogger
-    ):
+    def __init__(self, logger:MiddlewareLogger):
         self.logger = logger
 
     def log_request_response(
         self,
-        request:Request,
         authentication:Authentication,
         response:Response,
-        client_ip:str,
-        request_id:UUID,
+        request_context:RequestContextTransfers,
         log_level:str = "info"
     ) -> None:
         """Log request and response details."""
@@ -225,39 +215,32 @@ class RequestLogger:
 
         log_func = getattr(self.logger, log_level)
         log_func(
-            f"Request | ID: {request_id} {authentication_info} | IP: {client_ip} | "
-            f"Host: {request.client.host} | Port: {request.client.port} | "
-            f"Method: {request.method} | URL: {request.url.path} | "
-            f"Headers: {dict(request.headers)} - Response | Status: {response.status_code}"
+            f"Request | ID: {request_context.request_id} {authentication_info} | "
+            f"IP: {request_context.ip_address} | Host: {request_context.host} | "
+            f"Method: {request_context.method} | URL: {request_context.url} - "
+            f"Response | Status: {response.status_code}"
         )
     
     def log_exception(
         self,
-        request:Request,
         authentication:Authentication,
         error:Exception,
-        client_ip:str,
-        request_id:UUID
+        request_context:RequestContextTransfers
     ) -> None:
         """Log exception details."""
         authentication_info = self._get_authentication_info(authentication)
 
         error_details = {
-            "request_id": str(request_id),
+            "request_context": request_context.model_dump(mode="json"),
             "error": str(error),
-            "traceback": traceback.format_exc().split("\n"),
-            "client_ip": client_ip,
-            "method": request.method,
-            "url": request.url.path,
-            "headers": dict(request.headers),
+            "traceback": traceback.format_exc().split("\n")
         }
 
         self.logger.error(
-            f"Request | ID: {request_id} {authentication_info} | IP: {client_ip} | "
-            f"Host: {request.client.host} | Port: {request.client.port} | "
-            f"Method: {request.method} | URL: {request.url.path} | "
-            f"Headers: {dict(request.headers)} - Response | Status: 500 | "
-            f"Exception:\n{json.dumps(error_details, indent=4)}"
+            f"Request | ID: {request_context.request_id} {authentication_info} | "
+            f"IP: {request_context.ip_address} | Host: {request_context.host} | "
+            f"Method: {request_context.method} | URL: {request_context.url} - "
+            f"Response | Status: 500 | Exception:\n{json.dumps(error_details, indent=4)}"
         )
 
     def _get_authentication_info(self, authentication:Authentication) -> str:
@@ -312,43 +295,36 @@ class BaseMiddleware(BaseHTTPMiddleware):
 
     async def dispatch(self, request:Request, call_next:RequestResponseEndpoint) -> Response:
         """Main middleware dispatch method."""
-        # Generate unique request ID
-        request_id = uuid4()
-        request.state.request_id = request_id
-
         # Setup
         self.rate_limiter.cleanup_old_data(self.request_logger.logger)
-        request_timestamp = datetime.now(tz=timezone.utc)
-        request.state.request_timestamp = request_timestamp
+        request_context = extract_request_context(request)
+        request.state.request_context = request_context
         start_time = time.perf_counter()
-        client_ip = BaseExtractors.extract_client_ip(request)
         authentication = Authentication(credentials=request.auth, user=request.user)
 
         try:
             # Rate limiting check
-            if self.rate_limiter.is_rate_limited(client_ip):
+            if self.rate_limiter.is_rate_limited(request_context):
                 return self._create_rate_limit_response(
-                    request, authentication, client_ip, request_timestamp, start_time, request_id
+                    authentication, request_context, start_time
                 )
 
             # Optional preprocessing
             pre_response = await self._request_processor(request)
             if pre_response is not None:
                 return self._build_final_response(
-                    request, authentication, pre_response, client_ip,
-                    request_timestamp, start_time, request_id
+                    authentication, pre_response, request_context, start_time
                 )
 
             # Main request processing
             response = await call_next(request)
             return self._build_final_response(
-                request, authentication, response, client_ip,
-                request_timestamp, start_time, request_id
+                authentication, response, request_context, start_time
             )
 
         except Exception as e:
             return self._handle_exception(
-                request, authentication, e, client_ip, request_timestamp, start_time, request_id
+                request, authentication, e, request_context, start_time
             )
 
     async def _request_processor(self, request:Request) -> Optional[Response]:
@@ -357,12 +333,9 @@ class BaseMiddleware(BaseHTTPMiddleware):
 
     def _create_rate_limit_response(
         self,
-        request:Request,
         authentication:Authentication,
-        client_ip:str,
-        request_timestamp:datetime,
-        start_time:float,
-        request_id:UUID
+        request_context:RequestContextTransfers,
+        start_time:float
     ) -> Response:
         """Create rate limit exceeded response."""
         response = JSONResponse(
@@ -371,49 +344,42 @@ class BaseMiddleware(BaseHTTPMiddleware):
         )
         
         return self._build_final_response(
-            request, authentication, response, client_ip,
-            request_timestamp, start_time, request_id, log_level="warning"
+            authentication, response, request_context, start_time, log_level="warning"
         )
 
     def _build_final_response(
         self,
-        request:Request,
         authentication:Authentication,
         response:Response,
-        client_ip:str,
-        request_timestamp:datetime,
+        request_context:RequestContextTransfers,
         start_time:float,
-        request_id:UUID,
         log_level:str = "info"
     ) -> Response:
         """Build final response with headers and logging."""
-        response_timestamp = datetime.now(tz=timezone.utc)
+        responded_at = datetime.now(tz=timezone.utc)
         process_time = time.perf_counter() - start_time
         
         # Add headers
         response = self.response_builder.add_response_headers(
-            request, authentication, response, request_timestamp, response_timestamp, process_time, request_id
+            authentication, response, request_context, responded_at, process_time
         )
 
         # Log request/response
         self.request_logger.log_request_response(
-            request, authentication, response, client_ip, request_id, log_level
+            authentication, response, request_context, log_level
         )
 
         return response
 
     def _handle_exception(
         self,
-        request:Request,
         authentication:Authentication,
         error:Exception,
-        client_ip:str,
-        request_timestamp:datetime,
-        start_time:float,
-        request_id:UUID
+        request_context:RequestContextTransfers,
+        start_time:float
     ) -> Response:
         """Handle exceptions and create error response."""
-        response_timestamp = datetime.now(tz=timezone.utc)
+        responded_at = datetime.now(tz=timezone.utc)
         process_time = time.perf_counter() - start_time
         
         response = JSONResponse(
@@ -422,11 +388,11 @@ class BaseMiddleware(BaseHTTPMiddleware):
         )
 
         # Log exception
-        self.request_logger.log_exception(request, authentication, error, client_ip, request_id)
+        self.request_logger.log_exception(authentication, error, request_context)
         
         # Add headers
         return self.response_builder.add_response_headers(
-            request, authentication, response, request_timestamp, response_timestamp, process_time, request_id
+            authentication, response, request_context, responded_at, process_time
         )
 
 

maleo_foundation/models/transfers/general/__init__.py

@@ -1,5 +1,10 @@
 from __future__ import annotations
+from datetime import datetime, timezone
+from pydantic import BaseModel, Field
+from typing import Dict
+from uuid import UUID
 from maleo_foundation.models.schemas.general import BaseGeneralSchemas
+from maleo_foundation.types import BaseTypes
 from .token import MaleoFoundationTokenGeneralTransfers
 
 class BaseGeneralTransfers:
@@ -8,4 +13,23 @@ class BaseGeneralTransfers:
 class AccessTransfers(
     BaseGeneralSchemas.AccessedBy,
     BaseGeneralSchemas.AccessedAt
-): pass
+): pass
+
+class RequestContextTransfers(BaseModel):
+    request_id:UUID = Field(..., description="Unique identifier for tracing the request")
+    requested_at:datetime = Field(datetime.now(tz=timezone.utc), description="Request timestamp")
+    method:str = Field(..., description="Request's method")
+    url:str = Field(..., description="Request's URL")
+    path_params:Dict = Field(..., description="Request's path parameters")
+    query_params:Dict = Field(..., description="Request's query parameters")
+    ip_address:str = Field("unknown", description="Client's IP address")
+    is_internal:BaseTypes.OptionalBoolean = Field(None, description="True if IP is internal")
+    user_agent:BaseTypes.OptionalString = Field(None, description="User-Agent string")
+    ua_browser:BaseTypes.OptionalString = Field(None, description="Browser info from sec-ch-ua")
+    ua_mobile:BaseTypes.OptionalString = Field(None, description="Is mobile device?")
+    platform:BaseTypes.OptionalString = Field(None, description="Client platform or OS")
+    referer:BaseTypes.OptionalString = Field(None, description="Referrer URL")
+    origin:BaseTypes.OptionalString = Field(None, description="Origin of the request")
+    host:BaseTypes.OptionalString = Field(None, description="Host header from request")
+    forwarded_proto:BaseTypes.OptionalString = Field(None, description="Forwarded protocol (http/https)")
+    language:BaseTypes.OptionalString = Field(None, description="Accepted languages from client")

maleo_foundation/utils/dependencies/context.py

@@ -0,0 +1,9 @@
+from fastapi.requests import Request
+from maleo_foundation.models.transfers.general import RequestContextTransfers
+
+class ContextDependencies:
+    @staticmethod
+    def get_request_context(
+        request:Request
+    ) -> RequestContextTransfers:
+        return request.state.request_context

maleo_foundation/utils/extractor.py

@@ -1,20 +1,55 @@
+from datetime import datetime, timezone
+from fastapi import Request
 from starlette.requests import HTTPConnection
+from uuid import uuid4
+from maleo_foundation.models.transfers.general import RequestContextTransfers
 
-class BaseExtractors:
-    @staticmethod
-    def extract_client_ip(conn:HTTPConnection) -> str:
-        """Extract client IP with more robust handling of proxies"""
-        #* Check for X-Forwarded-For header (common when behind proxy/load balancer)
-        x_forwarded_for = conn.headers.get("X-Forwarded-For")
-        if x_forwarded_for:
-            #* The client's IP is the first one in the list
-            ips = [ip.strip() for ip in x_forwarded_for.split(",")]
-            return ips[0]
-
-        #* Check for X-Real-IP header (used by some proxies)
-        x_real_ip = conn.headers.get("X-Real-IP")
-        if x_real_ip:
-            return x_real_ip
-
-        #* Fall back to direct client connection
-        return conn.client.host if conn.client else "unknown"
+def extract_client_ip(conn:HTTPConnection) -> str:
+    """Extract client IP with more robust handling of proxies"""
+    #* Check for X-Forwarded-For header (common when behind proxy/load balancer)
+    x_forwarded_for = conn.headers.get("X-Forwarded-For")
+    if x_forwarded_for:
+        #* The client's IP is the first one in the list
+        ips = [ip.strip() for ip in x_forwarded_for.split(",")]
+        return ips[0]
+
+    #* Check for X-Real-IP header (used by some proxies)
+    x_real_ip = conn.headers.get("X-Real-IP")
+    if x_real_ip:
+        return x_real_ip
+
+    #* Fall back to direct client connection
+    return conn.client.host if conn.client else "unknown"
+
+def extract_request_context(request:Request) -> RequestContextTransfers:
+    headers = request.headers
+
+    request_id = headers.get("x-request-id")
+    if request_id is None:
+        request_id = uuid4()
+
+    ip_address = extract_client_ip(request)
+
+    ua_browser = headers.get("sec-ch-ua", "")
+    if ua_browser:
+        ua_browser = ua_browser.replace('"', "").split(",")[0].strip()
+
+    return RequestContextTransfers(
+        request_id=request_id,
+        requested_at=datetime.now(tz=timezone.utc),
+        method=request.method,
+        url=request.url.path,
+        path_params=dict(request.path_params),
+        query_params=dict(request.query_params),
+        ip_address=ip_address,
+        is_internal=ip_address.startswith("10.") or ip_address.startswith("192.168.") or ip_address.startswith("172."),
+        user_agent=headers.get("user-agent"),
+        ua_browser=ua_browser,
+        ua_mobile=headers.get("sec-ch-ua-mobile"),
+        platform=headers.get("sec-ch-ua-platform"),
+        referer=headers.get("referer"),
+        origin=headers.get("origin"),
+        host=headers.get("host"),
+        forwarded_proto=headers.get("x-forwarded-proto"),
+        language=headers.get("accept-language"),
+    )

{maleo_foundation-0.2.80.dist-info → maleo_foundation-0.2.81.dist-info}/METADATA

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

{maleo_foundation-0.2.80.dist-info → maleo_foundation-0.2.81.dist-info}/RECORD

@@ -34,7 +34,7 @@ maleo_foundation/expanded_types/encryption/rsa.py,sha256=Esf_H8nMz2kOLAWa3M7dlD-
 maleo_foundation/managers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 maleo_foundation/managers/db.py,sha256=cpY1IOiUytT9XXYtzS0E9OSYOuB7jBKo0XHe__uI1Jg,5340
 maleo_foundation/managers/middleware.py,sha256=77wRCC_CWc22nSDL-UJanO3rXmSB7wLzaAIXEFjXq6M,4249
-maleo_foundation/managers/service.py,sha256=n2ubW5NoeBBju0t0fLSWa0FxeZMLzmoRcimuCIobgzk,19284
+maleo_foundation/managers/service.py,sha256=9qPmOUh5PPXu03-xnZIRU4C3mNbMOnYrfJQs87oqt6k,19282
 maleo_foundation/managers/cache/__init__.py,sha256=CeY0oof2bVl_v5WS-FKXNwn2gf3xrEMfUsHK9cHo59s,471
 maleo_foundation/managers/cache/base.py,sha256=YyPjde4KTsp2IHV6NdFMysa0ev-1GX1rtX-0jQPuIBU,837
 maleo_foundation/managers/cache/redis.py,sha256=xLa8QfXdNtghs0eBxIqc04H3XTYmxLEzrqJZAFCigvM,1150
@@ -47,7 +47,7 @@ maleo_foundation/managers/client/google/parameter.py,sha256=Lnj7mQgxWQpsQwbmDRK5
 maleo_foundation/managers/client/google/secret.py,sha256=Ski1CHYeA8vjSk2Oc2Pf4CfFrzT_RcA6NEZwza7gM7Y,4464
 maleo_foundation/managers/client/google/storage.py,sha256=Hq79cVreWR2AGwUzpD57NzziZjqxj__TqYIBRy-A9A0,5340
 maleo_foundation/middlewares/authentication.py,sha256=UL6kL65SvqrzemlIDopoO9N1C05eWlYMHVR2tiRsVEA,4821
-maleo_foundation/middlewares/base.py,sha256=R-N8rxUaPt7_mvK6DI8y8Jal8GfzuD7Yyx3VLp9_tQA,17097
+maleo_foundation/middlewares/base.py,sha256=r3XDTEhK6BB8YZ1Y8oyqExY78s4yzOqX7s7XokRlTlw,16308
 maleo_foundation/middlewares/cors.py,sha256=9uvBvY2N6Vxa9RP_YtESxcWo6Doi6uS0lzAG9iLY7Uc,2288
 maleo_foundation/models/__init__.py,sha256=AaKehO7c1HyKhoTGRmNHDddSeBXkW-_YNrpOGBu8Ms8,246
 maleo_foundation/models/responses.py,sha256=nE5qThK-WgcYB-9J4wHzJltMA3PLmWbMI-dkxAxAdII,5631
@@ -62,7 +62,7 @@ maleo_foundation/models/schemas/result.py,sha256=MaWDyKGvZu0IcvKMj30lrMXojGV9Mhi
 maleo_foundation/models/schemas/signature.py,sha256=-5ldTnJsjwqPRbHw7PFcLKITqEXJ_qKDdRHShK75NVA,620
 maleo_foundation/models/schemas/token.py,sha256=RYq8v1T_WZIu8lcjwyV6Pp7ZjFkr_lW9x6QyDmXBsfw,563
 maleo_foundation/models/transfers/__init__.py,sha256=oJLJ3Geeme6vBw7R2Dhvdvg4ziVvzEYAGJaP-tm_90w,299
-maleo_foundation/models/transfers/general/__init__.py,sha256=7yQNGSihJt1db6i_zIrhLdY2Tgn5lrTxuDlAVlDh2vo,340
+maleo_foundation/models/transfers/general/__init__.py,sha256=IOt9afCpDu7bO0rkZLiiLLP37w5rIZTxmnv6MD9od8E,1990
 maleo_foundation/models/transfers/general/key.py,sha256=tLKkXbwNu7Oc1MdKa8-Y7TlBAIk54h_02AmL5Yg2PrQ,751
 maleo_foundation/models/transfers/general/signature.py,sha256=J9xQy2HjpCQOnES7RJqsUnDgjFPuakQ1mxyfdTdstSE,297
 maleo_foundation/models/transfers/general/token.py,sha256=O_U6dQS7oMScJzqufl6Pe21pTxMsYhOzKH8aFLxjblQ,2895
@@ -101,7 +101,7 @@ maleo_foundation/utils/__init__.py,sha256=KoERe8U2ERGZeAKUNBPW_itk7g9YpH7v7_mD9_
 maleo_foundation/utils/client.py,sha256=F5X9TUxWQgeOHjwsMpPoSRhZANQYZ_iFv0RJDTUVhrw,2820
 maleo_foundation/utils/controller.py,sha256=D8uUfqkMpPw8M8Ykn8Uxn7dfRGwxmBxSP1h9xSkYw1I,6945
 maleo_foundation/utils/exceptions.py,sha256=eM__Mxo-BC5d7JmoBd-Wh-fmryUdfjNfOuY_eONK5Fk,6361
-maleo_foundation/utils/extractor.py,sha256=SZXVYDHWGaA-Dd1BUydwF2HHdZqexEielS4CjL0Ceng,814
+maleo_foundation/utils/extractor.py,sha256=0HoJ0hLqt3-izaekjPfxqWjvUmXTsm4Muyttu0_VyuI,2109
 maleo_foundation/utils/logging.py,sha256=W5Fhk_xAXVqSujaY8mv3hRH4wlQSpUn4ReuMoiKcQa4,7759
 maleo_foundation/utils/merger.py,sha256=z9GROLVtGpwx84bOiakBFphKazsI-9l3F3WauTDwQLs,597
 maleo_foundation/utils/query.py,sha256=nDj-9Q-5eAOvqXqKgKjtHaFAxVAY87E0BMaVXmTN7jA,7957
@@ -109,6 +109,7 @@ maleo_foundation/utils/repository.py,sha256=knBi3xOLlhBIEtChvqbZh4wXmgrFCB3rDwQX
 maleo_foundation/utils/searcher.py,sha256=gsseMkr0swKj3l-xil5qqncTbYNkS96eieFE_ehaF8I,504
 maleo_foundation/utils/dependencies/__init__.py,sha256=0KKGrdfj8Cc5A4SRk_ZBAxzOP795Mizdb4zIBh07KC4,122
 maleo_foundation/utils/dependencies/auth.py,sha256=wS9qnmd1n2WsFhiSfyq_3Io3wwZKTENVPv4rMwxJslE,727
+maleo_foundation/utils/dependencies/context.py,sha256=OXem2E00u2D3GleXhV8VI3u0cayG2CZpvVz32a0xHhs,292
 maleo_foundation/utils/formatter/__init__.py,sha256=iKf5YCbEdg1qKnFHyKqqcQbqAqEeRUf8mhI3v3dQoj8,78
 maleo_foundation/utils/formatter/case.py,sha256=TmvvlfzGdC_omMTB5vAa40TZBxQ3hnr-SYeo0M52Rlg,1352
 maleo_foundation/utils/loaders/__init__.py,sha256=P_3ycGfeDXFjAi8bE4iLWHxBveqUIdpHgGv-klRWM3s,282
@@ -118,7 +119,7 @@ maleo_foundation/utils/loaders/credential/__init__.py,sha256=qopTKvcMVoTFwyRijeg
 maleo_foundation/utils/loaders/credential/google.py,sha256=HUcuHD4tXHPt0eHInlFYxA_MDrGSOtbenpd0PX156OM,1255
 maleo_foundation/utils/loaders/key/__init__.py,sha256=hVygcC2ImHc_aVrSrOmyedR8tMUZokWUKCKOSh5ctbo,106
 maleo_foundation/utils/loaders/key/rsa.py,sha256=gDhyX6iTFtHiluuhFCozaZ3pOLKU2Y9TlrNMK_GVyGU,3796
-maleo_foundation-0.2.80.dist-info/METADATA,sha256=dRNIGvejuDcdeeazla9MoD2p0H1LGUATumhyh2XTB00,3598
-maleo_foundation-0.2.80.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-maleo_foundation-0.2.80.dist-info/top_level.txt,sha256=_iBos3F_bhEOdjOnzeiEYSrCucasc810xXtLBXI8cQc,17
-maleo_foundation-0.2.80.dist-info/RECORD,,
+maleo_foundation-0.2.81.dist-info/METADATA,sha256=JLiCodCLzxMikL7jL0H8wQRjpRvlolRdVr-_iSfz0xM,3598
+maleo_foundation-0.2.81.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+maleo_foundation-0.2.81.dist-info/top_level.txt,sha256=_iBos3F_bhEOdjOnzeiEYSrCucasc810xXtLBXI8cQc,17
+maleo_foundation-0.2.81.dist-info/RECORD,,