maleo-foundation 0.3.70__tar.gz → 0.3.72__tar.gz

{maleo_foundation-0.3.70 → maleo_foundation-0.3.72}/PKG-INFO

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

{maleo_foundation-0.3.70 → maleo_foundation-0.3.72}/maleo_foundation/client/manager.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
+from typing import Optional
+from maleo_foundation.enums import BaseEnums
 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.encryption import (
     MaleoFoundationAESEncryptionClientService,
@@ -23,11 +24,16 @@ from maleo_foundation.client.services import (
 
 class MaleoFoundationClientManager(ClientManager):
     def __init__(
-        self, log_config: SimpleConfig, service_key: BaseTypes.OptionalString = None
+        self,
+        log_config: SimpleConfig,
+        service_environment: Optional[BaseEnums.EnvironmentType] = None,
+        service_key: Optional[BaseEnums.Service] = None,
     ) -> None:
         key = "maleo-foundation"
         name = "MaleoFoundation"
-        super().__init__(key, name, log_config, service_key)
+        super().__init__(
+            key, name, log_config, service_environment, service_key, service_environment
+        )
         self._initialize_services()
         self._logger.info("Client manager initialized successfully")
 

maleo_foundation-0.3.72/maleo_foundation/controller_types.py

@@ -0,0 +1,25 @@
+from google.cloud.pubsub_v1.subscriber.message import Message
+from typing import Awaitable, Callable, Optional, Union
+from maleo_foundation.models.transfers.results.service.controllers.rest import (
+    BaseServiceRESTControllerResults,
+)
+
+
+class ControllerTypes:
+    # * REST controller types
+    SyncRESTController = Callable[..., BaseServiceRESTControllerResults]
+    OptionalSyncRESTController = Optional[
+        Callable[..., BaseServiceRESTControllerResults]
+    ]
+    AsyncRESTController = Callable[..., Awaitable[BaseServiceRESTControllerResults]]
+    OptionalAsyncRESTController = Optional[
+        Callable[..., Awaitable[BaseServiceRESTControllerResults]]
+    ]
+    RESTController = Union[SyncRESTController, AsyncRESTController]
+    OptionalRESTController = Optional[RESTController]
+
+    # * Message controller types
+    SyncMessageController = Callable[[str, Message], bool]
+    AsyncMessageController = Callable[[str, Message], Awaitable[bool]]
+    MessageController = Union[SyncMessageController, AsyncMessageController]
+    OptionalMessageController = Optional[MessageController]

{maleo_foundation-0.3.70 → maleo_foundation-0.3.72}/maleo_foundation/managers/client/base.py

@@ -1,8 +1,9 @@
 import httpx
+import os
 from contextlib import asynccontextmanager
 from pydantic import BaseModel, ConfigDict, Field
-from typing import AsyncGenerator, Generator
-from maleo_foundation.types import BaseTypes
+from typing import AsyncGenerator, Generator, Optional
+from maleo_foundation.enums import BaseEnums
 from maleo_foundation.utils.logging import ClientLogger, SimpleConfig
 
 
@@ -107,18 +108,43 @@ class ClientManager:
         key: str,
         name: str,
         log_config: SimpleConfig,
-        service_key: BaseTypes.OptionalString = None,
+        service_environment: Optional[BaseEnums.EnvironmentType] = None,
+        service_key: Optional[BaseEnums.Service] = None,
+        environment: Optional[BaseEnums.EnvironmentType] = None,
     ) -> None:
         self._key = key
         self._name = name
         self._log_config = log_config
-        self._service_key = service_key
+
+        # Ensure environment exists
+        actual_service_environment = service_environment or os.getenv("ENVIRONMENT")
+        if actual_service_environment is None:
+            raise ValueError(
+                "ENVIRONMENT environment variable must be set if 'service_environment' is set to None"
+            )
+        else:
+            self._service_environment = BaseEnums.EnvironmentType(
+                actual_service_environment
+            )
+
+        # Ensure service_key exists
+        actual_service_key = service_key or os.getenv("SERVICE_KEY")
+        if actual_service_key is None:
+            raise ValueError(
+                "SERVICE_KEY environment variable must be set if 'service_key' is set to None"
+            )
+        else:
+            self._service_key = BaseEnums.Service(actual_service_key)
+
+        self._environment = environment
+
         self._initialize_logger()
-        self._logger.info("Initializing client manager")
+        self._logger.info(f"Initializing {self._name} client manager")
 
     def _initialize_logger(self) -> None:
         self._logger = ClientLogger(
             client_key=self._key,
+            environment=self._service_environment,
             service_key=self._service_key,
             **self._log_config.model_dump(),
         )
@@ -131,6 +157,12 @@ class ClientManager:
     def name(self) -> str:
         return self._name
 
+    @property
+    def environment(self) -> BaseEnums.EnvironmentType:
+        if self._environment is None:
+            raise ValueError("Environment has not been initialized.")
+        return self._environment
+
     @property
     def logger(self) -> ClientLogger:
         return self._logger

{maleo_foundation-0.3.70 → maleo_foundation-0.3.72}/maleo_foundation/managers/client/google/base.py

@@ -1,7 +1,7 @@
 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.enums import BaseEnums
 from maleo_foundation.managers.client.base import ClientManager
 from maleo_foundation.utils.loaders.credential.google import GoogleCredentialsLoader
 from maleo_foundation.utils.logging import SimpleConfig
@@ -13,11 +13,15 @@ class GoogleClientManager(ClientManager):
         key: str,
         name: str,
         log_config: SimpleConfig,
-        service_key: BaseTypes.OptionalString = None,
+        service_environment: Optional[BaseEnums.EnvironmentType] = None,
+        service_key: Optional[BaseEnums.Service] = None,
+        environment: Optional[BaseEnums.EnvironmentType] = None,
         credentials: Optional[Credentials] = None,
         credentials_path: Optional[Union[Path, str]] = None,
     ) -> None:
-        super().__init__(key, name, log_config, service_key)
+        super().__init__(
+            key, name, log_config, service_environment, service_key, environment
+        )
         if (credentials is not None and credentials_path is not None) or (
             credentials is None and credentials_path is None
         ):

{maleo_foundation-0.3.70 → maleo_foundation-0.3.72}/maleo_foundation/managers/client/google/secret.py

@@ -4,7 +4,7 @@ from google.cloud import secretmanager
 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.enums import BaseEnums
 from maleo_foundation.utils.logging import SimpleConfig
 from .base import GoogleClientManager
 
@@ -13,14 +13,23 @@ class GoogleSecretManager(GoogleClientManager):
     def __init__(
         self,
         log_config: SimpleConfig,
-        service_key: BaseTypes.OptionalString = None,
+        service_environment: Optional[BaseEnums.EnvironmentType] = None,
+        service_key: Optional[BaseEnums.Service] = None,
+        environment: Optional[BaseEnums.EnvironmentType] = 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, credentials_path
+            key,
+            name,
+            log_config,
+            service_environment,
+            service_key,
+            environment,
+            credentials,
+            credentials_path,
         )
         self._client = secretmanager.SecretManagerServiceClient(
             credentials=self._credentials

{maleo_foundation-0.3.70 → maleo_foundation-0.3.72}/maleo_foundation/managers/client/google/storage.py

@@ -15,7 +15,9 @@ class GoogleCloudStorage(GoogleClientManager):
     def __init__(
         self,
         log_config: SimpleConfig,
-        service_key: BaseTypes.OptionalString = None,
+        service_environment: Optional[BaseEnums.EnvironmentType] = None,
+        service_key: Optional[BaseEnums.Service] = None,
+        environment: Optional[BaseEnums.EnvironmentType] = None,
         credentials: Optional[Credentials] = None,
         credentials_path: Optional[Union[Path, str]] = None,
         bucket_name: BaseTypes.OptionalString = None,
@@ -24,7 +26,14 @@ class GoogleCloudStorage(GoogleClientManager):
         key = "google-cloud-storage"
         name = "GoogleCloudStorage"
         super().__init__(
-            key, name, log_config, service_key, credentials, credentials_path
+            key,
+            name,
+            log_config,
+            service_environment,
+            service_key,
+            environment,
+            credentials,
+            credentials_path,
         )
         self._client = Client(credentials=self._credentials)
         self._bucket_name = bucket_name or os.getenv("GCS_BUCKET_NAME")

{maleo_foundation-0.3.70 → maleo_foundation-0.3.72}/maleo_foundation/managers/client/google/subscription.py

@@ -5,36 +5,37 @@ from google.cloud.pubsub_v1.subscriber.futures import StreamingPullFuture
 from google.cloud.pubsub_v1.subscriber.message import Message
 from google.oauth2.service_account import Credentials
 from pathlib import Path
-from pydantic import BaseModel
-from typing import Awaitable, Callable, Dict, List, Optional, Union, cast
+from typing import Dict, List, Optional, Union, cast
+from maleo_foundation.controller_types import ControllerTypes
+from maleo_foundation.enums import BaseEnums
 from maleo_foundation.managers.client.google.base import GoogleClientManager
-
-SyncController = Callable[[str, Message], bool]
-AsyncController = Callable[[str, Message], Awaitable[bool]]
-Controller = Union[SyncController, AsyncController]
-OptionalController = Optional[Controller]
-
-
-class SubscriptionConfigurations(BaseModel):
-    subscription_name: str
-    max_messages: int = 10
-    ack_deadline: int = 10
-    controller: OptionalController = None
+from maleo_foundation.models.transfers.general.configurations.pubsub.subscription import (
+    ExtendedSubscriptionConfigurations,
+)
 
 
 class SubscriptionManager(GoogleClientManager):
     def __init__(
         self,
-        subscriptions: List[SubscriptionConfigurations],
+        subscriptions: List[ExtendedSubscriptionConfigurations],
         log_config,
-        service_key: Optional[str] = None,
+        service_environment: Optional[BaseEnums.EnvironmentType] = None,
+        service_key: Optional[BaseEnums.Service] = None,
+        environment: Optional[BaseEnums.EnvironmentType] = None,
         credentials: Optional[Credentials] = None,
         credentials_path: Optional[Union[Path, str]] = None,
     ):
         key = "google-subscription-manager"
         name = "GoogleSubscriptionManager"
         super().__init__(
-            key, name, log_config, service_key, credentials, credentials_path
+            key,
+            name,
+            log_config,
+            service_environment,
+            service_key,
+            environment,
+            credentials,
+            credentials_path,
         )
         self.subscriber = pubsub_v1.SubscriberClient(credentials=self._credentials)
         self.subscriptions = subscriptions
@@ -42,19 +43,28 @@ class SubscriptionManager(GoogleClientManager):
         self.loop: Optional[asyncio.AbstractEventLoop] = None
 
     async def _handle_async_controller(
-        self, controller: AsyncController, subscription_name: str, message: Message
+        self,
+        controller: ControllerTypes.AsyncMessageController,
+        subscription_name: str,
+        message: Message,
     ) -> None:
         success = await controller(subscription_name, message)
         message.ack() if success else message.nack()
 
     def _handle_sync_controller(
-        self, controller: SyncController, subscription_name: str, message: Message
+        self,
+        controller: ControllerTypes.SyncMessageController,
+        subscription_name: str,
+        message: Message,
     ) -> None:
         success = controller(subscription_name, message)
         message.ack() if success else message.nack()
 
     def _message_callback(
-        self, controller: OptionalController, subscription_name: str, message: Message
+        self,
+        controller: ControllerTypes.OptionalMessageController,
+        subscription_name: str,
+        message: Message,
     ):
         # If controller is not given, conduct default message processing
         if controller is None:
@@ -68,13 +78,17 @@ class SubscriptionManager(GoogleClientManager):
                 raise RuntimeError("Event loop not set in SubscriptionManager")
             asyncio.run_coroutine_threadsafe(
                 self._handle_async_controller(
-                    cast(AsyncController, controller), subscription_name, message
+                    cast(ControllerTypes.AsyncMessageController, controller),
+                    subscription_name,
+                    message,
                 ),
                 self.loop,
             )
         else:
             self._handle_sync_controller(
-                cast(SyncController, controller), subscription_name, message
+                cast(ControllerTypes.SyncMessageController, controller),
+                subscription_name,
+                message,
             )
 
     def _default_message_processing(
@@ -94,18 +108,18 @@ class SubscriptionManager(GoogleClientManager):
             message.nack()
 
     async def _start_subscription_listener(
-        self, config: SubscriptionConfigurations
+        self, config: ExtendedSubscriptionConfigurations
     ) -> None:
         if self.credentials.project_id is None:
             raise ValueError("Project ID must be set in credentials")
         subscription_path = self.subscriber.subscription_path(
-            self.credentials.project_id, config.subscription_name
+            self.credentials.project_id, config.id
         )
         flow_control = pubsub_v1.types.FlowControl(max_messages=config.max_messages)
         future = self.subscriber.subscribe(
             subscription_path,
             callback=lambda message: self._message_callback(
-                config.controller, config.subscription_name, message
+                config.controller, config.id, message
             ),
             flow_control=flow_control,
             await_callbacks_on_shutdown=True,
@@ -117,7 +131,7 @@ class SubscriptionManager(GoogleClientManager):
             if not isinstance(e, asyncio.CancelledError):
                 self._logger.error(
                     "Listener error for subscription '%s': %s",
-                    config.subscription_name,
+                    config.id,
                     e,
                     exc_info=True,
                 )

{maleo_foundation-0.3.70 → maleo_foundation-0.3.72}/maleo_foundation/managers/client/maleo.py

@@ -74,7 +74,9 @@ class MaleoClientManager(ClientManager):
             key,
             name,
             service_manager.log_config,
-            service_manager.configurations.service.key,
+            service_manager.settings.ENVIRONMENT,
+            service_manager.settings.SERVICE_KEY,
+            environment,
         )
         self._environment = environment
 
@@ -82,10 +84,6 @@ class MaleoClientManager(ClientManager):
     def service_manager(self) -> ServiceManager:
         return self._service_manager
 
-    @property
-    def environment(self) -> BaseEnums.EnvironmentType:
-        return self._environment
-
     def _initialize_controllers(self) -> None:
         # * Initialize managers
         http_controller_manager = ClientHTTPControllerManager(url=self._url)

{maleo_foundation-0.3.70 → maleo_foundation-0.3.72}/maleo_foundation/managers/credential.py

@@ -9,9 +9,13 @@ from maleo_foundation.utils.logging import SimpleConfig
 
 
 class CredentialManager:
-    def __init__(self, settings: Settings, log_config: SimpleConfig):
-        self.settings = settings
+    def __init__(
+        self,
+        log_config: SimpleConfig,
+        settings: Settings,
+    ):
         self.log_config = log_config
+        self.settings = settings
         self._initialize()
 
     def _load_google_credentials(self) -> None:

{maleo_foundation-0.3.70 → maleo_foundation-0.3.72}/maleo_foundation/managers/service.py

@@ -51,16 +51,14 @@ class ServiceManager:
         self,
         db_metadata: MetaData,
         log_config: SimpleConfig,
-        settings: Optional[Settings] = None,
+        settings: Settings,
         additional_topics_configurations: Optional[
             AdditionalTopicsConfigurations
         ] = None,
     ):
         self._db_metadata = db_metadata  # * Declare DB Metadata
         self._log_config = log_config  # * Declare log config
-        self._settings = (
-            settings if settings is not None else Settings()  # type: ignore
-        )  # * Initialize settings
+        self._settings = settings  # * Initialize settings
 
         # * Disable google cloud logging if environment is local
         if self._settings.ENVIRONMENT == "local":
@@ -134,22 +132,34 @@ class ServiceManager:
 
     def _initialize_loggers(self) -> None:
         application = ApplicationLogger(
-            service_key=self.configurations.service.key, **self._log_config.model_dump()
+            environment=self.settings.ENVIRONMENT,
+            service_key=self.settings.SERVICE_KEY,
+            **self._log_config.model_dump(),
         )
         cache = CacheLogger(
-            service_key=self.configurations.service.key, **self._log_config.model_dump()
+            environment=self.settings.ENVIRONMENT,
+            service_key=self.settings.SERVICE_KEY,
+            **self._log_config.model_dump(),
         )
         database = DatabaseLogger(
-            service_key=self.configurations.service.key, **self._log_config.model_dump()
+            environment=self.settings.ENVIRONMENT,
+            service_key=self.settings.SERVICE_KEY,
+            **self._log_config.model_dump(),
         )
         middleware = MiddlewareLogger(
-            service_key=self.configurations.service.key, **self._log_config.model_dump()
+            environment=self.settings.ENVIRONMENT,
+            service_key=self.settings.SERVICE_KEY,
+            **self._log_config.model_dump(),
         )
         repository = RepositoryLogger(
-            service_key=self.configurations.service.key, **self._log_config.model_dump()
+            environment=self.settings.ENVIRONMENT,
+            service_key=self.settings.SERVICE_KEY,
+            **self._log_config.model_dump(),
         )
         service = ServiceLogger(
-            service_key=self.configurations.service.key, **self._log_config.model_dump()
+            environment=self.settings.ENVIRONMENT,
+            service_key=self.settings.SERVICE_KEY,
+            **self._log_config.model_dump(),
         )
         self._loggers = Loggers(
             application=application,
@@ -166,8 +176,8 @@ class ServiceManager:
 
     async def _clear_cache(self) -> None:
         prefixes = [
-            self.configurations.service.key,
-            f"google-cloud-storage:{self.configurations.service.key}",
+            self.settings.SERVICE_KEY,
+            f"google-cloud-storage:{self.settings.SERVICE_KEY}",
         ]
         for prefix in prefixes:
             async for key in self._redis.scan_iter(f"{prefix}*"):
@@ -243,7 +253,9 @@ class ServiceManager:
 
     def _initialize_foundation(self) -> None:
         self._foundation = MaleoFoundationClientManager(
-            log_config=self._log_config, service_key=self._settings.SERVICE_KEY
+            log_config=self._log_config,
+            service_environment=self._settings.ENVIRONMENT,
+            service_key=self._settings.SERVICE_KEY,
         )
 
     @property

{maleo_foundation-0.3.70 → maleo_foundation-0.3.72}/maleo_foundation/models/schemas/general.py

@@ -8,6 +8,12 @@ from maleo_foundation.types import BaseTypes
 
 
 class BaseGeneralSchemas:
+    class ServiceContext(BaseModel):
+        key: BaseEnums.Service = Field(..., description="Service's key")
+        environment: BaseEnums.EnvironmentType = Field(
+            ..., description="Service's environment"
+        )
+
     class DateFilter(BaseModel):
         name: str = Field(..., description="Column name.")
         from_date: BaseTypes.OptionalDatetime = Field(None, description="From date.")
@@ -95,12 +101,6 @@ class BaseGeneralSchemas:
 
             return self
 
-    class OperationServiceContext(BaseModel):
-        key: BaseEnums.Service = Field(..., description="Service's key")
-        environment: BaseEnums.EnvironmentType = Field(
-            ..., description="Service's environment"
-        )
-
     class OperationTimestamps(BaseModel):
         started_at: BaseTypes.OptionalDatetime = Field(
             None, description="Started at timestamp (Optional)"
@@ -139,12 +139,8 @@ class BaseGeneralSchemas:
 
     class DatabaseOperationResult(BaseModel):
         data_id: int = Field(..., ge=1, description="Data's ID")
-        old_data: BaseTypes.OptionalStringToAnyDict = Field(
-            None, description="Old data"
-        )
-        new_data: BaseTypes.OptionalStringToAnyDict = Field(
-            None, description="New data"
-        )
+        old_data: BaseTypes.OptionalAny = Field(None, description="Old data")
+        new_data: BaseTypes.OptionalAny = Field(None, description="New data")
 
         @model_validator(mode="after")
         def validate_data(self) -> Self:

{maleo_foundation-0.3.70 → maleo_foundation-0.3.72}/maleo_foundation/models/transfers/general/configurations/client/maleo.py

@@ -7,7 +7,7 @@ class MaleoClientConfigurations(BaseModel):
     environment: BaseEnums.EnvironmentType = Field(
         ..., description="Client's environment"
     )
-    key: str = Field(..., description="Client's key")
+    key: BaseEnums.Service = Field(..., description="Client's key")
     name: str = Field(..., description="Client's name")
     url: str = Field(..., description="Client's URL")
 

maleo_foundation-0.3.72/maleo_foundation/models/transfers/general/configurations/pubsub/subscription.py

@@ -0,0 +1,16 @@
+from pydantic import BaseModel, ConfigDict, Field
+from maleo_foundation.controller_types import ControllerTypes
+
+
+class SubscriptionConfigurations(BaseModel):
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    id: str = Field(..., description="Subscription's ID")
+    max_messages: int = Field(10, description="Subscription's Max messages")
+    ack_deadline: int = Field(10, description="Subscription's ACK deadline")
+
+
+class ExtendedSubscriptionConfigurations(SubscriptionConfigurations):
+    controller: ControllerTypes.OptionalMessageController = Field(
+        None, description="Optional message controller"
+    )

{maleo_foundation-0.3.70 → maleo_foundation-0.3.72}/maleo_foundation/models/transfers/general/configurations/service.py

@@ -1,8 +1,9 @@
 from pydantic import BaseModel, Field
+from maleo_foundation.enums import BaseEnums
 
 
 class ServiceConfigurations(BaseModel):
-    key: str = Field(..., description="Service's key")
+    key: BaseEnums.Service = Field(..., description="Service's key")
     name: str = Field(..., description="Service's name")
     host: str = Field(..., description="Service's host")
     port: int = Field(..., description="Service's port")

{maleo_foundation-0.3.70 → maleo_foundation-0.3.72}/maleo_foundation/models/transfers/general/operation.py

@@ -10,7 +10,7 @@ class Operation(BaseModel):
     request_context: RequestContext = Field(..., description="Request context")
     authentication: Authentication = Field(..., description="Authentication")
     authorization: Optional[Authorization] = Field(None, description="Authorization")
-    service: BaseGeneralSchemas.OperationServiceContext = Field(
+    service: BaseGeneralSchemas.ServiceContext = Field(
         ..., description="Service's context"
     )
     timestamps: BaseGeneralSchemas.OperationTimestamps = Field(
@@ -34,7 +34,7 @@ class DatabaseOperation(BaseModel):
     request_context: RequestContext = Field(..., description="Request context")
     authentication: Authentication = Field(..., description="Authentication")
     authorization: Optional[Authorization] = Field(None, description="Authorization")
-    service: BaseGeneralSchemas.OperationServiceContext = Field(
+    service: BaseGeneralSchemas.ServiceContext = Field(
         ..., description="Service's context"
     )
     timestamps: BaseGeneralSchemas.OperationTimestamps = Field(

{maleo_foundation-0.3.70 → maleo_foundation-0.3.72}/maleo_foundation/models/transfers/general/settings.py

@@ -7,7 +7,7 @@ from maleo_foundation.types import BaseTypes
 
 class Settings(BaseSettings):
     ENVIRONMENT: BaseEnums.EnvironmentType = Field(..., description="Environment")
-    SERVICE_KEY: str = Field(..., description="Service's key")
+    SERVICE_KEY: BaseEnums.Service = Field(..., description="Service's key")
     ROOT_PATH: str = Field("", description="Application's root path")
     GOOGLE_CREDENTIALS_PATH: str = Field(
         "/credentials/maleo-google-service-account.json",