maleo-foundation 0.1.53__py3-none-any.whl → 0.1.55__py3-none-any.whl

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/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/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/managers/client/base.py

@@ -1,21 +1,110 @@
-from maleo_foundation.utils.logging import ClientLogger
-from maleo_foundation.managers.service import ServiceManager
+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, SimpleConfig
+
+class URL(BaseModel):
+    base:str = Field(..., description="Base URL")
+
+    @property
+    def api(self) -> str:
+        return f"{self.base}/api"
+
+class ClientHTTPControllerManager:
+    def __init__(self, url:str) -> None:
+        self._client = httpx.AsyncClient()
+        self._url = URL(base=url)
+
+    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]:
+        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
+
+    async def dispose(self) -> None:
+        await self._client.aclose()
+
+class ClientControllerManagers(BaseModel):
+    http:ClientHTTPControllerManager = Field(..., description="HTTP Client Controller")
+
+    class Config:
+        arbitrary_types_allowed=True
+
+class ClientHTTPController:
+    def __init__(self, manager:ClientHTTPControllerManager):
+        self._manager = manager
+
+    @property
+    def manager(self) -> ClientHTTPControllerManager:
+        return self._manager
+
+class ClientServiceControllers(BaseModel):
+    http:ClientHTTPController = 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, logger:ClientLogger):
+        self._logger = logger
+
+    @property
+    def controllers(self) -> ClientServiceControllers:
+        raise NotImplementedError()
+
+    @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 ClientManager:
     def __init__(
         self,
         key:str,
         name:str,
-        service_manager:ServiceManager
+        log_config:SimpleConfig,
+        service_key:BaseTypes.OptionalString=None
     ) -> None:
         self._key = key
         self._name = name
-        self._service_manager = service_manager
+        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_manager.configs.service.key, **self._service_manager.log_config.model_dump())
+        self._logger = ClientLogger(client_key=self._key, service_key=self._service_key, **self._log_config.model_dump())
 
     @property
     def key(self) -> str:
@@ -25,14 +114,19 @@ class ClientManager:
     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
 
+    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
+
     @property
     def credentials(self):
         raise NotImplementedError()

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/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/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/managers/client/maleo.py

@@ -1,96 +1,19 @@
-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.managers.client.base import ClientManager, ClientHTTPControllerManager, ClientControllerManagers, ClientHTTPController, ClientServiceControllers, ClientControllers
 from maleo_foundation.managers.service import ServiceManager
 
-class URL(BaseModel):
-    base:str = Field(..., description="Base URL")
-
-    @property
-    def api(self) -> str:
-        return f"{self.base}/api"
-
-class ClientHTTPControllerManager:
-    def __init__(self, url:str) -> None:
-        self._client = httpx.AsyncClient()
-        self._url = URL(base=url)
-
-    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]:
-        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
-
-    async def dispose(self) -> None:
-        await self._client.aclose()
-
-class ClientControllerManagers(BaseModel):
-    http:ClientHTTPControllerManager = Field(..., description="HTTP Client Controller")
-
-    class Config:
-        arbitrary_types_allowed=True
-
-class ClientHTTPController:
+class MaleoClientHTTPController(ClientHTTPController):
     def __init__(self, service_manager:ServiceManager, manager:ClientHTTPControllerManager):
         self._service_manager = service_manager
-        self._manager = manager
+        super().__init__(manager)
 
     @property
     def service_manager(self) -> ServiceManager:
         return self._service_manager
 
-    @property
-    def manager(self) -> ClientHTTPControllerManager:
-        return self._manager
-
-class ClientServiceControllers(BaseModel):
-    http:ClientHTTPController = 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 MaleoClientServiceControllers(ClientServiceControllers):
+    http:MaleoClientHTTPController = Field(..., description="Maleo's HTTP Client Controller")
 
-class ClientService:
-    def __init__(self, logger:ClientLogger):
-        self._logger = logger
-
-    @property
-    def controllers(self) -> ClientServiceControllers:
-        raise NotImplementedError()
-
-    @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
 
@@ -102,8 +25,8 @@ class MaleoClientManager(ClientManager):
         url:str,
         service_manager:ServiceManager
     ):
-        super().__init__(key, name, service_manager)
         self._url = url
+        super().__init__(key, name, service_manager.log_config, service_manager.configs.service.key)
 
     def _initialize_controllers(self) -> None:
         #* Initialize managers
@@ -117,15 +40,6 @@ class MaleoClientManager(ClientManager):
     def controllers(self) -> ClientControllers:
         return 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
-
     async def dispose(self) -> None:
         self._logger.info("Disposing client manager")
         await self._controller_managers.http.dispose()

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/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/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/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.53.dist-info → maleo_foundation-0.1.55.dist-info}/METADATA

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

{maleo_foundation-0.1.53.dist-info → maleo_foundation-0.1.55.dist-info}/RECORD

