maleo-foundation 0.1.81__py3-none-any.whl → 0.1.83__py3-none-any.whl

maleo_foundation/authentication.py

@@ -7,14 +7,20 @@ from maleo_foundation.types import BaseTypes
 class Credentials(AuthCredentials):
     def __init__(
         self,
+        key:BaseTypes.OptionalString = None,
         token:BaseTypes.OptionalString = None,
         payload:Optional[MaleoFoundationTokenGeneralTransfers.DecodePayload] = None,
         scopes:Optional[Sequence[str]] = None
     ) -> None:
+        self._key = key
         self._token = token
         self._payload = payload
         super().__init__(scopes)
 
+    @property
+    def key(self) -> BaseTypes.OptionalString:
+        return self._key
+
     @property
     def token(self) -> BaseTypes.OptionalString:
         return self._token

maleo_foundation/managers/client/google/base.py

@@ -1,8 +1,9 @@
-import os
-from google.auth import default
-from google.oauth2 import service_account
+from google.oauth2.service_account import Credentials
+from pathlib import Path
+from typing import Optional, Union
 from maleo_foundation.types import BaseTypes
 from maleo_foundation.managers.client.base import ClientManager
+from maleo_foundation.utils.loaders.credential.google import GoogleCredentialsLoader
 from maleo_foundation.utils.logging import SimpleConfig
 
 class GoogleClientManager(ClientManager):
@@ -12,22 +13,22 @@ class GoogleClientManager(ClientManager):
         name:str,
         log_config:SimpleConfig,
         service_key:BaseTypes.OptionalString=None,
-        credentials_path:BaseTypes.OptionalString=None
+        credentials:Optional[Credentials]=None,
+        credentials_path:Optional[Union[Path, str]]=None
     ) -> None:
         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:
-                self._credentials = service_account.Credentials.from_service_account_file(filename=credentials_path)
-            else:
-                self._credentials, _ = default()
-        except Exception as e:
-            raise ValueError(f"Failed to initialize credentials: {str(e)}")
+        if (credentials is not None and credentials_path is not None) or (credentials is None and credentials_path is None):
+            raise ValueError("Only either 'credentials' or 'credentials_path' can be passed as parameter")
+
+        if credentials is not None:
+            self._credentials = credentials
+        else:
+            self._credentials = GoogleCredentialsLoader(credentials_path)
 
         self._project_id = self._credentials.project_id
 
     @property
-    def credentials(self) -> service_account.Credentials:
+    def credentials(self) -> Credentials:
         return self._credentials
 
     @property

maleo_foundation/managers/client/google/secret.py

@@ -1,7 +1,9 @@
 from google.api_core import retry
 from google.api_core.exceptions import NotFound
 from google.cloud import secretmanager
-from typing import Optional
+from google.oauth2.service_account import Credentials
+from pathlib import Path
+from typing import Optional, Union
 from maleo_foundation.types import BaseTypes
 from maleo_foundation.utils.logging import SimpleConfig
 from .base import GoogleClientManager
@@ -11,11 +13,12 @@ class GoogleSecretManager(GoogleClientManager):
         self,
         log_config:SimpleConfig,
         service_key:BaseTypes.OptionalString=None,
-        credentials_path:BaseTypes.OptionalString = None
+        credentials:Optional[Credentials]=None,
+        credentials_path:Optional[Union[Path, str]]=None
     ) -> None:
         key = "google-secret-manager"
         name = "GoogleSecretManager"
-        super().__init__(key, name, log_config, service_key, credentials_path)
+        super().__init__(key, name, log_config, service_key, credentials, credentials_path)
         self._client = secretmanager.SecretManagerServiceClient(credentials=self._credentials)
         self._logger.info("Client manager initialized successfully")
 
@@ -30,34 +33,58 @@ class GoogleSecretManager(GoogleClientManager):
             self._logger.info("Client manager disposed successfully")
 
     @retry.Retry(predicate=retry.if_exception_type(Exception), timeout=5)
