Honor lecture filter across the whole pipeline + add DeepSeek V4

The Lecture filter on the Pipeline page only narrowed the note-generation
step. Download / transcribe / align silently processed every video, which
made "regenerate one note" download and transcribe the entire course.

Now the filter is forwarded all the way through:
  • app.js expands "1-5"/"1,3,5" into --download-video N N N for the
    downloader (replacing --download-video-all when set).
  • pipeline_worker.py gets --lectures, sorts videos by stem so the
    1-based position matches note_generation's caption-sort numbering,
    and forwards --lectures to semantic_alignment.
  • semantic_alignment.process_course filters captions to those positions
    before running BGE-M3.

Also surfaces DeepSeek V4 in the Settings → Tunable Constants dropdown
(both NOTE_MODEL and VERIFY_MODEL). The provider router already routed
any "deepseek*" model to api.deepseek.com; an 8k output cap was added
to _MODEL_MAX_COMPLETION for the V4 / V3 / R1 model IDs.

8 new regression tests in test/test_lecture_filter.py cover the parser,
the get_videos sort order, and the alignment-stage filter.

Author: nodeeeeee

electron/package.json

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

electron/renderer/app.js

@@ -1140,7 +1140,11 @@ const CONSTANTS_DEF = [
     ['Gemini 2.5 Pro','gemini-2.5-pro'],['Gemini 2.5 Flash','gemini-2.5-flash'],
     ['Gemini 2.5 Flash Lite','gemini-2.5-flash-lite'],['Gemini 2.0 Flash','gemini-2.0-flash'],
     // ── DeepSeek ────────────────────────────────────────────────────────
-    ['DeepSeek V3 (chat)','deepseek-chat'],['DeepSeek R1 (reasoning)','deepseek-reasoner'],
+    // `deepseek-chat` is an alias that DeepSeek points at the current
+    // latest non-reasoning model (V4 as of 2026-04). `deepseek-v4` is the
+    // pinned alias if you want to lock in V4 specifically.
+    ['DeepSeek V4 (chat)','deepseek-chat'],['DeepSeek V4 pinned','deepseek-v4'],
+    ['DeepSeek V3','deepseek-v3'],['DeepSeek R1 (reasoning)','deepseek-reasoner'],
     // ── xAI Grok ────────────────────────────────────────────────────────
     ['Grok 3','grok-3'],['Grok 3 mini','grok-3-mini'],
     // ── Mistral ─────────────────────────────────────────────────────────
@@ -1160,7 +1164,7 @@ const CONSTANTS_DEF = [
     ['Gemini 2.5 Flash','gemini-2.5-flash'],['Gemini 2.5 Flash Lite','gemini-2.5-flash-lite'],
     ['Gemini 2.0 Flash','gemini-2.0-flash'],
     // ── DeepSeek ────────────────────────────────────────────────────────
-    ['DeepSeek V3 (chat)','deepseek-chat'],
+    ['DeepSeek V4 (chat)','deepseek-chat'],['DeepSeek V4 pinned','deepseek-v4'],
     // ── xAI / Mistral ───────────────────────────────────────────────────
     ['Grok 3 mini','grok-3-mini'],['Mistral Small','mistral-small-latest'],
   ]],
