[JAC-CLOUD-MIN]: Initial Mini Version

.github/workflows/test-cloud.yml

@@ -57,5 +57,6 @@ jobs:
         jac clean
         jac tool gen_parser
         jac serve jac_cloud/tests/simple_graph.jac --port 8000 &
+        jac serve jac_cloud/tests/simple_graph_mini.jac --port 8001 &
         sleep 3
         pytest

jac-cloud/jac_cloud/plugin/cli.py

@@ -1,14 +1,17 @@
 """Module for registering CLI plugins for jaseci."""
 
-import os
-import pickle
+from os import getenv
+from os.path import split
+from pickle import load
 
 from jaclang import jac_import
 from jaclang.cli.cmdreg import cmd_registry
 from jaclang.plugin.default import hookimpl
 from jaclang.runtimelib.context import ExecutionContext
 from jaclang.runtimelib.machine import JacMachine, JacProgram
 
+from .mini.cli_mini import serve_mini
+
 
 class JacCmd:
     """Jac CLI."""
@@ -20,10 +23,14 @@ def create_cmd() -> None:
 
         @cmd_registry.register
         def serve(filename: str, host: str = "0.0.0.0", port: int = 8000) -> None:
+            if not getenv("DATABASE_HOST"):
+                serve_mini(filename=filename, host=host, port=port)
+                return
+
             from jac_cloud import FastAPI
 
             """Serve the jac application."""
-            base, mod = os.path.split(filename)
+            base, mod = split(filename)
             base = base if base else "./"
             mod = mod[:-4]
 
@@ -40,7 +47,7 @@ def serve(filename: str, host: str = "0.0.0.0", port: int = 8000) -> None:
             elif filename.endswith(".jir"):
                 with open(filename, "rb") as f:
                     JacMachine(base).attach_program(
-                        JacProgram(mod_bundle=pickle.load(f), bytecode=None)
+                        JacProgram(mod_bundle=load(f), bytecode=None)
                     )
                     jac_import(
                         target=mod,

jac-cloud/jac_cloud/plugin/jaseci.py

@@ -402,10 +402,7 @@ def decorator(cls: Type[Architype]) -> Type[Architype]:
     @hookimpl
     def report(expr: Any) -> None:  # noqa:ANN401
         """Jac's report stmt feature."""
-        if FastAPI.is_enabled():
-            JaseciContext.get().reports.append(expr)
-            return
-        JacFeatureDefaults.report(expr=expr)
+        Jac.get_context().reports.append(expr)
 
     @staticmethod
     @hookimpl

jac-cloud/jac_cloud/plugin/mini/__init__.py

@@ -0,0 +1 @@
+"""Jaseci Plugins Mini."""

jac-cloud/jac_cloud/plugin/mini/cli_mini.py

@@ -0,0 +1,188 @@
+"""Module for registering CLI plugins for jaseci."""
+
+from dataclasses import Field, MISSING, asdict, fields, is_dataclass
+from inspect import isclass
+from os import getenv, path
+from pickle import load
+from typing import Any, Type, cast, get_type_hints
+
+from asyncer import syncify
+
+from fastapi import Depends, FastAPI, File, Response, UploadFile, status
+from fastapi.responses import ORJSONResponse
+
+from jaclang import jac_import
+from jaclang.runtimelib.architype import (
+    Anchor,
+    Architype,
+    WalkerAnchor,
+    WalkerArchitype,
+)
+from jaclang.runtimelib.context import ExecutionContext
+from jaclang.runtimelib.machine import JacMachine, JacProgram
+
+from orjson import loads
+
+from pydantic import BaseModel, Field as pyField, ValidationError, create_model
+
+from starlette.datastructures import UploadFile as BaseUploadFile
+
+from uvicorn import run
+
+FILE_TYPES = {
+    UploadFile,
+    list[UploadFile],
+    UploadFile | None,
+    list[UploadFile] | None,
+}
+
+
+def response(reports: list[Any], status: int = 200) -> ORJSONResponse:
+    """Return serialized version of reports."""
+    resp: dict[str, Any] = {"status": status}
+
+    for key, val in enumerate(reports):
+        clean_response(key, val, reports)
+    resp["reports"] = reports
+
+    return ORJSONResponse(resp, status_code=status)
+
+
+def clean_response(key: str | int, val: Any, obj: list | dict) -> None:  # noqa: ANN401
+    """Cleanup and override current object."""
+    match val:
+        case list():
+            for idx, lval in enumerate(val):
+                clean_response(idx, lval, val)
+        case dict():
+            for key, dval in val.items():
+                clean_response(key, dval, val)
+        case Anchor():
+            cast(dict, obj)[key] = asdict(val.report())
+        case Architype():
+            cast(dict, obj)[key] = asdict(val.__jac__.report())
+        case val if is_dataclass(val) and not isinstance(val, type):
+            cast(dict, obj)[key] = asdict(val)
+        case _:
+            pass
+
+
+def gen_model_field(cls: type, field: Field, is_file: bool = False) -> tuple[type, Any]:
+    """Generate Specs for Model Field."""
+    if field.default is not MISSING:
+        consts = (cls, pyField(default=field.default))
+    elif callable(field.default_factory):
+        consts = (cls, pyField(default_factory=field.default_factory))
+    else:
+        consts = (cls, File(...) if is_file else ...)
+
+    return consts
+
+
+def populate_apis(app: FastAPI, cls: Type[WalkerArchitype]) -> None:
+    """Generate FastAPI endpoint based on WalkerArchitype class."""
+    body: dict[str, Any] = {}
+    files: dict[str, Any] = {}
+
+    hintings = get_type_hints(cls)
+    for f in fields(cls):
+        f_name = f.name
+        f_type = hintings[f_name]
+        if f_type in FILE_TYPES:
+            files[f_name] = gen_model_field(f_type, f, True)
+        else:
+            consts = gen_model_field(f_type, f)
+            body[f_name] = consts
+
+    payload: dict[str, Any] = {
+        "files": (
+            create_model(f"{cls.__name__.lower()}_files_model", **files),
+            Depends(),
+        ),
+    }
+
+    body_model = None
+    if body:
+        body_model = create_model(f"{cls.__name__.lower()}_body_model", **body)
+
+        if files:
+            payload["body"] = (UploadFile, File(...))
+        else:
+            payload["body"] = (body_model, ...)
+
+    payload_model = create_model(f"{cls.__name__.lower()}_request_model", **payload)
+
+    def api_entry(
+        node: str | None,
+        payload: payload_model = Depends(),  # type: ignore # noqa: B008
+    ) -> ORJSONResponse:
+        pl = cast(BaseModel, payload).model_dump()
+        body = pl.get("body", {})
+
+        if isinstance(body, BaseUploadFile) and body_model:
+            body = loads(syncify(body.read)())
+            try:
+                body = body_model(**body).model_dump()
+            except ValidationError as e:
+                return ORJSONResponse({"detail": e.errors()})
+
+        jctx = ExecutionContext.create(session=getenv("DATABASE", "database"))
+        jctx.set_entry_node(node)
+
+        wlk: WalkerAnchor = cls(**body, **pl["files"]).__jac__
+        wlk.spawn_call(jctx.entry_node)
+        jctx.close()
+
+        return response(jctx.reports, getattr(jctx, "status", 200))
+
+    def api_root(
+        payload: payload_model = Depends(),  # type: ignore # noqa: B008
+    ) -> Response:
+        return api_entry(None, payload)
+
+    app.post(url := f"/{cls.__name__}", summary=url)(api_root)
+    app.post(url := f"/{cls.__name__}/{{node}}", summary=url)(api_entry)
+
+
+def serve_mini(filename: str, host: str = "0.0.0.0", port: int = 8000) -> None:
+    """Serve the jac application."""
+    base, mod = path.split(filename)
+    base = base if base else "./"
+    mod = mod[:-4]
+
+    if filename.endswith(".jac"):
+        (module,) = jac_import(
+            target=mod,
+            base_path=base,
+            cachable=True,
+            override_name="__main__",
+        )
+    elif filename.endswith(".jir"):
+        with open(filename, "rb") as f:
+            JacMachine(base).attach_program(
+                JacProgram(mod_bundle=load(f), bytecode=None)
+            )
+            (module,) = jac_import(
+                target=mod,
+                base_path=base,
+                cachable=True,
+                override_name="__main__",
+            )
+    else:
+        JacMachine.detach()
+        raise ValueError("Not a valid file!\nOnly supports `.jac` and `.jir`")
+
+    app = FastAPI()
+
+    @app.get("/", status_code=status.HTTP_200_OK)
+    def healthz() -> Response:
+        """Healthz API."""
+        return Response()
+
+    for obj in module.__dict__.values():
+        if isclass(obj) and issubclass(obj, WalkerArchitype):
+            populate_apis(app, obj)
+
+    run(app, host=host, port=port)
+
+    JacMachine.detach()