修改了公式渲染、LLM限额问题、音频下载等一系列问题

Author: LeafCreeper

main.py

@@ -1,10 +1,9 @@
 """iCourse Subscriber — main orchestration.
 
-Runs a single check: login → detect new lectures → download → transcribe
+Runs a single check: login → detect new lectures → stream audio → transcribe
 → summarize → email. Designed to be triggered by GitHub Actions cron.
 """
 
-import os
 import time
 import traceback
 
@@ -28,6 +27,9 @@ def process_lecture(
 ) -> str | None:
     """Download, transcribe, and summarize a single lecture.
 
+    Supports stage-skipping: if a previous run already produced a transcript
+    or summary, that stage is not repeated.
+
     Returns the summary string, or None if no summary was produced.
     """
     sub_id = str(lecture["sub_id"])
@@ -37,41 +39,50 @@ def process_lecture(
     print(f"\n  -- Processing: {sub_title} ({date})")
     t_start = time.time()
 
-    # 1) Download video
-    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
-
-    video_dir = os.path.join(config.VIDEO_DIR, course_id)
-    video_path = os.path.join(video_dir, f"{sub_id}.mp4")
-    os.makedirs(video_dir, exist_ok=True)
+    # Check existing progress for stage-skipping
+    existing = db.get_lecture(sub_id)
+    has_transcript = existing and existing.get("transcript")
+    has_summary = existing and existing.get("summary")
+
+    # 1) Transcribe (stream audio directly from CDN — no video download)
+    if has_transcript:
+        print(f"    Transcript exists, skipping transcription.")
+        transcript = existing["transcript"]
+    else:
+        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
 
-    if not os.path.exists(video_path):
-        print(f"    Downloading video...")
-        client.download_video(video_url, video_path)
-
-    # 2) Transcribe via ffmpeg pipe + SenseVoice
-    print(f"    Transcribing...")
-    transcript = transcriber.transcribe_video(video_path)
-    db.update_transcript(sub_id, transcript)
-
-    # 3) Delete video to save disk
-    if os.path.exists(video_path):
-        os.remove(video_path)
-        print(f"    Video deleted.")
+        try:
+            print(f"    Streaming audio & transcribing...")
+            transcript = transcriber.transcribe_url(video_url)
+            db.update_transcript(sub_id, transcript)
+        except Exception as e:
+            db.update_error(sub_id, "transcribe", str(e))
+            raise
 
-    # 4) Summarize
+    # 2) Summarize
     if not transcript.strip():
         print(f"    Empty transcript, skipping summary.")
         db.mark_processed(sub_id)
+        db.clear_error(sub_id)
         return None
 
-    print(f"    Generating summary...")
-    summary = summarizer.summarize(course_title, transcript)
-    db.update_summary(sub_id, summary)
+    if has_summary:
+        print(f"    Summary exists, skipping summarization.")
+        summary = existing["summary"]
+    else:
+        try:
+            print(f"    Generating summary...")
+            summary, model_used = summarizer.summarize(course_title, transcript)
+            db.update_summary_with_model(sub_id, summary, model_used)
+        except Exception as 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)")
     return summary
@@ -191,12 +202,29 @@ def run():
             print(f"  ERROR processing course {course_id}:")
             traceback.print_exc()
 
+    # Recover any previously processed-but-unsent lectures
+    unsent = db.get_unsent_lectures()
+    if unsent:
+        seen_sub_ids = {item["sub_id"] for item in email_items}
+        for row in unsent:
+            if row["sub_id"] not in seen_sub_ids:
+                email_items.append({
+                    "sub_id": row["sub_id"],
+                    "course_title": row["course_title"],
+                    "sub_title": row["sub_title"],
+                    "date": row["date"],
+                    "summary": row["summary"],
+                })
+        print(f"[Email] Including {len(unsent)} previously unsent lecture(s).")
+
     # Send one email with all summaries
     if emailer and email_items:
         try:
             print(f"\n[Email] Sending summary for {len(email_items)} lecture(s)...")
-            emailer.send(email_items)
-            db.mark_emailed_batch([item["sub_id"] for item in email_items])
+            if emailer.send(email_items):
+                db.mark_emailed_batch([item["sub_id"] for item in email_items])
+            else:
+                print("[Email] Send failed, lectures will be retried next run.")
         except Exception:
             print("[Email] Failed to send:")
             traceback.print_exc()

