ecodev-core 0.0.67__py3-none-any.whl

ecodev_core/rest_api_client.py

@@ -0,0 +1,211 @@
+"""
+Module implementing a high level Client for calling REST API endpoints
+"""
+from datetime import datetime
+from datetime import timezone
+from typing import Optional
+
+import requests
+from ecodev_core import logger_get
+from ecodev_core.authentication import ALGO
+from ecodev_core.authentication import SECRET_KEY
+from jose import jwt
+from pydantic import BaseModel
+from ecodev_core.rest_api_configuration import LOGIN_URL
+from ecodev_core.rest_api_configuration import API_USER
+from ecodev_core.rest_api_configuration import API_PASSWORD
+
+log = logger_get(__name__)
+
+
+class RestApiClient(BaseModel):
+    """
+    Client for making calls to internal REST API endpoints.
+
+    Attributes:
+        timeout (int): HTTP connection timeout 30 (sec).
+        _token (dict): Last fetched authentication token.
+
+    NB:
+        - When using this class, tokens should be accessed using the property `token` and \
+            not `_token` to enforce token auto-refresh and avoid using expired auth. tokens.
+    """
+    timeout: int = 30
+    _token: dict = {}
+
+    def _get_new_token(self) -> dict:
+        """
+        Fetches the authentication token from login API.
+
+        Raises:
+            ConnectionRefusedError: If the request returned None
+
+        Returns:
+            dict: The authentication token response from login API.
+        """
+        if (data := handle_response(requests.post(f'{LOGIN_URL}',
+                                                  data={'username': API_USER,
+                                                        'password': API_PASSWORD}))) is None:
+            raise ConnectionRefusedError('Failed to login')
+        return data
+
+    @property
+    def token(self) -> dict:
+        """
+        Returns the authentication token with auto-refresh logic if the
+        token is expired or within 1 minute to expiration.
+
+        Returns:
+            token (dict): Dictionary containing Authentication token
+        """
+        if self.get_exp() < datetime.now(timezone.utc).timestamp() + 60:
+            self._token = self._get_new_token()
+        return self._token
+
+    def get_exp(self) -> float:
+        """
+        Fetch expiration time from existing token `_token`. Defaults to current time.
+
+        Returns:
+            float: Token expiration time.
+        """
+        try:
+            payload = jwt.decode(self._token.get('access_token'), SECRET_KEY, algorithms=[ALGO])
+            return payload.get('exp', datetime.now(timezone.utc).timestamp())
+        except Exception:
+            log.warning('Failed to decode token, exp set to current timestamp')
+            return datetime.now(timezone.utc).timestamp()
+
+    def _get_header(self) -> dict:
+        """
+        Returns the headers with authorization information for
+        HTTP requests to internal REST APIs.
+
+        Returns:
+            dict: HTTP request headers internal REST APIs.
+        """
+        return {'accept': 'application/json',
+                'Content-Type': 'application/json',
+                'Authorization': f'Bearer {self.token.get("access_token")}'}
+
+    def get(self,
+            url: str,
+            params: Optional[dict] = None):
+        """
+        Attributes:
+            url (str): Url of the HTTP request
+            params (Optional[dict] = None): Query parameters to add to the url. \
+                Defaults to None.
+
+        Returns:
+            response_data (Any): Response body
+        """
+        return handle_response(requests.get(url=url, headers=self._get_header(),
+                                            timeout=self.timeout, params=params))
+
+    def post(self,
+             url: str,
+             data: Optional[dict] = None,
+             params: Optional[dict] = None):
+        """
+        Attributes:
+            url (str): Url of the HTTP request
+            data (Optional[dict] = None): The body/payload of the request. Defaults to None.
+            params (Optional[dict] = None): Query parameters to add to the url. \
+                Defaults to None.
+
+        Returns:
+            response_data (Any): Response body
+        """
+        return handle_response(requests.post(url=url, data=data, headers=self._get_header(),
+                                             timeout=self.timeout, params=params))
+
+    def put(self,
+            url: str,
+            data: dict,
+            params: Optional[dict] = None):
+        """
+        Attributes:
+            url (str): Url of the HTTP request
+            data (Optional[dict] = None): The body/payload of the request. Defaults to None.
+            params (Optional[dict]): Requests parameters to add to the url. \
+                Defaults to None.
+
+        Returns:
+            response_data (Any): Response body
+        """
+        return handle_response(requests.put(url=url, data=data, headers=self._get_header(),
+                                            timeout=self.timeout, params=params))
+
+    def patch(self,
+              url: str,
+              data: dict,
+              params: Optional[dict] = None):
+        """
+        Attributes:
+            url (str): Url of the HTTP request
+            data (Optional[dict] = None): The body/payload of the request. Defaults to None.
+            params (Optional[dict]): Query parameters to add to the url. \
+                Defaults to None.
+
+        Returns:
+            response_data (Any): Response body
+        """
+        return handle_response(requests.patch(url=url, data=data, headers=self._get_header(),
+                                              timeout=self.timeout, params=params))
+
+    def delete(self,
+               url: str,
+               params: Optional[dict] = None):
+        """
+        Attributes:
+            url (str): Url of the HTTP request
+            params (Optional[dict]): Query parameters to add to the url. \
+                Defaults to None.
+
+        Returns:
+            response_data (Any): Response body
+        """
+        return handle_response(requests.delete(url=url, headers=self._get_header(),
+                                               timeout=self.timeout, params=params))
+
+
+def handle_response(response: requests.Response):
+    """
+    Extracts the data from the http response object
+
+    Attributes:
+        response (requests.Response): HTTP response object to handle
+
+    Raises:
+        HTTPError: If the HTTP request returned an unsuccessful status code.
+        Exception: For any other error parsing the response.
+
+    Returns:
+        data (Any): Extracted data from HTTP response object
+    """
+    try:
+        response.raise_for_status()
+        response_body = response.json()
+        return response_body
+    except requests.HTTPError as http_exception:
+        log.error(f'Error {response.status_code} : {response.text}')
+        raise http_exception
+    except Exception as e:
+        log.error('Failed to parse response body')
+        raise e
+
+
+REST_API_CLIENT: Optional[RestApiClient] = None
+
+
+def get_rest_api_client() -> RestApiClient:
+    """
+    Initiate or return existing RestApiClient instance
+    """
+    global REST_API_CLIENT
+
+    if REST_API_CLIENT is None:
+        REST_API_CLIENT = RestApiClient()
+
+    return REST_API_CLIENT

