acUIty-core 0.2.0__py3-none-any.whl

acuity/model/_page.py

@@ -0,0 +1,68 @@
+import uuid
+from typing import Any, Callable
+from pydantic import BaseModel
+
+from acuity.model._datalet import _Datalet
+from acuity.model._lucide import LucideIconName
+from acuity.model._panel import _Panel
+import re
+
+
+class _Page(BaseModel):
+    """Page class represents a page in the application UI.
+    Handles page configuration and properties.
+    """
+    page_id: str
+    title: str
+    route_path: str
+    icon: LucideIconName
+    panels: list[_Panel]
+
+    def __init__(self, page_id: str, title: str = "", route_path: str = "", icon : LucideIconName = "Box"):
+        """Initialize a new Page instance.
+
+        Args:
+            name: The name of the page
+            title: The title displayed in the menu (defaults to name if not provided)
+            route_path: The URL route path for the page (defaults to /name if not provided)
+        """
+
+        # Validate name
+        if page_id != page_id.lower():
+            raise ValueError(f"Page id must be lowercase: '{page_id}'")
+
+        if ' ' in page_id:
+            raise ValueError(f"Page id cannot contain spaces: '{page_id}'")
+
+        if not re.match(r'^[a-z_\-\.][a-z0-9_\-\.]*$', page_id):
+            raise ValueError(
+                f"Page id can only contain letters, numbers, '_', '-', '.', and cannot start with a number: '{page_id}'")
+
+        # set default values
+        if not title:
+                title = page_id
+        if not route_path:
+            route_path = f"/{page_id}"
+
+        super().__init__(page_id=page_id, title=title, route_path=route_path, icon=icon, panels=[])
+
+
+    def panel(self, width: str = "full", height: str = "full") -> Callable[[Callable], Callable]:
+        """Decorator that registers a panel to this page.
+
+        Args:
+            width: width of the panel
+            height: height of the panel
+
+        Returns:
+            A decorator function that registers the panel and returns the original function
+        """
+        def decorator(func: Callable[[], _Datalet]) -> Callable:
+            new_panel = _Panel(width=width, height=height)
+            datalet = func()
+            new_panel.id = datalet.id
+            new_panel.datalet = datalet.datalet_type
+            self.panels.append(new_panel)
+            return func
+
+        return decorator

acuity/model/_panel.py

@@ -0,0 +1,24 @@
+from pydantic import BaseModel
+from typing import Literal, Optional
+import uuid
+from ._datalet import _DataletType
+
+
+class _Panel(BaseModel):
+    id: Optional[str]
+    width: Literal["full", "half"]
+    height: Literal["full", "fit"]
+    datalet: Optional[_DataletType] = None
+    variant: Literal["default", "brand", "highlight", "gosth"]
+
+    def __init__(self, width: str = "full", height: str = "full", title: str = "", variant: str = "default"):
+        """Initialize a new Panel instance.
+
+        Args:
+            width: The width of the panel ("full" or "half")
+            height: The height of the panel ("full" or "fit")
+            datalet: The datalet within the panel
+        """
+        panel_id = f"panel_{uuid.uuid4().hex[:8]}"
+        super().__init__(id=panel_id, title=title, width=width, height=height, variant=variant)
+

acuity/runtime/__init__.py

@@ -0,0 +1,14 @@
+## runtime
+from acuity.runtime._engine import Engine
+
+engine = Engine()
+
+def run(file_path: str, port: int = 8000):
+    """Run a Python file as a acuity application."""
+    engine.run(file_path, port=port)
+
+def watch(file_path: str, port: int = 8000):
+    """Run a Python file as a acuity application in development mode with file watching."""
+    engine.watch(file_path, port=port)
+
+__all__ = ["run", "watch"]

acuity/runtime/_ai_router.py

