sera-2 1.1.0__py3-none-any.whl → 1.2.0__py3-none-any.whl

sera/make/make_python_model.py

@@ -1,21 +1,162 @@
 from __future__ import annotations
 
+from operator import is_
 from typing import Sequence
 
-from codegen.models import DeferredVar, PredefinedFn, Program, expr, stmt
-from sera.misc import assert_isinstance, filter_duplication
-from sera.models import DataProperty, ObjectProperty, Package, Schema
+from codegen.models import AST, DeferredVar, PredefinedFn, Program, expr, stmt
+from sera.misc import (
+    assert_isinstance,
+    assert_not_null,
+    filter_duplication,
+    to_snake_case,
+)
+from sera.models import (
+    Cardinality,
+    Class,
+    DataProperty,
+    ObjectProperty,
+    Package,
+    Schema,
+)
 
 
 def make_python_data_model(schema: Schema, target_pkg: Package):
     """Generate public classes for the API from the schema."""
-    for cls in schema.topological_sort():
-        program = Program()
+    app = target_pkg.app
+
+    def from_db_type_conversion(
+        record: expr.ExprIdent, prop: DataProperty | ObjectProperty
+    ):
+        value = PredefinedFn.attr_getter(record, expr.ExprIdent(prop.name))
+        if isinstance(prop, ObjectProperty) and prop.target.db is not None:
+            if prop.cardinality.is_star_to_many():
+                return PredefinedFn.map_list(
+                    value,
+                    lambda item: expr.ExprFuncCall(
+                        PredefinedFn.attr_getter(
+                            expr.ExprIdent(prop.target.name), expr.ExprIdent("from_db")
+                        ),
+                        [PredefinedFn.attr_getter(item, expr.ExprIdent(prop.name))],
+                    ),
+                )
+            else:
+                return expr.ExprFuncCall(
+                    PredefinedFn.attr_getter(
+                        expr.ExprIdent(prop.target.name), expr.ExprIdent("from_db")
+                    ),
+                    [value],
+                )
+
+        return value
+
+    def to_db_type_conversion(
+        program: Program,
+        slf: expr.ExprIdent,
+        cls: Class,
+        prop: DataProperty | ObjectProperty,
+    ):
+        value = PredefinedFn.attr_getter(slf, expr.ExprIdent(prop.name))
+        if (
+            isinstance(prop, ObjectProperty)
+            and prop.target.db is not None
+            and prop.cardinality == Cardinality.MANY_TO_MANY
+        ):
+            # we have to use the associated object
+            AssociationTable = f"{cls.name}{prop.target.name}"
+            program.import_(
+                app.models.db.path
+                + f".{to_snake_case(AssociationTable)}.{AssociationTable}",
+                True,
+            )
+            return PredefinedFn.map_list(
+                value,
+                lambda item: expr.ExprFuncCall(
+                    expr.ExprIdent(AssociationTable),
+                    [PredefinedFn.keyword_assignment(f"{prop.name}_id", item)],
+                ),
+            )
+        return value
+
+    def make_create(program: Program, cls: Class):
         program.import_("__future__.annotations", True)
         program.import_("msgspec", False)