ecodev_core/rest_api_configuration.py

@@ -0,0 +1,25 @@
+"""
+Module implementing restapi authentication configuration.
+"""
+from pydantic_settings import BaseSettings
+from pydantic_settings import SettingsConfigDict
+
+from ecodev_core.settings import SETTINGS
+
+
+class RestApiConfiguration(BaseSettings):
+    """
+    Simple authentication configuration class
+    """
+    host: str = ''
+    user: str = ''
+    password: str = ''
+    model_config = SettingsConfigDict(env_file='.env')
+
+
+API_AUTH = RestApiConfiguration()
+
+
+LOGIN_URL = SETTINGS.api.host or API_AUTH.host + '/login'
+API_USER = SETTINGS.api.user or API_AUTH.user
+API_PASSWORD = SETTINGS.api.password or API_AUTH.password

ecodev_core/safe_utils.py

@@ -0,0 +1,241 @@
+"""
+Unittest wrapper ensuring safe setUp / tearDown of all tests.
+This boilerplate code is not to be touched under any circumstances.
+"""
+import contextlib
+import shutil
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+from typing import Callable
+from typing import List
+from typing import Union
+from unittest import TestCase
+
+import numpy as np
+import pandas as pd
+from pydantic import Field
+from sqlalchemy import Engine
+from sqlmodel import create_engine
+from sqlmodel import SQLModel
+
+from ecodev_core.db_connection import exec_admin_queries
+from ecodev_core.db_connection import TEST_DB
+from ecodev_core.db_connection import TEST_DB_URL
+from ecodev_core.logger import log_critical
+from ecodev_core.logger import logger_get
+from ecodev_core.pydantic_utils import Frozen
+
+
+log = logger_get(__name__)
+
+
+class SafeTestCase(TestCase):
+    """
+    SafeTestCase makes sure that setUp / tearDown methods are always run when they should be.
+    This boilerplate code is not to be touched under any circumstances.
+    """
+    files_created: List[Path]
+    directories_created: List[Path]
+    test_engine: Engine
+
+    @classmethod
+    def setUpClass(cls) -> None:
+        """
+        Class set up, prompt class name and set files and folders to be suppressed at tearDownClass
+        """
+        log.info(f'Running test module: {cls.__module__.upper()}')
+        super().setUpClass()
+        cls.directories_created = []
+        cls.files_created = []
+
+    @classmethod
+    def tearDownClass(cls) -> None:
+        """
+        Safely suppress all files and directories used for this class
+        """
+        log.info(f'Done running test module: {cls.__module__.upper()}')
+        cls.safe_delete(cls.directories_created, cls.files_created)
+
+    def setUp(self) -> None:
+        """
+        Test set up, prompt test name and set files and folders to be suppressed at tearDown
+        """
+        super().setUp()
+        log.debug(f'Running test: {self._testMethodName.upper()}')
+        self.directories_created: List[Path] = []
+        self.files_created: List[Path] = []
+        exec_admin_queries([f'CREATE DATABASE {TEST_DB}'])
+        self.test_engine = create_engine(TEST_DB_URL, pool_pre_ping=True)
+        SQLModel.metadata.create_all(self.test_engine)
+
+    def tearDown(self) -> None:
+        """
+        Safely suppress all files and directories used for this test
+        """
+        log.debug(f'Done running test: {self._testMethodName.upper()}')
+        self.safe_delete(self.directories_created, self.files_created)
+        exec_admin_queries([
+            f"SELECT pg_terminate_backend(pid) FROM pg_stat_activity WHERE datname = '{TEST_DB}'",
+            f'DROP DATABASE IF EXISTS {TEST_DB}'
+        ])
+
+    @classmethod
+    def safe_delete(cls, directories_created: List[Path], files_created: List[Path]) -> None:
+        """
+        Safely suppress all passed files_created and directories_created
+
+        Args:
+            directories_created: directories used for the test making the call
+            files_created: files_created used for the test making the call
+        """
+        for directory in directories_created:
+            with contextlib.suppress(FileNotFoundError):
+                shutil.rmtree(directory)
+        for file_path in files_created:
+            file_path.unlink(missing_ok=True)
+
+    def run(self, result=None):
+        """
+        Wrapper around unittest run
+        """
+        test_method = getattr(self, self._testMethodName)
+        wrapped_test = self._cleanup_wrapper(test_method, KeyboardInterrupt)
+        setattr(self, self._testMethodName, wrapped_test)
+        self.setUp = self._cleanup_wrapper(self.setUp, BaseException)
+
+        return super().run(result)
+
+    def _cleanup_wrapper(self, method, exception):
+        """
+        Boilerplate code for clean setup and teardown
+        """
+
+        def _wrapped(*args, **kwargs):
+            try:
+                return method(*args, **kwargs)
+            except exception:
+                self.tearDown()
+                self.doCleanups()
+                raise
+
+        return _wrapped
+
+
+class SimpleReturn(Frozen):
+    """
+    Simple output for routes not returning anything
+    """
+    success: bool = Field(..., description=' True if the treatment went well.')
+    error: Union[str, None] = Field(..., description='the error that happened, if any.')
+
+    @classmethod
+    def route_success(cls) -> 'SimpleReturn':
+        """
+        Format DropDocumentReturn if the document was successfully dropped
+        """
+        return SimpleReturn(success=True, error=None)
+
+    @classmethod
+    def route_failure(cls, error: str) -> 'SimpleReturn':
+        """
+        Format DropDocumentReturn if the document failed to be dropped
+        """
+        return SimpleReturn(success=False, error=error)
+
+
+def safe_clt(func):
+    """
+    Safe execution of typer commands
+    """
+    def inner_function(*args, **kwargs):
+        try:
+            func(*args, **kwargs)
+            return SimpleReturn.route_success()
+        except Exception as error:
+            log_critical(f'something wrong happened: {error}', log)
+            return SimpleReturn.route_failure(str(error))
+    return inner_function
+
+
+def safe_method(func: Callable) -> Any | None:
+    """
+    Safe execution of a method
+    """
+    def inner_function(*args, **kwargs):
+        try:
+            return func(*args, **kwargs)
+        except Exception:
+            return None
+    return inner_function
+
+
+def stringify(x: Union[str, float], default: str | None = None) -> Union[str, None]:
+    """
+    Safe conversion of a (str, np.nan) value into a (str,None) one
+    """
+    return _transformify(x, str, default)
+
+
+def boolify(x: Union[Any], default: bool | None = None) -> Union[bool, None]:
+    """
+    Safe conversion of a (str, np.nan) value into a (str,None) one
+    """
+    return _transformify(x, _bool_check, default)
+
+
+def intify(x: Union[str, float], default: int | None = None) -> Union[int, None]:
+    """
+    Safe conversion of a (int, np.nan) value into a (int,None) one
+    """
+    return _transformify(x, int, default)
+
+
+def floatify(x: Union[str, float], default: float | None = None) -> Union[float, None]:
+    """
+    Safe conversion of a (float, np.nan) value into a (float,None) one
+    """
+    return _transformify(x, float, default)
+
+
+def datify(date: datetime | str,
+           date_format: str,
+           default: datetime | None = None
+           ) -> Union[datetime, None]:
+    """
+    Safe conversion to a date format
+    """
+    if pd.isnull(date):
+        return None
+    if isinstance(date, datetime):
+        return date
+    return _transformify(date, lambda x: datetime.strptime(x, date_format), default)
+
+
+def _transformify(x: Union[Any, float],
+                  transformation: Callable,
+                  default: Any | None) -> Union[Any, None]:
+    """
+    Safe conversion of a (Any, np.nan) value into a (Any,None) one thanks to transformation
+    """
+    if x is None or (isinstance(x, float) and np.isnan(x)):
+        return default
+
+    try:
+        return transformed if (transformed := transformation(x)) is not None else default
+
+    except ValueError:
+        return default
+
+
+def _bool_check(x: Union[Any, float]):
+    """
+    Check if the passed element can be cast into a boolean, or the boolean value inferred.
+    """
+    if isinstance(x, bool):
+        return x
+
+    if not isinstance(x, str) or x.lower() not in ['true', 'yes', 'false', 'no']:
+        return None
+
+    return x.lower() in ['true', 'yes']