-    def get(self, name:str, version:str = "latest") -> Optional[str]:
+    def get(self, name:str, version:str = "latest") -> str:
+        #* Check if secret exists
+        secret_name = f"projects/{self._project_id}/secrets/{name}"
         try:
-            secret_path = f"projects/{self._project_id}/secrets/{name}/versions/{version}"
-            request = secretmanager.AccessSecretVersionRequest(name=secret_path)
+            request = secretmanager.GetSecretRequest(name=secret_name)
+            self._client.get_secret(request=request)
+        except NotFound:
+            self._logger.error("Secret '%s' did not exist", name, exc_info=True)
+            raise
+        except Exception:
+            self._logger.error("Exception raised while checking secret '%s' existence", name, exc_info=True)
+            raise
+
+        #* Check if secret's version exists
+        secret_version_name = f"{secret_name}/versions/{version}"
+        try:
+            request = secretmanager.GetSecretVersionRequest(name=secret_version_name)
+            self._client.get_secret_version(request=request)
+        except NotFound:
+            self._logger.error("Secret '%s' with version '%s' did not exist", name, version, exc_info=True)
+            raise
+        except Exception:
+            self._logger.error("Exception raised while checking secret '%s' with version '%s' existence", name, version, exc_info=True)
+            raise
+
+        #* Access secret's version
+        try:
+            request = secretmanager.AccessSecretVersionRequest(name=secret_version_name)
             response = self._client.access_secret_version(request=request)
             self._logger.info("Successfully retrieved secret '%s' with version '%s'", name, version)
             return response.payload.data.decode()
         except Exception:
-            self._logger.error("Exception occured with retrieving secret '%s' with version '%s'", name, version, exc_info=True)
-            return None
+            self._logger.error("Exception occured while retrieving secret '%s' with version '%s'", name, version, exc_info=True)
+            raise
 
     @retry.Retry(predicate=retry.if_exception_type(Exception), timeout=5)
-    def create(self, name:str, data:str) -> Optional[str]:
+    def create(self, name:str, data:str) -> str:
         parent = f"projects/{self._project_id}"
         secret_path = f"{parent}/secrets/{name}"
         try:
             #* Check if the secret already exists
             request = secretmanager.GetSecretRequest(name=secret_path)
             self._client.get_secret(request=request)
-
         except NotFound:
             #* Secret does not exist, create it first
             try:
                 secret = secretmanager.Secret(name=name, replication={"automatic": {}})
                 request = secretmanager.CreateSecretRequest(parent=parent, secret_id=name, secret=secret)
                 self._client.create_secret(request=request)
-            except Exception as e:
-                return None
+            except Exception:
+                self._logger.error("Exception occured while creating secret '%s'", name)
+                raise
 
         #* Add a new secret version
         try:
@@ -65,5 +92,6 @@ class GoogleSecretManager(GoogleClientManager):
             request = secretmanager.AddSecretVersionRequest(parent=secret_path, payload=payload)
             response = self._client.add_secret_version(request=request)
             return data
-        except Exception as e:
-            return None
+        except Exception:
+            self._logger.error("Exception occured while adding secret '%s' version", name)
+            raise

maleo_foundation/managers/client/google/storage.py

@@ -1,6 +1,9 @@
 import os
 from datetime import timedelta
 from google.cloud.storage import Bucket, Client
+from google.oauth2.service_account import Credentials
+from pathlib import Path
+from typing import Optional, Union
 from maleo_foundation.types import BaseTypes
 from maleo_foundation.utils.logging import SimpleConfig
 from .base import GoogleClientManager
@@ -10,12 +13,13 @@ class GoogleCloudStorage(GoogleClientManager):
         self,
         log_config:SimpleConfig,
         service_key:BaseTypes.OptionalString=None,
-        credentials_path:BaseTypes.OptionalString = None,
+        credentials:Optional[Credentials]=None,
+        credentials_path:Optional[Union[Path, str]]=None,
         bucket_name:BaseTypes.OptionalString = None
     ) -> None:
         key = "google-cloud-storage"
         name = "GoogleCloudStorage"
