maleo-foundation 0.1.52__tar.gz → 0.1.54__tar.gz

{maleo_foundation-0.1.52 → maleo_foundation-0.1.54}/PKG-INFO

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

maleo_foundation-0.1.54/maleo_foundation/client/manager.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+from maleo_foundation.managers.client.base import ClientManager
+from maleo_foundation.types import BaseTypes
+from maleo_foundation.utils.logging import SimpleConfig
+from maleo_foundation.client.services import (
+    MaleoFoundationTokenClientService,
+    MaleoFoundationServices
+)
+
+class MaleoFoundationClientManager(ClientManager):
+    def __init__(self, log_config:SimpleConfig, service_key:BaseTypes.OptionalString=None):
+        key = "maleo-foundation"
+        name = "MaleoFoundation"
+        super().__init__(key, name, log_config, service_key)
+        self._initialize_services()
+        self._logger.info("Client manager initialized successfully")
+
+    def _initialize_services(self):
+        super()._initialize_services()
+        token_service = MaleoFoundationTokenClientService(logger=self._logger)
+        self._services = MaleoFoundationServices(
+            token=token_service,
+        )
+
+    @property
+    def services(self) -> MaleoFoundationServices:
+        return self._services

maleo_foundation-0.1.54/maleo_foundation/client/services/__init__.py

@@ -0,0 +1,7 @@
+from __future__ import annotations
+from pydantic import Field
+from maleo_foundation.managers.client.base import ClientServices
+from maleo_foundation.client.services.token import MaleoFoundationTokenClientService
+
+class MaleoFoundationServices(ClientServices):
+    token:MaleoFoundationTokenClientService = Field(..., description="Token's service")

maleo_foundation-0.1.54/maleo_foundation/client/services/token.py

@@ -0,0 +1,34 @@
+import jwt
+from maleo_foundation.models.schemas.token import BaseTokenSchemas
+from maleo_foundation.models.transfers.general.token import BaseTokenGeneralTransfers
+from maleo_foundation.models.transfers.parameters.token import BaseTokenParametersTransfers
+from maleo_foundation.models.transfers.results.token import BaseTokenResultsTransfers
+from maleo_foundation.expanded_types.token import BaseTokenResultsTypes
+from maleo_foundation.managers.client.base import ClientService
+from maleo_foundation.utils.exceptions import BaseExceptions
+
+class MaleoFoundationTokenClientService(ClientService):
+    def encode(self, parameters:BaseTokenParametersTransfers.Encode) -> BaseTokenResultsTypes.Encode:
+        @BaseExceptions.service_exception_handler(
+            operation="encoding a payload into a token",
+            logger=self._logger,
+            fail_result_class=BaseTokenResultsTransfers.Fail
+        )
+        def _impl():
+            payload = BaseTokenGeneralTransfers.EncodePayload.model_validate(parameters.payload.model_dump()).model_dump(mode="json")
+            token = jwt.encode(payload=payload, key=parameters.key, algorithm="RS256")
+            data = BaseTokenSchemas.Token(token=token)
+            return BaseTokenResultsTransfers.Encode(data=data)
+        return _impl()
+
+    def decode(self, parameters:BaseTokenParametersTransfers.Decode) -> BaseTokenResultsTypes.Decode:
+        @BaseExceptions.service_exception_handler(
+            operation="decoding a token into a payload",
+            logger=self._logger,
+            fail_result_class=BaseTokenResultsTransfers.Fail
+        )
+        def _impl():
+            payload = jwt.decode(jwt=parameters.token, key=parameters.key, algorithms=["RS256"])
+            data = BaseTokenGeneralTransfers.DecodePayload.model_validate(payload)
+            return BaseTokenResultsTransfers.Decode(data=data)
+        return _impl()

maleo_foundation-0.1.52/maleo_foundation/managers/client/maleo.py → maleo_foundation-0.1.54/maleo_foundation/managers/client/base.py

