ecodev-core 0.0.67__py3-none-any.whl

ecodev_core/__init__.py

@@ -0,0 +1,129 @@
+"""
+Module listing all public method from the ecodev_core modules
+"""
+from ecodev_core.app_activity import AppActivity
+from ecodev_core.app_activity import dash_monitor
+from ecodev_core.app_activity import fastapi_monitor
+from ecodev_core.app_activity import get_method
+from ecodev_core.app_activity import get_recent_activities
+from ecodev_core.app_rights import AppRight
+from ecodev_core.app_user import AppUser
+from ecodev_core.app_user import select_user
+from ecodev_core.app_user import upsert_app_users
+from ecodev_core.auth_configuration import AUTH
+from ecodev_core.authentication import attempt_to_log
+from ecodev_core.authentication import ban_token
+from ecodev_core.authentication import get_access_token
+from ecodev_core.authentication import get_app_services
+from ecodev_core.authentication import get_current_user
+from ecodev_core.authentication import get_user
+from ecodev_core.authentication import is_admin_user
+from ecodev_core.authentication import is_authorized_user
+from ecodev_core.authentication import is_banned
+from ecodev_core.authentication import is_monitoring_user
+from ecodev_core.authentication import JwtAuth
+from ecodev_core.authentication import safe_get_user
+from ecodev_core.authentication import SCHEME
+from ecodev_core.authentication import Token
+from ecodev_core.authentication import upsert_new_user
+from ecodev_core.backup import backup
+from ecodev_core.check_dependencies import check_dependencies
+from ecodev_core.check_dependencies import compute_dependencies
+from ecodev_core.custom_equal import custom_equal
+from ecodev_core.db_connection import create_db_and_tables
+from ecodev_core.db_connection import DB_URL
+from ecodev_core.db_connection import delete_table
+from ecodev_core.db_connection import engine
+from ecodev_core.db_connection import get_session
+from ecodev_core.db_connection import info_message
+from ecodev_core.db_filters import ServerSideFilter
+from ecodev_core.db_i18n import get_lang
+from ecodev_core.db_i18n import I18nMixin
+from ecodev_core.db_i18n import Lang
+from ecodev_core.db_i18n import localized_col
+from ecodev_core.db_i18n import set_lang
+from ecodev_core.db_insertion import generic_insertion
+from ecodev_core.db_insertion import get_raw_df
+from ecodev_core.db_retrieval import count_rows
+from ecodev_core.db_retrieval import get_rows
+from ecodev_core.db_retrieval import ServerSideField
+from ecodev_core.db_upsertion import add_missing_columns
+from ecodev_core.db_upsertion import add_missing_enum_values
+from ecodev_core.db_upsertion import field
+from ecodev_core.db_upsertion import filter_to_sfield_dict
+from ecodev_core.db_upsertion import get_sfield_columns
+from ecodev_core.db_upsertion import sfield
+from ecodev_core.db_upsertion import upsert_data
+from ecodev_core.db_upsertion import upsert_deletor
+from ecodev_core.db_upsertion import upsert_df_data
+from ecodev_core.db_upsertion import upsert_selector
+from ecodev_core.deployment import Deployment
+from ecodev_core.email_sender import send_email
+from ecodev_core.encryption import decrypt_value
+from ecodev_core.encryption import encrypt_value
+from ecodev_core.enum_utils import enum_converter
+from ecodev_core.list_utils import first_func_or_default
+from ecodev_core.list_utils import first_or_default
+from ecodev_core.list_utils import first_transformed_or_default
+from ecodev_core.list_utils import group_by
+from ecodev_core.list_utils import group_by_value
+from ecodev_core.list_utils import lselect
+from ecodev_core.list_utils import lselectfirst
+from ecodev_core.list_utils import sort_by_keys
+from ecodev_core.list_utils import sort_by_values
+from ecodev_core.logger import log_critical
+from ecodev_core.logger import logger_get
+from ecodev_core.pandas_utils import get_excelfile
+from ecodev_core.pandas_utils import get_value
+from ecodev_core.pandas_utils import is_null
+from ecodev_core.pandas_utils import jsonify_series
+from ecodev_core.pandas_utils import pd_equals
+from ecodev_core.pandas_utils import safe_drop_columns
+from ecodev_core.permissions import Permission
+from ecodev_core.pydantic_utils import Basic
+from ecodev_core.pydantic_utils import CustomFrozen
+from ecodev_core.pydantic_utils import Frozen
+from ecodev_core.pydantic_utils import OrmFrozen
+from ecodev_core.read_write import load_json_file
+from ecodev_core.read_write import load_yaml_file
+from ecodev_core.read_write import make_dir
+from ecodev_core.read_write import write_json_file
+from ecodev_core.safe_utils import boolify
+from ecodev_core.safe_utils import datify
+from ecodev_core.safe_utils import floatify
+from ecodev_core.safe_utils import intify
+from ecodev_core.safe_utils import safe_clt
+from ecodev_core.safe_utils import SafeTestCase
+from ecodev_core.safe_utils import SimpleReturn
+from ecodev_core.safe_utils import stringify
+from ecodev_core.settings import SETTINGS
+from ecodev_core.settings import Settings
+from ecodev_core.token_banlist import TokenBanlist
+from ecodev_core.version import db_to_value
+from ecodev_core.version import get_row_versions
+from ecodev_core.version import get_versions
+from ecodev_core.version import Version
+from ecodev_core.rest_api_client import get_rest_api_client
+from ecodev_core.rest_api_client import RestApiClient
+from ecodev_core.rest_api_client import handle_response
+from ecodev_core.rest_api_configuration import API_AUTH
+__all__ = [
+    'AUTH', 'Token', 'get_app_services', 'attempt_to_log', 'get_current_user', 'is_admin_user',
+    'write_json_file', 'load_json_file', 'make_dir', 'check_dependencies', 'compute_dependencies',
+    'engine', 'create_db_and_tables', 'get_session', 'info_message', 'group_by_value', 'OrmFrozen',
+    'first_or_default', 'lselect', 'lselectfirst', 'first_transformed_or_default', 'log_critical',
+    'logger_get', 'Permission', 'AppUser', 'AppRight', 'Basic', 'Frozen', 'CustomFrozen', 'JwtAuth',
+    'SafeTestCase', 'SimpleReturn', 'safe_clt', 'stringify', 'boolify', 'get_user', 'floatify',
+    'delete_table', 'SCHEME', 'DB_URL', 'pd_equals', 'jsonify_series', 'upsert_app_users', 'intify',
+    'enum_converter', 'ServerSideFilter', 'get_rows', 'count_rows', 'ServerSideField', 'get_raw_df',
+    'generic_insertion', 'custom_equal', 'is_authorized_user', 'get_method', 'AppActivity',
+    'fastapi_monitor', 'dash_monitor', 'is_monitoring_user', 'get_recent_activities', 'select_user',
+    'get_access_token', 'safe_get_user', 'backup', 'group_by', 'get_excelfile', 'upsert_new_user',
+    'datify', 'safe_drop_columns', 'get_value', 'is_null', 'send_email', 'first_func_or_default',
+    'sort_by_keys', 'sort_by_values', 'Settings', 'load_yaml_file', 'Deployment', 'Version',
+    'sfield', 'field', 'upsert_df_data', 'upsert_deletor', 'get_row_versions', 'get_versions',
+    'db_to_value', 'upsert_data', 'upsert_selector', 'get_sfield_columns', 'filter_to_sfield_dict',
+    'SETTINGS', 'add_missing_enum_values', 'ban_token', 'TokenBanlist', 'is_banned',
+    'get_lang', 'set_lang', 'Lang', 'localized_col', 'I18nMixin', 'add_missing_columns',
+    'encrypt_value', 'decrypt_value', 'get_rest_api_client', 'RestApiClient', 'handle_response',
+    'API_AUTH']

