maleo-foundation 0.3.46__py3-none-any.whl → 0.3.47__py3-none-any.whl

maleo_foundation/managers/configuration.py

@@ -4,11 +4,10 @@ from maleo_foundation.models.transfers.general.settings import Settings
 from maleo_foundation.utils.loaders.yaml import YAMLLoader
 from .credential import CredentialManager
 
+
 class ConfigurationManager:
     def __init__(
-        self,
-        settings: Settings,
-        credential_manager: CredentialManager
+        self, settings: Settings, credential_manager: CredentialManager
     ) -> None:
         self._settings = settings
         self._credential_manager = credential_manager
@@ -23,15 +22,12 @@ class ConfigurationManager:
                 self._configurations = Configurations.model_validate(data)
                 return
 
-        secret_data = (
-            self
-            ._credential_manager
-            .secret_manager
-            .get(f"{self._settings.SERVICE_KEY}-configurations-{self._settings.ENVIRONMENT}")
+        secret_data = self._credential_manager.secret_manager.get(
+            f"{self._settings.SERVICE_KEY}-configurations-{self._settings.ENVIRONMENT}"
         )
         data = YAMLLoader.load_from_string(secret_data)
         self._configurations = Configurations.model_validate(data)
 
     @property
     def configurations(self) -> Configurations:
-        return self._configurations
+        return self._configurations

maleo_foundation/managers/credential.py

@@ -7,12 +7,9 @@ from maleo_foundation.models.transfers.general.settings import Settings
 from maleo_foundation.utils.loaders.credential.google import GoogleCredentialsLoader
 from maleo_foundation.utils.logging import SimpleConfig
 
+
 class CredentialManager:
-    def __init__(
-        self,
-        settings: Settings,
-        log_config: SimpleConfig
-    ):
+    def __init__(self, settings: Settings, log_config: SimpleConfig):
         self.settings = settings
         self.log_config = log_config
         self._initialize()
@@ -34,7 +31,7 @@ class CredentialManager:
         self._secret_manager = GoogleSecretManager(
             log_config=self.log_config,
             service_key=self.settings.SERVICE_KEY,
-            credentials=self._google_credentials
+            credentials=self._google_credentials,
         )
 
     def _get_environment_for_credentials(self) -> str:
@@ -48,18 +45,18 @@ class CredentialManager:
         environment = self._get_environment_for_credentials()
 
         try:
-            id = int(self._secret_manager.get(f"maleo-service-account-id-{environment}"))
-            uuid = UUID(self._secret_manager.get(f"maleo-service-account-uuid-{environment}"))
+            id = int(
+                self._secret_manager.get(f"maleo-service-account-id-{environment}")
+            )
+            uuid = UUID(
+                self._secret_manager.get(f"maleo-service-account-uuid-{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,
-                uuid=uuid,
-                username=username,
-                email=email,
-                password=password
+                id=id, uuid=uuid, username=username, email=email, password=password
             )
         except Exception as e:
             raise RuntimeError(f"Failed to load Maleo credentials: {str(e)}")
@@ -72,11 +69,11 @@ class CredentialManager:
     @property
     def google_credentials(self) -> Credentials:
         return self._google_credentials
-    
+
     @property
     def secret_manager(self) -> GoogleSecretManager:
         return self._secret_manager
-    
+
     @property
     def maleo_credentials(self) -> MaleoCredentials:
-        return self._maleo_credentials
+        return self._maleo_credentials

maleo_foundation/managers/db.py

@@ -10,21 +10,18 @@ from typing import Generator
 from maleo_foundation.types import BaseTypes
 from maleo_foundation.utils.logging import DatabaseLogger
 
+
 class MetadataManager:
     Base: DeclarativeMeta = declarative_base()
     metadata: MetaData = Base.metadata
 
+
 class SessionManager:
-    def __init__(
-        self,
-        logger: DatabaseLogger,
-        engine: Engine
-    ):
+    def __init__(self, logger: DatabaseLogger, 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")
 
@@ -33,18 +30,22 @@ class SessionManager:
         session = self._sessionmaker()
         self._logger.debug("New database session created.")
         try:
-            yield session  #* Provide session
-            session.commit()  #* Auto-commit on success
+            yield session  # * Provide session
+            session.commit()  # * Auto-commit on success
         except SQLAlchemyError as e:
-            session.rollback()  #* Rollback on error
-            self._logger.error(f"[SQLAlchemyError] Database transaction failed: {e}", exc_info=True)
+            session.rollback()  # * Rollback on error
+            self._logger.error(
+                f"[SQLAlchemyError] Database transaction failed: {e}", exc_info=True
+            )
             raise
         except Exception as e:
-            session.rollback()  #* Rollback on error
-            self._logger.error(f"[Exception] Database transaction failed: {e}", exc_info=True)
+            session.rollback()  # * Rollback on error
+            self._logger.error(
+                f"[Exception] Database transaction failed: {e}", exc_info=True
+            )
             raise
         finally:
-            session.close()  #* Ensure session closes
+            session.close()  # * Ensure session closes
             self._logger.debug("Database session closed.")
 
     def inject(self) -> Generator[Session, None, None]:
@@ -60,10 +61,9 @@ class SessionManager:
         """Dispose of the sessionmaker and release any resources."""
         if self._sessionmaker is not None:
             self._sessionmaker.close_all()
-            self._sessionmaker = None
 
         self._logger.info("SessionManager disposed successfully")
-        self._logger = None
+
 
 class DatabaseConfigurations(BaseModel):
     username: str = Field("postgres", description="Database user's username")
@@ -76,83 +76,94 @@ class DatabaseConfigurations(BaseModel):
     def url(self) -> str:
         return f"postgresql://{self.username}:{self.password}@{self.host}:{self.port}/{self.database}"
 
+
 class DatabaseManager:
     def __init__(
         self,
         metadata: MetaData,
         logger: DatabaseLogger,
-        url: BaseTypes.OptionalString = None
+        url: BaseTypes.OptionalString = None,
     ):
-        self._metadata = metadata #* Define database metadata
-        self._logger = logger #* Define database logger
+        self._metadata = metadata  # * Define database metadata
+        self._logger = logger  # * Define database logger
 
-        #* Create engine
+        # * Create engine
         url = url or os.getenv("DB_URL")
         if url is None:
-            raise ValueError("DB_URL environment variable must be set if url is not provided")
+            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)
+            url=url, echo=False, pool_pre_ping=True, pool_recycle=3600
+        )
         self._logger.info("SQlAlchemy engine created successfully")
 
-        #* Creating all table from metadata
+        # * Creating all table from metadata
         self._logger.info("Creating all tables defined in metadata")
-        self._metadata.create_all(bind=self._engine) #* Create all tables
+        self._metadata.create_all(bind=self._engine)  # * Create all tables
         self._logger.info("Created all tables defined in metadata")
 
-        #* Initializing session manager
+        # * Initializing session manager
         self._logger.info("Initializing session manager")
-        #* Create session
-        self._session = SessionManager(
-            logger=self._logger,
-            engine=self._engine
-        )
+        # * Create session
+        self._session = SessionManager(logger=self._logger, engine=self._engine)
         self._logger.info("Session manager initialized successfully")
 
     @property
     def metadata(self) -> MetaData:
+        if self._metadata is None:
+            raise ValueError("Metadata has not been initialized.")
         return self._metadata
 
     @property
     def engine(self) -> Engine:
+        if self._engine is None:
+            raise ValueError("Engine has not been initialized.")
         return self._engine
 
     @property
     def session(self) -> SessionManager:
+        if self._session is None:
+            raise ValueError("Session manager has not been initialized.")
         return self._session
 
     def check_connection(self) -> bool:
         """Check database connectivity by executing a simple query."""
         self._logger.info("Checking database connectivity...")
+        if self._session is None:
+            self._logger.error("Session manager is not initialized.")
+            return False
         try:
             with self._session.get() as session:
                 session.execute(text("SELECT 1"))
             self._logger.info("Database connectivity check successful.")
             return True
         except SQLAlchemyError as se:
-            self._logger.error(f"Database connectivity check failed: {se}", exc_info=True)
+            self._logger.error(
+                f"Database connectivity check failed: {se}", exc_info=True
+            )
             return False
         except Exception as e:
-            self._logger.error(f"Unexpected error during connectivity check: {e}", exc_info=True)
+            self._logger.error(
+                f"Unexpected error during connectivity check: {e}", exc_info=True
+            )
             return False
 
     def dispose(self) -> None:
-        #* Dispose session
+        # * Dispose session
         if self._session is not None:
             self._logger.info("Disposing Session Manager")
             self._session.dispose()
             self._session = None
-        #* Dispose engine
+        # * Dispose engine
         if self._engine is not None:
             self._logger.info("Disposing Engine Manager")
             self._engine.dispose()
             self._engine = None
             self._logger.info("Engine Manager disposed successfully")
-        #* Dispose metadata
+        # * Dispose metadata
         if self._metadata is not None:
             self._logger.info("Disposing DB Metadata")
             self._metadata = None
-            self._logger.info("DB Metadata diposed succesfully")
+            self._logger.info("DB Metadata diposed succesfully")

maleo_foundation/managers/middleware.py

@@ -1,13 +1,15 @@
 from fastapi import FastAPI
 from maleo_foundation.client.manager import MaleoFoundationClientManager
 from maleo_foundation.models.schemas import BaseGeneralSchemas
-from maleo_foundation.models.transfers.general.configurations.middleware \
-    import MiddlewareConfigurations
+from maleo_foundation.models.transfers.general.configurations.middleware import (
+    MiddlewareConfigurations,
+)
 from maleo_foundation.middlewares.authentication import add_authentication_middleware
 from maleo_foundation.middlewares.base import add_base_middleware
 from maleo_foundation.middlewares.cors import add_cors_middleware
 from maleo_foundation.utils.logging import MiddlewareLogger
 
+
 class MiddlewareManager:
     def __init__(
         self,
@@ -15,7 +17,7 @@ class MiddlewareManager:
         configurations: MiddlewareConfigurations,
         keys: BaseGeneralSchemas.RSAKeys,
         logger: MiddlewareLogger,
-        maleo_foundation: MaleoFoundationClientManager
+        maleo_foundation: MaleoFoundationClientManager,
     ):
         self._app = app
         self._configurations = configurations
@@ -35,7 +37,7 @@ class MiddlewareManager:
             allow_methods=self._configurations.general.allow_methods,
             allow_headers=self._configurations.general.allow_headers,
             allow_credentials=self._configurations.general.allow_credentials,
-            expose_headers=self._configurations.cors.expose_headers
+            expose_headers=self._configurations.cors.expose_headers,
         )
 
     def add_base(self):