@@ -2,8 +2,8 @@ import httpx
 from contextlib import asynccontextmanager
 from pydantic import BaseModel, Field
 from typing import AsyncGenerator
-from maleo_foundation.utils.logging import ClientLogger
-from maleo_foundation.managers.client.base import ClientManager
+from maleo_foundation.types import BaseTypes
+from maleo_foundation.utils.logging import ClientLogger, SimpleConfig
 from maleo_foundation.managers.service import ServiceManager
 
 class URL(BaseModel):
@@ -20,6 +20,8 @@ class ClientHTTPControllerManager:
 
     async def _client_handler(self) -> AsyncGenerator[httpx.AsyncClient, None]:
         """Reusable generator for client handling."""
+        if self._client is None or (self._client is not None and self._client.is_closed):
+            self._client = httpx.AsyncClient()
         yield self._client
 
     async def inject_client(self) -> AsyncGenerator[httpx.AsyncClient, None]:
@@ -92,28 +94,35 @@ class ClientServices(BaseModel):
     class Config:
         arbitrary_types_allowed=True
 
-class MaleoClientManager(ClientManager):
+class ClientManager:
     def __init__(
         self,
         key:str,
         name:str,
-        url:str,
-        service_manager:ServiceManager
-    ):
-        super().__init__(key, name, service_manager)
-        self._url = url
-
-    def _initialize_controllers(self) -> None:
-        #* Initialize managers
-        http_controller_manager = ClientHTTPControllerManager(url=self._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()
+        log_config:SimpleConfig,
+        service_key:BaseTypes.OptionalString=None
+    ) -> None:
+        self._key = key
+        self._name = name
+        self._log_config = log_config
+        self._service_key = service_key
+        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_key, **self._log_config.model_dump())
 
     @property
-    def controllers(self) -> ClientControllers:
-        return self._controllers
+    def key(self) -> str:
+        return self._key
+
+    @property
+    def name(self) -> str:
+        return self._name
+
+    @property
+    def logger(self) -> ClientLogger:
+        return self._logger
 
     def _initialize_services(self) -> None:
         #* Initialize services
@@ -124,7 +133,10 @@ class MaleoClientManager(ClientManager):
     def services(self) -> ClientServices:
         return self._services
 
-    async def dispose(self) -> None:
-        self._logger.info("Disposing client manager")
-        await self._controller_managers.http.dispose()
-        self._logger.info("Client manager disposed successfully")
+    @property
+    def credentials(self):
+        raise NotImplementedError()
+
+    @property
+    def client(self):
+        raise NotImplementedError()

{maleo_foundation-0.1.52 → maleo_foundation-0.1.54}/maleo_foundation/managers/client/google/base.py

@@ -3,17 +3,18 @@ from google.auth import default
 from google.oauth2 import service_account
 from maleo_foundation.types import BaseTypes
 from maleo_foundation.managers.client.base import ClientManager
-from maleo_foundation.managers.service import ServiceManager
+from maleo_foundation.utils.logging import SimpleConfig
 
 class GoogleClientManager(ClientManager):
     def __init__(
         self,
         key:str,
         name:str,
-        service_manager:ServiceManager,
+        log_config:SimpleConfig,
+        service_key:BaseTypes.OptionalString=None,
         credentials_path:BaseTypes.OptionalString=None
     ) -> None:
-        super().__init__(key, name, service_manager)
+        super().__init__(key, name, log_config, service_key)
         credentials_path = credentials_path or os.getenv("GOOGLE_CREDENTIALS_PATH")
         try:
             if credentials_path is not None:

{maleo_foundation-0.1.52 → maleo_foundation-0.1.54}/maleo_foundation/managers/client/google/secret.py

@@ -3,18 +3,19 @@ from google.api_core.exceptions import NotFound
 from google.cloud import secretmanager
 from typing import Optional
 from maleo_foundation.types import BaseTypes
-from maleo_foundation.managers.service import ServiceManager
+from maleo_foundation.utils.logging import SimpleConfig
 from .base import GoogleClientManager
 
 class GoogleSecretManager(GoogleClientManager):
     def __init__(
         self,
-        service_manager:ServiceManager,
+        log_config:SimpleConfig,
+        service_key:BaseTypes.OptionalString=None,
         credentials_path:BaseTypes.OptionalString = None
     ) -> None:
         key = "google-secret-manager"
         name = "GoogleSecretManager"
-        super().__init__(key, name, service_manager, credentials_path)
+        super().__init__(key, name, log_config, service_key, credentials_path)
         self._client = secretmanager.SecretManagerServiceClient(credentials=self._credentials)
         self._logger.info("Client manager initialized successfully")
 

{maleo_foundation-0.1.52 → maleo_foundation-0.1.54}/maleo_foundation/managers/client/google/storage.py

@@ -2,19 +2,20 @@ import os
 from datetime import timedelta
 from google.cloud.storage import Bucket, Client
 from maleo_foundation.types import BaseTypes
-from maleo_foundation.managers.service import ServiceManager
+from maleo_foundation.utils.logging import SimpleConfig
 from .base import GoogleClientManager
 
 class GoogleCloudStorage(GoogleClientManager):
     def __init__(
         self,
-        service_manager:ServiceManager,
+        log_config:SimpleConfig,
+        service_key:BaseTypes.OptionalString=None,
         credentials_path:BaseTypes.OptionalString = None,
         bucket_name:BaseTypes.OptionalString = None
     ) -> None:
         key = "google-cloud-storage"
         name = "GoogleCloudStorage"
-        super().__init__(key, name, service_manager, credentials_path)
+        super().__init__(key, name, log_config, service_key, 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.54/maleo_foundation/managers/client/maleo.py

@@ -0,0 +1,30 @@
+from maleo_foundation.managers.client.base import ClientManager, ClientHTTPControllerManager, ClientControllerManagers, ClientControllers, ClientServices
+from maleo_foundation.managers.service import ServiceManager
+
+class MaleoClientManager(ClientManager):
+    def __init__(
+        self,
+        key:str,
+        name:str,
+        url:str,
+        service_manager:ServiceManager
+    ):
+        super().__init__(key, name, service_manager)
+        self._url = url
+
+    def _initialize_controllers(self) -> None:
+        #* Initialize managers
+        http_controller_manager = ClientHTTPControllerManager(url=self._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:
+        return self._controllers
+
+    async def dispose(self) -> None:
+        self._logger.info("Disposing client manager")
+        await self._controller_managers.http.dispose()
+        self._logger.info("Client manager disposed successfully")

{maleo_foundation-0.1.52 → maleo_foundation-0.1.54}/maleo_foundation/managers/db.py

@@ -65,15 +65,6 @@ class DatabaseConfigurations(BaseModel):
     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}"

{maleo_foundation-0.1.52 → maleo_foundation-0.1.54}/maleo_foundation/managers/service.py

@@ -6,16 +6,17 @@ from pydantic_settings import BaseSettings
 from pydantic import BaseModel, Field
 from sqlalchemy import MetaData
 from typing import Optional
+from maleo_foundation.client.manager import MaleoFoundationClientManager
 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.db import DatabaseConfigurations, DatabaseManager
+from maleo_foundation.managers.client.google.secret import GoogleSecretManager
+from maleo_foundation.managers.client.google.storage import GoogleCloudStorage
 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.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 SimpleConfig, ServiceLogger, MiddlewareLogger
 from maleo_foundation.utils.mergers import BaseMergers
@@ -24,12 +25,8 @@ class Settings(BaseSettings):
     ENVIRONMENT:BaseEnums.EnvironmentType = Field(..., description="Environment")
     GOOGLE_CREDENTIALS_PATH:str = Field("credentials/maleo-google-service-account.json", description="Internal credential's file path")
     INTERNAL_CREDENTIALS_PATH:str = Field("credentials/maleo-internal-service-account.json", description="Internal credential's file path")
-    PRIVATE_KEY_PATH:str = Field("keys/maleo-private-key.pem", description="Maleo's private key path")
-    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")
     STATIC_CONFIGURATIONS_PATH:str = Field("configs/static.yaml", description="Maleo's static configurations path")
     RUNTIME_CONFIGURATIONS_PATH:str = Field("configs/runtime.yaml", description="Service's runtime configurations path")
-    DB_PASSWORD:str = Field(..., description="Database's password")
 
 class Keys(BaseModel):
     password:str = Field(..., description="Key's password")
@@ -77,7 +74,7 @@ class ServiceConfigurations(BaseModel):
 class RuntimeConfigurations(BaseModel):
     service:ServiceConfigurations = Field(..., description="Service's configurations")
     middleware:MiddlewareRuntimeConfigurations = Field(..., description="Middleware's runtime configurations")
-    database:DatabaseConfigurations = Field(..., description="Database's configurations")
+    database:str = Field(..., description="Database's name")
 
     class Config:
         arbitrary_types_allowed=True
@@ -148,6 +145,26 @@ class Loggers(BaseModel):
     class Config:
         arbitrary_types_allowed=True
 
+class GoogleClientManagers(BaseModel):
+    secret:GoogleSecretManager = Field(..., description="Google secret manager's client manager")
+    storage:GoogleCloudStorage = Field(..., description="Google cloud storage's client manager")
+
+    class Config:
+        arbitrary_types_allowed=True
+
+class MaleoClientManagers(BaseModel):
+    foundation:MaleoFoundationClientManager = Field(..., description="MaleoFoundation's client manager")
+
+    class Config:
+        arbitrary_types_allowed=True
+
+class ClientManagers(BaseModel):
+    google:GoogleClientManagers = Field(..., description="Google's client managers")
+    maleo:MaleoClientManagers = Field(..., description="Maleo's client managers")
+
+    class Config:
+        arbitrary_types_allowed=True
+
 class ServiceManager:
     def __init__(
         self,
@@ -156,19 +173,21 @@ class ServiceManager:
         settings:Optional[Settings] = None
     ):
         self._db_metadata = db_metadata #* Declare DB Metadata
-
-        #* Initialize settings
-        if settings is None:
-            self._settings = Settings()
-        else:
-            self._settings = settings
-
-        self._load_configs()
         self._log_config = log_config #* Declare log config
-        self._initialize_loggers()
+        self._settings = settings if settings is not None else Settings() #* Initialize settings
+        #* Disable google cloud logging if environment is local
+        if self._settings.ENVIRONMENT == "local":
+            self._log_config.google_cloud_logging = None
         self._load_credentials()
-        self._parse_keys()
+        self._load_configs()
+        self._initialize_secret_manager()
+        #* Declare environment for configurations and client
+        environment = BaseEnums.EnvironmentType.STAGING if self._settings.ENVIRONMENT == BaseEnums.EnvironmentType.LOCAL else self._settings.ENVIRONMENT
+        self._initialize_configs(environment=environment)
+        self._initialize_keys()
+        self._initialize_loggers()
         self._initialize_db()
+        self._initialize_clients(environment=environment)
 
     @property
     def log_config(self) -> SimpleConfig:
@@ -178,18 +197,53 @@ class ServiceManager:
     def settings(self) -> Settings:
         return self._settings
 
+    def _load_credentials(self) -> None:
+        #* Load google credentials
+        data = JSONLoader.load(self._settings.GOOGLE_CREDENTIALS_PATH)
+        google = GoogleCredentials.model_validate(data)
+        #* Load internal credentials
+        data = JSONLoader.load(self._settings.INTERNAL_CREDENTIALS_PATH)
+        internal = InternalCredentials.model_validate(data)
+        self._credentials = Credentials(google=google, internal=internal)
+
+    @property
+    def credentials(self) -> Credentials:
+        return self._credentials
+
     def _load_configs(self) -> None:
         static_configurations = YAMLLoader.load(self._settings.STATIC_CONFIGURATIONS_PATH)
         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)
-        merged_configs = BaseMergers.deep_merge(self._static_configs.model_dump(), self._runtime_configs.model_dump())
+
+    def _initialize_secret_manager(self) -> None:
+        self._secret_manager = GoogleSecretManager(log_config=self._log_config, service_key=self._runtime_configs.service.key, credentials_path=self._settings.INTERNAL_CREDENTIALS_PATH)
+
+    @property
+    def secret_manager(self) -> None:
+        return self._secret_manager
+
+    def _initialize_configs(self, environment:BaseEnums.EnvironmentType) -> None:
+        password = self._secret_manager.get(name=f"maleo-db-password-{environment}")
+        host = self._secret_manager.get(name=f"maleo-db-host-{environment}")
+        database = DatabaseConfigurations(password=password, host=host)
+        merged_configs = BaseMergers.deep_merge(self._static_configs.model_dump(), self._runtime_configs.model_dump(exclude={"database"}), {"database": database.model_dump()})
         self._configs = Configurations.model_validate(merged_configs)
 
     @property
     def configs(self) -> Configurations:
         return self._configs
 
+    def _initialize_keys(self) -> None:
+        password = self._secret_manager.get(name="maleo-key-password")
+        private = self._secret_manager.get(name="maleo-private-key")
+        public = self._secret_manager.get(name="maleo-public-key")
+        self._keys = Keys(password=password, private=private, public=public)
+
+    @property
+    def keys(self) -> Keys:
+        return self._keys
+
     def _initialize_loggers(self) -> None:
         #* Service's loggers
         application = ServiceLogger(type=BaseEnums.LoggerType.APPLICATION, service_key=self._configs.service.key, **self._log_config.model_dump())
@@ -204,45 +258,32 @@ class ServiceManager:
     def loggers(self) -> Loggers:
         return self._loggers
 
-    def _load_credentials(self) -> None:
-        #* Load google credentials
-        data = JSONLoader.load(self._settings.GOOGLE_CREDENTIALS_PATH)
-        google = GoogleCredentials.model_validate(data)
-        #* Load internal credentials
-        data = JSONLoader.load(self._settings.INTERNAL_CREDENTIALS_PATH)
-        internal = InternalCredentials.model_validate(data)
-        self._credentials = Credentials(google=google, internal=internal)
+    def _initialize_db(self) -> None:
+        self._database = DatabaseManager(metadata=self._db_metadata, logger=self._loggers.database, url=self._configs.database.url)
 
     @property
-    def credentials(self) -> Credentials:
-        return self._credentials
+    def database(self) -> DatabaseManager:
+        return self._database
 
-    def _parse_keys(self) -> None:
-        #* Parse private key
-        key_type = BaseEnums.KeyType.PRIVATE
-        private = KeyLoader.load_rsa(
-            type=key_type,
-            path=self._settings.PRIVATE_KEY_PATH,
-            password=self._settings.KEY_PASSWORD
-        )
-        #* Parse public key
-        key_type = BaseEnums.KeyType.PUBLIC
-        public = KeyLoader.load_rsa(
-            type=key_type,
-            path=self._settings.PUBLIC_KEY_PATH
-        )
-        self._keys = Keys(password=self._settings.KEY_PASSWORD, private=private, public=public)
+    def _initialize_clients(self, environment:BaseEnums.EnvironmentType) -> None:
+        secret = self._secret_manager
+        storage = GoogleCloudStorage(log_config=self._log_config, service_key=self._runtime_configs.service.key, bucket_name=f"maleo-suite-{environment}", credentials_path=self._settings.INTERNAL_CREDENTIALS_PATH)
+        self._google_clients = GoogleClientManagers(secret=secret, storage=storage)
+        foundation = MaleoFoundationClientManager(log_config=self._log_config, service_key=self._runtime_configs.service.key)
+        self._maleo_clients = MaleoClientManagers(foundation=foundation)
+        self._clients = ClientManagers(google=self._google_clients, maleo=self._maleo_clients)
 
     @property
