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

maleo_foundation/client/services/token.py

@@ -1,16 +1,24 @@
 import jwt
 from maleo_foundation.enums import BaseEnums
-from maleo_foundation.expanded_types.token import MaleoFoundationTokenResultsTypes
+from maleo_foundation.expanded_types.token \
+    import MaleoFoundationTokenResultsTypes
 from maleo_foundation.managers.client.base import ClientService
-from maleo_foundation.models.schemas.token import MaleoFoundationTokenSchemas
-from maleo_foundation.models.transfers.general.token import MaleoFoundationTokenGeneralTransfers
-from maleo_foundation.models.transfers.parameters.token import MaleoFoundationTokenParametersTransfers
-from maleo_foundation.models.transfers.results.token import MaleoFoundationTokenResultsTransfers
+from maleo_foundation.models.schemas.token \
+    import MaleoFoundationTokenSchemas
+from maleo_foundation.models.transfers.general.token \
+    import MaleoFoundationTokenGeneralTransfers
+from maleo_foundation.models.transfers.parameters.token \
+    import MaleoFoundationTokenParametersTransfers
+from maleo_foundation.models.transfers.results.token \
+    import MaleoFoundationTokenResultsTransfers
 from maleo_foundation.utils.exceptions import BaseExceptions
 from maleo_foundation.utils.loaders.key.rsa import RSAKeyLoader
 
 class MaleoFoundationTokenClientService(ClientService):
-    def encode(self, parameters:MaleoFoundationTokenParametersTransfers.Encode) -> MaleoFoundationTokenResultsTypes.Encode:
+    def encode(
+        self,
+        parameters:MaleoFoundationTokenParametersTransfers.Encode
+    ) -> MaleoFoundationTokenResultsTypes.Encode:
         @BaseExceptions.service_exception_handler(
             operation="encoding a payload into a token",
             logger=self._logger,
@@ -18,25 +26,54 @@ class MaleoFoundationTokenClientService(ClientService):
         )
         def _impl():
             try:
-                private_key = RSAKeyLoader.load_with_pycryptodome(type=BaseEnums.KeyType.PRIVATE, extern_key=parameters.key, passphrase=parameters.password)
+                private_key = RSAKeyLoader.load_with_pycryptodome(
+                    type=BaseEnums.KeyType.PRIVATE,
+                    extern_key=parameters.key,
+                    passphrase=parameters.password
+                )
             except TypeError:
                 message = "Invalid key type"
                 description = "A private key must be used for payload encoding"
                 other = "Ensure the given key is of type private key"
-                return MaleoFoundationTokenResultsTransfers.Fail(message=message, description=description, other=other)
+                return MaleoFoundationTokenResultsTransfers.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 MaleoFoundationTokenResultsTransfers.Fail(message=message, description=description, other=other)
-            payload = MaleoFoundationTokenGeneralTransfers.EncodePayload.model_validate(parameters.payload.model_dump()).model_dump(mode="json", exclude_none=True)
-            token = jwt.encode(payload=payload, key=private_key.export_key(), algorithm="RS256")
+                return MaleoFoundationTokenResultsTransfers.Fail(
+                    message=message,
+                    description=description,
+                    other=other
+                )
+            payload = (
+                MaleoFoundationTokenGeneralTransfers
+                .EncodePayload
+                .model_validate(
+                    parameters.payload.model_dump()
+                )
+                .model_dump(
+                    mode="json",
+                    exclude_none=True
+                )
+            )
+            token = jwt.encode(
+                payload=payload,
+                key=private_key.export_key(),
+                algorithm="RS256"
+            )
             data = MaleoFoundationTokenSchemas.Token(token=token)
             return MaleoFoundationTokenResultsTransfers.Encode(data=data)
         return _impl()
 
-    def decode(self, parameters:MaleoFoundationTokenParametersTransfers.Decode) -> MaleoFoundationTokenResultsTypes.Decode:
+    def decode(
+        self,
+        parameters:MaleoFoundationTokenParametersTransfers.Decode
+    ) -> MaleoFoundationTokenResultsTypes.Decode:
         @BaseExceptions.service_exception_handler(
             operation="decoding a token into a payload",
             logger=self._logger,
@@ -44,19 +81,34 @@ class MaleoFoundationTokenClientService(ClientService):
         )
         def _impl():
             try:
-                public_key = RSAKeyLoader.load_with_pycryptodome(type=BaseEnums.KeyType.PUBLIC, extern_key=parameters.key)
+                public_key = RSAKeyLoader.load_with_pycryptodome(
+                    type=BaseEnums.KeyType.PUBLIC,
+                    extern_key=parameters.key
+                )
             except TypeError:
                 message = "Invalid key type"
                 description = "A public key must be used for token decoding"
                 other = "Ensure the given key is of type public key"
-                return MaleoFoundationTokenResultsTransfers.Fail(message=message, description=description, other=other)
+                return MaleoFoundationTokenResultsTransfers.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 MaleoFoundationTokenResultsTransfers.Fail(message=message, description=description, other=other)
-            payload = jwt.decode(jwt=parameters.token, key=public_key.export_key(), algorithms=["RS256"])
+                return MaleoFoundationTokenResultsTransfers.Fail(
+                    message=message,
+                    description=description,
+                    other=other
+                )
+            payload = jwt.decode(
+                jwt=parameters.token,
+                key=public_key.export_key(),
+                algorithms=["RS256"]
+            )
             data = MaleoFoundationTokenGeneralTransfers.DecodePayload.model_validate(payload)
             return MaleoFoundationTokenResultsTransfers.Decode(data=data)
         return _impl()

maleo_foundation/expanded_types/client.py

@@ -1,7 +1,10 @@
 from typing import Awaitable, Callable, Union
-from maleo_foundation.models.transfers.parameters.general import BaseGeneralParametersTransfers
-from maleo_foundation.models.transfers.parameters.client import BaseClientParametersTransfers
-from maleo_foundation.models.transfers.results.client.service import BaseClientServiceResultsTransfers
+from maleo_foundation.models.transfers.parameters.general \
+    import BaseGeneralParametersTransfers
+from maleo_foundation.models.transfers.parameters.client \
+    import BaseClientParametersTransfers
+from maleo_foundation.models.transfers.results.client.service \
+    import BaseClientServiceResultsTransfers
 
 class ExpandedClientTypes:
     #* Unpaginated multiple data

maleo_foundation/expanded_types/encryption/aes.py

@@ -1,5 +1,6 @@
 from typing import Union
