acUIty-core 0.2.0__py3-none-any.whl

acuity/__init__.py

@@ -0,0 +1,81 @@
+## acuity
+import asyncio
+import logging
+import os
+from typing import Optional
+
+from acuity.model import DataletType
+from acuity.app import app
+from acuity.model._lucide import LucideIconName
+from acuity.datalets.form._Form import _Form
+from acuity.datalets.cards._CardGrid import _CardGrid
+from acuity.datalets._Mock import _Mock
+from acuity.runtime.stream._stream_handler import channel, Channel
+
+logging.basicConfig(
+    level=getattr(logging, os.environ.get("ACUITY_LOG_LEVEL", "INFO").upper(), logging.INFO),
+    format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
+)
+
+
+
+def title(value: str):
+    app.title = value
+
+def description(value: str):
+    app.description = value
+
+def hideBreadcrumb():
+    app.breadcrumb_visible = False
+
+def logo(image_path: str):
+    app.setup_logo(image_path)
+
+def load_image(image_name: str, image_path: str):
+    app.load_image(image_name, image_path)
+
+def create_page(menu_title: str, route_path: str, icon: Optional[LucideIconName] = "Box"):
+    return app.new_page(menu_title, route_path, icon=icon)
+
+async def push_event(channel_name: str, data: dict):
+    ch = channel(channel_name)
+    await ch.push(data)
+
+def push_event_sync(channel_name: str, data: dict):
+    loop = asyncio.get_event_loop()
+    asyncio.run_coroutine_threadsafe(push_event(channel_name, data), loop)
+
+def create_datalet(datalet_type: DataletType):
+    return app.new_datalet(datalet_type)
+
+def new_mock():
+    mock = _Mock()
+    app._add_datalet(mock)
+    return mock
+
+def new_form(model=None, **kwargs):
+    """Create a form datalet; `model` is a pydantic class with Annotated form field markers."""
+    form = _Form(model, **kwargs)
+    app._add_datalet(form)
+    return form
+
+def new_card_grid(**kwargs):
+    """Create a card grid datalet; the `@dl.data()` handler returns a list of `CardItem`."""
+    grid = _CardGrid(**kwargs)
+    app._add_datalet(grid)
+    return grid
+
+__all__ = [
+    "title",
+    "description",
+    "hideBreadcrumb",
+    "logo",
+    "load_image",
+    "create_page",
+    "push_event_sync",
+    "create_datalet",
+    "new_form",
+    "new_card_grid",
+    "new_mock",
+    "DataletType"
+]

acuity/__main__.py

@@ -0,0 +1,19 @@
+# __main__.py
+import click
+
+from . import commands
+
+@click.group()
+def cli():
+    pass
+
+cli.add_command(commands.run)
+cli.add_command(commands.watch)
+cli.add_command(commands.add)
+cli.add_command(commands.sub)
+cli.add_command(commands.mul)
+cli.add_command(commands.div)
+
+# enables module to be run as a script
+if __name__ == "__main__":
+    cli()

acuity/app/__init__.py

@@ -0,0 +1,5 @@
+from acuity.model import App, DataletType
+
+app = App()
+
+__all__ = ["app"]

acuity/app/datalets/__init__.py

@@ -0,0 +1,4 @@
+from ._chat_container import _new_chat_container as new_chat_container
+from ._empty import _new_empty as new_empty
+
+__all__ = ["new_chat_container", "new_empty"]

acuity/app/datalets/_chat_container.py

@@ -0,0 +1,3 @@
+def _new_chat_container():
+    pass
+

acuity/app/datalets/_empty.py

@@ -0,0 +1,4 @@
+from acuity.model import Datalet
+
+def _new_empty():
+    return Datalet()

acuity/commands.py

