danvas 0.5.1__py3-none-win_amd64.whl

danvas-0.5.1.data/purelib/danvas/__init__.py

@@ -0,0 +1,105 @@
+"""danvas: a browser-based spatial canvas driven entirely from Python."""
+
+from .autopanel import autopanel
+from .canvas import Canvas
+from .components import (
+    AudioFeed,
+    BaseComponent,
+    Button,
+    Chat,
+    Custom,
+    Download,
+    FileBrowser,
+    Histogram,
+    Image,
+    Inspector,
+    Label,
+    LivePlot,
+    Markdown,
+    Plot,
+    React,
+    Slider,
+    Table,
+    TextField,
+    Toggle,
+    Upload,
+    UploadedFile,
+    VideoFeed,
+    Model3D,
+    WebView,
+)
+from .dispatch import panel_for
+from .shapes import (
+    BaseShape, DrawingShape,
+    Geo, Text, Note, Draw, Highlight, Line, Frame,
+)
+
+# Single source of truth is the installed package metadata (pyproject `version`).
+# Fall back to 0.0.0 when running straight from a source tree that was never
+# installed, so the import never fails just to read a version string.
+try:
+    from importlib.metadata import PackageNotFoundError, version as _version
+
+    __version__ = _version("danvas")
+except PackageNotFoundError:
+    __version__ = "0.0.0"
+
+__all__ = [
+    "Canvas",
+    "autopanel",
+    "panel_for",
+    "Merge",
+    "SourceClient",
+    "Slider",
+    "Button",
+    "Label",
+    "VideoFeed",
+    "AudioFeed",
+    "Chat",
+    "Custom",
+    "Download",
+    "FileBrowser",
+    "React",
+    "Markdown",
+    "Image",
+    "Table",
+    "TextField",
+    "Toggle",
+    "Plot",
+    "LivePlot",
+    "Histogram",
+    "Inspector",
+    "Upload",
+    "UploadedFile",
+    "Model3D",
+    "WebView",
+    "BaseComponent",
+    "BaseShape",
+    "DrawingShape",
+    "Geo",
+    "Text",
+    "Note",
+    "Draw",
+    "Highlight",
+    "Line",
+    "Frame",
+]
+
+
+def __getattr__(name):
+    # Lazily expose ``danvas.Merge`` / ``danvas.SourceClient`` so importing the
+    # package doesn't pull in the websocket *client* stack (only the merge
+    # aggregator and the dial-in source client need it).
+    if name == "Merge":
+        from .merge import Merge
+        return Merge
+    if name == "SourceClient":
+        from .source import SourceClient
+        return SourceClient
+    if name == "connect":
+        from .remote import connect
+        return connect
+    if name == "RemoteCanvas":
+        from .remote import RemoteCanvas
+        return RemoteCanvas
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

danvas-0.5.1.data/purelib/danvas/_dialin.py

