spectra-plot 0.2.0__tar.gz → 0.2.1__tar.gz

{spectra_plot-0.2.0/spectra_plot.egg-info → spectra_plot-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: spectra-plot
-Version: 0.2.0
+Version: 0.2.1
 Summary: GPU-accelerated scientific plotting via IPC
 License: MIT
 Classifier: Development Status :: 3 - Alpha

spectra_plot-0.2.1/VERSION

@@ -0,0 +1 @@
+0.2.1

{spectra_plot-0.2.0 → spectra_plot-0.2.1}/pyproject.toml

@@ -26,6 +26,9 @@ classifiers = [
 numpy = ["numpy>=1.20"]
 dev = ["pytest>=7.0", "numpy>=1.20"]
 
+[project.scripts]
+spectra-backend = "spectra._cli:backend_main"
+
 [tool.setuptools.dynamic]
 version = {file = "VERSION"}
 

spectra_plot-0.2.1/spectra/_cli.py

@@ -0,0 +1,61 @@
+"""Command-line entry points for spectra."""
+
+import os
+import sys
+
+
+def backend_main():
+    """Entry point for 'spectra-backend' console script.
+
+    Forwards all arguments to the bundled spectra-backend binary.
+    Supports --download to pre-fetch the binary without running it.
+    """
+    # Handle --download: fetch binary and exit
+    if len(sys.argv) > 1 and sys.argv[1] == "--download":
+        from ._download import download_backend
+        try:
+            path = download_backend()
+            print(f"spectra-backend ready: {path}")
+        except Exception as exc:
+            print(f"Download failed: {exc}", file=sys.stderr)
+            sys.exit(1)
+        sys.exit(0)
+
+    from ._launcher import _find_backend_binary
+
+    binary = _find_backend_binary()
+
+    # If not found locally, try auto-download
+    if binary is None:
+        try:
+            from ._download import download_backend
+            download_backend()
+            binary = _find_backend_binary()
+        except Exception as exc:
+            print(f"Auto-download failed: {exc}", file=sys.stderr)
+
+    if binary is None:
+        print(
+            "spectra-backend native binary not found.\n"
+            "Install the spectra-plot wheel (includes the binary), "
+            "set SPECTRA_BACKEND_PATH, or build with CMake "
+            "(cmake -B build -DSPECTRA_RUNTIME_MODE=multiproc).\n"
+            "Or run: spectra-backend --download",
+            file=sys.stderr,
+        )
+        sys.exit(1)
+
+    # Safety: the binary must be a native executable, not this script.
+    # _find_backend_binary already filters non-native binaries, but
+    # guard against future regressions that could cause an exec loop.
+    resolved = os.path.realpath(binary)
+    this_script = os.path.realpath(sys.argv[0])
+    if resolved == this_script:
+        print(
+            "spectra-backend: refusing to exec self (would loop). "
+            "Set SPECTRA_BACKEND_PATH to the native binary.",
+            file=sys.stderr,
+        )
+        sys.exit(1)
+
+    os.execv(binary, [binary] + sys.argv[1:])

spectra_plot-0.2.1/spectra/_download.py

@@ -0,0 +1,191 @@
+"""Download pre-built spectra-backend binaries from GitHub Releases.
+
+When spectra-plot is installed as a pure-Python package (e.g. via sdist or
+editable install), no compiled backend is bundled.  This module downloads the
+correct platform-specific binary on first use and caches it locally.
+
+Cache location (respects XDG / platform conventions):
+  Linux   : $XDG_DATA_HOME/spectra/bin/  or ~/.local/share/spectra/bin/
+  macOS   : ~/Library/Application Support/spectra/bin/
+  Windows : %LOCALAPPDATA%/spectra/bin/
+"""
+
+import io
+import os
+import platform
+import stat
+import sys
+import tarfile
+import zipfile
+from typing import Optional, Tuple
+from urllib.error import URLError
+from urllib.request import urlopen, Request
+
+# ── Constants ────────────────────────────────────────────────────────────────
+
+GITHUB_REPO = "danlil240/Spectra"
+_ASSET_PREFIX = "spectra-backend-"
+
+# Map (system, machine) to the asset suffix used in GitHub Releases.
+_PLATFORM_MAP = {
+    ("Linux", "x86_64"): "linux-x86_64",
+    ("Linux", "aarch64"): "linux-aarch64",
+    ("Darwin", "arm64"): "macos-arm64",
+    ("Darwin", "x86_64"): "macos-x86_64",
+    ("Windows", "AMD64"): "windows-x86_64",
+}
+
+
+def _detect_platform() -> str:
+    """Return the platform tag (e.g. 'linux-x86_64')."""
+    key = (platform.system(), platform.machine())
+    tag = _PLATFORM_MAP.get(key)
+    if tag is None:
+        raise RuntimeError(
+            f"No pre-built spectra-backend available for {key[0]}/{key[1]}. "
+            "Build from source: cmake -B build -DSPECTRA_RUNTIME_MODE=multiproc"
+        )
+    return tag
+
+
+def _cache_dir() -> str:
+    """Return the platform-appropriate cache directory for Spectra binaries."""
+    system = platform.system()
+    if system == "Linux":
+        base = os.environ.get("XDG_DATA_HOME", os.path.expanduser("~/.local/share"))
+    elif system == "Darwin":
+        base = os.path.expanduser("~/Library/Application Support")
+    elif system == "Windows":
+        base = os.environ.get("LOCALAPPDATA", os.path.expanduser("~/AppData/Local"))
+    else:
+        base = os.path.expanduser("~/.local/share")
+    return os.path.join(base, "spectra", "bin")
+
+
+def _read_version() -> str:
+    """Read the package version to match against GitHub Release tags."""
+    try:
+        from importlib.metadata import version
+        return version("spectra-plot")
+    except Exception:
+        pass
+    # Fallback: read VERSION file shipped next to this module
+    version_file = os.path.join(os.path.dirname(__file__), "..", "VERSION")
+    if os.path.isfile(version_file):
+        return open(version_file).read().strip()
+    return ""
+
+
+def _asset_url(tag: str, plat: str) -> Tuple[str, str]:
+    """Return (url, archive_name) for the asset.
+
+    Archive naming convention set by CI:
+      spectra-backend-{platform}.tar.gz   (Linux/macOS)
+      spectra-backend-{platform}.zip      (Windows)
+    """
+    ext = "zip" if plat.startswith("windows") else "tar.gz"
+    name = f"{_ASSET_PREFIX}{plat}.{ext}"
+    url = f"https://github.com/{GITHUB_REPO}/releases/download/v{tag}/{name}"
+    return url, name
+
+
+def _download_and_extract(url: str, dest_dir: str) -> None:
+    """Download an archive from *url* and extract binaries into *dest_dir*."""
+    req = Request(url, headers={"Accept": "application/octet-stream"})
+    try:
+        resp = urlopen(req, timeout=60)  # noqa: S310 — URL is hardcoded to GitHub
+        data = resp.read()
+    except URLError as exc:
+        raise RuntimeError(
+            f"Failed to download spectra-backend from {url}: {exc}"
+        ) from exc
+
+    os.makedirs(dest_dir, mode=0o755, exist_ok=True)
+
+    if url.endswith(".tar.gz"):
+        with tarfile.open(fileobj=io.BytesIO(data), mode="r:gz") as tf:
+            # Only extract known binary names to avoid path traversal
+            for member in tf.getmembers():
+                basename = os.path.basename(member.name)
+                if basename in ("spectra-backend", "spectra-window"):
+                    member.name = basename  # flatten into dest_dir
+                    tf.extract(member, dest_dir)
+                    _make_executable(os.path.join(dest_dir, basename))
+    elif url.endswith(".zip"):
+        with zipfile.ZipFile(io.BytesIO(data)) as zf:
+            for info in zf.infolist():
+                basename = os.path.basename(info.filename)
+                if basename in ("spectra-backend.exe", "spectra-window.exe",
+                                "spectra-backend", "spectra-window"):
+                    target = os.path.join(dest_dir, basename)
+                    with zf.open(info) as src, open(target, "wb") as dst:
+                        dst.write(src.read())
+                    _make_executable(target)
+    else:
+        raise RuntimeError(f"Unknown archive format: {url}")
+
+
+def _make_executable(path: str) -> None:
+    """chmod +x on non-Windows."""
+    if platform.system() != "Windows":
+        st = os.stat(path)
+        os.chmod(path, st.st_mode | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH)
+
+
+def _version_marker(cache: str) -> str:
+    return os.path.join(cache, ".version")
+
+
+def find_cached_backend() -> Optional[str]:
+    """Return path to a cached spectra-backend binary, or None."""
+    cache = _cache_dir()
+    suffix = ".exe" if platform.system() == "Windows" else ""
+    backend = os.path.join(cache, f"spectra-backend{suffix}")
+    if os.path.isfile(backend) and os.access(backend, os.X_OK):
+        return backend
+    return None
+
+
+def download_backend(version: Optional[str] = None) -> str:
+    """Download the spectra-backend binary for this platform.
+
+    Returns the path to the downloaded binary.
+    Raises RuntimeError on failure.
+    """
+    plat = _detect_platform()
+    ver = version or _read_version()
+    if not ver:
+        raise RuntimeError(
+            "Cannot determine spectra-plot version for download. "
+            "Set SPECTRA_BACKEND_PATH or install a platform wheel."
+        )
+
+    cache = _cache_dir()
+    marker = _version_marker(cache)
+
+    # Skip download if version already matches
+    if os.path.isfile(marker):
+        cached_ver = open(marker).read().strip()
+        cached_bin = find_cached_backend()
+        if cached_ver == ver and cached_bin:
+            return cached_bin
+
+    url, _ = _asset_url(ver, plat)
+    print(
+        f"[spectra] Downloading backend for {plat} (v{ver})...",
+        file=sys.stderr,
+    )
+    _download_and_extract(url, cache)
+
+    # Record version
+    with open(marker, "w") as f:
+        f.write(ver)
+
+    result = find_cached_backend()
+    if result is None:
+        raise RuntimeError(
+            f"Download succeeded but spectra-backend not found in {cache}. "
+            "This is a packaging bug — please file an issue."
+        )
+    print(f"[spectra] Backend ready: {result}", file=sys.stderr)
+    return result

{spectra_plot-0.2.0 → spectra_plot-0.2.1}/spectra/_easy.py

@@ -136,6 +136,7 @@ class _EasyState:
         self._live_stop_events: List[threading.Event] = []
         self._shutting_down = False
         self._axes_bounds: dict = {}  # id(axes) -> [xmin, xmax, ymin, ymax]
+        self._subplot_cache: dict = {}  # (figure_id, rows, cols, index) -> Axes
 
     def _ensure_session(self):
         """Lazily create the backend session."""
@@ -197,6 +198,8 @@ class _EasyState:
         self._current_axes3d = None
         self._figures.clear()
         self._axes_bounds.clear()
+        self._subplot_cache.clear()
+        self._shutting_down = False
 
 
 _state = _EasyState()
@@ -267,9 +270,17 @@ def subplot(rows: int, cols: int, index: int):
     Uses 1-based indexing: subplot(2, 1, 1) = top of 2-row layout.
     """
     fig = _state._ensure_figure()
+    cache_key = (fig.id, rows, cols, index)
+    cached = _state._subplot_cache.get(cache_key)
+    if cached is not None:
+        _state._current_axes_key = (rows, cols, index)
+        _state._current_axes = cached
+        _state._current_axes3d = None
+        return cached
     _state._current_axes_key = (rows, cols, index)
     _state._current_axes = fig.subplot(rows, cols, index)
     _state._current_axes3d = None
+    _state._subplot_cache[cache_key] = _state._current_axes
     return _state._current_axes
 
 
@@ -279,8 +290,15 @@ def subplot3d(rows: int = 1, cols: int = 1, index: int = 1):
     Uses 1-based indexing: subplot3d(2, 1, 1) = top of 2-row layout.
     """
     fig = _state._ensure_figure()
+    cache_key = (fig.id, rows, cols, index, '3d')
+    cached = _state._subplot_cache.get(cache_key)
+    if cached is not None:
+        _state._current_axes3d = cached
+        _state._current_axes = None
+        return cached
     _state._current_axes3d = fig.subplot3d(rows, cols, index)
     _state._current_axes = None
+    _state._subplot_cache[cache_key] = _state._current_axes3d
     return _state._current_axes3d
 
 

{spectra_plot-0.2.0 → spectra_plot-0.2.1}/spectra/_launcher.py

@@ -59,14 +59,33 @@ def _can_connect(path: str) -> bool:
         return False
 
 
+def _is_native_binary(path: str) -> bool:
+    """Return True if *path* looks like a compiled (ELF / Mach-O) executable
+    rather than a script wrapper (e.g. the pip-installed console_scripts shim).
+    """
+    try:
+        with open(path, "rb") as f:
+            magic = f.read(4)
+        # ELF: \x7fELF  |  Mach-O: \xfe\xed\xfa\xce / \xcf\xfa\xed\xfe
+        return magic[:4] == b"\x7fELF" or magic[:4] in (
+            b"\xfe\xed\xfa\xce",
+            b"\xfe\xed\xfa\xcf",
+            b"\xcf\xfa\xed\xfe",
+            b"\xce\xfa\xed\xfe",
+        )
+    except OSError:
+        return False
+
+
 def _find_backend_binary() -> Optional[str]:
     """Find the spectra-backend binary.
 
     Search order:
     1. $SPECTRA_BACKEND_PATH env var
     2. Bundled binary inside pip-installed package (_bin/spectra-backend)
-    3. System PATH
-    4. Heuristic: common build directories relative to project root
+    3. Heuristic: common build directories relative to project root
+    4. System PATH (filtered — skips script wrappers to avoid exec loops)
+    5. Previously downloaded binary in user cache
     """
     # 1. Explicit env var
     env_path = os.environ.get("SPECTRA_BACKEND_PATH")
@@ -90,11 +109,20 @@ def _find_backend_binary() -> Optional[str]:
         if os.path.isfile(candidate) and os.access(candidate, os.X_OK):
             return candidate
 
-    # 4. System PATH (fallback — may find stale installed binaries)
+    # 4. System PATH (fallback — may find stale installed binaries).
+    #    Skip script wrappers (e.g. the pip console_scripts shim) to avoid
+    #    an infinite os.execv loop where the wrapper calls _find_backend_binary
+    #    which finds the wrapper again.
     found = shutil.which("spectra-backend")
-    if found:
+    if found and _is_native_binary(found):
         return found
 
+    # 5. Previously downloaded binary in user cache
+    from ._download import find_cached_backend
+    cached = find_cached_backend()
+    if cached:
+        return cached
+
     return None
 
 
@@ -109,10 +137,27 @@ def ensure_backend(socket_path: str, timeout: float = 5.0) -> str:
 
     binary = _find_backend_binary()
     if binary is None:
-        raise RuntimeError(
-            "spectra-backend binary not found. "
-            "Set SPECTRA_BACKEND_PATH or add it to PATH."
-        )
+        # No binary found locally — try downloading from GitHub Releases
+        if os.environ.get("SPECTRA_NO_DOWNLOAD", "").lower() not in ("1", "true", "yes"):
+            try:
+                from ._download import download_backend
+                download_backend()
+                binary = _find_backend_binary()
+            except Exception as dl_err:
+                # Download failed — fall through to the error below with a hint
+                _dl_hint = f"\nAuto-download failed: {dl_err}"
+            else:
+                _dl_hint = ""
+        else:
+            _dl_hint = "\n(Auto-download disabled by SPECTRA_NO_DOWNLOAD)"
+        if binary is None:
+            raise RuntimeError(
+                "spectra-backend binary not found. "
+                "Install the spectra-plot wheel (includes the binary), "
+                "set SPECTRA_BACKEND_PATH, or build with CMake "
+                "(cmake -B build -DSPECTRA_RUNTIME_MODE=multiproc)."
+                + _dl_hint
+            )
 
     # Ensure socket directory exists
     sock_dir = os.path.dirname(socket_path)
@@ -129,7 +174,7 @@ def ensure_backend(socket_path: str, timeout: float = 5.0) -> str:
     # Launch backend
     _debug_log = os.environ.get("SPECTRA_DEBUG_LOG")
     _stderr_target = open(_debug_log, "w") if _debug_log else subprocess.PIPE
-    subprocess.Popen(
+    proc = subprocess.Popen(
         [binary, "--socket", socket_path],
         stdout=subprocess.DEVNULL,
         stderr=_stderr_target,
@@ -141,9 +186,20 @@ def ensure_backend(socket_path: str, timeout: float = 5.0) -> str:
     while time.monotonic() < deadline:
         if _can_connect(socket_path):
             return socket_path
+        # If the process already exited, don't keep waiting
+        if proc.poll() is not None:
+            break
         time.sleep(0.05)
 
+    # Collect stderr for the error message if available
+    hint = ""
+    if proc.poll() is not None and _stderr_target == subprocess.PIPE:
+        stderr_bytes = proc.stderr.read() if proc.stderr else b""
+        if stderr_bytes:
+            hint = f"\nBackend stderr:\n{stderr_bytes.decode(errors='replace').rstrip()}"
+
     raise RuntimeError(
         f"spectra-backend did not start within {timeout}s. "
-        f"Socket: {socket_path}"
+        f"Binary: {binary}\n"
+        f"Socket: {socket_path}{hint}"
     )

{spectra_plot-0.2.0 → spectra_plot-0.2.1/spectra_plot.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: spectra-plot
-Version: 0.2.0
+Version: 0.2.1
 Summary: GPU-accelerated scientific plotting via IPC
 License: MIT
 Classifier: Development Status :: 3 - Alpha

{spectra_plot-0.2.0 → spectra_plot-0.2.1}/spectra_plot.egg-info/SOURCES.txt

@@ -7,6 +7,7 @@ spectra/_axes.py
 spectra/_blob.py
 spectra/_cli.py
 spectra/_codec.py
+spectra/_download.py
 spectra/_easy.py
 spectra/_embed.py
 spectra/_errors.py
@@ -25,10 +26,12 @@ spectra/backends/backend_qtagg.py
 spectra_plot.egg-info/PKG-INFO
 spectra_plot.egg-info/SOURCES.txt
 spectra_plot.egg-info/dependency_links.txt
+spectra_plot.egg-info/entry_points.txt
 spectra_plot.egg-info/requires.txt
 spectra_plot.egg-info/top_level.txt
 tests/test_codec.py
 tests/test_cross_codec.py
+tests/test_download.py
 tests/test_easy.py
 tests/test_easy_embed.py
 tests/test_embed.py

spectra_plot-0.2.1/spectra_plot.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+spectra-backend = spectra._cli:backend_main

spectra_plot-0.2.1/tests/test_download.py

@@ -0,0 +1,110 @@
+#!/usr/bin/env python3
+"""Quick test for _download module logic."""
+import io
+import os
+import sys
+import tarfile
+import tempfile
+import shutil
+
+sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), "python"))
+
+from spectra._download import (
+    _detect_platform,
+    _cache_dir,
+    _asset_url,
+    _read_version,
+    _download_and_extract,
+    find_cached_backend,
+)
+import spectra._download as dl
+
+
+def test_platform_detection():
+    plat = _detect_platform()
+    assert plat == "linux-x86_64"
+
+
+def test_cache_directory():
+    cache = _cache_dir()
+    assert "spectra" in cache and "bin" in cache
+
+
+def test_asset_url_linux():
+    url, name = _asset_url("0.2.1", "linux-x86_64")
+    assert url == "https://github.com/danlil240/Spectra/releases/download/v0.2.1/spectra-backend-linux-x86_64.tar.gz"
+    assert name == "spectra-backend-linux-x86_64.tar.gz"
+
+
+def test_asset_url_windows():
+    url_w, name_w = _asset_url("0.2.1", "windows-x86_64")
+    assert url_w.endswith(".zip")
+    assert name_w.endswith(".zip")
+
+
+class FakeResp:
+    def __init__(self, data):
+        self._data = data
+    def read(self):
+        return self._data
+
+
+def test_tar_extraction():
+    buf = io.BytesIO()
+    with tarfile.open(fileobj=buf, mode="w:gz") as tf:
+        for n in ("bin/spectra-backend", "bin/spectra-window"):
+            info = tarfile.TarInfo(name=n)
+            data = b"\x7fELF" + b"\x00" * 100
+            info.size = len(data)
+            tf.addfile(info, io.BytesIO(data))
+    buf.seek(0)
+    tmpdir = tempfile.mkdtemp()
+    orig_urlopen = dl.urlopen
+
+    dl.urlopen = lambda req, timeout=60: FakeResp(buf.read())
+    try:
+        dl._download_and_extract("http://fake/test.tar.gz", tmpdir)
+        assert os.path.isfile(os.path.join(tmpdir, "spectra-backend"))
+        assert os.path.isfile(os.path.join(tmpdir, "spectra-window"))
+        assert os.access(os.path.join(tmpdir, "spectra-backend"), os.X_OK)
+    finally:
+        dl.urlopen = orig_urlopen
+        shutil.rmtree(tmpdir)
+
+
+def test_path_traversal_protection():
+    """Verify only allowed binaries are extracted, regardless of tar member names."""
+    buf2 = io.BytesIO()
+    with tarfile.open(fileobj=buf2, mode="w:gz") as tf:
+        info = tarfile.TarInfo(name="spectra-backend")
+        data = b"\x7fELF" + b"\x00" * 50
+        info.size = len(data)
+        tf.addfile(info, io.BytesIO(data))
+        # Malicious entry — basename "evilfile" is not in the allowed list
+        info2 = tarfile.TarInfo(name="../../tmp/evilfile")
+        data2 = b"evil"
+        info2.size = len(data2)
+        tf.addfile(info2, io.BytesIO(data2))
+        # Another malicious entry with an allowed-sounding directory
+        info3 = tarfile.TarInfo(name="../malicious")
+        data3 = b"bad"
+        info3.size = len(data3)
+        tf.addfile(info3, io.BytesIO(data3))
+    buf2.seek(0)
+    tmpdir2 = tempfile.mkdtemp()
+    orig_urlopen = dl.urlopen
+    dl.urlopen = lambda req, timeout=60: FakeResp(buf2.read())
+    try:
+        dl._download_and_extract("http://fake/test.tar.gz", tmpdir2)
+        assert os.path.isfile(os.path.join(tmpdir2, "spectra-backend"))
+        # Only spectra-backend should exist — nothing else
+        extracted = os.listdir(tmpdir2)
+        assert sorted(extracted) == ["spectra-backend"], f"Unexpected files: {extracted}"
+    finally:
+        dl.urlopen = orig_urlopen
+        shutil.rmtree(tmpdir2)
+
+
+def test_version_reading():
+    ver = _read_version()
+    assert ver, "Version should not be empty"

{spectra_plot-0.2.0 → spectra_plot-0.2.1}/tests/test_easy.py

@@ -175,7 +175,7 @@ class TestEasyState:
     def test_shutdown_without_session(self):
         state = _EasyState()
         state.shutdown()  # should not raise
-        assert state._shutting_down is True
+        assert state._shutting_down is False  # reset so new plots can be created
         assert state._session is None
 
     def test_double_shutdown(self):

{spectra_plot-0.2.0 → spectra_plot-0.2.1}/tests/test_phase2.py

@@ -279,7 +279,7 @@ class TestConvenienceAPI:
     def test_version_exists(self):
         import spectra as sp
         assert hasattr(sp, "__version__")
-        assert sp.__version__ == "0.1.0"
+        assert sp.__version__ == "0.2.0"
 
     def test_session_class_exported(self):
         from spectra import Session

spectra_plot-0.2.0/VERSION

@@ -1 +0,0 @@
-0.2.0

spectra_plot-0.2.0/spectra/_cli.py

@@ -1,23 +0,0 @@
-"""Command-line entry points for spectra."""
-
-import os
-import sys
-
-
-def backend_main():
-    """Entry point for 'spectra-backend' console script.
-
-    Forwards all arguments to the bundled spectra-backend binary.
-    """
-    from ._launcher import _find_backend_binary
-
-    binary = _find_backend_binary()
-    if binary is None:
-        print(
-            "spectra-backend binary not found. "
-            "Set SPECTRA_BACKEND_PATH or rebuild with CMake.",
-            file=sys.stderr,
-        )
-        sys.exit(1)
-
-    os.execv(binary, [binary] + sys.argv[1:])