funread-api 0.1.1__py3-none-any.whl

funread_api/__init__.py

@@ -0,0 +1 @@
+"""HTTP API service exposing funread's source-list collection."""

funread_api/app.py

@@ -0,0 +1,48 @@
+"""FastAPI app assembly (sync — funread's storage layer is sync SQLAlchemy)."""
+
+from __future__ import annotations
+
+from contextlib import asynccontextmanager
+from typing import AsyncIterator
+
+from fastapi import FastAPI
+
+from funread.legado.manage.source.storage import init_source_db
+from funread_api.v1 import api_router
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI) -> AsyncIterator[None]:
+    # Create tables (if missing) on startup so config/connectivity errors
+    # surface immediately instead of on the first request.
+    init_source_db()
+    yield
+
+
+def create_app() -> FastAPI:
+    app = FastAPI(
+        title="funread",
+        version="0.1.0",
+        description="Manage funread's source-list collection",
+        lifespan=lifespan,
+    )
+    app.include_router(api_router, prefix="/api/v1")
+
+    @app.get("/healthz", tags=["ops"])
+    def healthz() -> dict:
+        return {"status": "ok"}
+
+    return app
+
+
+app = create_app()
+
+
+def run() -> None:
+    import uvicorn
+
+    uvicorn.run("funread_api.app:app", host="0.0.0.0", port=18811)
+
+
+if __name__ == "__main__":
+    run()

funread_api/v1/__init__.py

@@ -0,0 +1,8 @@
+from fastapi import APIRouter
+
+from .sources import router as sources_router
+
+api_router = APIRouter()
+api_router.include_router(sources_router)
+
+__all__ = ["api_router"]

funread_api/v1/sources.py

