interactive-pipe 0.8.4__tar.gz → 0.8.6__tar.gz

{interactive_pipe-0.8.4/src/interactive_pipe.egg-info → interactive_pipe-0.8.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: interactive_pipe
-Version: 0.8.4
+Version: 0.8.6
 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
@@ -106,7 +106,7 @@ pip install -e ".[full]"
 
 ## :scroll:  Features
 
-**Version 0.8.4**
+**Version 0.8.6**
 - Modular multi-image processing filters
 - Declarative: Easily make graphical user interface without having to learn anything about pyQt or matplotlib
 - Support in jupyter notebooks
@@ -165,6 +165,11 @@ Shortcuts while using the GUI (QT & matplotlib backends)
 ### [Main tutorial](https://huggingface.co/spaces/balthou/interactive-pipe-tutorial)
 ![tuto](/doc/images/tutorial.png)
 
+[Tutorial on Hugging Face space](https://huggingface.co/spaces/balthou/interactive-pipe-tutorial)
+
+
+[Tutorial in a Colab notebook](https://colab.research.google.com/github/livalgo/interactive-pipe-examples/blob/main/interactive_pipe_tutorial.ipynb#scrollTo=U38Oh7coVKwf)
+
 ### Learn by examples
 #### [Basic image processing (python code sample for PyQT GUI)](/demo/multi_image.py)
 | GUI | Pipeline | 

{interactive_pipe-0.8.4 → interactive_pipe-0.8.6}/pyproject.toml

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

{interactive_pipe-0.8.4 → interactive_pipe-0.8.6}/readme.md

@@ -62,7 +62,7 @@ pip install -e ".[full]"
 
 ## :scroll:  Features
 
-**Version 0.8.4**
+**Version 0.8.6**
 - Modular multi-image processing filters
 - Declarative: Easily make graphical user interface without having to learn anything about pyQt or matplotlib
 - Support in jupyter notebooks
@@ -121,6 +121,11 @@ Shortcuts while using the GUI (QT & matplotlib backends)
 ### [Main tutorial](https://huggingface.co/spaces/balthou/interactive-pipe-tutorial)
 ![tuto](/doc/images/tutorial.png)
 
+[Tutorial on Hugging Face space](https://huggingface.co/spaces/balthou/interactive-pipe-tutorial)
+
+
+[Tutorial in a Colab notebook](https://colab.research.google.com/github/livalgo/interactive-pipe-examples/blob/main/interactive_pipe_tutorial.ipynb#scrollTo=U38Oh7coVKwf)
+
 ### Learn by examples
 #### [Basic image processing (python code sample for PyQT GUI)](/demo/multi_image.py)
 | GUI | Pipeline | 

{interactive_pipe-0.8.4 → interactive_pipe-0.8.6}/src/interactive_pipe/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.8.4"
+__version__ = "0.8.6"
 from interactive_pipe.helper.pipeline_decorator import pipeline, interactive_pipeline
 from interactive_pipe.headless.control import Control, CircularControl, TextPrompt
 from interactive_pipe.data_objects.curves import Curve, SingleCurve

{interactive_pipe-0.8.4 → interactive_pipe-0.8.6}/src/interactive_pipe/core/cache.py

@@ -48,8 +48,7 @@ class CachedResults:
         :param new_params: The new parameters to check.
         :return: True if an update is needed or False otherwise.
         """
-        change_state_from_params_check = self.state_change.has_changed(
-            new_params)
+        change_state_from_params_check = self.state_change.has_changed(new_params)
         if self.force_change:
             self.state_change.update_needed = True
             self.force_change = False
@@ -64,8 +63,9 @@ class CachedResults:
         """
         if self.name is not None:
             logging.debug(f"OVERRIDE CACHE RESULTS - {self.name}")
-        self.result = new_result if not self.safe_buffer_deepcopy else deepcopy(
-            new_result)
+        self.result = (
+            new_result if not self.safe_buffer_deepcopy else deepcopy(new_result)
+        )
 
     def __repr__(self) -> str:
         return self.name
@@ -106,4 +106,6 @@ class StateChange:
         self._update_needed = value
 
     def __repr__(self) -> str:
-        return f"{self.name}: " + ("needs update" if self.update_needed else "no update needed")
+        return f"{self.name}: " + (
+            "needs update" if self.update_needed else "no update needed"
+        )

{interactive_pipe-0.8.4 → interactive_pipe-0.8.6}/src/interactive_pipe/core/engine.py

@@ -4,7 +4,6 @@ import time
 import traceback
 from copy import deepcopy
 from typing import List
-from interactive_pipe.core.cache import CachedResults
 from interactive_pipe.core.filter import FilterCore
 
 
@@ -22,13 +21,12 @@ class PipelineEngine:
                 for input_index, inp in enumerate(imglst):
                     if self.safe_input_buffer_deepcopy:
                         result[input_index] = deepcopy(inp)
-                        logging.debug(
-                            f"<<< Deepcopy input images {input_index}")
+                        logging.debug(f"<<< Deepcopy input images {input_index}")
                     else:
                         result[input_index] = inp
             elif isinstance(imglst, dict):
                 if self.safe_input_buffer_deepcopy:
-                    logging.debug(f"<<< Deepcopy input images")
+                    logging.debug("<<< Deepcopy input images")
                     result = deepcopy(imglst)
                 else:
                     result = imglst
@@ -43,32 +41,38 @@ class PipelineEngine:
             # 1     | 0           | True  -> cache with no change, skip the calculation
             # 1     | 1           | False -> cache and result changed, cannot skip so calculate
             skip_calculation &= (prc.cache_mem is not None) and (
-                not prc.cache_mem.has_changed(prc.values))
+                not prc.cache_mem.has_changed(prc.values)
+            )
 
             if skip_calculation and self.cache:
-                logging.debug(
-                    f"-->  Load cached outputs from filter {idx}: {prc.name}")
+                logging.debug(f"-->  Load cached outputs from filter {idx}: {prc.name}")
                 out = prc.cache_mem.result
                 previous_calculation = False
             else:
                 logging.debug(
-                    ("... " if previous_calculation else "!!! ") + f"Calculating {prc.name}")
+                    ("... " if previous_calculation else "!!! ")
+                    + f"Calculating {prc.name}"
+                )
                 try:
                     routing_in = []
                     if prc.inputs:
                         routing_in = [
-                            result[idi] if idi is not None else None for idi in prc.inputs]
+                            result[idi] if idi is not None else None
+                            for idi in prc.inputs
+                        ]
                     logging.debug(f"in types-> {[type(inp) for inp in routing_in]}")
                     out = prc.run(*routing_in)
                     if out is not None:
                         logging.debug(f"out types-> {[type(ou) for ou in out]}")
                 except Exception as e:
-                    logging.error(f'Error in {prc.name} filter:')
+                    logging.error(f"Error in {prc.name} filter:")
                     logging.error(e)
                     traceback.print_exc()
                     sys.exit(1)
                 previous_calculation = True
-                if self.cache and prc.cache_mem is not None:  # cache result if cache available
+                if (
+                    self.cache and prc.cache_mem is not None
+                ):  # cache result if cache available
                     logging.debug(f"<-- Storing result from {prc.name}")
                     prc.cache_mem.update(out)
             # put prc output at the right position within result vector

{interactive_pipe-0.8.4 → interactive_pipe-0.8.6}/src/interactive_pipe/core/filter.py

@@ -5,13 +5,28 @@ from typing import Callable, List, Optional, Union, Tuple, Any
 from interactive_pipe.core.cache import CachedResults
 from interactive_pipe.core.signature import analyze_apply_fn_signature
 
-EQUIVALENT_STATE_KEYS = ["global_params", "global_parameters", "global_state", "global_context", "context", "state"]
+EQUIVALENT_STATE_KEYS = [
+    "global_params",
+    "global_parameters",
+    "global_state",
+    "global_context",
+    "context",
+    "state",
+]
 
 
 class PureFilter:
-    def __init__(self, apply_fn: Optional[Callable] = None, name: Optional[str] = None, default_params: dict = {}):
-        self.name = name if name else (
-            self.__class__.__name__ if not apply_fn else apply_fn.__name__)
+    def __init__(
+        self,
+        apply_fn: Optional[Callable] = None,
+        name: Optional[str] = None,
+        default_params: dict = {},
+    ):
+        self.name = (
+            name
+            if name
+            else (self.__class__.__name__ if not apply_fn else apply_fn.__name__)
+        )
         if apply_fn is not None:
             self.apply = apply_fn
         self._global_params = {}
@@ -34,7 +49,8 @@ class PureFilter:
     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.apply
+            )
             self.signature = (self.__args_names, self.__kwargs_names)
         else:  # skip computing signature
             pass
@@ -53,8 +69,7 @@ class PureFilter:
 
     @values.setter
     def values(self, new_values):
-        assert isinstance(
-            new_values, dict), f"{new_values} is not a dictionary"
+        assert isinstance(new_values, dict), f"{new_values} is not a dictionary"
         self._values = {**self._values, **new_values}
 
     def run(self, *imgs) -> Tuple[Any]:
@@ -62,14 +77,16 @@ class PureFilter:
         assert isinstance(self.values, dict), f"{self.values}"
         self.check_apply_signature()
         for key, val in self.values.items():
-            assert key in self.__kwargs_names.keys(
+            assert (
+                key in self.__kwargs_names.keys()
             ), f"{self.name} : {key} not in {self.__kwargs_names.keys()}"
         global_key_found = False
         for global_key in EQUIVALENT_STATE_KEYS:
             if global_key in self.__kwargs_names.keys():
                 # special key to provide the context dictionary
                 out = self.apply(
-                    *imgs, **{**{global_key: self.global_params}, **self.values})
+                    *imgs, **{**{global_key: self.global_params}, **self.values}
+                )
                 global_key_found = True
                 break
         if not global_key_found:
@@ -80,16 +97,16 @@ class PureFilter:
 class FilterCore(PureFilter):
     """PureFilter with cache storage + routing nodes defined (inputs & outputs fields)"""
 
-    def __init__(self,
-                 apply_fn: Callable = None,
-                 name: Optional[str] = None,
-                 default_params: dict = {},
-                 inputs: List[Union[int, str]] = [0],
-                 outputs: List[Union[int, str]] = [0],
-                 cache=True,
-                 ):
-        super().__init__(apply_fn=apply_fn, name=name,
-                         default_params=default_params)
+    def __init__(
+        self,
+        apply_fn: Callable = None,
+        name: Optional[str] = None,
+        default_params: dict = {},
+        inputs: List[Union[int, str]] = [0],
+        outputs: List[Union[int, str]] = [0],
+        cache=True,
+    ):
+        super().__init__(apply_fn=apply_fn, name=name, default_params=default_params)
         self.inputs = inputs
         self.outputs = outputs
         self.cache = cache
@@ -104,7 +121,8 @@ class FilterCore(PureFilter):
     def run(self, *imgs) -> Tuple[Any]:
         if imgs:
             assert len(imgs) == len(
-                self.inputs), "number of inputs shall match what's expected"
+                self.inputs
+            ), "number of inputs shall match what's expected"
         if self.inputs is None:
             if imgs is not None:
                 assert len(imgs) == 0