@@ -51,12 +53,10 @@ class MiddlewareManager:
             limit=self._configurations.base.limit,
             window=self._configurations.base.window,
             cleanup_interval=self._configurations.base.cleanup_interval,
-            ip_timeout=self._configurations.base.ip_timeout
+            ip_timeout=self._configurations.base.ip_timeout,
         )
 
     def add_authentication(self):
         add_authentication_middleware(
-            app=self._app,
-            keys=self._keys,
-            maleo_foundation=self._maleo_foundation
-        )
+            app=self._app, keys=self._keys, maleo_foundation=self._maleo_foundation
+        )

maleo_foundation/managers/service.py

@@ -1,4 +1,3 @@
-import asyncio
 from fastapi import FastAPI, APIRouter
 from fastapi.exceptions import RequestValidationError
 from google.oauth2.service_account import Credentials
@@ -11,13 +10,15 @@ 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.models.transfers.general.configurations import (
     Configurations,
-    Loggers
+    Loggers,
 )
 from maleo_foundation.models.transfers.general.credentials import MaleoCredentials
 from maleo_foundation.models.transfers.general.settings import Settings
@@ -35,36 +36,37 @@ from maleo_foundation.utils.logging import (
     DatabaseLogger,
     MiddlewareLogger,
     RepositoryLogger,
-    ServiceLogger
+    ServiceLogger,
 )
 from .credential import CredentialManager
 from .configuration import ConfigurationManager
 
