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

maleo_foundation/utils/loaders/credential/google.py

@@ -5,11 +5,10 @@ from google.oauth2.service_account import Credentials
 from pathlib import Path
 from typing import Optional, Union
 
+
 class GoogleCredentialsLoader:
     @staticmethod
-    def load(
-        credentials_path: Optional[Union[Path, str]] = None
-    ) -> Credentials:
+    def load(credentials_path: Optional[Union[Path, str]] = None) -> Credentials:
         """
         Load Google service account credentials with guaranteed project_id.
         Priority:
@@ -49,26 +48,37 @@ class GoogleCredentialsLoader:
         """Load credentials from a service account file."""
         try:
             # First, read and validate the service account file
-            with open(credentials_path, 'r') as f:
+            with open(credentials_path, "r") as f:
                 service_account_info = json.load(f)
 
             # Ensure project_id is present in the file
-            if 'project_id' not in service_account_info or not service_account_info['project_id']:
-                raise ValueError(f"Service account file {credentials_path} does not contain project_id")
+            if (
+                "project_id" not in service_account_info
+                or not service_account_info["project_id"]
+            ):
+                raise ValueError(
+                    f"Service account file {credentials_path} does not contain project_id"
+                )
 
             # Load credentials from the file
             credentials = Credentials.from_service_account_file(str(credentials_path))
 
             # Double-check that project_id is available in the credentials object
             if not credentials.project_id:
-                raise ValueError(f"Loaded credentials from {credentials_path} do not have project_id")
+                raise ValueError(
+                    f"Loaded credentials from {credentials_path} do not have project_id"
+                )
 
             return credentials
 
         except json.JSONDecodeError as e:
-            raise ValueError(f"Invalid JSON in credentials file {credentials_path}: {str(e)}")
+            raise ValueError(
+                f"Invalid JSON in credentials file {credentials_path}: {str(e)}"
+            )
         except Exception as e:
-            raise ValueError(f"Failed to load credentials from file {credentials_path}: {str(e)}")
+            raise ValueError(
+                f"Failed to load credentials from file {credentials_path}: {str(e)}"
+            )
 
     @staticmethod
     def _load_from_default() -> Credentials:
@@ -110,10 +120,10 @@ class GoogleCredentialsLoader:
     def _get_project_id_from_env() -> str:
         """Get project_id from environment variables."""
         project_id = (
-            os.getenv("GOOGLE_CLOUD_PROJECT") or
-            os.getenv("GCLOUD_PROJECT") or
-            os.getenv("GCP_PROJECT") or
-            os.getenv("PROJECT_ID")
+            os.getenv("GOOGLE_CLOUD_PROJECT")
+            or os.getenv("GCLOUD_PROJECT")
+            or os.getenv("GCP_PROJECT")
+            or os.getenv("PROJECT_ID")
         )
 
         if not project_id:
@@ -129,10 +139,14 @@ class GoogleCredentialsLoader:
     def validate_credentials(credentials: Credentials) -> None:
         """Validate that credentials are service account credentials with project_id."""
         if not isinstance(credentials, Credentials):
-            raise ValueError("Credentials must be google.oauth2.service_account.Credentials")
+            raise ValueError(
+                "Credentials must be google.oauth2.service_account.Credentials"
+            )
 
         if not credentials.project_id:
             raise ValueError("Service account credentials must have project_id")
 
         if not credentials.service_account_email:
-            raise ValueError("Service account credentials must have service_account_email")
+            raise ValueError(
+                "Service account credentials must have service_account_email"
+            )

maleo_foundation/utils/loaders/json.py

@@ -2,6 +2,7 @@ import json
 from typing import Dict, List, Union, Any
 from pathlib import Path
 
+
 class JSONLoader:
     @staticmethod
     def load_from_path(path: Union[Path, str]) -> Union[Dict[str, Any], List[Any]]:
@@ -10,9 +11,9 @@ class JSONLoader:
         if not file_path.is_file():
             raise FileNotFoundError(f"File not found: {file_path}")
 
-        with open(file_path, 'r') as f:
+        with open(file_path, "r") as f:
             return json.load(f)
 
     @staticmethod
     def load_from_string(string: str) -> Dict:
-        return json.loads(string)
+        return json.loads(string)

maleo_foundation/utils/loaders/key/__init__.py

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

maleo_foundation/utils/loaders/key/rsa.py

@@ -5,21 +5,27 @@ from typing import Optional, Union
 from maleo_foundation.enums import BaseEnums
 from maleo_foundation.types import BaseTypes
 
+
 class RSAKeyLoader:
     @staticmethod
     def load_with_cryptography(
-        type:BaseEnums.KeyType,
-        data:Optional[Union[bytes, str]] = None,
-        path:Optional[Union[str, Path]] = None,
-        password:Optional[Union[bytes, str]] = None,
-        format:BaseEnums.KeyFormatType = BaseEnums.KeyFormatType.STRING,
+        type: BaseEnums.KeyType,
+        data: Optional[Union[bytes, str]] = None,
+        path: Optional[Union[str, Path]] = None,
+        password: Optional[Union[bytes, str]] = None,
+        format: BaseEnums.KeyFormatType = BaseEnums.KeyFormatType.STRING,
     ) -> Union[bytes, str]:
         if not isinstance(type, BaseEnums.KeyType):
             raise TypeError("Invalid key type")
 
+        if data is None and path is None:
+            raise ValueError("Either data or path must be provided")
+
         if data is not None and path is not None:
             raise ValueError("Only either data or path will be accepted as parameters")
 
+        key_data: Optional[bytes] = None
+
         if data is not None:
             if isinstance(data, bytes):
                 key_data = data
@@ -36,6 +42,9 @@ class RSAKeyLoader:
 
             key_data = file_path.read_bytes()
 
+        if key_data is None:
+            raise ValueError("Key data is required")
+
         if password is not None and not isinstance(password, (str, bytes)):
             raise TypeError("Invalid passsword type")
 
@@ -50,7 +59,7 @@ class RSAKeyLoader:
             private_key_bytes = private_key.private_bytes(
                 encoding=serialization.Encoding.PEM,
                 format=serialization.PrivateFormat.PKCS8,
-                encryption_algorithm=serialization.NoEncryption()
+                encryption_algorithm=serialization.NoEncryption(),
             )
             if format == BaseEnums.KeyFormatType.BYTES:
                 return private_key_bytes
@@ -61,7 +70,7 @@ class RSAKeyLoader:
             public_key = serialization.load_pem_public_key(key_data)
             public_key_bytes = public_key.public_bytes(
                 encoding=serialization.Encoding.PEM,
-                format=serialization.PublicFormat.SubjectPublicKeyInfo
+                format=serialization.PublicFormat.SubjectPublicKeyInfo,
             )
             if format == BaseEnums.KeyFormatType.BYTES:
                 return public_key_bytes
@@ -70,9 +79,9 @@ class RSAKeyLoader:
 
     @staticmethod
     def load_with_pycryptodome(
-        type:BaseEnums.KeyType,
-        extern_key:Union[bytes, str],
-        passphrase:BaseTypes.OptionalString = None,
+        type: BaseEnums.KeyType,
+        extern_key: Union[bytes, str],
+        passphrase: BaseTypes.OptionalString = None,
     ) -> RSA.RsaKey:
         if not isinstance(type, BaseEnums.KeyType):
             raise TypeError("Invalid key type")
@@ -83,11 +92,15 @@ class RSAKeyLoader:
         if type == BaseEnums.KeyType.PRIVATE:
             private_key = RSA.import_key(extern_key=extern_key, passphrase=passphrase)
             if not private_key.has_private():
-                raise TypeError("Invalid chosen key type, the private key did not has private inside it")
+                raise TypeError(
+                    "Invalid chosen key type, the private key did not has private inside it"
+                )
             return private_key
 
         if type == BaseEnums.KeyType.PUBLIC:
             public_key = RSA.import_key(extern_key=extern_key)
             if public_key.has_private():
-                raise TypeError("Invalid chosen key type, the public key did has private inside it")
-            return public_key
+                raise TypeError(
+                    "Invalid chosen key type, the public key did has private inside it"
+                )
+            return public_key

maleo_foundation/utils/loaders/yaml.py

@@ -2,6 +2,7 @@ import yaml
 from pathlib import Path
 from typing import Dict, Union
 
+
 class YAMLLoader:
     @staticmethod
     def load_from_path(path: Union[Path, str]) -> Dict:
@@ -15,4 +16,4 @@ class YAMLLoader:
 
     @staticmethod
     def load_from_string(string: str) -> Dict:
-        return yaml.safe_load(string)
+        return yaml.safe_load(string)

maleo_foundation/utils/logging.py

@@ -11,21 +11,25 @@ from maleo_foundation.enums import BaseEnums
 from maleo_foundation.types import BaseTypes
 from maleo_foundation.utils.loaders.credential.google import GoogleCredentialsLoader
 
+
 class GoogleCloudLogging:
-    def __init__(
-        self,
-        credentials_path: Optional[Union[Path, str]] = None
-    ) -> None:
-        self._credentials = GoogleCredentialsLoader.load(credentials_path=credentials_path)
+    def __init__(self, credentials_path: Optional[Union[Path, str]] = None) -> None:
+        self._credentials = GoogleCredentialsLoader.load(
+            credentials_path=credentials_path
+        )
         self._client = Client(credentials=self._credentials)
         self._client.setup_logging()
 
     @property
     def credentials(self) -> Credentials:
+        if self._credentials is None:
+            raise ValueError("Credentials have not been initialized.")
         return self._credentials
 
     @property
     def client(self) -> Client:
+        if self._client is None:
+            raise ValueError("Client has not been initialized.")
         return self._client
 
     def dispose(self) -> None:
@@ -34,18 +38,21 @@ class GoogleCloudLogging:
         if self._client is not None:
             self._client = None
 
-    def create_handler(
-        self,
-        name: str
-    ) -> CloudLoggingHandler:
+    def create_handler(self, name: str) -> CloudLoggingHandler:
         return CloudLoggingHandler(client=self._client, name=name)
 
+
 class SimpleConfig(BaseModel):
     model_config = ConfigDict(arbitrary_types_allowed=True)
 
     dir: str = Field(..., description="Log's directory")
-    level: BaseEnums.LoggerLevel = Field(BaseEnums.LoggerLevel.INFO, description="Log's level")
-    google_cloud_logging: Optional[GoogleCloudLogging] = Field(default_factory=GoogleCloudLogging, description="Google cloud logging")
+    level: BaseEnums.LoggerLevel = Field(
+        BaseEnums.LoggerLevel.INFO, description="Log's level"
+    )
+    google_cloud_logging: Optional[GoogleCloudLogging] = Field(
+        default_factory=GoogleCloudLogging, description="Google cloud logging"
+    )
+
 
 class BaseLogger(logging.Logger):
     def __init__(
@@ -55,50 +62,58 @@ class BaseLogger(logging.Logger):
         service_key: BaseTypes.OptionalString = None,
         client_key: BaseTypes.OptionalString = None,
         level: BaseEnums.LoggerLevel = BaseEnums.LoggerLevel.INFO,
-        google_cloud_logging: Optional[GoogleCloudLogging] = None
+        google_cloud_logging: Optional[GoogleCloudLogging] = None,
     ):
-        self._type = type #* Declare logger type
+        self._type = type  # * Declare logger type
 
-        #* Ensure service_key exists
+        # * Ensure service_key exists
         self._service_key = service_key or os.getenv("SERVICE_KEY")
         if self._service_key is None:
-            raise ValueError("SERVICE_KEY environment variable must be set if 'service_key' is set to None")
+            raise ValueError(
+                "SERVICE_KEY environment variable must be set if 'service_key' is set to None"
+            )
 
-        self._client_key = client_key #* Declare client key
+        self._client_key = client_key  # * Declare client key
 
-        #* Ensure client_key is valid if logger type is a client
+        # * Ensure client_key is valid if logger type is a client
         if self._type == BaseEnums.LoggerType.CLIENT and self._client_key is None:
-            raise ValueError("'client_key' parameter must be provided if 'logger_type' is 'client'")
+            raise ValueError(
+                "'client_key' parameter must be provided if 'logger_type' is 'client'"
+            )
 
-        #* Define logger name
+        # * Define logger name
         if self._type == BaseEnums.LoggerType.CLIENT:
             self._name = f"{self._service_key} - {self._type} - {self._client_key}"
         else:
             self._name = f"{self._service_key} - {self._type}"
 
-        super().__init__(self._name, level) #* Init the superclass's logger
+        super().__init__(self._name, level)  # * Init the superclass's logger
 
-        #* Clear existing handlers to prevent duplicates
+        # * Clear existing handlers to prevent duplicates
         for handler in list(self.handlers):
             self.removeHandler(handler)
             handler.close()
 
-        #* Formatter for logs
-        formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+        # * Formatter for logs
+        formatter = logging.Formatter(
+            "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+        )
 
-        #* Console handler
+        # * Console handler
         console_handler = logging.StreamHandler()
         console_handler.setFormatter(formatter)
         self.addHandler(console_handler)
 
-        #* Google Cloud Logging handler (If enabled)
+        # * Google Cloud Logging handler (If enabled)
         if google_cloud_logging is not None:
-            cloud_logging_handler = google_cloud_logging.create_handler(name=self._name.replace(" ", ""))
+            cloud_logging_handler = google_cloud_logging.create_handler(
+                name=self._name.replace(" ", "")
+            )
             self.addHandler(cloud_logging_handler)
         else:
             self.info("Cloud logging is not configured.")
 
-        #* Define log directory
+        # * Define log directory
         if self._type == BaseEnums.LoggerType.CLIENT:
             log_dir = f"{self._type}/{self._client_key}"
         else:
@@ -106,11 +121,11 @@ class BaseLogger(logging.Logger):
         self._log_dir = os.path.join(dir, log_dir)
         os.makedirs(self._log_dir, exist_ok=True)
 
-        #* Generate timestamped filename
+        # * Generate timestamped filename
         timestamp = datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
         log_filename = os.path.join(self._log_dir, f"{timestamp}.log")
 
-        #* File handler
+        # * File handler
         file_handler = logging.FileHandler(log_filename, mode="a")
         file_handler.setFormatter(formatter)
         self.addHandler(file_handler)
@@ -121,6 +136,8 @@ class BaseLogger(logging.Logger):
 
     @property
     def service(self) -> str:
+        if self._service_key is None:
+            raise ValueError("Service key has not been initialized.")
         return self._service_key
 
     @property
@@ -142,13 +159,14 @@ class BaseLogger(logging.Logger):
             handler.close()
         self.handlers.clear()
 
+
 class ApplicationLogger(BaseLogger):
     def __init__(
         self,
         dir: str,
         service_key: BaseTypes.OptionalString = None,
         level: BaseEnums.LoggerLevel = BaseEnums.LoggerLevel.INFO,
-        google_cloud_logging: Optional[GoogleCloudLogging] = None
+        google_cloud_logging: Optional[GoogleCloudLogging] = None,
     ):
         super().__init__(
             dir=dir,
@@ -156,16 +174,17 @@ class ApplicationLogger(BaseLogger):
             service_key=service_key,
             client_key=None,
             level=level,
-            google_cloud_logging=google_cloud_logging
+            google_cloud_logging=google_cloud_logging,
         )
 
+
 class CacheLogger(BaseLogger):
     def __init__(
         self,
         dir: str,
         service_key: BaseTypes.OptionalString = None,
         level: BaseEnums.LoggerLevel = BaseEnums.LoggerLevel.INFO,
-        google_cloud_logging: Optional[GoogleCloudLogging] = None
+        google_cloud_logging: Optional[GoogleCloudLogging] = None,
     ):
         super().__init__(
             dir=dir,
@@ -173,9 +192,10 @@ class CacheLogger(BaseLogger):
             service_key=service_key,
             client_key=None,
             level=level,
-            google_cloud_logging=google_cloud_logging
+            google_cloud_logging=google_cloud_logging,
         )
 
+
 class ClientLogger(BaseLogger):
     def __init__(
         self,
@@ -183,7 +203,7 @@ class ClientLogger(BaseLogger):
         client_key: str,
         service_key: BaseTypes.OptionalString = None,
         level: BaseEnums.LoggerLevel = BaseEnums.LoggerLevel.INFO,
-        google_cloud_logging: Optional[GoogleCloudLogging] = None
+        google_cloud_logging: Optional[GoogleCloudLogging] = None,
     ):
         super().__init__(
             dir=dir,
@@ -191,16 +211,17 @@ class ClientLogger(BaseLogger):
             service_key=service_key,
             client_key=client_key,
             level=level,
-            google_cloud_logging=google_cloud_logging
+            google_cloud_logging=google_cloud_logging,
         )
 
+
 class DatabaseLogger(BaseLogger):
     def __init__(
         self,
         dir: str,
         service_key: BaseTypes.OptionalString = None,
-        level = BaseEnums.LoggerLevel.INFO,
-        google_cloud_logging = None
+        level=BaseEnums.LoggerLevel.INFO,
+        google_cloud_logging=None,
     ):
         super().__init__(
             dir=dir,
@@ -208,16 +229,17 @@ class DatabaseLogger(BaseLogger):
             service_key=service_key,
             client_key=None,
             level=level,
-            google_cloud_logging=google_cloud_logging
+            google_cloud_logging=google_cloud_logging,
         )
 
+
 class MiddlewareLogger(BaseLogger):
     def __init__(
         self,
         dir: str,
         service_key: BaseTypes.OptionalString = None,
-        level = BaseEnums.LoggerLevel.INFO,
-        google_cloud_logging = None
+        level=BaseEnums.LoggerLevel.INFO,
+        google_cloud_logging=None,
     ):
         super().__init__(
             dir=dir,
@@ -225,16 +247,17 @@ class MiddlewareLogger(BaseLogger):
             service_key=service_key,
             client_key=None,
             level=level,
-            google_cloud_logging=google_cloud_logging
+            google_cloud_logging=google_cloud_logging,
         )
 
+
 class RepositoryLogger(BaseLogger):
     def __init__(
         self,
         dir: str,
         service_key: BaseTypes.OptionalString = None,
         level: BaseEnums.LoggerLevel = BaseEnums.LoggerLevel.INFO,
-        google_cloud_logging: Optional[GoogleCloudLogging] = None
+        google_cloud_logging: Optional[GoogleCloudLogging] = None,
     ):
         super().__init__(
             dir=dir,
@@ -242,16 +265,17 @@ class RepositoryLogger(BaseLogger):
             service_key=service_key,
             client_key=None,
             level=level,
-            google_cloud_logging=google_cloud_logging
+            google_cloud_logging=google_cloud_logging,
         )
 
+
 class ServiceLogger(BaseLogger):
     def __init__(
         self,
         dir: str,
         service_key: BaseTypes.OptionalString = None,
         level: BaseEnums.LoggerLevel = BaseEnums.LoggerLevel.INFO,
-        google_cloud_logging: Optional[GoogleCloudLogging] = None
+        google_cloud_logging: Optional[GoogleCloudLogging] = None,
     ):
         super().__init__(
             dir=dir,
@@ -259,5 +283,5 @@ class ServiceLogger(BaseLogger):
             service_key=service_key,
             client_key=None,
             level=level,
-            google_cloud_logging=google_cloud_logging
-        )
+            google_cloud_logging=google_cloud_logging,
+        )

maleo_foundation/utils/merger.py

@@ -1,12 +1,10 @@
 from collections.abc import Mapping
-from typing import Dict
+from typing import Dict, Any
 
-def deep_merge(*obj: Dict) -> Dict:
-    def merge_dicts(
-        a: Dict,
-        b: Dict
-    ) -> Dict:
-        result = dict(a)
+
+def deep_merge(*obj: Dict[str, Any]) -> Dict[str, Any]:
+    def merge_dicts(a: Mapping[str, Any], b: Mapping[str, Any]) -> Dict[str, Any]:
+        result = dict(a)  # create a mutable copy
         for key, value in b.items():
             if (
                 key in result
@@ -18,7 +16,7 @@ def deep_merge(*obj: Dict) -> Dict:
                 result[key] = value
         return result
 
-    merged = {}
+    merged: Dict[str, Any] = {}
     for ob in obj:
         merged = merge_dicts(merged, ob)
-    return merged
+    return merged