sera-2 1.1.0__py3-none-any.whl

sera/models/_module.py

@@ -0,0 +1,140 @@
+from __future__ import annotations
+
+import datetime
+from dataclasses import dataclass
+from enum import Enum
+from pathlib import Path
+from typing import Sequence
+
+import black
+import black.mode
+from codegen.models import Program
+from loguru import logger
+
+
+class Language(str, Enum):
+    Python = "python"
+    Typescript = "typescript"
+
+
+@dataclass
+class Package:
+    """Represent an target generated module in the application"""
+
+    app: App
+    path: str
+    dir: Path
+    language: Language
+
+    def ensure_exists(self):
+        """Ensure the module exists"""
+        self.dir.mkdir(parents=True, exist_ok=True)
+        if self.language == Language.Python:
+            if not (self.dir / "__init__.py").exists():
+                (self.dir / "__init__.py").touch()
+
+    def pkg(self, name: str) -> Package:
+        """Create a package in this package"""
+        return Package(self.app, f"{self.path}.{name}", self.dir / name, self.language)
+
+    def module(self, name: str) -> Module:
+        """Create a module in this package"""
+        return Module(self, name, self.language)
+
+
+@dataclass
+class Module:
+    """Represent a module in a package"""
+
+    package: Package
+    name: str
+    language: Language
+
+    @property
+    def path(self) -> str:
+        return f"{self.package.path}.{self.name}"
+
+    def write(self, program: Program):
+        """Write the module to disk"""
+        self.package.ensure_exists()
+        if self.language == Language.Python:
+            try:
+                code = black.format_str(
+                    program.root.to_python(),
+                    mode=black.Mode(
+                        target_versions={black.mode.TargetVersion.PY312},
+                        line_length=120,
+                    ),
+                )
+            except:
+                logger.error("Error writing module {}", self.path)
+                print(">>> Program")
+                print(program.root.to_python())
+                print("<<<")
+                raise
+        else:
+            assert self.language == Language.Typescript
+            raise NotImplementedError()
+
+        copyright_statement = f"# Generated automatically at {datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')}. All rights reserved.\n\n"
+        (self.package.dir / f"{self.name}.py").write_text(copyright_statement + code)
+
+    def exists(self) -> bool:
+        """Check if the module exists"""
+        return (self.package.dir / f"{self.name}.py").exists()
+
+
+@dataclass
+class AppModels(Package):
+    data: Package
+    db: Package
+
+    @staticmethod
+    def from_pkg(pkg: Package) -> AppModels:
+        """Create an AppModels from a package"""
+        return AppModels(
+            pkg.app,
+            path=pkg.path,
+            dir=pkg.dir,
+            language=pkg.language,
+            data=pkg.pkg("data"),
+            db=pkg.pkg("db"),
+        )
+
+
+@dataclass
+class App:
+    """Represent the generated application"""
+
+    # top-level package of the application
+    root: Package
+
+    # application configuration
+    config: Module
+
+    # models of the application
+    models: AppModels
+
+    # services of the application, which encode the business logic
+    services: Package
+
+    # API of the application
+    api: Package
+
+    schema_files: Sequence[Path]
+
+    language: Language
+
+    def __init__(
+        self, name: str, dir: Path, schema_files: Sequence[Path], language: Language
+    ):
+        self.root = Package(self, name, dir, language)
+
+        self.config = self.root.module("config")
+        self.models = AppModels.from_pkg(self.root.pkg("models"))
+        self.services = self.root.pkg("services")
+        self.api = self.root.pkg("api")
+
+        self.schema_files = schema_files
+
+        self.language = language

