readloops 2.3.0__py3-none-any.whl

app/api/articles.py

@@ -0,0 +1,97 @@
+"""文章路由：生成、列表、详情。"""
+import json
+
+from fastapi import APIRouter, HTTPException
+
+from app.database import get_db
+from app.services.ai import generate_article
+
+router = APIRouter(prefix="/api/articles", tags=["articles"])
+
+
+@router.post("/generate")
+async def generate():
+    """生成一篇新文章。"""
+    article = generate_article()
+    if not article:
+        raise HTTPException(status_code=500, detail="无法生成文章，请检查 AI 配置")
+    return {
+        "id": article.id,
+        "title": article.title,
+        "content": article.content,
+        "source": article.source,
+        "word_count": article.word_count,
+        "new_word_count": article.new_word_count,
+        "target_words": json.loads(article.target_words) if article.target_words else [],
+        "created_at": article.created_at,
+    }
+
+
+@router.get("/")
+async def list_articles(limit: int = 30):
+    """获取文章列表。"""
+    with get_db() as conn:
+        rows = conn.execute(
+            "SELECT id, title, source, word_count, new_word_count, reading_time_seconds, created_at "
+            "FROM articles ORDER BY created_at DESC LIMIT ?",
+            (limit,),
+        ).fetchall()
+    return [
+        {
+            "id": r["id"],
+            "title": r["title"],
+            "source": r["source"],
+            "word_count": r["word_count"],
+            "new_word_count": r["new_word_count"],
+            "reading_time_seconds": r["reading_time_seconds"],
+            "created_at": r["created_at"],
+        }
+        for r in rows
+    ]
+
+
+@router.get("/{article_id}")
+async def get_article(article_id: int):
+    """获取文章详情。"""
+    with get_db() as conn:
+        row = conn.execute(
+            "SELECT * FROM articles WHERE id = ?", (article_id,)
+        ).fetchone()
+    if not row:
+        raise HTTPException(status_code=404, detail="文章不存在")
+    return {
+        "id": row["id"],
+        "title": row["title"],
+        "content": row["content"],
+        "source": row["source"],
+        "word_count": row["word_count"],
+        "new_word_count": row["new_word_count"],
+        "target_words": json.loads(row["target_words"]) if row["target_words"] else [],
+        "difficulty_score": row["difficulty_score"],
+        "reading_time_seconds": row["reading_time_seconds"],
+        "created_at": row["created_at"],
+    }
+
+
+@router.get("/{article_id}/details")
+async def get_article_details(article_id: int):
+    """获取文章增强详情：高频词、目标生词、真题相似度。"""
+    from app.services.similarity import get_article_details
+    details = get_article_details(article_id)
+    if not details:
+        raise HTTPException(status_code=404, detail="文章不存在")
+    return details
+
+
+@router.delete("/{article_id}")
+async def delete_article(article_id: int):
+    """删除文章。"""
+    with get_db() as conn:
+        row = conn.execute("SELECT id FROM articles WHERE id = ?", (article_id,)).fetchone()
+        if not row:
+            raise HTTPException(status_code=404, detail="文章不存在")
+        # 先删除关联数据，再删除文章本身（避免外键约束失败）
+        conn.execute("DELETE FROM highlights WHERE article_id = ?", (article_id,))
+        conn.execute("DELETE FROM reading_sessions WHERE article_id = ?", (article_id,))
+        conn.execute("DELETE FROM articles WHERE id = ?", (article_id,))
+    return {"status": "ok", "message": "文章已删除"}

app/api/reading.py

