simplify codebase

app.py

@@ -1,14 +1,94 @@
-# Interactive code
+
+import numpy as np
 import argparse
-from interactivity import run_interactive_pipeline
+from PIL import Image
+from interactive_pipe import (
+    interactive_pipeline, interactive, Curve, SingleCurve
+)
+from transformers import pipeline
+
+# -------------------
+# Processing blocks
+# -------------------
+
+
+@interactive(
+    radius=(0.005, [0., 0.01]),
+    isotropy=(0.5, [0., 1.]),
+)
+def gen_color(
+    radius: int = 0,  # discrete slider (int)
+    isotropy: float = 0.,  # continuous slider (float)
+):
+    out = np.zeros((256, 256, 3))  # Initial background set to black
+    out[:, :, 1] = 0.5
+    x, y = np.meshgrid(np.linspace(-1, 1, 256), np.linspace(-1, 1, 256))
+    # ball positions and colors: [(cx, cy), [R, G, B]]
+    balls = [
+        ((0, 0), [0.8, 0.8, 0.8]),  # Cue ball (white)
+        ((0.0, -0.6), [1, 1, 0]),
+        ((-0.15, -0.85), [1, 0, 0]),
+        ((0.0, -0.85), [0, 1, 0]),
+        ((0.15, -0.85), [1, 0, 0]),
+        ((-0.075, -0.725), [1, 1, 0]),
+        ((0.075, -0.725), [1, 0, 0]),
+    ]
+    if isotropy <= 0.5:
+        # 0.5 -> 1
+        x_scale, y_scale = isotropy, 1
+    else:
+        x_scale, y_scale = 1, 1-isotropy
+    for (cx, cy), color in balls:
+        r = (x_scale * (x - cx) ** 2 + y_scale * (y - cy) ** 2) < radius
+        out[r, :] = color  # Set the color for each ball based on its position
+
+    return out
+
+
+@interactive(detect=(True, "Enable classification"))
+def apply_classifier(img, context={}, detect=False):
+    result = {}
+    if detect:
+        if not context.get("clf", None):
+            context["clf"] = pipeline("image-classification")
+        result = context["clf"](Image.fromarray((img*255).astype(np.uint8)))
+    else:
+        result = [{"score": 0., "label": "No classification"}]*5
+    context["result"] = result
+    # return result
+
+
+def display_result(context={}):
+    result_dict = context.get("result", [])
+    curves = [
+        SingleCurve(
+            x=[id, id, id+1, id+1],
+            y=[0, r['score'], r['score'], 0],
+            label=r["label"], style="-"
+        )
+        for id, r in enumerate(result_dict)]
+    result_curves = Curve(curves, ylim=[0, 1])
+    return result_curves
+
+# -------------------
+# Pipeline definition
+# -------------------
+
+
+def tutorial_pipeline():
+    inp = gen_color()
+    apply_classifier(inp)
+    result_curve = display_result()
+    return inp, result_curve
+
 
 if __name__ == "__main__":
     BACKEND_OPTIONS = ["gradio", "qt", "mpl"]
     parser = argparse.ArgumentParser()
     parser.add_argument("-b", "--backend", type=str,
                         choices=BACKEND_OPTIONS, default=BACKEND_OPTIONS[0])
-    args = parser.parse_args()
-    backend = args.backend
-    markdown_description = "# 🔍 EXAMPLE Interactive-pipe + machine learning \n"
-    run_interactive_pipeline(
-        backend=backend, markdown_description=markdown_description)
+    args = parser.parse_args() 
+    md_description = "# 🔍 EXAMPLE Interactive-pipe + machine learning \n"
+    md_description += "```python\n"+open(__file__, 'r').read()+"```\n"
+    interactive_pipeline(gui=args.backend, markdown_description=md_description)(
+        tutorial_pipeline)()

core.py

