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

sera/misc/__init__.py

@@ -3,6 +3,8 @@ from sera.misc._utils import (
     assert_isinstance,
     assert_not_null,
     filter_duplication,
+    to_camel_case,
+    to_pascal_case,
     to_snake_case,
 )
 
@@ -13,4 +15,6 @@ __all__ = [
     "assert_isinstance",
     "filter_duplication",
     "assert_not_null",
+    "to_snake_case",
+    "to_camel_case",
 ]

sera/misc/_utils.py

@@ -13,6 +13,18 @@ def to_snake_case(camelcase: str) -> str:
     return snake.lower()
 
 
+def to_camel_case(snake: str) -> str:
+    """Convert snake_case to camelCase."""
+    components = snake.split("_")
+    return components[0] + "".join(x.title() for x in components[1:])
+
+
+def to_pascal_case(snake: str) -> str:
+    """Convert snake_case to PascalCase."""
+    components = snake.split("_")
+    return "".join(x.title() for x in components)
+
+
 def assert_isinstance(x: Any, cls: type[T]) -> T:
     if not isinstance(x, cls):
         raise Exception(f"{type(x)} doesn't match with {type(cls)}")

sera/models/__init__.py

@@ -1,6 +1,6 @@
 from sera.models._class import Class
 from sera.models._collection import DataCollection
-from sera.models._datatype import DataType
+from sera.models._datatype import DataType, PyTypeWithDep, TsTypeWithDep
 from sera.models._module import App, Language, Module, Package
 from sera.models._multi_lingual_string import MultiLingualString
 from sera.models._parse import parse_schema
@@ -22,4 +22,6 @@ __all__ = [
     "Module",
     "App",
     "Language",
+    "PyTypeWithDep",
+    "TsTypeWithDep",
 ]

sera/models/_class.py

@@ -8,12 +8,20 @@ from sera.models._multi_lingual_string import MultiLingualString
 from sera.models._property import DataProperty, ObjectProperty
 
 
+@dataclass(kw_only=True)
+class Index:
+    name: str
+    columns: list[str]
+    unique: bool = False
+
+
 @dataclass(kw_only=True)
 class ClassDBMapInfo:
     """Represent database information for a class."""
 
     # name of a corresponding table in the database for this class
     table_name: str
+    indices: list[Index] = field(default_factory=list)
 
 
 @dataclass(kw_only=True)