@@ -0,0 +1,84 @@
+from openai.types.responses import ResponseTextDeltaEvent, ResponseOutputItemDoneEvent, ResponseOutputMessage, ResponseCompletedEvent, ResponseFunctionToolCall
+from fastapi import APIRouter, Request
+from pydantic import BaseModel
+from openai import OpenAI
+import json
+import logging
+from sse_starlette.sse import EventSourceResponse, ServerSentEvent
+import os
+
+logger = logging.getLogger(__name__)
+
+ai_router = APIRouter()
+
+
+class ChatMessage(BaseModel):
+    role: str
+    content: str
+
+
+class ChatPayload(BaseModel):
+    prompt: str
+    history: list[ChatMessage] = []
+
+
+@ai_router.post("/invoke/{model_name}")
+async def ai_invoke(model_name: str, request: Request):
+    payload = ChatPayload(**(await request.json()))
+
+    messages = [{"role": msg.role, "content": msg.content} for msg in payload.history]
+    messages.append({"role": "user", "content": payload.prompt})
+
+    def event_generator():
+
+        base_url = "https://1276122062834378.8.gcp.databricks.com/serving-endpoints"
+        model_name = "mas-e00a6b00-endpoint"
+
+        token = os.environ.get("DATABRICKS_TOKEN")
+        logger.debug("DATABRICKS_TOKEN is %s", "set" if token else "not set")
+
+        client = OpenAI(
+            api_key=token,
+            base_url=f"{base_url}"
+        )
+
+        logger.info("Sending request to %s/%s/invocations for model %s...", base_url, model_name, model_name)
+
+        try:
+
+            with client.responses.create(
+                    model=model_name,
+                    input=messages,
+                    stream=True,
+                    extra_body={
+                        "databricks_options": {
+                            "return_trace": True
+                        }
+                    }
+            ) as response:
+
+                for chunk in response:
+                    logger.debug("Chunk: %s", chunk)
+                    if isinstance(chunk, ResponseTextDeltaEvent):
+                        event_type = "delta"
+                    elif isinstance(chunk, ResponseOutputItemDoneEvent) and isinstance(chunk.item, ResponseOutputMessage):
+                        if chunk.item.content[0].text.startswith("<name>"):
+                            event_type = "agent_router_message"
+                        else:
+                            event_type = "output_message"
+                    elif isinstance(chunk, ResponseOutputItemDoneEvent) and isinstance(chunk.item, ResponseFunctionToolCall):
+                        event_type = "function_call"
+                    elif isinstance(chunk, ResponseCompletedEvent):
+                        event_type = "completed"
+                        logger.info("Completed event received")
+
+                    else:
+                        event_type = "other"
+                        
+                    yield ServerSentEvent(data=json.dumps(chunk.model_dump()), event=event_type)
+
+        except Exception as e:
+            logger.error("Error during request: %s", e, exc_info=True)
+            yield ServerSentEvent(data=json.dumps({"error": str(e)}), event="error")
+
+    return EventSourceResponse(event_generator())

acuity/runtime/_datalet_router.py

@@ -0,0 +1,108 @@
+from openai.types.responses import ResponseTextDeltaEvent, ResponseOutputItemDoneEvent, ResponseOutputMessage, ResponseCompletedEvent, ResponseFunctionToolCall
+from fastapi import APIRouter, Request
+from openai import AsyncOpenAI
+import json
+import logging
+from sse_starlette.sse import EventSourceResponse, ServerSentEvent
+import os
+from acuity.app import app
+
+logger = logging.getLogger(__name__)
+
+datalet_router = APIRouter()
+
+@datalet_router.get("/{datalet_id}/config")
+async def datalet_config(datalet_id: str, request: Request):
+    datalet = app.datalet_by_id(datalet_id)
+    if datalet is not None:
+        return datalet.metadata()
+    else:
+        return {"error": "Datalet not found"}
+
+@datalet_router.get("/{datalet_id}/data")
+async def datalet_data_fetch(datalet_id: str, request: Request):
+    datalet = app.datalet_by_id(datalet_id)
+    if datalet is not None:
+        return datalet.fetch_data()
+    else:
+        return {"error": "Datalet not found"}
+
+@datalet_router.get("/{datalet_id}/data/{item_id}/fetch")
+async def datalet_data_item_fetch(datalet_id: str, item_id: str, request: Request):
+    datalet = app.datalet_by_id(datalet_id)
+    if datalet is not None:
+        try:
+            handler = datalet.fetch_item_data(item_id)
+        except RuntimeError as e:
+            return {"error": str(e)}
+        return handler()
+    else:
+        return {"error": "Datalet not found"}
+
+@datalet_router.post("/{datalet_id}/data/synch")
+async def datalet_data_synch(datalet_id: str, request: Request):
+    pass
+
+@datalet_router.post("/{datalet_id}/data/stream")
+async def datalet_data_stream(datalet_id: str, request: Request):
+
+    async def event_generator():
+
+        body = await request.json()
+        logger.info("Received question: %s", body["userPrompt"])
+
+        base_url = "https://1276122062834378.8.gcp.databricks.com/serving-endpoints"
+        model_name = "mas-e00a6b00-endpoint"
+
+        token = os.environ.get("DATABRICKS_TOKEN")
+        logger.debug("DATABRICKS_TOKEN is %s", "set" if token else "not set")
+
+        client = AsyncOpenAI(
+            api_key=token,
+            base_url=f"{base_url}"
+        )
+
+        logger.info("Sending request to %s/%s/invocations for model %s...", base_url, model_name, model_name)
+
+        try:
+
+            response = await client.responses.create(
+                    model=model_name,
+                    input=[
+                        {
+                            "role": "user",
+                            "content": body["userPrompt"]
+                        }
+                    ],
+                    stream=True,
+                    extra_body={
+                        "databricks_options": {
+                            "return_trace": True
+                        }
+                    }
+            )
+
+            async for chunk in response:
+                logger.debug("Chunk: %s", chunk)
+                if isinstance(chunk, ResponseTextDeltaEvent):
+                    event_type = "delta"
+                elif isinstance(chunk, ResponseOutputItemDoneEvent) and isinstance(chunk.item, ResponseOutputMessage):
+                    if chunk.item.content[0].text.startswith("<name>"):
+                        event_type = "agent_router_message"
+                    else:
+                        event_type = "output_message"
+                elif isinstance(chunk, ResponseOutputItemDoneEvent) and isinstance(chunk.item, ResponseFunctionToolCall):
+                    event_type = "function_call"
+                elif isinstance(chunk, ResponseCompletedEvent):
+                    event_type = "completed"
+                    logger.info("Completed event received")
+                else:
+                    event_type = "other"
+
+                yield ServerSentEvent(data=json.dumps(chunk.model_dump()), event=event_type)
+
+        except Exception as e:
+            logger.error("Error during request: %s", e, exc_info=True)
+            yield ServerSentEvent(data=json.dumps({"error": str(e)}), event="error")
+
+    return EventSourceResponse(event_generator())