@@ -1,74 +0,0 @@
-# "Production code"
-import numpy as np
-from PIL import Image
-from interactive_pipe import interactive_pipeline, interactive, Curve, SingleCurve
-from transformers import pipeline
-
-
-@interactive(
-    radius=(0.005, [0., 0.01]),
-    isotropy=(0.5, [0., 1.]),
-)
-def gen_color(
-    radius: int = 0,  # discrete slider (int)
-    isotropy: float = 0.,  # continuous slider (float)
-):
-    out = np.zeros((256, 256, 3))  # Initial background set to black
-    out[:, :, 1] = 0.5
-    x, y = np.meshgrid(np.linspace(-1, 1, 256), np.linspace(-1, 1, 256))
-    # ball positions and colors: [(cx, cy), [R, G, B]]
-    balls = [
-        ((0, 0), [0.8, 0.8, 0.8]),  # Cue ball (white)
-        ((0.0, -0.6), [1, 1, 0]),
-        ((-0.15, -0.85), [1, 0, 0]),
-        ((0.0, -0.85), [0, 1, 0]),
-        ((0.15, -0.85), [1, 0, 0]),
-        ((-0.075, -0.725), [1, 1, 0]),
-        ((0.075, -0.725), [1, 0, 0]),
-    ]
-    if isotropy <= 0.5:
-        # 0.5 -> 1
-        x_scale, y_scale = isotropy, 1
-    else:
-        x_scale, y_scale = 1, 1-isotropy
-    for (cx, cy), color in balls:
-        r = (x_scale * (x - cx) ** 2 + y_scale * (y - cy) ** 2) < radius
-        out[r, :] = color  # Set the color for each ball based on its position
-
-    return out
-
-
-@interactive(detect=(True, "Enable classification"))
-def apply_classifier(img, context={}, detect=False):
-    result = {}
-    if detect:
-        if not context.get("clf", None):
-            context["clf"] = pipeline("image-classification")
-        result = context["clf"](Image.fromarray((img*255).astype(np.uint8)))
-    else:
-        result = [{"score": 0., "label": "No classification"}]*5
-    context["result"] = result
-    # return result
-
-
-def display_result(context={}):
-    result_dict = context.get("result", [])
-    curves = [
-        SingleCurve(
-            x=[id, id, id+1, id+1],
-            y=[0, r['score'], r['score'], 0],
-            label=r["label"], style="-"
-        )
-        for id, r in enumerate(result_dict)]
-    result_curves = Curve(curves, ylim=[0, 1])
-    return result_curves
-# -------------------
-# Pipeline definition
-# -------------------
-
-
-def tutorial_pipeline():
-    inp = gen_color()
-    apply_classifier(inp)
-    result_curve = display_result()
-    return inp, result_curve

interactivity.py

@@ -1,49 +0,0 @@
-from interactive_pipe import interactive_pipeline, interactive
-from core import (gen_color, tutorial_pipeline)
-import argparse
-# --------------------------------------------------------------
-
-
-def add_interactivity() -> None:
-    # Depending on the level of control you want,
-    # you can add more or less controls to the pipeline
-    # interactive(
-    #     ratio=(0.5, [0., 1.], "Side by Side comparison")
-    # )(compare_by_splitting)
-    # interactive(
-    #     bnw=(True, "Black and White")
-    # )(change_color)
-    # interactive(
-    #     effect=("flip", ["flip", "mirror", "flip+mirror", "identity"])
-    # )(modify_geometry)
-    # interactive(
-    #     frequency=(80, [1, 100]),
-    #     isotropy=(0.8, [0.1, 1.])
-    # )(gen_color)
-    pass
-
-
-def run_interactive_pipeline(
-    backend: str = "gradio",
-    markdown_description: str = "# Tuto"
-) -> None:
-    add_interactivity()
-    playable_tutorial_pipeline = interactive_pipeline(
-        gui=backend,
-        cache=True,
-        markdown_description=markdown_description,
-        context={"initialized_param": 42}
-        # context is shared between processing blocks.
-        # Initialization allow to pre-load a neural network for example.
-    )(tutorial_pipeline)
-    playable_tutorial_pipeline()
-
-
-if __name__ == "__main__":
-    BACKEND_OPTIONS = ["gradio", "qt"]
-    parser = argparse.ArgumentParser()
-    parser.add_argument("-b", "--backend", type=str,
-                        choices=BACKEND_OPTIONS, default=BACKEND_OPTIONS[0])
-    args = parser.parse_args()
-    run_interactive_pipeline(backend=args.backend,
-                             markdown_description="# Tutorial")