maleo-foundation 0.1.35__py3-none-any.whl → 0.1.36__py3-none-any.whl

maleo_foundation/managers/db.py

@@ -5,17 +5,16 @@ 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 Generator, Optional, Type
+from typing import Generator
 from maleo_foundation.types import BaseTypes
-from maleo_foundation.utils.logger import BaseLogger
-from maleo_foundation.db.table import BaseTable
+from maleo_foundation.utils.logging import ServiceLogger
 
 class MetadataManager:
     Base:DeclarativeMeta = declarative_base()
     metadata:MetaData = Base.metadata
 
 class SessionManager:
-    def __init__(self, logger:BaseLogger, 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)
@@ -62,7 +61,7 @@ class DatabaseManager:
     def __init__(
         self,
         metadata:MetaData,
-        logger:BaseLogger,
+        logger:ServiceLogger,
         url:BaseTypes.OptionalString = None
     ):
         self._metadata = metadata #* Define database metadata

maleo_foundation/managers/service.py

@@ -1,6 +1,5 @@
 import json
 import os
-import uvicorn
 from fastapi import FastAPI, APIRouter
 from fastapi.exceptions import RequestValidationError
 from starlette.exceptions import HTTPException

maleo_foundation/utils/exceptions.py

@@ -8,7 +8,7 @@ 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.utils.logger import BaseLogger, LoggerFactory
+from maleo_foundation.utils.logging import BaseLogger
 
 class BaseExceptions:
     @staticmethod
@@ -27,15 +27,9 @@ class BaseExceptions:
     def database_exception_handler(
         operation:str,
         logger:Optional[BaseLogger] = None,
-        logger_factory:Optional[LoggerFactory] = None,
         fail_result_class:type[BaseServiceQueryResultsTransfers.Fail] = BaseServiceQueryResultsTransfers.Fail
     ):
         """Decorator to handle database-related exceptions consistently."""
-        if logger is not None and logger_factory is not None:
-            raise RuntimeError("Only one of 'logger' or 'logger_factory' should be provided, not both.")
-        if logger is None and logger_factory is None:
-            raise RuntimeError("One of 'logger' or 'logger_factory' must be provided.")
-        logger = logger or logger_factory()
         def decorator(func):
             @wraps(func)
             def wrapper(*args, **kwargs):
@@ -62,15 +56,9 @@ class BaseExceptions:
     def service_exception_handler(
         operation:str,
         logger:Optional[BaseLogger] = None,
-        logger_factory:Optional[LoggerFactory] = None,
         fail_result_class:type[BaseServiceGeneralResultsTransfers.Fail] = BaseServiceGeneralResultsTransfers.Fail
     ):
         """Decorator to handle service-related exceptions consistently."""
-        if logger is not None and logger_factory is not None:
-            raise RuntimeError("Only one of 'logger' or 'logger_factory' should be provided, not both.")
-        if logger is None and logger_factory is None:
-            raise RuntimeError("One of 'logger' or 'logger_factory' must be provided.")
-        logger = logger or logger_factory()
         def decorator(func):
             @wraps(func)
             def wrapper(*args, **kwargs):

{maleo_foundation-0.1.35.dist-info → maleo_foundation-0.1.36.dist-info}/METADATA

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

{maleo_foundation-0.1.35.dist-info → maleo_foundation-0.1.36.dist-info}/RECORD

@@ -4,25 +4,6 @@ maleo_foundation/constants.py,sha256=aBmEfWlBqZxi0k-n6h2NM1YRLOjMnheEiLyQcjP-zCQ
 maleo_foundation/enums.py,sha256=uvwl3dl2r6BoJMEbtSETiLoyJubHup9Lc7VOg7w7zQo,2943
 maleo_foundation/extended_types.py,sha256=pIKt-_9tby4rmune3fmWcCW_mohaNRh_1lywBmdc-L4,301
 maleo_foundation/types.py,sha256=aKXnIgEhYGSfFqNMGLc4qIKGkINBRpkOo9R9cb2CbwI,2414
-maleo_foundation/clients/__init__.py,sha256=W8vydJYeDEi6gdmOZSBFSSDsfZJtb8C05CHErZgsZ30,188
-maleo_foundation/clients/general/__init__.py,sha256=l9eQrBeLW4aXtGU5aK3i6fD-msVR4526W7D9V8WCXIg,91
-maleo_foundation/clients/general/http.py,sha256=pObW6EaMeLDNsRZ9QJPzfhZDzcZ33kCsb-9Yfoh2MA4,1670
-maleo_foundation/clients/google/__init__.py,sha256=1uv6nF9QbATsSAcMimQOT7Y-eBljjDunBojNX6oAtS8,90
-maleo_foundation/clients/google/base.py,sha256=tdiqNNtvy-Ev_L7R4Dg9y7V14QdlbfCOQ2Mulo238aE,1141
-maleo_foundation/clients/google/secret.py,sha256=4k3pDs4HAibeCEgv8nUBADfhk2aftG9L1sfR3UxAyfE,2516
-maleo_foundation/clients/google/storage.py,sha256=smsmrjKAyxtfdqz3EzuUVx_rQeaTaYZ5VKNWCvwQ4U8,1971
-maleo_foundation/clients/google/cloud/__init__.py,sha256=WGMPxEKKdkz3XGY5dZn9E-nYhD1kv1MgRHbmVnky4zk,245
-maleo_foundation/clients/google/cloud/base.py,sha256=V_5Zdu90FQLgAfUZvlB1KojFzXNKZNIR516gjDXgaPU,1146
-maleo_foundation/clients/google/cloud/logging.py,sha256=s9T9bex0GeCPwIHrBRvilT23iyNKqJ5z50KcT76Jt5Y,2202
-maleo_foundation/clients/google/cloud/secret.py,sha256=1dua0V2FHesjltLdc1N4PF8xTXPzmcSA3sgwBzYNUtM,5853
-maleo_foundation/clients/google/cloud/storage.py,sha256=t8hAZiQj_RFhJJXE8a20WP7spNKTEFw1RK1AqurL3T8,3848
-maleo_foundation/clients/utils/__init__.py,sha256=hChEGABHH4tOFxPRcpxmlhkM9PgF18M7wXapH88hpu4,131
-maleo_foundation/clients/utils/logger.py,sha256=FMnHKV4i6xR6e8XN7kCNwTf1jhSLdJUIO7teSm5g0D4,1829
-maleo_foundation/db/__init__.py,sha256=fmvhCz4_siHfyKJujcUakKDKmuLxMhxn2w5tmfQwfcM,135
-maleo_foundation/db/engine.py,sha256=hhYjCt5IEb864H2RNlUVS7GfMzuThHKRV260Bgkhn_o,3003
-maleo_foundation/db/manager.py,sha256=nSstMJ9JBoEKTSLlz6MNf4Wuet8DLp2Pipfveg4kM1c,4663
-maleo_foundation/db/session.py,sha256=6flx_HVh4Fe3EohK2xDcyXmVAPOci1KFvhVK4wFcKtA,4736
-maleo_foundation/db/table.py,sha256=Dk5GXeO0gbBBPN2PJtZhlUx2x3vMbT4dxTBc3YLBbuc,1199
 maleo_foundation/expanded_types/__init__.py,sha256=lm_r7rxlLA0sgSTGQBMR9ZbZbVDpD7Te-UYb3oRVi1g,364
 maleo_foundation/expanded_types/client.py,sha256=To0kRXp3QTmuSu5rWKaCiTsMK9qkYiyYKYbHfw-y1fY,2396
 maleo_foundation/expanded_types/general.py,sha256=bjIBREYTS73tvS-Key7P7db82a2HHlSJ1XBAvKuYmT0,826
