maleo-foundation 0.2.16__py3-none-any.whl → 0.2.17__py3-none-any.whl

maleo_foundation/middlewares/authentication.py

@@ -7,12 +7,18 @@ from maleo_foundation.authentication import Credentials, User
 from maleo_foundation.enums import BaseEnums
 from maleo_foundation.client.manager import MaleoFoundationClientManager
 from maleo_foundation.models.schemas import BaseGeneralSchemas
-from maleo_foundation.models.transfers.parameters.token import MaleoFoundationTokenParametersTransfers
+from maleo_foundation.models.transfers.parameters.token \
+    import MaleoFoundationTokenParametersTransfers
 from maleo_foundation.utils.exceptions import BaseExceptions
 from maleo_foundation.utils.logging import MiddlewareLogger
 
 class Backend(AuthenticationBackend):
-    def __init__(self, keys:BaseGeneralSchemas.RSAKeys, logger:MiddlewareLogger, maleo_foundation:MaleoFoundationClientManager):
+    def __init__(
+        self,
+        keys:BaseGeneralSchemas.RSAKeys,
+        logger:MiddlewareLogger,
+        maleo_foundation:MaleoFoundationClientManager
+    ):
         super().__init__()
         self._keys = keys
         self._logger = logger
@@ -29,8 +35,14 @@ class Backend(AuthenticationBackend):
                 raise AuthenticationError("Authorization scheme must be Bearer token")
             
             #* Decode token
