maleo-foundation 0.0.85__py3-none-any.whl → 0.0.87__py3-none-any.whl

maleo_foundation/clients/google/base.py

@@ -0,0 +1,32 @@
+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/base.py

@@ -0,0 +1,32 @@
+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

@@ -4,6 +4,7 @@ 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
@@ -41,4 +42,22 @@ class GoogleCloudLogging:
     @classmethod
     def create_handler(cls, name:str):
         cls.initialize()
-        return CloudLoggingHandler(client=cls._client, name=name)
+        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

@@ -5,6 +5,7 @@ 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
@@ -19,7 +20,7 @@ class GoogleSecretManager:
         if cls._client is None:
             #* Setup credentials with fallback chain
             credentials = None
-            credentials_file = os.getenv("GOOGLE_APPLICATION_CREDENTIALS")
+            credentials_file = os.getenv("GOOGLE_CREDENTIALS_PATH")
             try:
                 if credentials_file:
                     credentials = service_account.Credentials.from_service_account_file(credentials_file)
@@ -88,5 +89,61 @@ class GoogleSecretManager:
             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

@@ -4,6 +4,8 @@ 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
@@ -15,7 +17,7 @@ class GoogleCloudStorage:
         if cls._client is None:
             #* Setup credentials with fallback chain
             credentials = None
-            credentials_file = os.getenv("GOOGLE_APPLICATION_CREDENTIALS")
+            credentials_file = os.getenv("GOOGLE_CREDENTIALS_PATH")
             try:
                 if credentials_file:
                     credentials = service_account.Credentials.from_service_account_file(credentials_file)
@@ -74,4 +76,35 @@ class GoogleCloudStorage:
             raise ValueError(f"File '{location}' did not exists.")
 
         url = blob.generate_signed_url(version="v4", expiration=timedelta(minutes=15), method="GET")
-        return url
+        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

@@ -0,0 +1,61 @@
+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

@@ -0,0 +1,57 @@
+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/db/engine.py

@@ -1,6 +1,7 @@
 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:
@@ -37,4 +38,39 @@ class EngineManager:
             cls._engine = None
 
         cls._logger.info("Engine disposed successfully.")
-        cls._logger = None
+        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,6 +1,14 @@
-from sqlalchemy import Engine, MetaData
+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 declarative_base
+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
@@ -11,4 +19,104 @@ class DatabaseManager:
     @classmethod
     def initialize(cls, engine:Engine):
         """Creates the database tables if they do not exist."""
-        cls.metadata.create_all(engine)
+        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

@@ -61,4 +61,51 @@ class SessionManager:
             cls._sessionmaker = None
 
         cls._logger.info("SessionManager disposed successfully.")
-        cls._logger = None
+        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/enums.py

@@ -40,6 +40,10 @@ class BaseEnums:
     class ClientControllerType(StrEnum):
         HTTP = "http"
 
+    class ClientCategory(StrEnum):
+        GOOGLE = "google"
+        MALEO = "maleo"
+
     class KeyType(StrEnum):
         PRIVATE = "private"
         PUBLIC = "public"
@@ -69,6 +73,11 @@ class BaseEnums:
                 BaseEnums.RESTControllerResponseType.FILE: responses.FileResponse,
             }.get(self, responses.Response)
 
+    class ServiceLoggerType(StrEnum):
+        MIDDLEWARE = "middleware"
+        DATABASE = "database"
+        APPLICATION = "application"
+
     class LoggerType(StrEnum):
         MIDDLEWARE = "middleware"
         DATABASE = "database"

maleo_foundation/managers/client/base.py

@@ -0,0 +1,33 @@
+from typing import Optional
+from maleo_foundation.utils.logging import GoogleCloudLogging, ClientLogger
+
+class ClientManager:
+    def __init__(self, key:str, name:str, logs_dir:str, google_cloud_logging:Optional[GoogleCloudLogging] = None) -> None:
+        self._key = key
+        self._name = name
+        self._logs_dir = logs_dir
+        self._google_cloud_logging = google_cloud_logging
+        self._initialize_logger()
+
+    def _initialize_logger(self) -> None:
+        self._logger = ClientLogger(logs_dir=self._logs_dir, client_key=self._key, google_cloud_logging=self._google_cloud_logging)
+
+    @property
+    def key(self) -> str:
+        return self._key
+
+    @property
+    def name(self) -> str:
+        return self._name
+
+    @property
+    def logger(self):
+        return self._logger
+
+    @property
+    def credentials(self):
+        raise NotImplementedError()
+
+    @property
+    def client(self):
+        raise NotImplementedError()

maleo_foundation/managers/client/google/base.py

@@ -0,0 +1,26 @@
+import os
+from google.auth import default
+from google.oauth2 import service_account
+from maleo_foundation.managers.client.base import ClientManager
+
+class GoogleClientManager(ClientManager):
+    def __init__(self, key, name, logs_dir, google_cloud_logging=None, credentials_path=None) -> None:
+        super().__init__(key, name, logs_dir, google_cloud_logging)
+        credentials_path = credentials_path or os.getenv("GOOGLE_CREDENTIALS_PATH")
+        try:
+            if credentials_path is not None:
+                self._credentials = service_account.Credentials.from_service_account_file(filename=credentials_path)
+            else:
+                self._credentials, _ = default()
+        except Exception as e:
+            raise ValueError(f"Failed to initialize credentials: {str(e)}")
+
+        self._project_id = self._credentials.project_id
+
+    @property
+    def credentials(self) -> service_account.Credentials:
+        return self._credentials
+
+    @property
+    def project_id(self) -> str:
+        return self._project_id