-from maleo_foundation.models.transfers.results.encryption.aes import MaleoFoundationAESEncryptionResultsTransfers
+from maleo_foundation.models.transfers.results.encryption.aes \
+    import MaleoFoundationAESEncryptionResultsTransfers
 
 class MaleoFoundationAESEncryptionResultsTypes:
     Encrypt = Union[

maleo_foundation/expanded_types/encryption/rsa.py

@@ -1,5 +1,6 @@
 from typing import Union
-from maleo_foundation.models.transfers.results.encryption.rsa import MaleoFoundationRSAEncryptionResultsTransfers
+from maleo_foundation.models.transfers.results.encryption.rsa \
+    import MaleoFoundationRSAEncryptionResultsTransfers
 
 class MaleoFoundationRSAEncryptionResultsTypes:
     Encrypt = Union[

maleo_foundation/expanded_types/general.py

@@ -1,6 +1,7 @@
 from typing import Callable, List, Optional
 from maleo_foundation.types import BaseTypes
-from maleo_foundation.models.transfers.parameters.general import BaseGeneralParametersTransfers
+from maleo_foundation.models.transfers.parameters.general \
+    import BaseGeneralParametersTransfers
 
 class BaseGeneralExpandedTypes:
     #* Expansion processor related types

maleo_foundation/expanded_types/hash.py

@@ -1,5 +1,6 @@
 from typing import Union
-from maleo_foundation.models.transfers.results.hash import MaleoFoundationHashResultsTransfers
+from maleo_foundation.models.transfers.results.hash \
+    import MaleoFoundationHashResultsTransfers
 
 class MaleoFoundationHashResultsTypes:
     Hash = Union[

maleo_foundation/expanded_types/key.py

@@ -1,5 +1,6 @@
 from typing import Union
-from maleo_foundation.models.transfers.results.key import MaleoFoundationKeyResultsTransfers
+from maleo_foundation.models.transfers.results.key \
+    import MaleoFoundationKeyResultsTransfers
 
 class MaleoFoundationKeyResultsTypes:
     CreatePrivate = Union[

maleo_foundation/expanded_types/query.py

@@ -1,7 +1,10 @@
 from typing import Awaitable, Callable, Union
-from maleo_foundation.models.transfers.parameters.general import BaseGeneralParametersTransfers
-from maleo_foundation.models.transfers.parameters.service import BaseServiceParametersTransfers
-from maleo_foundation.models.transfers.results.service.query import BaseServiceQueryResultsTransfers
+from maleo_foundation.models.transfers.parameters.general \
+    import BaseGeneralParametersTransfers
+from maleo_foundation.models.transfers.parameters.service \
+    import BaseServiceParametersTransfers
+from maleo_foundation.models.transfers.results.service.query \
+    import BaseServiceQueryResultsTransfers
 
 class ExpandedQueryTypes:
     #* Unpaginated multiple data

maleo_foundation/expanded_types/service.py

@@ -1,7 +1,10 @@
 from typing import Awaitable, Callable, Union
-from maleo_foundation.models.transfers.parameters.general import BaseGeneralParametersTransfers
-from maleo_foundation.models.transfers.parameters.service import BaseServiceParametersTransfers
-from maleo_foundation.models.transfers.results.service.general import BaseServiceGeneralResultsTransfers
+from maleo_foundation.models.transfers.parameters.general \
+    import BaseGeneralParametersTransfers
+from maleo_foundation.models.transfers.parameters.service \
+    import BaseServiceParametersTransfers
+from maleo_foundation.models.transfers.results.service.general \
+    import BaseServiceGeneralResultsTransfers
 
 class ExpandedServiceTypes:
     #* Unpaginated multiple data

maleo_foundation/expanded_types/signature.py

@@ -1,5 +1,6 @@
 from typing import Union
-from maleo_foundation.models.transfers.results.signature import MaleoFoundationSignatureResultsTransfers
+from maleo_foundation.models.transfers.results.signature \
+    import MaleoFoundationSignatureResultsTransfers
 
 class MaleoFoundationSignatureResultsTypes:
     Sign = Union[

maleo_foundation/expanded_types/token.py

@@ -1,5 +1,6 @@
 from typing import Union
-from maleo_foundation.models.transfers.results.token import MaleoFoundationTokenResultsTransfers
+from maleo_foundation.models.transfers.results.token \
+    import MaleoFoundationTokenResultsTransfers
 
 class MaleoFoundationTokenResultsTypes:
     Encode = Union[

maleo_foundation/managers/client/base.py

@@ -115,7 +115,11 @@ class ClientManager:
         self._logger.info("Initializing client manager")
 
     def _initialize_logger(self) -> None:
-        self._logger = ClientLogger(client_key=self._key, service_key=self._service_key, **self._log_config.model_dump())
+        self._logger = ClientLogger(
+            client_key=self._key,
+            service_key=self._service_key,
+            **self._log_config.model_dump()
+        )
 
     @property
     def key(self) -> str:

maleo_foundation/managers/client/google/storage.py

@@ -64,5 +64,9 @@ class GoogleCloudStorage(GoogleClientManager):
         if not blob.exists():
             raise ValueError(f"File '{location}' did not exists.")
 
-        url = blob.generate_signed_url(version="v4", expiration=timedelta(minutes=15), method="GET")
+        url = blob.generate_signed_url(
+            version="v4",
+            expiration=timedelta(minutes=15),
+            method="GET"
+        )
         return url

maleo_foundation/managers/client/maleo.py

@@ -1,9 +1,20 @@
-from pydantic import BaseModel, Field
-from maleo_foundation.managers.client.base import ClientManager, ClientHTTPControllerManager, ClientControllerManagers, ClientHTTPController, ClientServiceControllers, ClientControllers
+from pydantic import Field
+from maleo_foundation.managers.client.base import (
+    ClientManager,
+    ClientHTTPControllerManager,
+    ClientControllerManagers,
+    ClientHTTPController,
+    ClientServiceControllers,
+    ClientControllers
+)
 from maleo_foundation.managers.service import ServiceManager
 
 class MaleoClientHTTPController(ClientHTTPController):
-    def __init__(self, service_manager:ServiceManager, manager:ClientHTTPControllerManager):
+    def __init__(
+        self,
+        service_manager:ServiceManager,
+        manager:ClientHTTPControllerManager
+    ):
         self._service_manager = service_manager
         super().__init__(manager)
 
@@ -27,7 +38,12 @@ class MaleoClientManager(ClientManager):
     ):
         self._url = url
         self._service_manager = service_manager
-        super().__init__(key, name, service_manager.log_config, service_manager.configs.service.key)
+        super().__init__(
+            key,
+            name,
+            service_manager.log_config,
+            service_manager.configs.service.key
+        )
 
     @property
     def service_manager(self) -> ServiceManager:

maleo_foundation/managers/db.py

@@ -1,12 +1,12 @@
 import os
 from contextlib import contextmanager
-from pydantic import BaseModel, Field, model_validator
+from pydantic import BaseModel, Field
 from sqlalchemy import MetaData
 from sqlalchemy.engine import Engine, create_engine
 from sqlalchemy.exc import SQLAlchemyError
 from sqlalchemy.ext.declarative import DeclarativeMeta
 from sqlalchemy.orm import sessionmaker, Session, declarative_base
-from typing import Dict, Generator
+from typing import Generator
 from maleo_foundation.types import BaseTypes
 from maleo_foundation.utils.logging import ServiceLogger
 
@@ -15,10 +15,17 @@ class MetadataManager:
     metadata:MetaData = Base.metadata
 
 class SessionManager:
-    def __init__(self, logger:ServiceLogger, engine:Engine):
+    def __init__(
+        self,
+        logger:ServiceLogger,
+        engine:Engine
+    ):
         self._logger = logger
         self._logger.info("Initializing SessionMaker")
-        self._sessionmaker:sessionmaker[Session] = sessionmaker(bind=engine, expire_on_commit=False)
+        self._sessionmaker:sessionmaker[Session] = sessionmaker(
+            bind=engine,
+            expire_on_commit=False
+        )
         self._logger.info("SessionMaker initialized successfully")
 
     def _session_handler(self) -> Generator[Session, None, None]:
@@ -84,7 +91,11 @@ class DatabaseManager:
         if url is None:
             raise ValueError("DB_URL environment variable must be set if url is not provided")
         self._logger.info("Creating SQlAlchemy engine")
-        self._engine = create_engine(url=url, echo=False, pool_pre_ping=True, pool_recycle=3600)
+        self._engine = create_engine(
+            url=url,
+            echo=False,
+            pool_pre_ping=True,
+            pool_recycle=3600)
         self._logger.info("SQlAlchemy engine created successfully")
 
         #* Creating all table from metadata
@@ -94,7 +105,11 @@ class DatabaseManager:
 
         #* Initializing session manager
         self._logger.info("Initializing session manager")
-        self._session = SessionManager(logger=self._logger, engine=self._engine) #* Define session
+        #* Create session
+        self._session = SessionManager(
+            logger=self._logger,
+            engine=self._engine
+        )
         self._logger.info("Session manager initialized successfully")
 
     @property

maleo_foundation/managers/service.py

@@ -11,8 +11,10 @@ from typing import Optional
 from maleo_foundation.client.manager import MaleoFoundationClientManager
 from maleo_foundation.enums import BaseEnums
 from maleo_foundation.models.schemas.general import BaseGeneralSchemas
-from maleo_foundation.models.transfers.general.token import MaleoFoundationTokenGeneralTransfers
-from maleo_foundation.models.transfers.parameters.token import MaleoFoundationTokenParametersTransfers
+from maleo_foundation.models.transfers.general.token \
+    import MaleoFoundationTokenGeneralTransfers
+from maleo_foundation.models.transfers.parameters.token \
+    import MaleoFoundationTokenParametersTransfers
 from maleo_foundation.managers.db import DatabaseConfigurations, DatabaseManager
 from maleo_foundation.managers.client.google.secret import GoogleSecretManager
 from maleo_foundation.managers.client.google.storage import GoogleCloudStorage
@@ -27,7 +29,11 @@ from maleo_foundation.managers.middleware import (
 from maleo_foundation.types import BaseTypes
 from maleo_foundation.utils.exceptions import BaseExceptions
 from maleo_foundation.utils.loaders.yaml import YAMLLoader
-from maleo_foundation.utils.logging import SimpleConfig, ServiceLogger, MiddlewareLogger
+from maleo_foundation.utils.logging import (
+    SimpleConfig,
+    ServiceLogger,
+    MiddlewareLogger
+)
 from maleo_foundation.utils.mergers import BaseMergers
 
 class Settings(BaseSettings):
@@ -161,27 +167,49 @@ class ServiceManager:
         return self._google_credentials
 
     def _initialize_secret_manager(self) -> None:
-        self._secret_manager = GoogleSecretManager(log_config=self._log_config, service_key=self._settings.SERVICE_KEY, credentials=self._google_credentials)
+        self._secret_manager = GoogleSecretManager(
+            log_config=self._log_config,
+            service_key=self._settings.SERVICE_KEY,
+            credentials=self._google_credentials
+        )
 
     @property
     def secret_manager(self) -> GoogleSecretManager:
         return self._secret_manager
 
     def _initialize_cloud_storage(self) -> None:
-        environment = BaseEnums.EnvironmentType.STAGING if self._settings.ENVIRONMENT == BaseEnums.EnvironmentType.LOCAL else self._settings.ENVIRONMENT
-        self._cloud_storage = GoogleCloudStorage(log_config=self._log_config, service_key=self._settings.SERVICE_KEY, bucket_name=f"maleo-suite-{environment}", credentials=self._google_credentials)
+        environment = (
+            BaseEnums.EnvironmentType.STAGING
+            if self._settings.ENVIRONMENT == BaseEnums.EnvironmentType.LOCAL
+            else self._settings.ENVIRONMENT
+        )
+        self._cloud_storage = GoogleCloudStorage(
+            log_config=self._log_config,
+            service_key=self._settings.SERVICE_KEY,
+            bucket_name=f"maleo-suite-{environment}",
+            credentials=self._google_credentials
+        )
 
     @property
     def cloud_storage(self) -> GoogleCloudStorage:
         return self._cloud_storage
 
     def _load_maleo_credentials(self) -> None:
-        environment = BaseEnums.EnvironmentType.STAGING if self._settings.ENVIRONMENT == BaseEnums.EnvironmentType.LOCAL else self._settings.ENVIRONMENT
+        environment = (
+            BaseEnums.EnvironmentType.STAGING
+            if self._settings.ENVIRONMENT == BaseEnums.EnvironmentType.LOCAL
+            else self._settings.ENVIRONMENT
+        )
         id = int(self._secret_manager.get(f"maleo-service-account-id-{environment}"))
         email = self._secret_manager.get("maleo-service-account-email")
         username = self._secret_manager.get("maleo-service-account-username")
         password = self._secret_manager.get("maleo-service-account-password")
-        self._maleo_credentials = MaleoCredentials(id=id, username=username, email=email, password=password)
+        self._maleo_credentials = MaleoCredentials(
+            id=id,
+            username=username,
+            email=email,
+            password=password
+        )
 
     @property
     def maleo_credentials(self) -> MaleoCredentials:
@@ -209,10 +237,18 @@ class ServiceManager:
         #* Load database configurations
         password = self._secret_manager.get(name=f"maleo-db-password-{self._settings.ENVIRONMENT}")
         host = self._secret_manager.get(name=f"maleo-db-host-{self._settings.ENVIRONMENT}")
-        database = DatabaseConfigurations(password=password, host=host, database=runtime_configs.database)
+        database = DatabaseConfigurations(
+            password=password,
+            host=host,
+            database=runtime_configs.database
+        )
 
         #* Load whole configurations
-        merged_configs = BaseMergers.deep_merge(static_configs.model_dump(), runtime_configs.model_dump(exclude={"database"}), {"database": database.model_dump()})
+        merged_configs = BaseMergers.deep_merge(
+            static_configs.model_dump(),
+            runtime_configs.model_dump(exclude={"database"}),
+            {"database": database.model_dump()}
+        )
         self._configs = Configurations.model_validate(merged_configs)
 
     @property
@@ -223,7 +259,11 @@ class ServiceManager:
         password = self._secret_manager.get(name="maleo-key-password")
         private = self._secret_manager.get(name="maleo-private-key")
         public = self._secret_manager.get(name="maleo-public-key")
-        self._keys = BaseGeneralSchemas.RSAKeys(password=password, private=private, public=public)
+        self._keys = BaseGeneralSchemas.RSAKeys(
+            password=password,
+            private=private,
+            public=public
+        )
 
     @property
     def keys(self) -> BaseGeneralSchemas.RSAKeys:
@@ -231,27 +271,54 @@ class ServiceManager:
 
     def _initialize_loggers(self) -> None:
         #* Service's loggers
-        application = ServiceLogger(type=BaseEnums.LoggerType.APPLICATION, service_key=self._configs.service.key, **self._log_config.model_dump())
-        database = ServiceLogger(type=BaseEnums.LoggerType.DATABASE, service_key=self._configs.service.key, **self._log_config.model_dump())
+        application = ServiceLogger(
+            type=BaseEnums.LoggerType.APPLICATION,
+            service_key=self._configs.service.key,
+            **self._log_config.model_dump()
+        )
+        database = ServiceLogger(
+            type=BaseEnums.LoggerType.DATABASE,
+            service_key=self._configs.service.key,
+            **self._log_config.model_dump()
+        )
         #* Middleware's loggers
-        base = MiddlewareLogger(middleware_type=BaseEnums.MiddlewareLoggerType.BASE, service_key=self._configs.service.key, **self._log_config.model_dump())
-        authentication = MiddlewareLogger(middleware_type=BaseEnums.MiddlewareLoggerType.AUTHENTICATION, service_key=self._configs.service.key, **self._log_config.model_dump())
+        base = MiddlewareLogger(
+            middleware_type=BaseEnums.MiddlewareLoggerType.BASE,
+            service_key=self._configs.service.key,
+            **self._log_config.model_dump()
+        )
+        authentication = MiddlewareLogger(
+            middleware_type=BaseEnums.MiddlewareLoggerType.AUTHENTICATION,
+            service_key=self._configs.service.key,
+            **self._log_config.model_dump()
+        )
         middleware = MiddlewareLoggers(base=base, authentication=authentication)
-        self._loggers = Loggers(application=application, database=database, middleware=middleware)
+        self._loggers = Loggers(
+            application=application,
+            database=database,
+            middleware=middleware
+        )
 
     @property
     def loggers(self) -> Loggers:
         return self._loggers
 
     def _initialize_db(self) -> None:
-        self._database = DatabaseManager(metadata=self._db_metadata, logger=self._loggers.database, url=self._configs.database.url)
+        self._database = DatabaseManager(
+            metadata=self._db_metadata,
+            logger=self._loggers.database,
+            url=self._configs.database.url
+        )
 
     @property
     def database(self) -> DatabaseManager:
         return self._database
 
     def _initialize_foundation(self) -> None:
-        self._foundation = MaleoFoundationClientManager(log_config=self._log_config, service_key=self._settings.SERVICE_KEY)
+        self._foundation = MaleoFoundationClientManager(
+            log_config=self._log_config,
+            service_key=self._settings.SERVICE_KEY
+        )
 
     @property
     def foundation(self) -> MaleoFoundationClientManager:
@@ -268,14 +335,26 @@ class ServiceManager:
             u_ut="service",
             exp_in=1
         )
-        parameters = MaleoFoundationTokenParametersTransfers.Encode(key=self._keys.private, password=self._keys.password, payload=payload)
+        parameters = MaleoFoundationTokenParametersTransfers.Encode(
+            key=self._keys.private,
+            password=self._keys.password,
+            payload=payload
+        )
         result = self._foundation.services.token.encode(parameters=parameters)
         return result.data.token if result.success else None
 
-    def create_app(self, router:APIRouter, lifespan:Optional[Lifespan[AppType]] = None) -> FastAPI:
+    def create_app(
+        self,
+        router:APIRouter,
+        lifespan:Optional[Lifespan[AppType]]=None
+    ) -> FastAPI:
         self._loggers.application.info("Creating FastAPI application")
         root_path = "" if self._settings.ENVIRONMENT == "local" else f"/{self._configs.service.key.removeprefix("maleo-")}"
-        self._app = FastAPI(title=self._configs.service.name, lifespan=lifespan, root_path=root_path)
+        self._app = FastAPI(
+            title=self._configs.service.name,
+            lifespan=lifespan,
+            root_path=root_path
+        )
         self._loggers.application.info("FastAPI application created successfully")
 
         #* Add middleware(s)
@@ -292,8 +371,14 @@ class ServiceManager:
 
         #* Add exception handler(s)
         self._loggers.application.info("Adding exception handlers")
-        self._app.add_exception_handler(RequestValidationError, BaseExceptions.validation_exception_handler)
-        self._app.add_exception_handler(HTTPException, BaseExceptions.http_exception_handler)
+        self._app.add_exception_handler(
+            exc_class_or_status_code=RequestValidationError,
+            handler=BaseExceptions.validation_exception_handler
+        )
+        self._app.add_exception_handler(
+            exc_class_or_status_code=HTTPException,
+            handler=BaseExceptions.http_exception_handler
+        )
         self._loggers.application.info("Exception handlers addedd successfully")
 
         #* Include router