maleo-foundation 0.3.46__py3-none-any.whl → 0.3.48__py3-none-any.whl

maleo_foundation/managers/client/google/base.py

@@ -6,6 +6,7 @@ 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):
     def __init__(
         self,
@@ -14,11 +15,15 @@ class GoogleClientManager(ClientManager):
         log_config: SimpleConfig,
         service_key: BaseTypes.OptionalString = None,
         credentials: Optional[Credentials] = None,
-        credentials_path: Optional[Union[Path, str]] = None
+        credentials_path: Optional[Union[Path, str]] = None,
     ) -> None:
         super().__init__(key, name, log_config, service_key)
-        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 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
@@ -33,4 +38,6 @@ class GoogleClientManager(ClientManager):
 
     @property
     def project_id(self) -> str:
-        return self._project_id
+        if self._project_id is None:
+            raise ValueError("Project ID has not been initialized.")
+        return self._project_id

maleo_foundation/managers/client/google/parameter.py

@@ -1,5 +1,3 @@
-from google.api_core import retry
-from google.api_core.exceptions import NotFound
 from google.cloud import parametermanager
 from google.oauth2.service_account import Credentials
 from pathlib import Path
@@ -8,33 +6,33 @@ from maleo_foundation.types import BaseTypes
 from maleo_foundation.utils.logging import SimpleConfig
 from .base import GoogleClientManager
 
+
 class GoogleParameterManager(GoogleClientManager):
     def __init__(
         self,
         log_config: SimpleConfig,
         service_key: BaseTypes.OptionalString = None,
         credentials: Optional[Credentials] = None,
-        credentials_path: Optional[Union[Path, str]] = None
+        credentials_path: Optional[Union[Path, str]] = None,
     ) -> None:
         key = "google-parameter-manager"
         name = "GoogleParameterManager"
         super().__init__(
-            key,
-            name,
-            log_config,
-            service_key,
-            credentials,
-            credentials_path
+            key, name, log_config, service_key, credentials, credentials_path
+        )
+        self._client = parametermanager.ParameterManagerClient(
+            credentials=self._credentials
         )
-        self._client = parametermanager.ParameterManagerClient(credentials=self._credentials)
         self._logger.info("Client manager initialized successfully")
 
     @property
     def client(self) -> parametermanager.ParameterManagerClient:
+        if self._client is None:
+            raise ValueError("Client has not been initialized.")
         return self._client
 
     def dispose(self) -> None:
         if self._client is not None:
             self._logger.info("Disposing client manager")
             self._client = None
-            self._logger.info("Client manager disposed successfully")
+            self._logger.info("Client manager disposed successfully")

maleo_foundation/managers/client/google/secret.py

@@ -8,44 +8,39 @@ from maleo_foundation.types import BaseTypes
 from maleo_foundation.utils.logging import SimpleConfig
 from .base import GoogleClientManager
 
+
 class GoogleSecretManager(GoogleClientManager):
     def __init__(
         self,
         log_config: SimpleConfig,
         service_key: BaseTypes.OptionalString = None,
         credentials: Optional[Credentials] = None,
-        credentials_path: Optional[Union[Path, str]] = 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_key, credentials, credentials_path
+        )
+        self._client = secretmanager.SecretManagerServiceClient(
+            credentials=self._credentials
         )
-        self._client = secretmanager.SecretManagerServiceClient(credentials=self._credentials)
         self._logger.info("Client manager initialized successfully")
 
     @property
     def client(self) -> secretmanager.SecretManagerServiceClient:
+        if self._client is None:
+            raise ValueError("Client has not been initialized.")
         return self._client
 
     def dispose(self) -> None:
         if self._client is not None:
             self._logger.info("Disposing client manager")
-            self._client = None
             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"
-    ) -> str:
-        #* Check if secret exists
+    def get(self, name: str, version: str = "latest") -> str:
+        # * Check if secret exists
         secret_name = f"projects/{self._project_id}/secrets/{name}"
         try:
             request = secretmanager.GetSecretRequest(name=secret_name)
@@ -54,59 +49,82 @@ class GoogleSecretManager(GoogleClientManager):
             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)
+            self._logger.error(
+                "Exception raised while checking secret '%s' existence",
+                name,
+                exc_info=True,
+            )
             raise
 