ecodev_core/settings.py

@@ -0,0 +1,51 @@
+"""
+Module defining a dynamic setting class
+"""
+from contextlib import suppress
+from pathlib import Path
+
+from pydantic.v1.utils import deep_update
+from pydantic_settings import BaseSettings
+from pydantic_settings import SettingsConfigDict
+
+from ecodev_core.deployment import Deployment
+from ecodev_core.list_utils import dict_to_class
+from ecodev_core.read_write import load_yaml_file
+
+
+class DeploymentSetting(BaseSettings):
+    """
+    Settings class used to load the deployment type from environment variables.
+    """
+    environment: str = 'local'
+    base_path: str = '/app'
+    model_config = SettingsConfigDict(env_file='.env')
+
+
+DEPLOYMENT_SETTINGS = DeploymentSetting()
+DEPLOYMENT = Deployment(DEPLOYMENT_SETTINGS.environment.lower())
+BASE_PATH = Path(DEPLOYMENT_SETTINGS.base_path)
+
+
+class Settings:
+    """
+    Dynami setting class, loading yaml configuration from config file, possibly overwriting some of
+    this configuration with additional information coming from a secret file.
+    """
+
+    def __init__(self, base_path: Path = BASE_PATH, deployment: Deployment = DEPLOYMENT):
+        """
+        Dynamically setting Settings attributes, doing so recursively. Attributes are loaded
+         from config file, possibly overwriting some of this configuration with additional
+         information coming from a secret file.
+        """
+        self.deployment = deployment
+        with suppress(FileNotFoundError):
+            data = load_yaml_file(base_path / 'config' / f'{deployment.value}.yaml')
+            if (secrets_file := base_path / 'secrets' / f'{deployment.value}.yaml').exists():
+                data = deep_update(data, load_yaml_file(secrets_file))
+            for k, v in dict_to_class(data).items():
+                setattr(self, k, v)
+
+
+SETTINGS = Settings()

ecodev_core/sqlmodel_utils.py

@@ -0,0 +1,16 @@
+"""
+module implementing SQLModel related helper methods. Related to validation
+"""
+from sqlmodel import SQLModel
+
+
+class SQLModelWithVal(SQLModel):
+    """
+    Helper class to ease validation in SQLModel classes with table=True
+    """
+    @classmethod
+    def create(cls, **kwargs):
+        """
+        Forces validation to take place, even for SQLModel classes with table=True
+        """
+        return cls(**cls.__bases__[0](**kwargs).model_dump())

ecodev_core/token_banlist.py

@@ -0,0 +1,18 @@
+"""
+Module implementing the token ban list table
+"""
+from datetime import datetime
+from typing import Optional
+
+from sqlmodel import Field
+from sqlmodel import SQLModel
+
+
+class TokenBanlist(SQLModel, table=True):  # type: ignore
+    """
+    A token banlist: timestamped banned token.
+    """
+    __tablename__ = 'token_banlist'
+    id: Optional[int] = Field(default=None, primary_key=True)
+    created_at: datetime = Field(default_factory=datetime.utcnow)
+    token: str = Field(index=True)