@@ -0,0 +1,157 @@
+"""阅读行为路由：查词记录、高亮、阅读会话。"""
+import time
+
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+from app.database import get_db
+
+router = APIRouter(prefix="/api/reading", tags=["reading"])
+
+
+class LookupRequest(BaseModel):
+    word_id: int = 0
+    article_id: int = 0
+    context: str = ""
+
+
+class HighlightRequest(BaseModel):
+    article_id: int
+    text: str
+    word_id: int = 0
+    color: str = "yellow"
+
+
+class SessionRequest(BaseModel):
+    article_id: int
+    duration_seconds: int = 0
+    lookups: int = 0
+    highlights: int = 0
+
+
+@router.post("/lookup")
+async def record_lookup(word_id: int = 0, article_id: int = 0, context: str = ""):
+    """记录一次查词。
+    算法：
+    - 第1次查词：只记录
+    - 第2次查词：标记为 target（后续文章优先包含，测验记忆）
+    - 第3次及以上：自动加入生词本（learning）
+    """
+    now = int(time.time())
+    with get_db() as conn:
+        if word_id:
+            conn.execute(
+                "INSERT INTO word_encounters (word_id, article_id, context, action, created_at) "
+                "VALUES (?, ?, ?, 'lookup', ?)",
+                (word_id, article_id or None, context, now),
+            )
+            # 获取当前 lookup_count（更新前）
+            row = conn.execute("SELECT lookup_count, status FROM words WHERE id=?", (word_id,)).fetchone()
+            if row:
+                current_count = row["lookup_count"]
+                new_count = current_count + 1
+                # 根据查词次数更新状态
+                if new_count >= 3 and row["status"] != "learning":
+                    # 第3次查词：自动加入生词本
+                    new_status = "learning"
+                elif new_count == 2 and row["status"] == "new":
+                    # 第2次查词：标记为目标词
+                    new_status = "target"
+                else:
+                    new_status = row["status"]
+                conn.execute(
+                    "UPDATE words SET lookup_count = ?, status = ?, updated_at = ? WHERE id=?",
+                    (new_count, new_status, now, word_id),
+                )
+                return {"status": "ok", "lookup_count": new_count, "word_status": new_status}
+    return {"status": "ok"}
+
+
+@router.get("/lookups")
+async def get_lookup_history(limit: int = 50):
+    """获取查词历史（最近查过的词，去重）。"""
+    with get_db() as conn:
+        rows = conn.execute(
+            """
+            SELECT w.id, w.text, w.phonetic, w.meaning, MAX(we.created_at) as last_lookup,
+                   COUNT(we.id) as lookup_count
+            FROM word_encounters we
+            JOIN words w ON w.id = we.word_id
+            WHERE we.action = 'lookup'
+            GROUP BY w.id
+            ORDER BY last_lookup DESC
+            LIMIT ?
+            """,
+            (limit,),
+        ).fetchall()
+    return [
+        {
+            "word_id": r["id"],
+            "text": r["text"],
+            "phonetic": r["phonetic"] or "",
+            "meaning": r["meaning"] or "",
+            "last_lookup": r["last_lookup"],
+            "lookup_count": r["lookup_count"],
+        }
+        for r in rows
+    ]
+
+
+@router.post("/highlight")
+async def record_highlight(req: HighlightRequest):
+    """记录一次高亮。"""
+    now = int(time.time())
+    with get_db() as conn:
+        conn.execute(
+            "INSERT INTO highlights (article_id, text, word_id, color, created_at) "
+            "VALUES (?, ?, ?, ?, ?)",
+            (req.article_id, req.text, req.word_id or None, req.color, now),
+        )
+        if req.word_id:
+            conn.execute(
+                "UPDATE words SET encounter_count = encounter_count + 1 WHERE id=?",
+                (req.word_id,),
+            )
+    return {"status": "ok"}
+
+
+@router.delete("/highlight")
+async def delete_highlight(article_id: int, text: str):
+    """删除一次高亮。"""
+    with get_db() as conn:
+        result = conn.execute(
+            "DELETE FROM highlights WHERE article_id=? AND text=?",
+            (article_id, text),
+        )
+    return {"status": "ok", "deleted": result.rowcount}
+
+
+@router.post("/session")
+async def record_session(req: SessionRequest):
+    """记录一次阅读会话。"""
+    now = int(time.time())
+    with get_db() as conn:
+        # 先检查文章是否存在，避免外键约束失败
+        article = conn.execute("SELECT id FROM articles WHERE id=?", (req.article_id,)).fetchone()
+        if article:
+            conn.execute(
+                "INSERT INTO reading_sessions (article_id, start_time, end_time, duration_seconds, lookups, highlights) "
+                "VALUES (?, ?, ?, ?, ?, ?)",
+                (req.article_id, now - req.duration_seconds, now, req.duration_seconds, req.lookups, req.highlights),
+            )
+            conn.execute(
+                "UPDATE articles SET reading_time_seconds = reading_time_seconds + ? WHERE id=?",
+                (req.duration_seconds, req.article_id),
+            )
+    return {"status": "ok"}
+
+
+@router.get("/highlights/{article_id}")
+async def get_highlights(article_id: int):
+    """获取文章的高亮。"""
+    with get_db() as conn:
+        rows = conn.execute(
+            "SELECT text, color, created_at FROM highlights WHERE article_id=? ORDER BY created_at",
+            (article_id,),
+        ).fetchall()
+    return [{"text": r["text"], "color": r["color"], "created_at": r["created_at"]} for r in rows]

app/api/stats.py

@@ -0,0 +1,254 @@
+"""统计、测试、设置路由。"""
+import time
+
+import httpx
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+from app.database import get_db
+
+router = APIRouter(prefix="/api", tags=["stats"])
+
+
+class SettingsRequest(BaseModel):
+    ai_base_url: str = ""
+    ai_api_key: str = ""
+    ai_model: str = ""
+    theme: str = ""
+    font_size: str = ""
+    line_height: str = ""
+
+
+class TestApiRequest(BaseModel):
+    ai_base_url: str = ""
+    ai_api_key: str = ""
+    ai_model: str = ""
+
+
+@router.get("/stats/overview")
+async def stats_overview():
+    """总览统计。"""
+    with get_db() as conn:
+        articles_read = conn.execute("SELECT COUNT(*) as c FROM articles").fetchone()["c"]
+        total_words = conn.execute("SELECT COALESCE(SUM(word_count),0) as s FROM articles").fetchone()["s"]
+        words_learning = conn.execute(
+            "SELECT COUNT(*) as c FROM words WHERE status='learning'"
+        ).fetchone()["c"]
+        words_known = conn.execute(
+            "SELECT COUNT(*) as c FROM words WHERE status='known'"
+        ).fetchone()["c"]
+        words_target = conn.execute(
+            "SELECT COUNT(*) as c FROM words WHERE status='target'"
+        ).fetchone()["c"]
+        total_time = conn.execute(
+            "SELECT COALESCE(SUM(duration_seconds),0) as s FROM reading_sessions"
+        ).fetchone()["s"]
+        total_lookups = conn.execute(
+            "SELECT COUNT(*) as c FROM word_encounters WHERE action='lookup'"
+        ).fetchone()["c"]
+
+        # 连续学习天数（streak）
+        streak = 0
+        days = conn.execute(
+            "SELECT DISTINCT date(created_at, 'unixepoch', 'localtime') as d "
+            "FROM articles ORDER BY d DESC LIMIT 30"
+        ).fetchall()
+        if days:
+            from datetime import datetime, timedelta
+            today = datetime.now().date()
+            day_set = set(d["d"] for d in days)
+            # 从今天或昨天开始算
+            check = today
+            if str(check) not in day_set:
+                check = today - timedelta(days=1)
+            while str(check) in day_set:
+                streak += 1
+                check -= timedelta(days=1)
+
+        # 词汇量估算（已掌握 + 学习中 * 0.5 + 测试正确率加权）
+        test_correct = conn.execute(
+            "SELECT COALESCE(SUM(correct_count),0) as s FROM words"
+        ).fetchone()["s"]
+        test_total = conn.execute(
+            "SELECT COALESCE(SUM(correct_count + wrong_count),0) as s FROM words"
+        ).fetchone()["s"]
+        vocab_estimate = words_known + int(words_learning * 0.5) + 2000  # 基础2000 + 已掌握 + 学习中一半
+
+        # FSRS 统计
+        from app.services.srs import get_review_stats
+        srs = get_review_stats(conn)
+
+        # 查词热词 TOP10
+        hot_words = conn.execute(
+            "SELECT w.text, w.lookup_count FROM words w "
+            "WHERE w.lookup_count > 0 ORDER BY w.lookup_count DESC LIMIT 10"
+        ).fetchall()
+
+    return {
+        "articles_read": articles_read,
+        "total_words": total_words,
+        "words_learning": words_learning,
+        "words_known": words_known,
+        "words_target": words_target,
+        "total_reading_seconds": total_time,
+        "total_lookups": total_lookups,
+        "streak_days": streak,
+        "vocab_estimate": vocab_estimate,
+        "test_accuracy": round(test_correct / test_total * 100, 1) if test_total > 0 else 0,
+        "srs": srs,
+        "hot_words": [{"text": r["text"], "count": r["lookup_count"]} for r in hot_words],
+    }
+
+
+@router.get("/stats/recent")
+async def stats_recent(days: int = 7):
+    """最近统计。"""
+    since = int(time.time()) - days * 86400
+    with get_db() as conn:
+        rows = conn.execute(
+            "SELECT date(created_at, 'unixepoch', 'localtime') as day, COUNT(*) as cnt "
+            "FROM articles WHERE created_at >= ? GROUP BY day ORDER BY day",
+            (since,),
+        ).fetchall()
+    return [{"date": r["day"], "count": r["cnt"]} for r in rows]
+
+
+@router.get("/stats/activity")
+async def stats_activity(weeks: int = 52):
+    """每日活动热力图数据（最近 N 周）。"""
+    from datetime import datetime, timedelta
+    today = datetime.now().date()
+    # 计算起始日期（对齐到周一）
+    start = today - timedelta(days=weeks * 7 + today.weekday())
+
+    with get_db() as conn:
+        # 文章数按天
+        articles_by_day = {}
+        for r in conn.execute(
+            "SELECT date(created_at, 'unixepoch', 'localtime') as d, COUNT(*) as c "
+            "FROM articles WHERE created_at >= ? GROUP BY d",
+            (int(datetime.combine(start, datetime.min.time()).timestamp()),),
+        ).fetchall():
+            articles_by_day[r["d"]] = r["c"]
+
+        # 阅读时长按天
+        time_by_day = {}
+        for r in conn.execute(
+            "SELECT date(start_time, 'unixepoch', 'localtime') as d, "
+            "COALESCE(SUM(duration_seconds),0) as s FROM reading_sessions "
+            "WHERE start_time >= ? GROUP BY d",
+            (int(datetime.combine(start, datetime.min.time()).timestamp()),),
+        ).fetchall():
+            time_by_day[r["d"]] = r["s"]
+
+        # 查词数按天
+        lookup_by_day = {}
+        for r in conn.execute(
+            "SELECT date(created_at, 'unixepoch', 'localtime') as d, COUNT(*) as c "
+            "FROM word_encounters WHERE action='lookup' AND created_at >= ? GROUP BY d",
+            (int(datetime.combine(start, datetime.min.time()).timestamp()),),
+        ).fetchall():
+            lookup_by_day[r["d"]] = r["c"]
+
+    # 生成完整日期序列
+    days = []
+    d = start
+    while d <= today:
+        ds = str(d)
+        articles = articles_by_day.get(ds, 0)
+        seconds = time_by_day.get(ds, 0)
+        lookups = lookup_by_day.get(ds, 0)
+        # 活动等级：0-4（基于文章数+阅读分钟+查词数综合）
+        score = articles * 2 + min(seconds / 300, 3) + min(lookups / 5, 2)
+        level = 0 if score == 0 else min(4, int(score) + 1)
+        days.append({
+            "date": ds,
+            "articles": articles,
+            "reading_seconds": seconds,
+            "lookups": lookups,
+            "level": level,
+        })
+        d += timedelta(days=1)
+
+    return {"days": days, "total_days": len(days), "active_days": sum(1 for d in days if d["level"] > 0)}
+
+
+@router.post("/stats/test/start")
+async def test_start():
+    """开始一次词汇测试。"""
+    now = int(time.time())
+    with get_db() as conn:
+        cur = conn.execute(
+            "INSERT INTO tests (type, status, created_at) VALUES ('vocab', 'in_progress', ?)",
+            (now,),
+        )
+        test_id = cur.lastrowid
+    return {"test_id": test_id}
+
+
+@router.post("/stats/test/{test_id}/submit")
+async def test_submit(test_id: int, correct: int = 0, total: int = 0):
+    """提交测试结果。"""
+    now = int(time.time())
+    with get_db() as conn:
+        conn.execute(
+            "UPDATE tests SET status='completed', score=?, total=?, completed_at=? WHERE id=?",
+            (correct, total, now, test_id),
+        )
+    return {"test_id": test_id, "score": correct, "total": total}
+
+
+@router.get("/settings")
+async def get_settings():
+    """获取设置。"""
+    with get_db() as conn:
+        rows = conn.execute("SELECT key, value FROM settings").fetchall()
+    return {r["key"]: r["value"] for r in rows}
+
+
+@router.post("/settings")
+async def update_settings(req: SettingsRequest):
+    """更新设置。"""
+    with get_db() as conn:
+        for key, value in req.model_dump().items():
+            if value:
+                conn.execute(
+                    "INSERT OR REPLACE INTO settings (key, value) VALUES (?, ?)",
+                    (key, value),
+                )
+    return {"status": "ok"}
+
+
+@router.post("/settings/test")
+async def test_api_connection(req: TestApiRequest):
+    """测试 AI API 连接。"""
+    base_url = req.ai_base_url.rstrip("/")
+    api_key = req.ai_api_key
+    model = req.ai_model
+    if not base_url or not api_key:
+        return {"ok": False, "error": "请填写 Base URL 和 API Key"}
+    try:
+        async with httpx.AsyncClient(timeout=10) as client:
+            resp = await client.get(
+                f"{base_url}/models",
+                headers={"Authorization": f"Bearer {api_key}"},
+            )
+            if resp.status_code == 200:
+                data = resp.json()
+                models = [m.get("id", "") for m in data.get("data", [])]
+                return {"ok": True, "model": model or (models[0] if models else "未知")}
+            resp2 = await client.post(
+                f"{base_url}/chat/completions",
+                headers={"Authorization": f"Bearer {api_key}"},
+                json={
+                    "model": model or "gpt-3.5-turbo",
+                    "messages": [{"role": "user", "content": "hi"}],
+                    "max_tokens": 5,
+                    "thinking": {"type": "disabled"},
+                },
+            )
+            if resp2.status_code == 200:
+                return {"ok": True, "model": model}
+            return {"ok": False, "error": f"HTTP {resp2.status_code}: {resp2.text[:100]}"}
+    except Exception as e:
+        return {"ok": False, "error": str(e)[:100]}