-    def keys(self) -> Keys:
-        return self._keys
+    def google_clients(self) -> GoogleClientManagers:
+        self._google_clients
 
-    def _initialize_db(self) -> None:
-        self._database = DatabaseManager(metadata=self._db_metadata, logger=self._loggers.database, url=self._configs.database.url)
+    @property
+    def maleo_clients(self) -> MaleoClientManagers:
+        self._maleo_clients
 
     @property
-    def database(self) -> DatabaseManager:
-        return self._database
+    def clients(self) -> ClientManagers:
+        self._clients
 
     @property
     def token(self) -> str:
@@ -252,14 +293,10 @@ class ServiceManager:
             u_e=self._credentials.internal.email,
             u_ut=self._credentials.internal.user_type
         )
-        parameters = BaseTokenParametersTransfers.Encode(
-            key=self.keys.private,
-            password=self.keys.password,
-            payload=payload
-        )
-        result = BaseTokenService.encode(parameters=parameters)
+        parameters = BaseTokenParametersTransfers.Encode(key=self._keys.private, password=self._keys.password, payload=payload)
+        result = self._clients.maleo.foundation.services.token.encode(parameters=parameters)
         if not result.success:
-            raise ValueError("Failed generating token")
+            return ""
         return result.data.token
 
     def create_app(self, router:APIRouter, lifespan:Optional[Lifespan[AppType]] = None, request_processor:Optional[RequestProcessor] = None) -> FastAPI:

maleo_foundation-0.1.54/maleo_foundation/models/schemas/signature.py

@@ -0,0 +1,14 @@
+from pydantic import BaseModel, Field
+
+class BaseSignatureSchemas:
+    class Key(BaseModel):
+        key:str = Field(..., description="Key")
+
+    class Message(BaseModel):
+        message:str = Field(..., description="Message")
+
+    class Signature(BaseModel):
+        signature:str = Field(..., description="Signature")
+
+    class IsValid(BaseModel):
+        is_valid:bool = Field(..., description="Is valid signature")

{maleo_foundation-0.1.52 → maleo_foundation-0.1.54}/maleo_foundation/utils/logging.py

@@ -43,7 +43,7 @@ class GoogleCloudLogging:
 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")
+    google_cloud_logging:Optional[GoogleCloudLogging] = Field(default_factory=GoogleCloudLogging, description="Google cloud logging")
 
     class Config:
         arbitrary_types_allowed=True

{maleo_foundation-0.1.52 → maleo_foundation-0.1.54}/maleo_foundation.egg-info/PKG-INFO

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

{maleo_foundation-0.1.52 → maleo_foundation-0.1.54}/maleo_foundation.egg-info/SOURCES.txt

@@ -11,6 +11,10 @@ maleo_foundation.egg-info/SOURCES.txt
 maleo_foundation.egg-info/dependency_links.txt
 maleo_foundation.egg-info/requires.txt
 maleo_foundation.egg-info/top_level.txt
+maleo_foundation/client/__init__.py
+maleo_foundation/client/manager.py
+maleo_foundation/client/services/__init__.py
+maleo_foundation/client/services/token.py
 maleo_foundation/expanded_types/__init__.py
 maleo_foundation/expanded_types/client.py
 maleo_foundation/expanded_types/general.py
@@ -39,6 +43,7 @@ maleo_foundation/models/schemas/__init__.py
 maleo_foundation/models/schemas/general.py
 maleo_foundation/models/schemas/parameter.py
 maleo_foundation/models/schemas/result.py
+maleo_foundation/models/schemas/signature.py
 maleo_foundation/models/schemas/token.py
 maleo_foundation/models/transfers/__init__.py
 maleo_foundation/models/transfers/general/__init__.py

{maleo_foundation-0.1.52 → maleo_foundation-0.1.54}/pyproject.toml

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

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

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