astralprims 0.1.0__py3-none-any.whl

astralprims/__init__.py

@@ -0,0 +1,115 @@
+"""Astral Primitives — composable, serializable UI primitives for Python.
+
+    >>> from astralprims import Button
+    >>> Button(label="Click me", action="open",
+    ...        css={"background-color": "white", "color": "#000000"}).to_dict()
+    {'type': 'button', 'css': {'background-color': 'white', 'color': '#000000'}, 'label': 'Click me', 'action': 'open', 'payload': {}, 'variant': 'primary'}
+"""
+
+from .base import CSS, Primitive
+from .primitives import (
+    Alert,
+    Audio,
+    BarChart,
+    Button,
+    Card,
+    ChartDataset,
+    CodeBlock,
+    Collapsible,
+    ColorPicker,
+    Container,
+    Divider,
+    FileDownload,
+    FileUpload,
+    Grid,
+    Grids,
+    Image,
+    Input,
+    LineChart,
+    List_,
+    MetricCard,
+    ParamPicker,
+    PieChart,
+    PlotlyChart,
+    ProgressBar,
+    Table,
+    Tabs,
+    TabItem,
+    Text,
+    ThemeApply,
+)
+from .response import create_ui_response
+
+from typing import Annotated, Union
+
+from pydantic import Field as _Field, TypeAdapter
+
+from .base import _REGISTRY
+
+__version__ = "0.1.0"
+
+
+def _build_union():
+    """Build a discriminated union + TypeAdapter over all registered primitives.
+
+    Used for validating/parsing arbitrary primitive payloads and for generating
+    a combined JSON Schema (e.g. for FastAPI request bodies / OpenAPI docs).
+    """
+    members = tuple(_REGISTRY.values())
+    union = Annotated[Union[members], _Field(discriminator="type")]
+    return union, TypeAdapter(union)
+
+
+AnyPrimitive, primitive_adapter = _build_union()
+
+
+def rebuild_primitive_union():
+    """Rebuild :data:`AnyPrimitive`/:data:`primitive_adapter` after registering
+    custom primitives. Returns the refreshed adapter."""
+    global AnyPrimitive, primitive_adapter
+    AnyPrimitive, primitive_adapter = _build_union()
+    return primitive_adapter
+
+
+__all__ = [
+    "CSS",
+    "Primitive",
+    "AnyPrimitive",
+    "primitive_adapter",
+    "rebuild_primitive_union",
+    "create_ui_response",
+    # Layout
+    "Container",
+    "Card",
+    "Grid",
+    "Grids",
+    "Tabs",
+    "TabItem",
+    "Collapsible",
+    "Divider",
+    # Content & controls
+    "Text",
+    "Button",
+    "Input",
+    "ParamPicker",
+    "Image",
+    "CodeBlock",
+    "Alert",
+    "ProgressBar",
+    "MetricCard",
+    "List_",
+    "Table",
+    # Charts
+    "BarChart",
+    "LineChart",
+    "PieChart",
+    "PlotlyChart",
+    "ChartDataset",
+    # Media & I/O
+    "Audio",
+    "FileUpload",
+    "FileDownload",
+    # Theming
+    "ColorPicker",
+    "ThemeApply",
+]

astralprims/base.py

