maleo-foundation 0.3.4__py3-none-any.whl → 0.3.6__py3-none-any.whl

maleo_foundation/constants.py

@@ -26,11 +26,11 @@ STATUS_UPDATE_CRITERIAS: dict[
     ]
 }
 IDENTIFIER_TYPE_VALUE_TYPE_MAP: dict[
-    BaseEnums.IdentifierTypes,
+    BaseEnums.IdentifierType,
     object
 ] = {
-    BaseEnums.IdentifierTypes.ID: int,
-    BaseEnums.IdentifierTypes.UUID: UUID
+    BaseEnums.IdentifierType.ID: int,
+    BaseEnums.IdentifierType.UUID: UUID
 }
 ALL_STATUSES: List[BaseEnums.StatusType] = [
     BaseEnums.StatusType.ACTIVE,

maleo_foundation/enums.py

@@ -16,6 +16,22 @@ class BaseEnums:
         CORE = "core"
         AI = "ai"
 
+    class ShortService(StrEnum):
+        STUDIO = "studio"
+        NEXUS = "nexus"
+        TELEMETRY = "telemetry"
+        METADATA = "metadata"
+        IDENTITY = "identity"
+        ACCESS = "access"
+        WORKSHOP = "workshop"
+        SOAPIE = "soapie"
+        MEDIX = "medix"
+        DICOM = "dicom"
+        SCRIBE = "scribe"
+        CDS = "cds"
+        IMAGING = "imaging"
+        MCU = "mcu"
+
     class Service(StrEnum):
         MALEO_STUDIO = "maleo-studio"
         MALEO_NEXUS = "maleo-nexus"
@@ -66,12 +82,13 @@ class BaseEnums:
         RESTORE = "restore"
         DELETE = "delete"
 
-    class IdentifierTypes(StrEnum):
+    class IdentifierType(StrEnum):
         ID = "id"
         UUID = "uuid"
 
     class ServiceControllerType(StrEnum):
         REST = "rest"
+        MESSAGE = "message"
 
     class ClientControllerType(StrEnum):
         HTTP = "http"
@@ -109,10 +126,6 @@ class BaseEnums:
                 BaseEnums.RESTControllerResponseType.FILE: responses.FileResponse,
             }.get(self, responses.Response)
 
-    class MiddlewareLoggerType(StrEnum):
-        BASE = "base"
-        AUTHENTICATION = "authentication"
-
     class ServiceLoggerType(StrEnum):
         REPOSITORY = "repository"
         DATABASE = "database"

maleo_foundation/managers/cache.py

@@ -0,0 +1,9 @@
+from __future__ import annotations
+from pydantic import BaseModel, Field
+from redis.asyncio.client import Redis
+
+class CacheManagers(BaseModel):
+    redis:Redis = Field(..., description="Redis client")
+
+    class Config:
+        arbitrary_types_allowed=True

maleo_foundation/managers/client/google/subscription.py