-        # program.import_("dataclasses.dataclass", True)
+        program.import_(
+            app.models.db.path + f".{cls.get_pymodule_name()}.{cls.name}",
+            True,
+            alias=f"{cls.name}DB",
+        )
+        cls_ast = program.root.class_(
+            "Upsert" + cls.name, [expr.ExprIdent("msgspec.Struct")]
+        )
+        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
+            # if prop.is_private:
+            #     continue
+
+            if isinstance(prop, DataProperty):
+                pytype = prop.datatype.get_python_type()
+                if pytype.dep is not None:
+                    program.import_(pytype.dep, True)
+                cls_ast(stmt.DefClassVarStatement(prop.name, pytype.type))
+            elif isinstance(prop, ObjectProperty):
+                if prop.target.db is not None:
+                    # if the target class is in the database, we expect the user to pass the foreign key for it.
+                    pytype = (
+                        assert_not_null(prop.target.get_id_property())
+                        .datatype.get_python_type()
+                        .type
+                    )
+                else:
+                    program.import_(
+                        f"{target_pkg.module(prop.target.get_pymodule_name()).path}.{prop.target.name}",
+                        is_import_attr=True,
+                    )
+                    pytype = prop.target.name
+
+                if prop.cardinality.is_star_to_many():
+                    pytype = f"list[{pytype}]"
+                cls_ast(stmt.DefClassVarStatement(prop.name, pytype))
+
+        # 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.LineBreak(),
+            lambda ast00: ast00.func(
+                "to_db",
+                [
+                    DeferredVar.simple("self"),
+                ],
+                return_type=expr.ExprIdent(f"{cls.name}DB"),
+            )(
+                lambda ast10: ast10.return_(
+                    expr.ExprFuncCall(
+                        expr.ExprIdent(f"{cls.name}DB"),
+                        [
+                            to_db_type_conversion(
+                                program, expr.ExprIdent("self"), cls, prop
+                            )
+                            for prop in cls.properties.values()
+                        ],
+                    )
+                )
+            ),
+        )
+
+    def make_update(program: Program, cls: Class):
+        if not cls.is_public:
+            # skip classes that are not public
+            return
+
+        program.import_("__future__.annotations", True)
+        program.import_("msgspec", False)
+        program.import_(
+            app.models.db.path + f".{cls.get_pymodule_name()}.{cls.name}",
+            True,
+            alias=f"{cls.name}DB",
+        )
 
-        # program.root(stmt.PythonStatement("@dataclass"))
         cls_ast = program.root.class_(cls.name, [expr.ExprIdent("msgspec.Struct")])
         for prop in cls.properties.values():
             if prop.is_private:
@@ -32,9 +173,42 @@ def make_python_data_model(schema: Schema, target_pkg: Package):
                     f"{target_pkg.module(prop.target.get_pymodule_name()).path}.{prop.target.name}",
                     is_import_attr=True,
                 )
-                pytype = prop.target.name
+                if prop.cardinality.is_star_to_many():
+                    pytype = f"list[{prop.target.name}]"
+                else:
+                    pytype = prop.target.name
                 cls_ast(stmt.DefClassVarStatement(prop.name, pytype))
 
+        cls_ast(
+            stmt.LineBreak(),
+            stmt.PythonDecoratorStatement(
+                expr.ExprFuncCall(expr.ExprIdent("classmethod"), [])
+            ),
+            lambda ast00: ast00.func(
+                "from_db",
+                [
+                    DeferredVar.simple("cls"),
+                    DeferredVar.simple("record", expr.ExprIdent(f"{cls.name}DB")),
+                ],
+            )(
+                lambda ast10: ast10.return_(
+                    expr.ExprFuncCall(
+                        expr.ExprIdent("cls"),
+                        [
+                            from_db_type_conversion(expr.ExprIdent("record"), prop)
+                            for prop in cls.properties.values()
+                            if not prop.is_private
+                        ],
+                    )
+                )
+            ),
+        )
+
+    for cls in schema.topological_sort():
+        program = Program()
+        make_create(program, cls)
+        program.root.linebreak()
+        make_update(program, cls)
         target_pkg.module(cls.get_pymodule_name()).write(program)
 
 
@@ -53,7 +227,7 @@ 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_("contextlib.contextmanager", True)
+        program.import_("sqlalchemy.orm.DeclarativeBase", True)
         program.import_("sqlalchemy.orm.Session", True)
 
         # assume configuration for the app at the top level
