maleo-foundation 0.1.42__tar.gz → 0.1.44__tar.gz

{maleo_foundation-0.1.42 → maleo_foundation-0.1.44}/PKG-INFO

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

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

@@ -0,0 +1,42 @@
+from maleo_foundation.utils.logging import ClientLogger
+from maleo_foundation.managers.service import ServiceManager
+
+class ClientManager:
+    def __init__(
+        self,
+        key:str,
+        name:str,
+        service_manager:ServiceManager
+    ) -> None:
+        self._key = key
+        self._name = name
+        self._service_manager = service_manager
+        self._initialize_logger()
+        self._logger.info("Initializing client manager")
+
+    def _initialize_logger(self) -> None:
+        self._logger = ClientLogger(client_key=self._key, service_key=self._service_manager.configs.service.key, **self._service_manager.log_config.model_dump())
+
+    @property
+    def key(self) -> str:
+        return self._key
+
+    @property
+    def name(self) -> str:
+        return self._name
+
+    @property
+    def service_manager(self) -> ServiceManager:
+        return self._service_manager
+
+    @property
+    def logger(self) -> ClientLogger:
+        return self._logger
+
+    @property
+    def credentials(self):
+        raise NotImplementedError()
+
+    @property
+    def client(self):
+        raise NotImplementedError()

{maleo_foundation-0.1.42 → maleo_foundation-0.1.44}/maleo_foundation/managers/client/google/base.py

@@ -1,24 +1,19 @@
 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
+from maleo_foundation.managers.service import ServiceManager
 
 class GoogleClientManager(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,
+        service_manager:ServiceManager,
         credentials_path:BaseTypes.OptionalString=None
     ) -> None:
-        super().__init__(key, name, logs_dir, service_key, level, google_cloud_logging)
+        super().__init__(key, name, service_manager)
         credentials_path = credentials_path or os.getenv("GOOGLE_CREDENTIALS_PATH")
         try:
             if credentials_path is not None:

{maleo_foundation-0.1.42 → maleo_foundation-0.1.44}/maleo_foundation/managers/client/google/secret.py

@@ -2,31 +2,19 @@ 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 maleo_foundation.managers.service import ServiceManager
 from .base import GoogleClientManager
 
 class GoogleSecretManager(GoogleClientManager):
     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
+        service_manager:ServiceManager,
+        credentials_path:BaseTypes.OptionalString = None
     ) -> None:
         key = "google-secret-manager"
         name = "GoogleSecretManager"
-        super().__init__(
-            key=key,
-            name=name,
-            logs_dir=logs_dir,
-            service_key=service_key,
-            level=level,
-            google_cloud_logging=google_cloud_logging,
-            credentials_path=credentials_path
-        )
+        super().__init__(key, name, service_manager, credentials_path)
         self._client = secretmanager.SecretManagerServiceClient(credentials=self._credentials)
         self._logger.info("Client manager initialized successfully")
 

{maleo_foundation-0.1.42 → maleo_foundation-0.1.44}/maleo_foundation/managers/client/google/storage.py

@@ -1,33 +1,20 @@
 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 maleo_foundation.managers.service import ServiceManager
 from .base import GoogleClientManager
 
 class GoogleCloudStorage(GoogleClientManager):
     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
+        service_manager:ServiceManager,
+        credentials_path:BaseTypes.OptionalString = None,
+        bucket_name:BaseTypes.OptionalString = None
     ) -> None:
         key = "google-cloud-storage"
         name = "GoogleCloudStorage"
-        super().__init__(
-            key=key,
-            name=name,
-            logs_dir=logs_dir,
-            service_key=service_key,
-            level=level,
-            google_cloud_logging=google_cloud_logging,
-            credentials_path=credentials_path
-        )
+        super().__init__(key, name, service_manager, 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:

{maleo_foundation-0.1.42 → maleo_foundation-0.1.44}/maleo_foundation/managers/client/maleo.py

@@ -1,11 +1,10 @@
 import httpx
 from contextlib import asynccontextmanager
 from pydantic import BaseModel, Field
-from typing import AsyncGenerator, Optional
-from maleo_foundation.enums import BaseEnums
-from maleo_foundation.types import BaseTypes
-from maleo_foundation.utils.logging import GoogleCloudLogging, ClientLogger
+from typing import AsyncGenerator
+from maleo_foundation.utils.logging import ClientLogger
 from maleo_foundation.managers.client.base import ClientManager
+from maleo_foundation.managers.service import ServiceManager
 
 class URL(BaseModel):
     base:str = Field(..., description="Base URL")
@@ -93,13 +92,10 @@ class MaleoClientManager(ClientManager):
         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
+        url:str,
+        service_manager:ServiceManager
     ):
