interactive-pipe 0.5.6__tar.gz → 0.5.7__tar.gz

{interactive_pipe-0.5.6 → interactive_pipe-0.5.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: interactive_pipe
-Version: 0.5.6
+Version: 0.5.7
 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
@@ -26,8 +26,8 @@ License-File: LICENSE
 | Science notebook | Toddler DIY Jukebox on a raspberry Pi |
 |:-----: |:-----:|
 | ![science notebook](/doc/images/scientific_notebook.jpg) |  ![jukebox](/doc/images/jukebox.jpg)
-| Sliders are added automatically in your jupyter notebook. This works on Google Collab and the code takes about 40 lines of code.| Plays some music when you touch the icon. Images can be generated using the OpenAI Dall-E API helpers. Text overlay is added using OpenCV |
-| [Sample notebook](https://colab.research.google.com/drive/1AwHyjZH8MnzZqwsvbmxBoB15btuMIwtk?usp=sharing) | :soon: sample code |
+| Sliders are added automatically in your jupyter notebook. This works on Google Collab and the code takes about 40 lines of code. No Widgets, event handlers or matplotlib knowledge required.| Plays some music when you touch the icon. Images can be generated using the OpenAI [Dall-E API helpers](https://github.com/balthazarneveu/interactive_pipe/blob/master/src/interactive_pipe/thirdparty/images_openai_api.py) . Caption added through the title mechanism. Music samples generated by prompting [MusicGen](https://huggingface.co/spaces/facebook/MusicGen) |
+| [Demo notebook on collab](https://colab.research.google.com/drive/1AwHyjZH8MnzZqwsvbmxBoB15btuMIwtk?usp=sharing) | [jukebox.py demo code](/demo/jukebox.py)|
 
 ----------------------
 
@@ -55,7 +55,7 @@ License-File: LICENSE
 ----------------------
 
 ## :scroll:  Features
-**Version 0.5.6**
+**Version 0.5.7**
 - Modular multi-image processing filters
 - Declarative: Easily make graphical user interface without having to learn anything about pyQt or matplotlib
 - Support in jupyter notebooks

{interactive_pipe-0.5.6 → interactive_pipe-0.5.7}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "interactive_pipe"
-version = "0.5.6"
+version = "0.5.7"
 authors = [
   { name="Balthazar Neveu", email="balthazarneveu@gmail.com" },
 ]

{interactive_pipe-0.5.6 → interactive_pipe-0.5.7}/readme.md

@@ -12,8 +12,8 @@
 | Science notebook | Toddler DIY Jukebox on a raspberry Pi |
 |:-----: |:-----:|
 | ![science notebook](/doc/images/scientific_notebook.jpg) |  ![jukebox](/doc/images/jukebox.jpg)
-| Sliders are added automatically in your jupyter notebook. This works on Google Collab and the code takes about 40 lines of code.| Plays some music when you touch the icon. Images can be generated using the OpenAI Dall-E API helpers. Text overlay is added using OpenCV |
-| [Sample notebook](https://colab.research.google.com/drive/1AwHyjZH8MnzZqwsvbmxBoB15btuMIwtk?usp=sharing) | :soon: sample code |
+| Sliders are added automatically in your jupyter notebook. This works on Google Collab and the code takes about 40 lines of code. No Widgets, event handlers or matplotlib knowledge required.| Plays some music when you touch the icon. Images can be generated using the OpenAI [Dall-E API helpers](https://github.com/balthazarneveu/interactive_pipe/blob/master/src/interactive_pipe/thirdparty/images_openai_api.py) . Caption added through the title mechanism. Music samples generated by prompting [MusicGen](https://huggingface.co/spaces/facebook/MusicGen) |
+| [Demo notebook on collab](https://colab.research.google.com/drive/1AwHyjZH8MnzZqwsvbmxBoB15btuMIwtk?usp=sharing) | [jukebox.py demo code](/demo/jukebox.py)|
 
 ----------------------
 
@@ -41,7 +41,7 @@
 ----------------------
 
 ## :scroll:  Features
-**Version 0.5.6**
+**Version 0.5.7**
 - Modular multi-image processing filters
 - Declarative: Easily make graphical user interface without having to learn anything about pyQt or matplotlib
 - Support in jupyter notebooks

interactive_pipe-0.5.7/src/interactive_pipe/__init__.py

@@ -0,0 +1,4 @@
+from interactive_pipe.helper.pipeline_decorator import pipeline, interactive_pipeline
+from interactive_pipe.headless.control import Control
+from interactive_pipe.headless.keyboard import  KeyboardControl
+from interactive_pipe.helper.filter_decorator import interactive, interact

{interactive_pipe-0.5.6 → interactive_pipe-0.5.7}/src/interactive_pipe/core/filter.py

@@ -27,14 +27,14 @@ class PureFilter:
         assert isinstance(new_global_params, dict)
         self._global_params = new_global_params
 
-
-
     def check_apply_signature(self):
         if not hasattr(self, "__args_names") or not hasattr(self, "__kwargs_names"):
             self.__args_names, self.__kwargs_names = analyze_apply_fn_signature(
                 self.apply)
+            self.signature = (self.__args_names, self.__kwargs_names)
         else:  # skip computing signature
             pass
+    
     def __initialize_default_values(self):
         assert not hasattr(self, "_values")
         self.check_apply_signature()
@@ -50,7 +50,6 @@ class PureFilter:
     def values(self, new_values):
         assert isinstance(
             new_values, dict), f"{new_values} is not a dictionary"
-        
         self._values = {**self._values, **new_values}
 
     def run(self, *imgs) -> Tuple[Any]:
@@ -120,4 +119,13 @@ class FilterCore(PureFilter):
         descr += "(" + (", ".join([f"{it}" for it in self.inputs])) + ")"
         descr += " -> " + "(" + ", ".join([f"{it}" for it in self.outputs]) + ")"
         # descr += "\n"
-        return descr
+        return descr
+    
+    def __call__(self, *args: Any, **kwargs: Any) -> Any:
+        control_dict = {}
+        if hasattr(self, "controls"):
+            for ctrl_name, ctrl in self.controls.items():
+                control_dict[ctrl_name] = ctrl.value
+        merged_kwargs = {**kwargs, **control_dict}
+        out = self.apply(*args, **merged_kwargs)
+        return out

{interactive_pipe-0.5.6 → interactive_pipe-0.5.7}/src/interactive_pipe/core/graph.py

@@ -2,6 +2,7 @@ import ast
 import inspect
 import logging
 from typing import List, Callable, Tuple, Optional, Union
+from interactive_pipe.core.filter import FilterCore
 from interactive_pipe.core.signature import analyze_apply_fn_signature
 
 def get_name(node: ast.NodeVisitor) -> Union[str, List[str], None]:
@@ -57,10 +58,25 @@ def get_call_graph(func:Callable, global_context=None) -> dict:
                 input_names = [get_name(arg) for arg in value.args]
                 output_names = flatten_target_names(targets, mapping_function=get_name)
                 function_object = global_context[function_name]
-                sig = analyze_apply_fn_signature(function_object)
+                if isinstance(function_object, FilterCore):
+                    # Case of a filter instance
+                    function_object.check_apply_signature()
+                    # ---> forcing filter instance .name to be the name of the object used in the func
+                    function_object.name = function_name
+                    # you could use instead: # function_name = function_object.name to keep the original name
+                    sig = function_object.signature
+                    function_object.inputs = input_names
+                    function_object.outputs = output_names
+                    function_apply = function_object
+                elif isinstance(function_object, Callable):
+                    # Case of a decorated function
+                    sig = analyze_apply_fn_signature(function_object)
+                    function_apply = global_context[function_name]
+                else:
+                    raise TypeError(f"Not supported {function_name} - should be function or FilterCore")
                 results.append({
                     "function_name": function_name,
-                    "function_object": global_context[function_name],
+                    "function_object": function_apply,
                     "signature" : {"args": sig[0], "kwargs": sig[1]},
                     "args": input_names,
                     "returns": output_names,

{interactive_pipe-0.5.6 → interactive_pipe-0.5.7}/src/interactive_pipe/data_objects/curves.py

@@ -419,7 +419,9 @@ class Curve(Data):
     
     @staticmethod
     def _update_plot(data, plt_obj, ax=None):
-        texts = ax.get_legend().get_texts()
+        legend = ax.get_legend()
+        if legend is not None:
+            texts = legend.get_texts()
         linear_index = 0
         for curve_idx, curve in enumerate(data["curves"]):
             if curve.data.get("x", None) is not None:

{interactive_pipe-0.5.6 → interactive_pipe-0.5.7}/src/interactive_pipe/graphical/gui.py

@@ -33,9 +33,11 @@ class InteractivePipeGUI():
         self.audio = audio
         self.name = name
         self.size = size
+        merged_controls = []
+        merged_controls+= controls
         if hasattr(pipeline, "controls"):
-            controls += pipeline.controls
-        self.controls = controls
+            merged_controls += pipeline.controls
+        self.controls = merged_controls
         if self.pipeline.outputs:
             if not isinstance(self.pipeline.outputs[0], list):
                 self.pipeline.outputs = [self.pipeline.outputs]

{interactive_pipe-0.5.6 → interactive_pipe-0.5.7}/src/interactive_pipe/graphical/qt_gui.py

@@ -56,7 +56,11 @@ import time
 
 class InteractivePipeQT(InteractivePipeGUI):    
     def init_app(self, **kwargs):
-        self.app = QApplication(sys.argv)
+        if not QApplication.instance():
+            self.app = QApplication(sys.argv)
+        else:
+            self.app = QApplication.instance()
+
         if self.audio:
             self.audio_player()
         self.window = MainWindow(controls=self.controls, name=self.name, pipeline=self.pipeline, size=self.size, main_gui=self, **kwargs)
@@ -365,8 +369,20 @@ class MainWindow(QWidget, InteractivePipeWindow):
             elif img_widget is not None:
                 img_widget.setParent(None)
 
-    def update_image(self, image_array, row, col):
-        if isinstance(image_array, np.ndarray):
+    def update_image(self, image_array_original, row, col):
+        if isinstance(image_array_original, np.ndarray):
+            if len(image_array_original.shape) == 2:
+                # Consider black & white
+                image_array = image_array_original.copy()
+                c = 3
+                image_array = np.expand_dims(image_array, axis=-1)
+                image_array = np.repeat(image_array, c, axis=-1)
+            elif len(image_array_original.shape) == 3:
+                assert isinstance(image_array_original, np.ndarray)
+                assert(image_array_original.shape[-1]) == 3
+                image_array = image_array_original
+            else:
+                raise NotImplementedError(f"{image_array_original.shape}4 dimensions image or more like burst are not supported")
             h, w, c = image_array.shape
             bytes_per_line = c * w
             image = QImage(image_array.data, w, h, bytes_per_line, QImage.Format.Format_RGB888)
@@ -374,6 +390,7 @@ class MainWindow(QWidget, InteractivePipeWindow):
             image_label = self.image_canvas[row][col]["image"]
             image_label.setPixmap(pixmap)
         else:
+            image_array = image_array_original
             if MPL_SUPPORT and isinstance(image_array, Curve):
                 image_label = FigureCanvas(Figure())
                 if self.image_canvas[row][col]["ax_placeholder"] is None:

{interactive_pipe-0.5.6 → interactive_pipe-0.5.7}/src/interactive_pipe/headless/pipeline.py

@@ -74,14 +74,22 @@ class HeadlessPipeline(PipelineCore):
                 inputs_filt = filt_dict["args"]
                 outputs_filt = filt_dict["returns"]
             logging.debug("----------------->", filt_name, inputs_filt, outputs_filt)
-            filter = FilterCore(
-                name=filt_name,
-                inputs=inputs_filt,
-                outputs = outputs_filt,
-                apply_fn=filt_dict["function_object"],
-            )
-            func_kwargs = analyze_apply_fn_signature(filt_dict["function_object"])[1]
-            params_to_analyze = {**func_kwargs, **Control.get_controls(filt_name)}
+            if isinstance(filt_dict["function_object"], FilterCore):
+                filter = filt_dict["function_object"]
+                filter.inputs = inputs_filt
+                filter.outputs = outputs_filt
+                filter.name = filt_name
+                params_to_analyze = filter.controls
+            else:
+                # when using the @interactive decorator
+                filter = FilterCore(
+                    name=filt_name,
+                    inputs=inputs_filt,
+                    outputs = outputs_filt,
+                    apply_fn=filt_dict["function_object"],
+                )
+                func_kwargs = analyze_apply_fn_signature(filt_dict["function_object"])[1]
+                params_to_analyze = {**func_kwargs, **Control.get_controls(filt_name)}
             for param_name, param_value in params_to_analyze.items():
                 if isinstance(param_value, Control):
                     param_value.connect_filter(filter, param_name)
@@ -146,7 +154,17 @@ class HeadlessPipeline(PipelineCore):
         ret += "}"
         return ret
     
+    def update_parameters_from_controls(self):
+        if not hasattr(self, "controls"):
+            # Not having .controls attribute
+            # This happens for headless pipelines which have no list of controls
+            return
+        for ctrl in self.controls:
+            logging.info(f"{ctrl.filter_to_connect.name}, {ctrl.parameter_name_to_connect}, {ctrl.value}")
+            self.parameters = {ctrl.filter_to_connect.name: {ctrl.parameter_name_to_connect:  ctrl.value}}
+        
     def __run(self):
+        self.update_parameters_from_controls()
         result_full = super().run()
         if self.outputs is not None:
             output_indexes = self.outputs

interactive_pipe-0.5.7/src/interactive_pipe/helper/_private.py

@@ -0,0 +1,2 @@
+registered_controls_names = []
+auto_gui = None

interactive_pipe-0.5.7/src/interactive_pipe/helper/choose_backend.py

@@ -0,0 +1,39 @@
+from interactive_pipe.helper import _private
+import logging
+
+def get_interactive_pipeline_class(gui="auto"):
+    selected_gui = None
+    if gui is None or gui == "auto":
+        if _private.auto_gui is not None:
+            
+            selected_gui = _private.auto_gui #skip selection, used cached one
+            logging.debug(f"auto gui already selected {selected_gui}")
+        else:
+            try:
+                __IPYTHON__  # noqa: F821
+                selected_gui = "nb"
+            except Exception:
+                try:
+                    from interactive_pipe.graphical.qt_gui import InteractivePipeQT as ChosenGui
+                    selected_gui = "qt"
+                except Exception as qt_import_execption:
+                    try:
+                        import matplotlib.pyplot as plt
+                        selected_gui = "mpl"
+                    except Exception as mpl_import_exception:
+                        raise NameError("Error in auto backend choice:\n"+
+                            f"Could not import Qt: {qt_import_execption}\n"+
+                            f"Could not import Matplotlib {mpl_import_exception}"
+                    )
+            _private.auto_gui = selected_gui
+    else:
+        selected_gui = gui     
+    if selected_gui == "qt":
+        from interactive_pipe.graphical.qt_gui import InteractivePipeQT as ChosenGui
+    elif selected_gui == "mpl":
+        from interactive_pipe.graphical.mpl_gui import InteractivePipeMatplotlib as ChosenGui
+    elif selected_gui == "nb":
+        from interactive_pipe.graphical.nb_gui import InteractivePipeJupyter as ChosenGui
+    else:
+        raise NotImplementedError(f"Gui {gui} not available")
+    return ChosenGui

interactive_pipe-0.5.7/src/interactive_pipe/helper/filter_decorator.py

@@ -0,0 +1,111 @@
+from interactive_pipe.headless.control import Control
+import functools
+import inspect
+from interactive_pipe.helper.keyword_args_analyzer import get_controls_from_decorated_function_declaration
+from interactive_pipe.helper import _private #import registered_controls_names
+from interactive_pipe.headless.pipeline import HeadlessPipeline
+
+from interactive_pipe.core.filter import FilterCore
+import logging
+
+from interactive_pipe.helper.choose_backend import get_interactive_pipeline_class
+
+class EnhancedFilterCore(FilterCore):
+    """Internally creates a pipeline with a single filter 
+    so you can graphically test a single filter without instantiating a pipeline.
+    Internally used by `@interact` decorator.
+    """
+    def get_gui(self, gui="auto", output_routing=None):
+        self.inputs = list(range(len(self.signature[0])))
+        if output_routing is None:
+            logging.warning("Single output assumed, cannot deduce the number of outputs from your code, please provide output_routing!")
+            self.outputs = ["output",]
+        else:
+            self.outputs = output_routing
+        pipeline = HeadlessPipeline(filters=[self], inputs=[], outputs=None)
+        for ctrl_name, _ctrl in self.controls.items():
+            self.controls[ctrl_name].filter_to_connect = self
+            self.controls[ctrl_name].parameter_name_to_connect = ctrl_name
+        controls = [ctrl for _, ctrl in self.controls.items()]
+        pipeline.controls = controls
+        return get_interactive_pipeline_class(gui=gui)(pipeline=pipeline)
+
+    def run_gui(self, *args, gui="auto", output_routing=None):
+        try:
+            self.inputs = args
+            out = self.run(*args)
+            output_routing = [f"output {idx}" for idx in range(len(out))]
+            self.outputs = output_routing
+        except Exception as exc:
+            logging.warning(f"cannot automatically deduce the output routing\n{exc}")
+        gui_pipeline = self.get_gui(gui=gui, output_routing=output_routing)
+        gui_pipeline.pipeline.inputs_routing = list(range(len(self.signature[0])))    
+        gui_pipeline(*args)
+        gui_pipeline.close()
+        gui_pipeline.controls = []
+        del gui_pipeline
+
+
+def interact(*decorator_args, gui="auto", disable=False, output_routing = None, **decorator_controls):
+    """interact decorator allows you to launch a GUI from a single function
+    
+    This will directly launch a GUI.
+    This is a "One shot decorator
+    
+    ___________________________________________________________________________
+
+    Note: `@interact` is a lot inspired by the `iPyWidget` interact function you'd usually use...
+    except that you can return numpy arrays & Curve class instances to automatically deal with the plot mechanism
+    Which avoids writing a lot of matplotlib boiler plate code
+    """
+    ommitted_parentheses_flag = False
+    def wrapper(func):
+        if disable:
+            return func
+        # this will run the GUI automatically
+        _private.registered_controls_names = []
+        filter_instance = filter_from_function(func, **decorator_controls)
+        filter_instance.run_gui(*(decorator_args if not ommitted_parentheses_flag else decorator_args[1:]), gui=gui, output_routing=output_routing)
+        # return the original function if you want to keep using it afterwards
+        return func
+    
+
+    if len(decorator_args)==1 and callable(decorator_args[0]):
+        ommitted_parentheses_flag = True
+        return wrapper(decorator_args[0]) # no parenthesis
+    return wrapper
+
+
+def filter_from_function(apply_fn, default_params={}, **kwargs) -> EnhancedFilterCore:
+    controls = get_controls_from_decorated_function_declaration(apply_fn, kwargs)
+    filter_instance = EnhancedFilterCore(apply_fn=apply_fn, default_params=default_params)
+    filter_instance.controls = controls
+    return filter_instance
+
+
+def interactive(**decorator_controls):
+    """Decorator to declare some controls linked to keyword arguments.
+    Parameters will become "variable" and sliders automatically appear in the GUI.
+
+    `@interactive` differs from `interact` in the sense that it will not launch a gui.
+    It is simply used to declare some sliders and allows re-using these functions afterwards.
+    Function decorator to add some controls
+    """
+    def wrapper(func):
+        controls = get_controls_from_decorated_function_declaration(func, decorator_controls)
+
+        @functools.wraps(func)
+        def inner(*args, **kwargs):
+            # Combine args and kwargs into a single dictionary
+            merged_kwargs = {**kwargs, **controls}
+            bound_args = inspect.signature(func).bind(*args, **merged_kwargs)
+            bound_args.apply_defaults()
+
+            for k, v in bound_args.arguments.items():
+                if isinstance(v, Control):
+                    bound_args.arguments[k] = v.value
+
+            # Call the original function with the processed arguments
+            return func(*bound_args.args, **bound_args.kwargs)
+        return inner
+    return wrapper

interactive_pipe-0.5.7/src/interactive_pipe/helper/keyword_args_analyzer.py

@@ -0,0 +1,72 @@
+from interactive_pipe.headless.control import Control
+from interactive_pipe.helper.control_abbreviation import control_from_tuple
+from typing import Callable, Union
+from interactive_pipe.core.graph import analyze_apply_fn_signature
+from interactive_pipe.helper import _private
+
+
+def __create_control_from_keyword_argument(
+        param_name: str,
+        unknown_keyword_arg: Union[Control, list, tuple]
+    ) -> Union[None, Control]:
+    """Create a Control from a given keyword argument named  param_name with value unknown_keyword_arg
+    
+    - If unknown_keyword_arg is already a Control, nothing to do.
+    - If unknown_keyword_arg is a tuple or a list or something else, 
+    guess the Slider declaration automatically (see `control_from_tuple`)
+
+    You cannot have several controls which have the same attribute .name
+    See https://github.com/balthazarneveu/interactive_pipe/issues/35 for more details
+    """
+    chosen_control = None
+    if isinstance(unknown_keyword_arg, Control): # This includes KeyboardControl aswell!!
+        if unknown_keyword_arg.name is None or unknown_keyword_arg._auto_named:
+            unknown_keyword_arg.name = param_name
+        chosen_control = unknown_keyword_arg
+    else:
+        if isinstance(unknown_keyword_arg, list) or isinstance(unknown_keyword_arg, tuple):
+            try:
+                chosen_control = control_from_tuple(unknown_keyword_arg, param_name=param_name)
+            except Exception as exc_1:
+                try:
+                    chosen_control = control_from_tuple((unknown_keyword_arg,), param_name=param_name)
+                except Exception as exc:
+                    raise Exception(exc)
+            # NOTE: for keyword args, setting a boolean will not trigger a tickmark (although it is possible)
+            # Use (True) instead of True if you want to make a tickbox
+    if chosen_control is not None:
+        assert chosen_control.name not in _private.registered_controls_names, f"{chosen_control.name} already attributed - {_private.registered_controls_names}"
+        _private.registered_controls_names.append(chosen_control.name)
+    return chosen_control
+
+def get_controls_from_decorated_function_declaration(func: Callable, decorator_controls: dict):
+    controls = {}
+    keyword_args = analyze_apply_fn_signature(func)[1]
+    keyword_names =  list(keyword_args.keys())
+    
+    # Analyze at 2 levels (function keyword args & decorator keyword args)  then register controls when necessary.
+    #-------------------------------------------
+    # @interactive(param_2=Control(...), )
+    # def func(img1, img2, param_1=Control(...)):
+    #-------------------------------------------
+    
+    # 1. Analyzing function keyword args
+    # def func(img1, img2, param_1=Control(...))
+    
+    for param_name, unknown_keyword_arg in keyword_args.items():
+        chosen_control = __create_control_from_keyword_argument(param_name, unknown_keyword_arg)
+        if chosen_control is not None:
+            controls[param_name] = chosen_control
+        
+    
+    # 2. Analyzing decorator keyword args 
+    # @interactive(param_2=Control(...))
+    for param_name, unknown_keyword_arg in decorator_controls.items():
+        assert param_name in keyword_names, f"typo: control {param_name} passed through the decorator does not match any of the function keyword args {keyword_names}"
+        chosen_control = __create_control_from_keyword_argument(param_name, unknown_keyword_arg)
+        if chosen_control is not None:
+            controls[param_name] = chosen_control
+
+    for param_name, unknown_control in controls.items():
+        Control.register(func.__name__, param_name, controls[param_name])
+    return controls

interactive_pipe-0.5.7/src/interactive_pipe/helper/pipeline_decorator.py

@@ -0,0 +1,32 @@
+from interactive_pipe.headless.pipeline import HeadlessPipeline
+from interactive_pipe.graphical.gui import InteractivePipeGUI
+
+import functools
+from typing import Callable,Union
+from interactive_pipe.helper.choose_backend import get_interactive_pipeline_class
+
+
+def pipeline(pipeline_function:Callable, **kwargs) -> HeadlessPipeline:
+    return HeadlessPipeline.from_function(pipeline_function, **kwargs)
+
+
+def interactive_pipeline(gui="auto", cache=False, output_canvas=None, **kwargs_gui) -> Union[HeadlessPipeline, InteractivePipeGUI]:
+    """@interactive_pipeline
+
+    Function decorator to add some controls @interactive_pipeline
+    """
+    def wrapper(pipeline_function):
+        headless_pipeline = HeadlessPipeline.from_function(pipeline_function, cache=cache)
+        if output_canvas is not None:
+            headless_pipeline.outputs = output_canvas
+        if gui is None:
+            return headless_pipeline
+        else:
+            InteractivePipeGui = get_interactive_pipeline_class(gui)
+            gui_pipeline = InteractivePipeGui(pipeline=headless_pipeline, name=pipeline_function.__name__, **kwargs_gui)
+
+        @functools.wraps(pipeline_function)
+        def inner(*args, **kwargs):
+            return gui_pipeline.__call__(*args, **kwargs)
+        return inner
+    return wrapper

{interactive_pipe-0.5.6 → interactive_pipe-0.5.7}/src/interactive_pipe.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: interactive-pipe
-Version: 0.5.6
+Version: 0.5.7
 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
@@ -26,8 +26,8 @@ License-File: LICENSE
 | Science notebook | Toddler DIY Jukebox on a raspberry Pi |
 |:-----: |:-----:|
 | ![science notebook](/doc/images/scientific_notebook.jpg) |  ![jukebox](/doc/images/jukebox.jpg)
-| Sliders are added automatically in your jupyter notebook. This works on Google Collab and the code takes about 40 lines of code.| Plays some music when you touch the icon. Images can be generated using the OpenAI Dall-E API helpers. Text overlay is added using OpenCV |
-| [Sample notebook](https://colab.research.google.com/drive/1AwHyjZH8MnzZqwsvbmxBoB15btuMIwtk?usp=sharing) | :soon: sample code |
+| Sliders are added automatically in your jupyter notebook. This works on Google Collab and the code takes about 40 lines of code. No Widgets, event handlers or matplotlib knowledge required.| Plays some music when you touch the icon. Images can be generated using the OpenAI [Dall-E API helpers](https://github.com/balthazarneveu/interactive_pipe/blob/master/src/interactive_pipe/thirdparty/images_openai_api.py) . Caption added through the title mechanism. Music samples generated by prompting [MusicGen](https://huggingface.co/spaces/facebook/MusicGen) |
+| [Demo notebook on collab](https://colab.research.google.com/drive/1AwHyjZH8MnzZqwsvbmxBoB15btuMIwtk?usp=sharing) | [jukebox.py demo code](/demo/jukebox.py)|
 
 ----------------------
 
@@ -55,7 +55,7 @@ License-File: LICENSE
 ----------------------
 
 ## :scroll:  Features
-**Version 0.5.6**
+**Version 0.5.7**
 - Modular multi-image processing filters
 - Declarative: Easily make graphical user interface without having to learn anything about pyQt or matplotlib
 - Support in jupyter notebooks

{interactive_pipe-0.5.6 → interactive_pipe-0.5.7}/src/interactive_pipe.egg-info/SOURCES.txt

@@ -33,8 +33,12 @@ src/interactive_pipe/headless/control.py
 src/interactive_pipe/headless/keyboard.py
 src/interactive_pipe/headless/pipeline.py
 src/interactive_pipe/helper/__init__.py
+src/interactive_pipe/helper/_private.py
+src/interactive_pipe/helper/choose_backend.py
 src/interactive_pipe/helper/control_abbreviation.py
-src/interactive_pipe/helper/decorator.py
+src/interactive_pipe/helper/filter_decorator.py
+src/interactive_pipe/helper/keyword_args_analyzer.py
+src/interactive_pipe/helper/pipeline_decorator.py
 src/interactive_pipe/thirdparty/images_openai_api.py
 src/interactive_pipe/thirdparty/music_spotify.py
 test/test_cache.py

{interactive_pipe-0.5.6 → interactive_pipe-0.5.7}/test/test_decorator.py

@@ -1,5 +1,5 @@
 from interactive_pipe.headless.control import Control
-from interactive_pipe import interactive
+from interactive_pipe.helper.filter_decorator import interactive
 import numpy as np
 
 @interactive(

interactive_pipe-0.5.6/src/interactive_pipe/__init__.py

@@ -1,3 +0,0 @@
-from interactive_pipe.helper.decorator import interactive, pipeline, interactive_pipeline
-from interactive_pipe.headless.control import Control
-from interactive_pipe.headless.keyboard import  KeyboardControl

interactive_pipe-0.5.6/src/interactive_pipe/helper/decorator.py

@@ -1,90 +0,0 @@
-from interactive_pipe.headless.control import Control
-from interactive_pipe.helper.control_abbreviation import control_from_tuple
-from interactive_pipe.headless.pipeline import HeadlessPipeline
-from interactive_pipe.graphical.gui import InteractivePipeGUI
-from interactive_pipe.core.graph import analyze_apply_fn_signature
-import functools
-import inspect
-from typing import Callable,Union
-import logging
-
-def interactive(**decorator_controls):
-    """Function decorator to add some controls
-    """
-    def wrapper(func):
-        controls = {}
-        keyword_args = analyze_apply_fn_signature(func)[1]
-        keyword_names =  list(keyword_args.keys())
-        for param_name, unknown_keyword_arg in keyword_args.items():
-            if isinstance(unknown_keyword_arg, Control):
-                if unknown_keyword_arg.name is None or unknown_keyword_arg._auto_named:
-                    unknown_keyword_arg.name = param_name
-                controls[param_name] = unknown_keyword_arg
-            else:
-                if isinstance(unknown_keyword_arg, list) or isinstance(unknown_keyword_arg, tuple):
-                    try:
-                        controls[param_name] = control_from_tuple(unknown_keyword_arg, param_name=param_name)
-                    except Exception as exc_1:
-                        try:
-                            controls[param_name] = control_from_tuple((unknown_keyword_arg,), param_name=param_name)
-                        except Exception as exc:
-                            print(exc_1)
-                            raise Exception(exc)
-                    # NOTE: for keyword args, setting a boolean will not trigger a tickmark (although it is possible)
-                    # Use (True) instead of True if you want to make a tickbox
-
-
-        for param_name, unknown_control in decorator_controls.items():
-            assert param_name in keyword_names, f"typo: control {param_name} passed through the decorator does not match any of the function keyword args {keyword_names}"
-            if isinstance(unknown_control, Control):
-                controls[param_name] = unknown_control
-            else: # you may get a tuple, list or a boolean
-                controls[param_name] = control_from_tuple(unknown_control, param_name=param_name)
-
-        for param_name, unknown_control in controls.items():
-            Control.register(func.__name__, param_name, controls[param_name])
-        @functools.wraps(func)
-        def inner(*args, **kwargs):
-            # Combine args and kwargs into a single dictionary
-            merged_kwargs = {**kwargs, **controls}
-            bound_args = inspect.signature(func).bind(*args, **merged_kwargs)
-            bound_args.apply_defaults()
-            
-            for k, v in bound_args.arguments.items():
-                if isinstance(v, Control):
-                    bound_args.arguments[k] = v.value
-            
-            # Call the original function with the processed arguments
-            return func(*bound_args.args, **bound_args.kwargs)
-        return inner
-    return wrapper
-
-
-def pipeline(pipeline_function:Callable, **kwargs) -> HeadlessPipeline:
-    return HeadlessPipeline.from_function(pipeline_function, **kwargs)
-
-
-def interactive_pipeline(gui=None, cache=False, output_canvas=None, **kwargs_gui) -> Union[HeadlessPipeline, InteractivePipeGUI]:
-    """Function decorator to add some controls
-    """
-    def wrapper(pipeline_function):
-        headless_pipeline = HeadlessPipeline.from_function(pipeline_function, cache=cache)
-        if output_canvas is not None:
-            headless_pipeline.outputs = output_canvas
-        if gui is None:
-            return headless_pipeline
-        if gui == "qt":
-            from interactive_pipe.graphical.qt_gui import InteractivePipeQT as InteractivePipeGui   
-        elif gui == "mpl":
-            from interactive_pipe.graphical.mpl_gui import InteractivePipeMatplotlib as InteractivePipeGui
-        elif gui == "nb":
-            from interactive_pipe.graphical.nb_gui import InteractivePipeJupyter as InteractivePipeGui
-        else:
-            raise NotImplementedError(f"Gui {gui} not available")
-        gui_pipeline = InteractivePipeGui(pipeline=headless_pipeline, name=pipeline_function.__name__, **kwargs_gui)
-
-        @functools.wraps(pipeline_function)
-        def inner(*args, **kwargs):
-            return gui_pipeline.__call__(*args, **kwargs)
-        return inner
-    return wrapper