ecodev-core 0.0.8__tar.gz → 0.0.10__tar.gz

{ecodev_core-0.0.8 → ecodev_core-0.0.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ecodev-core
-Version: 0.0.8
+Version: 0.0.10
 Summary: Low level sqlmodel/fastapi/pydantic building blocks
 License: MIT
 Author: Thomas Epelbaum
@@ -36,6 +36,7 @@ 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)

{ecodev_core-0.0.8 → ecodev_core-0.0.10}/ecodev_core/__init__.py

@@ -42,11 +42,13 @@ 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
@@ -76,4 +78,4 @@ __all__ = [
     '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']
+    'get_access_token', 'safe_get_user', 'backup', 'group_by', 'get_excelfile']

{ecodev_core-0.0.8 → ecodev_core-0.0.10}/ecodev_core/authentication.py

@@ -39,6 +39,7 @@ CONTEXT = CryptContext(schemes=['bcrypt'], deprecated='auto')
 MONITORING = 'monitoring'
 MONITORING_ERROR = 'Could not validate credentials. You need to be the monitoring user to call this'
 INVALID_USER = 'Invalid User'
+INVALID_TFA = 'Invalid TFA code'
 ADMIN_ERROR = 'Could not validate credentials. You need admin rights to call this'
 INVALID_CREDENTIALS = 'Invalid Credentials'
 log = logger_get(__name__)
@@ -93,7 +94,7 @@ class JwtAuth(AuthenticationBackend):
         return True if token else False
 
     @staticmethod
-    def authorized(form: Dict):
+    def authorized(form: Any):
         """
         Check that the user information contained in the form corresponds to an admin user
         """
@@ -122,9 +123,19 @@ class JwtAuth(AuthenticationBackend):
 
 def attempt_to_log(user: str,
                    password: str,
-                   session: Session) -> Union[Dict, HTTPException]:
+                   session: Session,
+                   tfa_value: Optional[str] = None
+                   ) -> Union[Dict, HTTPException]:
     """
-    Factorized security logic. Ensure that the user is a legit one with a valid password
+    Factorized security logic. Ensure that the user is a legit one with a valid password.
+    If so, generate a token (with or without encoded tfa_value depending on whether this argument is
+    passed as an argument). If not, returns an HTTP exception with an intelligible error message.
+
+    Attributes are:
+        user: the user as expected to be found in the AppUser db
+        password: the plain password, to be compared with the hashed one in the AppUser db
+        session: db connection
+        tfa_value: if filled, add it encoded to the generated token
     """
     selector = select(AppUser).where(col(AppUser.user) == user)
     if not (db_user := session.exec(selector).first()):
@@ -134,54 +145,54 @@ def attempt_to_log(user: str,
         log.warning('invalid user')
         raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail=INVALID_CREDENTIALS)
 
-    return {'access_token': _create_access_token(data={'user_id': db_user.id}),
+    return {'access_token': _create_access_token(data={'user_id': db_user.id, 'tfa': tfa_value}),
             'token_type': 'bearer'}
 
 
-def is_authorized_user(token: str = Depends(SCHEME)) -> bool:
+def is_authorized_user(token: str = Depends(SCHEME),  tfa_value: Optional[str] = None) -> bool:
     """
     Check if the passed token corresponds to an authorized user
     """
     try:
-        return get_current_user(token) is not None
+        return get_current_user(token, tfa_value) is not None
     except Exception:
         return False
 
 
-def safe_get_user(token: Dict) -> Union[AppUser, None]:
+def safe_get_user(token: Dict, tfa: bool = False) -> Union[AppUser, None]:
     """
     Safe method returning a user if one found given the passed token
     """
     try:
-        return get_user(get_access_token(token))
+        return get_user(get_access_token(token), token['tfa'] if tfa else None)
     except (HTTPException, AttributeError):
         return None
 
 
-def get_user(token: str = Depends(SCHEME)) -> AppUser:
+def get_user(token: str = Depends(SCHEME), tfa_value: Optional[str] = None) -> AppUser:
     """
     Retrieves (if it exists) the db user corresponding to the passed token
     """
-    if user := get_current_user(token):
+    if user := get_current_user(token, tfa_value):
         return user
     raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail=INVALID_CREDENTIALS,
                         headers={'WWW-Authenticate': 'Bearer'})
 
 
-def get_current_user(token: str) -> Union[AppUser, None]:
+def get_current_user(token: str, tfa_value: Optional[str] = None) -> Union[AppUser, None]:
     """
     Retrieves (if it exists) a valid (meaning who has valid credentials) user from the db
     """
-    token = _verify_access_token(token)
+    token = _verify_access_token(token, tfa_value)
     with Session(engine) as session:
         return session.exec(select(AppUser).where(col(AppUser.id) == token.id)).first()
 
 
