sera-2 1.1.0__tar.gz

sera_2-1.1.0/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,3 @@
+# Overview
+
+This library enables rapid application development by leveraging a graph-based architecture.

sera_2-1.1.0/pyproject.toml

@@ -0,0 +1,18 @@
+[tool.poetry]
+name = "sera-2"
+version = "1.1.0"
+description = ""
+authors = ["Binh Vu <bvu687@gmail.com>"]
+readme = "README.md"
+packages = [{ include = "sera" }]
+
+[tool.poetry.dependencies]
+python = "^3.12"
+codegen-2 = "^2.1.4"
+black = "^25.0.1"
+msgspec = "^0.19.0"
+litestar = "^2.15.1"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"

sera_2-1.1.0/sera/libs/api_helper.py

@@ -0,0 +1,66 @@
+from __future__ import annotations
+
+import re
+
+from litestar import Request, status_codes
+from litestar.exceptions import HTTPException
+from sera.libs.base_service import Query, QueryOp
+
+# for parsing field names and operations from query string
+FIELD_REG = re.compile(r"(?P<name>[a-zA-Z_0-9]+)(?:\[(?P<op>[a-zA-Z0-9]+)\])?")
+QUERY_OPS = {op.value for op in QueryOp}
+KEYWORDS = {"field", "limit", "offset", "unique", "sorted_by", "group_by"}
+
+
+def parse_query(request: Request, fields: set[str], debug: bool) -> Query:
+    """Parse query for retrieving records that match a query.
+
+    If a field name collides with a keyword, you can add `_` to the field name.
+
+    To filter records, you can apply a condition on a column using <field>=<value> (equal condition). Or you can
+    be explicit by using <field>[op]=<value>, where op is one of the operators defined in QueryOp.
+    """
+    query: Query = {}
+
+    for k, v in request.query_params.items():
+        if k in KEYWORDS:
+            continue
+        m = FIELD_REG.match(k)
+        if m:
+            field_name = m.group("name")
+            operation = m.group("op")  # This will be None if no operation is specified
+
+            # If field name ends with '_' and it's to avoid keyword conflict, remove it
+            if field_name.endswith("_") and field_name[:-1] in KEYWORDS:
+                field_name = field_name[:-1]
+
+            if field_name not in fields:
+                # Invalid field name, skip
+                if debug:
+                    raise HTTPException(
+                        status_code=status_codes.HTTP_400_BAD_REQUEST,
+                        detail=f"Invalid field name: {field_name}",
+                    )
+                continue
+
+            # Process based on operation or default to equality check
+            if not operation:
+                operation = QueryOp.eq
+            else:
+                if operation not in QUERY_OPS:
+                    raise HTTPException(
+                        status_code=status_codes.HTTP_400_BAD_REQUEST,
+                        detail=f"Invalid operation: {operation}",
+                    )
+                operation = QueryOp(operation)
+            query[field_name] = {operation: v}
+        else:
+            # Invalid field name format
+            if debug:
+                raise HTTPException(
+                    status_code=status_codes.HTTP_400_BAD_REQUEST,
+                    detail=f"Invalid field name: {k}",
+                )
+            continue
+
+    return query

sera_2-1.1.0/sera/libs/base_orm.py

@@ -0,0 +1,109 @@
+from __future__ import annotations
+
+from typing import Optional
+
+import orjson
+from sqlalchemy import LargeBinary, TypeDecorator
+from sqlalchemy import create_engine as sqlalchemy_create_engine
+from sqlalchemy import update
+from sqlalchemy.orm import DeclarativeBase, Session
+
+
+class BaseORM(DeclarativeBase):
+
+    def get_update_query(self):
+        q = update(self.__class__)
+        args = {}
+        for col in self.__table__.columns:
+            val = getattr(self, col.name)
+            if col.primary_key:
+                q = q.where(getattr(self.__class__, col.name) == val)
+            args[col.name] = val
+
+        return q.values(**args)
+
+    def get_update_args(self):
+        return {col.name: getattr(self, col.name) for col in self.__table__.columns}
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        raise NotImplementedError()
+
+
+class DataclassType(TypeDecorator):
+    """SqlAlchemy Type decorator to serialize dataclasses"""
+
+    impl = LargeBinary
+    cache_ok = True
+
+    def __init__(self, cls):
+        super().__init__()
+        self.cls = cls
+
+    def process_bind_param(self, value, dialect):
+        if value is None:
+            return None
+        return orjson.dumps(value.to_dict())
+
+    def process_result_value(self, value, dialect):
+        if value is None:
+            return None
+        result = orjson.loads(value)
+        return self.cls.from_dict(result)
+
+
+class ListDataclassType(TypeDecorator):
+    """SqlAlchemy Type decorator to serialize list of dataclasses"""
+
+    impl = LargeBinary
+    cache_ok = True
+
+    def __init__(self, cls):
+        super().__init__()
+        self.cls = cls
+
+    def process_bind_param(self, value, dialect):
+        if value is None:
+            return None
+        return orjson.dumps([x.to_dict() for x in value])
+
+    def process_result_value(self, value, dialect):
+        if value is None:
+            return None
+        result = orjson.loads(value)
+        return [self.cls.from_dict(x) for x in result]
+
+
+class DictDataClassType(TypeDecorator):
+    """SqlAlchemy Type decorator to serialize mapping of dataclasses"""
+
+    impl = LargeBinary
+    cache_ok = True
+
+    def __init__(self, cls):
+        super().__init__()
+        self.cls = cls
+
+    def process_bind_param(self, value, dialect):
+        if value is None:
+            return None
+        return orjson.dumps({k: v.to_dict() for k, v in value.items()})
+
+    def process_result_value(self, value, dialect):
+        if value is None:
+            return None
+        result = orjson.loads(value)
+        return {k: self.cls.from_dict(v) for k, v in result.items()}
+
+
+def create_engine(
+    dbconn: str,
+    connect_args: Optional[dict] = None,
+    debug: bool = False,
+):
+    if dbconn.startswith("sqlite"):
+        connect_args = {"check_same_thread": False}
+    else:
+        connect_args = {}
+    engine = sqlalchemy_create_engine(dbconn, connect_args=connect_args, echo=debug)
+    return engine