-        super().__init__(key, name, logs_dir, service_key, level, google_cloud_logging)
+        super().__init__(key, name, service_manager)
         self._url = url
 
     def _initialize_controllers(self) -> None:

{maleo_foundation-0.1.42 → maleo_foundation-0.1.44}/maleo_foundation/managers/db.py

@@ -1,11 +1,12 @@
 import os
 from contextlib import contextmanager
+from pydantic import BaseModel, Field, model_validator
 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
+from typing import Dict, Generator
 from maleo_foundation.types import BaseTypes
 from maleo_foundation.utils.logging import ServiceLogger
 
@@ -57,6 +58,26 @@ class SessionManager:
         self._logger.info("SessionManager disposed successfully")
         self._logger = None
 
+class DatabaseConfigurations(BaseModel):
+    username:str = Field("postgres", description="Database user's username")
+    password:str = Field(..., description="Database user's password")
+    host:str = Field(..., description="Database's host")
+    port:int = Field(5432, description="Database's port")
+    database:str = Field(..., description="Database")
+
+    @model_validator(mode='before')
+    @classmethod
+    def populate_password(cls, values:Dict):
+        env_value = os.getenv("DB_PASSWORD")
+        if env_value is None:
+            raise ValueError("'DB_PASSWORD' environmet variable must be set.")
+        values["password"] = env_value
+        return values
+
+    @property
+    def url(self) -> str:
+        return f"postgresql://{self.username}:{self.password}@{self.host}:{self.port}/{self.database}"
+
 class DatabaseManager:
     def __init__(
         self,

{maleo_foundation-0.1.42 → maleo_foundation-0.1.44}/maleo_foundation/managers/service.py

@@ -1,36 +1,24 @@
-import json
-import os
 from fastapi import FastAPI, APIRouter
 from fastapi.exceptions import RequestValidationError
 from starlette.exceptions import HTTPException
 from starlette.types import Lifespan, AppType
 from pydantic_settings import BaseSettings
-from pydantic import BaseModel, Field, model_validator
+from pydantic import BaseModel, Field
 from sqlalchemy import MetaData
-from typing import Dict, Optional, Type
+from typing import Optional
 from maleo_foundation.enums import BaseEnums
 from maleo_foundation.models.transfers.general.token import BaseTokenGeneralTransfers
 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.maleo import MaleoClientManager
-from maleo_foundation.managers.db import DatabaseManager
+from maleo_foundation.managers.db import DatabaseConfigurations, DatabaseManager
 from maleo_foundation.managers.middleware import MiddlewareConfigurations, BaseMiddlewareConfigurations, CORSMiddlewareConfigurations, GeneralMiddlewareConfigurations, MiddlewareLoggers, MiddlewareManager
 from maleo_foundation.middlewares.base import RequestProcessor
 from maleo_foundation.services.token import BaseTokenService
-from maleo_foundation.types import BaseTypes
 from maleo_foundation.utils.exceptions import BaseExceptions
 from maleo_foundation.utils.loaders.json import JSONLoader
 from maleo_foundation.utils.loaders.key import KeyLoader
 from maleo_foundation.utils.loaders.yaml import YAMLLoader
-from maleo_foundation.utils.logging import GoogleCloudLogging, ServiceLogger, MiddlewareLogger
-
-class LogConfig(BaseModel):
-    logs_dir:str = Field(..., description="Logs directory")
-    google_cloud_logging:GoogleCloudLogging = Field(..., description="Google cloud's logging")
-
-    class Config:
-        arbitrary_types_allowed=True
+from maleo_foundation.utils.logging import SimpleConfig, ServiceLogger, MiddlewareLogger
+from maleo_foundation.utils.mergers import BaseMergers
 
 class Settings(BaseSettings):
     ENVIRONMENT:BaseEnums.EnvironmentType = Field(..., description="Environment")
@@ -86,26 +74,6 @@ class ServiceConfigurations(BaseModel):
     host:str = Field(..., description="Service's host")
     port:int = Field(..., description="Service's port")
 
-class DatabaseConfigurations(BaseModel):
-    username:str = Field("postgres", description="Database user's username")
-    password:str = Field(..., description="Database user's password")
-    host:str = Field(..., description="Database's host")
-    port:int = Field(5432, description="Database's port")
-    database:str = Field(..., description="Database")
-
-    @model_validator(mode='before')
-    @classmethod
-    def populate_password(cls, values:Dict):
-        env_value = os.getenv("DB_PASSWORD")
-        if env_value is None:
-            raise ValueError("'DB_PASSWORD' environmet variable must be set.")
-        values["password"] = env_value
-        return values
-
-    @property
-    def url(self) -> str:
-        return f"postgresql://{self.username}:{self.password}@{self.host}:{self.port}/{self.database}"
-
 class RuntimeConfigurations(BaseModel):
     service:ServiceConfigurations = Field(..., description="Service's configurations")
     middleware:MiddlewareRuntimeConfigurations = Field(..., description="Middleware's runtime configurations")
@@ -180,71 +148,14 @@ class Loggers(BaseModel):
     class Config:
         arbitrary_types_allowed=True
 
-class GoogleClientManagers(BaseModel):
-    secret:GoogleSecretManager = Field(..., description="Google secret manager client manager")
-    storage:GoogleCloudStorage = Field(..., description="Google cloud storage client manager")
-
-    class Config:
-        arbitrary_types_allowed=True
-
-class MaleoClientManagerClasses(BaseModel):
-    metadata:Optional[Type[MaleoClientManager]] = Field(None, description="MaleoMetadata client manager")
-    security:Optional[Type[MaleoClientManager]] = Field(None, description="MaleoSecurity client manager")
-    storage:Optional[Type[MaleoClientManager]] = Field(None, description="MaleoStorage client manager")
-    identity:Optional[Type[MaleoClientManager]] = Field(None, description="MaleoIdentity client manager")
-    access:Optional[Type[MaleoClientManager]] = Field(None, description="MaleoAccess client manager")
-    soapie:Optional[Type[MaleoClientManager]] = Field(None, description="MaleoSOAPIE client manager")
-    fhir:Optional[Type[MaleoClientManager]] = Field(None, description="MaleoFHIR client manager")
-    dicom:Optional[Type[MaleoClientManager]] = Field(None, description="MaleoDICOM client manager")
-    scribe:Optional[Type[MaleoClientManager]] = Field(None, description="MaleoScribe client manager")
-    cds:Optional[Type[MaleoClientManager]] = Field(None, description="MaleoCDS client manager")
-    imaging:Optional[Type[MaleoClientManager]] = Field(None, description="MaleoImaging client manager")
-    mcu:Optional[Type[MaleoClientManager]] = Field(None, description="MaleoMCU client manager")
-
-    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 Config:
-        arbitrary_types_allowed=True
-
-class ClientManagers(BaseModel):
-    google:GoogleClientManagers = Field(..., description="Google client's managers")
-    maleo:MaleoClientManagers = Field(..., description="Maleo client's managers")
-
-    class Config:
-        arbitrary_types_allowed=True
-
 class ServiceManager:
     def __init__(
         self,
         db_metadata:MetaData,
-        base_dir:BaseTypes.OptionalString = None,
-        settings:Optional[Settings] = None,
-        google_cloud_logging:Optional[GoogleCloudLogging] = None,
-        maleo_client_manager_classes:Optional[MaleoClientManagerClasses] = None
+        log_config:SimpleConfig,
+        settings:Optional[Settings] = None
     ):
-        self._db_metadata = db_metadata
-
-        if base_dir is None:
-            self._base_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..")
-        else:
-            self._base_dir = base_dir
-
-        self._logs_dir = os.path.join(self._base_dir, "logs")
+        self._db_metadata = db_metadata #* Declare DB Metadata
 
         #* Initialize settings
         if settings is None:
@@ -252,42 +163,15 @@ class ServiceManager:
         else:
             self._settings = settings
 
-        #* Load configs
         self._load_configs()
-
-        #* Initialize google cloud logging
-        if google_cloud_logging is None:
-            self._google_cloud_logging = GoogleCloudLogging()
-        else:
-            self._google_cloud_logging = google_cloud_logging
-
-        self._log_config = LogConfig(
-            logs_dir=self._logs_dir,
-            google_cloud_logging=self._google_cloud_logging
-        )
-
+        self._log_config = log_config #* Declare log config
         self._initialize_loggers()
         self._load_credentials()
         self._parse_keys()
         self._initialize_db()
 
-        #* Initialize maleo client managers
-        if maleo_client_manager_classes is None:
-            self._maleo_client_manager_classes = MaleoClientManagerClasses()
-        else:
-            self._maleo_client_manager_classes = maleo_client_manager_classes
-        self._initialize_clients()
-
-    @property
-    def base_dir(self) -> str:
-        return self._base_dir
-
-    @property
-    def logs_dir(self) -> str:
-        return self._logs_dir
-    
     @property
-    def log_config(self) -> LogConfig:
+    def log_config(self) -> SimpleConfig:
         return self._log_config
 
     @property
@@ -299,7 +183,8 @@ class ServiceManager:
         self._static_configs = StaticConfigurations.model_validate(static_configurations)
         runtime_configurations = YAMLLoader.load(self._settings.RUNTIME_CONFIGURATIONS_PATH)
         self._runtime_configs = RuntimeConfigurations.model_validate(runtime_configurations)
-        self._configs = Configurations.model_validate(self._static_configs.model_dump() | self._runtime_configs.model_dump())
+        merged_configs = BaseMergers.deep_merge(self._static_configs.model_dump(), self._runtime_configs.model_dump())
+        self._configs = Configurations.model_validate(merged_configs)
 
     @property
     def configs(self) -> Configurations:
@@ -359,46 +244,6 @@ class ServiceManager:
     def database(self) -> DatabaseManager:
         return self._database
 
-    def _initialize_clients(self) -> None:
-        #* Initialize google clients
-        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 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(),
-                    service_key=self._configs.service.key
-                )
-                setattr(self._maleo_clients, client, client_instance)
-        self._clients = ClientManagers(google=self._google_clients, maleo=self._maleo_clients)
-
-    @property
-    def google_clients(self) -> GoogleClientManagers:
-        return self._google_clients
-
-    @property
-    def maleo_clients(self) -> MaleoClientManagers:
-        return self._maleo_clients
-
-    @property
-    def clients(self) -> ClientManagers:
-        return self._clients
-
     @property
     def token(self) -> str:
         payload = BaseTokenGeneralTransfers.BaseEncodePayload(
@@ -453,10 +298,6 @@ class ServiceManager:
         if self._clients is not None:
             self._clients.google.storage.dispose()
             self._clients.google.secret.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):
-                    await client_instance.dispose()
         self._loggers.application.info("Service manager disposed successfully")
         if self._loggers is not None:
             self._loggers.application.info("Disposing logger")

{maleo_foundation-0.1.42 → maleo_foundation-0.1.44}/maleo_foundation/utils/__init__.py

@@ -3,6 +3,7 @@ from .formatter import BaseFormatter
 from .exceptions import BaseExceptions
 from .extractor import BaseExtractors
 from .loaders import BaseLoaders
+from .mergers import BaseMergers
 from .controller import BaseControllerUtils
 from .query import BaseQueryUtils
 
@@ -11,5 +12,6 @@ class BaseUtils:
     Exceptions = BaseExceptions
     Extractors = BaseExtractors
     Loaders = BaseLoaders
+    Mergers = BaseMergers
     Controller = BaseControllerUtils
     Query = BaseQueryUtils

{maleo_foundation-0.1.42 → maleo_foundation-0.1.44}/maleo_foundation/utils/logging.py

@@ -5,6 +5,7 @@ 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 pydantic import BaseModel, Field
 from typing import Optional
 from maleo_foundation.enums import BaseEnums
 from maleo_foundation.types import BaseTypes
@@ -39,10 +40,15 @@ class GoogleCloudLogging:
     def create_handler(self, name:str) -> CloudLoggingHandler:
         return CloudLoggingHandler(client=self._client, name=name)
 
+class SimpleConfig(BaseModel):
+    dir:str = Field(..., description="Log's directory")
+    level:BaseEnums.LoggerLevel = Field(BaseEnums.LoggerLevel.INFO, description="Log's level")
+    google_cloud_logging:GoogleCloudLogging = Field(default_factory=GoogleCloudLogging, description="Google cloud logging")
+
 class BaseLogger(logging.Logger):
     def __init__(
         self,
-        logs_dir:str,
+        dir:str,
         type:BaseEnums.LoggerType,
         service_key:BaseTypes.OptionalString = None,
         middleware_type:Optional[BaseEnums.MiddlewareLoggerType] = None,
@@ -50,17 +56,6 @@ class BaseLogger(logging.Logger):
         level:BaseEnums.LoggerLevel = BaseEnums.LoggerLevel.INFO,
         google_cloud_logging:Optional[GoogleCloudLogging] = None
     ):
-        """
-        Custom extended logger with file, console, and Google Cloud Logging.
-
-        - Logs are stored in `logs_dir/logs/{type}`
-        - Uses Google Cloud Logging if configured
-
-        Args:
-            logs_dir (str): Base directory for logs (e.g., "/path/to/service")
-            type (str): Log type (e.g., "application", "middleware")
-            service_key (str): The service name (e.g., "service")
-        """
         self._type = type #* Declare logger type
 
         #* Ensure service_key exists
@@ -122,7 +117,7 @@ class BaseLogger(logging.Logger):
             log_dir = f"{self._type}/{self._client_key}"
         else:
             log_dir = f"{self._type}"
-        self._log_dir = os.path.join(logs_dir, log_dir)
+        self._log_dir = os.path.join(dir, log_dir)
         os.makedirs(self._log_dir, exist_ok=True)
 
         #* Generate timestamped filename
@@ -164,14 +159,14 @@ class BaseLogger(logging.Logger):
 class MiddlewareLogger(BaseLogger):
     def __init__(
         self,
-        logs_dir:str,
+        dir:str,
         service_key:BaseTypes.OptionalString = None,
         middleware_type = None,
         level = BaseEnums.LoggerLevel.INFO,
         google_cloud_logging = None
     ):
         super().__init__(
-            logs_dir=logs_dir,
+            dir=dir,
             type=BaseEnums.LoggerType.MIDDLEWARE,
             service_key=service_key,
             middleware_type=middleware_type,
@@ -183,14 +178,14 @@ class MiddlewareLogger(BaseLogger):
 class ServiceLogger(BaseLogger):
     def __init__(
         self,
-        logs_dir:str,
+        dir:str,
         type:BaseEnums.ServiceLoggerType,
         service_key:BaseTypes.OptionalString = None,
         level:BaseEnums.LoggerLevel = BaseEnums.LoggerLevel.INFO,
         google_cloud_logging:Optional[GoogleCloudLogging] = None
     ):
         super().__init__(
-            logs_dir=logs_dir,
+            dir=dir,
             type=type,
             service_key=service_key,
             middleware_type=None,
@@ -202,41 +197,18 @@ class ServiceLogger(BaseLogger):
 class ClientLogger(BaseLogger):
     def __init__(
         self,
-        logs_dir:str,
+        dir:str,
         client_key:str,
         service_key:BaseTypes.OptionalString = None,
         level:BaseEnums.LoggerLevel = BaseEnums.LoggerLevel.INFO,
         google_cloud_logging:Optional[GoogleCloudLogging] = None
     ):
         super().__init__(
-            logs_dir=logs_dir,
+            dir=dir,
             type=BaseEnums.LoggerType.CLIENT,
             service_key=service_key,
             middleware_type=None,
             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.1.44/maleo_foundation/utils/mergers.py

@@ -0,0 +1,23 @@
+from collections.abc import Mapping
+from typing import Dict
+
+class BaseMergers:
+    @staticmethod
+    def deep_merge(*obj:Dict) -> Dict:
+        def merge_dicts(a:Dict, b:Dict) -> Dict:
+            result = dict(a)
+            for key, value in b.items():
+                if (
+                    key in result
+                    and isinstance(result[key], Mapping)
+                    and isinstance(value, Mapping)
+                ):
+                    result[key] = merge_dicts(result[key], value)
+                else:
+                    result[key] = value
+            return result
+
+        merged = {}
+        for ob in obj:
+            merged = merge_dicts(merged, ob)
+        return merged

{maleo_foundation-0.1.42 → maleo_foundation-0.1.44}/maleo_foundation.egg-info/PKG-INFO

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

{maleo_foundation-0.1.42 → maleo_foundation-0.1.44}/maleo_foundation.egg-info/SOURCES.txt

@@ -66,6 +66,7 @@ maleo_foundation/utils/controller.py
 maleo_foundation/utils/exceptions.py
 maleo_foundation/utils/extractor.py
 maleo_foundation/utils/logging.py
+maleo_foundation/utils/mergers.py
 maleo_foundation/utils/query.py
 maleo_foundation/utils/formatter/__init__.py
 maleo_foundation/utils/formatter/case.py

{maleo_foundation-0.1.42 → maleo_foundation-0.1.44}/pyproject.toml

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

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

@@ -1,52 +0,0 @@
-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()