ecodev-core 0.0.16__tar.gz

ecodev_core-0.0.16/LICENSE.md

@@ -0,0 +1,11 @@
+Copyright 2024 Thomas EPELBAUM for EcoAct
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

ecodev_core-0.0.16/PKG-INFO

@@ -0,0 +1,79 @@
+Metadata-Version: 2.1
+Name: ecodev-core
+Version: 0.0.16
+Summary: Low level sqlmodel/fastapi/pydantic building blocks
+License: MIT
+Author: Thomas Epelbaum
+Author-email: tomepel@gmail.com
+Requires-Python: >=3.11,<4.0
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Environment :: Web Environment
+Classifier: Framework :: AsyncIO
+Classifier: Framework :: FastAPI
+Classifier: Framework :: Pydantic
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Information Technology
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: System Administrators
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Topic :: Database
+Classifier: Topic :: Database :: Database Engines/Servers
+Classifier: Topic :: Internet
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Internet :: WWW/HTTP :: HTTP Servers
+Classifier: Topic :: Software Development
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Dist: fastapi (>=0,<1)
+Requires-Dist: httpx (>=0,<1)
+Requires-Dist: numpy (>=1,<2)
+Requires-Dist: openpyxl (>=3,<4)
+Requires-Dist: pandas (>=2,<3)
+Requires-Dist: passlib[bcyrypt] (>=1,<2)
+Requires-Dist: psycopg2-binary (>=2,<3)
+Requires-Dist: pydantic-settings (>=2,<3)
+Requires-Dist: pydantic[python-dotenv] (>=2,<3)
+Requires-Dist: python-jose[cryptography] (>=3,<4)
+Requires-Dist: sqladmin (==0.15.2)
+Requires-Dist: sqlmodel (>=0,<1)
+Description-Content-Type: text/markdown
+
+# ecodev-core
+
+<p align="center">
+<a href="https://github.com/FR-PAR-ECOACT/ecodev-core/actions" target="_blank">
+    <img src="https://github.com/FR-PAR-ECOACT/ecodev-core/blob/main/badges/coverage.svg" alt="Coverage">
+</a>
+<a href="https://github.com/FR-PAR-ECOACT/ecodev-core/actions" target="_blank">
+    <img src="https://github.com/FR-PAR-ECOACT/ecodev-core/blob/main/badges/pylint.svg" alt="Publish">
+</a>
+<a href="https://github.com/FR-PAR-ECOACT/ecodev-core/actions/workflows/code-quality.yml/badge.svg" target="_blank">
+    <img src="https://github.com/FR-PAR-ECOACT/ecodev-core/actions/workflows/code-quality.yml/badge.svg" alt="Package version">
+</a>
+</p>
+
+Low level ecoact generic code. Aimed at being published in open source with poetry
+
+## Installation of this package
+
+You are strongly encouraged to install this package via Docker.
+
+Starting from a project with a Docker file:
+* add the module ecodev-core in the `requirements.txt` file
+* make sure the `.env` file includes all required fields (see `BaseSettings` and `AuthenticationConfiguration`)
+* build the new version of the Docker container (typically `docker build --tag xxx .`)
+* run it with docker compose (`dc up -d`).
+
+## Documentation
+
+Please find it in the [associated mkdoc website!](https://ecodev-doc.lcabox.com/)
+

ecodev_core-0.0.16/README.md

@@ -0,0 +1,29 @@
+# ecodev-core
+
+<p align="center">
+<a href="https://github.com/FR-PAR-ECOACT/ecodev-core/actions" target="_blank">
+    <img src="https://github.com/FR-PAR-ECOACT/ecodev-core/blob/main/badges/coverage.svg" alt="Coverage">
+</a>
+<a href="https://github.com/FR-PAR-ECOACT/ecodev-core/actions" target="_blank">
+    <img src="https://github.com/FR-PAR-ECOACT/ecodev-core/blob/main/badges/pylint.svg" alt="Publish">
+</a>
+<a href="https://github.com/FR-PAR-ECOACT/ecodev-core/actions/workflows/code-quality.yml/badge.svg" target="_blank">
+    <img src="https://github.com/FR-PAR-ECOACT/ecodev-core/actions/workflows/code-quality.yml/badge.svg" alt="Package version">
+</a>
+</p>
+
+Low level ecoact generic code. Aimed at being published in open source with poetry
+
+## Installation of this package
+
+You are strongly encouraged to install this package via Docker.
+
+Starting from a project with a Docker file:
+* add the module ecodev-core in the `requirements.txt` file
+* make sure the `.env` file includes all required fields (see `BaseSettings` and `AuthenticationConfiguration`)
+* build the new version of the Docker container (typically `docker build --tag xxx .`)
+* run it with docker compose (`dc up -d`).
+
+## Documentation
+
+Please find it in the [associated mkdoc website!](https://ecodev-doc.lcabox.com/)

ecodev_core-0.0.16/ecodev_core/__init__.py

@@ -0,0 +1,81 @@
+"""
+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 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_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.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_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.enum_utils import enum_converter
+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.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 jsonify_series
+from ecodev_core.pandas_utils import pd_equals
+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 make_dir
+from ecodev_core.read_write import write_json_file
+from ecodev_core.safe_utils import boolify
+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
+
+__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']

ecodev_core-0.0.16/ecodev_core/app_activity.py

@@ -0,0 +1,108 @@
+"""
+Module implementing a simple monitoring table
+"""
+import inspect
+from datetime import datetime
+from typing import Dict
+from typing import Optional
+
+from sqlmodel import col
+from sqlmodel import Field
+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):
+    """
+    Returns all activities that happened after last_date
+    """
+    return session.exec(select(AppActivity).where(col(AppActivity.created_at) > last_date)).all()

ecodev_core-0.0.16/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-0.0.16/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 Dict
+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[Dict]:
+    """
+    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-0.0.16/ecodev_core/auth_configuration.py

@@ -0,0 +1,18 @@
+"""
+Module implementing authentication configuration.
+"""
+from pydantic_settings import BaseSettings
+from pydantic_settings import SettingsConfigDict
+
+
+class AuthenticationConfiguration(BaseSettings):
+    """
+    Simple authentication configuration class
+    """
+    secret_key: str
+    algorithm: str
+    access_token_expire_minutes: int
+    model_config = SettingsConfigDict(env_file='.env')
+
+
+AUTH = AuthenticationConfiguration()