+
 class ServiceManager:
     def __init__(
         self,
         db_metadata: MetaData,
         log_config: SimpleConfig,
-        settings: Optional[Settings] = None
+        settings: Optional[Settings] = None,
     ):
-        self._db_metadata = db_metadata #* Declare DB Metadata
-        self._log_config = log_config #* Declare log config
-        self._settings = settings if settings is not None else Settings() #* Initialize settings
+        self._db_metadata = db_metadata  # * Declare DB Metadata
+        self._log_config = log_config  # * Declare log config
+        self._settings = (
+            settings if settings is not None else Settings()
+        )  # * Initialize settings
 
-        #* Disable google cloud logging if environment is local
+        # * Disable google cloud logging if environment is local
         if self._settings.ENVIRONMENT == "local":
             self._log_config.google_cloud_logging = None
 
-        #* Initialize Credential Manager
+        # * Initialize Credential Manager
         self._credential_manager = CredentialManager(
-            settings=self._settings,
-            log_config=self._log_config
+            settings=self._settings, log_config=self._log_config
         )
 
-        #* Initialize Configuration Manager
+        # * Initialize Configuration Manager
         self._configuration_manager = ConfigurationManager(
-            settings=self._settings,
-            credential_manager=self._credential_manager
+            settings=self._settings, credential_manager=self._credential_manager
         )
 
         self._load_keys()
