interactive-pipe 0.9.1__tar.gz → 0.9.2__tar.gz

{interactive_pipe-0.9.1/src/interactive_pipe.egg-info → interactive_pipe-0.9.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: interactive_pipe
-Version: 0.9.1
+Version: 0.9.2
 Summary: Library to create flexible interactive image processing pipelines and automatically add a graphical user interface without knowing anything about GUI coding!
 Author-email: Balthazar Neveu <balthazarneveu@gmail.com>
 Project-URL: Homepage, https://github.com/balthazarneveu/interactive_pipe
@@ -30,6 +30,14 @@ Requires-Dist: matplotlib>=3.5.3
 Requires-Dist: numpy>=1.21.6
 Requires-Dist: Pillow>=9.0.1
 Requires-Dist: PyYAML>=5.4.1
+Requires-Dist: PyQt6>=6.5.2
+Requires-Dist: PyQt6_sip>=13.5.2
+Requires-Dist: opencv_python_headless>=4.8.1.78
+Requires-Dist: pytest>=6.2.5
+Requires-Dist: ipywidgets>=7.7.1
+Requires-Dist: pandas
+Requires-Dist: gradio
+Requires-Dist: dearpygui>=1.11
 Provides-Extra: qt6
 Requires-Dist: PyQt6>=6.5.2; extra == "qt6"
 Requires-Dist: PyQt6_sip>=13.5.2; extra == "qt6"
@@ -38,6 +46,8 @@ Requires-Dist: PyQt5>=5.15.9; extra == "qt5"
 Requires-Dist: PyQt5_sip>=12.12.1; extra == "qt5"
 Provides-Extra: notebook
 Requires-Dist: ipywidgets>=7.7.1; extra == "notebook"
+Provides-Extra: dpg
+Requires-Dist: dearpygui>=1.11; extra == "dpg"
 Provides-Extra: pytest
 Requires-Dist: opencv_python_headless>=4.8.1.78; extra == "pytest"
 Requires-Dist: pytest>=6.2.5; extra == "pytest"
@@ -49,6 +59,7 @@ Requires-Dist: pytest>=6.2.5; extra == "full"
 Requires-Dist: ipywidgets>=7.7.1; extra == "full"
 Requires-Dist: pandas; extra == "full"
 Requires-Dist: gradio; extra == "full"
+Requires-Dist: dearpygui>=1.11; extra == "full"
 Provides-Extra: dev
 Requires-Dist: ruff>=0.9.0; extra == "dev"
 Requires-Dist: pyright>=1.1.390; extra == "dev"
@@ -93,20 +104,24 @@ pip install interactive-pipe
 from interactive_pipe import interactive, interactive_pipeline
 import numpy as np
 
+
 @interactive(coeff=(1.0, [0.5, 2.0], "exposure"), bias=(0.0, [-0.2, 0.2]))
 def exposure(img, coeff=1.0, bias=0.0):
     return img * coeff + bias
 
+
 @interactive(blend_coeff=(0.5, [0.0, 1.0]))
 def blend(img0, img1, blend_coeff=0.5):
     return (1 - blend_coeff) * img0 + blend_coeff * img1
 
-@interactive_pipeline(gui="qt")  # or "mpl", "nb" (Jupyter/Colab), "gradio"
+
+@interactive_pipeline(gui="qt")  # or "dpg" (Dear PyGui), "mpl", "nb" (Jupyter/Colab), "gradio"
 def pipe(img):
     exposed = exposure(img)
     blended = blend(img, exposed)
     return exposed, blended
 
+
 pipe(np.array([0.0, 0.5, 0.8]) * np.ones((256, 512, 3)))
 ```
 
@@ -119,7 +134,7 @@ Calling `pipe(...)` opens a window with sliders for every declared parameter.
 | `gui="qt"` | `gui="mpl"` | `gui="nb"` | `gui="gradio"` |
 | ![qt](docs/images/qt_backend.jpg) | ![mpl](docs/images/mpl_backend.jpg) | ![nb](docs/images/notebook_backend.jpg) | ![gradio](docs/images/gradio_backend.jpg) |
 
-Plus headless mode (`gui=None`) for batch processing. Full feature matrix in the [backends docs](https://balthazarneveu.github.io/interactive_pipe/getting-started/backends/).
+Plus a GPU-rendered [Dear PyGui](https://github.com/hoffstadt/DearPyGui) window (`gui="dpg"`, `pip install "interactive-pipe[dpg]"`) and headless mode (`gui=None`) for batch processing. Full feature matrix in the [backends docs](https://balthazarneveu.github.io/interactive_pipe/getting-started/backends/).
 
 ## Learn more
 

{interactive_pipe-0.9.1 → interactive_pipe-0.9.2}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "interactive_pipe"
-version = "0.9.1"
+version = "0.9.2"
 authors = [
   { name="Balthazar Neveu", email="balthazarneveu@gmail.com" },
 ]
@@ -14,6 +14,14 @@ dependencies = [
   "numpy>=1.21.6",
   "Pillow>=9.0.1",
   "PyYAML>=5.4.1",
+  "PyQt6>=6.5.2",
+  "PyQt6_sip>=13.5.2",
+  "opencv_python_headless>=4.8.1.78",
+  "pytest>=6.2.5",
+  "ipywidgets>=7.7.1",
+  "pandas",
+  "gradio",
+  "dearpygui>=1.11",
 ]
 
 description = "Library to create flexible interactive image processing pipelines and automatically add a graphical user interface without knowing anything about GUI coding!"
@@ -59,6 +67,10 @@ notebook=[
   "ipywidgets>=7.7.1",
 ]
 
+dpg=[
+  "dearpygui>=1.11",
+]
+
 pytest=[
   "opencv_python_headless>=4.8.1.78",
   "pytest>=6.2.5"
@@ -72,6 +84,7 @@ full=[
   "ipywidgets>=7.7.1",
   "pandas",
   "gradio",
+  "dearpygui>=1.11",
 ]
 
 dev=[

{interactive_pipe-0.9.1 → interactive_pipe-0.9.2}/readme.md

@@ -33,20 +33,24 @@ pip install interactive-pipe
 from interactive_pipe import interactive, interactive_pipeline
 import numpy as np
 
+
 @interactive(coeff=(1.0, [0.5, 2.0], "exposure"), bias=(0.0, [-0.2, 0.2]))
 def exposure(img, coeff=1.0, bias=0.0):
     return img * coeff + bias
 
+
 @interactive(blend_coeff=(0.5, [0.0, 1.0]))
 def blend(img0, img1, blend_coeff=0.5):
     return (1 - blend_coeff) * img0 + blend_coeff * img1
 
-@interactive_pipeline(gui="qt")  # or "mpl", "nb" (Jupyter/Colab), "gradio"
+
+@interactive_pipeline(gui="qt")  # or "dpg" (Dear PyGui), "mpl", "nb" (Jupyter/Colab), "gradio"
 def pipe(img):
     exposed = exposure(img)
     blended = blend(img, exposed)
     return exposed, blended
 
+
 pipe(np.array([0.0, 0.5, 0.8]) * np.ones((256, 512, 3)))
 ```
 
@@ -59,7 +63,7 @@ Calling `pipe(...)` opens a window with sliders for every declared parameter.
 | `gui="qt"` | `gui="mpl"` | `gui="nb"` | `gui="gradio"` |
 | ![qt](docs/images/qt_backend.jpg) | ![mpl](docs/images/mpl_backend.jpg) | ![nb](docs/images/notebook_backend.jpg) | ![gradio](docs/images/gradio_backend.jpg) |
 
-Plus headless mode (`gui=None`) for batch processing. Full feature matrix in the [backends docs](https://balthazarneveu.github.io/interactive_pipe/getting-started/backends/).
+Plus a GPU-rendered [Dear PyGui](https://github.com/hoffstadt/DearPyGui) window (`gui="dpg"`, `pip install "interactive-pipe[dpg]"`) and headless mode (`gui=None`) for batch processing. Full feature matrix in the [backends docs](https://balthazarneveu.github.io/interactive_pipe/getting-started/backends/).
 
 ## Learn more
 

{interactive_pipe-0.9.1 → interactive_pipe-0.9.2}/src/interactive_pipe/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.9.1"
+__version__ = "0.9.2"
 # Backend enum for type-safe backend specification
 from interactive_pipe.core.backend import Backend
 
@@ -23,6 +23,7 @@ from interactive_pipe.data_objects.table import Table
 from interactive_pipe.headless.control import (
     CircularControl,
     Control,
+    RangeControl,
     TextPrompt,
     TimeControl,
 )
@@ -33,6 +34,9 @@ from interactive_pipe.headless.panel import Panel
 from interactive_pipe.helper.filter_decorator import interact, interactive
 from interactive_pipe.helper.pipeline_decorator import interactive_pipeline
 
+# Animation export (TimeControl pipelines -> GIF / PNG frames)
+from interactive_pipe.headless.animation import export_animation
+
 # Allowing more straightforward naming convention
 block = interactive
 pipeline = interactive_pipeline
@@ -57,6 +61,7 @@ __all__ = [
     "Table",
     "Control",
     "CircularControl",
+    "RangeControl",
     "TextPrompt",
     "TimeControl",
     "KeyboardControl",
@@ -66,4 +71,5 @@ __all__ = [
     "interactive_pipeline",
     "block",
     "pipeline",
+    "export_animation",
 ]

interactive_pipe-0.9.2/src/interactive_pipe/cli.py

@@ -0,0 +1,216 @@
+"""Command-line and environment helpers to choose the GUI backend and window size.
+
+Lets a script pick its backend / window size without editing code::
+
+    from interactive_pipe import interactive_pipeline
+    from interactive_pipe.cli import parse_gui_args
+
+    args, gui_kwargs = parse_gui_args()
+    demo = interactive_pipeline(**gui_kwargs)(my_pipeline)  # gui="auto" unless --gui given
+    demo(img)
+
+Environment variables (read when ``interactive_pipeline`` decorates a function):
+
+- ``INTERACTIVE_PIPE_GUI``: one of auto/qt/dpg/mpl/nb/gradio/headless/none,
+  used when the decorator was called with ``gui="auto"`` (the default).
+- ``INTERACTIVE_PIPE_SIZE``: "fullscreen", "maximized" or "WxH" (e.g. "1280x800"),
+  used when the decorator was not given a ``size``.
+
+Precedence: CLI helper values > explicit decorator arguments (other than "auto") > environment.
+
+This module only depends on the standard library and has no side effects on import.
+"""
+
+import argparse
+import os
+from typing import Any, Dict, List, Optional, Sequence, Tuple, Union
+
+GUI_ENV_VAR = "INTERACTIVE_PIPE_GUI"
+SIZE_ENV_VAR = "INTERACTIVE_PIPE_SIZE"
+
+GUI_CHOICES: Tuple[str, ...] = ("auto", "qt", "dpg", "mpl", "nb", "gradio", "headless")
+# Accepted by the environment variable on top of GUI_CHOICES (aliases of "headless")
+_HEADLESS_ALIASES = ("headless", "none")
+
+SizeType = Union[str, Tuple[int, int]]
+
+
+def parse_size(value: str) -> SizeType:
+    """Parse a window size string.
+
+    Returns "fullscreen" for "fullscreen"/"full", "maximized" for "maximized"/"max",
+    or a ``(width, height)`` tuple for "WxH" (e.g. "1280x800").
+
+    Raises:
+        ValueError: If the value is not a recognized size.
+    """
+    if not isinstance(value, str):
+        raise TypeError(f"size should be a string, got {type(value).__name__}")
+    normalized = value.strip().lower()
+    if normalized in ("fullscreen", "full"):
+        return "fullscreen"
+    if normalized in ("maximized", "max"):
+        return "maximized"
+    parts = normalized.split("x")
+    if len(parts) == 2 and all(part.strip().isdigit() for part in parts):
+        width, height = (int(part) for part in parts)
+        if width > 0 and height > 0:
+            return (width, height)
+    raise ValueError(f"invalid size {value!r}: expected 'fullscreen', 'maximized' or 'WxH' (e.g. 1280x800)")
+
+
+def _argparse_size(value: str) -> Tuple[int, int]:
+    try:
+        size = parse_size(value)
+    except ValueError as exc:
+        raise argparse.ArgumentTypeError(str(exc)) from exc
+    if not isinstance(size, tuple):
+        raise argparse.ArgumentTypeError(f"--size expects WxH (e.g. 1280x800), use --{size} instead of {value!r}")
+    return size
+
+
+def gui_from_env() -> Optional[str]:
+    """Backend requested by ``INTERACTIVE_PIPE_GUI``, or None when unset/empty.
+
+    "none" is normalized to "headless".
+
+    Raises:
+        ValueError: If the variable holds an unknown backend name.
+    """
+    raw = os.environ.get(GUI_ENV_VAR, "").strip().lower()
+    if not raw:
+        return None
+    if raw in _HEADLESS_ALIASES:
+        return "headless"
+    if raw not in GUI_CHOICES:
+        raise ValueError(
+            f"{GUI_ENV_VAR}={raw!r} is not a valid backend, expected one of {', '.join(GUI_CHOICES + ('none',))}"
+        )
+    return raw
+
+
+def size_from_env() -> Optional[SizeType]:
+    """Window size requested by ``INTERACTIVE_PIPE_SIZE``, or None when unset/empty.
+
+    Raises:
+        ValueError: If the variable holds an invalid size.
+    """
+    raw = os.environ.get(SIZE_ENV_VAR, "").strip()
+    if not raw:
+        return None
+    try:
+        return parse_size(raw)
+    except ValueError as exc:
+        raise ValueError(f"{SIZE_ENV_VAR}: {exc}") from exc
+
+
+def resolve_gui(gui: Any) -> Any:
+    """Apply the ``INTERACTIVE_PIPE_GUI`` override to a ``gui`` decorator argument.
+
+    Only ``"auto"`` (or ``Backend.AUTO``) is overridden; explicit backends and
+    ``None`` (headless) are returned unchanged. ``"headless"`` from the
+    environment is returned as None.
+    """
+    if not (isinstance(gui, str) and gui == "auto"):
+        return gui
+    env_gui = gui_from_env()
+    if env_gui is None:
+        return gui
+    return None if env_gui == "headless" else env_gui
+
+
+def add_gui_arguments(
+    parser: argparse.ArgumentParser, *, defaults: Optional[Dict[str, Any]] = None
+) -> argparse._ArgumentGroup:
+    """Add ``--gui``, ``--fullscreen``, ``--maximized``, ``--size WxH`` and ``--name`` to a parser.
+
+    Args:
+        parser: Parser to extend.
+        defaults: Optional default values, keyed by destination
+            (``gui``, ``fullscreen``, ``maximized``, ``size``, ``name``).
+            A default set here is always reported by ``gui_kwargs_from_args``.
+
+    Returns:
+        The argument group holding the GUI options.
+    """
+    if defaults is None:
+        defaults = {}
+    unknown = set(defaults) - {"gui", "fullscreen", "maximized", "size", "name"}
+    if unknown:
+        raise ValueError(f"unknown GUI argument defaults: {sorted(unknown)}")
+    group = parser.add_argument_group("GUI", "interactive_pipe backend and window options")
+    group.add_argument(
+        "--gui",
+        choices=GUI_CHOICES,
+        default=defaults.get("gui"),
+        help="GUI backend (default: auto, or $%s)" % GUI_ENV_VAR,
+    )
+    window = group.add_mutually_exclusive_group()
+    window.add_argument(
+        "--fullscreen",
+        action="store_true",
+        default=defaults.get("fullscreen", False),
+        help="open the window in fullscreen",
+    )
+    window.add_argument(
+        "--maximized",
+        action="store_true",
+        default=defaults.get("maximized", False),
+        help="open the window maximized",
+    )
+    default_size = defaults.get("size")
+    if isinstance(default_size, str):
+        default_size = _argparse_size(default_size)
+    window.add_argument(
+        "--size",
+        type=_argparse_size,
+        default=default_size,
+        metavar="WxH",
+        help="window size in pixels, e.g. 1280x800",
+    )
+    group.add_argument("--name", default=defaults.get("name"), help="window title")
+    return group
+
+
+def gui_kwargs_from_args(args: argparse.Namespace) -> Dict[str, Any]:
+    """Keyword arguments for ``interactive_pipeline(**kwargs)`` from parsed arguments.
+
+    Only options that were given (or have a default) are included, so an empty
+    command line yields ``{}`` and keeps the decorator defaults
+    (and the environment overrides). ``--gui headless`` maps to ``gui=None``.
+    """
+    kwargs: Dict[str, Any] = {}
+    gui = getattr(args, "gui", None)
+    if gui is not None:
+        kwargs["gui"] = None if gui == "headless" else gui
+    if getattr(args, "fullscreen", False):
+        kwargs["size"] = "fullscreen"
+    elif getattr(args, "maximized", False):
+        kwargs["size"] = "maximized"
+    elif getattr(args, "size", None) is not None:
+        kwargs["size"] = tuple(args.size)
+    name = getattr(args, "name", None)
+    if name is not None:
+        kwargs["name"] = name
+    return kwargs
+
+
+def parse_gui_args(
+    argv: Optional[Sequence[str]] = None, parser: Optional[argparse.ArgumentParser] = None
+) -> Tuple[argparse.Namespace, Dict[str, Any]]:
+    """Parse the command line and return ``(args, gui_kwargs)``.
+
+    Args:
+        argv: Arguments to parse (defaults to ``sys.argv[1:]``).
+        parser: Your own parser to extend with the GUI options; a new one is
+            created when omitted.
+
+    Returns:
+        The parsed namespace and the keyword arguments for ``interactive_pipeline``.
+    """
+    if parser is None:
+        parser = argparse.ArgumentParser()
+    add_gui_arguments(parser)
+    argv_list: Optional[List[str]] = list(argv) if argv is not None else None
+    args = parser.parse_args(argv_list)
+    return args, gui_kwargs_from_args(args)

{interactive_pipe-0.9.1 → interactive_pipe-0.9.2}/src/interactive_pipe/core/backend.py

@@ -5,6 +5,7 @@ class Backend(str, Enum):
     """Supported GUI backends for interactive pipelines."""
 
     QT = "qt"
+    DPG = "dpg"
     GRADIO = "gradio"
     MPL = "mpl"
     NB = "nb"

{interactive_pipe-0.9.1 → interactive_pipe-0.9.2}/src/interactive_pipe/core/cache.py

@@ -2,6 +2,36 @@ import logging
 from copy import deepcopy
 from typing import Any, Optional
 
+import numpy as np
+
+
+def _values_equal(new_value: Any, old_value: Any) -> bool:
+    """Equality that also works for array-like parameter values.
+
+    Filter parameters are usually scalars, but any keyword argument default
+    (e.g. a numpy kernel) ends up in the compared dicts, and ``dict != dict``
+    raises on arrays ("truth value of an array is ambiguous").
+    """
+    if new_value is old_value:
+        return True
+    if isinstance(new_value, np.ndarray) or isinstance(old_value, np.ndarray):
+        return np.array_equal(np.asarray(new_value), np.asarray(old_value))
+    if isinstance(new_value, dict) and isinstance(old_value, dict):
+        return new_value.keys() == old_value.keys() and all(
+            _values_equal(new_value[key], old_value[key]) for key in new_value
+        )
+    if isinstance(new_value, (list, tuple)) and isinstance(old_value, (list, tuple)):
+        return (
+            type(new_value) is type(old_value)
+            and len(new_value) == len(old_value)
+            and all(_values_equal(a, b) for a, b in zip(new_value, old_value))
+        )
+    try:
+        return bool(new_value == old_value)
+    except (TypeError, ValueError):
+        # incomparable objects: conservatively consider them changed
+        return False
+
 
 class CachedResults:
     """
@@ -88,7 +118,7 @@ class StateChange:
         :param new_params: The new parameters to check.
         :return: True if the parameters have changed or False otherwise.
         """
-        if self._stored_params is None or new_params != self._stored_params:
+        if self._stored_params is None or not _values_equal(new_params, self._stored_params):
             self._stored_params = deepcopy(new_params)
             self._update_needed = True
         else:

{interactive_pipe-0.9.1 → interactive_pipe-0.9.2}/src/interactive_pipe/core/context.py

@@ -22,6 +22,10 @@ _framework_state: ContextVar[Optional[FrameworkState]] = ContextVar("_ip_framewo
 
 _user_context: ContextVar[Optional[Dict[str, Any]]] = ContextVar("_ip_user_context", default=None)
 
+# name of the filter currently executing (set by filter.run), used to attribute
+# event reads to filters
+_current_filter: ContextVar[Optional[str]] = ContextVar("_ip_current_filter", default=None)
+
 
 # ============================================================================
 # Internal Helper Functions (not exported)
@@ -54,6 +58,11 @@ def _set_user_context(ctx: Optional[Dict[str, Any]]) -> None:
     _user_context.set(ctx)
 
 
+def _set_current_filter(name: Optional[str]) -> None:
+    """Internal: Set the name of the running filter (called by filter.run)."""
+    _current_filter.set(name)
+
+
 # ============================================================================
 # Layout Proxy - Display Control
 # ============================================================================
@@ -251,13 +260,22 @@ class _EventsProxy:
     key binding.
     """
 
+    @staticmethod
+    def _record_read(state: FrameworkState, name: str) -> None:
+        """Register the running filter as a reader of the event (cache invalidation)."""
+        filter_name = _current_filter.get()
+        if filter_name is not None:
+            state.event_readers.setdefault(name, set()).add(filter_name)
+
     def __getitem__(self, name: str) -> bool:
         """Strict access: raises KeyError if the event was never bound.
 
         Raises:
             RuntimeError: If called outside of filter execution context.
         """
-        return _get_framework_state().events[name]
+        state = _get_framework_state()
+        self._record_read(state, name)
+        return state.events[name]
 
     def get(self, name: str, default: bool = False) -> bool:
         """Return the event flag, or `default` when the event is not bound.
@@ -265,15 +283,22 @@ class _EventsProxy:
         Raises:
             RuntimeError: If called outside of filter execution context.
         """
-        return _get_framework_state().events.get(name, default)
+        state = _get_framework_state()
+        self._record_read(state, name)
+        return state.events.get(name, default)
 
     def __contains__(self, name: str) -> bool:
         """Check whether an event name is bound."""
-        return name in _get_framework_state().events
+        state = _get_framework_state()
+        self._record_read(state, name)
+        return name in state.events
 
     def keys(self):
-        """Names of all bound events."""
-        return _get_framework_state().events.keys()
+        """Names of all bound events (registers the filter as a reader of each)."""
+        state = _get_framework_state()
+        for name in state.events:
+            self._record_read(state, name)
+        return state.events.keys()
 
     def __repr__(self) -> str:
         try:
@@ -368,10 +393,16 @@ class _ContextProxy:
 
     def __getattr__(self, name: str) -> Any:
         """Get item from context using attribute-style access."""
+        if name.startswith("_"):
+            # dunder/private lookups come from Python internals and tooling
+            # (copy, pickle, IPython completion...), never from user context keys
+            raise AttributeError(name)
         try:
             return get_context()[name]
         except KeyError:
-            raise AttributeError(f"Context has no attribute '{name}'. Available keys: {list(get_context().keys())}")
+            raise AttributeError(
+                f"Context has no attribute '{name}'. Available keys: {list(get_context().keys())}"
+            ) from None
 
     def __setattr__(self, name: str, value: Any) -> None:
         """Set item in context using attribute-style access."""