sera-2 1.12.3__py3-none-any.whl → 1.13.0__py3-none-any.whl

sera/make/make_python_model.py

@@ -1,9 +1,16 @@
 from __future__ import annotations
 
-from operator import is_
 from typing import Callable, Optional, Sequence
 
-from codegen.models import AST, DeferredVar, PredefinedFn, Program, expr, stmt
+from codegen.models import (
+    AST,
+    DeferredVar,
+    ImportHelper,
+    PredefinedFn,
+    Program,
+    expr,
+    stmt,
+)
 
 from sera.misc import (
     assert_isinstance,
@@ -20,6 +27,7 @@ from sera.models import (
     PyTypeWithDep,
     Schema,
 )
+from sera.models._property import SystemControlledMode
 from sera.typing import ObjectPath
 
 
@@ -211,10 +219,19 @@ def make_python_data_model(
                 alias=f"{cls.name}DB",
             )
 
-        has_system_controlled = any(
-            prop.data.is_system_controlled for prop in cls.properties.values()
+        ident_manager = ImportHelper(
+            program,
+            {
+                "UNSET": "sera.typing.UNSET",
+            },
+        )
+
+        # property that normal users cannot set, but super users can
+        has_restricted_system_controlled = any(
+            prop.data.is_system_controlled == SystemControlledMode.RESTRICTED
+            for prop in cls.properties.values()
         )
-        if has_system_controlled:
+        if has_restricted_system_controlled:
             program.import_("typing.TypedDict", True)
             program.root(
                 stmt.LineBreak(),
@@ -236,6 +253,7 @@ def make_python_data_model(
                         )
                         for prop in cls.properties.values()
                         if prop.data.is_system_controlled
+                        == SystemControlledMode.RESTRICTED
                     ],
                 ),
             )
@@ -246,11 +264,10 @@ def make_python_data_model(
             [expr.ExprIdent("msgspec.Struct"), expr.ExprIdent("kw_only=True")],
         )
         for prop in cls.properties.values():
-            # this is a create object, so users can create private field
-            # hence, we do not check for prop.is_private -- however, this field can be omitted
-            # during update, so we need to mark it as optional
-            # if prop.data.is_private:
-            #     continue
+            # a field that is fully controlled by the system (e.g., cached or derived fields)
+            # aren't allowed to be set by the users, so we skip them
+            if prop.data.is_system_controlled == SystemControlledMode.AUTO:
+                continue
 
             if isinstance(prop, DataProperty):
                 pytype = prop.get_data_model_datatype().get_python_type()
@@ -272,14 +289,20 @@ def make_python_data_model(
                     else:
                         raise NotImplementedError(prop.data.constraints)
 
-                if prop.data.is_private:
+                if (
+                    prop.data.is_private
+                    or prop.data.is_system_controlled == SystemControlledMode.RESTRICTED
+                ):
                     program.import_("typing.Union", True)
                     program.import_("sera.typing.UnsetType", True)
                     program.import_("sera.typing.UNSET", True)
                     pytype_type = f"Union[{pytype_type}, UnsetType]"
 
                 prop_default_value = None
-                if prop.data.is_private:
+                if (
+                    prop.data.is_private
+                    or prop.data.is_system_controlled == SystemControlledMode.RESTRICTED
+                ):
                     prop_default_value = expr.ExprIdent("UNSET")
                 elif prop.default_value is not None:
                     prop_default_value = expr.ExprConstant(prop.default_value)
@@ -321,25 +344,28 @@ def make_python_data_model(
                 elif prop.is_optional:
                     pytype = pytype.as_optional_type()
 
+                pytype_type = pytype.type
+                prop_default_value = None
+                if prop.data.is_system_controlled == SystemControlledMode.RESTRICTED:
+                    program.import_("typing.Union", True)
+                    program.import_("sera.typing.UnsetType", True)
+                    program.import_("sera.typing.UNSET", True)
+                    pytype_type = f"Union[{pytype_type}, UnsetType]"
+                    prop_default_value = expr.ExprIdent("UNSET")
+
                 for dep in pytype.deps:
                     program.import_(dep, True)
 
-                cls_ast(stmt.DefClassVarStatement(prop.name, pytype.type))
-
-        # 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
+                cls_ast(
+                    stmt.DefClassVarStatement(
+                        prop.name, pytype_type, prop_default_value
+                    )
+                )
 
-        if has_system_controlled:
+        if has_restricted_system_controlled:
             program.import_("typing.Optional", True)
+            program.import_("sera.typing.is_set", 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__",
@@ -347,12 +373,17 @@ def make_python_data_model(
                         DeferredVar.simple("self"),
                     ],
                 )(
-                    stmt.AssignStatement(
-                        PredefinedFn.attr_getter(
-                            expr.ExprIdent("self"), expr.ExprIdent("_verified")
-                        ),
-                        expr.ExprConstant(False),
-                    )
+                    *[
+                        stmt.AssignStatement(
+                            PredefinedFn.attr_getter(
+                                expr.ExprIdent("self"), expr.ExprIdent(prop.name)
+                            ),
+                            expr.ExprIdent("UNSET"),
+                        )
+                        for prop in cls.properties.values()
+                        if prop.data.is_system_controlled
+                        == SystemControlledMode.RESTRICTED
+                    ]
                 ),
                 stmt.LineBreak(),
                 lambda ast: ast.func(
@@ -381,14 +412,9 @@ def make_python_data_model(
                             )
                             for prop in cls.properties.values()
                             if prop.data.is_system_controlled
+                            == SystemControlledMode.RESTRICTED
                         ]
                     ),
-                    stmt.AssignStatement(
-                        PredefinedFn.attr_getter(
-                            expr.ExprIdent("self"), expr.ExprIdent("_verified")
-                        ),
-                        expr.ExprConstant(True),
-                    ),
                 ),
             )
 
@@ -405,14 +431,27 @@ def make_python_data_model(
             )(
                 (
                     stmt.AssertionStatement(
-                        PredefinedFn.attr_getter(
-                            expr.ExprIdent("self"), expr.ExprIdent("_verified")
+                        expr.ExprLogicalAnd(
+                            [
+                                expr.ExprFuncCall(
+                                    expr.ExprIdent("is_set"),
+                                    [
+                                        PredefinedFn.attr_getter(
+                                            expr.ExprIdent("self"),
+                                            expr.ExprIdent(prop.name),
+                                        )
+                                    ],
+                                )
+                                for prop in cls.properties.values()
+                                if prop.data.is_system_controlled
+                                == SystemControlledMode.RESTRICTED
+                            ]
                         ),
                         expr.ExprConstant(
                             "The model data must be verified before converting to db model"
                         ),
                     )
-                    if has_system_controlled
+                    if has_restricted_system_controlled
                     else None
                 ),
                 lambda ast10: ast10.return_(
@@ -421,8 +460,13 @@ def make_python_data_model(
                             f"{cls.name}DB" if cls.db is not None else cls.name
                         ),
                         [
-                            to_db_type_conversion(
-                                program, expr.ExprIdent("self"), cls, prop
+                            (
+                                to_db_type_conversion(
+                                    program, expr.ExprIdent("self"), cls, prop
+                                )
+                                if prop.data.is_system_controlled
+                                != SystemControlledMode.AUTO
+                                else ident_manager.use("UNSET")
                             )
                             for prop in cls.properties.values()
                         ],
@@ -623,8 +667,11 @@ def make_python_relational_model(
         program.import_("__future__.annotations", True)
         program.import_("sera.libs.base_orm.BaseORM", True)
         program.import_("sera.libs.base_orm.create_engine", True)
+        program.import_("sera.libs.base_orm.create_async_engine", True)
         program.import_("sqlalchemy.orm.DeclarativeBase", True)
         program.import_("sqlalchemy.orm.Session", True)
+        program.import_("sqlalchemy.ext.asyncio.AsyncSession", True)
+        program.import_("sqlalchemy.text", True)
 
         # assume configuration for the app at the top level
         program.import_(f"{app.config.path}.DB_CONNECTION", True)
@@ -673,14 +720,22 @@ def make_python_relational_model(
 
         program.root.linebreak()
         program.root.assign(
-            DeferredVar("engine", force_name="engine"),
+            DeferredVar.simple("engine"),
             expr.ExprFuncCall(
                 expr.ExprIdent("create_engine"),
                 [
                     expr.ExprIdent("DB_CONNECTION"),
-                    PredefinedFn.keyword_assignment(
-                        "debug", expr.ExprIdent("DB_DEBUG")
-                    ),
+                    PredefinedFn.keyword_assignment("echo", expr.ExprIdent("DB_DEBUG")),
+                ],
+            ),
+        )
+        program.root.assign(
+            DeferredVar.simple("async_engine"),
+            expr.ExprFuncCall(
+                expr.ExprIdent("create_async_engine"),
+                [
+                    expr.ExprIdent("DB_CONNECTION"),
+                    PredefinedFn.keyword_assignment("echo", expr.ExprIdent("DB_DEBUG")),
                 ],
             ),
         )
@@ -691,17 +746,96 @@ def make_python_relational_model(
         )
 
         program.root.linebreak()
-        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.func("get_async_session", [], is_async=True)(
+            lambda ast: ast.python_stmt(
+                "async with AsyncSession(async_engine, expire_on_commit=False) as session:"
+            )(
+                lambda ast_l1: ast_l1.try_()(stmt.PythonStatement("yield session")),
+                lambda ast_l1: ast_l1.catch()(
+                    stmt.SingleExprStatement(
+                        expr.ExprAwait(
+                            expr.ExprFuncCall(
+                                PredefinedFn.attr_getter(
+                                    expr.ExprIdent("session"),
+                                    expr.ExprIdent("rollback"),
+                                ),
+                                [],
+                            )
+                        )
+                    ),
+                    stmt.PythonStatement("raise"),
+                ),
+                lambda ast_l1: ast_l1.else_()(
+                    stmt.SingleExprStatement(
+                        expr.ExprAwait(
+                            expr.ExprFuncCall(
+                                PredefinedFn.attr_getter(
+                                    expr.ExprIdent("session"), expr.ExprIdent("execute")
+                                ),
+                                [
+                                    expr.ExprFuncCall(
+                                        expr.ExprIdent("text"),
+                                        [expr.ExprConstant("RESET ROLE;")],
+                                    )
+                                ],
+                            )
+                        )
+                    ),
+                    stmt.SingleExprStatement(
+                        expr.ExprAwait(
+                            expr.ExprFuncCall(
+                                PredefinedFn.attr_getter(
+                                    expr.ExprIdent("session"), expr.ExprIdent("commit")
+                                ),
+                                [],
+                            )
+                        )
+                    ),
+                ),
             )
         )
 
         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")
+            lambda ast: ast.python_stmt(
+                "with Session(engine, expire_on_commit=False) as session:"
+            )(
+                lambda ast_l1: ast_l1.try_()(stmt.PythonStatement("yield session")),
+                lambda ast_l1: ast_l1.catch()(
+                    stmt.SingleExprStatement(
+                        expr.ExprFuncCall(
+                            PredefinedFn.attr_getter(
+                                expr.ExprIdent("session"), expr.ExprIdent("rollback")
+                            ),
+                            [],
+                        )
+                    ),
+                    stmt.PythonStatement("raise"),
+                ),
+                lambda ast_l1: ast_l1.else_()(
+                    stmt.SingleExprStatement(
+                        expr.ExprFuncCall(
+                            PredefinedFn.attr_getter(
+                                expr.ExprIdent("session"), expr.ExprIdent("execute")
+                            ),
+                            [
+                                expr.ExprFuncCall(
+                                    expr.ExprIdent("text"),
+                                    [expr.ExprConstant("RESET ROLE;")],
+                                )
+                            ],
+                        )
+                    ),
+                    stmt.SingleExprStatement(
+                        expr.ExprFuncCall(
+                            PredefinedFn.attr_getter(
+                                expr.ExprIdent("session"), expr.ExprIdent("commit")
+                            ),
+                            [],
+                        )
+                    ),
+                ),
             )
         )
 

sera/make/make_python_services.py

@@ -4,6 +4,7 @@ from typing import Sequence
 
 from codegen.models import DeferredVar, Program, expr, stmt
 from loguru import logger
+
 from sera.misc import assert_not_null
 from sera.models import App, DataCollection, Package
 
@@ -35,13 +36,13 @@ def make_python_service(collection: DataCollection, target_pkg: Package):
         True,
     )
     program.import_(app.config.path + f".schema", True)
-    program.import_("sera.libs.base_service.BaseService", True)
+    program.import_("sera.libs.base_service.BaseAsyncService", True)
 
     program.root(
         stmt.LineBreak(),
         lambda ast00: ast00.class_(
             collection.get_service_name(),
-            [expr.ExprIdent(f"BaseService[{id_type}, {cls.name}]")],
+            [expr.ExprIdent(f"BaseAsyncService[{id_type}, {cls.name}]")],
         )(
             lambda ast01: ast01.func(
                 "__init__",

sera/models/__init__.py

@@ -5,7 +5,13 @@ from sera.models._enum import Enum
 from sera.models._module import App, Module, Package
 from sera.models._multi_lingual_string import MultiLingualString
 from sera.models._parse import parse_schema
-from sera.models._property import Cardinality, DataProperty, ObjectProperty, Property
+from sera.models._property import (
+    Cardinality,
+    DataProperty,
+    ObjectProperty,
+    Property,
+    SystemControlledMode,
+)
 from sera.models._schema import Schema
 
 __all__ = [
@@ -25,4 +31,5 @@ __all__ = [
     "PyTypeWithDep",
     "TsTypeWithDep",
     "Enum",
+    "SystemControlledMode",
 ]

sera/models/_constraints.py

@@ -3,7 +3,15 @@ from __future__ import annotations
 from dataclasses import dataclass
 from typing import Literal
 
-ConstraintName = Literal["phone_number", "email", "not_empty", "username", "password"]
+ConstraintName = Literal[
+    "phone_number",
+    "email",
+    "not_empty",
+    "username",
+    "password",
+    "whole_number",
+    "positive_number",
+]
 
 
 @dataclass
@@ -25,6 +33,10 @@ class Constraint:
             )
         elif self.name == "password":
             return "msgspec.Meta(min_length=8, max_length=40)"
+        elif self.name == "whole_number":
+            return "msgspec.Meta(ge=0)"
+        elif self.name == "positive_number":
+            return "msgspec.Meta(gt=0)"
 
         raise NotImplementedError()
 
@@ -43,4 +55,6 @@ predefined_constraints: dict[ConstraintName, Constraint] = {
     "not_empty": Constraint("not_empty", ()),
     "username": Constraint("username", ()),
     "password": Constraint("password", ()),
+    "whole_number": Constraint("whole_number", ()),
+    "positive_number": Constraint("positive_number", ()),
 }

sera/models/_datatype.py

@@ -164,6 +164,16 @@ predefined_datatypes = {
         tstype=TsTypeWithDep(type="number"),
         is_list=False,
     ),
+    "date": DataType(
+        pytype=PyTypeWithDep(type="date", deps=["datetime.date"]),
+        sqltype=SQLTypeWithDep(
+            type="Date",
+            mapped_pytype="date",
+            deps=["sqlalchemy.Date", "datetime.date"],
+        ),
+        tstype=TsTypeWithDep(type="string"),
+        is_list=False,
+    ),
     "datetime": DataType(
         pytype=PyTypeWithDep(type="datetime", deps=["datetime.datetime"]),
         sqltype=SQLTypeWithDep(

sera/models/_parse.py

@@ -31,6 +31,7 @@ from sera.models._property import (
     ObjectPropDBInfo,
     ObjectProperty,
     PropDataAttrs,
+    SystemControlledMode,
 )
 from sera.models._schema import Schema
 
@@ -76,7 +77,7 @@ def _parse_class_without_prop(schema: Schema, clsname: str, cls: dict) -> Class:
     return Class(
         name=clsname,
         label=_parse_multi_lingual_string(cls["label"]),
-        description=_parse_multi_lingual_string(cls["desc"]),
+        description=_parse_multi_lingual_string(cls.get("desc", "")),
         properties={},
         db=db,
     )
@@ -131,7 +132,9 @@ def _parse_property(
         constraints=[
             _parse_constraint(constraint) for constraint in _data.get("constraints", [])
         ],
-        is_system_controlled=prop.get("is_system_controlled", False),
+        is_system_controlled=SystemControlledMode(
+            _data.get("is_system_controlled", SystemControlledMode.NO.value)
+        ),
     )
 
     assert isinstance(prop, dict), prop
@@ -222,12 +225,14 @@ def _parse_datatype(schema: Schema, datatype: dict | str) -> DataType:
                 # the correct package yet.
                 pytype=PyTypeWithDep(
                     type=enum.name,
-                    dep=f"{schema.name}.models.enums.{enum.get_pymodule_name()}.{enum.name}",
+                    deps=[
+                        f"{schema.name}.models.enums.{enum.get_pymodule_name()}.{enum.name}"
+                    ],
                 ),
                 sqltype=SQLTypeWithDep(
                     type="String", mapped_pytype="str", deps=["sqlalchemy.String"]
                 ),
-                tstype=TsTypeWithDep(type=enum.name, dep="@/models/enums"),
+                tstype=TsTypeWithDep(type=enum.name, deps=["@/models/enums"]),
                 is_list=is_list,
             )
 

sera/models/_property.py

@@ -56,6 +56,19 @@ class Cardinality(str, Enum):
         ]
 
 
+class SystemControlledMode(str, Enum):
+    """Indicates if this property is controlled by the system.
+
+    There are two modes:
+    1. The system automatically sets the value, and users cannot modify it.
+    2. Users with special roles are allowed to set the value and other users cannot modify it
+    """
+
+    AUTO = "auto"
+    RESTRICTED = "restricted"
+    NO = "no"
+
+
 @dataclass(kw_only=True)
 class PropDataAttrs:
     """Storing other attributes for generating data model (upsert & public) -- this is different from a db model"""
@@ -72,7 +85,7 @@ class PropDataAttrs:
     constraints: list[Constraint] = field(default_factory=list)
 
     # whether this property is controlled by the system or not
-    is_system_controlled: bool = False
+    is_system_controlled: SystemControlledMode = SystemControlledMode.NO
 
 
 @dataclass(kw_only=True)

sera/models/_schema.py

@@ -34,3 +34,14 @@ class Schema:
 
         # Convert sorted names back to Class objects
         return [self.classes[name] for name in sorted_names]
+
+    def get_upstream_classes(self, cls: Class) -> list[tuple[Class, ObjectProperty]]:
+        """
+        Get all classes that depend on the given class.
+        """
+        upstream_classes = []
+        for other_cls in self.classes.values():
+            for prop in other_cls.properties.values():
+                if isinstance(prop, ObjectProperty) and prop.target.name == cls.name:
+                    upstream_classes.append((other_cls, prop))
+        return upstream_classes

{sera_2-1.12.3.dist-info → sera_2-1.13.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: sera-2
-Version: 1.12.3
+Version: 1.13.0
 Summary: 
 Author: Binh Vu
 Author-email: bvu687@gmail.com
@@ -9,13 +9,13 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Requires-Dist: black (>=25.1.0,<26.0.0)
-Requires-Dist: codegen-2 (>=2.10.0,<3.0.0)
+Requires-Dist: codegen-2 (>=2.11.0,<3.0.0)
 Requires-Dist: isort (>=6.0.1,<7.0.0)
 Requires-Dist: litestar (>=2.15.1,<3.0.0)
 Requires-Dist: loguru (>=0.7.0,<0.8.0)
 Requires-Dist: msgspec (>=0.19.0,<0.20.0)
 Requires-Dist: serde2 (>=1.9.0,<2.0.0)
-Requires-Dist: sqlalchemy (>=2.0.40,<3.0.0)
+Requires-Dist: sqlalchemy[asyncio] (>=2.0.41,<3.0.0)
 Requires-Dist: typer (>=0.12.3,<0.13.0)
 Project-URL: Repository, https://github.com/binh-vu/sera
 Description-Content-Type: text/markdown

{sera_2-1.12.3.dist-info → sera_2-1.13.0.dist-info}/RECORD

@@ -1,37 +1,40 @@
 sera/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sera/constants.py,sha256=mzAaMyIx8TJK0-RYYJ5I24C4s0Uvj26OLMJmBo0pxHI,123
+sera/exports/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sera/exports/schema.py,sha256=3F5Kx3r0zOmiVpDf9vnzGhtdcuF-vfgMhBbp4Ko4fgw,4740
+sera/exports/test.py,sha256=jK1EJmLGiy7eREpnY_68IIVRH43uH8S_u5Z7STPbXOM,2002
 sera/libs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sera/libs/api_helper.py,sha256=47y1kcwk3Xd2ZEMnUj_0OwCuUmgwOs5kYrE95BDVUn4,5411
-sera/libs/base_orm.py,sha256=dyh0OT2sbHku5qPJXvRzYAHRTSXvvbQaS-Qwg65Bw04,2918
-sera/libs/base_service.py,sha256=8uKMaIicLc8LbN5vyaK9dGWoCLf_wuaaOw9ooSiqSWM,4614
+sera/libs/base_orm.py,sha256=5hOH_diUeaABm3cpE2-9u50VRqG1QW2osPQnvVHIhIA,3365
+sera/libs/base_service.py,sha256=AX1WoTHte6Z_birkkfagkNE6BrCLTlTjQE4jEsKEaAY,5152
 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/auth.py,sha256=r6aix1ZBwxMd1Jv5hMCTB8a_gFOJQ6egvxIrf3DWEOs,2323
 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/__main__.py,sha256=bt-gDF8E026OWc2zqr9_a3paMOiDkFd3ybWn8ltL2g0,1448
 sera/make/make_app.py,sha256=n9NtW73O3s_5Q31VHIRmnd-jEIcpDO7ksAsOdovde2s,5999
-sera/make/make_python_api.py,sha256=CM0NTcSUMgRagscvpZwrbI_PR9d4CsgZ2xUVM0rCVVg,26031
-sera/make/make_python_model.py,sha256=ldaDnuwudkq81w2hwKZIuRqFnqhxOAaIT_VhYandXG4,46128
-sera/make/make_python_services.py,sha256=RsinYZdfkrTlTn9CT50VgqGs9w6IZawsJx-KEmqfnEY,2062
+sera/make/make_python_api.py,sha256=sf-J5Pt1LTyM_H-SgXSAvKjEMDrRA6WnDpgDPbJG360,26896
+sera/make/make_python_model.py,sha256=XWoNmfVNfdzF3lwEaItPZjo27ibqL9yjHA3a0vrHsnA,51708
+sera/make/make_python_services.py,sha256=0ZpWLwQ7Nwfn8BXAikAB4JRpNknpSJyJgY5b1cjtxV4,2073
 sera/make/make_typescript_model.py,sha256=ugDdSTw_1ayHLuL--92RQ8hf_D-dpJtnvmUZNxcwcDs,63687
 sera/misc/__init__.py,sha256=Dh4uDq0D4N53h3zhvmwfa5a0TPVRSUvLzb0hkFuPirk,411
 sera/misc/_formatter.py,sha256=aCGYL08l8f3aLODHxSocxBBwkRYEo3K1QzCDEn3suj0,1685
 sera/misc/_utils.py,sha256=V5g4oLGHOhUCR75Kkcn1w01pAvGvaepK-T8Z3pIgHjI,1450
-sera/models/__init__.py,sha256=vJC5Kzo_N7wd16ocNPy1VvAZDGNiWeiAhWJ4ihATKvA,780
+sera/models/__init__.py,sha256=VcC7HvqXuYrkgXwzs2vOH6LJPpzFBkeDvYVNrd3P-6E,855
 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=RDn0lDl_b0O_PwRqobcD1O903owEAEoMzRf4dyRcgBk,6819
+sera/models/_constraints.py,sha256=PsSOX94b9-73wZTcUif9KTzV9uTfoF0WN87g4GZXQmU,1827
+sera/models/_datatype.py,sha256=y5kfim0G3gLhnGjiokFBr8leU1Y6as_Vw7oK-caOo68,7140
 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=uw6fvvh1ucGqE2jFTCCr-e6_qMfZfSVpaPolNxmrHww,9897
-sera/models/_property.py,sha256=SJSm5fZJimd2rQuL4UH_aZuNyp9v7x64xMbEVbtYx8Q,5633
-sera/models/_schema.py,sha256=r-Gqg9Lb_wR3UrbNvfXXgt_qs5bts0t2Ve7aquuF_OI,1155
+sera/models/_parse.py,sha256=q_YZ7PrHWIN85_WW-fPP7-2gLXlGWM2-EIdbYXuG7Xg,10052
+sera/models/_property.py,sha256=4y9F58D6DoX25-6aWPBRiE72nCPQy0KWlGNDTZXSV-8,6038
+sera/models/_schema.py,sha256=VxJEiqgVvbXgcSUK4UW6JnRcggk4nsooVSE6MyXmfNY,1636
 sera/typing.py,sha256=Q4QMfbtfrCjC9tFfsZPhsAnbNX4lm4NHQ9lmjNXYdV0,772
-sera_2-1.12.3.dist-info/METADATA,sha256=5KV9Z9cwjWA1UZKqo9iCrj0XRwL54xS7JmRrGAc5S7s,858
-sera_2-1.12.3.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-sera_2-1.12.3.dist-info/RECORD,,
+sera_2-1.13.0.dist-info/METADATA,sha256=IFUs-nyqkQ4yDQeCL507_8not1XYcKeLFYrLxLg4lc8,867
+sera_2-1.13.0.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+sera_2-1.13.0.dist-info/RECORD,,