maleo-foundation 0.3.71__py3-none-any.whl → 0.3.74__py3-none-any.whl

maleo_foundation/authentication.py

@@ -1,17 +1,6 @@
-from pydantic import BaseModel, ConfigDict, Field, model_validator
 from starlette.authentication import AuthCredentials, BaseUser
-from typing import Optional, Self, Sequence
-from maleo_foundation.enums import BaseEnums
-from maleo_foundation.models.transfers.general.token import (
-    MaleoFoundationTokenGeneralTransfers,
-)
-
-
-class Token(BaseModel):
-    type: BaseEnums.TokenType = Field(..., description="Token's type")
-    payload: MaleoFoundationTokenGeneralTransfers.DecodePayload = Field(
-        ..., description="Token's payload"
-    )
+from typing import Optional, Sequence
+from maleo_foundation.models.transfers.general.authentication import Token
 
 
 class Credentials(AuthCredentials):
@@ -26,11 +15,6 @@ class Credentials(AuthCredentials):
         return self._token
 
 
-class CredentialsModel(BaseModel):
-    token: Optional[Token] = Field(None, description="Token")
-    scopes: Optional[Sequence[str]] = Field(None, description="Scopes")
-
-
 class User(BaseUser):
     def __init__(
         self, authenticated: bool = False, username: str = "", email: str = ""
@@ -50,33 +34,3 @@ class User(BaseUser):
     @property
     def identity(self) -> str:
         return self._email
-
-
-class UserModel(BaseModel):
-    is_authenticated: bool = Field(False, description="Authenticated")
-    display_name: str = Field("", description="Username")
-    identity: str = Field("", description="Email")
-
-
-class Authentication(BaseModel):
-    model_config = ConfigDict(arbitrary_types_allowed=True)
-
-    credentials: Credentials = Field(
-        ..., description="Credentials's information", exclude=True
-    )
-    credentials_model: CredentialsModel = Field(
-        default_factory=CredentialsModel,  # type: ignore
-        description="Credential's model",
-        serialization_alias="credentials",
-    )
-    user: User = Field(..., description="User's information", exclude=True)
-    user_model: UserModel = Field(default_factory=UserModel, description="User's model", serialization_alias="user")  # type: ignore
-
-    @model_validator(mode="after")
-    def define_models(self) -> Self:
-        self.credentials_model.token = self.credentials.token
-        self.credentials_model.scopes = self.credentials.scopes
-        self.user_model.is_authenticated = self.user.is_authenticated
-        self.user_model.display_name = self.user.display_name
-        self.user_model.identity = self.user.identity
-        return self

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/constants.py

@@ -1,9 +1,11 @@
 import re
+from fastapi.security import HTTPBearer
 from typing import List
 from uuid import UUID
 from maleo_foundation.enums import BaseEnums
 from maleo_foundation.types import BaseTypes
 
+TOKEN_SCHEME = HTTPBearer()
 EMAIL_REGEX: str = r"^[^\s@]+@[^\s@]+\.[^\s@]+$"
 TOKEN_COOKIE_KEY_NAME = "token"
 REFRESH_TOKEN_DURATION_DAYS: int = 7

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/enums.py

@@ -69,10 +69,12 @@ class BaseEnums:
 
     class ExceptionType(StrEnum):
         TIMEOUT = "timeout"
+        BAD = "bad"
         UNAUTHORIZED = "unauthorized"
         FORBIDDEN = "forbidden"
         NOT_FOUND = "not_found"
         VALIDATION = "validation"
+        RATE_LIMIT = "rate_limit"
         INTERNAL = "internal"
         UNAVAILABLE = "unavailable"
 
@@ -91,6 +93,7 @@ class BaseEnums:
         SERVICE = "service"
 
     class OperationLayer(StrEnum):
+        MIDDLEWARE = "middleware"
         ROUTER = "router"
         CONTROLLER = "controller"
         SERVICE = "service"
@@ -122,6 +125,7 @@ class BaseEnums:
         READ = "read"
         UPDATE = "update"
         DELETE = "delete"
+        OTHER = "other"
 
     class CreateType(StrEnum):
         CREATE = "create"
@@ -185,12 +189,14 @@ class BaseEnums:
         APPLICATION = "application"
         CACHE = "cache"
         CLIENT = "client"
+        CONTROLLER = "controller"
         DATABASE = "database"
         MIDDLEWARE = "middleware"
         REPOSITORY = "repository"
+        ROUTER = "router"
         SERVICE = "service"
 
-    class LoggerLevel(IntEnum):
+    class LogLevel(IntEnum):
         CRITICAL = logging.CRITICAL
         FATAL = logging.FATAL
         ERROR = logging.ERROR

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

@@ -4,6 +4,7 @@ from maleo_foundation.models.schemas import BaseGeneralSchemas
 from maleo_foundation.models.transfers.general.configurations.middleware import (
     MiddlewareConfigurations,
 )
+from maleo_foundation.models.transfers.general.settings import Settings
 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
@@ -14,12 +15,14 @@ class MiddlewareManager:
     def __init__(
         self,
         app: FastAPI,
+        settings: Settings,
         configurations: MiddlewareConfigurations,
         keys: BaseGeneralSchemas.RSAKeys,
         logger: MiddlewareLogger,
         maleo_foundation: MaleoFoundationClientManager,
     ):
         self._app = app
+        self._settings = settings
         self._configurations = configurations
         self._keys = keys
         self._logger = logger
@@ -33,23 +36,20 @@ class MiddlewareManager:
     def add_cors(self) -> None:
         add_cors_middleware(
             app=self._app,
-            allow_origins=self._configurations.general.allow_origins,
-            allow_methods=self._configurations.general.allow_methods,
-            allow_headers=self._configurations.general.allow_headers,
-            allow_credentials=self._configurations.general.allow_credentials,
+            allow_origins=self._configurations.cors.allow_origins,
+            allow_methods=self._configurations.cors.allow_methods,
+            allow_headers=self._configurations.cors.allow_headers,
+            allow_credentials=self._configurations.cors.allow_credentials,
             expose_headers=self._configurations.cors.expose_headers,
         )
 
     def add_base(self):
         add_base_middleware(
             app=self._app,
+            settings=self._settings,
             keys=self._keys,
             logger=self._logger,
             maleo_foundation=self._maleo_foundation,
-            allow_origins=self._configurations.general.allow_origins,
-            allow_methods=self._configurations.general.allow_methods,
-            allow_headers=self._configurations.general.allow_headers,
-            allow_credentials=self._configurations.general.allow_credentials,
             limit=self._configurations.base.limit,
             window=self._configurations.base.window,
             cleanup_interval=self._configurations.base.cleanup_interval,