moviefinder-cli 0.1.0__py3-none-any.whl

moviefinder_cli/__init__.py

@@ -0,0 +1,5 @@
+"""MovieFinder package."""
+
+__all__ = ["__version__"]
+
+__version__ = "0.1.0"

moviefinder_cli/__main__.py

@@ -0,0 +1,5 @@
+from .cli import main
+
+
+if __name__ == "__main__":
+    main()

moviefinder_cli/cache.py

@@ -0,0 +1,125 @@
+import json
+import sqlite3
+import time
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple
+
+
+class SqliteCache:
+    def __init__(self, db_path: str = "data/moviefinder.sqlite3") -> None:
+        self.db_path = Path(db_path)
+        self.db_path.parent.mkdir(parents=True, exist_ok=True)
+        self._ensure_schema()
+
+    def _connect(self) -> sqlite3.Connection:
+        connection = sqlite3.connect(str(self.db_path))
+        connection.row_factory = sqlite3.Row
+        return connection
+
+    def _ensure_schema(self) -> None:
+        with self._connect() as connection:
+            connection.execute(
+                """
+                CREATE TABLE IF NOT EXISTS cache_entries (
+                    namespace TEXT NOT NULL,
+                    cache_key TEXT NOT NULL,
+                    payload TEXT NOT NULL,
+                    created_at REAL NOT NULL,
+                    expires_at REAL NOT NULL,
+                    PRIMARY KEY (namespace, cache_key)
+                )
+                """
+            )
+            connection.execute(
+                """
+                CREATE INDEX IF NOT EXISTS idx_cache_entries_expires_at
+                ON cache_entries(expires_at)
+                """
+            )
+
+    def get_json(self, namespace: str, cache_key: str) -> Tuple[Optional[Any], bool]:
+        payload, hit, _expired = self.get_json_with_meta(namespace, cache_key)
+        return payload, hit
+
+    def get_json_with_meta(
+        self, namespace: str, cache_key: str, allow_expired: bool = False
+    ) -> Tuple[Optional[Any], bool, bool]:
+        now = time.time()
+        with self._connect() as connection:
+            row = connection.execute(
+                """
+                SELECT payload, expires_at
+                FROM cache_entries
+                WHERE namespace = ? AND cache_key = ?
+                """,
+                (namespace, cache_key),
+            ).fetchone()
+            if row is None:
+                return None, False, False
+            expired = float(row["expires_at"]) < now
+            if expired and not allow_expired:
+                return None, False, True
+            return json.loads(row["payload"]), True, expired
+
+    def set_json(
+        self, namespace: str, cache_key: str, value: Any, ttl_seconds: int
+    ) -> None:
+        now = time.time()
+        with self._connect() as connection:
+            connection.execute(
+                """
+                INSERT INTO cache_entries
+                    (namespace, cache_key, payload, created_at, expires_at)
+                VALUES (?, ?, ?, ?, ?)
+                ON CONFLICT(namespace, cache_key) DO UPDATE SET
+                    payload = excluded.payload,
+                    created_at = excluded.created_at,
+                    expires_at = excluded.expires_at
+                """,
+                (
+                    namespace,
+                    cache_key,
+                    json.dumps(value, ensure_ascii=False),
+                    now,
+                    now + ttl_seconds,
+                ),
+            )
+
+    def iter_json(
+        self, namespace: str, allow_expired: bool = False
+    ) -> List[Tuple[str, Any, bool]]:
+        now = time.time()
+        with self._connect() as connection:
+            rows = connection.execute(
+                """
+                SELECT cache_key, payload, expires_at
+                FROM cache_entries
+                WHERE namespace = ?
+                ORDER BY created_at DESC
+                """,
+                (namespace,),
+            ).fetchall()
+
+        entries: List[Tuple[str, Any, bool]] = []
+        for row in rows:
+            expired = float(row["expires_at"]) < now
+            if expired and not allow_expired:
+                continue
+            entries.append((str(row["cache_key"]), json.loads(row["payload"]), expired))
+        return entries
+
+    def clear(self) -> None:
+        with self._connect() as connection:
+            connection.execute("DELETE FROM cache_entries")
+
+    def stats(self) -> Dict[str, int]:
+        with self._connect() as connection:
+            rows = connection.execute(
+                """
+                SELECT namespace, COUNT(*) AS count
+                FROM cache_entries
+                GROUP BY namespace
+                ORDER BY namespace
+                """
+            ).fetchall()
+        return {str(row["namespace"]): int(row["count"]) for row in rows}