@@ -116,20 +134,21 @@ class FilterCore(PureFilter):
             return None
         if isinstance(out, tuple) or isinstance(out, list):
             assert len(out) >= len(
-                self.outputs), "number of outputs shall be at least greater or equal to what's expected by the filter"
+                self.outputs
+            ), "number of outputs shall be at least greater or equal to what's expected by the filter"
             return out
 
         else:
             logging.debug(
-                f"need to return a tuple when you have a single element out {type(out)}")
+                f"need to return a tuple when you have a single element out {type(out)}"
+            )
             assert len(self.outputs) == 1, "returning a single element!"
             return (out,)
 
     def __repr__(self) -> str:
         descr = f"{self.name}: "
         descr += "(" + (", ".join([f"{it}" for it in self.inputs])) + ")"
-        descr += " -> " + \
-            "(" + ", ".join([f"{it}" for it in self.outputs]) + ")"
+        descr += " -> " + "(" + ", ".join([f"{it}" for it in self.outputs]) + ")"
         # descr += "\n"
         return descr
 

{interactive_pipe-0.8.4 → interactive_pipe-0.8.6}/src/interactive_pipe/core/graph.py

@@ -1,7 +1,7 @@
 import ast
 import inspect
 import logging
-from typing import List, Callable, Tuple, Optional, Union
+from typing import List, Callable, Optional, Union
 from interactive_pipe.core.filter import FilterCore
 from interactive_pipe.core.signature import analyze_apply_fn_signature
 
