v1.4.7

Merge pull request #1180 from honue/main
fix singleton.py
2026-05-10 06:22:48 +08:00 · 2023-11-29 13:13:58 +08:00 · 2023-11-29 13:01:18 +08:00 · 2023-11-29 12:46:49 +08:00 · 2023-11-29 12:07:54 +08:00 · 2023-11-29 08:43:26 +08:00
45 changed files with 960 additions and 323 deletions
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -110,7 +110,7 @@ jobs:

      - name: Pyinstaller
        run: |
-          pyinstaller windows.spec
+          pyinstaller frozen.spec
        shell: pwsh

      - name: Upload Windows File
@@ -119,10 +119,54 @@ jobs:
          name: windows
          path: dist/MoviePilot.exe

+  Linux-build-amd64:
+    runs-on: ubuntu-latest
+    name: Build Linux Amd64
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Init Python 3.11.4
+        uses: actions/setup-python@v4
+        with:
+          python-version: '3.11.4'
+          cache: 'pip'
+
+      - name: Install Dependent Packages
+        run: |
+          python -m pip install --upgrade pip
+          pip install wheel pyinstaller
+          pip install -r requirements.txt
+
+      - name: Prepare Frontend
+        run: |
+          wget https://github.com/jxxghp/MoviePilot-Plugins/archive/refs/heads/main.zip
+          unzip main.zip
+          mv MoviePilot-Plugins-main/plugins/* app/plugins/
+          rm main.zip
+          rm -rf MoviePilot-Plugins-main
+          
+          wget https://github.com/jxxghp/MoviePilot-Resources/archive/refs/heads/main.zip
+          unzip main.zip
+          mv MoviePilot-Resources-main/resources/* app/helper/
+          rm main.zip
+          rm -rf MoviePilot-Resources-main
+
+      - name: Pyinstaller
+        run: |
+          pyinstaller frozen.spec
+          mv dist/MoviePilot dist/MoviePilot_Amd64
+
+      - name: Upload Linux File
+        uses: actions/upload-artifact@v3
+        with:
+          name: linux-amd64
+          path: dist/MoviePilot_Amd64
+
  Create-release:
    permissions: write-all
    runs-on: ubuntu-latest
-    needs: [ Windows-build, Docker-build ]
+    needs: [ Windows-build, Docker-build, Linux-build-amd64]
    steps:
      - uses: actions/checkout@v2

@@ -139,7 +183,8 @@ jobs:
        shell: bash
        run: |
          mkdir releases
-          mv ./windows/MoviePilot.exe ./releases/MoviePilot_v${{ env.app_version }}.exe
+          mv ./windows/MoviePilot.exe ./releases/MoviePilot_Win_v${{ env.app_version }}.exe
+          mv ./linux-amd64/MoviePilot_Amd64 ./releases/MoviePilot_Amd64_v${{ env.app_version }}

      - name: Create Release
        id: create_release
--- a/README.md
+++ b/README.md
@@ -39,11 +39,13 @@ MoviePilot需要配套下载器和媒体服务器配合使用。
  docker pull jxxghp/moviepilot:latest
  ```

-
 - Windows

-  下载 [MoviePilot.exe](https://github.com/jxxghp/MoviePilot/releases)，双击运行后自动生成配置文件目录。
+  下载 [MoviePilot.exe](https://github.com/jxxghp/MoviePilot/releases)，双击运行后自动生成配置文件目录，访问：http://localhost:3000

+- 群晖套件
+
+  添加套件源：https://spk7.imnks.com/

 - 本地运行

@@ -51,46 +53,73 @@ MoviePilot需要配套下载器和媒体服务器配合使用。
  2) 将工程 [MoviePilot-Resources](https://github.com/jxxghp/MoviePilot-Resources) resources目录下的所有文件复制到`app/helper`目录
  3) 执行命令：`pip install -r requirements.txt` 安装依赖
  4) 执行命令：`python app/main.py` 启动服务
+  5) 根据前端项目 [MoviePilot-Frontend](https://github.com/jxxghp/MoviePilot-Frontend) 说明，启动前端服务

 ## 配置

-项目的所有配置均通过环境变量进行设置，支持两种配置方式：
- 在Docker环境变量部分或Windows系统环境变量中进行参数配置，如未自动显示配置项则需要手动增加对应环境变量。
- 下载 [app.env](https://github.com/jxxghp/MoviePilot/raw/main/config/app.env) 配置文件，修改好配置后放置到配置文件映射路径根目录，配置项可根据说明自主增减。
-
 配置文件映射路径：`/config`，配置项生效优先级：环境变量 > env文件 > 默认值，**部分参数如路径映射、站点认证、权限端口、时区等必须通过环境变量进行配置**。

 > ❗号标识的为必填项，其它为可选项，可选项可删除配置变量从而使用默认值。

-### 1. **基础设置**
+### 1. **环境变量**

- **❗NGINX_PORT：** WEB服务端口，默认`3000`，可自行修改，不能与API服务端口冲突（仅支持环境变量配置）
- **❗PORT：** API服务端口，默认`3001`，可自行修改，不能与WEB服务端口冲突（仅支持环境变量配置）
- **PUID**：运行程序用户的`uid`，默认`0`（仅支持环境变量配置）
- **PGID**：运行程序用户的`gid`，默认`0`（仅支持环境变量配置）
- **UMASK**：掩码权限，默认`000`，可以考虑设置为`022`（仅支持环境变量配置）
- **PROXY_HOST：** 网络代理，访问themoviedb或者重启更新需要使用代理访问，格式为`http(s)://ip:port`、`socks5://user:pass@host:port`（仅支持环境变量配置）
- **MOVIEPILOT_AUTO_UPDATE**：重启更新，`true`/`release`/`dev`/`false`，默认`release` **注意：如果出现网络问题可以配置`PROXY_HOST`**（仅支持环境变量配置）
---
- **❗SUPERUSER：** 超级管理员用户名，默认`admin`，安装后使用该用户登录后台管理界面
- **❗SUPERUSER_PASSWORD：** 超级管理员初始密码，默认`password`，建议修改为复杂密码
+- **❗NGINX_PORT：** WEB服务端口，默认`3000`，可自行修改，不能与API服务端口冲突
+- **❗PORT：** API服务端口，默认`3001`，可自行修改，不能与WEB服务端口冲突
+- **PUID**：运行程序用户的`uid`，默认`0`
+- **PGID**：运行程序用户的`gid`，默认`0`
+- **UMASK**：掩码权限，默认`000`，可以考虑设置为`022`
+- **PROXY_HOST：** 网络代理，访问themoviedb或者重启更新需要使用代理访问，格式为`http(s)://ip:port`、`socks5://user:pass@host:port`
+- **MOVIEPILOT_AUTO_UPDATE：** 重启时自动更新，`true`/`release`/`dev`/`false`，默认`release`，需要能正常连接Github **注意：如果出现网络问题可以配置`PROXY_HOST`**
+- **AUTO_UPDATE_RESOURCE**：启动时自动检测和更新资源包（站点索引及认证等），`true`/`false`，默认`true`，需要能正常连接Github，仅支持Docker
+- **❗AUTH_SITE：** 认证站点（认证通过后才能使用站点相关功能），支持配置多个认证站点，使用`,`分隔，如：`iyuu,hhclub`，会依次执行认证操作，直到有一个站点认证成功。  
+
+  配置`AUTH_SITE`后，需要根据下表配置对应站点的认证参数，认证资源`v1.0.2`支持`iyuu`/`hhclub`/`audiences`/`hddolby`/`zmpt`/`freefarm`/`hdfans`/`wintersakura`/`leaves`/`1ptba`/`icc2022`/`ptlsp`/`xingtan`/`ptvicomo`/`agsvpt`
+  
+  |      站点      |                          参数                           |
+  |:------------:|:-----------------------------------------------------:|
+  |     iyuu     |                 `IYUU_SIGN`：IYUU登录令牌                  |
+  |    hhclub    |     `HHCLUB_USERNAME`：用户名<br/>`HHCLUB_PASSKEY`：密钥     |
+  |  audiences   |    `AUDIENCES_UID`：用户ID<br/>`AUDIENCES_PASSKEY`：密钥    |
+  |   hddolby    |      `HDDOLBY_ID`：用户ID<br/>`HDDOLBY_PASSKEY`：密钥       |
+  |     zmpt     |         `ZMPT_UID`：用户ID<br/>`ZMPT_PASSKEY`：密钥         |
+  |   freefarm   |     `FREEFARM_UID`：用户ID<br/>`FREEFARM_PASSKEY`：密钥     |
+  |    hdfans    |       `HDFANS_UID`：用户ID<br/>`HDFANS_PASSKEY`：密钥       |
+  | wintersakura | `WINTERSAKURA_UID`：用户ID<br/>`WINTERSAKURA_PASSKEY`：密钥 |
+  |    leaves    |       `LEAVES_UID`：用户ID<br/>`LEAVES_PASSKEY`：密钥       |
+  |    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`：密钥      |
+  |   ptvicomo   |     `PTVICOMO_UID`：用户ID<br/>`PTVICOMO_PASSKEY`：密钥     |
+  |    agsvpt    |      `AGSVPT_UID`：用户ID<br/>`AGSVPT_PASSKEY`：密钥       |
+
+
+### 2. **app.env配置文件**
+
+下载 [app.env 模板](https://github.com/jxxghp/MoviePilot/raw/main/config/app.env)，修改后放配置文件目录下，app.env 的所有配置项也可以通过环境变量进行配置。
+
+- **❗SUPERUSER：** 超级管理员用户名，默认`admin`，安装后使用该用户登录后台管理界面，**注意：启动一次后再次修改该值不会生效，除非删除数据库文件！**
+- **❗SUPERUSER_PASSWORD：** 超级管理员初始密码，默认`password`，建议修改为复杂密码，**注意：启动一次后再次修改该值不会生效，除非删除数据库文件！**
 - **❗API_TOKEN：** API密钥，默认`moviepilot`，在媒体服务器Webhook、微信回调等地址配置中需要加上`?token=`该值，建议修改为复杂字符串
- **TMDB_API_DOMAIN：** TMDB API地址，默认`api.themoviedb.org`，也可配置为`api.tmdb.org`或其它中转代理服务地址，能连通即可
+- **BIG_MEMORY_MODE：** 大内存模式，默认为`false`，开启后会增加缓存数量，占用更多的内存，但响应速度会更快
+- **GITHUB_TOKEN：** Github token，提高自动更新、插件安装等请求Github Api的限流阈值，格式：ghp_****
+---
+- **TMDB_API_DOMAIN：** TMDB API地址，默认`api.themoviedb.org`，也可配置为`api.tmdb.org`、`tmdb.movie-pilot.org` 或其它中转代理服务地址，能连通即可
 - **TMDB_IMAGE_DOMAIN：** TMDB图片地址，默认`image.tmdb.org`，可配置为其它中转代理以加速TMDB图片显示，如：`static-mdb.v.geilijiasu.com`
 - **WALLPAPER：** 登录首页电影海报，`tmdb`/`bing`，默认`tmdb`
 - **RECOGNIZE_SOURCE：** 媒体信息识别来源，`themoviedb`/`douban`，默认`themoviedb`，使用`douban`时不支持二级分类
- **SCRAP_SOURCE：** 刮削元数据及图片使用的数据源，`themoviedb`/`douban`，默认`themoviedb`
 ---
 - **SCRAP_METADATA：** 刮削入库的媒体文件，`true`/`false`，默认`true`
+- **SCRAP_SOURCE：** 刮削元数据及图片使用的数据源，`themoviedb`/`douban`，默认`themoviedb`
 - **SCRAP_FOLLOW_TMDB：** 新增已入库媒体是否跟随TMDB信息变化，`true`/`false`，默认`true`，为`false`时即使TMDB信息变化了也会仍然按历史记录中已入库的信息进行刮削
 ---
- **❗TRANSFER_TYPE：** 整理转移方式，支持`link`/`copy`/`move`/`softlink`/`rclone_copy`/`rclone_move`  **注意：在`link`和`softlink`转移方式下，转移后的文件会继承源文件的权限掩码，不受`UMASK`影响；rclone需要自行映射rclone配置目录到容器中或在容器内完成rclone配置，节点名称必须为：`MP`**
- **❗OVERWRITE_MODE：** 转移覆盖模式，默认为`size`，支持`nerver`/`size`/`always`/`latest`，分别表示`不覆盖同名文件`/`同名文件根据文件大小覆盖（大覆盖小）`/`总是覆盖同名文件`/`仅保留最新版本，删除旧版本文件（包括非同名文件）`
 - **❗LIBRARY_PATH：** 媒体库目录，多个目录使用`,`分隔
 - **LIBRARY_MOVIE_NAME：** 电影媒体库目录名称（不是完整路径），默认`电影`
 - **LIBRARY_TV_NAME：** 电视剧媒体库目录称（不是完整路径），默认`电视剧`
 - **LIBRARY_ANIME_NAME：** 动漫媒体库目录称（不是完整路径），默认`电视剧/动漫`
 - **LIBRARY_CATEGORY：** 媒体库二级分类开关，`true`/`false`，默认`false`，开启后会根据配置 [category.yaml](https://github.com/jxxghp/MoviePilot/raw/main/config/category.yaml) 自动在媒体库目录下建立二级目录分类
+- **❗TRANSFER_TYPE：** 整理转移方式，支持`link`/`copy`/`move`/`softlink`/`rclone_copy`/`rclone_move`  **注意：在`link`和`softlink`转移方式下，转移后的文件会继承源文件的权限掩码，不受`UMASK`影响；rclone需要自行映射rclone配置目录到容器中或在容器内完成rclone配置，节点名称必须为：`MP`**
+- **OVERWRITE_MODE：** 转移覆盖模式，默认为`size`，支持`nerver`/`size`/`always`/`latest`，分别表示`不覆盖同名文件`/`同名文件根据文件大小覆盖（大覆盖小）`/`总是覆盖同名文件`/`仅保留最新版本，删除旧版本文件（包括非同名文件）`
 ---
 - **❗COOKIECLOUD_HOST：** CookieCloud服务器地址，格式：`http(s)://ip:port`，不配置默认使用内建服务器`https://movie-pilot.org/cookiecloud`
 - **❗COOKIECLOUD_KEY：** CookieCloud用户KEY
@@ -104,7 +133,6 @@ MoviePilot需要配套下载器和媒体服务器配合使用。
 - **AUTO_DOWNLOAD_USER：** 远程交互搜索时自动择优下载的用户ID（消息通知渠道的用户ID），多个用户使用,分割，未设置需要选择资源或者回复`0`
 ---
 - **OCR_HOST：** OCR识别服务器地址，格式：`http(s)://ip:port`，用于识别站点验证码实现自动登录获取Cookie等，不配置默认使用内建服务器`https://movie-pilot.org`，可使用 [这个镜像](https://hub.docker.com/r/jxxghp/moviepilot-ocr) 自行搭建。
- **PLUGIN_MARKET：** 插件市场仓库地址，多个地址使用`,`分隔，保留最后的/，默认为官方插件仓库：`https://raw.githubusercontent.com/jxxghp/MoviePilot-Plugins/main/`。
 ---
 - **❗MESSAGER：** 消息通知渠道，支持 `telegram`/`wechat`/`slack`/`synologychat`，开启多个渠道时使用`,`分隔。同时还需要配置对应渠道的环境变量，非对应渠道的变量可删除，推荐使用`telegram`

@@ -135,7 +163,6 @@ MoviePilot需要配套下载器和媒体服务器配合使用。

    - **SYNOLOGYCHAT_WEBHOOK：** 在Synology Chat中创建机器人，获取机器人`传入URL`
    - **SYNOLOGYCHAT_TOKEN：** SynologyChat机器人`令牌`
-
 ---
 - **❗DOWNLOAD_PATH：** 下载保存目录，**注意：需要将`moviepilot`及`下载器`的映射路径保持一致**，否则会导致下载文件无法转移
 - **DOWNLOAD_MOVIE_PATH：** 电影下载保存目录路径，不设置则下载到`DOWNLOAD_PATH`
@@ -143,8 +170,7 @@ MoviePilot需要配套下载器和媒体服务器配合使用。
 - **DOWNLOAD_ANIME_PATH：** 动漫下载保存目录路径，不设置则下载到`DOWNLOAD_PATH`
 - **DOWNLOAD_CATEGORY：** 下载二级分类开关，`true`/`false`，默认`false`，开启后会根据配置 [category.yaml](https://github.com/jxxghp/MoviePilot/raw/main/config/category.yaml) 自动在下载目录下建立二级目录分类
 - **DOWNLOAD_SUBTITLE：** 下载站点字幕，`true`/`false`，默认`true`
- **DOWNLOADER_MONITOR：** 下载器监控，`true`/`false`，默认为`true`，开启后下载完成时才会自动整理入库
- **TORRENT_TAG：** 下载器种子标签，默认为`MOVIEPILOT`，设置后只有MoviePilot添加的下载才会处理，留空所有下载器中的任务均会处理
+---
 - **❗DOWNLOADER：** 下载器，支持`qbittorrent`/`transmission`，QB版本号要求>= 4.3.9，TR版本号要求>= 3.0，同时还需要配置对应渠道的环境变量，非对应渠道的变量可删除，推荐使用`qbittorrent`

  - `qbittorrent`设置项：
@@ -161,7 +187,8 @@ MoviePilot需要配套下载器和媒体服务器配合使用。
    - **TR_HOST：** transmission地址，格式：`ip:port`，https需要添加`https://`前缀
    - **TR_USER：** transmission用户名
    - **TR_PASSWORD：** transmission密码
-
+- **DOWNLOADER_MONITOR：** 下载器监控，`true`/`false`，默认为`true`，开启后下载完成时才会自动整理入库
+- **TORRENT_TAG：** 下载器种子标签，默认为`MOVIEPILOT`，设置后只有MoviePilot添加的下载才会处理，留空所有下载器中的任务均会处理
 ---
 - **❗MEDIASERVER：** 媒体服务器，支持`emby`/`jellyfin`/`plex`，同时开启多个使用`,`分隔。还需要配置对应媒体服务器的环境变量，非对应媒体服务器的变量可删除，推荐使用`emby`

@@ -179,87 +206,55 @@ MoviePilot需要配套下载器和媒体服务器配合使用。

    - **PLEX_HOST：** Plex服务器地址，格式：`ip:port`，https需要添加`https://`前缀
    - **PLEX_TOKEN：** Plex网页Url中的`X-Plex-Token`，通过浏览器F12->网络从请求URL中获取
-
 - **MEDIASERVER_SYNC_INTERVAL:** 媒体服务器同步间隔（小时），默认`6`，留空则不同步
 - **MEDIASERVER_SYNC_BLACKLIST:** 媒体服务器同步黑名单，多个媒体库名称使用,分割
+---
+- **MOVIE_RENAME_FORMAT：** 电影重命名格式，基于jinjia2语法

+  `MOVIE_RENAME_FORMAT`支持的配置项：

-### 2. **用户认证**
+  > `title`： 标题  
+  > `original_name`： 原文件名  
+  > `original_title`： 原语种标题  
+  > `name`： 识别名称  
+  > `year`： 年份  
+  > `resourceType`：资源类型  
+  > `effect`：特效  
+  > `edition`： 版本（资源类型+特效）  
+  > `videoFormat`： 分辨率  
+  > `releaseGroup`： 制作组/字幕组  
+  > `customization`： 自定义占位符  
+  > `videoCodec`： 视频编码  
+  > `audioCodec`： 音频编码  
+  > `tmdbid`： TMDBID  
+  > `imdbid`： IMDBID  
+  > `part`：段/节  
+  > `fileExt`：文件扩展名
+  > `tmdbid`：TMDB ID
+  > `imdbid`：IMDB ID
+  > `customization`：自定义占位符
+  
+  `MOVIE_RENAME_FORMAT`默认配置格式：
+  
+  ```
+  {{title}}{% if year %} ({{year}}){% endif %}/{{title}}{% if year %} ({{year}}){% endif %}{% if part %}-{{part}}{% endif %}{% if videoFormat %} - {{videoFormat}}{% endif %}{{fileExt}}
+  ```

-`MoviePilot`需要认证后才能使用，配置`AUTH_SITE`后，需要根据下表配置对应站点的认证参数（**仅能通过环境变量配置**）
-
-`AUTH_SITE`支持配置多个认证站点，使用`,`分隔，如：`iyuu,hhclub`，会依次执行认证操作，直到有一个站点认证成功。
-
- **❗AUTH_SITE：** 认证站点，认证资源`v1.0.1`支持`iyuu`/`hhclub`/`audiences`/`hddolby`/`zmpt`/`freefarm`/`hdfans`/`wintersakura`/`leaves`/`1ptba`/`icc2022`/`ptlsp`/`xingtan`/`ptvicomo`
-
-|      站点      |                          参数                           |
-|:------------:|:-----------------------------------------------------:|
-|     iyuu     |                 `IYUU_SIGN`：IYUU登录令牌                  |
-|    hhclub    |     `HHCLUB_USERNAME`：用户名<br/>`HHCLUB_PASSKEY`：密钥     |
-|  audiences   |    `AUDIENCES_UID`：用户ID<br/>`AUDIENCES_PASSKEY`：密钥    |
-|   hddolby    |      `HDDOLBY_ID`：用户ID<br/>`HDDOLBY_PASSKEY`：密钥       |
-|     zmpt     |         `ZMPT_UID`：用户ID<br/>`ZMPT_PASSKEY`：密钥         |
-|   freefarm   |     `FREEFARM_UID`：用户ID<br/>`FREEFARM_PASSKEY`：密钥     |
-|    hdfans    |       `HDFANS_UID`：用户ID<br/>`HDFANS_PASSKEY`：密钥       |
-| wintersakura | `WINTERSAKURA_UID`：用户ID<br/>`WINTERSAKURA_PASSKEY`：密钥 |
-|    leaves    |       `LEAVES_UID`：用户ID<br/>`LEAVES_PASSKEY`：密钥       |
-|    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`：密钥      |
-|   ptvicomo   |     `PTVICOMO_UID`：用户ID<br/>`PTVICOMO_PASSKEY`：密钥     |
-
-
-### 2. **进阶配置**
-
- **BIG_MEMORY_MODE：** 大内存模式，默认为`false`，开启后会增加缓存数量，占用更多的内存，但响应速度会更快
-
- **MOVIE_RENAME_FORMAT：** 电影重命名格式
-
-`MOVIE_RENAME_FORMAT`支持的配置项：
-
-> `title`： 标题  
-> `original_name`： 原文件名  
-> `original_title`： 原语种标题  
-> `name`： 识别名称  
-> `year`： 年份  
-> `resourceType`：资源类型  
-> `effect`：特效  
-> `edition`： 版本（资源类型+特效）  
-> `videoFormat`： 分辨率  
-> `releaseGroup`： 制作组/字幕组  
-> `customization`： 自定义占位符  
-> `videoCodec`： 视频编码  
-> `audioCodec`： 音频编码  
-> `tmdbid`： TMDBID  
-> `imdbid`： IMDBID  
-> `part`：段/节  
-> `fileExt`：文件扩展名
-> `tmdbid`：TMDB ID
-> `imdbid`：IMDB ID
-> `customization`：自定义占位符
-
-`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：** 电视剧重命名格式
-
-`TV_RENAME_FORMAT`额外支持的配置项：
-
-> `season`： 季号  
-> `episode`： 集号  
-> `season_episode`： 季集 SxxExx  
-> `episode_title`： 集标题
-
-`TV_RENAME_FORMAT`默认配置格式：
-
-```
-{{title}}{% if year %} ({{year}}){% endif %}/Season {{season}}/{{title}} - {{season_episode}}{% if part %}-{{part}}{% endif %}{% if episode %} - 第 {{episode}} 集{% endif %}{{fileExt}}
-```
+- **TV_RENAME_FORMAT：** 电视剧重命名格式，基于jinjia2语法

+  `TV_RENAME_FORMAT`额外支持的配置项：
+  
+  > `season`： 季号  
+  > `episode`： 集号  
+  > `season_episode`： 季集 SxxExx  
+  > `episode_title`： 集标题
+  
+  `TV_RENAME_FORMAT`默认配置格式：
+  
+  ```
+  {{title}}{% if year %} ({{year}}){% endif %}/Season {{season}}/{{title}} - {{season_episode}}{% if part %}-{{part}}{% endif %}{% if episode %} - 第 {{episode}} 集{% endif %}{{fileExt}}
+  ```
+  

 ### 3. **优先级规则**

@@ -267,6 +262,10 @@ MoviePilot需要配套下载器和媒体服务器配合使用。
 - 符合任一层级规则的资源将被标识选中，匹配成功的层级做为该资源的优先级，排越前面优先级超高
 - 不符合过滤规则所有层级规则的资源将不会被选中

+### 4. **插件扩展**
+
+- **PLUGIN_MARKET：** 插件市场仓库地址，仅支持Github仓库`main`分支，多个地址使用`,`分隔，默认为官方插件仓库：`https://github.com/jxxghp/MoviePilot-Plugins` ，通过查看[MoviePilot-Plugins](https://github.com/jxxghp/MoviePilot-Plugins)项目的fork，或者查看频道置顶了解更多第三方插件仓库。
+

 ## 使用

--- a/app/api/endpoints/douban.py
+++ b/app/api/endpoints/douban.py
@@ -149,6 +149,47 @@ def tv_hot(page: int = 1,
    return [MediaInfo(douban_info=tv).to_dict() for tv in tvs]


+@router.get("/credits/{doubanid}/{type_name}", summary="豆瓣演员阵容", response_model=List[schemas.DoubanPerson])
+def douban_credits(doubanid: str,
+                   type_name: str,
+                   page: int = 1,
+                   _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    根据TMDBID查询演员阵容，type_name: 电影/电视剧
+    """
+    mediatype = MediaType(type_name)
+    if mediatype == MediaType.MOVIE:
+        doubaninfos = DoubanChain().movie_credits(doubanid=doubanid, page=page)
+    elif mediatype == MediaType.TV:
+        doubaninfos = DoubanChain().tv_credits(doubanid=doubanid, page=page)
+    else:
+        return []
+    if not doubaninfos:
+        return []
+    else:
+        return [schemas.DoubanPerson(**doubaninfo) for doubaninfo in doubaninfos]
+
+
+@router.get("/recommend/{doubanid}/{type_name}", summary="豆瓣推荐电影/电视剧", response_model=List[schemas.MediaInfo])
+def douban_recommend(doubanid: str,
+                     type_name: str,
+                     _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    根据豆瓣ID查询推荐电影/电视剧，type_name: 电影/电视剧
+    """
+    mediatype = MediaType(type_name)
+    if mediatype == MediaType.MOVIE:
+        doubaninfos = DoubanChain().movie_recommend(doubanid=doubanid)
+    elif mediatype == MediaType.TV:
+        doubaninfos = DoubanChain().tv_recommend(doubanid=doubanid)
+    else:
+        return []
+    if not doubaninfos:
+        return []
+    else:
+        return [MediaInfo(douban_info=doubaninfo).to_dict() for doubaninfo in doubaninfos]
+
+
@router.get("/{doubanid}", summary="查询豆瓣详情", response_model=schemas.MediaInfo)
 def douban_info(doubanid: str,
                _: schemas.TokenPayload = Depends(verify_token)) -> Any:
--- a/app/api/endpoints/download.py
+++ b/app/api/endpoints/download.py
@@ -104,7 +104,7 @@ def stop_downloading(
        hashString: str,
        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
    """
-    控制下载任务
+    暂停下载任务
    """
    ret = DownloadChain().set_downloading(hashString, "stop")
    return schemas.Response(success=True if ret else False)
@@ -115,7 +115,7 @@ def remove_downloading(
        hashString: str,
        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
    """
-    控制下载任务
+    删除下载任务
    """
    ret = DownloadChain().remove_downloading(hashString)
    return schemas.Response(success=True if ret else False)
--- a/app/api/endpoints/media.py
+++ b/app/api/endpoints/media.py
@@ -131,5 +131,6 @@ def media_info(mediaid: str, type_name: str,
                return schemas.MediaInfo()
    mediainfo = MediaChain().recognize_media(tmdbid=tmdbid, doubanid=doubanid, mtype=mtype)
    if mediainfo:
+        MediaChain().obtain_images(mediainfo)
        return mediainfo.to_dict()
    return schemas.MediaInfo()
--- a/app/api/endpoints/plugin.py
+++ b/app/api/endpoints/plugin.py
@@ -62,7 +62,7 @@ def install_plugin(plugin_id: str,
        state, msg = PluginHelper().install(pid=plugin_id, repo_url=repo_url)
        if not state:
            # 安装失败
-            return schemas.Response(success=False, msg=msg)
+            return schemas.Response(success=False, message=msg)
    # 安装插件
    if plugin_id not in install_plugins:
        install_plugins.append(plugin_id)
@@ -89,11 +89,23 @@ def plugin_form(plugin_id: str,
@router.get("/page/{plugin_id}", summary="获取插件数据页面")
 def plugin_page(plugin_id: str, _: schemas.TokenPayload = Depends(verify_token)) -> List[dict]:
    """
-    根据插件ID获取插件配置信息
+    根据插件ID获取插件数据页面
    """
    return PluginManager().get_plugin_page(plugin_id)


+@router.get("/reset/{plugin_id}", summary="重置插件配置", response_model=schemas.Response)
+def reset_plugin(plugin_id: str, _: schemas.TokenPayload = Depends(verify_token)) -> List[dict]:
+    """
+    根据插件ID重置插件配置
+    """
+    # 删除配置
+    PluginManager().delete_plugin_config(plugin_id)
+    # 重新生效插件
+    PluginManager().reload_plugin(plugin_id, {})
+    return schemas.Response(success=True)
+
+
@router.get("/{plugin_id}", summary="获取插件配置")
 def plugin_config(plugin_id: str, _: schemas.TokenPayload = Depends(verify_token)) -> dict:
    """
@@ -106,7 +118,7 @@ def plugin_config(plugin_id: str, _: schemas.TokenPayload = Depends(verify_token
 def set_plugin_config(plugin_id: str, conf: dict,
                      _: schemas.TokenPayload = Depends(verify_token)) -> Any:
    """
-    根据插件ID获取插件配置信息
+    更新插件配置
    """
    # 保存配置
    PluginManager().save_plugin_config(plugin_id, conf)
--- a/app/api/endpoints/subscribe.py
+++ b/app/api/endpoints/subscribe.py
@@ -122,11 +122,13 @@ def update_subscribe(
 def subscribe_mediaid(
        mediaid: str,
        season: int = None,
+        title: str = None,
        db: Session = Depends(get_db),
        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
    """
    根据TMDBID或豆瓣ID查询订阅 tmdb:/douban:
    """
+    result = None
    if mediaid.startswith("tmdb:"):
        tmdbid = mediaid[5:]
        if not tmdbid or not str(tmdbid).isdigit():
@@ -137,8 +139,13 @@ def subscribe_mediaid(
        if not doubanid:
            return Subscribe()
        result = Subscribe.get_by_doubanid(db, doubanid)
-    else:
-        result = None
+
+    if not result and title:
+        meta = MetaInfo(title)
+        if season:
+            meta.begin_season = season
+        result = Subscribe.get_by_title(db, title=meta.name, season=meta.begin_season)
+
    if result and result.sites:
        result.sites = json.loads(result.sites)

@@ -257,7 +264,7 @@ def delete_subscribe(
 async def seerr_subscribe(request: Request, background_tasks: BackgroundTasks,
                          authorization: str = Header(None)) -> Any:
    """
-    Jellyseerr/Overseerr订阅
+    Jellyseerr/Overseerr网络勾子通知订阅
    """
    if not authorization or authorization != settings.API_TOKEN:
        raise HTTPException(
--- a/app/api/endpoints/system.py
+++ b/app/api/endpoints/system.py
@@ -1,10 +1,10 @@
 import json
 import time
 from datetime import datetime
-from typing import Union
+from typing import Union, Any

 import tailer
-from fastapi import APIRouter, HTTPException, Depends
+from fastapi import APIRouter, HTTPException, Depends, Response
 from fastapi.responses import StreamingResponse

 from app import schemas
@@ -24,6 +24,19 @@ from version import APP_VERSION
 router = APIRouter()


+@router.get("/img/{imgurl:path}", summary="图片代理")
+def get_img(imgurl: str) -> Any:
+    """
+    通过图片代理（使用代理服务器）
+    """
+    if not imgurl:
+        return None
+    response = RequestUtils(ua=settings.USER_AGENT, proxies=settings.PROXY).get_res(url=imgurl)
+    if response:
+        return Response(content=response.content, media_type="image/jpeg")
+    return None
+
+
@router.get("/env", summary="查询系统环境变量", response_model=schemas.Response)
 def get_env_setting(_: schemas.TokenPayload = Depends(verify_token)):
    """
@@ -163,7 +176,8 @@ def latest_version(_: schemas.TokenPayload = Depends(verify_token)):
    """
    查询Github所有Release版本
    """
-    version_res = RequestUtils().get_res(f"https://api.github.com/repos/jxxghp/MoviePilot/releases")
+    version_res = RequestUtils(proxies=settings.PROXY, headers=settings.GITHUB_HEADERS).get_res(
+        f"https://api.github.com/repos/jxxghp/MoviePilot/releases")
    if version_res:
        ver_json = version_res.json()
        if ver_json:
--- a/app/chain/douban.py
+++ b/app/chain/douban.py
@@ -72,3 +72,33 @@ class DoubanChain(ChainBase, metaclass=Singleton):
        if settings.RECOGNIZE_SOURCE != "douban":
            return None
        return self.run_module("tv_hot", page=page, count=count)
+
+    def movie_credits(self, doubanid: str, page: int = 1) -> List[dict]:
+        """
+        根据TMDBID查询电影演职人员
+        :param doubanid:  豆瓣ID
+        :param page:  页码
+        """
+        return self.run_module("douban_movie_credits", doubanid=doubanid, page=page)
+
+    def tv_credits(self, doubanid: str, page: int = 1) -> List[dict]:
+        """
+        根据TMDBID查询电视剧演职人员
+        :param doubanid:  豆瓣ID
+        :param page:  页码
+        """
+        return self.run_module("douban_tv_credits", doubanid=doubanid, page=page)
+
+    def movie_recommend(self, doubanid: str) -> List[dict]:
+        """
+        根据豆瓣ID查询推荐电影
+        :param doubanid:  豆瓣ID
+        """
+        return self.run_module("douban_movie_recommend", doubanid=doubanid)
+
+    def tv_recommend(self, doubanid: str) -> List[dict]:
+        """
+        根据豆瓣ID查询推荐电视剧
+        :param doubanid:  豆瓣ID
+        """
+        return self.run_module("douban_tv_recommend", doubanid=doubanid)
--- a/app/chain/download.py
+++ b/app/chain/download.py
@@ -192,7 +192,7 @@ class DownloadChain(ChainBase):
                                                                      channel=channel,
                                                                      userid=userid)
            if not content:
-                return
+                return None
        else:
            content = torrent_file
            # 获取种子文件的文件夹名和文件清单
@@ -283,6 +283,10 @@ class DownloadChain(ChainBase):
                    if not file_meta.begin_episode \
                            or file_meta.begin_episode not in episodes:
                        continue
+                # 只处理视频格式
+                if not Path(file).suffix \
+                        or Path(file).suffix not in settings.RMT_MEDIAEXT:
+                    continue
                files_to_add.append({
                    "download_hash": _hash,
                    "downloader": settings.DOWNLOADER,
--- a/app/chain/message.py
+++ b/app/chain/message.py
@@ -1,14 +1,22 @@
-from typing import Any
+import copy
+import json
+import re
+from typing import Any, Optional, Dict

-from app.chain.download import *
+from app.chain import ChainBase
+from app.chain.download import DownloadChain
 from app.chain.media import MediaChain
 from app.chain.search import SearchChain
 from app.chain.subscribe import SubscribeChain
-from app.core.context import MediaInfo
+from app.core.config import settings
+from app.core.context import MediaInfo, Context
 from app.core.event import EventManager
+from app.core.meta import MetaBase
+from app.helper.torrent import TorrentHelper
 from app.log import logger
 from app.schemas import Notification
-from app.schemas.types import EventType, MessageChannel
+from app.schemas.types import EventType, MessageChannel, MediaType
+from app.utils.string import StringUtils

 # 当前页面
 _current_page: int = 0
@@ -33,7 +41,6 @@ class MessageChain(ChainBase):
        self.subscribechain = SubscribeChain()
        self.searchchain = SearchChain()
        self.medtachain = MediaChain()
-        self.torrent = TorrentHelper()
        self.eventmanager = EventManager()
        self.torrenthelper = TorrentHelper()

@@ -353,6 +360,13 @@ class MessageChain(ChainBase):
        else:
            # 未完成下载
            logger.info(f'{_current_media.title_year} 未下载未完整，添加订阅 ...')
+            if downloads and _current_media.type == MediaType.TV:
+                # 获取已下载剧集
+                downloaded = [download.meta_info.begin_episode for download in downloads
+                              if download.meta_info.begin_episode]
+                note = json.dumps(downloaded)
+            else:
+                note = None
            # 添加订阅，状态为R
            self.subscribechain.add(title=_current_media.title,
                                    year=_current_media.year,
@@ -362,7 +376,8 @@ class MessageChain(ChainBase):
                                    channel=channel,
                                    userid=userid,
                                    username=username,
-                                    state="R")
+                                    state="R",
+                                    note=note)

    def __post_medias_message(self, channel: MessageChannel,
                              title: str, items: list, userid: str, total: int):
--- a/app/chain/search.py
+++ b/app/chain/search.py
@@ -213,7 +213,7 @@ class SearchChain(ChainBase):
                    continue
                # 在副标题中判断是否存在标题与原语种标题
                if torrent.description:
-                    subtitle = torrent.description.split()
+                    subtitle = re.split(r'[\s/|]+', torrent.description)
                    if (StringUtils.is_chinese(mediainfo.title)
                        and str(mediainfo.title) in subtitle) \
                            or (StringUtils.is_chinese(mediainfo.original_title)
--- a/app/chain/system.py
+++ b/app/chain/system.py
@@ -87,7 +87,7 @@ class SystemChain(ChainBase, metaclass=Singleton):
        """
        获取最新版本
        """
-        version_res = RequestUtils(proxies=settings.PROXY).get_res(
+        version_res = RequestUtils(proxies=settings.PROXY, headers=settings.GITHUB_HEADERS).get_res(
            "https://api.github.com/repos/jxxghp/MoviePilot/releases/latest")
        if version_res:
            ver_json = version_res.json()
--- a/app/chain/tmdb.py
+++ b/app/chain/tmdb.py
@@ -62,28 +62,28 @@ class TmdbChain(ChainBase, metaclass=Singleton):
        根据TMDBID查询类似电影
        :param tmdbid:  TMDBID
        """
-        return self.run_module("movie_similar", tmdbid=tmdbid)
+        return self.run_module("tmdb_movie_similar", tmdbid=tmdbid)

    def tv_similar(self, tmdbid: int) -> List[dict]:
        """
        根据TMDBID查询类似电视剧
        :param tmdbid:  TMDBID
        """
-        return self.run_module("tv_similar", tmdbid=tmdbid)
+        return self.run_module("tmdb_tv_similar", tmdbid=tmdbid)

    def movie_recommend(self, tmdbid: int) -> List[dict]:
        """
        根据TMDBID查询推荐电影
        :param tmdbid:  TMDBID
        """
-        return self.run_module("movie_recommend", tmdbid=tmdbid)
+        return self.run_module("tmdb_movie_recommend", tmdbid=tmdbid)

    def tv_recommend(self, tmdbid: int) -> List[dict]:
        """
        根据TMDBID查询推荐电视剧
        :param tmdbid:  TMDBID
        """
-        return self.run_module("tv_recommend", tmdbid=tmdbid)
+        return self.run_module("tmdb_tv_recommend", tmdbid=tmdbid)

    def movie_credits(self, tmdbid: int, page: int = 1) -> List[dict]:
        """
@@ -91,7 +91,7 @@ class TmdbChain(ChainBase, metaclass=Singleton):
        :param tmdbid:  TMDBID
        :param page:  页码
        """
-        return self.run_module("movie_credits", tmdbid=tmdbid, page=page)
+        return self.run_module("tmdb_movie_credits", tmdbid=tmdbid, page=page)

    def tv_credits(self, tmdbid: int, page: int = 1) -> List[dict]:
        """
@@ -99,14 +99,14 @@ class TmdbChain(ChainBase, metaclass=Singleton):
        :param tmdbid:  TMDBID
        :param page:  页码
        """
-        return self.run_module("tv_credits", tmdbid=tmdbid, page=page)
+        return self.run_module("tmdb_tv_credits", tmdbid=tmdbid, page=page)

    def person_detail(self, person_id: int) -> dict:
        """
        根据TMDBID查询演职员详情
        :param person_id:  人物ID
        """
-        return self.run_module("person_detail", person_id=person_id)
+        return self.run_module("tmdb_person_detail", person_id=person_id)

    def person_credits(self, person_id: int, page: int = 1) -> List[dict]:
        """
@@ -114,7 +114,7 @@ class TmdbChain(ChainBase, metaclass=Singleton):
        :param person_id:  人物ID
        :param page:  页码
        """
-        return self.run_module("person_credits", person_id=person_id, page=page)
+        return self.run_module("tmdb_person_credits", person_id=person_id, page=page)

    @cached(cache=TTLCache(maxsize=1, ttl=3600))
    def get_random_wallpager(self):
--- a/app/chain/torrents.py
+++ b/app/chain/torrents.py
@@ -12,6 +12,7 @@ from app.db.site_oper import SiteOper
 from app.db.systemconfig_oper import SystemConfigOper
 from app.helper.rss import RssHelper
 from app.helper.sites import SitesHelper
+from app.helper.torrent import TorrentHelper
 from app.log import logger
 from app.schemas import Notification
 from app.schemas.types import SystemConfigKey, MessageChannel, NotificationType
@@ -34,6 +35,7 @@ class TorrentsChain(ChainBase, metaclass=Singleton):
        self.rsshelper = RssHelper()
        self.systemconfig = SystemConfigOper()
        self.mediachain = MediaChain()
+        self.torrenthelper = TorrentHelper()

    def remote_refresh(self, channel: MessageChannel, userid: Union[str, int] = None):
        """
@@ -60,7 +62,16 @@ class TorrentsChain(ChainBase, metaclass=Singleton):
        else:
            return self.load_cache(self._rss_file) or {}

-    @cached(cache=TTLCache(maxsize=128, ttl=600))
+    def clear_torrents(self):
+        """
+        清理种子缓存数据
+        """
+        logger.info(f'开始清理种子缓存数据 ...')
+        self.remove_cache(self._spider_file)
+        self.remove_cache(self._rss_file)
+        logger.info(f'种子缓存数据清理完成')
+
+    @cached(cache=TTLCache(maxsize=128, ttl=595))
    def browse(self, domain: str) -> List[TorrentInfo]:
        """
        浏览站点首页内容，返回种子清单，TTL缓存10分钟
@@ -73,7 +84,7 @@ class TorrentsChain(ChainBase, metaclass=Singleton):
            return []
        return self.refresh_torrents(site=site)

-    @cached(cache=TTLCache(maxsize=128, ttl=300))
+    @cached(cache=TTLCache(maxsize=128, ttl=295))
    def rss(self, domain: str) -> List[TorrentInfo]:
        """
        获取站点RSS内容，返回种子清单，TTL缓存5分钟
@@ -134,6 +145,11 @@ class TorrentsChain(ChainBase, metaclass=Singleton):
        # 读取缓存
        torrents_cache = self.get_torrents()

+        # 缓存过滤掉无效种子
+        for _domain, _torrents in torrents_cache.items():
+            torrents_cache[_domain] = [_torrent for _torrent in _torrents
+                                       if not self.torrenthelper.is_invalid(_torrent.torrent_info.enclosure)]
+
        # 所有站点索引
        indexers = self.siteshelper.get_indexers()
        # 遍历站点缓存资源
--- a/app/core/config.py
+++ b/app/core/config.py
@@ -1,7 +1,7 @@
 import secrets
 import sys
 from pathlib import Path
-from typing import List
+from typing import List, Optional

 from pydantic import BaseSettings

@@ -156,7 +156,7 @@ class Settings(BaseSettings):
    # 媒体服务器 emby/jellyfin/plex，多个媒体服务器,分割
    MEDIASERVER: str = "emby"
    # 媒体服务器同步间隔（小时）
-    MEDIASERVER_SYNC_INTERVAL: int = 6
+    MEDIASERVER_SYNC_INTERVAL: Optional[int] = 6
    # 媒体服务器同步黑名单，多个媒体库名称,分割
    MEDIASERVER_SYNC_BLACKLIST: str = None
    # EMBY服务器地址，IP:PORT
@@ -180,7 +180,7 @@ class Settings(BaseSettings):
    # CookieCloud端对端加密密码
    COOKIECLOUD_PASSWORD: str = None
    # CookieCloud同步间隔（分钟）
-    COOKIECLOUD_INTERVAL: int = 60 * 24
+    COOKIECLOUD_INTERVAL: Optional[int] = 60 * 24
    # OCR服务器地址
    OCR_HOST: str = "https://movie-pilot.org"
    # CookieCloud对应的浏览器UA
@@ -211,7 +211,11 @@ class Settings(BaseSettings):
    # 大内存模式
    BIG_MEMORY_MODE: bool = False
    # 插件市场仓库地址，多个地址使用,分隔，地址以/结尾
-    PLUGIN_MARKET: str = "https://raw.githubusercontent.com/jxxghp/MoviePilot-Plugins/main/"
+    PLUGIN_MARKET: str = "https://github.com/jxxghp/MoviePilot-Plugins"
+    # Github token，提高请求api限流阈值 ghp_****
+    GITHUB_TOKEN: str = None
+    # 自动检查和更新站点资源包（站点索引、认证等）
+    AUTO_UPDATE_RESOURCE: bool = True

    @property
    def INNER_CONFIG_PATH(self):
@@ -321,6 +325,17 @@ class Settings(BaseSettings):
            return Path(self.DOWNLOAD_ANIME_PATH)
        return self.SAVE_TV_PATH

+    @property
+    def GITHUB_HEADERS(self):
+        """
+        Github请求头
+        """
+        if self.GITHUB_TOKEN:
+            return {
+                "Authorization": f"Bearer {self.GITHUB_TOKEN}"
+            }
+        return {}
+
    def __init__(self, **kwargs):
        super().__init__(**kwargs)
        with self.CONFIG_PATH as p:
--- a/app/core/context.py
+++ b/app/core/context.py
@@ -495,6 +495,18 @@ class MediaInfo:
            self.season_years = {
                season: self.year
            }
+        # 风格
+        if not self.genres:
+            self.genres = [{"id": genre, "name": genre} for genre in info.get("genres") or []]
+        # 时长
+        if not self.runtime and info.get("durations"):
+            # 查找数字
+            match = re.search(r'\d+', info.get("durations")[0])
+            if match:
+                self.runtime = int(match.group())
+        # 国家
+        if not self.production_countries:
+            self.production_countries = [{"id": country, "name": country} for country in info.get("countries") or []]
        # 剩余属性赋值
        for key, value in info.items():
            if not hasattr(self, key):
--- a/app/core/meta/metavideo.py
+++ b/app/core/meta/metavideo.py
@@ -34,6 +34,7 @@ class MetaVideo(MetaBase):
    _name_no_begin_re = r"^\[.+?]"
    _name_no_chinese_re = r".*版|.*字幕"
    _name_se_words = ['共', '第', '季', '集', '话', '話', '期']
+    _name_movie_words = ['剧场版', '劇場版', '电影版', '電影版']
    _name_nostring_re = r"^PTS|^JADE|^AOD|^CHC|^[A-Z]{1,4}TV[\-0-9UVHDK]*" \
                        r"|HBO$|\s+HBO|\d{1,2}th|\d{1,2}bit|NETFLIX|AMAZON|IMAX|^3D|\s+3D|^BBC\s+|\s+BBC|BBC$|DISNEY\+?|XXX|\s+DC$" \
                        r"|[第\s共]+[0-9一二三四五六七八九十\-\s]+季" \
@@ -182,8 +183,9 @@ class MetaVideo(MetaBase):
            if not self.cn_name:
                self.cn_name = token
            elif not self._stop_cnname_flag:
-                if not re.search("%s" % self._name_no_chinese_re, token, flags=re.IGNORECASE) \
-                        and not re.search("%s" % self._name_se_words, token, flags=re.IGNORECASE):
+                if re.search("%s" % self._name_movie_words, token, flags=re.IGNORECASE) \
+                        or (not re.search("%s" % self._name_no_chinese_re, token, flags=re.IGNORECASE)
+                            and not re.search("%s" % self._name_se_words, token, flags=re.IGNORECASE)):
                    self.cn_name = "%s %s" % (self.cn_name, token)
                self._stop_cnname_flag = True
        else:
--- a/app/core/plugin.py
+++ b/app/core/plugin.py
@@ -12,6 +12,7 @@ from app.schemas.types import SystemConfigKey
 from app.utils.object import ObjectUtils
 from app.utils.singleton import Singleton
 from app.utils.string import StringUtils
+from app.utils.system import SystemUtils


 class PluginManager(metaclass=Singleton):
@@ -105,6 +106,8 @@ class PluginManager(metaclass=Singleton):
        """
        安装本地不存在的在线插件
        """
+        if SystemUtils.is_frozen():
+            return
        logger.info("开始安装在线插件...")
        # 已安装插件
        install_plugins = self.systemconfig.get(SystemConfigKey.UserInstalledPlugins) or []
@@ -144,6 +147,14 @@ class PluginManager(metaclass=Singleton):
            return False
        return self.systemconfig.set(self._config_key % pid, conf)

+    def delete_plugin_config(self, pid: str) -> bool:
+        """
+        删除插件配置
+        """
+        if not self._plugins.get(pid):
+            return False
+        return self.systemconfig.delete(self._config_key % pid)
+
    def get_plugin_form(self, pid: str) -> Tuple[List[dict], Dict[str, Any]]:
        """
        获取插件表单
@@ -285,9 +296,6 @@ class PluginManager(metaclass=Singleton):
                # 图标
                if plugin.get("icon"):
                    conf.update({"plugin_icon": plugin.get("icon")})
-                # 主题色
-                if plugin.get("color"):
-                    conf.update({"plugin_color": plugin.get("color")})
                # 作者
                if plugin.get("author"):
                    conf.update({"plugin_author": plugin.get("author")})
@@ -355,9 +363,6 @@ class PluginManager(metaclass=Singleton):
            # 图标
            if hasattr(plugin, "plugin_icon"):
                conf.update({"plugin_icon": plugin.plugin_icon})
-            # 主题色
-            if hasattr(plugin, "plugin_color"):
-                conf.update({"plugin_color": plugin.plugin_color})
            # 作者
            if hasattr(plugin, "plugin_author"):
                conf.update({"plugin_author": plugin.plugin_author})
--- a/app/db/downloadhistory_oper.py
+++ b/app/db/downloadhistory_oper.py
@@ -57,7 +57,14 @@ class DownloadHistoryOper(DbOper):
        按fullpath查询下载文件记录
        :param fullpath: 数据key
        """
-        return DownloadFiles.get_by_fullpath(self._db, fullpath)
+        return DownloadFiles.get_by_fullpath(self._db, fullpath=fullpath, all_files=False)
+
+    def get_files_by_fullpath(self, fullpath: str) -> List[DownloadFiles]:
+        """
+        按fullpath查询下载文件记录
+        :param fullpath: 数据key
+        """
+        return DownloadFiles.get_by_fullpath(self._db, fullpath=fullpath, all_files=True)

    def get_files_by_savepath(self, fullpath: str) -> List[DownloadFiles]:
        """
@@ -78,7 +85,7 @@ class DownloadHistoryOper(DbOper):
        按fullpath查询下载文件记录hash
        :param fullpath: 数据key
        """
-        fileinfo: DownloadFiles = DownloadFiles.get_by_fullpath(self._db, fullpath)
+        fileinfo: DownloadFiles = DownloadFiles.get_by_fullpath(self._db, fullpath=fullpath, all_files=False)
        if fileinfo:
            return fileinfo.download_hash
        return ""
@@ -115,3 +122,13 @@ class DownloadHistoryOper(DbOper):
        return DownloadHistory.list_by_user_date(db=self._db,
                                                 date=date,
                                                 username=username)
+
+    def list_by_date(self, date: str, type: str, tmdbid: str, seasons: str = None) -> List[DownloadHistory]:
+        """
+        查询某时间之后的下载历史
+        """
+        return DownloadHistory.list_by_date(db=self._db,
+                                            date=date,
+                                            type=type,
+                                            tmdbid=tmdbid,
+                                            seasons=seasons)
--- a/app/db/models/downloadhistory.py
+++ b/app/db/models/downloadhistory.py
@@ -123,6 +123,24 @@ class DownloadHistory(Base):
                DownloadHistory.id.desc()).all()
        return list(result)

+    @staticmethod
+    @db_query
+    def list_by_date(db: Session, date: str, type: str, tmdbid: str, seasons: str = None):
+        """
+        查询某时间之后的下载历史
+        """
+        if seasons:
+            return db.query(DownloadHistory).filter(DownloadHistory.date > date,
+                                                    DownloadHistory.type == type,
+                                                    DownloadHistory.tmdbid == tmdbid,
+                                                    DownloadHistory.seasons == seasons).order_by(
+                DownloadHistory.id.desc()).all()
+        else:
+            return db.query(DownloadHistory).filter(DownloadHistory.date > date,
+                                                    DownloadHistory.type == type,
+                                                    DownloadHistory.tmdbid == tmdbid).order_by(
+                DownloadHistory.id.desc()).all()
+

 class DownloadFiles(Base):
    """
@@ -157,9 +175,13 @@ class DownloadFiles(Base):

    @staticmethod
    @db_query
-    def get_by_fullpath(db: Session, fullpath: str):
-        return db.query(DownloadFiles).filter(DownloadFiles.fullpath == fullpath).order_by(
-            DownloadFiles.id.desc()).first()
+    def get_by_fullpath(db: Session, fullpath: str, all_files: bool = False):
+        if not all_files:
+            return db.query(DownloadFiles).filter(DownloadFiles.fullpath == fullpath).order_by(
+                DownloadFiles.id.desc()).first()
+        else:
+            return db.query(DownloadFiles).filter(DownloadFiles.fullpath == fullpath).order_by(
+                DownloadFiles.id.desc()).all()

    @staticmethod
    @db_query
--- a/app/db/models/subscribe.py
+++ b/app/db/models/subscribe.py
@@ -97,7 +97,10 @@ class Subscribe(Base):

    @staticmethod
    @db_query
-    def get_by_title(db: Session, title: str):
+    def get_by_title(db: Session, title: str, season: int = None):
+        if season:
+            return db.query(Subscribe).filter(Subscribe.name == title,
+                                              Subscribe.season == season).first()
        return db.query(Subscribe).filter(Subscribe.name == title).first()

    @staticmethod
--- a/app/db/systemconfig_oper.py
+++ b/app/db/systemconfig_oper.py
@@ -56,6 +56,20 @@ class SystemConfigOper(DbOper, metaclass=Singleton):
            return self.__SYSTEMCONF
        return self.__SYSTEMCONF.get(key)

+    def delete(self, key: Union[str, SystemConfigKey]):
+        """
+        删除系统设置
+        """
+        if isinstance(key, SystemConfigKey):
+            key = key.value
+        # 更新内存
+        self.__SYSTEMCONF.pop(key, None)
+        # 写入数据库
+        conf = SystemConfig.get_by_key(self._db, key)
+        if conf:
+            conf.delete(self._db, conf.id)
+        return True
+
    def __del__(self):
        if self._db:
            self._db.close()
--- a/app/helper/plugin.py
+++ b/app/helper/plugin.py
@@ -16,6 +16,8 @@ class PluginHelper(metaclass=Singleton):
    插件市场管理，下载安装插件到本地
    """

+    _base_url = "https://raw.githubusercontent.com/%s/%s/main/"
+
    @cached(cache=TTLCache(maxsize=10, ttl=1800))
    def get_plugins(self, repo_url: str) -> Dict[str, dict]:
        """
@@ -24,32 +26,53 @@ class PluginHelper(metaclass=Singleton):
        """
        if not repo_url:
            return {}
-        res = RequestUtils(proxies=settings.PROXY, timeout=10).get_res(f"{repo_url}package.json")
+        user, repo = self.get_repo_info(repo_url)
+        if not user or not repo:
+            return {}
+        raw_url = self._base_url % (user, repo)
+        res = RequestUtils(proxies=settings.PROXY, headers=settings.GITHUB_HEADERS,
+                           timeout=10).get_res(f"{raw_url}package.json")
        if res:
            return json.loads(res.text)
        return {}

    @staticmethod
-    def install(pid: str, repo_url: str) -> Tuple[bool, str]:
+    def get_repo_info(repo_url: str) -> Tuple[Optional[str], Optional[str]]:
        """
-        安装插件
+        获取Github仓库信息
+        :param repo_url: Github仓库地址
        """
-        # 从Github的repo_url获取用户和项目名
+        if not repo_url:
+            return None, None
+        if not repo_url.endswith("/"):
+            repo_url += "/"
+        if repo_url.count("/") < 6:
+            repo_url = f"{repo_url}main/"
        try:
            user, repo = repo_url.split("/")[-4:-2]
        except Exception as e:
-            return False, f"不支持的插件仓库地址格式：{str(e)}"
-        if not user or not repo:
-            return False, "不支持的插件仓库地址格式"
+            print(str(e))
+            return None, None
+        return user, repo
+
+    def install(self, pid: str, repo_url: str) -> Tuple[bool, str]:
+        """
+        安装插件
+        """
        if SystemUtils.is_frozen():
            return False, "可执行文件模式下，只能安装本地插件"

+        # 从Github的repo_url获取用户和项目名
+        user, repo = self.get_repo_info(repo_url)
+        if not user or not repo:
+            return False, "不支持的插件仓库地址格式"
+
        def __get_filelist(_p: str) -> Tuple[Optional[list], Optional[str]]:
            """
            获取插件的文件列表
            """
            file_api = f"https://api.github.com/repos/{user}/{repo}/contents/plugins/{_p.lower()}"
-            r = RequestUtils(proxies=settings.PROXY).get_res(file_api)
+            r = RequestUtils(proxies=settings.PROXY, headers=settings.GITHUB_HEADERS, timeout=30).get_res(file_api)
            if not r or r.status_code != 200:
                return None, f"连接仓库失败：{r.status_code} - {r.reason}"
            ret = r.json()
@@ -66,7 +89,8 @@ class PluginHelper(metaclass=Singleton):
            for item in _l:
                if item.get("download_url"):
                    # 下载插件文件
-                    res = RequestUtils(proxies=settings.PROXY).get_res(item["download_url"])
+                    res = RequestUtils(proxies=settings.PROXY,
+                                       headers=settings.GITHUB_HEADERS, timeout=60).get_res(item["download_url"])
                    if not res:
                        return False, f"文件 {item.get('name')} 下载失败！"
                    elif res.status_code != 200:
--- a/app/helper/resource.py
+++ b/app/helper/resource.py
@@ -0,0 +1,103 @@
+import json
+from pathlib import Path
+
+from app.core.config import settings
+from app.helper.sites import SitesHelper
+from app.log import logger
+from app.utils.http import RequestUtils
+from app.utils.singleton import Singleton
+from app.utils.string import StringUtils
+from app.utils.system import SystemUtils
+
+
+class ResourceHelper(metaclass=Singleton):
+    """
+    检测和更新资源包
+    """
+    # 资源包的git仓库地址
+    _repo = "https://raw.githubusercontent.com/jxxghp/MoviePilot-Resources/main/package.json"
+    _files_api = f"https://api.github.com/repos/jxxghp/MoviePilot-Resources/contents/resources"
+    _base_dir: Path = settings.ROOT_PATH
+
+    def __init__(self):
+        self.siteshelper = SitesHelper()
+        self.check()
+
+    def check(self):
+        """
+        检测是否有更新，如有则下载安装
+        """
+        if not settings.AUTO_UPDATE_RESOURCE:
+            return
+        if SystemUtils.is_frozen():
+            return
+        logger.info("开始检测资源包版本...")
+        res = RequestUtils(proxies=settings.PROXY, headers=settings.GITHUB_HEADERS, timeout=10).get_res(self._repo)
+        if res:
+            resource_info = json.loads(res.text)
+        else:
+            logger.warn("无法连接资源包仓库！")
+            return
+        online_version = resource_info.get("version")
+        if online_version:
+            logger.info(f"最新资源包版本：v{online_version}")
+        # 需要更新的资源包
+        need_updates = {}
+        # 资源明细
+        resources: dict = resource_info.get("resources") or {}
+        for rname, resource in resources.items():
+            rtype = resource.get("type")
+            platform = resource.get("platform")
+            target = resource.get("target")
+            version = resource.get("version")
+            # 判断平台
+            if platform and platform != SystemUtils.platform:
+                continue
+            # 判断本地是否存在
+            local_path = self._base_dir / target / rname
+            if not local_path.exists():
+                continue
+            # 判断版本号
+            if rtype == "auth":
+                # 站点认证资源
+                local_version = self.siteshelper.auth_version
+            elif rtype == "sites":
+                # 站点索引资源
+                local_version = self.siteshelper.indexer_version
+            else:
+                continue
+            if StringUtils.compare_version(version, local_version) > 0:
+                logger.info(f"{rname} 资源包有更新，最新版本：v{version}")
+            else:
+                continue
+            # 需要安装
+            need_updates[rname] = target
+        if need_updates:
+            # 下载文件信息列表
+            r = RequestUtils(proxies=settings.PROXY, headers=settings.GITHUB_HEADERS,
+                             timeout=30).get_res(self._files_api)
+            if not r or r.status_code != 200:
+                return None, f"连接仓库失败：{r.status_code} - {r.reason}"
+            files_info = r.json()
+            for item in files_info:
+                save_path = need_updates.get(item.get("name"))
+                if not save_path:
+                    continue
+                if item.get("download_url"):
+                    # 下载资源文件
+                    res = RequestUtils(proxies=settings.PROXY, headers=settings.GITHUB_HEADERS,
+                                       timeout=180).get_res(item["download_url"])
+                    if not res:
+                        logger.error(f"文件 {item.get('name')} 下载失败！")
+                    elif res.status_code != 200:
+                        logger.error(f"下载文件 {item.get('name')} 失败：{res.status_code} - {res.reason}")
+                    # 创建插件文件夹
+                    file_path = self._base_dir / save_path / item.get("name")
+                    if not file_path.parent.exists():
+                        file_path.parent.mkdir(parents=True, exist_ok=True)
+                    # 写入文件
+                    file_path.write_bytes(res.content)
+            logger.info("资源包更新完成，开始重启服务...")
+            SystemUtils.restart()
+        else:
+            logger.info("所有资源已最新，无需更新")
--- a/app/helper/rss.py
+++ b/app/helper/rss.py
@@ -1,11 +1,14 @@
+import re
 import xml.dom.minidom
 from typing import List, Tuple, Union
 from urllib.parse import urljoin

+import chardet
 from lxml import etree

 from app.core.config import settings
 from app.helper.browser import PlaywrightHelper
+from app.log import logger
 from app.utils.dom import DomUtils
 from app.utils.http import RequestUtils
 from app.utils.string import StringUtils
@@ -240,8 +243,28 @@ class RssHelper:
            print(str(err))
            return []
        if ret:
-            ret_xml = ret.text
+            ret_xml = ""
            try:
+                # 使用chardet检测字符编码
+                raw_data = ret.content
+                if raw_data:
+                    try:
+                        result = chardet.detect(raw_data)
+                        encoding = result['encoding']
+                        # 解码为字符串
+                        ret_xml = raw_data.decode(encoding)
+                    except Exception as e:
+                        logger.debug(f"chardet解码失败：{str(e)}")
+                        # 探测utf-8解码
+                        match = re.search(r'encoding\s*=\s*["\']([^"\']+)["\']', ret.text)
+                        if match:
+                            encoding = match.group(1)
+                            if encoding:
+                                ret_xml = raw_data.decode(encoding)
+                        else:
+                            ret.encoding = ret.apparent_encoding
+                if not ret_xml:
+                    ret_xml = ret.text
                # 解析XML
                dom_tree = xml.dom.minidom.parseString(ret_xml)
                rootNode = dom_tree.documentElement
--- a/app/helper/torrent.py
+++ b/app/helper/torrent.py
@@ -14,13 +14,17 @@ from app.db.systemconfig_oper import SystemConfigOper
 from app.log import logger
 from app.utils.http import RequestUtils
 from app.schemas.types import MediaType, SystemConfigKey
+from app.utils.singleton import Singleton


-class TorrentHelper:
+class TorrentHelper(metaclass=Singleton):
    """
    种子帮助类
    """

+    # 失败的种子：站点链接
+    _invalid_torrents = []
+
    def __init__(self):
        self.system_config = SystemConfigOper()

@@ -123,6 +127,8 @@ class TorrentHelper:
        elif req.status_code == 429:
            return None, None, "", [], "触发站点流控，请稍后重试"
        else:
+            # 把错误的种子记下来，避免重复使用
+            self.add_invalid(url)
            return None, None, "", [], f"下载种子出错，状态码：{req.status_code}"

    @staticmethod
@@ -276,3 +282,16 @@ class TorrentHelper:
                continue
            episodes = list(set(episodes).union(set(meta.episode_list)))
        return episodes
+
+    def is_invalid(self, url: str) -> bool:
+        """
+        判断种子是否是无效种子
+        """
+        return url in self._invalid_torrents
+
+    def add_invalid(self, url: str):
+        """
+        添加无效种子
+        """
+        if url not in self._invalid_torrents:
+            self._invalid_torrents.append(url)
--- a/app/main.py
+++ b/app/main.py
@@ -22,10 +22,12 @@ from app.core.plugin import PluginManager
 from app.db.init import init_db, update_db
 from app.helper.thread import ThreadHelper
 from app.helper.display import DisplayHelper
+from app.helper.resource import ResourceHelper
 from app.helper.sites import SitesHelper
 from app.scheduler import Scheduler
 from app.command import Command

+
 # App
 App = FastAPI(title=settings.PROJECT_NAME,
              openapi_url=f"{settings.API_V1_STR}/openapi.json")
@@ -60,7 +62,9 @@ def start_frontend():
    """
    启动前端服务
    """
-    if not SystemUtils.is_frozen():
+    # 仅Windows可执行文件支持内嵌nginx
+    if not SystemUtils.is_frozen() \
+            or not SystemUtils.is_windows():
        return
    # 临时Nginx目录
    nginx_path = settings.ROOT_PATH / 'nginx'
@@ -73,27 +77,20 @@ def start_frontend():
        SystemUtils.move(nginx_path, run_nginx_dir)
    # 启动Nginx
    import subprocess
-    if SystemUtils.is_windows():
-        subprocess.Popen("start nginx.exe",
-                         cwd=run_nginx_dir,
-                         shell=True)
-    else:
-        subprocess.Popen("nohup ./nginx &",
-                         cwd=run_nginx_dir,
-                         shell=True)
+    subprocess.Popen("start nginx.exe",
+                     cwd=run_nginx_dir,
+                     shell=True)


 def stop_frontend():
    """
    停止前端服务
    """
-    if not SystemUtils.is_frozen():
+    if not SystemUtils.is_frozen() \
+            or not SystemUtils.is_windows():
        return
    import subprocess
-    if SystemUtils.is_windows():
-        subprocess.Popen(f"taskkill /f /im nginx.exe", shell=True)
-    else:
-        subprocess.Popen(f"killall nginx", shell=True)
+    subprocess.Popen(f"taskkill /f /im nginx.exe", shell=True)


 def start_tray():
@@ -104,6 +101,9 @@ def start_tray():
    if not SystemUtils.is_frozen():
        return

+    if not SystemUtils.is_windows():
+        return
+
    def open_web():
        """
        调用浏览器打开前端页面
@@ -169,6 +169,8 @@ def start_module():
    DisplayHelper()
    # 站点管理
    SitesHelper()
+    # 资源包检测
+    ResourceHelper()
    # 加载模块
    ModuleManager()
    # 加载插件
--- a/app/modules/douban/init.py
+++ b/app/modules/douban/init.py
@@ -561,7 +561,7 @@ class DoubanModule(_ModuleBase):
                continue
            if mtype and mtype.value != type_name:
                continue
-            if mtype == MediaType.TV and not season:
+            if mtype and mtype == MediaType.TV and not season:
                season = 1
            item = item_obj.get("target")
            title = item.get("title")
@@ -618,10 +618,17 @@ class DoubanModule(_ModuleBase):
            else:
                doubaninfo = self.douban_info(doubanid=mediainfo.douban_id,
                                              mtype=mediainfo.type)
+            if not doubaninfo:
+                logger(f"未获取到 {mediainfo.douban_id} 的豆瓣媒体信息，无法刮削！")
+                return
+            # 豆瓣媒体信息
+            mediainfo = MediaInfo(douban_info=doubaninfo)
+            # 补充图片
+            self.obtain_images(mediainfo)
            # 刮削路径
            scrape_path = path / path.name
            self.scraper.gen_scraper_files(meta=meta,
-                                           mediainfo=MediaInfo(douban_info=doubaninfo),
+                                           mediainfo=mediainfo,
                                           file_path=scrape_path,
                                           transfer_type=transfer_type)
        else:
@@ -649,18 +656,102 @@ class DoubanModule(_ModuleBase):
                    else:
                        doubaninfo = self.douban_info(doubanid=mediainfo.douban_id,
                                                      mtype=mediainfo.type)
+                    if not doubaninfo:
+                        logger(f"未获取到 {mediainfo.douban_id} 的豆瓣媒体信息，无法刮削！")
+                        continue
+                    # 豆瓣媒体信息
+                    mediainfo = MediaInfo(douban_info=doubaninfo)
+                    # 补充图片
+                    self.obtain_images(mediainfo)
                    # 刮削
                    self.scraper.gen_scraper_files(meta=meta,
-                                                   mediainfo=MediaInfo(douban_info=doubaninfo),
+                                                   mediainfo=mediainfo,
                                                   file_path=file,
                                                   transfer_type=transfer_type)
                except Exception as e:
                    logger.error(f"刮削文件 {file} 失败，原因：{str(e)}")
        logger.info(f"{path} 刮削完成")

+    def obtain_images(self, mediainfo: MediaInfo) -> Optional[MediaInfo]:
+        """
+        补充抓取媒体信息图片
+        :param mediainfo:  识别的媒体信息
+        :return: 更新后的媒体信息
+        """
+        if settings.RECOGNIZE_SOURCE != "douban":
+            return None
+        if not mediainfo.douban_id:
+            return None
+        if mediainfo.backdrop_path:
+            # 没有图片缺失
+            return mediainfo
+        # 调用图片接口
+        if not mediainfo.backdrop_path:
+            if mediainfo.type == MediaType.MOVIE:
+                info = self.doubanapi.movie_photos(mediainfo.douban_id)
+            else:
+                info = self.doubanapi.tv_photos(mediainfo.douban_id)
+            if not info:
+                return mediainfo
+            images = info.get("photos")
+            # 背景图
+            if images:
+                backdrop = images[0].get("image", {}).get("large") or {}
+                if backdrop:
+                    mediainfo.backdrop_path = backdrop.get("url")
+        return mediainfo
+
    def clear_cache(self):
        """
        清除缓存
        """
+        logger.info("开始清除豆瓣缓存 ...")
        self.doubanapi.clear_cache()
        self.cache.clear()
+        logger.info("豆瓣缓存清除完成")
+
+    def douban_movie_credits(self, doubanid: str, page: int = 1, count: int = 20) -> List[dict]:
+        """
+        根据TMDBID查询电影演职员表
+        :param doubanid:  豆瓣ID
+        :param page:  页码
+        :param count:  数量
+        """
+        result = self.doubanapi.movie_celebrities(subject_id=doubanid)
+        if not result:
+            return []
+        ret_list = result.get("actors") or []
+        if ret_list:
+            return ret_list[(page - 1) * count: page * count]
+        else:
+            return []
+
+    def douban_tv_credits(self, doubanid: str, page: int = 1, count: int = 20) -> List[dict]:
+        """
+        根据TMDBID查询电视剧演职员表
+        :param doubanid:  豆瓣ID
+        :param page:  页码
+        :param count:  数量
+        """
+        result = self.doubanapi.tv_celebrities(subject_id=doubanid)
+        if not result:
+            return []
+        ret_list = result.get("actors") or []
+        if ret_list:
+            return ret_list[(page - 1) * count: page * count]
+        else:
+            return []
+
+    def douban_movie_recommend(self, doubanid: str) -> List[dict]:
+        """
+        根据豆瓣ID查询推荐电影
+        :param doubanid:  豆瓣ID
+        """
+        return self.doubanapi.movie_recommendations(subject_id=doubanid) or []
+
+    def douban_tv_recommend(self, doubanid: str) -> List[dict]:
+        """
+        根据豆瓣ID查询推荐电视剧
+        :param doubanid:  豆瓣ID
+        """
+        return self.doubanapi.tv_recommendations(subject_id=doubanid) or []
--- a/app/modules/douban/apiv2.py
+++ b/app/modules/douban/apiv2.py
@@ -427,6 +427,54 @@ class DoubanApi(metaclass=Singleton):
        return self.__invoke(self._urls["doulist_items"] % subject_id,
                             start=start, count=count, _ts=ts)

+    def movie_recommendations(self, subject_id: str, start: int = 0, count: int = 20,
+                              ts=datetime.strftime(datetime.now(), '%Y%m%d')):
+        """
+        电影推荐
+        :param subject_id: 电影id
+        :param start: 开始
+        :param count: 数量
+        :param ts: 时间戳
+        """
+        return self.__invoke(self._urls["movie_recommendations"] % subject_id,
+                             start=start, count=count, _ts=ts)
+
+    def tv_recommendations(self, subject_id: str, start: int = 0, count: int = 20,
+                           ts=datetime.strftime(datetime.now(), '%Y%m%d')):
+        """
+        电视剧推荐
+        :param subject_id: 电视剧id
+        :param start: 开始
+        :param count: 数量
+        :param ts: 时间戳
+        """
+        return self.__invoke(self._urls["tv_recommendations"] % subject_id,
+                             start=start, count=count, _ts=ts)
+
+    def movie_photos(self, subject_id: str, start: int = 0, count: int = 20,
+                     ts=datetime.strftime(datetime.now(), '%Y%m%d')):
+        """
+        电影剧照
+        :param subject_id: 电影id
+        :param start: 开始
+        :param count: 数量
+        :param ts: 时间戳
+        """
+        return self.__invoke(self._urls["movie_photos"] % subject_id,
+                             start=start, count=count, _ts=ts)
+
+    def tv_photos(self, subject_id: str, start: int = 0, count: int = 20,
+                  ts=datetime.strftime(datetime.now(), '%Y%m%d')):
+        """
+        电视剧剧照
+        :param subject_id: 电视剧id
+        :param start: 开始
+        :param count: 数量
+        :param ts: 时间戳
+        """
+        return self.__invoke(self._urls["tv_photos"] % subject_id,
+                             start=start, count=count, _ts=ts)
+
    def clear_cache(self):
        """
        清空LRU缓存
--- a/app/modules/douban/scraper.py
+++ b/app/modules/douban/scraper.py
@@ -41,6 +41,10 @@ class DoubanScraper:
                # 生成电影图片
                self.__save_image(url=mediainfo.poster_path,
                                  file_path=file_path.with_name(f"poster{Path(mediainfo.poster_path).suffix}"))
+                # 背景图
+                if mediainfo.backdrop_path:
+                    self.__save_image(url=mediainfo.backdrop_path,
+                                      file_path=file_path.with_name(f"backdrop{Path(mediainfo.backdrop_path).suffix}"))
            # 电视剧
            else:
                # 不存在时才处理
@@ -51,6 +55,10 @@ class DoubanScraper:
                # 生成根目录图片
                self.__save_image(url=mediainfo.poster_path,
                                  file_path=file_path.with_name(f"poster{Path(mediainfo.poster_path).suffix}"))
+                # 背景图
+                if mediainfo.backdrop_path:
+                    self.__save_image(url=mediainfo.backdrop_path,
+                                      file_path=file_path.with_name(f"backdrop{Path(mediainfo.backdrop_path).suffix}"))
                # 季目录NFO
                if not file_path.with_name("season.nfo").exists():
                    self.__gen_tv_season_nfo_file(mediainfo=mediainfo,
--- a/app/modules/emby/emby.py
+++ b/app/modules/emby/emby.py
@@ -366,7 +366,7 @@ class Emby(metaclass=Singleton):
                        season_episodes[season_index] = []
                    season_episodes[season_index].append(episode_index)
                # 返回
-                return tv_item.get("Id"), season_episodes
+                return item_id, season_episodes
        except Exception as e:
            logger.error(f"连接Shows/Id/Episodes出错：" + str(e))
            return None, None
--- a/app/modules/filetransfer/init.py
+++ b/app/modules/filetransfer/init.py
@@ -416,14 +416,6 @@ class FileTransferModule(_ModuleBase):
                rename_dict=self.__get_naming_dict(meta=in_meta,
                                                   mediainfo=mediainfo)
            ).parent
-            # 目录已存在时不处理
-            if new_path.exists():
-                logger.warn(f"目标目录已存在：{new_path}")
-                return TransferInfo(success=False,
-                                    message=f"目标目录已存在：{new_path}",
-                                    path=in_path,
-                                    target_path=new_path,
-                                    is_bluray=bluray_flag)
            # 转移蓝光原盘
            retcode = self.__transfer_dir(file_path=in_path,
                                          new_path=new_path,
--- a/app/modules/jellyfin/jellyfin.py
+++ b/app/modules/jellyfin/jellyfin.py
@@ -332,7 +332,7 @@ class Jellyfin(metaclass=Singleton):
                    if not season_episodes.get(season_index):
                        season_episodes[season_index] = []
                    season_episodes[season_index].append(episode_index)
-                return tv_info.get('Id'), season_episodes
+                return item_id, season_episodes
        except Exception as e:
            logger.error(f"连接Shows/Id/Episodes出错：" + str(e))
            return None, None
--- a/app/modules/telegram/telegram.py
+++ b/app/modules/telegram/telegram.py
@@ -12,6 +12,7 @@ from app.core.config import settings
 from app.core.context import MediaInfo, Context
 from app.core.metainfo import MetaInfo
 from app.log import logger
+from app.utils.common import retry
 from app.utils.http import RequestUtils
 from app.utils.singleton import Singleton
 from app.utils.string import StringUtils
@@ -174,6 +175,7 @@ class Telegram(metaclass=Singleton):
            logger.error(f"发送消息失败：{msg_e}")
            return False

+    @retry(Exception, logger=logger)
    def __send_request(self, userid: str = None, image="", caption="") -> bool:
        """
        向Telegram发送报文
@@ -181,7 +183,9 @@ class Telegram(metaclass=Singleton):

        if image:
            req = RequestUtils(proxies=settings.PROXY).get_res(image)
-            if req and req.content:
+            if req is None:
+                raise Exception("获取图片失败")
+            if req.content:
                image_file = Path(settings.TEMP_PATH) / Path(image).name
                image_file.write_bytes(req.content)
                photo = InputFile(image_file)
@@ -189,12 +193,15 @@ class Telegram(metaclass=Singleton):
                                           photo=photo,
                                           caption=caption,
                                           parse_mode="Markdown")
+                if ret is None:
+                    raise Exception("发送图片消息失败")
                if ret:
                    return True
        ret = self._bot.send_message(chat_id=userid or self._telegram_chat_id,
                                     text=caption,
                                     parse_mode="Markdown")
-
+        if ret is None:
+            raise Exception("发送文本消息失败")
        return True if ret else False

    def register_commands(self, commands: Dict[str, dict]):
--- a/app/modules/themoviedb/init.py
+++ b/app/modules/themoviedb/init.py
@@ -312,6 +312,8 @@ class TheMovieDbModule(_ModuleBase):
        :param mediainfo:  识别的媒体信息
        :return: 更新后的媒体信息
        """
+        if settings.RECOGNIZE_SOURCE != "themoviedb":
+            return None
        if not mediainfo.tmdb_id:
            return mediainfo
        if mediainfo.logo_path \
@@ -382,35 +384,35 @@ class TheMovieDbModule(_ModuleBase):
            return f"https://{settings.TMDB_IMAGE_DOMAIN}/t/p/{image_prefix}{image_path}"
        return None

-    def movie_similar(self, tmdbid: int) -> List[dict]:
+    def tmdb_movie_similar(self, tmdbid: int) -> List[dict]:
        """
        根据TMDBID查询类似电影
        :param tmdbid:  TMDBID
        """
        return self.tmdb.get_movie_similar(tmdbid=tmdbid)

-    def tv_similar(self, tmdbid: int) -> List[dict]:
+    def tmdb_tv_similar(self, tmdbid: int) -> List[dict]:
        """
        根据TMDBID查询类似电视剧
        :param tmdbid:  TMDBID
        """
        return self.tmdb.get_tv_similar(tmdbid=tmdbid)

-    def movie_recommend(self, tmdbid: int) -> List[dict]:
+    def tmdb_movie_recommend(self, tmdbid: int) -> List[dict]:
        """
        根据TMDBID查询推荐电影
        :param tmdbid:  TMDBID
        """
        return self.tmdb.get_movie_recommend(tmdbid=tmdbid)

-    def tv_recommend(self, tmdbid: int) -> List[dict]:
+    def tmdb_tv_recommend(self, tmdbid: int) -> List[dict]:
        """
        根据TMDBID查询推荐电视剧
        :param tmdbid:  TMDBID
        """
        return self.tmdb.get_tv_recommend(tmdbid=tmdbid)

-    def movie_credits(self, tmdbid: int, page: int = 1) -> List[dict]:
+    def tmdb_movie_credits(self, tmdbid: int, page: int = 1) -> List[dict]:
        """
        根据TMDBID查询电影演职员表
        :param tmdbid:  TMDBID
@@ -418,7 +420,7 @@ class TheMovieDbModule(_ModuleBase):
        """
        return self.tmdb.get_movie_credits(tmdbid=tmdbid, page=page)

-    def tv_credits(self, tmdbid: int, page: int = 1) -> List[dict]:
+    def tmdb_tv_credits(self, tmdbid: int, page: int = 1) -> List[dict]:
        """
        根据TMDBID查询电视剧演职员表
        :param tmdbid:  TMDBID
@@ -426,14 +428,14 @@ class TheMovieDbModule(_ModuleBase):
        """
        return self.tmdb.get_tv_credits(tmdbid=tmdbid, page=page)

-    def person_detail(self, person_id: int) -> dict:
+    def tmdb_person_detail(self, person_id: int) -> dict:
        """
        根据TMDBID查询人物详情
        :param person_id:  人物ID
        """
        return self.tmdb.get_person_detail(person_id=person_id)

-    def person_credits(self, person_id: int, page: int = 1) -> List[dict]:
+    def tmdb_person_credits(self, person_id: int, page: int = 1) -> List[dict]:
        """
        根据TMDBID查询人物参演作品
        :param person_id:  人物ID
@@ -445,5 +447,7 @@ class TheMovieDbModule(_ModuleBase):
        """
        清除缓存
        """
+        logger.info("开始清除TMDB缓存 ...")
        self.tmdb.clear_cache()
        self.cache.clear()
+        logger.info("TMDB缓存清除完成")
--- a/app/scheduler.py
+++ b/app/scheduler.py
@@ -13,6 +13,7 @@ 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.torrents import TorrentsChain
 from app.chain.transfer import TransferChain
 from app.core.config import settings
 from app.log import logger
@@ -43,6 +44,14 @@ class Scheduler(metaclass=Singleton):
    _event = threading.Event()

    def __init__(self):
+
+        def clear_cache():
+            """
+            清理缓存
+            """
+            TorrentsChain().clear_cache()
+            SchedulerChain().clear_cache()
+
        # 各服务的运行状态
        self._jobs = {
            "cookiecloud": {
@@ -73,7 +82,7 @@ class Scheduler(metaclass=Singleton):
                "running": False,
            },
            "clear_cache": {
-                "func": SchedulerChain().clear_cache,
+                "func": clear_cache,
                "running": False,
            }
        }
--- a/app/schemas/plugin.py
+++ b/app/schemas/plugin.py
@@ -14,8 +14,6 @@ class Plugin(BaseModel):
    plugin_desc: Optional[str] = None
    # 插件图标
    plugin_icon: Optional[str] = None
-    # 主题色
-    plugin_color: Optional[str] = None
    # 插件版本
    plugin_version: Optional[str] = None
    # 插件作者
--- a/app/schemas/tmdb.py
+++ b/app/schemas/tmdb.py
@@ -49,3 +49,14 @@ class TmdbPerson(BaseModel):
    popularity: Optional[float] = None
    images: Optional[dict] = {}
    biography: Optional[str] = None
+
+
+class DoubanPerson(BaseModel):
+    id: Optional[str] = None
+    name: Optional[str] = None
+    roles: Optional[list] = []
+    title: Optional[str] = None
+    url: Optional[str] = None
+    character: Optional[str] = None
+    avatar: Optional[dict] = None
+    latin_name: Optional[str] = None
--- a/app/schemas/types.py
+++ b/app/schemas/types.py
@@ -16,16 +16,12 @@ class TorrentStatus(Enum):
 class EventType(Enum):
    # 插件重载
    PluginReload = "plugin.reload"
+    # 插件动作
+    PluginAction = "plugin.action"
    # 执行命令
    CommandExcute = "command.excute"
-    # 站点签到
-    SiteSignin = "site.signin"
-    # 站点数据统计
-    SiteStatistic = "site.statistic"
    # 站点删除
    SiteDeleted = "site.deleted"
-    # 豆瓣想看
-    DoubanSync = "douban.sync"
    # Webhook消息
    WebhookMessage = "webhook.message"
    # 转移完成
@@ -44,14 +40,6 @@ class EventType(Enum):
    NameRecognize = "name.recognize"
    # 名称识别结果
    NameRecognizeResult = "name.recognize.result"
-    # 目录监控同步
-    DirectorySync = "directory.sync"
-    # Cloudflare IP优选
-    CloudFlareSpeedTest = "cloudflare.speedtest"
-    # 站点自动登录更新Cookie、Ua
-    SiteLogin = "site.login"
-    # 网盘删除
-    NetworkDiskDel = "networkdisk.del"


 # 系统配置Key字典
--- a/app/utils/singleton.py
+++ b/app/utils/singleton.py
@@ -9,9 +9,10 @@ class Singleton(abc.ABCMeta, type):
    _instances: dict = {}

    def __call__(cls, *args, **kwargs):
-        if cls not in cls._instances:
-            cls._instances[cls] = super(Singleton, cls).__call__(*args, **kwargs)
-        return cls._instances[cls]
+        key = (cls, args, frozenset(kwargs.items()))
+        if key not in cls._instances:
+            cls._instances[key] = super().__call__(*args, **kwargs)
+        return cls._instances[key]


 class AbstractSingleton(abc.ABC, metaclass=Singleton):
--- a/config/app.env
+++ b/config/app.env
@@ -3,9 +3,9 @@
 #######################################################################

 ####################################
-#  基础设置                         #
+#  系统设置                         #
 ####################################
-# 【*】API监听地址
+# 【*】API监听地址（注意不是前端访问地址）
 HOST=0.0.0.0
 # 是否调试模式，打开后将输出更多日志
 DEBUG=false
@@ -15,6 +15,94 @@ DEV=false
 SUPERUSER=admin
 # 【*】超级管理员初始密码，设置后一但重启将固化到数据库中，修改将无效
 SUPERUSER_PASSWORD=password
+# 大内存模式，开启后会增加缓存数量，但会占用更多内存
+BIG_MEMORY_MODE=false
+# 自动检查和更新站点资源包（索引、认证等）
+AUTO_UPDATE_RESOURCE=true
+
+####################################
+#   消息通知渠道（按需配置）          #
+####################################
+# 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地址，IP:PORT
+QB_HOST=
+# Qbittorrent用户名
+QB_USER=
+# Qbittorrent密码
+QB_PASSWORD=
+# Qbittorrent分类自动管理
+QB_CATEGORY=false
+# Qbittorrent按顺序下载
+QB_SEQUENTIAL=true
+# Qbittorrent忽略队列限制，强制继续
+QB_FORCE_RESUME=true
+
+# Transmission地址，IP:PORT
+TR_HOST=
+# Transmission用户名
+TR_USER=
+# Transmission密码
+TR_PASSWORD=
+
+####################################
+#   媒体服务器（按需配置）            #
+####################################
+# 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=
+
+####################################
+#  基础设置                         #
+####################################
 # 【*】API密钥，建议更换复杂字符串，有Jellyseerr/Overseerr、媒体服务器Webhook等配置以及部分支持API_TOKEN的API中使用
 API_TOKEN=moviepilot
 # 登录页面电影海报，tmdb/bing，tmdb要求能正常连接api.themoviedb.org
@@ -25,8 +113,21 @@ TMDB_IMAGE_DOMAIN=image.tmdb.org
 TMDB_API_DOMAIN=api.themoviedb.org
 # 媒体识别来源 themoviedb/douban，使用themoviedb时需要确保能正常连接api.themoviedb.org，使用douban时不支持二级分类
 RECOGNIZE_SOURCE=themoviedb
-# 大内存模式，开启后会增加缓存数量，但会占用更多内存
-BIG_MEMORY_MODE=false
+
+# 【*】消息通知渠道 telegram/wechat/slack，多个通知渠道用,分隔，需要在上面配置对应消息通知渠道的参数
+MESSAGER=telegram
+
+# 【*】下载器 qbittorrent/transmission，仅支持单个下载器，做为主下载器使用，需要在上面配置对应消下载器的参数
+DOWNLOADER=qbittorrent
+# 下载器监控开关
+DOWNLOADER_MONITOR=true
+
+# 【*】媒体服务器 emby/jellyfin/plex，多个媒体服务器,分割
+MEDIASERVER=emby
+# 媒体服务器同步间隔（小时）
+MEDIASERVER_SYNC_INTERVAL=6
+# 媒体服务器同步黑名单，多个媒体库名称,分割
+MEDIASERVER_SYNC_BLACKLIST=

 ####################################
 #  媒体识别&刮削                     #
@@ -39,22 +140,24 @@ SCRAP_FOLLOW_TMDB=true
 SCRAP_SOURCE=themoviedb

 ####################################
-#   媒体库                          #
+#   文件整理 & 媒体库                #
 ####################################
 # 【*】转移方式 link/copy/move/softlink/rclone_copy/rclone_move
 TRANSFER_TYPE=copy
 # 转移覆盖模式，`nerver`/`size`/`always`/`latest`，分别表示`不覆盖同名文件`/`同名文件根据文件大小覆盖（大覆盖小）`/`总是覆盖同名文件`/`仅保留最新版本，删除旧版本文件（包括非同名文件）`
 OVERWRITE_MODE=size
+
 # 【*】媒体库目录，多个目录使用,分隔
-LIBRARY_PATH=
+LIBRARY_PATH=/media
 # 电影媒体库目录名，默认电影
-LIBRARY_MOVIE_NAME=
+LIBRARY_MOVIE_NAME=电影
 # 电视剧媒体库目录名，默认电视剧
-LIBRARY_TV_NAME=
+LIBRARY_TV_NAME=电视剧
 # 动漫媒体库目录名，默认电视剧/动漫
-LIBRARY_ANIME_NAME=
+LIBRARY_ANIME_NAME=电视剧/动漫
 # 二级分类，开启后会根据配置 [category.yaml](https://github.com/jxxghp/MoviePilot/raw/main/config/category.yaml) 自动在媒体库目录下建立二级目录分类
 LIBRARY_CATEGORY=true
+
 # 电影重命名格式，Jinja2语法，参考：https://jinja.palletsprojects.com/en/3.0.x/templates/
 MOVIE_RENAME_FORMAT={{title}}{% if year %} ({{year}}){% endif %}/{{title}}{% if year %} ({{year}}){% endif %}{% if part %}-{{part}}{% endif %}{% if videoFormat %} - {{videoFormat}}{% endif %}{{fileExt}}
 # 电视剧重命名格式，Jinja2语法，参考：https://jinja.palletsprojects.com/en/3.0.x/templates/
@@ -86,71 +189,9 @@ SUBSCRIBE_SEARCH=false
 # 交互搜索自动下载用户ID（消息通知渠道的用户ID），使用,分割，未设置需要用户手动选择资源或者回复`0`
 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
-# Qbittorrent按顺序下载
-QB_SEQUENTIAL=true
-# Qbittorrent忽略队列限制，强制继续
-QB_FORCE_RESUME=false
-# Transmission地址，IP:PORT
-TR_HOST=
-# Transmission用户名
-TR_USER=
-# Transmission密码
-TR_PASSWORD=
-# 种子标签
-TORRENT_TAG=MOVIEPILOT
 # 【*】下载保存目录，容器内映射路径需要一致，支持不同类型设置不同的下载目录（跨盘）
 DOWNLOAD_PATH=/downloads
 # 电影下载保存目录（路径），容器内映射路径需要一致
@@ -159,38 +200,19 @@ DOWNLOAD_MOVIE_PATH=
 DOWNLOAD_TV_PATH=
 # 动漫下载保存目录（路径），容器内映射路径需要一致
 DOWNLOAD_ANIME_PATH=
+
 # 下载目录二级分类，开启后会根据配置 [category.yaml](https://github.com/jxxghp/MoviePilot/raw/main/config/category.yaml) 自动在下载目录下建立二级目录分类
 DOWNLOAD_CATEGORY=false
-# 下载站点字幕
+# 种子标签
+TORRENT_TAG=MOVIEPILOT
+# 自动下载站点字幕（如有）
 DOWNLOAD_SUBTITLE=true

 ####################################
-#   媒体服务器                      #
-####################################
-# 【*】媒体服务器 emby/jellyfin/plex，多个媒体服务器,分割
-MEDIASERVER=emby
-# 媒体服务器同步间隔（小时）
-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=
-
-####################################
-#   第三方服务                      #
+#   扩展                           #
 ####################################
 # OCR服务器地址
 OCR_HOST=https://movie-pilot.org
 # 插件市场仓库地址，多个地址使用`,`分隔，保留最后的/
-PLUGIN_MARKET=https://raw.githubusercontent.com/jxxghp/MoviePilot-Plugins/main/
+PLUGIN_MARKET=https://github.com/jxxghp/MoviePilot-Plugins

--- a/windows.spec
+++ b/windows.spec
@@ -8,17 +8,22 @@ def collect_pkg_data(package: str, include_py_files: bool = False, subdir: str =
    from PyInstaller.utils.hooks import get_package_paths, PY_IGNORE_EXTENSIONS
    from PyInstaller.building.datastruct import TOC

+    data_toc = TOC()
+
    # Accept only strings as packages.
    if type(package) is not str:
        raise ValueError
-
-    pkg_base, pkg_dir = get_package_paths(package)
+    try:
+        pkg_base, pkg_dir = get_package_paths(package)
+    except ValueError:
+        return data_toc
    if subdir:
        pkg_path = Path(pkg_dir) / subdir
    else:
        pkg_path = Path(pkg_dir)
    # Walk through all file in the given package, looking for data files.
-    data_toc = TOC()
+    if not pkg_path.exists():
+        return data_toc
    for file in pkg_path.rglob('*'):
        if file.is_file():
            extension = file.suffix
@@ -37,6 +42,8 @@ def collect_local_submodules(package: str):
    package_dir = Path(package.replace('.', os.sep))
    submodules = [package]
    # Walk through all file in the given package, looking for data files.
+    if not package_dir.exists():
+        return []
    for file in package_dir.rglob('*.py'):
        if file.name == '__init__.py':
            module = f"{file.parent}".replace(os.sep, '.')
@@ -82,6 +89,7 @@ exe = EXE(
    collect_pkg_data('zhconv'),
    collect_pkg_data('cn2an'),
    collect_pkg_data('database', include_py_files=True),
+    collect_pkg_data('app.helper'),
    [],
    name='MoviePilot',
    debug=False,
--- a/11
+++ b/11
@@ -5,7 +5,7 @@ download_and_unzip() {
    url="$1"
    target_dir="$2"
    echo "正在下载 ${url}..."
-    curl ${CURL_OPTIONS} "$url" | busybox unzip -d /tmp -
+    curl ${CURL_OPTIONS} "$url" ${CURL_HEADERS} | busybox unzip -d /tmp -
    if [ $? -eq 0 ]; then
        if [ -e /tmp/MoviePilot-* ]; then
            mv /tmp/MoviePilot-* /tmp/${target_dir}
@@ -30,7 +30,7 @@ install_backend_and_download_resources() {
                download_and_unzip "https://github.com/jxxghp/MoviePilot-Resources/archive/refs/heads/main.zip" "Resources"
                if [ $? -eq 0 ]; then
                    echo "资源包下载成功"
-                    frontend_version=$(curl ${CURL_OPTIONS} "https://api.github.com/repos/jxxghp/MoviePilot-Frontend/releases/latest" | jq -r .tag_name)
+                    frontend_version=$(curl ${CURL_OPTIONS} "https://api.github.com/repos/jxxghp/MoviePilot-Frontend/releases/latest" ${CURL_HEADERS} | jq -r .tag_name)
                    if [[ "${frontend_version}" == *v* ]]; then
                        download_and_unzip "https://github.com/jxxghp/MoviePilot-Frontend/releases/download/${frontend_version}/dist.zip" "dist"
                        if [ $? -eq 0 ]; then
@@ -83,6 +83,11 @@ if [[ "${MOVIEPILOT_AUTO_UPDATE}" = "true" ]] || [[ "${MOVIEPILOT_AUTO_UPDATE}"
        CURL_OPTIONS="-sL"
        echo "不使用代理更新程序"
    fi
+    if [ -n "${GITHUB_TOKEN}" ]; then
+        CURL_HEADERS="--header 'Authorization: Bearer ${GITHUB_TOKEN}'"
+    else
+        CURL_HEADERS=""
+    fi
    if [ "${MOVIEPILOT_AUTO_UPDATE}" = "dev" ]; then
        echo "Dev 更新模式"
        install_backend_and_download_resources "heads/main.zip"
@@ -92,7 +97,7 @@ if [[ "${MOVIEPILOT_AUTO_UPDATE}" = "true" ]] || [[ "${MOVIEPILOT_AUTO_UPDATE}"
        if [[ "${old_version}" == *APP_VERSION* ]]; then
            current_version=v$(echo ${old_version} | sed -ne "s/APP_VERSION\s=\s'v\(.*\)'/\1/gp")
            echo "当前版本号：${current_version}"
-            new_version=$(curl ${CURL_OPTIONS} "https://api.github.com/repos/jxxghp/MoviePilot/releases/latest" | jq -r .tag_name)
+            new_version=$(curl ${CURL_OPTIONS} "https://api.github.com/repos/jxxghp/MoviePilot/releases/latest" ${CURL_HEADERS} | jq -r .tag_name)
            if [[ "${new_version}" == *v* ]]; then
                release_version=${new_version}
                echo "最新版本号：${release_version}"
--- a/version.py
+++ b/version.py
@@ -1 +1 @@
-APP_VERSION = 'v1.4.2'
+APP_VERSION = 'v1.4.7'
Author	SHA1	Message	Date
jxxghp	d049e04fa2	v1.4.7	2023-11-29 13:13:58 +08:00
jxxghp	ef45b08ee5	Merge pull request #1180 from honue/main	2023-11-29 13:01:18 +08:00
honue	d77644ab16	fix singleton.py	2023-11-29 12:46:49 +08:00
jxxghp	9e5d401a85	remove plugin_color	2023-11-29 12:07:54 +08:00
jxxghp	6da6dc2b8c	Merge pull request #1178 from cikezhu/main	2023-11-29 08:43:26 +08:00
叮叮当	2ca7021df0	fix item_id	2023-11-29 08:35:44 +08:00
jxxghp	1682cdad37	fix README.md	2023-11-28 14:55:05 +08:00
jxxghp	ec5e898feb	fix app.env	2023-11-27 08:36:45 +08:00
jxxghp	ccf6fb1b36	fix 插件重置	2023-11-27 08:30:13 +08:00
jxxghp	83c8d619d0	fix README.md	2023-11-27 08:17:23 +08:00
jxxghp	dd5b8219a1	更新 plugin.py	2023-11-27 07:09:38 +08:00
jxxghp	34fd927972	更新 README.md	2023-11-26 22:50:43 +08:00
jxxghp	6db5ad2697	feat：插件重置	2023-11-26 21:40:43 +08:00
jxxghp	0be1f27970	- 修复了种子失效时订阅一直偿试下载的问题 - 新增配置中心插件，可快速调整配置	2023-11-26 20:16:44 +08:00
jxxghp	54603798fc	fix bug	2023-11-24 15:26:54 +08:00
jxxghp	2f1e947323	fix #1144	2023-11-24 15:24:38 +08:00
jxxghp	ef2cfe1c1d	fix #1141 修复错误种子链接一直偿试下载的问题	2023-11-24 14:32:56 +08:00
jxxghp	f8edf79c59	fix api doc	2023-11-24 14:00:52 +08:00
jxxghp	dec80b6567	fix	2023-11-23 17:25:54 +08:00
jxxghp	4dac9237ef	fix README.md	2023-11-23 17:22:13 +08:00
jxxghp	12f5f373b3	fix frozen	2023-11-23 10:59:33 +08:00
jxxghp	76472770bf	v1.4.5	2023-11-22 15:35:12 +08:00
jxxghp	f5baf77c3c	Merge pull request #1155 from thsrite/main	2023-11-22 13:42:33 +08:00
thsrite	126276c727	fix #1154	2023-11-22 13:39:39 +08:00
jxxghp	5d6ba83fc5	Merge pull request #1153 from thsrite/main	2023-11-22 09:23:19 +08:00
thsrite	047c3b596d	add 插件方法	2023-11-22 09:21:51 +08:00
jxxghp	2240ff08a1	fix 插件事件依赖	2023-11-22 07:25:00 +08:00
jxxghp	4d6bf56fa0	fix bug	2023-11-21 21:44:50 +08:00
jxxghp	10ad9a5601	fix bug	2023-11-21 21:20:02 +08:00
jxxghp	fb39500428	feat 优化插件仓库URL格式	2023-11-21 21:10:34 +08:00
jxxghp	615a52cef9	更新 build.yml	2023-11-20 21:53:38 +08:00
jxxghp	791be0583a	fix build	2023-11-20 20:14:07 +08:00
jxxghp	a324731061	- 优化豆瓣详情展示	2023-11-20 20:06:25 +08:00
jxxghp	539d9cf537	- 优化豆瓣详情展示	2023-11-20 20:01:04 +08:00
jxxghp	699312ff28	- 优化豆瓣详情展示	2023-11-20 19:56:52 +08:00
jxxghp	b92b0ec149	fix build	2023-11-20 19:54:41 +08:00
jxxghp	51536062f1	fix	2023-11-20 16:43:49 +08:00
jxxghp	4c230b4c1e	feat 清理缓存时清理种子缓存	2023-11-20 10:56:28 +08:00
jxxghp	a7752ceb17	fix bug	2023-11-19 09:48:06 +08:00
jxxghp	ed59a90d78	fix update timeout	2023-11-19 09:45:13 +08:00
jxxghp	11d65e7527	fix douban scraper	2023-11-19 09:05:58 +08:00
jxxghp	b6ac5f0f84	feat 完善豆瓣详情API	2023-11-18 22:37:23 +08:00
jxxghp	c336e62885	Merge remote-tracking branch 'origin/main'	2023-11-18 21:54:10 +08:00
jxxghp	b868cdb25e	feat 完善豆瓣详情API	2023-11-18 21:53:58 +08:00
jxxghp	04339539d1	fix bug	2023-11-17 14:25:00 +08:00
jxxghp	2d146880ec	fix	2023-11-17 13:36:23 +08:00
jxxghp	6eec4ef7f4	fix build	2023-11-17 12:27:43 +08:00
jxxghp	9841f3dd18	fix build	2023-11-17 11:43:01 +08:00
jxxghp	03e0118fb7	add linux frozen build	2023-11-17 11:39:03 +08:00
jxxghp	c7c222b357	v1.4.3	2023-11-17 11:12:52 +08:00
jxxghp	2d8e45cd1b	feat TG消息重试	2023-11-17 10:41:14 +08:00
jxxghp	e2bd5cc245	更新 resource.py	2023-11-16 21:10:21 +08:00
jxxghp	47ddfec30e	feat 资源包自动更新	2023-11-16 20:57:41 +08:00
jxxghp	9344b2a324	add AGSVPT	2023-11-16 17:27:58 +08:00
jxxghp	8496fcccc5	Merge pull request #1133 from honue/main	2023-11-16 14:59:50 +08:00
honue	c6fa3b9d25	fix torrent_cache ttl	2023-11-16 13:34:23 +08:00
jxxghp	ce13987748	- 修复Windows打包	2023-11-15 08:20:57 +08:00
jxxghp	5221fc4f6a	fix #1125	2023-11-15 08:08:46 +08:00
jxxghp	d4dc388d3f	fix search	2023-11-14 17:54:41 +08:00
jxxghp	42966c2537	fix #1122	2023-11-14 17:35:31 +08:00
jxxghp	7921dcd86b	Merge pull request #1122 from thsrite/main	2023-11-14 17:30:52 +08:00
thsrite	4c69bb6c48	fix	2023-11-14 16:22:04 +08:00
thsrite	0aad809c82	feat 增加GITHUB_TOKEN，提高API限流阈值	2023-11-14 16:12:02 +08:00
thsrite	f514a5a416	fix `793a7460`	2023-11-14 14:17:14 +08:00
thsrite	793a7460c6	fix 动漫电影剧场版	2023-11-14 14:10:48 +08:00
jxxghp	6dcc979fd5	fix #1072 fix #1118	2023-11-14 08:19:57 +08:00
jxxghp	5a07732712	fix 豆瓣已订阅显示	2023-11-13 20:25:57 +08:00
jxxghp	61d71b32ff	fix 豆瓣已订阅显示	2023-11-13 20:22:51 +08:00