@@ -0,0 +1,157 @@
+"""Base machinery shared by every UI primitive.
+
+A primitive is a Pydantic model describing a piece of UI. It validates on
+construction, serializes to a plain ``dict``/JSON (``to_dict``/``to_json``), and
+can be reconstructed from a ``dict`` (``from_dict``) — so primitives can be
+stored, transported, validated on inbound FastAPI requests, and rendered by a
+server-driven UI. JSON stays the wire format; Pydantic is the authoring layer.
+"""
+
+from __future__ import annotations
+
+import json
+from typing import Any, ClassVar, Dict, List, Optional
+
+from pydantic import BaseModel, ConfigDict, Field, field_validator, model_serializer
+
+# A CSS block is just a mapping of (kebab-case) property -> value.
+CSS = Dict[str, str]
+
+# Registry of ``type`` string -> Primitive subclass, populated as subclasses are
+# defined. Used by :func:`Primitive.from_dict` to round-trip dicts back into
+# objects and by ``__init__`` to build the discriminated union.
+_REGISTRY: Dict[str, type["Primitive"]] = {}
+
+
+def _dump(value: Any) -> Any:
+    """Recursively serialize a value, dispatching nested models to their own
+    serializer (so each model controls its own output shape)."""
+    if isinstance(value, BaseModel):
+        return value.model_dump()
+    if isinstance(value, list):
+        return [_dump(v) for v in value]
+    if isinstance(value, dict):
+        return {k: _dump(v) for k, v in value.items()}
+    return value
+
+
+def _coerce_children(value: Any) -> Any:
+    """Turn a list of child dicts (each carrying a ``type``) into primitives."""
+    if isinstance(value, list):
+        return [
+            Primitive.from_dict(v) if isinstance(v, dict) and "type" in v else v
+            for v in value
+        ]
+    return value
+
+
+class SerModel(BaseModel):
+    """A model that serializes by dropping ``None`` fields and honoring aliases.
+
+    Used for nested non-primitive helpers (``TabItem``, ``ChartDataset``).
+    """
+
+    @model_serializer(mode="plain")
+    def _serialize(self) -> Dict[str, Any]:
+        out: Dict[str, Any] = {}
+        for name, field in type(self).model_fields.items():
+            value = getattr(self, name)
+            if value is None:
+                continue
+            out[field.alias or name] = _dump(value)
+        return out
+
+
+class Primitive(BaseModel):
+    """Base class for all UI primitives.
+
+    Subclasses set ``type`` to a ``Literal[...]`` and declare their own fields.
+    Serialization emits ``"type"`` first, drops ``None``, omits an empty ``css``
+    block, renames ``class_name`` to ``"class"``, and merges ``attributes`` at
+    the top level.
+    """
+
+    model_config = ConfigDict(populate_by_name=True, extra="ignore")
+
+    type: str = "primitive"
+    css: Optional[CSS] = None
+    id: Optional[str] = None
+    class_name: Optional[str] = Field(default=None, alias="class")
+    tooltip: Optional[str] = None
+    # Free-form extra attributes merged into the output (escape hatch).
+    attributes: Dict[str, Any] = Field(default_factory=dict)
+
+    @classmethod
+    def __pydantic_init_subclass__(cls, **kwargs: Any) -> None:
+        super().__pydantic_init_subclass__(**kwargs)
+        type_field = cls.model_fields.get("type")
+        if type_field is not None and isinstance(type_field.default, str):
+            _REGISTRY[type_field.default] = cls
+
+    # Reconstruct nested ``children``/``content`` dicts into primitives. Declared
+    # here with check_fields=False so it applies to whichever subclasses have
+    # those fields (Container, Card, Grids, Collapsible, ...).
+    @field_validator("children", "content", mode="before", check_fields=False)
+    @classmethod
+    def _coerce_primitive_children(cls, v: Any) -> Any:
+        return _coerce_children(v)
+
+    # -- serialization ----------------------------------------------------
+
+    @model_serializer(mode="plain")
+    def _serialize(self) -> Dict[str, Any]:
+        out: Dict[str, Any] = {"type": self.type}
+        for name, field in type(self).model_fields.items():
+            if name in ("type", "attributes"):
+                continue
+            value = getattr(self, name)
+            if value is None:
+                continue
+            if name == "css" and not value:
+                continue  # omit empty style blocks
+            out[field.alias or name] = _dump(value)
+        # Extra attributes are merged last so callers can override or extend.
+        out.update(self.attributes or {})
+        return out
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Serialize to a plain ``dict`` with ``"type"`` first."""
+        return self.model_dump()
+
+    def to_json(self, **kwargs: Any) -> str:
+        """Serialize to a JSON string. Extra kwargs go to :func:`json.dumps`."""
+        return json.dumps(self.model_dump(), **kwargs)
+
+    # -- deserialization --------------------------------------------------
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "Primitive":
+        """Reconstruct a primitive (and any children) from a ``dict``.
+
+        Dispatches on the ``"type"`` key to the matching registered subclass.
+        Unknown keys are funneled into ``attributes``.
+        """
+        if "type" not in data:
+            raise ValueError("primitive dict is missing required 'type' key")
+
+        type_name = data["type"]
+        target = cls if cls is not Primitive else _REGISTRY.get(type_name)
+        if target is None:
+            raise ValueError(f"unknown primitive type: {type_name!r}")
+
+        known = set()
+        for name, field in target.model_fields.items():
+            known.add(name)
+            if field.alias:
+                known.add(field.alias)
+
+        kwargs: Dict[str, Any] = {}
+        extra: Dict[str, Any] = {}
+        for key, value in data.items():
+            if key == "type":
+                continue
+            (kwargs if key in known else extra)[key] = value
+
+        if extra:
+            kwargs["attributes"] = {**kwargs.get("attributes", {}), **extra}
+        return target.model_validate(kwargs)

astralprims/primitives.py

@@ -0,0 +1,367 @@
+"""Concrete UI primitives.
+
+Each primitive is a Pydantic model that inherits ``css``, ``id``, ``class_name``,
+``tooltip`` and ``attributes`` from :class:`Primitive` and adds its own fields.
+Nesting (children / content / tabs) is reconstructed and serialized by the base
+class. Import the ones you need::
+
+    from astralprims import Button, Container, Card
+
+    Container().add(
+        Card(title="Welcome", content=[Button(label="Get started", action="go")])
+    )
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List, Literal, Optional, Union
+
+from pydantic import Field, field_validator
+
+from .base import SerModel, _coerce_children
+from .base import Primitive
+
+# ---------------------------------------------------------------------------
+# Layout
+# ---------------------------------------------------------------------------
+
+
+class Container(Primitive):
+    """A layout container holding child primitives."""
+
+    type: Literal["container"] = "container"
+    children: List[Primitive] = Field(default_factory=list)
+    direction: Optional[str] = None  # e.g. "row" | "column"
+
+    def add(self, *children: Primitive) -> "Container":
+        """Append one or more children and return self (chainable)."""
+        self.children.extend(children)
+        return self
+
+
+class Card(Primitive):
+    """A titled card wrapping child primitives."""
+
+    type: Literal["card"] = "card"
+    title: str = ""
+    content: List[Primitive] = Field(default_factory=list)
+    variant: str = "default"
+
+    def add(self, *content: Primitive) -> "Card":
+        self.content.extend(content)
+        return self
+
+
+class Grids(Primitive):
+    """A grid layout with a fixed column count."""
+
+    type: Literal["grid"] = "grid"
+    columns: int = 2
+    children: List[Primitive] = Field(default_factory=list)
+    gap: int = 20
+
+    def add(self, *children: Primitive) -> "Grids":
+        self.children.extend(children)
+        return self
+
+
+# Backwards-compatible alias.
+Grid = Grids
+
+
+class TabItem(SerModel):
+    """A single tab. Not a primitive itself (no ``type``); nested in ``Tabs``."""
+
+    label: str = ""
+    content: List[Primitive] = Field(default_factory=list)
+    value: Optional[str] = None
+
+    @field_validator("content", mode="before")
+    @classmethod
+    def _coerce_content(cls, v: Any) -> Any:
+        return _coerce_children(v)
+
+
+class Tabs(Primitive):
+    """A tabbed container."""
+
+    type: Literal["tabs"] = "tabs"
+    tabs: List[TabItem] = Field(default_factory=list)
+    variant: str = "default"
+
+    @field_validator("tabs", mode="before")
+    @classmethod
+    def _coerce_tabs(cls, v: Any) -> Any:
+        if isinstance(v, list):
+            return [TabItem.model_validate(t) if isinstance(t, dict) else t for t in v]
+        return v
+
+
+class Collapsible(Primitive):
+    """A collapsible / accordion section."""
+
+    type: Literal["collapsible"] = "collapsible"
+    title: str = ""
+    content: List[Primitive] = Field(default_factory=list)
+    default_open: bool = False
+
+
+class Divider(Primitive):
+    """A horizontal rule / visual separator."""
+
+    type: Literal["divider"] = "divider"
+    variant: str = "solid"
+
+
+# ---------------------------------------------------------------------------
+# Content & controls
+# ---------------------------------------------------------------------------
+
+
+class Text(Primitive):
+    """A run of text. ``variant`` is one of h1, h2, h3, body, caption."""
+
+    type: Literal["text"] = "text"
+    content: str = ""
+    variant: str = "body"
+
+
+class Button(Primitive):
+    """A clickable button that dispatches an action with an optional payload."""
+
+    type: Literal["button"] = "button"
+    label: str = ""
+    action: str = ""
+    payload: Dict[str, Any] = Field(default_factory=dict)
+    variant: str = "primary"
+
+
+class Input(Primitive):
+    """A single-line form input."""
+
+    type: Literal["input"] = "input"
+    placeholder: str = ""
+    name: str = ""
+    value: str = ""
+
+
+class ParamPicker(Primitive):
+    """Interactive parameter form rendered as a card with form fields.
+
+    Each entry in ``fields`` is a dict of the shape::
+
+        {"name": "models_to_train",
+         "label": "Models to train",
+         "kind": "boolean"|"number"|"text"|"checklist"|"select",
+         "default": <starting value>,
+         "options": [...]  # for checklist/select
+         "help": "...",
+         "step": 1  # optional, for number kind
+        }
+
+    On submit the renderer interpolates ``submit_message_template`` with the
+    user's field values. Two placeholder forms are supported:
+
+    * ``{field_name}`` — replaced with that field's value (JSON-encoded for
+      lists/dicts/bools).
+    * ``{__values_json__}`` — replaced with the JSON of the entire form state.
+    """
+
+    type: Literal["param_picker"] = "param_picker"
+    title: str = ""
+    description: str = ""
+    fields: List[Dict[str, Any]] = Field(default_factory=list)
+    submit_label: str = "Submit"
+    submit_message_template: str = ""
+
+
+class Image(Primitive):
+    """An image."""
+
+    type: Literal["image"] = "image"
+    url: str = ""
+    alt: Optional[str] = None
+    width: Optional[str] = None
+    height: Optional[str] = None
+
+
+class CodeBlock(Primitive):
+    """A syntax-highlighted code block."""
+
+    type: Literal["code"] = "code"
+    code: str = ""
+    language: str = "text"
+    show_line_numbers: bool = False
+
+
+class Alert(Primitive):
+    """A callout / banner. ``variant`` is info, success, warning, or error."""
+
+    type: Literal["alert"] = "alert"
+    message: str = ""
+    variant: str = "info"
+    title: Optional[str] = None
+
+
+class ProgressBar(Primitive):
+    """A progress bar."""
+
+    type: Literal["progress"] = "progress"
+    value: float = 0.0
+    label: Optional[str] = None
+    variant: str = "default"
+    show_percentage: bool = True
+
+
+class MetricCard(Primitive):
+    """A single KPI / metric tile."""
+
+    type: Literal["metric"] = "metric"
+    title: str = ""
+    value: str = ""
+    subtitle: Optional[str] = None
+    icon: Optional[str] = None
+    variant: str = "default"
+    progress: Optional[float] = None
+
+
+class List_(Primitive):
+    """An ordered or unordered list of strings or dict items."""
+
+    type: Literal["list"] = "list"
+    items: List[Union[str, Dict[str, Any]]] = Field(default_factory=list)
+    ordered: bool = False
+    variant: str = "default"
+
+
+class Table(Primitive):
+    """A data table with optional pagination and re-invocation context."""
+
+    type: Literal["table"] = "table"
+    headers: List[str] = Field(default_factory=list)
+    rows: List[List[Any]] = Field(default_factory=list)
+    variant: str = "default"
+    # Pagination (optional — when present, the renderer shows controls).
+    total_rows: Optional[int] = None
+    page_size: Optional[int] = None
+    page_offset: Optional[int] = None
+    page_sizes: List[int] = Field(default_factory=list)
+    # Tool re-invocation context (lets the renderer request different pages).
+    source_tool: Optional[str] = None
+    source_agent: Optional[str] = None
+    source_params: Dict[str, Any] = Field(default_factory=dict)
+
+
+# ---------------------------------------------------------------------------
+# Charts
+# ---------------------------------------------------------------------------
+
+
+class ChartDataset(SerModel):
+    """A named series of values. Not a primitive itself."""
+
+    label: str = ""
+    data: List[float] = Field(default_factory=list)
+    color: Optional[str] = None
+
+
+class BarChart(Primitive):
+    """A bar chart."""
+
+    type: Literal["bar_chart"] = "bar_chart"
+    title: str = ""
+    labels: List[str] = Field(default_factory=list)
+    datasets: List[Dict[str, Any]] = Field(default_factory=list)
+
+
+class LineChart(Primitive):
+    """A line chart."""
+
+    type: Literal["line_chart"] = "line_chart"
+    title: str = ""
+    labels: List[str] = Field(default_factory=list)
+    datasets: List[Dict[str, Any]] = Field(default_factory=list)
+
+
+class PieChart(Primitive):
+    """A pie chart."""
+
+    type: Literal["pie_chart"] = "pie_chart"
+    title: str = ""
+    labels: List[str] = Field(default_factory=list)
+    data: List[float] = Field(default_factory=list)
+    colors: List[str] = Field(default_factory=list)
+
+
+class PlotlyChart(Primitive):
+    """An arbitrary Plotly figure (data + layout + config)."""
+
+    type: Literal["plotly_chart"] = "plotly_chart"
+    title: str = ""
+    data: List[Dict[str, Any]] = Field(default_factory=list)
+    layout: Dict[str, Any] = Field(default_factory=dict)
+    config: Dict[str, Any] = Field(default_factory=dict)
+
+
+# ---------------------------------------------------------------------------
+# Media & I/O
+# ---------------------------------------------------------------------------
+
+
+class Audio(Primitive):
+    """Audio player primitive.
+
+    Supports inline base64 data, URLs, generated speech, and MIDI.
+    """
+
+    type: Literal["audio"] = "audio"
+    src: str = ""
+    contentType: Optional[str] = None  # audio/mpeg, audio/wav, audio/midi, ...
+    autoplay: bool = False
+    loop: bool = False
+    label: Optional[str] = None  # optional title above the player
+    showControls: bool = True
+    description: Optional[str] = None  # optional caption/description
+
+
+class FileUpload(Primitive):
+    """A file upload control."""
+
+    type: Literal["file_upload"] = "file_upload"
+    label: str = "Upload File"
+    accept: str = "*/*"
+    action: str = ""
+
+
+class FileDownload(Primitive):
+    """A file download link/button."""
+
+    type: Literal["file_download"] = "file_download"
+    label: str = "Download File"
+    url: str = ""
+    filename: Optional[str] = None
+
+
+# ---------------------------------------------------------------------------
+# Theming
+# ---------------------------------------------------------------------------
+
+
+class ColorPicker(Primitive):
+    """A color picker bound to a theme color key."""
+
+    type: Literal["color_picker"] = "color_picker"
+    label: str = ""
+    color_key: str = ""
+    value: str = "#000000"
+
+
+class ThemeApply(Primitive):
+    """Applies a theme preset or individual color change."""
+
+    type: Literal["theme_apply"] = "theme_apply"
+    preset: Optional[str] = None
+    colors: Optional[Dict[str, str]] = None
+    color_key: Optional[str] = None
+    color_value: Optional[str] = None
+    message: str = ""

