sera-2 1.20.16__tar.gz → 1.21.0__tar.gz

{sera_2-1.20.16 → sera_2-1.21.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: sera-2
-Version: 1.20.16
+Version: 1.21.0
 Summary: 
 Author: Binh Vu
 Author-email: bvu687@gmail.com

{sera_2-1.20.16 → sera_2-1.21.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "sera-2"
-version = "1.20.16"
+version = "1.21.0"
 description = ""
 authors = ["Binh Vu <bvu687@gmail.com>"]
 readme = "README.md"

{sera_2-1.20.16 → sera_2-1.21.0}/sera/libs/base_service.py

@@ -128,8 +128,6 @@ class BaseAsyncService(Generic[ID, R]):
                         func.to_tsvector(getattr(self.orm_cls, field)).match(value)
                     )
 
-        print(">>>", q)
-
         cq = select(func.count()).select_from(q.subquery())
         rq = q.limit(limit).offset(offset)
         records = self._process_result(await session.execute(rq)).scalars().all()

{sera_2-1.20.16 → sera_2-1.21.0}/sera/libs/directed_computing_graph/_dcg.py

@@ -201,7 +201,7 @@ class DirectedComputingGraph:
 
         Args:
             input: A dictionary mapping function identifiers to their input arguments.
-            output: A set of function identifiers that should be executed.
+            output: A set of function identifiers that their output should be captured.
             context: An optional context that can be a dictionary of functions or a single function.
         """
         assert all(
@@ -307,7 +307,7 @@ class DirectedComputingGraph:
 
         Args:
             input: A dictionary mapping function identifiers to their input arguments.
-            output: A set of function identifiers that should be executed.
+            output: A set of function identifiers that their output should be captured.
             context: An optional context that can be a dictionary of functions or a single function.
         """
         assert all(

{sera_2-1.20.16 → sera_2-1.21.0}/sera/misc/__init__.py

@@ -9,6 +9,7 @@ from sera.misc._utils import (
     identity,
     load_data,
     load_data_from_dir,
+    replay_events,
     to_camel_case,
     to_pascal_case,
     to_snake_case,
@@ -30,4 +31,5 @@ __all__ = [
     "LoadTableDataArgs",
     "RelTableIndex",
     "load_data_from_dir",
+    "replay_events",
 ]

{sera_2-1.20.16 → sera_2-1.21.0}/sera/misc/_utils.py

@@ -4,9 +4,9 @@ import importlib
 import inspect
 import re
 from collections import defaultdict
-from dataclasses import dataclass
 from pathlib import Path
 from typing import (
+    TYPE_CHECKING,
     Any,
     Callable,
     Iterable,
@@ -27,6 +27,9 @@ from sqlalchemy import Engine, text
 from sqlalchemy.orm import Session
 from tqdm import tqdm
 
+if TYPE_CHECKING:
+    from sera.libs.directed_computing_graph import DirectedComputingGraph
+
 T = TypeVar("T")
 
 TYPE_ALIASES = {"typing.List": "list", "typing.Dict": "dict", "typing.Set": "set"}
@@ -138,6 +141,52 @@ def filter_duplication(
     return new_lst
 
 
+def identity(x: T) -> T:
+    """Identity function that returns the input unchanged."""
+    return x
+
+
+def get_classpath(type: Type | Callable) -> str:
+    if type.__module__ == "builtins":
+        return type.__qualname__
+
+    if hasattr(type, "__qualname__"):
+        return type.__module__ + "." + type.__qualname__
+
+    # typically a class from the typing module
+    if hasattr(type, "_name") and type._name is not None:
+        path = type.__module__ + "." + type._name
+        if path in TYPE_ALIASES:
+            path = TYPE_ALIASES[path]
+    elif hasattr(type, "__origin__") and hasattr(type.__origin__, "_name"):
+        # found one case which is typing.Union
+        path = type.__module__ + "." + type.__origin__._name
+    else:
+        raise NotImplementedError(type)
+
+    return path
+
+
+def get_dbclass_deser_func(type: type[T]) -> Callable[[dict], T]:
+    """Get a deserializer function for a class in models.db."""
+    module, clsname = (
+        get_classpath(type)
+        .replace(".models.db.", ".models.data.")
+        .rsplit(".", maxsplit=1)
+    )
+    StructType = getattr(importlib.import_module(module), f"Create{clsname}")
+
+    def deser_func(obj: dict):
+        record = msgspec.json.decode(orjson.dumps(obj), type=StructType)
+        if hasattr(record, "_is_scp_updated"):
+            # Skip updating system-controlled properties
+            record._is_scp_updated = True
+
+        return record.to_db()
+
+    return deser_func
+
+
 class LoadTableDataArgs(TypedDict, total=False):
     table: type
     tables: Sequence[type]
@@ -324,47 +373,17 @@ def load_data_from_dir(
     load_data(engine, create_db_and_tables, load_args, verbose)
 
 
-def identity(x: T) -> T:
-    """Identity function that returns the input unchanged."""
-    return x
-
-
-def get_classpath(type: Type | Callable) -> str:
-    if type.__module__ == "builtins":
-        return type.__qualname__
-
-    if hasattr(type, "__qualname__"):
-        return type.__module__ + "." + type.__qualname__
-
-    # typically a class from the typing module
-    if hasattr(type, "_name") and type._name is not None:
-        path = type.__module__ + "." + type._name
-        if path in TYPE_ALIASES:
-            path = TYPE_ALIASES[path]
-    elif hasattr(type, "__origin__") and hasattr(type.__origin__, "_name"):
-        # found one case which is typing.Union
-        path = type.__module__ + "." + type.__origin__._name
-    else:
-        raise NotImplementedError(type)
-
-    return path
-
-
-def get_dbclass_deser_func(type: type[T]) -> Callable[[dict], T]:
-    """Get a deserializer function for a class in models.db."""
-    module, clsname = (
-        get_classpath(type)
-        .replace(".models.db.", ".models.data.")
-        .rsplit(".", maxsplit=1)
-    )
-    StructType = getattr(importlib.import_module(module), f"Create{clsname}")
-
-    def deser_func(obj: dict):
-        record = msgspec.json.decode(orjson.dumps(obj), type=StructType)
-        if hasattr(record, "_is_scp_updated"):
-            # Skip updating system-controlled properties
-            record._is_scp_updated = True
-
-        return record.to_db()
-
-    return deser_func
+async def replay_events(
+    engine: AsyncEngine, dcg: DirectedComputingGraph, tables: Sequence[type]
+):
+    """Replay the events in the DirectedComputingGraph. This is useful to re-run the workflows
+    that computes derived data after initial data loading.
+    """
+    async with AsyncSession(engine, expire_on_commit=False) as session:
+        for tbl in tables:
+            innode = f"{tbl.__tablename__}.create"
+            for record in tqdm(
+                session.execute(select(tbl)).scalars(),
+                desc=f"Replaying events for {tbl.__tablename__}",
+            ):
+                await dcg.execute_async(input={innode: record})

{sera_2-1.20.16 → sera_2-1.21.0}/sera/models/_constraints.py

@@ -10,8 +10,8 @@ ConstraintName = Literal[
     "not_empty",
     "username",
     "password",
-    "whole_number",
     "positive_number",
+    "non_negative_number",
 ]
 
 
@@ -34,7 +34,7 @@ class Constraint:
             )
         elif self.name == "password":
             return "msgspec.Meta(min_length=8, max_length=40)"
-        elif self.name == "whole_number":
+        elif self.name == "non_negative_number":
             return "msgspec.Meta(ge=0)"
         elif self.name == "positive_number":
             return "msgspec.Meta(gt=0)"
@@ -58,7 +58,7 @@ predefined_constraints: dict[ConstraintName, Constraint] = {
     "not_empty": Constraint("not_empty", ()),
     "username": Constraint("username", ()),
     "password": Constraint("password", ()),
-    "whole_number": Constraint("whole_number", ()),
+    "non_negative_number": Constraint("non_negative_number", ()),
     "positive_number": Constraint("positive_number", ()),
     "url": Constraint("url", ()),
 }