sera-2 1.11.1__py3-none-any.whl → 1.11.3__py3-none-any.whl

sera/libs/base_service.py

@@ -103,7 +103,7 @@ class BaseService(Generic[ID, R]):
 
         cq = select(func.count()).select_from(q.subquery())
         rq = q.limit(limit).offset(offset)
-        records = self._process_result(session.execute(q)).scalars().all()
+        records = self._process_result(session.execute(rq)).scalars().all()
         total = session.execute(cq).scalar_one()
         return QueryResult(records, total)
 

sera/make/make_python_model.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from operator import is_
 from typing import Callable, Sequence
 
 from codegen.models import AST, DeferredVar, PredefinedFn, Program, expr, stmt
@@ -234,8 +235,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:
@@ -288,14 +292,19 @@ 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)
-
                 if prop.cardinality.is_star_to_many():
                     pytype = pytype.as_list_type()
+                elif 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))
 
         # has_to_db = True
@@ -426,8 +435,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:
@@ -439,14 +452,19 @@ 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)
-
                 if prop.cardinality.is_star_to_many():
                     pytype = pytype.as_list_type()
+                elif 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))
 
         cls_ast(
@@ -679,7 +697,12 @@ def make_python_relational_model(
                     program.import_(dep, True)
 
                 propname = prop.name
-                proptype = f"Mapped[{sqltype.mapped_pytype}]"
+
+                if prop.is_optional:
+                    program.import_("typing.Optional", True)
+                    proptype = f"Mapped[Optional[{sqltype.mapped_pytype}]]"
+                else:
+                    proptype = f"Mapped[{sqltype.mapped_pytype}]"
 
                 propvalargs: list[expr.Expr] = [expr.ExprIdent(sqltype.type)]
                 if prop.db.is_primary_key:
@@ -816,7 +839,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()
@@ -824,7 +847,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,12 +68,16 @@ 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
                     tstype = TsTypeWithDep(f"{cls.name}Id")
+                
+                if prop.is_optional:
+                    # convert type to optional
+                    tstype = tstype.as_optional_type()
 
                 deser_args.append(
                     (
@@ -89,10 +93,15 @@ 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()
+                    elif prop.is_optional:
+                        # convert type to optional only if it isn't a list
+                        tstype = tstype.as_optional_type()
                     deser_args.append(
                         (
                             expr.ExprIdent(propname),
@@ -105,7 +114,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()
@@ -130,6 +141,9 @@ def make_typescript_data_model(schema: Schema, target_pkg: Package):
                             )
                         )
                     else:
+                        if prop.is_optional:
+                            # convert type to optional only if it isn't a list
+                            tstype = tstype.as_optional_type()
                         deser_args.append(
                             (
                                 expr.ExprIdent(propname),
@@ -148,9 +162,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 +333,18 @@ 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)
+                if prop.is_optional:
+                    # convert type to optional
+                    tstype = tstype.as_optional_type()
+
+                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,12 +444,18 @@ 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()
                         create_propvalue = expr.ExprConstant([])
                     else:
+                        if prop.is_optional:
+                            # convert type to optional - for list type, we don't need to do this
+                            # as we will use empty list as no value
+                            tstype = tstype.as_optional_type()
                         # if target class has an auto-increment primary key, we set a different default value
                         # to be -1 to avoid start from 0
                         target_idprop = prop.target.get_id_property()
@@ -461,7 +485,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()
@@ -488,6 +514,10 @@ def make_typescript_data_model(schema: Schema, target_pkg: Package):
                             )
                         )
                     else:
+                        if prop.is_optional:
+                            # convert type to optional - for list type, we don't need to do this
+                            # as we will use empty list as no value
+                            tstype = tstype.as_optional_type()
                         create_propvalue = expr.ExprMethodCall(
                             expr.ExprIdent(tstype.type),
                             "create",
@@ -515,9 +545,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 +728,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 +893,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 +919,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 +937,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 +998,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 +1091,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 +1268,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 +1279,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,14 @@ 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)
+
+    def as_optional_type(self) -> TsTypeWithDep:
+        if "undefined" in self.type:
+            raise NotImplementedError(
+                f"Have not handle nested optional yet: {self.type}"
+            )
+        return TsTypeWithDep(type=f"{self.type} | undefined", deps=self.deps)
 
 
 @dataclass
@@ -137,16 +156,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 +165,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_2-1.11.1.dist-info → sera_2-1.11.3.dist-info}/METADATA

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

{sera_2-1.11.1.dist-info → sera_2-1.11.3.dist-info}/RECORD

@@ -3,7 +3,7 @@ sera/constants.py,sha256=mzAaMyIx8TJK0-RYYJ5I24C4s0Uvj26OLMJmBo0pxHI,123
 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=tKvYyCNIBLUbcZUp0EbrU9T2vHSRu_oISbkPECjZEfo,4613
+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
@@ -13,9 +13,9 @@ 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=kq5DClmEeeNgg-a3Bb_8GN9jxvjnhjmW3RfBHNzynO8,25407
-sera/make/make_python_model.py,sha256=UWI-HbpFjt8n5yLAv2oGQK68LgrF-m0BUI334qtB9Mk,41228
+sera/make/make_python_model.py,sha256=AlNJyyovb99TWocS2jtfTxy0C5YaFizx-Bhwdw1mUNw,41923
 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=Mv6vXhvwQYzbKCMudzymxN_FH1utqaGGJB2dgyB5sIM,52601
 sera/misc/__init__.py,sha256=Dh4uDq0D4N53h3zhvmwfa5a0TPVRSUvLzb0hkFuPirk,411
 sera/misc/_formatter.py,sha256=aCGYL08l8f3aLODHxSocxBBwkRYEo3K1QzCDEn3suj0,1685
 sera/misc/_utils.py,sha256=V5g4oLGHOhUCR75Kkcn1w01pAvGvaepK-T8Z3pIgHjI,1450
@@ -23,7 +23,7 @@ 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=RDn0lDl_b0O_PwRqobcD1O903owEAEoMzRf4dyRcgBk,6819
 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
@@ -32,6 +32,6 @@ 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.11.1.dist-info/METADATA,sha256=vymmUgXvGuXjkCDXFhPc0Y8ZsM-Kwb7cBBLLy4I10ss,857
-sera_2-1.11.1.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-sera_2-1.11.1.dist-info/RECORD,,
+sera_2-1.11.3.dist-info/METADATA,sha256=Rw99XGPK9fkwo5e278P34cjeiLdiEq41e-jl7N269hI,857
+sera_2-1.11.3.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+sera_2-1.11.3.dist-info/RECORD,,