astralprims/response.py

@@ -0,0 +1,15 @@
+"""Helpers for shipping primitives over the wire."""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List
+
+from .base import Primitive
+
+
+def create_ui_response(components: List[Primitive]) -> Dict[str, Any]:
+    """Wrap a list of primitives in the standard UI response envelope."""
+    return {
+        "_ui_components": [c.to_dict() for c in components],
+        "_data": None,
+    }

astralprims-0.1.0.dist-info/METADATA

@@ -0,0 +1,135 @@
+Metadata-Version: 2.4
+Name: astralprims
+Version: 0.1.0
+Summary: Composable, serializable UI primitives for Python
+Project-URL: Homepage, https://github.com/AstralDeep/Astral-Primitives
+Project-URL: Issues, https://github.com/AstralDeep/Astral-Primitives/issues
+Author-email: Sam Armstrong <admin@example.com>
+License-Expression: Apache-2.0
+License-File: LICENSE
+Keywords: components,json,primitives,serialization,ui
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Requires-Dist: pydantic>=2
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# Astral Primitives
+
+Composable, serializable UI primitives for Python. Describe UI as plain Python
+objects, then serialize them to a `dict`/JSON for storage or for a server-driven
+UI to render.
+
+## Install
+
+```bash
+pip install -e ".[dev]"   # editable install with test deps
+```
+
+## Quick start
+
+```python
+from astralprims import Button
+
+button = Button(
+    label="the button text",
+    action="open",
+    css={"background-color": "white", "color": "#000000"},
+)
+
+button.to_dict()
+# {
+#   "type": "button",
+#   "css": {"background-color": "white", "color": "#000000"},
+#   "label": "the button text",
+#   "action": "open",
+#   "payload": {},
+#   "variant": "primary",
+# }
+
+button.to_json()  # -> JSON string
+```
+
+`None` and empty `css` are dropped from the output, so payloads stay clean.
+
+### Composing layouts
+
+```python
+from astralprims import Card, Container, Text, Button
+
+page = Container(css={"display": "flex"}, direction="column").add(
+    Text(content="Welcome", variant="h1"),
+    Card(title="Sign up").add(
+        Text(content="Enter your details below."),
+        Button(label="Get started", action="signup"),
+    ),
+)
+page.to_dict()  # children/content serialize recursively
+```
+
+### Round-tripping from data
+
+Already have a primitive as a `dict` (from storage or an API)? Rebuild it —
+including the full nested tree:
+
+```python
+from astralprims import Primitive
+
+spec = {"type": "button", "label": "Buy", "action": "checkout"}
+button = Primitive.from_dict(spec)   # -> Button(...)
+```
+
+### Shipping a response
+
+```python
+from astralprims import create_ui_response, Text, Button
+
+create_ui_response([Text(content="hi"), Button(label="ok", action="go")])
+# {"_ui_components": [{...}, {...}], "_data": None}
+```
+
+A FastAPI endpoint can return `primitive.to_dict()` or `create_ui_response(...)`
+directly.
+
+## Built-in primitives
+
+| Group     | Primitives                                                                 |
+|-----------|----------------------------------------------------------------------------|
+| Layout    | `Container`, `Card`, `Grid`/`Grids`, `Tabs` (+ `TabItem`), `Collapsible`, `Divider` |
+| Content   | `Text`, `Button`, `Input`, `ParamPicker`, `Image`, `CodeBlock`, `Alert`, `ProgressBar`, `MetricCard`, `List_`, `Table` |
+| Charts    | `BarChart`, `LineChart`, `PieChart`, `PlotlyChart` (+ `ChartDataset`)      |
+| Media/IO  | `Audio`, `FileUpload`, `FileDownload`                                      |
+| Theming   | `ColorPicker`, `ThemeApply`                                                |
+
+Every primitive also accepts `css`, `id`, `class_name` (serialized as `class`),
+`tooltip`, and an `attributes` dict for arbitrary extra keys.
+
+## Defining your own primitive
+
+Subclassing auto-registers the new `type` for `from_dict` — no manual map:
+
+```python
+from dataclasses import dataclass
+from typing import ClassVar, Optional
+from astralprims import Primitive
+
+@dataclass
+class Badge(Primitive):
+    type: ClassVar[str] = "badge"   # registered automatically
+    label: str = ""
+    count: Optional[int] = None
+```
+
+## Tests
+
+```bash
+pytest
+```
+
+## License
+
+Apache-2.0

astralprims-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+astralprims/__init__.py,sha256=p7uq3IbSOmperEQNd0QoBzA9xYE2pHeyop4VJKVwmr4,2489
+astralprims/base.py,sha256=swlwdXGwvsnXjE31M4urz9D9rWG8frxkCA2cDfCLGHc,5982
+astralprims/primitives.py,sha256=UtEJojo2c7fq5JFXqZifvYEqNpmhQj1i9HsJ3O0Kzm4,10299
+astralprims/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+astralprims/response.py,sha256=KshWYR-FpgUx4ftie-jkxk9JrUTkDVXJWSdgd1zVw74,404
+astralprims-0.1.0.dist-info/METADATA,sha256=EuSXHq9ZmFvZ9gWGRcJ3tVxhcELen1v4V7pDGR4JDEE,3871
+astralprims-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+astralprims-0.1.0.dist-info/licenses/LICENSE,sha256=d0VzGR8il10kGRtEpIGtqFW9xxj6e90y-cPkIluMfOM,11344
+astralprims-0.1.0.dist-info/RECORD,,

astralprims-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

astralprims-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2026 Sam Armstrong
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.