-        super().__init__(key, name, log_config, service_key, credentials_path)
+        super().__init__(key, name, log_config, service_key, credentials, 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/service.py

@@ -1,9 +1,11 @@
 from fastapi import FastAPI, APIRouter
 from fastapi.exceptions import RequestValidationError
-from starlette.exceptions import HTTPException
-from starlette.types import Lifespan, AppType
+from google.oauth2.service_account import Credentials
+from pathlib import Path
 from pydantic_settings import BaseSettings
 from pydantic import BaseModel, Field
+from starlette.exceptions import HTTPException
+from starlette.types import Lifespan, AppType
 from sqlalchemy import MetaData
 from typing import Optional
 from maleo_foundation.client.manager import MaleoFoundationClientManager
@@ -16,43 +18,21 @@ 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.utils.exceptions import BaseExceptions
-from maleo_foundation.utils.loaders.json import JSONLoader
 from maleo_foundation.utils.loaders.yaml import YAMLLoader
 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")
+    SERVICE_KEY:str = Field(..., description="Service's key")
     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")
     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")
 
-class GoogleCredentials(BaseModel):
-    type:str = Field(..., description="Credentials type")
-    project_id:str = Field(..., description="Google project ID")
-    private_key_id:str = Field(..., description="Private key ID")
-    private_key:str = Field(..., description="Private key")
-    client_email:str = Field(..., description="Client email")
-    client_id:str = Field(..., description="Client ID")
-    auth_uri:str = Field(..., description="Authorization URI")
-    token_uri:str = Field(..., description="Token URI")
-    auth_provider_x509_cert_url:str = Field(..., description="Authorization provider x509 certificate URL")
-    client_x509_cert_url:str = Field(..., description="Client x509 certificate URL")
-    universe_domain:str = Field(..., description="Universe domains")
-
-class InternalCredentials(BaseModel):
-    system_role:str = Field(..., description="System role")
+class MaleoCredentials(BaseModel):
     username:str = Field(..., description="Username")
     email:str = Field(..., description="Email")
-    user_type:str = Field(..., description="User type")
-
-class Credentials(BaseModel):
-    google:GoogleCredentials = Field(..., description="Google's credentials")
-    internal:InternalCredentials = Field(..., description="Internal's credentials")
-
-    class Config:
-        arbitrary_types_allowed=True
+    password:str = Field(..., description="Password")
 
 class MiddlewareRuntimeConfigurations(BaseModel):
     base:BaseMiddlewareConfigurations = Field(..., description="Base middleware's configurations")
@@ -166,16 +146,14 @@ class ServiceManager:
         #* Disable google cloud logging if environment is local
         if self._settings.ENVIRONMENT == "local":
             self._log_config.google_cloud_logging = None
-        self._load_credentials()
-        self._load_configs()
+        self._load_google_credentials()
         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._load_maleo_credentials()
+        self._load_configs()
+        self._load_keys()
         self._initialize_loggers()
         self._initialize_db()
-        self._initialize_clients(environment=environment)
+        self._initialize_clients()
 
     @property
     def log_config(self) -> SimpleConfig:
@@ -185,44 +163,54 @@ 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)
+    def _load_google_credentials(self) -> None:
+        self._google_credentials = Credentials.from_service_account_file(self._settings.GOOGLE_CREDENTIALS_PATH)
 
     @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)
+    def google_credentials(self) -> None:
+        return self._google_credentials
 
     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.GOOGLE_CREDENTIALS_PATH)
+        self._secret_manager = GoogleSecretManager(log_config=self._log_config, service_key=self._settings.SERVICE_KEY, credentials=self._google_credentials)
 
     @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, database=self._runtime_configs.database)