@@ -0,0 +1,92 @@
+"""Client-side dial-in helpers: normalise a source spec, probe it for auth, and
+run its password flow.
+
+These are pure-stdlib (http.client / urllib) and used by BOTH a dial-in source
+(``danvas.SourceClient`` / ``danvas.connect``) and the merge hub that dials out.
+They live here — not in merge.py, which pulls the FastAPI server stack — so a
+light client/broker install can dial into a canvas without that dependency. One
+definition, every caller.
+"""
+
+import re
+from http.client import HTTPConnection, HTTPSConnection
+from urllib.parse import quote, urlsplit
+
+
+def _parse_source(spec):
+    """Normalise a source spec to ``(ws_uri, http_parts, label)``.
+
+    ``http_parts`` is ``(scheme, host, port, is_tls)`` for the source's HTTP
+    origin -- used to probe whether the canvas is password-protected and to run
+    its ``/__auth__`` login flow. Accepts a bare port (``8001`` / ``":8001"``),
+    a ``host:port``, or a full URL (``https://x.loca.lt`` / ``wss://host/ws``).
+    """
+    if isinstance(spec, int):
+        ws_uri, label = f"ws://localhost:{spec}/ws", f"localhost:{spec}"
+    else:
+        text = str(spec).strip()
+        if "://" in text:
+            scheme, _, rest = text.partition("://")
+            scheme = {"http": "ws", "https": "wss"}.get(scheme.lower(), scheme.lower())
+            rest = rest.rstrip("/")
+            label = rest.split("/", 1)[0]
+            if not rest.endswith("/ws"):
+                rest += "/ws"
+            ws_uri = f"{scheme}://{rest}"
+        else:
+            if text.startswith(":"):
+                text = "localhost" + text
+            if ":" in text:
+                host, _, port = text.rpartition(":")
+                host = host or "localhost"
+            else:
+                host, port = "localhost", text
+            ws_uri, label = f"ws://{host}:{int(port)}/ws", f"{host}:{port}"
+    u = urlsplit(ws_uri)
+    tls = u.scheme == "wss"
+    host = u.hostname or "localhost"
+    port = u.port or (443 if tls else 80)
+    http_parts = ("https" if tls else "http", host, port, tls)
+    return ws_uri, http_parts, label
+
+
+def _http_conn(http_parts, timeout=6):
+    _scheme, host, port, tls = http_parts
+    cls = HTTPSConnection if tls else HTTPConnection
+    return cls(host, port, timeout=timeout)
+
+
+def _probe_source(http_parts):
+    """Classify a source (blocking; run in an executor): ``"open"`` (reachable, no
+    auth), ``"auth"`` (password-protected -> HTTP 401), or ``"offline"``."""
+    try:
+        conn = _http_conn(http_parts)
+        conn.request("GET", "/")
+        resp = conn.getresponse()
+        resp.read()
+        conn.close()
+        return "auth" if resp.status == 401 else "open"
+    except Exception:
+        return "offline"
+
+
+def _authenticate(http_parts, password):
+    """Run a source's ``/__auth__`` password flow (blocking; run in an executor).
+
+    Returns the ``pc_session`` cookie token on success, or ``None`` on a wrong
+    password / unreachable host. The canvas replies to a correct password with a
+    303 redirect carrying ``Set-Cookie: pc_session=...``.
+    """
+    try:
+        conn = _http_conn(http_parts)
+        body = "password=" + quote(password or "", safe="")
+        conn.request("POST", "/__auth__", body=body,
+                     headers={"Content-Type": "application/x-www-form-urlencoded"})
+        resp = conn.getresponse()
+        set_cookie = resp.getheader("Set-Cookie") or ""
+        resp.read()
+        conn.close()
+        m = re.search(r"pc_session=([^;]+)", set_cookie)
+        return m.group(1) if m else None
+    except Exception:
+        return None

danvas-0.5.1.data/purelib/danvas/_events.py

@@ -0,0 +1,50 @@
+"""canvas.emit / canvas.on_event: the backend's universal trigger.
+
+The frontend already has one universal trigger: a panel calls
+``canvas.send({...})`` and Python handlers fire. This is the same idea
+pointed the other way — *any* Python code (a watchdog thread, a timer, a
+serial reader, an MQTT callback, another handler) calls ``canvas.emit(name,
+data)`` and every ``@canvas.on_event(name)`` handler fires::
+
+    @canvas.on_event("part-dropped")
+    def _(path):
+        viewer.update(path)
+
+    # anywhere, any thread:
+    canvas.emit("part-dropped", "drop/bracket.glb")
+
+Emits are funnelled through the same shared dispatch thread as browser
+input, so an inline handler never races an ``on_change`` — an emit is an
+event like any other. And because each event name's handler list is a
+headless peer of a panel's (it *borrows* the component dispatch machinery
+wholesale), handlers get the identical feature set: ``threaded=True``,
+``dedicated=True`` with ``queue="fifo"/"latest"`` backpressure, ``async
+def`` support, an optional trailing ``viewer`` argument (``{}`` for
+backend emits), and visibility in the Inspector's dispatch trace.
+"""
+
+from .components.base import BaseComponent
+
+
+class EventChannel:
+    """The handler list for one event name — a headless peer of a panel.
+
+    Borrows :class:`BaseComponent`'s registration/dispatch methods verbatim
+    rather than reimplementing the threaded/dedicated/queue/async branching;
+    the attributes below are exactly the state those methods touch.
+    """
+
+    _register_callback = BaseComponent._register_callback
+    _dispatch_callbacks = BaseComponent._dispatch_callbacks
+    _accepts_viewer = staticmethod(BaseComponent._accepts_viewer)
+    _traced = staticmethod(BaseComponent._traced)
+
+    def __init__(self, canvas, name):
+        self._canvas = canvas
+        self.name = name              # labels dispatch-trace rows
+        self._callbacks = []
+        self._dedicated_kernels = {}
+
+    @property
+    def _bridge(self):
+        return self._canvas._bridge