sera/models/_multi_lingual_string.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+
+class MultiLingualString(str):
+    lang: str
+    lang2value: dict[str, str]
+
+    def __new__(cls, lang2value: dict[str, str], lang):
+        object = str.__new__(cls, lang2value[lang])
+        object.lang = lang
+        object.lang2value = lang2value
+        return object
+
+    def as_lang(self, lang: str) -> str:
+        return self.lang2value[lang]
+
+    def as_lang_default(self, lang: str, default: str) -> str:
+        return self.lang2value.get(lang, default)
+
+    def has_lang(self, lang: str) -> bool:
+        return lang in self.lang2value
+
+    @staticmethod
+    def en(label: str):
+        return MultiLingualString(lang2value={"en": label}, lang="en")
+
+    @staticmethod
+    def from_dict(obj: dict):
+        return MultiLingualString(obj["lang2value"], obj["lang"])
+
+    def to_dict(self):
+        return {"lang2value": self.lang2value, "lang": self.lang}
+
+    def to_tuple(self):
+        return self.lang2value, self.lang
+
+    def __getnewargs__(self) -> tuple[dict[str, str], str]:  # type: ignore
+        return self.lang2value, self.lang

sera/models/_parse.py

@@ -0,0 +1,153 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Sequence
+
+import serde.yaml
+from sera.models._class import Class, ClassDBMapInfo
+from sera.models._datatype import DataType
+from sera.models._multi_lingual_string import MultiLingualString
+from sera.models._property import (
+    Cardinality,
+    DataPropDBInfo,
+    DataProperty,
+    ForeignKeyOnDelete,
+    ForeignKeyOnUpdate,
+    ObjectPropDBInfo,
+    ObjectProperty,
+)
+from sera.models._schema import Schema
+
+
+def parse_schema(files: Sequence[Path | str]) -> Schema:
+    schema = Schema(classes={})
+
+    # parse all classes
+    raw_defs = {}
+    for file in files:
+        for k, v in serde.yaml.deser(file).items():
+            cdef = _parse_class_without_prop(schema, k, v)
+            assert k not in schema.classes
+            schema.classes[k] = cdef
+            raw_defs[k] = v
+
+    # now parse properties of the classes
+    for clsname, v in raw_defs.items():
+        cdef = schema.classes[clsname]
+
+        for propname, prop in (v["props"] or {}).items():
+            assert propname not in cdef.properties
+            cdef.properties[propname] = _parse_property(schema, propname, prop)
+
+    return schema
+
+
+def _parse_class_without_prop(schema: Schema, clsname: str, cls: dict) -> Class:
+    db = None
+    if "db" in cls:
+        db = ClassDBMapInfo(table_name=cls["db"]["table_name"])
+    return Class(
+        name=clsname,
+        label=_parse_multi_lingual_string(cls["label"]),
+        description=_parse_multi_lingual_string(cls["desc"]),
+        properties={},
+        db=db,
+    )
+
+
+def _parse_property(
+    schema: Schema, prop_name: str, prop: dict
+) -> DataProperty | ObjectProperty:
+    if isinstance(prop, str):
+        datatype = prop
+        if datatype in schema.classes:
+            return ObjectProperty(
+                name=prop_name,
+                label=_parse_multi_lingual_string(prop_name),
+                description=_parse_multi_lingual_string(""),
+                target=schema.classes[datatype],
+                cardinality=Cardinality.ONE_TO_ONE,
+                is_private=False,
+            )
+        else:
+            return DataProperty(
+                name=prop_name,
+                label=_parse_multi_lingual_string(prop_name),
+                description=_parse_multi_lingual_string(""),
+                datatype=_parse_datatype(datatype),
+                is_private=False,
+            )
+
+    db = prop.get("db", {})
+
+    assert isinstance(prop, dict), prop
+    if "datatype" in prop:
+        return DataProperty(
+            name=prop_name,
+            label=_parse_multi_lingual_string(prop.get("label", prop_name)),
+            description=_parse_multi_lingual_string(prop.get("desc", "")),
+            datatype=_parse_datatype(prop["datatype"]),
+            is_private=prop.get("is_private", False),
+            db=(
+                DataPropDBInfo(
+                    is_primary_key=db.get("is_primary_key", False),
+                    is_auto_increment=db.get("is_auto_increment", False),
+                    is_unique=db.get("is_unique", False),
+                )
+                if "db" in prop
+                else None
+            ),
+        )
+
+    assert "target" in prop, prop
+    return ObjectProperty(
+        name=prop_name,
+        label=_parse_multi_lingual_string(prop.get("label", prop_name)),
+        description=_parse_multi_lingual_string(prop.get("desc", "")),
+        target=schema.classes[prop["target"]],
+        cardinality=Cardinality(prop.get("cardinality", "1:1")),
+        is_optional=prop.get("is_optional", False),
+        is_private=prop.get("is_private", False),
+        db=(
+            ObjectPropDBInfo(
+                is_embedded=db.get("is_embedded", None),
+                on_delete=ForeignKeyOnDelete(db.get("on_delete", "restrict")),
+                on_update=ForeignKeyOnUpdate(db.get("on_update", "restrict")),
+            )
+            if "db" in prop
+            else None
+        ),
+    )
+
+
+def _parse_multi_lingual_string(o: dict | str) -> MultiLingualString:
+    if isinstance(o, str):
+        return MultiLingualString.en(o)
+    assert isinstance(o, dict), o
+    assert "en" in o
+    return MultiLingualString(lang2value=o, lang="en")
+
+
+def _parse_datatype(datatype: str) -> DataType:
+    if datatype.endswith("[]"):
+        datatype = datatype[:-2]
+        is_list = True
+    else:
+        is_list = False
+
+    if datatype == "string":
+        return DataType("str", is_list=is_list, parent=None)
+    if datatype == "integer":
+        return DataType("int", is_list=is_list, parent=None)
+    if datatype == "datetime":
+        return DataType("datetime", is_list=is_list, parent=None)
+    if datatype == "bool":
+        return DataType("bool", is_list=is_list, parent=None)
+    if datatype == "float":
+        return DataType("float", is_list=is_list, parent=None)
+    if datatype == "bytes":
+        return DataType("bytes", is_list=is_list, parent=None)
+    if datatype == "dict":
+        return DataType("dict", is_list=is_list, parent=None)
+
+    raise NotImplementedError(datatype)