@@ -0,0 +1,43 @@
+# commands.py
+
+import click
+from acuity import runtime
+
+
+@click.command(help="Run acuity App")
+@click.option("--port", default=8000, help="Port to run the app on.")
+@click.argument("file_path", type=click.Path(exists=True))
+def run(file_path, port):
+    runtime.run(file_path, port=port)
+    pass
+
+@click.command(help="Watch acuity App")
+@click.option("--port", default=8000, help="Port to watch the app on.")
+@click.argument("file_path", type=click.Path(exists=True))
+def watch(file_path, port):
+    runtime.watch(file_path, port=port)
+    pass
+
+@click.command(help="Add two numbers.")
+@click.argument("a", type=click.FLOAT)
+@click.argument("b", type=click.FLOAT)
+def add(a, b):
+    click.echo(a + b)
+
+@click.command(help="Subtract two numbers.")
+@click.argument("a", type=click.FLOAT)
+@click.argument("b", type=click.FLOAT)
+def sub(a, b):
+    click.echo(a - b)
+
+@click.command(help="Multiply two numbers.")
+@click.argument("a", type=click.FLOAT)
+@click.argument("b", type=click.FLOAT)
+def mul(a, b):
+    click.echo(a * b)
+
+@click.command(help="Divide two numbers.")
+@click.argument("a", type=click.FLOAT)
+@click.argument("b", type=click.FLOAT)
+def div(a, b):
+    click.echo(a / b)

acuity/datalets/_Mock.py

@@ -0,0 +1,15 @@
+from typing import Dict, Any
+
+from acuity.model._datalet import _Datalet, _DataletType
+
+
+class _Mock(_Datalet):
+
+    def __init__(self):
+        super().__init__(_DataletType.MOCK)
+
+    def metadata(self) -> Dict[str, Any]:
+        return {
+            "name": "Mock",
+            "description": "A mock datalet for testing purposes.",
+        }

acuity/datalets/cards/_CardGrid.py

@@ -0,0 +1,20 @@
+from typing import Any, Dict, List
+from acuity.model._datalet import _Datalet, _DataletType
+from acuity.datalets.cards._model import _CardItem
+
+
+class _CardGrid(_Datalet[List[_CardItem]]):
+    """Python binder of the CardGrid datalet; the data handler returns the list of cards."""
+
+    title: str = ""
+
+    def __init__(self, title: str = ""):
+        super().__init__(_DataletType.CARD_GRID)
+        self.title = title
+
+    def with_title(self, title: str) -> "_CardGrid":
+        self.title = title
+        return self
+
+    def metadata(self) -> Dict[str, Any]:
+        return {"title": self.title}

acuity/datalets/cards/__init__.py

@@ -0,0 +1,6 @@
+from acuity.datalets.cards._model import (
+    _CardItem as CardItem,
+    _CardKpi as CardKpi,
+)
+
+__all__ = ["CardItem", "CardKpi"]

acuity/datalets/cards/_model.py

@@ -0,0 +1,18 @@
+from typing import List, Optional, Union
+from pydantic import BaseModel, Field
+
+
+class _CardKpi(BaseModel):
+    label: str
+    value: Union[str, int, float]
+    trend: Optional[float]
+
+
+class _CardItem(BaseModel):
+    """Card shown by the CardGrid datalet (mirrors CardItem in CardsContainer.svelte)."""
+    id: Optional[Union[str, int]] = None
+    title: str
+    description: Optional[str] = None
+    image: Optional[str] = None
+    kpis: List[_CardKpi] = Field(default_factory=list)
+    tags: List[str] = Field(default_factory=list)

acuity/datalets/form/_Form.py