acuity/runtime/_engine.py

@@ -0,0 +1,144 @@
+import os
+from typing import Optional
+import logging
+import uvicorn
+import importlib.util
+from pathlib import Path
+from fastapi import FastAPI, Request
+from fastapi.staticfiles import StaticFiles
+from fastapi.responses import HTMLResponse, FileResponse, JSONResponse
+from starlette.exceptions import HTTPException
+from starlette.datastructures import Headers
+from starlette.responses import Response
+from starlette.types import Scope
+from fastapi.templating import Jinja2Templates
+from acuity.app import app
+from watchfiles import run_process
+from acuity.model._app import _ImageType
+from acuity.runtime._ai_router import ai_router
+from acuity.runtime._datalet_router import datalet_router
+from acuity.runtime._stream_router import events_router
+
+logger = logging.getLogger(__name__)
+
+def _run_app(file_path: str, port: int):
+    """
+    Helper function to run the acuity application.
+    This is used by watchfiles.run_process to support auto-reload.
+    """
+    engine = Engine()
+    engine.run(file_path, port=port)
+
+
+# --- Static Files Setup ---
+package_root = Path(__file__).parent
+static_dir = os.path.join(package_root, "static")
+os.makedirs(static_dir, exist_ok=True)
+
+# Mounted last: it matches every path, so it would shadow the API routers and
+# the /mas mount above.
+
+class Engine:
+
+    def __init__(self):
+        self.router_app = FastAPI()
+        self.router_app.include_router(router=ai_router, prefix="/ai")
+        self.router_app.include_router(router=datalet_router, prefix="/datalet")
+        self.router_app.include_router(router=events_router, prefix="/stream")
+        pass
+
+    def _provision_app_routes(self):
+        @self.router_app.get("/app/config")
+        async def api_sample():
+            return app.model_dump()
+
+        @self.router_app.get("/page/{page_id}")
+        async def get_page(page_id: str):
+            if page_id in app._pages:
+                return app._pages[page_id].model_dump()
+            return {"error": "Page not found"}
+
+        pass
+
+    
+
+    def _run_server(self, file_path: str, port: int = 8000):
+
+        self._provision_app_routes()
+
+        """Run a Python file as a FastAPI application."""
+        spec = importlib.util.spec_from_file_location("app_module", file_path)
+        module = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(module)
+
+
+        # Mount static files and templates
+        self.router_app.mount("/static", StaticFiles(directory=static_dir), name="static")
+        templates = Jinja2Templates(directory=str(package_root / "templates"))
+
+        @self.router_app.get("/", response_class=HTMLResponse)
+        async def read_root(request: Request):
+            return templates.TemplateResponse("index.html", {
+                "title": app.title,
+                "request": request,
+            })
+
+        # Determine the directory of the file being run
+        app_dir = Path(file_path).parent.resolve()
+
+        # image fetching route
+        @self.router_app.get("/image/generic/{image_name}")
+        async def fetch_images(image_name: Optional[str]):
+            image_path = app.image_registry()[image_name]
+            image_abs_path = app_dir / image_path
+            if image_abs_path.exists() and image_abs_path.suffix.lower() in [".png", ".svg"]:
+                return FileResponse(image_abs_path)
+
+            return {"error": "Image not found"}
+
+        # image fetching route
+        @self.router_app.get("/image/{image_type}")
+        async def fetch_images(image_type: _ImageType):
+
+            if image_type not in _ImageType or image_type == _ImageType.GENERIC:
+                return {"error": f"Invalid image type {image_type}"}
+
+            try:
+                image_path = app.image_path(image_type)
+            except ValueError:
+                return {"error": f"Image type {image_type} not found"}
+
+            image_abs_path = app_dir / image_path
+            if image_abs_path.exists() and image_abs_path.suffix.lower() in [".png", ".svg"]:
+                return FileResponse(image_abs_path)
+
+            return {"error": "Image not found"}
+
+        # Register routes from the runtime
+        if hasattr(module, 'runtime'):
+            for path, handler in module.runtime.routes.items():
+                self.router_app.get(path)(handler)
+
+        # SPA fallback: browser navigations to any unknown path (client-side
+        # router pages) are served the "/" page. API/static clients that don't
+        # ask for HTML still get the regular 404.
+        @self.router_app.exception_handler(404)
+        async def spa_fallback(request: Request, exc: HTTPException):
+            if request.method == "GET" and "text/html" in request.headers.get("accept", ""):
+                return templates.TemplateResponse("index.html", {
+                    "title": app.title,
+                    "request": request,
+                })
+            return JSONResponse({"detail": exc.detail}, status_code=404)
+
+        # Run the application
+        uvicorn.run(self.router_app, host="0.0.0.0", port=port)
+
+    def run(self, file_path: str, port: int = 8000):
+        """Run a Python file as a FastAPI application."""
+        self._run_server(file_path, port=port)
+
+    def watch(self, file_path: str, port: int = 8000):
+        """Run a Python file as a FastAPI application in watch mode with auto-reload."""
+        run_process(Path(file_path).parent, target=_run_app, args=(file_path, port))
+   