moviefinder_cli/cli.py

@@ -0,0 +1,82 @@
+import argparse
+import json
+import sys
+from typing import Any, Dict
+
+from .markdown import (
+    render_cache_stats_markdown,
+    render_error_markdown,
+    render_search_markdown,
+)
+from .server import run_server
+from .service import MovieFinderService
+
+
+def _add_output_format(parser: argparse.ArgumentParser) -> None:
+    parser.add_argument(
+        "--format",
+        choices=("markdown", "json"),
+        default="markdown",
+        help="Output format. Defaults to markdown.",
+    )
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(prog="moviefinder")
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    search_parser = subparsers.add_parser("search", help="Search rrdynb resources")
+    search_parser.add_argument("keyword")
+    search_parser.add_argument("--limit", type=int, default=10)
+    search_parser.add_argument("--refresh", action="store_true")
+    _add_output_format(search_parser)
+
+    cache_parser = subparsers.add_parser(
+        "cache-stats", help="Show SQLite cache entry counts"
+    )
+    _add_output_format(cache_parser)
+
+    serve_parser = subparsers.add_parser("serve", help="Start HTTP API")
+    serve_parser.add_argument("--host", default="127.0.0.1")
+    serve_parser.add_argument("--port", type=int, default=8000)
+
+    args = parser.parse_args()
+
+    if args.command == "serve":
+        run_server(args.host, args.port)
+        return
+
+    try:
+        service = MovieFinderService()
+        if args.command == "search":
+            payload = service.search_movies(args.keyword, args.limit, args.refresh)
+        elif args.command == "cache-stats":
+            payload = {"cache": service.cache_stats()}
+        else:
+            parser.error("unknown command")
+            return
+    except Exception as exc:
+        print(_format_error(str(exc), args.format), file=sys.stderr)
+        raise SystemExit(1)
+
+    print(_format_payload(args.command, payload, args.format))
+
+
+def _format_payload(command: str, payload: Dict[str, Any], output_format: str) -> str:
+    if output_format == "json":
+        return json.dumps(payload, ensure_ascii=False, indent=2)
+    if command == "search":
+        return render_search_markdown(payload)
+    if command == "cache-stats":
+        return render_cache_stats_markdown(payload)
+    return json.dumps(payload, ensure_ascii=False, indent=2)
+
+
+def _format_error(message: str, output_format: str) -> str:
+    if output_format == "json":
+        return json.dumps({"error": message}, ensure_ascii=False, indent=2)
+    return render_error_markdown(message)
+
+
+if __name__ == "__main__":
+    main()

moviefinder_cli/markdown.py