sera/models/_property.py

@@ -0,0 +1,124 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import TYPE_CHECKING, Literal, Optional
+
+from sera.models._datatype import DataType
+from sera.models._multi_lingual_string import MultiLingualString
+
+if TYPE_CHECKING:
+    from sera.models._class import Class
+
+
+class ForeignKeyOnDelete(str, Enum):
+    CASCADE = "cascade"
+    SET_NULL = "set null"
+    RESTRICT = "restrict"
+
+    def to_sqlalchemy(self) -> str:
+        if self == ForeignKeyOnDelete.CASCADE:
+            return "CASCADE"
+        elif self == ForeignKeyOnDelete.SET_NULL:
+            return "SET NULL"
+        elif self == ForeignKeyOnDelete.RESTRICT:
+            return "RESTRICT"
+        raise NotImplementedError(self)
+
+
+class ForeignKeyOnUpdate(str, Enum):
+    CASCADE = "cascade"
+    DELETE = "delete"
+    RESTRICT = "restrict"
+
+    def to_sqlalchemy(self) -> str:
+        if self == ForeignKeyOnUpdate.CASCADE:
+            return "CASCADE"
+        elif self == ForeignKeyOnUpdate.DELETE:
+            return "DELETE"
+        elif self == ForeignKeyOnUpdate.RESTRICT:
+            return "RESTRICT"
+        raise NotImplementedError(self)
+
+
+class Cardinality(str, Enum):
+    ONE_TO_ONE = "1:1"
+    ONE_TO_MANY = "1:N"
+    MANY_TO_ONE = "N:1"
+    MANY_TO_MANY = "N:N"
+
+    def is_star_to_many(self) -> bool:
+        return self in [
+            Cardinality.ONE_TO_MANY,
+            Cardinality.MANY_TO_MANY,
+        ]
+
+
+@dataclass(kw_only=True)
+class Property:
+    """Represent a property of a class."""
+
+    # name of the property in the application layer
+    name: str = field(
+        metadata={
+            "description": "Name of the property in the application layer, so it must be a valid Python identifier"
+        }
+    )
+    # human-readable name of the property
+    label: MultiLingualString
+    # human-readable description of the property
+    description: MultiLingualString
+    # whether this property is private and cannot be accessed by the end users
+    # default it is false
+    is_private: bool = field(default=False)
+
+
+@dataclass(kw_only=True)
+class DataPropDBInfo:
+    """Represent database information for a data property."""
+
+    # whether this property is a primary key or not
+    is_primary_key: bool = False
+    # if this property is an integer primary key, whether it is auto-incremented or not
+    is_auto_increment: bool = False
+    # whether this property contains unique values
+    is_unique: bool = False
+
+
+@dataclass(kw_only=True)
+class DataProperty(Property):
+    # data type of the property
+    datatype: DataType
+    # other database properties of this property
+    db: Optional[DataPropDBInfo] = None
+
+
+@dataclass(kw_only=True)
+class ObjectPropDBInfo:
+    """Represent database information for an object property."""
+
+    # if the target class is not stored in the database, whether to store this property as a composite class
+    # (see SQLAlchemy composite) or embedded (JSON). Note that it doesn't make sense to embed in composite mode
+    # if the cardinality is not 1:1
+    is_embedded: Optional[Literal["composite", "json"]] = None
+
+    # if the target class is stored in the database, control the cascade behavior
+    on_delete: ForeignKeyOnDelete = ForeignKeyOnDelete.RESTRICT
+    on_update: ForeignKeyOnUpdate = ForeignKeyOnUpdate.RESTRICT
+
+
+@dataclass(kw_only=True)
+class ObjectProperty(Property):
+    # the target class of the property
+    target: Class
+    # the cardinality of the property -- is it one-to-one, many-to-one, etc.
+    # if the cardinality is many-to-many, a new joint class is going to be generated automatically
+    # to store the relationship -- users can overwrite this generated class by define the one with the same
+    # name
+    cardinality: Cardinality
+    # whether this property is optional or not
+    is_optional: bool = False
+    # whether this property is stored as a mapping dic[str, Target] or not
+    # only valid for *-to-many relationships
+    is_map: bool = False
+    db: Optional[ObjectPropDBInfo] = None