acuity/runtime/_stream_router.py

@@ -0,0 +1,60 @@
+from fastapi import APIRouter, Request
+import json
+import logging
+
+from sse_starlette import EventSourceResponse
+from sse_starlette.sse import EventSourceResponse, ServerSentEvent
+import os
+import time
+import random
+from acuity.runtime.stream._stream_handler import registry
+
+logger = logging.getLogger(__name__)
+
+events_router = APIRouter()
+
+
+@events_router.get("/demo")
+async def event_dispatcher(request: Request) -> EventSourceResponse:
+    def event_generator():
+        logger.info("Sending events ...")
+        try:
+            while True:
+                time.sleep(random.uniform(0.1, 1.0))
+                yield ServerSentEvent(data=json.dumps({"content": "dummy"}))
+        except Exception as e:
+            logger.error("Error during request: %s", e, exc_info=True)
+            yield ServerSentEvent(data=json.dumps({"error": str(e)}), event="error")
+    return EventSourceResponse(event_generator())
+
+
+@events_router.get("/channel/{channel_name}")
+async def channel_stream(channel_name: str, request: Request) -> EventSourceResponse:
+    ch = registry.get_or_create(channel_name)
+
+    if not ch:
+        return EventSourceResponse({"error": f"Channel {channel_name} not found"}, status_code=404)
+
+    async def event_generator():
+        q = ch._subscribe()
+        logger.info("Subscribing to channel %s", channel_name)
+        try:
+            while True:
+                if await request.is_disconnected():
+                    logger.info("Request disconnected")
+                    break
+                try:
+                    logger.debug("Waiting for data on channel %s ...", channel_name)
+                    data = await q.get()
+                    logger.debug("Received data: %s", data)
+                    yield ServerSentEvent(
+                        data=json.dumps(data),
+                        event=channel_name,
+                    )
+                except Exception as e:
+                    yield ServerSentEvent(data=json.dumps({"error": str(e)}), event="error")
+                    break
+        finally:
+            ch._unsubscribe(q)
+
+    return EventSourceResponse(event_generator())

acuity/runtime/storage/__init__.py