@@ -30,9 +11,9 @@ maleo_foundation/expanded_types/query.py,sha256=0yUG-JIVsanzB7KAkrRz_OsrhP6J0bRq
 maleo_foundation/expanded_types/service.py,sha256=q8jpKdbCbLWwH1UPQavKpVE14rC5rveduk2cFWzuhGw,2416
 maleo_foundation/expanded_types/token.py,sha256=4fRTJw6W5MYq71NksNrWNi7qYHQ4_lQwfu9WxwrMipc,355
 maleo_foundation/managers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-maleo_foundation/managers/db.py,sha256=Jf0w-9JOAG5X2quDxqqw6d2WUIX7MYGdlPGxWP0rxHs,4699
+maleo_foundation/managers/db.py,sha256=ZN0b43OgqQtk2WHKMJQ0E2TeaSEyVJ0-l4FEkrSG0Qo,4645
 maleo_foundation/managers/middleware.py,sha256=7CDXPMb28AR7J72TWOeKFxOlMypKezEtO9mr53a88B0,4032
-maleo_foundation/managers/service.py,sha256=un1rJA9YdFK-8QRDQPurBIsHtRlmaVd2Z0-Lzr2o7_c,20392
+maleo_foundation/managers/service.py,sha256=c6syGWL5DdGWix075_WVaAIfSV7SSHbfrPlCQBnYOK8,20377
 maleo_foundation/managers/client/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 maleo_foundation/managers/client/base.py,sha256=lYREmEoTLShlPPXOKKiAopjefJ8nIWHCi7IvWkXXKeY,1465
 maleo_foundation/managers/client/maleo.py,sha256=NibYGdiN3EXUw5nx-tL48QAZym14GcA4BDZihGJNQ-g,4254
@@ -46,6 +27,7 @@ maleo_foundation/middlewares/base.py,sha256=3OaB5F57F3epKNieoAgarYM6PimoUdUl3Dgp
 maleo_foundation/middlewares/cors.py,sha256=9uvBvY2N6Vxa9RP_YtESxcWo6Doi6uS0lzAG9iLY7Uc,2288
 maleo_foundation/models/__init__.py,sha256=AaKehO7c1HyKhoTGRmNHDddSeBXkW-_YNrpOGBu8Ms8,246
 maleo_foundation/models/responses.py,sha256=Ka9Peb1fVuQKaxyy11FVkUPtGtzyEm_9Xfe8Vla3ml0,4764
+maleo_foundation/models/table.py,sha256=Dk5GXeO0gbBBPN2PJtZhlUx2x3vMbT4dxTBc3YLBbuc,1199
 maleo_foundation/models/schemas/__init__.py,sha256=Xj8Ahsqyra-fmEaVcGPok5GOOsPQlKcknHYMvbjvENA,277
 maleo_foundation/models/schemas/general.py,sha256=hEQQPcddxMsJXMb36nqItIAfp3pqUyJOlaD7nXkNM2I,3609
 maleo_foundation/models/schemas/parameter.py,sha256=K47z2NzmTEhUiOfRiRLyRPXoQurbWsKBL7ObXAxIWRY,2100
@@ -74,15 +56,14 @@ maleo_foundation/services/__init__.py,sha256=Ho5zJSA89xdGFKIwOdzjmd8sm23cIuwrqYA
 maleo_foundation/services/token.py,sha256=ZqRqOdGUnaSIam6-JHVdAW1UST-2EDtcVN0fpbPmXY4,1638
 maleo_foundation/utils/__init__.py,sha256=FavmL5XYGCm955EAKiWWcXYeU15p5rSzfcglpV2yI6c,387
 maleo_foundation/utils/controller.py,sha256=ECzPzpw36zBAjKcWcDbUAhIJGbc6UpeypdUUX6ipXBg,6396
-maleo_foundation/utils/exceptions.py,sha256=nk3rD57fDR-D7BQkU1JEKV-Mu7FGMpLSEsqxdDZdKjU,4532
+maleo_foundation/utils/exceptions.py,sha256=LPPcU-6_3NbRIBZg2Nr2Ac5HF1qZJbHbMVnwfIfZg6g,3702
 maleo_foundation/utils/extractor.py,sha256=BOYkEiEJZTixScd_mEiLt2svKZ4gXBgD2WDlU6giI3w,718
 maleo_foundation/utils/keyloader.py,sha256=g7LYypj7UolmSgHRGXMFgVaWr55UayMdtKXR5NmB7VM,2341
-maleo_foundation/utils/logger.py,sha256=uTvzzKnGjbxRVLHbiMDw2zKKWNaCwV35sxgjDStEwNQ,3569
 maleo_foundation/utils/logging.py,sha256=MwvZmZSA8SIdfq-knEvpYIgqnSpHcyHrZY9TVHWVHJA,9023
 maleo_foundation/utils/query.py,sha256=ODQ3adOYQNj5E2cRW9ytbjBz56nEDcnfq8mQ6YZbCCM,4375
 maleo_foundation/utils/formatter/__init__.py,sha256=iKf5YCbEdg1qKnFHyKqqcQbqAqEeRUf8mhI3v3dQoj8,78
 maleo_foundation/utils/formatter/case.py,sha256=TmvvlfzGdC_omMTB5vAa40TZBxQ3hnr-SYeo0M52Rlg,1352
-maleo_foundation-0.1.35.dist-info/METADATA,sha256=plzE197g_RRnn3THYEHohLmIL9ZZyGOwGt8dKnyiN44,3190
-maleo_foundation-0.1.35.dist-info/WHEEL,sha256=0CuiUZ_p9E4cD6NyLD6UG80LBXYyiSYZOKDm5lp32xk,91
-maleo_foundation-0.1.35.dist-info/top_level.txt,sha256=_iBos3F_bhEOdjOnzeiEYSrCucasc810xXtLBXI8cQc,17
-maleo_foundation-0.1.35.dist-info/RECORD,,
+maleo_foundation-0.1.36.dist-info/METADATA,sha256=XkamA11MYU7rbddrU-0vy_Lzhaq1SsdiJ9G7xsT4JbA,3190
+maleo_foundation-0.1.36.dist-info/WHEEL,sha256=0CuiUZ_p9E4cD6NyLD6UG80LBXYyiSYZOKDm5lp32xk,91
+maleo_foundation-0.1.36.dist-info/top_level.txt,sha256=_iBos3F_bhEOdjOnzeiEYSrCucasc810xXtLBXI8cQc,17
+maleo_foundation-0.1.36.dist-info/RECORD,,

maleo_foundation/clients/__init__.py

@@ -1,7 +0,0 @@
-from __future__ import annotations
-from .general import BaseGeneralClients
-from .google import GoogleClients
-
-class BaseClients:
-    General = BaseGeneralClients
-    Google = GoogleClients

maleo_foundation/clients/general/__init__.py

@@ -1,4 +0,0 @@
-from .http import HTTPClientManager
-
-class BaseGeneralClients:
-    HTTP = HTTPClientManager

maleo_foundation/clients/general/http.py

@@ -1,50 +0,0 @@
-import httpx
-from contextlib import asynccontextmanager
-from typing import AsyncGenerator, Optional
-
-class HTTPClientManager:
-    client:Optional[httpx.AsyncClient] = None
-    base_url:Optional[str] = None
-
-    @classmethod
-    def initialize(cls) -> None:
-        """Initialize the HTTP client if not already initialized."""
-        if cls.client is None:
-            cls.client = httpx.AsyncClient()
-
-    @classmethod
-    async def _client_handler(cls) -> AsyncGenerator[httpx.AsyncClient, None]:
-        """Reusable generator for client handling."""
-        if cls.client is None:
-            raise RuntimeError("Client has not been initialized. Call initialize first.")
-
-        yield cls.client
-
-    @classmethod
-    async def inject_client(cls) -> AsyncGenerator[httpx.AsyncClient, None]:
-        return cls._client_handler()
-
-    @classmethod
-    @asynccontextmanager
-    async def get_client(cls) -> AsyncGenerator[httpx.AsyncClient, None]:
-        """
-        Async context manager for manual HTTP client handling.
-        Supports `async with HTTPClientManager.get() as client:`
-        """
-        async for client in cls._client_handler():
-            yield client
-
-    @classmethod
-    def get_url(cls) -> str:
-        if cls.base_url is None:
-            raise RuntimeError("Base URL has not been initialized. Call initialize first.")
-        return cls.base_url
-
-    @classmethod
-    async def dispose(cls) -> None:
-        """Dispose of the HTTP client and release any resources."""
-        if cls.client is not None:
-            await cls.client.aclose()
-            cls.client = None
-        if cls.base_url is not None:
-            cls.base_url = None

maleo_foundation/clients/google/__init__.py

@@ -1,4 +0,0 @@
-from .cloud import GoogleCloudClients
-
-class GoogleClients:
-    Cloud = GoogleCloudClients

maleo_foundation/clients/google/base.py

@@ -1,32 +0,0 @@
-import os
-from google.auth import default
-from google.oauth2 import service_account
-from maleo_foundation.types import BaseTypes
-
-class GoogleClientManager:
-    def __init__(self, google_credentials_path:BaseTypes.OptionalString = None) -> None:
-        google_credentials_path = google_credentials_path or os.getenv("GOOGLE_CREDENTIALS_PATH")
-        try:
-            if google_credentials_path is not None:
-                self._credentials = service_account.Credentials.from_service_account_file(filename=google_credentials_path)
-            else:
-                self._credentials, _ = default()
-        except Exception as e:
-            raise ValueError(f"Failed to initialize credentials: {str(e)}")
-
-    @property
-    def credentials(self) -> service_account.Credentials:
-        return self._credentials
-    
-    @property
-    def name(self) -> str:
-        raise NotImplementedError()
-
-    @property
-    def client(self):
-        raise NotImplementedError()
-
-    def dispose(self) -> None:
-        """Dispose of the client and release any resources."""
-        if self._credentials is not None:
-            self._credentials = None

maleo_foundation/clients/google/cloud/__init__.py

@@ -1,8 +0,0 @@
-from .logging import GoogleCloudLogging
-from .secret import GoogleSecretManager
-from .storage import GoogleCloudStorage
-
-class GoogleCloudClients:
-    Logging = GoogleCloudLogging
-    Secret = GoogleSecretManager
-    Storage = GoogleCloudStorage

maleo_foundation/clients/google/cloud/base.py

@@ -1,32 +0,0 @@
-import os
-from google.auth import default
-from google.oauth2 import service_account
-from maleo_foundation.types import BaseTypes
-
-class GoogleCloudClientManager:
-    def __init__(self, google_credentials_path:BaseTypes.OptionalString = None) -> None:
-        google_credentials_path = google_credentials_path or os.getenv("GOOGLE_CREDENTIALS_PATH")
-        try:
-            if google_credentials_path is not None:
-                self._credentials = service_account.Credentials.from_service_account_file(filename=google_credentials_path)
-            else:
-                self._credentials, _ = default()
-        except Exception as e:
-            raise ValueError(f"Failed to initialize credentials: {str(e)}")
-
-    @property
-    def credentials(self) -> service_account.Credentials:
-        return self._credentials
-    
-    @property
-    def name(self) -> str:
-        raise NotImplementedError()
-
-    @property
-    def client(self):
-        raise NotImplementedError()
-
-    def dispose(self) -> None:
-        """Dispose of the client and release any resources."""
-        if self._credentials is not None:
-            self._credentials = None

maleo_foundation/clients/google/cloud/logging.py

@@ -1,63 +0,0 @@
-import os
-from google.auth import default
-from google.cloud.logging import Client
-from google.cloud.logging.handlers import CloudLoggingHandler
-from google.oauth2 import service_account
-from typing import Optional
-from .base import GoogleCloudClientManager
-
-class GoogleCloudLogging:
-    _client:Optional[Client] = None
-
-    @classmethod
-    def initialize(cls) -> Client:
-        """Initialize the cloud logging if not already initialized."""
-        if cls._client is None:
-            #* Setup credentials with fallback chain
-            credentials = None
-            credentials_file = os.getenv("GOOGLE_APPLICATION_CREDENTIALS")
-            try:
-                if credentials_file:
-                    credentials = service_account.Credentials.from_service_account_file(credentials_file)
-                else:
-                    credentials, _ = default()
-            except Exception as e:
-                raise ValueError(f"Failed to initialize credentials: {str(e)}")
-
-            cls._client = Client(credentials=credentials)
-            cls._client.setup_logging()
-
-    @classmethod
-    def dispose(cls) -> None:
-        """Dispose of the cloud logging and release any resources."""
-        if cls._client is not None:
-            cls._client = None
-
-    @classmethod
-    def _get_client(cls) -> Client:
-        """Retrieve the cloud logging client, initializing it if necessary."""
-        cls.initialize()
-        return cls._client
-
-    @classmethod
-    def create_handler(cls, name:str):
-        cls.initialize()
-        return CloudLoggingHandler(client=cls._client, name=name)
-
-class GoogleCloudLoggingV2(GoogleCloudClientManager):
-    def __init__(self, google_credentials_path = None) -> None:
-        super().__init__(google_credentials_path)
-        self._client = Client(credentials=self._credentials)
-        self._client.setup_logging()
-
-    @property
-    def client(self) -> Client:
-        return self._client
-
-    def dispose(self) -> None:
-        if self._client is not None:
-            self._client = None
-        return super().dispose()
-
-    def create_handler(self, name:str) -> CloudLoggingHandler:
-        return CloudLoggingHandler(client=self._client, name=name)

maleo_foundation/clients/google/cloud/secret.py

@@ -1,149 +0,0 @@
-import os
-from google.api_core import retry
-from google.api_core.exceptions import NotFound
-from google.auth import default
-from google.cloud import secretmanager
-from google.oauth2 import service_account
-from typing import Optional
-from .base import GoogleCloudClientManager
-
-class GoogleSecretManager:
-    _project:Optional[str] = None
-    _client:Optional[secretmanager.SecretManagerServiceClient] = None
-
-    @classmethod
-    def initialize(cls, project_id:Optional[str] = None) -> None:
-        """Initialize the cloud storage if not already initialized."""
-        cls._project = project_id or os.getenv("GCP_PROJECT_ID")
-        if cls._project is None:
-            raise ValueError("GCP_PROJECT_ID environment variable must be set if no project_id is provided")
-        if cls._client is None:
-            #* Setup credentials with fallback chain
-            credentials = None
-            credentials_file = os.getenv("GOOGLE_CREDENTIALS_PATH")
-            try:
-                if credentials_file:
-                    credentials = service_account.Credentials.from_service_account_file(credentials_file)
-                else:
-                    credentials, _ = default()
-            except Exception as e:
-                raise ValueError(f"Failed to initialize credentials: {str(e)}")
-
-            cls._client = secretmanager.SecretManagerServiceClient(credentials=credentials)
-
-    @classmethod
-    def dispose(cls):
-        """Disposes of the Google Secret Manager client"""
-        if cls._client is not None:
-            cls._client = None
-        if cls._project is not None:
-            cls._project = None
-
-    @classmethod
-    @retry.Retry(
-        predicate=retry.if_exception_type(Exception),
-        timeout=5
-    )
-    def get(
-        cls,
-        name:str,
-        version:str = "latest",
-    ) -> Optional[str]:
-        try:
-            secret_path = f"projects/{cls._project}/secrets/{name}/versions/{version}"
-            request = secretmanager.AccessSecretVersionRequest(name=secret_path)
-            response = cls._client.access_secret_version(request=request)
-            return response.payload.data.decode()
-        except Exception as e:
-            return None
-
-    @classmethod
-    @retry.Retry(
-        predicate=retry.if_exception_type(Exception),
-        timeout=5
-    )
-    def create(
-        cls,
-        name:str,
-        data:str
-    ) -> Optional[str]:
-        parent = f"projects/{cls._project}"
-        secret_path = f"{parent}/secrets/{name}"
-        try:
-            #* Check if the secret already exists
-            request = secretmanager.GetSecretRequest(name=secret_path)
-            cls._client.get_secret(request=request)
-
-        except NotFound:
-            #* Secret does not exist, create it first
-            try:
-                secret = secretmanager.Secret(name=name, replication={"automatic": {}})
-                request = secretmanager.CreateSecretRequest(parent=parent, secret_id=name, secret=secret)
-                cls._client.create_secret(request=request)
-            except Exception as e:
-                return None
-
-        #* Add a new secret version
-        try:
-            payload = secretmanager.SecretPayload(data=data.encode())  # ✅ Fixed attribute name
-            request = secretmanager.AddSecretVersionRequest(parent=secret_path, payload=payload)
-            response = cls._client.add_secret_version(request=request)
-            return data
-        except Exception as e:
-            return None
-
-class GoogleSecretManagerV2(GoogleCloudClientManager):
-    def __init__(self, google_credentials_path = None) -> None:
-        super().__init__(google_credentials_path)
-        self._project_id = self.credentials.project_id
-        self._client = secretmanager.SecretManagerServiceClient(credentials=self.credentials)
-
-    @property
-    def project_id(self):
-        return self._project_id
-
-    @property
-    def client(self) -> secretmanager.SecretManagerServiceClient:
-        return self._client
-
-    def dispose(self):
-        if self._client is not None:
-            self._client = None
-        return super().dispose()
-
-    @retry.Retry(predicate=retry.if_exception_type(Exception), timeout=5)
-    def get(self, name:str, version:str = "latest") -> Optional[str]:
-        try:
-            secret_path = f"projects/{self._project_id}/secrets/{name}/versions/{version}"
-            request = secretmanager.AccessSecretVersionRequest(name=secret_path)
-            response = self._client.access_secret_version(request=request)
-            return response.payload.data.decode()
-        except Exception as e:
-            return None
-
-    @retry.Retry(predicate=retry.if_exception_type(Exception), timeout=5)
-    def create(self, name:str, data:str) -> Optional[str]:
-        parent = f"projects/{self._project_id}"
-        secret_path = f"{parent}/secrets/{name}"
-        try:
-            #* Check if the secret already exists
-            request = secretmanager.GetSecretRequest(name=secret_path)
-            self._client.get_secret(request=request)
-
-        except NotFound:
-            #* Secret does not exist, create it first
-            try:
-                secret = secretmanager.Secret(name=name, replication={"automatic": {}})
-                request = secretmanager.CreateSecretRequest(parent=parent, secret_id=name, secret=secret)
-                self._client.create_secret(request=request)
-            except Exception as e:
-                return None
-
-        #* Add a new secret version
-        try:
-            payload = secretmanager.SecretPayload(data=data.encode())  # ✅ Fixed attribute name
-            request = secretmanager.AddSecretVersionRequest(parent=secret_path, payload=payload)
-            response = self._client.add_secret_version(request=request)
-            return data
-        except Exception as e:
-            return None

maleo_foundation/clients/google/cloud/storage.py

@@ -1,110 +0,0 @@
-import os
-from datetime import timedelta
-from google.auth import default
-from google.cloud.storage import Bucket, Client
-from google.oauth2 import service_account
-from typing import Optional
-from maleo_foundation.types import BaseTypes
-from .base import GoogleCloudClientManager
-
-class GoogleCloudStorage:
-    _client:Optional[Client] = None
-    _bucket:Optional[Bucket] = None
-
-    @classmethod
-    def initialize(cls) -> None:
-        """Initialize the cloud storage if not already initialized."""
-        if cls._client is None:
-            #* Setup credentials with fallback chain
-            credentials = None
-            credentials_file = os.getenv("GOOGLE_CREDENTIALS_PATH")
-            try:
-                if credentials_file:
-                    credentials = service_account.Credentials.from_service_account_file(credentials_file)
-                else:
-                    credentials, _ = default()
-            except Exception as e:
-                raise ValueError(f"Failed to initialize credentials: {str(e)}")
-
-            cls._client = Client(credentials=credentials)
-
-            #* Preload bucket
-            bucket_name = os.getenv("GCS_BUCKET_NAME")
-            if not bucket_name:
-                cls._client.close()
-                raise ValueError("GCS_BUCKET_NAME environment variable must be set")
-
-            #* Validate bucket existence
-            bucket = cls._client.lookup_bucket(bucket_name)
-            if bucket is None:
-                raise ValueError(f"Bucket '{bucket_name}' does not exist.")
-
-            cls._bucket = bucket
-
-    @classmethod
-    def dispose(cls) -> None:
-        """Dispose of the cloud storage and release any resources."""
-        if cls._client is not None:
-            cls._client.close()
-            cls._client = None
-            cls._bucket = None
-
-    @classmethod
-    def _get_client(cls) -> Client:
-        """Retrieve the cloud storage client, initializing it if necessary."""
-        cls.initialize()
-        return cls._client
-
-    @classmethod
-    def generate_signed_url(cls, location:str) -> str:
-        """
-        generate signed URL of a file in the bucket based on its location.
-
-        Args:
-            location: str
-                Location of the file inside the bucket
-
-        Returns:
-            str: File's pre-signed download url
-
-        Raises:
-            ValueError: If the file does not exist
-        """
-        cls.initialize()
-        blob = cls._bucket.blob(blob_name=location)
-        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")
-        return url
-
-class GoogleCloudStorageV2(GoogleCloudClientManager):
-    def __init__(self, google_credentials_path = None, bucket_name:BaseTypes.OptionalString = None) -> None:
-        super().__init__(google_credentials_path)
-        self._client = Client(credentials=self._credentials)
-        self._bucket_name = bucket_name or os.getenv("GCS_BUCKET_NAME")
-        if self._bucket_name is None:
-            self._client.close()
-            raise ValueError("GCS_BUCKET_NAME environment variable must be set if 'bucket_name' is set to None")
-        self._bucket = self._client.lookup_bucket(bucket_name=self._bucket_name)
-        if self._bucket is None:
-            raise ValueError(f"Bucket '{self._bucket_name}' does not exist.")
-
-    @property
-    def client(self) -> Client:
-        return self._client
-
-    @property
-    def bucket_name(self) -> str:
-        return self._bucket_name
-
-    @property
-    def bucket(self) -> Bucket:
-        return self._bucket
-
-    def dispose(self):
-        if self._bucket is not None:
-            self._bucket = None
-        if self._client is not None:
-            self._client = None
-        return super().dispose()

maleo_foundation/clients/google/secret.py

@@ -1,61 +0,0 @@
-from google.api_core import retry
-from google.api_core.exceptions import NotFound
-from google.cloud import secretmanager
-from typing import Optional
-from .base import GoogleClientManager
-
-class GoogleSecretManager(GoogleClientManager):
-    def __init__(self, google_credentials_path = None) -> None:
-        super().__init__(google_credentials_path)
-        self._project_id = self.credentials.project_id
-        self._client = secretmanager.SecretManagerServiceClient(credentials=self.credentials)
-
-    @property
-    def project_id(self):
-        return self._project_id
-
-    @property
-    def client(self) -> secretmanager.SecretManagerServiceClient:
-        return self._client
-
-    def dispose(self):
-        if self._client is not None:
-            self._client = None
-        return super().dispose()
-
-    @retry.Retry(predicate=retry.if_exception_type(Exception), timeout=5)
-    def get(self, name:str, version:str = "latest") -> Optional[str]:
-        try:
-            secret_path = f"projects/{self._project_id}/secrets/{name}/versions/{version}"
-            request = secretmanager.AccessSecretVersionRequest(name=secret_path)
-            response = self._client.access_secret_version(request=request)
-            return response.payload.data.decode()
-        except Exception as e:
-            return None
-
-    @retry.Retry(predicate=retry.if_exception_type(Exception), timeout=5)
-    def create(self, name:str, data:str) -> Optional[str]:
-        parent = f"projects/{self._project_id}"
-        secret_path = f"{parent}/secrets/{name}"
-        try:
-            #* Check if the secret already exists
-            request = secretmanager.GetSecretRequest(name=secret_path)
-            self._client.get_secret(request=request)
-
-        except NotFound:
-            #* Secret does not exist, create it first
-            try:
-                secret = secretmanager.Secret(name=name, replication={"automatic": {}})
-                request = secretmanager.CreateSecretRequest(parent=parent, secret_id=name, secret=secret)
-                self._client.create_secret(request=request)
-            except Exception as e:
-                return None
-
-        #* Add a new secret version
-        try:
-            payload = secretmanager.SecretPayload(data=data.encode())
-            request = secretmanager.AddSecretVersionRequest(parent=secret_path, payload=payload)
-            response = self._client.add_secret_version(request=request)
-            return data
-        except Exception as e:
-            return None

maleo_foundation/clients/google/storage.py

@@ -1,57 +0,0 @@
-import os
-from datetime import timedelta
-from google.cloud.storage import Bucket, Client
-from maleo_foundation.types import BaseTypes
-from .base import GoogleClientManager
-
-class GoogleCloudStorage(GoogleClientManager):
-    def __init__(self, google_credentials_path = None, bucket_name:BaseTypes.OptionalString = None) -> None:
-        super().__init__(google_credentials_path)
-        self._client = Client(credentials=self._credentials)
-        self._bucket_name = bucket_name or os.getenv("GCS_BUCKET_NAME")
-        if self._bucket_name is None:
-            self._client.close()
-            raise ValueError("GCS_BUCKET_NAME environment variable must be set if 'bucket_name' is set to None")
-        self._bucket = self._client.lookup_bucket(bucket_name=self._bucket_name)
-        if self._bucket is None:
-            raise ValueError(f"Bucket '{self._bucket_name}' does not exist.")
-
-    @property
-    def client(self) -> Client:
-        return self._client
-
-    @property
-    def bucket_name(self) -> str:
-        return self._bucket_name
-
-    @property
-    def bucket(self) -> Bucket:
-        return self._bucket
-
-    def dispose(self):
-        if self._bucket is not None:
-            self._bucket = None
-        if self._client is not None:
-            self._client = None
-        return super().dispose()
-
-    def generate_signed_url(self, location:str) -> str:
-        """
-        generate signed URL of a file in the bucket based on its location.
-
-        Args:
-            location: str
-                Location of the file inside the bucket
-
-        Returns:
-            str: File's pre-signed download url
-
-        Raises:
-            ValueError: If the file does not exist
-        """
-        blob = self._bucket.blob(blob_name=location)
-        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")
-        return url

maleo_foundation/clients/utils/__init__.py

@@ -1,5 +0,0 @@
-from __future__ import annotations
-from .logger import ClientLoggerManager
-
-class BaseClientUtils:
-    Logger = ClientLoggerManager

maleo_foundation/clients/utils/logger.py

@@ -1,54 +0,0 @@
-from typing import Dict
-from maleo_foundation.enums import BaseEnums
-from maleo_foundation.types import BaseTypes
-from maleo_foundation.utils.logger import BaseLogger
-
-class ClientLoggerManager:
-    _loggers:Dict[type, BaseLogger] = {}
-
-    @classmethod
-    def initialize(
-        cls,
-        base_dir:str,
-        client_name:str,
-        service_name:BaseTypes.OptionalString = None,
-        level:BaseEnums.LoggerLevel = BaseEnums.LoggerLevel.INFO
-    ) -> BaseLogger:
-        """Initialize client logger if not already initialized."""
-        if cls not in cls._loggers:
-            cls._loggers[cls] = BaseLogger(
-                base_dir=base_dir,
-                type=BaseEnums.LoggerType.CLIENT,
-                service_name=service_name,
-                client_name=client_name,
-                level=level
-            )
-        return cls._loggers[cls]
-
-    @classmethod
-    def get(cls) -> BaseLogger:
-        """Return client logger (if exist) or raise Runtime Error"""
-        if cls not in cls._loggers:
-            raise RuntimeError("Logger has not been initialized. Call 'initialize' first.")
-        return cls._loggers[cls]
-
-class MaleoFoundationLoggerManager(ClientLoggerManager):
-    @classmethod
-    def initialize(
-        cls,
-        base_dir:str,
-        service_name:BaseTypes.OptionalString = None,
-        level:BaseEnums.LoggerLevel = BaseEnums.LoggerLevel.INFO
-    ) -> BaseLogger:
-        """Initialize MaleoFoundation's client logger if not already initialized."""
-        return super().initialize(
-            base_dir=base_dir,
-            client_name="MaleoFoundation",
-            service_name=service_name,
-            level=level
-        )
-
-    @classmethod
-    def get(cls) -> BaseLogger:
-        """Return client logger (if exist) or raise Runtime Error"""
-        return super().get()

maleo_foundation/db/__init__.py

@@ -1,4 +0,0 @@
-from .table import BaseTable
-from .engine import EngineManager
-from .session import SessionManager
-from .manager import DatabaseManager

maleo_foundation/db/engine.py

@@ -1,76 +0,0 @@
-import os
-from sqlalchemy import create_engine, Engine
-from typing import Optional
-from maleo_foundation.types import BaseTypes
-from maleo_foundation.utils.logger import BaseLogger
-
-class EngineManager:
-    _logger:Optional[BaseLogger] = None
-    _engine:Optional[Engine] = None
-
-    @classmethod
-    def initialize(cls, logger:BaseLogger, url:Optional[str] = None) -> Engine:
-        """Initialize the engine if not already initialized."""
-        if cls._engine is None:
-            cls._logger = logger
-            url = url or os.getenv("DB_CONNECTION_STRING")
-            if url is None:
-                raise ValueError("DB_CONNECTION_STRING environment variable must be set if url is not provided")
-            cls._engine = create_engine(url=url, echo=False, pool_pre_ping=True, pool_recycle=3600)
-            cls._logger.info("EngineManager initialized successfully.")
-        return cls._engine
-
-    @classmethod
-    def get(cls) -> Engine:
-        """Retrieve the engine, initializing it if necessary."""
-        if cls._logger is None:
-            raise RuntimeError("Logger has not been initialized. Call initialize(db_connection_string, logger) first.")
-        if cls._engine is None:
-            raise RuntimeError("Engine has not been initialized. Call initialize(db_connection_string, logger) first.")
-
-        return cls._engine
-
-    @classmethod
-    def dispose(cls) -> None:
-        """Dispose of the engine and release any resources."""
-        if cls._engine is not None:
-            cls._engine.dispose()
-            cls._engine = None
-
-        cls._logger.info("Engine disposed successfully.")
-        cls._logger = None
-
-class EngineManagerV2:
-    _logger:Optional[BaseLogger] = None
-    _engine:Optional[Engine] = None
-
-    def __init__(self, logger:BaseLogger, url:BaseTypes.OptionalString = None):
-        """Initialize the engine manager."""
-        self._logger = logger
-        url = url or os.getenv("DB_CONNECTION_STRING")
-        if url is None:
-            raise ValueError("DB_CONNECTION_STRING environment variable must be set if url is not provided")
-        self._engine = create_engine(url=url, echo=False, pool_pre_ping=True, pool_recycle=3600)
-
-    @property
-    def logger(self) -> BaseLogger:
-        """Retrieve the logger."""
-        if self._logger is None:
-            raise RuntimeError("Logger has not been initialized. Call initialize(db_connection_string, logger) first.")
-        return self._logger
-
-    @property
-    def engine(self) -> Engine:
-        """Retrieve the engine."""
-        if self._engine is None:
-            raise RuntimeError("Engine has not been initialized. Call initialize(db_connection_string, logger) first.")
-        return self._engine
-
-    def dispose(self) -> None:
-        """Dispose of the engine and release any resources."""
-        if self._engine is not None:
-            self._engine.dispose()
-            self._engine = None
-
-        self._logger.info("Engine disposed successfully.")
-        self._logger = None

maleo_foundation/db/manager.py

@@ -1,122 +0,0 @@
-import os
-from contextlib import contextmanager
-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 Generator, Optional, Type
-from maleo_foundation.types import BaseTypes
-from maleo_foundation.utils.logger import BaseLogger
-from .table import BaseTable
-
-class DatabaseManager:
-    Base:DeclarativeMeta = declarative_base()  #* Correct way to define a declarative base
-
-    #* Explicitly define the type of metadata
-    metadata:MetaData = Base.metadata
-
-    @classmethod
-    def initialize(cls, engine:Engine):
-        """Creates the database tables if they do not exist."""
-        cls.metadata.create_all(engine)
-
-class MetadataManager:
-    _Base:DeclarativeMeta = declarative_base()
-
-    @property
-    def Base(self) -> DeclarativeMeta:
-        return self._Base
-
-    @property
-    def metadata(self) -> MetaData:
-        return self._Base.metadata
-
-class SessionManager:
-    def __init__(self, logger:BaseLogger, engine:Engine):
-        self._logger = logger
-        self._sessionmaker:sessionmaker[Session] = sessionmaker(bind=engine, expire_on_commit=False)
-        self._logger.info("SessionManager initialized successfully.")
-
-    def _session_handler(self) -> Generator[Session, None, None]:
-        """Reusable function for managing database sessions."""
-        if self._logger is None:
-            raise RuntimeError("Logger has not been initialized. Call initialize() first.")
-        if self._sessionmaker is None:
-            raise RuntimeError("SessionLocal has not been initialized. Call initialize() first.")
-
-        session = self._sessionmaker()
-        self._logger.debug("New database session created.")
-        try:
-            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)
-            raise
-        except Exception as e:
-            session.rollback()  #* Rollback on error
-            self._logger.error(f"[Exception] Database transaction failed: {e}", exc_info=True)
-            raise
-        finally:
-            session.close()  #* Ensure session closes
-            self._logger.debug("Database session closed.")
-
-    def inject(self) -> Generator[Session, None, None]:
-        """Returns a generator that yields a SQLAlchemy session for dependency injection."""
-        return self._session_handler()
-
-    @contextmanager
-    def get(self) -> Generator[Session, None, None]:
-        """Context manager for manual session handling. Supports `with SessionManager.get() as session:`"""
-        yield from self._session_handler()
-
-    def dispose(self) -> None:
-        """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 DatabaseManagerV2:
-    # _metadata:Optional[MetaData] = None
-    # _logger:Optional[BaseLogger] = None
-    # _engine:Optional[Engine] = None
-    # _session:Optional[SessionManager] = None
-
-    def __init__(
-        self,
-        metadata:MetaData,
-        logger:BaseLogger,
-        url:BaseTypes.OptionalString = None
-    ):
-        self._metadata = metadata #* Define database metadata
-        self._logger = logger #* Define database logger
-
-        #* 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")
-        self._engine = create_engine(url=url, echo=False, pool_pre_ping=True, pool_recycle=3600)
-
-        self._metadata.create_all(bind=self._engine) #* Create all tables
-        self._session = SessionManager(logger=self._logger, engine=self._engine) #* Define session
-
-    def dispose(self) -> None:
-        #* Dispose session
-        if self._session is not None:
-            self._session.dispose()
-            self._session = None
-        #* Dispose engine
-        if self._engine is not None:
-            self._engine.dispose()
-            self._engine = None
-        #* Dispose logger
-        if self._logger is not None:
-            self._logger.dispose()
-            self._logger = None
-        #* Dispose metadata
-        if self._metadata is not None:
-            self._metadata = None

maleo_foundation/db/session.py

@@ -1,111 +0,0 @@
-from contextlib import contextmanager
-from sqlalchemy import Engine
-from sqlalchemy.orm import sessionmaker, Session
-from sqlalchemy.exc import SQLAlchemyError
-from typing import Generator, Optional
-from maleo_foundation.utils.logger import BaseLogger
-
-class SessionManager:
-    _logger:Optional[BaseLogger] = None
-    _sessionmaker:Optional[sessionmaker[Session]] = None
-
-    @classmethod
-    def initialize(cls, logger:BaseLogger, engine:Engine) -> None:
-        """Initialize the sessionmaker if not already initialized."""
-        if cls._sessionmaker is None:
-            cls._logger = logger
-            cls._sessionmaker = sessionmaker(bind=engine, expire_on_commit=False)
-            cls._logger.info("SessionManager initialized successfully.")
-
-    @classmethod
-    def _session_handler(cls) -> Generator[Session, None, None]:
-        """Reusable function for managing database sessions."""
-        if cls._logger is None:
-            raise RuntimeError("Logger has not been initialized. Call initialize() first.")
-        if cls._sessionmaker is None:
-            raise RuntimeError("SessionLocal has not been initialized. Call initialize() first.")
-
-        session = cls._sessionmaker()
-        cls._logger.debug("New database session created.")
-        try:
-            yield session  #* Provide session
-            session.commit()  #* Auto-commit on success
-        except SQLAlchemyError as e:
-            session.rollback()  #* Rollback on error
-            cls._logger.error(f"[SQLAlchemyError] Database transaction failed: {e}", exc_info=True)
-            raise
-        except Exception as e:
-            session.rollback()  #* Rollback on error
-            cls._logger.error(f"[Exception] Database transaction failed: {e}", exc_info=True)
-            raise
-        finally:
-            session.close()  #* Ensure session closes
-            cls._logger.debug("Database session closed.")
-
-    @classmethod
-    def inject(cls) -> Generator[Session, None, None]:
-        """Returns a generator that yields a SQLAlchemy session for dependency injection."""
-        return cls._session_handler()
-
-    @classmethod
-    @contextmanager
-    def get(cls) -> Generator[Session, None, None]:
-        """Context manager for manual session handling. Supports `with SessionManager.get() as session:`"""
-        yield from cls._session_handler()
-
-    @classmethod
-    def dispose(cls) -> None:
-        """Dispose of the sessionmaker and release any resources."""
-        if cls._sessionmaker is not None:
-            cls._sessionmaker.close_all()
-            cls._sessionmaker = None
-
-        cls._logger.info("SessionManager disposed successfully.")
-        cls._logger = None
-
-class SessionManagerV2:
-    def __init__(self, logger:BaseLogger, sessionmaker:sessionmaker[Session]):
-        self._logger = logger
-        self._sessionmaker = sessionmaker
-
-    def _session_handler(self) -> Generator[Session, None, None]:
-        """Reusable function for managing database sessions."""
-        if self._logger is None:
-            raise RuntimeError("Logger has not been initialized. Call initialize() first.")
-        if self._sessionmaker is None:
-            raise RuntimeError("SessionLocal has not been initialized. Call initialize() first.")
-
-        session = self._sessionmaker()
-        self._logger.debug("New database session created.")
-        try:
-            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)
-            raise
-        except Exception as e:
-            session.rollback()  #* Rollback on error
-            self._logger.error(f"[Exception] Database transaction failed: {e}", exc_info=True)
-            raise
-        finally:
-            session.close()  #* Ensure session closes
-            self._logger.debug("Database session closed.")
-
-    def inject(self) -> Generator[Session, None, None]:
-        """Returns a generator that yields a SQLAlchemy session for dependency injection."""
-        return self._session_handler()
-
-    @contextmanager
-    def get(self) -> Generator[Session, None, None]:
-        """Context manager for manual session handling. Supports `with SessionManager.get() as session:`"""
-        yield from self._session_handler()
-
-    def dispose(self) -> None:
-        """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