@@ -17,7 +17,9 @@ def get_name(node: ast.NodeVisitor) -> Union[str, List[str], None]:
         return None
 
 
-def flatten_target_names(targets: List[Union[list, str, None]], mapping_function: Optional[Callable] = None) -> List[str]:
+def flatten_target_names(
+    targets: List[Union[list, str, None]], mapping_function: Optional[Callable] = None
+) -> List[str]:
     output_names = []
     for target in targets:
         target_name = mapping_function(target) if mapping_function else target
@@ -42,26 +44,27 @@ def get_call_graph(func: Callable, global_context=None) -> dict:
         if isinstance(node, ast.Expr) and isinstance(node.value, ast.Call):
             function_name = get_name(node.value.func)
             input_names = [get_name(arg) for arg in node.value.args]
-            results.append({
-                "function_name": function_name,
-                "function_object": global_context[function_name],
-                "args": input_names,
-                "returns": [],
-                "output_names": [],
-            })
+            results.append(
+                {
+                    "function_name": function_name,
+                    "function_object": global_context[function_name],
+                    "args": input_names,
+                    "returns": [],
+                    "output_names": [],
+                }
+            )
             logging.debug(f"Function without assignment {function_name}")
         elif isinstance(node, ast.Assign):
             targets = node.targets
             value = node.value
             if isinstance(value, ast.Call):
                 function_name = get_name(value.func)