-        #* Check if secret's version exists
+        # * 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)
+            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)
+            self._logger.error(
+                "Exception raised while checking secret '%s' with version '%s' existence",
+                name,
+                version,
+                exc_info=True,
+            )
             raise
 
-        #* Access secret's version
+        # * 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)
+            self._logger.info(
+                "Successfully retrieved secret '%s' with version '%s'", name, version
+            )
             return response.payload.data.decode()
         except Exception:
-            self._logger.error("Exception occured while retrieving secret '%s' with version '%s'", name, version, exc_info=True)
+            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
-    ) -> 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
+            # * 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
+            # * 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)
+                request = secretmanager.CreateSecretRequest(
+                    parent=parent, secret_id=name, secret=secret
+                )
                 self._client.create_secret(request=request)
             except Exception:
                 self._logger.error("Exception occured while creating secret '%s'", name)
                 raise
 
-        #* Add a new secret version
+        # * Add a new secret version
         try:
             payload = secretmanager.SecretPayload(data=data.encode())
-            request = secretmanager.AddSecretVersionRequest(parent=secret_path, payload=payload)
-            response = self._client.add_secret_version(request=request)
+            request = secretmanager.AddSecretVersionRequest(
+                parent=secret_path, payload=payload
+            )
+            self._client.add_secret_version(request=request)
             return data
         except Exception:
-            self._logger.error("Exception occured while adding secret '%s' version", name)
-            raise
+            self._logger.error(
+                "Exception occured while adding secret '%s' version", name
+            )
+            raise

maleo_foundation/managers/client/google/storage.py

@@ -10,6 +10,7 @@ from maleo_foundation.types import BaseTypes
 from maleo_foundation.utils.logging import SimpleConfig
 from .base import GoogleClientManager
 
+
 class GoogleCloudStorage(GoogleClientManager):
     def __init__(
         self,
@@ -18,16 +19,20 @@ class GoogleCloudStorage(GoogleClientManager):
         credentials: Optional[Credentials] = None,
         credentials_path: Optional[Union[Path, str]] = None,
         bucket_name: BaseTypes.OptionalString = None,
-        redis: Optional[Redis] = None
+        redis: Optional[Redis] = None,
     ) -> None:
         key = "google-cloud-storage"
         name = "GoogleCloudStorage"
-        super().__init__(key, name, log_config, service_key, credentials, 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:
             self._client.close()
-            raise ValueError("GCS_BUCKET_NAME environment variable must be set if 'bucket_name' is set to None")
+            raise ValueError(
+                "GCS_BUCKET_NAME environment variable must be set if 'bucket_name' is set to None"
+            )
         self._bucket = self._client.lookup_bucket(bucket_name=self._bucket_name)
         if self._bucket is None:
             self._client.close()
@@ -38,10 +43,14 @@ class GoogleCloudStorage(GoogleClientManager):
 
     @property
     def bucket_name(self) -> str:
+        if self._bucket_name is None:
+            raise ValueError("Bucket name has not been initialized.")
         return self._bucket_name
 
     @property
     def bucket(self) -> Bucket:
+        if self._bucket is None:
+            raise ValueError("Bucket has not been initialized.")
         return self._bucket
 
     def dispose(self) -> None:
@@ -55,11 +64,11 @@ class GoogleCloudStorage(GoogleClientManager):
         self,
         content: bytes,
         location: str,
-        content_type: Optional[str]=None,
-        make_public: bool=False,
-        expiration: BaseEnums=BaseEnums.Expiration.EXP_15MN,
-        root_location_override: BaseTypes.OptionalString=None,
-        set_in_redis: bool=True
+        content_type: Optional[str] = None,
+        make_public: bool = False,
+        expiration: BaseEnums.Expiration = BaseEnums.Expiration.EXP_15MN,
+        root_location_override: BaseTypes.OptionalString = None,
+        set_in_redis: bool = True,
     ) -> str:
         """
         Upload a file to Google Cloud Storage.
@@ -73,13 +82,20 @@ class GoogleCloudStorage(GoogleClientManager):
         Returns:
             str: The public URL or blob path depending on `make_public`.
         """
-        if root_location_override is None or (isinstance(root_location_override, str) and len(root_location_override) <= 0):
+        if root_location_override is None or (
+            isinstance(root_location_override, str) and len(root_location_override) <= 0
+        ):
             blob_name = f"{self._root_location}/{location}"
         else:
             blob_name = f"{root_location_override}/{location}"
 