-def is_admin_user(token: str = Depends(SCHEME)) -> AppUser:
+def is_admin_user(token: str = Depends(SCHEME), tfa_value: Optional[str] = None) -> AppUser:
     """
     Retrieves (if it exists) the admin (meaning who has valid credentials) user from the db
     """
-    if (user := get_current_user(token)) and user.permission == Permission.ADMIN:
+    if (user := get_current_user(token, tfa_value)) and user.permission == Permission.ADMIN:
         return user
     raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail=ADMIN_ERROR,
                         headers={'WWW-Authenticate': 'Bearer'})
@@ -197,22 +208,27 @@ def is_monitoring_user(token: str = Depends(SCHEME)) -> AppUser:
                         detail=MONITORING_ERROR, headers={'WWW-Authenticate': 'Bearer'})
 
 
-def _create_access_token(data: Dict) -> str:
+def _create_access_token(data: Dict, tfa_value: Optional[str] = None) -> str:
     """
     Create an access token out of the passed data. Only called if credentials are valid
     """
     to_encode = data.copy()
     expire = datetime.now(timezone.utc) + timedelta(minutes=AUTH.access_token_expire_minutes)
-    to_encode.update({'exp': expire})
+    to_encode['exp'] = expire
+    if tfa_value:
+        to_encode['tfa'] = _hash_password(tfa_value)
     return jwt.encode(to_encode, AUTH.secret_key, algorithm=AUTH.algorithm)
 
 
-def _verify_access_token(token: str) -> TokenData:
+def _verify_access_token(token: str, tfa_value: Optional[str] = None) -> TokenData:
     """
     Retrieves the token data associated to the passed token if it contains valid credential info.
     """
     try:
         payload = jwt.decode(token, AUTH.secret_key, algorithms=[AUTH.algorithm])
+        if tfa_value and not _check_password(tfa_value, payload.get('tfa')):
+            raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail=INVALID_TFA,
+                                headers={'WWW-Authenticate': 'Bearer'})
         if (user_id := payload.get('user_id')) is None:
             raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail=INVALID_USER,
                                 headers={'WWW-Authenticate': 'Bearer'})

{ecodev_core-0.0.8 → ecodev_core-0.0.10}/ecodev_core/list_utils.py

@@ -2,11 +2,14 @@
 Module implementing helper methods working on lists
 """
 from collections import defaultdict
+from itertools import groupby
 from typing import Any
 from typing import Callable
 from typing import Dict
+from typing import Iterator
 from typing import List
 from typing import Optional
+from typing import Tuple
 from typing import Union
 
 
@@ -42,6 +45,19 @@ def first_or_default(sequence: Union[List[Any], None],
     return next((elt for elt in sequence if condition(elt)), default)
 
 
+def group_by(sequence: List[Any], key: Union[Callable, None]) -> Iterator[Tuple[Any, List[Any]]]:
+    """
+    Extension of itertools groupby method.
+
+    Reasons of existence:
+        - do the sorting before the grouping to avoid the usual mistake of forgetting the sorting
+        - convert the group Iterator to a list. More convenient that the default groupby behaviour
+           in all cases where you need to iterate more than once on the group
+    """
+    for key, group in groupby(sorted(sequence, key=key), key=key):
+        yield key, list(group)
+
+
 def lselect(sequence: List[Any], condition: Union[Callable, None] = None) -> List[Any]:
     """
     Filter the passed sequence according to the passed condition

{ecodev_core-0.0.8 → ecodev_core-0.0.10}/ecodev_core/pandas_utils.py

@@ -2,6 +2,7 @@
 Module implementing some utilitary methods on pandas types
 """
 import tempfile
+from base64 import b64decode
 from pathlib import Path
 from typing import Dict
 
@@ -28,3 +29,12 @@ def jsonify_series(row: pd.Series) -> Dict:
     """
     return {key: None if isinstance(value, float) and np.isnan(value) else value for key, value in
             row.to_dict().items()}
+
+
+def get_excelfile(contents: str) -> pd.ExcelFile:
+    """
+    Function which converts user xlsx file upload into a pd.ExcelFile
+    """
+    content_type, content_string = contents.split(',')
+    xl = b64decode(content_string)
+    return pd.ExcelFile(xl)

{ecodev_core-0.0.8 → ecodev_core-0.0.10}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "ecodev-core"
-version = "0.0.8"
+version = "0.0.10"
 description = "Low level sqlmodel/fastapi/pydantic building blocks"
 authors = ["Thomas Epelbaum <tomepel@gmail.com>",
 					 "Olivier Gabriel <olivier.gabriel.geom@gmail.com>",
@@ -53,6 +53,7 @@ sqladmin = "0.15.2"
 httpx = "~0"
 pydantic-settings = "~2"
 psycopg2-binary = "~2"
+openpyxl = "~3"
 
 
 [build-system]