@@ -0,0 +1,143 @@
+from typing import Any, Dict, List, Optional, Type
+from pydantic import BaseModel, Field
+from pydantic_core import PydanticUndefined
+from acuity.model._datalet import _Datalet, _DataletType
+from acuity.datalets.form._markers import FormField, Group
+
+
+class _Form(_Datalet[BaseModel]):
+    """Datalet describing a form; `to_json()` yields the same structure as
+    web/stories/bricks/organisms/forms/metadata.ts (fluent/functional builder)."""
+
+    title: str = ""
+    abstract: str = ""
+    lock_unlock: bool = False
+    tabs: List[Any] = Field(default_factory=list)
+    defaults: Dict[str, Any] = Field(default_factory=dict)
+    validation_schema: Dict[str, Any] = Field(default_factory=dict)
+    groups: List[Dict[str, Any]] = Field(default_factory=list)
+    submit_label: Optional[str] = None
+    cancel_label: Optional[str] = None
+
+    def __init__(self, model: Optional[Type[BaseModel]] = None, title: str = "", abstract: str = "",
+                 lock_unlock: bool = False):
+        """Create a form, optionally from a pydantic class whose fields are annotated with
+        `acuity.datalets._form` markers, e.g. `domain: Annotated[str, Select(group="target")]`.
+        Fields without a marker are ignored; field defaults become form defaults."""
+        super().__init__(_DataletType.FORM)
+        self.title = title
+        self.abstract = abstract
+        self.lock_unlock = lock_unlock
+        if model is not None:
+            self.from_model(model)
+
+    def from_model(self, model: Type[BaseModel]) -> "_Form":
+        for name, info in model.model_fields.items():
+            group = next((m for m in info.metadata if isinstance(m, Group)), None)
+            gtype = info.annotation
+            if group is not None and isinstance(gtype, type) and issubclass(gtype, BaseModel):
+                gname = group.name or name
+                self.add_group(gname, group.title, group.description)
+                self._from_fields(gtype, gname)
+        self._from_fields(model, None)
+        return self
+
+    def _from_fields(self, model: Type[BaseModel], group: Optional[str]) -> None:
+        for name, info in model.model_fields.items():
+            marker = next((m for m in info.metadata if isinstance(m, FormField)), None)
+            if marker is None:
+                continue
+            gname = group if group is not None else marker.group
+            self.add_field(
+                gname, name, type=marker.type, label=marker.label, placeholder=marker.placeholder,
+                cols=marker.cols, options=getattr(marker, "options", None), attributes=marker.attributes,
+                remote=marker.remote, depends_on=marker.depends_on, params=marker.params)
+            if info.default is not PydanticUndefined and info.default is not None:
+                self.with_defaults(gname, {name: info.default})
+
+    def with_title(self, title: str) -> "_Form":
+        self.title = title
+        return self
+
+    def with_abstract(self, abstract: str) -> "_Form":
+        self.abstract = abstract
+        return self
+
+    def with_lock_unlock(self, value: bool = True) -> "_Form":
+        self.lock_unlock = value
+        return self
+
+    def withSubmitLabel(self, label: str) -> "_Form":
+        self.submit_label = label
+        return self
+
+    def withCancelLabel(self, label: str) -> "_Form":
+        self.cancel_label = label
+        return self
+
+    def with_defaults(self, group: str, values: Dict[str, Any]) -> "_Form":
+        self.defaults.setdefault(group, {}).update(values)
+        return self
+
+    def with_validation_schema(self, schema: Dict[str, Any]) -> "_Form":
+        self.validation_schema = schema
+        return self
+
+    def add_group(self, name: str, title: Optional[str] = None, description: str = "",
+                  fields: Optional[List[Dict[str, Any]]] = None) -> "_Form":
+        self.groups.append({
+            "name": name,
+            "title": title if title is not None else name,
+            "description": description,
+            "fields": list(fields or []),
+        })
+        return self
+
+    def add_field(self, group: str, name: str, type: str = "text", label: Optional[str] = None,
+                  placeholder: str = "", cols: int = 2, options: Optional[List[Dict[str, Any]]] = None,
+                  attributes: Optional[Dict[str, Any]] = None, remote: Optional[bool] = None,
+                  depends_on: Optional[List[str]] = None, params: Optional[List[str]] = None) -> "_Form":
+        field: Dict[str, Any] = {
+            "name": name,
+            "type": type,
+            "label": label if label is not None else name,
+            "placeholder": placeholder,
+            "cols": cols,
+        }
+        if options is not None:
+            field["options"] = options
+        if attributes is not None:
+            field["attributes"] = attributes
+        if remote is not None:
+            field["remote"] = remote
+        if depends_on is not None:
+            field["dependsOn"] = depends_on
+        if params is not None:
+            field["params"] = params
+
+        target = next((g for g in self.groups if g["name"] == group), None)
+        if target is None:
+            self.add_group(group)
+            target = self.groups[-1]
+        target["fields"].append(field)
+        return self
+
+    def metadata(self) -> Dict[str, Any]:
+        """Return the form metadata structure expected by the web Form brick."""
+        meta: Dict[str, Any] = {
+            "title": self.title,
+            "abstract": self.abstract,
+            "lockUnlock": self.lock_unlock,
+            "tabs": list(self.tabs),
+            "validationSchema": self.validation_schema,
+            "groups": self.groups,
+        }
+        actions: Dict[str, Any] = {}
+        if self.submit_label is not None:
+            actions["submitLabel"] = self.submit_label
+        if self.cancel_label is not None:
+            actions["cancelLabel"] = self.cancel_label
+        if actions:
+            meta["actions"] = actions
+        return meta
+