sera/models/_schema.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from graphlib import TopologicalSorter
+
+from sera.models._class import Class
+from sera.models._property import ObjectProperty
+
+
+@dataclass
+class Schema:
+    classes: dict[str, Class]
+
+    def topological_sort(self) -> list[Class]:
+        """
+        Sort classes in topological order using graphlib.TopologicalSorter.
+        """
+        # Build the dependency graph
+        graph = {}
+        for cls_name, cls in self.classes.items():
+            dependencies = set()
+            for prop in cls.properties.values():
+                if isinstance(prop, ObjectProperty) and prop.target.name != cls_name:
+                    dependencies.add(prop.target.name)
+            graph[cls_name] = dependencies
+
+        # Create topological sorter and get sorted class names
+        sorter = TopologicalSorter(graph)
+        sorted_names = list(sorter.static_order())
+
+        # Convert sorted names back to Class objects
+        return [self.classes[name] for name in sorted_names]

sera/namespace.py

@@ -0,0 +1,5 @@
+from __future__ import annotations
+
+from sera.misc import SingleNS
+
+APP_NS = SingleNS("app", "https://purl.org/sera/1.0/")

sera/typing.py

@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from typing import Annotated, TypeVar
+
+
+class doc(str):
+    """A docstring for a type. Typically used in Annotated"""
+
+
+T = TypeVar("T")
+FieldName = Annotated[str, doc("field name of a class")]

sera_2-1.1.0.dist-info/METADATA

@@ -0,0 +1,20 @@
+Metadata-Version: 2.1
+Name: sera-2
+Version: 1.1.0
+Summary: 
+Author: Binh Vu
+Author-email: bvu687@gmail.com
+Requires-Python: >=3.12,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: black (>=25.0.1,<26.0.0)
+Requires-Dist: codegen-2 (>=2.1.4,<3.0.0)
+Requires-Dist: litestar (>=2.15.1,<3.0.0)
+Requires-Dist: msgspec (>=0.19.0,<0.20.0)
+Description-Content-Type: text/markdown
+
+# Overview
+
+This library enables rapid application development by leveraging a graph-based architecture.
+