@@ -91,7 +265,9 @@ def make_python_relational_model(
 
             type_map.append((expr.ExprIdent(type), expr.ExprIdent(maptype)))
 
-        cls_ast = program.root.class_("Base", [expr.ExprIdent("BaseORM")])(
+        cls_ast = program.root.class_(
+            "Base", [expr.ExprIdent("DeclarativeBase"), expr.ExprIdent("BaseORM")]
+        )(
             stmt.DefClassVarStatement(
                 "type_annotation_map", "dict", PredefinedFn.dict(type_map)
             ),
@@ -118,8 +294,7 @@ def make_python_relational_model(
         )
 
         program.root.linebreak()
-        program.root.python_stmt("@contextmanager")
-        program.root.func("get_session", [])(
+        program.root.func("get_session", [], is_async=True)(
             lambda ast00: ast00.python_stmt("with Session(engine) as session:")(
                 lambda ast01: ast01.python_stmt("yield session")
             )
@@ -139,7 +314,6 @@ def make_python_relational_model(
         program.import_("sqlalchemy.orm.MappedAsDataclass", True)
         program.import_("sqlalchemy.orm.mapped_column", True)
         program.import_("sqlalchemy.orm.Mapped", True)
-        program.import_("typing.ClassVar", True)
         program.import_(f"{target_pkg.path}.base.Base", True)
 
         cls_ast = program.root.class_(
@@ -148,7 +322,7 @@ def make_python_relational_model(
         cls_ast(
             stmt.DefClassVarStatement(
                 "__tablename__",
-                type="ClassVar[str]",
+                type=None,
                 value=expr.ExprConstant(cls.db.table_name),
             ),
             stmt.LineBreak(),
@@ -189,94 +363,306 @@ def make_python_relational_model(
                 propval = expr.ExprFuncCall(
                     expr.ExprIdent("mapped_column"), propvalargs
                 )
+                cls_ast(stmt.DefClassVarStatement(propname, proptype, propval))
             else:
                 assert isinstance(prop, ObjectProperty)
-                if prop.target.db is not None:
-                    # if the target class is in the database, we generate a foreign key for it.
-                    program.import_("sqlalchemy.ForeignKey", True)
-
-                    # we store this class in the database
-                    propname = f"{prop.name}_id"
-                    idprop = prop.target.get_id_property()
-                    assert idprop is not None
-                    idprop_pytype = idprop.datatype.get_sqlalchemy_type()
-                    if idprop_pytype.dep is not None:
-                        program.import_(idprop_pytype.dep, True)
-
-                    proptype = f"Mapped[{idprop_pytype.type}]"
-
-                    propvalargs: list[expr.Expr] = [
-                        expr.ExprConstant(f"{prop.target.db.table_name}.{idprop.name}")
-                    ]
-                    propvalargs.append(
+                make_python_relational_object_property(
+                    program=program,
+                    target_pkg=target_pkg,
+                    cls_ast=cls_ast,
+                    cls=cls,
+                    prop=prop,
+                    custom_types=custom_types,
+                )
+
+        target_pkg.module(cls.get_pymodule_name()).write(program)
+
+    # make a base class that implements the mapping for custom types
+    custom_types = filter_duplication(
+        custom_types, lambda p: (p.target.name, p.cardinality, p.is_optional, p.is_map)
+    )
+    make_base(custom_types)
+
+
+def make_python_relational_object_property(
+    program: Program,
+    target_pkg: Package,
+    cls_ast: AST,
+    cls: Class,
+    prop: ObjectProperty,
+    custom_types: list[ObjectProperty],
+):
+    assert prop.db is not None
+    if prop.target.db is not None:
+        # if the target class is in the database, we generate a foreign key for it.
+        program.import_("sqlalchemy.orm.relationship", True)
+
+        if prop.cardinality == Cardinality.MANY_TO_MANY:
+            make_python_relational_object_property_many_to_many(
+                program, cls_ast, target_pkg, cls, prop
+            )
+            return
+
+        if prop.cardinality.is_star_to_many():
+            raise NotImplementedError()
+
+        # we store this class in the database
+        propname = f"{prop.name}_id"
+        idprop = prop.target.get_id_property()
+        assert idprop is not None
+        idprop_pytype = idprop.datatype.get_sqlalchemy_type()
+        if idprop_pytype.dep is not None:
+            program.import_(idprop_pytype.dep, True)
+
+        proptype = f"Mapped[{idprop_pytype.type}]"
+        propval = expr.ExprFuncCall(
+            expr.ExprIdent("mapped_column"),
+            [
+                expr.ExprFuncCall(
+                    expr.ExprIdent("ForeignKey"),
+                    [
+                        expr.ExprConstant(f"{prop.target.db.table_name}.{idprop.name}"),
                         PredefinedFn.keyword_assignment(
                             "ondelete",
-                            expr.ExprConstant(prop.db.on_delete.to_sqlalchemy()),
-                        )
-                    )
-                    propvalargs.append(
+                            expr.ExprConstant(prop.db.on_target_delete.to_sqlalchemy()),
+                        ),
                         PredefinedFn.keyword_assignment(
                             "onupdate",
-                            expr.ExprConstant(prop.db.on_update.to_sqlalchemy()),
-                        )
-                    )
+                            expr.ExprConstant(prop.db.on_target_update.to_sqlalchemy()),
+                        ),
+                    ],
+                ),
+            ],
+        )
 
-                    propval = expr.ExprFuncCall(
-                        expr.ExprIdent("mapped_column"),
-                        [
-                            expr.ExprFuncCall(
-                                expr.ExprIdent("ForeignKey"),
-                                propvalargs,
-                            ),
-                        ],
-                    )
-                else:
-                    # if the target class is not in the database,
-                    program.import_(
-                        f"{target_pkg.module(prop.target.get_pymodule_name()).path}.{prop.target.name}",
-                        is_import_attr=True,
-                    )
-                    propname = prop.name
-                    proptype = f"Mapped[{prop.target.name}]"
-
-                    # we have two choices, one is to create a composite class, one is to create a custom field
-                    if prop.db.is_embedded == "composite":
-                        # for a class to be composite, it must have only data properties
-                        program.import_("sqlalchemy.orm.composite", True)
-                        propvalargs = [expr.ExprIdent(prop.target.name)]
-                        for p in prop.target.properties.values():
-                            propvalargs.append(
-                                expr.ExprFuncCall(
-                                    expr.ExprIdent("mapped_column"),
-                                    [
-                                        expr.ExprIdent(f"{prop.name}_{p.name}"),
-                                        expr.ExprIdent(
-                                            assert_isinstance(p, DataProperty)
-                                            .datatype.get_sqlalchemy_type()
-                                            .type
-                                        ),
-                                        expr.PredefinedFn.keyword_assignment(
-                                            "nullable",
-                                            expr.ExprConstant(prop.is_optional),
-                                        ),
-                                    ],
-                                )
-                            )
-                        propval = expr.ExprFuncCall(
-                            expr.ExprIdent("composite"),
-                            propvalargs,
-                        )
-                    else:
-                        # we create a custom field, the custom field mapping need to be defined in the base
-                        propval = expr.ExprFuncCall(expr.ExprIdent("mapped_column"), [])
-                        custom_types.append(prop)
+        cls_ast(stmt.DefClassVarStatement(propname, proptype, propval))
+        return
 
-            cls_ast(stmt.DefClassVarStatement(propname, proptype, propval))
+    # if the target class is not in the database,
+    program.import_(
+        f"{target_pkg.module(prop.target.get_pymodule_name()).path}.{prop.target.name}",
+        is_import_attr=True,
+    )
+    propname = prop.name
+    proptype = f"Mapped[{prop.target.name}]"
+
+    # we have two choices, one is to create a composite class, one is to create a custom field
+    if prop.db.is_embedded == "composite":
+        # for a class to be composite, it must have only data properties
+        program.import_("sqlalchemy.orm.composite", True)
+        propvalargs: list[expr.Expr] = [expr.ExprIdent(prop.target.name)]
+        for p in prop.target.properties.values():
+            propvalargs.append(
+                expr.ExprFuncCall(
+                    expr.ExprIdent("mapped_column"),
+                    [
+                        expr.ExprIdent(f"{prop.name}_{p.name}"),
+                        expr.ExprIdent(
+                            assert_isinstance(p, DataProperty)
+                            .datatype.get_sqlalchemy_type()
+                            .type
+                        ),
+                        expr.PredefinedFn.keyword_assignment(
+                            "nullable",
+                            expr.ExprConstant(prop.is_optional),
+                        ),
+                    ],
+                )
+            )
+        propval = expr.ExprFuncCall(
+            expr.ExprIdent("composite"),
+            propvalargs,
+        )
+    else:
+        # we create a custom field, the custom field mapping need to be defined in the base
+        propval = expr.ExprFuncCall(expr.ExprIdent("mapped_column"), [])
+        custom_types.append(prop)
 
-        target_pkg.module(cls.get_pymodule_name()).write(program)
+    cls_ast(stmt.DefClassVarStatement(propname, proptype, propval))
 
-    # make a base class that implements the mapping for custom types
-    custom_types = filter_duplication(
-        custom_types, lambda p: (p.target.name, p.cardinality, p.is_optional, p.is_map)
+
+def make_python_relational_object_property_many_to_many(
+    program: Program, ast: AST, target_pkg: Package, cls: Class, prop: ObjectProperty
+):
+    assert cls.db is not None
+    assert prop.db is not None and prop.target.db is not None
+    assert prop.cardinality == Cardinality.MANY_TO_MANY
+
+    # we create a new table to store the many-to-many relationship
+    new_table = f"{cls.name}{prop.target.name}"
+    clsdb = cls.db
+    propdb = prop.db
+    targetdb = prop.target.db
+
+    source_idprop = assert_not_null(cls.get_id_property())
+    source_id_type = source_idprop.datatype.get_python_type().type
+    target_idprop = assert_not_null(prop.target.get_id_property())
+    target_id_type = target_idprop.datatype.get_python_type().type
+
+    newprogram = Program()
+    newprogram.import_("__future__.annotations", True)
+    newprogram.import_("sqlalchemy.ForeignKey", True)
+    newprogram.import_("sqlalchemy.orm.mapped_column", True)
+    newprogram.import_("sqlalchemy.orm.Mapped", True)
+    newprogram.import_("sqlalchemy.orm.relationship", True)
+    newprogram.import_(f"{target_pkg.path}.base.Base", True)
+    newprogram.import_("typing.TYPE_CHECKING", True)
+    newprogram.import_area.if_(expr.ExprIdent("TYPE_CHECKING"))(
+        lambda ast00: ast00.import_(
+            target_pkg.path + f".{cls.get_pymodule_name()}.{cls.name}",
+            is_import_attr=True,
+        ),
+        lambda ast10: ast10.import_(
+            target_pkg.path + f".{prop.target.get_pymodule_name()}.{prop.target.name}",
+            is_import_attr=True,
+        ),
+    )
+
+    newprogram.root(
+        stmt.LineBreak(),
+        lambda ast00: ast00.class_(new_table, [expr.ExprIdent("Base")])(
+            stmt.DefClassVarStatement(
+                "__tablename__",
+                type=None,
+                value=expr.ExprConstant(f"{clsdb.table_name}_{targetdb.table_name}"),
+            ),
+            stmt.LineBreak(),
+            stmt.DefClassVarStatement(
+                "id",
+                "Mapped[int]",
+                expr.ExprFuncCall(
+                    expr.ExprIdent("mapped_column"),
+                    [
+                        PredefinedFn.keyword_assignment(
+                            "primary_key", expr.ExprConstant(True)
+                        ),
+                        PredefinedFn.keyword_assignment(
+                            "autoincrement", expr.ExprConstant("auto")
+                        ),
+                    ],
+                ),
+            ),
+            stmt.DefClassVarStatement(
+                to_snake_case(cls.name),
+                f"Mapped[{cls.name}]",
+                expr.ExprFuncCall(
+                    expr.ExprIdent("relationship"),
+                    [
+                        PredefinedFn.keyword_assignment(
+                            "back_populates",
+                            expr.ExprConstant(prop.name),
+                        ),
+                        PredefinedFn.keyword_assignment(
+                            "lazy",
+                            expr.ExprConstant("raise_on_sql"),
+                        ),
+                    ],
+                ),
+            ),
+            stmt.DefClassVarStatement(
+                to_snake_case(cls.name) + "_id",
+                f"Mapped[{source_id_type}]",
+                expr.ExprFuncCall(
+                    expr.ExprIdent("mapped_column"),
+                    [
+                        expr.ExprFuncCall(
+                            expr.ExprIdent("ForeignKey"),
+                            [
+                                expr.ExprConstant(
+                                    f"{clsdb.table_name}.{source_idprop.name}"
+                                ),
+                                PredefinedFn.keyword_assignment(
+                                    "ondelete",
+                                    expr.ExprConstant(
+                                        propdb.on_source_delete.to_sqlalchemy()
+                                    ),
+                                ),
+                                PredefinedFn.keyword_assignment(
+                                    "onupdate",
+                                    expr.ExprConstant(
+                                        propdb.on_source_update.to_sqlalchemy()
+                                    ),
+                                ),
+                            ],
+                        ),
+                    ],
+                ),
+            ),
+            stmt.DefClassVarStatement(
+                to_snake_case(prop.target.name),
+                f"Mapped[{prop.target.name}]",
+                expr.ExprFuncCall(
+                    expr.ExprIdent("relationship"),
+                    [
+                        PredefinedFn.keyword_assignment(
+                            "lazy",
+                            expr.ExprConstant("raise_on_sql"),
+                        ),
+                    ],
+                ),
+            ),
+            stmt.DefClassVarStatement(
+                to_snake_case(prop.target.name) + "_id",
+                f"Mapped[{target_id_type}]",
+                expr.ExprFuncCall(
+                    expr.ExprIdent("mapped_column"),
+                    [
+                        expr.ExprFuncCall(
+                            expr.ExprIdent("ForeignKey"),
+                            [
+                                expr.ExprConstant(
+                                    f"{targetdb.table_name}.{target_idprop.name}"
+                                ),
+                                PredefinedFn.keyword_assignment(
+                                    "ondelete",
+                                    expr.ExprConstant(
+                                        propdb.on_target_delete.to_sqlalchemy()
+                                    ),
+                                ),
+                                PredefinedFn.keyword_assignment(
+                                    "onupdate",
+                                    expr.ExprConstant(
+                                        propdb.on_target_update.to_sqlalchemy()
+                                    ),
+                                ),
+                            ],
+                        ),
+                    ],
+                ),
+            ),
+        ),
+    )
+
+    new_table_module = target_pkg.module(to_snake_case(new_table))
+    new_table_module.write(newprogram)
+
+    # now we add the relationship to the source.
+    # we can configure it to be list, set, or dict depends on what we want.
+    program.import_(new_table_module.path + f".{new_table}", True)
+    # program.import_("typing.TYPE_CHECKING", True)
+    # program.import_area.if_(expr.ExprIdent("TYPE_CHECKING"))(
+    #     lambda ast00: ast00.import_(
+    #         target_pkg.path + f".{prop.target.get_pymodule_name()}.{prop.target.name}",
+    #         is_import_attr=True,
+    #     )
+    # )
+
+    ast(
+        stmt.DefClassVarStatement(
+            prop.name,
+            f"Mapped[list[{new_table}]]",
+            expr.ExprFuncCall(
+                expr.ExprIdent("relationship"),
+                [
+                    PredefinedFn.keyword_assignment(
+                        "back_populates",
+                        expr.ExprConstant(to_snake_case(cls.name)),
+                    ),
+                    PredefinedFn.keyword_assignment(
+                        "lazy",
+                        expr.ExprConstant("raise_on_sql"),
+                    ),
+                ],
+            ),
+        ),
     )
-    make_base(custom_types)

sera/models/__init__.py

@@ -1,7 +1,7 @@
 from sera.models._class import Class
 from sera.models._collection import DataCollection
 from sera.models._datatype import DataType
-from sera.models._module import App, Module, Package
+from sera.models._module import App, Language, 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
@@ -21,4 +21,5 @@ __all__ = [
     "DataCollection",
     "Module",
     "App",
+    "Language",
 ]

sera/models/_class.py

@@ -35,6 +35,8 @@ class Class:
 
     # whether to store this class in a table in the database
     db: Optional[ClassDBMapInfo]
+    # whether this class is public and we generate a data model for it.
+    is_public: bool = True
 
     def get_id_property(self) -> Optional[DataProperty]:
         """