maleo-foundation 0.0.100__tar.gz → 0.1.2__tar.gz

{maleo_foundation-0.0.100 → maleo_foundation-0.1.2}/PKG-INFO

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

maleo_foundation-0.1.2/maleo_foundation/clients/utils/logger.py

@@ -0,0 +1,54 @@
+# 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-0.0.100 → maleo_foundation-0.1.2}/maleo_foundation/managers/client/base.py

@@ -21,7 +21,7 @@ class ClientManager:
         return self._name
 
     @property
-    def logger(self):
+    def logger(self) -> ClientLogger:
         return self._logger
 
     @property

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

@@ -0,0 +1,82 @@
+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(..., "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()

maleo_foundation-0.1.2/maleo_foundation/managers/client/maleo.py

@@ -0,0 +1,112 @@
+import httpx
+from contextlib import asynccontextmanager
+from pydantic import BaseModel, Field
+from typing import AsyncGenerator
+from maleo_foundation.types import BaseTypes
+from maleo_foundation.utils.logging import ClientLogger
+from maleo_foundation.managers.client.base import ClientManager
+
+class URL(BaseModel):
+    base:str = Field(..., "Base URL")
+
+    @property
+    def api(self) -> str:
+        return f"{self.base}/api"
+
+class HTTPClientControllerManager:
+    def __init__(self, base_url:str) -> None:
+        self._client = httpx.AsyncClient()
+        self._url = URL(base=base_url)
+
+    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:
+        return self._url
+
+class ClientControllerManagers(BaseModel):
+    http:HTTPClientControllerManager = Field(..., description="HTTP Client Controller")
+
+    class Config:
+        arbitrary_types_allowed=True
+
+class HTTPClientController:
+    def __init__(self, manager:HTTPClientControllerManager):
+        self._manager = manager
+
+    @property
+    def manager(self) -> HTTPClientControllerManager:
+        return self._manager
+
+class ClientServiceControllers(BaseModel):
+    http:HTTPClientController = Field(..., description="HTTP Client Controller")
+
+    class Config:
+        arbitrary_types_allowed=True
+
+class ClientControllers(BaseModel):
+    #* Reuse this class while also adding all controllers of the client
+    class Config:
+        arbitrary_types_allowed=True
+
+class ClientService:
+    def __init__(self, controllers:ClientServiceControllers, logger:ClientLogger):
+        self._controllers = controllers
+        self._logger = logger
+
+    @property
+    def controllers(self) -> ClientServiceControllers:
+        return self._controllers
+
+    @property
+    def logger(self) -> ClientLogger:
+        return self._logger
+
+class ClientServices(BaseModel):
+    #* Reuse this class while also adding all the services of the client
+    class Config:
+        arbitrary_types_allowed=True
+
+class MaleoClientManager(ClientManager):
+    def __init__(self, key, name, logs_dir, google_cloud_logging = None, base_url:BaseTypes.OptionalString = None):
+        super().__init__(key, name, logs_dir, google_cloud_logging)
+        self._base_url = base_url
+
+    def _initialize_controllers(self) -> None:
+        #* Initialize managers
+        http_controller_manager = HTTPClientControllerManager(base_url=self._base_url)
+        self._controller_managers = ClientControllerManagers(http=http_controller_manager)
+        #* Initialize controllers
+        #! This initialied an empty controllers. Extend this function in the actual class to initialize all controllers.
+        self._controllers = ClientControllers()
+
+    @property
+    def controllers(self) -> ClientControllers:
+        raise self._controllers
+
+    def _initialize_services(self) -> None:
+        #* Initialize services
+        #! This initialied an empty services. Extend this function in the actual class to initialize all services.
+        self._services = ClientServices()
+
+    @property
+    def services(self) -> ClientServices:
+        return self._services

{maleo_foundation-0.0.100 → maleo_foundation-0.1.2}/maleo_foundation/managers/service.py

@@ -11,11 +11,12 @@ from maleo_foundation.models.transfers.parameters.token import BaseTokenParamete
 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.services.token import BaseTokenService
 from maleo_foundation.types import BaseTypes
 from maleo_foundation.utils.keyloader import load_key
-from maleo_foundation.utils.logging import GoogleCloudLogging, ServiceLogger
+from maleo_foundation.utils.logging import GoogleCloudLogging, ServiceLogger, ClientLoggerManager
 
 class Settings(BaseSettings):
     GOOGLE_CREDENTIALS_PATH:str = Field("/creds/maleo-google-service-account.json", description="Internal credential's file path")
@@ -84,10 +85,13 @@ class Configurations(BaseModel):
     class Config:
         arbitrary_types_allowed=True
 
+ClientLoggerManagers = Dict[str, ClientLoggerManager]
+
 class Loggers(BaseModel):
     application:ServiceLogger = Field(..., description="Application logger")
     database:ServiceLogger = Field(..., description="Database logger")
     middleware:ServiceLogger = Field(..., description="Middleware logger")
+    client:ClientLoggerManagers = Field(default_factory=dict, description="Client logger manager")
 
     class Config:
         arbitrary_types_allowed=True
@@ -99,9 +103,24 @@ class GoogleClientManagers(BaseModel):
     class Config:
         arbitrary_types_allowed=True
 
+class MaleoClientManagers(BaseModel):
+    metadata:Optional[MaleoClientManager] = Field(None, description="MaleoMetadata client manager")
+    security:Optional[MaleoClientManager] = Field(None, description="MaleoSecurity client manager")
+    storage:Optional[MaleoClientManager] = Field(None, description="MaleoStorage client manager")
+    identity:Optional[MaleoClientManager] = Field(None, description="MaleoIdentity client manager")
+    access:Optional[MaleoClientManager] = Field(None, description="MaleoAccess client manager")
+    soapie:Optional[MaleoClientManager] = Field(None, description="MaleoSOAPIE client manager")
+    fhir:Optional[MaleoClientManager] = Field(None, description="MaleoFHIR client manager")
+    dicom:Optional[MaleoClientManager] = Field(None, description="MaleoDICOM client manager")
+    scribe:Optional[MaleoClientManager] = Field(None, description="MaleoScribe client manager")
+    cds:Optional[MaleoClientManager] = Field(None, description="MaleoCDS client manager")
+    imaging:Optional[MaleoClientManager] = Field(None, description="MaleoImaging client manager")
+    mcu:Optional[MaleoClientManager] = Field(None, description="MaleoMCU client manager")
+
 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:
         arbitrary_types_allowed=True
@@ -112,7 +131,9 @@ class ServiceManager:
         db_metadata:MetaData,
         base_dir:BaseTypes.OptionalString = None,
         settings:Optional[Settings] = None,
-        google_cloud_logging:Optional[GoogleCloudLogging] = None
+        google_cloud_logging:Optional[GoogleCloudLogging] = None,
+        client_logger_managers:ClientLoggerManagers = {},
+        maleo_client_managers:Optional[MaleoClientManagers] = None
     ):
         self._db_metadata = db_metadata
 
