fix app.env

功能改进增加选择类型

.github/ISSUE_TEMPLATE/feature_request.yml

@@ -14,6 +14,18 @@ body:
       description: 目前使用的程序版本
     validations:
       required: true
+  - type: dropdown
+    id: type
+    attributes:
+      label: 功能改进类型
+      description: 你需要在下面哪个方面改进功能
+      options:
+        - 主程序
+        - 插件
+        - Docker
+        - 其他
+    validations:
+      required: true
   - type: textarea
     id: feature-request
     attributes:

.github/workflows/build.yml

@@ -62,3 +62,5 @@ jobs:
             MOVIEPILOT_VERSION=${{ env.app_version }}
           tags: ${{ steps.meta.outputs.tags }}
           labels: ${{ steps.meta.outputs.labels }}
+          cache-from: type=gha, scope=${{ github.workflow }}
+          cache-to: type=gha, scope=${{ github.workflow }}

Dockerfile

@@ -34,8 +34,7 @@ ENV LANG="C.UTF-8" \
     EMBY_HOST="http://127.0.0.1:8096" \
     EMBY_API_KEY=""
 WORKDIR "/app"
-COPY . .
-RUN apt-get update \
+RUN apt-get update -y \
     && apt-get -y install \
         musl-dev \
         nginx \
@@ -56,26 +55,20 @@ RUN apt-get update \
     elif [ "$(uname -m)" = "aarch64" ]; \
         then ln -s /usr/lib/aarch64-linux-musl/libc.so /lib/libc.musl-aarch64.so.1; \
     fi \