ecodev_core/app_activity.py

@@ -0,0 +1,126 @@
+"""
+Module implementing a simple monitoring table
+"""
+import inspect
+from datetime import datetime
+from typing import Optional
+
+from sqlmodel import cast
+from sqlmodel import col
+from sqlmodel import extract
+from sqlmodel import Field
+from sqlmodel import func
+from sqlmodel import Integer
+from sqlmodel import select
+from sqlmodel import Session
+from sqlmodel import SQLModel
+
+from ecodev_core.app_user import AppUser
+from ecodev_core.authentication import get_user
+from ecodev_core.db_connection import engine
+
+
+"""
+Simple helper to retrieve the method name in which this helper is called
+
+NB: this is meant to stay a lambda, otherwise the name retrieved is get_method, not the caller
+"""
+
+
+def get_method(): return inspect.stack()[1][3]
+
+
+class AppActivityBase(SQLModel):
+    """
+    Simple monitoring class
+
+    Attributes are:
+        - user: the name of the user that triggered the monitoring log
+        - application: the application in which the user triggered the monitoring log
+        - method: the method called by the user  that triggered the monitoring log
+        - relevant_option: if filled, complementary information on method (num of treated lines...)
+    """
+    user: str = Field(index=True)
+    application: str = Field(index=True)
+    method: str = Field(index=True)
+    relevant_option: Optional[str] = Field(index=True, default=None)
+
+
+class AppActivity(AppActivityBase, table=True):  # type: ignore
+    """
+    The table version of the AppActivityBase monitoring class
+    """
+    __tablename__ = 'app_activity'
+    id: Optional[int] = Field(default=None, primary_key=True)
+    created_at: datetime = Field(default_factory=datetime.utcnow)
+
+
+def dash_monitor(method: str,
+                 token: dict,
+                 application: str,
+                 relevant_option: Optional[str] = None):
+    """
+    Generic dash monitor.
+
+     Attributes are:
+        - method: the method called by the user  that triggered the monitoring log
+        - token: contains the information on the user that triggered the monitoring log
+        - application: the application in which the user triggered the monitoring log
+        - relevant_option: if filled, complementary information on method (num of treated lines...)
+    """
+    with Session(engine) as session:
+        user = get_user(token.get('token', {}).get('access_token'))
+        add_activity_to_db(method, user, application, session, relevant_option)
+
+
+def fastapi_monitor(method: str,
+                    user: AppUser,
+                    application: str,
+                    session: Session,
+                    relevant_option: Optional[str] = None):
+    """
+    Generic fastapi monitor.
+
+     Attributes are:
+        - method: the method called by the user  that triggered the monitoring log
+        - user: the name of the user that triggered the monitoring log
+        - application: the application in which the user triggered the monitoring log
+        - session: db connection
+        - relevant_option: if filled, complementary information on method (num of treated lines...)
+    """
+    add_activity_to_db(method, user, application, session, relevant_option)
+
+
+def add_activity_to_db(method: str,
+                       user: AppUser,
+                       application: str,
+                       session: Session,
+                       relevant_option: Optional[str] = None):
+    """
+    Add a new entry in AppActivity given the passed arguments
+    """
+    session.add(AppActivity(user=user.user, application=application, method=method,
+                            relevant_option=relevant_option))
+    session.commit()
+
+
+def get_recent_activities(last_date: str, session: Session) -> list[AppActivity]:
+    """
+    Returns all activities that happened after last_date
+    """
+    return session.exec(select(AppActivity).where(col(AppActivity.created_at) > last_date)).all()
+
+
+def get_monthly_activities(last_date: str, session: Session) -> dict[tuple[int, int], int]:
+    """
+    Returns all activities that happened after last_date, grouped by year month.
+    """
+    query = (select(
+        cast(extract('year', AppActivity.created_at), Integer).label('year'),
+        cast(extract('month', AppActivity.created_at), Integer).label('month'),
+        func.count().label('count'))
+        .where(col(AppActivity.created_at) > last_date)
+        .group_by(extract('year', AppActivity.created_at), extract('month', AppActivity.created_at))
+        .order_by(extract('year', AppActivity.created_at), extract('month', AppActivity.created_at))
+    )
+    return dict(sorted(((year, month), value) for year, month, value in session.exec(query).all()))