@@ -113,9 +115,7 @@ class ServiceManager:
             public = self.secret_manager.get(name="maleo-public-key")
 
         self._keys = BaseGeneralSchemas.RSAKeys(
-            password=password,
-            private=private,
-            public=public
+            password=password, private=private, public=public
         )
 
     @property
@@ -124,28 +124,22 @@ class ServiceManager:
 
     def _initialize_loggers(self) -> None:
         application = ApplicationLogger(
-            service_key=self.configurations.service.key,
-            **self._log_config.model_dump()
+            service_key=self.configurations.service.key, **self._log_config.model_dump()
         )
         cache = CacheLogger(
-            service_key=self.configurations.service.key,
-            **self._log_config.model_dump()
+            service_key=self.configurations.service.key, **self._log_config.model_dump()
         )
         database = DatabaseLogger(
-            service_key=self.configurations.service.key,
-            **self._log_config.model_dump()
+            service_key=self.configurations.service.key, **self._log_config.model_dump()
         )
         middleware = MiddlewareLogger(
-            service_key=self.configurations.service.key,
-            **self._log_config.model_dump()
+            service_key=self.configurations.service.key, **self._log_config.model_dump()
         )
         repository = RepositoryLogger(
-            service_key=self.configurations.service.key,
-            **self._log_config.model_dump()
+            service_key=self.configurations.service.key, **self._log_config.model_dump()
         )
         service = ServiceLogger(
-            service_key=self.configurations.service.key,
-            **self._log_config.model_dump()
+            service_key=self.configurations.service.key, **self._log_config.model_dump()
         )
         self._loggers = Loggers(
             application=application,
@@ -153,7 +147,7 @@ class ServiceManager:
             database=database,
             middleware=middleware,
             repository=repository,
-            service=service
+            service=service,
         )
 
     @property
@@ -163,7 +157,7 @@ class ServiceManager:
     async def _clear_cache(self) -> None:
         prefixes = [
             self.configurations.service.key,
-            f"google-cloud-storage:{self.configurations.service.key}"
+            f"google-cloud-storage:{self.configurations.service.key}",
         ]
         for prefix in prefixes:
             async for key in self._redis.scan_iter(f"{prefix}*"):
@@ -175,7 +169,9 @@ class ServiceManager:
             self._loggers.cache.info("Redis connection check successful.")
             return True
         except RedisError as e:
-            self._loggers.cache.error(f"Redis connection check failed: {e}", exc_info=True)
+            self._loggers.cache.error(
+                f"Redis connection check failed: {e}", exc_info=True
+            )
             return False
 
     async def initialize_cache(self) -> None:
@@ -185,7 +181,7 @@ class ServiceManager:
             db=self.configurations.cache.redis.db,
             password=self.configurations.cache.redis.password,
             decode_responses=self.configurations.cache.redis.decode_responses,
-            health_check_interval=self.configurations.cache.redis.health_check_interval
+            health_check_interval=self.configurations.cache.redis.health_check_interval,
         )
         await self.check_redis_connection()
         self._cache = CacheManagers(redis=self._redis)
@@ -210,7 +206,7 @@ class ServiceManager:
             service_key=self._settings.SERVICE_KEY,
             bucket_name=f"maleo-suite-{environment}",
             credentials=self.google_credentials,
-            redis=self._redis
+            redis=self._redis,
         )
 
     @property
@@ -221,7 +217,7 @@ class ServiceManager:
         self._database = DatabaseManager(
             metadata=self._db_metadata,
             logger=self._loggers.database,
-            url=self.configurations.database.url
+            url=self.configurations.database.url,
         )
 
     @property
@@ -230,8 +226,7 @@ class ServiceManager:
 
     def _initialize_foundation(self) -> None:
         self._foundation = MaleoFoundationClientManager(
-            log_config=self._log_config,
-            service_key=self._settings.SERVICE_KEY
+            log_config=self._log_config, service_key=self._settings.SERVICE_KEY
         )
 
     @property
@@ -249,12 +244,10 @@ class ServiceManager:
             u_u=self.maleo_credentials.username,
             u_e=self.maleo_credentials.email,
             u_ut="service",
-            exp_in=1
+            exp_in=1,
         )
         parameters = MaleoFoundationTokenParametersTransfers.Encode(
-            key=self._keys.private,
-            password=self._keys.password,
-            payload=payload
+            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
@@ -263,7 +256,7 @@ class ServiceManager:
         self,
         router: APIRouter,
         lifespan: Optional[Lifespan[AppType]] = None,
-        version: str = "unknown"
+        version: str = "unknown",
     ) -> FastAPI:
         self._loggers.application.info("Creating FastAPI application")
         root_path = self._settings.ROOT_PATH
@@ -271,35 +264,35 @@ class ServiceManager:
             title=self.configurations.service.name,
             version=version,
             lifespan=lifespan,
-            root_path=root_path
+            root_path=root_path,
         )
         self._loggers.application.info("FastAPI application created successfully")
 
-        #* Add middleware(s)
+        # * Add middleware(s)
         self._loggers.application.info("Configuring middlewares")
         self._middleware = MiddlewareManager(
             app=self._app,
             configurations=self.configurations.middleware,
             keys=self._keys,
             logger=self._loggers.middleware,
-            maleo_foundation=self._foundation
+            maleo_foundation=self._foundation,
         )
         self._middleware.add_all()
         self._loggers.application.info("Middlewares added successfully")
 
-        #* Add exception handler(s)
+        # * Add exception handler(s)
         self._loggers.application.info("Adding exception handlers")
         self._app.add_exception_handler(
             exc_class_or_status_code=RequestValidationError,
-            handler=BaseExceptions.validation_exception_handler
+            handler=BaseExceptions.validation_exception_handler,
         )
         self._app.add_exception_handler(
             exc_class_or_status_code=HTTPException,
-            handler=BaseExceptions.http_exception_handler
+            handler=BaseExceptions.http_exception_handler,
         )
         self._loggers.application.info("Exception handlers added successfully")
 
-        #* Include router
+        # * Include router
         self._loggers.application.info("Including routers")
         self._app.include_router(router)
         self._loggers.application.info("Routers included successfully")
@@ -326,4 +319,4 @@ class ServiceManager:
             self._loggers.database.dispose()
             self._loggers.middleware.info("Disposing logger")
             self._loggers.middleware.dispose()
-            self._loggers = None
+            self._loggers = None