acuity/datalets/form/__init__.py

@@ -0,0 +1,10 @@
+from acuity.datalets.form._markers import (
+    Group, FormField, Text, Email, Secret, Number, Date, DateTime, TextArea, Select, Combo, MultiCombo,
+)
+
+from acuity.datalets.form._model import (
+    _FormItemOption as FormItemOption,
+)
+
+__all__ = ["Group", "FormField", "Text", "Email", "Secret", "Number", "Date", "DateTime",
+           "TextArea", "Select", "Combo", "MultiCombo", "FormItemOption"]

acuity/datalets/form/_markers.py

@@ -0,0 +1,82 @@
+from dataclasses import dataclass, field
+from typing import Any, ClassVar, Dict, List, Optional
+
+from acuity.datalets.form._model import _FormItemOption
+
+
+@dataclass(frozen=True)
+class Group:
+    """`Annotated` marker declaring a form group. The annotated type is a pydantic class whose
+    fields carry `FormField` markers, e.g. `user: Annotated[User, Group('user', 'User', 'who')]`.
+    `name` defaults to the attribute name and `title` to the name."""
+    name: Optional[str] = None
+    title: Optional[str] = None
+    description: str = ""
+
+
+@dataclass(frozen=True)
+class FormField:
+    """Base `Annotated` marker describing a form field (see metadata.ts)."""
+    type: ClassVar[str] = "text"
+    label: Optional[str] = None
+    placeholder: str = ""
+    cols: int = 2
+    attributes: Optional[Dict[str, Any]] = None
+    remote: Optional[bool] = None
+    depends_on: Optional[List[str]] = None
+    params: Optional[List[str]] = None
+
+
+@dataclass(frozen=True)
+class Text(FormField):
+    type: ClassVar[str] = "text"
+
+
+@dataclass(frozen=True)
+class Email(FormField):
+    type: ClassVar[str] = "email"
+
+
+@dataclass(frozen=True)
+class Secret(FormField):
+    type: ClassVar[str] = "secret"
+
+
+@dataclass(frozen=True)
+class Number(FormField):
+    type: ClassVar[str] = "number"
+
+
+@dataclass(frozen=True)
+class Date(FormField):
+    type: ClassVar[str] = "date"
+
+
+@dataclass(frozen=True)
+class DateTime(FormField):
+    type: ClassVar[str] = "datetime"
+
+
+@dataclass(frozen=True)
+class TextArea(FormField):
+    type: ClassVar[str] = "textarea"
+    cols: int = 4
+
+
+@dataclass(frozen=True)
+class Select(FormField):
+    type: ClassVar[str] = "select"
+    options: Optional[List[_FormItemOption]] = None
+
+
+@dataclass(frozen=True)
+class Combo(Select):
+    type: ClassVar[str] = "combo"
+
+
+@dataclass(frozen=True)
+class MultiCombo(Select):
+    type: ClassVar[str] = "multicombo"
+
+
+FIELD_MARKERS = (Text, Email, Secret, Number, Date, DateTime, TextArea, Select, Combo, MultiCombo)

