Match Panopto stream tags case-insensitively + filter test patterns

Two production failures from the EE2022 run:

1. Six Wednesday lectures downloaded the lecture-hall webcam instead of
   the slide-recording. Root cause: Panopto's DeliveryInfo API returns
   stream Tag in either upper-case ("OBJECT") or lower-case ("object")
   depending on the session's recording profile. The downloader's
   preference order tuple ("SS","OBJECT","DV") was matched
   case-sensitively, so when tags were lower-case the OBJECT branch
   never fired and the code fell through to "first stream" — which is
   `dv` (the camera). Fix: normalise both sides to upper-case before
   comparing, in both _extract_streams (the source picker) and the
   later video/audio classification loop.

2. For some lectures the OBJECT stream itself contained a TV-style
   "No Signal" test pattern — the screen-capture HDMI input was
   disconnected at recording time, so the slide-projector content was
   never captured. Added the obvious test-pattern phrasings to
   _JUNK_DESC_RE so those frames get dropped during the vision-API
   filter pass instead of being embedded in notes as colour bars.

7 new regression tests:
  - 5 cover the tag-case normalisation (lower, upper, mixed, dv-only,
    untagged-fallthrough)
  - 2 cover the junk-regex extensions (matches no-signal patterns,
    leaves real slide descriptions alone)

Author: nodeeeeee

downloader.py