@@ -1538,13 +1542,39 @@ async function attachPageHandlers() {
       const paths = await window.api.getScriptsPaths();
       const chain = [];
 
+      // Expand the lecture filter ('1-5' / '1,3,5') into individual numbers
+      // so the downloader can pass them via --download-video N N N. The
+      // numbering convention here follows the post-download alphabetical
+      // sort used by transcribe / align / generate; passing those same
+      // numbers to the downloader assumes Panopto's course_num matches
+      // (it does in the common case when lectures upload chronologically).
+      const lecNums = [];
+      if (lf) {
+        for (const part of lf.split(',')) {
+          const t = part.trim();
+          if (!t) continue;
+          const m = t.match(/^(\d+)\s*-\s*(\d+)$/);
+          if (m) {
+            const a = parseInt(m[1], 10), b = parseInt(m[2], 10);
+            if (a > 0 && b >= a) for (let n = a; n <= b; n++) lecNums.push(n);
+          } else if (/^\d+$/.test(t)) {
+            lecNums.push(parseInt(t, 10));
+          }
+        }
+      }
+
       if (steps.includes('dl_mat')) {
         const c = [python, paths.downloader, '--course', cid, '--download-material-all', '--path', outDir];
         if (stealth) c.push('--secretly');
         chain.push(['Download materials', c]);
       }
       if (steps.includes('dl_vid')) {
-        const c = [python, paths.downloader, '--course', cid, '--download-video-all', '--path', outDir];
+        const c = [python, paths.downloader, '--course', cid, '--path', outDir];
+        if (lecNums.length) {
+          c.push('--download-video', ...lecNums.map(String));
+        } else {
+          c.push('--download-video-all');
+        }
         if (stealth) c.push('--secretly');
         chain.push(['Download videos', c]);
       }
@@ -1560,6 +1590,7 @@ async function attachPageHandlers() {
         if (force) c.push('--force');
         if (imgSrc === 'slides')      c.push('--skip-frames');
         else if (imgSrc === 'frames') c.push('--force-screen');
+        if (lf) c.push('--lectures', lf);
         chain.push(['Transcribe + Align', c]);
       }
       if (steps.includes('generate')) {

note_generation.py

@@ -552,6 +552,11 @@ def _translate(text: str, lang: str) -> str:
     "gpt-5.2":         128000,
     "o3":              100000,
     "o4-mini":         100000,
+    # DeepSeek V4 / V3 / R1 share an 8k default output cap on the public API.
+    "deepseek-chat":     8192,
+    "deepseek-v4":       8192,
+    "deepseek-v3":       8192,
+    "deepseek-reasoner": 8192,
 }
 
 

pipeline_worker.py

@@ -76,7 +76,14 @@ def _run(cmd: list[str], label: str) -> bool:
 
 
 def get_videos(course_id: str, base_dir: Path) -> list[dict]:
-    """Get list of downloaded videos for a course from manifest."""
+    """Get list of downloaded videos for a course from manifest.
+
+    Sorted by stem so the 1-based position matches the lecture numbering
+    used by ``note_generation._discover_video_lectures`` and
+    ``semantic_alignment.process_course`` — both of which sort captions
+    alphabetically. This makes ``--lectures`` filters consistent across
+    transcribe / align / generate stages.
+    """
     if not MANIFEST_FILE.exists():
         return []
     with open(MANIFEST_FILE, encoding="utf-8") as f:
@@ -100,9 +107,32 @@ def get_videos(course_id: str, base_dir: Path) -> list[dict]:
             "stream_tag": entry.get("stream_tag", ""),
             "course_dir": base_dir / course_id,
         })
+    videos.sort(key=lambda v: v["stem"])
     return videos
 
 
+def _parse_lecture_filter(spec: str) -> set[int]:
+    """Parse '1-5' or '1,3,5' or '1-3,7' into a set of 1-based lecture nums.
+    Returns an empty set when spec is empty/blank — caller treats that as
+    'no filter'."""
+    sel: set[int] = set()
+    if not spec:
+        return sel
+    for part in spec.split(","):
+        part = part.strip()
+        if not part:
+            continue
+        if "-" in part:
+            try:
+                a, b = part.split("-", 1)
+                sel.update(range(int(a), int(b) + 1))
+            except ValueError:
+                continue
+        elif part.isdigit():
+            sel.add(int(part))
+    return sel
+
+
 def transcribe_one(video: dict, force: bool) -> bool:
     """Transcribe a single video."""
     caption = video["course_dir"] / "captions" / f"{video['stem']}.json"
@@ -183,7 +213,8 @@ def align_one(video: dict, force: bool) -> bool:
 
 def pipeline_sequential(videos: list[dict], force: bool,
                         skip_frames: bool = False,
-                        force_screen: bool = False) -> None:
+                        force_screen: bool = False,
+                        lectures: str = "") -> None:
     """Simple sequential pipeline: transcribe → frames → align per video."""
     for i, video in enumerate(videos, 1):
         print(f"\n{'═' * 60}")
@@ -201,12 +232,15 @@ def pipeline_sequential(videos: list[dict], force: bool,
                "--course", course_dir.name]
         if force:
             cmd.append("--force")