acuity/datalets/form/_model.py

@@ -0,0 +1,10 @@
+from pydantic import BaseModel
+
+
+class _FormItemOption(BaseModel):
+    value: str
+    label: str
+
+
+class FormI:
+    pass

acuity/model/__init__.py

@@ -0,0 +1,6 @@
+# acuity app singleton
+from ._app import _App as App
+from ._datalet import _Datalet as Datalet
+from ._datalet import _DataletType as DataletType
+
+__all__ = ["Datalet", "App", "DataletType"]

acuity/model/_agen_resp_chunk.py

@@ -0,0 +1,7 @@
+from pydantic import BaseModel
+
+
+class AgentRespChunk(BaseModel):
+    type: str
+    id: str
+    item_id: str

acuity/model/_app.py

@@ -0,0 +1,104 @@
+## acuity app properties modifiers
+from enum import Enum
+from typing import Any
+
+from pydantic import BaseModel, PrivateAttr, computed_field
+from acuity.model._lucide import LucideIconName
+from acuity.model._datalet import _Datalet, _DataletType
+from acuity.model._page import _Page
+import uuid
+
+class _ImageType(Enum):
+    LOGO = "logo"
+    FAVICON = "favicon"
+    BANNER = "banner"
+    GENERIC  = "generic"
+
+class _App(BaseModel):
+    """App class represents the main application configuration and properties.
+    Handles core application settings and validates their values.
+    """
+    title: str = "acUIty App"
+    description: str = "lorem ipsum"
+    breadcrumb_visible: bool = True
+
+    _datalets: dict[str, _Datalet] = {}
+    _pages: dict[str, _Page] = {}
+    _images: dict[_ImageType, Any] = {
+        _ImageType.LOGO: None,
+        _ImageType.FAVICON: None,
+        _ImageType.BANNER: None,
+        _ImageType.GENERIC: {}
+    }
+
+    def datalet_by_id(self, datalet_id: str):
+        return self._datalets[datalet_id]
+
+    @computed_field
+    @property
+    def datalets(self) -> list[_Datalet]:
+        """Returns the list of datalets from the internal datalets dictionary."""
+        return [datalet.model_dump() for datalet in self._datalets.values()]
+
+    @computed_field
+    @property
+    def pages(self) -> list[_Page]:
+        """Returns the list of pages from the internal pages dictionary."""
+        return [page.model_dump(exclude={'panels'}) for page in self._pages.values()]
+    
+    @computed_field
+    @property
+    def images(self) -> dict[str, str | dict[str, str]]:
+        """Returns the icons dictionary with transformed image paths."""
+        result = {}
+        for key, value in self._images.items():
+            if key == _ImageType.LOGO:
+                result["logo"] = "/image/logo"
+            elif key == _ImageType.FAVICON:
+                result["favicon"] = "/image/favicon"
+            elif key == _ImageType.BANNER:
+                result["banner"] = "/image/banner"
+            elif key == _ImageType.GENERIC:
+                result["generic"] = {
+                    image_name: f"/image/generic/{image_name}"
+                    for image_name in value.keys()
+                }
+        return result
+
+    def new_page(self, title: str, route_path: str, icon: LucideIconName) -> _Page:
+        """Create a new page with the given name and return it."""
+
+        page_id = f"page_{uuid.uuid4().hex[:8]}"
+
+        page = _Page(page_id=page_id, title=title, route_path=route_path, icon=icon)
+        self._pages[page_id] = page
+        return page
+
+    def _add_datalet(self, datalet: _Datalet) -> _Datalet:
+        datalet_id = datalet.id
+        self._datalets[datalet_id] = datalet
+        return datalet
+
+    def new_datalet(self, datalet_type: _DataletType) -> _Datalet:
+        """Create a new datalet with the given type."""
+
+        datalet_id = f"datalet_{uuid.uuid4().hex[:8]}"
+
+        datalet = _Datalet(datalet_id=datalet_id, datalet_type=datalet_type)
+        self._datalets[datalet_id] = datalet
+        return datalet
+
+    def load_image(self, image_name: str, image_path: str):
+        self._images[_ImageType.GENERIC][image_name] = image_path
+
+    def setup_logo(self, image_path):
+        self._images[_ImageType.LOGO] = image_path
+
+    def image_registry(self) -> dict[str, str]:
+        return self._images[_ImageType.GENERIC]
+
+    def image_path(self, image_type: _ImageType) -> str:
+        if image_type == _ImageType.GENERIC:
+            raise ValueError(f"a single image path by image type {image_type} cannot be retrieved")
+        return self._images[image_type]
+