@@ -830,20 +830,29 @@ def _extract_streams(body: dict) -> list[tuple[str, str]]:
         """Return a list of (stream_url, tag) candidates in preference order.
         Caller can try each until one produces a video with an audio track —
         some Panopto recordings store audio only in the DV stream while SS /
-        OBJECT are video-only for screen recordings."""
+        OBJECT are video-only for screen recordings.
+
+        Tag matching is case-insensitive: Panopto returns either upper-case
+        ("OBJECT", "DV") or lower-case ("object", "dv") tags depending on
+        the session's recording setup. A case-sensitive match would fall
+        through to "any stream first" — which is DV (the camera), so the
+        downloaded video would be a lecture-hall camera shot instead of
+        the screen recording.
+        """
         streams = (body.get("Delivery") or {}).get("Streams") or []
         # Preference: SS (screen-share) > OBJECT (screen recording) > DV (camera).
         # We still yield *all* streams so the caller can fall back if the
         # preferred one lacks audio.
-        order = _PREFER_STREAM_ORDER
+        order = tuple(t.upper() for t in _PREFER_STREAM_ORDER)
         out: list[tuple[str, str]] = []
         seen_urls: set[str] = set()
         for tag in order + (None,):
             for s in streams:
                 surl = s.get("StreamUrl", "")
                 if not surl or surl in seen_urls:
                     continue
-                if tag is None or s.get("Tag") == tag:
+                stream_tag = (s.get("Tag", "") or "").upper()
+                if tag is None or stream_tag == tag:
                     seen_urls.add(surl)
                     out.append((surl, s.get("Tag", "unknown")))
         return out
@@ -1201,7 +1210,10 @@ def download_video(video: dict, manifest: dict, base_dir: Path) -> bool | None:
     # recording from a split-stream case where the audio is in DV but the
     # screen video is in OBJECT/SS.
     available_tags = [ct for (_, _, ct) in candidates]
-    has_screen_stream = any(t in ("SS", "OBJECT") for t in available_tags)
+    # Tags from Panopto are sometimes lower-case ("object"/"dv"). Normalise
+    # before matching so the "screen-stream-first" preference still fires.
+    has_screen_stream = any((t or "").upper() in ("SS", "OBJECT")
+                            for t in available_tags)
 
     # Classify each candidate as "video-with-audio" or "video-only" up front.
     # Panopto screen recordings often store SS/OBJECT (screen content, no
@@ -1214,9 +1226,10 @@ def download_video(video: dict, manifest: dict, base_dir: Path) -> bool | None:
         tried.append(ct)
         is_m3u8 = "master.m3u8" in cu
         has_audio = (not is_m3u8) or _hls_has_audio(cu)
+        ct_upper = (ct or "").upper()
         # Preferred screen stream (first one we see that is SS/OBJECT) becomes
         # the chosen VIDEO source — regardless of whether it has audio.
-        if video_cand is None and ct in ("SS", "OBJECT"):
+        if video_cand is None and ct_upper in ("SS", "OBJECT"):
             video_cand = (cu, ch, ct, is_m3u8, has_audio)
         # First stream with audio becomes the audio source.
         if audio_cand is None and has_audio:

electron/package.json

@@ -1,6 +1,6 @@
 {
   "name": "auto-note",
-  "version": "1.0.7",
+  "version": "1.0.8",
   "description": "AutoNote — lecture notes generator from Canvas recordings",
   "homepage": "https://github.com/nodeeeeee/Auto-Note",
   "author": {

frame_extractor.py

@@ -165,6 +165,12 @@ def _parse_ffmpeg_duration(stderr: str | None) -> float | None:
     r"cannot (describe|view|generate|provide|access)|"
     r"i'?m sorry|\bsorry\b|"
     r"abstract blue wave|swirling blue|"
+    # TV-style "no signal" screens: when Panopto's screen-capture input
+    # was disconnected at recording time, the OBJECT stream is just the
+    # broadcast color-bar test pattern. These have no lecture content.
+    r"(test (pattern|screen|card)|color bars|colour bars|"
+    r"vertical (stripes|bars) (in (various|standard) colou?rs|of various colou?rs)|"
+    r"(static|broadcast) (screen|signal)|no signal|no input)|"
     r"(humorous|funny|joke) (meme|image|comic|cartoon|scene|depiction|strip|illustration|individuals|panel)|"
     r"(meme|comic) (format|image|strip|panel)|"
     r"xkcd|four-panel comic|meme structure)\b",

test/test_panopto_stream_case.py

@@ -0,0 +1,132 @@
+"""
+Regression tests for the v1.0.8 Panopto-stream case-sensitivity fix.
+
+Some Panopto sessions return stream tags in upper-case (`OBJECT`, `DV`)
+while others use lower-case (`object`, `dv`). The downloader's preference
+order is `("SS","OBJECT","DV")`. Before v1.0.8 the comparison was
+case-sensitive, so when Panopto returned lower-case tags the OBJECT
+branch never matched and the code fell through to "first stream" — which
+is `dv` (the camera). Result: a lecture-hall webcam shot got downloaded
+instead of the slide-recording, and downstream notes embedded camera
+frames of the lecturer instead of slides.
+
+Six EE2022 Wednesday lectures were affected in production:
+  01/04, 04/03, 08/04, 11/03, 18/03, 25/03 — all dated 2026.
+"""
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+PROJECT_DIR = Path(__file__).parent.parent
+sys.path.insert(0, str(PROJECT_DIR))
+
+
+def _build_extract(prefer_order=("SS", "OBJECT", "DV")):
+    """Reimplement downloader._extract_streams with the v1.0.8 fix so we
+    can test it without a real Panopto delivery payload."""
+    def _extract_streams(body):
+        streams = (body.get("Delivery") or {}).get("Streams") or []
+        order = tuple(t.upper() for t in prefer_order)
+        out = []
+        seen = set()
+        for tag in order + (None,):
+            for s in streams:
+                surl = s.get("StreamUrl", "")
+                if not surl or surl in seen:
+                    continue
+                stream_tag = (s.get("Tag", "") or "").upper()
+                if tag is None or stream_tag == tag:
+                    seen.add(surl)
+                    out.append((surl, s.get("Tag", "unknown")))
+        return out
+    return _extract_streams
+
+
+class TestStreamTagCaseInsensitive:
+    def test_lowercase_object_picked_over_lowercase_dv(self):
+        # The bug case: tags are lowercase. Before the fix this fell
+        # through to "first stream" = dv (camera). After: OBJECT wins.
+        body = {"Delivery": {"Streams": [
+            {"Tag": "dv",     "StreamUrl": "https://cdn/dv.m3u8"},
+            {"Tag": "object", "StreamUrl": "https://cdn/obj.m3u8"},
+        ]}}
+        result = _build_extract()(body)
+        assert result[0] == ("https://cdn/obj.m3u8", "object")
+        assert result[1] == ("https://cdn/dv.m3u8", "dv")
+
+    def test_uppercase_object_still_works(self):
+        # Backward-compat: existing Panopto sessions returning upper-case
+        # tags must continue to be matched. v1.0.8 normalises both sides
+        # to upper-case before comparing.
+        body = {"Delivery": {"Streams": [
+            {"Tag": "DV",     "StreamUrl": "https://cdn/dv.m3u8"},
+            {"Tag": "OBJECT", "StreamUrl": "https://cdn/obj.m3u8"},
+        ]}}
+        result = _build_extract()(body)
+        assert result[0] == ("https://cdn/obj.m3u8", "OBJECT")
+
+    def test_mixed_case_doesnt_break_anything(self):
+        body = {"Delivery": {"Streams": [
+            {"Tag": "Dv",     "StreamUrl": "https://cdn/dv.m3u8"},
+            {"Tag": "Object", "StreamUrl": "https://cdn/obj.m3u8"},
+            {"Tag": "Ss",     "StreamUrl": "https://cdn/ss.m3u8"},
+        ]}}
+        result = _build_extract()(body)
+        # SS first (highest preference), then OBJECT, then DV
+        assert result[0][1] == "Ss"
+        assert result[1][1] == "Object"
+        assert result[2][1] == "Dv"
+
+    def test_dv_only_camera_only_recording(self):
+        # Some Panopto sessions only have a DV stream (no screen capture).
+        # In that case DV must be returned as the only candidate.
+        body = {"Delivery": {"Streams": [
+            {"Tag": "dv", "StreamUrl": "https://cdn/dv.m3u8"},
+        ]}}
+        result = _build_extract()(body)
+        assert len(result) == 1
+        assert result[0][1] == "dv"
+
+    def test_empty_tag_falls_through_to_any(self):
+        # If Panopto returns a stream with no Tag at all, it should still
+        # be returned (after preferred tags are exhausted).
+        body = {"Delivery": {"Streams": [
+            {"StreamUrl": "https://cdn/u1.m3u8"},
+            {"Tag": "OBJECT", "StreamUrl": "https://cdn/obj.m3u8"},
+        ]}}
+        result = _build_extract()(body)
+        # OBJECT should still come first
+        assert result[0][1] == "OBJECT"
+        # Untagged stream still appears in the list
+        assert any(t == "unknown" for _, t in result)
+
+
+class TestJunkDescRegexExtensions:
+    def test_no_signal_test_pattern_caught(self):
+        from frame_extractor import _JUNK_DESC_RE
+        # The exact pathology from EE2022 06/03 Fri — Panopto recorded
+        # a TV-style "No Signal" screen because the slide projector wasn't
+        # plugged in at recording time.
+        descs = [
+            'The image displays a test pattern commonly used to indicate a "No Signal" status on television screens.',
+            "The image is a classic test pattern used for television broadcasts, featuring vertical stripes of various colors.",
+            "The image displays a static screen with vertical color bars in various shades.",
+            "The image displays a test screen typically used for television signals, consisting of vertical stripes in various colors.",
+        ]
+        for d in descs:
+            assert _JUNK_DESC_RE.search(d), f"Should be junk: {d}"
+
+    def test_legitimate_slide_descriptions_not_caught(self):
+        from frame_extractor import _JUNK_DESC_RE
+        # These are real lecture slide descriptions that must NOT be
+        # filtered — false positives would silently drop slides.
+        legit = [
+            'The slide features the title "Renewable Energy Integration".',
+            "The slide shows a network configuration diagram featuring a laptop and a TV.",
+            "The image shows a circuit diagram for a synchronous generator.",
+            "Architecture drawing of a power transmission system with multiple transformers.",
+            'The slide titled "Tutorial: 3-Phase Balanced Power" shows a table summarising key concepts.',
+        ]
+        for d in legit:
+            assert not _JUNK_DESC_RE.search(d), f"Wrongly junked: {d}"