@@ -138,10 +159,17 @@ class ServiceManager:
         else:
             self._google_cloud_logging = google_cloud_logging
 
+        self._client_logger_managers = client_logger_managers
         self._initialize_loggers()
         self._load_credentials()
         self._parse_keys()
         self._initialize_db()
+
+        #* Initialize maleo client managers
+        if maleo_client_managers is None:
+            self._maleo_client_managers = MaleoClientManagers()
+        else:
+            self._maleo_client_managers = maleo_client_managers
         self._initialize_clients()
 
     @property
@@ -169,7 +197,11 @@ class ServiceManager:
         application = ServiceLogger(logs_dir=self._logs_dir, type=BaseEnums.LoggerType.APPLICATION, google_cloud_logging=self._google_cloud_logging)
         database = ServiceLogger(logs_dir=self._logs_dir, type=BaseEnums.LoggerType.DATABASE, google_cloud_logging=self._google_cloud_logging)
         middleware = ServiceLogger(logs_dir=self._logs_dir, type=BaseEnums.LoggerType.MIDDLEWARE, google_cloud_logging=self._google_cloud_logging)
-        self._loggers = Loggers(application=application, database=database, middleware=middleware)
+        client = self._client_logger_managers
+        for key, logger_manager in client.items():
+            application.info(f"Initializing logger manager for client '{key}'")
+            logger_manager.initialize(logs_dir=self._logs_dir ,client_key=key)
+        self._loggers = Loggers(application=application, database=database, middleware=middleware, client=client)
 
     @property
     def loggers(self) -> Loggers:
@@ -225,7 +257,7 @@ class ServiceManager:
         #* Initialize http clients
         self._http_client = HTTPClientManager
         self._http_client.initialize()
-        self._clients = ClientManagers(google=self._google_clients, http=self._http_client)
+        self._clients = ClientManagers(google=self._google_clients, http=self._http_client, maleo=self._maleo_client_managers)
 
     @property
     def google_clients(self) -> GoogleClientManagers:
@@ -258,6 +290,7 @@ class ServiceManager:
         return result.data.token
 
     async def dispose(self) -> None:
+        self._loggers.application.info("Disposing service manager")
         if self._database is not None:
             self._database.dispose()
             self._database = None

{maleo_foundation-0.0.100 → maleo_foundation-0.1.2}/maleo_foundation/services/token.py

@@ -1,8 +1,6 @@
 import jwt
 from cryptography.hazmat.primitives import serialization
 from cryptography.hazmat.backends import default_backend
-# from maleo_foundation.clients.utils.logger import MaleoFoundationLoggerManager
-# from maleo_foundation.utils.exceptions import BaseExceptions
 from maleo_foundation.models.transfers.general.token import BaseTokenGeneralTransfers
 from maleo_foundation.models.schemas.token import BaseTokenSchemas
 from maleo_foundation.models.transfers.parameters.token import BaseTokenParametersTransfers
@@ -11,11 +9,6 @@ from maleo_foundation.expanded_types.token import BaseTokenResultsTypes
 
 class BaseTokenService:
     @staticmethod
-    # @BaseExceptions.service_exception_handler(
-    #     operation="encoding a payload",
-    #     logger_factory=MaleoFoundationLoggerManager.get,
-    #     fail_result_class=BaseTokenResultsTransfers.Fail
-    # )
     def encode(parameters:BaseTokenParametersTransfers.Encode) -> BaseTokenResultsTypes.Encode:
         #* Serialize private key
         private_key_bytes = parameters.key.encode()
@@ -27,17 +20,10 @@ class BaseTokenService:
         payload = BaseTokenGeneralTransfers.EncodePayload.model_validate(parameters.payload.model_dump()).model_dump(mode="json")
         token = jwt.encode(payload=payload, key=private_key, algorithm="RS256")
         data = BaseTokenSchemas.Token(token=token)
-        # MaleoFoundationLoggerManager.get().info("Payload successfully encoded")
         return BaseTokenResultsTransfers.Encode(data=data)
 
     @staticmethod
-    # @BaseExceptions.service_exception_handler(
-    #     operation="decoding a token",
-    #     logger_factory=MaleoFoundationLoggerManager.get,
-    #     fail_result_class=BaseTokenResultsTransfers.Fail
-    # )
     def decode(parameters:BaseTokenParametersTransfers.Decode) -> BaseTokenResultsTypes.Decode:
         payload = jwt.decode(jwt=parameters.token, key=parameters.key, algorithms=["RS256"])
         data = BaseTokenGeneralTransfers.DecodePayload.model_validate(payload)
-        # MaleoFoundationLoggerManager.get().info("Token successfully decoded")
         return BaseTokenResultsTransfers.Decode(data=data)

{maleo_foundation-0.0.100 → maleo_foundation-0.1.2}/maleo_foundation/utils/logging.py

@@ -179,4 +179,27 @@ class ClientLogger(BaseLogger):
             client_key=client_key,
             level=level,
             google_cloud_logging=google_cloud_logging
-        )
+        )
+
+class ClientLoggerManager:
+    _logger:Optional[ClientLogger] = None
+
+    @classmethod
+    def initialize(
+        cls,
+        logs_dir:str,
+        client_key:str,
+        service_key:BaseTypes.OptionalString = None,
+        level:BaseEnums.LoggerLevel = BaseEnums.LoggerLevel.INFO,
+        google_cloud_logging:Optional[GoogleCloudLogging] = None
+    ) -> None:
+        """Initialize client logger if not already initialized."""
+        if cls._logger is None:
+            cls.logger = ClientLogger(logs_dir=logs_dir, client_key=client_key, service_key=service_key, level=level, google_cloud_logging=google_cloud_logging)
+
+    @classmethod
+    def get(cls) -> ClientLogger:
+        """Return client logger (if exist) or raise Runtime Error"""
+        if cls._logger is None:
+            raise RuntimeError("Logger has not been initialized. Initialize it first.")
+        return cls._logger

{maleo_foundation-0.0.100 → maleo_foundation-0.1.2}/maleo_foundation.egg-info/PKG-INFO

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

{maleo_foundation-0.0.100 → maleo_foundation-0.1.2}/maleo_foundation.egg-info/SOURCES.txt

@@ -41,6 +41,7 @@ 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/managers/client/google/secret.py

{maleo_foundation-0.0.100 → maleo_foundation-0.1.2}/pyproject.toml

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

maleo_foundation-0.0.100/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-0.0.100/maleo_foundation/managers/client/http.py

@@ -1,40 +0,0 @@
-import httpx
-from contextlib import asynccontextmanager
-from typing import AsyncGenerator, Optional
-
-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
-    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