-            decode_token_parameters = MaleoFoundationTokenParametersTransfers.Decode(key=self._keys.public, token=token)
-            decode_token_result = self._maleo_foundation.services.token.decode(parameters=decode_token_parameters)
+            decode_token_parameters = (
+                MaleoFoundationTokenParametersTransfers
+                .Decode(key=self._keys.public, token=token)
+            )
+            decode_token_result = (
+                self._maleo_foundation.services.token
+                .decode(parameters=decode_token_parameters)
+            )
             if decode_token_result.success:
                 payload = decode_token_result.data
                 return (
@@ -50,8 +62,14 @@ class Backend(AuthenticationBackend):
         if "token" in conn.cookies:
             token = conn.cookies["token"]
             #* Decode token
-            decode_token_parameters = MaleoFoundationTokenParametersTransfers.Decode(key=self._keys.public, token=token)
-            decode_token_result = self._maleo_foundation.services.token.decode(parameters=decode_token_parameters)
+            decode_token_parameters = (
+                MaleoFoundationTokenParametersTransfers
+                .Decode(key=self._keys.public, token=token)
+            )
+            decode_token_result = (
+                self._maleo_foundation.services.token
+                .decode(parameters=decode_token_parameters)
+            )
             if decode_token_result.success:
                 payload = decode_token_result.data
                 return (
@@ -70,7 +88,12 @@ class Backend(AuthenticationBackend):
 
         return Credentials(), User(authenticated=False)
 
-def add_authentication_middleware(app:FastAPI, keys:BaseGeneralSchemas.RSAKeys, logger:MiddlewareLogger, maleo_foundation:MaleoFoundationClientManager) -> None:
+def add_authentication_middleware(
+    app:FastAPI,
+    keys:BaseGeneralSchemas.RSAKeys,
+    logger:MiddlewareLogger,
+    maleo_foundation:MaleoFoundationClientManager
+) -> None:
     """
     Adds Authentication middleware to the FastAPI application.
 
@@ -96,4 +119,8 @@ def add_authentication_middleware(app:FastAPI, keys:BaseGeneralSchemas.RSAKeys,
     add_authentication_middleware(app=app, limit=10, window=1, cleanup_interval=60, ip_timeout=300)
     ```
     """
-    app.add_middleware(AuthenticationMiddleware, backend=Backend(keys, logger, maleo_foundation), on_error=BaseExceptions.authentication_error_handler)
+    app.add_middleware(
+        AuthenticationMiddleware,
+        backend=Backend(keys, logger, maleo_foundation),
+        on_error=BaseExceptions.authentication_error_handler
+    )

maleo_foundation/middlewares/base.py

@@ -13,9 +13,12 @@ from maleo_foundation.enums import BaseEnums
 from maleo_foundation.client.manager import MaleoFoundationClientManager
 from maleo_foundation.models.schemas import BaseGeneralSchemas
 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.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.utils.logging import MiddlewareLogger
 
@@ -89,14 +92,20 @@ class BaseMiddleware(BaseHTTPMiddleware):
                 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:
+    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
 
             #* 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:
@@ -106,7 +115,11 @@ class BaseMiddleware(BaseHTTPMiddleware):
             self._requests[client_ip].append(now)
             return False
 
-    def _append_cors_headers(self, request:Request, response:Response) -> Response:
+    def _append_cors_headers(
+        self,
+        request:Request,
+        response:Response
+    ) -> Response:
         origin = request.headers.get("Origin")
 
         if origin in self._allow_origins:
@@ -131,18 +144,29 @@ class BaseMiddleware(BaseHTTPMiddleware):
         response.headers["X-Response-Timestamp"] = response_timestamp.isoformat() #* Define and add response timestamp header
         #* Generate signature header
         message = f"{request.method}|{request.url.path}|{request_timestamp.isoformat()}|{response_timestamp.isoformat()}|{str(process_time)}"
-        sign_parameters = MaleoFoundationSignatureParametersTransfers.Sign(key=self._keys.private, password=self._keys.password, message=message)
+        sign_parameters = (
+            MaleoFoundationSignatureParametersTransfers
+            .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
-        if authentication.user.is_authenticated \
-            and authentication.credentials.token_type == BaseEnums.TokenType.REFRESH \
-            and authentication.credentials.payload is not None \
-            and (response.status_code >= 200 and response.status_code < 300):
+        if (authentication.user.is_authenticated
+            and authentication.credentials.token_type == BaseEnums.TokenType.REFRESH
+            and authentication.credentials.payload is not None
+            and (response.status_code >= 200 and response.status_code < 300)
+        ):
             #* Regenerate new authorization
-            payload = MaleoFoundationTokenGeneralTransfers.BaseEncodePayload.model_validate(authentication.credentials.payload.model_dump())
-            parameters = MaleoFoundationTokenParametersTransfers.Encode(key=self._keys.private, password=self._keys.password, payload=payload)
+            payload = (
+                MaleoFoundationTokenGeneralTransfers
+                .BaseEncodePayload
+                .model_validate(authentication.credentials.payload.model_dump())
+            )
+            parameters = (
+                MaleoFoundationTokenParametersTransfers
+                .Encode(key=self._keys.private, password=self._keys.password, payload=payload)
+            )
             result = self._maleo_foundation.services.token.encode(parameters=parameters)
             if result.success:
                 response.headers["X-New-Authorization"] = result.data.token
@@ -160,7 +184,14 @@ class BaseMiddleware(BaseHTTPMiddleware):
         log_level:str = "info",
         client_ip:str = "unknown"
     ) -> Response:
-        response = self._add_response_headers(request, authentication, response, request_timestamp, response_timestamp, process_time)
+        response = self._add_response_headers(
+            request,
+            authentication,
+            response,
+            request_timestamp,
+            response_timestamp,
+            process_time
+        )
         log_func = getattr(self._logger, log_level)
         log_func(
             f"Request {authentication_info} | IP: {client_ip} | Host: {request.client.host} | Port: {request.client.port} | Method: {request.method} | URL: {request.url.path} | "
@@ -199,7 +230,14 @@ class BaseMiddleware(BaseHTTPMiddleware):
             f"Headers: {dict(request.headers)} - Response | Status: 500 | Exception:\n{json.dumps(error_details, indent=4)}"
         )
 
-        return self._add_response_headers(request, authentication, response, request_timestamp, response_timestamp, process_time)
+        return self._add_response_headers(
+            request,
+            authentication,
+            response,
+            request_timestamp,
+            response_timestamp,
+            process_time
+        )
 
     async def _request_processor(self, request:Request) -> Optional[Response]:
         return None

maleo_foundation/models/table.py

@@ -18,12 +18,29 @@ class BaseTable:
     uuid = Column(UUID, default=uuid4, unique=True, nullable=False)
 
     #* Timestamps
-    created_at = Column(TIMESTAMP(timezone=True), server_default=func.now(), nullable=False)
-    updated_at = Column(TIMESTAMP(timezone=True), server_default=func.now(), onupdate=func.now(), nullable=False)
+    created_at = Column(
+        TIMESTAMP(timezone=True),
+        server_default=func.now(),
+        nullable=False
+    )
+    updated_at = Column(
+        TIMESTAMP(timezone=True),
+        server_default=func.now(),
+        onupdate=func.now(),
+        nullable=False
+    )
     deleted_at = Column(TIMESTAMP(timezone=True))
     restored_at = Column(TIMESTAMP(timezone=True))
     deactivated_at = Column(TIMESTAMP(timezone=True))
-    activated_at = Column(TIMESTAMP(timezone=True), server_default=func.now(), nullable=False)
+    activated_at = Column(
+        TIMESTAMP(timezone=True),
+        server_default=func.now(),
+        nullable=False
+    )
 
     #* Statuses
-    status = Column(Enum(BaseEnums.StatusType, name="statustype"), default=BaseEnums.StatusType.ACTIVE, nullable=False)
+    status = Column(
+        Enum(BaseEnums.StatusType, name="statustype"),
+        default=BaseEnums.StatusType.ACTIVE,
+        nullable=False
+    )

maleo_foundation/models/transfers/parameters/service.py

@@ -27,7 +27,13 @@ class BaseServiceParametersTransfers:
                 parts = item.split('.')
                 if len(parts) == 2 and parts[1].lower() in ["asc", "desc"]:
                     try:
-                        sort_columns.append(BaseGeneralSchemas.SortColumn(name=parts[0], order=BaseEnums.SortOrder(parts[1].lower())))
+                        sort_columns.append(
+                            BaseGeneralSchemas
+                            .SortColumn(
+                                name=parts[0],
+                                order=BaseEnums.SortOrder(parts[1].lower())
+                            )
+                        )
                     except ValueError:
                         continue
 
@@ -64,7 +70,14 @@ class BaseServiceParametersTransfers:
 
                     #* Only add filter if at least one date is specified
                     if from_date or to_date:
-                        date_filters.append(BaseGeneralSchemas.DateFilter(name=name, from_date=from_date, to_date=to_date))
+                        date_filters.append(
+                            BaseGeneralSchemas
+                            .DateFilter(
+                                name=name,
+                                from_date=from_date,
+                                to_date=to_date
+                            )
+                        )
 
             #* Update date_filters
             self.date_filters = date_filters
@@ -88,7 +101,13 @@ class BaseServiceParametersTransfers:
                 parts = item.split('.')
                 if len(parts) == 2 and parts[1].lower() in ["asc", "desc"]:
                     try:
-                        sort_columns.append(BaseGeneralSchemas.SortColumn(name=parts[0], order=BaseEnums.SortOrder(parts[1].lower())))
+                        sort_columns.append(
+                            BaseGeneralSchemas
+                            .SortColumn(
+                                name=parts[0],
+                                order=BaseEnums.SortOrder(parts[1].lower())
+                            )
+                        )
                     except ValueError:
                         continue
 
@@ -125,7 +144,14 @@ class BaseServiceParametersTransfers:
 
                     #* Only add filter if at least one date is specified
                     if from_date or to_date:
-                        date_filters.append(BaseGeneralSchemas.DateFilter(name=name, from_date=from_date, to_date=to_date))
+                        date_filters.append(
+                            BaseGeneralSchemas
+                            .DateFilter(
+                                name=name,
+                                from_date=from_date,
+                                to_date=to_date
+                            )
+                        )
 
             #* Update date_filters
             self.date_filters = date_filters

maleo_foundation/utils/controller.py

@@ -3,8 +3,10 @@ from functools import wraps
 from typing import Awaitable, Callable, Dict, List
 from maleo_foundation.types import BaseTypes
 from maleo_foundation.models.responses import BaseResponses
-from maleo_foundation.models.transfers.parameters.general import BaseGeneralParametersTransfers
-from maleo_foundation.models.transfers.results.service.controllers.rest import BaseServiceRESTControllerResults
+from maleo_foundation.models.transfers.parameters.general \
+    import BaseGeneralParametersTransfers
+from maleo_foundation.models.transfers.results.service.controllers.rest \
+    import BaseServiceRESTControllerResults
 from maleo_foundation.expanded_types.general import BaseGeneralExpandedTypes
 
 class BaseControllerUtils:
@@ -33,7 +35,11 @@ class BaseControllerUtils:
                                 if dependent in expand:
                                     other = f"'{dependency}' must also be expanded if '{dependent}' is expanded"
                                     content = BaseResponses.InvalidExpand(other=other).model_dump()
-                                    return BaseServiceRESTControllerResults(success=False, content=content, status_code=status.HTTP_400_BAD_REQUEST)
+                                    return BaseServiceRESTControllerResults(
+                                        success=False,
+                                        content=content,
+                                        status_code=status.HTTP_400_BAD_REQUEST
+                                    )
 
                 #* Call the original function
                 result = await func(parameters, *args, **kwargs)
@@ -42,18 +48,29 @@ class BaseControllerUtils:
                     return result
 
                 #* Process the fields if needed
-                if result.success and result.content.get("data", None) is not None and field_expansion_processors is not None:
+                if (result.success
+                    and result.content.get("data", None) is not None
+                    and field_expansion_processors is not None
+                ):
                     data = result.content["data"]
                     if isinstance(data, List):
                         for idx, dt in enumerate(data):
                             for processor in field_expansion_processors:
                                 raw_parameters = {"data": dt, "expand": expand}
-                                parameters = BaseGeneralParametersTransfers.FieldExpansionProcessor.model_validate(raw_parameters)
+                                parameters = (
+                                    BaseGeneralParametersTransfers
+                                    .FieldExpansionProcessor
+                                    .model_validate(raw_parameters)
+                                )
                                 dt = processor(parameters)
                                 data[idx] = dt
                     elif isinstance(data, Dict):
                         raw_parameters = {"data": data, "expand": expand}
-                        parameters = BaseGeneralParametersTransfers.FieldExpansionProcessor.model_validate(raw_parameters)
+                        parameters = (
+                            BaseGeneralParametersTransfers
+                            .FieldExpansionProcessor
+                            .model_validate(raw_parameters)
+                        )
                         for processor in field_expansion_processors:
                             data = processor(parameters)
                     result.content["data"] = data

maleo_foundation/utils/dependencies/auth.py

@@ -6,9 +6,19 @@ from maleo_foundation.authorization import TOKEN_SCHEME, Authorization
 
 class AuthDependencies:
     @staticmethod
-    def authentication(request:Request) -> Authentication:
-        return Authentication(credentials=request.auth, user=request.user)
+    def authentication(
+        request:Request
+    ) -> Authentication:
+        return Authentication(
+            credentials=request.auth,
+            user=request.user
+        )
 
     @staticmethod
-    def authorization(token:HTTPAuthorizationCredentials = Security(TOKEN_SCHEME)) -> Authorization:
-        return Authorization(scheme=token.scheme, credentials=token.credentials)
+    def authorization(
+        token:HTTPAuthorizationCredentials = Security(TOKEN_SCHEME)
+    ) -> Authorization:
+        return Authorization(
+            scheme=token.scheme,
+            credentials=token.credentials
+        )

maleo_foundation/utils/exceptions.py

@@ -6,24 +6,39 @@ from starlette.exceptions import HTTPException as StarletteHTTPException
 from sqlalchemy.exc import SQLAlchemyError
 from typing import Optional
 from maleo_foundation.models.responses import BaseResponses
-from maleo_foundation.models.transfers.results.service.general import BaseServiceGeneralResultsTransfers
-from maleo_foundation.models.transfers.results.service.query import BaseServiceQueryResultsTransfers
+from maleo_foundation.models.transfers.results.service.general \
+    import BaseServiceGeneralResultsTransfers
+from maleo_foundation.models.transfers.results.service.query \
+    import BaseServiceQueryResultsTransfers
 from maleo_foundation.utils.logging import BaseLogger
 
 class BaseExceptions:
     @staticmethod
     def authentication_error_handler(request:Request, exc:Exception):
-        return JSONResponse(content=BaseResponses.Unauthorized(other=str(exc)).model_dump(mode="json"), status_code=status.HTTP_401_UNAUTHORIZED)
+        return JSONResponse(
+            content=BaseResponses.Unauthorized(other=str(exc)).model_dump(mode="json"),
+            status_code=status.HTTP_401_UNAUTHORIZED
+        )
 
     @staticmethod
     async def validation_exception_handler(request:Request, exc:RequestValidationError):
-        return JSONResponse(content=BaseResponses.ValidationError(other=exc.errors()).model_dump(mode="json"), status_code=status.HTTP_422_UNPROCESSABLE_ENTITY)
+        return JSONResponse(
+            content=BaseResponses.ValidationError(other=exc.errors()).model_dump(mode="json"),
+            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY
+        )
 
     @staticmethod
     async def http_exception_handler(request:Request, exc:StarletteHTTPException):
         if exc.status_code in BaseResponses.other_responses:
-            return JSONResponse(content=BaseResponses.other_responses[exc.status_code]["model"]().model_dump(mode="json"), status_code=exc.status_code)
-        return JSONResponse(content=BaseResponses.ServerError().model_dump(mode="json"), status_code=status.HTTP_500_INTERNAL_SERVER_ERROR)
+            return JSONResponse(
+                content=BaseResponses.other_responses[exc.status_code]["model"]().model_dump(mode="json"),
+                status_code=exc.status_code
+            )
+
+        return JSONResponse(
+            content=BaseResponses.ServerError().model_dump(mode="json"),
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR
+        )
 
     @staticmethod
     def database_exception_handler(

maleo_foundation/utils/loaders/credential/google.py

@@ -15,7 +15,9 @@ class GoogleCredentialsLoader:
             if credentials_path is not None:
                 credentials_path = Path(credentials_path)
                 if credentials_path.exists() or credentials_path.is_file():
-                    credentials = Credentials.from_service_account_file(filename=str(credentials_path))
+                    credentials = Credentials.from_service_account_file(
+                        filename=str(credentials_path)
+                    )
             else:
                 credentials, _ = default()
             return credentials

maleo_foundation/utils/query.py

@@ -10,7 +10,12 @@ from maleo_foundation.extended_types import ExtendedTypes
 
 class BaseQueryUtils:
     @staticmethod
-    def filter_column(query:Query, table:Type[DeclarativeMeta], column:str, value:BaseTypes.OptionalAny) -> Query:
+    def filter_column(
+        query:Query,
+        table:Type[DeclarativeMeta],
+        column:str,
+        value:BaseTypes.OptionalAny
+    ) -> Query:
         if not value:
             return query
         column_attr = getattr(table, column, None)
@@ -24,7 +29,12 @@ class BaseQueryUtils:
         return query
 
     @staticmethod
-    def filter_ids(query:Query, table:Type[DeclarativeMeta], column:str, ids:BaseTypes.OptionalListOfIntegers) -> Query:
+    def filter_ids(
+        query:Query,
+        table:Type[DeclarativeMeta],
+        column:str,
+        ids:BaseTypes.OptionalListOfIntegers
+    ) -> Query:
         if ids is not None:
             column_attr = getattr(table, column, None)
             if column_attr:
@@ -33,7 +43,11 @@ class BaseQueryUtils:
         return query
     
     @staticmethod
-    def filter_timestamps(query:Query, table:Type[DeclarativeMeta], date_filters:ExtendedTypes.ListOfDateFilters) -> Query:
+    def filter_timestamps(
+        query:Query,
+        table:Type[DeclarativeMeta],
+        date_filters:ExtendedTypes.ListOfDateFilters
+    ) -> Query:
         if date_filters and len(date_filters) > 0:
             for date_filter in date_filters:
                 try:
@@ -42,7 +56,12 @@ class BaseQueryUtils:
                     column_attr:InstrumentedAttribute = getattr(table, date_filter.name)
                     if isinstance(column.type, (TIMESTAMP, DATE)):
                         if date_filter.from_date and date_filter.to_date:
-                            query = query.filter(column_attr.between(date_filter.from_date, date_filter.to_date))
+                            query = query.filter(
+                                column_attr.between(
+                                    date_filter.from_date,
+                                    date_filter.to_date
+                                )
+                            )
                         elif date_filter.from_date:
                             query = query.filter(column_attr >= date_filter.from_date)
                         elif date_filter.to_date:
@@ -52,14 +71,22 @@ class BaseQueryUtils:
         return query
     
     @staticmethod
-    def filter_statuses(query:Query, table:Type[DeclarativeMeta], statuses:BaseTypes.OptionalListOfStatuses) -> Query:
+    def filter_statuses(
+        query:Query,
+        table:Type[DeclarativeMeta],
+        statuses:BaseTypes.OptionalListOfStatuses
+    ) -> Query:
         if statuses is not None:
             status_filters = [table.status == status for status in statuses]
             query = query.filter(or_(*status_filters))
         return query
     
     @staticmethod
-    def filter_search(query:Query, table:Type[DeclarativeMeta], search:BaseTypes.OptionalString) -> Query:
+    def filter_search(
+        query:Query,
+        table:Type[DeclarativeMeta],
+        search:BaseTypes.OptionalString
+    ) -> Query:
         if search:
             search_term = f"%{search}%" #* Use wildcard for partial matching
             search_filters = []
@@ -78,7 +105,11 @@ class BaseQueryUtils:
         return query
     
     @staticmethod
-    def sort(query:Query, table:Type[DeclarativeMeta], sort_columns:ExtendedTypes.ListOfSortColumns) -> Query:
+    def sort(
+        query:Query,
+        table:Type[DeclarativeMeta],
+        sort_columns:ExtendedTypes.ListOfSortColumns
+    ) -> Query:
         for sort_column in sort_columns:
             try:
                 sort_col = getattr(table, sort_column.name)

{maleo_foundation-0.2.16.dist-info → maleo_foundation-0.2.17.dist-info}/METADATA

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