danvas-0.5.1.data/purelib/danvas/_factories.py

@@ -0,0 +1,288 @@
+"""Component factory methods for :class:`~danvas.canvas.Canvas`
+(``canvas.slider`` / ``button`` / ``react`` / …).
+
+Split out of canvas.py: each is a thin wrapper that builds a component and hands
+it to ``Canvas.insert`` via ``_make``. Mixed into Canvas as :class:`_FactoryMixin`,
+so the methods run on the real Canvas instance — ``self.insert`` /
+``self._auto_name`` / ``self._show_seq`` resolve there.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from ._flags import LAYOUT_FLAGS
+from .components import (
+    AudioFeed,
+    Button,
+    Chat,
+    Custom,
+    Download,
+    FileBrowser,
+    Histogram,
+    Image,
+    Inspector,
+    Label,
+    LivePlot,
+    Markdown,
+    Plot,
+    React,
+    Slider,
+    Table,
+    TextField,
+    Toggle,
+    Upload,
+    VideoFeed,
+    Model3D,
+    WebView,
+)
+
+if TYPE_CHECKING:
+    from typing_extensions import Unpack
+
+    from .canvas import Place
+
+# Keyword names consumed by ``Canvas.insert`` itself. A factory splits these off
+# and forwards everything else to the component constructor. ``name`` is
+# intentionally absent: it is the component's identity (set in its constructor),
+# not a placement option. The lock/chrome flags come from the shared LAYOUT_FLAGS
+# table; ``queue`` lives here so all factories accept it uniformly.
+_INSERT_KEYS = ("x", "y", "w", "h", "width", "height", "rotation", "queue",
+                "below", "above", "right_of", "left_of", "gap",
+                "roles", "lock_for", "decorative", *LAYOUT_FLAGS)
+
+
+class _FactoryMixin:
+    """The ``canvas.<component>(...)`` factories. Mixed into :class:`Canvas`."""
+
+    def _make(self, cls, *args, **kw):
+        place = {k: kw.pop(k) for k in _INSERT_KEYS if k in kw}
+        return self.insert(cls(*args, **kw), **place)
+
+    def slider(self, name="slider", min=0, max=100, default=None, step=1,
+               on_release=False, label=None, **place: Unpack[Place]):
+        """Insert a :class:`~danvas.Slider`. See :meth:`insert` for ``place``.
+
+        ``step`` sets the granularity and the int-vs-float behaviour (a
+        fractional step like ``0.1`` makes it a float slider). ``on_release=True``
+        reports only the settled value when the user lets go, instead of every
+        value during the drag.
+        """
+        return self._make(Slider, name=name, min=min, max=max, default=default,
+                          step=step, on_release=on_release, label=label, **place)
+
+    def toggle(self, options, name="toggle", default=None, label=None, **place: Unpack[Place]):
+        """Insert a :class:`~danvas.Toggle`. See :meth:`insert` for ``place``."""
+        return self._make(Toggle, options, name=name, default=default, label=label,
+                          **place)
+
+    def button(self, name="button", text=None, label=None, **place: Unpack[Place]):
+        """Insert a :class:`~danvas.Button`. See :meth:`insert` for ``place``."""
+        return self._make(Button, name=name, text=text, label=label, **place)
+
+    def label(self, name="label", value="", label=None, **place: Unpack[Place]):
+        """Insert a :class:`~danvas.Label`. See :meth:`insert` for ``place``."""
+        return self._make(Label, name=name, value=value, label=label, **place)
+
+    def video(self, name="video", quality=70, label=None, **place: Unpack[Place]):
+        """Insert a :class:`~danvas.VideoFeed`. See :meth:`insert` for ``place``."""
+        return self._make(VideoFeed, name=name, quality=quality, label=label, **place)
+
+    def audio(self, name="audio", sample_rate=16000, channels=1, label=None, **place: Unpack[Place]):
+        """Insert an :class:`~danvas.AudioFeed`. See :meth:`insert` for ``place``."""
+        return self._make(AudioFeed, name=name, sample_rate=sample_rate,
+                          channels=channels, label=label, **place)
+
+    def chat(self, name="chat", label=None, **place: Unpack[Place]):
+        """Insert a :class:`~danvas.Chat` panel. See :meth:`insert` for ``place``."""
+        return self._make(Chat, name=name, label=label, **place)
+
+    def custom(self, html=None, path=None, css=None, js=None, name="custom",
+               label=None, **place: Unpack[Place]):
+        """Insert a :class:`~danvas.Custom`. See :meth:`insert` for ``place``.
+
+        ``html``/``css``/``js`` may be given as separate strings (e.g. pasted
+        from uiverse.io) — they are composed into one document under the hood.
+        Size the panel with ``w``/``h`` in ``place``.
+        """
+        return self._make(Custom, html=html, path=path, css=css, js=js,
+                          name=name, label=label, **place)
+
+    def download(self, name="download", source=None, filename=None, text=None, label=None,
+                 **place: Unpack[Place]):
+        """Insert a :class:`~danvas.Download` button. See :meth:`insert` for ``place``.
+
+        Clicking it downloads ``source`` — a file path or ``bytes`` — to the
+        viewer's machine. For content generated fresh on each click, omit
+        ``source`` and register a provider with ``@download.provide``.
+        ``filename`` sets the saved name (otherwise a path's basename, or the
+        panel name, is used). The host code chooses what each click serves, so
+        nothing the viewer sends selects a path.
+        """
+        return self._make(Download, name=name, source=source, filename=filename,
+                          text=text, label=label, **place)
+
+    def upload(self, name="upload", text=None, label=None, dest=None,
+               accept=None, multiple=False, max_size=None, **place: Unpack[Place]):
+        """Insert an :class:`~danvas.Upload` panel. See :meth:`insert` for ``place``.
+
+        A click-or-drop zone that receives a viewer's file into Python; wire it
+        with ``@upload.on_upload``. By default the bytes arrive in memory
+        (``file.data``); pass ``dest=`` a directory to stream each upload to disk
+        instead (``file.path``), which keeps memory flat for large files.
+        ``accept`` filters the picker (e.g. ``".csv"``), ``multiple=True`` allows
+        several at once, and ``max_size`` (bytes) rejects oversized uploads — set
+        it on any public/tunneled canvas.
+        """
+        return self._make(Upload, name=name, text=text, label=label, dest=dest,
+                          accept=accept, multiple=multiple, max_size=max_size,
+                          **place)
+
+    def file_browser(self, name="filebrowser", root=".", label=None, pattern=None,
+                     show_hidden=False, **place: Unpack[Place]):
+        """Insert a :class:`~danvas.FileBrowser`. See :meth:`insert` for ``place``.
+
+        Navigation is confined to ``root``. ``pattern`` (an fnmatch glob like
+        ``"*.csv"``) filters which files are shown. Size it with ``w``/``h`` in
+        ``place``.
+        """
+        return self._make(FileBrowser, name=name, root=root, label=label,
+                          pattern=pattern, show_hidden=show_hidden, **place)
+
+    def react(self, source=None, path=None, jsx=None, css=None, css_path=None,
+              name="react", label=None, props=None, scope=None,
+              wasm=None, wasm_path=None, **place: Unpack[Place]):
+        """Insert a :class:`~danvas.React` panel — the workhorse for custom UI.
+
+        ``source`` is JSX defining ``function Component(...)`` (or load it from a
+        file with ``path=``); alternatively pass just ``jsx`` markup plus optional
+        ``css`` and the Component wrapper is added under the hood. ``css`` also
+        works with ``source=`` (it rides as a ``<style>`` the host renders), so a
+        full component can keep its styles in a separate string — or load it from a
+        file with ``css_path=`` (the ``css`` twin of ``path=``), so a panel keeps
+        both halves in sibling files. Use :meth:`React.from_uiverse` to convert a
+        uiverse.io styled-components snippet. ``props`` is the initial props dict; ``scope`` is third-party
+        library names (e.g. ``["d3"]``) loaded as ESM and exposed as ``libs``.
+
+        ``wasm`` accepts raw ``.wasm`` bytes; ``wasm_path=`` loads them from a
+        file. The module is compiled once in the browser and its exports are
+        available as ``await canvas.wasm`` inside the JSX component.
+
+        Placement, visibility (``roles`` / ``lock_for``), the lock/chrome flags,
+        and ``queue`` all flow through ``**place`` — see :meth:`insert` (and the
+        :class:`Place` keys your editor now autocompletes).
+        """
+        return self._make(React, source=source, path=path, jsx=jsx, css=css,
+                          css_path=css_path, name=name, label=label, props=props,
+                          scope=scope, wasm=wasm, wasm_path=wasm_path, **place)
+
+    def markdown(self, text="", name="markdown", label=None, **place: Unpack[Place]):
+        """Insert a :class:`~danvas.Markdown` panel. See :meth:`insert` for ``place``."""
+        return self._make(Markdown, text=text, name=name, label=label, **place)
+
+    def image(self, src, name="image", label=None, fit="contain", **place: Unpack[Place]):
+        """Insert an :class:`~danvas.Image` panel. See :meth:`insert` for ``place``.
+
+        ``src`` is a path, URL, image bytes, Matplotlib/PIL figure, or array.
+        """
+        return self._make(Image, src, name=name, label=label, fit=fit, **place)
+
+    def table(self, data, name="table", label=None, **place: Unpack[Place]):
+        """Insert a :class:`~danvas.Table` panel. See :meth:`insert` for ``place``.
+
+        ``data`` is a pandas DataFrame/Series, a list of dicts/rows, or a dict.
+        """
+        return self._make(Table, data, name=name, label=label, **place)
+
+    def text_field(self, name="text_field", placeholder="", default="", multiline=False,
+                   label=None, **place: Unpack[Place]):
+        """Insert a :class:`~danvas.TextField`. See :meth:`insert` for ``place``.
+
+        Single-line (default): fires ``on_change`` on Enter or focus-loss.
+        Pass ``multiline=True`` for a textarea that fires on focus-loss.
+        """
+        return self._make(TextField, name=name, placeholder=placeholder,
+                          default=default, multiline=multiline, label=label,
+                          **place)
+
+    def show(self, value, name=None, label=None, **kw):
+        """Auto-render any value as the best-fitting panel and insert it.
+
+        Picks the component the way a notebook decides how to render an output
+        (DataFrame → table, figure/array → image, Plotly → plot, rich
+        ``_repr_*`` → its HTML, dict/list → JSON, string → label/markdown, else a
+        repr label) via :func:`danvas.panel_for`. With no ``name`` a unique one
+        is generated; re-using a ``name`` replaces that panel in place. Returns
+        the inserted component. See :meth:`insert` for ``place``.
+
+        Any keyword arguments not used for placement are forwarded to the
+        chosen component's constructor when it accepts them and silently ignored
+        otherwise — so ``editable=True`` enables editing on a table but is a
+        no-op if the value renders as an image or label.
+        """
+        from .dispatch import panel_for
+        # Split placement kwargs from component-specific ones.
+        place = {k: kw.pop(k) for k in _INSERT_KEYS if k in kw}
+        if name is None:
+            self._show_seq += 1
+            name = f"panel_{self._show_seq}"
+        comp = panel_for(value, name=name, label=label, **kw)
+        # insert() handles eviction of whatever currently holds this name, so
+        # re-showing under the same name replaces in place on its own.
+        return self.insert(comp, **place)
+
+    def webview(self, url, name="webview", label=None, **place: Unpack[Place]):
+        """Insert a :class:`~danvas.WebView`. See :meth:`insert` for ``place``."""
+        return self._make(WebView, url, name=name, label=label, **place)
+
+    def model3d(self, name="model3d", label=None, color=None,
+                **place: Unpack[Place]):
+        """Insert a :class:`~danvas.Model3D` — the prebuilt CAD/3D viewer:
+        ``viewer.update(glb_bytes_or_path_or_trimesh)`` shows the model with
+        orbit, snap measurements, and a section plane. See :meth:`insert`."""
+        return self._make(Model3D, name=name, label=label, color=color,
+                          **place)
+
+    def plot(self, name="plot", label=None, **place: Unpack[Place]):
+        """Insert a :class:`~danvas.Plot`. See :meth:`insert` for ``place``."""
+        return self._make(Plot, name=name, label=label, **place)
+
+    def live_plot(self, name="liveplot", traces=None, max_points=300,
+                  mode="lines", layout=None, smoothing=0.0, label=None,
+                  color=None, **place: Unpack[Place]):
+        """Insert a :class:`~danvas.LivePlot`. See :meth:`insert` for ``place``.
+
+        ``traces`` only fixes the legend order — pushing an unseen key adds a
+        trace on the fly. ``smoothing`` (0–1) is an EMA over each trace;
+        ``max_points`` caps the rolling window per trace.
+        """
+        return self._make(LivePlot, name=name, traces=traces,
+                          max_points=max_points, mode=mode, layout=layout,
+                          smoothing=smoothing, label=label, color=color,
+                          **place)
+
+    def histogram(self, name="histogram", bins=30, mode="heatmap",
+                  value_range=None, max_steps=200, label=None, color=None,
+                  **place: Unpack[Place]):
+        """Insert a :class:`~danvas.Histogram` — a distribution-over-time panel.
+        See :meth:`insert` for ``place``.
+
+        Feed it with ``panel.add(values, step)``; needs ``plotly``. ``bins``
+        sets the resolution, ``value_range`` pins the bin edges, ``max_steps``
+        caps the rolling history, and ``mode`` is ``"heatmap"`` or ``"overlay"``.
+        """
+        return self._make(Histogram, name=name, bins=bins, mode=mode,
+                          value_range=value_range, max_steps=max_steps,
+                          label=label, color=color, **place)
+
+    def inspector(self, name="inspector", refresh=1.0, source="components",
+                  namespace=None, label=None, **place: Unpack[Place]):
+        """Insert an :class:`~danvas.Inspector`. See :meth:`insert` for ``place``.
+
+        ``refresh`` is the auto-refresh period in seconds, so the table stays live
+        as panel values and positions change (default ``1.0``); the rebuild only
+        runs while serving with a browser connected, so an idle inspector is free.
+        Pass ``refresh=None`` to make it manual (the **Refresh** button only).
+        """
+        return self._make(Inspector, name=name, refresh=refresh, source=source,
+                          namespace=namespace, label=label, **place)

danvas-0.5.1.data/purelib/danvas/_flags.py

@@ -0,0 +1,76 @@
+"""Single source of truth for a panel's lock / chrome flags.
+
+Every panel shares the same set of boolean flags that gate how a *viewer* may
+interact with it (drag, resize, operate its controls, select it) and whether it
+draws its card chrome. Each flag is described once here as a :class:`Flag` and
+the same table drives:
+
+- the read/write properties and ``set_layout`` on
+  :class:`~danvas.components.base.BaseComponent`,
+- the ``register`` message built in :mod:`danvas.bridge`,
+- ``Canvas.insert`` and the save/load formation in :mod:`danvas.canvas`.
+
+So adding a new flag is a single edit here rather than a change threaded through
+seven places. ``wire`` is the key sent to the browser; it is deliberately kept
+distinct from the Python name (e.g. ``draggable`` → ``movable``) and **must not**
+change without updating the frontend's ``lockMeta`` handling. ``default`` is both
+the initial value and the "don't bother sending it" baseline in the register
+message.
+"""
+
+from collections import namedtuple
+
+from ._protocol import FLAG_WIRE_KEYS
+
+Flag = namedtuple("Flag", "wire attr default doc")
+
+
+# Python name -> Flag(wire key, backing attribute, default, property docstring).
+# Insertion order is the canonical order used wherever the flags are iterated.
+# The ``wire`` keys come from the canonical danvas/_protocol.py (the same
+# definition the frontend's protocol.generated.js is rendered from) so the
+# browser-facing names can't drift; this module owns the backing attr / default /
+# docstring.
+LAYOUT_FLAGS = {
+    "locked": Flag(
+        FLAG_WIRE_KEYS["locked"], "_locked", False,
+        "Whether the panel is fully locked (no move/resize/interaction)."),
+    "draggable": Flag(
+        FLAG_WIRE_KEYS["draggable"], "_draggable", True,
+        "Whether the user can drag the panel. Control interaction is "
+        "unaffected."),
+    "resizable": Flag(
+        FLAG_WIRE_KEYS["resizable"], "_resizable", True,
+        "Whether the user can resize the panel. Interaction is unaffected."),
+    "operable": Flag(
+        FLAG_WIRE_KEYS["operable"], "_operable", True,
+        "Whether the user can operate the panel's controls from the UI.\n\n"
+        "        Set to ``False`` to make the controls inert to the user while "
+        "the panel\n        stays unlocked, so Python ``update()`` calls still "
+        "render live (e.g. a\n        slider thumb that tracks an automatic "
+        "value the user mustn't drag). The\n        panel can still be "
+        "moved/selected; use ``locked`` to freeze everything.\n        "),
+    "grabbable": Flag(
+        FLAG_WIRE_KEYS["grabbable"], "_grabbable", True,
+        "Whether the user can grab/select this panel at all.\n\n"
+        "        Content-heavy panels (Custom, React, WebView, plots…) normally "
+        "need a\n        first click to select the panel before their content "
+        "becomes\n        interactive. Set to ``False`` to drop that cover "
+        "*and* make the panel\n        invisible to selection: the content is "
+        "live (hover and clicks work)\n        from the start, and no click, "
+        "marquee, or select-all ever highlights\n        or selects the panel — "
+        "only the widget itself reacts. The trade-off is\n        that the user "
+        "can't move or resize it; do that from Python (or flip\n        "
+        "``grabbable`` back on).\n        "),
+    "frame": Flag(
+        FLAG_WIRE_KEYS["frame"], "_frame", True,
+        "Whether the panel draws its rectangular card chrome.\n\n"
+        "        Set to ``False`` to strip the card entirely — background, "
+        "border,\n        shadow, padding, label header, and the "
+        "hover/selection highlight\n        rectangle — so the component's "
+        "content appears to float directly on\n        the canvas. The panel "
+        "still occupies its w×h box and can be moved or\n        resized as "
+        "usual (marquee select still works). Pair with\n        "
+        "``grabbable=False`` if clicks on the content should never select it.\n"
+        "        "),
+}

danvas-0.5.1.data/purelib/danvas/_hotreload_monitor.py

@@ -0,0 +1,27 @@
+"""Clean monitor entry-point for ``serve(hot_reload=True)``.
+
+Spawned as a subprocess by ``canvas._maybe_handoff_reload`` so the monitor
+process never contains user code or user-launched daemon threads. The original
+``python script.py`` process exits (killing its threads) after spawning this;
+all file-watching and worker management happens here.
+
+Usage (internal only):
+    python -m danvas._hotreload_monitor <main_file> <port> <tunnel 0|1> <provider> [broker 0|1]
+
+Extra ``serve(watch=...)`` globs ride in the ``_danvas_RELOAD_WATCH`` env var
+(a JSON list) rather than argv, so they don't collide with the positional args.
+"""
+
+import json
+import os
+import sys
+
+from danvas.hotreload import run_monitor
+
+if __name__ == "__main__":
+    main_file, port_s, tunnel_s, provider = sys.argv[1:5]
+    broker = bool(int(sys.argv[5])) if len(sys.argv) > 5 else False
+    watch = json.loads(os.environ.get("_danvas_RELOAD_WATCH", "[]"))
+    run_monitor(main_file, port=int(port_s),
+                tunnel=bool(int(tunnel_s)), tunnel_provider=provider,
+                watch=watch, broker=broker)