src/config.py

@@ -22,7 +22,12 @@
 # LLM (ModelScope OpenAI-compatible API)
 DASHSCOPE_API_KEY = os.environ.get("DASHSCOPE_API_KEY", "")
 LLM_BASE_URL = "https://api-inference.modelscope.cn/v1/"
-LLM_MODEL = "ZhipuAI/GLM-5"
+LLM_MODELS = [
+    "ZhipuAI/GLM-5",
+    "MiniMax/MiniMax-M2.5",
+    "deepseek-ai/DeepSeek-V3.2",
+    "ZhipuAI/GLM-4.7",
+]
 
 # QQ SMTP
 SMTP_EMAIL = os.environ.get("SMTP_EMAIL", "")

src/database.py

@@ -39,6 +39,19 @@ def _init_tables(self):
                     FOREIGN KEY (course_id) REFERENCES courses(course_id)
                 )
             """)
+            # Migrate: add error tracking and summary_model columns
+            existing = {
+                row[1]
+                for row in self.conn.execute("PRAGMA table_info(lectures)").fetchall()
+            }
+            for col, typedef in [
+                ("error_msg", "TEXT"),
+                ("error_count", "INTEGER DEFAULT 0"),
+                ("error_stage", "TEXT"),
+                ("summary_model", "TEXT"),
+            ]:
+                if col not in existing:
+                    self.conn.execute(f"ALTER TABLE lectures ADD COLUMN {col} {typedef}")
 
     def upsert_course(self, course_id: str, title: str, teacher: str):
         with self.conn:
@@ -120,3 +133,51 @@ def mark_emailed_batch(self, sub_ids: list[str]):
                 "UPDATE lectures SET emailed_at = ? WHERE sub_id = ?",
                 [(now, sid) for sid in sub_ids],
             )
+
+    def update_error(self, sub_id: str, stage: str, error_msg: str):
+        """Record a processing error for a lecture."""
+        with self.conn:
+            self.conn.execute(
+                """UPDATE lectures
+                   SET error_stage = ?, error_msg = ?,
+                       error_count = COALESCE(error_count, 0) + 1
+                   WHERE sub_id = ?""",
+                (stage, error_msg, sub_id),
+            )
+
+    def clear_error(self, sub_id: str):
+        """Clear error state after successful processing."""
+        with self.conn:
+            self.conn.execute(
+                """UPDATE lectures
+                   SET error_stage = NULL, error_msg = NULL, error_count = 0
+                   WHERE sub_id = ?""",
+                (sub_id,),
+            )
+
+    def update_summary_with_model(self, sub_id: str, summary: str, model: str):
+        """Save summary and the model that produced it."""
+        with self.conn:
+            self.conn.execute(
+                "UPDATE lectures SET summary = ?, summary_model = ? WHERE sub_id = ?",
+                (summary, model, sub_id),
+            )
+
+    def get_lecture(self, sub_id: str) -> dict | None:
+        """Get a single lecture row by sub_id."""
+        row = self.conn.execute(
+            "SELECT * FROM lectures WHERE sub_id = ?", (sub_id,)
+        ).fetchone()
+        return dict(row) if row else None
+
+    def get_unsent_lectures(self) -> list[dict]:
+        """Find lectures that are processed but not yet emailed."""
+        rows = self.conn.execute(
+            """SELECT l.*, c.title AS course_title, c.teacher
+               FROM lectures l
+               JOIN courses c ON l.course_id = c.course_id
+               WHERE l.processed_at IS NOT NULL
+                 AND l.emailed_at IS NULL
+                 AND l.summary IS NOT NULL""",
+        ).fetchall()
+        return [dict(row) for row in rows]

src/emailer.py

@@ -1,11 +1,14 @@
 """Email notification via QQ SMTP."""
 
+import re
 import smtplib
+import time
 from collections import OrderedDict
 from email.mime.multipart import MIMEMultipart
 from email.mime.text import MIMEText
 from html import escape
 from email.utils import formataddr
+from urllib.parse import quote
 
 import markdown
 
@@ -95,6 +98,41 @@ def _md_to_html(md_text: str) -> str:
     return markdown.markdown(md_text, extensions=_MD_EXTENSIONS)
 
 
+def _latex_to_img_html(html: str) -> str:
+    """Replace LaTeX math expressions with rendered <img> tags.
+
+    Skips content inside <code> and <pre> tags.
+    $$...$$ → centered block image, $...$ → inline image.
+    """
+    # Split HTML to skip code/pre blocks
+    parts = re.split(r"(<code>.*?</code>|<pre>.*?</pre>)", html, flags=re.DOTALL)
+    for i, part in enumerate(parts):
+        if part.startswith("<code>") or part.startswith("<pre>"):
+            continue
+        # Block math: $$...$$
+        part = re.sub(
+            r"\$\$(.+?)\$\$",
+            lambda m: (
+                f'<div style="text-align:center;margin:12px 0">'
+                f'<img src="https://latex.codecogs.com/svg.latex?{quote(m.group(1))}"'
+                f' alt="{escape(m.group(1))}" style="vertical-align:middle"></div>'
+            ),
+            part,
+            flags=re.DOTALL,
+        )
+        # Inline math: $...$
+        part = re.sub(
+            r"\$(.+?)\$",
+            lambda m: (
+                f'<img src="https://latex.codecogs.com/svg.latex?\\inline%20{quote(m.group(1))}"'
+                f' alt="{escape(m.group(1))}" style="vertical-align:middle">'
+            ),
+            part,
+        )
+        parts[i] = part
+    return "".join(parts)
+
+
 class Emailer:
     """Send course summary emails via QQ SMTP SSL."""
 
@@ -105,15 +143,18 @@ def __init__(self):
         self.password = config.SMTP_PASSWORD
         self.receiver = config.RECEIVER_EMAIL
 
-    def send(self, items: list[dict]):
+    def send(self, items: list[dict]) -> bool:
         """Send a single email containing all lecture summaries.
 
         Args:
             items: List of dicts, each with keys:
                    course_title, sub_title, date, summary
+
+        Returns:
+            True if email was sent successfully, False otherwise.
         """
         if not items:
-            return
+            return True
 
         # Group by course (preserve insertion order)
         courses: OrderedDict[str, list[dict]] = OrderedDict()
@@ -137,7 +178,7 @@ def send(self, items: list[dict]):
                 plain_sections.append(lec["summary"])
         plain = "\n".join(plain_sections)
 
-        # HTML (Markdown → styled HTML)
+        # HTML (Markdown → styled HTML with LaTeX rendering)
         body_parts = []
         for course_title, lectures in courses.items():
             body_parts.append(f"<h2>{escape(course_title)}</h2>")
@@ -146,7 +187,7 @@ def send(self, items: list[dict]):
                     f"<h3>{escape(lec['sub_title'])} "
                     f"<small>({escape(lec['date'])})</small></h3>"
                 )
-                body_parts.append(_md_to_html(lec["summary"]))
+                body_parts.append(_latex_to_img_html(_md_to_html(lec["summary"])))
                 body_parts.append("<hr>")
 
         html = (
@@ -165,8 +206,18 @@ def send(self, items: list[dict]):
         msg.attach(MIMEText(plain, "plain", "utf-8"))
         msg.attach(MIMEText(html, "html", "utf-8"))
 
-        with smtplib.SMTP_SSL(self.host, self.port) as server:
-            server.login(self.sender, self.password)
-            server.sendmail(self.sender, self.receiver, msg.as_string())
-
-        print(f"[Emailer] Sent: {subject}")
+        # Retry with exponential backoff
+        for attempt in range(3):
+            try:
+                with smtplib.SMTP_SSL(self.host, self.port) as server:
+                    server.login(self.sender, self.password)
+                    server.sendmail(self.sender, self.receiver, msg.as_string())
+                print(f"[Emailer] Sent: {subject}")
+                return True
+            except Exception as e:
+                print(f"[Emailer] Attempt {attempt + 1}/3 failed: {e}")
+                if attempt < 2:
+                    time.sleep(2 ** attempt)
+
+        print("[Emailer] All send attempts failed.")
+        return False