@@ -0,0 +1,140 @@
+import asyncio
+import inspect
+from google.cloud import pubsub_v1
+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
+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 = 30
+    controller: OptionalController = None
+
+class SubscriptionManager(GoogleClientManager):
+    def __init__(
+        self,
+        subscriptions: List[SubscriptionConfigurations],
+        log_config,
+        service_key: Optional[str] = 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)
+        self.subscriber = pubsub_v1.SubscriberClient(credentials=self._credentials)
+        self.subscriptions = subscriptions
+        self.active_listeners: Dict[str, StreamingPullFuture] = {}
+        self.loop: Optional[asyncio.AbstractEventLoop] = None
+
+    async def _handle_async_controller(
+        self,
+        controller: AsyncController,
+        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
+    ) -> None:
+        success = controller(subscription_name, message)
+        message.ack() if success else message.nack()
+
+    def _message_callback(
+        self,
+        controller: OptionalController,
+        subscription_name: str,
+        message: Message
+    ):
+        # If controller is not given, conduct default message processing
+        if controller is None:
+            self._default_message_processing(subscription_name, message)
+            return
+
+        # Check controller function type and handle accordingly
+        is_async_controller = inspect.iscoroutinefunction(controller)
+        if is_async_controller:
+            if not self.loop:
+                raise RuntimeError("Event loop not set in SubscriptionManager")
+            asyncio.run_coroutine_threadsafe(
+                self._handle_async_controller(
+                    controller,
+                    subscription_name,
+                    message
+                ),
+                self.loop
+            )
+        else:
+            self._handle_sync_controller(
+                controller,
+                subscription_name,
+                message
+            )
+
+    def _default_message_processing(
+        self,
+        subscription_name: str,
+        message: Message
+    ) -> None:
+        try:
+            self._logger.info("Default message processing for subscription '%s': %s", subscription_name, message.data.decode("utf-8"))
+            message.ack()
+        except Exception as e:
+            self._logger.error("Error handling message through default processor: %s", e, exc_info=True)
+            message.nack()
+
+    async def _start_subscription_listener(
+        self,
+        config: SubscriptionConfigurations
+    ) -> None:
+        subscription_path = self.subscriber.subscription_path(self.credentials.project_id, config.subscription_name)
+        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
+            ),
+            flow_control=flow_control,
+            await_callbacks_on_shutdown=True
+        )
+        self.active_listeners[subscription_path] = future
+        try:
+            await asyncio.get_event_loop().run_in_executor(None, future.result)
+        except Exception as e:
+            if not isinstance(e, asyncio.CancelledError):
+                self._logger.error("Listener error for subscription '%s': %s", config.subscription_name, e, exc_info=True)
+
+    async def start_listeners(
+        self,
+        loop: asyncio.AbstractEventLoop
+    ) -> None:
+        self.loop = loop
+        for config in self.subscriptions:
+            asyncio.create_task(self._start_subscription_listener(config))
+        await asyncio.sleep(0.1)
+
+    async def stop_listeners(self):
+        for future in self.active_listeners.values():
+            future.cancel()
+            try:
+                future.result()
+            except Exception:
+                pass
+        self.active_listeners.clear()

maleo_foundation/managers/configuration.py

@@ -0,0 +1,102 @@
+from pathlib import Path
+from maleo_foundation.models.transfers.general.configurations.cache.redis import (
+    RedisCacheNamespaces,
+    RedisCacheConfigurations
+)
+from maleo_foundation.models.transfers.general.configurations.cache \
+    import CacheConfigurations
+from maleo_foundation.models.transfers.general.configurations.database \
+    import DatabaseConfigurations
+from maleo_foundation.models.transfers.general.configurations import (
+    RuntimeConfigurations,
+    StaticConfigurations,
+    Configurations
+)
+from maleo_foundation.models.transfers.general.settings import Settings
+from maleo_foundation.utils.loaders.yaml import YAMLLoader
+from maleo_foundation.utils.merger import deep_merge
+from .credential import CredentialManager
+
+class ConfigurationManager:
+    def __init__(
+        self,
+        settings: Settings,
+        credential_manager: CredentialManager
+    ):
+        self.settings = settings
+        self.credential_manager = credential_manager
+
+        self._load_configs()
+
+    def _load_static_configurations(self) -> StaticConfigurations:
+        config_path = Path(self.settings.STATIC_CONFIGURATIONS_PATH)
+        
+        if config_path.exists() and config_path.is_file():
+            data = YAMLLoader.load_from_path(str(config_path))
+        else:
+            secret_data = self.credential_manager.secret_manager.get(
+                f"maleo-static-config-{self.settings.ENVIRONMENT}"
+            )
+            data = YAMLLoader.load_from_string(secret_data)
+        
+        return StaticConfigurations.model_validate(data)
+    
+    def _load_runtime_configurations(self) -> RuntimeConfigurations:
+        config_path = Path(self.settings.RUNTIME_CONFIGURATIONS_PATH)
+        
+        if config_path.exists() and config_path.is_file():
+            data = YAMLLoader.load_from_path(str(config_path))
+        else:
+            secret_data = self.credential_manager.secret_manager.get(
+                f"{self.settings.SERVICE_KEY}-runtime-config-{self.settings.ENVIRONMENT}"
+            )
+            data = YAMLLoader.load_from_string(secret_data)
+        
+        return RuntimeConfigurations.model_validate(data)
+    
+    def _load_cache_configurations(self) -> CacheConfigurations:
+        namespaces = RedisCacheNamespaces(base=self.settings.SERVICE_KEY)
+        host = self.credential_manager.secret_manager.get(
+            f"maleo-redis-host-{self.settings.ENVIRONMENT}"
+        )
+        password = self.credential_manager.secret_manager.get(
+            f"maleo-redis-password-{self.settings.ENVIRONMENT}"
+        )
+        redis = RedisCacheConfigurations(
+            namespaces=namespaces, 
+            host=host, 
+            password=password
+        )
+        return CacheConfigurations(redis=redis)
+    
+    def _load_database_configurations(self, database_name: str) -> DatabaseConfigurations:
+        password = self.credential_manager.secret_manager.get(
+            f"maleo-db-password-{self.settings.ENVIRONMENT}"
+        )
+        host = self.credential_manager.secret_manager.get(
+            f"maleo-db-host-{self.settings.ENVIRONMENT}"
+        )
+        return DatabaseConfigurations(
+            password=password,
+            host=host,
+            database=database_name
+        )
+
+    def _load_configs(self) -> None:
+        static_configs = self._load_static_configurations()
+        runtime_configs = self._load_runtime_configurations()
+        cache_configs = self._load_cache_configurations()
+        database_configs = self._load_database_configurations(runtime_configs.database)
+        
+        merged_configs = deep_merge(
+            static_configs.model_dump(),
+            runtime_configs.model_dump(exclude={"database"}),
+            {"cache": cache_configs.model_dump()},
+            {"database": database_configs.model_dump()}
+        )
+        
+        self._configs = Configurations.model_validate(merged_configs)
+
+    @property
+    def configs(self) -> Configurations:
+        return self._configs