acuity/model/_datalet.py

@@ -0,0 +1,77 @@
+import uuid
+from enum import Enum
+from typing import Optional, Callable, Dict, Any, Generic, TypeVar
+from abc import ABC, abstractmethod
+import json
+
+from pydantic import BaseModel, PrivateAttr
+
+T = TypeVar("T", bound=BaseModel)
+
+class _DataletType(Enum):
+    MOCK = "Mock"
+    CHAT_CONTAINER = "ChatContainer"
+    FORM = "Form"
+    CARD_GRID = "CardGrid"
+
+class _Datalet(BaseModel, ABC, Generic[T]):
+    """Base datalet. Subclasses parametrize it with the data model type,
+    e.g. `class _Chart(_Datalet[ChartData])`."""
+    id: str
+    datalet_type: _DataletType
+    _data_handler: Optional[Callable[..., T]] = PrivateAttr(default=None)
+    _item_data_handlers: Dict[str, Callable[..., Any]] = PrivateAttr(default_factory=dict)
+
+    def __init__(self, datalet_type: _DataletType):
+        """Initialize a new Datalet instance.
+        """
+        datalet_id = f"datalet_{uuid.uuid4().hex[:8]}"
+        super().__init__(id=datalet_id, datalet_type=datalet_type)
+
+    @abstractmethod
+    def metadata(self) -> Dict[str, Any]:
+        return {}
+
+    def metadata_json(self, indent: int = 2) -> str:
+        return json.dumps(self.metadata(), indent=indent)
+
+    def data(self) -> Callable[[Callable[..., T]], Callable[..., T]]:
+        """Decorator factory registering the decorated function as the data fetch
+        handler of this datalet. The function must return the datalet's data model `T`.
+        """
+
+        def decorator(func: Callable[..., T]) -> Callable[..., T]:
+            self._data_handler = func
+            return func
+
+        return decorator
+
+    def item_data(self, field: str) -> Callable[[Callable[..., Any]], Callable[..., Any]]:
+        """Decorator factory registering the decorated function as the data item
+        handler of the field identified as `<group>.<name>`.
+        """
+
+        def decorator(func: Callable[..., Any]) -> Callable[..., Any]:
+            self._item_data_handlers[field] = func
+            return func
+
+        return decorator
+
+    def fetch_item_data(self, field: str) -> Callable[..., Any]:
+        """Return the data item handler registered for the field identified as
+        `<group>.<name>`."""
+        handler = self._item_data_handlers.get(field)
+        if handler is None:
+            raise RuntimeError(f"No item data handler registered for {field} in {self.id}")
+        return handler
+
+    def fetch_data(self, *args: Any, **kwargs: Any) -> T:
+        """Invoke the registered data handler."""
+        if self._data_handler is None:
+            raise RuntimeError(f"No data handler registered for {self.id}")
+        return self._data_handler(*args, **kwargs)
+
+
+
+
+