maleo-foundation 0.1.36__tar.gz → 0.1.38__tar.gz

{maleo_foundation-0.1.36 → maleo_foundation-0.1.38}/PKG-INFO

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

{maleo_foundation-0.1.36 → maleo_foundation-0.1.38}/maleo_foundation/managers/service.py

@@ -20,7 +20,8 @@ from maleo_foundation.middlewares.base import RequestProcessor
 from maleo_foundation.services.token import BaseTokenService
 from maleo_foundation.types import BaseTypes
 from maleo_foundation.utils.exceptions import BaseExceptions
-from maleo_foundation.utils.keyloader import load_key
+from maleo_foundation.utils.loaders.json import JSONLoader
+from maleo_foundation.utils.loaders.key import KeyLoader
 from maleo_foundation.utils.logging import GoogleCloudLogging, ServiceLogger, MiddlewareLogger
 
 class LogConfig(BaseModel):
@@ -38,6 +39,7 @@ class Settings(BaseSettings):
     PUBLIC_KEY_PATH:str = Field("/keys/maleo-public-key.pem", description="Maleo's public key path")
     KEY_PASSWORD:str = Field(..., description="Maleo key's password")
     CONFIGURATIONS_PATH:str = Field(..., description="Service's configuration file path")
+    DB_PASSWORD:str = Field(..., description="Database's password")
 
 class Keys(BaseModel):
     password:str = Field(..., description="Key's password")
@@ -78,7 +80,8 @@ class ServiceConfigurations(BaseModel):
 
 class DatabaseConfigurations(BaseModel):
     username:str = Field("postgres", description="Database user's username")
-    password:str = Field(..., description="Database user's password")
+    password_env:str = Field("DB_PASSWORD", description="Database user's password .env")
+    password:str = Field(os.getenv(password_env), description="Database user's password")
     host:str = Field(..., description="Database's host")
     port:int = Field(5432, description="Database's port")
     database:str = Field(..., description="Database")
@@ -254,9 +257,8 @@ class ServiceManager:
         return self._settings
 
     def _load_configs(self) -> None:
-        with open(self._settings.CONFIGURATIONS_PATH) as f:
-            data = json.load(f)
-            self._configs = Configurations.model_validate(data)
+        data = JSONLoader.load(self._settings.CONFIGURATIONS_PATH)
+        self._configs = Configurations.model_validate(data)
 
     @property
     def configs(self) -> Configurations:
@@ -278,13 +280,11 @@ class ServiceManager:
 
     def _load_credentials(self) -> None:
         #* Load google credentials
-        with open(self._settings.GOOGLE_CREDENTIALS_PATH) as f:
-            data = json.load(f)
-            google = GoogleCredentials.model_validate(data)
+        data = JSONLoader.load(self._settings.GOOGLE_CREDENTIALS_PATH)
+        google = GoogleCredentials.model_validate(data)
         #* Load internal credentials
-        with open(self._settings.INTERNAL_CREDENTIALS_PATH) as f:
-            data = json.load(f)
-            internal = InternalCredentials.model_validate(data)
+        data = JSONLoader.load(self._settings.INTERNAL_CREDENTIALS_PATH)
+        internal = InternalCredentials.model_validate(data)
         self._credentials = Credentials(google=google, internal=internal)
 
     @property
@@ -294,14 +294,14 @@ class ServiceManager:
     def _parse_keys(self) -> None:
         #* Parse private key
         key_type = BaseEnums.KeyType.PRIVATE