sera_2-1.1.0/sera/libs/base_service.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+from enum import Enum
+from typing import Annotated, Any, Generic, Optional, Sequence, TypeVar
+
+from sera.libs.base_orm import BaseORM
+from sera.misc import assert_not_null
+from sera.models import Class
+from sera.typing import FieldName, T, doc
+from sqlalchemy import exists, select
+from sqlalchemy.orm import Session
+
+
+class QueryOp(str, Enum):
+    lt = "<"
+    lte = "<="
+    gt = ">"
+    gte = ">="
+    eq = "="
+    ne = "!="
+    # select records where values are in the given list
+    in_ = "in"
+    not_in = "not in"
+    # for full text search
+    fuzzy = "fuzzy"
+
+
+Query = Annotated[
+    dict[FieldName, dict[QueryOp, Annotated[Any, doc("query value")]]],
+    doc("query operations"),
+]
+C = TypeVar("C", bound=BaseORM)
+ID = Annotated[TypeVar("ID"), doc("ID of a class")]
+
+
+class BaseService(Generic[ID, C]):
+
+    def __init__(self, cls: Class, orm_cls: type[C]):
+        self.cls = cls
+        self.orm_cls = orm_cls
+        self.id_prop = assert_not_null(cls.get_id_property())
+
+        self._cls_id_prop = getattr(self.orm_cls, self.id_prop.name)
+
+    def get(
+        self,
+        query: Query,
+        limit: int,
+        offset: int,
+        unique: bool,
+        sorted_by: list[str],
+        group_by: list[str],
+        fields: list[str],
+    ) -> Sequence[C]:
+        """Retrieving records matched a query.
+
+        Args:
+            query: The query to filter the records
+            limit: The maximum number of records to return
+            offset: The number of records to skip before returning results
+            unique: Whether to return unique results only
+            sorted_by: list of field names to sort by, prefix a field with '-' to sort that field in descending order
+            group_by: list of field names to group by
+            fields: list of field names to include in the results
+        """
+        return []
+
+    def get_by_id(self, id: ID, session: Session) -> Optional[C]:
+        """Retrieving a record by ID."""
+        q = select(self.orm_cls).where(self._cls_id_prop == id)
+        result = session.execute(q).scalar_one_or_none()
+        return result
+
+    def has_id(self, id: ID, session: Session) -> bool:
+        """Check whether we have a record with the given ID."""
+        q = exists().where(self._cls_id_prop == id)
+        result = session.query(q).scalar()
+        return bool(result)

sera_2-1.1.0/sera/make/__main__.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Annotated
+
+import typer
+from sera.make.make_app import make_app
+
+app = typer.Typer(pretty_exceptions_short=True, pretty_exceptions_enable=False)
+
+
+@app.command()
+def cli(
+    app_dir: Annotated[
+        Path,
+        typer.Option("--app", help="Directory of the generated application"),
+    ],
+    schema_files: Annotated[
+        list[Path],
+        typer.Option(
+            "-s", help="YAML schema files. Multiple files are merged automatically"
+        ),
+    ],
+    api_collections: Annotated[
+        list[str],
+        typer.Option(
+            "-c",
+            "--collection",
+            help="API collections to generate.",
+        ),
+    ],
+):
+    """Generate Python model classes from a schema file."""
+    typer.echo(f"Generating application in {app_dir}")
+    make_app(app_dir, schema_files, api_collections)
+
+
+app()

sera_2-1.1.0/sera/make/make_app.py

@@ -0,0 +1,142 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from pydoc import doc
+from typing import Annotated
+
+from codegen.models import DeferredVar, PredefinedFn, Program, expr, stmt
+from loguru import logger
+from sera.make.make_python_api import make_python_api
+from sera.make.make_python_model import (
+    make_python_data_model,
+    make_python_relational_model,
+)
+from sera.make.make_python_services import make_python_service_structure
+from sera.models import App, DataCollection, parse_schema
+
+
+def make_config(app: App):
+    """Make the configuration for the application."""
+    if app.config.exists():
+        logger.info("`{}` already exists. Skip generation.", app.config.path)
+        return
+
+    program = Program()
+    program.import_("__future__.annotations", True)
+    program.import_("os", False)
+    program.import_("serde.yaml", False)
+    program.import_("pathlib.Path", True)
+    program.import_("sera.models.parse_schema", True)
+
+    program.root(
+        lambda ast: ast.if_(
+            PredefinedFn.not_has_item(
+                expr.ExprIdent("os.environ"), expr.ExprConstant("CFG_FILE")
+            )
+        )(
+            lambda ast01: ast01.assign(
+                DeferredVar.simple("CFG_FILE"),
+                expr.ExprRawPython("Path(__file__).parent.parent / 'config.yaml'"),
+            ),
+        ),
+        lambda ast: ast.else_()(
+            lambda ast01: ast01.assign(
+                DeferredVar.simple("CFG_FILE"),
+                expr.ExprRawPython('Path(os.environ["CFG_FILE"])'),
+            ),
+        ),
+        lambda ast: ast.assign(
+            DeferredVar.simple("cfg"),
+            expr.ExprFuncCall(
+                expr.ExprIdent("serde.yaml.deser"), [expr.ExprIdent("CFG_FILE")]
+            ),
+        ),
+        stmt.LineBreak(),
+        lambda ast: ast.assign(
+            DeferredVar.simple("DB_CONNECTION"),
+            expr.ExprIdent("cfg['db']['connection']"),
+        ),
+        lambda ast: ast.assign(
+            DeferredVar.simple("DB_DEBUG"),
+            expr.ExprIdent('os.environ.get("DB_DEBUG", "0") == "1"'),
+        ),
+        lambda ast: ast.assign(
+            DeferredVar.simple("ROUTER_DEBUG"),
+            expr.ExprIdent('os.environ.get("ROUTER_DEBUG", "0") == "1"'),
+        ),
+        stmt.LineBreak(),
+        lambda ast: ast.assign(
+            DeferredVar.simple("PKG_DIR"),
+            expr.ExprRawPython("Path(__file__).parent"),
+        ),
+        lambda ast: ast.assign(
+            DeferredVar.simple("schema"),
+            expr.ExprFuncCall(
+                expr.ExprIdent("parse_schema"),
+                [
+                    PredefinedFn.list(
+                        [
+                            expr.ExprDivision(
+                                expr.ExprIdent("PKG_DIR"),
+                                expr.ExprConstant(
+                                    os.path.relpath(path.absolute(), app.root.dir)
+                                ),
+                            )
+                            for path in app.schema_files
+                        ]
+                    )
+                ],
+            ),
+        ),
+    )
+
+    app.config.write(program)
+
+
+def make_app(
+    app_dir: Annotated[
+        Path,
+        doc("Directory of the generated application"),
+    ],
+    schema_files: Annotated[
+        list[Path],
+        doc("YAML schema files. Multiple files are merged automatically"),
+    ],
+    api_collections: Annotated[
+        list[str],
+        doc("API collections to generate."),
+    ],
+):
+    schema = parse_schema(schema_files)
+
+    app = App(app_dir.name, app_dir, schema_files)
+
+    # generate application configuration
+    make_config(app)
+
+    # generate models from schema
+    make_python_data_model(schema, app.models.pkg("data"))
+    make_python_relational_model(schema, app.models.pkg("db"), app.models.pkg("data"))
+
+    collections = [DataCollection(schema.classes[cname]) for cname in api_collections]
+
+    # generate API
+    make_python_api(app, collections)
+
+    # generate services
+    make_python_service_structure(app, collections)
+
+    return app
+
+
+if __name__ == "__main__":
+    make_app(
+        Path("/Volumes/research/workspace/libs/sera/tests/resources/myapp"),
+        [
+            Path(
+                "/Volumes/research/workspace/libs/sera/tests/resources/schema/product.yml"
+            )
+        ],
+        ["Product", "Category"],
+    )