@@ -0,0 +1,249 @@
+"""Source-list registration, management, and manual collection."""
+
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Literal
+
+import requests
+from fastapi import APIRouter, HTTPException, Query, status
+from pydantic import AnyHttpUrl, BaseModel
+from sqlalchemy import func, select
+from sqlalchemy.orm import Session
+
+from funread.legado.manage.source.storage import (
+    SourceListRecord,
+    count_source_items,
+    count_source_payloads,
+    fetch_source_list_data,
+    get_session_factory,
+    utcnow,
+)
+
+router = APIRouter(prefix="/sources", tags=["sources"])
+SourceType = Literal["book", "rss"]
+
+
+class SourceCreate(BaseModel):
+    url: AnyHttpUrl
+    source_type: SourceType | None = None
+
+
+class SourceUpdate(BaseModel):
+    enabled: bool
+
+
+class SourceListRecordOut(BaseModel):
+    id: int
+    url: str
+    source_type: SourceType
+    source_count: int
+    enabled: bool
+    consecutive_failures: int
+    last_error: str | None
+    last_success_at: datetime | None
+    increment_start: int | None
+    increment_stop: int | None
+    last_queried_at: datetime
+    created_at: datetime
+    updated_at: datetime
+
+    model_config = {"from_attributes": True}
+
+
+class SourceListPage(BaseModel):
+    items: list[SourceListRecordOut]
+    total: int
+    limit: int
+    offset: int
+
+
+class CollectReport(BaseModel):
+    source_id: int
+    ok: bool
+    source_count: int
+    error: str | None = None
+
+
+def _get_or_404(session: Session, source_id: int) -> SourceListRecord:
+    record = session.get(SourceListRecord, source_id)
+    if record is None:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="采集源不存在")
+    return record
+
+
+def _download(url: str) -> object:
+    response = requests.get(url, timeout=30)
+    response.raise_for_status()
+    return response.json()
+
+
+def _detect_source_type(payload: object) -> SourceType | None:
+    if isinstance(payload, list):
+        items = payload
+    elif isinstance(payload, dict):
+        items = next(
+            (payload[key] for key in ("list", "data") if isinstance(payload.get(key), list)),
+            [payload],
+        )
+    else:
+        return None
+
+    for item in items:
+        if not isinstance(item, dict):
+            continue
+        if "bookSourceUrl" in item or "bookSourceName" in item:
+            return "book"
+        if "sourceUrl" in item or "sourceName" in item:
+            return "rss"
+    return None
+
+
+@router.get("/supported", response_model=list[SourceType])
+def list_supported() -> list[SourceType]:
+    return ["book", "rss"]
+
+
+@router.post("", response_model=SourceListRecordOut, status_code=status.HTTP_201_CREATED)
+def create_source(payload: SourceCreate) -> SourceListRecordOut:
+    url = str(payload.url)
+    session_factory = get_session_factory()
+    with session_factory() as session:
+        existing = session.scalar(select(SourceListRecord).where(SourceListRecord.url == url))
+        if existing is not None:
+            raise HTTPException(
+                status_code=status.HTTP_409_CONFLICT,
+                detail=f"采集源已存在（id={existing.id}）",
+            )
+
+        try:
+            source_data = _download(url)
+        except Exception as exc:
+            raise HTTPException(
+                status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+                detail=f"无法读取采集源：{exc}",
+            ) from exc
+
+        detected = _detect_source_type(source_data)
+        source_type = payload.source_type or detected
+        if source_type is None:
+            raise HTTPException(
+                status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+                detail="无法识别采集源类型，请选择书源或 RSS 源",
+            )
+        if (
+            detected is not None
+            and payload.source_type is not None
+            and detected != payload.source_type
+        ):
+            raise HTTPException(
+                status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+                detail=f"采集源内容识别为 {detected}，与所选类型 {payload.source_type} 不一致",
+            )
+
+        now = utcnow()
+        record = SourceListRecord(
+            url=url,
+            source_type=source_type,
+            source_count=count_source_items(source_data),
+            last_queried_at=now,
+            last_success_at=now,
+        )
+        session.add(record)
+        session.commit()
+        session.refresh(record)
+        return SourceListRecordOut.model_validate(record)
+
+
+@router.get("", response_model=SourceListPage)
+def list_sources(
+    limit: int = Query(default=50, ge=1, le=500),
+    offset: int = Query(default=0, ge=0),
+    source_type: SourceType | None = None,
+    enabled: bool | None = None,
+    keyword: str | None = Query(default=None, min_length=1, max_length=255),
+) -> SourceListPage:
+    session_factory = get_session_factory()
+    with session_factory() as session:
+        filters = []
+        if source_type is not None:
+            filters.append(SourceListRecord.source_type == source_type)
+        if enabled is not None:
+            filters.append(SourceListRecord.enabled.is_(enabled))
+        if keyword is not None:
+            filters.append(SourceListRecord.url.contains(keyword))
+        total = session.execute(
+            select(func.count()).select_from(SourceListRecord).where(*filters)
+        ).scalar_one()
+        rows = (
+            session.execute(
+                select(SourceListRecord)
+                .where(*filters)
+                .order_by(SourceListRecord.id.desc())
+                .offset(offset)
+                .limit(limit)
+            )
+            .scalars()
+            .all()
+        )
+        items = [SourceListRecordOut.model_validate(row) for row in rows]
+    return SourceListPage(items=items, total=total, limit=limit, offset=offset)
+
+
+@router.patch("/{source_id}", response_model=SourceListRecordOut)
+def update_source(source_id: int, payload: SourceUpdate) -> SourceListRecordOut:
+    session_factory = get_session_factory()
+    with session_factory() as session:
+        record = _get_or_404(session, source_id)
+        record.enabled = payload.enabled
+        session.commit()
+        session.refresh(record)
+        return SourceListRecordOut.model_validate(record)
+
+
+@router.delete("/{source_id}", status_code=status.HTTP_204_NO_CONTENT, response_model=None)
+def delete_source(source_id: int) -> None:
+    session_factory = get_session_factory()
+    with session_factory() as session:
+        session.delete(_get_or_404(session, source_id))
+        session.commit()
+
+
+@router.post(
+    "/{source_id}/reset-cursor",
+    status_code=status.HTTP_204_NO_CONTENT,
+    response_model=None,
+)
+def reset_source_cursor(source_id: int) -> None:
+    session_factory = get_session_factory()
+    with session_factory() as session:
+        record = _get_or_404(session, source_id)
+        record.last_queried_at = datetime(2000, 1, 1)
+        record.consecutive_failures = 0
+        record.last_error = None
+        session.commit()
+
+
+@router.post("/{source_id}/collect", response_model=CollectReport)
+def collect_source(source_id: int) -> CollectReport:
+    session_factory = get_session_factory()
+    with session_factory() as session:
+        record = _get_or_404(session, source_id)
+        record.last_queried_at = utcnow()
+        try:
+            record.source_count = count_source_payloads(fetch_source_list_data(record))
+            record.last_success_at = record.last_queried_at
+            record.consecutive_failures = 0
+            record.last_error = None
+            report = CollectReport(source_id=record.id, ok=True, source_count=record.source_count)
+        except Exception as exc:
+            record.consecutive_failures += 1
+            record.last_error = str(exc)[:2048]
+            report = CollectReport(
+                source_id=record.id,
+                ok=False,
+                source_count=record.source_count,
+                error=record.last_error,
+            )
+        session.commit()
+        return report