sera_2-1.1.0.dist-info/RECORD

@@ -0,0 +1,29 @@
+sera/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sera/libs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sera/libs/api_helper.py,sha256=hUEy0INHM18lxTQ348tgbXNceOHcjiAnqmuL_8CRpLQ,2509
+sera/libs/base_orm.py,sha256=IxsHjNPjF60YbLyTsMTOhQbjQX-L30UZtvE_vJDgZfo,2950
+sera/libs/base_service.py,sha256=nVHODZjdTqC8rrDKxYUWrK95APrtdMSCYzflePNxXns,2379
+sera/make/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sera/make/__main__.py,sha256=TLHA3e9QVoE0Nic6HSQDNiAe1MrTTw5IdYlNSNxjN5Q,912
+sera/make/make_app.py,sha256=e0DQpx6ilB76lxg2BYF6wjL7RFRQzvmOXq2322xm2SQ,4398
+sera/make/make_python_api.py,sha256=ikZfJrJ4B606td4os1QgX-7G5QJypmR-3qgLvGOIRh0,8765
+sera/make/make_python_model.py,sha256=1zC_NaFkyLYpZ3ytT-ZV6d8xmxtQHUpEFsqd0PkJ6x4,12031
+sera/make/make_python_services.py,sha256=RsinYZdfkrTlTn9CT50VgqGs9w6IZawsJx-KEmqfnEY,2062
+sera/make/make_typescript_model.py,sha256=U4S_2y3zgLZVfMenHRaJFBW8yqh2mUBuI291LGQVOJ8,35
+sera/misc/__init__.py,sha256=hjW2Lf1itdqlDjf1X8hwSZZfmE0XKDFlYtMMC1AXkT4,300
+sera/misc/_rdf.py,sha256=G0ekWLUSw-eiKUOaPSGkELbZld19S9d36gWwiswjrrs,1671
+sera/misc/_utils.py,sha256=MY85CZruRLYI2bf44d-a8g4lJibznD2MnAfd9VY1UdQ,1094
+sera/models/__init__.py,sha256=3ooJQulUc7oyUoMM89KT5f6nsoYagCjYEyC0AmyYyzY,661
+sera/models/_class.py,sha256=vFCuzG0vfAHYBjk1HQMFszT7zUAqGex-VAVJ2CUPIaE,1824
+sera/models/_collection.py,sha256=u3k4t7Z38FiZj9CstPArnf9KsIGr05zbwUn2ZrbQVJE,1078
+sera/models/_datatype.py,sha256=JkD3aRQ11DWicS2xaiNPwhBzJNJPwSkktBunx3EVr1s,1714
+sera/models/_module.py,sha256=-XW4bJ3v4QZPYPRMnbUW2zp0F5aJVH8uve_MrnwYz7w,3736
+sera/models/_multi_lingual_string.py,sha256=cVoxge1SW68dVmOjDZJU93tUq2ccJse3kSPqxrNkmgc,1091
+sera/models/_parse.py,sha256=l106WMAFTLjKio5L3rBK3B0NtwjnXh-sLF4Ofk2uFHE,5072
+sera/models/_property.py,sha256=lrI6V2zEblUVuEy9lahbLPLFisFRX6zrkO8wFWzU35k,4018
+sera/models/_schema.py,sha256=1F_Ict1NLvDcQDUZwcvnRS5MtsOTv584y3ChymUeUYA,1046
+sera/namespace.py,sha256=5NJ0A7weZwblqkncpgY2Vfcat04mNtigNcVrqu7TGOc,123
+sera/typing.py,sha256=CsazgVptDN-far3yISogTtA2KBJlFFOn0lK_WyZFDv8,230
+sera_2-1.1.0.dist-info/METADATA,sha256=zmJ_UdY6SLvr7d6pkcQL-oCo9DYB8gxpiM3CikxzySU,599
+sera_2-1.1.0.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+sera_2-1.1.0.dist-info/RECORD,,

sera_2-1.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 1.9.1
+Root-Is-Purelib: true
+Tag: py3-none-any