sera-2 1.9.1__py3-none-any.whl → 1.11.2__py3-none-any.whl

sera/make/make_python_model.py

@@ -190,6 +190,37 @@ def make_python_data_model(
                 True,
                 alias=f"{cls.name}DB",
             )
+
+        has_system_controlled = any(
+            prop.data.is_system_controlled for prop in cls.properties.values()
+        )
+        if has_system_controlled:
+            program.import_("typing.TypedDict", True)
+            program.root(
+                stmt.LineBreak(),
+                lambda ast: ast.class_(
+                    "SystemControlledProps",
+                    [expr.ExprIdent("TypedDict")],
+                )(
+                    *[
+                        stmt.DefClassVarStatement(
+                            prop.name,
+                            (
+                                prop.get_data_model_datatype().get_python_type().type
+                                if isinstance(prop, DataProperty)
+                                else assert_not_null(prop.target.get_id_property())
+                                .get_data_model_datatype()
+                                .get_python_type()
+                                .type
+                            ),
+                        )
+                        for prop in cls.properties.values()
+                        if prop.data.is_system_controlled
+                    ],
+                ),
+            )
+
+        program.root.linebreak()
         cls_ast = program.root.class_(
             "Upsert" + cls.name,
             [expr.ExprIdent("msgspec.Struct"), expr.ExprIdent("kw_only=True")],
@@ -203,8 +234,11 @@ def make_python_data_model(
 
             if isinstance(prop, DataProperty):
                 pytype = prop.get_data_model_datatype().get_python_type()
-                if pytype.dep is not None:
-                    program.import_(pytype.dep, True)
+                if prop.is_optional:
+                    pytype = pytype.as_optional_type()
+
+                for dep in pytype.deps:
+                    program.import_(dep, True)
 
                 pytype_type = pytype.type
                 if len(prop.data.constraints) > 0:
@@ -257,11 +291,13 @@ def make_python_data_model(
                 else:
                     pytype = PyTypeWithDep(
                         f"Upsert{prop.target.name}",
-                        f"{target_pkg.module(prop.target.get_pymodule_name()).path}.Upsert{prop.target.name}",
+                        [
+                            f"{target_pkg.module(prop.target.get_pymodule_name()).path}.Upsert{prop.target.name}"
+                        ],
                     )
 
-                if pytype.dep is not None:
-                    program.import_(pytype.dep, True)
+                for dep in pytype.deps:
+                    program.import_(dep, True)
 
                 if prop.cardinality.is_star_to_many():
                     pytype = pytype.as_list_type()
@@ -270,6 +306,69 @@ def make_python_data_model(
         # has_to_db = True
         # if any(prop for prop in cls.properties.values() if isinstance(prop, ObjectProperty) and prop.cardinality == Cardinality.MANY_TO_MANY):
         #     # if the class has many-to-many relationship, we need to
+
+        if has_system_controlled:
+            program.import_("typing.Optional", True)
+            cls_ast(
+                stmt.LineBreak(),
+                stmt.Comment(
+                    "_verified is a special marker to indicate whether the data is updated by the system."
+                ),
+                stmt.DefClassVarStatement(
+                    "_verified", "bool", expr.ExprConstant(False)
+                ),
+                stmt.LineBreak(),
+                lambda ast: ast.func(
+                    "__post_init__",
+                    [
+                        DeferredVar.simple("self"),
+                    ],
+                )(
+                    stmt.AssignStatement(
+                        PredefinedFn.attr_getter(
+                            expr.ExprIdent("self"), expr.ExprIdent("_verified")
+                        ),
+                        expr.ExprConstant(False),
+                    )
+                ),
+                stmt.LineBreak(),
+                lambda ast: ast.func(
+                    "update_system_controlled_props",
+                    [
+                        DeferredVar.simple("self"),
+                        DeferredVar.simple(
+                            "data",
+                            expr.ExprIdent("Optional[SystemControlledProps]"),
+                        ),
+                    ],
+                )(
+                    lambda ast00: ast00.if_(
+                        expr.ExprNegation(
+                            expr.ExprIs(expr.ExprIdent("data"), expr.ExprConstant(None))
+                        ),
+                    )(
+                        *[
+                            stmt.AssignStatement(
+                                PredefinedFn.attr_getter(
+                                    expr.ExprIdent("self"), expr.ExprIdent(prop.name)
+                                ),
+                                PredefinedFn.item_getter(
+                                    expr.ExprIdent("data"), expr.ExprConstant(prop.name)
+                                ),
+                            )
+                            for prop in cls.properties.values()
+                            if prop.data.is_system_controlled
+                        ]
+                    ),
+                    stmt.AssignStatement(
+                        PredefinedFn.attr_getter(
+                            expr.ExprIdent("self"), expr.ExprIdent("_verified")
+                        ),
+                        expr.ExprConstant(True),
+                    ),
+                ),
+            )
+
         cls_ast(
             stmt.LineBreak(),
             lambda ast00: ast00.func(
@@ -281,6 +380,18 @@ def make_python_data_model(
                     f"{cls.name}DB" if cls.db is not None else cls.name
                 ),
             )(
+                (
+                    stmt.AssertionStatement(
+                        PredefinedFn.attr_getter(
+                            expr.ExprIdent("self"), expr.ExprIdent("_verified")
+                        ),
+                        expr.ExprConstant(
+                            "The model data must be verified before converting to db model"
+                        ),
+                    )
+                    if has_system_controlled
+                    else None
+                ),
                 lambda ast10: ast10.return_(
                     expr.ExprFuncCall(
                         expr.ExprIdent(
@@ -293,7 +404,7 @@ def make_python_data_model(
                             for prop in cls.properties.values()
                         ],
                     )
-                )
+                ),
             ),
         )
 
@@ -320,8 +431,12 @@ def make_python_data_model(
 
             if isinstance(prop, DataProperty):
                 pytype = prop.get_data_model_datatype().get_python_type()
-                if pytype.dep is not None:
-                    program.import_(pytype.dep, True)
+                if prop.is_optional:
+                    pytype = pytype.as_optional_type()
+
+                for dep in pytype.deps:
+                    program.import_(dep, True)
+
                 cls_ast(stmt.DefClassVarStatement(prop.name, pytype.type))
             elif isinstance(prop, ObjectProperty):
                 if prop.target.db is not None:
@@ -333,11 +448,13 @@ def make_python_data_model(
                 else:
                     pytype = PyTypeWithDep(
                         prop.target.name,
-                        f"{target_pkg.module(prop.target.get_pymodule_name()).path}.{prop.target.name}",
+                        [
+                            f"{target_pkg.module(prop.target.get_pymodule_name()).path}.{prop.target.name}"
+                        ],
                     )
 
-                if pytype.dep is not None:
-                    program.import_(pytype.dep, True)
+                for dep in pytype.deps:
+                    program.import_(dep, True)
 
                 if prop.cardinality.is_star_to_many():
                     pytype = pytype.as_list_type()
@@ -423,6 +540,7 @@ def make_python_relational_model(
         # assume configuration for the app at the top level
         program.import_(f"{app.config.path}.DB_CONNECTION", True)
         program.import_(f"{app.config.path}.DB_DEBUG", True)
+        program.import_(f"contextlib.contextmanager", True)
 
         program.root.linebreak()
 
@@ -484,7 +602,15 @@ def make_python_relational_model(
         )
 
         program.root.linebreak()
-        program.root.func("get_session", [], is_async=True)(
+        program.root.func("async_get_session", [], is_async=True)(
+            lambda ast00: ast00.python_stmt("with Session(engine) as session:")(
+                lambda ast01: ast01.python_stmt("yield session")
+            )
+        )
+
+        program.root.linebreak()
+        program.root.python_stmt("@contextmanager")
+        program.root.func("get_session", [])(
             lambda ast00: ast00.python_stmt("with Session(engine) as session:")(
                 lambda ast01: ast01.python_stmt("yield session")
             )
@@ -701,7 +827,7 @@ def make_python_relational_object_property(
                 expr.ExprFuncCall(
                     expr.ExprIdent("mapped_column"),
                     [
-                        expr.ExprIdent(f"{prop.name}_{p.name}"),
+                        expr.ExprConstant(f"{prop.name}_{p.name}"),
                         expr.ExprIdent(
                             assert_isinstance(p, DataProperty)
                             .datatype.get_sqlalchemy_type()
@@ -709,7 +835,7 @@ def make_python_relational_object_property(
                         ),
                         PredefinedFn.keyword_assignment(
                             "nullable",
-                            expr.ExprConstant(prop.is_optional),
+                            expr.ExprConstant(prop.is_optional or p.is_optional),
                         ),
                     ],
                 )

sera/make/make_typescript_model.py

@@ -68,8 +68,8 @@ def make_typescript_data_model(schema: Schema, target_pkg: Package):
 
             if isinstance(prop, DataProperty):
                 tstype = prop.get_data_model_datatype().get_typescript_type()
-                if tstype.dep is not None:
-                    program.import_(tstype.dep, True)
+                for dep in tstype.deps:
+                    program.import_(dep, True)
 
                 if idprop is not None and prop.name == idprop.name:
                     # use id type alias
@@ -89,7 +89,9 @@ def make_typescript_data_model(schema: Schema, target_pkg: Package):
                     # this class is stored in the database, we store the id instead
                     tstype = TsTypeWithDep(
                         f"{prop.target.name}Id",
-                        f"@.models.{prop.target.get_tsmodule_name()}.{prop.target.name}.{prop.target.name}Id",
+                        [
+                            f"@.models.{prop.target.get_tsmodule_name()}.{prop.target.name}.{prop.target.name}Id"
+                        ],
                     )
                     if prop.cardinality.is_star_to_many():
                         tstype = tstype.as_list_type()
@@ -105,7 +107,9 @@ def make_typescript_data_model(schema: Schema, target_pkg: Package):
                     # we are going to store the whole object
                     tstype = TsTypeWithDep(
                         prop.target.name,
-                        f"@.models.{prop.target.get_tsmodule_name()}.{prop.target.name}.{prop.target.name}",
+                        [
+                            f"@.models.{prop.target.get_tsmodule_name()}.{prop.target.name}.{prop.target.name}"
+                        ],
                     )
                     if prop.cardinality.is_star_to_many():
                         tstype = tstype.as_list_type()
@@ -148,9 +152,9 @@ def make_typescript_data_model(schema: Schema, target_pkg: Package):
                             )
                         )
 
-                if tstype.dep is not None:
+                for dep in tstype.deps:
                     program.import_(
-                        tstype.dep,
+                        dep,
                         True,
                     )
 
@@ -319,14 +323,14 @@ def make_typescript_data_model(schema: Schema, target_pkg: Package):
                     # use id type alias
                     tstype = TsTypeWithDep(
                         f"{cls.name}Id",
-                        dep=f"@.models.{pkg.dir.name}.{cls.name}.{cls.name}Id",
+                        deps=[f"@.models.{pkg.dir.name}.{cls.name}.{cls.name}Id"],
                     )
                 else:
                     # for none id properties, we need to include a type for "invalid" value
                     tstype = _inject_type_for_invalid_value(tstype)
 
-                if tstype.dep is not None:
-                    program.import_(tstype.dep, True)
+                for dep in tstype.deps:
+                    program.import_(dep, True)
 
                 # however, if this is a primary key and auto-increment, we set a different default value
                 # to be -1 to avoid start from 0
@@ -426,7 +430,9 @@ def make_typescript_data_model(schema: Schema, target_pkg: Package):
                     # this class is stored in the database, we store the id instead
                     tstype = TsTypeWithDep(
                         f"{prop.target.name}Id",
-                        f"@.models.{prop.target.get_tsmodule_name()}.{prop.target.name}.{prop.target.name}Id",
+                        [
+                            f"@.models.{prop.target.get_tsmodule_name()}.{prop.target.name}.{prop.target.name}Id"
+                        ],
                     )
                     if prop.cardinality.is_star_to_many():
                         tstype = tstype.as_list_type()
@@ -461,7 +467,9 @@ def make_typescript_data_model(schema: Schema, target_pkg: Package):
                     # we are going to store the whole object
                     tstype = TsTypeWithDep(
                         f"Draft{prop.target.name}",
-                        f"@.models.{prop.target.get_tsmodule_name()}.Draft{prop.target.name}.Draft{prop.target.name}",
+                        [
+                            f"@.models.{prop.target.get_tsmodule_name()}.Draft{prop.target.name}.Draft{prop.target.name}"
+                        ],
                     )
                     if prop.cardinality.is_star_to_many():
                         tstype = tstype.as_list_type()
@@ -515,9 +523,9 @@ def make_typescript_data_model(schema: Schema, target_pkg: Package):
                             )
                         )
 
-                if tstype.dep is not None:
+                for dep in tstype.deps:
                     program.import_(
-                        tstype.dep,
+                        dep,
                         True,
                     )
 
@@ -698,12 +706,16 @@ def make_typescript_data_model(schema: Schema, target_pkg: Package):
                     comment="Check if the draft is valid (only check the required fields as the non-required fields if it's invalid will be set to undefined)",
                 )(
                     stmt.ReturnStatement(
-                        stmt.TypescriptStatement(
+                        expr.ExprRawTypescript(
                             " && ".join(
                                 f"{draft_validators}.{prop2tsname[prop.name]}(this.{prop2tsname[prop.name]}).isValid"
                                 for prop in cls.properties.values()
                                 if not prop.is_optional
                             )
+                            if any(
+                                not prop.is_optional for prop in cls.properties.values()
+                            )
+                            else "true"
                         )
                     )
                 ),
@@ -859,8 +871,8 @@ def make_typescript_data_model(schema: Schema, target_pkg: Package):
                 # if prop.name == idprop.name:
                 #     # use id type alias
                 #     tstype = TsTypeWithDep(f"{cls.name}Id")
-                if tstype.dep is not None:
-                    program.import_(tstype.dep, True)
+                for dep in tstype.deps:
+                    program.import_(dep, True)
                 tsprop = [
                     (expr.ExprIdent("datatype"), expr.ExprConstant(tstype.type)),
                     (
@@ -885,7 +897,9 @@ def make_typescript_data_model(schema: Schema, target_pkg: Package):
                     # we are going to store the whole object
                     tstype = TsTypeWithDep(
                         prop.target.name,
-                        f"@.models.{prop.target.get_tsmodule_name()}.{prop.target.name}.{prop.target.name}",
+                        [
+                            f"@.models.{prop.target.get_tsmodule_name()}.{prop.target.name}.{prop.target.name}"
+                        ],
                     )
 
                 # we don't store the type itself, but just the name of the type
@@ -901,7 +915,12 @@ def make_typescript_data_model(schema: Schema, target_pkg: Package):
                         expr.ExprIdent("targetClass"),
                         expr.ExprConstant(prop.target.name),
                     ),
-                    (expr.ExprIdent("datatype"), expr.ExprConstant(tstype.type)),
+                    (
+                        expr.ExprIdent("datatype"),
+                        expr.ExprConstant(
+                            tstype.type if prop.target.db is not None else "embedded"
+                        ),
+                    ),
                     (
                         expr.ExprIdent("cardinality"),
                         expr.ExprConstant(prop.cardinality.value),
@@ -957,24 +976,36 @@ def make_typescript_data_model(schema: Schema, target_pkg: Package):
                 )
             )
 
-        for type in ["Schema", "ObjectProperty", "DataProperty"]:
+        for type in ["ObjectProperty", "DataProperty"]:
             program.import_(f"sera-db.{type}", True)
+        if cls.db is not None:
+            program.import_(f"sera-db.Schema", True)
+        else:
+            program.import_(f"sera-db.EmbeddedSchema", True)
 
         program.import_(f"@.models.{pkg.dir.name}.{cls.name}.{cls.name}", True)
-        program.import_(f"@.models.{pkg.dir.name}.{cls.name}.{cls.name}Id", True)
         program.import_(
             f"@.models.{pkg.dir.name}.Draft{cls.name}.Draft{cls.name}", True
         )
         program.import_(
             f"@.models.{pkg.dir.name}.Draft{cls.name}.draft{cls.name}Validators", True
         )
+        if cls.db is not None:
+            program.import_(f"@.models.{pkg.dir.name}.{cls.name}.{cls.name}Id", True)
+
         program.root(
             stmt.LineBreak(),
             stmt.TypescriptStatement(
                 f"export type {cls.name}SchemaType = "
                 + PredefinedFn.dict(
-                    [
-                        (expr.ExprIdent("id"), expr.ExprIdent(f"{cls.name}Id")),
+                    (
+                        [
+                            (expr.ExprIdent("id"), expr.ExprIdent(f"{cls.name}Id")),
+                        ]
+                        if cls.db is not None
+                        else []
+                    )
+                    + [
                         (
                             expr.ExprIdent("publicProperties"),
                             expr.ExprIdent(
@@ -1038,7 +1069,11 @@ def make_typescript_data_model(schema: Schema, target_pkg: Package):
             ),
             stmt.LineBreak(),
             stmt.TypescriptStatement(
-                f"export const {cls.name}Schema: Schema<{cls.name}SchemaType['id'], {cls.name}SchemaType['cls'], {cls.name}SchemaType['draftCls'], {cls.name}SchemaType['publicProperties'], {cls.name}SchemaType['allProperties'], {cls.name}SchemaType> = "
+                (
+                    f"export const {cls.name}Schema: Schema<{cls.name}SchemaType['id'], {cls.name}SchemaType['cls'], {cls.name}SchemaType['draftCls'], {cls.name}SchemaType['publicProperties'], {cls.name}SchemaType['allProperties'], {cls.name}SchemaType> = "
+                    if cls.db is not None
+                    else f"export const {cls.name}Schema: EmbeddedSchema<{cls.name}SchemaType['cls'], {cls.name}SchemaType['draftCls'], {cls.name}SchemaType['publicProperties'], {cls.name}SchemaType['allProperties']> = "
+                )
                 + PredefinedFn.dict(
                     [
                         (
@@ -1211,7 +1246,7 @@ def _inject_type_for_invalid_value(tstype: TsTypeWithDep) -> TsTypeWithDep:
             else:
                 # Need to add parentheses
                 inner_type = f"({inner_type} | string)"
-        return TsTypeWithDep(inner_type + "[]", tstype.dep)
+        return TsTypeWithDep(inner_type + "[]", tstype.deps)
 
     m = re.match(r"^\(?[a-zA-Z \|]+\)?$", tstype.type)
     if m is not None:
@@ -1222,7 +1257,7 @@ def _inject_type_for_invalid_value(tstype: TsTypeWithDep) -> TsTypeWithDep:
             else:
                 # Needs parentheses for clarity
                 new_type = f"({tstype.type} | string)"
-            return TsTypeWithDep(new_type, tstype.dep)
+            return TsTypeWithDep(new_type, tstype.deps)
         return tstype
 
     raise NotImplementedError(tstype.type)

sera/models/_datatype.py

@@ -24,7 +24,7 @@ SQLAlchemyDataType = Literal[
 @dataclass
 class PyTypeWithDep:
     type: str
-    dep: str | None = None
+    deps: list[str] = field(default_factory=list)
 
     def get_python_type(self) -> type:
         """Get the Python type from the type string for typing annotation in Python."""
@@ -50,13 +50,25 @@ class PyTypeWithDep:
 
     def as_list_type(self) -> PyTypeWithDep:
         """Convert the type to a list type."""
-        return PyTypeWithDep(type=f"list[{self.type}]", dep=self.dep)
+        return PyTypeWithDep(type=f"list[{self.type}]", deps=self.deps)
+
+    def as_optional_type(self) -> PyTypeWithDep:
+        """Convert the type to an optional type."""
+        if "typing.Optional" not in self.deps:
+            deps = self.deps + ["typing.Optional"]
+        else:
+            deps = self.deps
+        if "Optional[" in self.type:
+            raise NotImplementedError(
+                f"Have not handle nested optional yet: {self.type}"
+            )
+        return PyTypeWithDep(type=f"Optional[{self.type}]", deps=deps)
 
 
 @dataclass
 class TsTypeWithDep:
     type: str
-    dep: str | None = None
+    deps: list[str] = field(default_factory=list)
 
     def get_default(self) -> expr.ExprConstant:
         if self.type.endswith("[]"):
@@ -83,7 +95,7 @@ class TsTypeWithDep:
             list_type = f"({self.type})[]"
         else:
             list_type = f"{self.type}[]"
-        return TsTypeWithDep(type=list_type, dep=self.dep)
+        return TsTypeWithDep(type=list_type, deps=self.deps)
 
 
 @dataclass
@@ -137,16 +149,6 @@ predefined_datatypes = {
         tstype=TsTypeWithDep(type="string"),
         is_list=False,
     ),
-    "optional[string]": DataType(
-        pytype=PyTypeWithDep(type="Optional[str]", dep="typing.Optional"),
-        sqltype=SQLTypeWithDep(
-            type="String",
-            mapped_pytype="Optional[str]",
-            deps=["sqlalchemy.String", "typing.Optional"],
-        ),
-        tstype=TsTypeWithDep(type="string | undefined"),
-        is_list=False,
-    ),
     "integer": DataType(
         pytype=PyTypeWithDep(type="int"),
         sqltype=SQLTypeWithDep(
@@ -156,7 +158,7 @@ predefined_datatypes = {
         is_list=False,
     ),
     "datetime": DataType(
-        pytype=PyTypeWithDep(type="datetime", dep="datetime.datetime"),
+        pytype=PyTypeWithDep(type="datetime", deps=["datetime.datetime"]),
         sqltype=SQLTypeWithDep(
             type="DateTime",
             mapped_pytype="datetime",

sera/models/_parse.py

@@ -6,6 +6,7 @@ from pathlib import Path
 from typing import Sequence
 
 import serde.yaml
+
 from sera.models._class import Class, ClassDBMapInfo, Index
 from sera.models._constraints import Constraint, predefined_constraints
 from sera.models._datatype import (
@@ -101,22 +102,24 @@ def _parse_property(
     schema: Schema, prop_name: str, prop: dict
 ) -> DataProperty | ObjectProperty:
     if isinstance(prop, str):
-        datatype = prop
-        if datatype in schema.classes:
-            return ObjectProperty(
-                name=prop_name,
-                label=_parse_multi_lingual_string(prop_name),
-                description=_parse_multi_lingual_string(""),
-                target=schema.classes[datatype],
-                cardinality=Cardinality.ONE_TO_ONE,
-            )
-        else:
-            return DataProperty(
-                name=prop_name,
-                label=_parse_multi_lingual_string(prop_name),
-                description=_parse_multi_lingual_string(""),
-                datatype=_parse_datatype(schema, datatype),
-            )
+        # deprecated
+        assert False, prop
+        # datatype = prop
+        # if datatype in schema.classes:
+        #     return ObjectProperty(
+        #         name=prop_name,
+        #         label=_parse_multi_lingual_string(prop_name),
+        #         description=_parse_multi_lingual_string(""),
+        #         target=schema.classes[datatype],
+        #         cardinality=Cardinality.ONE_TO_ONE,
+        #     )
+        # else:
+        #     return DataProperty(
+        #         name=prop_name,
+        #         label=_parse_multi_lingual_string(prop_name),
+        #         description=_parse_multi_lingual_string(""),
+        #         datatype=_parse_datatype(schema, datatype),
+        #     )
 
     db = prop.get("db", {})
     _data = prop.get("data", {})
@@ -128,6 +131,7 @@ def _parse_property(
         constraints=[
             _parse_constraint(constraint) for constraint in _data.get("constraints", [])
         ],
+        is_system_controlled=prop.get("is_system_controlled", False),
     )
 
     assert isinstance(prop, dict), prop

sera/models/_property.py

@@ -71,6 +71,9 @@ class PropDataAttrs:
     # list of constraints applied to the data model's field
     constraints: list[Constraint] = field(default_factory=list)
 
+    # whether this property is controlled by the system or not
+    is_system_controlled: bool = False
+
 
 @dataclass(kw_only=True)
 class Property:

{sera_2-1.9.1.dist-info → sera_2-1.11.2.dist-info}/METADATA

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

{sera_2-1.9.1.dist-info → sera_2-1.11.2.dist-info}/RECORD

@@ -1,18 +1,21 @@
 sera/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sera/constants.py,sha256=mzAaMyIx8TJK0-RYYJ5I24C4s0Uvj26OLMJmBo0pxHI,123
 sera/libs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sera/libs/api_helper.py,sha256=hUEy0INHM18lxTQ348tgbXNceOHcjiAnqmuL_8CRpLQ,2509
+sera/libs/api_helper.py,sha256=47y1kcwk3Xd2ZEMnUj_0OwCuUmgwOs5kYrE95BDVUn4,5411
 sera/libs/base_orm.py,sha256=dyh0OT2sbHku5qPJXvRzYAHRTSXvvbQaS-Qwg65Bw04,2918
-sera/libs/base_service.py,sha256=l5D4IjxIiz8LBRranUYddb8J0Y6SwSyetKYTLrCUdQA,4098
+sera/libs/base_service.py,sha256=8uKMaIicLc8LbN5vyaK9dGWoCLf_wuaaOw9ooSiqSWM,4614
 sera/libs/dag/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sera/libs/dag/_dag.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sera/libs/middlewares/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sera/libs/middlewares/auth.py,sha256=aH2fJshQpJT_dw3lUr67doZ8zdf90XyakdY35qZ1iZs,2443
+sera/libs/middlewares/uscp.py,sha256=H5umW8iEQSCdb_MJ5Im49kxg1E7TpxSg1p2_2A5zI1U,2600
 sera/make/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sera/make/__main__.py,sha256=G5O7s6135-708honwqMFn2yPTs06WbGQTHpupID0eZ4,1417
 sera/make/make_app.py,sha256=n9NtW73O3s_5Q31VHIRmnd-jEIcpDO7ksAsOdovde2s,5999
-sera/make/make_python_api.py,sha256=FcklRwGDGTKPjuhbHKyEog8PYPACi-5DA_nB1ZgxeJU,29424
-sera/make/make_python_model.py,sha256=v5edXKMTQ2XAYDoM7fBONx3S9H6DRUPQp9UwWWUowLg,36594
+sera/make/make_python_api.py,sha256=kq5DClmEeeNgg-a3Bb_8GN9jxvjnhjmW3RfBHNzynO8,25407
+sera/make/make_python_model.py,sha256=MyEhVXeeHxAzqUkjSUuVzQJLUCCe7RKL6VxEMiCfTxk,41507
 sera/make/make_python_services.py,sha256=RsinYZdfkrTlTn9CT50VgqGs9w6IZawsJx-KEmqfnEY,2062
-sera/make/make_typescript_model.py,sha256=fMjz4YxdGHijb2pHI4xj7rKJf1PxyJxVLYW0ivsu70c,50128
+sera/make/make_typescript_model.py,sha256=-FNeUlcrqz2Zd1Eg6P14usXTrgTXd9oGhpOApLqntOw,51395
 sera/misc/__init__.py,sha256=Dh4uDq0D4N53h3zhvmwfa5a0TPVRSUvLzb0hkFuPirk,411
 sera/misc/_formatter.py,sha256=aCGYL08l8f3aLODHxSocxBBwkRYEo3K1QzCDEn3suj0,1685
 sera/misc/_utils.py,sha256=V5g4oLGHOhUCR75Kkcn1w01pAvGvaepK-T8Z3pIgHjI,1450
@@ -20,15 +23,15 @@ sera/models/__init__.py,sha256=vJC5Kzo_N7wd16ocNPy1VvAZDGNiWeiAhWJ4ihATKvA,780
 sera/models/_class.py,sha256=Wf0e8x6-szG9TzoFkAlqj7_dG0SCICMBw_333n3paxk,2514
 sera/models/_collection.py,sha256=ZnQEriKC4X88Zz48Kn1AVZKH-1_l8OgWa-zf2kcQOOE,1414
 sera/models/_constraints.py,sha256=L6QwKL3hRJ5DvvIB4JNgLoyvTKbE9FrpYRzezM4CweE,1484
-sera/models/_datatype.py,sha256=eF71q-X7LA91sNYG29aXQiDVMjjr8-e6ez7P9NRwq_E,6376
+sera/models/_datatype.py,sha256=zkqOKOTZIkoYhJkIpytWWhGp-LtD10Jzud7lxOSd5UQ,6533
 sera/models/_default.py,sha256=ABggW6qdPR4ZDqIPJdJ0GCGQ-7kfsfZmQ_DchgZEa-I,137
 sera/models/_enum.py,sha256=sy0q7E646F-APsqrVQ52r1fAQ_DCAeaNq5YM5QN3zIk,2070
 sera/models/_module.py,sha256=8QRSCubZmdDP9rL58rGAS6X5VCrkc1ZHvuMu1I1KrWk,5043
 sera/models/_multi_lingual_string.py,sha256=JETN6k00VH4wrA4w5vAHMEJV8fp3SY9bJebskFTjQLA,1186
-sera/models/_parse.py,sha256=sJYfQtwek96ltpgxExG4xUbiLnU3qvNYhTP1CeyXGjs,9746
-sera/models/_property.py,sha256=CmEmgOShtSyNFq05YW3tGupwCIVRzPMKudXWld8utPk,5530
+sera/models/_parse.py,sha256=uw6fvvh1ucGqE2jFTCCr-e6_qMfZfSVpaPolNxmrHww,9897
+sera/models/_property.py,sha256=SJSm5fZJimd2rQuL4UH_aZuNyp9v7x64xMbEVbtYx8Q,5633
 sera/models/_schema.py,sha256=r-Gqg9Lb_wR3UrbNvfXXgt_qs5bts0t2Ve7aquuF_OI,1155
 sera/typing.py,sha256=Q4QMfbtfrCjC9tFfsZPhsAnbNX4lm4NHQ9lmjNXYdV0,772
-sera_2-1.9.1.dist-info/METADATA,sha256=Xg1hqLX0htdcQaJxgMUXAr4e_DAiDp3BiyTXXtIfHpg,856
-sera_2-1.9.1.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-sera_2-1.9.1.dist-info/RECORD,,
+sera_2-1.11.2.dist-info/METADATA,sha256=t32pt4lTWNgWc27jVQKlmlK_xf9c99crcgWGVVQjo-Y,857
+sera_2-1.11.2.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+sera_2-1.11.2.dist-info/RECORD,,