funread_api-0.1.1.dist-info/METADATA

@@ -0,0 +1,31 @@
+Metadata-Version: 2.5
+Name: funread-api
+Version: 0.1.1
+Summary: funread 采集源管理后端服务
+Project-URL: Organization, https://github.com/farfarfun
+Project-URL: Repository, https://github.com/farfarfun/funread-api
+Project-URL: Releases, https://github.com/farfarfun/funread-api/releases
+Author-email: 牛哥 <niuliangtao@qq.com>, farfarfun <farfarfun@qq.com>
+Maintainer-email: 牛哥 <niuliangtao@qq.com>, farfarfun <farfarfun@qq.com>
+License-Expression: MIT
+Requires-Python: >=3.12
+Requires-Dist: fastapi>=0.110.0
+Requires-Dist: funread>=1.1.101
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: requests>=2.28.0
+Requires-Dist: sqlalchemy>=2.0.0
+Requires-Dist: uvicorn[standard]>=0.27.0
+Provides-Extra: dev
+Requires-Dist: httpx>=0.27.0; extra == 'dev'
+Requires-Dist: pytest-cov>=4.0.0; extra == 'dev'
+Requires-Dist: pytest>=7.0.0; extra == 'dev'
+Requires-Dist: ruff>=0.1.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# funread-api
+
+`funread` 的后端服务，依赖 [funread](https://github.com/farfarfun/funread) 核心库并对外暴露 API，供
+[funread-web](https://github.com/farfarfun/funread-web) 调用。搭配使用见
+[funread-dev](https://github.com/farfarfun/funread-dev)。
+
+目前处于开发初期，具体接口、部署方式与配置项尚未确定。

funread_api-0.1.1.dist-info/RECORD

@@ -0,0 +1,8 @@
+funread_api/__init__.py,sha256=3kKTNSSYl8RscdaiyGalWr5UsMCPknoBWx-TUKCY8_M,66
+funread_api/app.py,sha256=fRXSJMRhBuWjTBPlz-ZBv5hxd200sW6Z4ySt9d54aTI,1103
+funread_api/v1/__init__.py,sha256=EXuUv3Jd-eBpz3saxorqoK6OuE7L4qd5o5-j-xAqYSY,171
+funread_api/v1/sources.py,sha256=ZMaAZ9EqlBlSu3Mf3YDm8iJZczakhRxPhfmMJc6HynI,8055
+funread_api-0.1.1.dist-info/METADATA,sha256=esQIt45AIBvdIWnGVNuLqrdPmLwr1z97ghUtoVKLOBA,1291
+funread_api-0.1.1.dist-info/WHEEL,sha256=6zicbvgMWfHSD_sSydPAPL1UNY8-QHIQA4J8fOxyAc8,87
+funread_api-0.1.1.dist-info/entry_points.txt,sha256=4LXfMRMLiiEFeQXa8myro44--DQ36pSbvt4FUcQtmpk,52
+funread_api-0.1.1.dist-info/RECORD,,

funread_api-0.1.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.1
+Root-Is-Purelib: true
+Tag: py3-none-any

funread_api-0.1.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+funread-api = funread_api.app:run