qmlmathplot 0.4.4__py3-none-any.whl → 0.6.0__py3-none-any.whl

qmlmathplot/__init__.py

@@ -20,7 +20,7 @@ QtWidgets layout in one line:
 
 Qt Quick (QML) — the component plus the model:
 
-    import QmlMathPlot 1.0
+    import QmlMathPlot 2.0
     PlotView { plot: myPlot; anchors.fill: parent }
 
     from PySide6.QtGui import QGuiApplication
@@ -50,30 +50,24 @@ Demos: ``examples/minimal.py``, ``examples/explorer_qtwidgets.py``,
 
 from typing import TYPE_CHECKING
 
-from .camera import HOME_SIZE, HOME_VIEW, Camera, nice_ticks
-from .curve import Curve, CurveListModel, ImplicitCurve
-from .figure import Axes, Figure
-from .input import ViewInput
-from .overlay import Annotation, Guide
-from .plot import Plot
-from .qsb import cache_dir, cache_info, clear_cache, prune_cache
-from .view import QML_MAJOR, QML_MINOR, QML_URI, qml_component_path, register_qml_types
-
 if TYPE_CHECKING:  # only for type checkers; at runtime the module-level __getattr__ is used
-    from .canvas import FigureCanvasQt
+    from .camera import HOME_SIZE, HOME_VIEW, Camera, nice_ticks
+    from .curve import Curve, CurveListModel, ImplicitCurve
+    from .input import ViewInput
+    from .overlay import Annotation, Guide
+    from .plot import Plot
+    from .qsb import cache_dir, cache_info, clear_cache, prune_cache
+    from .view import QML_MAJOR, QML_MINOR, QML_URI, qml_component_path, register_qml_types
     from .widget import MathPlotWidget
 
 __all__ = [
     "Annotation",
-    "Axes",
     "cache_dir",
     "cache_info",
     "Camera",
     "clear_cache",
     "Curve",
     "CurveListModel",
-    "Figure",
-    "FigureCanvasQt",
     "Guide",
     "HOME_SIZE",
     "HOME_VIEW",
@@ -91,18 +85,45 @@ __all__ = [
 ]
 
 
-def __getattr__(name: str) -> object:
-    """QtWidgets-backed names are lazy, so pure-QML use never loads QtWidgets."""
-    if name == "MathPlotWidget":
-        from .widget import MathPlotWidget
-
-        return MathPlotWidget
-    if name == "FigureCanvasQt":
-        from .canvas import FigureCanvasQt
+#: name -> (module, attribute). ``None`` for the attribute means "the module itself".
+_LAZY: dict[str, tuple[str, str | None]] = {
+    "Annotation": (".overlay", "Annotation"),
+        "cache_dir": (".qsb", "cache_dir"),
+    "cache_info": (".qsb", "cache_info"),
+    "Camera": (".camera", "Camera"),
+    "clear_cache": (".qsb", "clear_cache"),
+    "Curve": (".curve", "Curve"),
+    "CurveListModel": (".curve", "CurveListModel"),
+            "Guide": (".overlay", "Guide"),
+    "HOME_SIZE": (".camera", "HOME_SIZE"),
+    "HOME_VIEW": (".camera", "HOME_VIEW"),
+    "ImplicitCurve": (".curve", "ImplicitCurve"),
+    "MathPlotWidget": (".widget", "MathPlotWidget"),
+    "nice_ticks": (".camera", "nice_ticks"),
+    "Plot": (".plot", "Plot"),
+    "prune_cache": (".qsb", "prune_cache"),
+        "qml_component_path": (".view", "qml_component_path"),
+    "QML_MAJOR": (".view", "QML_MAJOR"),
+    "QML_MINOR": (".view", "QML_MINOR"),
+    "QML_URI": (".view", "QML_URI"),
+    "register_qml_types": (".view", "register_qml_types"),
+    "ViewInput": (".input", "ViewInput"),
+}
 
-        return FigureCanvasQt
-    if name == "pyplot":
-        from importlib import import_module
 
-        return import_module(".pyplot", __name__)
-    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+def __getattr__(name: str) -> object:
+    """Resolve public names lazily.
+
+    Nothing is imported at package-import time: ``import qmlmathplot`` must not load Qt or
+    sympy, so a host that only needs the calculator protocol (or a QML-only app) pays for
+    nothing it does not use. The same laziness keeps the calculator process free of Qt.
+    """
+    target = _LAZY.get(name)
+    if target is None:
+        raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+    from importlib import import_module
+
+    module = import_module(target[0], __name__)
+    value = module if target[1] is None else getattr(module, target[1])
+    globals()[name] = value
+    return value

qmlmathplot/calc/__init__.py

@@ -0,0 +1,11 @@
+"""The calculator side: sympy lives here, not in the model.
+
+``build_program`` is Qt-free, so it runs both in-process and inside the worker launched by
+``python -m qmlmathplot.calc``.
+"""
+
+from __future__ import annotations
+
+from .build import build_program, python_sources
+
+__all__ = ["build_program", "python_sources"]

qmlmathplot/calc/__main__.py

@@ -0,0 +1,61 @@
+"""Worker process entry point: ``python -m qmlmathplot.calc``.
+
+Reads length-prefixed JSON requests from stdin and writes one response per request to
+stdout. Nothing but frames is ever written to stdout (import-time noise from sympy goes to
+stderr, which the client drains), so the channel is safe to parse.
+"""
+
+from __future__ import annotations
+
+import sys
+
+from ..protocol import (
+    SCHEMA,
+    Program,
+    decode_frames,
+    encode_frame,
+    parse_request,
+    response_payload,
+)
+from .build import build_program
+
+__all__ = ["main"]
+
+
+def _error_program(payload: object) -> tuple[int, Program]:
+    text = ""
+    request_id = 0
+    if isinstance(payload, dict):
+        request_id = int(payload.get("id", 0) or 0)
+        text = str(payload.get("text", ""))
+    return request_id, Program(text=text, error="malformed request")
+
+
+def main() -> int:
+    stdin = sys.stdin.buffer
+    stdout = sys.stdout.buffer
+    buffer = b""
+    while True:
+        chunk = stdin.read1(65536) if hasattr(stdin, "read1") else stdin.read(65536)
+        if not chunk:
+            break
+        buffer += chunk
+        try:
+            frames, buffer = decode_frames(buffer, limit=64)
+        except ValueError as exc:
+            stdout.write(encode_frame({"schema": SCHEMA, "id": 0, "error": str(exc)}))
+            stdout.flush()
+            return 1
+        for payload in frames:
+            try:
+                request_id, text, implicit = parse_request(payload)
+                program = build_program(text, implicit=implicit)
+            except Exception:  # noqa: BLE001 - a bad frame must not kill the worker
+                request_id, program = _error_program(payload)
+            stdout.write(encode_frame(response_payload(request_id, program)))
+            stdout.flush()
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

qmlmathplot/calc/build.py

@@ -0,0 +1,103 @@
+"""Text -> :class:`Program`. The only place in the package that needs sympy at runtime.
+
+Kept Qt-free on purpose: the same code runs in-process (:class:`qmlmathplot.client.
+InlineCalculator`) and inside the worker process (``python -m qmlmathplot.calc``). The
+routing rules are the model's established ones: an equation or a free ``y`` is a level set,
+an expression the interval gate accepts is drawn by the compute path, everything else goes
+through the CPU plotter. Shader sources and Python sources are generated here so the model
+never parses an expression again.
+"""
+
+from __future__ import annotations
+
+import sympy as sp
+from sympy.printing.numpy import NumPyPrinter
+
+from ..ggb_compute import path_compute_source
+from ..interval import compute_supported
+from ..model import implicit_shader_sources
+from ..protocol import Program
+
+__all__ = ["build_program", "python_sources"]
+
+_EXTRA_SYMBOLS = "substitute parameters first"
+
+
+def _parse(text: str) -> tuple[str, sp.Expr, bool]:
+    """Canonical text, normalized expression, and whether the input was an equation.
+
+    Mirrors ``qmlmathplot.curve._parse``: an ``Eq(lhs, rhs)`` becomes the level set
+    ``lhs - rhs = 0`` and is always implicit.
+    """
+    expr = sp.sympify(text, locals={"x": sp.Symbol("x"), "y": sp.Symbol("y")})
+    if not isinstance(expr, sp.Basic):
+        raise ValueError(f"cannot parse {text!r}")
+    if isinstance(expr, sp.Eq):
+        return text, expr.lhs - expr.rhs, True
+    return text, expr, False
+
+
+def python_sources(
+    expr: sp.Expr, args: tuple[str, ...], name: str
+) -> tuple[str | None, str | None]:
+    """``(math_source, numpy_source)``: complete function definitions, or ``None``.
+
+    The two differ in the module they call (``math`` vs ``numpy``) and in vectorisation; the
+    model uses ``math`` for its scalar sampler and ``numpy`` for vectorised work.
+    """
+    math_source = _define(expr, args, name, lambda node: sp.pycode(node))
+    numpy_source = _define(expr, args, name, NumPyPrinter().doprint)
+    return math_source, numpy_source
+
+
+def _define(
+    expr: sp.Expr,
+    args: tuple[str, ...],
+    name: str,
+    printer: object,
+) -> str | None:
+    try:
+        body = printer(expr)  # type: ignore[operator] - a callable passed by the caller
+    except Exception:  # noqa: BLE001 - some expressions have no printer representation
+        return None
+    signature = ", ".join(args)
+    return f"def {name}({signature}):\n    return {body}\n"
+
+
+def build_program(text: str, *, implicit: bool | None = None) -> Program:
+    """Turn one expression into a :class:`Program`; parse errors become ``Program.error``."""
+    text = str(text)
+    try:
+        _, expr, is_equation = _parse(text)
+    except Exception as exc:  # noqa: BLE001 - reported through the program
+        return Program(text=text, error=f"{type(exc).__name__}: {exc}")
+    names = {symbol.name for symbol in expr.free_symbols}
+    if names - {"x", "y"}:
+        return Program(
+            text=text,
+            error=(f"only x (or x and y) may be free, got {sorted(names - {'x', 'y'})}: "
+                   f"{_EXTRA_SYMBOLS}"),
+        )
+    level_set = bool(implicit) or is_equation or "y" in names
+    args: tuple[str, ...] = ("x", "y") if level_set else ("x",)
+    kind = "implicit" if level_set else "adaptive"
+    glsl: dict[str, str] = {}
+    error = ""
+    try:
+        if level_set:
+            glsl["fragment"] = implicit_shader_sources(expr)[1]
+        elif compute_supported(expr):
+            kind = "intervals"
+            glsl["compute"] = path_compute_source(expr)
+    except Exception as exc:  # noqa: BLE001 - the model keeps the last working shader
+        error = f"{type(exc).__name__}: {exc}"
+    math_source, numpy_source = python_sources(expr, args, "F" if level_set else "f")
+    return Program(
+        text=text,
+        kind=kind,  # type: ignore[arg-type]
+        args=args,
+        glsl=glsl,
+        numpy=numpy_source,
+        math=math_source,
+        error=error,
+    )

qmlmathplot/client.py

@@ -0,0 +1,243 @@
+"""Calculators: the injection point between the model and the expression source.
+
+The model never parses text. It asks a :class:`Calculator` for a
+:class:`~qmlmathplot.protocol.Program` and consumes that. Two implementations ship here:
+
+* :class:`InlineCalculator` — builds the program in the calling thread. Needed by scripts,
+  headless use and the test suite; it imports sympy lazily, on the first request.
+* :class:`ProcessCalculator` — asks a worker process (``python -m qmlmathplot.calc``). The
+  host owns the process: when to start it, how to ship it, when to stop it.
+
+Both deliver through the same ``ready`` / ``failed`` signals, so the model has exactly one
+state machine. A host may implement its own calculator (any language, any transport); it
+only has to produce programs.
+
+Results carry an opaque **token** chosen by the caller (the model uses its generation
+counter). The calculator never interprets it, so several curves may share one calculator
+without coordinating ids, and a stale answer is discarded by the caller.
+"""
+
+from __future__ import annotations
+
+import os
+import shlex
+import subprocess
+import sys
+import threading
+from collections import deque
+
+from PySide6.QtCore import QObject, Signal
+
+from .protocol import (
+    Program,
+    decode_frames,
+    encode_frame,
+    parse_response,
+    request_payload,
+)
+
+__all__ = ["Calculator", "InlineCalculator", "ProcessCalculator", "calculator_command"]
+
+#: Environment override for the worker command line (any executable/shell words).
+COMMAND_ENV = "QMLMATHPLOT_CALC"
+
+
+def calculator_command() -> list[str]:
+    """The worker command: ``$QMLMATHPLOT_CALC`` if set, else this interpreter's module."""
+    override = os.environ.get(COMMAND_ENV)
+    if override:
+        return shlex.split(override, posix=False)
+    return [sys.executable, "-m", "qmlmathplot.calc"]
+
+
+class Calculator(QObject):
+    """Asynchronous expression source: ``request`` now, ``ready``/``failed`` later."""
+
+    #: ``(token, Program)``. Always emitted for a well-formed request, including parse errors
+    #: (which arrive as ``Program.error``).
+    ready = Signal(object, object)
+    #: ``(token, message)`` — transport failures only (worker died, timeout, bad frame).
+    failed = Signal(object, str)
+
+    def request(self, text: str, implicit: bool | None = None, *, token: object = None) -> None:
+        """Ask for a program. The result signals carry ``token`` back."""
+        raise NotImplementedError
+
+    def close(self) -> None:
+        """Release resources (the inline calculator has none)."""
+
+
+class InlineCalculator(Calculator):
+    """Build programs in-process — the default, and what the tests use."""
+
+    def request(self, text: str, implicit: bool | None = None, *, token: object = None) -> None:
+        try:
+            from .calc import build_program
+        except ImportError:  # the core install has no sympy; the host can inject a process
+            self.failed.emit(
+                token,
+                "the in-process calculator needs sympy: pip install 'qmlmathplot[calc]' "
+                "(or inject a ProcessCalculator / your own Calculator)",
+            )
+            return
+        self.ready.emit(token, build_program(text, implicit=implicit))
+
+
+class ProcessCalculator(Calculator):
+    """Ask a worker process; framed JSON over its stdin/stdout.
+
+    The worker is started on the first request and restarted after a crash. One request is in
+    flight per token; the reader and stderr-drain threads spend their time blocked in C
+    reads, so they do not hold the GIL.
+    """
+
+    def __init__(
+        self,
+        command: list[str] | None = None,
+        *,
+        timeout: float = 10.0,
+        parent: QObject | None = None,
+    ) -> None:
+        super().__init__(parent)
+        self._command = list(command) if command is not None else calculator_command()
+        self._timeout = float(timeout)
+        self._lock = threading.Lock()
+        self._process: subprocess.Popen[bytes] | None = None
+        self._pending: dict[int, tuple[object, threading.Timer]] = {}
+        self._stderr: deque[str] = deque(maxlen=20)
+        self._next_id = 0
+        self._closed = False
+
+    # ------------------------------------------------------------------ public
+    def request(self, text: str, implicit: bool | None = None, *, token: object = None) -> None:
+        if self._closed:
+            raise RuntimeError("this calculator has been closed")
+        self._ensure_started()
+        self._next_id += 1
+        wire_id = self._next_id
+        payload = request_payload(wire_id, text, implicit)
+        timer = threading.Timer(self._timeout, self._on_timeout, args=(wire_id,))
+        timer.daemon = True
+        with self._lock:
+            self._pending[wire_id] = (token, timer)
+        timer.start()
+        try:
+            assert self._process is not None and self._process.stdin is not None
+            self._process.stdin.write(encode_frame(payload))
+            self._process.stdin.flush()
+        except (OSError, ValueError) as exc:
+            self._finish(wire_id, error=f"calculator write failed: {exc}")
+
+    def close(self) -> None:
+        self._closed = True
+        process = self._process
+        self._process = None
+        if process is not None:
+            try:
+                process.terminate()
+                process.wait(timeout=2.0)
+            except (OSError, subprocess.TimeoutExpired):
+                process.kill()
+        with self._lock:
+            timers = [timer for _token, timer in self._pending.values()]
+            self._pending.clear()
+        for timer in timers:
+            timer.cancel()
+
+    # --------------------------------------------------------------- internals
+    def _ensure_started(self) -> None:
+        if self._process is not None and self._process.poll() is None:
+            return
+        flags = 0
+        if sys.platform == "win32":           # no console window from a GUI host (AGENTS 57)
+            flags = subprocess.CREATE_NO_WINDOW
+        self._process = subprocess.Popen(
+            self._command,
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            creationflags=flags,
+        )
+        threading.Thread(target=self._read_stdout, name="qmlmathplot-calc-out",
+                         daemon=True).start()
+        threading.Thread(target=self._read_stderr, name="qmlmathplot-calc-err",
+                         daemon=True).start()
+
+    def _read_stdout(self) -> None:
+        process = self._process
+        if process is None or process.stdout is None:
+            return
+        buffer = b""
+        while True:
+            try:
+                read = getattr(process.stdout, "read1", process.stdout.read)
+                chunk = read(65536)
+            except (OSError, ValueError):
+                break
+            if not chunk:
+                break
+            buffer += chunk
+            try:
+                frames, buffer = decode_frames(buffer, limit=64)
+            except ValueError as exc:
+                self._fail_all(f"calculator sent a bad frame: {exc}")
+                break
+            for payload in frames:
+                try:
+                    wire_id, program = parse_response(payload)
+                except ValueError as exc:
+                    self._fail_all(f"calculator sent a bad response: {exc}")
+                    continue
+                self._deliver(wire_id, program)
+        self._fail_all(self._death_message())
+
+    def _read_stderr(self) -> None:
+        process = self._process
+        if process is None or process.stderr is None:
+            return
+        while True:
+            line = process.stderr.readline()
+            if not line:
+                break
+            text = line.decode("utf-8", "replace").rstrip()
+            if text:
+                with self._lock:
+                    self._stderr.append(text)
+
+    def _death_message(self) -> str:
+        with self._lock:
+            tail = list(self._stderr)[-3:]
+        return "calculator process exited" + (": " + " | ".join(tail) if tail else "")
+
+    def _deliver(self, wire_id: int, program: Program) -> None:
+        entry = self._take(wire_id)
+        if entry is None:
+            return                           # already timed out / closed
+        token, timer = entry
+        timer.cancel()
+        self.ready.emit(token, program)
+
+    def _on_timeout(self, wire_id: int) -> None:
+        entry = self._take(wire_id)
+        if entry is not None:
+            token, _timer = entry
+            self.failed.emit(token, f"calculator timed out after {self._timeout:.1f} s")
+
+    def _finish(self, wire_id: int, *, error: str) -> None:
+        entry = self._take(wire_id)
+        if entry is not None:
+            token, timer = entry
+            timer.cancel()
+            self.failed.emit(token, error)
+
+    def _take(self, wire_id: int) -> tuple[object, threading.Timer] | None:
+        with self._lock:
+            return self._pending.pop(wire_id, None)
+
+    def _fail_all(self, message: str) -> None:
+        with self._lock:
+            pending = list(self._pending.values())
+            self._pending.clear()
+        for token, timer in pending:
+            timer.cancel()
+            self.failed.emit(token, message)