Duplicate from MarcSkovMadsen/awesome-panel

Co-authored-by: Marc Skov Madsen <MarcSkovMadsen@users.noreply.huggingface.co>

.gitattributes

@@ -0,0 +1,28 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bin.* filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zstandard filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,160 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/

README.md

@@ -0,0 +1,20 @@
+---
+title: Awesome Panel
+emoji: 🐠
+colorFrom: indigo
+colorTo: pink
+sdk: gradio
+sdk_version: 2.9.4
+app_file: app.py
+pinned: false
+license: mit
+duplicated_from: MarcSkovMadsen/awesome-panel
+---
+
+# Awesome Panel on Hugging Face Spaces
+
+Awesome Panel supports [Panel](panel.holoviz.org) and its users. We want to show how awesome the framework is and help push it forward. Now on Hugging Face Spaces 🤗.
+
+[Panel](panel.holoviz.org) is a very powerful data app framework that enables you to use the tools you know and love.
+
+You can deploy Panel apps on [Hugging Face](https://huggingface.co/) [Spaces](https://huggingface.co/spaces), if you use the Gradio deployment option and a customized `app.py` file. This repository shows how. For more details check out the [Panel Hugging Face Deployment guide](https://github.com/holoviz/panel/blob/feature/hugging-face-deployment/doc/user_guide/Server_Deployment.md#hugging-face).

app.py

@@ -0,0 +1,39 @@
+"""This files enables serving Panel apps on Hugging Face Spaces"""
+import os
+from subprocess import Popen
+
+# CONFIGURE YOUR SETTINGS HERE
+
+# Space separated list of .py or .ipynb files to serve
+APPS_TO_SERVE = "pages/index.py pages/videostream.py"
+# Prefix of the index .py or .ipynb file. Must be in APPS_TO_SERVE too
+INDEX_PAGE = "index"
+
+# NORMALLY NO NEED TO CHANGE THE BELOW
+PORT = os.environ.get("PORT", "7860")
+ADDRESS = "0.0.0.0"
+command = [
+    "panel",
+    "serve",
+    *APPS_TO_SERVE.split(" "),
+    "--index",
+    INDEX_PAGE,
+    "--port",
+    PORT,
+    "--address",
+    ADDRESS,
+    "--allow-websocket-origin",
+    "localhost",
+    "--allow-websocket-origin",
+    "*.hf.space",
+    "--allow-websocket-origin",
+    "*.huggingface.co",
+    # "--log-level",
+    # "debug"
+]
+if os.name != "nt":
+    command = command + ["--num-procs", "4", "--num-threads", "4"] 
+
+print(" ".join(command))
+worker = Popen(command) 
+worker.wait()

pages/index.py

@@ -0,0 +1,22 @@
+import panel as pn
+
+pn.extension(sizing_mode="stretch_width")
+
+INTRO = """
+# Awesome Panel on Hugging Face Spaces
+
+<a href="https://awesome-panel.org" target="_blank">Awesome Panel</a> supports the powerful data app framework <a href="https://panel.holoviz.org" target="_blank">Panel</a> and its users. Now on Hugging Face Spaces 🤗.
+
+You can also deploy Panel apps on Hugging Face Spaces. For details check out the <a href="https://github.com/holoviz/panel/blob/feature/hugging-face-deployment/doc/user_guide/Server_Deployment.md#hugging-face" target="_blank">Panel Hugging Face Deployment guide</a>.
+
+Now check out some of our example apps by clicking the links below.
+
+[videostream](videostream), ... more is coming soon 🤗
+"""
+
+some_component = pn.panel(INTRO)
+
+pn.template.FastListTemplate(
+    site="Awesome Panel 🤗", title="Hello Hugging Face World", main=[some_component],
+    favicon="https://sharing.awesome-panel.org/favicon.ico", accent="#fef3c7", header_color="#4b5563"
+).servable()

pages/videostream.py

@@ -0,0 +1,116 @@
+"""The VideoStreamInterface provides an easy way to apply transforms to a video stream"""
+import numpy as np
+import panel as pn
+import param
+import skimage
+from PIL import Image, ImageFilter
+from skimage import data, filters
+from skimage.color.adapt_rgb import adapt_rgb, each_channel
+from skimage.draw import rectangle
+from skimage.exposure import rescale_intensity
+from skimage.feature import Cascade
+from videostream_utils import PILImageTransform, NumpyImageTransform, VideoStreamInterface
+
+pn.extension("terminal", sizing_mode="stretch_width")
+
+ACCENT = "#fef3c7"
+
+
+class GaussianBlur(PILImageTransform):
+    """Gaussian Blur
+
+    https://pillow.readthedocs.io/en/stable/reference/ImageFilter.html#PIL.ImageFilter.GaussianBlur
+    """
+
+    radius = param.Integer(default=2, bounds=(0, 10))
+
+    def transform(self, image: Image):
+        return image.filter(ImageFilter.GaussianBlur(radius=self.radius))
+
+
+class GrayscaleTransform(NumpyImageTransform):
+    """GrayScale transform
+
+    https://scikit-image.org/docs/0.15.x/auto_examples/color_exposure/plot_rgb_to_gray.html
+    """
+
+    def transform(self, image: np.ndarray):
+        grayscale = skimage.color.rgb2gray(image[:, :, :3])
+        return skimage.color.gray2rgb(grayscale)
+
+
+class SobelTransform(NumpyImageTransform):
+    """Sobel Transform
+
+    https://scikit-image.org/docs/0.15.x/auto_examples/color_exposure/plot_adapt_rgb.html
+    """
+
+    def transform(self, image):
+        @adapt_rgb(each_channel)
+        def sobel_each(image):
+            return filters.sobel(image)
+
+        return rescale_intensity(1 - sobel_each(image))
+
+
+@pn.cache()
+def get_detector():
+    """Returns the Cascade detector"""
+    trained_file = data.lbp_frontal_face_cascade_filename()
+    return Cascade(trained_file)
+
+class FaceDetectionTransform(NumpyImageTransform):
+    """Face detection using a cascade classifier.
+
+    https://scikit-image.org/docs/0.15.x/auto_examples/applications/plot_face_detection.html
+    """
+
+    scale_factor = param.Number(1.4, bounds=(1.0, 2.0), step=0.1)
+    step_ratio = param.Integer(1, bounds=(1, 10))
+    size_x = param.Range(default=(60, 322), bounds=(10, 500))
+    size_y = param.Range(default=(60, 322), bounds=(10, 500))
+
+    def transform(self, image):
+        detector = get_detector()
+        detected = detector.detect_multi_scale(
+            img=image,
+            scale_factor=self.scale_factor,
+            step_ratio=self.step_ratio,
+            min_size=(self.size_x[0], self.size_y[0]),
+            max_size=(self.size_x[1], self.size_y[1]),
+        )
+
+        for patch in detected:
+            rrr, ccc = rectangle(
+                start=(patch["r"], patch["c"]),
+                extent=(patch["height"], patch["width"]),
+                shape=image.shape[:2],
+            )
+            image[rrr, ccc, 0] = 200
+
+        return image
+
+
+component = VideoStreamInterface(
+    transforms=[
+        GaussianBlur,
+        GrayscaleTransform,
+        SobelTransform,
+        FaceDetectionTransform,
+    ]
+)
+
+component.video_stream.timeout=1000
+component.video_stream.param.timeout.bounds=(250, 2000)
+
+pn.template.FastListTemplate(
+    site="Awesome Panel 🤗",
+    title="VideoStream with transforms",
+    sidebar=[component.settings],
+    main=[
+        """Try a much, much faster version <a href="https://sharing.awesome-panel.org/MarcSkovMadsen/videostream-interface/app.html" target="_blank">here</a> powered by Webassembly.""",
+        component],
+    favicon="https://sharing.awesome-panel.org/favicon.ico",
+    accent=ACCENT,
+    header_color="#4b5563"
+).servable()

pages/videostream_utils.py

@@ -0,0 +1,305 @@
+"""The VideoStreamInterface provides an easy way to apply transforms to a video stream"""
+import base64
+import io
+import time
+
+import numpy as np
+import panel as pn
+import param
+import PIL
+from PIL import Image
+
+HEIGHT = 400
+WIDTH = 400
+TIMEOUT = 250
+ACCENT = "#fef3c7"
+
+
+def to_instance(value, **params):
+    """Converts the value to an instance
+
+    Args:
+        value: A param.Parameterized class or instance
+
+    Returns:
+        An instance of the param.Parameterized class
+    """
+    if isinstance(value, param.Parameterized):
+        value.param.update(**params)
+        return value
+    return value(**params)
+
+
+class Timer(pn.viewable.Viewer):
+    """Helper Component used to show duration trends"""
+
+    _trends = param.Dict()
+
+    def __init__(self, **params):
+        super().__init__()
+
+        self.last_updates = {}
+        self._trends = {}
+
+        self._layout = pn.Row(**params)
+
+    def time_it(self, name, func, *args, **kwargs):
+        """Measures the duration of the execution of the func function and reports it under the
+        name specified"""
+        start = time.time()
+        result = func(*args, **kwargs)
+        end = time.time()
+        duration = round(end - start, 2)
+        self._report(name=name, duration=duration)
+        return result
+
+    def inc_it(self, name):
+        """Measures the duration since the last time `inc_it` was called and reports it under the
+        specified name"""
+        start = self.last_updates.get(name, time.time())
+        end = time.time()
+        duration = round(end - start, 2)
+        self._report(name=name, duration=duration)
+        self.last_updates[name] = end
+
+    def _report(self, name, duration):
+        if not name in self._trends:
+            self._trends[name] = pn.indicators.Trend(
+                title=name,
+                data={"x": [1], "y": [duration]},
+                plot_color=ACCENT,
+                height=100,
+                width=150,
+                sizing_mode="fixed",
+            )
+            self.param.trigger("_trends")
+        else:
+            trend = self._trends[name]
+            next_x = max(trend.data["x"]) + 1
+            trend.stream({"x": [next_x], "y": [duration]}, rollover=10)
+
+    @pn.depends("_trends")
+    def _panel(self):
+        self._layout[:] = list(self._trends.values())
+        return self._layout
+
+    def __panel__(self):
+        return self._panel
+
+
+class ImageTransform(pn.viewable.Viewer):
+    """Base class for image transforms."""
+
+    def __init__(self, **params):
+        super().__init__(**params)
+
+        with param.edit_constant(self):
+            self.name = self.__class__.name.replace("Transform", "")
+        self.view = self.create_view()
+
+    def __panel__(self):
+        return self.view
+
+    def run(self, image: str, height: int = HEIGHT, width: int = WIDTH) -> str:
+        """Transforms the base64 encoded jpg image to a base64 encoded jpg BytesIO object"""
+        raise NotImplementedError()
+
+    def create_view(self):
+        """Creates a view of the parameters of the transform to enable the user to configure them"""
+        return pn.Param(self, name=self.name)
+
+    def transform(self, image):
+        """Transforms the image"""
+        raise NotImplementedError()
+
+
+class PILImageTransform(ImageTransform):
+    """Base class for PIL image transforms"""
+
+    @staticmethod
+    def to_pil_img(value: str, height=HEIGHT, width=WIDTH):
+        """Converts a base64 jpeg image string to a PIL.Image"""
+        encoded_data = value.split(",")[1]
+        base64_decoded = base64.b64decode(encoded_data)
+        image = Image.open(io.BytesIO(base64_decoded))
+        image.draft("RGB", (height, width))
+        return image
+
+    @staticmethod
+    def from_pil_img(image: Image):
+        """Converts a PIL.Image to a base64 encoded JPG BytesIO object"""
+        buff = io.BytesIO()
+        image.save(buff, format="JPEG")
+        return buff
+
+    def run(self, image: str, height: int = HEIGHT, width: int = WIDTH) -> io.BytesIO:
+        pil_img = self.to_pil_img(image, height=height, width=width)
+
+        transformed_image = self.transform(pil_img)
+
+        return self.from_pil_img(transformed_image)
+
+    def transform(self, image: PIL.Image) -> PIL.Image:
+        """Transforms the PIL.Image image"""
+        raise NotImplementedError()
+
+
+class NumpyImageTransform(ImageTransform):
+    """Base class for np.ndarray image transforms"""
+
+    @staticmethod
+    def to_np_ndarray(image: str, height=HEIGHT, width=WIDTH) -> np.ndarray:
+        """Converts a base64 encoded jpeg string to a np.ndarray"""
+        pil_img = PILImageTransform.to_pil_img(image, height=height, width=width)
+        return np.array(pil_img)
+
+    @staticmethod
+    def from_np_ndarray(image: np.ndarray) -> io.BytesIO:
+        """Converts np.ndarray jpeg image to a jpeg BytesIO instance"""
+        if image.dtype == np.dtype("float64"):
+            image = (image * 255).astype(np.uint8)
+        pil_img = PIL.Image.fromarray(image)
+        return PILImageTransform.from_pil_img(pil_img)
+
+    def run(self, image: str, height: int = HEIGHT, width: int = WIDTH) -> io.BytesIO:
+        np_array = self.to_np_ndarray(image, height=height, width=width)
+
+        transformed_image = self.transform(np_array)
+
+        return self.from_np_ndarray(transformed_image)
+
+    def transform(self, image: np.ndarray) -> np.ndarray:
+        """Transforms the nd.array image"""
+        raise NotImplementedError()
+
+
+class VideoStreamInterface(pn.viewable.Viewer):
+    """An easy to use interface for a VideoStream and a set of transforms"""
+
+    video_stream = param.ClassSelector(
+        class_=pn.widgets.VideoStream, constant=True, doc="The source VideoStream"
+    )
+
+    height = param.Integer(
+        HEIGHT,
+        bounds=(10, 2000),
+        step=10,
+        doc="""The height of the image converted and shown""",
+    )
+    width = param.Integer(
+        WIDTH,
+        bounds=(10, 2000),
+        step=10,
+        doc="""The width of the image converted and shown""",
+    )
+
+    transform = param.Selector(doc="The currently selected transform")
+
+    def __init__(
+        self,
+        transforms,
+        timeout=TIMEOUT,
+        paused=False,
+        **params,
+    ):
+        super().__init__(
+            video_stream=pn.widgets.VideoStream(
+                name="Video Stream",
+                timeout=timeout,
+                paused=paused,
+                height=0,
+                width=0,
+                visible=False,
+                format="jpeg",
+            ),
+            **params,
+        )
+        self.image = pn.pane.JPG(
+            height=self.height, width=self.width, sizing_mode="fixed"
+        )
+        self._updating = False
+        transforms = [to_instance(transform) for transform in transforms]
+        self.param.transform.objects = transforms
+        self.transform = transforms[0]
+        self.timer = Timer(sizing_mode="stretch_width")
+        self.settings = self._create_settings()
+        self._panel = self._create_panel()
+
+    def _create_settings(self):
+        return pn.Column(
+            pn.Param(
+                self.video_stream,
+                parameters=["timeout", "paused"],
+                widgets={
+                    "timeout": {
+                        "widget_type": pn.widgets.IntSlider,
+                        "start": 10,
+                        "end": 2000,
+                        "step": 10,
+                    }
+                },
+            ),
+            self.timer,
+            pn.Param(self, parameters=["height", "width"], name="Image"),
+            pn.Param(
+                self,
+                parameters=["transform"],
+                expand_button=False,
+                expand=False,
+                widgets={
+                    "transform": {
+                        "widget_type": pn.widgets.RadioButtonGroup,
+                        "orientation": "vertical",
+                        "button_type": "success",
+                    }
+                },
+                name="Transform",
+            ),
+            self._get_transform,
+        )
+
+    def _create_panel(self):
+        return pn.Row(
+            self.video_stream,
+            pn.layout.HSpacer(),
+            self.image,
+            pn.layout.HSpacer(),
+            sizing_mode="stretch_width",
+            align="center",
+        )
+
+    @pn.depends("height", "width", watch=True)
+    def _update_height_width(self):
+        self.image.height = self.height
+        self.image.width = self.width
+
+    @pn.depends("transform")
+    def _get_transform(self):
+        # Hack: returning self.transform stops working after browsing the transforms for a while
+        return self.transform.view
+
+    def __panel__(self):
+        return self._panel
+
+    @pn.depends("video_stream.value", watch=True)
+    def _handle_stream(self):
+        if self._updating:
+            return
+
+        self._updating = True
+        if self.transform and self.video_stream.value:
+            value = self.video_stream.value
+            try:
+                image = self.timer.time_it(
+                    name="Transform",
+                    func=self.transform.run,
+                    image=value,
+                    height=self.height,
+                    width=self.width,
+                )
+                self.image.object = image
+            except PIL.UnidentifiedImageError:
+                print("unidentified image")
+
+            self.timer.inc_it("last update")
+        self._updating = False

requirements.txt

@@ -0,0 +1,3 @@
+panel==0.14.1
+scikit-image
+Pillow