+        if lectures:
+            cmd.extend(["--lectures", lectures])
         _run(cmd, "Align all transcripts")
 
 
 def pipeline_threaded(videos: list[dict], force: bool,
                       skip_frames: bool = False,
-                      force_screen: bool = False) -> None:
+                      force_screen: bool = False,
+                      lectures: str = "") -> None:
     """Threaded pipeline: transcribe and frame-extract/align overlap.
 
     Thread 1 (transcriber): transcribes videos one at a time, pushes
@@ -256,6 +290,8 @@ def frame_processor():
            "--course", course_dir.name]
     if force:
         cmd.append("--force")
+    if lectures:
+        cmd.extend(["--lectures", lectures])
     _run(cmd, "Align all transcripts")
 
     if errors:
@@ -285,6 +321,11 @@ def main() -> None:
                              "screenshots so camera-style recordings still "
                              "produce images instead of falling through to "
                              "missing slide PDFs.")
+    parser.add_argument("--lectures", metavar="N-N or N,N,N", default="",
+                        help="Filter to specific lectures, e.g. '1-5' or "
+                             "'1,3,5'. Numbers are 1-based positions over "
+                             "videos sorted alphabetically by filename — the "
+                             "same numbering note_generation uses.")
     args = parser.parse_args()
 
     base_dir = Path(args.path) if args.path else COURSE_DATA_DIR
@@ -295,14 +336,27 @@ def main() -> None:
         print("Run 'Download videos' first.")
         return
 
+    sel = _parse_lecture_filter(args.lectures)
+    if sel:
+        before = len(videos)
+        videos = [v for i, v in enumerate(videos, start=1) if i in sel]
+        if not videos:
+            print(f"[error] Lecture filter '{args.lectures}' selected no "
+                  f"videos (out of {before} available). Aborting.")
+            return
+        print(f"Lecture filter '{args.lectures}': "
+              f"{len(videos)}/{before} video(s) selected.")
+
     print(f"Found {len(videos)} video(s) for course {args.course}.")
 
     if args.sequential:
         pipeline_sequential(videos, args.force, skip_frames=args.skip_frames,
-                            force_screen=args.force_screen)
+                            force_screen=args.force_screen,
+                            lectures=args.lectures)
     else:
         pipeline_threaded(videos, args.force, skip_frames=args.skip_frames,
-                          force_screen=args.force_screen)
+                          force_screen=args.force_screen,
+                          lectures=args.lectures)
 
     print(f"\n✓ Pipeline complete: {len(videos)} video(s) processed.")
 

semantic_alignment.py

@@ -1786,13 +1786,19 @@ def _load_mapping(mapping_path: Path, course_dir: Path) -> dict[str, list[Path]]
 
 def process_course(course_id: int | str, use_jina: bool = False,
                    mapping_path: Path | None = None,
-                   force: bool = False) -> None:
+                   force: bool = False,
+                   lectures: set[int] | None = None) -> None:
     course_dir  = COURSE_DATA_DIR / str(course_id)
     captions_dir = course_dir / "captions"
     print(f"Course dir : {course_dir}", flush=True)
     print(f"Captions   : {captions_dir}", flush=True)
 
     captions = sorted(captions_dir.glob("*.json")) if captions_dir.exists() else []
+    if lectures:
+        before = len(captions)
+        captions = [c for i, c in enumerate(captions, start=1) if i in lectures]
+        print(f"Lecture filter: {len(captions)}/{before} caption(s) selected.",
+              flush=True)
     all_slides = _candidate_slides(course_dir)
     out_dir    = course_dir / "alignment"
 
@@ -2025,8 +2031,28 @@ def main() -> None:
                              "(default: bge-m3, alternatives: jina, google, mpnet)")
     parser.add_argument("--force", action="store_true",
                         help="Re-align all captions even if alignment files already exist")
+    parser.add_argument("--lectures", metavar="N-N or N,N,N", default="",
+                        help="Filter to specific lectures (1-based positions "
+                             "over alphabetically sorted captions), e.g. "
+                             "'1-5' or '1,3,5'.")
     args = parser.parse_args()
 
+    def _parse_lec(spec: str) -> set[int]:
+        out: set[int] = set()
+        for part in (spec or "").split(","):
+            part = part.strip()
+            if not part:
+                continue
+            if "-" in part:
+                try:
+                    a, b = part.split("-", 1)
+                    out.update(range(int(a), int(b) + 1))
+                except ValueError:
+                    continue
+            elif part.isdigit():
+                out.add(int(part))
+        return out
+
     if args.suggest_matches:
         if not args.course:
             parser.error("--suggest-matches requires --course ID")
@@ -2049,8 +2075,9 @@ def main() -> None:
 
     if args.course:
         mapping = Path(args.mapping) if args.mapping else None
+        lec_filter = _parse_lec(args.lectures) or None
         process_course(args.course, use_jina=args.jina, mapping_path=mapping,
-                       force=args.force)
+                       force=args.force, lectures=lec_filter)
         return
 
     if not args.caption or not args.slides: