maleo-foundation 0.1.32__tar.gz → 0.1.34__tar.gz

{maleo_foundation-0.1.32 → maleo_foundation-0.1.34}/PKG-INFO

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

maleo_foundation-0.1.34/maleo_foundation/managers/client/base.py

@@ -0,0 +1,52 @@
+from typing import Optional
+from maleo_foundation.enums import BaseEnums
+from maleo_foundation.types import BaseTypes
+from maleo_foundation.utils.logging import GoogleCloudLogging, ClientLogger
+
+class ClientManager:
+    def __init__(
+        self,
+        key:str,
+        name:str,
+        logs_dir:str,
+        service_key:BaseTypes.OptionalString = None,
+        level:BaseEnums.LoggerLevel = BaseEnums.LoggerLevel.INFO,
+        google_cloud_logging:Optional[GoogleCloudLogging] = None
+    ) -> None:
+        self._key = key
+        self._name = name
+        self._logs_dir = logs_dir
+        self._service_key = service_key
+        self._level = level
+        self._google_cloud_logging = google_cloud_logging
+        self._initialize_logger()
+        self._logger.info("Initializing client manager")
+
+    def _initialize_logger(self) -> None:
+        self._logger = ClientLogger(
+            logs_dir=self._logs_dir,
+            client_key=self._key,
+            service_key=self._service_key,
+            level=self._level,
+            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) -> ClientLogger:
+        return self._logger
+
+    @property
+    def credentials(self):
+        raise NotImplementedError()
+
+    @property
+    def client(self):
+        raise NotImplementedError()

{maleo_foundation-0.1.32 → maleo_foundation-0.1.34}/maleo_foundation/managers/client/google/base.py

@@ -1,11 +1,24 @@
 import os
 from google.auth import default
 from google.oauth2 import service_account
+from typing import Optional
+from maleo_foundation.enums import BaseEnums
+from maleo_foundation.types import BaseTypes
 from maleo_foundation.managers.client.base import ClientManager
+from maleo_foundation.utils.logging import GoogleCloudLogging
 
 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)
+    def __init__(
+        self,
+        key:str,
+        name:str,
+        logs_dir:str,
+        service_key:BaseTypes.OptionalString=None,
+        level:BaseEnums.LoggerLevel=BaseEnums.LoggerLevel.INFO,
+        google_cloud_logging:Optional[GoogleCloudLogging]=None,
+        credentials_path:BaseTypes.OptionalString=None
+    ) -> None:
+        super().__init__(key, name, logs_dir, service_key, level, google_cloud_logging)
         credentials_path = credentials_path or os.getenv("GOOGLE_CREDENTIALS_PATH")
         try:
             if credentials_path is not None:

{maleo_foundation-0.1.32 → maleo_foundation-0.1.34}/maleo_foundation/managers/client/google/secret.py

@@ -2,16 +2,28 @@ from google.api_core import retry
 from google.api_core.exceptions import NotFound
 from google.cloud import secretmanager
 from typing import Optional
+from maleo_foundation.enums import BaseEnums
+from maleo_foundation.types import BaseTypes
+from maleo_foundation.utils.logging import GoogleCloudLogging
 from .base import GoogleClientManager
 
 class GoogleSecretManager(GoogleClientManager):
-    def __init__(self, logs_dir, google_cloud_logging=None, credentials_path=None) -> None:
+    def __init__(
+        self,
+        logs_dir:str,
+        service_key:BaseTypes.OptionalString = None,
+        level:BaseEnums.LoggerLevel = BaseEnums.LoggerLevel.INFO,
+        google_cloud_logging:Optional[GoogleCloudLogging] = None,
+        credentials_path:BaseTypes.OptionalString=None
+    ) -> None:
         self._key = "google-secret-manager"
         self._name = "GoogleSecretManager"
         super().__init__(
             key=self._key,
             name=self._name,
             logs_dir=logs_dir,
+            service_key=service_key,
+            level=level,
             google_cloud_logging=google_cloud_logging,
             credentials_path=credentials_path
         )

{maleo_foundation-0.1.32 → maleo_foundation-0.1.34}/maleo_foundation/managers/client/google/storage.py

@@ -1,17 +1,30 @@
 import os
 from datetime import timedelta
 from google.cloud.storage import Bucket, Client
+from typing import Optional
+from maleo_foundation.enums import BaseEnums
 from maleo_foundation.types import BaseTypes
+from maleo_foundation.utils.logging import GoogleCloudLogging
 from .base import GoogleClientManager
 
 class GoogleCloudStorage(GoogleClientManager):