-                logging.debug(
-                    f"classic function with assignment {function_name}")
-                assert function_name in global_context.keys(
+                logging.debug(f"classic function with assignment {function_name}")
+                assert (
+                    function_name in global_context.keys()
                 ), f"Probably mispelled {function_name}"
                 input_names = [get_name(arg) for arg in value.args]
-                output_names = flatten_target_names(
-                    targets, mapping_function=get_name)
+                output_names = flatten_target_names(targets, mapping_function=get_name)
                 function_object = global_context[function_name]
                 if isinstance(function_object, FilterCore):
                     # Case of a filter instance
@@ -79,17 +82,21 @@ def get_call_graph(func: Callable, global_context=None) -> dict:
                     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": function_apply,
-                    "signature": {"args": sig[0], "kwargs": sig[1]},
-                    "args": input_names,
-                    "returns": output_names,
-                })
+                        f"Not supported {function_name} - should be function or FilterCore"
+                    )
+                results.append(
+                    {
+                        "function_name": function_name,
+                        "function_object": function_apply,
+                        "signature": {"args": sig[0], "kwargs": sig[1]},
+                        "args": input_names,
+                        "returns": output_names,
+                    }
+                )
     main_function = tree.body[0]
-    outputs = [get_name(ret.value)
-               for ret in main_function.body if isinstance(ret, ast.Return)]
+    outputs = [
+        get_name(ret.value) for ret in main_function.body if isinstance(ret, ast.Return)
+    ]
     assert len(outputs) <= 1, "cannot return several times!"
     outputs = flatten_target_names(outputs, mapping_function=None)
     inputs, kwargs = analyze_apply_fn_signature(func)
@@ -98,7 +105,7 @@ def get_call_graph(func: Callable, global_context=None) -> dict:
         "call_graph": results,
         "args": inputs,
         "kwargs": kwargs,
-        "returns": outputs
+        "returns": outputs,
     }
 
     return graph

{interactive_pipe-0.8.4 → interactive_pipe-0.8.6}/src/interactive_pipe/core/pipeline.py

@@ -24,15 +24,17 @@ class PipelineCore:
         global_context: Optional[dict] = None,  # alias for global_params
         context: Optional[dict] = None,  # alias for global_params
         state: Optional[dict] = None,  # alias for global_params
-        outputs:  Optional[list] = None,
-        safe_input_buffer_deepcopy: bool = True
+        outputs: Optional[list] = None,
+        safe_input_buffer_deepcopy: bool = True,
     ):
         if not all(isinstance(f, FilterCore) for f in filters):
             raise ValueError(
-                f"All elements in 'filters' must be instances of 'Filter'. {[type(f) for f in filters]}")
+                f"All elements in 'filters' must be instances of 'Filter'. {[type(f) for f in filters]}"
+            )
         self.filters = filters
         self.engine = PipelineEngine(
-            cache, safe_input_buffer_deepcopy=safe_input_buffer_deepcopy)
+            cache, safe_input_buffer_deepcopy=safe_input_buffer_deepcopy
+        )
         if global_parameters is not None:
             global_params = global_parameters
         elif global_context is not None:
@@ -52,7 +54,8 @@ class PipelineCore:
         self.reset_cache()
         if inputs is None:
             logging.warning(
-                "Setting a pipeline without input -  use inputs=[] to get rid of this warning")
+                "Setting a pipeline without input -  use inputs=[] to get rid of this warning"
+            )
             self.inputs_routing = []
         else:
             self.inputs_routing = inputs
@@ -60,8 +63,7 @@ class PipelineCore:
         self.__initialized_inputs = False
         if outputs is None:
             outputs = self.filters[-1].outputs
-            logging.warning(
-                f"Using last filter outputs {self.filters[-1]} {outputs}")
+            logging.warning(f"Using last filter outputs {self.filters[-1]} {outputs}")
 
         self.outputs = outputs  # output indexes (routing)
         # You need to set the values to their default_value for each filter
@@ -74,8 +76,7 @@ class PipelineCore:
             filter.reset_cache()
 
     def run(self) -> list:
-        """Useful for standalone python acess without gui or disk write
-        """
+        """Useful for standalone python acess without gui or disk write"""
         return self.engine.run(self.filters, imglst=self.inputs)
 
     def _reset_global_params(self):
@@ -110,10 +111,12 @@ class PipelineCore:
         """
         available_filters_names = [filt.name for filt in self.filters]
         for filter_name in new_parameters.keys():
-            assert filter_name in available_filters_names, f"filter {filter_name}" + \
-                f"does not exist {available_filters_names}"
-            self.filters[available_filters_names.index(
-                filter_name)].values = new_parameters[filter_name]
+            assert filter_name in available_filters_names, (
+                f"filter {filter_name}" + f"does not exist {available_filters_names}"
+            )
+            self.filters[available_filters_names.index(filter_name)].values = (
+                new_parameters[filter_name]
+            )
 
     @property
     def inputs(self):
@@ -126,13 +129,16 @@ class PipelineCore:
             if isinstance(inputs, dict):
                 provided_keys = list(inputs.keys())
                 for idx, input_name in enumerate(self.inputs_routing):
-                    assert input_name in provided_keys, f"{input_name} is not among {provided_keys}"
+                    assert (
+                        input_name in provided_keys
+                    ), f"{input_name} is not among {provided_keys}"
                 self.__inputs = inputs
             elif isinstance(inputs, list) or isinstance(inputs, tuple):
                 # inputs is a list or a tuple
-                assert len(inputs) == len(
-                    self.inputs_routing), f"wrong amount of inputs\nprovided {len(inputs)}" + \
-                    f"inputs vs expected:{len(self.inputs_routing)}"
+                assert len(inputs) == len(self.inputs_routing), (
+                    f"wrong amount of inputs\nprovided {len(inputs)}"
+                    + f"inputs vs expected:{len(self.inputs_routing)}"
+                )
                 self.__inputs = {}
                 for idx, input_name in enumerate(self.inputs_routing):
                     self.__inputs[input_name] = inputs[idx]
@@ -145,8 +151,13 @@ class PipelineCore:
                 # similar to having no input, but explicitly saying that we have initialized it.
                 self.__inputs = None
         else:
-            assert self.inputs_routing is None or ((isinstance(self.inputs_routing, tuple) or isinstance(
-                self.inputs_routing, list)) and len(self.inputs_routing) == 0)
+            assert self.inputs_routing is None or (
+                (
+                    isinstance(self.inputs_routing, tuple)
+                    or isinstance(self.inputs_routing, list)
+                )
+                and len(self.inputs_routing) == 0
+            )
             self.__inputs = None
         self.__initialized_inputs = True
         self.reset_cache()

{interactive_pipe-0.8.4 → interactive_pipe-0.8.6}/src/interactive_pipe/data_objects/audio.py

@@ -5,6 +5,7 @@ from io import BytesIO
 import base64
 import logging
 from typing import Union, Tuple
+
 WAVIO_AVAILABLE = False
 WAVIO = "wavio"
 try:
@@ -16,7 +17,9 @@ except ImportError:
 __iter_audio_player = 0
 
 
-def audio_to_html(audio: Union[None, str, Path, Tuple[int, np.ndarray]], controls=True) -> str:
+def audio_to_html(
+    audio: Union[None, str, Path, Tuple[int, np.ndarray]], controls=True
+) -> str:
     if audio is None:
         logging.debug("No audio to display")
         return ""
@@ -33,11 +36,11 @@ def audio_to_html(audio: Union[None, str, Path, Tuple[int, np.ndarray]], control
         audio_base64 = base64.b64encode(audio_bytes.read()).decode("utf-8")
     audio_player = f'<audio src="data:audio/mpeg;base64,{audio_base64}"'
     if controls:
-        audio_player += ' controls'
-    audio_player += ' autoplay></audio>'
+        audio_player += " controls"
+    audio_player += " autoplay></audio>"
     global __iter_audio_player
     # to avoid reusing the same exact id and thus not updating the audio player
-    audio_player += "<p hidden>"+str(__iter_audio_player)+"</p>"
+    audio_player += "<p hidden>" + str(__iter_audio_player) + "</p>"
     __iter_audio_player += 1
 
     return audio_player
@@ -98,5 +101,5 @@ class Audio(Data):
 
 
 if __name__ == "__main__":
-    audio_sample_path = Path("demo")/"audio"/"rabbit.mp4"
+    audio_sample_path = Path("demo") / "audio" / "rabbit.mp4"
     rate, data = Audio.load_audio(audio_sample_path)