@@ -0,0 +1,129 @@
+from typing import Any, Dict, Iterable, List
+
+
+def render_search_markdown(payload: Dict[str, Any]) -> str:
+    lines: List[str] = []
+    keyword = payload.get("keyword") or ""
+    items = payload.get("items") or []
+    cache = payload.get("cache") or {}
+
+    lines.append(f"# 搜索结果：{_escape_heading(keyword)}")
+    lines.append("")
+    cache_label = "过期缓存兜底" if cache.get("stale") else ("命中" if cache.get("hit") else "未命中")
+    lines.extend(
+        [
+            f"- 来源：{_plain(payload.get('source'))}",
+            f"- 搜索页：{_link(payload.get('source_url'))}",
+            f"- 结果数：{payload.get('total', len(items))}",
+            f"- 缓存：{cache_label}",
+        ]
+    )
+    if cache.get("warning"):
+        lines.append(f"- 警告：{_plain(cache.get('warning'))}")
+
+    errors = payload.get("errors") or []
+    if errors:
+        lines.append(f"- 详情解析错误：{len(errors)} 条")
+
+    if not items:
+        lines.append("")
+        lines.append("没有搜索到结果。")
+        return "\n".join(lines)
+
+    for index, item in enumerate(items, start=1):
+        lines.append("")
+        lines.append(f"## {index}. {_escape_heading(item.get('title') or '未命名影片')}")
+        lines.append("")
+        lines.extend(
+            _table(
+                ["字段", "值"],
+                [
+                    ("分类", item.get("category")),
+                    ("发布日期", item.get("published_at")),
+                    ("豆瓣评分", item.get("douban_score")),
+                    ("IMDB 评分", item.get("imdb_score")),
+                    ("IMDb ID", item.get("imdb_id")),
+                    ("详情页", _link(item.get("detail_url"))),
+                    ("海报", _link(item.get("poster_url"))),
+                ],
+            )
+        )
+
+        summary = item.get("summary")
+        if summary:
+            lines.append("")
+            lines.append("### 简介")
+            lines.append("")
+            lines.append(_paragraph(summary))
+
+        resources = item.get("resources") or []
+        lines.append("")
+        lines.append("### 网盘资源")
+        lines.append("")
+        if resources:
+            rows = []
+            for resource in resources:
+                rows.append(
+                    (
+                        resource.get("platform"),
+                        _link(resource.get("url")),
+                        resource.get("access_code"),
+                        resource.get("url_password"),
+                    )
+                )
+            lines.extend(_table(["平台", "地址", "提取码", "URL 密码"], rows))
+        else:
+            lines.append("未解析到网盘资源。")
+
+    return "\n".join(lines)
+
+
+def render_cache_stats_markdown(payload: Dict[str, Any]) -> str:
+    cache = payload.get("cache") or {}
+    lines = ["# 缓存统计", ""]
+    if not cache:
+        lines.append("暂无缓存记录。")
+        return "\n".join(lines)
+    rows = [(namespace, count) for namespace, count in sorted(cache.items())]
+    lines.extend(_table(["命名空间", "数量"], rows))
+    return "\n".join(lines)
+
+
+def render_error_markdown(message: str) -> str:
+    return "\n".join(["# 错误", "", _paragraph(message)])
+
+
+def _table(headers: List[str], rows: Iterable[Iterable[Any]]) -> List[str]:
+    table = [
+        "| " + " | ".join(_cell(header) for header in headers) + " |",
+        "| " + " | ".join("---" for _ in headers) + " |",
+    ]
+    for row in rows:
+        table.append("| " + " | ".join(_cell(value) for value in row) + " |")
+    return table
+
+
+def _cell(value: Any) -> str:
+    text = _plain(value)
+    return text.replace("|", "\\|").replace("\n", "<br>")
+
+
+def _plain(value: Any) -> str:
+    if value is None or value == "":
+        return "-"
+    return str(value).strip()
+
+
+def _paragraph(value: Any) -> str:
+    return " ".join(_plain(value).split())
+
+
+def _escape_heading(value: Any) -> str:
+    return _plain(value).replace("#", "\\#").strip()
+
+
+def _link(url: Any) -> str:
+    value = _plain(url)
+    if value == "-":
+        return "-"
+    return f"[打开]({value})"

moviefinder_cli/mcp/__init__.py

@@ -0,0 +1 @@
+"""MovieFinder MCP integration."""

moviefinder_cli/mcp/server.py