-        private = load_key(
+        private = KeyLoader.load_rsa(
             type=key_type,
             path=self._settings.PRIVATE_KEY_PATH,
             password=self._settings.KEY_PASSWORD
         )
         #* Parse public key
         key_type = BaseEnums.KeyType.PUBLIC
-        public = load_key(
+        public = KeyLoader.load_rsa(
             type=key_type,
             path=self._settings.PUBLIC_KEY_PATH
         )

{maleo_foundation-0.1.36 → maleo_foundation-0.1.38}/maleo_foundation/middlewares/authentication.py

@@ -6,7 +6,7 @@ from typing import Tuple
 from maleo_foundation.authentication import Credentials, User
 from maleo_foundation.models.transfers.parameters.token import BaseTokenParametersTransfers
 from maleo_foundation.services.token import BaseTokenService
-from maleo_foundation.utils.extractor import extract_client_ip
+from maleo_foundation.utils.extractor import BaseExtractors
 from maleo_foundation.utils.logging import MiddlewareLogger
 
 class Backend(AuthenticationBackend):
@@ -16,7 +16,7 @@ class Backend(AuthenticationBackend):
         self._key = key
 
     async def authenticate(self, conn:HTTPConnection) -> Tuple[Credentials, User]:
-        client_ip = extract_client_ip(conn)
+        client_ip = BaseExtractors.extract_client_ip(conn)
         if "Authorization" not in conn.headers:
             self._logger.info(f"Request | IP: {client_ip} | URL: {conn.url.path} - Result | General: Header did not contain authorization")
             return Credentials(), User(authenticated=False)

{maleo_foundation-0.1.36 → maleo_foundation-0.1.38}/maleo_foundation/middlewares/base.py

@@ -9,7 +9,7 @@ from fastapi.responses import JSONResponse
 from starlette.middleware.base import BaseHTTPMiddleware, RequestResponseEndpoint
 from typing import Awaitable, Callable, Optional, Sequence
 from maleo_foundation.models.responses import BaseResponses
-from maleo_foundation.utils.extractor import extract_client_ip
+from maleo_foundation.utils.extractor import BaseExtractors
 from maleo_foundation.utils.logging import MiddlewareLogger
 
 RequestProcessor = Callable[[Request], Awaitable[Optional[Response]]]
@@ -80,23 +80,6 @@ class BaseMiddleware(BaseHTTPMiddleware):
                 self.last_cleanup = now
                 self.logger.debug(f"Cleaned up request cache. Removed {len(inactive_ips)} inactive IPs. Current tracked IPs: {len(self.requests)}")
 
-    def _extract_client_ip(self, request:Request) -> str:
-        """Extract client IP with more robust handling of proxies"""
-        #* Check for X-Forwarded-For header (common when behind proxy/load balancer)
-        x_forwarded_for = request.headers.get("X-Forwarded-For")
-        if x_forwarded_for:
-            #* The client's IP is the first one in the list
-            ips = [ip.strip() for ip in x_forwarded_for.split(",")]
-            return ips[0]
-        
-        #* Check for X-Real-IP header (used by some proxies)
-        x_real_ip = request.headers.get("X-Real-IP")
-        if x_real_ip:
-            return x_real_ip
-            
-        #* Fall back to direct client connection
-        return request.client.host if request.client else "unknown"
-
     def _check_rate_limit(self, client_ip:str) -> bool:
         """Check if the client has exceeded their rate limit"""
         with self._lock:
@@ -179,7 +162,7 @@ class BaseMiddleware(BaseHTTPMiddleware):
         self._cleanup_old_data() #* Run periodic cleanup
         request_timestamp = datetime.now(tz=timezone.utc) #* Record the request timestamp
         start_time = time.perf_counter() #* Record the start time
-        client_ip = extract_client_ip(request) #* Get request IP with improved extraction
+        client_ip = BaseExtractors.extract_client_ip(request) #* Get request IP with improved extraction
 
         try:
             #* 1. Rate limit check

{maleo_foundation-0.1.36 → maleo_foundation-0.1.38}/maleo_foundation/utils/__init__.py

@@ -1,13 +1,15 @@
 from __future__ import annotations
 from .formatter import BaseFormatter
-from .logger import BaseLogger
 from .exceptions import BaseExceptions
+from .extractor import BaseExtractors
+from .loaders import BaseLoaders
 from .controller import BaseControllerUtils
 from .query import BaseQueryUtils
 
 class BaseUtils:
     Formatter = BaseFormatter
-    Logger = BaseLogger
     Exceptions = BaseExceptions
+    Extractors = BaseExtractors
+    Loaders = BaseLoaders
     Controller = BaseControllerUtils
     Query = BaseQueryUtils

maleo_foundation-0.1.38/maleo_foundation/utils/extractor.py

@@ -0,0 +1,20 @@
+from starlette.requests import HTTPConnection
+
+class BaseExtractors:
+    @staticmethod
+    def extract_client_ip(conn:HTTPConnection) -> str:
+        """Extract client IP with more robust handling of proxies"""
+        #* Check for X-Forwarded-For header (common when behind proxy/load balancer)
+        x_forwarded_for = conn.headers.get("X-Forwarded-For")
+        if x_forwarded_for:
+            #* The client's IP is the first one in the list
+            ips = [ip.strip() for ip in x_forwarded_for.split(",")]
+            return ips[0]
+
+        #* Check for X-Real-IP header (used by some proxies)
+        x_real_ip = conn.headers.get("X-Real-IP")
+        if x_real_ip:
+            return x_real_ip
+
+        #* Fall back to direct client connection
+        return conn.client.host if conn.client else "unknown"

maleo_foundation-0.1.38/maleo_foundation/utils/loaders/__init__.py

@@ -0,0 +1,9 @@
+from __future__ import annotations
+from .json import JSONLoader
+from .key import KeyLoader
+from .yaml import YAMLLoader
+
+class BaseLoaders:
+    Json = JSONLoader
+    Key = KeyLoader
+    Yaml = YAMLLoader

maleo_foundation-0.1.38/maleo_foundation/utils/loaders/json.py

@@ -0,0 +1,14 @@
+import json
+from typing import Dict, List, Union, Any
+from pathlib import Path
+
+class JSONLoader:
+    @staticmethod
+    def load(path:Union[Path, str]) -> Union[Dict[str, Any], List[Any]]:
+        file_path = Path(path)
+
+        if not file_path.is_file():
+            raise FileNotFoundError(f"File not found: {file_path}")
+
+        with open(file_path, 'r') as f:
+            return json.load(f)

maleo_foundation-0.1.38/maleo_foundation/utils/loaders/key.py

@@ -0,0 +1,67 @@
+from cryptography.hazmat.primitives import serialization
+from pathlib import Path
+from typing import Optional, Union
+from maleo_foundation.enums import BaseEnums
+
+class KeyLoader:
+    @staticmethod
+    def load_rsa(
+        type:BaseEnums.KeyType,
+        path: Union[str, Path],
+        password:Optional[Union[str, bytes]] = None,
+        format:BaseEnums.KeyFormatType = BaseEnums.KeyFormatType.STRING,
+    ) -> Union[bytes, str]:
+        """
+        Load an RSA private or public key strictly from a file.
+
+        Args:
+            path (str | Path): Path to the PEM file.
+            password (str | bytes | None): Password for encrypted private keys (optional).
+
+        Returns:
+            rsa.RSAPrivateKey | rsa.RSAPublicKey
+        """
+        if not isinstance(type, BaseEnums.KeyType):
+            raise TypeError("Invalid key type")
+
+        file_path = Path(path)
+
+        if not file_path.is_file():
+            raise FileNotFoundError(f"Key file not found: {file_path}")
+
+        if password is not None and not isinstance(password, (str, bytes)):
+            raise TypeError("Invalid passsword type")
+
+        if not isinstance(format, BaseEnums.KeyFormatType):
+            raise TypeError("Invalid key format type")
+
+        key_data = file_path.read_bytes()
+
+        if type == BaseEnums.KeyType.PRIVATE:
+            private_key = serialization.load_pem_private_key(
+                key_data,
+                password=password.encode() if isinstance(password, str) else password,
+            )
+            private_key_bytes = private_key.private_bytes(
+                encoding=serialization.Encoding.PEM,
+                format=serialization.PrivateFormat.PKCS8,
+                encryption_algorithm=serialization.NoEncryption()
+            )
+            if format == BaseEnums.KeyFormatType.BYTES:
+                return private_key_bytes
+            elif format == BaseEnums.KeyFormatType.STRING:
+                return private_key_bytes.decode()
+
+        elif type == BaseEnums.KeyType.PUBLIC:
+            public_key = serialization.load_pem_public_key(key_data)
+            public_key_bytes = public_key.public_bytes(
+                encoding=serialization.Encoding.PEM,
+                format=serialization.PublicFormat.SubjectPublicKeyInfo
+            )
+            if format == BaseEnums.KeyFormatType.BYTES:
+                return public_key_bytes
+            elif format == BaseEnums.KeyFormatType.STRING:
+                return public_key_bytes.decode()
+
+        else:
+            raise ValueError(f"Unsupported key type: {type}")

maleo_foundation-0.1.38/maleo_foundation/utils/loaders/yaml.py

@@ -0,0 +1,14 @@
+import yaml
+from pathlib import Path
+from typing import Dict, Union
+
+class YAMLLoader:
+    @staticmethod
+    def load(path:Union[Path, str]) -> Dict:
+        file_path = Path(path)
+
+        if not file_path.is_file():
+            raise FileNotFoundError(f"File not found: {file_path}")
+
+        with file_path.open("r") as f:
+            return yaml.safe_load(f)

{maleo_foundation-0.1.36 → maleo_foundation-0.1.38}/maleo_foundation.egg-info/PKG-INFO

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

{maleo_foundation-0.1.36 → maleo_foundation-0.1.38}/maleo_foundation.egg-info/SOURCES.txt

@@ -65,8 +65,11 @@ maleo_foundation/utils/__init__.py
 maleo_foundation/utils/controller.py
 maleo_foundation/utils/exceptions.py
 maleo_foundation/utils/extractor.py
-maleo_foundation/utils/keyloader.py
 maleo_foundation/utils/logging.py
 maleo_foundation/utils/query.py
 maleo_foundation/utils/formatter/__init__.py
-maleo_foundation/utils/formatter/case.py
+maleo_foundation/utils/formatter/case.py
+maleo_foundation/utils/loaders/__init__.py
+maleo_foundation/utils/loaders/json.py
+maleo_foundation/utils/loaders/key.py
+maleo_foundation/utils/loaders/yaml.py

{maleo_foundation-0.1.36 → maleo_foundation-0.1.38}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "maleo_foundation"
-version = "0.1.36"
+version = "0.1.38"
 description = "Foundation package for Maleo"
 authors = [
     { name = "Agra Bima Yuda", email = "agra@nexmedis.com" }

maleo_foundation-0.1.36/maleo_foundation/utils/extractor.py

@@ -1,18 +0,0 @@
-from starlette.requests import HTTPConnection
-
-def extract_client_ip(conn:HTTPConnection) -> str:
-    """Extract client IP with more robust handling of proxies"""
-    #* Check for X-Forwarded-For header (common when behind proxy/load balancer)
-    x_forwarded_for = conn.headers.get("X-Forwarded-For")
-    if x_forwarded_for:
-        #* The client's IP is the first one in the list
-        ips = [ip.strip() for ip in x_forwarded_for.split(",")]
-        return ips[0]
-
-    #* Check for X-Real-IP header (used by some proxies)
-    x_real_ip = conn.headers.get("X-Real-IP")
-    if x_real_ip:
-        return x_real_ip
-
-    #* Fall back to direct client connection
-    return conn.client.host if conn.client else "unknown"

maleo_foundation-0.1.36/maleo_foundation/utils/keyloader.py

@@ -1,65 +0,0 @@
-import pathlib
-from cryptography.hazmat.primitives import serialization
-from typing import Optional, Union
-from maleo_foundation.enums import BaseEnums
-
-def load_key(
-    type:BaseEnums.KeyType,
-    path: Union[str, pathlib.Path],
-    password:Optional[Union[str, bytes]] = None,
-    format:BaseEnums.KeyFormatType = BaseEnums.KeyFormatType.STRING,
-) -> Union[bytes, str]:
-    """
-    Load an RSA private or public key strictly from a file.
-
-    Args:
-        path (str | pathlib.Path): Path to the PEM file.
-        password (str | bytes | None): Password for encrypted private keys (optional).
-
-    Returns:
-        rsa.RSAPrivateKey | rsa.RSAPublicKey
-    """
-    if not isinstance(type, BaseEnums.KeyType):
-        raise TypeError("Invalid key type")
-
-    file_path = pathlib.Path(path)
-
-    if not file_path.is_file():
-        raise FileNotFoundError(f"Key file not found: {file_path}")
-
-    if password is not None and not isinstance(password, (str, bytes)):
-        raise TypeError("Invalid passsword type")
-
-    if not isinstance(format, BaseEnums.KeyFormatType):
-        raise TypeError("Invalid key format type")
-
-    key_data = file_path.read_bytes()
-
-    if type == BaseEnums.KeyType.PRIVATE:
-        private_key = serialization.load_pem_private_key(
-            key_data,
-            password=password.encode() if isinstance(password, str) else password,
-        )
-        private_key_bytes = private_key.private_bytes(
-            encoding=serialization.Encoding.PEM,
-            format=serialization.PrivateFormat.PKCS8,
-            encryption_algorithm=serialization.NoEncryption()
-        )
-        if format == BaseEnums.KeyFormatType.BYTES:
-            return private_key_bytes
-        elif format == BaseEnums.KeyFormatType.STRING:
-            return private_key_bytes.decode()
-
-    elif type == BaseEnums.KeyType.PUBLIC:
-        public_key = serialization.load_pem_public_key(key_data)
-        public_key_bytes = public_key.public_bytes(
-            encoding=serialization.Encoding.PEM,
-            format=serialization.PublicFormat.SubjectPublicKeyInfo
-        )
-        if format == BaseEnums.KeyFormatType.BYTES:
-            return public_key_bytes
-        elif format == BaseEnums.KeyFormatType.STRING:
-            return public_key_bytes.decode()
-
-    else:
-        raise ValueError(f"Unsupported key type: {type}")