-    def __init__(self, logs_dir, google_cloud_logging=None, credentials_path=None, bucket_name:BaseTypes.OptionalString=None) -> None:
+    def __init__(
+        self,
+        logs_dir:str,
+        service_key:BaseTypes.OptionalString = None,
+        level:BaseEnums.LoggerLevel = BaseEnums.LoggerLevel.INFO,
+        google_cloud_logging:Optional[GoogleCloudLogging] = None,
+        credentials_path:BaseTypes.OptionalString=None,
+        bucket_name:BaseTypes.OptionalString=None
+    ) -> None:
         self._key = "google-cloud-storage"
         self._name = "GoogleCloudStorage"
         super().__init__(
             key=self._key,
             name=self._name,
             logs_dir=logs_dir,
+            service_key=service_key,
+            level=level,
             google_cloud_logging=google_cloud_logging,
             credentials_path=credentials_path
         )

{maleo_foundation-0.1.32 → maleo_foundation-0.1.34}/maleo_foundation/managers/client/maleo.py

@@ -1,9 +1,10 @@
 import httpx
 from contextlib import asynccontextmanager
 from pydantic import BaseModel, Field
-from typing import AsyncGenerator
+from typing import AsyncGenerator, Optional
+from maleo_foundation.enums import BaseEnums
 from maleo_foundation.types import BaseTypes
-from maleo_foundation.utils.logging import ClientLogger
+from maleo_foundation.utils.logging import GoogleCloudLogging, ClientLogger
 from maleo_foundation.managers.client.base import ClientManager
 
 class URL(BaseModel):
@@ -88,8 +89,17 @@ class ClientServices(BaseModel):
         arbitrary_types_allowed=True
 
 class MaleoClientManager(ClientManager):
-    def __init__(self, key, name, logs_dir, google_cloud_logging = None, url:BaseTypes.OptionalString = None):
-        super().__init__(key, name, logs_dir, google_cloud_logging)
+    def __init__(
+        self,
+        key:str,
+        name:str,
+        logs_dir:str,
+        service_key:BaseTypes.OptionalString=None,
+        level:BaseEnums.LoggerLevel=BaseEnums.LoggerLevel.INFO,
+        google_cloud_logging:Optional[GoogleCloudLogging]=None,
+        url:BaseTypes.OptionalString = None
+    ):
+        super().__init__(key, name, logs_dir, service_key, level, google_cloud_logging)
         self._url = url
 
     def _initialize_controllers(self) -> None:

{maleo_foundation-0.1.32 → maleo_foundation-0.1.34}/maleo_foundation/managers/service.py

@@ -14,7 +14,6 @@ from maleo_foundation.models.transfers.general.token import BaseTokenGeneralTran
 from maleo_foundation.models.transfers.parameters.token import BaseTokenParametersTransfers
 from maleo_foundation.managers.client.google.secret import GoogleSecretManager
 from maleo_foundation.managers.client.google.storage import GoogleCloudStorage
-from maleo_foundation.managers.client.http import HTTPClientManager
 from maleo_foundation.managers.client.maleo import MaleoClientManager
 from maleo_foundation.managers.db import DatabaseManager
 from maleo_foundation.managers.middleware import MiddlewareConfigurations, MiddlewareLoggers, MiddlewareManager
@@ -40,7 +39,6 @@ class Settings(BaseSettings):
     PUBLIC_KEY_PATH:str = Field("/keys/maleo-public-key.pem", description="Maleo's public key path")
     KEY_PASSWORD:str = Field(..., description="Maleo key's password")
     CONFIGURATIONS_PATH:str = Field(..., description="Service's configuration file path")
-    GCS_BUCKET_NAME:str = Field(..., description="Google cloud storage (GCS)'s bucket name")
 
 class Keys(BaseModel):
     password:str = Field(..., description="Key's password")
@@ -90,6 +88,12 @@ class DatabaseConfigurations(BaseModel):
     def url(self) -> str:
         return f"postgresql://{self.username}:{self.password}@{self.host}:{self.port}/{self.database}"
 
+class GoogleCloudStorageConfigurations(BaseModel):
+    bucket_name:str = Field(..., description="Bucket's name")
+
+class GoogleClientConfigurations(BaseModel):
+    storage:GoogleCloudStorageConfigurations = Field(..., description="Google cloud storage client configurations")
+
 class MaleoClientConfiguration(BaseModel):
     key:str = Field(..., description="Client's key")
     name:str = Field(..., description="Client's name")
@@ -113,8 +117,12 @@ class MaleoClientConfigurations(BaseModel):
         arbitrary_types_allowed=True
 
 class ClientConfigurations(BaseModel):
+    google:GoogleClientConfigurations = Field(..., description="Google client's configurations")
     maleo:MaleoClientConfigurations = Field(..., description="Maleo client's configurations")
 
+    class Config:
+        arbitrary_types_allowed=True
+
 class Configurations(BaseModel):
     service:ServiceConfigurations = Field(..., description="Service's configurations")
     middleware:MiddlewareConfigurations = Field(..., description="Middleware's configurations")
@@ -175,7 +183,6 @@ class MaleoClientManagers(BaseModel):
 
 class ClientManagers(BaseModel):
     google:GoogleClientManagers = Field(..., description="Google client's managers")
-    http:Type[HTTPClientManager] = Field(..., description="HTTP client's manager")
     maleo:MaleoClientManagers = Field(..., description="Maleo client's managers")
 
     class Config:
@@ -314,30 +321,36 @@ class ServiceManager:
 
     def _initialize_clients(self) -> None:
         #* Initialize google clients
-        secret = GoogleSecretManager(**self._log_config.model_dump())
-        storage = GoogleCloudStorage(**self._log_config.model_dump())
+        secret = GoogleSecretManager(
+            **self._log_config.model_dump(),
+            service_key=self._configs.service.key,
+            credentials_path=self._settings.GOOGLE_CREDENTIALS_PATH
+        )
+        storage = GoogleCloudStorage(
+            **self._log_config.model_dump(),
+            service_key=self._configs.service.key,
+            credentials_path=self._settings.GOOGLE_CREDENTIALS_PATH,
+            bucket_name=self._configs.client.google.storage.bucket_name
+        )
         self._google_clients = GoogleClientManagers(secret=secret, storage=storage)
-        #* Initialize http clients
-        self._http_client = HTTPClientManager
-        self._http_client.initialize()
         #* Initialize maleo clients
         self._maleo_clients = MaleoClientManagers()
         for client in self._maleo_client_manager_classes.__class__.__annotations__:
             client_cls = getattr(self._maleo_client_manager_classes, client)
             if client_cls is not None and issubclass(client_cls, MaleoClientManager):
                 cfg:MaleoClientConfiguration = getattr(self._configs.client.maleo, client)
-                client_instance = client_cls(**cfg.model_dump(), **self._log_config.model_dump())
+                client_instance = client_cls(
+                    **cfg.model_dump(),
+                    **self._log_config.model_dump(),
+                    service_key=self._configs.service.key
+                )
                 setattr(self._maleo_clients, client, client_instance)
-        self._clients = ClientManagers(google=self._google_clients, http=self._http_client, maleo=self._maleo_clients)
+        self._clients = ClientManagers(google=self._google_clients, maleo=self._maleo_clients)
 
     @property
     def google_clients(self) -> GoogleClientManagers:
         return self._google_clients
 
-    @property
-    def http_client(self) -> Type[HTTPClientManager]:
-        return self._http_client
-
     @property
     def maleo_clients(self) -> MaleoClientManagers:
         return self._maleo_clients
@@ -400,7 +413,6 @@ class ServiceManager:
         if self._clients is not None:
             self._clients.google.storage.dispose()
             self._clients.google.secret.dispose()
-            await self._clients.http.dispose()
             for client in self._maleo_clients.__class__.__annotations__:
                 client_instance = getattr(self._maleo_clients, client)
                 if client_instance is not None and isinstance(client_instance, MaleoClientManager):

{maleo_foundation-0.1.32 → maleo_foundation-0.1.34}/maleo_foundation/middlewares/authentication.py

@@ -18,22 +18,22 @@ class Backend(AuthenticationBackend):
     async def authenticate(self, conn:HTTPConnection) -> Tuple[Credentials, User]:
         client_ip = extract_client_ip(conn)
         if "Authorization" not in conn.headers:
-            self._logger.info(f"Authentication - Request | IP: {client_ip} | URL: {conn.url.path} - Result | General: Header did not contain authorization")
+            self._logger.info(f"Request | IP: {client_ip} | URL: {conn.url.path} - Result | General: Header did not contain authorization")
             return Credentials(), User(authenticated=False)
 
         auth = conn.headers["Authorization"]
         scheme, token = auth.split()
         if scheme != 'Bearer':
-            self._logger.info(f"Authentication - Request | IP: {client_ip} | URL: {conn.url.path} - Result | General: Authorization scheme is not Bearer")
+            self._logger.info(f"Request | IP: {client_ip} | URL: {conn.url.path} - Result | General: Authorization scheme is not Bearer")
             return Credentials(), User(authenticated=False)
 
         decode_token_parameters = BaseTokenParametersTransfers.Decode(key=self._key, token=token)
         decode_token_result = BaseTokenService.decode(parameters=decode_token_parameters)
         if not decode_token_result.success:
-            self._logger.error(f"Authentication - Request | IP: {client_ip} | URL: {conn.url.path} - Result | General: Failed decoding authorization token")
+            self._logger.error(f"Request | IP: {client_ip} | URL: {conn.url.path} - Result | General: Failed decoding authorization token")
             return Credentials(token=token), User(authenticated=False)
 
-        self._logger.info(f"Authentication - Request | IP: {client_ip} | URL: {conn.url.path} - Result | Username: {decode_token_result.data.u_u} | Email: {decode_token_result.data.u_e}")
+        self._logger.info(f"Request | IP: {client_ip} | URL: {conn.url.path} - Result | Username: {decode_token_result.data.u_u} | Email: {decode_token_result.data.u_e}")
         return Credentials(token=token), User(authenticated=True, username=decode_token_result.data.u_u, email=decode_token_result.data.u_e)
 
 def add_authentication_middleware(app:FastAPI, logger:MiddlewareLogger, key:str) -> None:

{maleo_foundation-0.1.32 → maleo_foundation-0.1.34}/maleo_foundation.egg-info/PKG-INFO

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

{maleo_foundation-0.1.32 → maleo_foundation-0.1.34}/maleo_foundation.egg-info/SOURCES.txt

@@ -42,7 +42,6 @@ maleo_foundation/managers/middleware.py
 maleo_foundation/managers/service.py
 maleo_foundation/managers/client/__init__.py
 maleo_foundation/managers/client/base.py
-maleo_foundation/managers/client/http.py
 maleo_foundation/managers/client/maleo.py
 maleo_foundation/managers/client/google/__init__.py
 maleo_foundation/managers/client/google/base.py

{maleo_foundation-0.1.32 → maleo_foundation-0.1.34}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "maleo_foundation"
-version = "0.1.32"
+version = "0.1.34"
 description = "Foundation package for Maleo"
 authors = [
     { name = "Agra Bima Yuda", email = "agra@nexmedis.com" }

maleo_foundation-0.1.32/maleo_foundation/managers/client/base.py

@@ -1,34 +0,0 @@
-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()
-        self._logger.info("Initializing client manager")
-
-    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) -> ClientLogger:
-        return self._logger
-
-    @property
-    def credentials(self):
-        raise NotImplementedError()
-
-    @property
-    def client(self):
-        raise NotImplementedError()

maleo_foundation-0.1.32/maleo_foundation/managers/client/http.py

@@ -1,82 +0,0 @@
-import httpx
-from contextlib import asynccontextmanager
-from pydantic import BaseModel, Field
-from typing import AsyncGenerator, Optional
-from maleo_foundation.managers.client.base import ClientManager
-
-class HTTPClientManager:
-    _client:Optional[httpx.AsyncClient] = 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_base_url(cls) -> str:
-        raise NotImplementedError()
-
-    @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
-
-class URL(BaseModel):
-    base:str = Field(..., description="Base URL")
-
-    @property
-    def api(self) -> str:
-        return f"{self.base}/api"
-
-class HTTPClientManagerV2(ClientManager):
-    def __init__(self, key, name, logs_dir, google_cloud_logging = None):
-        super().__init__(key, name, logs_dir, google_cloud_logging)
-        self._client = httpx.AsyncClient()
-
-    async def _client_handler(self) -> AsyncGenerator[httpx.AsyncClient, None]:
-        """Reusable generator for client handling."""
-        yield self._client
-
-    async def inject_client(self) -> AsyncGenerator[httpx.AsyncClient, None]:
-        return self._client_handler()
-
-    @asynccontextmanager
-    async def get_client(self) -> AsyncGenerator[httpx.AsyncClient, None]:
-        """
-        Async context manager for manual HTTP client handling.
-        Supports `async with HTTPClientManager.get() as client:`
-        """
-        async for client in self._client_handler():
-            yield client
-
-    @property
-    def client(self) -> httpx.AsyncClient:
-        return self._client
-
-    @property
-    def url(self) -> URL:
-        raise NotImplementedError()