ecodev_core/app_rights.py

@@ -0,0 +1,24 @@
+"""
+Module implementing the sqlmodel orm part of the right table
+"""
+from typing import Optional
+from typing import TYPE_CHECKING
+
+from sqlmodel import Field
+from sqlmodel import Relationship
+from sqlmodel import SQLModel
+
+
+if TYPE_CHECKING:  # pragma: no cover
+    from ecodev_core.app_user import AppUser
+
+
+class AppRight(SQLModel, table=True):  # type: ignore
+    """
+    Simple right class: listing all app_services that a particular user can access to
+    """
+    __tablename__ = 'app_right'
+    id: Optional[int] = Field(default=None, primary_key=True)
+    app_service: str
+    user_id: Optional[int] = Field(default=None, foreign_key='app_user.id')
+    user: Optional['AppUser'] = Relationship(back_populates='rights')

ecodev_core/app_user.py

@@ -0,0 +1,92 @@
+"""
+Module implementing the sqlmodel orm part of the user table
+"""
+from pathlib import Path
+from typing import Any
+from typing import List
+from typing import Optional
+from typing import TYPE_CHECKING
+
+import pandas as pd
+from sqlmodel import col
+from sqlmodel import Field
+from sqlmodel import Relationship
+from sqlmodel import select
+from sqlmodel import Session
+from sqlmodel import SQLModel
+from sqlmodel.sql.expression import SelectOfScalar
+
+from ecodev_core.db_insertion import create_or_update
+from ecodev_core.db_insertion import Insertor
+from ecodev_core.permissions import Permission
+from ecodev_core.read_write import load_json_file
+
+
+if TYPE_CHECKING:  # pragma: no cover
+    from ecodev_core.app_rights import AppRight
+
+
+class AppUser(SQLModel, table=True):  # type: ignore
+    """
+    Simple user class: an id associate to a user with a password
+    """
+    __tablename__ = 'app_user'
+    id: Optional[int] = Field(default=None, primary_key=True)
+    user: str = Field(index=True)
+    password: str
+    permission: Permission = Field(default=Permission.ADMIN)
+    client: Optional[str] = Field(default=None)
+    rights: List['AppRight'] = Relationship(back_populates='user')
+
+
+def user_convertor(df: pd.DataFrame) -> List[Any]:
+    """
+    Dummy user convertor
+    """
+    return [x for _, x in df.iterrows()]
+
+
+def user_reductor(in_db_row: AppUser,  db_row: AppUser) -> AppUser:
+    """
+    Update an existing in_db_row with new information coming from db_row
+
+    NB: in the future this will maybe handle the client as well
+    """
+    in_db_row.permission = db_row.permission
+    in_db_row.password = db_row.password
+    return in_db_row
+
+
+def user_selector(db_row: AppUser) -> SelectOfScalar:
+    """
+    Criteria on which to decide whether creating a new row or updating an existing one in db
+    """
+    return select(AppUser).where(col(AppUser.user) == db_row.user)
+
+
+USER_INSERTOR = Insertor(convertor=user_convertor, selector=user_selector,
+                         reductor=user_reductor, db_schema=AppUser, read_excel_file=False)
+
+
+def upsert_app_users(file_path: Path, session: Session) -> None:
+    """
+    Upsert db users with a list of users provided in the file_path (json format)
+    """
+    for user in load_json_file(file_path):
+        session.add(create_or_update(session, user, USER_INSERTOR))
+        session.commit()
+
+
+def select_user(username: str, session: Session) -> AppUser:
+    """
+    Helper function to (attempt to) retrieve AppUser from username.
+
+    NB: Used to check whether user exists, before resetting its password.
+    I.e. User does not yet have a token - we are simply checking if
+    an active account exists under that username.
+
+    Raises:
+        sqlalchemy.exc.NoResultFound: Typical error is no users are found.
+        sqlalchemy.exc.MultipleResultsFound: Should normally never be an issue.
+    """
+    return session.exec(select(AppUser).where(col(AppUser.user) == username)).one()

ecodev_core/auth_configuration.py

@@ -0,0 +1,24 @@
+"""
+Module implementing authentication configuration.
+"""
+from pydantic_settings import BaseSettings
+from pydantic_settings import SettingsConfigDict
+
+from ecodev_core.settings import SETTINGS
+
+
+class AuthenticationConfiguration(BaseSettings):
+    """
+    Simple authentication configuration class
+    """
+    secret_key: str = ''
+    algorithm: str = ''
+    access_token_expire_minutes: int = 0
+    model_config = SettingsConfigDict(env_file='.env')
+
+
+AUTH = AuthenticationConfiguration()
+SETTINGS_AUTH = SETTINGS.authentication  # type: ignore[attr-defined]
+SECRET_KEY = SETTINGS_AUTH.secret_key or AUTH.secret_key
+ALGO = SETTINGS_AUTH.algorithm or AUTH.algorithm
+EXPIRATION_LENGTH = SETTINGS_AUTH.access_token_expire_minutes or AUTH.access_token_expire_minutes