maleo_foundation/utils/logger.py

@@ -1,92 +0,0 @@
-import logging
-import os
-from datetime import datetime
-from typing import Callable, Optional
-from maleo_foundation.clients.google.cloud.logging import GoogleCloudLoggingV2
-from maleo_foundation.enums import BaseEnums
-from maleo_foundation.types import BaseTypes
-
-class BaseLogger(logging.Logger):
-    def __init__(
-        self,
-        base_dir:str,
-        type:BaseEnums.LoggerType,
-        service_name:BaseTypes.OptionalString = None,
-        client_name:BaseTypes.OptionalString = None,
-        level:BaseEnums.LoggerLevel = BaseEnums.LoggerLevel.INFO,
-        cloud_logging_manager:Optional[GoogleCloudLoggingV2] = None
-    ):
-        """
-        Custom extended logger with file, console, and Google Cloud Logging.
-
-        - Logs are stored in `base_dir/logs/{type}`
-        - Uses Google Cloud Logging if configured
-
-        Args:
-            base_dir (str): Base directory for logs (e.g., "/path/to/maleo_security")
-            type (str): Log type (e.g., "application", "middleware")
-            service_name (str): The service name (e.g., "maleo_security")
-        """
-        #* Ensure service_name exists
-        service_name = service_name or os.getenv("SERVICE_NAME")
-        if service_name is None:
-            raise ValueError("SERVICE_NAME environment variable must be set if 'service_name' is set to None")
-
-        #* Ensure client_name is valid if logger type is a client
-        if type == BaseEnums.LoggerType.CLIENT and client_name is None:
-            raise ValueError("'client_name' parameter must be provided if 'logger_type' is 'client'")
-
-        self.type = type #* Define logger type
-
-        #* Define logger name
-        if self.type == BaseEnums.LoggerType.CLIENT:
-            self.name = f"{service_name} - {self.type} - {client_name}"
-        else:
-            self.name = f"{service_name} - {self.type}"
-        super().__init__(self.name, level)
-
-        #* Clear existing handlers to prevent duplicates
-        for handler in list(self.handlers):
-            self.removeHandler(handler)
-            handler.close()
-
-        #* Formatter for logs
-        formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
-
-        #* Console handler
-        console_handler = logging.StreamHandler()
-        console_handler.setFormatter(formatter)
-        self.addHandler(console_handler)
-
-        #* Google Cloud Logging handler (If enabled)
-        if cloud_logging_manager is not None:
-            cloud_logging_handler = cloud_logging_manager.create_handler(name=self.name)
-            self.addHandler(cloud_logging_handler)
-        else:
-            self.info("Cloud logging is not configured.")
-
-        #* Define log directory
-        if type == BaseEnums.LoggerType.CLIENT:
-            log_dir = f"logs/{type}/{client_name}"
-        else:
-            log_dir = f"logs/{type}"
-        full_log_dir = os.path.join(base_dir, log_dir)
-        os.makedirs(full_log_dir, exist_ok=True)
-
-        #* Generate timestamped filename
-        timestamp = datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
-        log_filename = os.path.join(full_log_dir, f"{timestamp}.log")
-
-        #* File handler
-        file_handler = logging.FileHandler(log_filename, mode="a")
-        file_handler.setFormatter(formatter)
-        self.addHandler(file_handler)
-
-    def dispose(self):
-        """Dispose of the logger by removing all handlers."""
-        for handler in list(self.handlers):
-            self.removeHandler(handler)
-            handler.close()
-        self.handlers.clear()
-
-LoggerFactory = Callable[[], BaseLogger]