interactive-pipe 0.8.8__tar.gz → 0.8.10__tar.gz

{interactive_pipe-0.8.8/src/interactive_pipe.egg-info → interactive_pipe-0.8.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: interactive_pipe
-Version: 0.8.8
+Version: 0.8.10
 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
@@ -15,13 +15,6 @@ 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
 Provides-Extra: qt6
 Requires-Dist: PyQt6>=6.5.2; extra == "qt6"
 Requires-Dist: PyQt6_sip>=13.5.2; extra == "qt6"
@@ -41,6 +34,9 @@ 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"
+Provides-Extra: dev
+Requires-Dist: ruff>=0.9.0; extra == "dev"
+Requires-Dist: pyright>=1.1.390; extra == "dev"
 Dynamic: license-file
 
 
@@ -61,7 +57,7 @@ Dynamic: license-file
 - Develop an algorithm while debugging visually with plots, while checking robustness & continuity to parameters change.
 - Magically create a graphical interface to easily demonstrate a concept or simply tune your algorithm.
 
-:heart: **You do not need to learn anything about making a graphical user interface (GUI)** :heart:
+❤️ **You do not need to learn anything about making a graphical user interface (GUI)** ❤️
 
 
 ### Examples
@@ -86,13 +82,13 @@ pip install -e ".[full]"
 ----------------------
 
 ### Who is this for? 
-#### :mortar_board: Scientific education
+#### 🎓 Scientific education
 - Demonstrate concepts by interacting with curves / images.
 - Easy integration in Jupyter Notebooks (popular with Google Collab) 
-#### :gift: DIY hobbyist
+#### 🎁 DIY hobbyist
 - You can also use the declarative nature of interactive pipe to make a graphical interface in a few lines of codes. 
 - For instance, it is possible to code a jukebox for a toddler on a RaspberryPi.
-#### :camera: Engineering *(computer vision, image/signal processing)*
+#### 📷 Engineering *(computer vision, image/signal processing)*
 - While prototyping an algorithm or testing a neural network, you may be interested in making small experiments with visual checks. Instead of making a draft quick & dirty code that you'll never keep, you can use interactive pipe to show your team how your library works. A visual demo is always good, it shows that the algorithm is not buggy if anyone can play with it.
 - Tune your algorithms with a graphical interface and save your parameters for later batch processing.
 - Ready to batch under the hood, the processing engine can be ran without GUI (therefore allowing to use the same code for tuning & batch processing if needed).
@@ -102,31 +98,30 @@ pip install -e ".[full]"
 
 
 ----------------------
-## :scroll:  Terminology
 
-![interactive_pipe_concept](static/interact-pipe-concept.svg)
+## 📜  Features
 
-## :scroll:  Features
-
-**Version 0.8.8**
+**Version 0.8.10**
 - Modular multi-image processing filters
 - Declarative: Easily make graphical user interface without having to learn anything about pyQt or matplotlib
 - Support in jupyter notebooks
 - Tuning sliders & check buttons  with a GUI
 - Cache intermediate results in RAM for much faster processing
 - `KeyboardControl` : no slider on UI but exactly the same internal mechanism, update on key press.
-- Support Curve plots (2D signals)
+- Support Curve plots (2D signals).
 - Gradio backend (+allows sharing with others). 
 - Audio support in Gradio (live audio or display several players by returning 1D numpy arrays)
 - Circular sliders for Qt Backend
 - Text prompt (`free_text=("Hello world!", None),`)
 - TimeControl (possibility to play/pause time using an incrementing timer)
-- :new: **Context API**: Direct access to shared context across filters via `get_context()`, `context`, `layout`, `audio` 
-- :new: MIT License
+- 🆕 **Context API**: Direct access to shared context across filters via `get_context()`, `context`, `layout`, `audio` 
+- 🆕 MIT License
+- 🆕 Panel **Panel System**: group the sliders in defined panels. allows fine control on GUI layout.
+- 🆕 Support Table outputs
 
 
 
-#### :keyboard:   Keyboard shortcuts
+#### ⌨️   Keyboard shortcuts
 Shortcuts while using the GUI (QT & matplotlib backends)
 
 - `F1` to show the help shortcuts in the terminal
@@ -142,27 +137,31 @@ Shortcuts while using the GUI (QT & matplotlib backends)
 
 # Status
 - supported backends 
-    - :ok: `gui='qt'` pyQt/pySide 
-    - :ok: `gui='mpl'` matplotlib
-    - :ok: `gui='nb'`  ipywidget for jupyter notebooks
-    - :test_tube: `gui='gradio'` gradio wrapping (+use `share_gradio_app=True` to share your app with others)
+    - ✅ `gui='qt'` pyQt/pySide 
+    - ✅ `gui='mpl'` matplotlib
+    - ✅ `gui='nb'`  ipywidget for jupyter notebooks
+    - ✅ `gui='gradio'` gradio wrapping (+use `share_gradio_app=True` to share your app with others)
 - tested platforms
-    - :ok: Linux (Ubuntu / KDE Neon)
-    - :ok: RapsberryPi
-    - :ok: On google collab (use `gui='nb'`)
+    - ✅ Linux (Ubuntu / KDE Neon)
+    - ✅ RapsberryPi
+    - ✅ On google collab (use `gui='nb'`)
 
 
 
-| :star: | *PyQt / PySide* |  *Matplotlib*   | *Jupyter notebooks including Google collab*   | *Gradio* | 
+| ⭐ | *PyQt / PySide* |  *Matplotlib*   | *Jupyter notebooks including Google collab*   | *Gradio* | 
 |:-----: |:-----:|:------:|:----: |:----: |
 | Backend name | `qt`  | `mpl`  | `nb`| `gradio` |
 | Preview | ![qt backend](/doc/images/qt_backend.jpg)   | ![mpl backend](/doc/images/mpl_backend.jpg)    |  ![nb backend](/doc/images/notebook_backend.jpg)  | ![mpl backend](/doc/images/gradio_backend.jpg)| 
-| Plot curves | :heavy_check_mark: | :heavy_check_mark: |   :heavy_check_mark: | :heavy_check_mark:|
-| Auto refreshed layout | :heavy_check_mark: | :heavy_check_mark: |   :heavy_check_mark: | :heavy_minus_sign: |
-| Keyboard shortcuts / fullscreen| :heavy_check_mark: | :heavy_check_mark: |  :heavy_minus_sign: | :heavy_minus_sign: |
-| Audio support | :heavy_check_mark: | :heavy_minus_sign: |  :heavy_minus_sign: | :heavy_check_mark: |
-| Image buttons| :heavy_check_mark: | :heavy_minus_sign: |  :heavy_minus_sign: | :heavy_minus_sign:| 
-| Circular slider| :heavy_check_mark: | :heavy_minus_sign: |  :heavy_minus_sign: | :heavy_minus_sign:| 
+| Plot curves | ✅ | ✅ |   ✅ | ✅|
+| Change layout | ✅ | ✅ |   ✅ | ➖ |
+| Keyboard shortcuts / fullscreen| ✅ | ✅ |  ➖ | ➖ |
+| Audio support | ✅ | ➖ |  ➖ | ✅ |
+| Image buttons| ✅ | ➖ |  ➖ | ➖ | 
+| Circular slider| ✅ | ➖ |  ➖ | ➖ |
+| Collapsible Panels | ✅ | ➖ |  ➖ | ✅ |
+| Animations | ✅ | ➖ |  ➖ | ➖ |
+| Panels with sliders | ✅ | ➖ |  ➖ | ✅ |
+| Tables |  ✅ | ✅ |   ✅ | ✅|
 
 
 
@@ -189,7 +188,7 @@ Shortcuts while using the GUI (QT & matplotlib backends)
 
 
 
-## :rocket: Ultra short code
+## 🚀 Ultra short code
 
 
 *Since ipywidgets in notebooks are supported, the tutorial is also available in a [google collab notebook](https://colab.research.google.com/drive/1PZn8P_5TABVCugT3IcLespvZG-gxnFbO?usp=sharing)*
@@ -202,9 +201,9 @@ By design:
 - keyword arguments are the parameters which can be later turned into interactive widgets.
 - output buffers are simply returned like you'd do in a regular function.
 
-We use the `@interactive()` wrapper which will turn each keyword parameters initialized to a **tuple/list** into a graphical interactive widgets (slider, tick box, dropdown men). 
+We use the `@interactive()` decorator to specify which parameters become interactive widgets. Parameters defined in the decorator as **tuple/list** will become graphical interactive widgets (slider, tick box, dropdown menu). 
 
-The syntax to turn keyword arguments into sliders is pretty simple `(default, [min, max], name)` will turn into a float slider for instance.
+The syntax to turn keyword arguments into sliders is pretty simple: `@interactive(param=(default, [min, max], name))` will create a float slider for instance.
 
 Finally, we need to the glue to combo these filters. This is where the sample_pipeline function comes in.
 
@@ -215,8 +214,11 @@ By decorating it with `@interactive_pipeline(gui="qt")`, calling this function w
 from interactive_pipe import interactive, interactive_pipeline
 import numpy as np
 
-@interactive()
-def exposure(img, coeff = (1., [0.5, 2.], "exposure"), bias=(0., [-0.2, 0.2])):
+@interactive(
+    coeff=(1., [0.5, 2.], "exposure"),
+    bias=(0., [-0.2, 0.2])
+)
+def exposure(img, coeff=1., bias=0.):
     '''Applies a multiplication by coeff & adds a constant bias to the image'''
     # In the GUI, the coeff will be labelled as "exposure". 
     # As the default tuple provided to bias does not end up with a string, 
@@ -224,15 +226,15 @@ def exposure(img, coeff = (1., [0.5, 2.], "exposure"), bias=(0., [-0.2, 0.2])):
     return img*coeff + bias
 
 
-@interactive()
-def black_and_white(img, bnw=(True, "black and white")):
+@interactive(bnw=(True, "black and white"))
+def black_and_white(img, bnw=True):
     '''Averages the 3 color channels (Black & White) if bnw=True
     '''
     # Special mention for booleans: using a tuple like (True,) allows creating the tick box.
     return np.repeat(np.expand_dims(np.average(img, axis=-1), -1), img.shape[-1], axis=-1) if bnw else img
 
-@interactive()
-def blend(img0, img1, blend_coeff=(0.5, [0., 1.])):
+@interactive(blend_coeff=(0.5, [0., 1.]))
+def blend(img0, img1, blend_coeff=0.5):
     '''Blends between two image. 
     - when blend_coeff=0 -> image 0  [slider to the left ] 
     - when blend_coeff=1 -> image 1   [slider to the right] 
@@ -252,25 +254,25 @@ if __name__ == '__main__':
     sample_pipeline(input_image)
 
 ```
-:heart: This code shall display you a GUI with three images. The middle one is the result of the blend
+❤️ This code shall display you a GUI with three images. The middle one is the result of the blend
 
 
 
 Notes:
-- If you write `def blend(img0, img1, blend_coeff=0.5):`, blend_coeff will simply not be a slider on the GUI no more.
-- If you write `blend_coeff=[0., 1.]` , blend_coeff will be a slider initalized to 0.5
-- If you write `bnw=(True, "black and white", "k")`, the checkbox will disappear and be replaced by a keypress event (press `k` to enable/disable black & white)
+- If you write `@interactive()` with `def blend(img0, img1, blend_coeff=0.5):`, blend_coeff will simply not be a slider on the GUI.
+- If you write `@interactive(blend_coeff=[0., 1.])` in the decorator, blend_coeff will be a slider initialized to 0.5
+- If you write `@interactive(bnw=(True, "black and white", "k"))`, the checkbox will disappear and be replaced by a keypress event (press `k` to enable/disable black & white)
 
 -----------
-## :bulb: Some more tips
+## 💡 Some more tips
 
 ```python
-from interactive_pipe import interactive, interactive_pipeline
+from interactive_pipe import interactive, interactive_pipeline, context
 import numpy as np
 
 COLOR_DICT = {"red": [1., 0., 0.],  "green": [0., 1.,0.], "blue": [0., 0., 1.], "gray": [0.5, 0.5, 0.5]}
-@interactive()
-def generate_flat_colored_image(color_choice=["red", "green", "blue", "gray"], context={}):
+@interactive(color_choice=["red", "green", "blue", "gray"])
+def generate_flat_colored_image(color_choice="red"):
     '''Generate a constant colorful image
     '''
     flat_array =  np.array(COLOR_DICT.get(color_choice)) * np.ones((64, 64, 3))
@@ -282,15 +284,15 @@ def generate_flat_colored_image(color_choice=["red", "green", "blue", "gray"], c
 - The `color_choice` list will be turned into a nice dropdown menu. Default value here will be red as this is the first element of the list!
 ----------
 
-:bulb: Can filters communicate together?
-Yes, using the special keyword argument `context={}`. 
-- Check carefully how we stored the image average of the flat image in  context. 
+💡 Can filters communicate together?
+Yes, using the `context` proxy from `interactive_pipe`. 
+- Check carefully how we stored the image average of the flat image in context. 
 - This value will be available to other filters.
 `special_image_slice` is going to use that value to set the half bottom image to dark in case the average is high.
 
 ```python
-@interactive()
-def special_image_slice(img, context={}):
+def special_image_slice(img):
+    out_img = img.copy()
     if context["avg"] > 0.4:
         out_img[out_img.shape[0]//2:, ...] = 0.
     return out_img
@@ -299,8 +301,8 @@ def special_image_slice(img, context={}):
 
 
 ```python
-@interactive()
-def switch_image(img1, img2, img3, image_index=(0, [0, 2], None, ["pagedown", "pageup", True])):
+@interactive(image_index=(0, [0, 2], None, ["pagedown", "pageup", True]))
+def switch_image(img1, img2, img3, image_index=0):
     '''Switch between 3 images
     '''
     return [img1, img2, img3][image_index]
@@ -308,8 +310,8 @@ def switch_image(img1, img2, img3, image_index=(0, [0, 2], None, ["pagedown", "p
 Note that you can create a filter to switch between several images. In `["pagedown", "pageup", True]`, True means that the image_index will wrap around. (it will return to 0 as soon as it goes above the maximum value of 2).
 
 ```python
-@interactive()
-def black_top_image_slice(img, top_slice_black=(True, "special", "k"), context={}):
+@interactive(top_slice_black=(True, "special", "k"))
+def black_top_image_slice(img, top_slice_black=True):
     out_img = img.copy()
     if top_slice_black:
         out_img[:out_img.shape[0]//2, ...] = 0.
@@ -332,6 +334,40 @@ if __name__ == '__main__':
 
 ### Release Notes
 
+
+#### Version 0.8.10 (March 2026)
+- Bugfix for jupyter notebooks backends.
+#### Version 0.8.9 (February 2026)
+
+**New Features:**
+- **Panel System**: Control panel layout and organization
+  - Flexible panel positioning (left, right, top, bottom)
+  - Detached control panels for separate windows
+  - Nested panels and subpanels support
+  - Grouped controls within panels
+  - Improved spacing and borders for better visual organization
+  - Full backend support (Qt, Gradio, matplotlib, notebook)
+
+- **Table Data Type**: Display tabular data natively
+  - Core Table functionality without external dependencies
+  - Optional pandas DataFrame support for advanced use cases
+  - Rendering support across all backends (Qt, Gradio, matplotlib)
+  - Headerless tables option
+
+- **TimeControl Enhancements**: Better time-based parameter control
+  - Improved slider help display
+  - Additional demos showcasing time-based animations
+
+**API Improvements:**
+- Context support at pipeline initialization
+- Backend selection via enum (string format still supported)
+- Graph visualization for GUI pipelines (press `G`)
+
+**Deprecations:**
+- Inline syntax deprecated (use decorator syntax instead)
+- `output_canvas` argument removed
+- Context aliases (`global_params`, `states` etc...) deprecated at initialization
+
 #### Version 0.8.8 (January 2026)
 
 **New Features:**
@@ -357,27 +393,34 @@ if __name__ == '__main__':
 - Fixed pytest failures for optional dependencies in CI
 - Fixed various edge cases in error handling
 
-**Migration of old context or global_params:**  
-- Use `global_params=SharedContext.injected()` to let code interpreters know that there's no need to pass this parameter.
+**Migration from old `context={}` or `global_params={}` patterns:**  
 
 ```python
-# Before
-def apply_brightness(img:np.ndarray, brightness: float = 0.5, global_params:dict =None):
-    global_params["brightness"] = brightness
-    return img * brightness
+# OLD (deprecated) - using context={} or global_params={}
+from interactive_pipe import interactive
 
-# Progressive migration
-def apply_brightness(img:np.ndarray, brightness: float = 0.5, global_params:dict ==SharedContext.injected()):
-    global_params["brightness"] = brightness
+@interactive(brightness=(0.5, [0., 1.]))
+def apply_brightness(img:np.ndarray, brightness: float = 0.5, global_params={}):
+    global_params["brightness"] = brightness  # Storing shared data
+    global_params["__output_styles"]["output"] = {"title": "Brightened"}  # Setting layout
     return img * brightness
 
-# Recommended version
-from interactive_pipe import context
+# NEW (recommended) - using context and layout proxies
+from interactive_pipe import interactive, context, layout
+
+@interactive(brightness=(0.5, [0., 1.]))
 def apply_brightness(img:np.ndarray, brightness: float = 0.5):
-    context.shared_brightness = brightness # shared with all filters
+    context["brightness"] = brightness  # or: context.brightness = brightness
+    layout.style("output", title="Brightened")
     return img * brightness
 ```
 
+The new API provides:
+- `context` - For sharing data between filters (replaces `global_params["key"]`)
+- `layout` - For controlling output display (replaces `global_params["__output_styles"]`)
+- `audio` - For audio playback control
+- `get_context()` - Get the shared context dictionary directly
+
 
 
 
@@ -395,7 +438,7 @@ def apply_brightness(img:np.ndarray, brightness: float = 0.5):
 
 
 ### FAQ
-- :question: What is the recommended way to access shared context?
+- ❓ What is the recommended way to access shared context?
 > **New in v0.8.8**: Use the clean context API for direct access:
 > ```python
 > from interactive_pipe import context, layout, audio, get_context
@@ -409,7 +452,7 @@ def apply_brightness(img:np.ndarray, brightness: float = 0.5):
 >     return img
 > ```
 
-- :question: How do I change the layout?  *Can I change the grid layout of images live? (like you compare 2 images side by side and you want to start comparing 4 images in a 2x2 fashion for debugging purpose)*. It is possible with Qt backend. 
+- ❓ How do I change the layout?  *Can I change the grid layout of images live? (like you compare 2 images side by side and you want to start comparing 4 images in a 2x2 fashion for debugging purpose)*. It is possible with Qt backend. 
 
 > Use the `layout` helper to control image arrangement and styling:
 > ```python
@@ -434,16 +477,16 @@ def apply_brightness(img:np.ndarray, brightness: float = 0.5):
 >     return result
 > ```
 
-- :question: Do I have to remove `KeyboardSlider` when using gradio or notebook backends?
+- ❓ Do I have to remove `KeyboardSlider` when using gradio or notebook backends?
 > No, don't worry, these will be mapped back to regular sliders!
-- :question: How do I play audio live?
-> :sound: Inside a processing block, write the audio file to disk and use the audio helper:
+- ❓ How do I play audio live?
+> 🔊 Inside a processing block, write the audio file to disk and use the audio helper:
 > ```python
 > from interactive_pipe import audio
 > audio.set_audio(audio_file)  # New clean API (v0.8.8)
 > # or legacy: context["__set_audio"](audio_file)
 > ```
-- :question: Do I have to decorate my processing block using the `@interactive` 
+- ❓ Do I have to decorate my processing block using the `@interactive` 
 > If you use the `@` decoration style, your function won't be useable in a regular manner (wich may be problematic in a serious development environment)
 ```python
 @interactive(angle=(0., [-360., 360.]))
@@ -465,11 +508,11 @@ from core_filter import processing_block
 def add_interactivity():
     interactive(angle=(0., [-360., 360.]))(processing_block)
 ```
-- :question: Can I call the pipeline in a command line/batch fashion?
-> Yes, headless mode is supported. :soon: documentation needed.
+- ❓ Can I call the pipeline in a command line/batch fashion?
+> Yes, headless mode is supported. 🔜 documentation needed.
 
 
-- :question: Can I use inplace operations?
+- ❓ Can I use inplace operations?
 > Better avoid these in general. To avoid making extra copies, computing hashes everywhere and avoid loosing precious computation time, there are no checks that inputs are not modified in place.
 ```python
 # Don't do that!
@@ -477,38 +520,18 @@ def bad_processing_block(inp):
     inp+=1
 ```
 
-- :question: Is there a difference between `global_params` and `context` ?
+- ❓ Is there a difference between `global_params` and `context` ?
 > No, `global_params`, `global_parameters`, `global_state`, `global_context`, `context`, `state` all mean the same thing and are all supported for legacy reasons. `context` is the preferred wording. However, we now recommend using the clean context API (see above).
-> :warning: The old `global_params={}` / `context={}` keyword argument style still works for backwards compatibility but is deprecated.
+> ⚠️ The old `global_params={}` / `context={}` keyword argument style still works for backwards compatibility but is deprecated.
 
 
 
 # Roadmap and todos
-:bug: Want to contribute or interested in adding new features? Enter a new [Github issue](https://github.com/balthazarneveu/interactive_pipe/issues)
+🐛 Want to contribute or interested in adding new features? Enter a new [Github issue](https://github.com/balthazarneveu/interactive_pipe/issues)
 
-:gift: Want to dig into the code? Take a look at [code_architecture.md](/code_architecture.md)
+🎁 Want to dig into the code? Take a look at [code_architecture.md](/code_architecture.md)
 
-## Short term roadmap
-- Backport previous features
-    - Image class support in interactive pipe (Heatmaps/Float images)
 
-## Long term roadmap
-- Advanced feature
-    - Webcam based "slider" for dropdown menu (like "elephant" will trigget if an elephant is magically detected on the webcam)
-    - Animations/While loops/Video source (Time slider)
-- Exploratory backends
-    - Create a [textual](https://github.com/Textualize/textual) backend for simplified GUI (probably no images displayed)
-    - Create a [Kivy](https://kivy.org/) backend
-
-
-### Further examples
-
-#### [Minimalistic pytorch based ISP ](https://github.com/balthazarneveu/interactive_pipe/tree/sample_interactive_isp/samples/isp)
-[ISP means image signal processor](https://en.wikipedia.org/wiki/Image_processor)
-
-:warning: Work in progess (no proper demosaicking, no denoiser, no tone mapping.)
-
-![Ultra simplistic ISP](/doc/images/isp_pipeline.png)
 
 ----------------------
 
@@ -516,30 +539,44 @@ def bad_processing_block(inp):
 
 #### Code quality checks
 
-Before committing, ensure your code passes the linters and tests. The CI runs these checks automatically:
+Before committing, ensure your code passes the linters, type checker, and tests. The CI runs these checks automatically:
 
 **What CI does:**
-- **Black formatting check** (`.github/workflows/formatting.yaml`): Runs `black --check` to verify code formatting
-- **Flake8 linting** (`.github/workflows/flake8.yaml`): Runs `flake8` to check code quality
+- **Ruff formatting check** (`.github/workflows/ruff-format.yaml`): Runs `ruff format --check` to verify code formatting
+- **Ruff linting** (`.github/workflows/ruff-lint.yaml`): Runs `ruff check` to check code quality (replaces flake8)
+- **Pyright type checking** (`.github/workflows/pyright.yaml`): Runs `pyright` for static type checking (informational, non-blocking)
 - **Pytest tests** (`.github/workflows/pytest.yaml`): Runs `pytest` on Python 3.9, 3.10, and 3.11
 
 **Local commands (match CI):**
 
 ```bash
-# Install linting tools and test dependencies
-pip install black flake8
-pip install -e ".[pytest]"
+# Install development tools and test dependencies
+pip install -e ".[dev,pytest]"
 
-# Check code formatting (Black) - matches CI
-black --check .
+# Format code (Ruff) - matches CI
+ruff format .
 
-# Auto-format code (Black) - run this if check fails
-black .
+# Check formatting (Ruff) - matches CI
+ruff format --check .
 
-# Run linting checks (flake8) - matches CI
-flake8 .
+# Lint code (Ruff) - matches CI (auto-fixes when possible)
+ruff check .
+
+# Auto-fix linting issues (Ruff)
+ruff check --fix .
+
+# Type check (Pyright) - matches CI (informational)
+pyright src/
 
 # Run tests (pytest) - matches CI
 pytest
+
+# Pre-commit checklist (run all before committing)
+ruff format .
+ruff check --fix .
+pyright src/  # Optional, won't block commit
+pytest
 ```
 
+**Note:** Ruff replaces both Black (formatting) and Flake8 (linting) in a single, faster tool. Pyright provides static type checking to catch type errors early.
+

{interactive_pipe-0.8.8 → interactive_pipe-0.8.10}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "interactive_pipe"
-version = "0.8.8"
+version = "0.8.10"
 authors = [
   { name="Balthazar Neveu", email="balthazarneveu@gmail.com" },
 ]
@@ -14,13 +14,6 @@ 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",
 ]
 
 description = "Library to create flexible interactive image processing pipelines and automatically add a graphical user interface without knowing anything about GUI coding!"
@@ -65,3 +58,35 @@ full=[
   "pandas",
   "gradio",
 ]
+
+dev=[
+  "ruff>=0.9.0",
+  "pyright>=1.1.390",
+]
+
+[tool.ruff]
+line-length = 120
+target-version = "py39"
+exclude = ["__init__.py", "*/__pycache__/*", "*venv*/*"]
+
+[tool.ruff.lint]
+select = ["E", "F", "W", "I"]  # E/F/W = flake8 rules, I = isort
+ignore = ["E203"]  # E203: whitespace before ':' (conflicts with black formatting)
+
+[tool.ruff.lint.isort]
+# isort compatibility
+
+[tool.ruff.format]
+# Black-compatible formatting (default)
+
+[tool.pyright]
+pythonVersion = "3.9"
+typeCheckingMode = "basic"
+include = ["src"]
+exclude = ["**/venv/**", "**/__pycache__/**", "test/**"]
+reportMissingImports = "none"  # Qt libs and other optional dependencies
+reportMissingTypeStubs = false
+reportUnknownMemberType = false
+reportUnknownArgumentType = false
+reportUnknownVariableType = false
+reportPrivateUsage = false