Merge pull request #422 from hx2A/fix421

Fix421

Author: hx2A

generator/reference.py

@@ -267,6 +267,7 @@
                 "hook_post_draw: bool = False",
                 "queue_limit: int = None",
                 "block: bool = False",
+                "display_progress: bool = True",
             ],
             "None",
         )

py5_docs/Reference/api_en/Py5Tools_offline_frame_processing.txt

@@ -5,12 +5,13 @@ category = sketch_hooks
 subcategory = None
 
 @@ signatures
-offline_frame_processing(func: Callable[[npt.NDArray[np.uint8]], None], *, limit: int = 0, period: float = 0.0, batch_size: int = 1, complete_func: Callable[[], None] = None, stop_processing_func: Callable[[], bool] = None, sketch: Sketch = None, hook_post_draw: bool = False, queue_limit: int = None, block: bool = False) -> None
+offline_frame_processing(func: Callable[[npt.NDArray[np.uint8]], None], *, limit: int = 0, period: float = 0.0, batch_size: int = 1, complete_func: Callable[[], None] = None, stop_processing_func: Callable[[], bool] = None, sketch: Sketch = None, hook_post_draw: bool = False, queue_limit: int = None, block: bool = False, display_progress: bool = True) -> None
 
 @@ variables
 batch_size: int = 1 - number of frames to include in each batch passed to the frame processing function
 block: bool = False - method returns immediately (False) or blocks until function returns (True)
 complete_func: Callable[[], None] = None - function to call when frame processing is complete
+display_progress: bool = True - display progress as frames are processed
 func: Callable[[npt.NDArray[np.uint8]], None] - function to process the Sketch's pixels, one batch at a time
 hook_post_draw: bool = False - attach hook to Sketch's post_draw method instead of draw
 limit: int = 0 - total number of frames to pass to the frame processing function
@@ -30,6 +31,8 @@ The `queue_limit` parameter specifies a maximum queue size. If frames are added
 
 By default this function will return right away and will process frames in the background while the Sketch is running. Set the `block` parameter to `True` to instruct the method to not return until the processing is complete or the Sketch terminates. This blocking feature is not available on macOS when the Sketch is executed through an IPython kernel.
 
+By default this function will report its progress as frames are processed. If you are using a Jupyter Notebook and happen to be processing tens of thousands of frames, this might cause Jupyter to crash. To avoid that fate, set the `display_progress` parameter to `False`.
+
 Use the `sketch` parameter to specify a different running Sketch, such as a Sketch created using Class mode. If your Sketch has a `post_draw()` method, use the `hook_post_draw` parameter to make this function run after `post_draw()` instead of `draw()`. This is important when using Processing libraries that support `post_draw()` such as Camera3D or ColorBlindness.
 
 @@ example

py5_resources/py5_module/py5_tools/hooks/frame_hooks.py

@@ -151,6 +151,7 @@ def offline_frame_processing(
     hook_post_draw: bool = False,
     queue_limit: int = None,
     block: bool = None,
+    display_progress: bool = True,
 ) -> None:
     """$module_Py5Tools_offline_frame_processing"""
     import py5
@@ -179,6 +180,7 @@ def offline_frame_processing(
         complete_func=complete_func,
         stop_processing_func=stop_processing_func,
         queue_limit=queue_limit,
+        display_progress=display_progress,
     )
     sketch._add_post_hook(
         "post_draw" if hook_post_draw else "draw", hook.hook_name, hook

py5_resources/py5_module/py5_tools/hooks/hooks.py

@@ -217,12 +217,14 @@ def __init__(
         complete_func=None,
         stop_processing_func=None,
         queue_limit=0,
+        display_progress=True,
     ):
         super().__init__("py5queued_block_processing_hook")
         self.period = period
         self.limit = limit
         self.batch_size = batch_size
         self.queue_limit = queue_limit
+        self.display_progress = display_progress
 
         self.continue_grabbing_frames = True
         self.current_batch = None
@@ -305,7 +307,8 @@ def __call__(self, sketch):
                 self.processor.stop_processing = True
                 self.hook_finished(sketch)
 
-            self.status_msg(self.msg())
+            if self.display_progress:
+                self.status_msg(self.msg())
 
         except Exception as e:
             self.hook_error(sketch, e)