+        if self._bucket is None:
+            raise ValueError(
+                "Bucket is not initialized. Please check the bucket name and credentials."
+            )
+
         blob = self._bucket.blob(blob_name=blob_name)
-        blob.upload_from_string(content, content_type=content_type)
+        blob.upload_from_string(content, content_type=content_type or "text/plain")
 
         if make_public:
             blob.make_public()
@@ -88,23 +104,27 @@ class GoogleCloudStorage(GoogleClientManager):
             url = blob.generate_signed_url(
                 version="v4",
                 expiration=timedelta(seconds=int(expiration)),
-                method="GET"
+                method="GET",
             )
 
         if set_in_redis:
+            if self._redis is None:
+                raise ValueError("Can not use redis. Redis is not initialized")
             if make_public:
                 await self._redis.set(f"{self.key}:{blob_name}", url)
             else:
-                await self._redis.set(f"{self.key}:{blob_name}", url, ex=int(expiration))
+                await self._redis.set(
+                    f"{self.key}:{blob_name}", url, ex=int(expiration)
+                )
 
         return url
 
     async def generate_signed_url(
         self,
         location: str,
-        expiration: BaseEnums=BaseEnums.Expiration.EXP_15MN,
+        expiration: BaseEnums.Expiration = BaseEnums.Expiration.EXP_15MN,
         root_location_override: BaseTypes.OptionalString = None,
-        use_redis: bool = True
+        use_redis: bool = True,
     ) -> str:
         """
         generate signed URL of a file in the bucket based on its location.
@@ -122,10 +142,17 @@ class GoogleCloudStorage(GoogleClientManager):
         if use_redis and self._redis is None:
             raise ValueError("Can not use redis. Redis is not initialized")
 
-        if root_location_override is None or (isinstance(root_location_override, str) and len(root_location_override) <= 0):
-            blob_name=f"{self._root_location}/{location}"
+        if root_location_override is None or (
+            isinstance(root_location_override, str) and len(root_location_override) <= 0
+        ):
+            blob_name = f"{self._root_location}/{location}"
         else:
-            blob_name=f"{root_location_override}/{location}"
+            blob_name = f"{root_location_override}/{location}"
+
+        if self._bucket is None:
+            raise ValueError(
+                "Bucket is not initialized. Please check the bucket name and credentials."
+            )
 
         blob = self._bucket.blob(blob_name=blob_name)
         if not blob.exists():
@@ -139,9 +166,12 @@ class GoogleCloudStorage(GoogleClientManager):
                 return url
 
         url = blob.generate_signed_url(
-            version="v4",
-            expiration=timedelta(seconds=int(expiration)),
-            method="GET"
+            version="v4", expiration=timedelta(seconds=int(expiration)), method="GET"
         )
-        await self._redis.set(f"{self.key}:{blob_name}", url, ex=int(expiration))
-        return url
+
+        if use_redis:
+            if self._redis is None:
+                raise ValueError("Can not use redis. Redis is not initialized")
+            await self._redis.set(f"{self.key}:{blob_name}", url, ex=int(expiration))
+
+        return url

maleo_foundation/managers/client/google/subscription.py

@@ -6,7 +6,7 @@ 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 typing import Awaitable, Callable, Dict, List, Optional, Union, cast
 from maleo_foundation.managers.client.google.base import GoogleClientManager
 
 SyncController = Callable[[str, Message], bool]
@@ -14,12 +14,14 @@ 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
 
+
 class SubscriptionManager(GoogleClientManager):
     def __init__(
         self,
@@ -31,35 +33,28 @@ class SubscriptionManager(GoogleClientManager):
     ):
         key = "google-subscription-manager"
         name = "GoogleSubscriptionManager"
-        super().__init__(key, name, log_config, service_key, credentials, credentials_path)
+        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
+        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
+        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
+        self, controller: OptionalController, subscription_name: str, message: Message
     ):
         # If controller is not given, conduct default message processing
         if controller is None:
@@ -73,58 +68,61 @@ class SubscriptionManager(GoogleClientManager):
                 raise RuntimeError("Event loop not set in SubscriptionManager")
             asyncio.run_coroutine_threadsafe(
                 self._handle_async_controller(
-                    controller,
-                    subscription_name,
-                    message
+                    cast(AsyncController, controller), subscription_name, message
                 ),
-                self.loop
+                self.loop,
             )
         else:
             self._handle_sync_controller(
-                controller,
-                subscription_name,
-                message
+                cast(SyncController, controller), subscription_name, message
             )
 
     def _default_message_processing(
-        self,
-        subscription_name: str,
-        message: Message
+        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"))
+            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)
+            self._logger.error(
+                "Error handling message through default processor: %s", e, exc_info=True
+            )
             message.nack()
 
     async def _start_subscription_listener(
-        self,
-        config: SubscriptionConfigurations
+        self, config: SubscriptionConfigurations
     ) -> None:
-        subscription_path = self.subscriber.subscription_path(self.credentials.project_id, config.subscription_name)
+        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
+        )
         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.subscription_name, message
             ),
             flow_control=flow_control,
-            await_callbacks_on_shutdown=True
+            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)
+                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:
+    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))
@@ -137,4 +135,4 @@ class SubscriptionManager(GoogleClientManager):
                 future.result()
             except Exception:
                 pass
-        self.active_listeners.clear()
+        self.active_listeners.clear()

maleo_foundation/managers/client/maleo.py

@@ -6,16 +6,15 @@ from maleo_foundation.managers.client.base import (
     ClientHTTPController,
     ClientServiceControllers,
     ClientService,
-    ClientControllers
+    ClientControllers,
 )
 from maleo_foundation.managers.service import ServiceManager
 from maleo_foundation.utils.logging import ClientLogger
 
+
 class MaleoClientHTTPController(ClientHTTPController):
     def __init__(
-        self,
-        service_manager: ServiceManager,
-        manager: ClientHTTPControllerManager
+        self, service_manager: ServiceManager, manager: ClientHTTPControllerManager
     ):
         super().__init__(manager)
         self._service_manager = service_manager
@@ -24,18 +23,17 @@ class MaleoClientHTTPController(ClientHTTPController):
     def service_manager(self) -> ServiceManager:
         return self._service_manager
 
+
 class MaleoClientServiceControllers(ClientServiceControllers):
     model_config = ConfigDict(arbitrary_types_allowed=True)
 
-    http:MaleoClientHTTPController = Field(..., description="Maleo's HTTP Client Controller")
+    http: MaleoClientHTTPController = Field(  # type: ignore
+        ..., description="Maleo's HTTP Client Controller"
+    )
+
 
 class MaleoClientService(ClientService):
-    def __init__(
-        self,
-        key: str,
-        logger: ClientLogger,
-        service_manager: ServiceManager
-    ):
+    def __init__(self, key: str, logger: ClientLogger, service_manager: ServiceManager):
         super().__init__(logger)
         self._key = key
         self._service_manager = service_manager
@@ -48,21 +46,16 @@ class MaleoClientService(ClientService):
     def service_manager(self) -> ServiceManager:
         return self._service_manager
 
+
 class MaleoClientManager(ClientManager):
-    def __init__(
-        self,
-        key: str,
-        name: str,
-        url: str,
-        service_manager: ServiceManager
-    ):
+    def __init__(self, key: str, name: str, url: str, service_manager: ServiceManager):
         self._url = url
         self._service_manager = service_manager
         super().__init__(
             key,
             name,
             service_manager.log_config,
-            service_manager.configurations.service.key
+            service_manager.configurations.service.key,
         )
 
     @property
@@ -70,10 +63,12 @@ class MaleoClientManager(ClientManager):
         return self._service_manager
 
     def _initialize_controllers(self) -> None:
-        #* Initialize managers
+        # * Initialize managers
         http_controller_manager = ClientHTTPControllerManager(url=self._url)
-        self._controller_managers = ClientControllerManagers(http=http_controller_manager)
-        #* Initialize controllers
+        self._controller_managers = ClientControllerManagers(
+            http=http_controller_manager
+        )
+        # * Initialize controllers
         #! This initialied an empty controllers. Extend this function in the actual class to initialize all controllers.
         self._controllers = ClientControllers()
 
@@ -84,4 +79,4 @@ class MaleoClientManager(ClientManager):
     async def dispose(self) -> None:
         self._logger.info("Disposing client manager")
         await self._controller_managers.http.dispose()
-        self._logger.info("Client manager disposed successfully")
+        self._logger.info("Client manager disposed successfully")