-        merged_configs = BaseMergers.deep_merge(self._static_configs.model_dump(), self._runtime_configs.model_dump(exclude={"database"}), {"database": database.model_dump()})
+    def _load_maleo_credentials(self) -> None:
+        email = self._secret_manager.get("maleo-service-account-email")
+        username = self._secret_manager.get("maleo-service-account-username")
+        password = self._secret_manager.get("maleo-service-account-password")
+        self._maleo_credentials = MaleoCredentials(username=username, email=email, password=password)
+
+    @property
+    def maleo_credentials(self) -> Credentials:
+        return self._maleo_credentials
+
+    def _load_configs(self) -> None:
+        static_configurations_path = Path(self._settings.STATIC_CONFIGURATIONS_PATH)
+        if static_configurations_path.exists() and static_configurations_path.is_file():
+            static_configurations = YAMLLoader.load(self._settings.STATIC_CONFIGURATIONS_PATH)
+        else:
+            static_configurations = self._secret_manager.get(f"maleo-static-config-{self._settings.ENVIRONMENT}")
+        static_configs = StaticConfigurations.model_validate(static_configurations)
+        runtime_configurations_path = Path(self._settings.RUNTIME_CONFIGURATIONS_PATH)
+        if runtime_configurations_path.exists() and runtime_configurations_path.is_file():
+            runtime_configurations = YAMLLoader.load(self._settings.RUNTIME_CONFIGURATIONS_PATH)
+        else:
+            runtime_configurations = self._secret_manager.get(f"{self._settings.SERVICE_KEY}-runtime-config-{self._settings.ENVIRONMENT}")
+        runtime_configs = RuntimeConfigurations.model_validate(runtime_configurations)
+        password = self._secret_manager.get(name=f"maleo-db-password-{self._settings.ENVIRONMENT}")
+        host = self._secret_manager.get(name=f"maleo-db-host-{self._settings.ENVIRONMENT}")
+        database = DatabaseConfigurations(password=password, host=host, database=runtime_configs.database)
+        merged_configs = BaseMergers.deep_merge(static_configs.model_dump(), 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:
+    def _load_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")
@@ -253,11 +241,12 @@ class ServiceManager:
     def database(self) -> DatabaseManager:
         return self._database
 
-    def _initialize_clients(self, environment:BaseEnums.EnvironmentType) -> None:
+    def _initialize_clients(self) -> 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.GOOGLE_CREDENTIALS_PATH)
+        environment = BaseEnums.EnvironmentType.STAGING if self._settings.ENVIRONMENT == BaseEnums.EnvironmentType.LOCAL else self._settings.ENVIRONMENT
+        storage = GoogleCloudStorage(log_config=self._log_config, service_key=self._settings.SERVICE_KEY, bucket_name=f"maleo-suite-{environment}", credentials=self._google_credentials)
         self._google_clients = GoogleClientManagers(secret=secret, storage=storage)
-        foundation = MaleoFoundationClientManager(log_config=self._log_config, service_key=self._runtime_configs.service.key)
+        foundation = MaleoFoundationClientManager(log_config=self._log_config, service_key=self._settings.SERVICE_KEY)
         self._maleo_clients = MaleoClientManagers(foundation=foundation)
         self._clients = ClientManagers(google=self._google_clients, maleo=self._maleo_clients)
 
@@ -276,10 +265,10 @@ class ServiceManager:
     @property
     def token(self) -> str:
         payload = MaleoFoundationTokenGeneralTransfers.BaseEncodePayload(
-            sr=self._credentials.internal.system_role,
-            u_u=self._credentials.internal.username,
-            u_e=self._credentials.internal.email,
-            u_ut=self._credentials.internal.user_type
+            sr="administrator",
+            u_u=self._maleo_credentials.username,
+            u_e=self._maleo_credentials.email,
+            u_ut="service"
         )
         parameters = MaleoFoundationTokenParametersTransfers.Encode(key=self._keys.private, password=self._keys.password, payload=payload)
         result = self._clients.maleo.foundation.services.token.encode(parameters=parameters)

maleo_foundation/utils/loaders/__init__.py

@@ -1,9 +1,11 @@
 from __future__ import annotations
+from .credential import CredentialLoaders
 from .json import JSONLoader
-from .key import BaseKeyLoaders
+from .key import KeyLoaders
 from .yaml import YAMLLoader
 
 class BaseLoaders:
-    Json = JSONLoader
-    Key = BaseKeyLoaders
-    Yaml = YAMLLoader
+    Credential = CredentialLoaders
+    JSON = JSONLoader
+    Key = KeyLoaders
+    YAML = YAMLLoader

maleo_foundation/utils/loaders/credential/__init__.py

@@ -0,0 +1,5 @@
+from __future__ import annotations
+from .google import GoogleCredentialsLoader
+
+class CredentialLoaders:
+    Google = GoogleCredentialsLoader

maleo_foundation/utils/loaders/credential/google.py

@@ -0,0 +1,25 @@
+import os
+from google.auth import default
+from google.oauth2.service_account import Credentials
+from pathlib import Path
+from typing import Optional, Type, Union
+
+class GoogleCredentialsLoader:
+    @staticmethod
+    def load(credentials_path:Optional[Union[Path, str]] = None) -> Credentials:
+        if not isinstance(credentials_path, (Path, Type[None], str)):
+            raise TypeError("Google credentials type can only be 'Path', 'str', or 'None'")
+        if credentials_path is None:
+            credentials_path = os.getenv("GOOGLE_CREDENTIALS_PATH")
+        else:
+            credentials_path = credentials_path
+        try:
+            if credentials_path is not None:
+                credentials_path = Path(credentials_path)
+                if credentials_path.exists() or credentials_path.is_file():
+                    credentials = Credentials.from_service_account_file(filename=str(credentials_path))
+            else:
+                credentials, _ = default()
+            return credentials
+        except Exception as e:
+            raise ValueError(f"Failed to initialize credentials: {str(e)}")

maleo_foundation/utils/loaders/key/__init__.py

@@ -1,5 +1,5 @@
 from __future__ import annotations
 from .rsa import RSAKeyLoader
 
-class BaseKeyLoaders:
+class KeyLoaders:
     RSA = RSAKeyLoader

maleo_foundation/utils/loaders/yaml.py

@@ -7,7 +7,7 @@ class YAMLLoader:
     def load(path:Union[Path, str]) -> Dict:
         file_path = Path(path)
 
-        if not file_path.is_file():
+        if not file_path.exists() or not file_path.is_file():
             raise FileNotFoundError(f"File not found: {file_path}")
 
         with file_path.open("r") as f:

maleo_foundation/utils/logging.py

@@ -1,30 +1,24 @@
 import logging
 import os
 from datetime import datetime
-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 google.oauth2.service_account import Credentials
+from pathlib import Path
 from pydantic import BaseModel, Field
-from typing import Optional
+from typing import Optional, Union
 from maleo_foundation.enums import BaseEnums
 from maleo_foundation.types import BaseTypes
+from maleo_foundation.utils.loaders.credential.google import GoogleCredentialsLoader
 
 class GoogleCloudLogging:
-    def __init__(self, google_credentials_path:BaseTypes.OptionalString = None) -> None:
-        google_credentials_path = google_credentials_path or os.getenv("GOOGLE_CREDENTIALS_PATH")
-        try:
-            if google_credentials_path is not None:
-                self._credentials = service_account.Credentials.from_service_account_file(filename=google_credentials_path)
-            else:
-                self._credentials, _ = default()
-        except Exception as e:
-            raise ValueError(f"Failed to initialize credentials: {str(e)}")
+    def __init__(self, credentials_path:Optional[Union[Path, str]] = None) -> None:
+        self._credentials = GoogleCredentialsLoader.load(credentials_path=credentials_path)
         self._client = Client(credentials=self._credentials)
         self._client.setup_logging()
 
     @property
-    def credentials(self) -> service_account.Credentials:
+    def credentials(self) -> Credentials:
         return self._credentials
 
     @property

{maleo_foundation-0.1.81.dist-info → maleo_foundation-0.1.83.dist-info}/METADATA

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

{maleo_foundation-0.1.81.dist-info → maleo_foundation-0.1.83.dist-info}/RECORD

@@ -1,5 +1,5 @@
 maleo_foundation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-maleo_foundation/authentication.py,sha256=PJ_1j9SskRa0vtEkj91yLhzc71aFGSFTg1TaY3rHbgE,1594
+maleo_foundation/authentication.py,sha256=0HhZsmZM_oMiC71FpnTBLbx2sQzdsI-RgwNqvxvn5zg,1750
 maleo_foundation/constants.py,sha256=aBmEfWlBqZxi0k-n6h2NM1YRLOjMnheEiLyQcjP-zCQ,1164
 maleo_foundation/enums.py,sha256=uvwl3dl2r6BoJMEbtSETiLoyJubHup9Lc7VOg7w7zQo,2943
 maleo_foundation/extended_types.py,sha256=pIKt-_9tby4rmune3fmWcCW_mohaNRh_1lywBmdc-L4,301
@@ -32,14 +32,14 @@ maleo_foundation/expanded_types/encryption/rsa.py,sha256=MuhB_DGrjnsl4t96W4pKuCt
 maleo_foundation/managers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 maleo_foundation/managers/db.py,sha256=Pn5EZ-c1Hy6-BihN7KokHJWmBIt3Ty96fZ0zF-srtF4,5208
 maleo_foundation/managers/middleware.py,sha256=ODIQU1Hpu-Xempjjo_VRbVtxiD5oi74mNuoWuDawRh0,4250
-maleo_foundation/managers/service.py,sha256=G2AOYVg56Pl3D2xD7CgFhEjpP-wMgq1PN4inXMy2qOA,17080
+maleo_foundation/managers/service.py,sha256=l5YoDj5mT4B6XtAP4LDF9h93VUkKVQGrgWIZ7nsaklE,16420
 maleo_foundation/managers/client/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 maleo_foundation/managers/client/base.py,sha256=5z9l2GN4QASF0-Lft8o5QQ3SRPXqeNZNT1S1CgaE764,4384
 maleo_foundation/managers/client/maleo.py,sha256=iCM47TLL-RSQ2FkTmHVPdsb2JCd1LebMx6OJvIr4vCQ,2035
 maleo_foundation/managers/client/google/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-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/managers/client/google/base.py,sha256=eIdd6C2BFIu4EyZ1j017VZaJn_nSTPGFftBwQmVAUDA,1366
+maleo_foundation/managers/client/google/secret.py,sha256=Ski1CHYeA8vjSk2Oc2Pf4CfFrzT_RcA6NEZwza7gM7Y,4464
+maleo_foundation/managers/client/google/storage.py,sha256=JFqXd9QgusT75KAWyWdin8V6BbbKcbBCrmWDpqg6i3Q,2530
 maleo_foundation/middlewares/authentication.py,sha256=qg4BwJ72aHOKyo19II37bafQaV5OFvff173aKRCp54o,3359
 maleo_foundation/middlewares/base.py,sha256=g4cg9gIUveK9zbjhwQtkdefhuoSlv9BUWVCFaSlOClw,13303
 maleo_foundation/middlewares/cors.py,sha256=9uvBvY2N6Vxa9RP_YtESxcWo6Doi6uS0lzAG9iLY7Uc,2288
@@ -95,17 +95,19 @@ maleo_foundation/utils/__init__.py,sha256=SRPEVoqjZoO6W8rtF_Ti8VIangg6Auwm6eHbZM
 maleo_foundation/utils/controller.py,sha256=ECzPzpw36zBAjKcWcDbUAhIJGbc6UpeypdUUX6ipXBg,6396
 maleo_foundation/utils/exceptions.py,sha256=hstsXST24mbJLuDtAfcdC0FxMgH3IkG97A026CvaX-w,4034
 maleo_foundation/utils/extractor.py,sha256=SZXVYDHWGaA-Dd1BUydwF2HHdZqexEielS4CjL0Ceng,814
-maleo_foundation/utils/logging.py,sha256=bBi73GTwRK8Ll4m5vSNHGymXUrbRsSNQYZ1vF7Iq1z8,8052
+maleo_foundation/utils/logging.py,sha256=W5Fhk_xAXVqSujaY8mv3hRH4wlQSpUn4ReuMoiKcQa4,7759
 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
 maleo_foundation/utils/formatter/case.py,sha256=TmvvlfzGdC_omMTB5vAa40TZBxQ3hnr-SYeo0M52Rlg,1352
-maleo_foundation/utils/loaders/__init__.py,sha256=RCfPdfgY-F25VDMSA-TWyoczRVUiIDDXpmui8tv5HxM,213
+maleo_foundation/utils/loaders/__init__.py,sha256=P_3ycGfeDXFjAi8bE4iLWHxBveqUIdpHgGv-klRWM3s,282
 maleo_foundation/utils/loaders/json.py,sha256=NsXLq3VZSgzmEf99tV1VtrmiudWdQ8Pzh_hI4Rm0cM8,397
-maleo_foundation/utils/loaders/yaml.py,sha256=jr8v3BlgmRCMTzdNgKhIYt1tnubaJXcDSSGkKVR8pbw,362
-maleo_foundation/utils/loaders/key/__init__.py,sha256=G03cA_Oxu02uDsg0WBPfPkIM2uUsxnjwOPgtBKe02kc,110
+maleo_foundation/utils/loaders/yaml.py,sha256=L438PTWFnE0St_T4-7f_3TV4apfh0LhYkIdODCuYuDw,388
+maleo_foundation/utils/loaders/credential/__init__.py,sha256=qopTKvcMVoTFwyRijeg7rejnG4I684FjUwh70tvhtVM,141
+maleo_foundation/utils/loaders/credential/google.py,sha256=ZWdgdTasDDYBbBLaVrlnXAv8tN2MaOUNEgmcywENrSk,1116
+maleo_foundation/utils/loaders/key/__init__.py,sha256=hVygcC2ImHc_aVrSrOmyedR8tMUZokWUKCKOSh5ctbo,106
 maleo_foundation/utils/loaders/key/rsa.py,sha256=gDhyX6iTFtHiluuhFCozaZ3pOLKU2Y9TlrNMK_GVyGU,3796
-maleo_foundation-0.1.81.dist-info/METADATA,sha256=y9zQTDej3oB5hWmm8KXSBGCII4kMsBnvS6bEeaJbfVs,3419
-maleo_foundation-0.1.81.dist-info/WHEEL,sha256=0CuiUZ_p9E4cD6NyLD6UG80LBXYyiSYZOKDm5lp32xk,91
-maleo_foundation-0.1.81.dist-info/top_level.txt,sha256=_iBos3F_bhEOdjOnzeiEYSrCucasc810xXtLBXI8cQc,17
-maleo_foundation-0.1.81.dist-info/RECORD,,
+maleo_foundation-0.1.83.dist-info/METADATA,sha256=zm7d1DKfe-eaDzlirlZmgBlJnXaLxRYQ9odBFHOfZdM,3419
+maleo_foundation-0.1.83.dist-info/WHEEL,sha256=DnLRTWE75wApRYVsjgc6wsVswC54sMSJhAEd4xhDpBk,91
+maleo_foundation-0.1.83.dist-info/top_level.txt,sha256=_iBos3F_bhEOdjOnzeiEYSrCucasc810xXtLBXI8cQc,17
+maleo_foundation-0.1.83.dist-info/RECORD,,

{maleo_foundation-0.1.81.dist-info → maleo_foundation-0.1.83.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.3.1)
+Generator: setuptools (80.4.0)
 Root-Is-Purelib: true
 Tag: py3-none-any