@@ -43,16 +51,25 @@ class Class:
         Get the ID property of this class.
         The ID property is the one tagged with is_primary_key
         """
-        assert self.db is not None, "This class is not stored in the database"
         for prop in self.properties.values():
             if (
                 isinstance(prop, DataProperty)
                 and prop.db is not None
                 and prop.db.is_primary_key
             ):
+                assert (
+                    self.db is not None
+                ), "This class is not stored in the database and thus, cannot have a primary key"
                 return prop
+        assert (
+            self.db is None
+        ), "This class is stored in the database and thus, must have a primary key"
         return None
 
     def get_pymodule_name(self) -> str:
         """Get the python module name of this class as if there is a python module created to store this class only."""
         return to_snake_case(self.name)
+
+    def get_tsmodule_name(self) -> str:
+        """Get the typescript module name of this class as if there is a typescript module created to store this class only."""
+        return self.name[0].lower() + self.name[1:]

sera/models/_collection.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 from dataclasses import dataclass
 
 from sera.models._class import Class
+from sera.models._property import DataProperty
 
 
 @dataclass
@@ -24,8 +25,15 @@ class DataCollection:
         """Get the fields of this collection that can be used in a queries."""
         field_names = set()
         for prop in self.cls.properties.values():
-            if prop.db is None:
-                # This property is not stored in the database, so we skip it
+            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
+                continue
+            if (
+                isinstance(prop, DataProperty)
+                and prop.db is not None
+                and not prop.db.is_indexed
+            ):
+                # This property is not indexed, so we skip it
                 continue
             field_names.add(prop.name)
         return field_names

sera/models/_datatype.py

@@ -1,10 +1,12 @@
 from __future__ import annotations
 
 import datetime
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from enum import Enum
 from typing import Literal
 
+from codegen.models import expr
+
 PyDataType = Literal["str", "int", "datetime", "float", "bool", "bytes", "dict"]
 TypescriptDataType = Literal["string", "number", "boolean"]
 SQLAlchemyDataType = Literal[
@@ -20,73 +22,176 @@ SQLAlchemyDataType = Literal[
 
 
 @dataclass
-class TypeWithDep:
+class PyTypeWithDep:
     type: str
     dep: str | None = None
 
-
-@dataclass
-class PyTypeWithDep(TypeWithDep):
-
     def get_python_type(self) -> type:
         """Get the Python type from the type string for typing annotation in Python."""
-        if self.type == "str":
-            return str
-        elif self.type == "int":
-            return int
-        elif self.type == "float":
-            return float
-        elif self.type == "bool":
-            return bool
-        elif self.type == "bytes":
-            return bytes
-        elif self.type == "dict":
-            return dict
-        elif self.type == "datetime":
-            return datetime.datetime
-        else:
+        type = {
+            "str": str,
+            "int": int,
+            "float": float,
+            "bool": bool,
+            "bytes": bytes,
+            "dict": dict,
+            "datetime": datetime.datetime,
+            "list[str]": list[str],
+            "list[int]": list[int],
+            "list[float]": list[float],
+            "list[bool]": list[bool],
+            "list[bytes]": list[bytes],
+            "list[dict]": list[dict],
+            "list[datetime]": list[datetime.datetime],
+        }.get(self.type, None)
+        if type is None:
             raise ValueError(f"Unknown type: {self.type}")
+        return type
+
+    def as_list_type(self) -> PyTypeWithDep:
+        """Convert the type to a list type."""
+        return PyTypeWithDep(type=f"list[{self.type}]", dep=self.dep)
+
+
+@dataclass
+class TsTypeWithDep:
+    type: str
+    dep: str | None = None
+
+    def get_default(self) -> expr.ExprConstant:
+        if self.type.endswith("[]"):
+            return expr.ExprConstant([])
+        if self.type == "string":
+            return expr.ExprConstant("")
+        if self.type == "number":
+            return expr.ExprConstant(0)
+        if self.type == "boolean":
+            return expr.ExprConstant(False)
+        if self.type == "string | undefined":
+            return expr.ExprConstant("undefined")
+        raise ValueError(f"Unknown type: {self.type}")
+
+    def as_list_type(self) -> TsTypeWithDep:
+        return TsTypeWithDep(type=f"{self.type}[]", dep=self.dep)
+
+
+@dataclass
+class SQLTypeWithDep:
+    type: str
+    mapped_pytype: str
+    deps: list[str] = field(default_factory=list)
+
+    def as_list_type(self) -> SQLTypeWithDep:
+        """Convert the type to a list type."""
+        return SQLTypeWithDep(
+            type=f"ARRAY({self.type})",
+            deps=self.deps + ["sqlalchemy.ARRAY"],
+            mapped_pytype=f"list[{self.mapped_pytype}]",
+        )
 
 
 @dataclass
 class DataType:
-    pytype: PyDataType
-    sqltype: SQLAlchemyDataType
-    tstype: TypescriptDataType
+    pytype: PyTypeWithDep
+    sqltype: SQLTypeWithDep
+    tstype: TsTypeWithDep
 
     is_list: bool = False
 
-    def get_python_type(self) -> TypeWithDep:
-        if self.pytype in ["str", "int", "float", "bool", "bytes", "dict"]:
-            return TypeWithDep(type=self.pytype)
-        if self.pytype == "datetime":
-            return TypeWithDep(type="datetime", dep="datetime.datetime")
-        raise NotImplementedError(self.pytype)
+    def get_python_type(self) -> PyTypeWithDep:
+        pytype = self.pytype
+        if self.is_list:
+            return pytype.as_list_type()
+        return pytype
 
-    def get_sqlalchemy_type(self) -> TypeWithDep:
-        if self.pytype in ["str", "int", "float", "bool", "bytes"]:
-            return TypeWithDep(type=self.pytype)
-        if self.pytype == "dict":
-            return TypeWithDep(type="JSON")
-        if self.pytype == "datetime":
-            return TypeWithDep(type="datetime", dep="datetime.datetime")
-        raise NotImplementedError(self.pytype)
+    def get_sqlalchemy_type(self) -> SQLTypeWithDep:
+        sqltype = self.sqltype
+        if self.is_list:
+            return sqltype.as_list_type()
+        return sqltype
+
+    def get_typescript_type(self) -> TsTypeWithDep:
+        tstype = self.tstype
+        if self.is_list:
+            return tstype.as_list_type()
+        return tstype
 
 
 predefined_datatypes = {
-    "string": DataType(pytype="str", sqltype="String", tstype="string", is_list=False),
+    "string": DataType(
+        pytype=PyTypeWithDep(type="str"),
+        sqltype=SQLTypeWithDep(
+            type="String", mapped_pytype="str", deps=["sqlalchemy.String"]
+        ),
+        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="int", sqltype="Integer", tstype="number", is_list=False
+        pytype=PyTypeWithDep(type="int"),
+        sqltype=SQLTypeWithDep(
+            type="Integer", mapped_pytype="int", deps=["sqlalchemy.Integer"]
+        ),
+        tstype=TsTypeWithDep(type="number"),
+        is_list=False,
     ),
     "datetime": DataType(
-        pytype="datetime", sqltype="DateTime", tstype="string", is_list=False
+        pytype=PyTypeWithDep(type="datetime", dep="datetime.datetime"),
+        sqltype=SQLTypeWithDep(
+            type="DateTime", mapped_pytype="datetime", deps=["sqlalchemy.DateTime"]
+        ),
+        tstype=TsTypeWithDep(type="string"),
+        is_list=False,
+    ),
+    "float": DataType(
+        pytype=PyTypeWithDep(type="float"),
+        sqltype=SQLTypeWithDep(
+            type="Float", mapped_pytype="float", deps=["sqlalchemy.Float"]
+        ),
+        tstype=TsTypeWithDep(type="number"),
+        is_list=False,
     ),
-    "float": DataType(pytype="float", sqltype="Float", tstype="number", is_list=False),
     "boolean": DataType(
-        pytype="bool", sqltype="Boolean", tstype="boolean", is_list=False
+        pytype=PyTypeWithDep(type="bool"),
+        sqltype=SQLTypeWithDep(
+            type="Boolean", mapped_pytype="bool", deps=["sqlalchemy.Boolean"]
+        ),
+        tstype=TsTypeWithDep(type="boolean"),
+        is_list=False,
     ),
     "bytes": DataType(
-        pytype="bytes", sqltype="LargeBinary", tstype="string", is_list=False
+        pytype=PyTypeWithDep(type="bytes"),
+        sqltype=SQLTypeWithDep(
+            type="LargeBinary", mapped_pytype="bytes", deps=["sqlalchemy.LargeBinary"]
+        ),
+        tstype=TsTypeWithDep(type="string"),
+        is_list=False,
+    ),
+    "dict": DataType(
+        pytype=PyTypeWithDep(type="dict"),
+        sqltype=SQLTypeWithDep(
+            type="JSON", mapped_pytype="dict", deps=["sqlalchemy.JSON"]
+        ),
+        tstype=TsTypeWithDep(type="string"),
+        is_list=False,
+    ),
+}
+
+predefined_py_datatypes = {"bytes": PyTypeWithDep(type="bytes")}
+predefined_sql_datatypes = {
+    "bit": SQLTypeWithDep(
+        type="BIT", mapped_pytype="bytes", deps=["sqlalchemy.dialects.postgresql.BIT"]
     ),
-    "dict": DataType(pytype="dict", sqltype="JSON", tstype="string", is_list=False),
+}
+predefined_ts_datatypes = {
+    "string": TsTypeWithDep(type="string"),
 }

sera/models/_module.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-import datetime
+import subprocess
 from dataclasses import dataclass
 from enum import Enum
 from pathlib import Path
@@ -75,22 +75,53 @@ class Module:
                 raise
         else:
             assert self.language == Language.Typescript
-            raise NotImplementedError()
+            try:
+                code = program.root.to_typescript()
+            except:
+                logger.error("Error writing module {}", self.path)
+                print(">>> Program")
+                print(program.root.to_typescript())
+                print("<<<")
+                raise
+
+        if self.language == Language.Python:
+            outfile = self.package.dir / f"{self.name}.py"
+            copyright_statement = f"# Generated by SERA. All rights reserved.\n\n"
+        else:
+            assert self.language == Language.Typescript
+            outfile = self.package.dir / f"{self.name}.ts"
+            copyright_statement = f"/// Generated by SERA. All rights reserved.\n\n"
 
-        outfile = self.package.dir / f"{self.name}.py"
         if outfile.exists():
-            if outfile.read_text().startswith("# sera:skip"):
+            outfile_content = outfile.read_text()
+            if outfile_content.startswith("# sera:skip") or outfile_content.startswith(
+                "/// sera:skip"
+            ):
                 logger.info(
                     "`{}` already exists and is in manual edit mode. Skip updating it.",
                     outfile,
                 )
                 return
-        copyright_statement = f"# Generated by SERA \n\n"
+
         outfile.write_text(copyright_statement + code)
 
+        if self.language == Language.Typescript:
+            # invoke prettier to format the code
+            try:
+                subprocess.check_output(
+                    ["npx", "prettier", "--write", str(outfile.absolute())],
+                    cwd=self.package.app.root.dir,
+                )
+            except Exception as e:
+                logger.error("Error formatting Typescript file: {}", e)
+                raise
+
     def exists(self) -> bool:
         """Check if the module exists"""
-        return (self.package.dir / f"{self.name}.py").exists()
+        if self.language == Language.Python:
+            return (self.package.dir / f"{self.name}.py").exists()
+        else:
+            return (self.package.dir / f"{self.name}.ts").exists()
 
 
 @dataclass

sera/models/_parse.py

@@ -1,12 +1,19 @@
 from __future__ import annotations
 
+import re
 from copy import deepcopy
 from pathlib import Path
 from typing import Sequence
 
 import serde.yaml
-from sera.models._class import Class, ClassDBMapInfo
-from sera.models._datatype import DataType, predefined_datatypes
+from sera.models._class import Class, ClassDBMapInfo, Index
+from sera.models._datatype import (
+    DataType,
+    predefined_datatypes,
+    predefined_py_datatypes,
+    predefined_sql_datatypes,
+    predefined_ts_datatypes,
+)
 from sera.models._multi_lingual_string import MultiLingualString
 from sera.models._property import (
     Cardinality,
@@ -16,6 +23,7 @@ from sera.models._property import (
     ForeignKeyOnUpdate,
     ObjectPropDBInfo,
     ObjectProperty,
+    PropDataAttrs,
 )
 from sera.models._schema import Schema
 
@@ -46,7 +54,16 @@ def parse_schema(files: Sequence[Path | str]) -> 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"])
+        indices = []
+        for idx in cls["db"].get("indices", []):
+            index = Index(
+                name=idx.get("name", "_".join(idx["columns"]) + "_index"),
+                columns=idx["columns"],
+                unique=idx.get("unique", False),
+            )
+            indices.append(index)
+        db = ClassDBMapInfo(table_name=cls["db"]["table_name"], indices=indices)
+
     return Class(
         name=clsname,
         label=_parse_multi_lingual_string(cls["label"]),
@@ -68,7 +85,6 @@ def _parse_property(
                 description=_parse_multi_lingual_string(""),
                 target=schema.classes[datatype],
                 cardinality=Cardinality.ONE_TO_ONE,
-                is_private=False,
             )
         else:
             return DataProperty(
@@ -76,10 +92,14 @@ def _parse_property(
                 label=_parse_multi_lingual_string(prop_name),
                 description=_parse_multi_lingual_string(""),
                 datatype=_parse_datatype(datatype),
-                is_private=False,
             )
 
     db = prop.get("db", {})
+    _data = prop.get("data", {})
+    data_attrs = PropDataAttrs(
+        is_private=_data.get("is_private", False),
+        datatype=_parse_datatype(_data["datatype"]) if "datatype" in _data else None,
+    )
 
     assert isinstance(prop, dict), prop
     if "datatype" in prop:
@@ -88,12 +108,16 @@ def _parse_property(
             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),
+            data=data_attrs,
             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),
+                    is_indexed=db.get("is_indexed", False)
+                    or db.get("is_unique", False)
+                    or db.get("is_primary_key", False),
+                    is_nullable=db.get("is_nullable", False),
                 )
                 if "db" in prop
                 else None
@@ -108,7 +132,7 @@ def _parse_property(
         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),
+        data=data_attrs,
         db=(
             ObjectPropDBInfo(
                 is_embedded=db.get("is_embedded", None),
@@ -139,16 +163,43 @@ def _parse_multi_lingual_string(o: dict | str) -> MultiLingualString:
     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
+def _parse_datatype(datatype: dict | str) -> DataType:
+    if isinstance(datatype, str):
+        if datatype.endswith("[]"):
+            datatype = datatype[:-2]
+            is_list = True
+        else:
+            is_list = False
+
+        if datatype not in predefined_datatypes:
+            raise NotImplementedError(datatype)
+
+        dt = deepcopy(predefined_datatypes[datatype])
+        dt.is_list = is_list
+        return dt
+    if isinstance(datatype, dict):
+        is_list = datatype.get("is_list", False)
+
+        # Parse SQL type and argument if present
+        m = re.match(r"^([a-zA-Z0-9_]+)(\([^)]+\))?$", datatype["sqltype"])
+        if m is not None:
+            sql_type_name = m.group(1)
+            sql_type_arg = m.group(2)
+            # Use the extracted type to get the predefined SQL type
+            if sql_type_name not in predefined_sql_datatypes:
+                raise NotImplementedError(sql_type_name)
+            sql_type = predefined_sql_datatypes[sql_type_name]
+            if sql_type_arg is not None:
+                # process the argument
+                sql_type.type = sql_type.type + sql_type_arg
+        else:
+            raise ValueError(f"Invalid SQL type format: {datatype['sqltype']}")
 
-    if datatype not in predefined_datatypes:
-        raise NotImplementedError(datatype)
+        return DataType(
+            pytype=predefined_py_datatypes[datatype["pytype"]],
+            sqltype=sql_type,
+            tstype=predefined_ts_datatypes[datatype["tstype"]],
+            is_list=is_list,
+        )
 
-    dt = deepcopy(predefined_datatypes[datatype])
-    dt.is_list = is_list
-    return dt
+    raise NotImplementedError(datatype)

sera/models/_property.py

@@ -54,6 +54,19 @@ class Cardinality(str, Enum):
         ]
 
 
+@dataclass(kw_only=True)
+class PropDataAttrs:
+    """Storing other attributes for generating data model (upsert & public) -- this is different from a db model"""
+
+    # whether this property is private and cannot be accessed by the end users
+    # meaning the public data model will not include this property
+    # default it is false
+    is_private: bool = False
+
+    # whether this data model has a different data type than the one from the database
+    datatype: Optional[DataType] = None
+
+
 @dataclass(kw_only=True)
 class Property:
     """Represent a property of a class."""
@@ -68,9 +81,8 @@ class 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)
+    # other attributes for generating data model such as upsert and return.
+    data: PropDataAttrs = field(default_factory=PropDataAttrs)
 
 
 @dataclass(kw_only=True)
@@ -83,6 +95,10 @@ class DataPropDBInfo:
     is_auto_increment: bool = False
     # whether this property contains unique values
     is_unique: bool = False
+    # whether this property is indexed or not
+    is_indexed: bool = False
+    # whether this property is nullable or not
+    is_nullable: bool = False
 
 
 @dataclass(kw_only=True)
@@ -92,6 +108,14 @@ class DataProperty(Property):
     # other database properties of this property
     db: Optional[DataPropDBInfo] = None
 
+    def get_data_model_datatype(self) -> DataType:
+        if self.data.datatype is not None:
+            return self.data.datatype
+        return self.datatype
+
+    def is_diff_data_model_datatype(self):
+        return self.data.datatype is not None
+
 
 @dataclass(kw_only=True)
 class ObjectPropDBInfo:

sera/typing.py

@@ -9,3 +9,6 @@ class doc(str):
 
 T = TypeVar("T")
 FieldName = Annotated[str, doc("field name of a class")]
+ObjectPath = Annotated[
+    str, doc("path of an object (e.g., can be function, class, etc.)")
+]

{sera_2-1.2.0.dist-info → sera_2-1.4.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: sera-2
-Version: 1.2.0
+Version: 1.4.2
 Summary: 
 Author: Binh Vu
 Author-email: bvu687@gmail.com
@@ -8,10 +8,10 @@ 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)
+Project-URL: Repository, https://github.com/binh-vu/sera
 Description-Content-Type: text/markdown
 
 # Overview