@@ -4,6 +4,10 @@ maleo_foundation/constants.py,sha256=aBmEfWlBqZxi0k-n6h2NM1YRLOjMnheEiLyQcjP-zCQ
 maleo_foundation/enums.py,sha256=uvwl3dl2r6BoJMEbtSETiLoyJubHup9Lc7VOg7w7zQo,2943
 maleo_foundation/extended_types.py,sha256=pIKt-_9tby4rmune3fmWcCW_mohaNRh_1lywBmdc-L4,301
 maleo_foundation/types.py,sha256=aKXnIgEhYGSfFqNMGLc4qIKGkINBRpkOo9R9cb2CbwI,2414
+maleo_foundation/client/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+maleo_foundation/client/manager.py,sha256=hF5Uiv93yHmno8ec4ukCDrpTh2apUabMeYZNVgSbxZM,1035
+maleo_foundation/client/services/__init__.py,sha256=ur502vxzT2FxhkZ7F0c7RjOGYAYEqmwRzz3pQsrAM8M,347
+maleo_foundation/client/services/token.py,sha256=KJcA6aTW12JovrbBf0KoKMDgOopz-mZ_SmCRHhWLS_k,1894
 maleo_foundation/expanded_types/__init__.py,sha256=lm_r7rxlLA0sgSTGQBMR9ZbZbVDpD7Te-UYb3oRVi1g,364
 maleo_foundation/expanded_types/client.py,sha256=To0kRXp3QTmuSu5rWKaCiTsMK9qkYiyYKYbHfw-y1fY,2396
 maleo_foundation/expanded_types/general.py,sha256=bjIBREYTS73tvS-Key7P7db82a2HHlSJ1XBAvKuYmT0,826
@@ -11,16 +15,16 @@ maleo_foundation/expanded_types/query.py,sha256=0yUG-JIVsanzB7KAkrRz_OsrhP6J0bRq
 maleo_foundation/expanded_types/service.py,sha256=q8jpKdbCbLWwH1UPQavKpVE14rC5rveduk2cFWzuhGw,2416
 maleo_foundation/expanded_types/token.py,sha256=4fRTJw6W5MYq71NksNrWNi7qYHQ4_lQwfu9WxwrMipc,355
 maleo_foundation/managers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-maleo_foundation/managers/db.py,sha256=lIOGE2qVofnJNqRJKaxFQ6Md3Lg5RB-oGqfZN-85diA,5522
+maleo_foundation/managers/db.py,sha256=Pn5EZ-c1Hy6-BihN7KokHJWmBIt3Ty96fZ0zF-srtF4,5208
 maleo_foundation/managers/middleware.py,sha256=7CDXPMb28AR7J72TWOeKFxOlMypKezEtO9mr53a88B0,4032
-maleo_foundation/managers/service.py,sha256=0T3dHcpGdkvT0YuTvPssRR8_wDkHTPW-VI8yUl9iY80,14928
+maleo_foundation/managers/service.py,sha256=P4-vEcLznfsH0JbHmpNcihQdw2_lmhTsoc4G7wJ8JCM,17296
 maleo_foundation/managers/client/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-maleo_foundation/managers/client/base.py,sha256=Z7_ANKbrlnShoZeSpP6N9Y0JLquDWG2FAedMvceYtt0,1120
-maleo_foundation/managers/client/maleo.py,sha256=xxzUERrpFQKWrOMxPi8t3zH0z3MliBii2cvXaRQunGI,4290
+maleo_foundation/managers/client/base.py,sha256=qfWu_wxoPSSzgZwuTEwRiXERg60diAkz65Qk3fnQej4,3972
+maleo_foundation/managers/client/maleo.py,sha256=G6C0rn_5c1MEmnoZkJbyXptfoDEofgC5BwLzfQC4NEk,1886
 maleo_foundation/managers/client/google/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-maleo_foundation/managers/client/google/base.py,sha256=0_4MYc-clsnSS2hjwwe-DNaycmcwsoUeF9mm21GLpbI,1202
-maleo_foundation/managers/client/google/secret.py,sha256=BNRE-VnD3GTgRtUQg2zzaitYHZ_yThTl7wRKPngqW-U,3067
-maleo_foundation/managers/client/google/storage.py,sha256=d2ysrFOHAfKXWbM9u9XCxstMJgS8twSiZUshpGBfwg8,2308
+maleo_foundation/managers/client/google/base.py,sha256=j3W18Pmcu9jJ5wK12bbWBI6r8cVt5f7QmGU9uIJgKrU,1249
+maleo_foundation/managers/client/google/secret.py,sha256=Uh01RoOp8QOIvu8X4AGJzOJRlrfAeXHO8ZFvmKo7A-E,3114
+maleo_foundation/managers/client/google/storage.py,sha256=MPuVpLTl0QJhlBOqpxv5UtD3ANO1WCCE1sRrfHnlCZM,2355
 maleo_foundation/middlewares/__init__.py,sha256=bqE2EIFC3rWcR2AwFPR0fk2kSFfeTRzgA24GbnuT5RA,3697
 maleo_foundation/middlewares/authentication.py,sha256=mpJ4WJ25zw4SGvgpeJE9eSV3-AtK5IJtN2U8Dh9rmMk,3132
 maleo_foundation/middlewares/base.py,sha256=iGc_4JZYxE0k47Dty4aFOvpgXjQY_W_4tgqYndhq3V8,10991
@@ -32,6 +36,7 @@ maleo_foundation/models/schemas/__init__.py,sha256=Xj8Ahsqyra-fmEaVcGPok5GOOsPQl
 maleo_foundation/models/schemas/general.py,sha256=hEQQPcddxMsJXMb36nqItIAfp3pqUyJOlaD7nXkNM2I,3609
 maleo_foundation/models/schemas/parameter.py,sha256=K47z2NzmTEhUiOfRiRLyRPXoQurbWsKBL7ObXAxIWRY,2100
 maleo_foundation/models/schemas/result.py,sha256=V3dljS2AdtWW4Pf8YsnQuiCylN1bZtEY1AtYC7okWuI,1747
+maleo_foundation/models/schemas/signature.py,sha256=32ECoksXCVRloTFNcb9ne3IAi5F6e6MuDniCj76ppmQ,420
 maleo_foundation/models/schemas/token.py,sha256=u71kPXJyCxqn_INK05MSNFhQr9MaLfQM-icYc536xik,551
 maleo_foundation/models/transfers/__init__.py,sha256=oJLJ3Geeme6vBw7R2Dhvdvg4ziVvzEYAGJaP-tm_90w,299
 maleo_foundation/models/transfers/general/__init__.py,sha256=0yW67vJvKgJmZ9htteOVatG7mb-YEpHF62dpwH2g_Bk,146
@@ -58,7 +63,7 @@ maleo_foundation/utils/__init__.py,sha256=SRPEVoqjZoO6W8rtF_Ti8VIangg6Auwm6eHbZM
 maleo_foundation/utils/controller.py,sha256=ECzPzpw36zBAjKcWcDbUAhIJGbc6UpeypdUUX6ipXBg,6396
 maleo_foundation/utils/exceptions.py,sha256=LPPcU-6_3NbRIBZg2Nr2Ac5HF1qZJbHbMVnwfIfZg6g,3702
 maleo_foundation/utils/extractor.py,sha256=SZXVYDHWGaA-Dd1BUydwF2HHdZqexEielS4CjL0Ceng,814
-maleo_foundation/utils/logging.py,sha256=cO9QLui0W9CVtQZOj_lfyuggdFaaffHkrOS12fl0i5I,8042
+maleo_foundation/utils/logging.py,sha256=bBi73GTwRK8Ll4m5vSNHGymXUrbRsSNQYZ1vF7Iq1z8,8052
 maleo_foundation/utils/mergers.py,sha256=DniUu3Ot4qkYH_YSw4uD1cn9cfirum4S_Opp8fMkQwA,702
 maleo_foundation/utils/query.py,sha256=ODQ3adOYQNj5E2cRW9ytbjBz56nEDcnfq8mQ6YZbCCM,4375
 maleo_foundation/utils/formatter/__init__.py,sha256=iKf5YCbEdg1qKnFHyKqqcQbqAqEeRUf8mhI3v3dQoj8,78
@@ -67,7 +72,7 @@ maleo_foundation/utils/loaders/__init__.py,sha256=Dnuv7BWyglSddnbsFb96s-b3KaW7UK
 maleo_foundation/utils/loaders/json.py,sha256=NsXLq3VZSgzmEf99tV1VtrmiudWdQ8Pzh_hI4Rm0cM8,397
 maleo_foundation/utils/loaders/key.py,sha256=GZ4h1ONfp6Xx8-E8AWoGP4ajAZrwPhZRtidjn_u82Qg,2562
 maleo_foundation/utils/loaders/yaml.py,sha256=jr8v3BlgmRCMTzdNgKhIYt1tnubaJXcDSSGkKVR8pbw,362
-maleo_foundation-0.1.53.dist-info/METADATA,sha256=kbspfEHcLNmIwhVZ9VJvqTU3IJcCR3VC4TWlY2aF2NQ,3354
-maleo_foundation-0.1.53.dist-info/WHEEL,sha256=0CuiUZ_p9E4cD6NyLD6UG80LBXYyiSYZOKDm5lp32xk,91
-maleo_foundation-0.1.53.dist-info/top_level.txt,sha256=_iBos3F_bhEOdjOnzeiEYSrCucasc810xXtLBXI8cQc,17
-maleo_foundation-0.1.53.dist-info/RECORD,,
+maleo_foundation-0.1.55.dist-info/METADATA,sha256=PtkqUBr25XaRh8S_Lw63cZmOtbo9xiUupcwD71DNjeQ,3354
+maleo_foundation-0.1.55.dist-info/WHEEL,sha256=0CuiUZ_p9E4cD6NyLD6UG80LBXYyiSYZOKDm5lp32xk,91
+maleo_foundation-0.1.55.dist-info/top_level.txt,sha256=_iBos3F_bhEOdjOnzeiEYSrCucasc810xXtLBXI8cQc,17
+maleo_foundation-0.1.55.dist-info/RECORD,,