maleo_foundation/managers/credential.py

@@ -0,0 +1,82 @@
+from google.oauth2.service_account import Credentials
+from uuid import UUID
+from maleo_foundation.enums import BaseEnums
+from maleo_foundation.managers.client.google.secret import GoogleSecretManager
+from maleo_foundation.models.transfers.general.credentials import MaleoCredentials
+from maleo_foundation.models.transfers.general.settings import Settings
+from maleo_foundation.utils.loaders.credential.google import GoogleCredentialsLoader
+from maleo_foundation.utils.logging import SimpleConfig
+
+class CredentialManager:
+    def __init__(
+        self,
+        settings: Settings,
+        log_config: SimpleConfig
+    ):
+        self.settings = settings
+        self.log_config = log_config
+        self._initialize()
+
+    def _load_google_credentials(self) -> None:
+        """Load Google service account credentials with validation."""
+        try:
+            self._google_credentials = GoogleCredentialsLoader.load(
+                credentials_path=self.settings.GOOGLE_CREDENTIALS_PATH
+            )
+
+            # Validate the loaded credentials
+            GoogleCredentialsLoader.validate_credentials(self._google_credentials)
+
+        except Exception as e:
+            raise RuntimeError(f"Failed to load Google credentials: {str(e)}")
+
+    def _initialize_secret_manager(self) -> None:
+        self._secret_manager = GoogleSecretManager(
+            log_config=self.log_config,
+            service_key=self.settings.SERVICE_KEY,
+            credentials=self._google_credentials
+        )
+
+    def _get_environment_for_credentials(self) -> str:
+        return (
+            BaseEnums.EnvironmentType.STAGING
+            if self.settings.ENVIRONMENT == BaseEnums.EnvironmentType.LOCAL
+            else self.settings.ENVIRONMENT
+        )
+
+    def _load_maleo_credentials(self) -> None:
+        environment = self._get_environment_for_credentials()
+        
+        try:
+            id = int(self._secret_manager.get(f"maleo-service-account-id-{environment}"))
+            uuid = UUID(self._secret_manager.get(f"maleo-service-account-uuid-{environment}"))
+            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(
+                id=id,
+                uuid=uuid,
+                username=username,
+                email=email,
+                password=password
+            )
+        except Exception as e:
+            raise RuntimeError(f"Failed to load Maleo credentials: {str(e)}")
+
+    def _initialize(self):
+        self._load_google_credentials()
+        self._initialize_secret_manager()
+        self._load_maleo_credentials()
+
+    @property
+    def google_credentials(self) -> Credentials:
+        return self._google_credentials
+    
+    @property
+    def secret_manager(self) -> GoogleSecretManager:
+        return self._secret_manager
+    
+    @property
+    def maleo_credentials(self) -> MaleoCredentials:
+        return self._maleo_credentials

