ecodev-core 0.0.41__tar.gz → 0.0.42__tar.gz

{ecodev_core-0.0.41 → ecodev_core-0.0.42}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ecodev-core
-Version: 0.0.41
+Version: 0.0.42
 Summary: Low level sqlmodel/fastapi/pydantic building blocks
 License: MIT
 Author: Thomas Epelbaum

{ecodev_core-0.0.41 → ecodev_core-0.0.42}/ecodev_core/app_activity.py

@@ -3,11 +3,14 @@ Module implementing a simple monitoring table
 """
 import inspect
 from datetime import datetime
-from typing import Dict
 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
@@ -53,7 +56,7 @@ class AppActivity(AppActivityBase, table=True):  # type: ignore
 
 
 def dash_monitor(method: str,
-                 token: Dict,
+                 token: dict,
                  application: str,
                  relevant_option: Optional[str] = None):
     """
@@ -101,8 +104,23 @@ def add_activity_to_db(method: str,
     session.commit()
 
 
-def get_recent_activities(last_date: str, session: Session):
+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-0.0.41 → ecodev_core-0.0.42}/ecodev_core/backup.py

@@ -43,6 +43,17 @@ def backup(backed_folder: Path, nb_saves: int = 5, additional_id: str = 'default
     _backup_files(backed_folder, Path.cwd() / f'{additional_id}_files.{timestamp}.tgz', nb_saves)
 
 
+def retrieve_most_recent_backup(name: str = 'default_files') -> None:
+    """
+    Retrieve from backup server the most recent backup of the name family.
+    """
+    output = run(['lftp', '-c', f'open {BACKUP_URL}; ls'], capture_output=True, text=True)
+    all_backups = sorted([x.split(' ')[-1] for x in output.stdout.splitlines() if name in x])
+    log.info(f'most recent backup {all_backups[-1]}')
+    run(['lftp', '-c', f'open {BACKUP_URL}; get {all_backups[-1]}'])
+    return None
+
+
 def _backup_db(db_dump_path: Path, nb_saves: int) -> None:
     """
     Pg_dump of DB_URL db andwrite on the backup server
@@ -80,8 +91,7 @@ def _get_old_backups(file_to_backup: Path, nb_saves: int) -> List[str]:
     """
     Retrieve old versions of file_to_backup in order to erase them (more than nb_saves ago)
     """
-    output = run(['lftp', '-c', f'open {BACKUP_URL}; ls'],
-                 capture_output=True, text=True)
+    output = run(['lftp', '-c', f'open {BACKUP_URL}; ls'], capture_output=True, text=True)
     filename_base = file_to_backup.name.split('.')[0]
     all_backups = sorted([x.split(' ')[-1]
                          for x in output.stdout.splitlines() if filename_base in x])

{ecodev_core-0.0.41 → ecodev_core-0.0.42}/ecodev_core/safe_utils.py

@@ -144,35 +144,50 @@ def safe_clt(func):
     return inner_function
 
 
-def stringify(x: Union[str, float]) -> Union[str, None]:
+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)
+    return _transformify(x, str, default)
 
 
-def boolify(x: Union[Any]) -> Union[bool, None]:
+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)
+    return _transformify(x, _bool_check, default)
 
 
-def intify(x: Union[str, float]) -> Union[int, None]:
+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)
+    return _transformify(x, int, default)
 
 
-def floatify(x: Union[str, float]) -> Union[float, None]:
+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)
+    return _transformify(x, float, default)
 
 
-def datify(date: str, date_format: str) -> Union[datetime, None]:
+def datify(date: datetime | str,
+           date_format: str,
+           default: datetime | None = None
+           ) -> Union[datetime, None]:
     """
     Safe conversion to a date format
     """
@@ -180,21 +195,23 @@ def datify(date: str, date_format: str) -> Union[datetime, None]:
         return None
     if isinstance(date, datetime):
         return date
-    return _transformify(date, lambda x: datetime.strptime(x, date_format))
+    return _transformify(date, lambda x: datetime.strptime(x, date_format), default)
 
 
-def _transformify(x: Union[Any, float], transformation: Callable) -> Union[Any, None]:
+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 None
+        return default
 
     try:
-        return transformation(x)
+        return transformed if (transformed := transformation(x)) is not None else default
 
     except ValueError:
-        return None
+        return default
 
 
 def _bool_check(x: Union[Any, float]):

{ecodev_core-0.0.41 → ecodev_core-0.0.42}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "ecodev-core"
-version = "0.0.41"
+version = "0.0.42"
 description = "Low level sqlmodel/fastapi/pydantic building blocks"
 authors = ["Thomas Epelbaum <tomepel@gmail.com>",
 					 "Olivier Gabriel <olivier.gabriel.geom@gmail.com>",