sera-2 1.19.2__py3-none-any.whl → 1.20.4__py3-none-any.whl

sera/libs/api_helper.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import re
-from typing import Collection, Generic, cast
+from typing import Callable, Collection, Generic, TypeVar, cast
 
 from litestar import Request, status_codes
 from litestar.connection import ASGIConnection
@@ -19,12 +19,30 @@ from sera.libs.middlewares.uscp import STATE_SYSTEM_CONTROLLED_PROP_KEY
 from sera.typing import T
 
 # for parsing field names and operations from query string
-FIELD_REG = re.compile(r"(?P<name>[a-zA-Z_0-9]+)(?:\[(?P<op>[a-zA-Z0-9]+)\])?")
+FIELD_REG = re.compile(r"(?P<name>[a-zA-Z_0-9]+)(?:\[(?P<op>[a-zA-Z_0-9]+)\])?")
 QUERY_OPS = {op.value for op in QueryOp}
 KEYWORDS = {"field", "limit", "offset", "unique", "sorted_by", "group_by"}
 
 
-def parse_query(request: Request, fields: set[str], debug: bool) -> Query:
+class TypeConversion:
+
+    to_int = int
+    to_float = float
+
+    @staticmethod
+    def to_bool(value: str) -> bool:
+        if value == "1":
+            return True
+        elif value == "0":
+            return False
+        raise ValueError(f"Invalid boolean value: {value}")
+
+
+def parse_query(
+    request: Request,
+    fields: dict[str, Callable[[str], str | int | bool | float]],
+    debug: bool,
+) -> Query:
     """Parse query for retrieving records that match a query.
 
     If a field name collides with a keyword, you can add `_` to the field name.
@@ -56,6 +74,7 @@ def parse_query(request: Request, fields: set[str], debug: bool) -> Query:
                 continue
 
             # Process based on operation or default to equality check
+            # TODO: validate if the operation is allowed for the field
             if not operation:
                 operation = QueryOp.eq
             else:
@@ -65,6 +84,21 @@ def parse_query(request: Request, fields: set[str], debug: bool) -> Query:
                         detail=f"Invalid operation: {operation}",
                     )
                 operation = QueryOp(operation)
+
+            try:
+                norm_func = fields[field_name]
+                if isinstance(v, list):
+                    v = [norm_func(x) for x in v]
+                else:
+                    v = norm_func(v)
+            except ValueError:
+                if debug:
+                    raise HTTPException(
+                        status_code=status_codes.HTTP_400_BAD_REQUEST,
+                        detail=f"Invalid value for field {field_name}: {v}",
+                    )
+                continue
+
             query[field_name] = {operation: v}
         else:
             # Invalid field name format
@@ -78,7 +112,10 @@ def parse_query(request: Request, fields: set[str], debug: bool) -> Query:
     return query
 
 
-class SingleAutoUSCP(MsgspecDTO[T], Generic[T]):
+S = TypeVar("S", bound=Struct)
+
+
+class SingleAutoUSCP(MsgspecDTO[S], Generic[S]):
     """Auto Update System Controlled Property DTO"""
 
     @classmethod

sera/libs/base_service.py

@@ -17,15 +17,15 @@ from sera.typing import FieldName, T, doc
 
 
 class QueryOp(str, Enum):
-    lt = "<"
-    lte = "<="
-    gt = ">"
-    gte = ">="
-    eq = "="
-    ne = "!="
+    lt = "lt"
+    lte = "lte"
+    gt = "gt"
+    gte = "gte"
+    eq = "eq"
+    ne = "ne"
     # select records where values are in the given list
     in_ = "in"
-    not_in = "not in"
+    not_in = "not_in"
     # for full text search
     fuzzy = "fuzzy"
 
@@ -94,15 +94,41 @@ class BaseAsyncService(Generic[ID, R]):
             )
         if unique:
             q = q.distinct()
-        if sorted_by:
-            for field in sorted_by:
-                if field.startswith("-"):
-                    q = q.order_by(getattr(self.orm_cls, field[1:]).desc())
+        for field in sorted_by:
+            if field.startswith("-"):
+                q = q.order_by(getattr(self.orm_cls, field[1:]).desc())
+            else:
+                q = q.order_by(getattr(self.orm_cls, field))
+        for field in group_by:
+            q = q.group_by(getattr(self.orm_cls, field))
+
+        for field, conditions in query.items():
+            for op, value in conditions.items():
+                # TODO: check if the operation is valid for the field.
+                if op == QueryOp.eq:
+                    q = q.where(getattr(self.orm_cls, field) == value)
+                elif op == QueryOp.ne:
+                    q = q.where(getattr(self.orm_cls, field) != value)
+                elif op == QueryOp.lt:
+                    q = q.where(getattr(self.orm_cls, field) < value)
+                elif op == QueryOp.lte:
+                    q = q.where(getattr(self.orm_cls, field) <= value)
+                elif op == QueryOp.gt:
+                    q = q.where(getattr(self.orm_cls, field) > value)
+                elif op == QueryOp.gte:
+                    q = q.where(getattr(self.orm_cls, field) >= value)
+                elif op == QueryOp.in_:
+                    q = q.where(getattr(self.orm_cls, field).in_(value))
+                elif op == QueryOp.not_in:
+                    q = q.where(~getattr(self.orm_cls, field).in_(value))
                 else:
-                    q = q.order_by(getattr(self.orm_cls, field))
-        if group_by:
-            for field in group_by:
-                q = q.group_by(getattr(self.orm_cls, field))
+                    assert op == QueryOp.fuzzy
+                    # Assuming fuzzy search is implemented as a full-text search
+                    q = q.where(
+                        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)

sera/make/make_python_api.py

@@ -4,6 +4,7 @@ from typing import Sequence
 
 from codegen.models import DeferredVar, ImportHelper, PredefinedFn, Program, expr, stmt
 from loguru import logger
+from msgspec import convert
 
 from sera.misc import assert_not_null, to_snake_case
 from sera.models import App, DataCollection, Module, Package
@@ -134,11 +135,21 @@ def make_python_get_api(
 
     func_name = "get_"
 
+    queryable_fields = []
+    for propname, (
+        convert_func,
+        convert_func_import,
+    ) in collection.get_queryable_fields():
+        program.import_(convert_func_import, True)
+        queryable_fields.append(
+            (expr.ExprConstant(propname), expr.ExprIdent(convert_func))
+        )
+
     program.root(
         stmt.LineBreak(),
         lambda ast00: ast00.assign(
             DeferredVar.simple("QUERYABLE_FIELDS"),
-            expr.ExprConstant(collection.get_queryable_fields()),
+            PredefinedFn.dict(queryable_fields),
         ),
         stmt.PythonDecoratorStatement(
             expr.ExprFuncCall(

sera/make/make_python_model.py

@@ -749,6 +749,7 @@ def make_python_data_model(
                 # skip private fields as this is for APIs exchange
                 continue
 
+            propname = prop.name
             if isinstance(prop, DataProperty):
                 pytype = prop.get_data_model_datatype().get_python_type()
                 if prop.is_optional:
@@ -760,6 +761,7 @@ def make_python_data_model(
                 cls_ast(stmt.DefClassVarStatement(prop.name, pytype.type))
             elif isinstance(prop, ObjectProperty):
                 if prop.target.db is not None:
+                    propname = prop.name + "_id"
                     pytype = (
                         assert_not_null(prop.target.get_id_property())
                         .get_data_model_datatype()
@@ -781,7 +783,7 @@ def make_python_data_model(
                 for dep in pytype.deps:
                     program.import_(dep, True)
 
-                cls_ast(stmt.DefClassVarStatement(prop.name, pytype.type))
+                cls_ast(stmt.DefClassVarStatement(propname, pytype.type))
 
         cls_ast(
             stmt.LineBreak(),
@@ -1294,6 +1296,10 @@ def make_python_relational_object_property(
         idprop = prop.target.get_id_property()
         assert idprop is not None
         idprop_pytype = idprop.datatype.get_sqlalchemy_type()
+
+        if prop.is_optional:
+            idprop_pytype = idprop_pytype.as_optional_type()
+
         for dep in idprop_pytype.deps:
             program.import_(dep, True)
 

sera/make/make_typescript_model.py

@@ -50,6 +50,66 @@ def make_typescript_data_model(schema: Schema, target_pkg: Package):
         # the original object, then it's okay.
         return value
 
+    def get_normal_deser_args(
+        prop: DataProperty | ObjectProperty,
+    ) -> expr.Expr:
+        """Extract the value from the data record from the server response to set to the class property in the client."""
+        handle_optional = lambda value: expr.ExprTernary(
+            expr.ExprNotEqual(value, expr.ExprConstant(None)),
+            value,
+            expr.ExprConstant("undefined"),
+        )
+
+        if isinstance(prop, DataProperty):
+            value = PredefinedFn.attr_getter(
+                expr.ExprIdent("data"), expr.ExprIdent(prop.name)
+            )
+            if prop.is_optional:
+                value = handle_optional(value)
+            return value
+
+        assert isinstance(prop, ObjectProperty)
+        if prop.target.db is not None:
+            value = PredefinedFn.attr_getter(
+                expr.ExprIdent("data"), expr.ExprIdent(prop.name + "_id")
+            )
+            if prop.is_optional:
+                value = handle_optional(value)
+            return value
+        else:
+            if prop.cardinality.is_star_to_many():
+                # optional type for a list is simply an empty list, we don't need to check for None
+                value = PredefinedFn.map_list(
+                    PredefinedFn.attr_getter(
+                        expr.ExprIdent("data"),
+                        expr.ExprIdent(prop.name),
+                    ),
+                    lambda item: expr.ExprMethodCall(
+                        expr.ExprIdent(
+                            assert_isinstance(prop, ObjectProperty).target.name
+                        ),
+                        "deser",
+                        [item],
+                    ),
+                )
+                return value
+            else:
+                value = expr.ExprFuncCall(
+                    PredefinedFn.attr_getter(
+                        expr.ExprIdent(prop.target.name),
+                        expr.ExprIdent("deser"),
+                    ),
+                    [
+                        PredefinedFn.attr_getter(
+                            expr.ExprIdent("data"),
+                            expr.ExprIdent(prop.name),
+                        )
+                    ],
+                )
+                if prop.is_optional:
+                    value = handle_optional(value)
+                return value
+
     def make_normal(cls: Class, pkg: Package):
         """Make a data model for the normal Python data model"""
         if not cls.is_public:
@@ -89,9 +149,7 @@ def make_typescript_data_model(schema: Schema, target_pkg: Package):
                 deser_args.append(
                     (
                         expr.ExprIdent(propname),
-                        PredefinedFn.attr_getter(
-                            expr.ExprIdent("data"), expr.ExprIdent(prop.name)
-                        ),
+                        get_normal_deser_args(prop),
                     )
                 )
             else:
@@ -101,9 +159,13 @@ def make_typescript_data_model(schema: Schema, target_pkg: Package):
                     propname = propname + "Id"
                     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.target.name != cls.name
+                            else []
+                        ),
                     )
                     if prop.cardinality.is_star_to_many():
                         tstype = tstype.as_list_type()
@@ -113,10 +175,7 @@ def make_typescript_data_model(schema: Schema, target_pkg: Package):
                     deser_args.append(
                         (
                             expr.ExprIdent(propname),
-                            PredefinedFn.attr_getter(
-                                expr.ExprIdent("data"),
-                                expr.ExprIdent(prop.name + "_id"),
-                            ),
+                            get_normal_deser_args(prop),
                         )
                     )
                 else:
@@ -132,21 +191,7 @@ def make_typescript_data_model(schema: Schema, target_pkg: Package):
                         deser_args.append(
                             (
                                 expr.ExprIdent(propname),
-                                PredefinedFn.map_list(
-                                    PredefinedFn.attr_getter(
-                                        expr.ExprIdent("data"),
-                                        expr.ExprIdent(prop.name),
-                                    ),
-                                    lambda item: expr.ExprMethodCall(
-                                        expr.ExprIdent(
-                                            assert_isinstance(
-                                                prop, ObjectProperty
-                                            ).target.name
-                                        ),
-                                        "deser",
-                                        [item],
-                                    ),
-                                ),
+                                get_normal_deser_args(prop),
                             )
                         )
                     else:
@@ -156,18 +201,7 @@ def make_typescript_data_model(schema: Schema, target_pkg: Package):
                         deser_args.append(
                             (
                                 expr.ExprIdent(propname),
-                                expr.ExprFuncCall(
-                                    PredefinedFn.attr_getter(
-                                        expr.ExprIdent(prop.target.name),
-                                        expr.ExprIdent("deser"),
-                                    ),
-                                    [
-                                        PredefinedFn.attr_getter(
-                                            expr.ExprIdent("data"),
-                                            expr.ExprIdent(prop.name),
-                                        )
-                                    ],
-                                ),
+                                get_normal_deser_args(prop),
                             )
                         )
 
@@ -378,8 +412,13 @@ def make_typescript_data_model(schema: Schema, target_pkg: Package):
                     if tstype.type in idprop_aliases:
                         create_propvalue = idprop_aliases[tstype.type].get_default()
                     elif tstype.type in schema.enums:
-                        create_propvalue = expr.ExprConstant(
-                            next(iter(schema.enums[tstype.type].values.values())).value
+                        enum_value = next(
+                            iter(schema.enums[tstype.type].values.values())
+                        ).value
+                        # TODO: handle enum value integer
+                        assert isinstance(enum_value, str)
+                        create_propvalue = expr.ExprIdent(
+                            tstype.type + "." + enum_value
                         )
                     else:
                         create_propvalue = tstype.get_default()
@@ -1131,7 +1170,13 @@ def make_typescript_data_model(schema: Schema, target_pkg: Package):
             # if prop.data.is_private:
             #     # skip private fields as this is for APIs exchange
             #     continue
-            propname = to_camel_case(prop.name)
+            tspropname = to_camel_case(prop.name)
+            pypropname = prop.name
+            if isinstance(prop, ObjectProperty) and prop.target.db is not None:
+                # this is a database object, we append id to the property name
+                tspropname = tspropname + "Id"
+                pypropname = prop.name + "_id"
+
             tsprop = {}
 
             if isinstance(prop, DataProperty):
@@ -1169,7 +1214,7 @@ def make_typescript_data_model(schema: Schema, target_pkg: Package):
                 norm_func = get_normalizer(tstype, import_helper)
                 if norm_func is not None:
                     # we have a normalizer for this type
-                    prop_normalizers.append((expr.ExprIdent(propname), norm_func))
+                    prop_normalizers.append((expr.ExprIdent(tspropname), norm_func))
             else:
                 assert isinstance(prop, ObjectProperty)
                 if prop.target.db is not None:
@@ -1224,11 +1269,11 @@ def make_typescript_data_model(schema: Schema, target_pkg: Package):
             prop_defs.append(
                 (
                     prop,
-                    expr.ExprIdent(propname),
+                    expr.ExprIdent(tspropname),
                     PredefinedFn.dict(
                         [
-                            (expr.ExprIdent("name"), expr.ExprConstant(prop.name)),
-                            (expr.ExprIdent("tsName"), expr.ExprConstant(propname)),
+                            (expr.ExprIdent("name"), expr.ExprConstant(pypropname)),
+                            (expr.ExprIdent("tsName"), expr.ExprConstant(tspropname)),
                             (
                                 expr.ExprIdent("updateFuncName"),
                                 expr.ExprConstant(f"update{to_pascal_case(prop.name)}"),
@@ -1298,7 +1343,10 @@ def make_typescript_data_model(schema: Schema, target_pkg: Package):
                                 " | ".join(
                                     [
                                         expr.ExprConstant(
-                                            to_camel_case(prop.name)
+                                            to_camel_case(prop.name) + "Id"
+                                            if isinstance(prop, ObjectProperty)
+                                            and prop.target.db is not None
+                                            else to_camel_case(prop.name)
                                         ).to_typescript()
                                         for prop in cls.properties.values()
                                         if not prop.data.is_private

sera/models/_collection.py

@@ -2,6 +2,8 @@ from __future__ import annotations
 
 from dataclasses import dataclass
 
+from codegen.models import ImportHelper
+
 from sera.models._class import Class
 from sera.models._property import DataProperty, ObjectProperty
 
@@ -21,9 +23,9 @@ class DataCollection:
         """Get the python module name of this collection as if there is a python module created to store this collection only."""
         return self.cls.get_pymodule_name()
 
-    def get_queryable_fields(self) -> set[str]:
+    def get_queryable_fields(self) -> list[tuple[str, tuple[str, str]]]:
         """Get the fields of this collection that can be used in a queries."""
-        field_names = set()
+        output = []
         for prop in self.cls.properties.values():
             if prop.db is None or prop.data.is_private:
                 # This property is not stored in the database or it's private, so we skip it
@@ -45,8 +47,19 @@ class DataCollection:
             else:
                 # This property is a data property or an object property not stored in the database, so we use its name
                 propname = prop.name
-            field_names.add(propname)
-        return field_names
+
+            if isinstance(prop, DataProperty):
+                convert_func = prop.datatype.pytype.get_string_conversion_func()
+            else:
+                assert isinstance(prop, ObjectProperty) and prop.target.db is not None
+                target_idprop = prop.target.get_id_property()
+                assert target_idprop is not None
+                convert_func = (
+                    target_idprop.datatype.pytype.get_string_conversion_func()
+                )
+
+            output.append((propname, convert_func))
+        return output
 
     def get_service_name(self):
         return f"{self.name}Service"

sera/models/_datatype.py

@@ -67,6 +67,18 @@ class PyTypeWithDep:
         """Clone the type with the same dependencies."""
         return PyTypeWithDep(type=self.type, deps=list(self.deps))
 
+    def get_string_conversion_func(self) -> tuple[str, str]:
+        if self.type == "str":
+            return ("identity", "sera.misc.identity")
+        if self.type == "int":
+            return ("TypeConversion.to_int", "sera.libs.api_helper.TypeConversion")
+        if self.type == "float":
+            return ("TypeConversion.to_float", "sera.libs.api_helper.TypeConversion")
+        if self.type == "bool":
+            return ("TypeConversion.to_bool", "sera.libs.api_helper.TypeConversion")
+        else:
+            raise NotImplementedError()
+
 
 @dataclass
 class TsTypeWithDep:
@@ -122,6 +134,23 @@ class SQLTypeWithDep:
             mapped_pytype=f"list[{self.mapped_pytype}]",
         )
 
+    def as_optional_type(self) -> SQLTypeWithDep:
+        """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.mapped_pytype:
+            raise NotImplementedError(
+                f"Have not handle nested optional yet: {self.mapped_pytype}"
+            )
+        return SQLTypeWithDep(
+            type=self.type,
+            mapped_pytype=f"Optional[{self.mapped_pytype}]",
+            deps=deps,
+        )
+
 
 @dataclass
 class DataType:

sera/models/_parse.py

@@ -238,7 +238,12 @@ def _parse_datatype(schema: Schema, datatype: dict | str) -> DataType:
                     ],
                 ),
                 sqltype=SQLTypeWithDep(
-                    type="String", mapped_pytype="str", deps=["sqlalchemy.String"]
+                    type=f"Enum({enum.name})",
+                    mapped_pytype=enum.name,
+                    deps=[
+                        "sqlalchemy.Enum",
+                        f"{schema.name}.models.enums.{enum.get_pymodule_name()}.{enum.name}",
+                    ],
                 ),
                 tstype=TsTypeWithDep(
                     type=enum.name, deps=[f"@.models.enums.{enum.name}"]

{sera_2-1.19.2.dist-info → sera_2-1.20.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: sera-2
-Version: 1.19.2
+Version: 1.20.4
 Summary: 
 Author: Binh Vu
 Author-email: bvu687@gmail.com
@@ -9,7 +9,7 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Requires-Dist: black (==25.1.0)
-Requires-Dist: codegen-2 (>=2.12.0,<3.0.0)
+Requires-Dist: codegen-2 (>=2.12.2,<3.0.0)
 Requires-Dist: graph-wrapper (>=1.7.2,<2.0.0)
 Requires-Dist: isort (==6.0.1)
 Requires-Dist: litestar (>=2.15.1,<3.0.0)

{sera_2-1.19.2.dist-info → sera_2-1.20.4.dist-info}/RECORD

@@ -4,10 +4,10 @@ sera/exports/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sera/exports/schema.py,sha256=wEBUrDOyuCoCJC8X4RlmoWpeqSugaboG-9Q1UQ8HEzk,7824
 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/api_helper.py,sha256=VZsYDeeMxzH4-7quM8W-1rl3zLFEEVShb8kLHS2UdHE,6382
 sera/libs/api_test_helper.py,sha256=3tRr8sLN4dBSrHgKAHMmyoENI0xh7K_JLel8AvujU7k,1323
 sera/libs/base_orm.py,sha256=5hOH_diUeaABm3cpE2-9u50VRqG1QW2osPQnvVHIhIA,3365
-sera/libs/base_service.py,sha256=AX1WoTHte6Z_birkkfagkNE6BrCLTlTjQE4jEsKEaAY,5152
+sera/libs/base_service.py,sha256=V6wug1QA5KD0FsQU9r1XQmLUTB85E6oIR2e12Fi1IE0,6457
 sera/libs/directed_computing_graph/__init__.py,sha256=xiF5_I1y9HtQ-cyq02iwkRYgEZvxBB8YIvysCHCLBco,1290
 sera/libs/directed_computing_graph/_dcg.py,sha256=AGTzKVSl-EsSOJlNKPOA1Io7pIxfq0SMXuumq1IExl0,14902
 sera/libs/directed_computing_graph/_edge.py,sha256=iBq6cpLWWyuD99QWTHVEh8naWUJrR4WJJuq5iuCrwHo,1026
@@ -22,26 +22,26 @@ sera/libs/middlewares/uscp.py,sha256=H5umW8iEQSCdb_MJ5Im49kxg1E7TpxSg1p2_2A5zI1U
 sera/make/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sera/make/__main__.py,sha256=HRfOR53p351h6KblVvYm3DLhDIfEtk6R0kjl78_S_S8,1453
 sera/make/make_app.py,sha256=n9NtW73O3s_5Q31VHIRmnd-jEIcpDO7ksAsOdovde2s,5999
-sera/make/make_python_api.py,sha256=iXGbKQ3IJvsY1ur_fhurr_THFNnH66E3Wl85o0emUbw,26853
-sera/make/make_python_model.py,sha256=3qz1OUg2n4QPt31mZHMncU5v9riXUAoQwIpXCa4Fyv4,63306
+sera/make/make_python_api.py,sha256=aOm8QSiXNLe4akiOx_KKsDCwLVwetRzuxOgZaWqEj0w,27172
+sera/make/make_python_model.py,sha256=t_2RUaO6WL4b5FtYj-Ly70njmcGGYwoddbL_oim9378,63479
 sera/make/make_python_services.py,sha256=0ZpWLwQ7Nwfn8BXAikAB4JRpNknpSJyJgY5b1cjtxV4,2073
-sera/make/make_typescript_model.py,sha256=laW27gFYGFhvLY5DfcVgh8tPlDqvmS824r-fbBnG7JI,67493
+sera/make/make_typescript_model.py,sha256=u9pbe9JnSwiV1wLAS_H3p2mdOL_FKXjsZRCRuPu2QBY,69156
 sera/misc/__init__.py,sha256=rOmGMv7QNzpSKZSyxChbRmEnBr3O443UlLGS0FIs3AI,561
 sera/misc/_formatter.py,sha256=aCGYL08l8f3aLODHxSocxBBwkRYEo3K1QzCDEn3suj0,1685
 sera/misc/_utils.py,sha256=_-17XbK6qp3HobcI9iLF4xfaATvFg1ckUzgg7r7Ctmw,7135
 sera/models/__init__.py,sha256=vJC5Kzo_N7wd16ocNPy1VvAZDGNiWeiAhWJ4ihATKvA,780
 sera/models/_class.py,sha256=1J4Bd_LanzhhDWwZFHWGtFYD7lupe_alaB3D02ebNDI,2862
-sera/models/_collection.py,sha256=AmEy6SoTTaxqFU4mBFVfFMGyutJuNnUGBaIV7xzGxbc,2143
+sera/models/_collection.py,sha256=nLlP85OfEhfj4pFAYxB5ZvtBN6EdPSWPJ5ZFh5SSEC4,2686
 sera/models/_constraints.py,sha256=RpWDU-TfCslXaMUaTG9utWbl5z8Z6nzvF_fhqlek6ew,1987
-sera/models/_datatype.py,sha256=cC6Wm0IvobDF5Tq9Jy_ncbjPWBRl3ECGBy0wJyDDMzU,7281
+sera/models/_datatype.py,sha256=6s2TIhUX8Eb1w3XXKUcOoVybF_lrmKtNAriDgzv2JAE,8407
 sera/models/_default.py,sha256=ABggW6qdPR4ZDqIPJdJ0GCGQ-7kfsfZmQ_DchgZEa-I,137
 sera/models/_enum.py,sha256=sy0q7E646F-APsqrVQ52r1fAQ_DCAeaNq5YM5QN3zIk,2070
 sera/models/_module.py,sha256=I-GfnTgAa-5R87qTAvEzOt-VVEGeFBBwubGCgUkXVSw,5159
 sera/models/_multi_lingual_string.py,sha256=JETN6k00VH4wrA4w5vAHMEJV8fp3SY9bJebskFTjQLA,1186
-sera/models/_parse.py,sha256=ciTLzCkO0q6xA1R_rHbnYJYK3Duo2oh56WeuwxXwJaI,12392
+sera/models/_parse.py,sha256=sm-TuhFuru4e-g8HYmPo694sGJooBtIFZeky24X7YYk,12588
 sera/models/_property.py,sha256=9yMDxrmbyuF6-29lQjiq163Xzwbk75TlmGBpu0NLpkI,7485
 sera/models/_schema.py,sha256=VxJEiqgVvbXgcSUK4UW6JnRcggk4nsooVSE6MyXmfNY,1636
 sera/typing.py,sha256=m4rir-fB6Cgcm7_ZSXXcNdla2LJgq96WXxtTTrDaJno,1058
-sera_2-1.19.2.dist-info/METADATA,sha256=yv6pv0XvFLzt1CqYP5u38CCVGHLInOCB1AflthDV5_g,936
-sera_2-1.19.2.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-sera_2-1.19.2.dist-info/RECORD,,
+sera_2-1.20.4.dist-info/METADATA,sha256=2HIbHZt_ScaEAzPZGlpNNX7jEmiv1sGmMVgmK-7nJU4,936
+sera_2-1.20.4.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+sera_2-1.20.4.dist-info/RECORD,,