-    && cp -f /app/nginx.conf /etc/nginx/nginx.template.conf \
-    && cp -f /app/update /usr/local/bin/mp_update \
-    && cp -f /app/entrypoint /entrypoint \
-    && chmod +x /entrypoint /usr/local/bin/mp_update \
-    && mkdir -p ${HOME} /var/lib/haproxy/server-state \
-    && groupadd -r moviepilot -g 911 \
-    && useradd -r moviepilot -g moviepilot -d ${HOME} -s /bin/bash -u 911 \
+    && apt-get autoremove -y \
+    && apt-get clean -y \
+    && rm -rf \
+        /tmp/* \
+        /moviepilot/.cache \
+        /var/lib/apt/lists/* \
+        /var/tmp/*
+COPY requirements.txt requirements.txt
+RUN apt-get update -y \
     && apt-get install -y build-essential \
     && pip install --upgrade pip \
     && pip install Cython \
     && pip install -r requirements.txt \
     && playwright install-deps chromium \
-    && python_ver=$(python3 -V | awk '{print $2}') \
-    && echo "/app/" > /usr/local/lib/python${python_ver%.*}/site-packages/app.pth \
-    && echo 'fs.inotify.max_user_watches=5242880' >> /etc/sysctl.conf \
-    && echo 'fs.inotify.max_user_instances=5242880' >> /etc/sysctl.conf \
-    && locale-gen zh_CN.UTF-8 \
-    && FRONTEND_VERSION=$(curl -sL "https://api.github.com/repos/jxxghp/MoviePilot-Frontend/releases/latest" | jq -r .tag_name) \
-    && curl -sL "https://github.com/jxxghp/MoviePilot-Frontend/releases/download/${FRONTEND_VERSION}/dist.zip" | busybox unzip -d / - \
-    && mv /dist /public \
     && apt-get remove -y build-essential \
     && apt-get autoremove -y \
     && apt-get clean -y \
@@ -84,6 +77,22 @@ RUN apt-get update \
         /moviepilot/.cache \
         /var/lib/apt/lists/* \
         /var/tmp/*
+COPY . .
+RUN cp -f /app/nginx.conf /etc/nginx/nginx.template.conf \
+    && cp -f /app/update /usr/local/bin/mp_update \
+    && cp -f /app/entrypoint /entrypoint \
+    && chmod +x /entrypoint /usr/local/bin/mp_update \
+    && mkdir -p ${HOME} /var/lib/haproxy/server-state \
+    && groupadd -r moviepilot -g 911 \
+    && useradd -r moviepilot -g moviepilot -d ${HOME} -s /bin/bash -u 911 \
+    && python_ver=$(python3 -V | awk '{print $2}') \
+    && echo "/app/" > /usr/local/lib/python${python_ver%.*}/site-packages/app.pth \
+    && echo 'fs.inotify.max_user_watches=5242880' >> /etc/sysctl.conf \
+    && echo 'fs.inotify.max_user_instances=5242880' >> /etc/sysctl.conf \
+    && locale-gen zh_CN.UTF-8 \
+    && FRONTEND_VERSION=$(curl -sL "https://api.github.com/repos/jxxghp/MoviePilot-Frontend/releases/latest" | jq -r .tag_name) \
+    && curl -sL "https://github.com/jxxghp/MoviePilot-Frontend/releases/download/${FRONTEND_VERSION}/dist.zip" | busybox unzip -d / - \
+    && mv /dist /public
 EXPOSE 3000
 VOLUME [ "/config" ]
 ENTRYPOINT [ "/entrypoint" ]

README.md

@@ -41,9 +41,11 @@ docker pull jxxghp/moviepilot:latest
 
 ## 配置
 
-项目的所有配置均通过环境变量进行设置，部分环境建立容器后会自动显示待配置项，如未自动显示配置项则需要手动增加对应环境变量。
+项目的所有配置均通过环境变量进行设置，支持两种配置方式：
+1. 在docker环境变量部分进行参数配置，部分环境建立容器后会自动显示待配置项，如未自动显示配置项则需要手动增加对应环境变量。
+2. 下载 [app.env](https://github.com/jxxghp/MoviePilot/raw/main/config/app.env) 文件，修改好配置后放置到配置文件映射路径根目录，配置项可根据说明自主增减。
 
-配置文件映射路径：`/config`
+配置文件映射路径：`/config`，配置项生效优先级：环境变量 > env文件 > 默认值，部分参数如路径映射、站点认证等必须通过环境变量进行配置。
 
 ### 1. **基础设置**
 
@@ -63,7 +65,7 @@ docker pull jxxghp/moviepilot:latest
 - **DOWNLOAD_MOVIE_PATH：** 电影下载保存目录，不设置则下载到`DOWNLOAD_PATH`
 - **DOWNLOAD_TV_PATH：** 电视剧下载保存目录，不设置则下载到`DOWNLOAD_PATH`
 - **DOWNLOAD_ANIME_PATH：** 动漫下载保存目录，不设置则下载到`DOWNLOAD_PATH`
-- **DOWNLOAD_CATEGORY：** 下载二级分类开关，`true`/`false`，默认`false`，开启后会根据配置`category.yaml`自动在下载目录下建立二级目录分类
+- **DOWNLOAD_CATEGORY：** 下载二级分类开关，`true`/`false`，默认`false`，开启后会根据配置 [category.yaml](https://github.com/jxxghp/MoviePilot/raw/main/config/category.yaml) 自动在下载目录下建立二级目录分类
 - **DOWNLOAD_SUBTITLE：** 下载站点字幕，`true`/`false`，默认`true`
 - **REFRESH_MEDIASERVER：** 入库刷新媒体库，`true`/`false`，默认`true`
 - **SCRAP_METADATA：** 刮削入库的媒体文件，`true`/`false`，默认`true`
@@ -73,7 +75,7 @@ docker pull jxxghp/moviepilot:latest
 - **LIBRARY_MOVIE_NAME：** 电影媒体库目录名，默认`电影`
 - **LIBRARY_TV_NAME：** 电视剧媒体库目录名，默认`电视剧`
 - **LIBRARY_ANIME_NAME：** 动漫媒体库目录名，默认`电视剧/动漫`
-- **LIBRARY_CATEGORY：** 媒体库二级分类开关，`true`/`false`，默认`false`，开启后会根据配置`category.yaml`自动在媒体库目录下建立二级目录分类
+- **LIBRARY_CATEGORY：** 媒体库二级分类开关，`true`/`false`，默认`false`，开启后会根据配置 [category.yaml](https://github.com/jxxghp/MoviePilot/raw/main/config/category.yaml) 自动在媒体库目录下建立二级目录分类
 - **TRANSFER_TYPE：** 转移方式，支持`link`/`copy`/`move`/`softlink`  **注意：在`link`和`softlink`转移方式下，转移后的文件会继承源文件的权限掩码，不受`UMASK`影响**
 - **COOKIECLOUD_HOST：** CookieCloud服务器地址，格式：`http(s)://ip:port`，不配置默认使用内建服务器`https://movie-pilot.org/cookiecloud`
 - **COOKIECLOUD_KEY：** CookieCloud用户KEY
@@ -156,9 +158,9 @@ docker pull jxxghp/moviepilot:latest
 
 ### 2. **用户认证**
 
-- **AUTH_SITE：** 认证站点，支持`iyuu`/`hhclub`/`audiences`/`hddolby`/`zmpt`/`freefarm`/`hdfans`/`wintersakura`/`leaves`/`1ptba`/`icc2022`/`ptlsp`
+`MoviePilot`需要认证后才能使用，配置`AUTH_SITE`后，需要根据下表配置对应站点的认证参数（**仅能通过docker环境变量配置**）
 
-`MoviePilot`需要认证后才能使用，配置`AUTH_SITE`后，需要根据下表配置对应站点的认证参数。
+- **AUTH_SITE：** 认证站点，支持`iyuu`/`hhclub`/`audiences`/`hddolby`/`zmpt`/`freefarm`/`hdfans`/`wintersakura`/`leaves`/`1ptba`/`icc2022`/`ptlsp`/`xingtan`
 
 |      站点      |                          参数                           |
 |:------------:|:-----------------------------------------------------:|
@@ -174,6 +176,7 @@ docker pull jxxghp/moviepilot:latest
 |    1ptba     |        `1PTBA_UID`：用户ID<br/>`1PTBA_PASSKEY`：密钥        |
 |   icc2022    |      `ICC2022_UID`：用户ID<br/>`ICC2022_PASSKEY`：密钥      |
 |    ptlsp     |        `PTLSP_UID`：用户ID<br/>`PTLSP_PASSKEY`：密钥        |
+|   xingtan    |      `XINGTAN_UID`：用户ID<br/>`XINGTAN_PASSKEY`：密钥      |
 
 
 ### 2. **进阶配置**

app/api/endpoints/dashboard.py

@@ -2,7 +2,7 @@ from pathlib import Path
 from typing import Any, List, Optional
 
 from fastapi import APIRouter, Depends
-from requests import Session
+from sqlalchemy.orm import Session
 
 from app import schemas
 from app.chain.dashboard import DashboardChain

app/api/endpoints/filebrowser.py

@@ -16,10 +16,16 @@ router = APIRouter()
 IMAGE_TYPES = [".jpg", ".png", ".gif", ".bmp", ".jpeg", ".webp"]
 
 
-@router.get("/list", summary="所有插件", response_model=List[schemas.FileItem])
-def list_path(path: str, sort: str = 'time', _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+@router.get("/list", summary="所有目录和文件", response_model=List[schemas.FileItem])
+def list_path(path: str,
+              sort: str = 'time',
+              _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     查询当前目录下所有目录和文件
+    :param path: 目录路径
+    :param sort: 排序方式，name:按名称排序，time:按修改时间排序
+    :param _: token
+    :return: 所有目录和文件
     """
     # 返回结果
     ret_items = []

app/api/endpoints/system.py

@@ -222,5 +222,8 @@ def execute_command(jobid: str,
     """
     if not jobid:
         return schemas.Response(success=False, message="命令不能为空！")
-    Scheduler().start(jobid)
-    return schemas.Response(success=True)
+    if jobid == "subscribe_search":
+        Scheduler().start(jobid, state = 'R')
+    else:
+        Scheduler().start(jobid)
+    return schemas.Response(success=True)

app/api/servarr.py

@@ -1,7 +1,7 @@
 from typing import Any, List
 
 from fastapi import APIRouter, HTTPException, Depends
-from requests import Session
+from sqlalchemy.orm import Session
 
 from app import schemas
 from app.chain.media import MediaChain

app/chain/__init__.py

@@ -115,6 +115,17 @@ class ChainBase(metaclass=ABCMeta):
         """
         return self.run_module("recognize_media", meta=meta, mtype=mtype, tmdbid=tmdbid)
 
+    def match_doubaninfo(self, name: str, mtype: str = None,
+                         year: str = None, season: int = None) -> Optional[dict]:
+        """
+        搜索和匹配豆瓣信息
+        :param name: 标题
+        :param mtype: 类型
+        :param year: 年份
+        :param season: 季
+        """
+        return self.run_module("match_doubaninfo", name=name, mtype=mtype, year=year, season=season)
+
     def obtain_images(self, mediainfo: MediaInfo) -> Optional[MediaInfo]:
         """
         补充抓取媒体信息图片
@@ -197,21 +208,19 @@ class ChainBase(metaclass=ABCMeta):
         return self.run_module("search_medias", meta=meta)
 
     def search_torrents(self, site: CommentedMap,
-                        mediainfo: MediaInfo,
-                        keyword: str = None,
-                        page: int = 0,
-                        area: str = "title") -> List[TorrentInfo]:
+                        keywords: List[str],
+                        mtype: MediaType = None,
+                        page: int = 0) -> List[TorrentInfo]:
         """
         搜索一个站点的种子资源
         :param site:  站点
-        :param mediainfo:  识别的媒体信息
-        :param keyword:  搜索关键词，如有按关键词搜索，否则按媒体信息名称搜索
+        :param keywords:  搜索关键词列表
+        :param mtype:  媒体类型
         :param page:  页码
-        :param area:  搜索区域
         :reutrn: 资源列表
         """
-        return self.run_module("search_torrents", mediainfo=mediainfo, site=site,
-                               keyword=keyword, page=page, area=area)
+        return self.run_module("search_torrents", site=site, keywords=keywords,
+                               mtype=mtype, page=page)
 
     def refresh_torrents(self, site: CommentedMap) -> List[TorrentInfo]:
         """

app/chain/mediaserver.py

@@ -28,12 +28,18 @@ class MediaServerChain(ChainBase):
         """
         return self.run_module("mediaserver_librarys", server=server)
 
-    def items(self, server: str, library_id: Union[str, int]) -> Generator:
+    def items(self, server: str, library_id: Union[str, int]) -> List[schemas.MediaServerItem]:
         """
         获取媒体服务器所有项目
         """
         return self.run_module("mediaserver_items", server=server, library_id=library_id)
 
+    def iteminfo(self, server: str, item_id: Union[str, int]) -> schemas.MediaServerItem:
+        """
+        获取媒体服务器项目信息
+        """
+        return self.run_module("mediaserver_iteminfo", server=server, item_id=item_id)
+
     def episodes(self, server: str, item_id: Union[str, int]) -> List[schemas.MediaServerSeasonInfo]:
         """
         获取媒体服务器剧集信息

app/chain/search.py

@@ -62,7 +62,7 @@ class SearchChain(ChainBase):
         else:
             logger.info(f'开始浏览资源，站点：{site} ...')
         # 搜索
-        return self.__search_all_sites(keyword=title, sites=[site] if site else None, page=page) or []
+        return self.__search_all_sites(keywords=[title], sites=[site] if site else None, page=page) or []
 
     def last_search_results(self) -> List[Context]:
         """
@@ -117,16 +117,12 @@ class SearchChain(ChainBase):
         else:
             keywords = [mediainfo.title]
         # 执行搜索
-        torrents: List[TorrentInfo] = []
-        for keyword in keywords:
-            torrents = self.__search_all_sites(
-                mediainfo=mediainfo,
-                keyword=keyword,
-                sites=sites,
-                area=area
-            )
-            if torrents:
-                break
+        torrents: List[TorrentInfo] = self.__search_all_sites(
+            mediainfo=mediainfo,
+            keywords=keywords,
+            sites=sites,
+            area=area
+        )
         if not torrents:
             logger.warn(f'{keyword or mediainfo.title} 未搜索到资源')
             return []
@@ -241,15 +237,15 @@ class SearchChain(ChainBase):
         # 返回
         return contexts
 
-    def __search_all_sites(self, mediainfo: Optional[MediaInfo] = None,
-                           keyword: str = None,
+    def __search_all_sites(self, keywords: List[str],
+                           mediainfo: Optional[MediaInfo] = None,
                            sites: List[int] = None,
                            page: int = 0,
                            area: str = "title") -> Optional[List[TorrentInfo]]:
         """
         多线程搜索多个站点
         :param mediainfo:  识别的媒体信息
-        :param keyword:  搜索关键词，如有按关键词搜索，否则按媒体信息名称搜索
+        :param keywords:  搜索关键词列表
         :param sites:  指定站点ID列表，如有则只搜索指定站点，否则搜索所有站点
         :param page:  搜索页码
         :param area:  搜索区域 title or imdbid
@@ -291,8 +287,18 @@ class SearchChain(ChainBase):
         executor = ThreadPoolExecutor(max_workers=len(indexer_sites))
         all_task = []
         for site in indexer_sites:
-            task = executor.submit(self.search_torrents, mediainfo=mediainfo,
-                                   site=site, keyword=keyword, page=page, area=area)
+            if area == "imdbid":
+                # 搜索IMDBID
+                task = executor.submit(self.search_torrents, site=site,
+                                       keywords=[mediainfo.imdb_id] if mediainfo else None,
+                                       mtype=mediainfo.type if mediainfo else None,
+                                       page=page)
+            else:
+                # 搜索标题
+                task = executor.submit(self.search_torrents, site=site,
+                                       keywords=keywords,
+                                       mtype=mediainfo.type if mediainfo else None,
+                                       page=page)
             all_task.append(task)
         # 结果集
         results = []
@@ -303,7 +309,7 @@ class SearchChain(ChainBase):
                 results.extend(result)
             logger.info(f"站点搜索进度：{finish_count} / {total_num}")
             self.progress.update(value=finish_count / total_num * 100,
-                                 text=f"正在搜索{keyword or ''}，已完成 {finish_count} / {total_num} 个站点 ...",
+                                 text=f"正在搜索{keywords or ''}，已完成 {finish_count} / {total_num} 个站点 ...",
                                  key=ProgressKey.Search)
         # 计算耗时
         end_time = datetime.now()

app/chain/subscribe.py

@@ -3,7 +3,7 @@ import re
 from datetime import datetime
 from typing import Dict, List, Optional, Union, Tuple
 
-from requests import Session
+from sqlalchemy.orm import Session
 
 from app.chain import ChainBase
 from app.chain.download import DownloadChain

app/chain/tmdb.py

@@ -5,6 +5,7 @@ from cachetools import cached, TTLCache
 
 from app import schemas
 from app.chain import ChainBase
+from app.core.config import settings
 from app.schemas import MediaType
 from app.utils.singleton import Singleton
 
@@ -122,5 +123,5 @@ class TmdbChain(ChainBase, metaclass=Singleton):
             while True:
                 info = random.choice(infos)
                 if info and info.get("backdrop_path"):
-                    return f"https://image.tmdb.org/t/p/original{info.get('backdrop_path')}"
+                    return f"https://{settings.TMDB_IMAGE_DOMAIN}/t/p/original{info.get('backdrop_path')}"
         return None

app/chain/transfer.py

@@ -622,8 +622,9 @@ class TransferChain(ChainBase):
         if not path.exists():
             return
         if path.is_file():
-            # 删除文件、nfo、jpg
-            files = glob.glob(f"{Path(path.parent).joinpath(path.stem)}*")
+            # 删除文件、nfo、jpg等同名文件
+            pattern = path.stem.replace('[', '?').replace(']', '?')
+            files = path.parent.glob(f"{pattern}.*")
             for file in files:
                 Path(file).unlink()
             logger.warn(f"文件 {path} 已删除")

app/core/config.py

@@ -27,7 +27,7 @@ class Settings(BaseSettings):
     # 是否开发模式
     DEV: bool = False
     # 配置文件目录
-    CONFIG_DIR: str = None
+    CONFIG_DIR: str = "/config"
     # 超级管理员
     SUPERUSER: str = "admin"
     # 超级管理员初始密码
@@ -268,8 +268,8 @@ class Settings(BaseSettings):
             return [Path(path) for path in self.LIBRARY_PATH.split(",")]
         return []
 
-    def __init__(self):
-        super().__init__()
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
         with self.CONFIG_PATH as p:
             if not p.exists():
                 p.mkdir(parents=True, exist_ok=True)
@@ -284,4 +284,7 @@ class Settings(BaseSettings):
         case_sensitive = True
 
 
-settings = Settings()
+settings = Settings(
+    _env_file=Settings().CONFIG_PATH / "app.env",
+    _env_file_encoding="utf-8"
+)

app/modules/douban/__init__.py

@@ -14,7 +14,6 @@ from app.utils.system import SystemUtils
 
 
 class DoubanModule(_ModuleBase):
-
     doubanapi: DoubanApi = None
     scraper: DoubanScraper = None
 
@@ -34,6 +33,271 @@ class DoubanModule(_ModuleBase):
         :param doubanid: 豆瓣ID
         :return: 豆瓣信息
         """
+        """
+        {
+          "rating": {
+            "count": 287365,
+            "max": 10,
+            "star_count": 3.5,
+            "value": 6.6
+          },
+          "lineticket_url": "",
+          "controversy_reason": "",
+          "pubdate": [
+            "2021-10-29(中国大陆)"
+          ],
+          "last_episode_number": null,
+          "interest_control_info": null,
+          "pic": {
+            "large": "https://img9.doubanio.com/view/photo/m_ratio_poster/public/p2707553644.webp",
+            "normal": "https://img9.doubanio.com/view/photo/s_ratio_poster/public/p2707553644.webp"
+          },
+          "vendor_count": 6,
+          "body_bg_color": "f4f5f9",
+          "is_tv": false,
+          "head_info": null,
+          "album_no_interact": false,
+          "ticket_price_info": "",
+          "webisode_count": 0,
+          "year": "2021",
+          "card_subtitle": "2021 / 英国 美国 / 动作 惊悚 冒险 / 凯瑞·福永 / 丹尼尔·克雷格 蕾雅·赛杜",
+          "forum_info": null,
+          "webisode": null,
+          "id": "20276229",
+          "gallery_topic_count": 0,
+          "languages": [
+            "英语",
+            "法语",
+            "意大利语",
+            "俄语",
+            "西班牙语"
+          ],
+          "genres": [
+            "动作",
+            "惊悚",
+            "冒险"
+          ],
+          "review_count": 926,
+          "title": "007：无暇赴死",
+          "intro": "世界局势波诡云谲，再度出山的邦德（丹尼尔·克雷格 饰）面临有史以来空前的危机，传奇特工007的故事在本片中达到高潮。新老角色集结亮相，蕾雅·赛杜回归，二度饰演邦女郎玛德琳。系列最恐怖反派萨芬（拉米·马雷克 饰）重磅登场，毫不留情地展示了自己狠辣的一面，不仅揭开了玛德琳身上隐藏的秘密，还酝酿着危及数百万人性命的阴谋，幽灵党的身影也似乎再次浮出水面。半路杀出的新00号特工（拉什纳·林奇 饰）与神秘女子（安娜·德·阿玛斯 饰）看似与邦德同阵作战，但其真实目的依然成谜。关乎邦德生死的新仇旧怨接踵而至，暗潮汹涌之下他能否拯救世界？",
+          "interest_cmt_earlier_tip_title": "发布于上映前",
+          "has_linewatch": true,
+          "ugc_tabs": [
+            {
+              "source": "reviews",
+              "type": "review",
+              "title": "影评"
+            },
+            {
+              "source": "forum_topics",
+              "type": "forum",
+              "title": "讨论"
+            }
+          ],
+          "forum_topic_count": 857,
+          "ticket_promo_text": "",
+          "webview_info": {},
+          "is_released": true,
+          "actors": [
+            {
+              "name": "丹尼尔·克雷格",
+              "roles": [
+                "演员",
+                "制片人",
+                "配音"
+              ],
+              "title": "丹尼尔·克雷格（同名）英国,英格兰,柴郡,切斯特影视演员",
+              "url": "https://movie.douban.com/celebrity/1025175/",
+              "user": null,
+              "character": "饰 詹姆斯·邦德 James Bond 007",
+              "uri": "douban://douban.com/celebrity/1025175?subject_id=27230907",
+              "avatar": {
+                "large": "https://qnmob3.doubanio.com/view/celebrity/raw/public/p42588.jpg?imageView2/2/q/80/w/600/h/3000/format/webp",
+                "normal": "https://qnmob3.doubanio.com/view/celebrity/raw/public/p42588.jpg?imageView2/2/q/80/w/200/h/300/format/webp"
+              },
+              "sharing_url": "https://www.douban.com/doubanapp/dispatch?uri=/celebrity/1025175/",
+              "type": "celebrity",
+              "id": "1025175",
+              "latin_name": "Daniel Craig"
+            }
+          ],
+          "interest": null,
+          "vendor_icons": [
+            "https://img9.doubanio.com/f/frodo/fbc90f355fc45d5d2056e0d88c697f9414b56b44/pics/vendors/tencent.png",
+            "https://img2.doubanio.com/f/frodo/8286b9b5240f35c7e59e1b1768cd2ccf0467cde5/pics/vendors/migu_video.png",
+            "https://img9.doubanio.com/f/frodo/88a62f5e0cf9981c910e60f4421c3e66aac2c9bc/pics/vendors/bilibili.png"
+          ],
+          "episodes_count": 0,
+          "color_scheme": {
+            "is_dark": true,
+            "primary_color_light": "868ca5",
+            "_base_color": [
+              0.6333333333333333,
+              0.18867924528301885,
+              0.20784313725490197
+            ],
+            "secondary_color": "f4f5f9",
+            "_avg_color": [
+              0.059523809523809625,
+              0.09790209790209795,
+              0.5607843137254902
+            ],
+            "primary_color_dark": "676c7f"
+          },
+          "type": "movie",
+          "null_rating_reason": "",
+          "linewatches": [
+            {
+              "url": "http://v.youku.com/v_show/id_XNTIwMzM2NDg5Mg==.html?tpa=dW5pb25faWQ9MzAwMDA4XzEwMDAwMl8wMl8wMQ&refer=esfhz_operation.xuka.xj_00003036_000000_FNZfau_19010900",
+              "source": {
+                "literal": "youku",
+                "pic": "https://img1.doubanio.com/img/files/file-1432869267.png",
+                "name": "优酷视频"
+              },
+              "source_uri": "youku://play?vid=XNTIwMzM2NDg5Mg==&source=douban&refer=esfhz_operation.xuka.xj_00003036_000000_FNZfau_19010900",
+              "free": false
+            },
+          ],
+          "info_url": "https://www.douban.com/doubanapp//h5/movie/20276229/desc",
+          "tags": [],
+          "durations": [
+            "163分钟"
+          ],
+          "comment_count": 97204,
+          "cover": {
+            "description": "",
+            "author": {
+              "loc": {
+                "id": "108288",
+                "name": "北京",
+                "uid": "beijing"
+              },
+              "kind": "user",
+              "name": "雨落下",
+              "reg_time": "2020-08-11 16:22:48",
+              "url": "https://www.douban.com/people/221011676/",
+              "uri": "douban://douban.com/user/221011676",
+              "id": "221011676",
+              "avatar_side_icon_type": 3,
+              "avatar_side_icon_id": "234",
+              "avatar": "https://img2.doubanio.com/icon/up221011676-2.jpg",
+              "is_club": false,
+              "type": "user",
+              "avatar_side_icon": "https://img2.doubanio.com/view/files/raw/file-1683625971.png",
+              "uid": "221011676"
+            },
+            "url": "https://movie.douban.com/photos/photo/2707553644/",
+            "image": {
+              "large": {
+                "url": "https://img9.doubanio.com/view/photo/l/public/p2707553644.webp",
+                "width": 1082,
+                "height": 1600,
+                "size": 0
+              },
+              "raw": null,
+              "small": {
+                "url": "https://img9.doubanio.com/view/photo/s/public/p2707553644.webp",
+                "width": 405,
+                "height": 600,
+                "size": 0
+              },
+              "normal": {
+                "url": "https://img9.doubanio.com/view/photo/m/public/p2707553644.webp",
+                "width": 405,
+                "height": 600,
+                "size": 0
+              },
+              "is_animated": false
+            },
+            "uri": "douban://douban.com/photo/2707553644",
+            "create_time": "2021-10-26 15:05:01",
+            "position": 0,
+            "owner_uri": "douban://douban.com/movie/20276229",
+            "type": "photo",
+            "id": "2707553644",
+            "sharing_url": "https://www.douban.com/doubanapp/dispatch?uri=/photo/2707553644/"
+          },
+          "cover_url": "https://img9.doubanio.com/view/photo/m_ratio_poster/public/p2707553644.webp",
+          "restrictive_icon_url": "",
+          "header_bg_color": "676c7f",
+          "is_douban_intro": false,
+          "ticket_vendor_icons": [
+            "https://img9.doubanio.com/view/dale-online/dale_ad/public/0589a62f2f2d7c2.jpg"
+          ],
+          "honor_infos": [],
+          "sharing_url": "https://movie.douban.com/subject/20276229/",
+          "subject_collections": [],
+          "wechat_timeline_share": "screenshot",
+          "countries": [
+            "英国",
+            "美国"
+          ],
+          "url": "https://movie.douban.com/subject/20276229/",
+          "release_date": null,
+          "original_title": "No Time to Die",
+          "uri": "douban://douban.com/movie/20276229",
+          "pre_playable_date": null,
+          "episodes_info": "",
+          "subtype": "movie",
+          "directors": [
+            {
+              "name": "凯瑞·福永",
+              "roles": [
+                "导演",
+                "制片人",
+                "编剧",
+                "摄影",
+                "演员"
+              ],
+              "title": "凯瑞·福永（同名）美国,加利福尼亚州,奥克兰影视演员",
+              "url": "https://movie.douban.com/celebrity/1009531/",
+              "user": null,
+              "character": "导演",
+              "uri": "douban://douban.com/celebrity/1009531?subject_id=27215222",
+              "avatar": {
+                "large": "https://qnmob3.doubanio.com/view/celebrity/raw/public/p1392285899.57.jpg?imageView2/2/q/80/w/600/h/3000/format/webp",
+                "normal": "https://qnmob3.doubanio.com/view/celebrity/raw/public/p1392285899.57.jpg?imageView2/2/q/80/w/200/h/300/format/webp"
+              },
+              "sharing_url": "https://www.douban.com/doubanapp/dispatch?uri=/celebrity/1009531/",
+              "type": "celebrity",
+              "id": "1009531",
+              "latin_name": "Cary Fukunaga"
+            }
+          ],
+          "is_show": false,
+          "in_blacklist": false,
+          "pre_release_desc": "",
+          "video": null,
+          "aka": [
+            "007：生死有时(港)",
+            "007：生死交战(台)",
+            "007：间不容死",
+            "邦德25",
+            "007：没空去死(豆友译名)",
+            "James Bond 25",
+            "Never Dream of Dying",
+            "Shatterhand"
+          ],
+          "is_restrictive": false,
+          "trailer": {
+            "sharing_url": "https://www.douban.com/doubanapp/dispatch?uri=/movie/20276229/trailer%3Ftrailer_id%3D282585%26trailer_type%3DA",
+            "video_url": "https://vt1.doubanio.com/202310011325/3b1f5827e91dde7826dc20930380dfc2/view/movie/M/402820585.mp4",
+            "title": "中国预告片：终极决战版 (中文字幕)",
+            "uri": "douban://douban.com/movie/20276229/trailer?trailer_id=282585&trailer_type=A",
+            "cover_url": "https://img1.doubanio.com/img/trailer/medium/2712944408.jpg",
+            "term_num": 0,
+            "n_comments": 21,
+            "create_time": "2021-11-01",
+            "subject_title": "007：无暇赴死",
+            "file_size": 10520074,
+            "runtime": "00:42",
+            "type": "A",
+            "id": "282585",
+            "desc": ""
+          },
+          "interest_cmt_earlier_tip_desc": "该短评的发布时间早于公开上映时间，作者可能通过其他渠道提前观看，请谨慎参考。其评分将不计入总评分。"
+        }
+        """
         if not doubanid:
             return None
         logger.info(f"开始获取豆瓣信息：{doubanid} ...")
@@ -129,22 +393,38 @@ class DoubanModule(_ModuleBase):
 
         return ret_medias
 
-    def __match(self, name: str, year: str, season: int = None) -> dict:
+    def match_doubaninfo(self, name: str, mtype: str = None,
+                         year: str = None, season: int = None) -> dict:
         """
         搜索和匹配豆瓣信息
+        :param name:  名称
+        :param mtype:  类型 电影/电视剧
+        :param year:  年份
+        :param season:  季号
         """
-        result = self.doubanapi.search(f"{name} {year or ''}")
+        result = self.doubanapi.search(f"{name} {year or ''}".strip())
         if not result:
             return {}
         for item_obj in result.get("items"):
-            if item_obj.get("type_name") not in (MediaType.TV.value, MediaType.MOVIE.value):
+            type_name = item_obj.get("type_name")
+            if type_name not in [MediaType.TV.value, MediaType.MOVIE.value]:
                 continue
-            title = item_obj.get("title")
+            if mtype and mtype != type_name:
+                continue
+            if mtype == MediaType.TV and not season:
+                season = 1
+            item = item_obj.get("target")
+            title = item.get("title")
             if not title:
                 continue
             meta = MetaInfo(title)
-            if meta.name == name and (not season or meta.begin_season == season):
-                return item_obj
+            if type_name == MediaType.TV.value:
+                meta.type = MediaType.TV
+                meta.begin_season = meta.begin_season or 1
+            if meta.name == name \
+                    and ((not season and not meta.begin_season) or meta.begin_season == season) \
+                    and (not year or item.get('year') == year):
+                return item
         return {}
 
     def movie_top250(self, page: int = 1, count: int = 30) -> List[dict]:
@@ -173,7 +453,10 @@ class DoubanModule(_ModuleBase):
             if not meta.name:
                 return
             # 根据名称查询豆瓣数据
-            doubaninfo = self.__match(name=mediainfo.title, year=mediainfo.year, season=meta.begin_season)
+            doubaninfo = self.match_doubaninfo(name=mediainfo.title,
+                                               mtype=mediainfo.type.value,
+                                               year=mediainfo.year,
+                                               season=meta.begin_season)
             if not doubaninfo:
                 logger.warn(f"未找到 {mediainfo.title} 的豆瓣信息")
                 return
@@ -192,9 +475,10 @@ class DoubanModule(_ModuleBase):
                     if not meta.name:
                         continue
                     # 根据名称查询豆瓣数据
-                    doubaninfo = self.__match(name=mediainfo.title,
-                                              year=mediainfo.year,
-                                              season=meta.begin_season)
+                    doubaninfo = self.match_doubaninfo(name=mediainfo.title,
+                                                       mtype=mediainfo.type.value,
+                                                       year=mediainfo.year,
+                                                       season=meta.begin_season)
                     if not doubaninfo:
                         logger.warn(f"未找到 {mediainfo.title} 的豆瓣信息")
                         break

app/modules/douban/apiv2.py

@@ -146,72 +146,111 @@ class DoubanApi(metaclass=Singleton):
     _api_secret_key = "bf7dddc7c9cfe6f7"
     _api_key = "0dad551ec0f84ed02907ff5c42e8ec70"
     _base_url = "https://frodo.douban.com/api/v2"
-    _session = requests.Session()
+    _session = None
 
     def __init__(self):
-        pass
+        self._session = requests.Session()
 
     @classmethod
     def __sign(cls, url: str, ts: int, method='GET') -> str:
         url_path = parse.urlparse(url).path
         raw_sign = '&'.join([method.upper(), parse.quote(url_path, safe=''), str(ts)])
-        return base64.b64encode(hmac.new(cls._api_secret_key.encode(), raw_sign.encode(), hashlib.sha1).digest()
-                                ).decode()
+        return base64.b64encode(
+            hmac.new(
+                cls._api_secret_key.encode(),
+                raw_sign.encode(),
+                hashlib.sha1
+            ).digest()
+        ).decode()
 
-    @classmethod
     @lru_cache(maxsize=settings.CACHE_CONF.get('douban'))
-    def __invoke(cls, url, **kwargs):
-        req_url = cls._base_url + url
+    def __invoke(self, url, **kwargs):
+        req_url = self._base_url + url
 
-        params = {'apiKey': cls._api_key}
+        params = {'apiKey': self._api_key}
         if kwargs:
             params.update(kwargs)
 
-        ts = params.pop('_ts', int(datetime.strftime(datetime.now(), '%Y%m%d')))
-        params.update({'os_rom': 'android', 'apiKey': cls._api_key, '_ts': ts, '_sig': cls.__sign(url=req_url, ts=ts)})
-
-        resp = RequestUtils(ua=choice(cls._user_agents), session=cls._session).get_res(url=req_url, params=params)
-
+        ts = params.pop(
+            '_ts',
+            int(datetime.strftime(datetime.now(), '%Y%m%d'))
+        )
+        params.update({
+            'os_rom': 'android',
+            'apiKey': self._api_key,
+            '_ts': ts,
+            '_sig': self.__sign(url=req_url, ts=ts)
+        })
+        resp = RequestUtils(
+            ua=choice(self._user_agents),
+            session=self._session
+        ).get_res(url=req_url, params=params)
         return resp.json() if resp else {}
 
-    def search(self, keyword, start=0, count=20, ts=datetime.strftime(datetime.now(), '%Y%m%d')):
-        return self.__invoke(self._urls["search"], q=keyword, start=start, count=count, _ts=ts)
+    def search(self, keyword, start=0, count=20,
+               ts=datetime.strftime(datetime.now(), '%Y%m%d')):
+        return self.__invoke(self._urls["search"], q=keyword,
+                             start=start, count=count, _ts=ts)
 
-    def movie_search(self, keyword, start=0, count=20, ts=datetime.strftime(datetime.now(), '%Y%m%d')):
-        return self.__invoke(self._urls["movie_search"], q=keyword, start=start, count=count, _ts=ts)
+    def movie_search(self, keyword, start=0, count=20,
+                     ts=datetime.strftime(datetime.now(), '%Y%m%d')):
+        return self.__invoke(self._urls["movie_search"], q=keyword,
+                             start=start, count=count, _ts=ts)
 
-    def tv_search(self, keyword, start=0, count=20, ts=datetime.strftime(datetime.now(), '%Y%m%d')):
-        return self.__invoke(self._urls["tv_search"], q=keyword, start=start, count=count, _ts=ts)
+    def tv_search(self, keyword, start=0, count=20,
+                  ts=datetime.strftime(datetime.now(), '%Y%m%d')):
+        return self.__invoke(self._urls["tv_search"], q=keyword,
+                             start=start, count=count, _ts=ts)
 
-    def book_search(self, keyword, start=0, count=20, ts=datetime.strftime(datetime.now(), '%Y%m%d')):
-        return self.__invoke(self._urls["book_search"], q=keyword, start=start, count=count, _ts=ts)
+    def book_search(self, keyword, start=0, count=20,
+                    ts=datetime.strftime(datetime.now(), '%Y%m%d')):
+        return self.__invoke(self._urls["book_search"], q=keyword,
+                             start=start, count=count, _ts=ts)
 
-    def group_search(self, keyword, start=0, count=20, ts=datetime.strftime(datetime.now(), '%Y%m%d')):
-        return self.__invoke(self._urls["group_search"], q=keyword, start=start, count=count, _ts=ts)
+    def group_search(self, keyword, start=0, count=20,
+                     ts=datetime.strftime(datetime.now(), '%Y%m%d')):
+        return self.__invoke(self._urls["group_search"], q=keyword,
+                             start=start, count=count, _ts=ts)
 
-    def movie_showing(self, start=0, count=20, ts=datetime.strftime(datetime.now(), '%Y%m%d')):
-        return self.__invoke(self._urls["movie_showing"], start=start, count=count, _ts=ts)
+    def movie_showing(self, start=0, count=20,
+                      ts=datetime.strftime(datetime.now(), '%Y%m%d')):
+        return self.__invoke(self._urls["movie_showing"],
+                             start=start, count=count, _ts=ts)
 
-    def movie_soon(self, start=0, count=20, ts=datetime.strftime(datetime.now(), '%Y%m%d')):
-        return self.__invoke(self._urls["movie_soon"], start=start, count=count, _ts=ts)
+    def movie_soon(self, start=0, count=20,
+                   ts=datetime.strftime(datetime.now(), '%Y%m%d')):
+        return self.__invoke(self._urls["movie_soon"],
+                             start=start, count=count, _ts=ts)
 
-    def movie_hot_gaia(self, start=0, count=20, ts=datetime.strftime(datetime.now(), '%Y%m%d')):
-        return self.__invoke(self._urls["movie_hot_gaia"], start=start, count=count, _ts=ts)
+    def movie_hot_gaia(self, start=0, count=20,
+                       ts=datetime.strftime(datetime.now(), '%Y%m%d')):
+        return self.__invoke(self._urls["movie_hot_gaia"],
+                             start=start, count=count, _ts=ts)
 
-    def tv_hot(self, start=0, count=20, ts=datetime.strftime(datetime.now(), '%Y%m%d')):
-        return self.__invoke(self._urls["tv_hot"], start=start, count=count, _ts=ts)
+    def tv_hot(self, start=0, count=20,
+               ts=datetime.strftime(datetime.now(), '%Y%m%d')):
+        return self.__invoke(self._urls["tv_hot"],
+                             start=start, count=count, _ts=ts)
 
-    def tv_animation(self, start=0, count=20, ts=datetime.strftime(datetime.now(), '%Y%m%d')):
-        return self.__invoke(self._urls["tv_animation"], start=start, count=count, _ts=ts)
+    def tv_animation(self, start=0, count=20,
+                     ts=datetime.strftime(datetime.now(), '%Y%m%d')):
+        return self.__invoke(self._urls["tv_animation"],
+                             start=start, count=count, _ts=ts)
 
-    def tv_variety_show(self, start=0, count=20, ts=datetime.strftime(datetime.now(), '%Y%m%d')):
-        return self.__invoke(self._urls["tv_variety_show"], start=start, count=count, _ts=ts)
+    def tv_variety_show(self, start=0, count=20,
+                        ts=datetime.strftime(datetime.now(), '%Y%m%d')):
+        return self.__invoke(self._urls["tv_variety_show"],
+                             start=start, count=count, _ts=ts)
 
-    def tv_rank_list(self, start=0, count=20, ts=datetime.strftime(datetime.now(), '%Y%m%d')):
-        return self.__invoke(self._urls["tv_rank_list"], start=start, count=count, _ts=ts)
+    def tv_rank_list(self, start=0, count=20,
+                     ts=datetime.strftime(datetime.now(), '%Y%m%d')):
+        return self.__invoke(self._urls["tv_rank_list"],
+                             start=start, count=count, _ts=ts)
 
-    def show_hot(self, start=0, count=20, ts=datetime.strftime(datetime.now(), '%Y%m%d')):
-        return self.__invoke(self._urls["show_hot"], start=start, count=count, _ts=ts)
+    def show_hot(self, start=0, count=20,
+                 ts=datetime.strftime(datetime.now(), '%Y%m%d')):
+        return self.__invoke(self._urls["show_hot"],
+                             start=start, count=count, _ts=ts)
 
     def movie_detail(self, subject_id):
         return self.__invoke(self._urls["movie_detail"] + subject_id)
@@ -228,20 +267,30 @@ class DoubanApi(metaclass=Singleton):
     def book_detail(self, subject_id):
         return self.__invoke(self._urls["book_detail"] + subject_id)
 
-    def movie_top250(self, start=0, count=20, ts=datetime.strftime(datetime.now(), '%Y%m%d')):
-        return self.__invoke(self._urls["movie_top250"], start=start, count=count, _ts=ts)
+    def movie_top250(self, start=0, count=20,
+                     ts=datetime.strftime(datetime.now(), '%Y%m%d')):
+        return self.__invoke(self._urls["movie_top250"],
+                             start=start, count=count, _ts=ts)
 
-    def movie_recommend(self, tags='', sort='R', start=0, count=20, ts=datetime.strftime(datetime.now(), '%Y%m%d')):
-        return self.__invoke(self._urls["movie_recommend"], tags=tags, sort=sort, start=start, count=count, _ts=ts)
+    def movie_recommend(self, tags='', sort='R', start=0, count=20,
+                        ts=datetime.strftime(datetime.now(), '%Y%m%d')):
+        return self.__invoke(self._urls["movie_recommend"], tags=tags, sort=sort,
+                             start=start, count=count, _ts=ts)
 
-    def tv_recommend(self, tags='', sort='R', start=0, count=20, ts=datetime.strftime(datetime.now(), '%Y%m%d')):
-        return self.__invoke(self._urls["tv_recommend"], tags=tags, sort=sort, start=start, count=count, _ts=ts)
+    def tv_recommend(self, tags='', sort='R', start=0, count=20,
+                     ts=datetime.strftime(datetime.now(), '%Y%m%d')):
+        return self.__invoke(self._urls["tv_recommend"], tags=tags, sort=sort,
+                             start=start, count=count, _ts=ts)
 
-    def tv_chinese_best_weekly(self, start=0, count=20, ts=datetime.strftime(datetime.now(), '%Y%m%d')):
-        return self.__invoke(self._urls["tv_chinese_best_weekly"], start=start, count=count, _ts=ts)
+    def tv_chinese_best_weekly(self, start=0, count=20,
+                               ts=datetime.strftime(datetime.now(), '%Y%m%d')):
+        return self.__invoke(self._urls["tv_chinese_best_weekly"],
+                             start=start, count=count, _ts=ts)
 
-    def tv_global_best_weekly(self, start=0, count=20, ts=datetime.strftime(datetime.now(), '%Y%m%d')):
-        return self.__invoke(self._urls["tv_global_best_weekly"], start=start, count=count, _ts=ts)
+    def tv_global_best_weekly(self, start=0, count=20,
+                              ts=datetime.strftime(datetime.now(), '%Y%m%d')):
+        return self.__invoke(self._urls["tv_global_best_weekly"],
+                             start=start, count=count, _ts=ts)
 
     def doulist_detail(self, subject_id):
         """
@@ -250,7 +299,8 @@ class DoubanApi(metaclass=Singleton):
         """
         return self.__invoke(self._urls["doulist"] + subject_id)
 
-    def doulist_items(self, subject_id, start=0, count=20, ts=datetime.strftime(datetime.now(), '%Y%m%d')):
+    def doulist_items(self, subject_id, start=0, count=20,
+                      ts=datetime.strftime(datetime.now(), '%Y%m%d')):
         """
         豆列列表
         :param subject_id: 豆列id
@@ -258,4 +308,9 @@ class DoubanApi(metaclass=Singleton):
         :param count: 数量
         :param ts: 时间戳
         """
-        return self.__invoke(self._urls["doulist_items"] % subject_id, start=start, count=count, _ts=ts)
+        return self.__invoke(self._urls["doulist_items"] % subject_id,
+                             start=start, count=count, _ts=ts)
+
+    def __del__(self):
+        if self._session:
+            self._session.close()

app/modules/emby/__init__.py

@@ -6,7 +6,6 @@ from app.core.context import MediaInfo
 from app.log import logger
 from app.modules import _ModuleBase
 from app.modules.emby.emby import Emby
-from app.schemas import ExistMediaInfo, RefreshMediaItem, WebhookEventInfo
 from app.schemas.types import MediaType
 
 
@@ -40,7 +39,7 @@ class EmbyModule(_ModuleBase):
         # Emby认证
         return self.emby.authenticate(name, password)
 
-    def webhook_parser(self, body: Any, form: Any, args: Any) -> Optional[WebhookEventInfo]:
+    def webhook_parser(self, body: Any, form: Any, args: Any) -> Optional[schemas.WebhookEventInfo]:
         """
         解析Webhook报文体
         :param body:  请求体
@@ -50,7 +49,7 @@ class EmbyModule(_ModuleBase):
         """
         return self.emby.get_webhook_message(form, args)
 
-    def media_exists(self, mediainfo: MediaInfo, itemid: str = None) -> Optional[ExistMediaInfo]:
+    def media_exists(self, mediainfo: MediaInfo, itemid: str = None) -> Optional[schemas.ExistMediaInfo]:
         """
         判断媒体文件是否存在
         :param mediainfo:  识别的媒体信息
@@ -62,25 +61,40 @@ class EmbyModule(_ModuleBase):
                 movie = self.emby.get_iteminfo(itemid)
                 if movie:
                     logger.info(f"媒体库中已存在：{movie}")
-                    return ExistMediaInfo(type=MediaType.MOVIE)
-            movies = self.emby.get_movies(title=mediainfo.title, year=mediainfo.year, tmdb_id=mediainfo.tmdb_id)
+                    return schemas.ExistMediaInfo(
+                        type=MediaType.MOVIE,
+                        server="emby",
+                        itemid=movie.item_id
+                    )
+            movies = self.emby.get_movies(title=mediainfo.title,
+                                          year=mediainfo.year,
+                                          tmdb_id=mediainfo.tmdb_id)
             if not movies:
                 logger.info(f"{mediainfo.title_year} 在媒体库中不存在")
                 return None
             else:
                 logger.info(f"媒体库中已存在：{movies}")
-                return ExistMediaInfo(type=MediaType.MOVIE)
+                return schemas.ExistMediaInfo(
+                    type=MediaType.MOVIE,
+                    server="emby",
+                    itemid=movies[0].item_id
+                )
         else:
-            tvs = self.emby.get_tv_episodes(title=mediainfo.title,
-                                            year=mediainfo.year,
-                                            tmdb_id=mediainfo.tmdb_id,
-                                            item_id=itemid)
+            itemid, tvs = self.emby.get_tv_episodes(title=mediainfo.title,
+                                                    year=mediainfo.year,
+                                                    tmdb_id=mediainfo.tmdb_id,
+                                                    item_id=itemid)
             if not tvs:
                 logger.info(f"{mediainfo.title_year} 在媒体库中不存在")
                 return None
             else:
                 logger.info(f"{mediainfo.title_year} 媒体库中已存在：{tvs}")
-                return ExistMediaInfo(type=MediaType.TV, seasons=tvs)
+                return schemas.ExistMediaInfo(
+                    type=MediaType.TV,
+                    seasons=tvs,
+                    server="emby",
+                    itemid=itemid
+                )
 
     def refresh_mediaserver(self, mediainfo: MediaInfo, file_path: Path) -> None:
         """
@@ -90,7 +104,7 @@ class EmbyModule(_ModuleBase):
         :return: 成功或失败
         """
         items = [
-            RefreshMediaItem(
+            schemas.RefreshMediaItem(
                 title=mediainfo.title,
                 year=mediainfo.year,
                 type=mediainfo.type,
@@ -105,13 +119,8 @@ class EmbyModule(_ModuleBase):
         媒体数量统计
         """
         media_statistic = self.emby.get_medias_count()
-        user_count = self.emby.get_user_count()
-        return [schemas.Statistic(
-            movie_count=media_statistic.get("MovieCount") or 0,
-            tv_count=media_statistic.get("SeriesCount") or 0,
-            episode_count=media_statistic.get("EpisodeCount") or 0,
-            user_count=user_count or 0
-        )]
+        media_statistic.user_count = self.emby.get_user_count()
+        return [media_statistic]
 
     def mediaserver_librarys(self, server: str) -> Optional[List[schemas.MediaServerLibrary]]:
         """
@@ -119,16 +128,7 @@ class EmbyModule(_ModuleBase):
         """
         if server != "emby":
             return None
-        librarys = self.emby.get_librarys()
-        if not librarys:
-            return []
-        return [schemas.MediaServerLibrary(
-            server="emby",
-            id=library.get("id"),
-            name=library.get("name"),
-            type=library.get("type"),
-            path=library.get("path")
-        ) for library in librarys]
+        return self.emby.get_librarys()
 
     def mediaserver_items(self, server: str, library_id: str) -> Optional[Generator]:
         """
@@ -136,21 +136,15 @@ class EmbyModule(_ModuleBase):
         """
         if server != "emby":
             return None
-        items = self.emby.get_items(library_id)
-        for item in items:
-            yield schemas.MediaServerItem(
-                server="emby",
-                library=item.get("library"),
-                item_id=item.get("id"),
-                item_type=item.get("type"),
-                title=item.get("title"),
-                original_title=item.get("original_title"),
-                year=item.get("year"),
-                tmdbid=int(item.get("tmdbid")) if item.get("tmdbid") else None,
-                imdbid=item.get("imdbid"),
-                tvdbid=item.get("tvdbid"),
-                path=item.get("path"),
-            )
+        return self.emby.get_items(library_id)
+
+    def mediaserver_iteminfo(self, server: str, item_id: str) -> Optional[schemas.MediaServerItem]:
+        """
+        媒体库项目详情
+        """
+        if server != "emby":
+            return None
+        return self.emby.get_iteminfo(item_id)
 
     def mediaserver_tv_episodes(self, server: str,
                                 item_id: Union[str, int]) -> Optional[List[schemas.MediaServerSeasonInfo]]:
@@ -159,7 +153,7 @@ class EmbyModule(_ModuleBase):
         """
         if server != "emby":
             return None
-        seasoninfo = self.emby.get_tv_episodes(item_id=item_id)
+        _, seasoninfo = self.emby.get_tv_episodes(item_id=item_id)
         if not seasoninfo:
             return []
         return [schemas.MediaServerSeasonInfo(

app/modules/emby/emby.py

@@ -1,17 +1,16 @@
 import json
 import re
 from pathlib import Path
-from typing import List, Optional, Union, Dict, Generator
+from typing import List, Optional, Union, Dict, Generator, Tuple
 
 from requests import Response
 
+from app import schemas
 from app.core.config import settings
 from app.log import logger
-from app.schemas import RefreshMediaItem, WebhookEventInfo
 from app.schemas.types import MediaType
 from app.utils.http import RequestUtils
 from app.utils.singleton import Singleton
-from app.utils.string import StringUtils
 
 
 class Emby(metaclass=Singleton):
@@ -78,7 +77,7 @@ class Emby(metaclass=Singleton):
             logger.error(f"连接User/Views 出错：" + str(e))
             return []
 
-    def get_librarys(self):
+    def get_librarys(self) -> List[schemas.MediaServerLibrary]:
         """
         获取媒体服务器所有媒体库列表
         """
@@ -93,12 +92,15 @@ class Emby(metaclass=Singleton):
                     library_type = MediaType.TV.value
                 case _:
                     continue
-            libraries.append({
-                "id": library.get("Id"),
-                "name": library.get("Name"),
-                "path": library.get("Path"),
-                "type": library_type
-            })
+            libraries.append(
+                schemas.MediaServerLibrary(
+                    server="emby",
+                    id=library.get("Id"),
+                    name=library.get("Name"),
+                    path=library.get("Path"),
+                    type=library_type
+                )
+            )
         return libraries
 
     def get_user(self, user_name: str = None) -> Optional[Union[str, int]]:
@@ -200,59 +202,29 @@ class Emby(metaclass=Singleton):
             logger.error(f"连接Users/Query出错：" + str(e))
             return 0
 
-    def get_activity_log(self, num: int = 30) -> List[dict]:
-        """
-        获取Emby活动记录
-        """
-        if not self._host or not self._apikey:
-            return []
-        req_url = "%semby/System/ActivityLog/Entries?api_key=%s&" % (self._host, self._apikey)
-        ret_array = []
-        try:
-            res = RequestUtils().get_res(req_url)
-            if res:
-                ret_json = res.json()
-                items = ret_json.get('Items')
-                for item in items:
-                    if item.get("Type") == "AuthenticationSucceeded":
-                        event_type = "LG"
-                        event_date = StringUtils.get_time(item.get("Date"))
-                        event_str = "%s, %s" % (item.get("Name"), item.get("ShortOverview"))
-                        activity = {"type": event_type, "event": event_str, "date": event_date}
-                        ret_array.append(activity)
-                    if item.get("Type") in ["VideoPlayback", "VideoPlaybackStopped"]:
-                        event_type = "PL"
-                        event_date = StringUtils.get_time(item.get("Date"))
-                        event_str = item.get("Name")
-                        activity = {"type": event_type, "event": event_str, "date": event_date}
-                        ret_array.append(activity)
-            else:
-                logger.error(f"System/ActivityLog/Entries 未获取到返回数据")
-                return []
-        except Exception as e:
-
-            logger.error(f"连接System/ActivityLog/Entries出错：" + str(e))
-            return []
-        return ret_array[:num]
-
-    def get_medias_count(self) -> dict:
+    def get_medias_count(self) -> schemas.Statistic:
         """
         获得电影、电视剧、动漫媒体数量
         :return: MovieCount SeriesCount SongCount
         """
         if not self._host or not self._apikey:
-            return {}
+            return schemas.Statistic()
         req_url = "%semby/Items/Counts?api_key=%s" % (self._host, self._apikey)
         try:
             res = RequestUtils().get_res(req_url)
             if res:
-                return res.json()
+                result = res.json()
+                return schemas.Statistic(
+                    movie_count=result.get("MovieCount") or 0,
+                    tv_count=result.get("SeriesCount") or 0,
+                    episode_count=result.get("EpisodeCount") or 0
+                )
             else:
                 logger.error(f"Items/Counts 未获取到返回数据")
-                return {}
+                return schemas.Statistic()
         except Exception as e:
             logger.error(f"连接Items/Counts出错：" + str(e))
-            return {}
+            return schemas.Statistic()
 
     def __get_emby_series_id_by_name(self, name: str, year: str) -> Optional[str]:
         """
@@ -263,7 +235,15 @@ class Emby(metaclass=Singleton):
         """
         if not self._host or not self._apikey:
             return None
-        req_url = "%semby/Items?IncludeItemTypes=Series&Fields=ProductionYear&StartIndex=0&Recursive=true&SearchTerm=%s&Limit=10&IncludeSearchTypes=false&api_key=%s" % (
+        req_url = ("%semby/Items?"
+                   "IncludeItemTypes=Series"
+                   "&Fields=ProductionYear"
+                   "&StartIndex=0"
+                   "&Recursive=true"
+                   "&SearchTerm=%s"
+                   "&Limit=10"
+                   "&IncludeSearchTypes=false"
+                   "&api_key=%s") % (
             self._host, name, self._apikey)
         try:
             res = RequestUtils().get_res(req_url)
@@ -282,7 +262,7 @@ class Emby(metaclass=Singleton):
     def get_movies(self,
                    title: str,
                    year: str = None,
-                   tmdb_id: int = None) -> Optional[List[dict]]:
+                   tmdb_id: int = None) -> Optional[List[schemas.MediaServerItem]]:
         """
         根据标题和年份，检查电影是否在Emby中存在，存在则返回列表
         :param title: 标题
@@ -303,17 +283,28 @@ class Emby(metaclass=Singleton):
                     ret_movies = []
                     for res_item in res_items:
                         item_tmdbid = res_item.get("ProviderIds", {}).get("Tmdb")
+                        mediaserver_item = schemas.MediaServerItem(
+                            server="emby",
+                            library=res_item.get("ParentId"),
+                            item_id=res_item.get("Id"),
+                            item_type=res_item.get("Type"),
+                            title=res_item.get("Name"),
+                            original_title=res_item.get("OriginalTitle"),
+                            year=res_item.get("ProductionYear"),
+                            tmdbid=int(item_tmdbid) if item_tmdbid else None,
+                            imdbid=res_item.get("ProviderIds", {}).get("Imdb"),
+                            tvdbid=res_item.get("ProviderIds", {}).get("Tvdb"),
+                            path=res_item.get("Path")
+                        )
                         if tmdb_id and item_tmdbid:
                             if str(item_tmdbid) != str(tmdb_id):
                                 continue
                             else:
-                                ret_movies.append(
-                                    {'title': res_item.get('Name'), 'year': str(res_item.get('ProductionYear'))})
+                                ret_movies.append(mediaserver_item)
                                 continue
-                        if res_item.get('Name') == title and (
-                                not year or str(res_item.get('ProductionYear')) == str(year)):
-                            ret_movies.append(
-                                {'title': res_item.get('Name'), 'year': str(res_item.get('ProductionYear'))})
+                        if (mediaserver_item.title == title
+                                and (not year or str(mediaserver_item.year) == str(year))):
+                            ret_movies.append(mediaserver_item)
                     return ret_movies
         except Exception as e:
             logger.error(f"连接Items出错：" + str(e))
@@ -325,7 +316,8 @@ class Emby(metaclass=Singleton):
                         title: str = None,
                         year: str = None,
                         tmdb_id: int = None,
-                        season: int = None) -> Optional[Dict[int, list]]:
+                        season: int = None
+                        ) -> Tuple[Optional[str], Optional[Dict[int, List[Dict[int, list]]]]]:
         """
         根据标题和年份和季，返回Emby中的剧集列表
         :param item_id: Emby中的ID
@@ -336,22 +328,21 @@ class Emby(metaclass=Singleton):
         :return: 每一季的已有集数
         """
         if not self._host or not self._apikey:
-            return None
+            return None, None
         # 电视剧
         if not item_id:
             item_id = self.__get_emby_series_id_by_name(title, year)
             if item_id is None:
-                return None
+                return None, None
             if not item_id:
-                return {}
+                return None, {}
         # 验证tmdbid是否相同
         item_info = self.get_iteminfo(item_id)
         if item_info:
-            item_tmdbid = (item_info.get("ProviderIds") or {}).get("Tmdb")
-            if tmdb_id and item_tmdbid:
-                if str(tmdb_id) != str(item_tmdbid):
-                    return {}
-        # /Shows/Id/Episodes 查集的信息
+            if tmdb_id and item_info.tmdbid:
+                if str(tmdb_id) != str(item_info.tmdbid):
+                    return None, {}
+        # 查集的信息
         if not season:
             season = ""
         try:
@@ -359,7 +350,8 @@ class Emby(metaclass=Singleton):
                 self._host, item_id, season, self._apikey)
             res_json = RequestUtils().get_res(req_url)
             if res_json:
-                res_items = res_json.json().get("Items")
+                tv_item = res_json.json()
+                res_items = tv_item.get("Items")
                 season_episodes = {}
                 for res_item in res_items:
                     season_index = res_item.get("ParentIndexNumber")
@@ -374,11 +366,11 @@ class Emby(metaclass=Singleton):
                         season_episodes[season_index] = []
                     season_episodes[season_index].append(episode_index)
                 # 返回
-                return season_episodes
+                return tv_item.get("Id"), season_episodes
         except Exception as e:
             logger.error(f"连接Shows/Id/Episodes出错：" + str(e))
-            return None
-        return {}
+            return None, None
+        return None, {}
 
     def get_remote_image_by_id(self, item_id: str, image_type: str) -> Optional[str]:
         """
@@ -441,7 +433,7 @@ class Emby(metaclass=Singleton):
             return False
         return False
 
-    def refresh_library_by_items(self, items: List[RefreshMediaItem]) -> bool:
+    def refresh_library_by_items(self, items: List[schemas.RefreshMediaItem]) -> bool:
         """
         按类型、名称、年份来刷新媒体库
         :param items: 已识别的需要刷新媒体库的媒体信息列表
@@ -463,7 +455,7 @@ class Emby(metaclass=Singleton):
                 return self.__refresh_emby_library_by_id(library_id)
         logger.info(f"Emby媒体库刷新完成")
 
-    def __get_emby_library_id_by_item(self, item: RefreshMediaItem) -> Optional[str]:
+    def __get_emby_library_id_by_item(self, item: schemas.RefreshMediaItem) -> Optional[str]:
         """
         根据媒体信息查询在哪个媒体库，返回要刷新的位置的ID
         :param item: {title, year, type, category, target_path}
@@ -491,39 +483,53 @@ class Emby(metaclass=Singleton):
                         return folder.get("Id")
                 except Exception as err:
                     print(str(err))
-        # 如果找不到，只要路径中有分类目录名就命中
-        for subfolder in folder.get("SubFolders"):
-            if subfolder.get("Path") and re.search(r"[/\\]%s" % item.category,
-                                                    subfolder.get("Path")):
-                return folder.get("Id")
+            # 如果找不到，只要路径中有分类目录名就命中
+            for subfolder in folder.get("SubFolders"):
+                if subfolder.get("Path") and re.search(r"[/\\]%s" % item.category,
+                                                       subfolder.get("Path")):
+                    return folder.get("Id")
         # 刷新根目录
         return "/"
 
-    def get_iteminfo(self, itemid: str) -> dict:
+    def get_iteminfo(self, itemid: str) -> Optional[schemas.MediaServerItem]:
         """
         获取单个项目详情
         """
         if not itemid:
-            return {}
+            return None
         if not self._host or not self._apikey:
-            return {}
+            return None
         req_url = "%semby/Users/%s/Items/%s?api_key=%s" % (self._host, self.user, itemid, self._apikey)
         try:
             res = RequestUtils().get_res(req_url)
             if res and res.status_code == 200:
-                return res.json()
+                item = res.json()
+                tmdbid = item.get("ProviderIds", {}).get("Tmdb")
+                return schemas.MediaServerItem(
+                    server="emby",
+                    library=item.get("ParentId"),
+                    item_id=item.get("Id"),
+                    item_type=item.get("Type"),
+                    title=item.get("Name"),
+                    original_title=item.get("OriginalTitle"),
+                    year=item.get("ProductionYear"),
+                    tmdbid=int(tmdbid) if tmdbid else None,
+                    imdbid=item.get("ProviderIds", {}).get("Imdb"),
+                    tvdbid=item.get("ProviderIds", {}).get("Tvdb"),
+                    path=item.get("Path")
+                )
         except Exception as e:
             logger.error(f"连接Items/Id出错：" + str(e))
-            return {}
+        return None
 
     def get_items(self, parent: str) -> Generator:
         """
         获取媒体服务器所有媒体库列表
         """
         if not parent:
-            yield {}
+            yield None
         if not self._host or not self._apikey:
-            yield {}
+            yield None
         req_url = "%semby/Users/%s/Items?ParentId=%s&api_key=%s" % (self._host, self.user, parent, self._apikey)
         try:
             res = RequestUtils().get_res(req_url)
@@ -533,26 +539,15 @@ class Emby(metaclass=Singleton):
                     if not result:
                         continue
                     if result.get("Type") in ["Movie", "Series"]:
-                        item_info = self.get_iteminfo(result.get("Id"))
-                        yield {"id": result.get("Id"),
-                               "library": item_info.get("ParentId"),
-                               "type": item_info.get("Type"),
-                               "title": item_info.get("Name"),
-                               "original_title": item_info.get("OriginalTitle"),
-                               "year": item_info.get("ProductionYear"),
-                               "tmdbid": item_info.get("ProviderIds", {}).get("Tmdb"),
-                               "imdbid": item_info.get("ProviderIds", {}).get("Imdb"),
-                               "tvdbid": item_info.get("ProviderIds", {}).get("Tvdb"),
-                               "path": item_info.get("Path"),
-                               "json": str(item_info)}
+                        yield self.get_iteminfo(result.get("Id"))
                     elif "Folder" in result.get("Type"):
                         for item in self.get_items(parent=result.get('Id')):
                             yield item
         except Exception as e:
             logger.error(f"连接Users/Items出错：" + str(e))
-        yield {}
+        yield None
 
-    def get_webhook_message(self, form: any, args: dict) -> Optional[WebhookEventInfo]:
+    def get_webhook_message(self, form: any, args: dict) -> Optional[schemas.WebhookEventInfo]:
         """
         解析Emby Webhook报文
         电影：
@@ -805,7 +800,7 @@ class Emby(metaclass=Singleton):
         if not eventType:
             return None
         logger.info(f"接收到emby webhook：{message}")
-        eventItem = WebhookEventInfo(event=eventType, channel="emby")
+        eventItem = schemas.WebhookEventInfo(event=eventType, channel="emby")
         if message.get('Item'):
             if message.get('Item', {}).get('Type') == 'Episode':
                 eventItem.item_type = "TV"
@@ -871,16 +866,36 @@ class Emby(metaclass=Singleton):
 
     def get_data(self, url: str) -> Optional[Response]:
         """
-        自定义URL从媒体服务器获取数据，其中{HOST}、{APIKEY}、{USER}会被替换成实际的值
+        自定义URL从媒体服务器获取数据，其中[HOST]、[APIKEY]、[USER]会被替换成实际的值
         :param url: 请求地址
         """
         if not self._host or not self._apikey:
             return None
-        url = url.replace("{HOST}", self._host) \
-            .replace("{APIKEY}", self._apikey) \
-            .replace("{USER}", self.user)
+        url = url.replace("[HOST]", self._host) \
+            .replace("[APIKEY]", self._apikey) \
+            .replace("[USER]", self.user)
         try:
-            return RequestUtils().get_res(url=url)
+            return RequestUtils(content_type="application/json").get_res(url=url)
+        except Exception as e:
+            logger.error(f"连接Emby出错：" + str(e))
+            return None
+
+    def post_data(self, url: str, data: str = None, headers: dict = None) -> Optional[Response]:
+        """
+        自定义URL从媒体服务器获取数据，其中[HOST]、[APIKEY]、[USER]会被替换成实际的值
+        :param url: 请求地址
+        :param data: 请求数据
+        :param headers: 请求头
+        """
+        if not self._host or not self._apikey:
+            return None
+        url = url.replace("[HOST]", self._host) \
+            .replace("[APIKEY]", self._apikey) \
+            .replace("[USER]", self.user)
+        try:
+            return RequestUtils(
+                headers=headers,
+            ).post_res(url=url, data=data)
         except Exception as e:
             logger.error(f"连接Emby出错：" + str(e))
             return None

app/modules/indexer/__init__.py

@@ -3,7 +3,7 @@ from typing import List, Optional, Tuple, Union
 
 from ruamel.yaml import CommentedMap
 
-from app.core.context import MediaInfo, TorrentInfo
+from app.core.context import TorrentInfo
 from app.log import logger
 from app.modules import _ModuleBase
 from app.modules.indexer.mtorrent import MTorrentSpider
@@ -28,69 +28,71 @@ class IndexerModule(_ModuleBase):
     def init_setting(self) -> Tuple[str, Union[str, bool]]:
         return "INDEXER", "builtin"
 
-    def search_torrents(self, site: CommentedMap, mediainfo: MediaInfo = None,
-                        keyword: str = None, page: int = 0, area: str = "title") -> List[TorrentInfo]:
+    def search_torrents(self, site: CommentedMap,
+                        keywords: List[str] = None,
+                        mtype: MediaType = None,
+                        page: int = 0) -> List[TorrentInfo]:
         """
         搜索一个站点
-        :param mediainfo:  识别的媒体信息
         :param site:  站点
-        :param keyword:  搜索关键词，如有按关键词搜索，否则按媒体信息名称搜索
+        :param keywords:  搜索关键词列表
+        :param mtype:  媒体类型
         :param page:  页码
-        :param area:  搜索区域 title or imdbid
         :return: 资源列表
         """
         # 确认搜索的名字
-        if keyword:
-            search_word = keyword
-        elif mediainfo:
-            search_word = mediainfo.title
-        else:
-            search_word = None
-
-        if search_word \
-                and site.get('language') == "en" \
-                and StringUtils.is_chinese(search_word):
-            # 不支持中文
-            logger.warn(f"{site.get('name')} 不支持中文搜索")
-            return []
-
-        # 去除搜索关键字中的特殊字符
-        if search_word:
-            search_word = StringUtils.clear(search_word, replace_word=" ", allow_space=True)
+        if not keywords:
+            # 浏览种子页
+            keywords = [None]
 
         # 开始索引
         result_array = []
         # 开始计时
         start_time = datetime.now()
-        try:
-            imdbid = mediainfo.imdb_id if mediainfo and area == "imdbid" else None
-            if site.get('parser') == "TNodeSpider":
-                error_flag, result_array = TNodeSpider(site).search(
-                    keyword=search_word,
-                    imdbid=imdbid,
-                    page=page
-                )
-            elif site.get('parser') == "TorrentLeech":
-                error_flag, result_array = TorrentLeech(site).search(
-                    keyword=search_word,
-                    page=page
-                )
-            elif site.get('parser') == "mTorrent":
-                error_flag, result_array = MTorrentSpider(site).search(
-                    keyword=search_word,
-                    mtype=mediainfo.type if mediainfo else None,
-                    page=page
-                )
-            else:
-                error_flag, result_array = self.__spider_search(
-                    keyword=search_word,
-                    imdbid=imdbid,
-                    indexer=site,
-                    mtype=mediainfo.type if mediainfo else None,
-                    page=page
-                )
-        except Exception as err:
-            logger.error(f"{site.get('name')} 搜索出错：{err}")
+
+        # 搜索多个关键字
+        for search_word in keywords:
+            # 可能为关键字或ttxxxx
+            if search_word \
+                    and site.get('language') == "en" \
+                    and StringUtils.is_chinese(search_word):
+                # 不支持中文
+                logger.warn(f"{site.get('name')} 不支持中文搜索")
+                continue
+
+            # 去除搜索关键字中的特殊字符
+            if search_word:
+                search_word = StringUtils.clear(search_word, replace_word=" ", allow_space=True)
+
+            try:
+                if site.get('parser') == "TNodeSpider":
+                    error_flag, result_array = TNodeSpider(site).search(
+                        keyword=search_word,
+                        page=page
+                    )
+                elif site.get('parser') == "TorrentLeech":
+                    error_flag, result_array = TorrentLeech(site).search(
+                        keyword=search_word,
+                        page=page
+                    )
+                elif site.get('parser') == "mTorrent":
+                    error_flag, result_array = MTorrentSpider(site).search(
+                        keyword=search_word,
+                        mtype=mtype,
+                        page=page
+                    )
+                else:
+                    error_flag, result_array = self.__spider_search(
+                        search_word=search_word,
+                        indexer=site,
+                        mtype=mtype,
+                        page=page
+                    )
+                # 有结果后停止
+                if result_array:
+                    break
+            except Exception as err:
+                logger.error(f"{site.get('name')} 搜索出错：{err}")
 
         # 索引花费的时间
         seconds = round((datetime.now() - start_time).seconds, 1)
@@ -112,15 +114,13 @@ class IndexerModule(_ModuleBase):
 
     @staticmethod
     def __spider_search(indexer: CommentedMap,
-                        keyword: str = None,
-                        imdbid: str = None,
+                        search_word: str = None,
                         mtype: MediaType = None,
                         page: int = 0) -> (bool, List[dict]):
         """
         根据关键字搜索单个站点
         :param: indexer: 站点配置
-        :param: keyword: 关键字
-        :param: imdbid: imdbid
+        :param: search_word: 关键字
         :param: page: 页码
         :param: mtype: 媒体类型
         :param: timeout: 超时时间
@@ -128,8 +128,7 @@ class IndexerModule(_ModuleBase):
         """
         _spider = TorrentSpider(indexer=indexer,
                                 mtype=mtype,
-                                keyword=keyword,
-                                imdbid=imdbid,
+                                keyword=search_word,
                                 page=page)
 
         return _spider.is_error, _spider.get_torrents()

app/modules/indexer/spider.py

@@ -40,8 +40,6 @@ class TorrentSpider:
     referer: str = None
     # 搜索关键字
     keyword: str = None
-    # 搜索IMDBID
-    imdbid: str = None
     # 媒体类型
     mtype: MediaType = None
     # 搜索路径、方式配置
@@ -68,7 +66,6 @@ class TorrentSpider:
     def __init__(self,
                  indexer: CommentedMap,
                  keyword: [str, list] = None,
-                 imdbid: str = None,
                  page: int = 0,
                  referer: str = None,
                  mtype: MediaType = None):
@@ -76,7 +73,6 @@ class TorrentSpider:
         设置查询参数
         :param indexer: 索引器
         :param keyword: 搜索关键字，如果数组则为批量搜索
-        :param imdbid: IMDB ID
         :param page: 页码
         :param referer: Referer
         :param mtype: 媒体类型
@@ -84,7 +80,6 @@ class TorrentSpider:
         if not indexer:
             return
         self.keyword = keyword
-        self.imdbid = imdbid
         self.mtype = mtype
         self.indexerid = indexer.get('id')
         self.indexername = indexer.get('name')
@@ -159,20 +154,17 @@ class TorrentSpider:
             # 搜索URL
             indexer_params = self.search.get("params") or {}
             if indexer_params:
-                # 支持IMDBID时优先使用IMDBID搜索
-                search_area = indexer_params.get("search_area") or 0
-                if self.imdbid and search_area:
-                    search_word = self.imdbid
-                else:
-                    search_word = self.keyword
-                    # 不启用IMDBID搜索时需要将search_area移除
-                    if search_area:
-                        indexer_params.pop('search_area')
+                search_area = indexer_params.get('search_area')
+                # search_area非0表示支持imdbid搜索
+                if (search_area and
+                        (not self.keyword or not self.keyword.startswith('tt'))):
+                    # 支持imdbid搜索，但关键字不是imdbid时，不启用imdbid搜索
+                    indexer_params.pop('search_area')
                 # 变量字典
                 inputs_dict = {
                     "keyword": search_word
                 }
-                # 查询参数
+                # 查询参数，默认查询标题
                 params = {
                     "search_mode": search_mode,
                     "search_area": 0,

app/modules/indexer/tnode.py

@@ -49,16 +49,16 @@ class TNodeSpider:
             if csrf_token:
                 self._token = csrf_token.group(1)
 
-    def search(self, keyword: str, imdbid: str = None, page: int = 0) -> Tuple[bool, List[dict]]:
+    def search(self, keyword: str, page: int = 0) -> Tuple[bool, List[dict]]:
         if not self._token:
             logger.warn(f"{self._name} 未获取到token，无法搜索")
             return True, []
-        search_type = "imdbid" if imdbid else "title"
+        search_type = "imdbid" if (keyword and keyword.startswith('tt')) else "title"
         params = {
             "page": int(page) + 1,
             "size": self._size,
             "type": search_type,
-            "keyword": imdbid or keyword or "",
+            "keyword": keyword or "",
             "sorter": "id",
             "order": "desc",
             "tags": [],

app/modules/jellyfin/__init__.py

@@ -6,7 +6,6 @@ from app.core.context import MediaInfo
 from app.log import logger
 from app.modules import _ModuleBase
 from app.modules.jellyfin.jellyfin import Jellyfin
-from app.schemas import ExistMediaInfo, WebhookEventInfo
 from app.schemas.types import MediaType
 
 
@@ -40,7 +39,7 @@ class JellyfinModule(_ModuleBase):
         # Jellyfin认证
         return self.jellyfin.authenticate(name, password)
 
-    def webhook_parser(self, body: Any, form: Any, args: Any) -> Optional[WebhookEventInfo]:
+    def webhook_parser(self, body: Any, form: Any, args: Any) -> Optional[schemas.WebhookEventInfo]:
         """
         解析Webhook报文体
         :param body:  请求体
@@ -50,7 +49,7 @@ class JellyfinModule(_ModuleBase):
         """
         return self.jellyfin.get_webhook_message(body)
 
-    def media_exists(self, mediainfo: MediaInfo, itemid: str = None) -> Optional[ExistMediaInfo]:
+    def media_exists(self, mediainfo: MediaInfo, itemid: str = None) -> Optional[schemas.ExistMediaInfo]:
         """
         判断媒体文件是否存在
         :param mediainfo:  识别的媒体信息
@@ -62,25 +61,38 @@ class JellyfinModule(_ModuleBase):
                 movie = self.jellyfin.get_iteminfo(itemid)
                 if movie:
                     logger.info(f"媒体库中已存在：{movie}")
-                    return ExistMediaInfo(type=MediaType.MOVIE)
+                    return schemas.ExistMediaInfo(
+                        type=MediaType.MOVIE,
+                        server="jellyfin",
+                        itemid=movie.item_id
+                    )
             movies = self.jellyfin.get_movies(title=mediainfo.title, year=mediainfo.year, tmdb_id=mediainfo.tmdb_id)
             if not movies:
                 logger.info(f"{mediainfo.title_year} 在媒体库中不存在")
                 return None
             else:
                 logger.info(f"媒体库中已存在：{movies}")
-                return ExistMediaInfo(type=MediaType.MOVIE)
+                return schemas.ExistMediaInfo(
+                    type=MediaType.MOVIE,
+                    server="jellyfin",
+                    itemid=movies[0].item_id
+                )
         else:
-            tvs = self.jellyfin.get_tv_episodes(title=mediainfo.title,
-                                                year=mediainfo.year,
-                                                tmdb_id=mediainfo.tmdb_id,
-                                                item_id=itemid)
+            itemid, tvs = self.jellyfin.get_tv_episodes(title=mediainfo.title,
+                                                        year=mediainfo.year,
+                                                        tmdb_id=mediainfo.tmdb_id,
+                                                        item_id=itemid)
             if not tvs:
                 logger.info(f"{mediainfo.title_year} 在媒体库中不存在")
                 return None
             else:
                 logger.info(f"{mediainfo.title_year} 媒体库中已存在：{tvs}")
-                return ExistMediaInfo(type=MediaType.TV, seasons=tvs)
+                return schemas.ExistMediaInfo(
+                    type=MediaType.TV,
+                    seasons=tvs,
+                    server="jellyfin",
+                    itemid=itemid
+                )
 
     def refresh_mediaserver(self, mediainfo: MediaInfo, file_path: Path) -> None:
         """
@@ -96,13 +108,8 @@ class JellyfinModule(_ModuleBase):
         媒体数量统计
         """
         media_statistic = self.jellyfin.get_medias_count()
-        user_count = self.jellyfin.get_user_count()
-        return [schemas.Statistic(
-            movie_count=media_statistic.get("MovieCount") or 0,
-            tv_count=media_statistic.get("SeriesCount") or 0,
-            episode_count=media_statistic.get("EpisodeCount") or 0,
-            user_count=user_count or 0
-        )]
+        media_statistic.user_count = self.jellyfin.get_user_count()
+        return [media_statistic]
 
     def mediaserver_librarys(self, server: str) -> Optional[List[schemas.MediaServerLibrary]]:
         """
@@ -110,16 +117,7 @@ class JellyfinModule(_ModuleBase):
         """
         if server != "jellyfin":
             return None
-        librarys = self.jellyfin.get_librarys()
-        if not librarys:
-            return []
-        return [schemas.MediaServerLibrary(
-            server="jellyfin",
-            id=library.get("id"),
-            name=library.get("name"),
-            type=library.get("type"),
-            path=library.get("path")
-        ) for library in librarys]
+        return self.jellyfin.get_librarys()
 
     def mediaserver_items(self, server: str, library_id: str) -> Optional[Generator]:
         """
@@ -127,21 +125,15 @@ class JellyfinModule(_ModuleBase):
         """
         if server != "jellyfin":
             return None
-        items = self.jellyfin.get_items(library_id)
-        for item in items:
-            yield schemas.MediaServerItem(
-                server="jellyfin",
-                library=item.get("library"),
-                item_id=item.get("id"),
-                item_type=item.get("type"),
-                title=item.get("title"),
-                original_title=item.get("original_title"),
-                year=item.get("year"),
-                tmdbid=item.get("tmdbid"),
-                imdbid=item.get("imdbid"),
-                tvdbid=item.get("tvdbid"),
-                path=item.get("path"),
-            )
+        return self.jellyfin.get_items(library_id)
+
+    def mediaserver_iteminfo(self, server: str, item_id: str) -> Optional[schemas.MediaServerItem]:
+        """
+        媒体库项目详情
+        """
+        if server != "jellyfin":
+            return None
+        return self.jellyfin.get_iteminfo(item_id)
 
     def mediaserver_tv_episodes(self, server: str,
                                 item_id: Union[str, int]) -> Optional[List[schemas.MediaServerSeasonInfo]]:
@@ -150,7 +142,7 @@ class JellyfinModule(_ModuleBase):
         """
         if server != "jellyfin":
             return None
-        seasoninfo = self.jellyfin.get_tv_episodes(item_id=item_id)
+        _, seasoninfo = self.jellyfin.get_tv_episodes(item_id=item_id)
         if not seasoninfo:
             return []
         return [schemas.MediaServerSeasonInfo(

app/modules/jellyfin/jellyfin.py

@@ -1,15 +1,14 @@
 import json
-import re
-from typing import List, Union, Optional, Dict, Generator
+from typing import List, Union, Optional, Dict, Generator, Tuple
 
 from requests import Response
 
+from app import schemas
 from app.core.config import settings
 from app.log import logger
-from app.schemas import MediaType, WebhookEventInfo
+from app.schemas import MediaType
 from app.utils.http import RequestUtils
 from app.utils.singleton import Singleton
-from app.utils.string import StringUtils
 
 
 class Jellyfin(metaclass=Singleton):
@@ -73,12 +72,14 @@ class Jellyfin(metaclass=Singleton):
                     library_type = MediaType.TV.value
                 case _:
                     continue
-            libraries.append({
-                "id": library.get("Id"),
-                "name": library.get("Name"),
-                "path": library.get("Path"),
-                "type": library_type
-            })
+            libraries.append(
+                schemas.MediaServerLibrary(
+                    server="jellyfin",
+                    id=library.get("Id"),
+                    name=library.get("Name"),
+                    path=library.get("Path"),
+                    type=library_type
+                ))
         return libraries
 
     def get_user_count(self) -> int:
@@ -179,59 +180,29 @@ class Jellyfin(metaclass=Singleton):
             logger.error(f"连接System/Info出错：" + str(e))
         return None
 
-    def get_activity_log(self, num: int = 30) -> List[dict]:
-        """
-        获取Jellyfin活动记录
-        """
-        if not self._host or not self._apikey:
-            return []
-        req_url = "%sSystem/ActivityLog/Entries?api_key=%s&Limit=%s" % (self._host, self._apikey, num)
-        ret_array = []
-        try:
-            res = RequestUtils().get_res(req_url)
-            if res:
-                ret_json = res.json()
-                items = ret_json.get('Items')
-                for item in items:
-                    if item.get("Type") == "SessionStarted":
-                        event_type = "LG"
-                        event_date = re.sub(r'\dZ', 'Z', item.get("Date"))
-                        event_str = "%s, %s" % (item.get("Name"), item.get("ShortOverview"))
-                        activity = {"type": event_type, "event": event_str,
-                                    "date": StringUtils.get_time(event_date)}
-                        ret_array.append(activity)
-                    if item.get("Type") in ["VideoPlayback", "VideoPlaybackStopped"]:
-                        event_type = "PL"
-                        event_date = re.sub(r'\dZ', 'Z', item.get("Date"))
-                        activity = {"type": event_type, "event": item.get("Name"),
-                                    "date": StringUtils.get_time(event_date)}
-                        ret_array.append(activity)
-            else:
-                logger.error(f"System/ActivityLog/Entries 未获取到返回数据")
-                return []
-        except Exception as e:
-            logger.error(f"连接System/ActivityLog/Entries出错：" + str(e))
-            return []
-        return ret_array
-
-    def get_medias_count(self) -> Optional[dict]:
+    def get_medias_count(self) -> schemas.Statistic:
         """
         获得电影、电视剧、动漫媒体数量
         :return: MovieCount SeriesCount SongCount
         """
         if not self._host or not self._apikey:
-            return None
+            return schemas.Statistic()
         req_url = "%sItems/Counts?api_key=%s" % (self._host, self._apikey)
         try:
             res = RequestUtils().get_res(req_url)
             if res:
-                return res.json()
+                result = res.json()
+                return schemas.Statistic(
+                    movie_count=result.get("MovieCount") or 0,
+                    tv_count=result.get("SeriesCount") or 0,
+                    episode_count=result.get("EpisodeCount") or 0
+                )
             else:
                 logger.error(f"Items/Counts 未获取到返回数据")
-                return {}
+                return schemas.Statistic()
         except Exception as e:
             logger.error(f"连接Items/Counts出错：" + str(e))
-            return {}
+        return schemas.Statistic()
 
     def __get_jellyfin_series_id_by_name(self, name: str, year: str) -> Optional[str]:
         """
@@ -239,7 +210,8 @@ class Jellyfin(metaclass=Singleton):
         """
         if not self._host or not self._apikey or not self.user:
             return None
-        req_url = "%sUsers/%s/Items?api_key=%s&searchTerm=%s&IncludeItemTypes=Series&Limit=10&Recursive=true" % (
+        req_url = ("%sUsers/%s/Items?"
+                   "api_key=%s&searchTerm=%s&IncludeItemTypes=Series&Limit=10&Recursive=true") % (
             self._host, self.user, self._apikey, name)
         try:
             res = RequestUtils().get_res(req_url)
@@ -258,7 +230,7 @@ class Jellyfin(metaclass=Singleton):
     def get_movies(self, 
                    title: str, 
                    year: str = None,
-                   tmdb_id: int = None) -> Optional[List[dict]]:
+                   tmdb_id: int = None) -> Optional[List[schemas.MediaServerItem]]:
         """
         根据标题和年份，检查电影是否在Jellyfin中存在，存在则返回列表
         :param title: 标题
@@ -268,7 +240,8 @@ class Jellyfin(metaclass=Singleton):
         """
         if not self._host or not self._apikey or not self.user:
             return None
-        req_url = "%sUsers/%s/Items?api_key=%s&searchTerm=%s&IncludeItemTypes=Movie&Limit=10&Recursive=true" % (
+        req_url = ("%sUsers/%s/Items?"
+                   "api_key=%s&searchTerm=%s&IncludeItemTypes=Movie&Limit=10&Recursive=true") % (
             self._host, self.user, self._apikey, title)
         try:
             res = RequestUtils().get_res(req_url)
@@ -276,19 +249,30 @@ class Jellyfin(metaclass=Singleton):
                 res_items = res.json().get("Items")
                 if res_items:
                     ret_movies = []
-                    for res_item in res_items:
-                        item_tmdbid = res_item.get("ProviderIds", {}).get("Tmdb")
+                    for item in res_items:
+                        item_tmdbid = item.get("ProviderIds", {}).get("Tmdb")
+                        mediaserver_item = schemas.MediaServerItem(
+                            server="jellyfin",
+                            library=item.get("ParentId"),
+                            item_id=item.get("Id"),
+                            item_type=item.get("Type"),
+                            title=item.get("Name"),
+                            original_title=item.get("OriginalTitle"),
+                            year=item.get("ProductionYear"),
+                            tmdbid=int(item_tmdbid) if item_tmdbid else None,
+                            imdbid=item.get("ProviderIds", {}).get("Imdb"),
+                            tvdbid=item.get("ProviderIds", {}).get("Tvdb"),
+                            path=item.get("Path")
+                        )
                         if tmdb_id and item_tmdbid:
                             if str(item_tmdbid) != str(tmdb_id):
                                 continue
                             else:
-                                ret_movies.append(
-                                    {'title': res_item.get('Name'), 'year': str(res_item.get('ProductionYear'))})
+                                ret_movies.append(mediaserver_item)
                                 continue
-                        if res_item.get('Name') == title and (
-                                not year or str(res_item.get('ProductionYear')) == str(year)):
-                            ret_movies.append(
-                                {'title': res_item.get('Name'), 'year': str(res_item.get('ProductionYear'))})
+                        if mediaserver_item.title == title and (
+                                not year or str(mediaserver_item.year) == str(year)):
+                            ret_movies.append(mediaserver_item)
                     return ret_movies
         except Exception as e:
             logger.error(f"连接Items出错：" + str(e))
@@ -300,7 +284,7 @@ class Jellyfin(metaclass=Singleton):
                         title: str = None,
                         year: str = None,
                         tmdb_id: int = None,
-                        season: int = None) -> Optional[Dict[int, list]]:
+                        season: int = None) -> Tuple[Optional[str], Optional[Dict[int, list]]]:
         """
         根据标题和年份和季，返回Jellyfin中的剧集列表
         :param item_id: Jellyfin中的Id
@@ -311,19 +295,20 @@ class Jellyfin(metaclass=Singleton):
         :return: 集号的列表
         """
         if not self._host or not self._apikey or not self.user:
-            return None
+            return None, None
         # 查TVID
         if not item_id:
             item_id = self.__get_jellyfin_series_id_by_name(title, year)
             if item_id is None:
-                return None
+                return None, None
             if not item_id:
-                return {}
+                return None, {}
         # 验证tmdbid是否相同
-        item_tmdbid = (self.get_iteminfo(item_id).get("ProviderIds") or {}).get("Tmdb")
-        if tmdb_id and item_tmdbid:
-            if str(tmdb_id) != str(item_tmdbid):
-                return {}
+        item_info = self.get_iteminfo(item_id)
+        if item_info:
+            if tmdb_id and item_info.tmdbid:
+                if str(tmdb_id) != str(item_info.tmdbid):
+                    return None, {}
         if not season:
             season = ""
         try:
@@ -331,7 +316,8 @@ class Jellyfin(metaclass=Singleton):
                 self._host, item_id, season, self.user, self._apikey)
             res_json = RequestUtils().get_res(req_url)
             if res_json:
-                res_items = res_json.json().get("Items")
+                tv_info = res_json.json()
+                res_items = tv_info.get("Items")
                 # 返回的季集信息
                 season_episodes = {}
                 for res_item in res_items:
@@ -346,11 +332,11 @@ class Jellyfin(metaclass=Singleton):
                     if not season_episodes.get(season_index):
                         season_episodes[season_index] = []
                     season_episodes[season_index].append(episode_index)
-                return season_episodes
+                return tv_info.get('Id'), season_episodes
         except Exception as e:
             logger.error(f"连接Shows/Id/Episodes出错：" + str(e))
-            return None
-        return {}
+            return None, None
+        return None, {}
 
     def get_remote_image_by_id(self, item_id: str, image_type: str) -> Optional[str]:
         """
@@ -394,7 +380,7 @@ class Jellyfin(metaclass=Singleton):
             logger.error(f"连接Library/Refresh出错：" + str(e))
             return False
 
-    def get_webhook_message(self, body: any) -> Optional[WebhookEventInfo]:
+    def get_webhook_message(self, body: any) -> Optional[schemas.WebhookEventInfo]:
         """
         解析Jellyfin报文
         {
@@ -470,7 +456,7 @@ class Jellyfin(metaclass=Singleton):
         eventType = message.get('NotificationType')
         if not eventType:
             return None
-        eventItem = WebhookEventInfo(
+        eventItem = schemas.WebhookEventInfo(
             event=eventType,
             channel="jellyfin"
         )
@@ -506,32 +492,46 @@ class Jellyfin(metaclass=Singleton):
 
         return eventItem
 
-    def get_iteminfo(self, itemid: str) -> dict:
+    def get_iteminfo(self, itemid: str) -> Optional[schemas.MediaServerItem]:
         """
         获取单个项目详情
         """
         if not itemid:
-            return {}
+            return None
         if not self._host or not self._apikey:
-            return {}
+            return None
         req_url = "%sUsers/%s/Items/%s?api_key=%s" % (
             self._host, self.user, itemid, self._apikey)
         try:
             res = RequestUtils().get_res(req_url)
             if res and res.status_code == 200:
-                return res.json()
+                item = res.json()
+                tmdbid = item.get("ProviderIds", {}).get("Tmdb")
+                return schemas.MediaServerItem(
+                    server="jellyfin",
+                    library=item.get("ParentId"),
+                    item_id=item.get("Id"),
+                    item_type=item.get("Type"),
+                    title=item.get("Name"),
+                    original_title=item.get("OriginalTitle"),
+                    year=item.get("ProductionYear"),
+                    tmdbid=int(tmdbid) if tmdbid else None,
+                    imdbid=item.get("ProviderIds", {}).get("Imdb"),
+                    tvdbid=item.get("ProviderIds", {}).get("Tvdb"),
+                    path=item.get("Path")
+                )
         except Exception as e:
             logger.error(f"连接Users/Items出错：" + str(e))
-            return {}
+        return None
 
     def get_items(self, parent: str) -> Generator:
         """
         获取媒体服务器所有媒体库列表
         """
         if not parent:
-            yield {}
+            yield None
         if not self._host or not self._apikey:
-            yield {}
+            yield None
         req_url = "%sUsers/%s/Items?parentId=%s&api_key=%s" % (self._host, self.user, parent, self._apikey)
         try:
             res = RequestUtils().get_res(req_url)
@@ -541,37 +541,46 @@ class Jellyfin(metaclass=Singleton):
                     if not result:
                         continue
                     if result.get("Type") in ["Movie", "Series"]:
-                        item_info = self.get_iteminfo(result.get("Id"))
-                        yield {"id": result.get("Id"),
-                               "library": item_info.get("ParentId"),
-                               "type": item_info.get("Type"),
-                               "title": item_info.get("Name"),
-                               "original_title": item_info.get("OriginalTitle"),
-                               "year": item_info.get("ProductionYear"),
-                               "tmdbid": item_info.get("ProviderIds", {}).get("Tmdb"),
-                               "imdbid": item_info.get("ProviderIds", {}).get("Imdb"),
-                               "tvdbid": item_info.get("ProviderIds", {}).get("Tvdb"),
-                               "path": item_info.get("Path"),
-                               "json": str(item_info)}
+                        yield self.get_iteminfo(result.get("Id"))
                     elif "Folder" in result.get("Type"):
                         for item in self.get_items(result.get("Id")):
                             yield item
         except Exception as e:
             logger.error(f"连接Users/Items出错：" + str(e))
-        yield {}
+        yield None
 
     def get_data(self, url: str) -> Optional[Response]:
         """
-        自定义URL从媒体服务器获取数据，其中{HOST}、{APIKEY}、{USER}会被替换成实际的值
+        自定义URL从媒体服务器获取数据，其中[HOST]、[APIKEY]、[USER]会被替换成实际的值
         :param url: 请求地址
         """
         if not self._host or not self._apikey:
             return None
-        url = url.replace("{HOST}", self._host) \
-            .replace("{APIKEY}", self._apikey) \
-            .replace("{USER}", self.user)
+        url = url.replace("[HOST]", self._host) \
+            .replace("[APIKEY]", self._apikey) \
+            .replace("[USER]", self.user)
         try:
-            return RequestUtils().get_res(url=url)
+            return RequestUtils(accept_type="application/json").get_res(url=url)
+        except Exception as e:
+            logger.error(f"连接Jellyfin出错：" + str(e))
+            return None
+
+    def post_data(self, url: str, data: str = None, headers: dict = None) -> Optional[Response]:
+        """
+        自定义URL从媒体服务器获取数据，其中[HOST]、[APIKEY]、[USER]会被替换成实际的值
+        :param url: 请求地址
+        :param data: 请求数据
+        :param headers: 请求头
+        """
+        if not self._host or not self._apikey:
+            return None
+        url = url.replace("[HOST]", self._host) \
+            .replace("[APIKEY]", self._apikey) \
+            .replace("[USER]", self.user)
+        try:
+            return RequestUtils(
+                headers=headers
+            ).post_res(url=url, data=data)
         except Exception as e:
             logger.error(f"连接Jellyfin出错：" + str(e))
             return None

app/modules/plex/__init__.py

@@ -6,12 +6,10 @@ from app.core.context import MediaInfo
 from app.log import logger
 from app.modules import _ModuleBase
 from app.modules.plex.plex import Plex
-from app.schemas import ExistMediaInfo, RefreshMediaItem, WebhookEventInfo
 from app.schemas.types import MediaType
 
 
 class PlexModule(_ModuleBase):
-
     plex: Plex = None
 
     def init_module(self) -> None:
@@ -31,7 +29,7 @@ class PlexModule(_ModuleBase):
         if not self.plex.is_inactive():
             self.plex.reconnect()
 
-    def webhook_parser(self, body: Any, form: Any, args: Any) -> Optional[WebhookEventInfo]:
+    def webhook_parser(self, body: Any, form: Any, args: Any) -> Optional[schemas.WebhookEventInfo]:
         """
         解析Webhook报文体
         :param body:  请求体
@@ -41,7 +39,7 @@ class PlexModule(_ModuleBase):
         """
         return self.plex.get_webhook_message(form)
 
-    def media_exists(self, mediainfo: MediaInfo, itemid: str = None) -> Optional[ExistMediaInfo]:
+    def media_exists(self, mediainfo: MediaInfo, itemid: str = None) -> Optional[schemas.ExistMediaInfo]:
         """
         判断媒体文件是否存在
         :param mediainfo:  识别的媒体信息
@@ -53,29 +51,42 @@ class PlexModule(_ModuleBase):
                 movie = self.plex.get_iteminfo(itemid)
                 if movie:
                     logger.info(f"媒体库中已存在：{movie}")
-                    return ExistMediaInfo(type=MediaType.MOVIE)
+                    return schemas.ExistMediaInfo(
+                        type=MediaType.MOVIE,
+                        server="plex",
+                        itemid=movie.item_id
+                    )
             movies = self.plex.get_movies(title=mediainfo.title,
-                                          original_title=mediainfo.original_title, 
-                                          year=mediainfo.year, 
+                                          original_title=mediainfo.original_title,
+                                          year=mediainfo.year,
                                           tmdb_id=mediainfo.tmdb_id)
             if not movies:
                 logger.info(f"{mediainfo.title_year} 在媒体库中不存在")
                 return None
             else:
                 logger.info(f"媒体库中已存在：{movies}")
-                return ExistMediaInfo(type=MediaType.MOVIE)
+                return schemas.ExistMediaInfo(
+                    type=MediaType.MOVIE,
+                    server="plex",
+                    itemid=movies[0].item_id
+                )
         else:
-            tvs = self.plex.get_tv_episodes(title=mediainfo.title,
-                                            original_title=mediainfo.original_title,
-                                            year=mediainfo.year,
-                                            tmdb_id=mediainfo.tmdb_id,
-                                            item_id=itemid)
+            item_id, tvs = self.plex.get_tv_episodes(title=mediainfo.title,
+                                                     original_title=mediainfo.original_title,
+                                                     year=mediainfo.year,
+                                                     tmdb_id=mediainfo.tmdb_id,
+                                                     item_id=itemid)
             if not tvs:
                 logger.info(f"{mediainfo.title_year} 在媒体库中不存在")
                 return None
             else:
                 logger.info(f"{mediainfo.title_year} 媒体库中已存在：{tvs}")
-                return ExistMediaInfo(type=MediaType.TV, seasons=tvs)
+                return schemas.ExistMediaInfo(
+                    type=MediaType.TV,
+                    seasons=tvs,
+                    server="plex",
+                    itemid=item_id
+                )
 
     def refresh_mediaserver(self, mediainfo: MediaInfo, file_path: Path) -> None:
         """
@@ -85,7 +96,7 @@ class PlexModule(_ModuleBase):
         :return: 成功或失败
         """
         items = [
-            RefreshMediaItem(
+            schemas.RefreshMediaItem(
                 title=mediainfo.title,
                 year=mediainfo.year,
                 type=mediainfo.type,
@@ -100,12 +111,8 @@ class PlexModule(_ModuleBase):
         媒体数量统计
         """
         media_statistic = self.plex.get_medias_count()
-        return [schemas.Statistic(
-            movie_count=media_statistic.get("MovieCount") or 0,
-            tv_count=media_statistic.get("SeriesCount") or 0,
-            episode_count=media_statistic.get("EpisodeCount") or 0,
-            user_count=1
-        )]
+        media_statistic.user_count = 1
+        return [media_statistic]
 
     def mediaserver_librarys(self, server: str) -> Optional[List[schemas.MediaServerLibrary]]:
         """
@@ -113,16 +120,7 @@ class PlexModule(_ModuleBase):
         """
         if server != "plex":
             return None
-        librarys = self.plex.get_librarys()
-        if not librarys:
-            return []
-        return [schemas.MediaServerLibrary(
-            server="plex",
-            id=library.get("id"),
-            name=library.get("name"),
-            type=library.get("type"),
-            path=library.get("path")
-        ) for library in librarys]
+        return self.plex.get_librarys()
 
     def mediaserver_items(self, server: str, library_id: str) -> Optional[Generator]:
         """
@@ -130,21 +128,15 @@ class PlexModule(_ModuleBase):
         """
         if server != "plex":
             return None
-        items = self.plex.get_items(library_id)
-        for item in items:
-            yield schemas.MediaServerItem(
-                server="plex",
-                library=item.get("library"),
-                item_id=item.get("id"),
-                item_type=item.get("type"),
-                title=item.get("title"),
-                original_title=item.get("original_title"),
-                year=item.get("year"),
-                tmdbid=item.get("tmdbid"),
-                imdbid=item.get("imdbid"),
-                tvdbid=item.get("tvdbid"),
-                path=item.get("path"),
-            )
+        return self.plex.get_items(library_id)
+
+    def mediaserver_iteminfo(self, server: str, item_id: str) -> Optional[schemas.MediaServerItem]:
+        """
+        媒体库项目详情
+        """
+        if server != "plex":
+            return None
+        return self.plex.get_iteminfo(item_id)
 
     def mediaserver_tv_episodes(self, server: str,
                                 item_id: Union[str, int]) -> Optional[List[schemas.MediaServerSeasonInfo]]:
@@ -153,7 +145,7 @@ class PlexModule(_ModuleBase):
         """
         if server != "plex":
             return None
-        seasoninfo = self.plex.get_tv_episodes(item_id=item_id)
+        _, seasoninfo = self.plex.get_tv_episodes(item_id=item_id)
         if not seasoninfo:
             return []
         return [schemas.MediaServerSeasonInfo(

app/modules/plex/plex.py

@@ -6,9 +6,10 @@ from urllib.parse import quote_plus
 from plexapi import media
 from plexapi.server import PlexServer
 
+from app import schemas
 from app.core.config import settings
 from app.log import logger
-from app.schemas import RefreshMediaItem, MediaType, WebhookEventInfo
+from app.schemas import MediaType
 from app.utils.singleton import Singleton
 
 
@@ -49,7 +50,7 @@ class Plex(metaclass=Singleton):
             self._plex = None
             logger.error(f"Plex服务器连接失败：{str(e)}")
 
-    def get_librarys(self):
+    def get_librarys(self) -> List[schemas.MediaServerLibrary]:
         """
         获取媒体服务器所有媒体库列表
         """
@@ -69,81 +70,42 @@ class Plex(metaclass=Singleton):
                     library_type = MediaType.TV.value
                 case _:
                     continue
-            libraries.append({
-                "id": library.key,
-                "name": library.title,
-                "path": library.locations,
-                "type": library_type
-            })
+            libraries.append(
+                schemas.MediaServerLibrary(
+                    id=library.key,
+                    name=library.title,
+                    path=library.locations,
+                    type=library_type
+                )
+            )
         return libraries
 
-    def get_activity_log(self, num: int = 30) -> Optional[List[dict]]:
-        """
-        获取Plex活动记录
-        """
-        if not self._plex:
-            return []
-        ret_array = []
-        try:
-            # type的含义: 1 电影 4 剧集单集 详见 plexapi/utils.py中SEARCHTYPES的定义
-            # 根据最后播放时间倒序获取数据
-            historys = self._plex.library.search(sort='lastViewedAt:desc', limit=num, type='1,4')
-            for his in historys:
-                # 过滤掉最后播放时间为空的
-                if his.lastViewedAt:
-                    if his.type == "episode":
-                        event_title = "%s %s%s %s" % (
-                            his.grandparentTitle,
-                            "S" + str(his.parentIndex),
-                            "E" + str(his.index),
-                            his.title
-                        )
-                        event_str = "开始播放剧集 %s" % event_title
-                    else:
-                        event_title = "%s %s" % (
-                            his.title, "(" + str(his.year) + ")")
-                        event_str = "开始播放电影 %s" % event_title
-
-                    event_type = "PL"
-                    event_date = his.lastViewedAt.strftime('%Y-%m-%d %H:%M:%S')
-                    activity = {"type": event_type, "event": event_str, "date": event_date}
-                    ret_array.append(activity)
-        except Exception as e:
-            logger.error(f"连接System/ActivityLog/Entries出错：" + str(e))
-            return []
-        if ret_array:
-            ret_array = sorted(ret_array, key=lambda x: x['date'], reverse=True)
-        return ret_array
-
-    def get_medias_count(self) -> dict:
+    def get_medias_count(self) -> schemas.Statistic:
         """
         获得电影、电视剧、动漫媒体数量
         :return: MovieCount SeriesCount SongCount
         """
         if not self._plex:
-            return {}
+            return schemas.Statistic()
         sections = self._plex.library.sections()
-        MovieCount = SeriesCount = SongCount = EpisodeCount = 0
+        MovieCount = SeriesCount = EpisodeCount = 0
         for sec in sections:
             if sec.type == "movie":
                 MovieCount += sec.totalSize
             if sec.type == "show":
                 SeriesCount += sec.totalSize
                 EpisodeCount += sec.totalViewSize(libtype='episode')
-            if sec.type == "artist":
-                SongCount += sec.totalSize
-        return {
-            "MovieCount": MovieCount,
-            "SeriesCount": SeriesCount,
-            "SongCount": SongCount,
-            "EpisodeCount": EpisodeCount
-        }
+        return schemas.Statistic(
+            movie_count=MovieCount,
+            tv_count=SeriesCount,
+            episode_count=EpisodeCount
+        )
 
-    def get_movies(self, 
-                   title: str, 
+    def get_movies(self,
+                   title: str,
                    original_title: str = None,
                    year: str = None,
-                   tmdb_id: int = None) -> Optional[List[dict]]:
+                   tmdb_id: int = None) -> Optional[List[schemas.MediaServerItem]]:
         """
         根据标题和年份，检查电影是否在Plex中存在，存在则返回列表
         :param title: 标题
@@ -156,20 +118,43 @@ class Plex(metaclass=Singleton):
             return None
         ret_movies = []
         if year:
-            movies = self._plex.library.search(title=title, year=year, libtype="movie")
+            movies = self._plex.library.search(title=title,
+                                               year=year,
+                                               libtype="movie")
             # 根据原标题再查一遍
             if original_title and str(original_title) != str(title):
-                movies.extend(self._plex.library.search(title=original_title, year=year, libtype="movie"))
+                movies.extend(self._plex.library.search(title=original_title,
+                                                        year=year,
+                                                        libtype="movie"))
         else:
-            movies = self._plex.library.search(title=title, libtype="movie")
+            movies = self._plex.library.search(title=title,
+                                               libtype="movie")
             if original_title and str(original_title) != str(title):
-                movies.extend(self._plex.library.search(title=original_title, year=year, libtype="movie"))
-        for movie in set(movies):
-            movie_tmdbid = self.__get_ids(movie.guids).get("tmdb_id")
-            if tmdb_id and movie_tmdbid:
-                if str(movie_tmdbid) != str(tmdb_id):
+                movies.extend(self._plex.library.search(title=original_title,
+                                                        libtype="movie"))
+        for item in set(movies):
+            ids = self.__get_ids(item.guids)
+            if tmdb_id and ids['tmdb_id']:
+                if str(ids['tmdb_id']) != str(tmdb_id):
                     continue
-            ret_movies.append({'title': movie.title, 'year': movie.year})
+            path = None
+            if item.locations:
+                path = item.locations[0]
+            ret_movies.append(
+                schemas.MediaServerItem(
+                    server="plex",
+                    library=item.librarySectionID,
+                    item_id=item.key,
+                    item_type=item.type,
+                    title=item.title,
+                    original_title=item.originalTitle,
+                    year=item.year,
+                    tmdbid=ids['tmdb_id'],
+                    imdbid=ids['imdb_id'],
+                    tvdbid=ids['tvdb_id'],
+                    path=path,
+                )
+            )
         return ret_movies
 
     def get_tv_episodes(self,
@@ -178,7 +163,7 @@ class Plex(metaclass=Singleton):
                         original_title: str = None,
                         year: str = None,
                         tmdb_id: int = None,
-                        season: int = None) -> Optional[Dict[int, list]]:
+                        season: int = None) -> Tuple[Optional[str], Optional[Dict[int, list]]]:
         """
         根据标题、年份、季查询电视剧所有集信息
         :param item_id: 媒体ID
@@ -190,22 +175,28 @@ class Plex(metaclass=Singleton):
         :return: 所有集的列表
         """
         if not self._plex:
-            return {}
+            return None, {}
         if item_id:
             videos = self._plex.fetchItem(item_id)
         else:
             # 根据标题和年份模糊搜索，该结果不够准确
-            videos = self._plex.library.search(title=title, year=year, libtype="show")
-            if not videos and original_title and str(original_title) != str(title):
-                videos = self._plex.library.search(title=original_title, year=year, libtype="show")
+            videos = self._plex.library.search(title=title,
+                                               year=year,
+                                               libtype="show")
+            if (not videos
+                    and original_title
+                    and str(original_title) != str(title)):
+                videos = self._plex.library.search(title=original_title,
+                                                   year=year,
+                                                   libtype="show")
         if not videos:
-            return {}
+            return None, {}
         if isinstance(videos, list):
             videos = videos[0]
         video_tmdbid = self.__get_ids(videos.guids).get('tmdb_id')
         if tmdb_id and video_tmdbid:
             if str(video_tmdbid) != str(tmdb_id):
-                return {}
+                return None, {}
         episodes = videos.episodes()
         season_episodes = {}
         for episode in episodes:
@@ -214,7 +205,7 @@ class Plex(metaclass=Singleton):
             if episode.seasonNumber not in season_episodes:
                 season_episodes[episode.seasonNumber] = []
             season_episodes[episode.seasonNumber].append(episode.index)
-        return season_episodes
+        return videos.key, season_episodes
 
     def get_remote_image_by_id(self, item_id: str, image_type: str) -> Optional[str]:
         """
@@ -227,9 +218,11 @@ class Plex(metaclass=Singleton):
             return None
         try:
             if image_type == "Poster":
-                images = self._plex.fetchItems('/library/metadata/%s/posters' % item_id, cls=media.Poster)
+                images = self._plex.fetchItems('/library/metadata/%s/posters' % item_id,
+                                               cls=media.Poster)
             else:
-                images = self._plex.fetchItems('/library/metadata/%s/arts' % item_id, cls=media.Art)
+                images = self._plex.fetchItems('/library/metadata/%s/arts' % item_id,
+                                               cls=media.Art)
             for image in images:
                 if hasattr(image, 'key') and image.key.startswith('http'):
                     return image.key
@@ -245,7 +238,7 @@ class Plex(metaclass=Singleton):
             return False
         return self._plex.library.update()
 
-    def refresh_library_by_items(self, items: List[RefreshMediaItem]) -> bool:
+    def refresh_library_by_items(self, items: List[schemas.RefreshMediaItem]) -> bool:
         """
         按路径刷新媒体库 item: target_path
         """
@@ -294,19 +287,34 @@ class Plex(metaclass=Singleton):
             logger.error(f"查找媒体库出错：{err}")
         return "", ""
 
-    def get_iteminfo(self, itemid: str) -> dict:
+    def get_iteminfo(self, itemid: str) -> Optional[schemas.MediaServerItem]:
         """
         获取单个项目详情
         """
         if not self._plex:
-            return {}
+            return None
         try:
             item = self._plex.fetchItem(itemid)
             ids = self.__get_ids(item.guids)
-            return {'ProviderIds': {'Tmdb': ids['tmdb_id'], 'Imdb': ids['imdb_id']}}
+            path = None
+            if item.locations:
+                path = item.locations[0]
+            return schemas.MediaServerItem(
+                server="plex",
+                library=item.librarySectionID,
+                item_id=item.key,
+                item_type=item.type,
+                title=item.title,
+                original_title=item.originalTitle,
+                year=item.year,
+                tmdbid=ids['tmdb_id'],
+                imdbid=ids['imdb_id'],
+                tvdbid=ids['tvdb_id'],
+                path=path,
+            )
         except Exception as err:
             logger.error(f"获取项目详情出错：{err}")
-            return {}
+        return None
 
     @staticmethod
     def __get_ids(guids: List[Any]) -> dict:
@@ -337,9 +345,9 @@ class Plex(metaclass=Singleton):
         获取媒体服务器所有媒体库列表
         """
         if not parent:
-            yield {}
+            yield None
         if not self._plex:
-            yield {}
+            yield None
         try:
             section = self._plex.library.sectionByID(int(parent))
             if section:
@@ -350,21 +358,24 @@ class Plex(metaclass=Singleton):
                     path = None
                     if item.locations:
                         path = item.locations[0]
-                    yield {"id": item.key,
-                           "library": item.librarySectionID,
-                           "type": item.type,
-                           "title": item.title,
-                           "original_title": item.originalTitle,
-                           "year": item.year,
-                           "tmdbid": ids['tmdb_id'],
-                           "imdbid": ids['imdb_id'],
-                           "tvdbid": ids['tvdb_id'],
-                           "path": path}
+                    yield schemas.MediaServerItem(
+                        server="plex",
+                        library=item.librarySectionID,
+                        item_id=item.key,
+                        item_type=item.type,
+                        title=item.title,
+                        original_title=item.originalTitle,
+                        year=item.year,
+                        tmdbid=ids['tmdb_id'],
+                        imdbid=ids['imdb_id'],
+                        tvdbid=ids['tvdb_id'],
+                        path=path,
+                    )
         except Exception as err:
             logger.error(f"获取媒体库列表出错：{err}")
-        yield {}
+        yield None
 
-    def get_webhook_message(self, form: any) -> Optional[WebhookEventInfo]:
+    def get_webhook_message(self, form: any) -> Optional[schemas.WebhookEventInfo]:
         """
         解析Plex报文
         eventItem  字段的含义
@@ -413,7 +424,7 @@ class Plex(metaclass=Singleton):
             "parentTitle": "Combat Shadow Fighting Saga / Great Prison Battle Saga",
             "originalTitle": "Baki Hanma",
             "contentRating": "TV-MA",
-            "summary": "The world is shaken by news of a man taking down a monstrous elephant with his bare hands. Back in Japan, Baki is confronted by a knife-wielding child.",
+            "summary": "The world is shaken by news",
             "index": 1,
             "parentIndex": 1,
             "audienceRating": 8.5,
@@ -482,7 +493,7 @@ class Plex(metaclass=Singleton):
         if not eventType:
             return None
         logger.info(f"接收到plex webhook：{message}")
-        eventItem = WebhookEventInfo(event=eventType, channel="plex")
+        eventItem = schemas.WebhookEventInfo(event=eventType, channel="plex")
         if message.get('Metadata'):
             if message.get('Metadata', {}).get('type') == 'episode':
                 eventItem.item_type = "TV"
@@ -495,14 +506,17 @@ class Plex(metaclass=Singleton):
                 eventItem.season_id = message.get('Metadata', {}).get('parentIndex')
                 eventItem.episode_id = message.get('Metadata', {}).get('index')
 
-                if message.get('Metadata', {}).get('summary') and len(message.get('Metadata', {}).get('summary')) > 100:
+                if (message.get('Metadata', {}).get('summary')
+                        and len(message.get('Metadata', {}).get('summary')) > 100):
                     eventItem.overview = str(message.get('Metadata', {}).get('summary'))[:100] + "..."
                 else:
                     eventItem.overview = message.get('Metadata', {}).get('summary')
             else:
-                eventItem.item_type = "MOV" if message.get('Metadata', {}).get('type') == 'movie' else "SHOW"
+                eventItem.item_type = "MOV" if message.get('Metadata',
+                                                           {}).get('type') == 'movie' else "SHOW"
                 eventItem.item_name = "%s %s" % (
-                    message.get('Metadata', {}).get('title'), "(" + str(message.get('Metadata', {}).get('year')) + ")")
+                    message.get('Metadata', {}).get('title'),
+                    "(" + str(message.get('Metadata', {}).get('year')) + ")")
                 eventItem.item_id = message.get('Metadata', {}).get('ratingKey')
                 if len(message.get('Metadata', {}).get('summary')) > 100:
                     eventItem.overview = str(message.get('Metadata', {}).get('summary'))[:100] + "..."

app/modules/qbittorrent/__init__.py

@@ -225,6 +225,8 @@ class QbittorrentModule(_ModuleBase):
         """
         # 调用Qbittorrent API查询实时信息
         info = self.qbittorrent.transfer_info()
+        if not info:
+            return schemas.DownloaderInfo()
         return schemas.DownloaderInfo(
             download_speed=info.get("dl_info_speed"),
             upload_speed=info.get("up_info_speed"),

app/modules/telegram/telegram.py

@@ -158,10 +158,8 @@ class Telegram(metaclass=Singleton):
                 title = re.sub(r"\s+", " ", title).strip()
                 free = torrent.volume_factor
                 seeder = f"{torrent.seeders}↑"
-                description = torrent.description
                 caption = f"{caption}\n{index}.【{site_name}】[{title}]({link}) " \
-                          f"{StringUtils.str_filesize(torrent.size)} {free} {seeder}\n" \
-                          f"_{description}_"
+                          f"{StringUtils.str_filesize(torrent.size)} {free} {seeder}"
                 index += 1
 
             if userid:

app/modules/themoviedb/__init__.py

@@ -345,7 +345,7 @@ class TheMovieDbModule(_ModuleBase):
                 image_path = seasoninfo.get(image_type.value)
 
         if image_path:
-            return f"https://image.tmdb.org/t/p/{image_prefix}{image_path}"
+            return f"https://{settings.TMDB_IMAGE_DOMAIN}/t/p/{image_prefix}{image_path}"
         return None
 
     def movie_similar(self, tmdbid: int) -> List[dict]:

app/modules/themoviedb/scraper.py

@@ -12,7 +12,6 @@ from app.schemas.types import MediaType
 from app.utils.common import retry
 from app.utils.dom import DomUtils
 from app.utils.http import RequestUtils
-from app.utils.string import StringUtils
 
 
 class TmdbScraper:
@@ -122,25 +121,8 @@ class TmdbScraper:
         except Exception as e:
             logger.error(f"{file_path} 刮削失败：{e}")
 
-    def __get_chinese_name(self, person: dict):
-        """
-        获取TMDB别名中的中文名
-        """
-        if not person.get("id"):
-            return ""
-        try:
-            personinfo = self.tmdb.get_person_detail(person.get("id"))
-            if personinfo:
-                also_known_as = personinfo.get("also_known_as") or []
-                if also_known_as:
-                    for name in also_known_as:
-                        if name and StringUtils.is_chinese(name):
-                            return name
-        except Exception as err:
-            logger.error(f"获取人物中文名失败：{err}")
-        return person.get("name") or ""
-
-    def __gen_common_nfo(self, mediainfo: MediaInfo, doc, root):
+    @staticmethod
+    def __gen_common_nfo(mediainfo: MediaInfo, doc, root):
         """
         生成公共NFO
         """
@@ -173,19 +155,20 @@ class TmdbScraper:
         xoutline.appendChild(doc.createCDATASection(mediainfo.overview or ""))
         # 导演
         for director in mediainfo.directors:
-            # 获取中文名
-            cn_name = self.__get_chinese_name(director)
-            xdirector = DomUtils.add_node(doc, root, "director", cn_name)
+            xdirector = DomUtils.add_node(doc, root, "director", director.get("name") or "")
             xdirector.setAttribute("tmdbid", str(director.get("id") or ""))
         # 演员
         for actor in mediainfo.actors:
             # 获取中文名
-            cn_name = self.__get_chinese_name(actor)
             xactor = DomUtils.add_node(doc, root, "actor")
-            DomUtils.add_node(doc, xactor, "name", cn_name)
+            DomUtils.add_node(doc, xactor, "name", actor.get("name") or "")
             DomUtils.add_node(doc, xactor, "type", "Actor")
             DomUtils.add_node(doc, xactor, "role", actor.get("character") or actor.get("role") or "")
             DomUtils.add_node(doc, xactor, "tmdbid", actor.get("id") or "")
+            DomUtils.add_node(doc, xactor, "thumb",
+                              f"https://{settings.TMDB_IMAGE_DOMAIN}/t/p/original{actor.get('profile_path')}")
+            DomUtils.add_node(doc, xactor, "profile",
+                              f"https://www.themoviedb.org/person/{actor.get('id')}")
         # 风格
         genres = mediainfo.genres or []
         for genre in genres:
@@ -260,7 +243,8 @@ class TmdbScraper:
         doc = minidom.Document()
         root = DomUtils.add_node(doc, doc, "season")
         # 添加时间
-        DomUtils.add_node(doc, root, "dateadded", time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(time.time())))
+        DomUtils.add_node(doc, root, "dateadded",
+                          time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(time.time())))
         # 简介
         xplot = DomUtils.add_node(doc, root, "plot")
         xplot.appendChild(doc.createCDATASection(seasoninfo.get("overview") or ""))
@@ -272,7 +256,8 @@ class TmdbScraper:
         DomUtils.add_node(doc, root, "premiered", seasoninfo.get("air_date") or "")
         DomUtils.add_node(doc, root, "releasedate", seasoninfo.get("air_date") or "")
         # 发行年份
-        DomUtils.add_node(doc, root, "year", seasoninfo.get("air_date")[:4] if seasoninfo.get("air_date") else "")
+        DomUtils.add_node(doc, root, "year",
+                          seasoninfo.get("air_date")[:4] if seasoninfo.get("air_date") else "")
         # seasonnumber
         DomUtils.add_node(doc, root, "seasonnumber", str(season))
         # 保存
@@ -326,20 +311,20 @@ class TmdbScraper:
         directors = episodeinfo.get("crew") or []
         for director in directors:
             if director.get("known_for_department") == "Directing":
-                # 获取中文名
-                cn_name = self.__get_chinese_name(director)
-                xdirector = DomUtils.add_node(doc, root, "director", cn_name)
+                xdirector = DomUtils.add_node(doc, root, "director", director.get("name") or "")
                 xdirector.setAttribute("tmdbid", str(director.get("id") or ""))
         # 演员
         actors = episodeinfo.get("guest_stars") or []
         for actor in actors:
             if actor.get("known_for_department") == "Acting":
-                # 获取中文名
-                cn_name = self.__get_chinese_name(actor)
                 xactor = DomUtils.add_node(doc, root, "actor")
-                DomUtils.add_node(doc, xactor, "name", cn_name)
+                DomUtils.add_node(doc, xactor, "name", actor.get("name") or "")
                 DomUtils.add_node(doc, xactor, "type", "Actor")
                 DomUtils.add_node(doc, xactor, "tmdbid", actor.get("id") or "")
+                DomUtils.add_node(doc, xactor, "thumb",
+                                  f"https://{settings.TMDB_IMAGE_DOMAIN}/t/p/original{actor.get('profile_path')}")
+                DomUtils.add_node(doc, xactor, "profile",
+                                  f"https://www.themoviedb.org/person/{actor.get('id')}")
         # 保存文件
         self.__save_nfo(doc, file_path.with_suffix(".nfo"))
 

app/modules/themoviedb/tmdbv3api/tmdb.py

@@ -3,18 +3,19 @@
 import logging
 import os
 import time
+from datetime import datetime
 from functools import lru_cache
 
 import requests
 import requests.exceptions
 
+from app.utils.http import RequestUtils
 from .exceptions import TMDbException
 
 logger = logging.getLogger(__name__)
 
 
 class TMDb(object):
-    _session = None
     TMDB_API_KEY = "TMDB_API_KEY"
     TMDB_LANGUAGE = "TMDB_LANGUAGE"
     TMDB_SESSION_ID = "TMDB_SESSION_ID"
@@ -25,9 +26,15 @@ class TMDb(object):
     TMDB_DOMAIN = "TMDB_DOMAIN"
     REQUEST_CACHE_MAXSIZE = None
 
+    _req = None
+    _session = None
+
     def __init__(self, obj_cached=True, session=None):
-        if self.__class__._session is None or session is not None:
-            self.__class__._session = requests.Session() if session is None else session
+        if session is not None:
+            self._req = RequestUtils(session=session, proxies=self.proxies)
+        else:
+            self._session = requests.Session()
+            self._req = RequestUtils(session=self._session, proxies=self.proxies)
         self._remaining = 40
         self._reset = None
         self._timeout = 15
@@ -54,7 +61,7 @@ class TMDb(object):
     @property
     def domain(self):
         return os.environ.get(self.TMDB_DOMAIN)
-    
+
     @property
     def proxies(self):
         proxy = os.environ.get(self.TMDB_PROXIES)
@@ -131,9 +138,18 @@ class TMDb(object):
         os.environ[self.TMDB_CACHE_ENABLED] = str(cache)
 
     @lru_cache(maxsize=REQUEST_CACHE_MAXSIZE)
-    def cached_request(self, method, url, data, json):
-        return requests.request(method, url, data=data, json=json,
-                                timeout=self._timeout, proxies=self.proxies)
+    def cached_request(self, method, url, data, json,
+                       _ts=datetime.strftime(datetime.now(), '%Y%m%d')):
+        """
+        缓存请求，时间默认1天
+        """
+        return self.request(method, url, data, json)
+
+    def request(self, method, url, data, json):
+        if method == "GET":
+            return self._req.get_res(url, params=data, json=json)
+        else:
+            return self._req.post_res(url, data=data, json=json)
 
     def cache_clear(self):
         return self.cached_request.cache_clear()
@@ -154,8 +170,7 @@ class TMDb(object):
         if self.cache and self.obj_cached and call_cached and method != "POST":
             req = self.cached_request(method, url, data, json)
         else:
-            req = self.__class__._session.request(method, url, data=data, json=json,
-                                                  timeout=self._timeout, proxies=self.proxies)
+            req = self.request(method, url, data, json)
 
         headers = req.headers
 
@@ -200,3 +215,7 @@ class TMDb(object):
         if key:
             return json.get(key)
         return json
+
+    def __del__(self):
+        if self._session:
+            self._session.close()

app/modules/transmission/__init__.py

@@ -211,6 +211,8 @@ class TransmissionModule(_ModuleBase):
         下载器信息
         """
         info = self.transmission.transfer_info()
+        if not info:
+            return schemas.DownloaderInfo()
         return schemas.DownloaderInfo(
             download_speed=info.download_speed,
             upload_speed=info.upload_speed,

app/plugins/bestfilmversion/__init__.py

@@ -420,8 +420,7 @@ class BestFilmVersion(_PluginBase):
                         item_info_resp = Emby().get_iteminfo(itemid=data.get('Id'))
                     else:
                         item_info_resp = self.plex_get_iteminfo(itemid=data.get('Id'))
-
-                    logger.info(f'BestFilmVersion插件 item打印 {item_info_resp}')
+                    logger.debug(f'BestFilmVersion插件 item打印 {item_info_resp}')
                     if not item_info_resp:
                         continue
 
@@ -430,41 +429,35 @@ class BestFilmVersion(_PluginBase):
                         continue
 
                     # 获取tmdb_id
-                    media_info_ids = item_info_resp.get('ExternalUrls')
-                    if not media_info_ids:
+                    tmdb_id = item_info_resp.tmdbid
+                    if not tmdb_id:
                         continue
-                    for media_info_id in media_info_ids:
-                        if 'TheMovieDb' != media_info_id.get('Name'):
-                            continue
-                        tmdb_find_id = str(media_info_id.get('Url')).split('/')
-                        tmdb_find_id.reverse()
-                        tmdb_id = tmdb_find_id[0]
-                        # 识别媒体信息
-                        mediainfo: MediaInfo = self.chain.recognize_media(tmdbid=tmdb_id, mtype=MediaType.MOVIE)
-                        if not mediainfo:
-                            logger.warn(f'未识别到媒体信息，标题：{data.get("Name")}，tmdbID：{tmdb_id}')
-                            continue
-                        # 添加订阅
-                        self.subscribechain.add(mtype=MediaType.MOVIE,
-                                                title=mediainfo.title,
-                                                year=mediainfo.year,
-                                                tmdbid=mediainfo.tmdb_id,
-                                                best_version=True,
-                                                username="收藏洗版",
-                                                exist_ok=True)
-                        # 加入缓存
-                        caches.append(data.get('Name'))
-                        # 存储历史记录
-                        if mediainfo.tmdb_id not in [h.get("tmdbid") for h in history]:
-                            history.append({
-                                "title": mediainfo.title,
-                                "type": mediainfo.type.value,
-                                "year": mediainfo.year,
-                                "poster": mediainfo.get_poster_image(),
-                                "overview": mediainfo.overview,
-                                "tmdbid": mediainfo.tmdb_id,
-                                "time": datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-                            })
+                    # 识别媒体信息
+                    mediainfo: MediaInfo = self.chain.recognize_media(tmdbid=tmdb_id, mtype=MediaType.MOVIE)
+                    if not mediainfo:
+                        logger.warn(f'未识别到媒体信息，标题：{data.get("Name")}，tmdbid：{tmdb_id}')
+                        continue
+                    # 添加订阅
+                    self.subscribechain.add(mtype=MediaType.MOVIE,
+                                            title=mediainfo.title,
+                                            year=mediainfo.year,
+                                            tmdbid=mediainfo.tmdb_id,
+                                            best_version=True,
+                                            username="收藏洗版",
+                                            exist_ok=True)
+                    # 加入缓存
+                    caches.append(data.get('Name'))
+                    # 存储历史记录
+                    if mediainfo.tmdb_id not in [h.get("tmdbid") for h in history]:
+                        history.append({
+                            "title": mediainfo.title,
+                            "type": mediainfo.type.value,
+                            "year": mediainfo.year,
+                            "poster": mediainfo.get_poster_image(),
+                            "overview": mediainfo.overview,
+                            "tmdbid": mediainfo.tmdb_id,
+                            "time": datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+                        })
             # 保存历史记录
             self.save_data('history', history)
             # 保存缓存
@@ -474,7 +467,7 @@ class BestFilmVersion(_PluginBase):
 
     def jellyfin_get_items(self) -> List[dict]:
         # 获取所有user
-        users_url = "{HOST}Users?&apikey={APIKEY}"
+        users_url = "[HOST]Users?&apikey=[APIKEY]"
         users = self.get_users(Jellyfin().get_data(users_url))
         if not users:
             logger.info(f"bestfilmversion/users_url: {users_url}")
@@ -482,7 +475,7 @@ class BestFilmVersion(_PluginBase):
         all_items = []
         for user in users:
             # 根据加入日期 降序排序
-            url = "{HOST}Users/" + user + "/Items?SortBy=DateCreated%2CSortName" \
+            url = "[HOST]Users/" + user + "/Items?SortBy=DateCreated%2CSortName" \
                                           "&SortOrder=Descending" \
                                           "&Filters=IsFavorite" \
                                           "&Recursive=true" \
@@ -491,7 +484,7 @@ class BestFilmVersion(_PluginBase):
                                           "&ExcludeLocationTypes=Virtual" \
                                           "&EnableTotalRecordCount=false" \
                                           "&Limit=20" \
-                                          "&apikey={APIKEY}"
+                                          "&apikey=[APIKEY]"
             resp = self.get_items(Jellyfin().get_data(url))
             if not resp:
                 continue
@@ -500,14 +493,14 @@ class BestFilmVersion(_PluginBase):
 
     def emby_get_items(self) -> List[dict]:
         # 获取所有user
-        get_users_url = "{HOST}Users?&api_key={APIKEY}"
+        get_users_url = "[HOST]Users?&api_key=[APIKEY]"
         users = self.get_users(Emby().get_data(get_users_url))
         if not users:
             return []
         all_items = []
         for user in users:
             # 根据加入日期 降序排序
-            url = "{HOST}emby/Users/" + user + "/Items?SortBy=DateCreated%2CSortName" \
+            url = "[HOST]emby/Users/" + user + "/Items?SortBy=DateCreated%2CSortName" \
                                                "&SortOrder=Descending" \
                                                "&Filters=IsFavorite" \
                                                "&Recursive=true" \
@@ -515,7 +508,7 @@ class BestFilmVersion(_PluginBase):
                                                "&CollapseBoxSetItems=false" \
                                                "&ExcludeLocationTypes=Virtual" \
                                                "&EnableTotalRecordCount=false" \
-                                               "&Limit=20&api_key={APIKEY}"
+                                               "&Limit=20&api_key=[APIKEY]"
             resp = self.get_items(Emby().get_data(url))
             if not resp:
                 continue
@@ -634,52 +627,34 @@ class BestFilmVersion(_PluginBase):
         if not _is_lock:
             return
         try:
-
-            mediainfo: Optional[MediaInfo] = None
             if not data.tmdb_id:
                 info = None
-                if data.channel == 'jellyfin' and data.save_reason == 'UpdateUserRating' and data.item_favorite:
+                if (data.channel == 'jellyfin'
+                        and data.save_reason == 'UpdateUserRating'
+                        and data.item_favorite):
                     info = Jellyfin().get_iteminfo(itemid=data.item_id)
                 elif data.channel == 'emby' and data.event == 'item.rate':
                     info = Emby().get_iteminfo(itemid=data.item_id)
                 elif data.channel == 'plex' and data.event == 'item.rate':
                     info = Plex().get_iteminfo(itemid=data.item_id)
-                logger.info(f'BestFilmVersion/webhook_message_action item打印：{info}')
-
+                logger.debug(f'BestFilmVersion/webhook_message_action item打印：{info}')
                 if not info:
                     return
-                if info['Type'] not in ['Movie', 'MOV', 'movie']:
+                if info.item_type not in ['Movie', 'MOV', 'movie']:
                     return
-
                 # 获取tmdb_id
-                media_info_ids = info.get('ExternalUrls')
-                if not media_info_ids:
-                    return
-                for media_info_id in media_info_ids:
-
-                    if 'TheMovieDb' != media_info_id.get('Name'):
-                        continue
-
-                    tmdb_find_id = str(media_info_id.get('Url')).split('/')
-                    tmdb_find_id.reverse()
-                    tmdb_id = tmdb_find_id[0]
-
-                    mediainfo = self.chain.recognize_media(tmdbid=tmdb_id, mtype=MediaType.MOVIE)
-                    if not mediainfo:
-                        logger.warn(f'未识别到媒体信息，标题：{data.item_name}，tmdbID：{tmdb_id}')
-                        return
+                tmdb_id = info.tmdbid
             else:
-                if data.channel == 'jellyfin' and (data.save_reason != 'UpdateUserRating' or not data.item_favorite):
+                tmdb_id = data.tmdb_id
+                if (data.channel == 'jellyfin'
+                        and (data.save_reason != 'UpdateUserRating' or not data.item_favorite)):
                     return
                 if data.item_type not in ['Movie', 'MOV', 'movie']:
                     return
-
-                mediainfo = self.chain.recognize_media(tmdbid=data.tmdb_id, mtype=MediaType.MOVIE)
-                if not mediainfo:
-                    logger.warn(f'未识别到媒体信息，标题：{data.item_name}，tmdbID：{data.tmdb_id}')
-                    return
-
+            # 识别媒体信息
+            mediainfo = self.chain.recognize_media(tmdbid=tmdb_id, mtype=MediaType.MOVIE)
             if not mediainfo:
+                logger.warn(f'未识别到媒体信息，标题：{data.item_name}，tmdbID：{tmdb_id}')
                 return
             # 读取缓存
             caches = self._cache_path.read_text().split("\n") if self._cache_path.exists() else []

app/plugins/brushflow/__init__.py

@@ -49,6 +49,7 @@ class BrushFlow(_PluginBase):
     siteshelper = None
     siteoper = None
     torrents = None
+    sites = None
     qb = None
     tr = None
     # 添加种子定时
@@ -88,6 +89,7 @@ class BrushFlow(_PluginBase):
         self.siteshelper = SitesHelper()
         self.siteoper = SiteOper()
         self.torrents = TorrentsChain()
+        self.sites = SitesHelper()
         if config:
             self._enabled = config.get("enabled")
             self._notify = config.get("notify")
@@ -115,6 +117,13 @@ class BrushFlow(_PluginBase):
             self._save_path = config.get("save_path")
             self._clear_task = config.get("clear_task")
 
+            # 过滤掉已删除的站点
+            self._brushsites = [site.get("id") for site in self.sites.get_indexers() if
+                                not site.get("public") and site.get("id") in self._brushsites]
+
+            # 保存配置
+            self.__update_config()
+
             if self._clear_task:
                 # 清除统计数据
                 self.save_data("statistic", {})
@@ -228,7 +237,7 @@ class BrushFlow(_PluginBase):
                     self._scheduler.add_job(self.brush, 'interval', minutes=self._cron)
                 except Exception as e:
                     logger.error(f"站点刷流服务启动失败：{e}")
-                    self.systemmessage(f"站点刷流服务启动失败：{e}")
+                    self.systemmessage.put(f"站点刷流服务启动失败：{e}")
                     return
                 if self._onlyonce:
                     logger.info(f"站点刷流服务启动，立即运行一次")
@@ -1113,7 +1122,7 @@ class BrushFlow(_PluginBase):
                                     {
                                         'component': 'thead',
                                         'props': {
-                                          'class': 'text-no-wrap'
+                                            'class': 'text-no-wrap'
                                         },
                                         'content': [
                                             {
@@ -1290,10 +1299,10 @@ class BrushFlow(_PluginBase):
                         else:
                             end_size = 0
                         if begin_size and not end_size \
-                                and torrent.size > float(begin_size) * 1024**3:
+                                and torrent.size > float(begin_size) * 1024 ** 3:
                             continue
                         elif begin_size and end_size \
-                                and not float(begin_size) * 1024**3 <= torrent.size <= float(end_size) * 1024**3:
+                                and not float(begin_size) * 1024 ** 3 <= torrent.size <= float(end_size) * 1024 ** 3:
                             continue
                     # 做种人数
                     if self._seeder:
@@ -1350,7 +1359,7 @@ class BrushFlow(_PluginBase):
                             break
                     # 保种体积（GB）
                     if self._disksize \
-                            and (torrents_size + torrent.size) > float(self._disksize) * 1024**3:
+                            and (torrents_size + torrent.size) > float(self._disksize) * 1024 ** 3:
                         logger.warn(f"当前做种体积 {StringUtils.str_filesize(torrents_size)} "
                                     f"已超过保种体积 {self._disksize}，停止新增任务")
                         break
@@ -1372,6 +1381,7 @@ class BrushFlow(_PluginBase):
                         "deleted": False,
                     }
                     # 统计数据
+                    torrents_size += torrent.size
                     statistic_info["count"] += 1
                     # 发送消息
                     self.__send_add_message(torrent)
@@ -1860,7 +1870,7 @@ class BrushFlow(_PluginBase):
             return 0
         torrents = downlader.get_downloading_torrents()
         return len(torrents) or 0
-    
+
     @staticmethod
     def __get_pubminutes(pubdate: str) -> int:
         """
@@ -1876,4 +1886,3 @@ class BrushFlow(_PluginBase):
         except Exception as e:
             print(str(e))
             return 0
-    

app/plugins/cloudflarespeedtest/__init__.py

@@ -725,9 +725,9 @@ class CloudflareSpeedTest(_PluginBase):
                 new_entrys.append(host_entry)
             except Exception as err:
                 err_hosts.append(host + "\n")
-                logger.error(f"{host} 格式转换错误：{str(err)}")
+                logger.error(f"[HOST] 格式转换错误：{str(err)}")
                 # 推送实时消息
-                self.systemmessage.put(f"{host} 格式转换错误：{str(err)}")
+                self.systemmessage.put(f"[HOST] 格式转换错误：{str(err)}")
 
         # 写入系统hosts
         if new_entrys:

app/plugins/customhosts/__init__.py

@@ -199,9 +199,9 @@ class CustomHosts(_PluginBase):
                 new_entrys.append(host_entry)
             except Exception as err:
                 err_hosts.append(host + "\n")
-                logger.error(f"{host} 格式转换错误：{str(err)}")
+                logger.error(f"[HOST] 格式转换错误：{str(err)}")
                 # 推送实时消息
-                self.systemmessage.put(f"{host} 格式转换错误：{str(err)}")
+                self.systemmessage.put(f"[HOST] 格式转换错误：{str(err)}")
 
         # 写入系统hosts
         if new_entrys:

app/plugins/doubanrank/__init__.py

@@ -4,6 +4,7 @@ import xml.dom.minidom
 from threading import Event
 from typing import Tuple, List, Dict, Any, Optional
 
+import pytz
 from apscheduler.schedulers.background import BackgroundScheduler
 from apscheduler.triggers.cron import CronTrigger
 
@@ -100,11 +101,19 @@ class DoubanRank(_PluginBase):
                     logger.error(f"豆瓣榜单订阅服务启动失败，错误信息：{str(e)}")
                     self.systemmessage.put(f"豆瓣榜单订阅服务启动失败，错误信息：{str(e)}")
             else:
-                self._scheduler.add_job(func=self.__refresh_rss,
-                                        trigger=CronTrigger.from_crontab("0 8 * * *"),
-                                        name="豆瓣榜单订阅")
+                self._scheduler.add_job(func=self.__refresh_rss, trigger='date',
+                                        run_date=datetime.datetime.now(
+                                            tz=pytz.timezone(settings.TZ)) + datetime.timedelta(seconds=3)
+                                        )
                 logger.info("豆瓣榜单订阅服务启动，周期：每天 08:00")
 
+            if self._onlyonce:
+                logger.info("豆瓣榜单订阅服务启动，立即运行一次")
+                self._scheduler.add_job(func=self.__refresh_rss, trigger='date',
+                                        run_date=datetime.datetime.now(
+                                            tz=pytz.timezone(settings.TZ)) + datetime.timedelta(seconds=3)
+                                        )
+
             if self._onlyonce or self._clear:
                 # 关闭一次性开关
                 self._onlyonce = False

app/plugins/mediasyncdel/__init__.py

@@ -673,6 +673,8 @@ class MediaSyncDel(_PluginBase):
             paths = self._library_path.split("\n")
             for path in paths:
                 sub_paths = path.split(":")
+                if len(sub_paths) < 2:
+                    continue
                 media_path = media_path.replace(sub_paths[0], sub_paths[1]).replace('\\', '/')
 
         # 删除电影
@@ -765,6 +767,8 @@ class MediaSyncDel(_PluginBase):
                 paths = self._library_path.split("\n")
                 for path in paths:
                     sub_paths = path.split(":")
+                    if len(sub_paths) < 2:
+                        continue
                     media_path = media_path.replace(sub_paths[0], sub_paths[1]).replace('\\', '/')
 
             # 获取删除的记录
@@ -1043,7 +1047,7 @@ class MediaSyncDel(_PluginBase):
 
     @staticmethod
     def parse_emby_log(last_time):
-        log_url = "{HOST}System/Logs/embyserver.txt?api_key={APIKEY}"
+        log_url = "[HOST]System/Logs/embyserver.txt?api_key=[APIKEY]"
         log_res = Emby().get_data(log_url)
         if not log_res or log_res.status_code != 200:
             logger.error("获取emby日志失败，请检查服务器配置")
@@ -1116,7 +1120,7 @@ class MediaSyncDel(_PluginBase):
     @staticmethod
     def parse_jellyfin_log(last_time: datetime):
         # 根据加入日期 降序排序
-        log_url = "{HOST}System/Logs/Log?name=log_%s.log&api_key={APIKEY}" % datetime.date.today().strftime("%Y%m%d")
+        log_url = "[HOST]System/Logs/Log?name=log_%s.log&api_key=[APIKEY]" % datetime.date.today().strftime("%Y%m%d")
         log_res = Jellyfin().get_data(log_url)
         if not log_res or log_res.status_code != 200:
             logger.error("获取jellyfin日志失败，请检查服务器配置")

app/plugins/personmeta/__init__.py

@@ -1,17 +1,34 @@
+import base64
+import copy
+import datetime
+import json
+import re
+import threading
+import time
 from pathlib import Path
-from typing import Any, List, Dict, Tuple
+from typing import Any, List, Dict, Tuple, Optional
 
+import pytz
+import zhconv
+from apscheduler.schedulers.background import BackgroundScheduler
+from apscheduler.triggers.cron import CronTrigger
 from requests import RequestException
 
+from app.chain.mediaserver import MediaServerChain
 from app.chain.tmdb import TmdbChain
+from app.core.config import settings
 from app.core.event import eventmanager, Event
-from app.helper.nfo import NfoReader
+from app.core.meta import MetaBase
 from app.log import logger
+from app.modules.emby import Emby
+from app.modules.jellyfin import Jellyfin
+from app.modules.plex import Plex
 from app.plugins import _PluginBase
-from app.schemas import TransferInfo, MediaInfo
+from app.schemas import MediaInfo, MediaServerItem
 from app.schemas.types import EventType, MediaType
 from app.utils.common import retry
 from app.utils.http import RequestUtils
+from app.utils.string import StringUtils
 
 
 class PersonMeta(_PluginBase):
@@ -36,16 +53,72 @@ class PersonMeta(_PluginBase):
     # 可使用的用户级别
     auth_level = 1
 
+    # 退出事件
+    _event = threading.Event()
+
     # 私有属性
+    _scheduler = None
     tmdbchain = None
+    mschain = None
     _enabled = False
-    _metadir = ""
+    _onlyonce = False
+    _cron = None
+    _delay = 0
+    _remove_nozh = False
 
     def init_plugin(self, config: dict = None):
         self.tmdbchain = TmdbChain(self.db)
+        self.mschain = MediaServerChain(self.db)
         if config:
             self._enabled = config.get("enabled")
-            self._metadir = config.get("metadir")
+            self._onlyonce = config.get("onlyonce")
+            self._cron = config.get("cron")
+            self._delay = config.get("delay") or 0
+            self._remove_nozh = config.get("remove_nozh") or False
+
+        # 停止现有任务
+        self.stop_service()
+
+        # 启动服务
+        if self._enabled or self._onlyonce:
+            self._scheduler = BackgroundScheduler(timezone=settings.TZ)
+            if self._cron or self._onlyonce:
+                if self._cron:
+                    try:
+                        self._scheduler.add_job(func=self.scrap_library,
+                                                trigger=CronTrigger.from_crontab(self._cron),
+                                                name="演职人员刮削")
+                        logger.info(f"演职人员刮削服务启动，周期：{self._cron}")
+                    except Exception as e:
+                        logger.error(f"演职人员刮削服务启动失败，错误信息：{str(e)}")
+                        self.systemmessage.put(f"演职人员刮削服务启动失败，错误信息：{str(e)}")
+                if self._onlyonce:
+                    self._scheduler.add_job(func=self.scrap_library, trigger='date',
+                                            run_date=datetime.datetime.now(
+                                                tz=pytz.timezone(settings.TZ)) + datetime.timedelta(seconds=3)
+                                            )
+                    logger.info(f"演职人员刮削服务启动，立即运行一次")
+                    # 关闭一次性开关
+                    self._onlyonce = False
+                    # 保存配置
+                    self.__update_config()
+
+            if self._scheduler.get_jobs():
+                # 启动服务
+                self._scheduler.print_jobs()
+                self._scheduler.start()
+
+    def __update_config(self):
+        """
+        更新配置
+        """
+        self.update_config({
+            "enabled": self._enabled,
+            "onlyonce": self._onlyonce,
+            "cron": self._cron,
+            "delay": self._delay,
+            "remove_nozh": self._remove_nozh
+        })
 
     def get_state(self) -> bool:
         return self._enabled
@@ -83,6 +156,22 @@ class PersonMeta(_PluginBase):
                                         }
                                     }
                                 ]
+                            },
+                            {
+                                'component': 'VCol',
+                                'props': {
+                                    'cols': 12,
+                                    'md': 6
+                                },
+                                'content': [
+                                    {
+                                        'component': 'VSwitch',
+                                        'props': {
+                                            'model': 'onlyonce',
+                                            'label': '立即运行一次',
+                                        }
+                                    }
+                                ]
                             }
                         ]
                     },
@@ -93,14 +182,53 @@ class PersonMeta(_PluginBase):
                                 'component': 'VCol',
                                 'props': {
                                     'cols': 12,
+                                    'md': 6
                                 },
                                 'content': [
                                     {
                                         'component': 'VTextField',
                                         'props': {
-                                            'model': 'metadir',
-                                            'label': '人物元数据目录',
-                                            'placeholder': '/metadata/people'
+                                            'model': 'cron',
+                                            'label': '媒体库扫描周期',
+                                            'placeholder': '5位cron表达式'
+                                        }
+                                    }
+                                ]
+                            },
+                            {
+                                'component': 'VCol',
+                                'props': {
+                                    'cols': 12,
+                                    'md': 6
+                                },
+                                'content': [
+                                    {
+                                        'component': 'VTextField',
+                                        'props': {
+                                            'model': 'delay',
+                                            'label': '入库延迟时间（秒）',
+                                            'placeholder': '30'
+                                        }
+                                    }
+                                ]
+                            }
+                        ]
+                    },
+                    {
+                        'component': 'VRow',
+                        'content': [
+                            {
+                                'component': 'VCol',
+                                'props': {
+                                    'cols': 12,
+                                    'md': 6
+                                },
+                                'content': [
+                                    {
+                                        'component': 'VSwitch',
+                                        'props': {
+                                            'model': 'remove_nozh',
+                                            'label': '删除非中文演员',
                                         }
                                     }
                                 ]
@@ -111,7 +239,10 @@ class PersonMeta(_PluginBase):
             }
         ], {
             "enabled": False,
-            "metadir": ""
+            "onlyonce": False,
+            "cron": "",
+            "delay": 30,
+            "remove_nozh": False
         }
 
     def get_page(self) -> List[dict]:
@@ -124,81 +255,719 @@ class PersonMeta(_PluginBase):
         """
         if not self._enabled:
             return
-        # 下载人物头像
-        if not self._metadir:
-            logger.warning("人物元数据目录未配置，无法下载人物头像")
-            return
         # 事件数据
         mediainfo: MediaInfo = event.event_data.get("mediainfo")
-        transferinfo: TransferInfo = event.event_data.get("transferinfo")
-        if not mediainfo or not transferinfo:
+        meta: MetaBase = event.event_data.get("meta")
+        if not mediainfo or not meta:
             return
-        # 文件路径
-        filepath = transferinfo.target_path
-        if not filepath:
+        # 延迟
+        if self._delay:
+            time.sleep(int(self._delay))
+        # 查询媒体服务器中的条目
+        existsinfo = self.chain.media_exists(mediainfo=mediainfo)
+        if not existsinfo or not existsinfo.itemid:
+            logger.warn(f"演职人员刮削 {mediainfo.title_year} 在媒体库中不存在")
             return
-        # 电影
-        if mediainfo.type == MediaType.MOVIE:
-            # nfo文件
-            nfofile = filepath.with_name("movie.nfo")
-            if not nfofile.exists():
-                nfofile = filepath.parent / f"{filepath.stem}.nfo"
-                if not nfofile.exists():
-                    logger.warning(f"电影nfo文件不存在：{nfofile}")
-                    return
-        else:
-            # nfo文件
-            nfofile = filepath.parent.with_name("tvshow.nfo")
-            if not nfofile.exists():
-                logger.warning(f"剧集nfo文件不存在：{nfofile}")
+        # 查询条目详情
+        iteminfo = self.mschain.iteminfo(server=existsinfo.server, item_id=existsinfo.itemid)
+        if not iteminfo:
+            logger.warn(f"演职人员刮削 {mediainfo.title_year} 条目详情获取失败")
+            return
+        # 刮削演职人员信息
+        self.__update_item(server=existsinfo.server, item=iteminfo,
+                           mediainfo=mediainfo, season=meta.begin_season)
+
+    def scrap_library(self):
+        """
+        扫描整个媒体库，刮削演员信息
+        """
+        # 所有媒体服务器
+        if not settings.MEDIASERVER:
+            return
+        for server in settings.MEDIASERVER.split(","):
+            # 扫描所有媒体库
+            logger.info(f"开始刮削服务器 {server} 的演员信息 ...")
+            for library in self.mschain.librarys(server):
+                logger.info(f"开始刮削媒体库 {library.name} 的演员信息 ...")
+                for item in self.mschain.items(server, library.id):
+                    if not item:
+                        continue
+                    if not item.item_id:
+                        continue
+                    if "Series" not in item.item_type \
+                            and "Movie" not in item.item_type:
+                        continue
+                    if self._event.is_set():
+                        logger.info(f"演职人员刮削服务停止")
+                        return
+                    # 处理条目
+                    logger.info(f"开始刮削 {item.title} 的演员信息 ...")
+                    self.__update_item(server=server, item=item)
+                    logger.info(f"{item.title} 的演员信息刮削完成")
+                logger.info(f"媒体库 {library.name} 的演员信息刮削完成")
+            logger.info(f"服务器 {server} 的演员信息刮削完成")
+
+    def __update_item(self, server: str, item: MediaServerItem,
+                      mediainfo: MediaInfo = None, season: int = None):
+        """
+        更新媒体服务器中的条目
+        """
+        # 识别媒体信息
+        if not mediainfo:
+            if not item.tmdbid:
+                logger.warn(f"{item.title} 未找到tmdbid，无法识别媒体信息")
                 return
-        # 读取nfo文件
-        nfo = NfoReader(nfofile)
-        # 读取演员信息
-        actors = nfo.get_elements("actor") or []
-        for actor in actors:
-            # 演员ID
-            actor_id = actor.find("id").text
-            if not actor_id:
-                continue
-            # 演员名称
-            actor_name = actor.find("name").text
-            # 查询演员详情
-            actor_info = self.tmdbchain.person_detail(actor_id)
-            if not actor_info:
-                continue
-            # 演员头像
-            actor_image = actor_info.get("profile_path")
-            if not actor_image:
-                continue
-            # 计算保存路径
-            image_path = Path(self._metadir) / f"{actor_name}-tmdb-{actor_id}" / f"folder{Path(actor_image).suffix}"
-            if image_path.exists():
-                continue
-            # 下载图片
-            self.download_image(f"https://image.tmdb.org/t/p/original{actor_image}", image_path)
+            mtype = MediaType.TV if item.item_type in ['Series', 'show'] else MediaType.MOVIE
+            mediainfo = self.chain.recognize_media(mtype=mtype, tmdbid=item.tmdbid)
+            if not mediainfo:
+                logger.warn(f"{item.title} 未识别到媒体信息")
+                return
+
+        # 获取豆瓣演员信息
+        douban_actors = self.__get_douban_actors(mediainfo=mediainfo, season=season)
+
+        # 获取媒体项
+        iteminfo = self.get_iteminfo(server=server, itemid=item.item_id)
+        if not iteminfo:
+            logger.warn(f"{item.title} 未找到媒体项")
+            return
+
+        # 处理媒体项中的人物信息
+        if iteminfo.get("People"):
+            """
+            "People": [
+                {
+                  "Name": "丹尼尔·克雷格",
+                  "Id": "33625",
+                  "Role": "James Bond",
+                  "Type": "Actor",
+                  "PrimaryImageTag": "bef4f764540f10577f804201d8d27918"
+                }
+            ]
+            """
+            peoples = []
+            # 更新当前媒体项人物
+            for people in iteminfo["People"]:
+                if not people.get("Name"):
+                    continue
+                if StringUtils.is_chinese(people.get("Name")):
+                    peoples.append(people)
+                    continue
+                if self._event.is_set():
+                    logger.info(f"演职人员刮削服务停止")
+                    return
+                info = self.__update_people(server=server, people=people,
+                                            douban_actors=douban_actors)
+                if info:
+                    peoples.append(info)
+                elif not self._remove_nozh:
+                    peoples.append(people)
+            # 保存媒体项信息
+            if peoples:
+                iteminfo["People"] = peoples
+                self.set_iteminfo(server=server, itemid=item.item_id, iteminfo=iteminfo)
+
+        # 处理季和集人物
+        if iteminfo.get("Type") and "Series" in iteminfo["Type"]:
+            # 获取季媒体项
+            seasons = self.get_items(server=server, parentid=item.item_id, mtype="Season")
+            if not seasons:
+                logger.warn(f"{item.title} 未找到季媒体项")
+                return
+            for season in seasons["Items"]:
+                # 获取豆瓣演员信息
+                season_actors = self.__get_douban_actors(mediainfo=mediainfo, season=season.get("IndexNumber"))
+                # 如果是Jellyfin，更新季的人物，Emby/Plex季没有人物
+                if server == "jellyfin":
+                    seasoninfo = self.get_iteminfo(server=server, itemid=season.get("Id"))
+                    if not seasoninfo:
+                        logger.warn(f"{item.title} 未找到季媒体项：{season.get('Id')}")
+                        continue
+                    # 更新季媒体项人物
+                    peoples = []
+                    if seasoninfo.get("People"):
+                        logger.info(f"开始更新季 {seasoninfo.get('Id')} 的人物信息 ...")
+                        for people in seasoninfo["People"]:
+                            if not people.get("Name"):
+                                continue
+                            if StringUtils.is_chinese(people.get("Name")):
+                                peoples.append(people)
+                                continue
+                            if self._event.is_set():
+                                logger.info(f"演职人员刮削服务停止")
+                                return
+                            # 更新人物信息
+                            info = self.__update_people(server=server, people=people,
+                                                        douban_actors=season_actors)
+                            if info:
+                                peoples.append(info)
+                            elif not self._remove_nozh:
+                                peoples.append(people)
+                        # 保存季媒体项信息
+                        if peoples:
+                            seasoninfo["People"] = peoples
+                            self.set_iteminfo(server=server, itemid=season.get("Id"), iteminfo=seasoninfo)
+                        logger.info(f"季 {seasoninfo.get('Id')} 的人物信息更新完成")
+                # 获取集媒体项
+                episodes = self.get_items(server=server, parentid=season.get("Id"), mtype="Episode")
+                if not episodes:
+                    logger.warn(f"{item.title} 未找到集媒体项")
+                    continue
+                # 更新集媒体项人物
+                for episode in episodes["Items"]:
+                    # 获取集媒体项详情
+                    episodeinfo = self.get_iteminfo(server=server, itemid=episode.get("Id"))
+                    if not episodeinfo:
+                        logger.warn(f"{item.title} 未找到集媒体项：{episode.get('Id')}")
+                        continue
+                    # 更新集媒体项人物
+                    if episodeinfo.get("People"):
+                        logger.info(f"开始更新集 {episodeinfo.get('Id')} 的人物信息 ...")
+                        peoples = []
+                        for people in episodeinfo["People"]:
+                            if not people.get("Name"):
+                                continue
+                            if StringUtils.is_chinese(people.get("Name")):
+                                peoples.append(people)
+                                continue
+                            if self._event.is_set():
+                                logger.info(f"演职人员刮削服务停止")
+                                return
+                            # 更新人物信息
+                            info = self.__update_people(server=server, people=people,
+                                                        douban_actors=season_actors)
+                            if info:
+                                peoples.append(info)
+                            elif not self._remove_nozh:
+                                peoples.append(people)
+                        # 保存集媒体项信息
+                        if peoples:
+                            episodeinfo["People"] = peoples
+                            self.set_iteminfo(server=server, itemid=episode.get("Id"), iteminfo=episodeinfo)
+                        logger.info(f"集 {episodeinfo.get('Id')} 的人物信息更新完成")
+
+    def __update_people(self, server: str, people: dict, douban_actors: list = None) -> Optional[dict]:
+        """
+        更新人物信息，返回替换后的人物信息
+        """
+
+        def __get_peopleid(p: dict) -> Tuple[Optional[str], Optional[str]]:
+            """
+            获取人物的TMDBID、IMDBID
+            """
+            if not p.get("ProviderIds"):
+                return None, None
+            peopletmdbid, peopleimdbid = None, None
+            if "Tmdb" in p["ProviderIds"]:
+                peopletmdbid = p["ProviderIds"]["Tmdb"]
+            if "tmdb" in p["ProviderIds"]:
+                peopletmdbid = p["ProviderIds"]["tmdb"]
+            if "Imdb" in p["ProviderIds"]:
+                peopleimdbid = p["ProviderIds"]["Imdb"]
+            if "imdb" in p["ProviderIds"]:
+                peopleimdbid = p["ProviderIds"]["imdb"]
+            return peopletmdbid, peopleimdbid
+
+        # 返回的人物信息
+        ret_people = copy.deepcopy(people)
+
+        try:
+            # 查询媒体库人物详情
+            personinfo = self.get_iteminfo(server=server, itemid=people.get("Id"))
+            if not personinfo:
+                logger.warn(f"未找到人物 {people.get('Name')} 的信息")
+                return None
+
+            # 是否更新标志
+            updated_name = False
+            updated_overview = False
+            update_character = False
+            profile_path = None
+
+            # 从TMDB信息中更新人物信息
+            person_tmdbid, person_imdbid = __get_peopleid(personinfo)
+            if person_tmdbid:
+                person_tmdbinfo = self.tmdbchain.person_detail(int(person_tmdbid))
+                if person_tmdbinfo:
+                    cn_name = self.__get_chinese_name(person_tmdbinfo)
+                    if cn_name:
+                        # 更新中文名
+                        logger.info(f"{people.get('Name')} 从TMDB获取到中文名：{cn_name}")
+                        personinfo["Name"] = cn_name
+                        ret_people["Name"] = cn_name
+                        updated_name = True
+                        # 更新中文描述
+                        biography = person_tmdbinfo.get("biography")
+                        if biography and StringUtils.is_chinese(biography):
+                            logger.info(f"{people.get('Name')} 从TMDB获取到中文描述")
+                            personinfo["Overview"] = biography
+                            updated_overview = True
+                        # 图片
+                        profile_path = person_tmdbinfo.get('profile_path')
+                        if profile_path:
+                            logger.info(f"{people.get('Name')} 从TMDB获取到图片：{profile_path}")
+                            profile_path = f"https://{settings.TMDB_IMAGE_DOMAIN}/t/p/original{profile_path}"
+
+            # 从豆瓣信息中更新人物信息
+            if douban_actors and (not updated_name
+                                  or not updated_overview
+                                  or not update_character):
+                # 从豆瓣演员中匹配中文名称、角色和简介
+                for douban_actor in douban_actors:
+                    if douban_actor.get("latin_name") == people.get("Name"):
+                        # 名称
+                        if not updated_name:
+                            logger.info(f"{people.get('Name')} 从豆瓣中获取到中文名：{douban_actor.get('name')}")
+                            personinfo["Name"] = douban_actor.get("name")
+                            ret_people["Name"] = douban_actor.get("name")
+                            updated_name = True
+                        # 描述
+                        if not updated_overview:
+                            if douban_actor.get("title"):
+                                logger.info(f"{people.get('Name')} 从豆瓣中获取到中文描述：{douban_actor.get('title')}")
+                                personinfo["Overview"] = douban_actor.get("title")
+                                updated_overview = True
+                        # 饰演角色
+                        if not update_character:
+                            if douban_actor.get("character"):
+                                # "饰 詹姆斯·邦德 James Bond 007"
+                                character = re.sub(r"饰\s+", "",
+                                                   douban_actor.get("character"))
+                                character = re.sub("演员", "",
+                                                   character)
+                                if character:
+                                    logger.info(f"{people.get('Name')} 从豆瓣中获取到饰演角色：{character}")
+                                    ret_people["Role"] = character
+                                    update_character = True
+                        # 图片
+                        if not profile_path:
+                            avatar = douban_actor.get("avatar") or {}
+                            if avatar.get("large"):
+                                logger.info(f"{people.get('Name')} 从豆瓣中获取到图片：{avatar.get('large')}")
+                                profile_path = avatar.get("large")
+                        break
+
+            # 更新人物图片
+            if profile_path:
+                logger.info(f"更新人物 {people.get('Name')} 的图片：{profile_path}")
+                self.set_item_image(server=server, itemid=people.get("Id"), imageurl=profile_path)
+
+            # 锁定人物信息
+            if updated_name:
+                if "Name" not in personinfo["LockedFields"]:
+                    personinfo["LockedFields"].append("Name")
+            if updated_overview:
+                if "Overview" not in personinfo["LockedFields"]:
+                    personinfo["LockedFields"].append("Overview")
+
+            # 更新人物信息
+            if updated_name or updated_overview or update_character:
+                logger.info(f"更新人物 {people.get('Name')} 的信息：{personinfo}")
+                ret = self.set_iteminfo(server=server, itemid=people.get("Id"), iteminfo=personinfo)
+                if ret:
+                    return ret_people
+            else:
+                logger.info(f"人物 {people.get('Name')} 未找到中文数据")
+        except Exception as err:
+            logger.error(f"更新人物信息失败：{err}")
+        return None
+
+    def __get_douban_actors(self, mediainfo: MediaInfo, season: int = None) -> List[dict]:
+        """
+        获取豆瓣演员信息
+        """
+        # 随机休眠1-5秒
+        time.sleep(1 + int(time.time()) % 5)
+        # 匹配豆瓣信息
+        doubaninfo = self.chain.match_doubaninfo(name=mediainfo.title,
+                                                 mtype=mediainfo.type.value,
+                                                 year=mediainfo.year,
+                                                 season=season)
+        # 豆瓣演员
+        if doubaninfo:
+            doubanitem = self.chain.douban_info(doubaninfo.get("id")) or {}
+            return (doubanitem.get("actors") or []) + (doubanitem.get("directors") or [])
+        return []
+
+    @staticmethod
+    def get_iteminfo(server: str, itemid: str) -> dict:
+        """
+        获得媒体项详情
+        """
+
+        def __get_emby_iteminfo() -> dict:
+            """
+            获得Emby媒体项详情
+            """
+            try:
+                url = f'[HOST]emby/Users/[USER]/Items/{itemid}?' \
+                      f'Fields=ChannelMappingInfo&api_key=[APIKEY]'
+                res = Emby().get_data(url=url)
+                if res:
+                    return res.json()
+            except Exception as err:
+                logger.error(f"获取Emby媒体项详情失败：{err}")
+            return {}
+
+        def __get_jellyfin_iteminfo() -> dict:
+            """
+            获得Jellyfin媒体项详情
+            """
+            try:
+                url = f'[HOST]Users/[USER]/Items/{itemid}?Fields=ChannelMappingInfo&api_key=[APIKEY]'
+                res = Jellyfin().get_data(url=url)
+                if res:
+                    result = res.json()
+                    if result:
+                        result['FileName'] = Path(result['Path']).name
+                    return result
+            except Exception as err:
+                logger.error(f"获取Jellyfin媒体项详情失败：{err}")
+            return {}
+
+        def __get_plex_iteminfo() -> dict:
+            """
+            获得Plex媒体项详情
+            """
+            iteminfo = {}
+            try:
+                plexitem = Plex().get_plex().library.fetchItem(ekey=itemid)
+                if 'movie' in plexitem.METADATA_TYPE:
+                    iteminfo['Type'] = 'Movie'
+                    iteminfo['IsFolder'] = False
+                elif 'episode' in plexitem.METADATA_TYPE:
+                    iteminfo['Type'] = 'Series'
+                    iteminfo['IsFolder'] = False
+                    if 'show' in plexitem.TYPE:
+                        iteminfo['ChildCount'] = plexitem.childCount
+                iteminfo['Name'] = plexitem.title
+                iteminfo['Id'] = plexitem.key
+                iteminfo['ProductionYear'] = plexitem.year
+                iteminfo['ProviderIds'] = {}
+                for guid in plexitem.guids:
+                    idlist = str(guid.id).split(sep='://')
+                    if len(idlist) < 2:
+                        continue
+                    iteminfo['ProviderIds'][idlist[0]] = idlist[1]
+                for location in plexitem.locations:
+                    iteminfo['Path'] = location
+                    iteminfo['FileName'] = Path(location).name
+                iteminfo['Overview'] = plexitem.summary
+                iteminfo['CommunityRating'] = plexitem.audienceRating
+                return iteminfo
+            except Exception as err:
+                logger.error(f"获取Plex媒体项详情失败：{err}")
+            return {}
+
+        if server == "emby":
+            return __get_emby_iteminfo()
+        elif server == "jellyfin":
+            return __get_jellyfin_iteminfo()
+        else:
+            return __get_plex_iteminfo()
+
+    @staticmethod
+    def get_items(server: str, parentid: str, mtype: str = None) -> dict:
+        """
+        获得媒体的所有子媒体项
+        """
+        pass
+
+        def __get_emby_items() -> dict:
+            """
+            获得Emby媒体的所有子媒体项
+            """
+            try:
+                if parentid:
+                    url = f'[HOST]emby/Users/[USER]/Items?ParentId={parentid}&api_key=[APIKEY]'
+                else:
+                    url = '[HOST]emby/Users/[USER]/Items?api_key=[APIKEY]'
+                res = Emby().get_data(url=url)
+                if res:
+                    return res.json()
+            except Exception as err:
+                logger.error(f"获取Emby媒体的所有子媒体项失败：{err}")
+            return {}
+
+        def __get_jellyfin_items() -> dict:
+            """
+            获得Jellyfin媒体的所有子媒体项
+            """
+            try:
+                if parentid:
+                    url = f'[HOST]Users/[USER]/Items?ParentId={parentid}&api_key=[APIKEY]'
+                else:
+                    url = '[HOST]Users/[USER]/Items?api_key=[APIKEY]'
+                res = Jellyfin().get_data(url=url)
+                if res:
+                    return res.json()
+            except Exception as err:
+                logger.error(f"获取Jellyfin媒体的所有子媒体项失败：{err}")
+            return {}
+
+        def __get_plex_items(t: str) -> dict:
+            """
+            获得Plex媒体的所有子媒体项
+            """
+            items = {}
+            try:
+                plex = Plex().get_plex()
+                items['Items'] = []
+                if parentid:
+                    if mtype and 'Season' in t:
+                        plexitem = plex.library.fetchItem(ekey=parentid)
+                        items['Items'] = []
+                        for season in plexitem.seasons():
+                            item = {
+                                'Name': season.title,
+                                'Id': season.key,
+                                'IndexNumber': season.seasonNumber,
+                                'Overview': season.summary
+                            }
+                            items['Items'].append(item)
+                    elif mtype and 'Episode' in t:
+                        plexitem = plex.library.fetchItem(ekey=parentid)
+                        items['Items'] = []
+                        for episode in plexitem.episodes():
+                            item = {
+                                'Name': episode.title,
+                                'Id': episode.key,
+                                'IndexNumber': episode.episodeNumber,
+                                'Overview': episode.summary,
+                                'CommunityRating': episode.audienceRating
+                            }
+                            items['Items'].append(item)
+                    else:
+                        plexitems = plex.library.sectionByID(sectionID=parentid)
+                        for plexitem in plexitems.all():
+                            item = {}
+                            if 'movie' in plexitem.METADATA_TYPE:
+                                item['Type'] = 'Movie'
+                                item['IsFolder'] = False
+                            elif 'episode' in plexitem.METADATA_TYPE:
+                                item['Type'] = 'Series'
+                                item['IsFolder'] = False
+                            item['Name'] = plexitem.title
+                            item['Id'] = plexitem.key
+                            items['Items'].append(item)
+                else:
+                    plexitems = plex.library.sections()
+                    for plexitem in plexitems:
+                        item = {}
+                        if 'Directory' in plexitem.TAG:
+                            item['Type'] = 'Folder'
+                            item['IsFolder'] = True
+                        elif 'movie' in plexitem.METADATA_TYPE:
+                            item['Type'] = 'Movie'
+                            item['IsFolder'] = False
+                        elif 'episode' in plexitem.METADATA_TYPE:
+                            item['Type'] = 'Series'
+                            item['IsFolder'] = False
+                        item['Name'] = plexitem.title
+                        item['Id'] = plexitem.key
+                        items['Items'].append(item)
+                return items
+            except Exception as err:
+                logger.error(f"获取Plex媒体的所有子媒体项失败：{err}")
+            return {}
+
+        if server == "emby":
+            return __get_emby_items()
+        elif server == "jellyfin":
+            return __get_jellyfin_items()
+        else:
+            return __get_plex_items(mtype)
+
+    @staticmethod
+    def set_iteminfo(server: str, itemid: str, iteminfo: dict):
+        """
+        更新媒体项详情
+        """
+
+        def __set_emby_iteminfo():
+            """
+            更新Emby媒体项详情
+            """
+            try:
+                res = Emby().post_data(
+                    url=f'[HOST]emby/Items/{itemid}?api_key=[APIKEY]&reqformat=json',
+                    data=json.dumps(iteminfo),
+                    headers={
+                        "Content-Type": "application/json"
+                    }
+                )
+                if res and res.status_code in [200, 204]:
+                    return True
+                else:
+                    logger.error(f"更新Emby媒体项详情失败，错误码：{res.status_code}")
+                    return False
+            except Exception as err:
+                logger.error(f"更新Emby媒体项详情失败：{err}")
+            return False
+
+        def __set_jellyfin_iteminfo():
+            """
+            更新Jellyfin媒体项详情
+            """
+            try:
+                res = Jellyfin().post_data(
+                    url=f'[HOST]Items/{itemid}?api_key=[APIKEY]',
+                    data=json.dumps(iteminfo),
+                    headers={
+                        "Content-Type": "application/json"
+                    }
+                )
+                if res and res.status_code in [200, 204]:
+                    return True
+                else:
+                    logger.error(f"更新Jellyfin媒体项详情失败，错误码：{res.status_code}")
+                    return False
+            except Exception as err:
+                logger.error(f"更新Jellyfin媒体项详情失败：{err}")
+            return False
+
+        def __set_plex_iteminfo():
+            """
+            更新Plex媒体项详情
+            """
+            try:
+                plexitem = Plex().get_plex().library.fetchItem(ekey=itemid)
+                if 'CommunityRating' in iteminfo:
+                    edits = {
+                        'audienceRating.value': iteminfo['CommunityRating'],
+                        'audienceRating.locked': 1
+                    }
+                    plexitem.edit(**edits)
+                plexitem.editTitle(iteminfo['Name']).editSummary(iteminfo['Overview']).reload()
+                return True
+            except Exception as err:
+                logger.error(f"更新Plex媒体项详情失败：{err}")
+            return False
+
+        if server == "emby":
+            return __set_emby_iteminfo()
+        elif server == "jellyfin":
+            return __set_jellyfin_iteminfo()
+        else:
+            return __set_plex_iteminfo()
 
     @staticmethod
     @retry(RequestException, logger=logger)
-    def download_image(image_url: str, path: Path):
+    def set_item_image(server: str, itemid: str, imageurl: str):
         """
-        下载图片，保存到指定路径
+        更新媒体项图片
+        """
+
+        def __download_image():
+            """
+            下载图片
+            """
+            try:
+                if "doubanio.com" in imageurl:
+                    r = RequestUtils(headers={
+                        'Referer': "https://movie.douban.com/"
+                    }, ua=settings.USER_AGENT).get_res(url=imageurl, raise_exception=True)
+                else:
+                    r = RequestUtils().get_res(url=imageurl, raise_exception=True)
+                if r:
+                    return base64.b64encode(r.content).decode()
+                else:
+                    logger.info(f"{imageurl} 图片下载失败，请检查网络连通性")
+            except Exception as err:
+                logger.error(f"下载图片失败：{err}")
+            return None
+
+        def __set_emby_item_image(_base64: str):
+            """
+            更新Emby媒体项图片
+            """
+            try:
+                url = f'[HOST]emby/Items/{itemid}/Images/Primary?api_key=[APIKEY]'
+                res = Emby().post_data(
+                    url=url,
+                    data=_base64,
+                    headers={
+                        "Content-Type": "image/png"
+                    }
+                )
+                if res and res.status_code in [200, 204]:
+                    return True
+                else:
+                    logger.error(f"更新Emby媒体项图片失败，错误码：{res.status_code}")
+                    return False
+            except Exception as result:
+                logger.error(f"更新Emby媒体项图片失败：{result}")
+            return False
+
+        def __set_jellyfin_item_image():
+            """
+            更新Jellyfin媒体项图片
+            # FIXME 改为预下载图片
+            """
+            try:
+                url = f'[HOST]Items/{itemid}/RemoteImages/Download?' \
+                      f'Type=Primary&ImageUrl={imageurl}&ProviderName=TheMovieDb&api_key=[APIKEY]'
+                res = Jellyfin().post_data(url=url)
+                if res and res.status_code in [200, 204]:
+                    return True
+                else:
+                    logger.error(f"更新Jellyfin媒体项图片失败，错误码：{res.status_code}")
+                    return False
+            except Exception as err:
+                logger.error(f"更新Jellyfin媒体项图片失败：{err}")
+            return False
+
+        def __set_plex_item_image():
+            """
+            更新Plex媒体项图片
+            # FIXME 改为预下载图片
+            """
+            try:
+                plexitem = Plex().get_plex().library.fetchItem(ekey=itemid)
+                plexitem.uploadPoster(url=imageurl)
+                return True
+            except Exception as err:
+                logger.error(f"更新Plex媒体项图片失败：{err}")
+            return False
+
+        if server == "emby":
+            # 下载图片获取base64
+            image_base64 = __download_image()
+            if image_base64:
+                return __set_emby_item_image(image_base64)
+        elif server == "jellyfin":
+            return __set_jellyfin_item_image()
+        else:
+            return __set_plex_item_image()
+        return None
+
+    @staticmethod
+    def __get_chinese_name(personinfo: dict) -> str:
+        """
+        获取TMDB别名中的中文名
         """
         try:
-            logger.info(f"正在下载演职人员图片：{image_url} ...")
-            r = RequestUtils().get_res(url=image_url, raise_exception=True)
-            if r:
-                path.write_bytes(r.content)
-                logger.info(f"图片已保存：{path}")
-            else:
-                logger.info(f"图片下载失败，请检查网络连通性：{image_url}")
-        except RequestException as err:
-            raise err
+            also_known_as = personinfo.get("also_known_as") or []
+            if also_known_as:
+                for name in also_known_as:
+                    if name and StringUtils.is_chinese(name):
+                        # 使用cn2an将繁体转化为简体
+                        return zhconv.convert(name, "zh-hans")
         except Exception as err:
-            logger.error(f"图片下载失败：{err}")
+            logger.error(f"获取人物中文名失败：{err}")
+        return ""
 
     def stop_service(self):
         """
-        退出插件
+        停止服务
         """
-        pass
+        try:
+            if self._scheduler:
+                self._scheduler.remove_all_jobs()
+                if self._scheduler.running:
+                    self._event.set()
+                    self._scheduler.shutdown()
+                    self._event.clear()
+                self._scheduler = None
+        except Exception as e:
+            print(str(e))

app/plugins/sitestatistic/__init__.py

@@ -841,87 +841,88 @@ class SiteStatistic(_PluginBase):
         url = site_info.get("url")
         proxy = site_info.get("proxy")
         ua = site_info.get("ua")
-        session = requests.Session()
-        proxies = settings.PROXY if proxy else None
-        proxy_server = settings.PROXY_SERVER if proxy else None
-        render = site_info.get("render")
+        # 会话管理
+        with requests.Session() as session:
+            proxies = settings.PROXY if proxy else None
+            proxy_server = settings.PROXY_SERVER if proxy else None
+            render = site_info.get("render")
 
-        logger.debug(f"站点 {site_name} url={url} site_cookie={site_cookie} ua={ua}")
-        if render:
-            # 演染模式
-            html_text = PlaywrightHelper().get_page_source(url=url,
-                                                           cookies=site_cookie,
-                                                           ua=ua,
-                                                           proxies=proxy_server)
-        else:
-            # 普通模式
-            res = RequestUtils(cookies=site_cookie,
-                               session=session,
-                               ua=ua,
-                               proxies=proxies
-                               ).get_res(url=url)
-            if res and res.status_code == 200:
-                if re.search(r"charset=\"?utf-8\"?", res.text, re.IGNORECASE):
-                    res.encoding = "utf-8"
-                else:
-                    res.encoding = res.apparent_encoding
-                html_text = res.text
-                # 第一次登录反爬
-                if html_text.find("title") == -1:
-                    i = html_text.find("window.location")
-                    if i == -1:
-                        return None
-                    tmp_url = url + html_text[i:html_text.find(";")] \
-                        .replace("\"", "") \
-                        .replace("+", "") \
-                        .replace(" ", "") \
-                        .replace("window.location=", "")
-                    res = RequestUtils(cookies=site_cookie,
-                                       session=session,
-                                       ua=ua,
-                                       proxies=proxies
-                                       ).get_res(url=tmp_url)
-                    if res and res.status_code == 200:
-                        if "charset=utf-8" in res.text or "charset=UTF-8" in res.text:
-                            res.encoding = "UTF-8"
-                        else:
-                            res.encoding = res.apparent_encoding
-                        html_text = res.text
-                        if not html_text:
-                            return None
-                    else:
-                        logger.error("站点 %s 被反爬限制：%s, 状态码：%s" % (site_name, url, res.status_code))
-                        return None
-
-                # 兼容假首页情况，假首页通常没有 <link rel="search" 属性
-                if '"search"' not in html_text and '"csrf-token"' not in html_text:
-                    res = RequestUtils(cookies=site_cookie,
-                                       session=session,
-                                       ua=ua,
-                                       proxies=proxies
-                                       ).get_res(url=url + "/index.php")
-                    if res and res.status_code == 200:
-                        if re.search(r"charset=\"?utf-8\"?", res.text, re.IGNORECASE):
-                            res.encoding = "utf-8"
-                        else:
-                            res.encoding = res.apparent_encoding
-                        html_text = res.text
-                        if not html_text:
-                            return None
-            elif res is not None:
-                logger.error(f"站点 {site_name} 连接失败，状态码：{res.status_code}")
-                return None
+            logger.debug(f"站点 {site_name} url={url} site_cookie={site_cookie} ua={ua}")
+            if render:
+                # 演染模式
+                html_text = PlaywrightHelper().get_page_source(url=url,
+                                                               cookies=site_cookie,
+                                                               ua=ua,
+                                                               proxies=proxy_server)
             else:
-                logger.error(f"站点 {site_name} 无法访问：{url}")
-                return None
-        # 解析站点类型
-        if html_text:
-            site_schema = self.__build_class(html_text)
-            if not site_schema:
-                logger.error("站点 %s 无法识别站点类型" % site_name)
-                return None
-            return site_schema(site_name, url, site_cookie, html_text, session=session, ua=ua, proxy=proxy)
-        return None
+                # 普通模式
+                res = RequestUtils(cookies=site_cookie,
+                                   session=session,
+                                   ua=ua,
+                                   proxies=proxies
+                                   ).get_res(url=url)
+                if res and res.status_code == 200:
+                    if re.search(r"charset=\"?utf-8\"?", res.text, re.IGNORECASE):
+                        res.encoding = "utf-8"
+                    else:
+                        res.encoding = res.apparent_encoding
+                    html_text = res.text
+                    # 第一次登录反爬
+                    if html_text.find("title") == -1:
+                        i = html_text.find("window.location")
+                        if i == -1:
+                            return None
+                        tmp_url = url + html_text[i:html_text.find(";")] \
+                            .replace("\"", "") \
+                            .replace("+", "") \
+                            .replace(" ", "") \
+                            .replace("window.location=", "")
+                        res = RequestUtils(cookies=site_cookie,
+                                           session=session,
+                                           ua=ua,
+                                           proxies=proxies
+                                           ).get_res(url=tmp_url)
+                        if res and res.status_code == 200:
+                            if "charset=utf-8" in res.text or "charset=UTF-8" in res.text:
+                                res.encoding = "UTF-8"
+                            else:
+                                res.encoding = res.apparent_encoding
+                            html_text = res.text
+                            if not html_text:
+                                return None
+                        else:
+                            logger.error("站点 %s 被反爬限制：%s, 状态码：%s" % (site_name, url, res.status_code))
+                            return None
+
+                    # 兼容假首页情况，假首页通常没有 <link rel="search" 属性
+                    if '"search"' not in html_text and '"csrf-token"' not in html_text:
+                        res = RequestUtils(cookies=site_cookie,
+                                           session=session,
+                                           ua=ua,
+                                           proxies=proxies
+                                           ).get_res(url=url + "/index.php")
+                        if res and res.status_code == 200:
+                            if re.search(r"charset=\"?utf-8\"?", res.text, re.IGNORECASE):
+                                res.encoding = "utf-8"
+                            else:
+                                res.encoding = res.apparent_encoding
+                            html_text = res.text
+                            if not html_text:
+                                return None
+                elif res is not None:
+                    logger.error(f"站点 {site_name} 连接失败，状态码：{res.status_code}")
+                    return None
+                else:
+                    logger.error(f"站点 {site_name} 无法访问：{url}")
+                    return None
+            # 解析站点类型
+            if html_text:
+                site_schema = self.__build_class(html_text)
+                if not site_schema:
+                    logger.error("站点 %s 无法识别站点类型" % site_name)
+                    return None
+                return site_schema(site_name, url, site_cookie, html_text, session=session, ua=ua, proxy=proxy)
+            return None
 
     def refresh_by_domain(self, domain: str) -> schemas.Response:
         """

app/plugins/sitestatistic/siteuserinfo/__init__.py

@@ -6,7 +6,6 @@ from enum import Enum
 from typing import Optional
 from urllib.parse import urljoin, urlsplit
 
-import requests
 from requests import Session
 
 from app.core.config import settings
@@ -107,7 +106,7 @@ class ISiteUserInfo(metaclass=ABCMeta):
         self._base_url = f"{split_url.scheme}://{split_url.netloc}"
         self._site_cookie = site_cookie
         self._index_html = index_html
-        self._session = session if session else requests.Session()
+        self._session = session if session else None
         self._ua = ua
 
         self._emulate = emulate

app/plugins/speedlimiter/__init__.py

@@ -383,7 +383,14 @@ class SpeedLimiter(_PluginBase):
             return
         if event:
             event_data: WebhookEventInfo = event.event_data
-            if event_data.event not in ["playback.start", "PlaybackStart", "media.play"]:
+            if event_data.event not in [
+                "playback.start",
+                "PlaybackStart",
+                "media.play",
+                "media.stop",
+                "PlaybackStop",
+                "playback.stop"
+            ]:
                 return
         # 当前播放的总比特率
         total_bit_rate = 0
@@ -396,7 +403,7 @@ class SpeedLimiter(_PluginBase):
             # 查询播放中会话
             playing_sessions = []
             if media_server == "emby":
-                req_url = "{HOST}emby/Sessions?api_key={APIKEY}"
+                req_url = "[HOST]emby/Sessions?api_key=[APIKEY]"
                 try:
                     res = Emby().get_data(req_url)
                     if res and res.status_code == 200:
@@ -419,7 +426,7 @@ class SpeedLimiter(_PluginBase):
                             and session.get("NowPlayingItem", {}).get("MediaType") == "Video":
                         total_bit_rate += int(session.get("NowPlayingItem", {}).get("Bitrate") or 0)
             elif media_server == "jellyfin":
-                req_url = "{HOST}Sessions?api_key={APIKEY}"
+                req_url = "[HOST]Sessions?api_key=[APIKEY]"
                 try:
                     res = Jellyfin().get_data(req_url)
                     if res and res.status_code == 200:

app/plugins/torrenttransfer/__init__.py

@@ -100,7 +100,7 @@ class TorrentTransfer(_PluginBase):
                 return
             if self._fromdownloader == self._todownloader:
                 logger.error(f"源下载器和目的下载器不能相同")
-                self.systemmessage(f"源下载器和目的下载器不能相同")
+                self.systemmessage.put(f"源下载器和目的下载器不能相同")
                 return
             self._scheduler = BackgroundScheduler(timezone=settings.TZ)
             if self._cron:
@@ -110,7 +110,7 @@ class TorrentTransfer(_PluginBase):
                                             CronTrigger.from_crontab(self._cron))
                 except Exception as e:
                     logger.error(f"转移做种服务启动失败：{e}")
-                    self.systemmessage(f"转移做种服务启动失败：{e}")
+                    self.systemmessage.put(f"转移做种服务启动失败：{e}")
                     return
             if self._onlyonce:
                 logger.info(f"转移做种服务启动，立即运行一次")

app/plugins/webhook/__init__.py

@@ -137,13 +137,29 @@ class WebHook(_PluginBase):
             return
 
         def __to_dict(_event):
-            result = {}
-            for key, value in _event.items():
-                if hasattr(value, 'to_dict'):
-                    result[key] = value.to_dict()
-                else:
-                    result[key] = str(value)
-            return result
+            """
+            递归将对象转换为字典
+            """
+            if isinstance(_event, dict):
+                for k, v in _event.items():
+                    _event[k] = __to_dict(v)
+                return _event
+            elif isinstance(_event, list):
+                for i in range(len(_event)):
+                    _event[i] = __to_dict(_event[i])
+                return _event
+            elif isinstance(_event, tuple):
+                return tuple(__to_dict(list(_event)))
+            elif isinstance(_event, set):
+                return set(__to_dict(list(_event)))
+            elif hasattr(_event, 'to_dict'):
+                return __to_dict(_event.to_dict())
+            elif hasattr(_event, '__dict__'):
+                return __to_dict(_event.__dict__)
+            elif isinstance(_event, (int, float, str, bool, type(None))):
+                return _event
+            else:
+                return str(_event)
 
         event_info = {
             "type": event.event_type,

app/scheduler.py

@@ -11,6 +11,7 @@ from app.chain import ChainBase
 from app.chain.cookiecloud import CookieCloudChain
 from app.chain.mediaserver import MediaServerChain
 from app.chain.subscribe import SubscribeChain
+from app.chain.tmdb import TmdbChain
 from app.chain.transfer import TransferChain
 from app.core.config import settings
 from app.db import SessionFactory
@@ -183,6 +184,14 @@ class Scheduler(metaclass=Singleton):
                 }
             )
 
+        # 后台刷新TMDB壁纸
+        self._scheduler.add_job(
+            TmdbChain(self._db).get_random_wallpager,
+            "interval",
+            minutes=30,
+            next_run_time=datetime.now(pytz.timezone(settings.TZ)) + timedelta(seconds=3)
+        )
+
         # 公共定时服务
         self._scheduler.add_job(
             SchedulerChain(self._db).scheduler_job,

app/schemas/mediaserver.py

@@ -14,6 +14,10 @@ class ExistMediaInfo(BaseModel):
     type: Optional[MediaType]
     # 季
     seasons: Optional[Dict[int, list]] = {}
+    # 媒体服务器
+    server: Optional[str] = None
+    # 媒体ID
+    itemid: Optional[Union[str, int]] = None
 
 
 class NotExistMediaInfo(BaseModel):

app/utils/http.py

@@ -59,7 +59,8 @@ class RequestUtils:
                                           headers=self._headers,
                                           proxies=self._proxies,
                                           timeout=self._timeout,
-                                          json=json)
+                                          json=json,
+                                          stream=False)
             else:
                 return requests.post(url,
                                      data=data,
@@ -67,7 +68,8 @@ class RequestUtils:
                                      headers=self._headers,
                                      proxies=self._proxies,
                                      timeout=self._timeout,
-                                     json=json)
+                                     json=json,
+                                     stream=False)
         except requests.exceptions.RequestException:
             return None
 
@@ -91,27 +93,38 @@ class RequestUtils:
         except requests.exceptions.RequestException:
             return None
 
-    def get_res(self, url: str, params: dict = None,
-                allow_redirects: bool = True, raise_exception: bool = False) -> Optional[Response]:
+    def get_res(self, url: str,
+                params: dict = None,
+                data: Any = None,
+                json: dict = None,
+                allow_redirects: bool = True,
+                raise_exception: bool = False
+                ) -> Optional[Response]:
         try:
             if self._session:
                 return self._session.get(url,
                                          params=params,
+                                         data=data,
+                                         json=json,
                                          verify=False,
                                          headers=self._headers,
                                          proxies=self._proxies,
                                          cookies=self._cookies,
                                          timeout=self._timeout,
-                                         allow_redirects=allow_redirects)
+                                         allow_redirects=allow_redirects,
+                                         stream=False)
             else:
                 return requests.get(url,
                                     params=params,
+                                    data=data,
+                                    json=json,
                                     verify=False,
                                     headers=self._headers,
                                     proxies=self._proxies,
                                     cookies=self._cookies,
                                     timeout=self._timeout,
-                                    allow_redirects=allow_redirects)
+                                    allow_redirects=allow_redirects,
+                                    stream=False)
         except requests.exceptions.RequestException:
             if raise_exception:
                 raise requests.exceptions.RequestException
@@ -120,7 +133,8 @@ class RequestUtils:
     def post_res(self, url: str, data: Any = None, params: dict = None,
                  allow_redirects: bool = True,
                  files: Any = None,
-                 json: dict = None) -> Optional[Response]:
+                 json: dict = None,
+                 raise_exception: bool = False) -> Optional[Response]:
         try:
             if self._session:
                 return self._session.post(url,
@@ -133,7 +147,8 @@ class RequestUtils:
                                           timeout=self._timeout,
                                           allow_redirects=allow_redirects,
                                           files=files,
-                                          json=json)
+                                          json=json,
+                                          stream=False)
             else:
                 return requests.post(url,
                                      data=data,
@@ -145,8 +160,11 @@ class RequestUtils:
                                      timeout=self._timeout,
                                      allow_redirects=allow_redirects,
                                      files=files,
-                                     json=json)
+                                     json=json,
+                                     stream=False)
         except requests.exceptions.RequestException:
+            if raise_exception:
+                raise requests.exceptions.RequestException
             return None
 
     @staticmethod

config/app.env

@@ -0,0 +1,185 @@
+####################################
+#  系统设置                         #
+####################################
+# 时区
+TZ="Asia/Shanghai"
+# API监听地址
+HOST="0.0.0.0"
+# API监听端口
+PORT=3001
+# 是否调试模式
+DEBUG=false
+# 是否开发模式
+DEV=false
+# 超级管理员
+SUPERUSER="admin"
+# 超级管理员初始密码
+SUPERUSER_PASSWORD="password"
+# API密钥，建议更换复杂字符串
+API_TOKEN="moviepilot"
+# 网络代理 IP:PORT
+PROXY_HOST=
+# 大内存模式
+BIG_MEMORY_MODE=false
+
+####################################
+#  媒体识别&刮削                     #
+####################################
+# 媒体信息搜索来源 themoviedb/douban
+SEARCH_SOURCE="themoviedb"
+# 刮削入库的媒体文件 true/false
+SCRAP_METADATA=true
+# 新增已入库媒体是否跟随TMDB信息变化
+SCRAP_FOLLOW_TMDB=true
+# 刮削来源 themoviedb/douban
+SCRAP_SOURCE="themoviedb"
+# TMDB图片地址，无需修改需保留默认值
+TMDB_IMAGE_DOMAIN="image.tmdb.org"
+# TMDB API地址，无需修改需保留默认值
+TMDB_API_DOMAIN="api.themoviedb.org"
+
+####################################
+#   订阅&搜索                       #
+####################################
+# 订阅模式 spider/rss
+SUBSCRIBE_MODE="spider"
+# RSS订阅模式刷新时间间隔（分钟）
+SUBSCRIBE_RSS_INTERVAL=30
+# 订阅搜索开关
+SUBSCRIBE_SEARCH=false
+# 交互搜索自动下载用户ID，使用,分割
+AUTO_DOWNLOAD_USER=
+
+####################################
+#   消息通知                        #
+####################################
+# 消息通知渠道 telegram/wechat/slack，多个通知渠道用,分隔
+MESSAGER="telegram"
+# WeChat企业ID
+WECHAT_CORPID=
+# WeChat应用Secret
+WECHAT_APP_SECRET=
+# WeChat应用ID
+WECHAT_APP_ID=
+# WeChat代理服务器，无需代理需保留默认值
+WECHAT_PROXY="https://qyapi.weixin.qq.com"
+# WeChat Token
+WECHAT_TOKEN=
+# WeChat EncodingAESKey
+WECHAT_ENCODING_AESKEY=
+# WeChat 管理员
+WECHAT_ADMINS=
+# Telegram Bot Token
+TELEGRAM_TOKEN=
+# Telegram Chat ID
+TELEGRAM_CHAT_ID=
+# Telegram 用户ID，使用,分隔
+TELEGRAM_USERS=
+# Telegram 管理员ID，使用,分隔
+TELEGRAM_ADMINS=
+# Slack Bot User OAuth Token
+SLACK_OAUTH_TOKEN=
+# Slack App-Level Token
+SLACK_APP_TOKEN=
+# Slack 频道名称
+SLACK_CHANNEL=
+# SynologyChat Webhook
+SYNOLOGYCHAT_WEBHOOK=
+# SynologyChat Token
+SYNOLOGYCHAT_TOKEN=
+
+####################################
+#   下载                           #
+####################################
+# 下载器 qbittorrent/transmission
+DOWNLOADER="qbittorrent"
+# 下载器监控开关
+DOWNLOADER_MONITOR=true
+# Qbittorrent地址，IP:PORT
+QB_HOST=
+# Qbittorrent用户名
+QB_USER=
+# Qbittorrent密码
+QB_PASSWORD=
+# Qbittorrent分类自动管理
+QB_CATEGORY=false
+# Transmission地址，IP:PORT
+TR_HOST=
+# Transmission用户名
+TR_USER=
+# Transmission密码
+TR_PASSWORD=
+# 种子标签
+TORRENT_TAG="MOVIEPILOT"
+# 下载保存目录，容器内映射路径需要一致
+DOWNLOAD_PATH="/downloads"
+# 电影下载保存目录，容器内映射路径需要一致
+DOWNLOAD_MOVIE_PATH=
+# 电视剧下载保存目录，容器内映射路径需要一致
+DOWNLOAD_TV_PATH=
+# 动漫下载保存目录，容器内映射路径需要一致
+DOWNLOAD_ANIME_PATH=
+# 下载目录二级分类
+DOWNLOAD_CATEGORY=false
+# 下载站点字幕
+DOWNLOAD_SUBTITLE=true
+
+####################################
+#   媒体服务器                      #
+####################################
+# 媒体服务器 emby/jellyfin/plex，多个媒体服务器,分割
+MEDIASERVER="emby"
+# 入库刷新媒体库
+REFRESH_MEDIASERVER=true
+# 媒体服务器同步间隔（小时）
+MEDIASERVER_SYNC_INTERVAL=6
+# 媒体服务器同步黑名单，多个媒体库名称,分割
+MEDIASERVER_SYNC_BLACKLIST=
+# EMBY服务器地址，IP:PORT
+EMBY_HOST=
+# EMBY Api Key
+EMBY_API_KEY=
+# Jellyfin服务器地址，IP:PORT
+JELLYFIN_HOST=
+# Jellyfin Api Key
+JELLYFIN_API_KEY=
+# Plex服务器地址，IP:PORT
+PLEX_HOST=
+# Plex Token
+PLEX_TOKEN=
+
+####################################
+#   站点                           #
+####################################
+# CookieCloud服务器地址，默认为公共服务器
+COOKIECLOUD_HOST="https://movie-pilot.org/cookiecloud"
+# CookieCloud用户KEY
+COOKIECLOUD_KEY=
+# CookieCloud端对端加密密码
+COOKIECLOUD_PASSWORD=
+# CookieCloud同步间隔（分钟）
+COOKIECLOUD_INTERVAL=1440
+# OCR服务器地址
+OCR_HOST="https://movie-pilot.org"
+# CookieCloud对应的浏览器UA
+USER_AGENT="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/113.0.0.0 Safari/537.36 Edg/113.0.1774.57"
+
+####################################
+#   媒体库                          #
+####################################
+# 转移方式 link/copy/move/softlink
+TRANSFER_TYPE="copy"
+# 媒体库目录，多个目录使用,分隔
+LIBRARY_PATH=
+# 电影媒体库目录名，默认"电影"
+LIBRARY_MOVIE_NAME=
+# 电视剧媒体库目录名，默认"电视剧"
+LIBRARY_TV_NAME=
+# 动漫媒体库目录名，默认"电视剧/动漫"
+LIBRARY_ANIME_NAME=
+# 二级分类
+LIBRARY_CATEGORY=true
+# 电影重命名格式
+MOVIE_RENAME_FORMAT="{{title}}{% if year %} ({{year}}){% endif %}/{{title}}{% if year %} ({{year}}){% endif %}{% if part %}-{{part}}{% endif %}{% if videoFormat %} - {{videoFormat}}{% endif %}{{fileExt}}"
+# 电视剧重命名格式
+TV_RENAME_FORMAT="{{title}}{% if year %} ({{year}}){% endif %}/Season {{season}}/{{title}} - {{season_episode}}{% if part %}-{{part}}{% endif %}{% if episode %} - 第 {{episode}} 集{% endif %}{{fileExt}}"

requirements.txt

@@ -42,6 +42,7 @@ chardet~=4.0.0
 starlette~=0.27.0
 PyVirtualDisplay~=3.0
 psutil~=5.9.4
+python_dotenv~=1.0.0
 python_hosts~=1.0.3
 watchdog~=3.0.0
 tailer~=0.4.1

version.py

@@ -1 +1 @@
-APP_VERSION = 'v1.2.7'
+APP_VERSION = 'v1.2.9'