@@ -0,0 +1,143 @@
+"""MovieFinder MCP server.
+
+The server exposes rrdynb movie search to Agent clients through MCP.
+"""
+
+import argparse
+import json
+import logging
+import os
+
+from fastmcp import FastMCP
+
+from moviefinder_cli import __version__
+from moviefinder_cli.markdown import (
+    render_cache_stats_markdown,
+    render_search_markdown,
+)
+from moviefinder_cli.service import MovieFinderService
+
+
+mcp = FastMCP(
+    name="moviefinder",
+    instructions="""MovieFinder MCP - Search movie resources from rrdynb.
+
+Tools available:
+- search_movies(query, limit=5, refresh=False, output_format="markdown"): Search movies and return synopsis, ratings, detail URLs, and cloud-drive resource links.
+- movie_cache_stats(output_format="markdown"): Show local SQLite cache counts.
+
+Recommended workflow:
+1. Use search_movies() with a specific movie or TV title.
+2. Read the Markdown output and choose the most relevant result by title/year.
+3. Use the returned detail URL and cloud-drive links as source references.
+
+Notes:
+- MovieFinder only reads public pages and does not download media files.
+- If the live search page is blocked temporarily, cached results may be returned with a warning.
+""",
+)
+
+logger = logging.getLogger("moviefinder_cli.mcp")
+
+
+@mcp.tool()
+def search_movies(
+    query: str,
+    limit: int = 5,
+    refresh: bool = False,
+    output_format: str = "markdown",
+) -> str:
+    """Search movie resources by keyword.
+
+    Args:
+        query: Movie, TV, anime, actor, or title keyword.
+        limit: Maximum number of results to return. Values above 50 are capped.
+        refresh: Force live refresh instead of using fresh cache.
+        output_format: "markdown" or "json".
+
+    Returns:
+        Search results containing synopsis, Douban/IMDB ratings, and cloud-drive links.
+    """
+    try:
+        payload = MovieFinderService().search_movies(query, limit, refresh)
+    except Exception as exc:
+        return _format_error(exc, output_format)
+
+    if output_format == "json":
+        return json.dumps(payload, ensure_ascii=False, indent=2)
+    return render_search_markdown(payload)
+
+
+@mcp.tool()
+def movie_cache_stats(output_format: str = "markdown") -> str:
+    """Return local MovieFinder cache statistics.
+
+    Args:
+        output_format: "markdown" or "json".
+
+    Returns:
+        Cache entry counts grouped by namespace.
+    """
+    payload = {"cache": MovieFinderService().cache_stats()}
+    if output_format == "json":
+        return json.dumps(payload, ensure_ascii=False, indent=2)
+    return render_cache_stats_markdown(payload)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description="MovieFinder MCP Server",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    parser.add_argument(
+        "--transport",
+        "-t",
+        choices=["stdio", "sse"],
+        default=os.environ.get("MOVIEFINDER_MCP_TRANSPORT", "stdio"),
+        help="Transport protocol (default: stdio)",
+    )
+    parser.add_argument(
+        "--host",
+        "-H",
+        default=os.environ.get("MOVIEFINDER_MCP_HOST", "127.0.0.1"),
+        help="Host to bind for SSE (default: 127.0.0.1)",
+    )
+    parser.add_argument(
+        "--port",
+        "-p",
+        type=int,
+        default=int(os.environ.get("MOVIEFINDER_MCP_PORT", "8000")),
+        help="Port for SSE transport (default: 8000)",
+    )
+    parser.add_argument(
+        "--debug",
+        action="store_true",
+        default=os.environ.get("MOVIEFINDER_MCP_DEBUG", "").lower() == "true",
+        help="Enable debug logging",
+    )
+
+    args = parser.parse_args()
+
+    if args.debug:
+        logging.basicConfig(
+            level=logging.DEBUG,
+            format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+        )
+        logger.setLevel(logging.DEBUG)
+        logger.debug("Starting MovieFinder MCP v%s", __version__)
+
+    if args.transport == "stdio":
+        mcp.run()
+    else:
+        mcp.run(transport="sse", host=args.host, port=args.port)
+
+
+def _format_error(exc: Exception, output_format: str) -> str:
+    message = str(exc)
+    if output_format == "json":
+        return json.dumps({"error": message}, ensure_ascii=False, indent=2)
+    return f"# 错误\n\n{message}"
+
+
+if __name__ == "__main__":
+    main()

moviefinder_cli/models.py

@@ -0,0 +1,53 @@
+from dataclasses import asdict, dataclass, field
+from typing import Any, Dict, List, Optional
+
+
+@dataclass
+class ResourceLink:
+    platform: str
+    url: str
+    label: str = ""
+    access_code: Optional[str] = None
+    url_password: Optional[str] = None
+
+    def to_dict(self) -> Dict[str, Any]:
+        return asdict(self)
+
+
+@dataclass
+class MovieResult:
+    title: str
+    detail_url: str
+    category: Optional[str] = None
+    published_at: Optional[str] = None
+    summary: Optional[str] = None
+    intro: Optional[str] = None
+    douban_score: Optional[str] = None
+    imdb_score: Optional[str] = None
+    imdb_id: Optional[str] = None
+    poster_url: Optional[str] = None
+    resources: List[ResourceLink] = field(default_factory=list)
+    source: str = "rrdynb"
+
+    def merge_detail(self, detail: "MovieResult") -> "MovieResult":
+        self.title = detail.title or self.title
+        self.published_at = detail.published_at or self.published_at
+        self.summary = detail.summary or self.summary
+        self.intro = detail.intro or self.intro
+        self.imdb_id = detail.imdb_id or self.imdb_id
+        self.poster_url = detail.poster_url or self.poster_url
+        self.resources = detail.resources or self.resources
+        return self
+
+    def to_dict(self) -> Dict[str, Any]:
+        data = asdict(self)
+        data["resources"] = [resource.to_dict() for resource in self.resources]
+        return data
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "MovieResult":
+        payload = dict(data)
+        payload["resources"] = [
+            ResourceLink(**resource) for resource in payload.get("resources", [])
+        ]
+        return cls(**payload)