maleo_foundation/managers/middleware.py

@@ -1,57 +1,26 @@
 from fastapi import FastAPI
-from pydantic import BaseModel, Field
-from typing import List
 from maleo_foundation.client.manager import MaleoFoundationClientManager
 from maleo_foundation.models.schemas import BaseGeneralSchemas
+from maleo_foundation.models.transfers.general.configurations.middleware \
+    import MiddlewareConfigurations
 from maleo_foundation.middlewares.authentication import add_authentication_middleware
 from maleo_foundation.middlewares.base import add_base_middleware
 from maleo_foundation.middlewares.cors import add_cors_middleware
 from maleo_foundation.utils.logging import MiddlewareLogger
 
-_ALLOW_METHODS: List[str] = ["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"]
-_ALLOW_HEADERS: List[str] = ["X-Organization", "X-User", "X-Signature"]
-_EXPOSE_HEADERS: List[str] = ["X-Request-Timestamp", "X-Response-Timestamp", "X-Process-Time", "X-Signature"]
-
-class GeneralMiddlewareConfigurations(BaseModel):
-    allow_origins: List[str] = Field(default_factory=list, description="Allowed origins")
-    allow_methods: List[str] = Field(_ALLOW_METHODS, description="Allowed methods")
-    allow_headers: list[str] = Field(_ALLOW_HEADERS, description="Allowed headers")
-    allow_credentials: bool = Field(True, description="Allowed credentials")
-
-class CORSMiddlewareConfigurations(BaseModel):
-    expose_headers: List[str] = Field(_EXPOSE_HEADERS, description="Exposed headers")
-
-class BaseMiddlewareConfigurations(BaseModel):
-    limit: int = Field(10, description="Request limit (per 'window' seconds)")
-    window: int = Field(1, description="Request limit window (seconds)")
-    cleanup_interval: int = Field(60, description="Interval for middleware cleanup (seconds)")
-    ip_timeout: int = Field(300, description="Idle IP's timeout (seconds)")
-
-class MiddlewareConfigurations(BaseModel):
-    general: GeneralMiddlewareConfigurations = Field(..., description="Middleware's general configurations")
-    cors: CORSMiddlewareConfigurations = Field(..., description="CORS middleware's configurations")
-    base: BaseMiddlewareConfigurations = Field(..., description="Base middleware's configurations")
-
-class MiddlewareLoggers(BaseModel):
-    base: MiddlewareLogger = Field(..., description="Base middleware's logger")
-    authentication: MiddlewareLogger = Field(..., description="Authentication middleware's logger")
-
-    class Config:
-        arbitrary_types_allowed=True
-
 class MiddlewareManager:
     def __init__(
         self,
         app: FastAPI,
         configurations: MiddlewareConfigurations,
         keys: BaseGeneralSchemas.RSAKeys,
-        loggers: MiddlewareLoggers,
+        logger: MiddlewareLogger,
         maleo_foundation: MaleoFoundationClientManager
     ):
         self._app = app
         self._configurations = configurations
         self._keys = keys
-        self._loggers = loggers
+        self._logger = logger
         self._maleo_foundation = maleo_foundation
 
     def add_all(self):
@@ -73,7 +42,7 @@ class MiddlewareManager:
         add_base_middleware(
             app=self._app,
             keys=self._keys,
-            logger=self._loggers.base,
+            logger=self._logger,
             maleo_foundation=self._maleo_foundation,
             allow_origins=self._configurations.general.allow_origins,
             allow_methods=self._configurations.general.allow_methods,
@@ -89,6 +58,5 @@ class MiddlewareManager:
         add_authentication_middleware(
             app=self._app,
             keys=self._keys,
-            logger=self._loggers.authentication,
             maleo_foundation=self._maleo_foundation
         )