Upload LSCC-Demo-HMI-Human-Machine-Interface-Edge-Vision-Engine with upload_repo.py

README.md

@@ -1,6 +1,7 @@
 ---
-title: HMI (Human-Machine Interface) - Edge Vision Engine 
-short_description: Person, Face, Hand Detection and Face ID on CPU, runs on NXP
+title: Lattice sensAI Edge Vision Engine SDK
+slug: HMI-Human-Machine-Interface-Edge-Vision-Engine
+short_description: Best in class human sensing SDK for far edge
 emoji: 🏆
 colorFrom: yellow
 colorTo: gray
@@ -8,18 +9,24 @@ sdk: docker
 pinned: false
 ---
 
-Powered by the [Edge Vision Engine SDK](https://huggingface.co/mgamsby-lattice/gated-content-test-unknown-license).
-
-### Get a Free 30-Day Trial License
-Request access to the [EVE SDK model repository](https://huggingface.co/mgamsby-lattice/gated-content-test-unknown-license)
-and receive a trial license key automatically via email.
-
-After activation, EVE can run offline for a limited number of days before needing
-to reconnect to the internet to re-verify your license.
-
-### Need a Longer or Commercial License?
-- **Email**: [CONTACT_EMAIL_PLACEHOLDER]
-- **Web**: [CONTACT_URL_PLACEHOLDER]
+The Lattice sensAI Edge Vision Engine SDK (or simply EVE!) provides an Extern-C interface and ready to use Python bindings to access retrieve the following from a camera image:
+
+| Human Sensing Attribute | Description | Can be visualized in 🤗 space |
+| --- | --- | :---: |
+| 3D Head Pose | x, y, z, roll, pitch and yaw of user(s) | yes |
+| Face Landmarks | 23 or 68 face landmarks | yes |
+| Fatigue | Karolinska Sleepiness score |  |
+| Face ID | Provides identification of detected user (if user was registered) | yes |
+| Gaze | Gaze vectors of main user | |
+| ROI Selection | Indicates if gaze (or projection of face) of main user intersects custom ROI(s) |  |
+| Visual Speech Detection | Indicates if main user is speaking |  |
+| Personal protective equipment detection | Indicates if protective eyewear, hat and gloves are worn for detected user(s) |  |
+| Person Detection | Person bounding box(es) | yes |
+| Depth | Depth of user(s) up to 5m |  |
+| Object Detection | Bounding box(es) and classification of 90 objects |  |
+
+Our models have a low computation footprint and are ideal for <.5 TOPS devices like FPGAs, small NPUs and SOCs.
+EVE SDK packages are available for Windows, Linux and RPI.
 
 ## About
 
@@ -28,3 +35,7 @@ This demo is maintained by **Lattice Semiconductor** (LatticeSemi).
 ## License
 
 Proprietary - Lattice Semiconductor Corporation. All rights reserved.
+
+## Need a Longer or Commercial License?
+
+- **Email**: senseaiAccessrequest@latticesemi.com

app.py

@@ -15,9 +15,8 @@ sys.path.insert(0, str(Path(__file__).resolve().parent / "shared"))
 from env_utils import load_dotenv_if_present, require_secrets
 from eve_messages import FeatureFlags
 from eve_worker_pool import EveWorkerPool
-from frame_utils import draw_countdown_banner, draw_overlay, draw_session_timer
-from video_file_server import VideoFileServer
 from face_id_tab import FaceEntry, FaceIdTab
+from frame_utils import draw_countdown_banner, draw_overlay, draw_session_timer
 from live_inference import (
     RtcConfigProvider,
     build_webrtc_stream,
@@ -25,12 +24,14 @@ from live_inference import (
 )
 from live_stream_manager import LiveStreamManager
 from log_utils import setup_logger
+from video_file_server import VideoFileServer
 from video_processing import (
     VideoLimits,
     build_video_constraints_accordion,
     get_example_videos,
     wire_video_upload,
 )
+
 # --- Handlers ---
 
 
@@ -124,9 +125,7 @@ def run_eve_inference(
             total_frames=total_frames,
             progress=progress,
         )
-        logger.info(
-            f"[{session}] run_eve_inference: done, {frames_processed} frames processed"
-        )
+        logger.info(f"[{session}] run_eve_inference: done, {frames_processed} frames processed")
     finally:
         pool.release(worker)
         logger.info(f"[{session}] run_eve_inference: worker {worker.worker_id} released")
@@ -231,12 +230,12 @@ def _build_video_processing_tab() -> tuple[
         Tuple of (video_tab, input_video, output_video, cb_face, cb_person,
                   cb_face_id, cb_hand_gesture, process_btn, example_dataset).
     """
-    with gr.TabItem("Video Processing") as video_tab:
+    with gr.TabItem("Offline Inference") as video_tab:
         with gr.Accordion("Instructions", open=False):
             gr.Markdown(
                 "1. Select the features that will be processed on the video\n"
                 "2. Select a video (or upload your own in the Input Video frame)\n"
-                "3. Press the **Process Video** button\n"
+                "3. Press the **Process Video** button\n\n"
                 "Once the video has been processed, you can play the video in the "
                 "Output Video frame"
             )
@@ -304,7 +303,6 @@ def _build_live_tab(
     return tab, webrtc_stream, cb_face, cb_person, cb_face_id, cb_hand_gesture
 
 
-
 def _process_live_frame(
     frame: np.ndarray,
     face_detection: bool,
@@ -341,12 +339,8 @@ def _process_live_frame(
                 mins, secs = divmod(int(eta), 60)
                 eta_text = f"\nest. wait ~{mins}:{secs:02d}"
             if total > 1:
-                return draw_overlay(
-                    frame, f"In queue (position {pos}/{total}){eta_text}"
-                )
-            return draw_overlay(
-                frame, f"Waiting for available worker...{eta_text}"
-            )
+                return draw_overlay(frame, f"In queue (position {pos}/{total}){eta_text}")
+            return draw_overlay(frame, f"Waiting for available worker...{eta_text}")
         # Terminal reason (session expired, pressure timeout, etc.)
         # — close the WebRTC stream so the UI resets to "Start Inference".
         from fastrtc import CloseStream
@@ -401,7 +395,7 @@ if __name__ == "__main__":
     max_workers = int(os.environ.get("MAX_WORKERS", os.cpu_count()))
     max_ram_gb = float(os.environ.get("MAX_RAM_GB", 32))
     pool = EveWorkerPool(max_workers=max_workers, max_ram_gb=max_ram_gb, ram_headroom_gb=2.0)
-    stream_manager = LiveStreamManager(pool, session_lifetime_seconds=60*4)
+    stream_manager = LiveStreamManager(pool, session_lifetime_seconds=60 * 4)
 
     # Separate HTTP server for video output — bypasses Chrome's per-origin
     # connection limit that blocks /file= requests while SSE connections are open.
@@ -427,17 +421,34 @@ if __name__ == "__main__":
     )
 
     with gr.Blocks(title="Eve HMI Demo") as demo:
-        gr.Markdown("# Edge Vision Engine Demo")
+        gr.Markdown("# Lattice sensAI Edge Vision Engine SDK")
         gr.Markdown(
-            "Powered by the [Edge Vision Engine SDK]"
-            "(https://huggingface.co/mgamsby-lattice/gated-content-test-unknown-license) — "
-            "[Request access](https://huggingface.co/mgamsby-lattice/"
-            "gated-content-test-unknown-license) to get started."
+            "Our SDK solves the human sensing challenges by outputting ready-to-use data."
+            " Our models have a low computation footprint and are ideal for <.5 TOPS devices"
+            " like FPGAs, small NPUs and SOCs.\n\n"
+            # TODO: Insert performance summary table
+            "EVE SDK packages are available for Windows, Linux and RPI.\n\n"
+            "Follow the instructions [here](https://huggingface.co/LatticeSemi/LSCC-SDK-HMI-Human-Machine-Interface-Edge-Vision-Engine)"
+            " to download and start using the EVE SDK within minutes.\n\n"
+            "You can also preview the EVE SDK with the following tabs:\n\n"
+            "- **Live Inference** to run it live from your webcam\n"
+            "- **Offline Inference** to test it with videos you can upload\n"
+            "- Use the **Face ID Registration** tab to register face(s) you can use in either Live or Offline Inference to test the Face ID model.\n"
+            "\n\n"
         )
 
         session_registry = gr.State(value={})
 
         with gr.Tabs():
+            (
+                _live_tab,
+                webrtc_stream,
+                live_cb_face,
+                live_cb_person,
+                live_cb_face_id,
+                live_cb_hand_gesture,
+            ) = _build_live_tab(rtc_config_provider.get(), face_id_tab)
+
             (
                 video_tab,
                 input_video,
@@ -452,15 +463,6 @@ if __name__ == "__main__":
 
             face_id_tab.build()
 
-            (
-                _live_tab,
-                webrtc_stream,
-                live_cb_face,
-                live_cb_person,
-                live_cb_face_id,
-                live_cb_hand_gesture,
-            ) = _build_live_tab(rtc_config_provider.get(), face_id_tab)
-
         # --- Video Processing wiring ---
 
         feature_controls = [

install_eve.py

@@ -21,7 +21,7 @@ import sys
 from huggingface_hub import hf_hub_download
 
 EVE_REPO = "LatticeSemi/PRIVATE-Edge-Vision-Engine-EVE-v7.0"
-EVE_DEB = "LINUX_X86-571-dev-eve-huggingface_7.0.571~git20260331.f4bdc1d_amd64.deb"
+EVE_DEB = "LINUX_X86-5-7.0-eve-huggingface_7.0.5~git20260402.50d837a_amd64.deb"
 EVE_LICENSE_REPO = "LatticeSemi/PRIVATE-Edge-Vision-Engine-EVE-v7.0-License"
 EVE_LICENSE = "libEveDevLicense.so"
 SECRET_PATH = "/run/secrets/MODEL_ACCESS_TOKEN"
@@ -88,10 +88,7 @@ def main():
     subprocess.run(["apt-get", "install", "-y", deb_path], check=True)
 
     license_path = hf_hub_download(
-        repo_id=EVE_LICENSE_REPO,
-        filename=EVE_LICENSE,
-        local_dir=DOWNLOAD_DIR,
-        token=token
+        repo_id=EVE_LICENSE_REPO, filename=EVE_LICENSE, local_dir=DOWNLOAD_DIR, token=token
     )
 
     destination_path = get_license_destination_path()

shared/env_utils.py

@@ -1,6 +1,5 @@
 import os
 import sys
-
 from pathlib import Path
 
 from dotenv import load_dotenv  # type: ignore
@@ -44,8 +43,7 @@ def require_secrets(*names: str) -> None:
 
     settings_url = f"https://huggingface.co/spaces/{space_id}/settings"
     print(
-        f"ERROR: Missing required secrets: {', '.join(missing)}\n"
-        f"Set them at: {settings_url}",
+        f"ERROR: Missing required secrets: {', '.join(missing)}\n" f"Set them at: {settings_url}",
         file=sys.stderr,
     )
     sys.exit(1)

shared/eve_messages.py

@@ -6,7 +6,6 @@ main Gradio process and Eve SDK worker processes.
 
 from dataclasses import dataclass
 
-
 # ---------------------------------------------------------------------------
 # Shared data types
 # ---------------------------------------------------------------------------

shared/eve_worker_pool.py

@@ -22,12 +22,11 @@ import multiprocessing as mp
 import os
 import threading
 import time
+from collections.abc import Callable
 from dataclasses import dataclass
 from multiprocessing.connection import Connection
-from collections.abc import Callable
 
 import numpy as np
-
 from eve_messages import (
     CalibrateNewUserCmd,
     CalibrateOkResponse,
@@ -62,7 +61,9 @@ logger = setup_logger("EveWorkerPool")
 # (required on Windows; avoids CDLL sharing on Linux/fork).
 _mp_ctx = mp.get_context("spawn")
 
-DO_PROBE_WORKER = False  # Set to False to skip the RAM probe and just use an estimate of the RAM used
+DO_PROBE_WORKER = (
+    False  # Set to False to skip the RAM probe and just use an estimate of the RAM used
+)
 
 
 # ---------------------------------------------------------------------------
@@ -127,9 +128,7 @@ def _eve_worker_main(
 
         try:
             if isinstance(cmd, InferenceCmd):
-                frame = np.frombuffer(cmd.frame_bytes, dtype=cmd.dtype).reshape(
-                    cmd.shape
-                )
+                frame = np.frombuffer(cmd.frame_bytes, dtype=cmd.dtype).reshape(cmd.shape)
                 features = cmd.features
                 del cmd  # free recv'd bytes early; numpy holds its own ref
 
@@ -167,9 +166,7 @@ def _eve_worker_main(
                 result = eve.calibrate_new_user(frames)
                 conn.send(
                     CalibrateOkResponse(
-                        result=CalibrationResultMsg(
-                            result.success, result.user_id, result.message
-                        ),
+                        result=CalibrationResultMsg(result.success, result.user_id, result.message),
                     )
                 )
 
@@ -178,16 +175,13 @@ def _eve_worker_main(
                 conn.send(RemoveUsersOkResponse(result=ok))
 
             elif isinstance(cmd, RestoreGalleryCmd):
-                frames_per_user = [
-                    _deserialize_frames(fd) for fd in cmd.frames_per_user_data
-                ]
+                frames_per_user = [_deserialize_frames(fd) for fd in cmd.frames_per_user_data]
                 eve.remove_all_users()
                 results = eve.restore_gallery(frames_per_user)
                 conn.send(
                     RestoreGalleryOkResponse(
                         results=[
-                            CalibrationResultMsg(r.success, r.user_id, r.message)
-                            for r in results
+                            CalibrationResultMsg(r.success, r.user_id, r.message) for r in results
                         ],
                     )
                 )
@@ -209,14 +203,11 @@ def _eve_worker_main(
                 if cmd.remove_all_users:
                     eve.remove_all_users()
                 if cmd.gallery_paths:
-                    frames_per_user = [
-                        load_media_frames_raw(p) for p in cmd.gallery_paths
-                    ]
+                    frames_per_user = [load_media_frames_raw(p) for p in cmd.gallery_paths]
                     raw_results = eve.restore_gallery(frames_per_user)
                     del frames_per_user
                     gallery_results = [
-                        CalibrationResultMsg(r.success, r.user_id, r.message)
-                        for r in raw_results
+                        CalibrationResultMsg(r.success, r.user_id, r.message) for r in raw_results
                     ]
                     del raw_results
                     conn.send(GalleryRestoredResponse(results=gallery_results))
@@ -233,9 +224,7 @@ def _eve_worker_main(
 
                 # Video processing loop
                 cap = cv2.VideoCapture(cmd.input_path)
-                container = av.open(
-                    cmd.output_path, mode="w", options={"movflags": "faststart"}
-                )
+                container = av.open(cmd.output_path, mode="w", options={"movflags": "faststart"})
                 stream = container.add_stream("libx264", rate=round(cmd.fps))
                 stream.width = cmd.width
                 stream.height = cmd.height
@@ -274,7 +263,11 @@ def _eve_worker_main(
                 finally:
                     cap.release()
                     container.close()
-                    del cap, container, stream,
+                    del (
+                        cap,
+                        container,
+                        stream,
+                    )
 
                 job_count += 1
                 conn.send(
@@ -491,14 +484,10 @@ class EveWorker:
                 return resp.frames_processed, gallery_results
 
             elif isinstance(resp, ErrorResponse):
-                raise RuntimeError(
-                    f"Worker {self.worker_id} process_video error: {resp.error}"
-                )
+                raise RuntimeError(f"Worker {self.worker_id} process_video error: {resp.error}")
 
             else:
-                raise RuntimeError(
-                    f"Worker {self.worker_id} unexpected response: {resp}"
-                )
+                raise RuntimeError(f"Worker {self.worker_id} unexpected response: {resp}")
 
     def send_shutdown(self) -> None:
         try:
@@ -760,7 +749,7 @@ class EveWorkerPool:
         headroom_mb = self._cfg.ram_headroom_gb * 1024
 
         # Spawn a probe worker to measure init RSS
-        
+
         if DO_PROBE_WORKER:
             probe = self._spawn_worker(probe=True)
             try:
@@ -780,7 +769,7 @@ class EveWorkerPool:
         # +1 because the probe worker already consumed memory
         max_by_ram = max(1, int(usable_mb / estimated_peak_mb) + 1)
         if DO_PROBE_WORKER:
-            actual = min(self._cfg.max_workers-1, max_by_ram)
+            actual = min(self._cfg.max_workers - 1, max_by_ram)
         else:
             actual = min(self._cfg.max_workers, max_by_ram)
 
@@ -807,15 +796,19 @@ class EveWorkerPool:
         parent_conn, child_conn = _mp_ctx.Pipe()
         proc = _mp_ctx.Process(
             target=_eve_worker_main,
-            args=(child_conn, self._eve_bin_path, self._eve_lib_path, wid, self._cfg.max_jobs_per_worker),
+            args=(
+                child_conn,
+                self._eve_bin_path,
+                self._eve_lib_path,
+                wid,
+                self._cfg.max_jobs_per_worker,
+            ),
             daemon=True,
         )
         proc.start()
         return wid, proc, parent_conn
 
-    def _wait_for_ready(
-        self, wid: int, proc: mp.Process, parent_conn: Connection
-    ) -> EveWorker:
+    def _wait_for_ready(self, wid: int, proc: mp.Process, parent_conn: Connection) -> EveWorker:
         """Block until a launched worker sends its "ready" message.
 
         Raises:
@@ -889,9 +882,7 @@ class EveWorkerPool:
                 # Detect crashed / zombie processes
                 if not w.process.is_alive():
                     if w.pending_recycle:
-                        logger.info(
-                            f"Worker {w.worker_id} (pid={w.process.pid}) recycled cleanly"
-                        )
+                        logger.info(f"Worker {w.worker_id} (pid={w.process.pid}) recycled cleanly")
                     else:
                         logger.error(
                             f"Worker {w.worker_id} (pid={w.process.pid}) died unexpectedly"
@@ -914,4 +905,3 @@ class EveWorkerPool:
                             f"Worker {w.worker_id} busy for {elapsed:.0f}s "
                             f"(threshold={self._cfg.stuck_timeout_s}s)"
                         )
-

shared/eve_wrapper.py

@@ -3,12 +3,10 @@ import glob
 import os
 import platform
 import sys
-
 from dataclasses import dataclass
 
 import cv2
 import numpy as np
-
 from eve_python import eve_sdk as sdk
 from eve_python.structs.CFaceIdStructs import (
     EveFaceIdCommand,
@@ -170,8 +168,7 @@ class EveWrapper:
             if enabled
             else sdk.structs.EveOptionEnabled.EVE_OPTION_DISABLED
         )
-        options = sdk.structs.EveFaceIdOptions(enabled=eve_enabled,
-                                               threshold=threshold)
+        options = sdk.structs.EveFaceIdOptions(enabled=eve_enabled, threshold=threshold)
         if enabled:
             options.calibrationPoses = (
                 sdk.structs.EveFaceIdCalibrationPoseMode.EVE_FACEID_CALIBRATION_FRONTAL_ONLY

shared/face_id_tab.py

@@ -133,8 +133,7 @@ class FaceIdTab:
             with gr.Accordion("Instructions", open=False):
                 gr.Markdown(
                     (
-                        "1. Choose between registering a face from an **Image** or a "
-                        "**Video**\n"
+                        "1. Choose between registering a face from an **Image** or a " "**Video**\n"
                         if self._accept_video
                         else "1. Select an example image or upload your own\n"
                     )
@@ -158,7 +157,9 @@ class FaceIdTab:
                 with gr.Column(scale=3):
                     if self._accept_video:
                         # Image section (expanded by default)
-                        with gr.Accordion("Input from an Image", open=True) as self._image_accordion:
+                        with gr.Accordion(
+                            "Input from an Image", open=True
+                        ) as self._image_accordion:
                             if self._image_examples:
                                 with gr.Accordion("Examples", open=True):
                                     self._image_example_dataset = gr.Dataset(
@@ -173,7 +174,9 @@ class FaceIdTab:
                             )
 
                         # Video section (collapsed by default)
-                        with gr.Accordion("Input from a Video", open=False) as self._video_accordion:
+                        with gr.Accordion(
+                            "Input from a Video", open=False
+                        ) as self._video_accordion:
                             if self._video_examples:
                                 with gr.Accordion("Examples", open=True):
                                     self._video_example_dataset = gr.Dataset(
@@ -244,14 +247,10 @@ class FaceIdTab:
         column = gr.Column(scale=scale, min_width=100, visible=False)
         with column:
             gr.Markdown("**Registered Faces**")
-            hint = gr.Markdown(
-                "_Go to the **Face ID Registration** tab to register faces._"
-            )
+            hint = gr.Markdown("_Go to the **Face ID Registration** tab to register faces._")
             for _ in range(self._max_users):
                 imgs.append(gr.HTML(value="", visible=False))
-        self._summaries.append(
-            {"column": column, "hint": hint, "imgs": imgs, "height": height}
-        )
+        self._summaries.append({"column": column, "hint": hint, "imgs": imgs, "height": height})
 
     # ------------------------------------------------------------------
     # Event wiring
@@ -429,18 +428,13 @@ class FaceIdTab:
             media_source = image_path if image_path is not None else video_path
             ext = os.path.splitext(media_source)[1]
             session_tmp = _session_dir(request.session_hash)
-            stored_path = os.path.join(
-                session_tmp, f"face_id_{uuid.uuid4().hex[:8]}{ext}"
-            )
+            stored_path = os.path.join(session_tmp, f"face_id_{uuid.uuid4().hex[:8]}{ext}")
             shutil.copy2(media_source, stored_path)
 
             next_key = max(registry.keys(), default=0) + 1
             registry = {**registry, next_key: FaceEntry(path=stored_path)}
 
-            # Restore the full gallery so every entry gets a consistent sdk_id
-            all_frames = [
-                load_media_frames(entry.path) for entry in registry.values()
-            ]
+            all_frames = [load_media_frames(entry.path) for entry in registry.values()]
             restore_results = worker.send_restore_gallery(all_frames)
             for entry, r in zip(registry.values(), restore_results):
                 entry.sdk_id = r.user_id if r.success else None
@@ -463,9 +457,11 @@ class FaceIdTab:
         return (
             *self._slot_updates(registry),
             *self._summary_updates(registry),
-            f"Successfully registered (Face ID: {registry[next_key].sdk_id})."
-            if registry[next_key].sdk_id is not None
-            else f"Successfully registered as User {next_key}.",
+            (
+                f"Successfully registered (Face ID: {registry[next_key].sdk_id})."
+                if registry[next_key].sdk_id is not None
+                else f"Successfully registered as User {next_key}."
+            ),
             None,
             None,
             registry,
@@ -504,13 +500,9 @@ class FaceIdTab:
                         frames = load_media_frames(entry.path)
                         result = worker.send_calibrate_new_user(frames)
                         if result.success:
-                            new_registry[u] = FaceEntry(
-                                path=entry.path, sdk_id=result.user_id
-                            )
+                            new_registry[u] = FaceEntry(path=entry.path, sdk_id=result.user_id)
                         else:
-                            logger.warning(
-                                f"Failed to re-register user {u}: {result.message}"
-                            )
+                            logger.warning(f"Failed to re-register user {u}: {result.message}")
                             if os.path.exists(entry.path):
                                 os.remove(entry.path)
                     registry = new_registry
@@ -593,9 +585,7 @@ class FaceIdTab:
                 updates.append(gr.update(interactive=False))
         return tuple(updates)
 
-    def _summary_updates_single(
-        self, registry: dict[int, FaceEntry], summary: dict
-    ) -> list:
+    def _summary_updates_single(self, registry: dict[int, FaceEntry], summary: dict) -> list:
         """Build updates for one summary group (column + hint + images)."""
         updates: list = []
         user_ids = sorted(registry.keys())

shared/frame_utils.py

@@ -49,9 +49,7 @@ def load_media_frames_raw(media_path: str) -> list[np.ndarray]:
     return [img]
 
 
-def extract_frames(
-    image_path: str | None, video_path: str | None
-) -> list[np.ndarray]:
+def extract_frames(image_path: str | None, video_path: str | None) -> list[np.ndarray]:
     """Extract BGR frames from an image or video.
 
     Args:

shared/live_inference.py

@@ -14,7 +14,6 @@ from typing import Any, Callable
 import cv2
 import gradio as gr
 import numpy as np
-
 from log_utils import setup_logger
 
 InferenceFn = Callable[[np.ndarray], np.ndarray]
@@ -180,9 +179,10 @@ def patch_fastrtc_frame_queue() -> None:
     Must be called **before** any ``WebRTC`` component is created
     (typically at the top of ``__main__``).
     """
+    from typing import cast as _cast
+
     import fastrtc.tracks as frt
     from aiortc.mediastreams import MediaStreamError
-    from typing import cast as _cast
 
     _orig_init = frt.VideoCallback.__init__
 

shared/live_stream_manager.py

@@ -134,15 +134,12 @@ class LiveStreamManager:
                     self._release_entry(connection_id)
                     with self._lock:
                         self._expired.add(connection_id)
-                    return None, (
-                        "Session ended\nclick `Start Inference` to restart."
-                    )
+                    return None, ("Session ended\nclick `Start Inference` to restart.")
 
             # Pressure-based countdown (only when enabled)
             if self._timeout_s is not None:
-                under_pressure = (
-                    self._pool.idle_count == 0
-                    and (self._pool.waiting_count > 0 or len(self._waiting) > 0)
+                under_pressure = self._pool.idle_count == 0 and (
+                    self._pool.waiting_count > 0 or len(self._waiting) > 0
                 )
                 if under_pressure:
                     if entry.pressure_start is None:
@@ -279,8 +276,7 @@ class LiveStreamManager:
             with self._lock:
                 entries = list(self._streams.values())
             known = sorted(
-                max(0.0, self._session_lifetime_s - (now - e.start_time))
-                for e in entries
+                max(0.0, self._session_lifetime_s - (now - e.start_time)) for e in entries
             )
 
         # Workers doing video processing (busy, not live-stream) have
@@ -351,12 +347,9 @@ class LiveStreamManager:
         with self._lock:
             self._waiting.pop(connection_id, None)
         logger.info(
-            f"Live stream ({connection_id}) acquired worker {worker.worker_id} "
-            f"after waiting"
-        )
-        return self._setup_stream(
-            connection_id, waiting.session_hash, worker, waiting.registry
+            f"Live stream ({connection_id}) acquired worker {worker.worker_id} " f"after waiting"
         )
+        return self._setup_stream(connection_id, waiting.session_hash, worker, waiting.registry)
 
     def _release_entry(self, connection_id: str) -> None:
         with self._lock:

shared/log_utils.py

@@ -11,8 +11,10 @@ def setup_logger(name: str = "hf_demos", level: str | None = None) -> logging.Lo
     logger.setLevel(getattr(logging, lvl, logging.INFO))
 
     ch = logging.StreamHandler()
-    fmt = logging.Formatter("%(asctime)s [%(levelname)s] [%(name)s] %(message)s", datefmt="%Y-%m-%d %H:%M:%S")
+    fmt = logging.Formatter(
+        "%(asctime)s [%(levelname)s] [%(name)s] %(message)s", datefmt="%Y-%m-%d %H:%M:%S"
+    )
     ch.setFormatter(fmt)
     logger.addHandler(ch)
     logger.propagate = False
-    return logger
+    return logger

shared/memory_monitor.py

@@ -13,6 +13,7 @@ from log_utils import setup_logger
 
 logger = setup_logger("MemoryMonitor")
 
+
 class _HasWorkerInfo(Protocol):
     """Minimal interface a worker object must expose for memory reporting."""
 
@@ -25,7 +26,7 @@ def start_memory_reporter(
     get_workers: callable,
     lock: threading.Condition,
     shutdown_flag: callable,
-    interval_s: float = 60*60,
+    interval_s: float = 60 * 60,
     max_ram_gb: float = 0,
 ) -> threading.Thread:
     """Launch a daemon thread that logs memory usage periodically.
@@ -117,9 +118,7 @@ def _log_report(
         workers = list(get_workers())
     for w in workers:
         if w.status == "dead" or not w.process.is_alive():
-            lines.append(
-                f"   worker {w.worker_id} (pid={w.process.pid}): dead"
-            )
+            lines.append(f"   worker {w.worker_id} (pid={w.process.pid}): dead")
             continue
         try:
             w_rss = psutil.Process(w.process.pid).memory_info().rss / (1024 * 1024)
@@ -129,10 +128,7 @@ def _log_report(
                 f"RSS={w_rss:.0f} MB, status={w.status}"
             )
         except (psutil.NoSuchProcess, psutil.AccessDenied):
-            lines.append(
-                f"   worker {w.worker_id} (pid={w.process.pid}): "
-                f"not accessible"
-            )
+            lines.append(f"   worker {w.worker_id} (pid={w.process.pid}): " f"not accessible")
 
     lines.append(
         f"   total: main={main_rss:.0f} MB + "

shared/video_file_server.py

@@ -56,7 +56,9 @@ class _VideoHandler(http.server.BaseHTTPRequestHandler):
         self.send_header("Access-Control-Allow-Origin", "*")
         self.send_header("Access-Control-Allow-Methods", "GET, HEAD, OPTIONS")
         self.send_header("Access-Control-Allow-Headers", "Range")
-        self.send_header("Access-Control-Expose-Headers", "Content-Range, Content-Length, Accept-Ranges")
+        self.send_header(
+            "Access-Control-Expose-Headers", "Content-Range, Content-Length, Accept-Ranges"
+        )
 
     # ------------------------------------------------------------------
     # HTTP methods
@@ -151,7 +153,7 @@ class _VideoHandler(http.server.BaseHTTPRequestHandler):
         """Parse ``Range: bytes=start-end`` and return (start, end) inclusive."""
         if not header.startswith("bytes="):
             raise ValueError(header)
-        spec = header[len("bytes="):]
+        spec = header[len("bytes=") :]
         parts = spec.split("-", 1)
         if len(parts) != 2:
             raise ValueError(header)

shared/video_processing.py

@@ -4,17 +4,17 @@ Provides validation, frame-by-frame inference processing, and Gradio UI helpers
 that are common across all video-based demos.
 """
 
-import av
-import cv2
-import gradio as gr
-import numpy as np
 import os
 import tempfile
-
 from dataclasses import dataclass
 from pathlib import Path
 from typing import Any, Callable
 
+import av
+import cv2
+import gradio as gr
+import numpy as np
+
 InferenceFn = Callable[[np.ndarray], np.ndarray]
 
 
@@ -115,7 +115,8 @@ def validate_video(video_path: str, limits: VideoLimits = DEFAULT_LIMITS) -> Non
 
         if duration > limits.max_duration_seconds:
             raise gr.Error(
-                f"Video duration ({duration:.1f}s) exceeds the maximum allowed length of {limits.max_duration_seconds} seconds.")
+                f"Video duration ({duration:.1f}s) exceeds the maximum allowed length of {limits.max_duration_seconds} seconds."
+            )
     finally:
         video_capture.release()
 
@@ -184,7 +185,7 @@ def process_video(
 
     fps = video_capture.get(cv2.CAP_PROP_FPS)
     width = int(video_capture.get(cv2.CAP_PROP_FRAME_WIDTH))
-    height = int(video_capture.get(cv2.CAP_PROP_FRAME_HEIGHT))    
+    height = int(video_capture.get(cv2.CAP_PROP_FRAME_HEIGHT))
     total_frames = int(video_capture.get(cv2.CAP_PROP_FRAME_COUNT))
 
     # Webcam-recorded videos (especially WebM from browsers) can report bogus
@@ -279,9 +280,7 @@ def wire_video_upload(
     )
 
     input_video.stop_recording(
-        fn=validate_and_update,
-        inputs=input_video,
-        outputs=[input_video, process_btn]
+        fn=validate_and_update, inputs=input_video, outputs=[input_video, process_btn]
     )
 
     input_video.clear(