完善了一些调试信息和输出缓冲问题

Author: LeafCreeper

.github/workflows/check.yml

@@ -87,7 +87,7 @@ jobs:
           SMTP_EMAIL: ${{ secrets.SMTP_EMAIL }}
           SMTP_PASSWORD: ${{ secrets.SMTP_PASSWORD }}
           RECEIVER_EMAIL: ${{ secrets.RECEIVER_EMAIL }}
-        run: python main.py
+        run: python -u main.py
 
       # Encrypt and commit database only if it changed
       - name: Commit database

main.py

@@ -37,6 +37,7 @@ def process_lecture(
     date = lecture.get("date", "")
 
     print(f"\n  -- Processing: {sub_title} ({date})")
+    print(f"    [Time] Start: {time.strftime('%Y-%m-%d %H:%M:%S')}")
     t_start = time.time()
 
     # Check existing progress for stage-skipping
@@ -46,20 +47,23 @@ def process_lecture(
 
     # 1) Transcribe (stream audio directly from CDN — no video download)
     if has_transcript:
-        print(f"    Transcript exists, skipping transcription.")
+        print(f"    Transcript exists ({len(existing['transcript'])} chars), skipping transcription.")
         transcript = existing["transcript"]
     else:
+        print(f"    [Time] Fetching video URL at {time.strftime('%H:%M:%S')}")
         video_url = client.get_video_url(course_id, sub_id)
         if not video_url:
             print(f"    No video URL for {sub_id}, skipping.")
             return None
 
         try:
-            print(f"    Streaming audio & transcribing...")
             vpn_url, http_headers = client.get_stream_params(video_url)
+            print(f"    [Time] Streaming audio at {time.strftime('%H:%M:%S')}")
+            print(f"    [URL] {vpn_url[:100]}...")
             transcript = transcriber.transcribe_url(vpn_url, http_headers=http_headers)
             db.update_transcript(sub_id, transcript)
         except Exception as e:
+            print(f"    [FAIL] Transcription error: {type(e).__name__}: {e}")
             db.update_error(sub_id, "transcribe", str(e))
             raise
 
@@ -71,21 +75,24 @@ def process_lecture(
         return None
 
     if has_summary:
-        print(f"    Summary exists, skipping summarization.")
+        print(f"    Summary exists ({len(existing['summary'])} chars), skipping summarization.")
         summary = existing["summary"]
     else:
         try:
-            print(f"    Generating summary...")
+            print(f"    [Time] Generating summary at {time.strftime('%H:%M:%S')}")
+            print(f"    Transcript length: {len(transcript)} chars")
             summary, model_used = summarizer.summarize(course_title, transcript)
+            print(f"    [OK] Summary by {model_used}: {len(summary)} chars")
             db.update_summary_with_model(sub_id, summary, model_used)
         except Exception as e:
+            print(f"    [FAIL] Summarization error: {type(e).__name__}: {e}")
             db.update_error(sub_id, "summarize", str(e))
             raise
 
     db.mark_processed(sub_id)
     db.clear_error(sub_id)
     elapsed = time.time() - t_start
-    print(f"    Done: {sub_title} (total {elapsed:.0f}s)")
+    print(f"    [Time] Done at {time.strftime('%H:%M:%S')}: {sub_title} (total {elapsed:.0f}s)")
     return summary
 
 

src/transcriber.py

@@ -2,6 +2,7 @@
 
 import os
 import subprocess
+import threading
 import time
 
 import numpy as np
@@ -78,22 +79,37 @@ def _transcribe_from_cmd(self, cmd: list[str], timeout: int = 7200) -> str:
         self._init()
         self._reset_vad()
         t0 = time.time()
+        print(f"[Transcriber] Starting at {time.strftime('%H:%M:%S')}", flush=True)
 
         proc = subprocess.Popen(
-            cmd, stdout=subprocess.PIPE, stderr=subprocess.DEVNULL,
+            cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
         )
 
+        # Drain stderr in background thread to prevent pipe deadlock
+        stderr_chunks = []
+        def _drain_stderr():
+            try:
+                for line in proc.stderr:
+                    stderr_chunks.append(line)
+            except Exception:
+                pass
+        stderr_thread = threading.Thread(target=_drain_stderr, daemon=True)
+        stderr_thread.start()
+
         sample_rate = 16000
         window_size = 512  # samples per VAD window (32ms at 16kHz)
         chunk_size = 16000  # read 1 second at a time from ffmpeg
         bytes_per_sample = 4  # float32
 
         texts = []
         total_read = 0
+        total_bytes = 0
+        last_report = t0
 
         try:
             while True:
-                if time.time() - t0 > timeout:
+                now = time.time()
+                if now - t0 > timeout:
                     proc.kill()
                     proc.wait()
                     raise TimeoutError(
@@ -104,9 +120,24 @@ def _transcribe_from_cmd(self, cmd: list[str], timeout: int = 7200) -> str:
                 if not raw:
                     break
 
+                total_bytes += len(raw)
                 samples = np.frombuffer(raw, dtype=np.float32)
                 total_read += len(samples)
 
+                # Progress report every 60 seconds
+                if now - last_report >= 60:
+                    elapsed_so_far = now - t0
+                    audio_so_far = total_read / sample_rate
+                    speed_kbps = (total_bytes / 1024) / elapsed_so_far
+                    print(
+                        f"[Transcriber] Progress: {audio_so_far:.0f}s audio,"
+                        f" {total_bytes / 1024 / 1024:.1f} MB received,"
+                        f" {speed_kbps:.1f} KB/s,"
+                        f" {len(texts)} segments so far",
+                        flush=True,
+                    )
+                    last_report = now
+
                 # Feed samples to VAD in window-sized chunks
                 idx = 0
                 while idx + window_size <= len(samples):
@@ -125,16 +156,35 @@ def _transcribe_from_cmd(self, cmd: list[str], timeout: int = 7200) -> str:
             if proc.poll() is None:
                 proc.kill()
             proc.wait()
-
-        if proc.returncode not in (0, -9, None):
-            raise RuntimeError(f"ffmpeg exited with code {proc.returncode}")
+            stderr_thread.join(timeout=5)
+            stderr_output = b"".join(stderr_chunks)
 
         elapsed = time.time() - t0
         duration = total_read / sample_rate
+
+        if proc.returncode not in (0, -9, None):
+            stderr_text = stderr_output.decode(errors="replace")[-500:]
+            raise RuntimeError(
+                f"ffmpeg exited with code {proc.returncode}.\n"
+                f"stderr (last 500 chars):\n{stderr_text}"
+            )
+
+        # Warn if no audio received (likely auth/network issue)
+        if total_bytes == 0:
+            stderr_text = stderr_output.decode(errors="replace")[-500:]
+            raise RuntimeError(
+                f"ffmpeg produced no audio output (0 bytes received).\n"
+                f"stderr (last 500 chars):\n{stderr_text}"
+            )
+
+        speed_kbps = (total_bytes / 1024) / elapsed if elapsed > 0 else 0
         transcript = " ".join(texts)
         print(
-            f"[Transcriber] Done: {duration:.0f}s audio, {len(transcript)} chars,"
-            f" {len(texts)} segments in {elapsed:.0f}s"
+            f"[Transcriber] Done at {time.strftime('%H:%M:%S')}:"
+            f" {duration:.0f}s audio, {total_bytes / 1024 / 1024:.1f} MB,"
+            f" avg {speed_kbps:.1f} KB/s,"
+            f" {len(transcript)} chars, {len(texts)} segments in {elapsed:.0f}s",
+            flush=True,
         )
         return transcript