@@ -0,0 +1,4 @@
+from acuity.runtime.storage._model import LakebaseModel
+from acuity.runtime.storage._client import LakebaseClient
+
+__all__ = ["LakebaseModel", "LakebaseClient"]

acuity/runtime/storage/_client.py

@@ -0,0 +1,132 @@
+from __future__ import annotations
+
+import logging
+import uuid
+from typing import Any, Sequence, Type, TypeVar
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker
+from databricks_ai_bridge.lakebase import AsyncLakebaseSQLAlchemy
+from acuity.runtime.storage._model import LakebaseModel
+
+logger = logging.getLogger(__name__)
+
+T = TypeVar("T", bound=LakebaseModel)
+
+
+class LakebaseClient:
+    """Async ORM client for Databricks Lakebase.
+
+    Wraps :class:`AsyncLakebaseSQLAlchemy` and exposes CRUD helpers that
+    operate on :class:`LakebaseModel` subclasses.
+
+    Example::
+
+        async with LakebaseClient(instance_name="my-lakebase") as db:
+            await db.initialize()
+            user = User(name="Alice", email="alice@example.com")
+            await db.create(user)
+            found = await db.get(User, user.id)
+    """
+
+    def __init__(
+        self,
+        *,
+        instance_name: str | None = None,
+        autoscaling_endpoint: str | None = None,
+        project: str | None = None,
+        branch: str | None = None,
+        schema: str | None = None,
+        **engine_kwargs: Any,
+    ) -> None:
+
+
+        self._lakebase = AsyncLakebaseSQLAlchemy(
+            instance_name=instance_name,
+            autoscaling_endpoint=autoscaling_endpoint,
+            project=project,
+            branch=branch,
+            schema=schema,
+            **engine_kwargs,
+        )
+        self._session_factory = async_sessionmaker(
+            self._lakebase.engine,
+            class_=AsyncSession,
+            expire_on_commit=False,
+        )
+        logger.info("LakebaseClient initialized")
+
+    # ------------------------------------------------------------------
+    # Lifecycle
+    # ------------------------------------------------------------------
+
+    async def initialize(self) -> None:
+        """Create the schema (if configured) and all registered tables."""
+        await self._lakebase.create_schema()
+        async with self._lakebase.engine.begin() as conn:
+            await conn.run_sync(LakebaseModel.metadata.create_all)
+        logger.info("Database tables initialized")
+
+    async def close(self) -> None:
+        """Dispose the underlying engine and release connections."""
+        await self._lakebase.engine.dispose()
+        logger.info("LakebaseClient closed")
+
+    async def __aenter__(self) -> LakebaseClient:
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb) -> bool:
+        await self.close()
+        return False
+
+    # ------------------------------------------------------------------
+    # CRUD operations
+    # ------------------------------------------------------------------
+
+    async def create(self, obj: T) -> T:
+        """Insert a new model instance and return it with server-set fields populated."""
+        async with self._session_factory() as session:
+            session.add(obj)
+            await session.commit()
+            await session.refresh(obj)
+        logger.debug("Created %s id=%s", type(obj).__name__, obj.id)
+        return obj
+
+    async def get(self, model_cls: Type[T], id: uuid.UUID) -> T | None:
+        """Fetch a single record by primary key, or ``None`` if not found."""
+        async with self._session_factory() as session:
+            result = await session.get(model_cls, id)
+        return result
+
+    async def get_all(self, model_cls: Type[T], **filters: Any) -> Sequence[T]:
+        """Fetch all records of *model_cls*, optionally filtered by column values.
+
+        Example::
+
+            users = await db.get_all(User, name="Alice")
+        """
+        async with self._session_factory() as session:
+            stmt = select(model_cls)
+            for attr, value in filters.items():
+                stmt = stmt.where(getattr(model_cls, attr) == value)
+            result = await session.execute(stmt)
+            return result.scalars().all()
+
+    async def update(self, obj: T) -> T:
+        """Merge changes from *obj* back into the database."""
+        async with self._session_factory() as session:
+            merged = await session.merge(obj)
+            await session.commit()
+            await session.refresh(merged)
+        logger.debug("Updated %s id=%s", type(obj).__name__, obj.id)
+        return merged
+
+    async def delete(self, model_cls: Type[T], id: uuid.UUID) -> bool:
+        """Delete a record by primary key. Returns ``True`` if a row was deleted."""
+        async with self._session_factory() as session:
+            obj = await session.get(model_cls, id)
+            if obj is None:
+                return False
+            await session.delete(obj)
+            await session.commit()
+        logger.debug("Deleted %s id=%s", model_cls.__name__, id)
+        return True