v2.4.0

增加两个站制作组的匹配规则

.github/workflows/bulit-lite.yml

@@ -0,0 +1,55 @@
+name: MoviePilot Builder v2 Lite
+on:
+  workflow_dispatch:
+  push:
+    branches:
+      - v2
+    paths:
+      - 'version.py'
+
+jobs:
+  Docker-build:
+    runs-on: ubuntu-latest
+    name: Build Docker Image
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Release version
+        id: release_version
+        run: |
+          app_version=$(cat version.py |sed -ne "s/APP_VERSION\s=\s'v\(.*\)'/\1/gp")
+          echo "app_version=$app_version" >> $GITHUB_ENV
+
+      - name: Docker Meta
+        id: meta
+        uses: docker/metadata-action@v5
+        with:
+          images: ${{ secrets.DOCKER_USERNAME }}/moviepilot-v2
+          tags: |
+            type=raw,value=lite-latest
+
+      - name: Set Up QEMU
+        uses: docker/setup-qemu-action@v3
+
+      - name: Set Up Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Login DockerHub
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.DOCKER_USERNAME }}
+          password: ${{ secrets.DOCKER_PASSWORD }}
+
+      - name: Build Image
+        uses: docker/build-push-action@v5
+        with:
+          context: .
+          file: Dockerfile.lite
+          platforms: |
+            linux/amd64
+          push: true
+          tags: ${{ steps.meta.outputs.tags }}
+          labels: ${{ steps.meta.outputs.labels }}
+          cache-from: type=gha, scope=${{ github.workflow }}-docker
+          cache-to: type=gha, scope=${{ github.workflow }}-docker

.gitignore

@@ -1,6 +1,9 @@
 .idea/
 *.c
+*.so
+*.pyd
 build/
+cython_cache/
 dist/
 nginx/
 test.py

Dockerfile

@@ -1,4 +1,4 @@
-FROM python:3.11.4-slim-bookworm
+FROM python:3.12.8-slim-bookworm
 ENV LANG="C.UTF-8" \
     TZ="Asia/Shanghai" \
     HOME="/moviepilot" \
@@ -38,7 +38,6 @@ RUN apt-get update -y \
         then ln -s /usr/lib/aarch64-linux-musl/libc.so /lib/libc.musl-aarch64.so.1; \
     fi \
     && curl https://rclone.org/install.sh | bash \
-    && curl --insecure -fsSL https://raw.githubusercontent.com/DDS-Derek/Aria2-Pro-Core/master/aria2-install.sh | bash \
     && apt-get autoremove -y \
     && apt-get clean -y \
     && rm -rf \

Dockerfile.lite

@@ -0,0 +1,92 @@
+FROM python:3.12.8-slim-bookworm
+ENV LANG="C.UTF-8" \
+    TZ="Asia/Shanghai" \
+    HOME="/moviepilot" \
+    CONFIG_DIR="/config" \
+    TERM="xterm" \
+    DISPLAY=:987 \
+    PUID=0 \
+    PGID=0 \
+    UMASK=000 \
+    PORT=3001 \
+    NGINX_PORT=3000 \
+    MOVIEPILOT_AUTO_UPDATE=release
+WORKDIR "/app"
+RUN apt-get update -y \
+    && apt-get upgrade -y \
+    && apt-get -y install \
+        musl-dev \
+        nginx \
+        gettext-base \
+        locales \
+        procps \
+        gosu \
+        bash \
+        wget \
+        curl \
+        busybox \
+        dumb-init \
+        jq \
+        fuse3 \
+        rsync \
+        ffmpeg \
+        nano \
+    && \
+    if [ "$(uname -m)" = "x86_64" ]; \
+        then ln -s /usr/lib/x86_64-linux-musl/libc.so /lib/libc.musl-x86_64.so.1; \
+    elif [ "$(uname -m)" = "aarch64" ]; \
+        then ln -s /usr/lib/aarch64-linux-musl/libc.so /lib/libc.musl-aarch64.so.1; \
+    fi \
+    && curl https://rclone.org/install.sh | bash \
+    && apt-get autoremove -y \
+    && apt-get clean -y \
+    && rm -rf \
+        /tmp/* \
+        /moviepilot/.cache \
+        /var/lib/apt/lists/* \
+        /var/tmp/*
+COPY requirements.in requirements.in
+RUN apt-get update -y \
+    && apt-get install -y build-essential \
+    && pip install --upgrade pip \
+    && pip install Cython pip-tools \
+    && pip-compile requirements.in \
+    && pip install -r requirements.txt \
+    && playwright install-deps chromium \
+    && apt-get remove -y build-essential \
+    && apt-get autoremove -y \
+    && apt-get clean -y \
+    && rm -rf \
+        /tmp/* \
+        /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 \
+    && cp -f /app/docker_http_proxy.conf /etc/nginx/docker_http_proxy.conf \
+    && chmod +x /entrypoint /usr/local/bin/mp_update \
+    && mkdir -p ${HOME} \
+    && groupadd -r moviepilot -g 918 \
+    && useradd -r moviepilot -g moviepilot -d ${HOME} -s /bin/bash -u 918 \
+    && 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 \
+    && python3 /app/setup.py \
+    && find /app/app -type f -name "*.py" ! -path "/app/app/main.py" -exec rm -f {} \; \
+    && FRONTEND_VERSION=$(sed -n "s/^FRONTEND_VERSION\s*=\s*'\([^']*\)'/\1/p" /app/version.py) \
+    && curl -sL "https://github.com/jxxghp/MoviePilot-Frontend/releases/download/${FRONTEND_VERSION}/dist.zip" | busybox unzip -d / - \
+    && mv /dist /public \
+    && curl -sL "https://github.com/jxxghp/MoviePilot-Plugins/archive/refs/heads/main.zip" | busybox unzip -d /tmp - \
+    && mv -f /tmp/MoviePilot-Plugins-main/plugins.v2/* /app/app/plugins/ \
+    && cat /tmp/MoviePilot-Plugins-main/package.json | jq -r 'to_entries[] | select(.value.v2 == true) | .key' | awk '{print tolower($0)}' | \
+        while read -r i; do if [ ! -d "/app/app/plugins/$i" ]; then mv "/tmp/MoviePilot-Plugins-main/plugins/$i" "/app/app/plugins/"; else echo "跳过 $i"; fi; done \
+    && curl -sL "https://github.com/jxxghp/MoviePilot-Resources/archive/refs/heads/main.zip" | busybox unzip -d /tmp - \
+    && mv -f /tmp/MoviePilot-Resources-main/resources/* /app/app/helper/ \
+    && rm -rf /tmp/* /app/build
+EXPOSE 3000
+VOLUME [ "/config" ]
+ENTRYPOINT [ "/entrypoint" ]

README.md

@@ -26,6 +26,34 @@
 
 访问官方Wiki：https://wiki.movie-pilot.org
 
+## 参与开发
+
+需要 `Python 3.12`、`Node JS v20.12.1`
+
+- 克隆主项目 [MoviePilot](https://github.com/jxxghp/MoviePilot) 
+```shell
+git clone https://github.com/jxxghp/MoviePilot
+```
+- 克隆资源项目 [MoviePilot-Resources](https://github.com/jxxghp/MoviePilot-Resources) ，将 `resources` 目录下对应平台及版本的库 `.so`/`.pyd`/`.bin` 文件复制到 `app/helper` 目录
+```shell
+git clone https://github.com/jxxghp/MoviePilot-Resources
+```
+- 安装后端依赖，设置`app`为源代码根目录，运行 `main.py` 启动后端服务，默认监听端口：`3001`，API文档地址：`http://localhost:3001/docs`
+```shell
+pip install -r requirements.txt
+python3 main.py
+```
+- 克隆前端项目 [MoviePilot-Frontend](https://github.com/jxxghp/MoviePilot-Frontend)
+```shell
+git clone https://github.com/jxxghp/MoviePilot-Frontend
+```
+- 安装前端依赖，运行前端项目，访问：`http://localhost:5173`
+```shell
+yarn
+yarn dev
+```
+- 参考 [插件开发指引](https://wiki.movie-pilot.org/zh/plugindev) 在 `app/plugins` 目录下开发插件代码
+
 ## 贡献者
 
 <a href="https://github.com/jxxghp/MoviePilot/graphs/contributors">

app/actions/__init__.py

@@ -0,0 +1,106 @@
+from abc import ABC, abstractmethod
+from typing import Union
+
+from app.chain import ChainBase
+from app.db.systemconfig_oper import SystemConfigOper
+from app.schemas import ActionContext, ActionParams
+
+
+class ActionChain(ChainBase):
+    pass
+
+
+class BaseAction(ABC):
+    """
+    工作流动作基类
+    """
+
+    # 动作ID
+    _action_id = None
+    # 完成标志
+    _done_flag = False
+    # 执行信息
+    _message = ""
+    # 缓存键值
+    _cache_key = "WorkflowCache-%s"
+
+    def __init__(self, action_id: str):
+        self._action_id = action_id
+        self.systemconfigoper = SystemConfigOper()
+
+    @classmethod
+    @property
+    @abstractmethod
+    def name(cls) -> str:  # noqa
+        pass
+
+    @classmethod
+    @property
+    @abstractmethod
+    def description(cls) -> str:  # noqa
+        pass
+
+    @classmethod
+    @property
+    @abstractmethod
+    def data(cls) -> dict:  # noqa
+        pass
+
+    @property
+    def done(self) -> bool:
+        """
+        判断动作是否完成
+        """
+        return self._done_flag
+
+    @property
+    @abstractmethod
+    def success(self) -> bool:
+        """
+        判断动作是否成功
+        """
+        pass
+
+    @property
+    def message(self) -> str:
+        """
+        执行信息
+        """
+        return self._message
+
+    def job_done(self, message: str = None):
+        """
+        标记动作完成
+        """
+        self._message = message
+        self._done_flag = True
+
+    def check_cache(self, workflow_id: int, key: str) -> bool:
+        """
+        检查是否处理过
+        """
+        workflow_key = self._cache_key % workflow_id
+        workflow_cache = self.systemconfigoper.get(workflow_key) or {}
+        action_cache = workflow_cache.get(self._action_id) or []
+        return key in action_cache
+
+    def save_cache(self, workflow_id: int, data: Union[list, str]):
+        """
+        保存缓存
+        """
+        workflow_key = self._cache_key % workflow_id
+        workflow_cache = self.systemconfigoper.get(workflow_key) or {}
+        action_cache = workflow_cache.get(self._action_id) or []
+        if isinstance(data, list):
+            action_cache.extend(data)
+        else:
+            action_cache.append(data)
+        workflow_cache[self._action_id] = action_cache
+        self.systemconfigoper.set(workflow_key, workflow_cache)
+
+    @abstractmethod
+    def execute(self, workflow_id: int, params: ActionParams, context: ActionContext) -> ActionContext:
+        """
+        执行动作
+        """
+        raise NotImplementedError

app/actions/add_download.py

@@ -0,0 +1,121 @@
+from typing import Optional
+
+from pydantic import Field
+
+from app.actions import BaseAction
+from app.chain.download import DownloadChain
+from app.chain.media import MediaChain
+from app.core.config import global_vars
+from app.core.metainfo import MetaInfo
+from app.log import logger
+from app.schemas import ActionParams, ActionContext, DownloadTask, MediaType
+
+
+class AddDownloadParams(ActionParams):
+    """
+    添加下载资源参数
+    """
+    downloader: Optional[str] = Field(default=None, description="下载器")
+    save_path: Optional[str] = Field(default=None, description="保存路径")
+    labels: Optional[str] = Field(default=None, description="标签（,分隔）")
+    only_lack: Optional[bool] = Field(default=False, description="仅下载缺失的资源")
+
+
+class AddDownloadAction(BaseAction):
+    """
+    添加下载资源
+    """
+
+    # 已添加的下载
+    _added_downloads = []
+    _has_error = False
+
+    def __init__(self, action_id: str):
+        super().__init__(action_id)
+        self.downloadchain = DownloadChain()
+        self.mediachain = MediaChain()
+        self._added_downloads = []
+        self._has_error = False
+
+    @classmethod
+    @property
+    def name(cls) -> str: # noqa
+        return "添加下载"
+
+    @classmethod
+    @property
+    def description(cls) -> str: # noqa
+        return "根据资源列表添加下载任务"
+
+    @classmethod
+    @property
+    def data(cls) -> dict: # noqa
+        return AddDownloadParams().dict()
+
+    @property
+    def success(self) -> bool:
+        return not self._has_error
+
+    def execute(self, workflow_id: int,  params: dict, context: ActionContext) -> ActionContext:
+        """
+        将上下文中的torrents添加到下载任务中
+        """
+        params = AddDownloadParams(**params)
+        _started = False
+        for t in context.torrents:
+            if global_vars.is_workflow_stopped(workflow_id):
+                break
+            # 检查缓存
+            cache_key = f"{t.torrent_info.site}-{t.torrent_info.title}"
+            if self.check_cache(workflow_id, cache_key):
+                logger.info(f"{t.torrent_info.title} 已添加过下载，跳过")
+                continue
+            if not t.meta_info:
+                t.meta_info = MetaInfo(title=t.torrent_info.title, subtitle=t.torrent_info.description)
+            if not t.media_info:
+                t.media_info = self.mediachain.recognize_media(meta=t.meta_info)
+            if not t.media_info:
+                self._has_error = True
+                logger.warning(f"{t.torrent_info.title} 未识别到媒体信息，无法下载")
+                continue
+            if params.only_lack:
+                exists_info = self.downloadchain.media_exists(t.media_info)
+                if exists_info:
+                    if t.media_info.type == MediaType.MOVIE:
+                        # 电影
+                        logger.warning(f"{t.torrent_info.title} 媒体库中已存在，跳过")
+                        continue
+                    else:
+                        # 电视剧
+                        exists_seasons = exists_info.seasons or {}
+                        if len(t.meta_info.season_list) > 1:
+                            # 多季不下载
+                            logger.warning(f"{t.meta_info.title} 有多季，跳过")
+                            continue
+                        else:
+                            exists_episodes = exists_seasons.get(t.meta_info.begin_season)
+                            if exists_episodes:
+                                if set(t.meta_info.episode_list).issubset(exists_episodes):
+                                    logger.warning(f"{t.meta_info.title} 第 {t.meta_info.begin_season} 季第 {t.meta_info.episode_list} 集已存在，跳过")
+                                    continue
+
+            _started = True
+            did = self.downloadchain.download_single(context=t,
+                                                     downloader=params.downloader,
+                                                     save_path=params.save_path,
+                                                     label=params.labels)
+            if did:
+                self._added_downloads.append(did)
+                # 保存缓存
+                self.save_cache(workflow_id, cache_key)
+
+        if self._added_downloads:
+            logger.info(f"已添加 {len(self._added_downloads)} 个下载任务")
+            context.downloads.extend(
+                [DownloadTask(download_id=did, downloader=params.downloader) for did in self._added_downloads]
+            )
+        elif _started:
+            self._has_error = True
+
+        self.job_done(f"已添加 {len(self._added_downloads)} 个下载任务")
+        return context

app/actions/add_subscribe.py

@@ -0,0 +1,92 @@
+from app.actions import BaseAction
+from app.chain.subscribe import SubscribeChain
+from app.core.config import settings, global_vars
+from app.core.context import MediaInfo
+from app.db.subscribe_oper import SubscribeOper
+from app.log import logger
+from app.schemas import ActionParams, ActionContext
+
+
+class AddSubscribeParams(ActionParams):
+    """
+    添加订阅参数
+    """
+    pass
+
+
+class AddSubscribeAction(BaseAction):
+    """
+    添加订阅
+    """
+
+    _added_subscribes = []
+    _has_error = False
+
+    def __init__(self, action_id: str):
+        super().__init__(action_id)
+        self.subscribechain = SubscribeChain()
+        self.subscribeoper = SubscribeOper()
+        self._added_subscribes = []
+        self._has_error = False
+
+    @classmethod
+    @property
+    def name(cls) -> str: # noqa
+        return "添加订阅"
+
+    @classmethod
+    @property
+    def description(cls) -> str: # noqa
+        return "根据媒体列表添加订阅"
+
+    @classmethod
+    @property
+    def data(cls) -> dict: # noqa
+        return AddSubscribeParams().dict()
+
+    @property
+    def success(self) -> bool:
+        return not self._has_error
+
+    def execute(self, workflow_id: int, params: dict, context: ActionContext) -> ActionContext:
+        """
+        将medias中的信息添加订阅，如果订阅不存在的话
+        """
+        _started = False
+        for media in context.medias:
+            if global_vars.is_workflow_stopped(workflow_id):
+                break
+            # 检查缓存
+            cache_key = f"{media.type}-{media.title}-{media.year}-{media.season}"
+            if self.check_cache(workflow_id, cache_key):
+                logger.info(f"{media.title} {media.year} 已添加过订阅，跳过")
+                continue
+            mediainfo = MediaInfo()
+            mediainfo.from_dict(media.dict())
+            if self.subscribechain.exists(mediainfo):
+                logger.info(f"{media.title} 已存在订阅")
+                continue
+            # 添加订阅
+            _started = True
+            sid, message = self.subscribechain.add(mtype=mediainfo.type,
+                                                   title=mediainfo.title,
+                                                   year=mediainfo.year,
+                                                   tmdbid=mediainfo.tmdb_id,
+                                                   season=mediainfo.season,
+                                                   doubanid=mediainfo.douban_id,
+                                                   bangumiid=mediainfo.bangumi_id,
+                                                   username=settings.SUPERUSER)
+            if sid:
+                self._added_subscribes.append(sid)
+                # 保存缓存
+                self.save_cache(workflow_id, cache_key)
+
+        if self._added_subscribes:
+            logger.info(f"已添加 {len(self._added_subscribes)} 个订阅")
+            for sid in self._added_subscribes:
+                context.subscribes.append(self.subscribeoper.get(sid))
+        elif _started:
+            self._has_error = True
+
+        self.job_done(f"已添加 {len(self._added_subscribes)} 个订阅")
+        return context

app/actions/fetch_downloads.py

@@ -0,0 +1,68 @@
+from app.actions import BaseAction, ActionChain
+from app.core.config import global_vars
+from app.schemas import ActionParams, ActionContext
+from app.log import logger
+
+
+class FetchDownloadsParams(ActionParams):
+    """
+    获取下载任务参数
+    """
+    pass
+
+
+class FetchDownloadsAction(BaseAction):
+    """
+    获取下载任务
+    """
+
+    _downloads = []
+
+    def __init__(self, action_id: str):
+        super().__init__(action_id)
+        self.chain = ActionChain()
+        self._downloads = []
+
+    @classmethod
+    @property
+    def name(cls) -> str: # noqa
+        return "获取下载任务"
+
+    @classmethod
+    @property
+    def description(cls) -> str: # noqa
+        return "获取下载队列中的任务状态"
+
+    @classmethod
+    @property
+    def data(cls) -> dict: # noqa
+        return FetchDownloadsParams().dict()
+
+    @property
+    def success(self) -> bool:
+        return self.done
+
+    def execute(self, workflow_id: int, params: dict, context: ActionContext) -> ActionContext:
+        """
+        更新downloads中的下载任务状态
+        """
+        __all_complete = False
+        for download in self._downloads:
+            if global_vars.is_workflow_stopped(workflow_id):
+                break
+            logger.info(f"获取下载任务 {download.download_id} 状态 ...")
+            torrents = self.chain.list_torrents(hashs=[download.download_id])
+            if not torrents:
+                download.completed = True
+                continue
+            for t in torrents:
+                download.path = t.path
+                if t.progress >= 100:
+                    logger.info(f"下载任务 {download.download_id} 已完成")
+                    download.completed = True
+                else:
+                    logger.info(f"下载任务 {download.download_id} 未完成")
+                    download.completed = False
+        if all([d.completed for d in self._downloads]):
+            self.job_done()
+        return context

app/actions/fetch_medias.py

@@ -0,0 +1,176 @@
+from typing import List, Optional
+
+from pydantic import Field
+
+from app.actions import BaseAction
+from app.chain.recommend import RecommendChain
+from app.schemas import ActionParams, ActionContext
+from app.core.config import settings, global_vars
+from app.core.event import eventmanager
+from app.log import logger
+from app.schemas import RecommendSourceEventData, MediaInfo
+from app.schemas.types import ChainEventType
+from app.utils.http import RequestUtils
+
+
+class FetchMediasParams(ActionParams):
+    """
+    获取媒体数据参数
+    """
+    source_type: Optional[str] = Field(default="ranking", description="来源")
+    sources: Optional[List[str]] = Field(default=[], description="榜单")
+    api_path: Optional[str] = Field(default=None, description="API路径")
+
+
+class FetchMediasAction(BaseAction):
+    """
+    获取媒体数据
+    """
+
+    _inner_sources = []
+    _medias = []
+    _has_error = False
+
+    def __init__(self, action_id: str):
+        super().__init__(action_id)
+
+        self._medias = []
+        self._has_error = False
+        self.__inner_sources = [
+            {
+                "func": RecommendChain().tmdb_trending,
+                "name": '流行趋势',
+            },
+            {
+                "func": RecommendChain().douban_movie_showing,
+                "name": '正在热映',
+            },
+            {
+                "func": RecommendChain().bangumi_calendar,
+                "name": 'Bangumi每日放送',
+            },
+            {
+                "func": RecommendChain().tmdb_movies,
+                "name": 'TMDB热门电影',
+            },
+            {
+                "func": RecommendChain().tmdb_tvs,
+                "name": 'TMDB热门电视剧',
+            },
+            {
+                "func": RecommendChain().douban_movie_hot,
+                "name": '豆瓣热门电影',
+            },
+            {
+                "func": RecommendChain().douban_tv_hot,
+                "name": '豆瓣热门电视剧',
+            },
+            {
+                "func": RecommendChain().douban_tv_animation,
+                "name": '豆瓣热门动漫',
+            },
+            {
+                "func": RecommendChain().douban_movies,
+                "name": '豆瓣最新电影',
+            },
+            {
+                "func": RecommendChain().douban_tvs,
+                "name": '豆瓣最新电视剧',
+            },
+            {
+                "func": RecommendChain().douban_movie_top250,
+                "name": '豆瓣电影TOP250',
+            },
+            {
+                "func": RecommendChain().douban_tv_weekly_chinese,
+                "name": '豆瓣国产剧集榜',
+            },
+            {
+                "func": RecommendChain().douban_tv_weekly_global,
+                "name": '豆瓣全球剧集榜',
+            }
+        ]
+
+        # 广播事件，请示额外的推荐数据源支持
+        event_data = RecommendSourceEventData()
+        event = eventmanager.send_event(ChainEventType.RecommendSource, event_data)
+        # 使用事件返回的上下文数据
+        if event and event.event_data:
+            event_data: RecommendSourceEventData = event.event_data
+            if event_data.extra_sources:
+                self.__inner_sources.extend([s.dict() for s in event_data.extra_sources])
+
+    @classmethod
+    @property
+    def name(cls) -> str: # noqa
+        return "获取媒体数据"
+
+    @classmethod
+    @property
+    def description(cls) -> str: # noqa
+        return "获取榜单等媒体数据列表"
+
+    @classmethod
+    @property
+    def data(cls) -> dict: # noqa
+        return FetchMediasParams().dict()
+
+    @property
+    def success(self) -> bool:
+        return not self._has_error
+
+    def __get_source(self, source: str):
+        """
+        获取数据源
+        """
+        for s in self.__inner_sources:
+            if s['name'] == source:
+                return s
+        return None
+
+    def execute(self, workflow_id: int, params: dict, context: ActionContext) -> ActionContext:
+        """
+        获取媒体数据，填充到medias
+        """
+        params = FetchMediasParams(**params)
+        try:
+            if params.source_type == "ranking":
+                for name in params.sources:
+                    if global_vars.is_workflow_stopped(workflow_id):
+                        break
+                    source = self.__get_source(name)
+                    if not source:
+                        continue
+                    logger.info(f"获取媒体数据 {source} ...")
+                    results = []
+                    if source.get("func"):
+                        results = source['func']()
+                    else:
+                        # 调用内部API获取数据
+                        api_url = f"http://127.0.0.1:{settings.PORT}/api/v1/{source['api_path']}?token={settings.API_TOKEN}"
+                        res = RequestUtils(timeout=15).post_res(api_url)
+                        if res:
+                            results = res.json()
+                    if results:
+                        logger.info(f"{name} 获取到 {len(results)} 条数据")
+                        self._medias.extend([MediaInfo(**r) for r in results])
+                    else:
+                        logger.error(f"{name} 获取数据失败")
+            else:
+                # 调用内部API获取数据
+                api_url = f"http://127.0.0.1:{settings.PORT}{params.api_path}?token={settings.API_TOKEN}"
+                res = RequestUtils(timeout=15).post_res(api_url)
+                if res:
+                    results = res.json()
+                    if results:
+                        logger.info(f"{params.api_path} 获取到 {len(results)} 条数据")
+                        self._medias.extend([MediaInfo(**r) for r in results])
+        except Exception as e:
+            logger.error(f"获取媒体数据失败: {e}")
+            self._has_error = True
+
+        if self._medias:
+            context.medias.extend(self._medias)
+
+        self.job_done(f"获取到 {len(self._medias)} 条媒数据")
+        return context

app/actions/fetch_rss.py

@@ -0,0 +1,117 @@
+from typing import Optional
+
+from pydantic import Field
+
+from app.actions import BaseAction, ActionChain
+from app.core.config import settings, global_vars
+from app.core.context import Context
+from app.core.metainfo import MetaInfo
+from app.helper.rss import RssHelper
+from app.log import logger
+from app.schemas import ActionParams, ActionContext, TorrentInfo
+
+
+class FetchRssParams(ActionParams):
+    """
+    获取RSS资源列表参数
+    """
+    url: str = Field(default=None, description="RSS地址")
+    proxy: Optional[bool] = Field(default=False, description="是否使用代理")
+    timeout: Optional[int] = Field(default=15, description="超时时间")
+    content_type: Optional[str] = Field(default=None, description="Content-Type")
+    referer: Optional[str] = Field(default=None, description="Referer")
+    ua: Optional[str] = Field(default=None, description="User-Agent")
+    match_media: Optional[str] = Field(default=None, description="匹配媒体信息")
+
+
+class FetchRssAction(BaseAction):
+    """
+    获取RSS资源列表
+    """
+
+    _rss_torrents = []
+    _has_error = False
+
+    def __init__(self, action_id: str):
+        super().__init__(action_id)
+        self.rsshelper = RssHelper()
+        self.chain = ActionChain()
+        self._rss_torrents = []
+        self._has_error = False
+
+    @classmethod
+    @property
+    def name(cls) -> str: # noqa
+        return "获取RSS资源"
+
+    @classmethod
+    @property
+    def description(cls) -> str: # noqa
+        return "订阅RSS地址获取资源"
+
+    @classmethod
+    @property
+    def data(cls) -> dict: # noqa
+        return FetchRssParams().dict()
+
+    @property
+    def success(self) -> bool:
+        return not self._has_error
+
+    def execute(self, workflow_id: int, params: dict, context: ActionContext) -> ActionContext:
+        """
+        请求RSS地址获取数据，并解析为资源列表
+        """
+        params = FetchRssParams(**params)
+        if not params.url:
+            return context
+
+        headers = {}
+        if params.content_type:
+            headers["Content-Type"] = params.content_type
+        if params.referer:
+            headers["Referer"] = params.referer
+        if params.ua:
+            headers["User-Agent"] = params.ua
+
+        rss_items = self.rsshelper.parse(url=params.url,
+                                         proxy=settings.PROXY if params.proxy else None,
+                                         timeout=params.timeout,
+                                         headers=headers)
+        if rss_items is None or rss_items is False:
+            logger.error(f'RSS地址 {params.url} 请求失败！')
+            self._has_error = True
+            return context
+
+        if not rss_items:
+            logger.error(f'RSS地址 {params.url} 未获取到RSS数据！')
+            return context
+
+        # 组装种子
+        for item in rss_items:
+            if global_vars.is_workflow_stopped(workflow_id):
+                break
+            if not item.get("title"):
+                continue
+            torrentinfo = TorrentInfo(
+                title=item.get("title"),
+                enclosure=item.get("enclosure"),
+                page_url=item.get("link"),
+                size=item.get("size"),
+                pubdate=item["pubdate"].strftime("%Y-%m-%d %H:%M:%S") if item.get("pubdate") else None,
+            )
+            meta = MetaInfo(title=torrentinfo.title, subtitle=torrentinfo.description)
+            mediainfo = None
+            if params.match_media:
+                mediainfo = self.chain.recognize_media(meta)
+                if not mediainfo:
+                    logger.warning(f"{torrentinfo.title} 未识别到媒体信息")
+                    continue
+            self._rss_torrents.append(Context(meta_info=meta, media_info=mediainfo, torrent_info=torrentinfo))
+
+        if self._rss_torrents:
+            logger.info(f"获取到 {len(self._rss_torrents)} 个RSS资源")
+            context.torrents.extend(self._rss_torrents)
+
+        self.job_done(f"获取到 {len(self._rss_torrents)} 个资源")
+        return context

app/actions/fetch_torrents.py

@@ -0,0 +1,104 @@
+import random
+import time
+from typing import Optional, List
+
+from pydantic import Field
+
+from app.actions import BaseAction
+from app.chain.search import SearchChain
+from app.core.config import global_vars
+from app.log import logger
+from app.schemas import ActionParams, ActionContext, MediaType
+
+
+class FetchTorrentsParams(ActionParams):
+    """
+    获取站点资源参数
+    """
+    search_type: Optional[str] = Field(default="keyword", description="搜索类型")
+    name: Optional[str] = Field(default=None, description="资源名称")
+    year: Optional[str] = Field(default=None, description="年份")
+    type: Optional[str] = Field(default=None, description="资源类型 (电影/电视剧)")
+    season: Optional[int] = Field(default=None, description="季度")
+    sites: Optional[List[int]] = Field(default=[], description="站点列表")
+    match_media: Optional[bool] = Field(default=False, description="匹配媒体信息")
+
+
+class FetchTorrentsAction(BaseAction):
+    """
+    搜索站点资源
+    """
+
+    _torrents = []
+
+    def __init__(self, action_id: str):
+        super().__init__(action_id)
+        self.searchchain = SearchChain()
+        self._torrents = []
+
+    @classmethod
+    @property
+    def name(cls) -> str: # noqa
+        return "搜索站点资源"
+
+    @classmethod
+    @property
+    def description(cls) -> str: # noqa
+        return "搜索站点种子资源列表"
+
+    @classmethod
+    @property
+    def data(cls) -> dict: # noqa
+        return FetchTorrentsParams().dict()
+
+    @property
+    def success(self) -> bool:
+        return self.done
+
+    def execute(self, workflow_id: int, params: dict, context: ActionContext) -> ActionContext:
+        """
+        搜索站点，获取资源列表
+        """
+        params = FetchTorrentsParams(**params)
+        if params.search_type == "keyword":
+            # 按关键字搜索
+            torrents = self.searchchain.search_by_title(title=params.name, sites=params.sites)
+            for torrent in torrents:
+                if global_vars.is_workflow_stopped(workflow_id):
+                    break
+                if params.year and torrent.meta_info.year != params.year:
+                    continue
+                if params.type and torrent.media_info and torrent.media_info.type != MediaType(params.type):
+                    continue
+                if params.season and torrent.meta_info.begin_season != params.season:
+                    continue
+                # 识别媒体信息
+                if params.match_media:
+                    torrent.media_info = self.searchchain.recognize_media(torrent.meta_info)
+                    if not torrent.media_info:
+                        logger.warning(f"{torrent.torrent_info.title} 未识别到媒体信息")
+                        continue
+                self._torrents.append(torrent)
+        else:
+            # 搜索媒体列表
+            for media in context.medias:
+                if global_vars.is_workflow_stopped(workflow_id):
+                    break
+                torrents = self.searchchain.search_by_id(tmdbid=media.tmdb_id,
+                                                         doubanid=media.douban_id,
+                                                         mtype=MediaType(media.type),
+                                                         sites=params.sites)
+                for torrent in torrents:
+                    self._torrents.append(torrent)
+
+                # 随机休眠 5-30秒
+                sleep_time = random.randint(5, 30)
+                logger.info(f"随机休眠 {sleep_time} 秒 ...")
+                time.sleep(sleep_time)
+
+        if self._torrents:
+            context.torrents.extend(self._torrents)
+            logger.info(f"共搜索到 {len(self._torrents)} 条资源")
+
+        self.job_done(f"搜索到 {len(self._torrents)} 个资源")
+        return context

app/actions/filter_medias.py

@@ -0,0 +1,71 @@
+from typing import Optional
+
+from pydantic import Field
+
+from app.actions import BaseAction
+from app.core.config import global_vars
+from app.log import logger
+from app.schemas import ActionParams, ActionContext
+
+
+class FilterMediasParams(ActionParams):
+    """
+    过滤媒体数据参数
+    """
+    type: Optional[str] = Field(default=None, description="媒体类型 (电影/电视剧)")
+    vote: Optional[int] = Field(default=0, description="评分")
+    year: Optional[str] = Field(default=None, description="年份")
+
+
+class FilterMediasAction(BaseAction):
+    """
+    过滤媒体数据
+    """
+
+    _medias = []
+
+    def __init__(self, action_id: str):
+        super().__init__(action_id)
+        self._medias = []
+
+    @classmethod
+    @property
+    def name(cls) -> str: # noqa
+        return "过滤媒体数据"
+
+    @classmethod
+    @property
+    def description(cls) -> str: # noqa
+        return "对媒体数据列表进行过滤"
+
+    @classmethod
+    @property
+    def data(cls) -> dict: # noqa
+        return FilterMediasParams().dict()
+
+    @property
+    def success(self) -> bool:
+        return self.done
+
+    def execute(self, workflow_id: int, params: dict, context: ActionContext) -> ActionContext:
+        """
+        过滤medias中媒体数据
+        """
+        params = FilterMediasParams(**params)
+        for media in context.medias:
+            if global_vars.is_workflow_stopped(workflow_id):
+                break
+            if params.type and media.type != params.type:
+                continue
+            if params.vote and media.vote_average < params.vote:
+                continue
+            if params.year and media.year != params.year:
+                continue
+            self._medias.append(media)
+
+        logger.info(f"过滤后剩余 {len(self._medias)} 条媒体数据")
+
+        context.medias = self._medias
+
+        self.job_done(f"过滤后剩余 {len(self._medias)} 条媒体数据")
+        return context

app/actions/filter_torrents.py

@@ -0,0 +1,88 @@
+from typing import Optional, List
+
+from pydantic import Field
+
+from app.actions import BaseAction, ActionChain
+from app.core.config import global_vars
+from app.helper.torrent import TorrentHelper
+from app.log import logger
+from app.schemas import ActionParams, ActionContext
+
+
+class FilterTorrentsParams(ActionParams):
+    """
+    过滤资源数据参数
+    """
+    rule_groups: Optional[List[str]] = Field(default=[], description="规则组")
+    quality: Optional[str] = Field(default=None, description="资源质量")
+    resolution: Optional[str] = Field(default=None, description="资源分辨率")
+    effect: Optional[str] = Field(default=None, description="特效")
+    include: Optional[str] = Field(default=None, description="包含规则")
+    exclude: Optional[str] = Field(default=None, description="排除规则")
+    size: Optional[str] = Field(default=None, description="资源大小范围（MB）")
+
+
+class FilterTorrentsAction(BaseAction):
+    """
+    过滤资源数据
+    """
+
+    _torrents = []
+
+    def __init__(self, action_id: str):
+        super().__init__(action_id)
+        self.torrenthelper = TorrentHelper()
+        self.chain = ActionChain()
+        self._torrents = []
+
+    @classmethod
+    @property
+    def name(cls) -> str: # noqa
+        return "过滤资源"
+
+    @classmethod
+    @property
+    def description(cls) -> str: # noqa
+        return "对资源列表数据进行过滤"
+
+    @classmethod
+    @property
+    def data(cls) -> dict: # noqa
+        return FilterTorrentsParams().dict()
+
+    @property
+    def success(self) -> bool:
+        return self.done
+
+    def execute(self, workflow_id: int, params: dict, context: ActionContext) -> ActionContext:
+        """
+        过滤torrents中的资源
+        """
+        params = FilterTorrentsParams(**params)
+        for torrent in context.torrents:
+            if global_vars.is_workflow_stopped(workflow_id):
+                break
+            if self.torrenthelper.filter_torrent(
+                    torrent_info=torrent.torrent_info,
+                    filter_params={
+                        "quality": params.quality,
+                        "resolution": params.resolution,
+                        "effect": params.effect,
+                        "include": params.include,
+                        "exclude": params.exclude,
+                        "size": params.size
+                    }
+            ):
+                if self.chain.filter_torrents(
+                        rule_groups=params.rule_groups,
+                        torrent_list=[torrent.torrent_info],
+                        mediainfo=torrent.media_info
+                ):
+                    self._torrents.append(torrent)
+
+        logger.info(f"过滤后剩余 {len(self._torrents)} 个资源")
+
+        context.torrents = self._torrents
+
+        self.job_done(f"过滤后剩余 {len(self._torrents)} 个资源")
+        return context

app/actions/scan_file.py

@@ -0,0 +1,86 @@
+from pathlib import Path
+from typing import Optional
+
+from pydantic import Field
+
+from app.actions import BaseAction
+from app.chain.storage import StorageChain
+from app.core.config import global_vars, settings
+from app.log import logger
+from app.schemas import ActionParams, ActionContext
+
+
+class ScanFileParams(ActionParams):
+    """
+    整理文件参数
+    """
+    # 存储
+    storage: Optional[str] = Field(default="local", description="存储")
+    directory: Optional[str] = Field(default=None, description="目录")
+
+
+class ScanFileAction(BaseAction):
+    """
+    整理文件
+    """
+
+    _fileitems = []
+    _has_error = False
+
+    def __init__(self, action_id: str):
+        super().__init__(action_id)
+        self.storagechain = StorageChain()
+        self._fileitems = []
+        self._has_error = False
+
+    @classmethod
+    @property
+    def name(cls) -> str: # noqa
+        return "扫描目录"
+
+    @classmethod
+    @property
+    def description(cls) -> str: # noqa
+        return "扫描目录文件到队列"
+
+    @classmethod
+    @property
+    def data(cls) -> dict: # noqa
+        return ScanFileParams().dict()
+
+    @property
+    def success(self) -> bool:
+        return not self._has_error
+
+    def execute(self, workflow_id: int, params: dict, context: ActionContext) -> ActionContext:
+        """
+        扫描目录中的所有文件，记录到fileitems
+        """
+        params = ScanFileParams(**params)
+        if not params.storage or not params.directory:
+            return context
+        fileitem = self.storagechain.get_file_item(params.storage, Path(params.directory))
+        if not fileitem:
+            logger.error(f"目录不存在: 【{params.storage}】{params.directory}")
+            self._has_error = True
+            return context
+        files = self.storagechain.list_files(fileitem, recursion=True)
+        for file in files:
+            if global_vars.is_workflow_stopped(workflow_id):
+                break
+            if not file.extension or f".{file.extension.lower()}" not in settings.RMT_MEDIAEXT:
+                continue
+            # 检查缓存
+            cache_key = f"{file.path}"
+            if self.check_cache(workflow_id, cache_key):
+                logger.info(f"{file.path} 已处理过，跳过")
+                continue
+            self._fileitems.append(fileitem)
+            # 保存缓存
+            self.save_cache(workflow_id, cache_key)
+
+        if self._fileitems:
+            context.fileitems.extend(self._fileitems)
+
+        self.job_done(f"扫描到 {len(self._fileitems)} 个文件")
+        return context

app/actions/scrape_file.py

@@ -0,0 +1,86 @@
+from pathlib import Path
+
+from app.actions import BaseAction
+from app.core.config import global_vars
+from app.schemas import ActionParams, ActionContext
+from app.chain.media import MediaChain
+from app.chain.storage import StorageChain
+from app.core.metainfo import MetaInfoPath
+from app.log import logger
+
+
+class ScrapeFileParams(ActionParams):
+    """
+    刮削文件参数
+    """
+    pass
+
+
+class ScrapeFileAction(BaseAction):
+    """
+    刮削文件
+    """
+
+    _scraped_files = []
+    _has_error = False
+
+    def __init__(self, action_id: str):
+        super().__init__(action_id)
+        self.storagechain = StorageChain()
+        self.mediachain = MediaChain()
+        self._scraped_files = []
+        self._has_error = False
+
+    @classmethod
+    @property
+    def name(cls) -> str: # noqa
+        return "刮削文件"
+
+    @classmethod
+    @property
+    def description(cls) -> str: # noqa
+        return "刮削媒体信息和图片"
+
+    @classmethod
+    @property
+    def data(cls) -> dict: # noqa
+        return ScrapeFileParams().dict()
+
+    @property
+    def success(self) -> bool:
+        return not self._has_error
+
+    def execute(self, workflow_id: int, params: dict, context: ActionContext) -> ActionContext:
+        """
+        刮削fileitems中的所有文件
+        """
+        # 失败次数
+        _failed_count = 0
+        for fileitem in context.fileitems:
+            if global_vars.is_workflow_stopped(workflow_id):
+                break
+            if fileitem in self._scraped_files:
+                continue
+            if not self.storagechain.exists(fileitem):
+                continue
+            # 检查缓存
+            cache_key = f"{fileitem.path}"
+            if self.check_cache(workflow_id, cache_key):
+                logger.info(f"{fileitem.path} 已刮削过，跳过")
+                continue
+            meta = MetaInfoPath(Path(fileitem.path))
+            mediainfo = self.mediachain.recognize_media(meta)
+            if not mediainfo:
+                _failed_count += 1
+                logger.info(f"{fileitem.path} 未识别到媒体信息，无法刮削")
+                continue
+            self.mediachain.scrape_metadata(fileitem=fileitem, meta=meta, mediainfo=mediainfo)
+            self._scraped_files.append(fileitem)
+            # 保存缓存
+            self.save_cache(workflow_id, cache_key)
+
+        if not self._scraped_files and _failed_count:
+            self._has_error = True
+
+        self.job_done(f"成功刮削 {len(self._scraped_files)} 个文件，失败 {_failed_count} 个")
+        return context

app/actions/send_event.py

@@ -0,0 +1,48 @@
+from app.actions import BaseAction
+from app.core.event import eventmanager
+from app.schemas import ActionParams, ActionContext
+from app.schemas.types import ChainEventType
+
+
+class SendEventParams(ActionParams):
+    """
+    发送事件参数
+    """
+    pass
+
+
+class SendEventAction(BaseAction):
+    """
+    发送事件
+    """
+
+    @classmethod
+    @property
+    def name(cls) -> str: # noqa
+        return "发送事件"
+
+    @classmethod
+    @property
+    def description(cls) -> str: # noqa
+        return "发送任务执行事件"
+
+    @classmethod
+    @property
+    def data(cls) -> dict: # noqa
+        return SendEventParams().dict()
+
+    @property
+    def success(self) -> bool:
+        return self.done
+
+    def execute(self, workflow_id: int, params: dict, context: ActionContext) -> ActionContext:
+        """
+        发送工作流事件，以更插件干预工作流执行
+        """
+        # 触发资源下载事件，更新执行上下文
+        event = eventmanager.send_event(ChainEventType.WorkflowExecution, context)
+        if event and event.event_data:
+            context = event.event_data
+
+        self.job_done()
+        return context

app/actions/send_message.py

@@ -0,0 +1,74 @@
+from typing import List, Optional, Union
+
+from pydantic import Field
+
+from app.actions import BaseAction, ActionChain
+from app.schemas import ActionParams, ActionContext, Notification
+from core.config import settings
+
+
+class SendMessageParams(ActionParams):
+    """
+    发送消息参数
+    """
+    client: Optional[List[str]] = Field(default=[], description="消息渠道")
+    userid: Optional[Union[str, int]] = Field(default=None, description="用户ID")
+
+
+class SendMessageAction(BaseAction):
+    """
+    发送消息
+    """
+
+    def __init__(self, action_id: str):
+        super().__init__(action_id)
+        self.chain = ActionChain()
+
+    @classmethod
+    @property
+    def name(cls) -> str: # noqa
+        return "发送消息"
+
+    @classmethod
+    @property
+    def description(cls) -> str: # noqa
+        return "发送任务执行消息"
+
+    @classmethod
+    @property
+    def data(cls) -> dict: # noqa
+        return SendMessageParams().dict()
+
+    @property
+    def success(self) -> bool:
+        return self.done
+
+    def execute(self, workflow_id: int, params: dict, context: ActionContext) -> ActionContext:
+        """
+        发送messages中的消息
+        """
+        params = SendMessageParams(**params)
+        msg_text = f"当前进度：{context.progress}%"
+        index = 1
+        if context.execute_history:
+            for history in context.execute_history:
+                if not history.message:
+                    continue
+                msg_text += f"\n{index}. {history.action}：{history.message}"
+                index += 1
+            # 发送消息
+            if not params.client:
+                params.client = [""]
+            for client in params.client:
+                self.chain.post_message(
+                    Notification(
+                        source=client,
+                        userid=params.userid,
+                        title="【工作流执行结果】",
+                        text=msg_text,
+                        link=settings.MP_DOMAIN("#/workflow")
+                    )
+                )
+
+        self.job_done()
+        return context

app/actions/transfer_file.py

@@ -0,0 +1,139 @@
+import copy
+from pathlib import Path
+from typing import Optional
+
+from pydantic import Field
+
+from app.actions import BaseAction
+from app.core.config import global_vars
+from app.db.transferhistory_oper import TransferHistoryOper
+from app.schemas import ActionParams, ActionContext
+from app.chain.storage import StorageChain
+from app.chain.transfer import TransferChain
+from app.log import logger
+
+
+class TransferFileParams(ActionParams):
+    """
+    整理文件参数
+    """
+    # 来源
+    source: Optional[str] = Field(default="downloads", description="来源")
+
+
+class TransferFileAction(BaseAction):
+    """
+    整理文件
+    """
+
+    _fileitems = []
+    _has_error = False
+
+    def __init__(self, action_id: str):
+        super().__init__(action_id)
+        self.transferchain = TransferChain()
+        self.storagechain = StorageChain()
+        self.transferhis = TransferHistoryOper()
+        self._fileitems = []
+        self._has_error = False
+
+    @classmethod
+    @property
+    def name(cls) -> str: # noqa
+        return "整理文件"
+
+    @classmethod
+    @property
+    def description(cls) -> str: # noqa
+        return "整理队列中的文件"
+
+    @classmethod
+    @property
+    def data(cls) -> dict: # noqa
+        return TransferFileParams().dict()
+
+    @property
+    def success(self) -> bool:
+        return not self._has_error
+
+    def execute(self, workflow_id: int, params: dict, context: ActionContext) -> ActionContext:
+        """
+        从 downloads / fileitems 中整理文件，记录到fileitems
+        """
+
+        def check_continue():
+            """
+            检查是否继续整理文件
+            """
+            if global_vars.is_workflow_stopped(workflow_id):
+                return False
+            return True
+
+        params = TransferFileParams(**params)
+        # 失败次数
+        _failed_count = 0
+        if params.source == "downloads":
+            # 从下载任务中整理文件
+            for download in context.downloads:
+                if global_vars.is_workflow_stopped(workflow_id):
+                    break
+                if not download.completed:
+                    logger.info(f"下载任务 {download.download_id} 未完成")
+                    continue
+                # 检查缓存
+                cache_key = f"{download.download_id}"
+                if self.check_cache(workflow_id, cache_key):
+                    logger.info(f"{download.path} 已整理过，跳过")
+                    continue
+                fileitem = self.storagechain.get_file_item(storage="local", path=Path(download.path))
+                if not fileitem:
+                    logger.info(f"文件 {download.path} 不存在")
+                    continue
+                transferd = self.transferhis.get_by_src(fileitem.path, storage=fileitem.storage)
+                if transferd:
+                    # 已经整理过的文件不再整理
+                    continue
+                logger.info(f"开始整理文件 {download.path} ...")
+                state, errmsg = self.transferchain.do_transfer(fileitem, background=False)
+                if not state:
+                    _failed_count += 1
+                    logger.error(f"整理文件 {download.path} 失败: {errmsg}")
+                    continue
+                logger.info(f"整理文件 {download.path} 完成")
+                self._fileitems.append(fileitem)
+                self.save_cache(workflow_id, cache_key)
+        else:
+            # 从 fileitems 中整理文件
+            for fileitem in copy.deepcopy(context.fileitems):
+                if not check_continue():
+                    break
+                # 检查缓存
+                cache_key = f"{fileitem.path}"
+                if self.check_cache(workflow_id, cache_key):
+                    logger.info(f"{fileitem.path} 已整理过，跳过")
+                    continue
+                transferd = self.transferhis.get_by_src(fileitem.path, storage=fileitem.storage)
+                if transferd:
+                    # 已经整理过的文件不再整理
+                    continue
+                logger.info(f"开始整理文件 {fileitem.path} ...")
+                state, errmsg = self.transferchain.do_transfer(fileitem, background=False,
+                                                               continue_callback=check_continue)
+                if not state:
+                    _failed_count += 1
+                    logger.error(f"整理文件 {fileitem.path} 失败: {errmsg}")
+                    continue
+                logger.info(f"整理文件 {fileitem.path} 完成")
+                # 从 fileitems 中移除已整理的文件
+                context.fileitems.remove(fileitem)
+                self._fileitems.append(fileitem)
+                # 记录已整理的文件
+                self.save_cache(workflow_id, cache_key)
+
+        if self._fileitems:
+            context.fileitems.extend(self._fileitems)
+        elif _failed_count:
+            self._has_error = True
+
+        self.job_done(f"整理成功 {len(self._fileitems)} 个文件，失败 {_failed_count} 个")
+        return context

app/api/apiv1.py

@@ -2,7 +2,7 @@ from fastapi import APIRouter
 
 from app.api.endpoints import login, user, site, message, webhook, subscribe, \
     media, douban, search, plugin, tmdb, history, system, download, dashboard, \
-    transfer, mediaserver, bangumi, storage
+    transfer, mediaserver, bangumi, storage, discover, recommend, workflow
 
 api_router = APIRouter()
 api_router.include_router(login.router, prefix="/login", tags=["login"])
@@ -24,3 +24,6 @@ api_router.include_router(storage.router, prefix="/storage", tags=["storage"])
 api_router.include_router(transfer.router, prefix="/transfer", tags=["transfer"])
 api_router.include_router(mediaserver.router, prefix="/mediaserver", tags=["mediaserver"])
 api_router.include_router(bangumi.router, prefix="/bangumi", tags=["bangumi"])
+api_router.include_router(discover.router, prefix="/discover", tags=["discover"])
+api_router.include_router(recommend.router, prefix="/recommend", tags=["recommend"])
+api_router.include_router(workflow.router, prefix="/workflow", tags=["workflow"])

app/api/endpoints/bangumi.py

@@ -1,30 +1,19 @@
-from typing import List, Any
+from typing import List, Any, Optional
 
 from fastapi import APIRouter, Depends
 
 from app import schemas
 from app.chain.bangumi import BangumiChain
-from app.chain.recommend import RecommendChain
 from app.core.context import MediaInfo
 from app.core.security import verify_token
 
 router = APIRouter()
 
 
-@router.get("/calendar", summary="Bangumi每日放送", response_model=List[schemas.MediaInfo])
-def calendar(page: int = 1,
-             count: int = 30,
-             _: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    浏览Bangumi每日放送
-    """
-    return RecommendChain().bangumi_calendar(page=page, count=count)
-
-
 @router.get("/credits/{bangumiid}", summary="查询Bangumi演职员表", response_model=List[schemas.MediaPerson])
 def bangumi_credits(bangumiid: int,
-                    page: int = 1,
-                    count: int = 20,
+                    page: Optional[int] = 1,
+                    count: Optional[int] = 20,
                     _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     查询Bangumi演职员表
@@ -37,8 +26,8 @@ def bangumi_credits(bangumiid: int,
 
 @router.get("/recommend/{bangumiid}", summary="查询Bangumi推荐", response_model=List[schemas.MediaInfo])
 def bangumi_recommend(bangumiid: int,
-                      page: int = 1,
-                      count: int = 20,
+                      page: Optional[int] = 1,
+                      count: Optional[int] = 20,
                       _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     查询Bangumi推荐
@@ -60,14 +49,15 @@ def bangumi_person(person_id: int,
 
 @router.get("/person/credits/{person_id}", summary="人物参演作品", response_model=List[schemas.MediaInfo])
 def bangumi_person_credits(person_id: int,
-                           page: int = 1,
+                           page: Optional[int] = 1,
+                           count: Optional[int] = 20,
                            _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     根据人物ID查询人物参演作品
     """
     medias = BangumiChain().person_credits(person_id=person_id)
     if medias:
-        return [media.to_dict() for media in medias[(page - 1) * 20: page * 20]]
+        return [media.to_dict() for media in medias[(page - 1) * count: page * count]]
     return []
 
 

app/api/endpoints/dashboard.py

@@ -1,5 +1,5 @@
 from pathlib import Path
-from typing import Any, List, Optional
+from typing import Any, List, Optional, Annotated
 
 from fastapi import APIRouter, Depends
 from sqlalchemy.orm import Session
@@ -18,7 +18,7 @@ router = APIRouter()
 
 
 @router.get("/statistic", summary="媒体数量统计", response_model=schemas.Statistic)
-def statistic(name: str = None, _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+def statistic(name: Optional[str] = None, _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     查询媒体数量统计信息
     """
@@ -37,7 +37,7 @@ def statistic(name: str = None, _: schemas.TokenPayload = Depends(verify_token))
 
 
 @router.get("/statistic2", summary="媒体数量统计（API_TOKEN）", response_model=schemas.Statistic)
-def statistic2(_: str = Depends(verify_apitoken)) -> Any:
+def statistic2(_: Annotated[str, Depends(verify_apitoken)]) -> Any:
     """
     查询媒体数量统计信息 API_TOKEN认证（?token=xxx）
     """
@@ -66,7 +66,7 @@ def storage(_: schemas.TokenPayload = Depends(verify_token)) -> Any:
 
 
 @router.get("/storage2", summary="本地存储空间（API_TOKEN）", response_model=schemas.Storage)
-def storage2(_: str = Depends(verify_apitoken)) -> Any:
+def storage2(_: Annotated[str, Depends(verify_apitoken)]) -> Any:
     """
     查询本地存储空间信息 API_TOKEN认证（?token=xxx）
     """
@@ -82,7 +82,7 @@ def processes(_: schemas.TokenPayload = Depends(verify_token)) -> Any:
 
 
 @router.get("/downloader", summary="下载器信息", response_model=schemas.DownloaderInfo)
-def downloader(name: str = None, _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+def downloader(name: Optional[str] = None, _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     查询下载器信息
     """
@@ -103,7 +103,7 @@ def downloader(name: str = None, _: schemas.TokenPayload = Depends(verify_token)
 
 
 @router.get("/downloader2", summary="下载器信息（API_TOKEN）", response_model=schemas.DownloaderInfo)
-def downloader2(_: str = Depends(verify_apitoken)) -> Any:
+def downloader2(_: Annotated[str, Depends(verify_apitoken)]) -> Any:
     """
     查询下载器信息 API_TOKEN认证（?token=xxx）
     """
@@ -119,7 +119,7 @@ def schedule(_: schemas.TokenPayload = Depends(verify_token)) -> Any:
 
 
 @router.get("/schedule2", summary="后台服务（API_TOKEN）", response_model=List[schemas.ScheduleInfo])
-def schedule2(_: str = Depends(verify_apitoken)) -> Any:
+def schedule2(_: Annotated[str, Depends(verify_apitoken)]) -> Any:
     """
     查询下载器信息 API_TOKEN认证（?token=xxx）
     """
@@ -127,7 +127,7 @@ def schedule2(_: str = Depends(verify_apitoken)) -> Any:
 
 
 @router.get("/transfer", summary="文件整理统计", response_model=List[int])
-def transfer(days: int = 7, db: Session = Depends(get_db),
+def transfer(days: Optional[int] = 7, db: Session = Depends(get_db),
              _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     查询文件整理统计信息
@@ -145,7 +145,7 @@ def cpu(_: schemas.TokenPayload = Depends(verify_token)) -> Any:
 
 
 @router.get("/cpu2", summary="获取当前CPU使用率（API_TOKEN）", response_model=int)
-def cpu2(_: str = Depends(verify_apitoken)) -> Any:
+def cpu2(_: Annotated[str, Depends(verify_apitoken)]) -> Any:
     """
     获取当前CPU使用率 API_TOKEN认证（?token=xxx）
     """
@@ -161,7 +161,7 @@ def memory(_: schemas.TokenPayload = Depends(verify_token)) -> Any:
 
 
 @router.get("/memory2", summary="获取当前内存使用量和使用率（API_TOKEN）", response_model=List[int])
-def memory2(_: str = Depends(verify_apitoken)) -> Any:
+def memory2(_: Annotated[str, Depends(verify_apitoken)]) -> Any:
     """
     获取当前内存使用率 API_TOKEN认证（?token=xxx）
     """

app/api/endpoints/discover.py

@@ -0,0 +1,130 @@
+from typing import Any, List, Optional
+
+from fastapi import APIRouter, Depends
+
+from app import schemas
+from app.core.event import eventmanager
+from app.core.security import verify_token
+from app.schemas import DiscoverSourceEventData
+from app.schemas.types import ChainEventType, MediaType
+from chain.bangumi import BangumiChain
+from chain.douban import DoubanChain
+from chain.tmdb import TmdbChain
+
+router = APIRouter()
+
+
+@router.get("/source", summary="获取探索数据源", response_model=List[schemas.DiscoverMediaSource])
+def source(_: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    获取探索数据源
+    """
+    # 广播事件，请示额外的探索数据源支持
+    event_data = DiscoverSourceEventData()
+    event = eventmanager.send_event(ChainEventType.DiscoverSource, event_data)
+    # 使用事件返回的上下文数据
+    if event and event.event_data:
+        event_data: DiscoverSourceEventData = event.event_data
+        if event_data.extra_sources:
+            return event_data.extra_sources
+    return []
+
+
+@router.get("/bangumi", summary="探索Bangumi", response_model=List[schemas.MediaInfo])
+def bangumi(type: Optional[int] = 2,
+            cat: Optional[int] = None,
+            sort: Optional[str] = 'rank',
+            year: Optional[str] = None,
+            page: Optional[int] = 1,
+            count: Optional[int] = 30,
+            _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    探索Bangumi
+    """
+    medias = BangumiChain().discover(type=type, cat=cat, sort=sort, year=year,
+                                     limit=count, offset=(page - 1) * count)
+    if medias:
+        return [media.to_dict() for media in medias]
+    return []
+
+
+@router.get("/douban_movies", summary="探索豆瓣电影", response_model=List[schemas.MediaInfo])
+def douban_movies(sort: Optional[str] = "R",
+                  tags: Optional[str] = "",
+                  page: Optional[int] = 1,
+                  count: Optional[int] = 30,
+                  _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    浏览豆瓣电影信息
+    """
+    movies = DoubanChain().douban_discover(mtype=MediaType.MOVIE,
+                                           sort=sort, tags=tags, page=page, count=count)
+    return [media.to_dict() for media in movies] if movies else []
+
+
+@router.get("/douban_tvs", summary="探索豆瓣剧集", response_model=List[schemas.MediaInfo])
+def douban_tvs(sort: Optional[str] = "R",
+               tags: Optional[str] = "",
+               page: Optional[int] = 1,
+               count: Optional[int] = 30,
+               _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    浏览豆瓣剧集信息
+    """
+    tvs = DoubanChain().douban_discover(mtype=MediaType.TV,
+                                        sort=sort, tags=tags, page=page, count=count)
+    return [media.to_dict() for media in tvs] if tvs else []
+
+
+@router.get("/tmdb_movies", summary="探索TMDB电影", response_model=List[schemas.MediaInfo])
+def tmdb_movies(sort_by: Optional[str] = "popularity.desc",
+                with_genres: Optional[str] = "",
+                with_original_language: Optional[str] = "",
+                with_keywords: Optional[str] = "",
+                with_watch_providers: Optional[str] = "",
+                vote_average: Optional[float] = 0.0,
+                vote_count: Optional[int] = 0,
+                release_date: Optional[str] = "",
+                page: Optional[int] = 1,
+                _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    浏览TMDB电影信息
+    """
+    movies = TmdbChain().tmdb_discover(mtype=MediaType.MOVIE,
+                                       sort_by=sort_by,
+                                       with_genres=with_genres,
+                                       with_original_language=with_original_language,
+                                       with_keywords=with_keywords,
+                                       with_watch_providers=with_watch_providers,
+                                       vote_average=vote_average,
+                                       vote_count=vote_count,
+                                       release_date=release_date,
+                                       page=page)
+    return [movie.to_dict() for movie in movies] if movies else []
+
+
+@router.get("/tmdb_tvs", summary="探索TMDB剧集", response_model=List[schemas.MediaInfo])
+def tmdb_tvs(sort_by: Optional[str] = "popularity.desc",
+             with_genres: Optional[str] = "",
+             with_original_language: Optional[str] = "",
+             with_keywords: Optional[str] = "",
+             with_watch_providers: Optional[str] = "",
+             vote_average: Optional[float] = 0.0,
+             vote_count: Optional[int] = 0,
+             release_date: Optional[str] = "",
+             page: Optional[int] = 1,
+             _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    浏览TMDB剧集信息
+    """
+    tvs = TmdbChain().tmdb_discover(mtype=MediaType.TV,
+                                    sort_by=sort_by,
+                                    with_genres=with_genres,
+                                    with_original_language=with_original_language,
+                                    with_keywords=with_keywords,
+                                    with_watch_providers=with_watch_providers,
+                                    vote_average=vote_average,
+                                    vote_count=vote_count,
+                                    release_date=release_date,
+                                    page=page)
+    return [tv.to_dict() for tv in tvs] if tvs else []

app/api/endpoints/douban.py

@@ -1,10 +1,9 @@
-from typing import Any, List
+from typing import Any, List, Optional
 
 from fastapi import APIRouter, Depends
 
 from app import schemas
 from app.chain.douban import DoubanChain
-from app.chain.recommend import RecommendChain
 from app.core.context import MediaInfo
 from app.core.security import verify_token
 from app.schemas import MediaType
@@ -23,7 +22,7 @@ def douban_person(person_id: int,
 
 @router.get("/person/credits/{person_id}", summary="人物参演作品", response_model=List[schemas.MediaInfo])
 def douban_person_credits(person_id: int,
-                          page: int = 1,
+                          page: Optional[int] = 1,
                           _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     根据人物ID查询人物参演作品
@@ -34,100 +33,6 @@ def douban_person_credits(person_id: int,
     return []
 
 
-@router.get("/showing", summary="豆瓣正在热映", response_model=List[schemas.MediaInfo])
-def movie_showing(page: int = 1,
-                  count: int = 30,
-                  _: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    浏览豆瓣正在热映
-    """
-    return RecommendChain().douban_movie_showing(page=page, count=count)
-
-
-@router.get("/movies", summary="豆瓣电影", response_model=List[schemas.MediaInfo])
-def douban_movies(sort: str = "R",
-                  tags: str = "",
-                  page: int = 1,
-                  count: int = 30,
-                  _: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    浏览豆瓣电影信息
-    """
-    return RecommendChain().douban_movies(sort=sort, tags=tags, page=page, count=count)
-
-
-@router.get("/tvs", summary="豆瓣剧集", response_model=List[schemas.MediaInfo])
-def douban_tvs(sort: str = "R",
-               tags: str = "",
-               page: int = 1,
-               count: int = 30,
-               _: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    浏览豆瓣剧集信息
-    """
-    return RecommendChain().douban_tvs(sort=sort, tags=tags, page=page, count=count)
-
-
-@router.get("/movie_top250", summary="豆瓣电影TOP250", response_model=List[schemas.MediaInfo])
-def movie_top250(page: int = 1,
-                 count: int = 30,
-                 _: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    浏览豆瓣剧集信息
-    """
-    return RecommendChain().douban_movie_top250(page=page, count=count)
-
-
-@router.get("/tv_weekly_chinese", summary="豆瓣国产剧集周榜", response_model=List[schemas.MediaInfo])
-def tv_weekly_chinese(page: int = 1,
-                      count: int = 30,
-                      _: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    中国每周剧集口碑榜
-    """
-    return RecommendChain().douban_tv_weekly_chinese(page=page, count=count)
-
-
-@router.get("/tv_weekly_global", summary="豆瓣全球剧集周榜", response_model=List[schemas.MediaInfo])
-def tv_weekly_global(page: int = 1,
-                     count: int = 30,
-                     _: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    全球每周剧集口碑榜
-    """
-    return RecommendChain().douban_tv_weekly_global(page=page, count=count)
-
-
-@router.get("/tv_animation", summary="豆瓣动画剧集", response_model=List[schemas.MediaInfo])
-def tv_animation(page: int = 1,
-                 count: int = 30,
-                 _: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    热门动画剧集
-    """
-    return RecommendChain().douban_tv_animation(page=page, count=count)
-
-
-@router.get("/movie_hot", summary="豆瓣热门电影", response_model=List[schemas.MediaInfo])
-def movie_hot(page: int = 1,
-              count: int = 30,
-              _: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    热门电影
-    """
-    return RecommendChain().douban_movie_hot(page=page, count=count)
-
-
-@router.get("/tv_hot", summary="豆瓣热门电视剧", response_model=List[schemas.MediaInfo])
-def tv_hot(page: int = 1,
-           count: int = 30,
-           _: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    热门电视剧
-    """
-    return RecommendChain().douban_tv_hot(page=page, count=count)
-
-
 @router.get("/credits/{doubanid}/{type_name}", summary="豆瓣演员阵容", response_model=List[schemas.MediaPerson])
 def douban_credits(doubanid: str,
                    type_name: str,

app/api/endpoints/download.py

@@ -1,4 +1,4 @@
-from typing import Any, List
+from typing import Any, List, Annotated, Optional
 
 from fastapi import APIRouter, Depends, Body
 
@@ -18,7 +18,7 @@ router = APIRouter()
 
 @router.get("/", summary="正在下载", response_model=List[schemas.DownloadingTorrent])
 def current(
-        name: str = None,
+        name: Optional[str] = None,
         _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     查询正在下载的任务
@@ -30,8 +30,8 @@ def current(
 def download(
         media_in: schemas.MediaInfo,
         torrent_in: schemas.TorrentInfo,
-        downloader: str = Body(None),
-        save_path: str = Body(None),
+        downloader: Annotated[str | None, Body()] = None,
+        save_path: Annotated[str | None, Body()] = None,
         current_user: User = Depends(get_current_active_user)) -> Any:
     """
     添加下载任务（含媒体信息）
@@ -62,8 +62,8 @@ def download(
 @router.post("/add", summary="添加下载（不含媒体信息）", response_model=schemas.Response)
 def add(
         torrent_in: schemas.TorrentInfo,
-        downloader: str = Body(None),
-        save_path: str = Body(None),
+        downloader: Annotated[str | None, Body()] = None,
+        save_path: Annotated[str | None, Body()] = None,
         current_user: User = Depends(get_current_active_user)) -> Any:
     """
     添加下载任务（不含媒体信息）

app/api/endpoints/history.py

@@ -1,4 +1,4 @@
-from typing import List, Any
+from typing import List, Any, Optional
 
 import jieba
 from fastapi import APIRouter, Depends
@@ -20,8 +20,8 @@ router = APIRouter()
 
 
 @router.get("/download", summary="查询下载历史记录", response_model=List[schemas.DownloadHistory])
-def download_history(page: int = 1,
-                     count: int = 30,
+def download_history(page: Optional[int] = 1,
+                     count: Optional[int] = 30,
                      db: Session = Depends(get_db),
                      _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
@@ -42,10 +42,10 @@ def delete_download_history(history_in: schemas.DownloadHistory,
 
 
 @router.get("/transfer", summary="查询整理记录", response_model=schemas.Response)
-def transfer_history(title: str = None,
-                     page: int = 1,
-                     count: int = 30,
-                     status: bool = None,
+def transfer_history(title: Optional[str] = None,
+                     page: Optional[int] = 1,
+                     count: Optional[int] = 30,
+                     status: Optional[bool] = None,
                      db: Session = Depends(get_db),
                      _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
@@ -78,8 +78,8 @@ def transfer_history(title: str = None,
 
 @router.delete("/transfer", summary="删除整理记录", response_model=schemas.Response)
 def delete_transfer_history(history_in: schemas.TransferHistory,
-                            deletesrc: bool = False,
-                            deletedest: bool = False,
+                            deletesrc: Optional[bool] = False,
+                            deletedest: Optional[bool] = False,
                             db: Session = Depends(get_db),
                             _: schemas.TokenPayload = Depends(get_current_active_superuser)) -> Any:
     """

app/api/endpoints/login.py

@@ -1,5 +1,5 @@
 from datetime import timedelta
-from typing import Any, List
+from typing import Any, List, Annotated
 
 from fastapi import APIRouter, Depends, Form, HTTPException
 from fastapi.security import OAuth2PasswordRequestForm
@@ -18,8 +18,8 @@ router = APIRouter()
 
 @router.post("/access-token", summary="获取token", response_model=schemas.Token)
 def login_access_token(
-        form_data: OAuth2PasswordRequestForm = Depends(),
-        otp_password: str = Form(None)
+        form_data: Annotated[OAuth2PasswordRequestForm, Depends()],
+        otp_password: Annotated[str | None, Form()] = None
 ) -> Any:
     """
     获取认证Token

app/api/endpoints/media.py

@@ -1,22 +1,25 @@
 from pathlib import Path
-from typing import List, Any, Union
+from typing import List, Any, Union, Annotated, Optional
 
 from fastapi import APIRouter, Depends
 
 from app import schemas
 from app.chain.media import MediaChain
+from app.chain.tmdb import TmdbChain
 from app.core.config import settings
 from app.core.context import Context
+from app.core.event import eventmanager
 from app.core.metainfo import MetaInfo, MetaInfoPath
 from app.core.security import verify_token, verify_apitoken
-from app.schemas import MediaType
+from app.schemas import MediaType, MediaRecognizeConvertEventData
+from app.schemas.types import ChainEventType
 
 router = APIRouter()
 
 
 @router.get("/recognize", summary="识别媒体信息（种子）", response_model=schemas.Context)
 def recognize(title: str,
-              subtitle: str = None,
+              subtitle: Optional[str] = None,
               _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     根据标题、副标题识别媒体信息
@@ -30,9 +33,10 @@ def recognize(title: str,
 
 
 @router.get("/recognize2", summary="识别种子媒体信息（API_TOKEN）", response_model=schemas.Context)
-def recognize2(title: str,
-               subtitle: str = None,
-               _: str = Depends(verify_apitoken)) -> Any:
+def recognize2(_: Annotated[str, Depends(verify_apitoken)],
+               title: str,
+               subtitle: Optional[str] = None
+               ) -> Any:
     """
     根据标题、副标题识别媒体信息 API_TOKEN认证（?token=xxx）
     """
@@ -55,7 +59,7 @@ def recognize_file(path: str,
 
 @router.get("/recognize_file2", summary="识别文件媒体信息（API_TOKEN）", response_model=schemas.Context)
 def recognize_file2(path: str,
-                    _: str = Depends(verify_apitoken)) -> Any:
+                    _: Annotated[str, Depends(verify_apitoken)]) -> Any:
     """
     根据文件路径识别媒体信息 API_TOKEN认证（?token=xxx）
     """
@@ -65,13 +69,14 @@ def recognize_file2(path: str,
 
 @router.get("/search", summary="搜索媒体/人物信息", response_model=List[dict])
 def search(title: str,
-           type: str = "media",
+           type: Optional[str] = "media",
            page: int = 1,
            count: int = 8,
            _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     模糊搜索媒体/人物信息列表 media：媒体信息，person：人物信息
     """
+
     def __get_source(obj: Union[schemas.MediaInfo, schemas.MediaPerson, dict]):
         """
         获取对象属性
@@ -101,7 +106,7 @@ def search(title: str,
 
 @router.post("/scrape/{storage}", summary="刮削媒体信息", response_model=schemas.Response)
 def scrape(fileitem: schemas.FileItem,
-           storage: str = "local",
+           storage: Optional[str] = "local",
            _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     刮削媒体信息
@@ -131,25 +136,108 @@ def category(_: schemas.TokenPayload = Depends(verify_token)) -> Any:
     return MediaChain().media_category() or {}
 
 
+@router.get("/group/seasons/{episode_group}", summary="查询剧集组季信息", response_model=List[schemas.MediaSeason])
+def group_seasons(episode_group: str, _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    查询剧集组季信息（themoviedb）
+    """
+    return TmdbChain().tmdb_group_seasons(group_id=episode_group)
+
+
+@router.get("/groups/{tmdbid}", summary="查询媒体剧集组", response_model=List[dict])
+def seasons(tmdbid: int, _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    查询媒体剧集组列表（themoviedb）
+    """
+    mediainfo  = MediaChain().recognize_media(tmdbid=tmdbid, mtype=MediaType.TV)
+    if not mediainfo:
+        return []
+    return mediainfo.episode_groups
+
+@router.get("/seasons", summary="查询媒体季信息", response_model=List[schemas.MediaSeason])
+def seasons(mediaid: Optional[str] = None,
+            title: Optional[str] = None,
+            year: str = None,
+            season: int = None,
+            _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    查询媒体季信息
+    """
+    if mediaid:
+        if mediaid.startswith("tmdb:"):
+            tmdbid = int(mediaid[5:])
+            seasons_info = TmdbChain().tmdb_seasons(tmdbid=tmdbid)
+            if seasons_info:
+                if season:
+                    return [sea for sea in seasons_info if sea.season_number == season]
+                return seasons_info
+    if title:
+        meta = MetaInfo(title)
+        if year:
+            meta.year = year
+        mediainfo = MediaChain().recognize_media(meta, mtype=MediaType.TV)
+        if mediainfo:
+            if settings.RECOGNIZE_SOURCE == "themoviedb":
+                seasons_info = TmdbChain().tmdb_seasons(tmdbid=mediainfo.tmdb_id)
+                if seasons_info:
+                    if season:
+                        return [sea for sea in seasons_info if sea.season_number == season]
+                    return seasons_info
+            else:
+                sea = season or 1
+                return schemas.MediaSeason(
+                    season_number=sea,
+                    poster_path=mediainfo.poster_path,
+                    name=f"第 {sea} 季",
+                    air_date=mediainfo.release_date,
+                    overview=mediainfo.overview,
+                    vote_average=mediainfo.vote_average,
+                    episode_count=mediainfo.number_of_episodes
+                )
+    return []
+
+
 @router.get("/{mediaid}", summary="查询媒体详情", response_model=schemas.MediaInfo)
-def media_info(mediaid: str, type_name: str,
-               _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+def detail(mediaid: str, type_name: str, title: Optional[str] = None, year: int = None,
+           _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     根据媒体ID查询themoviedb或豆瓣媒体信息，type_name: 电影/电视剧
     """
     mtype = MediaType(type_name)
-    tmdbid, doubanid, bangumiid = None, None, None
+    mediainfo = None
     if mediaid.startswith("tmdb:"):
-        tmdbid = int(mediaid[5:])
+        mediainfo = MediaChain().recognize_media(tmdbid=int(mediaid[5:]), mtype=mtype)
     elif mediaid.startswith("douban:"):
-        doubanid = mediaid[7:]
+        mediainfo = MediaChain().recognize_media(doubanid=mediaid[7:], mtype=mtype)
     elif mediaid.startswith("bangumi:"):
-        bangumiid = int(mediaid[8:])
-    if not tmdbid and not doubanid and not bangumiid:
-        return schemas.MediaInfo()
+        mediainfo = MediaChain().recognize_media(bangumiid=int(mediaid[8:]), mtype=mtype)
+    else:
+        # 广播事件解析媒体信息
+        event_data = MediaRecognizeConvertEventData(
+            mediaid=mediaid,
+            convert_type=settings.RECOGNIZE_SOURCE
+        )
+        event = eventmanager.send_event(ChainEventType.MediaRecognizeConvert, event_data)
+        # 使用事件返回的上下文数据
+        if event and event.event_data:
+            event_data: MediaRecognizeConvertEventData = event.event_data
+            if event_data.media_dict:
+                new_id = event_data.media_dict.get("id")
+                if event_data.convert_type == "themoviedb":
+                    mediainfo = MediaChain().recognize_media(tmdbid=new_id, mtype=mtype)
+                elif event_data.convert_type == "douban":
+                    mediainfo = MediaChain().recognize_media(doubanid=new_id, mtype=mtype)
+        elif title:
+            # 使用名称识别兜底
+            meta = MetaInfo(title)
+            if year:
+                meta.year = year
+            if mtype:
+                meta.type = mtype
+            mediainfo = MediaChain().recognize_media(meta=meta)
     # 识别
-    mediainfo = MediaChain().recognize_media(tmdbid=tmdbid, doubanid=doubanid, bangumiid=bangumiid, mtype=mtype)
     if mediainfo:
         MediaChain().obtain_images(mediainfo)
         return mediainfo.to_dict()
+
     return schemas.MediaInfo()

app/api/endpoints/mediaserver.py

@@ -1,4 +1,4 @@
-from typing import Any, List, Dict
+from typing import Any, List, Dict, Optional
 
 from fastapi import APIRouter, Depends
 from sqlalchemy.orm import Session
@@ -43,11 +43,11 @@ def play_item(itemid: str, _: schemas.TokenPayload = Depends(verify_token)) -> s
 
 
 @router.get("/exists", summary="查询本地是否存在（数据库）", response_model=schemas.Response)
-def exists_local(title: str = None,
-                 year: int = None,
-                 mtype: str = None,
-                 tmdbid: int = None,
-                 season: int = None,
+def exists_local(title: Optional[str] = None,
+                 year: Optional[str] = None,
+                 mtype: Optional[str] = None,
+                 tmdbid: Optional[int] = None,
+                 season: Optional[int] = None,
                  db: Session = Depends(get_db),
                  _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
@@ -121,7 +121,7 @@ def not_exists(media_in: schemas.MediaInfo,
 
 
 @router.get("/latest", summary="最新入库条目", response_model=List[schemas.MediaServerPlayItem])
-def latest(server: str, count: int = 18,
+def latest(server: str, count: Optional[int] = 18,
            userinfo: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     获取媒体服务器最新入库条目
@@ -130,7 +130,7 @@ def latest(server: str, count: int = 18,
 
 
 @router.get("/playing", summary="正在播放条目", response_model=List[schemas.MediaServerPlayItem])
-def playing(server: str, count: int = 12,
+def playing(server: str, count: Optional[int] = 12,
             userinfo: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     获取媒体服务器正在播放条目
@@ -139,7 +139,7 @@ def playing(server: str, count: int = 12,
 
 
 @router.get("/library", summary="媒体库列表", response_model=List[schemas.MediaServerLibrary])
-def library(server: str, hidden: bool = False,
+def library(server: str, hidden: Optional[bool] = False,
             userinfo: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     获取媒体服务器媒体库列表

app/api/endpoints/message.py

@@ -1,5 +1,5 @@
 import json
-from typing import Union, Any, List
+from typing import Union, Any, List, Optional
 
 from fastapi import APIRouter, BackgroundTasks, Depends, Request
 from pywebpush import WebPushException, webpush
@@ -60,8 +60,8 @@ def web_message(text: str, current_user: User = Depends(get_current_active_super
 @router.get("/web", summary="获取WEB消息", response_model=List[dict])
 def get_web_message(_: schemas.TokenPayload = Depends(verify_token),
                     db: Session = Depends(get_db),
-                    page: int = 1,
-                    count: int = 20):
+                    page: Optional[int] = 1,
+                    count: Optional[int] = 20):
     """
     获取WEB消息列表
     """
@@ -77,7 +77,7 @@ def get_web_message(_: schemas.TokenPayload = Depends(verify_token),
 
 
 def wechat_verify(echostr: str, msg_signature: str, timestamp: Union[str, int], nonce: str,
-                  source: str = None) -> Any:
+                  source: Optional[str] = None) -> Any:
     """
     微信验证响应
     """
@@ -114,8 +114,8 @@ def vocechat_verify() -> Any:
 
 
 @router.get("/", summary="回调请求验证")
-def incoming_verify(token: str = None, echostr: str = None, msg_signature: str = None,
-                    timestamp: Union[str, int] = None, nonce: str = None, source: str = None,
+def incoming_verify(token: Optional[str] = None, echostr: Optional[str] = None, msg_signature: Optional[str] = None,
+                    timestamp: Union[str, int] = None, nonce: Optional[str] = None, source: Optional[str] = None,
                     _: schemas.TokenPayload = Depends(verify_apitoken)) -> Any:
     """
     微信/VoceChat等验证响应

app/api/endpoints/plugin.py

@@ -118,7 +118,7 @@ def _clean_protected_routes(existing_paths: dict):
 
 @router.get("/", summary="所有插件", response_model=List[schemas.Plugin])
 def all_plugins(_: schemas.TokenPayload = Depends(get_current_active_superuser),
-                state: str = "all") -> List[schemas.Plugin]:
+                state: Optional[str] = "all") -> List[schemas.Plugin]:
     """
     查询所有插件清单，包括本地插件和在线插件，插件状态：installed, market, all
     """
@@ -181,8 +181,8 @@ def statistic(_: schemas.TokenPayload = Depends(verify_token)) -> Any:
 
 @router.get("/install/{plugin_id}", summary="安装插件", response_model=schemas.Response)
 def install(plugin_id: str,
-            repo_url: str = "",
-            force: bool = False,
+            repo_url: Optional[str] = "",
+            force: Optional[bool] = False,
             _: schemas.TokenPayload = Depends(get_current_active_superuser)) -> Any:
     """
     安装插件

app/api/endpoints/recommend.py

@@ -0,0 +1,191 @@
+from typing import Any, List, Optional
+
+from fastapi import APIRouter, Depends
+
+from app import schemas
+from app.core.event import eventmanager
+from app.core.security import verify_token
+from app.schemas.types import ChainEventType
+from app.chain.recommend import RecommendChain
+from app.schemas import RecommendSourceEventData
+
+router = APIRouter()
+
+
+@router.get("/source", summary="获取推荐数据源", response_model=List[schemas.RecommendMediaSource])
+def source(_: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    获取推荐数据源
+    """
+    # 广播事件，请示额外的推荐数据源支持
+    event_data = RecommendSourceEventData()
+    event = eventmanager.send_event(ChainEventType.RecommendSource, event_data)
+    # 使用事件返回的上下文数据
+    if event and event.event_data:
+        event_data: RecommendSourceEventData = event.event_data
+        if event_data.extra_sources:
+            return event_data.extra_sources
+    return []
+
+
+@router.get("/bangumi_calendar", summary="Bangumi每日放送", response_model=List[schemas.MediaInfo])
+def bangumi_calendar(page: Optional[int] = 1,
+                     count: Optional[int] = 30,
+                     _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    浏览Bangumi每日放送
+    """
+    return RecommendChain().bangumi_calendar(page=page, count=count)
+
+
+@router.get("/douban_showing", summary="豆瓣正在热映", response_model=List[schemas.MediaInfo])
+def douban_showing(page: Optional[int] = 1,
+                   count: Optional[int] = 30,
+                   _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    浏览豆瓣正在热映
+    """
+    return RecommendChain().douban_movie_showing(page=page, count=count)
+
+
+@router.get("/douban_movies", summary="豆瓣电影", response_model=List[schemas.MediaInfo])
+def douban_movies(sort: Optional[str] = "R",
+                  tags: Optional[str] = "",
+                  page: Optional[int] = 1,
+                  count: Optional[int] = 30,
+                  _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    浏览豆瓣电影信息
+    """
+    return RecommendChain().douban_movies(sort=sort, tags=tags, page=page, count=count)
+
+
+@router.get("/douban_tvs", summary="豆瓣剧集", response_model=List[schemas.MediaInfo])
+def douban_tvs(sort: Optional[str] = "R",
+               tags: Optional[str] = "",
+               page: Optional[int] = 1,
+               count: Optional[int] = 30,
+               _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    浏览豆瓣剧集信息
+    """
+    return RecommendChain().douban_tvs(sort=sort, tags=tags, page=page, count=count)
+
+
+@router.get("/douban_movie_top250", summary="豆瓣电影TOP250", response_model=List[schemas.MediaInfo])
+def douban_movie_top250(page: Optional[int] = 1,
+                        count: Optional[int] = 30,
+                        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    浏览豆瓣剧集信息
+    """
+    return RecommendChain().douban_movie_top250(page=page, count=count)
+
+
+@router.get("/douban_tv_weekly_chinese", summary="豆瓣国产剧集周榜", response_model=List[schemas.MediaInfo])
+def douban_tv_weekly_chinese(page: Optional[int] = 1,
+                             count: Optional[int] = 30,
+                             _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    中国每周剧集口碑榜
+    """
+    return RecommendChain().douban_tv_weekly_chinese(page=page, count=count)
+
+
+@router.get("/douban_tv_weekly_global", summary="豆瓣全球剧集周榜", response_model=List[schemas.MediaInfo])
+def douban_tv_weekly_global(page: Optional[int] = 1,
+                            count: Optional[int] = 30,
+                            _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    全球每周剧集口碑榜
+    """
+    return RecommendChain().douban_tv_weekly_global(page=page, count=count)
+
+
+@router.get("/douban_tv_animation", summary="豆瓣动画剧集", response_model=List[schemas.MediaInfo])
+def douban_tv_animation(page: Optional[int] = 1,
+                        count: Optional[int] = 30,
+                        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    热门动画剧集
+    """
+    return RecommendChain().douban_tv_animation(page=page, count=count)
+
+
+@router.get("/douban_movie_hot", summary="豆瓣热门电影", response_model=List[schemas.MediaInfo])
+def douban_movie_hot(page: Optional[int] = 1,
+                     count: Optional[int] = 30,
+                     _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    热门电影
+    """
+    return RecommendChain().douban_movie_hot(page=page, count=count)
+
+
+@router.get("/douban_tv_hot", summary="豆瓣热门电视剧", response_model=List[schemas.MediaInfo])
+def douban_tv_hot(page: Optional[int] = 1,
+                  count: Optional[int] = 30,
+                  _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    热门电视剧
+    """
+    return RecommendChain().douban_tv_hot(page=page, count=count)
+
+
+@router.get("/tmdb_movies", summary="TMDB电影", response_model=List[schemas.MediaInfo])
+def tmdb_movies(sort_by: Optional[str] = "popularity.desc",
+                with_genres: Optional[str] = "",
+                with_original_language: Optional[str] = "",
+                with_keywords: Optional[str] = "",
+                with_watch_providers: Optional[str] = "",
+                vote_average: Optional[float] = 0.0,
+                vote_count: Optional[int] = 0,
+                release_date: Optional[str] = "",
+                page: Optional[int] = 1,
+                _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    浏览TMDB电影信息
+    """
+    return RecommendChain().tmdb_movies(sort_by=sort_by,
+                                        with_genres=with_genres,
+                                        with_original_language=with_original_language,
+                                        with_keywords=with_keywords,
+                                        with_watch_providers=with_watch_providers,
+                                        vote_average=vote_average,
+                                        vote_count=vote_count,
+                                        release_date=release_date,
+                                        page=page)
+
+
+@router.get("/tmdb_tvs", summary="TMDB剧集", response_model=List[schemas.MediaInfo])
+def tmdb_tvs(sort_by: Optional[str] = "popularity.desc",
+             with_genres: Optional[str] = "",
+             with_original_language: Optional[str] = "",
+             with_keywords: Optional[str] = "",
+             with_watch_providers: Optional[str] = "",
+             vote_average: Optional[float] = 0.0,
+             vote_count: Optional[int] = 0,
+             release_date: Optional[str] = "",
+             page: Optional[int] = 1,
+             _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    浏览TMDB剧集信息
+    """
+    return RecommendChain().tmdb_tvs(sort_by=sort_by,
+                                     with_genres=with_genres,
+                                     with_original_language=with_original_language,
+                                     with_keywords=with_keywords,
+                                     with_watch_providers=with_watch_providers,
+                                     vote_average=vote_average,
+                                     vote_count=vote_count,
+                                     release_date=release_date,
+                                     page=page)
+
+
+@router.get("/tmdb_trending", summary="TMDB流行趋势", response_model=List[schemas.MediaInfo])
+def tmdb_trending(page: Optional[int] = 1,
+                  _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    TMDB流行趋势
+    """
+    return RecommendChain().tmdb_trending(page=page)

app/api/endpoints/search.py

@@ -1,4 +1,4 @@
-from typing import List, Any
+from typing import List, Any, Optional
 
 from fastapi import APIRouter, Depends
 
@@ -6,8 +6,11 @@ from app import schemas
 from app.chain.media import MediaChain
 from app.chain.search import SearchChain
 from app.core.config import settings
+from app.core.event import eventmanager
+from app.core.metainfo import MetaInfo
 from app.core.security import verify_token
-from app.schemas.types import MediaType
+from app.schemas import MediaRecognizeConvertEventData
+from app.schemas.types import MediaType, ChainEventType
 
 router = APIRouter()
 
@@ -23,43 +26,60 @@ def search_latest(_: schemas.TokenPayload = Depends(verify_token)) -> Any:
 
 @router.get("/media/{mediaid}", summary="精确搜索资源", response_model=schemas.Response)
 def search_by_id(mediaid: str,
-                 mtype: str = None,
-                 area: str = "title",
-                 season: str = None,
+                 mtype: Optional[str] = None,
+                 area: Optional[str] = "title",
+                 title: Optional[str] = None,
+                 year: Optional[str] = None,
+                 season: Optional[str] = None,
+                 sites: Optional[str] = None,
                  _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     根据TMDBID/豆瓣ID精确搜索站点资源 tmdb:/douban:/bangumi:
     """
     if mtype:
-        mtype = MediaType(mtype)
+        media_type = MediaType(mtype)
+    else:
+        media_type = None
     if season:
-        season = int(season)
+        media_season = int(season)
+    else:
+        media_season = None
+    if sites:
+        site_list = [int(site) for site in sites.split(",") if site]
+    else:
+        site_list = None
+    torrents = None
+    # 根据前缀识别媒体ID
     if mediaid.startswith("tmdb:"):
         tmdbid = int(mediaid.replace("tmdb:", ""))
         if settings.RECOGNIZE_SOURCE == "douban":
             # 通过TMDBID识别豆瓣ID
-            doubaninfo = MediaChain().get_doubaninfo_by_tmdbid(tmdbid=tmdbid, mtype=mtype)
+            doubaninfo = MediaChain().get_doubaninfo_by_tmdbid(tmdbid=tmdbid, mtype=media_type)
             if doubaninfo:
                 torrents = SearchChain().search_by_id(doubanid=doubaninfo.get("id"),
-                                                      mtype=mtype, area=area, season=season)
+                                                      mtype=media_type, area=area, season=media_season,
+                                                      sites=site_list, cache_local=True)
             else:
                 return schemas.Response(success=False, message="未识别到豆瓣媒体信息")
         else:
-            torrents = SearchChain().search_by_id(tmdbid=tmdbid, mtype=mtype, area=area, season=season)
+            torrents = SearchChain().search_by_id(tmdbid=tmdbid, mtype=media_type, area=area, season=media_season,
+                                                  sites=site_list, cache_local=True)
     elif mediaid.startswith("douban:"):
         doubanid = mediaid.replace("douban:", "")
         if settings.RECOGNIZE_SOURCE == "themoviedb":
             # 通过豆瓣ID识别TMDBID
-            tmdbinfo = MediaChain().get_tmdbinfo_by_doubanid(doubanid=doubanid, mtype=mtype)
+            tmdbinfo = MediaChain().get_tmdbinfo_by_doubanid(doubanid=doubanid, mtype=media_type)
             if tmdbinfo:
-                if tmdbinfo.get('season') and not season:
-                    season = tmdbinfo.get('season')
+                if tmdbinfo.get('season') and not media_season:
+                    media_season = tmdbinfo.get('season')
                 torrents = SearchChain().search_by_id(tmdbid=tmdbinfo.get("id"),
-                                                      mtype=mtype, area=area, season=season)
+                                                      mtype=media_type, area=area, season=media_season,
+                                                      sites=site_list, cache_local=True)
             else:
                 return schemas.Response(success=False, message="未识别到TMDB媒体信息")
         else:
-            torrents = SearchChain().search_by_id(doubanid=doubanid, mtype=mtype, area=area, season=season)
+            torrents = SearchChain().search_by_id(doubanid=doubanid, mtype=media_type, area=area, season=media_season,
+                                                  sites=site_list, cache_local=True)
     elif mediaid.startswith("bangumi:"):
         bangumiid = int(mediaid.replace("bangumi:", ""))
         if settings.RECOGNIZE_SOURCE == "themoviedb":
@@ -67,7 +87,8 @@ def search_by_id(mediaid: str,
             tmdbinfo = MediaChain().get_tmdbinfo_by_bangumiid(bangumiid=bangumiid)
             if tmdbinfo:
                 torrents = SearchChain().search_by_id(tmdbid=tmdbinfo.get("id"),
-                                                      mtype=mtype, area=area, season=season)
+                                                      mtype=media_type, area=area, season=media_season,
+                                                      sites=site_list, cache_local=True)
             else:
                 return schemas.Response(success=False, message="未识别到TMDB媒体信息")
         else:
@@ -75,12 +96,49 @@ def search_by_id(mediaid: str,
             doubaninfo = MediaChain().get_doubaninfo_by_bangumiid(bangumiid=bangumiid)
             if doubaninfo:
                 torrents = SearchChain().search_by_id(doubanid=doubaninfo.get("id"),
-                                                      mtype=mtype, area=area, season=season)
+                                                      mtype=media_type, area=area, season=media_season,
+                                                      sites=site_list, cache_local=True)
             else:
                 return schemas.Response(success=False, message="未识别到豆瓣媒体信息")
     else:
-        return schemas.Response(success=False, message="未知的媒体ID")
-
+        # 未知前缀，广播事件解析媒体信息
+        event_data = MediaRecognizeConvertEventData(
+            mediaid=mediaid,
+            convert_type=settings.RECOGNIZE_SOURCE
+        )
+        event = eventmanager.send_event(ChainEventType.MediaRecognizeConvert, event_data)
+        # 使用事件返回的上下文数据
+        if event and event.event_data:
+            event_data: MediaRecognizeConvertEventData = event.event_data
+            if event_data.media_dict:
+                search_id = event_data.media_dict.get("id")
+                if event_data.convert_type == "themoviedb":
+                    torrents = SearchChain().search_by_id(tmdbid=search_id, mtype=media_type, area=area,
+                                                          season=media_season, cache_local=True)
+                elif event_data.convert_type == "douban":
+                    torrents = SearchChain().search_by_id(doubanid=search_id, mtype=media_type, area=area,
+                                                          season=media_season, cache_local=True)
+        else:
+            if not title:
+                return schemas.Response(success=False, message="未知的媒体ID")
+            # 使用名称识别兜底
+            meta = MetaInfo(title)
+            if year:
+                meta.year = year
+            if media_type:
+                meta.type = media_type
+            if media_season:
+                meta.type = MediaType.TV
+                meta.begin_season = media_season
+            mediainfo = MediaChain().recognize_media(meta=meta)
+            if mediainfo:
+                if settings.RECOGNIZE_SOURCE == "themoviedb":
+                    torrents = SearchChain().search_by_id(tmdbid=mediainfo.tmdb_id, mtype=media_type, area=area,
+                                                          season=media_season, cache_local=True)
+                else:
+                    torrents = SearchChain().search_by_id(doubanid=mediainfo.douban_id, mtype=media_type, area=area,
+                                                          season=media_season, cache_local=True)
+    # 返回搜索结果
     if not torrents:
         return schemas.Response(success=False, message="未搜索到任何资源")
     else:
@@ -88,14 +146,16 @@ def search_by_id(mediaid: str,
 
 
 @router.get("/title", summary="模糊搜索资源", response_model=schemas.Response)
-def search_by_title(keyword: str = None,
-                    page: int = 0,
-                    site: int = None,
+def search_by_title(keyword: Optional[str] = None,
+                    page: Optional[int] = 0,
+                    sites: Optional[str] = None,
                     _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     根据名称模糊搜索站点资源，支持分页，关键词为空是返回首页资源
     """
-    torrents = SearchChain().search_by_title(title=keyword, page=page, site=site)
+    torrents = SearchChain().search_by_title(title=keyword, page=page,
+                                             sites=[int(site) for site in sites.split(",") if site] if sites else None,
+                                             cache_local=True)
     if not torrents:
         return schemas.Response(success=False, message="未搜索到任何资源")
     return schemas.Response(success=True, data=[torrent.to_dict() for torrent in torrents])

app/api/endpoints/site.py

@@ -1,4 +1,4 @@
-from typing import List, Any
+from typing import List, Any, Dict, Optional
 
 from fastapi import APIRouter, Depends, HTTPException
 from sqlalchemy.orm import Session
@@ -145,7 +145,7 @@ def update_cookie(
         site_id: int,
         username: str,
         password: str,
-        code: str = None,
+        code: Optional[str] = None,
         db: Session = Depends(get_db),
         _: schemas.TokenPayload = Depends(get_current_active_superuser)) -> Any:
     """
@@ -203,7 +203,7 @@ def read_userdata_latest(
 @router.get("/userdata/{site_id}", summary="查询某站点用户数据", response_model=schemas.Response)
 def read_userdata(
         site_id: int,
-        workdate: str = None,
+        workdate: Optional[str] = None,
         db: Session = Depends(get_db),
         _: schemas.TokenPayload = Depends(get_current_active_superuser)) -> Any:
     """
@@ -259,8 +259,41 @@ def site_icon(site_id: int,
     })
 
 
+@router.get("/category/{site_id}", summary="站点分类", response_model=List[schemas.SiteCategory])
+def site_category(site_id: int,
+                  db: Session = Depends(get_db),
+                  _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    获取站点分类
+    """
+    site = Site.get(db, site_id)
+    if not site:
+        raise HTTPException(
+            status_code=404,
+            detail=f"站点 {site_id} 不存在",
+        )
+    indexer = SitesHelper().get_indexer(site.domain)
+    if not indexer:
+        raise HTTPException(
+            status_code=404,
+            detail=f"站点 {site.domain} 不支持",
+        )
+    category: Dict[str, List[dict]] = indexer.get('category') or []
+    if not category:
+        return []
+    result = []
+    for cats in category.values():
+        for cat in cats:
+            if cat not in result:
+                result.append(cat)
+    return result
+
+
 @router.get("/resource/{site_id}", summary="站点资源", response_model=List[schemas.TorrentInfo])
 def site_resource(site_id: int,
+                  keyword: Optional[str] = None,
+                  cat: Optional[str] = None,
+                  page: Optional[int] = 0,
                   db: Session = Depends(get_db),
                   _: schemas.TokenPayload = Depends(get_current_active_superuser)) -> Any:
     """
@@ -272,7 +305,7 @@ def site_resource(site_id: int,
             status_code=404,
             detail=f"站点 {site_id} 不存在",
         )
-    torrents = TorrentsChain().browse(domain=site.domain)
+    torrents = TorrentsChain().browse(domain=site.domain, keyword=keyword, cat=cat, page=page)
     if not torrents:
         return []
     return [torrent.to_dict() for torrent in torrents]

app/api/endpoints/storage.py

@@ -1,6 +1,6 @@
 from datetime import datetime
 from pathlib import Path
-from typing import Any, List
+from typing import Any, List, Optional
 
 from fastapi import APIRouter, Depends, HTTPException
 from starlette.responses import FileResponse, Response
@@ -27,11 +27,12 @@ def qrcode(name: str, _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     qrcode_data, errmsg = StorageChain().generate_qrcode(name)
     if qrcode_data:
         return schemas.Response(success=True, data=qrcode_data, message=errmsg)
-    return schemas.Response(success=False)
+    return schemas.Response(success=False, message=errmsg)
 
 
 @router.get("/check/{name}", summary="二维码登录确认", response_model=schemas.Response)
-def check(name: str, ck: str = None, t: str = None, _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+def check(name: str, ck: Optional[str] = None, t: Optional[str] = None, 
+          _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     二维码登录确认
     """
@@ -57,7 +58,7 @@ def save(name: str,
 
 @router.post("/list", summary="所有目录和文件", response_model=List[schemas.FileItem])
 def list_files(fileitem: schemas.FileItem,
-               sort: str = 'updated_at',
+               sort: Optional[str] = 'updated_at',
                _: User = Depends(get_current_active_superuser)) -> Any:
     """
     查询当前目录下所有目录和文件
@@ -140,7 +141,7 @@ def image(fileitem: schemas.FileItem,
 @router.post("/rename", summary="重命名文件或目录", response_model=schemas.Response)
 def rename(fileitem: schemas.FileItem,
            new_name: str,
-           recursive: bool = False,
+           recursive: Optional[bool] = False,
            _: User = Depends(get_current_active_superuser)) -> Any:
     """
     重命名文件或目录

app/api/endpoints/subscribe.py

@@ -1,4 +1,4 @@
-from typing import List, Any
+from typing import List, Any, Annotated, Optional
 
 import cn2an
 from fastapi import APIRouter, Request, BackgroundTasks, Depends, HTTPException, Header
@@ -15,10 +15,11 @@ from app.db import get_db
 from app.db.models.subscribe import Subscribe
 from app.db.models.subscribehistory import SubscribeHistory
 from app.db.models.user import User
+from app.db.systemconfig_oper import SystemConfigOper
 from app.db.user_oper import get_current_active_user
 from app.helper.subscribe import SubscribeHelper
 from app.scheduler import Scheduler
-from app.schemas.types import MediaType, EventType
+from app.schemas.types import MediaType, EventType, SystemConfigKey
 
 router = APIRouter()
 
@@ -43,7 +44,7 @@ def read_subscribes(
 
 
 @router.get("/list", summary="查询所有订阅（API_TOKEN）", response_model=List[schemas.Subscribe])
-def list_subscribes(_: str = Depends(verify_apitoken)) -> Any:
+def list_subscribes(_: Annotated[str, Depends(verify_apitoken)]) -> Any:
     """
     查询所有订阅 API_TOKEN认证（?token=xxx）
     """
@@ -74,21 +75,12 @@ def create_subscribe(
         title = subscribe_in.name
     else:
         title = None
+    # 订阅用户
+    subscribe_in.username = current_user.name
     sid, message = SubscribeChain().add(mtype=mtype,
                                         title=title,
-                                        year=subscribe_in.year,
-                                        tmdbid=subscribe_in.tmdbid,
-                                        season=subscribe_in.season,
-                                        doubanid=subscribe_in.doubanid,
-                                        bangumiid=subscribe_in.bangumiid,
-                                        username=current_user.name,
-                                        best_version=subscribe_in.best_version,
-                                        save_path=subscribe_in.save_path,
-                                        search_imdbid=subscribe_in.search_imdbid,
-                                        custom_words=subscribe_in.custom_words,
-                                        media_category=subscribe_in.media_category,
-                                        filter_groups=subscribe_in.filter_groups,
-                                        exist_ok=True)
+                                        exist_ok=True,
+                                        **subscribe_in.dict())
     return schemas.Response(
         success=bool(sid), message=message, data={"id": sid}
     )
@@ -108,6 +100,7 @@ def update_subscribe(
     if not subscribe:
         return schemas.Response(success=False, message="订阅不存在")
     # 避免更新缺失集数
+    old_subscribe_dict = subscribe.to_dict()
     subscribe_dict = subscribe_in.dict()
     if not subscribe_in.lack_episode:
         # 没有缺失集数时，缺失集数清空，避免更新为0
@@ -125,7 +118,8 @@ def update_subscribe(
     # 发送订阅调整事件
     eventmanager.send_event(EventType.SubscribeModified, {
         "subscribe_id": subscribe.id,
-        "subscribe_info": subscribe_dict,
+        "old_subscribe_info": old_subscribe_dict,
+        "subscribe_info": subscribe.to_dict(),
     })
     return schemas.Response(success=True)
 
@@ -145,23 +139,29 @@ def update_subscribe_status(
     valid_states = ["R", "P", "S"]
     if state not in valid_states:
         return schemas.Response(success=False, message="无效的订阅状态")
+    old_subscribe_dict = subscribe.to_dict()
     subscribe.update(db, {
         "state": state
     })
+    # 发送订阅调整事件
+    eventmanager.send_event(EventType.SubscribeModified, {
+        "subscribe_id": subscribe.id,
+        "old_subscribe_info": old_subscribe_dict,
+        "subscribe_info": subscribe.to_dict(),
+    })
     return schemas.Response(success=True)
 
 
 @router.get("/media/{mediaid}", summary="查询订阅", response_model=schemas.Subscribe)
 def subscribe_mediaid(
         mediaid: str,
-        season: int = None,
-        title: str = None,
+        season: Optional[int] = None,
+        title: Optional[str] = None,
         db: Session = Depends(get_db),
         _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     根据 TMDBID/豆瓣ID/BangumiId 查询订阅 tmdb:/douban:
     """
-    result = None
     title_check = False
     if mediaid.startswith("tmdb:"):
         tmdbid = mediaid[5:]
@@ -182,6 +182,10 @@ def subscribe_mediaid(
         result = Subscribe.get_by_bangumiid(db, int(bangumiid))
         if not result and title:
             title_check = True
+    else:
+        result = Subscribe.get_by_mediaid(db, mediaid)
+        if not result and title:
+            title_check = True
     # 使用名称检查订阅
     if title_check and title:
         meta = MetaInfo(title)
@@ -212,11 +216,18 @@ def reset_subscribes(
     """
     subscribe = Subscribe.get(db, subid)
     if subscribe:
+        old_subscribe_dict = subscribe.to_dict()
         subscribe.update(db, {
             "note": [],
             "lack_episode": subscribe.total_episode,
             "state": "R"
         })
+        # 发送订阅调整事件
+        eventmanager.send_event(EventType.SubscribeModified, {
+            "subscribe_id": subscribe.id,
+            "old_subscribe_info": old_subscribe_dict,
+            "subscribe_info": subscribe.to_dict(),
+        })
         return schemas.Response(success=True)
     return schemas.Response(success=False, message="订阅不存在")
 
@@ -273,7 +284,7 @@ def search_subscribe(
 @router.delete("/media/{mediaid}", summary="删除订阅", response_model=schemas.Response)
 def delete_subscribe_by_mediaid(
         mediaid: str,
-        season: int = None,
+        season: Optional[int] = None,
         db: Session = Depends(get_db),
         _: schemas.TokenPayload = Depends(verify_token)
 ) -> Any:
@@ -294,6 +305,10 @@ def delete_subscribe_by_mediaid(
         subscribe = Subscribe().get_by_doubanid(db, doubanid)
         if subscribe:
             delete_subscribes.append(subscribe)
+    else:
+        subscribe = Subscribe().get_by_mediaid(db, mediaid)
+        if subscribe:
+            delete_subscribes.append(subscribe)
     for subscribe in delete_subscribes:
         Subscribe().delete(db, subscribe.id)
         # 发送事件
@@ -306,7 +321,7 @@ def delete_subscribe_by_mediaid(
 
 @router.post("/seerr", summary="OverSeerr/JellySeerr通知订阅", response_model=schemas.Response)
 async def seerr_subscribe(request: Request, background_tasks: BackgroundTasks,
-                          authorization: str = Header(None)) -> Any:
+                          authorization: Annotated[str | None, Header()] = None) -> Any:
     """
     Jellyseerr/Overseerr网络勾子通知订阅
     """
@@ -360,8 +375,8 @@ async def seerr_subscribe(request: Request, background_tasks: BackgroundTasks,
 @router.get("/history/{mtype}", summary="查询订阅历史", response_model=List[schemas.Subscribe])
 def subscribe_history(
         mtype: str,
-        page: int = 1,
-        count: int = 30,
+        page: Optional[int] = 1,
+        count: Optional[int] = 30,
         db: Session = Depends(get_db),
         _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
@@ -386,9 +401,9 @@ def delete_subscribe(
 @router.get("/popular", summary="热门订阅（基于用户共享数据）", response_model=List[schemas.MediaInfo])
 def popular_subscribes(
         stype: str,
-        page: int = 1,
-        count: int = 30,
-        min_sub: int = None,
+        page: Optional[int] = 1,
+        count: Optional[int] = 30,
+        min_sub: Optional[int] = None,
         _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     查询热门订阅
@@ -497,11 +512,47 @@ def subscribe_fork(
     return result
 
 
+@router.get("/follow", summary="查询已Follow的订阅分享人", response_model=List[str])
+def followed_subscribers(_: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    查询已Follow的订阅分享人
+    """
+    return SystemConfigOper().get(SystemConfigKey.FollowSubscribers) or []
+
+
+@router.post("/follow", summary="Follow订阅分享人", response_model=schemas.Response)
+def follow_subscriber(
+        share_uid: Optional[str] = None,
+        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    Follow订阅分享人
+    """
+    subscribers = SystemConfigOper().get(SystemConfigKey.FollowSubscribers) or []
+    if share_uid and share_uid not in subscribers:
+        subscribers.append(share_uid)
+        SystemConfigOper().set(SystemConfigKey.FollowSubscribers, subscribers)
+    return schemas.Response(success=True)
+
+
+@router.delete("/follow", summary="取消Follow订阅分享人", response_model=schemas.Response)
+def unfollow_subscriber(
+        share_uid: Optional[str] = None,
+        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    取消Follow订阅分享人
+    """
+    subscribers = SystemConfigOper().get(SystemConfigKey.FollowSubscribers) or []
+    if share_uid and share_uid in subscribers:
+        subscribers.remove(share_uid)
+        SystemConfigOper().set(SystemConfigKey.FollowSubscribers, subscribers)
+    return schemas.Response(success=True)
+
+
 @router.get("/shares", summary="查询分享的订阅", response_model=List[schemas.SubscribeShare])
 def popular_subscribes(
-        name: str = None,
-        page: int = 1,
-        count: int = 30,
+        name: Optional[str] = None,
+        page: Optional[int] = 1,
+        count: Optional[int] = 30,
         _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     查询分享的订阅

app/api/endpoints/system.py

@@ -5,9 +5,10 @@ import tempfile
 from collections import deque
 from datetime import datetime
 from pathlib import Path
-from typing import Optional, Union
+from typing import Optional, Union, Annotated
 
 import aiofiles
+import pillow_avif  # noqa 用于自动注册AVIF支持
 from PIL import Image
 from fastapi import APIRouter, Depends, HTTPException, Header, Request, Response
 from fastapi.responses import StreamingResponse
@@ -23,10 +24,11 @@ from app.db.models import User
 from app.db.systemconfig_oper import SystemConfigOper
 from app.db.user_oper import get_current_active_superuser
 from app.helper.mediaserver import MediaServerHelper
-from app.helper.message import MessageHelper
+from app.helper.message import MessageHelper, MessageQueueManager
 from app.helper.progress import ProgressHelper
 from app.helper.rule import RuleHelper
 from app.helper.sites import SitesHelper
+from app.helper.subscribe import SubscribeHelper
 from app.log import logger
 from app.monitor import Monitor
 from app.scheduler import Scheduler
@@ -50,7 +52,6 @@ def fetch_image(
     """
     处理图片缓存逻辑，支持HTTP缓存和磁盘缓存
     """
-
     if not url:
         raise HTTPException(status_code=404, detail="URL not provided")
 
@@ -68,6 +69,10 @@ def fetch_image(
         sanitized_path = SecurityUtils.sanitize_url_path(url)
         cache_path = settings.CACHE_PATH / "images" / sanitized_path
 
+        # 没有文件类型，则添加后缀，在恶意文件类型和实际需求下的折衷选择
+        if not cache_path.suffix:
+            cache_path = cache_path.with_suffix(".jpg")
+
         # 确保缓存路径和文件类型合法
         if not SecurityUtils.is_safe_path(settings.CACHE_PATH, cache_path, settings.SECURITY_IMAGE_SUFFIXES):
             raise HTTPException(status_code=400, detail="Invalid cache path or file type")
@@ -88,7 +93,8 @@ def fetch_image(
     # 请求远程图片
     referer = "https://movie.douban.com/" if "doubanio.com" in url else None
     proxies = settings.PROXY if proxy else None
-    response = RequestUtils(ua=settings.USER_AGENT, proxies=proxies, referer=referer).get_res(url=url)
+    response = RequestUtils(ua=settings.USER_AGENT, proxies=proxies, referer=referer,
+                            accept_type="image/avif,image/webp,image/apng,*/*").get_res(url=url)
     if not response:
         raise HTTPException(status_code=502, detail="Failed to fetch the image from the remote server")
 
@@ -136,7 +142,7 @@ def fetch_image(
 def proxy_img(
         imgurl: str,
         proxy: bool = False,
-        if_none_match: Optional[str] = Header(None),
+        if_none_match: Annotated[str | None, Header()] = None,
         _: schemas.TokenPayload = Depends(verify_resource_token)
 ) -> Response:
     """
@@ -153,7 +159,7 @@ def proxy_img(
 @router.get("/cache/image", summary="图片缓存")
 def cache_img(
         url: str,
-        if_none_match: Optional[str] = Header(None),
+        if_none_match: Annotated[str | None, Header()] = None,
         _: schemas.TokenPayload = Depends(verify_resource_token)
 ) -> Response:
     """
@@ -174,9 +180,10 @@ def get_global_setting():
         exclude={"SECRET_KEY", "RESOURCE_SECRET_KEY", "API_TOKEN", "TMDB_API_KEY", "TVDB_API_KEY", "FANART_API_KEY",
                  "COOKIECLOUD_KEY", "COOKIECLOUD_PASSWORD", "GITHUB_TOKEN", "REPO_GITHUB_TOKEN"}
     )
-    # 追加用户唯一ID
+    # 追加用户唯一ID和订阅分享管理权限
     info.update({
-        "USER_UNIQUE_ID": SystemUtils.generate_user_unique_id()
+        "USER_UNIQUE_ID": SubscribeHelper().get_user_uuid(),
+        "SUBSCRIBE_SHARE_MANAGE": SubscribeHelper().is_admin_user(),
     })
     return schemas.Response(success=True,
                             data=info)
@@ -276,6 +283,9 @@ def set_setting(key: str, value: Union[list, dict, bool, int, str] = None,
         success, message = settings.update_setting(key=key, value=value)
         return schemas.Response(success=success, message=message)
     elif key in {item.value for item in SystemConfigKey}:
+        if isinstance(value, list):
+            value = list(filter(None, value))
+            value = value if value else None
         SystemConfigOper().set(key, value)
         return schemas.Response(success=True)
     else:
@@ -283,7 +293,8 @@ def set_setting(key: str, value: Union[list, dict, bool, int, str] = None,
 
 
 @router.get("/message", summary="实时消息")
-async def get_message(request: Request, role: str = "system", _: schemas.TokenPayload = Depends(verify_resource_token)):
+async def get_message(request: Request, role: Optional[str] = "system",
+                      _: schemas.TokenPayload = Depends(verify_resource_token)):
     """
     实时获取系统消息，返回格式为SSE
     """
@@ -304,7 +315,7 @@ async def get_message(request: Request, role: str = "system", _: schemas.TokenPa
 
 
 @router.get("/logging", summary="实时日志")
-async def get_logging(request: Request, length: int = 50, logfile: str = "moviepilot.log",
+async def get_logging(request: Request, length: Optional[int] = 50, logfile: Optional[str] = "moviepilot.log",
                       _: schemas.TokenPayload = Depends(verify_resource_token)):
     """
     实时获取系统日志
@@ -376,7 +387,7 @@ def latest_version(_: schemas.TokenPayload = Depends(verify_token)):
 @router.get("/ruletest", summary="过滤规则测试", response_model=schemas.Response)
 def ruletest(title: str,
              rulegroup_name: str,
-             subtitle: str = None,
+             subtitle: Optional[str] = None,
              _: schemas.TokenPayload = Depends(verify_token)):
     """
     过滤规则测试，规则类型 1-订阅，2-洗版，3-搜索
@@ -474,6 +485,7 @@ def reload_module(_: User = Depends(get_current_active_superuser)):
     """
     重新加载模块（仅管理员）
     """
+    MessageQueueManager().init_config()
     ModuleManager().reload()
     Scheduler().init()
     Monitor().init()
@@ -494,7 +506,7 @@ def run_scheduler(jobid: str,
 
 @router.get("/runscheduler2", summary="运行服务（API_TOKEN）", response_model=schemas.Response)
 def run_scheduler2(jobid: str,
-                   _: str = Depends(verify_apitoken)):
+                   _: Annotated[str, Depends(verify_apitoken)]):
     """
     执行命令（API_TOKEN认证）
     """

app/api/endpoints/tmdb.py

@@ -1,9 +1,8 @@
-from typing import List, Any
+from typing import List, Any, Optional
 
 from fastapi import APIRouter, Depends
 
 from app import schemas
-from app.chain.recommend import RecommendChain
 from app.chain.tmdb import TmdbChain
 from app.core.security import verify_token
 from app.schemas.types import MediaType
@@ -62,8 +61,8 @@ def tmdb_recommend(tmdbid: int,
 
 @router.get("/collection/{collection_id}", summary="系列合集详情", response_model=List[schemas.MediaInfo])
 def tmdb_collection(collection_id: int,
-                    page: int = 1,
-                    count: int = 20,
+                    page: Optional[int] = 1,
+                    count: Optional[int] = 20,
                     _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     根据合集ID查询合集详情
@@ -77,7 +76,7 @@ def tmdb_collection(collection_id: int,
 @router.get("/credits/{tmdbid}/{type_name}", summary="演员阵容", response_model=List[schemas.MediaPerson])
 def tmdb_credits(tmdbid: int,
                  type_name: str,
-                 page: int = 1,
+                 page: Optional[int] = 1,
                  _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     根据TMDBID查询演员阵容，type_name: 电影/电视剧
@@ -103,7 +102,7 @@ def tmdb_person(person_id: int,
 
 @router.get("/person/credits/{person_id}", summary="人物参演作品", response_model=List[schemas.MediaInfo])
 def tmdb_person_credits(person_id: int,
-                        page: int = 1,
+                        page: Optional[int] = 1,
                         _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     根据人物ID查询人物参演作品
@@ -114,49 +113,10 @@ def tmdb_person_credits(person_id: int,
     return []
 
 
-@router.get("/movies", summary="TMDB电影", response_model=List[schemas.MediaInfo])
-def tmdb_movies(sort_by: str = "popularity.desc",
-                with_genres: str = "",
-                with_original_language: str = "",
-                page: int = 1,
-                _: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    浏览TMDB电影信息
-    """
-    return RecommendChain().tmdb_movies(sort_by=sort_by,
-                                        with_genres=with_genres,
-                                        with_original_language=with_original_language,
-                                        page=page)
-
-
-@router.get("/tvs", summary="TMDB剧集", response_model=List[schemas.MediaInfo])
-def tmdb_tvs(sort_by: str = "popularity.desc",
-             with_genres: str = "",
-             with_original_language: str = "",
-             page: int = 1,
-             _: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    浏览TMDB剧集信息
-    """
-    return RecommendChain().tmdb_tvs(sort_by=sort_by,
-                                     with_genres=with_genres,
-                                     with_original_language=with_original_language,
-                                     page=page)
-
-
-@router.get("/trending", summary="TMDB流行趋势", response_model=List[schemas.MediaInfo])
-def tmdb_trending(page: int = 1,
-                  _: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    TMDB流行趋势
-    """
-    return RecommendChain().tmdb_trending(page=page)
-
-
 @router.get("/{tmdbid}/{season}", summary="TMDB季所有集", response_model=List[schemas.TmdbEpisode])
-def tmdb_season_episodes(tmdbid: int, season: int,
+def tmdb_season_episodes(tmdbid: int, season: int, episode_group: Optional[str] = None,
                          _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     根据TMDBID查询某季的所有信信息
     """
-    return TmdbChain().tmdb_episodes(tmdbid=tmdbid, season=season)
+    return TmdbChain().tmdb_episodes(tmdbid=tmdbid, season=season, episode_group=episode_group)

app/api/endpoints/transfer.py

@@ -1,5 +1,5 @@
 from pathlib import Path
-from typing import Any, List
+from typing import Any, List, Annotated, Optional
 
 from fastapi import APIRouter, Depends
 from sqlalchemy.orm import Session
@@ -69,7 +69,7 @@ def remove_queue(fileitem: schemas.FileItem, _: schemas.TokenPayload = Depends(v
 
 @router.post("/manual", summary="手动转移", response_model=schemas.Response)
 def manual_transfer(transer_item: ManualTransferItem,
-                    background: bool = False,
+                    background: Optional[bool] = False,
                     db: Session = Depends(get_db),
                     _: schemas.TokenPayload = Depends(get_current_active_superuser)) -> Any:
     """
@@ -146,6 +146,7 @@ def manual_transfer(transer_item: ManualTransferItem,
         doubanid=transer_item.doubanid,
         mtype=mtype,
         season=transer_item.season,
+        episode_group=transer_item.episode_group,
         transfer_type=transer_item.transfer_type,
         epformat=epformat,
         min_filesize=transer_item.min_filesize,
@@ -165,7 +166,7 @@ def manual_transfer(transer_item: ManualTransferItem,
 
 
 @router.get("/now", summary="立即执行下载器文件整理", response_model=schemas.Response)
-def now(_: str = Depends(verify_apitoken)) -> Any:
+def now(_: Annotated[str, Depends(verify_apitoken)]) -> Any:
     """
     立即执行下载器文件整理 API_TOKEN认证（?token=xxx）
     """

app/api/endpoints/webhook.py

@@ -1,4 +1,4 @@
-from typing import Any
+from typing import Any, Annotated
 
 from fastapi import APIRouter, BackgroundTasks, Request, Depends
 
@@ -19,7 +19,7 @@ def start_webhook_chain(body: Any, form: Any, args: Any):
 @router.post("/", summary="Webhook消息响应", response_model=schemas.Response)
 async def webhook_message(background_tasks: BackgroundTasks,
                           request: Request,
-                          _: str = Depends(verify_apitoken)
+                          _: Annotated[str, Depends(verify_apitoken)]
                           ) -> Any:
     """
     Webhook响应，配置请求中需要添加参数：token=API_TOKEN&source=媒体服务器名
@@ -33,7 +33,7 @@ async def webhook_message(background_tasks: BackgroundTasks,
 
 @router.get("/", summary="Webhook消息响应", response_model=schemas.Response)
 def webhook_message(background_tasks: BackgroundTasks,
-                    request: Request, _: str = Depends(verify_apitoken)) -> Any:
+                    request: Request, _: Annotated[str, Depends(verify_apitoken)]) -> Any:
     """
     Webhook响应，配置请求中需要添加参数：token=API_TOKEN&source=媒体服务器名
     """

app/api/endpoints/workflow.py

@@ -0,0 +1,162 @@
+from datetime import datetime
+from typing import List, Any, Optional
+
+from fastapi import APIRouter, Depends
+from sqlalchemy.orm import Session
+
+from app import schemas
+from app.core.config import global_vars
+from app.core.workflow import WorkFlowManager
+from app.db import get_db
+from app.db.models.workflow import Workflow
+from app.db.systemconfig_oper import SystemConfigOper
+from app.db.user_oper import get_current_active_user
+from app.chain.workflow import WorkflowChain
+from app.scheduler import Scheduler
+
+router = APIRouter()
+
+
+@router.get("/", summary="所有工作流", response_model=List[schemas.Workflow])
+def list_workflows(db: Session = Depends(get_db),
+                   _: schemas.TokenPayload = Depends(get_current_active_user)) -> Any:
+    """
+    获取工作流列表
+    """
+    return Workflow.list(db)
+
+
+@router.post("/", summary="创建工作流", response_model=schemas.Response)
+def create_workflow(workflow: schemas.Workflow,
+                    db: Session = Depends(get_db),
+                    _: schemas.TokenPayload = Depends(get_current_active_user)) -> Any:
+    """
+    创建工作流
+    """
+    if Workflow.get_by_name(db, workflow.name):
+        return schemas.Response(success=False, message="已存在相同名称的工作流")
+    if not workflow.add_time:
+        workflow.add_time = datetime.strftime(datetime.now(), "%Y-%m-%d %H:%M:%S")
+    if not workflow.state:
+        workflow.state = "P"
+    Workflow(**workflow.dict()).create(db)
+    return schemas.Response(success=True, message="创建工作流成功")
+
+
+@router.get("/actions", summary="所有动作", response_model=List[dict])
+def list_actions(_: schemas.TokenPayload = Depends(get_current_active_user)) -> Any:
+    """
+    获取所有动作
+    """
+    return WorkFlowManager().list_actions()
+
+
+@router.get("/{workflow_id}", summary="工作流详情", response_model=schemas.Workflow)
+def get_workflow(workflow_id: int,
+                 db: Session = Depends(get_db),
+                 _: schemas.TokenPayload = Depends(get_current_active_user)) -> Any:
+    """
+    获取工作流详情
+    """
+    return Workflow.get(db, workflow_id)
+
+
+@router.put("/{workflow_id}", summary="更新工作流", response_model=schemas.Response)
+def update_workflow(workflow: schemas.Workflow,
+                    db: Session = Depends(get_db),
+                    _: schemas.TokenPayload = Depends(get_current_active_user)) -> Any:
+    """
+    更新工作流
+    """
+    wf = Workflow.get(db, workflow.id)
+    if not wf:
+        return schemas.Response(success=False, message="工作流不存在")
+    wf.update(db, workflow.dict())
+    return schemas.Response(success=True, message="更新成功")
+
+
+@router.delete("/{workflow_id}", summary="删除工作流", response_model=schemas.Response)
+def delete_workflow(workflow_id: int,
+                    db: Session = Depends(get_db),
+                    _: schemas.TokenPayload = Depends(get_current_active_user)) -> Any:
+    """
+    删除工作流
+    """
+    workflow = Workflow.get(db, workflow_id)
+    if not workflow:
+        return schemas.Response(success=False, message="工作流不存在")
+    # 删除定时任务
+    Scheduler().remove_workflow_job(workflow)
+    # 删除工作流
+    Workflow.delete(db, workflow_id)
+    # 删除缓存
+    SystemConfigOper().delete(f"WorkflowCache-{workflow_id}")
+    return schemas.Response(success=True, message="删除成功")
+
+
+@router.post("/{workflow_id}/run", summary="执行工作流", response_model=schemas.Response)
+def run_workflow(workflow_id: int,
+                 from_begin: Optional[bool] = True,
+                 _: schemas.TokenPayload = Depends(get_current_active_user)) -> Any:
+    """
+    执行工作流
+    """
+    state, errmsg = WorkflowChain().process(workflow_id, from_begin=from_begin)
+    if not state:
+        return schemas.Response(success=False, message=errmsg)
+    return schemas.Response(success=True)
+
+
+@router.post("/{workflow_id}/start", summary="启用工作流", response_model=schemas.Response)
+def start_workflow(workflow_id: int,
+                   db: Session = Depends(get_db),
+                   _: schemas.TokenPayload = Depends(get_current_active_user)) -> Any:
+    """
+    启用工作流
+    """
+    workflow = Workflow.get(db, workflow_id)
+    if not workflow:
+        return schemas.Response(success=False, message="工作流不存在")
+    # 添加定时任务
+    Scheduler().update_workflow_job(workflow)
+    # 更新状态
+    workflow.update_state(db, workflow_id, "W")
+    return schemas.Response(success=True)
+
+
+@router.post("/{workflow_id}/pause", summary="停用工作流", response_model=schemas.Response)
+def pause_workflow(workflow_id: int,
+                   db: Session = Depends(get_db),
+                   _: schemas.TokenPayload = Depends(get_current_active_user)) -> Any:
+    """
+    停用工作流
+    """
+    workflow = Workflow.get(db, workflow_id)
+    if not workflow:
+        return schemas.Response(success=False, message="工作流不存在")
+    # 删除定时任务
+    Scheduler().remove_workflow_job(workflow)
+    # 停止工作流
+    global_vars.stop_workflow(workflow_id)
+    # 更新状态
+    workflow.update_state(db, workflow_id, "P")
+    return schemas.Response(success=True)
+
+
+@router.post("/{workflow_id}/reset", summary="重置工作流", response_model=schemas.Response)
+def reset_workflow(workflow_id: int,
+                   db: Session = Depends(get_db),
+                   _: schemas.TokenPayload = Depends(get_current_active_user)) -> Any:
+    """
+    重置工作流
+    """
+    workflow = Workflow.get(db, workflow_id)
+    if not workflow:
+        return schemas.Response(success=False, message="工作流不存在")
+    # 停止工作流
+    global_vars.stop_workflow(workflow_id)
+    # 重置工作流
+    workflow.reset(db, workflow_id, reset_count=True)
+    # 删除缓存
+    SystemConfigOper().delete(f"WorkflowCache-{workflow_id}")
+    return schemas.Response(success=True)

app/api/servarr.py

@@ -1,4 +1,4 @@
-from typing import Any, List
+from typing import Any, List, Annotated
 
 from fastapi import APIRouter, HTTPException, Depends
 from sqlalchemy.orm import Session
@@ -18,7 +18,7 @@ arr_router = APIRouter(tags=['servarr'])
 
 
 @arr_router.get("/system/status", summary="系统状态")
-def arr_system_status(_: str = Depends(verify_apikey)) -> Any:
+def arr_system_status(_: Annotated[str, Depends(verify_apikey)]) -> Any:
     """
     模拟Radarr、Sonarr系统状态
     """
@@ -72,7 +72,7 @@ def arr_system_status(_: str = Depends(verify_apikey)) -> Any:
 
 
 @arr_router.get("/qualityProfile", summary="质量配置")
-def arr_qualityProfile(_: str = Depends(verify_apikey)) -> Any:
+def arr_qualityProfile(_: Annotated[str, Depends(verify_apikey)]) -> Any:
     """
     模拟Radarr、Sonarr质量配置
     """
@@ -113,7 +113,7 @@ def arr_qualityProfile(_: str = Depends(verify_apikey)) -> Any:
 
 
 @arr_router.get("/rootfolder", summary="根目录")
-def arr_rootfolder(_: str = Depends(verify_apikey)) -> Any:
+def arr_rootfolder(_: Annotated[str, Depends(verify_apikey)]) -> Any:
     """
     模拟Radarr、Sonarr根目录
     """
@@ -129,7 +129,7 @@ def arr_rootfolder(_: str = Depends(verify_apikey)) -> Any:
 
 
 @arr_router.get("/tag", summary="标签")
-def arr_tag(_: str = Depends(verify_apikey)) -> Any:
+def arr_tag(_: Annotated[str, Depends(verify_apikey)]) -> Any:
     """
     模拟Radarr、Sonarr标签
     """
@@ -142,7 +142,7 @@ def arr_tag(_: str = Depends(verify_apikey)) -> Any:
 
 
 @arr_router.get("/languageprofile", summary="语言")
-def arr_languageprofile(_: str = Depends(verify_apikey)) -> Any:
+def arr_languageprofile(_: Annotated[str, Depends(verify_apikey)]) -> Any:
     """
     模拟Radarr、Sonarr语言
     """
@@ -168,7 +168,7 @@ def arr_languageprofile(_: str = Depends(verify_apikey)) -> Any:
 
 
 @arr_router.get("/movie", summary="所有订阅电影", response_model=List[schemas.RadarrMovie])
-def arr_movies(_: str = Depends(verify_apikey), db: Session = Depends(get_db)) -> Any:
+def arr_movies(_: Annotated[str, Depends(verify_apikey)], db: Session = Depends(get_db)) -> Any:
     """
     查询Rardar电影
     """
@@ -259,7 +259,7 @@ def arr_movies(_: str = Depends(verify_apikey), db: Session = Depends(get_db)) -
 
 
 @arr_router.get("/movie/lookup", summary="查询电影", response_model=List[schemas.RadarrMovie])
-def arr_movie_lookup(term: str, db: Session = Depends(get_db), _: str = Depends(verify_apikey)) -> Any:
+def arr_movie_lookup(term: str, _: Annotated[str, Depends(verify_apikey)], db: Session = Depends(get_db)) -> Any:
     """
     查询Rardar电影 term: `tmdb:${id}`
     存在和不存在均不能返回错误
@@ -305,7 +305,7 @@ def arr_movie_lookup(term: str, db: Session = Depends(get_db), _: str = Depends(
 
 
 @arr_router.get("/movie/{mid}", summary="电影订阅详情", response_model=schemas.RadarrMovie)
-def arr_movie(mid: int, db: Session = Depends(get_db), _: str = Depends(verify_apikey)) -> Any:
+def arr_movie(mid: int, _: Annotated[str, Depends(verify_apikey)], db: Session = Depends(get_db)) -> Any:
     """
     查询Rardar电影订阅
     """
@@ -331,9 +331,9 @@ def arr_movie(mid: int, db: Session = Depends(get_db), _: str = Depends(verify_a
 
 
 @arr_router.post("/movie", summary="新增电影订阅")
-def arr_add_movie(movie: RadarrMovie,
-                  db: Session = Depends(get_db),
-                  _: str = Depends(verify_apikey)
+def arr_add_movie(_: Annotated[str, Depends(verify_apikey)],
+                  movie: RadarrMovie,
+                  db: Session = Depends(get_db)
                   ) -> Any:
     """
     新增Rardar电影订阅
@@ -362,7 +362,7 @@ def arr_add_movie(movie: RadarrMovie,
 
 
 @arr_router.delete("/movie/{mid}", summary="删除电影订阅", response_model=schemas.Response)
-def arr_remove_movie(mid: int, db: Session = Depends(get_db), _: str = Depends(verify_apikey)) -> Any:
+def arr_remove_movie(mid: int, _: Annotated[str, Depends(verify_apikey)], db: Session = Depends(get_db)) -> Any:
     """
     删除Rardar电影订阅
     """
@@ -378,7 +378,7 @@ def arr_remove_movie(mid: int, db: Session = Depends(get_db), _: str = Depends(v
 
 
 @arr_router.get("/series", summary="所有剧集", response_model=List[schemas.SonarrSeries])
-def arr_series(_: str = Depends(verify_apikey), db: Session = Depends(get_db)) -> Any:
+def arr_series(_: Annotated[str, Depends(verify_apikey)], db: Session = Depends(get_db)) -> Any:
     """
     查询Sonarr剧集
     """
@@ -514,7 +514,7 @@ def arr_series(_: str = Depends(verify_apikey), db: Session = Depends(get_db)) -
 
 
 @arr_router.get("/series/lookup", summary="查询剧集")
-def arr_series_lookup(term: str, db: Session = Depends(get_db), _: str = Depends(verify_apikey)) -> Any:
+def arr_series_lookup(term: str, _: Annotated[str, Depends(verify_apikey)], db: Session = Depends(get_db)) -> Any:
     """
     查询Sonarr剧集 term: `tvdb:${id}` title
     """
@@ -603,7 +603,7 @@ def arr_series_lookup(term: str, db: Session = Depends(get_db), _: str = Depends
 
 
 @arr_router.get("/series/{tid}", summary="剧集详情")
-def arr_serie(tid: int, db: Session = Depends(get_db), _: str = Depends(verify_apikey)) -> Any:
+def arr_serie(tid: int, _: Annotated[str, Depends(verify_apikey)], db: Session = Depends(get_db)) -> Any:
     """
     查询Sonarr剧集
     """
@@ -638,8 +638,8 @@ def arr_serie(tid: int, db: Session = Depends(get_db), _: str = Depends(verify_a
 
 @arr_router.post("/series", summary="新增剧集订阅")
 def arr_add_series(tv: schemas.SonarrSeries,
-                   db: Session = Depends(get_db),
-                   _: str = Depends(verify_apikey)) -> Any:
+                   _: Annotated[str, Depends(verify_apikey)],
+                   db: Session = Depends(get_db)) -> Any:
     """
     新增Sonarr剧集订阅
     """
@@ -680,8 +680,16 @@ def arr_add_series(tv: schemas.SonarrSeries,
         )
 
 
+@arr_router.put("/series", summary="更新剧集订阅")
+def arr_update_series(tv: schemas.SonarrSeries) -> Any:
+    """
+    更新Sonarr剧集订阅
+    """
+    return arr_add_series(tv)
+
+
 @arr_router.delete("/series/{tid}", summary="删除剧集订阅")
-def arr_remove_series(tid: int, db: Session = Depends(get_db), _: str = Depends(verify_apikey)) -> Any:
+def arr_remove_series(tid: int, _: Annotated[str, Depends(verify_apikey)], db: Session = Depends(get_db)) -> Any:
     """
     删除Sonarr剧集订阅
     """

app/chain/__init__.py

@@ -7,7 +7,6 @@ from pathlib import Path
 from typing import Optional, Any, Tuple, List, Set, Union, Dict
 
 from qbittorrentapi import TorrentFilesList
-from ruamel.yaml import CommentedMap
 from transmission_rpc import File
 
 from app.core.config import settings
@@ -17,7 +16,7 @@ from app.core.meta import MetaBase
 from app.core.module import ModuleManager
 from app.db.message_oper import MessageOper
 from app.db.user_oper import UserOper
-from app.helper.message import MessageHelper
+from app.helper.message import MessageHelper, MessageQueueManager
 from app.helper.service import ServiceConfigHelper
 from app.log import logger
 from app.schemas import TransferInfo, TransferTorrent, ExistMediaInfo, DownloadingTorrent, CommingMessage, Notification, \
@@ -39,6 +38,9 @@ class ChainBase(metaclass=ABCMeta):
         self.eventmanager = EventManager()
         self.messageoper = MessageOper()
         self.messagehelper = MessageHelper()
+        self.messagequeue = MessageQueueManager(
+            send_callback=self.run_module
+        )
         self.useroper = UserOper()
 
     @staticmethod
@@ -77,7 +79,7 @@ class ChainBase(metaclass=ABCMeta):
         """
         cache_path = settings.TEMP_PATH / filename
         if cache_path.exists():
-            Path(cache_path).unlink()
+            cache_path.unlink()
 
     def run_module(self, method: str, *args, **kwargs) -> Any:
         """
@@ -92,10 +94,10 @@ class ChainBase(metaclass=ABCMeta):
             if isinstance(ret, tuple):
                 return all(value is None for value in ret)
             else:
-                return result is None
+                return ret is None
 
-        logger.debug(f"请求模块执行：{method} ...")
         result = None
+        logger.debug(f"请求模块执行：{method} ...")
         modules = self.modulemanager.get_running_modules(method)
         # 按优先级排序
         modules = sorted(modules, key=lambda x: x.get_priority())
@@ -144,10 +146,11 @@ class ChainBase(metaclass=ABCMeta):
         return result
 
     def recognize_media(self, meta: MetaBase = None,
-                        mtype: MediaType = None,
-                        tmdbid: int = None,
-                        doubanid: str = None,
-                        bangumiid: int = None,
+                        mtype: Optional[MediaType] = None,
+                        tmdbid: Optional[int] = None,
+                        doubanid: Optional[str] = None,
+                        bangumiid: Optional[int] = None,
+                        episode_group: Optional[str] = None,
                         cache: bool = True) -> Optional[MediaInfo]:
         """
         识别媒体信息，不含Fanart图片
@@ -156,6 +159,7 @@ class ChainBase(metaclass=ABCMeta):
         :param tmdbid:   tmdbid
         :param doubanid: 豆瓣ID
         :param bangumiid: BangumiID
+        :param episode_group: 剧集组
         :param cache:    是否使用缓存
         :return: 识别的媒体信息，包括剧集信息
         """
@@ -171,10 +175,11 @@ class ChainBase(metaclass=ABCMeta):
             doubanid = None
             bangumiid = None
         return self.run_module("recognize_media", meta=meta, mtype=mtype,
-                               tmdbid=tmdbid, doubanid=doubanid, bangumiid=bangumiid, cache=cache)
+                               tmdbid=tmdbid, doubanid=doubanid, bangumiid=bangumiid,
+                               episode_group=episode_group, cache=cache)
 
-    def match_doubaninfo(self, name: str, imdbid: str = None,
-                         mtype: MediaType = None, year: str = None, season: int = None,
+    def match_doubaninfo(self, name: str, imdbid: Optional[str] = None,
+                         mtype: Optional[MediaType] = None, year: Optional[str] = None, season: Optional[int] = None,
                          raise_exception: bool = False) -> Optional[dict]:
         """
         搜索和匹配豆瓣信息
@@ -188,8 +193,8 @@ class ChainBase(metaclass=ABCMeta):
         return self.run_module("match_doubaninfo", name=name, imdbid=imdbid,
                                mtype=mtype, year=year, season=season, raise_exception=raise_exception)
 
-    def match_tmdbinfo(self, name: str, mtype: MediaType = None,
-                       year: str = None, season: int = None) -> Optional[dict]:
+    def match_tmdbinfo(self, name: str, mtype: Optional[MediaType] = None,
+                       year: Optional[str] = None, season: Optional[int] = None) -> Optional[dict]:
         """
         搜索和匹配TMDB信息
         :param name: 标题
@@ -209,8 +214,8 @@ class ChainBase(metaclass=ABCMeta):
         return self.run_module("obtain_images", mediainfo=mediainfo)
 
     def obtain_specific_image(self, mediaid: Union[str, int], mtype: MediaType,
-                              image_type: MediaImageType, image_prefix: str = None,
-                              season: int = None, episode: int = None) -> Optional[str]:
+                              image_type: MediaImageType, image_prefix: Optional[str] = None,
+                              season: Optional[int] = None, episode: Optional[int] = None) -> Optional[str]:
         """
         获取指定媒体信息图片，返回图片地址
         :param mediaid:     媒体ID
@@ -224,7 +229,7 @@ class ChainBase(metaclass=ABCMeta):
                                image_prefix=image_prefix, image_type=image_type,
                                season=season, episode=episode)
 
-    def douban_info(self, doubanid: str, mtype: MediaType = None,
+    def douban_info(self, doubanid: str, mtype: Optional[MediaType] = None,
                     raise_exception: bool = False) -> Optional[dict]:
         """
         获取豆瓣信息
@@ -243,7 +248,7 @@ class ChainBase(metaclass=ABCMeta):
         """
         return self.run_module("tvdb_info", tvdbid=tvdbid)
 
-    def tmdb_info(self, tmdbid: int, mtype: MediaType, season: int = None) -> Optional[dict]:
+    def tmdb_info(self, tmdbid: int, mtype: MediaType, season: Optional[int] = None) -> Optional[dict]:
         """
         获取TMDB信息
         :param tmdbid: int
@@ -308,10 +313,10 @@ class ChainBase(metaclass=ABCMeta):
         """
         return self.run_module("search_collections", name=name)
 
-    def search_torrents(self, site: CommentedMap,
+    def search_torrents(self, site: dict,
                         keywords: List[str],
-                        mtype: MediaType = None,
-                        page: int = 0) -> List[TorrentInfo]:
+                        mtype: Optional[MediaType] = None,
+                        page: Optional[int] = 0) -> List[TorrentInfo]:
         """
         搜索一个站点的种子资源
         :param site:  站点
@@ -323,13 +328,17 @@ class ChainBase(metaclass=ABCMeta):
         return self.run_module("search_torrents", site=site, keywords=keywords,
                                mtype=mtype, page=page)
 
-    def refresh_torrents(self, site: CommentedMap) -> List[TorrentInfo]:
+    def refresh_torrents(self, site: dict, keyword: Optional[str] = None, 
+                         cat: Optional[str] = None, page: Optional[int] = 0) -> List[TorrentInfo]:
         """
         获取站点最新一页的种子，多个站点需要多线程处理
         :param site:  站点
+        :param keyword:  标题
+        :param cat:  分类
+        :param page:  页码
         :reutrn: 种子资源列表
         """
-        return self.run_module("refresh_torrents", site=site)
+        return self.run_module("refresh_torrents", site=site, keyword=keyword, cat=cat, page=page)
 
     def filter_torrents(self, rule_groups: List[str],
                         torrent_list: List[TorrentInfo],
@@ -345,8 +354,8 @@ class ChainBase(metaclass=ABCMeta):
                                torrent_list=torrent_list, mediainfo=mediainfo)
 
     def download(self, content: Union[Path, str], download_dir: Path, cookie: str,
-                 episodes: Set[int] = None, category: str = None,
-                 downloader: str = None
+                 episodes: Set[int] = None, category: Optional[str] = None, label: Optional[str] = None,
+                 downloader: Optional[str] = None
                  ) -> Optional[Tuple[Optional[str], Optional[str], Optional[str], str]]:
         """
         根据种子文件，选择并添加下载任务
@@ -355,11 +364,12 @@ class ChainBase(metaclass=ABCMeta):
         :param cookie:  cookie
         :param episodes:  需要下载的集数
         :param category:  种子分类
+        :param label:  标签
         :param downloader:  下载器
         :return: 下载器名称、种子Hash、种子文件布局、错误原因
         """
         return self.run_module("download", content=content, download_dir=download_dir,
-                               cookie=cookie, episodes=episodes, category=category,
+                               cookie=cookie, episodes=episodes, category=category, label=label,
                                downloader=downloader)
 
     def download_added(self, context: Context, download_dir: Path, torrent_path: Path = None) -> None:
@@ -375,7 +385,7 @@ class ChainBase(metaclass=ABCMeta):
 
     def list_torrents(self, status: TorrentStatus = None,
                       hashs: Union[list, str] = None,
-                      downloader: str = None
+                      downloader: Optional[str] = None
                       ) -> Optional[List[Union[TransferTorrent, DownloadingTorrent]]]:
         """
         获取下载器种子列表
@@ -388,8 +398,8 @@ class ChainBase(metaclass=ABCMeta):
 
     def transfer(self, fileitem: FileItem, meta: MetaBase, mediainfo: MediaInfo,
                  target_directory: TransferDirectoryConf = None,
-                 target_storage: str = None, target_path: Path = None,
-                 transfer_type: str = None, scrape: bool = None,
+                 target_storage: Optional[str] = None, target_path: Path = None,
+                 transfer_type: Optional[str] = None, scrape: bool = None,
                  library_type_folder: bool = None, library_category_folder: bool = None,
                  episodes_info: List[TmdbEpisode] = None) -> Optional[TransferInfo]:
         """
@@ -416,7 +426,7 @@ class ChainBase(metaclass=ABCMeta):
                                library_category_folder=library_category_folder,
                                episodes_info=episodes_info)
 
-    def transfer_completed(self, hashs: str, downloader: str = None) -> None:
+    def transfer_completed(self, hashs: str, downloader: Optional[str] = None) -> None:
         """
         下载器转移完成后的处理
         :param hashs:  种子Hash
@@ -425,7 +435,7 @@ class ChainBase(metaclass=ABCMeta):
         return self.run_module("transfer_completed", hashs=hashs, downloader=downloader)
 
     def remove_torrents(self, hashs: Union[str, list], delete_file: bool = True,
-                        downloader: str = None) -> bool:
+                        downloader: Optional[str] = None) -> bool:
         """
         删除下载器种子
         :param hashs:  种子Hash
@@ -435,7 +445,7 @@ class ChainBase(metaclass=ABCMeta):
         """
         return self.run_module("remove_torrents", hashs=hashs, delete_file=delete_file, downloader=downloader)
 
-    def start_torrents(self, hashs: Union[list, str], downloader: str = None) -> bool:
+    def start_torrents(self, hashs: Union[list, str], downloader: Optional[str] = None) -> bool:
         """
         开始下载
         :param hashs:  种子Hash
@@ -444,7 +454,7 @@ class ChainBase(metaclass=ABCMeta):
         """
         return self.run_module("start_torrents", hashs=hashs, downloader=downloader)
 
-    def stop_torrents(self, hashs: Union[list, str], downloader: str = None) -> bool:
+    def stop_torrents(self, hashs: Union[list, str], downloader: Optional[str] = None) -> bool:
         """
         停止下载
         :param hashs:  种子Hash
@@ -454,7 +464,7 @@ class ChainBase(metaclass=ABCMeta):
         return self.run_module("stop_torrents", hashs=hashs, downloader=downloader)
 
     def torrent_files(self, tid: str,
-                      downloader: str = None) -> Optional[Union[TorrentFilesList, List[File]]]:
+                      downloader: Optional[str] = None) -> Optional[Union[TorrentFilesList, List[File]]]:
         """
         获取种子文件
         :param tid:  种子Hash
@@ -463,8 +473,8 @@ class ChainBase(metaclass=ABCMeta):
         """
         return self.run_module("torrent_files", tid=tid, downloader=downloader)
 
-    def media_exists(self, mediainfo: MediaInfo, itemid: str = None,
-                     server: str = None) -> Optional[ExistMediaInfo]:
+    def media_exists(self, mediainfo: MediaInfo, itemid: Optional[str] = None,
+                     server: Optional[str] = None) -> Optional[ExistMediaInfo]:
         """
         判断媒体文件是否存在
         :param mediainfo:  识别的媒体信息
@@ -488,11 +498,6 @@ class ChainBase(metaclass=ABCMeta):
         :param message:  消息体
         :return: 成功或失败
         """
-        logger.info(f"发送消息：channel={message.channel}，"
-                    f"source={message.source},"
-                    f"title={message.title}, "
-                    f"text={message.text}，"
-                    f"userid={message.userid}")
         # 保存原消息
         self.messagehelper.put(message, role="user", title=message.title)
         self.messageoper.add(**message.dict())
@@ -531,6 +536,9 @@ class ChainBase(metaclass=ABCMeta):
                                 # 管理员发过了，此消息不发了
                                 logger.info(f"用户 {send_message.username} 不存在，消息无法发送到对应用户")
                                 continue
+                        elif send_message.username == settings.SUPERUSER:
+                            # 管理员同名已发送
+                            admin_sended = True
                     else:
                         # 按原消息发送全体
                         if not admin_sended:
@@ -539,13 +547,13 @@ class ChainBase(metaclass=ABCMeta):
                     # 按设定发送
                     self.eventmanager.send_event(etype=EventType.NoticeMessage,
                                                  data={**send_message.dict(), "type": send_message.mtype})
-                    self.run_module("post_message", message=send_message)
+                    self.messagequeue.send_message("post_message", message=send_message)
                 if not send_orignal:
                     return
         # 发送消息事件
         self.eventmanager.send_event(etype=EventType.NoticeMessage, data={**message.dict(), "type": message.mtype})
         # 按原消息发送
-        self.run_module("post_message", message=message)
+        self.messagequeue.send_message("post_message", message=message)
 
     def post_medias_message(self, message: Notification, medias: List[MediaInfo]) -> None:
         """
@@ -557,7 +565,7 @@ class ChainBase(metaclass=ABCMeta):
         note_list = [media.to_dict() for media in medias]
         self.messagehelper.put(message, role="user", note=note_list, title=message.title)
         self.messageoper.add(**message.dict(), note=note_list)
-        return self.run_module("post_medias_message", message=message, medias=medias)
+        return self.messagequeue.send_message("post_medias_message", message=message, medias=medias)
 
     def post_torrents_message(self, message: Notification, torrents: List[Context]) -> None:
         """
@@ -569,9 +577,10 @@ class ChainBase(metaclass=ABCMeta):
         note_list = [torrent.torrent_info.to_dict() for torrent in torrents]
         self.messagehelper.put(message, role="user", note=note_list, title=message.title)
         self.messageoper.add(**message.dict(), note=note_list)
-        return self.run_module("post_torrents_message", message=message, torrents=torrents)
+        return self.messagequeue.send_message("post_torrents_message", message=message, torrents=torrents)
 
-    def metadata_img(self, mediainfo: MediaInfo, season: int = None, episode: int = None) -> Optional[dict]:
+    def metadata_img(self, mediainfo: MediaInfo, 
+                     season: Optional[int] = None, episode: Optional[int] = None) -> Optional[dict]:
         """
         获取图片名称和url
         :param mediainfo: 媒体信息

app/chain/bangumi.py

@@ -17,6 +17,12 @@ class BangumiChain(ChainBase, metaclass=Singleton):
         """
         return self.run_module("bangumi_calendar")
 
+    def discover(self, **kwargs) -> Optional[List[MediaInfo]]:
+        """
+        发现Bangumi番剧
+        """
+        return self.run_module("bangumi_discover", **kwargs)
+
     def bangumi_info(self, bangumiid: int) -> Optional[dict]:
         """
         获取Bangumi信息

app/chain/dashboard.py

@@ -9,13 +9,13 @@ class DashboardChain(ChainBase, metaclass=Singleton):
     """
     各类仪表板统计处理链
     """
-    def media_statistic(self, server: str = None) -> Optional[List[schemas.Statistic]]:
+    def media_statistic(self, server: Optional[str] = None) -> Optional[List[schemas.Statistic]]:
         """
         媒体数量统计
         """
         return self.run_module("media_statistic", server=server)
 
-    def downloader_info(self, downloader: str = None) -> Optional[List[schemas.DownloaderInfo]]:
+    def downloader_info(self, downloader: Optional[str] = None) -> Optional[List[schemas.DownloaderInfo]]:
         """
         下载器信息
         """

app/chain/douban.py

@@ -19,7 +19,7 @@ class DoubanChain(ChainBase, metaclass=Singleton):
         """
         return self.run_module("douban_person_detail", person_id=person_id)
 
-    def person_credits(self, person_id: int, page: int = 1) -> List[MediaInfo]:
+    def person_credits(self, person_id: int, page: Optional[int] = 1) -> List[MediaInfo]:
         """
         根据人物ID查询人物参演作品
         :param person_id:  人物ID
@@ -27,7 +27,7 @@ class DoubanChain(ChainBase, metaclass=Singleton):
         """
         return self.run_module("douban_person_credits", person_id=person_id, page=page)
 
-    def movie_top250(self, page: int = 1, count: int = 30) -> Optional[List[MediaInfo]]:
+    def movie_top250(self, page: Optional[int] = 1, count: Optional[int] = 30) -> Optional[List[MediaInfo]]:
         """
         获取豆瓣电影TOP250
         :param page:  页码
@@ -35,26 +35,26 @@ class DoubanChain(ChainBase, metaclass=Singleton):
         """
         return self.run_module("movie_top250", page=page, count=count)
 
-    def movie_showing(self, page: int = 1, count: int = 30) -> Optional[List[MediaInfo]]:
+    def movie_showing(self, page: Optional[int] = 1, count: Optional[int] = 30) -> Optional[List[MediaInfo]]:
         """
         获取正在上映的电影
         """
         return self.run_module("movie_showing", page=page, count=count)
 
-    def tv_weekly_chinese(self, page: int = 1, count: int = 30) -> Optional[List[MediaInfo]]:
+    def tv_weekly_chinese(self, page: Optional[int] = 1, count: Optional[int] = 30) -> Optional[List[MediaInfo]]:
         """
         获取本周中国剧集榜
         """
         return self.run_module("tv_weekly_chinese", page=page, count=count)
 
-    def tv_weekly_global(self, page: int = 1, count: int = 30) -> Optional[List[MediaInfo]]:
+    def tv_weekly_global(self, page: Optional[int] = 1, count: Optional[int] = 30) -> Optional[List[MediaInfo]]:
         """
         获取本周全球剧集榜
         """
         return self.run_module("tv_weekly_global", page=page, count=count)
 
     def douban_discover(self, mtype: MediaType, sort: str, tags: str,
-                        page: int = 0, count: int = 30) -> Optional[List[MediaInfo]]:
+                        page: Optional[int] = 0, count: Optional[int] = 30) -> Optional[List[MediaInfo]]:
         """
         发现豆瓣电影、剧集
         :param mtype:  媒体类型
@@ -67,19 +67,19 @@ class DoubanChain(ChainBase, metaclass=Singleton):
         return self.run_module("douban_discover", mtype=mtype, sort=sort, tags=tags,
                                page=page, count=count)
 
-    def tv_animation(self, page: int = 1, count: int = 30) -> Optional[List[MediaInfo]]:
+    def tv_animation(self, page: Optional[int] = 1, count: Optional[int] = 30) -> Optional[List[MediaInfo]]:
         """
         获取动画剧集
         """
         return self.run_module("tv_animation", page=page, count=count)
 
-    def movie_hot(self, page: int = 1, count: int = 30) -> Optional[List[MediaInfo]]:
+    def movie_hot(self, page: Optional[int] = 1, count: Optional[int] = 30) -> Optional[List[MediaInfo]]:
         """
         获取热门电影
         """
         return self.run_module("movie_hot", page=page, count=count)
 
-    def tv_hot(self, page: int = 1, count: int = 30) -> Optional[List[MediaInfo]]:
+    def tv_hot(self, page: Optional[int] = 1, count: Optional[int] = 30) -> Optional[List[MediaInfo]]:
         """
         获取热门剧集
         """

app/chain/download.py

@@ -39,8 +39,8 @@ class DownloadChain(ChainBase):
         self.messagehelper = MessageHelper()
 
     def post_download_message(self, meta: MetaBase, mediainfo: MediaInfo, torrent: TorrentInfo,
-                              channel: MessageChannel = None, username: str = None,
-                              download_episodes: str = None):
+                              channel: MessageChannel = None, username: Optional[str] = None,
+                              download_episodes: Optional[str] = None):
         """
         发送添加下载的消息，根据消息场景开关决定发给谁
         :param meta: 元数据
@@ -97,7 +97,7 @@ class DownloadChain(ChainBase):
 
     def download_torrent(self, torrent: TorrentInfo,
                          channel: MessageChannel = None,
-                         source: str = None,
+                         source: Optional[str] = None,
                          userid: Union[str, int] = None
                          ) -> Tuple[Optional[Union[Path, str]], str, list]:
         """
@@ -105,7 +105,7 @@ class DownloadChain(ChainBase):
         :return: 种子路径，种子目录名，种子文件清单
         """
 
-        def __get_redict_url(url: str, ua: str = None, cookie: str = None) -> Optional[str]:
+        def __get_redict_url(url: str, ua: Optional[str] = None, cookie: Optional[str] = None) -> Optional[str]:
             """
             获取下载链接， url格式：[base64]url
             """
@@ -204,12 +204,12 @@ class DownloadChain(ChainBase):
     def download_single(self, context: Context, torrent_file: Path = None,
                         episodes: Set[int] = None,
                         channel: MessageChannel = None,
-                        source: str = None,
-                        downloader: str = None,
-                        save_path: str = None,
+                        source: Optional[str] = None,
+                        downloader: Optional[str] = None,
+                        save_path: Optional[str] = None,
                         userid: Union[str, int] = None,
-                        username: str = None,
-                        media_category: str = None) -> Optional[str]:
+                        username: Optional[str] = None,
+                        label: Optional[str] = None) -> Optional[str]:
         """
         下载及发送通知
         :param context: 资源上下文
@@ -221,8 +221,13 @@ class DownloadChain(ChainBase):
         :param save_path: 保存路径
         :param userid: 用户ID
         :param username: 调用下载的用户名/插件名
-        :param media_category: 自定义媒体类别
+        :param label: 自定义标签
         """
+        _torrent = context.torrent_info
+        _media = context.media_info
+        _meta = context.meta_info
+        _site_downloader = _torrent.site_downloader
+
         # 发送资源下载事件，允许外部拦截下载
         event_data = ResourceDownloadEventData(
             context=context,
@@ -234,7 +239,7 @@ class DownloadChain(ChainBase):
                 "save_path": save_path,
                 "userid": userid,
                 "username": username,
-                "media_category": media_category
+                "media_category": _media.category
             }
         )
         # 触发资源下载事件
@@ -248,15 +253,11 @@ class DownloadChain(ChainBase):
                     f"Reason: {event_data.reason}")
                 return None
 
-        _torrent = context.torrent_info
-        _media = context.media_info
-        _meta = context.meta_info
-        _site_downloader = _torrent.site_downloader
-
         # 补充完整的media数据
         if not _media.genre_ids:
             new_media = self.recognize_media(mtype=_media.type, tmdbid=_media.tmdb_id,
-                                             doubanid=_media.douban_id, bangumiid=_media.bangumi_id)
+                                             doubanid=_media.douban_id, bangumiid=_media.bangumi_id,
+                                             episode_group=_media.episode_group)
             if new_media:
                 _media = new_media
 
@@ -310,6 +311,7 @@ class DownloadChain(ChainBase):
                                                 episodes=episodes,
                                                 download_dir=download_dir,
                                                 category=_media.category,
+                                                label=label,
                                                 downloader=downloader or _site_downloader)
         if result:
             _downloader, _hash, _layout, error_msg = result
@@ -352,7 +354,8 @@ class DownloadChain(ChainBase):
                 username=username,
                 channel=channel.value if channel else None,
                 date=time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()),
-                media_category=media_category,
+                media_category=_media.category,
+                episode_group=_media.episode_group,
                 note={"source": source}
             )
 
@@ -415,13 +418,12 @@ class DownloadChain(ChainBase):
     def batch_download(self,
                        contexts: List[Context],
                        no_exists: Dict[Union[int, str], Dict[int, NotExistMediaInfo]] = None,
-                       save_path: str = None,
+                       save_path: Optional[str] = None,
                        channel: MessageChannel = None,
-                       source: str = None,
-                       userid: str = None,
-                       username: str = None,
-                       media_category: str = None,
-                       downloader: str = None
+                       source: Optional[str] = None,
+                       userid: Optional[str] = None,
+                       username: Optional[str] = None,
+                       downloader: Optional[str] = None
                        ) -> Tuple[List[Context], Dict[Union[int, str], Dict[int, NotExistMediaInfo]]]:
         """
         根据缺失数据，自动种子列表中组合择优下载
@@ -432,7 +434,6 @@ class DownloadChain(ChainBase):
         :param source:  来源（消息通知、订阅、手工下载等）
         :param userid:  用户ID
         :param username: 调用下载的用户名/插件名
-        :param media_category: 自定义媒体类别
         :param downloader: 下载器
         :return: 已经下载的资源列表、剩余未下载到的剧集 no_exists[tmdb_id/douban_id] = {season: NotExistMediaInfo}
         """
@@ -521,7 +522,7 @@ class DownloadChain(ChainBase):
                 logger.info(f"开始下载电影 {context.torrent_info.title} ...")
                 if self.download_single(context, save_path=save_path, channel=channel,
                                         source=source, userid=userid, username=username,
-                                        media_category=media_category, downloader=downloader):
+                                        downloader=downloader):
                     # 下载成功
                     logger.info(f"{context.torrent_info.title} 添加下载成功")
                     downloaded_list.append(context)
@@ -606,8 +607,7 @@ class DownloadChain(ChainBase):
                                         source=source,
                                         userid=userid,
                                         username=username,
-                                        media_category=media_category,
-                                        downloader=downloader,
+                                        downloader=downloader
                                     )
                             else:
                                 # 下载
@@ -615,7 +615,6 @@ class DownloadChain(ChainBase):
                                 download_id = self.download_single(context, save_path=save_path,
                                                                    channel=channel, source=source,
                                                                    userid=userid, username=username,
-                                                                   media_category=media_category,
                                                                    downloader=downloader)
 
                             if download_id:
@@ -687,7 +686,6 @@ class DownloadChain(ChainBase):
                                 download_id = self.download_single(context, save_path=save_path,
                                                                    channel=channel, source=source,
                                                                    userid=userid, username=username,
-                                                                   media_category=media_category,
                                                                    downloader=downloader)
                                 if download_id:
                                     # 下载成功
@@ -777,7 +775,6 @@ class DownloadChain(ChainBase):
                                 source=source,
                                 userid=userid,
                                 username=username,
-                                media_category=media_category,
                                 downloader=downloader
                             )
                             if not download_id:
@@ -863,7 +860,8 @@ class DownloadChain(ChainBase):
                 # 补充媒体信息
                 mediainfo: MediaInfo = self.recognize_media(mtype=mediainfo.type,
                                                             tmdbid=mediainfo.tmdb_id,
-                                                            doubanid=mediainfo.douban_id)
+                                                            doubanid=mediainfo.douban_id,
+                                                            episode_group=mediainfo.episode_group)
                 if not mediainfo:
                     logger.error(f"媒体信息识别失败！")
                     return False, {}
@@ -930,7 +928,7 @@ class DownloadChain(ChainBase):
             # 全部存在
             return True, no_exists
 
-    def remote_downloading(self, channel: MessageChannel, userid: Union[str, int] = None, source: str = None):
+    def remote_downloading(self, channel: MessageChannel, userid: Union[str, int] = None, source: Optional[str] = None):
         """
         查询正在下载的任务，并发送消息
         """
@@ -964,7 +962,7 @@ class DownloadChain(ChainBase):
             link=settings.MP_DOMAIN('#/downloading')
         ))
 
-    def downloading(self, name: str = None) -> List[DownloadingTorrent]:
+    def downloading(self, name: Optional[str] = None) -> List[DownloadingTorrent]:
         """
         查询正在下载的任务
         """

app/chain/media.py

@@ -32,7 +32,7 @@ class MediaChain(ChainBase, metaclass=Singleton):
         self.storagechain = StorageChain()
 
     def metadata_nfo(self, meta: MetaBase, mediainfo: MediaInfo,
-                     season: int = None, episode: int = None) -> Optional[str]:
+                     season: Optional[int] = None, episode: Optional[int] = None) -> Optional[str]:
         """
         获取NFO文件内容文本
         :param meta: 元数据
@@ -42,13 +42,13 @@ class MediaChain(ChainBase, metaclass=Singleton):
         """
         return self.run_module("metadata_nfo", meta=meta, mediainfo=mediainfo, season=season, episode=episode)
 
-    def recognize_by_meta(self, metainfo: MetaBase) -> Optional[MediaInfo]:
+    def recognize_by_meta(self, metainfo: MetaBase, episode_group: Optional[str] = None) -> Optional[MediaInfo]:
         """
         根据主副标题识别媒体信息
         """
         title = metainfo.title
         # 识别媒体信息
-        mediainfo: MediaInfo = self.recognize_media(meta=metainfo)
+        mediainfo: MediaInfo = self.recognize_media(meta=metainfo, episode_group=episode_group)
         if not mediainfo:
             # 尝试使用辅助识别，如果有注册响应事件的话
             if eventmanager.check(ChainEventType.NameRecognize):
@@ -112,7 +112,7 @@ class MediaChain(ChainBase, metaclass=Singleton):
         # 重新识别
         return self.recognize_media(meta=org_meta)
 
-    def recognize_by_path(self, path: str) -> Optional[Context]:
+    def recognize_by_path(self, path: str, episode_group: Optional[str] = None) -> Optional[Context]:
         """
         根据文件路径识别媒体信息
         """
@@ -121,7 +121,7 @@ class MediaChain(ChainBase, metaclass=Singleton):
         # 元数据
         file_meta = MetaInfoPath(file_path)
         # 识别媒体信息
-        mediainfo = self.recognize_media(meta=file_meta)
+        mediainfo = self.recognize_media(meta=file_meta, episode_group=episode_group)
         if not mediainfo:
             # 尝试使用辅助识别，如果有注册响应事件的话
             if eventmanager.check(ChainEventType.NameRecognize):
@@ -238,7 +238,7 @@ class MediaChain(ChainBase, metaclass=Singleton):
         return None
 
     def get_doubaninfo_by_tmdbid(self, tmdbid: int,
-                                 mtype: MediaType = None, season: int = None) -> Optional[dict]:
+                                 mtype: MediaType = None, season: Optional[int] = None) -> Optional[dict]:
         """
         根据TMDBID获取豆瓣信息
         """
@@ -375,7 +375,7 @@ class MediaChain(ChainBase, metaclass=Singleton):
                 if item:
                     logger.info(f"已保存文件：{item.path}")
                 else:
-                    logger.warn(f"文件保存失败：{item.path}")
+                    logger.warn(f"文件保存失败：{_path}")
             finally:
                 if tmp_file.exists():
                     tmp_file.unlink()
@@ -444,7 +444,8 @@ class MediaChain(ChainBase, metaclass=Singleton):
                     for file in files:
                         self.scrape_metadata(fileitem=file,
                                              meta=meta, mediainfo=mediainfo,
-                                             init_folder=False, parent=fileitem)
+                                             init_folder=False, parent=fileitem,
+                                             overwrite=overwrite)
                 # 生成目录内图片文件
                 if init_folder:
                     # 图片
@@ -473,7 +474,8 @@ class MediaChain(ChainBase, metaclass=Singleton):
                 if not file_meta.begin_episode:
                     logger.warn(f"{filepath.name} 无法识别文件集数！")
                     return
-                file_mediainfo = self.recognize_media(meta=file_meta, tmdbid=mediainfo.tmdb_id)
+                file_mediainfo = self.recognize_media(meta=file_meta, tmdbid=mediainfo.tmdb_id,
+                                                      episode_group=mediainfo.episode_group)
                 if not file_mediainfo:
                     logger.warn(f"{filepath.name} 无法识别文件媒体信息！")
                     return
@@ -482,7 +484,8 @@ class MediaChain(ChainBase, metaclass=Singleton):
                 if overwrite or not self.storagechain.get_file_item(storage=fileitem.storage, path=nfo_path):
                     # 获取集的nfo文件
                     episode_nfo = self.metadata_nfo(meta=file_meta, mediainfo=file_mediainfo,
-                                                    season=file_meta.begin_season, episode=file_meta.begin_episode)
+                                                    season=file_meta.begin_season,
+                                                    episode=file_meta.begin_episode)
                     if episode_nfo:
                         # 保存或上传nfo文件到上级目录
                         if not parent:
@@ -515,7 +518,8 @@ class MediaChain(ChainBase, metaclass=Singleton):
                     self.scrape_metadata(fileitem=file,
                                          meta=meta, mediainfo=mediainfo,
                                          parent=fileitem if file.type == "file" else None,
-                                         init_folder=True if file.type == "dir" else False)
+                                         init_folder=True if file.type == "dir" else False,
+                                         overwrite=overwrite)
                 # 生成目录的nfo和图片
                 if init_folder:
                     # 识别文件夹名称

app/chain/mediaserver.py

@@ -1,9 +1,8 @@
 import threading
-from typing import List, Union, Optional, Generator
-
-from cachetools import cached, TTLCache
+from typing import List, Union, Optional, Generator, Any
 
 from app.chain import ChainBase
+from app.core.cache import cached
 from app.core.config import global_vars
 from app.db.mediaserver_oper import MediaServerOper
 from app.helper.service import ServiceConfigHelper
@@ -22,14 +21,15 @@ class MediaServerChain(ChainBase):
         super().__init__()
         self.dboper = MediaServerOper()
 
-    def librarys(self, server: str, username: str = None, hidden: bool = False) -> List[MediaServerLibrary]:
+    def librarys(self, server: str, username: Optional[str] = None,
+                 hidden: bool = False) -> List[MediaServerLibrary]:
         """
         获取媒体服务器所有媒体库
         """
         return self.run_module("mediaserver_librarys", server=server, username=username, hidden=hidden)
 
-    def items(self, server: str, library_id: Union[str, int], start_index: int = 0, limit: Optional[int] = -1) \
-            -> Optional[Generator]:
+    def items(self, server: str, library_id: Union[str, int],
+              start_index: Optional[int] = 0, limit: Optional[int] = -1) -> Generator[Any, None, None]:
         """
         获取媒体服务器项目列表，支持分页和不分页逻辑，默认不分页获取所有数据
 
@@ -82,28 +82,31 @@ class MediaServerChain(ChainBase):
         """
         return self.run_module("mediaserver_tv_episodes", server=server, item_id=item_id)
 
-    def playing(self, server: str, count: int = 20, username: str = None) -> List[MediaServerPlayItem]:
+    def playing(self, server: str, count: Optional[int] = 20,
+                username: Optional[str] = None) -> List[MediaServerPlayItem]:
         """
         获取媒体服务器正在播放信息
         """
         return self.run_module("mediaserver_playing", count=count, server=server, username=username)
 
-    def latest(self, server: str, count: int = 20, username: str = None) -> List[MediaServerPlayItem]:
+    def latest(self, server: str, count: Optional[int] = 20,
+               username: Optional[str] = None) -> List[MediaServerPlayItem]:
         """
         获取媒体服务器最新入库条目
         """
         return self.run_module("mediaserver_latest", count=count, server=server, username=username)
 
-    @cached(cache=TTLCache(maxsize=1, ttl=3600))
-    def get_latest_wallpapers(self, server: str = None, count: int = 10,
-                              remote: bool = True, username: str = None) -> List[str]:
+    @cached(maxsize=1, ttl=3600)
+    def get_latest_wallpapers(self, server: Optional[str] = None, count: Optional[int] = 10,
+                              remote: bool = True, username: Optional[str] = None) -> List[str]:
         """
         获取最新最新入库条目海报作为壁纸，缓存1小时
         """
         return self.run_module("mediaserver_latest_images", server=server, count=count,
                                remote=remote, username=username)
 
-    def get_latest_wallpaper(self, server: str = None, remote: bool = True, username: str = None) -> Optional[str]:
+    def get_latest_wallpaper(self, server: Optional[str] = None,
+                             remote: bool = True, username: Optional[str] = None) -> Optional[str]:
         """
         获取最新最新入库条目海报作为壁纸，缓存1小时
         """

app/chain/message.py

@@ -295,6 +295,8 @@ class MessageChain(ChainBase):
                         return
                 else:
                     best_version = True
+                # 转换用户名
+                mp_name = self.useroper.get_name(**{f"{channel.name.lower()}_userid": userid}) if channel else None
                 # 添加订阅，状态为N
                 self.subscribechain.add(title=mediainfo.title,
                                         year=mediainfo.year,
@@ -304,7 +306,7 @@ class MessageChain(ChainBase):
                                         channel=channel,
                                         source=source,
                                         userid=userid,
-                                        username=username,
+                                        username=mp_name or username,
                                         best_version=best_version)
             elif cache_type == "Torrent":
                 if int(text) == 0:
@@ -505,6 +507,8 @@ class MessageChain(ChainBase):
                 note = downloaded
             else:
                 note = None
+            # 转换用户名
+            mp_name = self.useroper.get_name(**{f"{channel.name.lower()}_userid": userid}) if channel else None
             # 添加订阅，状态为R
             self.subscribechain.add(title=_current_media.title,
                                     year=_current_media.year,
@@ -514,7 +518,7 @@ class MessageChain(ChainBase):
                                     channel=channel,
                                     source=source,
                                     userid=userid,
-                                    username=username,
+                                    username=mp_name or username,
                                     state="R",
                                     note=note)
 

app/chain/recommend.py

@@ -1,18 +1,16 @@
-import inspect
 import io
 import tempfile
-from functools import wraps
 from pathlib import Path
-from typing import Any, Callable, List
+from typing import List, Optional
 
+import pillow_avif  # noqa 用于自动注册AVIF支持
 from PIL import Image
-from cachetools import TTLCache
-from cachetools.keys import hashkey
 
 from app.chain import ChainBase
 from app.chain.bangumi import BangumiChain
 from app.chain.douban import DoubanChain
 from app.chain.tmdb import TmdbChain
+from app.core.cache import cache_backend, cached
 from app.core.config import settings, global_vars
 from app.log import logger
 from app.schemas import MediaType
@@ -23,42 +21,7 @@ from app.utils.singleton import Singleton
 
 # 推荐相关的专用缓存
 recommend_ttl = 24 * 3600
-recommend_cache = TTLCache(maxsize=256, ttl=recommend_ttl)
-
-
-# 推荐缓存装饰器，避免偶发网络获取数据为空时，页面由于缓存为空长时间渲染异常问题
-def cached_with_empty_check(func: Callable):
-    """
-    缓存装饰器，用于缓存函数的返回结果，仅在结果非空时进行缓存
-
-    :param func: 被装饰的函数
-    :return: 包装后的函数
-    """
-
-    @wraps(func)
-    def wrapper(*args, **kwargs):
-        signature = inspect.signature(func)
-        resolved_kwargs = {}
-        # 获取默认值并结合传递的参数（如果有）
-        for param, value in signature.parameters.items():
-            if param in kwargs:
-                # 使用显式传递的参数
-                resolved_kwargs[param] = kwargs[param]
-            elif value.default is not inspect.Parameter.empty:
-                # 没有传递参数时使用默认值
-                resolved_kwargs[param] = value.default
-        # 使用 cachetools 缓存，构造缓存键
-        cache_key = f"{func.__name__}_{hashkey(*args, **resolved_kwargs)}"
-        if cache_key in recommend_cache:
-            return recommend_cache[cache_key]
-        result = func(*args, **kwargs)
-        # 如果返回值为空，则不缓存
-        if result in [None, [], {}]:
-            return result
-        recommend_cache[cache_key] = result
-        return result
-
-    return wrapper
+recommend_cache_region = "recommend"
 
 
 class RecommendChain(ChainBase, metaclass=Singleton):
@@ -78,7 +41,7 @@ class RecommendChain(ChainBase, metaclass=Singleton):
         刷新推荐
         """
         logger.debug("Starting to refresh Recommend data.")
-        recommend_cache.clear()
+        cache_backend.clear(region=recommend_cache_region)
         logger.debug("Recommend Cache has been cleared.")
 
         # 推荐来源方法
@@ -154,6 +117,10 @@ class RecommendChain(ChainBase, metaclass=Singleton):
         sanitized_path = SecurityUtils.sanitize_url_path(url)
         cache_path = settings.CACHE_PATH / "images" / sanitized_path
 
+        # 没有文件类型，则添加后缀，在恶意文件类型和实际需求下的折衷选择
+        if not cache_path.suffix:
+            cache_path = cache_path.with_suffix(".jpg")
+
         # 确保缓存路径和文件类型合法
         if not SecurityUtils.is_safe_path(settings.CACHE_PATH, cache_path, settings.SECURITY_IMAGE_SUFFIXES):
             logger.debug(f"Invalid cache path or file type for URL: {url}, sanitized path: {sanitized_path}")
@@ -194,9 +161,16 @@ class RecommendChain(ChainBase, metaclass=Singleton):
             logger.debug(f"Failed to write cache file {cache_path} for URL {url}: {e}")
 
     @log_execution_time(logger=logger)
-    @cached_with_empty_check
-    def tmdb_movies(self, sort_by: str = "popularity.desc", with_genres: str = "",
-                    with_original_language: str = "", page: int = 1) -> Any:
+    @cached(ttl=recommend_ttl, region=recommend_cache_region)
+    def tmdb_movies(self, sort_by: Optional[str] = "popularity.desc",
+                    with_genres: Optional[str] = "",
+                    with_original_language: Optional[str] = "",
+                    with_keywords: Optional[str] = "",
+                    with_watch_providers: Optional[str] = "",
+                    vote_average: Optional[float] = 0.0,
+                    vote_count: Optional[int] = 0,
+                    release_date: Optional[str] = "",
+                    page: Optional[int] = 1) -> List[dict]:
         """
         TMDB热门电影
         """
@@ -204,13 +178,25 @@ class RecommendChain(ChainBase, metaclass=Singleton):
                                               sort_by=sort_by,
                                               with_genres=with_genres,
                                               with_original_language=with_original_language,
+                                              with_keywords=with_keywords,
+                                              with_watch_providers=with_watch_providers,
+                                              vote_average=vote_average,
+                                              vote_count=vote_count,
+                                              release_date=release_date,
                                               page=page)
         return [movie.to_dict() for movie in movies] if movies else []
 
     @log_execution_time(logger=logger)
-    @cached_with_empty_check
-    def tmdb_tvs(self, sort_by: str = "popularity.desc", with_genres: str = "",
-                 with_original_language: str = "zh|en|ja|ko", page: int = 1) -> Any:
+    @cached(ttl=recommend_ttl, region=recommend_cache_region)
+    def tmdb_tvs(self, sort_by: Optional[str] = "popularity.desc",
+                 with_genres: Optional[str] = "",
+                 with_original_language: Optional[str] = "zh|en|ja|ko",
+                 with_keywords: Optional[str] = "",
+                 with_watch_providers: Optional[str] = "",
+                 vote_average: Optional[float] = 0.0,
+                 vote_count: Optional[int] = 0,
+                 release_date: Optional[str] = "",
+                 page: Optional[int] = 1) -> List[dict]:
         """
         TMDB热门电视剧
         """
@@ -218,12 +204,17 @@ class RecommendChain(ChainBase, metaclass=Singleton):
                                            sort_by=sort_by,
                                            with_genres=with_genres,
                                            with_original_language=with_original_language,
+                                           with_keywords=with_keywords,
+                                           with_watch_providers=with_watch_providers,
+                                           vote_average=vote_average,
+                                           vote_count=vote_count,
+                                           release_date=release_date,
                                            page=page)
         return [tv.to_dict() for tv in tvs] if tvs else []
 
     @log_execution_time(logger=logger)
-    @cached_with_empty_check
-    def tmdb_trending(self, page: int = 1) -> Any:
+    @cached(ttl=recommend_ttl, region=recommend_cache_region)
+    def tmdb_trending(self, page: Optional[int] = 1) -> List[dict]:
         """
         TMDB流行趋势
         """
@@ -231,8 +222,8 @@ class RecommendChain(ChainBase, metaclass=Singleton):
         return [info.to_dict() for info in infos] if infos else []
 
     @log_execution_time(logger=logger)
-    @cached_with_empty_check
-    def bangumi_calendar(self, page: int = 1, count: int = 30) -> Any:
+    @cached(ttl=recommend_ttl, region=recommend_cache_region)
+    def bangumi_calendar(self, page: Optional[int] = 1, count: Optional[int] = 30) -> List[dict]:
         """
         Bangumi每日放送
         """
@@ -240,8 +231,8 @@ class RecommendChain(ChainBase, metaclass=Singleton):
         return [media.to_dict() for media in medias[(page - 1) * count: page * count]] if medias else []
 
     @log_execution_time(logger=logger)
-    @cached_with_empty_check
-    def douban_movie_showing(self, page: int = 1, count: int = 30) -> Any:
+    @cached(ttl=recommend_ttl, region=recommend_cache_region)
+    def douban_movie_showing(self, page: Optional[int] = 1, count: Optional[int] = 30) -> List[dict]:
         """
         豆瓣正在热映
         """
@@ -249,8 +240,9 @@ class RecommendChain(ChainBase, metaclass=Singleton):
         return [media.to_dict() for media in movies] if movies else []
 
     @log_execution_time(logger=logger)
-    @cached_with_empty_check
-    def douban_movies(self, sort: str = "R", tags: str = "", page: int = 1, count: int = 30) -> Any:
+    @cached(ttl=recommend_ttl, region=recommend_cache_region)
+    def douban_movies(self, sort: Optional[str] = "R", tags: Optional[str] = "",
+                      page: Optional[int] = 1, count: Optional[int] = 30) -> List[dict]:
         """
         豆瓣最新电影
         """
@@ -259,8 +251,9 @@ class RecommendChain(ChainBase, metaclass=Singleton):
         return [media.to_dict() for media in movies] if movies else []
 
     @log_execution_time(logger=logger)
-    @cached_with_empty_check
-    def douban_tvs(self, sort: str = "R", tags: str = "", page: int = 1, count: int = 30) -> Any:
+    @cached(ttl=recommend_ttl, region=recommend_cache_region)
+    def douban_tvs(self, sort: Optional[str] = "R", tags: Optional[str] = "",
+                   page: Optional[int] = 1, count: Optional[int] = 30) -> List[dict]:
         """
         豆瓣最新电视剧
         """
@@ -269,8 +262,8 @@ class RecommendChain(ChainBase, metaclass=Singleton):
         return [media.to_dict() for media in tvs] if tvs else []
 
     @log_execution_time(logger=logger)
-    @cached_with_empty_check
-    def douban_movie_top250(self, page: int = 1, count: int = 30) -> Any:
+    @cached(ttl=recommend_ttl, region=recommend_cache_region)
+    def douban_movie_top250(self, page: Optional[int] = 1, count: Optional[int] = 30) -> List[dict]:
         """
         豆瓣电影TOP250
         """
@@ -278,8 +271,8 @@ class RecommendChain(ChainBase, metaclass=Singleton):
         return [media.to_dict() for media in movies] if movies else []
 
     @log_execution_time(logger=logger)
-    @cached_with_empty_check
-    def douban_tv_weekly_chinese(self, page: int = 1, count: int = 30) -> Any:
+    @cached(ttl=recommend_ttl, region=recommend_cache_region)
+    def douban_tv_weekly_chinese(self, page: Optional[int] = 1, count: Optional[int] = 30) -> List[dict]:
         """
         豆瓣国产剧集榜
         """
@@ -287,8 +280,8 @@ class RecommendChain(ChainBase, metaclass=Singleton):
         return [media.to_dict() for media in tvs] if tvs else []
 
     @log_execution_time(logger=logger)
-    @cached_with_empty_check
-    def douban_tv_weekly_global(self, page: int = 1, count: int = 30) -> Any:
+    @cached(ttl=recommend_ttl, region=recommend_cache_region)
+    def douban_tv_weekly_global(self, page: Optional[int] = 1, count: Optional[int] = 30) -> List[dict]:
         """
         豆瓣全球剧集榜
         """
@@ -296,8 +289,8 @@ class RecommendChain(ChainBase, metaclass=Singleton):
         return [media.to_dict() for media in tvs] if tvs else []
 
     @log_execution_time(logger=logger)
-    @cached_with_empty_check
-    def douban_tv_animation(self, page: int = 1, count: int = 30) -> Any:
+    @cached(ttl=recommend_ttl, region=recommend_cache_region)
+    def douban_tv_animation(self, page: Optional[int] = 1, count: Optional[int] = 30) -> List[dict]:
         """
         豆瓣热门动漫
         """
@@ -305,8 +298,8 @@ class RecommendChain(ChainBase, metaclass=Singleton):
         return [media.to_dict() for media in tvs] if tvs else []
 
     @log_execution_time(logger=logger)
-    @cached_with_empty_check
-    def douban_movie_hot(self, page: int = 1, count: int = 30) -> Any:
+    @cached(ttl=recommend_ttl, region=recommend_cache_region)
+    def douban_movie_hot(self, page: Optional[int] = 1, count: Optional[int] = 30) -> List[dict]:
         """
         豆瓣热门电影
         """
@@ -314,8 +307,8 @@ class RecommendChain(ChainBase, metaclass=Singleton):
         return [media.to_dict() for media in movies] if movies else []
 
     @log_execution_time(logger=logger)
-    @cached_with_empty_check
-    def douban_tv_hot(self, page: int = 1, count: int = 30) -> Any:
+    @cached(ttl=recommend_ttl, region=recommend_cache_region)
+    def douban_tv_hot(self, page: Optional[int] = 1, count: Optional[int] = 30) -> List[dict]:
         """
         豆瓣热门电视剧
         """

app/chain/search.py

@@ -34,15 +34,18 @@ class SearchChain(ChainBase):
         self.systemconfig = SystemConfigOper()
         self.torrenthelper = TorrentHelper()
 
-    def search_by_id(self, tmdbid: int = None, doubanid: str = None,
-                     mtype: MediaType = None, area: str = "title", season: int = None) -> List[Context]:
+    def search_by_id(self, tmdbid: Optional[int] = None, doubanid: Optional[str] = None,
+                     mtype: MediaType = None, area: Optional[str] = "title", season: Optional[int] = None,
+                     sites: List[int] = None, cache_local: bool = False) -> List[Context]:
         """
-        根据TMDBID/豆瓣ID搜索资源，精确匹配，但不不过滤本地存在的资源
+        根据TMDBID/豆瓣ID搜索资源，精确匹配，不过滤本地存在的资源
         :param tmdbid: TMDB ID
         :param doubanid: 豆瓣 ID
         :param mtype: 媒体，电影 or 电视剧
         :param area: 搜索范围，title or imdbid
         :param season: 季数
+        :param sites: 站点ID列表
+        :param cache_local: 是否缓存到本地
         """
         mediainfo = self.recognize_media(tmdbid=tmdbid, doubanid=doubanid, mtype=mtype)
         if not mediainfo:
@@ -55,25 +58,27 @@ class SearchChain(ChainBase):
                     season: NotExistMediaInfo(episodes=[])
                 }
             }
-        results = self.process(mediainfo=mediainfo, area=area, no_exists=no_exists)
+        results = self.process(mediainfo=mediainfo, sites=sites, area=area, no_exists=no_exists)
         # 保存到本地文件
-        bytes_results = pickle.dumps(results)
-        self.save_cache(bytes_results, self.__result_temp_file)
+        if cache_local:
+            self.save_cache(pickle.dumps(results), self.__result_temp_file)
         return results
 
-    def search_by_title(self, title: str, page: int = 0, site: int = None) -> List[Context]:
+    def search_by_title(self, title: str, page: Optional[int] = 0,
+                        sites: List[int] = None, cache_local: Optional[bool] = False) -> List[Context]:
         """
         根据标题搜索资源，不识别不过滤，直接返回站点内容
         :param title: 标题，为空时返回所有站点首页内容
         :param page: 页码
-        :param site: 站点ID
+        :param sites: 站点ID列表
+        :param cache_local: 是否缓存到本地
         """
         if title:
             logger.info(f'开始搜索资源，关键词：{title} ...')
         else:
-            logger.info(f'开始浏览资源，站点：{site} ...')
+            logger.info(f'开始浏览资源，站点：{sites} ...')
         # 搜索
-        torrents = self.__search_all_sites(keywords=[title], sites=[site] if site else None, page=page) or []
+        torrents = self.__search_all_sites(keywords=[title], sites=sites, page=page) or []
         if not torrents:
             logger.warn(f'{title} 未搜索到资源')
             return []
@@ -81,8 +86,8 @@ class SearchChain(ChainBase):
         contexts = [Context(meta_info=MetaInfo(title=torrent.title, subtitle=torrent.description),
                             torrent_info=torrent) for torrent in torrents]
         # 保存到本地文件
-        bytes_results = pickle.dumps(contexts)
-        self.save_cache(bytes_results, self.__result_temp_file)
+        if cache_local:
+            self.save_cache(pickle.dumps(contexts), self.__result_temp_file)
         return contexts
 
     def last_search_results(self) -> List[Context]:
@@ -100,11 +105,11 @@ class SearchChain(ChainBase):
             return []
 
     def process(self, mediainfo: MediaInfo,
-                keyword: str = None,
+                keyword: Optional[str] = None,
                 no_exists: Dict[int, Dict[int, NotExistMediaInfo]] = None,
                 sites: List[int] = None,
                 rule_groups: List[str] = None,
-                area: str = "title",
+                area: Optional[str] = "title",
                 custom_words: List[str] = None,
                 filter_params: Dict[str, str] = None) -> List[Context]:
         """
@@ -286,8 +291,8 @@ class SearchChain(ChainBase):
     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]]:
+                           page: Optional[int] = 0,
+                           area: Optional[str] = "title") -> Optional[List[TorrentInfo]]:
         """
         多线程搜索多个站点
         :param mediainfo:  识别的媒体信息
@@ -307,11 +312,6 @@ class SearchChain(ChainBase):
         for indexer in self.siteshelper.get_indexers():
             # 检查站点索引开关
             if not sites or indexer.get("id") in sites:
-                # 站点流控
-                state, msg = self.siteshelper.check(indexer.get("domain"))
-                if state:
-                    logger.warn(msg)
-                    continue
                 indexer_sites.append(indexer)
         if not indexer_sites:
             logger.warn('未开启任何有效站点，无法搜索资源')

app/chain/site.py

@@ -1,12 +1,10 @@
 import base64
 import re
 from datetime import datetime
-from time import time
 from typing import Optional, Tuple, Union, Dict
 from urllib.parse import urljoin
 
 from lxml import etree
-from ruamel.yaml import CommentedMap
 
 from app.chain import ChainBase
 from app.core.config import global_vars, settings
@@ -53,9 +51,10 @@ class SiteChain(ChainBase):
             "1ptba.com": self.__indexphp_test,
             "star-space.net": self.__indexphp_test,
             "yemapt.org": self.__yema_test,
+            "hddolby.com": self.__hddolby_test,
         }
 
-    def refresh_userdata(self, site: CommentedMap = None) -> Optional[SiteUserData]:
+    def refresh_userdata(self, site: dict = None) -> Optional[SiteUserData]:
         """
         刷新站点的用户数据
         :param site:  站点
@@ -138,10 +137,14 @@ class SiteChain(ChainBase):
             proxies=settings.PROXY if site.proxy else None,
             timeout=site.timeout or 15
         ).get_res(url=site.url)
-        if res and res.status_code == 200:
+        if res is None:
+            return False, "无法打开网站！"
+        if res.status_code == 200:
             csrf_token = re.search(r'<meta name="x-csrf-token" content="(.+?)">', res.text)
             if csrf_token:
                 token = csrf_token.group(1)
+        else:
+            return False, f"错误：{res.status_code} {res.reason}"
         if not token:
             return False, "无法获取Token"
         # 调用查询用户信息接口
@@ -155,11 +158,15 @@ class SiteChain(ChainBase):
             proxies=settings.PROXY if site.proxy else None,
             timeout=site.timeout or 15
         ).get_res(url=f"{site.url}api/user/getInfo")
-        if user_res and user_res.status_code == 200:
+        if user_res is None:
+            return False, "无法打开网站！"
+        if user_res.status_code == 200:
             user_info = user_res.json()
             if user_info and user_info.get("data"):
                 return True, "连接成功"
-        return False, "Cookie已失效"
+            return False, "Cookie已失效"
+        else:
+            return False, f"错误：{user_res.status_code} {user_res.reason}"
 
     @staticmethod
     def __mteam_test(site: Site) -> Tuple[bool, str]:
@@ -170,40 +177,24 @@ class SiteChain(ChainBase):
         domain = StringUtils.get_url_domain(site.url)
         url = f"https://api.{domain}/api/member/profile"
         headers = {
-            "Content-Type": "application/json",
             "User-Agent": user_agent,
             "Accept": "application/json, text/plain, */*",
-            "Authorization": site.token,
             "x-api-key": site.apikey,
-            "ts": str(int(time()))
         }
         res = RequestUtils(
             headers=headers,
             proxies=settings.PROXY if site.proxy else None,
             timeout=site.timeout or 15
         ).post_res(url=url)
-        state = False
-        message = "鉴权已过期或无效"
-        if res and res.status_code == 200:
+        if res is None:
+            return False, "无法打开网站！"
+        if res.status_code == 200:
             user_info = res.json() or {}
             if user_info.get("data"):
-                # 更新最后访问时间
-                del headers["x-api-key"]
-                res = RequestUtils(headers=headers,
-                                   timeout=site.timeout or 15,
-                                   proxies=settings.PROXY if site.proxy else None,
-                                   referer=f"{site.url}index"
-                                   ).post_res(url=f"https://api.{domain}/api/member/updateLastBrowse")
-                state = True
-                message = "连接成功，但更新状态失败"
-                if res and res.status_code == 200:
-                    update_info = res.json() or {}
-                    if "code" in update_info and int(update_info["code"]) == 0:
-                        message = "连接成功"
-            elif user_info.get("message"):
-                # 使用馒头的错误提示
-                message = user_info.get("message")
-        return state, message
+                return True, "连接成功"
+            return False, user_info.get("message", "鉴权已过期或无效")
+        else:
+            return False, f"错误：{res.status_code} {res.reason}"
 
     @staticmethod
     def __yema_test(site: Site) -> Tuple[bool, str]:
@@ -223,11 +214,15 @@ class SiteChain(ChainBase):
             proxies=settings.PROXY if site.proxy else None,
             timeout=site.timeout or 15
         ).get_res(url=url)
-        if res and res.status_code == 200:
+        if res is None:
+            return False, "无法打开网站！"
+        if res.status_code == 200:
             user_info = res.json()
             if user_info and user_info.get("success"):
                 return True, "连接成功"
-        return False, "Cookie已过期"
+            return False, "Cookie已过期"
+        else:
+            return False, f"错误：{res.status_code} {res.reason}"
 
     def __indexphp_test(self, site: Site) -> Tuple[bool, str]:
         """
@@ -236,6 +231,32 @@ class SiteChain(ChainBase):
         site.url = f"{site.url}index.php"
         return self.__test(site)
 
+    @staticmethod
+    def __hddolby_test(site: Site) -> Tuple[bool, str]:
+        """
+        判断站点是否已经登陆：hddolby
+        """
+        url = f"{site.url}api/v1/user/data"
+        headers = {
+            "Content-Type": "application/json",
+            "Accept": "application/json, text/plain, */*",
+            "x-api-key": site.apikey,
+        }
+        res = RequestUtils(
+            headers=headers,
+            proxies=settings.PROXY if site.proxy else None,
+            timeout=site.timeout or 15
+        ).get_res(url=url)
+        if res is None:
+            return False, "无法打开网站！"
+        if res.status_code == 200:
+            user_info = res.json()
+            if user_info and user_info.get("status") == 0:
+                return True, "连接成功"
+            return False, "APIKEY已过期"
+        else:
+            return False, f"错误：{res.status_code} {res.reason}"
+
     @staticmethod
     def __parse_favicon(url: str, cookie: str, ua: str) -> Tuple[str, Optional[str]]:
         """
@@ -557,18 +578,18 @@ class SiteChain(ChainBase):
                     elif res.status_code == 200:
                         msg = "Cookie已失效"
                     else:
-                        msg = f"状态码：{res.status_code}"
+                        msg = f"错误：{res.status_code} {res.reason}"
                     return False, f"{msg}！"
                 elif public and res.status_code != 200:
-                    return False, f"状态码：{res.status_code}！"
+                    return False, f"错误：{res.status_code} {res.reason}！"
             elif res is not None:
-                return False, f"状态码：{res.status_code}！"
+                return False, f"错误：{res.status_code} {res.reason}！"
             else:
                 return False, f"无法打开网站！"
         return True, "连接成功"
 
     def remote_list(self, channel: MessageChannel,
-                    userid: Union[str, int] = None, source: str = None):
+                    userid: Union[str, int] = None, source: Optional[str] = None):
         """
         查询所有站点，发送消息
         """
@@ -602,7 +623,7 @@ class SiteChain(ChainBase):
         )
 
     def remote_disable(self, arg_str: str, channel: MessageChannel,
-                       userid: Union[str, int] = None, source: str = None):
+                       userid: Union[str, int] = None, source: Optional[str] = None):
         """
         禁用站点
         """
@@ -627,7 +648,7 @@ class SiteChain(ChainBase):
         self.remote_list(channel=channel, userid=userid, source=source)
 
     def remote_enable(self, arg_str: str, channel: MessageChannel,
-                      userid: Union[str, int] = None, source: str = None):
+                      userid: Union[str, int] = None, source: Optional[str] = None):
         """
         启用站点
         """
@@ -653,7 +674,7 @@ class SiteChain(ChainBase):
         self.remote_list(channel=channel, userid=userid, source=source)
 
     def update_cookie(self, site_info: Site,
-                      username: str, password: str, two_step_code: str = None) -> Tuple[bool, str]:
+                      username: str, password: str, two_step_code: Optional[str] = None) -> Tuple[bool, str]:
         """
         根据用户名密码更新站点Cookie
         :param site_info: 站点信息
@@ -682,7 +703,7 @@ class SiteChain(ChainBase):
         return False, "未知错误"
 
     def remote_cookie(self, arg_str: str, channel: MessageChannel,
-                      userid: Union[str, int] = None, source: str = None):
+                      userid: Union[str, int] = None, source: Optional[str] = None):
         """
         使用用户名密码更新站点Cookie
         """
@@ -752,7 +773,7 @@ class SiteChain(ChainBase):
                 userid=userid))
 
     def remote_refresh_userdatas(self, channel: MessageChannel,
-                                 userid: Union[str, int] = None, source: str = None):
+                                 userid: Union[str, int] = None, source: Optional[str] = None):
         """
         刷新所有站点用户数据
         """

app/chain/storage.py

@@ -63,7 +63,7 @@ class StorageChain(ChainBase):
         return self.run_module("download_file", fileitem=fileitem, path=path)
 
     def upload_file(self, fileitem: schemas.FileItem, path: Path,
-                    new_name: str = None) -> Optional[schemas.FileItem]:
+                    new_name: Optional[str] = None) -> Optional[schemas.FileItem]:
         """
         上传文件
         :param fileitem: 保存目录项
@@ -84,6 +84,12 @@ class StorageChain(ChainBase):
         """
         return self.run_module("rename_file", fileitem=fileitem, name=name)
 
+    def exists(self, fileitem: schemas.FileItem) -> Optional[bool]:
+        """
+        判断文件或目录是否存在
+        """
+        return True if self.get_item(fileitem) else False
+
     def get_item(self, fileitem: schemas.FileItem) -> Optional[schemas.FileItem]:
         """
         查询目录或文件

app/chain/subscribe.py

@@ -6,6 +6,7 @@ import time
 from datetime import datetime
 from typing import Dict, List, Optional, Union, Tuple
 
+from app import schemas
 from app.chain import ChainBase
 from app.chain.download import DownloadChain
 from app.chain.media import MediaChain
@@ -27,9 +28,8 @@ from app.helper.message import MessageHelper
 from app.helper.subscribe import SubscribeHelper
 from app.helper.torrent import TorrentHelper
 from app.log import logger
-from app.schemas import NotExistMediaInfo, Notification, SubscrbieInfo, SubscribeEpisodeInfo, SubscribeDownloadFileInfo, \
-    SubscribeLibraryFileInfo
-from app.schemas.types import MediaType, SystemConfigKey, MessageChannel, NotificationType, EventType
+from app.schemas import MediaRecognizeConvertEventData
+from app.schemas.types import MediaType, SystemConfigKey, MessageChannel, NotificationType, EventType, ChainEventType
 from app.utils.singleton import Singleton
 
 
@@ -56,21 +56,45 @@ class SubscribeChain(ChainBase, metaclass=Singleton):
 
     def add(self, title: str, year: str,
             mtype: MediaType = None,
-            tmdbid: int = None,
-            doubanid: str = None,
-            bangumiid: int = None,
-            season: int = None,
+            tmdbid: Optional[int] = None,
+            doubanid: Optional[str] = None,
+            bangumiid: Optional[int] = None,
+            mediaid: Optional[str] = None,
+            episode_group: Optional[str] = None,
+            season: Optional[int] = None,
             channel: MessageChannel = None,
-            source: str = None,
-            userid: str = None,
-            username: str = None,
-            message: bool = True,
-            exist_ok: bool = False,
+            source: Optional[str] = None,
+            userid: Optional[str] = None,
+            username: Optional[str] = None,
+            message: Optional[bool] = True,
+            exist_ok: Optional[bool] = False,
             **kwargs) -> Tuple[Optional[int], str]:
         """
         识别媒体信息并添加订阅
         """
+
+        def __get_event_meida(_mediaid: str, _meta: MetaBase) -> Optional[MediaInfo]:
+            """
+            广播事件解析媒体信息
+            """
+            event_data = MediaRecognizeConvertEventData(
+                mediaid=_mediaid,
+                convert_type=settings.RECOGNIZE_SOURCE
+            )
+            event = eventmanager.send_event(ChainEventType.MediaRecognizeConvert, event_data)
+            # 使用事件返回的上下文数据
+            if event and event.event_data:
+                event_data: MediaRecognizeConvertEventData = event.event_data
+                if event_data.media_dict:
+                    new_id = event_data.media_dict.get("id")
+                    if event_data.convert_type == "themoviedb":
+                        return self.mediachain.recognize_media(meta=_meta, tmdbid=new_id)
+                    elif event_data.convert_type == "douban":
+                        return self.mediachain.recognize_media(meta=_meta, doubanid=new_id)
+            return None
+
         logger.info(f'开始添加订阅，标题：{title} ...')
+
         mediainfo = None
         metainfo = MetaInfo(title)
         if year:
@@ -83,39 +107,55 @@ class SubscribeChain(ChainBase, metaclass=Singleton):
         # 识别媒体信息
         if settings.RECOGNIZE_SOURCE == "themoviedb":
             # TMDB识别模式
-            if not tmdbid and doubanid:
-                # 将豆瓣信息转换为TMDB信息
-                tmdbinfo = self.mediachain.get_tmdbinfo_by_doubanid(doubanid=doubanid, mtype=mtype)
-                if tmdbinfo:
-                    mediainfo = MediaInfo(tmdb_info=tmdbinfo)
+            if not tmdbid:
+                if doubanid:
+                    # 将豆瓣信息转换为TMDB信息
+                    tmdbinfo = self.mediachain.get_tmdbinfo_by_doubanid(doubanid=doubanid, mtype=mtype)
+                    if tmdbinfo:
+                        mediainfo = MediaInfo(tmdb_info=tmdbinfo)
+                elif mediaid:
+                    # 未知前缀，广播事件解析媒体信息
+                    mediainfo = __get_event_meida(mediaid, metainfo)
             else:
-                # 识别TMDB信息，不使用缓存
-                mediainfo = self.recognize_media(meta=metainfo, mtype=mtype, tmdbid=tmdbid, cache=False)
+                # 使用TMDBID识别
+                mediainfo = self.recognize_media(meta=metainfo, mtype=mtype, tmdbid=tmdbid,
+                                                 episode_group=episode_group, cache=False)
         else:
-            # 豆瓣识别模式，不使用缓存
-            mediainfo = self.recognize_media(meta=metainfo, mtype=mtype, doubanid=doubanid, cache=False)
+            if doubanid:
+                # 豆瓣识别模式，不使用缓存
+                mediainfo = self.recognize_media(meta=metainfo, mtype=mtype, doubanid=doubanid, cache=False)
+            elif mediaid:
+                # 未知前缀，广播事件解析媒体信息
+                mediainfo = __get_event_meida(mediaid, metainfo)
             if mediainfo:
                 # 豆瓣标题处理
                 meta = MetaInfo(mediainfo.title)
                 mediainfo.title = meta.name
                 if not season:
                     season = meta.begin_season
+
+        # 使用名称识别兜底
+        if not mediainfo:
+            mediainfo = self.recognize_media(meta=metainfo, episode_group=episode_group)
+
         # 识别失败
         if not mediainfo:
             logger.warn(f'未识别到媒体信息，标题：{title}，tmdbid：{tmdbid}，doubanid：{doubanid}')
             return None, "未识别到媒体信息"
+
         # 总集数
         if mediainfo.type == MediaType.TV:
             if not season:
                 season = 1
             # 总集数
             if not kwargs.get('total_episode'):
-                if not mediainfo.seasons:
+                if not mediainfo.seasons or episode_group:
                     # 补充媒体信息
                     mediainfo = self.recognize_media(mtype=mediainfo.type,
                                                      tmdbid=mediainfo.tmdb_id,
                                                      doubanid=mediainfo.douban_id,
                                                      bangumiid=mediainfo.bangumi_id,
+                                                     episode_group=episode_group,
                                                      cache=False)
                     if not mediainfo:
                         logger.error(f"媒体信息识别失败！")
@@ -138,6 +178,7 @@ class SubscribeChain(ChainBase, metaclass=Singleton):
         else:
             # 避免season为0的问题
             season = None
+
         # 更新媒体图片
         self.obtain_images(mediainfo=mediainfo)
         # 合并信息
@@ -145,6 +186,7 @@ class SubscribeChain(ChainBase, metaclass=Singleton):
             mediainfo.douban_id = doubanid
         if bangumiid:
             mediainfo.bangumi_id = bangumiid
+
         # 添加订阅
         kwargs.update({
             'quality': self.__get_default_subscribe_config(mediainfo.type, "quality") if not kwargs.get(
@@ -166,21 +208,24 @@ class SubscribeChain(ChainBase, metaclass=Singleton):
             'downloader': self.__get_default_subscribe_config(mediainfo.type, "downloader") if not kwargs.get(
                 "downloader") else kwargs.get("downloader"),
             'save_path': self.__get_default_subscribe_config(mediainfo.type, "save_path") if not kwargs.get(
-                "save_path") else kwargs.get("save_path")
+                "save_path") else kwargs.get("save_path"),
+            'filter_groups': self.__get_default_subscribe_config(mediainfo.type, "filter_groups") if not kwargs.get(
+                "filter_groups") else kwargs.get("filter_groups")
         })
+        # 操作数据库
         sid, err_msg = self.subscribeoper.add(mediainfo=mediainfo, season=season, username=username, **kwargs)
         if not sid:
             logger.error(f'{mediainfo.title_year} {err_msg}')
             if not exist_ok and message:
                 # 失败发回原用户
-                self.post_message(Notification(channel=channel,
-                                               source=source,
-                                               mtype=NotificationType.Subscribe,
-                                               title=f"{mediainfo.title_year} {metainfo.season} "
-                                                     f"添加订阅失败！",
-                                               text=f"{err_msg}",
-                                               image=mediainfo.get_message_image(),
-                                               userid=userid))
+                self.post_message(schemas.Notification(channel=channel,
+                                                       source=source,
+                                                       mtype=NotificationType.Subscribe,
+                                                       title=f"{mediainfo.title_year} {metainfo.season} "
+                                                             f"添加订阅失败！",
+                                                       text=f"{err_msg}",
+                                                       image=mediainfo.get_message_image(),
+                                                       userid=userid))
             return None, err_msg
         elif message:
             logger.info(f'{mediainfo.title_year} {metainfo.season} 添加订阅成功')
@@ -193,12 +238,12 @@ class SubscribeChain(ChainBase, metaclass=Singleton):
             else:
                 link = settings.MP_DOMAIN('#/subscribe/movie?tab=mysub')
             # 订阅成功按规则发送消息
-            self.post_message(Notification(mtype=NotificationType.Subscribe,
-                                           title=f"{mediainfo.title_year} {metainfo.season} 已添加订阅",
-                                           text=text,
-                                           image=mediainfo.get_message_image(),
-                                           link=link,
-                                           username=username))
+            self.post_message(schemas.Notification(mtype=NotificationType.Subscribe,
+                                                   title=f"{mediainfo.title_year} {metainfo.season} 已添加订阅",
+                                                   text=text,
+                                                   image=mediainfo.get_message_image(),
+                                                   link=link,
+                                                   username=username))
         # 发送事件
         EventManager().send_event(EventType.SubscribeAdded, {
             "subscribe_id": sid,
@@ -234,7 +279,7 @@ class SubscribeChain(ChainBase, metaclass=Singleton):
             return True
         return False
 
-    def search(self, sid: int = None, state: str = 'N', manual: bool = False):
+    def search(self, sid: Optional[int] = None, state: Optional[str] = 'N', manual: Optional[bool] = False):
         """
         订阅搜索
         :param sid: 订阅ID，有值时只处理该订阅
@@ -282,6 +327,7 @@ class SubscribeChain(ChainBase, metaclass=Singleton):
                     mediainfo: MediaInfo = self.recognize_media(meta=meta, mtype=meta.type,
                                                                 tmdbid=subscribe.tmdbid,
                                                                 doubanid=subscribe.doubanid,
+                                                                episode_group=subscribe.episode_group,
                                                                 cache=False)
                     if not mediainfo:
                         logger.warn(
@@ -289,7 +335,8 @@ class SubscribeChain(ChainBase, metaclass=Singleton):
                         continue
 
                     # 如果媒体已存在或已下载完毕，跳过当前订阅处理
-                    exist_flag, no_exists = self.check_and_handle_existing_media(subscribe=subscribe, meta=meta,
+                    exist_flag, no_exists = self.check_and_handle_existing_media(subscribe=subscribe,
+                                                                                 meta=meta,
                                                                                  mediainfo=mediainfo,
                                                                                  mediakey=mediakey)
                     if exist_flag:
@@ -341,6 +388,11 @@ class SubscribeChain(ChainBase, metaclass=Singleton):
                                 logger.info(
                                     f'{subscribe.name} 正在洗版，{torrent_info.title} 优先级低于或等于已下载优先级')
                                 continue
+                        # 更新订阅自定义属性
+                        if subscribe.media_category:
+                            torrent_mediainfo.category = subscribe.media_category
+                        if subscribe.episode_group:
+                            torrent_mediainfo.episode_group = subscribe.episode_group
                         matched_contexts.append(context)
 
                     if not matched_contexts:
@@ -356,7 +408,6 @@ class SubscribeChain(ChainBase, metaclass=Singleton):
                         userid=subscribe.username,
                         username=subscribe.username,
                         save_path=subscribe.save_path,
-                        media_category=subscribe.media_category,
                         downloader=subscribe.downloader,
                         source=self.get_subscribe_source_keyword(subscribe)
                     )
@@ -385,7 +436,7 @@ class SubscribeChain(ChainBase, metaclass=Singleton):
             logger.debug(f"search Lock released at {datetime.now()}")
 
     def update_subscribe_priority(self, subscribe: Subscribe, meta: MetaBase,
-                                  mediainfo: MediaInfo, downloads: List[Context]):
+                                  mediainfo: MediaInfo, downloads: Optional[List[Context]]):
         """
         更新订阅已下载资源的优先级
         """
@@ -409,8 +460,8 @@ class SubscribeChain(ChainBase, metaclass=Singleton):
 
     def finish_subscribe_or_not(self, subscribe: Subscribe, meta: MetaBase, mediainfo: MediaInfo,
                                 downloads: List[Context] = None,
-                                lefts: Dict[Union[int | str], Dict[int, NotExistMediaInfo]] = None,
-                                force: bool = False):
+                                lefts: Dict[Union[int | str], Dict[int, schemas.NotExistMediaInfo]] = None,
+                                force: Optional[bool] = False):
         """
         判断是否应完成订阅
         """
@@ -464,18 +515,16 @@ class SubscribeChain(ChainBase, metaclass=Singleton):
         """
         # 从系统配置获取默认订阅站点
         default_sites = self.systemconfig.get(SystemConfigKey.RssSites) or []
-        # 如果订阅未指定站点信息，直接返回默认站点
+        # 如果订阅未指定站点，直接返回默认站点
         if not subscribe.sites:
             return default_sites
+        # 如果默认订阅站点未设置，直接返回订阅指定站点
+        if not default_sites:
+            return subscribe.sites or []
         # 尝试解析订阅中的站点数据
         user_sites = subscribe.sites
         # 计算 user_sites 和 default_sites 的交集
         intersection_sites = [site for site in user_sites if site in default_sites]
-        # 如果交集与原始订阅不一致，更新数据库
-        if set(intersection_sites) != set(user_sites):
-            self.subscribeoper.update(subscribe.id, {
-                "sites": intersection_sites
-            })
         # 如果交集为空，返回默认站点
         return intersection_sites if intersection_sites else default_sites
 
@@ -534,6 +583,7 @@ class SubscribeChain(ChainBase, metaclass=Singleton):
                 mediainfo: MediaInfo = self.recognize_media(meta=meta, mtype=meta.type,
                                                             tmdbid=subscribe.tmdbid,
                                                             doubanid=subscribe.doubanid,
+                                                            episode_group=subscribe.episode_group,
                                                             cache=False)
                 if not mediainfo:
                     logger.warn(
@@ -563,9 +613,10 @@ class SubscribeChain(ChainBase, metaclass=Singleton):
                     logger.debug(f'开始匹配站点：{domain}，共缓存了 {len(contexts)} 个种子...')
                     for context in contexts:
                         # 提取信息
-                        torrent_meta = copy.deepcopy(context.meta_info)
-                        torrent_mediainfo = copy.deepcopy(context.media_info)
-                        torrent_info = context.torrent_info
+                        _context = copy.deepcopy(context)
+                        torrent_meta = _context.meta_info
+                        torrent_mediainfo = _context.media_info
+                        torrent_info = _context.torrent_info
 
                         # 不在订阅站点范围的不处理
                         sub_sites = self.get_sub_sites(subscribe)
@@ -574,9 +625,9 @@ class SubscribeChain(ChainBase, metaclass=Singleton):
                             continue
 
                         # 有自定义识别词时，需要判断是否需要重新识别
-                        apply_words = None
                         if custom_words_list:
-                            _, apply_words = WordsMatcher().prepare(torrent_info.title,
+                            # 使用org_string，应用一次后理论上不能再次应用
+                            _, apply_words = WordsMatcher().prepare(torrent_meta.org_string,
                                                                     custom_words=custom_words_list)
                             if apply_words:
                                 logger.info(
@@ -584,6 +635,8 @@ class SubscribeChain(ChainBase, metaclass=Singleton):
                                 # 重新识别元数据
                                 torrent_meta = MetaInfo(title=torrent_info.title, subtitle=torrent_info.description,
                                                         custom_words=custom_words_list)
+                                # 更新元数据缓存
+                                context.meta_info = torrent_meta
                                 # 媒体信息需要重新识别
                                 torrent_mediainfo = None
 
@@ -591,11 +644,11 @@ class SubscribeChain(ChainBase, metaclass=Singleton):
                         if not torrent_mediainfo \
                                 or (not torrent_mediainfo.tmdb_id and not torrent_mediainfo.douban_id):
                             # 重新识别媒体信息
-                            torrent_mediainfo = self.recognize_media(meta=torrent_meta)
+                            torrent_mediainfo = self.recognize_media(meta=torrent_meta,
+                                                                     episode_group=subscribe.episode_group)
                             if torrent_mediainfo:
                                 # 更新种子缓存
-                                if not apply_words:
-                                    context.media_info = torrent_mediainfo
+                                context.media_info = torrent_mediainfo
                             else:
                                 # 通过标题匹配兜底
                                 logger.warn(
@@ -607,9 +660,7 @@ class SubscribeChain(ChainBase, metaclass=Singleton):
                                     logger.info(
                                         f'{mediainfo.title_year} 通过标题匹配到可选资源：{torrent_info.site_name} - {torrent_info.title}')
                                     torrent_mediainfo = mediainfo
-                                    # 更新种子缓存
-                                    if not apply_words:
-                                        context.media_info = mediainfo
+                                    context.media_info = torrent_mediainfo
                                 else:
                                     continue
 
@@ -697,7 +748,12 @@ class SubscribeChain(ChainBase, metaclass=Singleton):
 
                         # 匹配成功
                         logger.info(f'{mediainfo.title_year} 匹配成功：{torrent_info.title}')
-                        _match_context.append(context)
+                        # 自定义属性
+                        if subscribe.media_category:
+                            torrent_mediainfo.category = subscribe.media_category
+                        if subscribe.episode_group:
+                            torrent_mediainfo.episode_group = subscribe.episode_group
+                        _match_context.append(_context)
 
                 if not _match_context:
                     # 未匹配到资源
@@ -713,7 +769,6 @@ class SubscribeChain(ChainBase, metaclass=Singleton):
                                                                      userid=subscribe.username,
                                                                      username=subscribe.username,
                                                                      save_path=subscribe.save_path,
-                                                                     media_category=subscribe.media_category,
                                                                      downloader=subscribe.downloader,
                                                                      source=self.get_subscribe_source_keyword(subscribe)
                                                                      )
@@ -754,6 +809,7 @@ class SubscribeChain(ChainBase, metaclass=Singleton):
             mediainfo: MediaInfo = self.recognize_media(meta=meta, mtype=meta.type,
                                                         tmdbid=subscribe.tmdbid,
                                                         doubanid=subscribe.doubanid,
+                                                        episode_group=subscribe.episode_group,
                                                         cache=False)
             if not mediainfo:
                 logger.warn(
@@ -784,7 +840,69 @@ class SubscribeChain(ChainBase, metaclass=Singleton):
             })
             logger.info(f'{subscribe.name} 订阅元数据更新完成')
 
-    def __update_subscribe_note(self, subscribe: Subscribe, downloads: List[Context]):
+    def follow(self):
+        """
+        刷新follow的用户分享，并自动添加订阅
+        """
+        follow_users: List[str] = self.systemconfig.get(SystemConfigKey.FollowSubscribers)
+        if not follow_users:
+            return
+        share_subs = self.subscribehelper.get_shares()
+        logger.info(f'开始刷新follow用户分享订阅 ...')
+        success_count = 0
+        for share_sub in share_subs:
+            uid = share_sub.get("share_uid")
+            if uid and uid in follow_users:
+                # 订阅已存在则跳过
+                if self.subscribeoper.exists(tmdbid=share_sub.get("tmdbid"),
+                                             doubanid=share_sub.get("doubanid"),
+                                             season=share_sub.get("season")):
+                    continue
+                # 已经订阅过跳过
+                if self.subscribeoper.exist_history(tmdbid=share_sub.get("tmdbid"),
+                                                    doubanid=share_sub.get("doubanid"),
+                                                    season=share_sub.get("season")):
+                    continue
+                # 去除无效属性
+                for key in list(share_sub.keys()):
+                    if not hasattr(schemas.Subscribe(), key):
+                        share_sub.pop(key)
+                # 类型转换
+                subscribe_in = schemas.Subscribe(**share_sub)
+                mtype = MediaType(subscribe_in.type)
+                # 豆瓣标题处理
+                if subscribe_in.doubanid or subscribe_in.bangumiid:
+                    meta = MetaInfo(subscribe_in.name)
+                    subscribe_in.name = meta.name
+                    subscribe_in.season = meta.begin_season
+                # 标题转换
+                if subscribe_in.name:
+                    title = subscribe_in.name
+                else:
+                    title = None
+                sid, message = SubscribeChain().add(mtype=mtype,
+                                                    title=title,
+                                                    year=subscribe_in.year,
+                                                    tmdbid=subscribe_in.tmdbid,
+                                                    season=subscribe_in.season,
+                                                    doubanid=subscribe_in.doubanid,
+                                                    bangumiid=subscribe_in.bangumiid,
+                                                    username="订阅分享",
+                                                    best_version=subscribe_in.best_version,
+                                                    save_path=subscribe_in.save_path,
+                                                    search_imdbid=subscribe_in.search_imdbid,
+                                                    custom_words=subscribe_in.custom_words,
+                                                    media_category=subscribe_in.media_category,
+                                                    filter_groups=subscribe_in.filter_groups,
+                                                    exist_ok=True)
+                if sid:
+                    success_count += 1
+                    logger.info(f'follow用户分享订阅 {title} 添加成功')
+                else:
+                    logger.error(f'follow用户分享订阅 {title} 添加失败：{message}')
+        logger.info(f'follow用户分享订阅刷新完成，共添加 {success_count} 个订阅')
+
+    def __update_subscribe_note(self, subscribe: Subscribe, downloads: Optional[List[Context]]):
         """
         更新已下载信息到note字段
         """
@@ -840,10 +958,10 @@ class SubscribeChain(ChainBase, metaclass=Singleton):
             return note
         return []
 
-    def __update_lack_episodes(self, lefts: Dict[Union[int, str], Dict[int, NotExistMediaInfo]],
+    def __update_lack_episodes(self, lefts: Dict[Union[int, str], Dict[int, schemas.NotExistMediaInfo]],
                                subscribe: Subscribe,
                                mediainfo: MediaInfo,
-                               update_date: bool = False):
+                               update_date: Optional[bool] = False):
         """
         更新订阅剩余集数及时间
         """
@@ -895,11 +1013,11 @@ class SubscribeChain(ChainBase, metaclass=Singleton):
         else:
             link = settings.MP_DOMAIN('#/subscribe/movie?tab=mysub')
         # 完成订阅按规则发送消息
-        self.post_message(Notification(mtype=NotificationType.Subscribe,
-                                       title=f'{mediainfo.title_year} {meta.season} 已完成{msgstr}',
-                                       image=mediainfo.get_message_image(),
-                                       link=link,
-                                       username=subscribe.username))
+        self.post_message(schemas.Notification(mtype=NotificationType.Subscribe,
+                                               title=f'{mediainfo.title_year} {meta.season} 已完成{msgstr}',
+                                               image=mediainfo.get_message_image(),
+                                               link=link,
+                                               username=subscribe.username))
         # 发送事件
         EventManager().send_event(EventType.SubscribeComplete, {
             "subscribe_id": subscribe.id,
@@ -913,15 +1031,15 @@ class SubscribeChain(ChainBase, metaclass=Singleton):
         })
 
     def remote_list(self, channel: MessageChannel,
-                    userid: Union[str, int] = None, source: str = None):
+                    userid: Union[str, int] = None, source: Optional[str] = None):
         """
         查询订阅并发送消息
         """
         subscribes = self.subscribeoper.list()
         if not subscribes:
-            self.post_message(Notification(channel=channel,
-                                           source=source,
-                                           title='没有任何订阅！', userid=userid))
+            self.post_message(schemas.Notification(channel=channel,
+                                                   source=source,
+                                                   title='没有任何订阅！', userid=userid))
             return
         title = f"共有 {len(subscribes)} 个订阅，回复对应指令操作： " \
                 f"\n- 删除订阅：/subscribe_delete [id]" \
@@ -937,18 +1055,18 @@ class SubscribeChain(ChainBase, metaclass=Singleton):
                                 f"[{subscribe.total_episode - (subscribe.lack_episode or subscribe.total_episode)}"
                                 f"/{subscribe.total_episode}]")
         # 发送列表
-        self.post_message(Notification(channel=channel, source=source,
-                                       title=title, text='\n'.join(messages), userid=userid))
+        self.post_message(schemas.Notification(channel=channel, source=source,
+                                               title=title, text='\n'.join(messages), userid=userid))
 
     def remote_delete(self, arg_str: str, channel: MessageChannel,
-                      userid: Union[str, int] = None, source: str = None):
+                      userid: Union[str, int] = None, source: Optional[str] = None):
         """
         删除订阅
         """
         if not arg_str:
-            self.post_message(Notification(channel=channel, source=source,
-                                           title="请输入正确的命令格式：/subscribe_delete [id]，"
-                                                 "[id]为订阅编号", userid=userid))
+            self.post_message(schemas.Notification(channel=channel, source=source,
+                                                   title="请输入正确的命令格式：/subscribe_delete [id]，"
+                                                         "[id]为订阅编号", userid=userid))
             return
         arg_strs = str(arg_str).split()
         for arg_str in arg_strs:
@@ -958,8 +1076,8 @@ class SubscribeChain(ChainBase, metaclass=Singleton):
             subscribe_id = int(arg_str)
             subscribe = self.subscribeoper.get(subscribe_id)
             if not subscribe:
-                self.post_message(Notification(channel=channel, source=source,
-                                               title=f"订阅编号 {subscribe_id} 不存在！", userid=userid))
+                self.post_message(schemas.Notification(channel=channel, source=source,
+                                                       title=f"订阅编号 {subscribe_id} 不存在！", userid=userid))
                 return
             # 删除订阅
             self.subscribeoper.delete(subscribe_id)
@@ -973,13 +1091,13 @@ class SubscribeChain(ChainBase, metaclass=Singleton):
 
     @staticmethod
     def __get_subscribe_no_exits(subscribe_name: str,
-                                 no_exists: Dict[Union[int, str], Dict[int, NotExistMediaInfo]],
+                                 no_exists: Dict[Union[int, str], Dict[int, schemas.NotExistMediaInfo]],
                                  mediakey: Union[str, int],
                                  begin_season: int,
-                                 total_episode: int,
-                                 start_episode: int,
+                                 total_episode: Optional[int],
+                                 start_episode: Optional[int],
                                  downloaded_episodes: List[int] = None
-                                 ) -> Tuple[bool, Dict[Union[int, str], Dict[int, NotExistMediaInfo]]]:
+                                 ) -> Tuple[bool, Dict[Union[int, str], Dict[int, schemas.NotExistMediaInfo]]]:
         """
         根据订阅开始集数和总集数，结合TMDB信息计算当前订阅的缺失集数
         :param subscribe_name: 订阅名称
@@ -1029,7 +1147,7 @@ class SubscribeChain(ChainBase, metaclass=Singleton):
                     # 与原集列表取交集
                     episodes = list(set(episode_list).intersection(set(new_episodes)))
                 # 更新集合
-                no_exists[mediakey][begin_season] = NotExistMediaInfo(
+                no_exists[mediakey][begin_season] = schemas.NotExistMediaInfo(
                     season=begin_season,
                     episodes=episodes,
                     total_episode=total_episode,
@@ -1056,7 +1174,7 @@ class SubscribeChain(ChainBase, metaclass=Singleton):
                 if not episodes:
                     return True, {}
                 # 更新集合
-                no_exists[mediakey][begin_season] = NotExistMediaInfo(
+                no_exists[mediakey][begin_season] = schemas.NotExistMediaInfo(
                     season=begin_season,
                     episodes=episodes,
                     total_episode=total,
@@ -1070,7 +1188,7 @@ class SubscribeChain(ChainBase, metaclass=Singleton):
                 # 如果存在已下载剧集，则差集为空时，说明所有均已存在
                 if not episodes:
                     return True, {}
-                no_exists[mediakey][begin_season] = NotExistMediaInfo(
+                no_exists[mediakey][begin_season] = schemas.NotExistMediaInfo(
                     season=begin_season,
                     episodes=episodes,
                     total_episode=total_episode,
@@ -1157,27 +1275,28 @@ class SubscribeChain(ChainBase, metaclass=Singleton):
                 "min_seeders_time": default_rule.get("min_seeders_time"),
             }.items() if value is not None}
 
-    def subscribe_files_info(self, subscribe: Subscribe) -> Optional[SubscrbieInfo]:
+    def subscribe_files_info(self, subscribe: Subscribe) -> Optional[schemas.SubscrbieInfo]:
         """
         订阅相关的下载和文件信息
         """
         if not subscribe:
-            return
+            return None
 
         # 返回订阅数据
-        subscribe_info = SubscrbieInfo()
+        subscribe_info = schemas.SubscrbieInfo()
 
         # 所有集的数据
-        episodes: Dict[int, SubscribeEpisodeInfo] = {}
+        episodes: Dict[int, schemas.SubscribeEpisodeInfo] = {}
         if subscribe.tmdbid and subscribe.type == MediaType.TV.value:
             # 查询TMDB中的集信息
             tmdb_episodes = self.tmdbchain.tmdb_episodes(
                 tmdbid=subscribe.tmdbid,
-                season=subscribe.season
+                season=subscribe.season,
+                episode_group=subscribe.episode_group
             )
             if tmdb_episodes:
                 for episode in tmdb_episodes:
-                    info = SubscribeEpisodeInfo()
+                    info = schemas.SubscribeEpisodeInfo()
                     info.title = episode.name
                     info.description = episode.overview
                     info.backdrop = f"https://{settings.TMDB_IMAGE_DOMAIN}/t/p/w500${episode.still_path}"
@@ -1185,12 +1304,12 @@ class SubscribeChain(ChainBase, metaclass=Singleton):
         elif subscribe.type == MediaType.TV.value:
             # 根据开始结束集计算集信息
             for i in range(subscribe.start_episode or 1, subscribe.total_episode + 1):
-                info = SubscribeEpisodeInfo()
+                info = schemas.SubscribeEpisodeInfo()
                 info.title = f'第 {i} 集'
                 episodes[i] = info
         else:
             # 电影
-            info = SubscribeEpisodeInfo()
+            info = schemas.SubscribeEpisodeInfo()
             info.title = subscribe.name
             episodes[0] = info
 
@@ -1205,7 +1324,7 @@ class SubscribeChain(ChainBase, metaclass=Singleton):
                         # 识别文件名
                         file_meta = MetaInfo(file.filepath)
                         # 下载文件信息
-                        file_info = SubscribeDownloadFileInfo(
+                        file_info = schemas.SubscribeDownloadFileInfo(
                             torrent_title=his.torrent_name,
                             site_name=his.torrent_site,
                             downloader=file.downloader,
@@ -1235,6 +1354,7 @@ class SubscribeChain(ChainBase, metaclass=Singleton):
         mediainfo: MediaInfo = self.recognize_media(meta=meta, mtype=meta.type,
                                                     tmdbid=subscribe.tmdbid,
                                                     doubanid=subscribe.doubanid,
+                                                    episode_group=subscribe.episode_group,
                                                     cache=False)
         if not mediainfo:
             logger.warn(
@@ -1248,7 +1368,7 @@ class SubscribeChain(ChainBase, metaclass=Singleton):
                 # 识别文件名
                 file_meta = MetaInfo(fileitem.path)
                 # 媒体库文件信息
-                file_info = SubscribeLibraryFileInfo(
+                file_info = schemas.SubscribeLibraryFileInfo(
                     storage=fileitem.storage,
                     file_path=fileitem.path,
                 )
@@ -1268,7 +1388,7 @@ class SubscribeChain(ChainBase, metaclass=Singleton):
         return subscribe_info
 
     def check_and_handle_existing_media(self, subscribe: Subscribe, meta: MetaBase,
-                                        mediainfo: MediaInfo, mediakey: str):
+                                        mediainfo: MediaInfo, mediakey: Union[str, int]):
         """
         检查媒体是否已经存在，并根据情况执行相应的操作
         1. 查询缺失的媒体信息
@@ -1308,7 +1428,7 @@ class SubscribeChain(ChainBase, metaclass=Singleton):
                     # 对于电视剧，构造缺失的媒体信息
                     no_exists = {
                         mediakey: {
-                            subscribe.season: NotExistMediaInfo(
+                            subscribe.season: schemas.NotExistMediaInfo(
                                 season=subscribe.season,
                                 episodes=[],
                                 total_episode=subscribe.total_episode,

app/chain/system.py

@@ -1,7 +1,7 @@
 import json
 import re
 from pathlib import Path
-from typing import Union
+from typing import Union, Optional
 
 from app.chain import ChainBase
 from app.core.config import settings
@@ -25,7 +25,7 @@ class SystemChain(ChainBase, metaclass=Singleton):
         # 重启完成检测
         self.restart_finish()
 
-    def remote_clear_cache(self, channel: MessageChannel, userid: Union[int, str], source: str = None):
+    def remote_clear_cache(self, channel: MessageChannel, userid: Union[int, str], source: Optional[str] = None):
         """
         清理系统缓存
         """
@@ -33,7 +33,7 @@ class SystemChain(ChainBase, metaclass=Singleton):
         self.post_message(Notification(channel=channel, source=source,
                                        title=f"缓存清理完成！", userid=userid))
 
-    def restart(self, channel: MessageChannel, userid: Union[int, str], source: str = None):
+    def restart(self, channel: MessageChannel, userid: Union[int, str], source: Optional[str] = None):
         """
         重启系统
         """
@@ -65,7 +65,7 @@ class SystemChain(ChainBase, metaclass=Singleton):
             title += f"当前前端版本：{front_local_version}，远程版本：{front_release_version}"
         return title
 
-    def version(self, channel: MessageChannel, userid: Union[int, str], source: str = None):
+    def version(self, channel: MessageChannel, userid: Union[int, str], source: Optional[str] = None):
         """
         查看当前版本、远程版本
         """

app/chain/tmdb.py

@@ -1,10 +1,9 @@
 import random
 from typing import Optional, List
 
-from cachetools import cached, TTLCache
-
 from app import schemas
 from app.chain import ChainBase
+from app.core.cache import cached
 from app.core.context import MediaInfo
 from app.schemas import MediaType
 from app.utils.singleton import Singleton
@@ -15,22 +14,41 @@ class TmdbChain(ChainBase, metaclass=Singleton):
     TheMovieDB处理链，单例运行
     """
 
-    def tmdb_discover(self, mtype: MediaType, sort_by: str, with_genres: str,
-                      with_original_language: str, page: int = 1) -> Optional[List[MediaInfo]]:
+    def tmdb_discover(self, mtype: MediaType,
+                      sort_by: str,
+                      with_genres: str,
+                      with_original_language: str,
+                      with_keywords: str,
+                      with_watch_providers: str,
+                      vote_average: float,
+                      vote_count: int,
+                      release_date: str,
+                      page: Optional[int] = 1) -> Optional[List[MediaInfo]]:
         """
         :param mtype:  媒体类型
         :param sort_by:  排序方式
         :param with_genres:  类型
         :param with_original_language:  语言
+        :param with_keywords:  关键字
+        :param with_watch_providers:  提供商
+        :param vote_average:  评分
+        :param vote_count:  评分人数
+        :param release_date:  上映日期
         :param page:  页码
         :return: 媒体信息列表
         """
         return self.run_module("tmdb_discover", mtype=mtype,
-                               sort_by=sort_by, with_genres=with_genres,
+                               sort_by=sort_by,
+                               with_genres=with_genres,
                                with_original_language=with_original_language,
+                               with_keywords=with_keywords,
+                               with_watch_providers=with_watch_providers,
+                               vote_average=vote_average,
+                               vote_count=vote_count,
+                               release_date=release_date,
                                page=page)
 
-    def tmdb_trending(self, page: int = 1) -> Optional[List[MediaInfo]]:
+    def tmdb_trending(self, page: Optional[int] = 1) -> Optional[List[MediaInfo]]:
         """
         TMDB流行趋势
         :param page: 第几页
@@ -52,13 +70,21 @@ class TmdbChain(ChainBase, metaclass=Singleton):
         """
         return self.run_module("tmdb_seasons", tmdbid=tmdbid)
 
-    def tmdb_episodes(self, tmdbid: int, season: int) -> List[schemas.TmdbEpisode]:
+    def tmdb_group_seasons(self, group_id: str) -> List[schemas.TmdbSeason]:
+        """
+        根据剧集组ID查询themoviedb所有季集信息
+        :param group_id: 剧集组ID
+        """
+        return self.run_module("tmdb_group_seasons", group_id=group_id)
+
+    def tmdb_episodes(self, tmdbid: int, season: int, episode_group: Optional[str] = None) -> List[schemas.TmdbEpisode]:
         """
         根据TMDBID查询某季的所有信信息
         :param tmdbid:  TMDBID
         :param season:  季
+        :param episode_group:  剧集组
         """
-        return self.run_module("tmdb_episodes", tmdbid=tmdbid, season=season)
+        return self.run_module("tmdb_episodes", tmdbid=tmdbid, season=season, episode_group=episode_group)
 
     def movie_similar(self, tmdbid: int) -> Optional[List[MediaInfo]]:
         """
@@ -88,7 +114,7 @@ class TmdbChain(ChainBase, metaclass=Singleton):
         """
         return self.run_module("tmdb_tv_recommend", tmdbid=tmdbid)
 
-    def movie_credits(self, tmdbid: int, page: int = 1) -> Optional[List[schemas.MediaPerson]]:
+    def movie_credits(self, tmdbid: int, page: Optional[int] = 1) -> Optional[List[schemas.MediaPerson]]:
         """
         根据TMDBID查询电影演职人员
         :param tmdbid:  TMDBID
@@ -96,7 +122,7 @@ class TmdbChain(ChainBase, metaclass=Singleton):
         """
         return self.run_module("tmdb_movie_credits", tmdbid=tmdbid, page=page)
 
-    def tv_credits(self, tmdbid: int, page: int = 1) -> Optional[List[schemas.MediaPerson]]:
+    def tv_credits(self, tmdbid: int, page: Optional[int] = 1) -> Optional[List[schemas.MediaPerson]]:
         """
         根据TMDBID查询电视剧演职人员
         :param tmdbid:  TMDBID
@@ -111,7 +137,7 @@ class TmdbChain(ChainBase, metaclass=Singleton):
         """
         return self.run_module("tmdb_person_detail", person_id=person_id)
 
-    def person_credits(self, person_id: int, page: int = 1) -> Optional[List[MediaInfo]]:
+    def person_credits(self, person_id: int, page: Optional[int] = 1) -> Optional[List[MediaInfo]]:
         """
         根据人物ID查询人物参演作品
         :param person_id:  人物ID
@@ -119,7 +145,7 @@ class TmdbChain(ChainBase, metaclass=Singleton):
         """
         return self.run_module("tmdb_person_credits", person_id=person_id, page=page)
 
-    @cached(cache=TTLCache(maxsize=1, ttl=3600))
+    @cached(maxsize=1, ttl=3600)
     def get_random_wallpager(self) -> Optional[str]:
         """
         获取随机壁纸，缓存1个小时
@@ -133,8 +159,8 @@ class TmdbChain(ChainBase, metaclass=Singleton):
                     return info.backdrop_path
         return None
 
-    @cached(cache=TTLCache(maxsize=1, ttl=3600))
-    def get_trending_wallpapers(self, num: int = 10) -> List[str]:
+    @cached(maxsize=1, ttl=3600)
+    def get_trending_wallpapers(self, num: Optional[int] = 10) -> List[str]:
         """
         获取所有流行壁纸
         """

app/chain/torrents.py

@@ -1,6 +1,6 @@
 import re
 import traceback
-from typing import Dict, List, Union
+from typing import Dict, List, Union, Optional
 
 from cachetools import cached, TTLCache
 
@@ -48,7 +48,7 @@ class TorrentsChain(ChainBase, metaclass=Singleton):
         self.post_message(Notification(channel=channel,
                                        title=f"种子刷新完成！", userid=userid))
 
-    def get_torrents(self, stype: str = None) -> Dict[str, List[Context]]:
+    def get_torrents(self, stype: Optional[str] = None) -> Dict[str, List[Context]]:
         """
         获取当前缓存的种子
         :param stype: 强制指定缓存类型，spider:爬虫缓存，rss:rss缓存
@@ -73,17 +73,21 @@ class TorrentsChain(ChainBase, metaclass=Singleton):
         logger.info(f'种子缓存数据清理完成')
 
     @cached(cache=TTLCache(maxsize=128, ttl=595))
-    def browse(self, domain: str) -> List[TorrentInfo]:
+    def browse(self, domain: str, keyword: Optional[str] = None, cat: Optional[str] = None,
+               page: Optional[int] = 0) -> List[TorrentInfo]:
         """
         浏览站点首页内容，返回种子清单，TTL缓存10分钟
         :param domain: 站点域名
+        :param keyword: 搜索标题
+        :param cat: 搜索分类
+        :param page: 页码
         """
         logger.info(f'开始获取站点 {domain} 最新种子 ...')
         site = self.siteshelper.get_indexer(domain)
         if not site:
             logger.error(f'站点 {domain} 不存在！')
             return []
-        return self.refresh_torrents(site=site)
+        return self.refresh_torrents(site=site, keyword=keyword, cat=cat, page=page)
 
     @cached(cache=TTLCache(maxsize=128, ttl=295))
     def rss(self, domain: str) -> List[TorrentInfo]:
@@ -131,7 +135,7 @@ class TorrentsChain(ChainBase, metaclass=Singleton):
 
         return ret_torrents
 
-    def refresh(self, stype: str = None, sites: List[int] = None) -> Dict[str, List[Context]]:
+    def refresh(self, stype: Optional[str] = None, sites: List[int] = None) -> Dict[str, List[Context]]:
         """
         刷新站点最新资源，识别并缓存起来
         :param stype: 强制指定缓存类型，spider:爬虫缓存，rss:rss缓存

app/chain/transfer.py

@@ -53,14 +53,14 @@ class JobManager:
         self._season_episodes = {}
 
     @staticmethod
-    def __get_meta_id(meta: MetaBase = None, season: int = None) -> Tuple:
+    def __get_meta_id(meta: MetaBase = None, season: Optional[int] = None) -> Tuple:
         """
         获取元数据ID
         """
         return meta.name, season
 
     @staticmethod
-    def __get_media_id(media: MediaInfo = None, season: int = None) -> Tuple:
+    def __get_media_id(media: MediaInfo = None, season: Optional[int] = None) -> Tuple:
         """
         获取媒体ID
         """
@@ -104,7 +104,7 @@ class JobManager:
         """
         return schemas.MetaInfo(**task.meta.to_dict())
 
-    def add_task(self, task: TransferTask, state: str = "waiting"):
+    def add_task(self, task: TransferTask, state: Optional[str] = "waiting"):
         """
         添加整理任务
         """
@@ -296,7 +296,7 @@ class JobManager:
             media_success = True
         return meta_success and media_success
 
-    def success_tasks(self, media: MediaInfo, season: int = None) -> List[TransferJobTask]:
+    def success_tasks(self, media: MediaInfo, season: Optional[int] = None) -> List[TransferJobTask]:
         """
         获取某项任务成功的任务
         """
@@ -306,7 +306,7 @@ class JobManager:
                 return []
             return [task for task in self._job_view[__mediaid__].tasks if task.state == "completed"]
 
-    def count(self, media: MediaInfo, season: int = None) -> int:
+    def count(self, media: MediaInfo, season: Optional[int] = None) -> int:
         """
         获取某项任务总数
         """
@@ -317,7 +317,7 @@ class JobManager:
                 return 0
             return len([task for task in self._job_view[__mediaid__].tasks if task.state == "completed"])
 
-    def size(self, media: MediaInfo, season: int = None) -> int:
+    def size(self, media: MediaInfo, season: Optional[int] = None) -> int:
         """
         获取某项任务总大小
         """
@@ -326,7 +326,7 @@ class JobManager:
             # 计算状态为完成的任务数
             if __mediaid__ not in self._job_view:
                 return 0
-            return sum([task.fileitem.size for task in self._job_view[__mediaid__].tasks if task.state == "completed"])
+            return sum([task.fileitem.size for task in self._job_view[__mediaid__].tasks if task.state == "completed" and task.fileitem.size is not None])
 
     def total(self) -> int:
         """
@@ -341,7 +341,7 @@ class JobManager:
         """
         return list(self._job_view.values())
 
-    def season_episodes(self, media: MediaInfo, season: int = None) -> List[int]:
+    def season_episodes(self, media: MediaInfo, season: Optional[int] = None) -> List[int]:
         """
         获取季集清单
         """
@@ -453,9 +453,12 @@ class TransferChain(ChainBase, metaclass=Singleton):
                 if transferinfo.transfer_type in ["move"]:
                     # 所有成功的业务
                     tasks = self.jobview.success_tasks(task.mediainfo, task.meta.begin_season)
+                    # 记录已处理的种子hash
+                    processed_hashes = set()
                     for t in tasks:
                         # 下载器hash
-                        if t.download_hash:
+                        if t.download_hash and t.download_hash not in processed_hashes:
+                            processed_hashes.add(t.download_hash)
                             if self.remove_torrents(t.download_hash, downloader=t.downloader):
                                 logger.info(f"移动模式删除种子成功：{t.download_hash} ")
                         # 删除残留目录
@@ -603,7 +606,7 @@ class TransferChain(ChainBase, metaclass=Singleton):
                 logger.error(f"整理队列处理出现错误：{e} - {traceback.format_exc()}")
 
     def __handle_transfer(self, task: TransferTask,
-                          callback: Optional[Callable] = None) -> Tuple[bool, str]:
+                          callback: Optional[Callable] = None) -> Optional[Tuple[bool, str]]:
         """
         处理整理任务
         """
@@ -620,7 +623,8 @@ class TransferChain(ChainBase, metaclass=Singleton):
                         # 下载记录中已存在识别信息
                         mediainfo: Optional[MediaInfo] = self.recognize_media(mtype=MediaType(download_history.type),
                                                                               tmdbid=download_history.tmdbid,
-                                                                              doubanid=download_history.doubanid)
+                                                                              doubanid=download_history.doubanid,
+                                                                              episode_group=download_history.episode_group)
                         if mediainfo:
                             # 更新自定义媒体类别
                             if download_history.media_category:
@@ -660,22 +664,28 @@ class TransferChain(ChainBase, metaclass=Singleton):
                     if transfer_history:
                         mediainfo.title = transfer_history.title
 
-                # 获取集数据
-                if not task.episodes_info and mediainfo.type == MediaType.TV:
-                    if task.meta.begin_season is None:
-                        task.meta.begin_season = 1
-                    mediainfo.season = mediainfo.season or task.meta.begin_season
-                    task.episodes_info = self.tmdbchain.tmdb_episodes(
-                        tmdbid=mediainfo.tmdb_id,
-                        season=mediainfo.season
-                    )
-
                 # 更新任务信息
                 task.mediainfo = mediainfo
                 # 更新队列任务
                 curr_task = self.jobview.remove_task(task.fileitem)
                 self.jobview.add_task(task, state=curr_task.state if curr_task else "waiting")
 
+            # 获取集数据
+            if task.mediainfo.type == MediaType.TV and not task.episodes_info:
+                # 判断注意season为0的情况
+                season_num = task.mediainfo.season
+                if season_num is None and task.meta.season_seq:
+                    if task.meta.season_seq.isdigit():
+                        season_num = int(task.meta.season_seq)
+                # 默认值1
+                if season_num is None:
+                    season_num = 1
+                task.episodes_info = self.tmdbchain.tmdb_episodes(
+                    tmdbid=task.mediainfo.tmdb_id,
+                    season=season_num,
+                    episode_group=task.mediainfo.episode_group
+                )
+
             # 查询整理目标目录
             if not task.target_directory:
                 if task.target_path:
@@ -790,7 +800,8 @@ class TransferChain(ChainBase, metaclass=Singleton):
                     # 按TMDBID识别
                     mediainfo = self.recognize_media(mtype=mtype,
                                                      tmdbid=downloadhis.tmdbid,
-                                                     doubanid=downloadhis.doubanid)
+                                                     doubanid=downloadhis.doubanid,
+                                                     episode_group=downloadhis.episode_group)
                     if mediainfo:
                         # 补充图片
                         self.obtain_images(mediainfo)
@@ -899,13 +910,13 @@ class TransferChain(ChainBase, metaclass=Singleton):
     def do_transfer(self, fileitem: FileItem,
                     meta: MetaBase = None, mediainfo: MediaInfo = None,
                     target_directory: TransferDirectoryConf = None,
-                    target_storage: str = None, target_path: Path = None,
-                    transfer_type: str = None, scrape: bool = None,
-                    library_type_folder: bool = None, library_category_folder: bool = None,
-                    season: int = None, epformat: EpisodeFormat = None, min_filesize: int = 0,
-                    downloader: str = None, download_hash: str = None,
-                    force: bool = False, background: bool = True,
-                    manual: bool = False) -> Tuple[bool, str]:
+                    target_storage: Optional[str] = None, target_path: Path = None,
+                    transfer_type: Optional[str] = None, scrape: Optional[bool] = None,
+                    library_type_folder: Optional[bool] = None, library_category_folder: Optional[bool] = None,
+                    season: Optional[int] = None, epformat: EpisodeFormat = None, min_filesize: Optional[int] = 0,
+                    downloader: Optional[str] = None, download_hash: Optional[str] = None,
+                    force: Optional[bool] = False, background: Optional[bool] = True,
+                    manual: Optional[bool] = False, continue_callback: Callable = None) -> Tuple[bool, str]:
         """
         执行一个复杂目录的整理操作
         :param fileitem: 文件项
@@ -926,6 +937,7 @@ class TransferChain(ChainBase, metaclass=Singleton):
         :param force: 是否强制整理
         :param background: 是否后台运行
         :param manual: 是否手动整理
+        :param continue_callback: 继续处理回调
         返回：成功标识，错误信息
         """
 
@@ -991,6 +1003,8 @@ class TransferChain(ChainBase, metaclass=Singleton):
         for file_item, bluray_dir in file_items:
             if global_vars.is_system_stopped:
                 break
+            if continue_callback and not continue_callback():
+                break
             file_path = Path(file_item.path)
             # 回收站及隐藏的文件不处理
             if file_item.path.find('/@Recycle/') != -1 \
@@ -1111,6 +1125,8 @@ class TransferChain(ChainBase, metaclass=Singleton):
             for transfer_task in transfer_tasks:
                 if global_vars.is_system_stopped:
                     break
+                if continue_callback and not continue_callback():
+                    break
                 # 更新进度
                 __process_msg = f"正在整理 （{processed_num + fail_num + 1}/{total_num}）{transfer_task.fileitem.name} ..."
                 logger.info(__process_msg)
@@ -1140,7 +1156,7 @@ class TransferChain(ChainBase, metaclass=Singleton):
         return all_success, "，".join(err_msgs)
 
     def remote_transfer(self, arg_str: str, channel: MessageChannel,
-                        userid: Union[str, int] = None, source: str = None):
+                        userid: Union[str, int] = None, source: Optional[str] = None):
         """
         远程重新整理，参数 历史记录ID TMDBID|类型
         """
@@ -1182,7 +1198,7 @@ class TransferChain(ChainBase, metaclass=Singleton):
             return
 
     def __re_transfer(self, logid: int, mtype: MediaType = None,
-                      mediaid: str = None) -> Tuple[bool, str]:
+                      mediaid: Optional[str] = None) -> Tuple[bool, str]:
         """
         根据历史记录，重新识别整理，只支持简单条件
         :param logid: 历史记录ID
@@ -1201,12 +1217,12 @@ class TransferChain(ChainBase, metaclass=Singleton):
         # 查询媒体信息
         if mtype and mediaid:
             mediainfo = self.recognize_media(mtype=mtype, tmdbid=int(mediaid) if str(mediaid).isdigit() else None,
-                                             doubanid=mediaid)
+                                             doubanid=mediaid, episode_group=history.episode_group)
             if mediainfo:
                 # 更新媒体图片
                 self.obtain_images(mediainfo=mediainfo)
         else:
-            mediainfo = self.mediachain.recognize_by_path(str(src_path))
+            mediainfo = self.mediachain.recognize_by_path(str(src_path), episode_group=history.episode_group)
         if not mediainfo:
             return False, f"未识别到媒体信息，类型：{mtype.value}，id：{mediaid}"
         # 重新执行整理
@@ -1233,20 +1249,21 @@ class TransferChain(ChainBase, metaclass=Singleton):
 
     def manual_transfer(self,
                         fileitem: FileItem,
-                        target_storage: str = None,
+                        target_storage: Optional[str] = None,
                         target_path: Path = None,
-                        tmdbid: int = None,
-                        doubanid: str = None,
+                        tmdbid: Optional[int] = None,
+                        doubanid: Optional[str] = None,
                         mtype: MediaType = None,
-                        season: int = None,
-                        transfer_type: str = None,
+                        season: Optional[int] = None,
+                        episode_group: Optional[str] = None,
+                        transfer_type: Optional[str] = None,
                         epformat: EpisodeFormat = None,
-                        min_filesize: int = 0,
-                        scrape: bool = None,
-                        library_type_folder: bool = None,
-                        library_category_folder: bool = None,
-                        force: bool = False,
-                        background: bool = False) -> Tuple[bool, Union[str, list]]:
+                        min_filesize: Optional[int] = 0,
+                        scrape: Optional[bool] = None,
+                        library_type_folder: Optional[bool] = None,
+                        library_category_folder: Optional[bool] = None,
+                        force: Optional[bool] = False,
+                        background: Optional[bool] = False) -> Tuple[bool, Union[str, list]]:
         """
         手动整理，支持复杂条件，带进度显示
         :param fileitem: 文件项
@@ -1256,6 +1273,7 @@ class TransferChain(ChainBase, metaclass=Singleton):
         :param doubanid: 豆瓣ID
         :param mtype: 媒体类型
         :param season: 季度
+        :param episode_group: 剧集组
         :param transfer_type: 整理类型
         :param epformat: 剧集格式
         :param min_filesize: 最小文件大小(MB)
@@ -1269,7 +1287,8 @@ class TransferChain(ChainBase, metaclass=Singleton):
         if tmdbid or doubanid:
             # 有输入TMDBID时单个识别
             # 识别媒体信息
-            mediainfo: MediaInfo = self.mediachain.recognize_media(tmdbid=tmdbid, doubanid=doubanid, mtype=mtype)
+            mediainfo: MediaInfo = self.mediachain.recognize_media(tmdbid=tmdbid, doubanid=doubanid,
+                                                                   mtype=mtype, episode_group=episode_group)
             if not mediainfo:
                 return False, f"媒体信息识别失败，tmdbid：{tmdbid}，doubanid：{doubanid}，type: {mtype.value}"
             else:
@@ -1321,7 +1340,7 @@ class TransferChain(ChainBase, metaclass=Singleton):
             return state, errmsg
 
     def send_transfer_message(self, meta: MetaBase, mediainfo: MediaInfo,
-                              transferinfo: TransferInfo, season_episode: str = None, username: str = None):
+                              transferinfo: TransferInfo, season_episode: Optional[str] = None, username: Optional[str] = None):
         """
         发送入库成功的消息
         """

app/chain/user.py

@@ -30,7 +30,7 @@ class UserChain(ChainBase, metaclass=Singleton):
             password: Optional[str] = None,
             mfa_code: Optional[str] = None,
             code: Optional[str] = None,
-            grant_type: str = "password"
+            grant_type: Optional[str] = "password"
     ) -> Union[Tuple[bool, Optional[str]], Tuple[bool, Optional[User]]]:
         """
         认证用户，根据不同的 grant_type 处理不同的认证流程

app/chain/workflow.py

@@ -0,0 +1,250 @@
+import base64
+import pickle
+import threading
+from collections import defaultdict, deque
+from concurrent.futures import ThreadPoolExecutor
+from time import sleep
+from typing import List, Tuple, Optional
+
+from pydantic.fields import Callable
+
+from app.chain import ChainBase
+from app.core.config import global_vars
+from app.core.workflow import WorkFlowManager
+from app.db.models import Workflow
+from app.db.workflow_oper import WorkflowOper
+from app.log import logger
+from app.schemas import ActionContext, ActionFlow, Action, ActionExecution
+
+
+class WorkflowExecutor:
+    """
+    工作流执行器
+    """
+
+    def __init__(self, workflow: Workflow, step_callback: Callable = None):
+        """
+        初始化工作流执行器
+        :param workflow: 工作流对象
+        :param step_callback: 步骤回调函数
+        """
+        # 工作流数据
+        self.workflow = workflow
+        self.step_callback = step_callback
+        self.actions = {action['id']: Action(**action) for action in workflow.actions}
+        self.flows = [ActionFlow(**flow) for flow in workflow.flows]
+        self.total_actions = len(self.actions)
+        self.finished_actions = 0
+
+        self.success = True
+        self.errmsg = ""
+
+        # 工作流管理器
+        self.workflowmanager = WorkFlowManager()
+        # 线程安全队列
+        self.queue = deque()
+        # 锁用于保证线程安全
+        self.lock = threading.Lock()
+        # 线程池
+        self.executor = ThreadPoolExecutor()
+        # 跟踪运行中的任务数
+        self.running_tasks = 0
+
+        # 构建邻接表、入度表
+        self.adjacency = defaultdict(list)
+        self.indegree = defaultdict(int)
+        for flow in self.flows:
+            source = flow.source
+            target = flow.target
+            self.adjacency[source].append(target)
+            self.indegree[target] += 1
+
+        # 初始化所有节点的入度（确保未被引用的节点入度为0）
+        for action_id in self.actions:
+            if action_id not in self.indegree:
+                self.indegree[action_id] = 0
+
+        # 初始上下文
+        if workflow.current_action and workflow.context:
+            logger.info(f"工作流已执行动作：{workflow.current_action}")
+            # Base64解码
+            decoded_data = base64.b64decode(workflow.context["content"])
+            # 反序列化数据
+            self.context = pickle.loads(decoded_data)
+        else:
+            self.context = ActionContext()
+
+        # 恢复工作流
+        global_vars.workflow_resume(self.workflow.id)
+        # 初始化队列，添加入度为0的节点
+        for action_id in self.actions:
+            if self.indegree[action_id] == 0:
+                self.queue.append(action_id)
+
+    def execute(self):
+        """
+        执行工作流
+        """
+        while True:
+            with self.lock:
+                # 退出条件：队列为空且无运行任务
+                if not self.queue and self.running_tasks == 0:
+                    break
+                # 退出条件：出现了错误
+                if not self.success:
+                    break
+                if not self.queue:
+                    sleep(0.1)
+                    continue
+                # 取出队首节点
+                node_id = self.queue.popleft()
+                # 标记任务开始
+                self.running_tasks += 1
+
+            # 已停机
+            if global_vars.is_workflow_stopped(self.workflow.id):
+                global_vars.workflow_resume(self.workflow.id)
+                break
+
+            # 已执行的跳过
+            if (self.workflow.current_action
+                    and node_id in self.workflow.current_action.split(',')):
+                continue
+
+            # 提交任务到线程池
+            future = self.executor.submit(
+                self.execute_node,
+                self.workflow.id,
+                node_id,
+                self.context
+            )
+            future.add_done_callback(self.on_node_complete)
+
+    def execute_node(self, workflow_id: int, node_id: int,
+                     context: ActionContext) -> Tuple[Action, bool, str, ActionContext]:
+        """
+        执行单个节点操作，返回修改后的上下文和节点ID
+        """
+        action = self.actions[node_id]
+        state, message, result_ctx = self.workflowmanager.excute(workflow_id, action, context=context)
+        return action, state, message, result_ctx
+
+    def on_node_complete(self, future):
+        """
+        节点完成回调：更新上下文、处理后继节点
+        """
+        action, state, message, result_ctx = future.result()
+
+        try:
+            self.finished_actions += 1
+            # 更新当前进度
+            self.context.progress = round(self.finished_actions / self.total_actions) * 100
+
+            # 补充执行历史
+            self.context.execute_history.append(
+                ActionExecution(
+                    action=action.name,
+                    result=state,
+                    message=message
+                )
+            )
+
+            # 节点执行失败
+            if not state:
+                self.success = False
+                self.errmsg = f"{action.name} 失败"
+                return
+
+            with self.lock:
+                # 更新主上下文
+                self.merge_context(result_ctx)
+                # 回调
+                if self.step_callback:
+                    self.step_callback(action, self.context)
+
+            # 处理后继节点
+            successors = self.adjacency.get(action.id, [])
+            for succ_id in successors:
+                with self.lock:
+                    self.indegree[succ_id] -= 1
+                    if self.indegree[succ_id] == 0:
+                        self.queue.append(succ_id)
+        finally:
+            # 标记任务完成
+            with self.lock:
+                self.running_tasks -= 1
+
+    def merge_context(self, context: ActionContext):
+        """
+        合并上下文
+        """
+        for key, value in context.dict().items():
+            if not getattr(self.context, key, None):
+                setattr(self.context, key, value)
+
+
+class WorkflowChain(ChainBase):
+    """
+    工作流链
+    """
+
+    def __init__(self):
+        super().__init__()
+        self.workflowoper = WorkflowOper()
+
+    def process(self, workflow_id: int, from_begin: Optional[bool] = True) -> Tuple[bool, str]:
+        """
+        处理工作流
+        :param workflow_id: 工作流ID
+        :param from_begin: 是否从头开始，默认为True
+        """
+
+        def save_step(action: Action, context: ActionContext):
+            """
+            保存上下文到数据库
+            """
+            # 序列化数据
+            serialized_data = pickle.dumps(context)
+            # 使用Base64编码字节流
+            encoded_data = base64.b64encode(serialized_data).decode('utf-8')
+            self.workflowoper.step(workflow_id, action_id=action.id, context={
+                "content": encoded_data
+            })
+
+        # 重置工作流
+        if from_begin:
+            self.workflowoper.reset(workflow_id)
+
+        # 查询工作流数据
+        workflow = self.workflowoper.get(workflow_id)
+        if not workflow:
+            logger.warn(f"工作流 {workflow_id} 不存在")
+            return False, "工作流不存在"
+        if not workflow.actions:
+            logger.warn(f"工作流 {workflow.name} 无动作")
+            return False, "工作流无动作"
+        if not workflow.flows:
+            logger.warn(f"工作流 {workflow.name} 无流程")
+            return False, "工作流无流程"
+
+        logger.info(f"开始处理 {workflow.name}，共 {len(workflow.actions)} 个动作 ...")
+        self.workflowoper.start(workflow_id)
+
+        # 执行工作流
+        executor = WorkflowExecutor(workflow, step_callback=save_step)
+        executor.execute()
+
+        if not executor.success:
+            logger.info(f"工作流 {workflow.name} 执行失败：{executor.errmsg}")
+            self.workflowoper.fail(workflow_id, result=executor.errmsg)
+            return False, executor.errmsg
+        else:
+            logger.info(f"工作流 {workflow.name} 执行完成")
+            self.workflowoper.success(workflow_id)
+            return True, ""
+
+    def get_workflows(self) -> List[Workflow]:
+        """
+        获取工作流列表
+        """
+        return self.workflowoper.list_enabled()

app/command.py

@@ -1,3 +1,4 @@
+import copy
 import threading
 import traceback
 from typing import Any, Union, Dict, Optional
@@ -272,8 +273,8 @@ class Command(metaclass=Singleton):
                 }
         return plugin_commands
 
-    def __run_command(self, command: Dict[str, any], data_str: str = "",
-                      channel: MessageChannel = None, source: str = None, userid: Union[str, int] = None):
+    def __run_command(self, command: Dict[str, any], data_str: Optional[str] = "",
+                      channel: MessageChannel = None, source: Optional[str] = None, userid: Union[str, int] = None):
         """
         运行定时服务
         """
@@ -303,7 +304,7 @@ class Command(metaclass=Singleton):
                 )
         else:
             # 命令
-            cmd_data = command['data'] if command.get('data') else {}
+            cmd_data = copy.deepcopy(command['data']) if command.get('data') else {}
             args_num = ObjectUtils.arguments(command['func'])
             if args_num > 0:
                 if cmd_data:
@@ -338,8 +339,8 @@ class Command(metaclass=Singleton):
         """
         return self._commands.get(cmd, {})
 
-    def register(self, cmd: str, func: Any, data: dict = None,
-                 desc: str = None, category: str = None) -> None:
+    def register(self, cmd: str, func: Any, data: Optional[dict] = None,
+                 desc: Optional[str] = None, category: Optional[str] = None) -> None:
         """
         注册单个命令
         """
@@ -351,8 +352,8 @@ class Command(metaclass=Singleton):
             "data": data or {}
         }
 
-    def execute(self, cmd: str, data_str: str = "",
-                channel: MessageChannel = None, source: str = None,
+    def execute(self, cmd: str, data_str: Optional[str] = "",
+                channel: MessageChannel = None, source: Optional[str] = None,
                 userid: Union[str, int] = None) -> None:
         """
         执行命令

app/core/cache.py

@@ -0,0 +1,576 @@
+import inspect
+import json
+import pickle
+import threading
+from abc import ABC, abstractmethod
+from functools import wraps
+from typing import Any, Dict, Optional
+from urllib.parse import quote
+
+import redis
+from cachetools import TTLCache
+from cachetools.keys import hashkey
+
+from app.core.config import settings
+from app.log import logger
+
+# 默认缓存区
+DEFAULT_CACHE_REGION = "DEFAULT"
+
+lock = threading.Lock()
+
+
+class CacheBackend(ABC):
+    """
+    缓存后端基类，定义通用的缓存接口
+    """
+
+    @abstractmethod
+    def set(self, key: str, value: Any, ttl: int, region: Optional[str] = DEFAULT_CACHE_REGION, **kwargs) -> None:
+        """
+        设置缓存
+
+        :param key: 缓存的键
+        :param value: 缓存的值
+        :param ttl: 缓存的存活时间，单位秒
+        :param region: 缓存的区
+        :param kwargs: 其他参数
+        """
+        pass
+
+    @abstractmethod
+    def exists(self, key: str, region: Optional[str] = DEFAULT_CACHE_REGION) -> bool:
+        """
+        判断缓存键是否存在
+
+        :param key: 缓存的键
+        :param region: 缓存的区
+        :return: 存在返回 True，否则返回 False
+        """
+        pass
+
+    @abstractmethod
+    def get(self, key: str, region: Optional[str] = DEFAULT_CACHE_REGION) -> Any:
+        """
+        获取缓存
+
+        :param key: 缓存的键
+        :param region: 缓存的区
+        :return: 返回缓存的值，如果缓存不存在返回 None
+        """
+        pass
+
+    @abstractmethod
+    def delete(self, key: str, region: Optional[str] = DEFAULT_CACHE_REGION) -> None:
+        """
+        删除缓存
+
+        :param key: 缓存的键
+        :param region: 缓存的区
+        """
+        pass
+
+    @abstractmethod
+    def clear(self, region: Optional[str] = None) -> None:
+        """
+        清除指定区域的缓存或全部缓存
+
+        :param region: 缓存的区
+        """
+        pass
+
+    @abstractmethod
+    def close(self) -> None:
+        """
+        关闭缓存连接
+        """
+        pass
+
+    @staticmethod
+    def get_region(region: Optional[str] = DEFAULT_CACHE_REGION):
+        """
+        获取缓存的区
+        """
+        return f"region:{region}" if region else "region:default"
+
+    @staticmethod
+    def get_cache_key(func, args, kwargs):
+        """
+        获取缓存的键，通过哈希函数对函数的参数进行处理
+        :param func: 被装饰的函数
+        :param args: 位置参数
+        :param kwargs: 关键字参数
+        :return: 缓存键
+        """
+        signature = inspect.signature(func)
+        # 绑定传入的参数并应用默认值
+        bound = signature.bind(*args, **kwargs)
+        bound.apply_defaults()
+        # 忽略第一个参数，如果它是实例(self)或类(cls)
+        parameters = list(signature.parameters.keys())
+        if parameters and parameters[0] in ("self", "cls"):
+            bound.arguments.pop(parameters[0], None)
+        # 按照函数签名顺序提取参数值列表
+        keys = [
+            bound.arguments[param] for param in signature.parameters if param in bound.arguments
+        ]
+        # 使用有序参数生成缓存键
+        return f"{func.__name__}_{hashkey(*keys)}"
+
+
+class CacheToolsBackend(CacheBackend):
+    """
+    基于 `cachetools.TTLCache` 实现的缓存后端
+
+    特性：
+    - 支持动态设置缓存的 TTL（Time To Live，存活时间）和最大条目数（Maxsize）
+    - 缓存实例按区域（region）划分，不同 region 拥有独立的缓存实例
+    - 同一 region 共享相同的 TTL 和 Maxsize，设置时只能作用于整个 region
+
+    限制：
+    - 不支持按 `key` 独立隔离 TTL 和 Maxsize，仅支持作用于 region 级别
+    """
+
+    def __init__(self, maxsize: Optional[int] = 1000, ttl: Optional[int] = 1800):
+        """
+        初始化缓存实例
+
+        :param maxsize: 缓存的最大条目数
+        :param ttl: 默认缓存存活时间，单位秒
+        """
+        self.maxsize = maxsize
+        self.ttl = ttl
+        # 存储各个 region 的缓存实例，region -> TTLCache
+        self._region_caches: Dict[str, TTLCache] = {}
+
+    def __get_region_cache(self, region: str) -> Optional[TTLCache]:
+        """
+        获取指定区域的缓存实例，如果不存在则返回 None
+        """
+        region = self.get_region(region)
+        return self._region_caches.get(region)
+
+    def set(self, key: str, value: Any, ttl: Optional[int] = None, 
+            region: Optional[str] = DEFAULT_CACHE_REGION, **kwargs) -> None:
+        """
+        设置缓存值支持每个 key 独立配置 TTL 和 Maxsize
+
+        :param key: 缓存的键
+        :param value: 缓存的值
+        :param ttl: 缓存的存活时间，单位秒如果未传入则使用默认值
+        :param region: 缓存的区
+        :param kwargs: maxsize: 缓存的最大条目数如果未传入则使用默认值
+        """
+        ttl = ttl or self.ttl
+        maxsize = kwargs.get("maxsize", self.maxsize)
+        region = self.get_region(region)
+        # 如果该 key 尚未有缓存实例，则创建一个新的 TTLCache 实例
+        region_cache = self._region_caches.setdefault(region, TTLCache(maxsize=maxsize, ttl=ttl))
+        # 设置缓存值
+        with lock:
+            region_cache[key] = value
+
+    def exists(self, key: str, region: Optional[str] = DEFAULT_CACHE_REGION) -> bool:
+        """
+        判断缓存键是否存在
+
+        :param key: 缓存的键
+        :param region: 缓存的区
+        :return: 存在返回 True，否则返回 False
+        """
+        region_cache = self.__get_region_cache(region)
+        if region_cache is None:
+            return False
+        return key in region_cache
+
+    def get(self, key: str, region: Optional[str] = DEFAULT_CACHE_REGION) -> Any:
+        """
+        获取缓存的值
+
+        :param key: 缓存的键
+        :param region: 缓存的区
+        :return: 返回缓存的值，如果缓存不存在返回 None
+        """
+        region_cache = self.__get_region_cache(region)
+        if region_cache is None:
+            return None
+        return region_cache.get(key)
+
+    def delete(self, key: str, region: Optional[str] = DEFAULT_CACHE_REGION) -> None:
+        """
+        删除缓存
+
+        :param key: 缓存的键
+        :param region: 缓存的区
+        """
+        region_cache = self.__get_region_cache(region)
+        if region_cache is None:
+            return None
+        with lock:
+            del region_cache[key]
+
+    def clear(self, region: Optional[str] = None) -> None:
+        """
+        清除指定区域的缓存或全部缓存
+
+        :param region: 缓存的区
+        """
+        if region:
+            # 清理指定缓存区
+            region_cache = self.__get_region_cache(region)
+            if region_cache:
+                with lock:
+                    region_cache.clear()
+                logger.info(f"Cleared cache for region: {region}")
+        else:
+            # 清除所有区域的缓存
+            for region_cache in self._region_caches.values():
+                with lock:
+                    region_cache.clear()
+            logger.info("Cleared all cache")
+
+    def close(self) -> None:
+        """
+        内存缓存不需要关闭资源
+        """
+        pass
+
+
+class RedisBackend(CacheBackend):
+    """
+    基于 Redis 实现的缓存后端，支持通过 Redis 存储缓存
+
+    特性：
+    - 支持动态设置缓存的 TTL（Time To Live，存活时间）
+    - 支持分区域（region）管理缓存，不同的 region 采用独立的命名空间
+    - 支持自定义最大内存限制（maxmemory）和内存淘汰策略（如 allkeys-lru）
+
+    限制：
+    - 由于 Redis 的分布式特性，写入和读取可能受到网络延迟的影响
+    - Pickle 反序列化可能存在安全风险，需进一步重构调用来源，避免复杂对象缓存
+    """
+
+    # 类型缓存集合，针对非容器简单类型
+    _complex_serializable_types = set()
+    _simple_serializable_types = set()
+
+    def __init__(self, redis_url: Optional[str] = "redis://localhost", ttl: Optional[int] = 1800):
+        """
+        初始化 Redis 缓存实例
+
+        :param redis_url: Redis 服务的 URL
+        :param ttl: 缓存的存活时间，单位秒
+        """
+        self.redis_url = redis_url
+        self.ttl = ttl
+        try:
+            self.client = redis.Redis.from_url(
+                redis_url,
+                decode_responses=False,
+                socket_timeout=30,
+                socket_connect_timeout=5,
+                health_check_interval=60,
+            )
+            # 测试连接，确保 Redis 可用
+            self.client.ping()
+            logger.debug(f"Successfully connected to Redis")
+            self.set_memory_limit()
+        except Exception as e:
+            logger.error(f"Failed to connect to Redis: {e}")
+            raise RuntimeError("Redis connection failed") from e
+
+    def set_memory_limit(self, policy: Optional[str] = "allkeys-lru"):
+        """
+        动态设置 Redis 最大内存和内存淘汰策略
+        :param policy: 淘汰策略（如 'allkeys-lru'）
+        """
+        try:
+            # 如果有显式值，则直接使用，为 0 时说明不限制，如果未配置，开启 BIG_MEMORY_MODE 时为 "1024mb"，未开启时为 "256mb"
+            maxmemory = settings.CACHE_REDIS_MAXMEMORY or ("1024mb" if settings.BIG_MEMORY_MODE else "256mb")
+            self.client.config_set("maxmemory", maxmemory)
+            self.client.config_set("maxmemory-policy", policy)
+            logger.debug(f"Redis maxmemory set to {maxmemory}, policy: {policy}")
+        except Exception as e:
+            logger.error(f"Failed to set Redis maxmemory or policy: {e}")
+
+    @staticmethod
+    def is_container_type(t):
+        return t in (list, dict, tuple, set)
+
+    @classmethod
+    def serialize(cls, value: Any) -> bytes:
+        """
+        将值序列化为二进制数据，根据序列化方式标识格式
+        """
+        vt = type(value)
+        # 针对非容器类型使用缓存策略
+        if not cls.is_container_type(vt):
+            # 如果已知需要复杂序列化
+            if vt in cls._complex_serializable_types:
+                return b"PICKLE" + b"\x00" + pickle.dumps(value)
+            # 如果已知可以简单序列化
+            if vt in cls._simple_serializable_types:
+                json_data = json.dumps(value).encode("utf-8")
+                return b"JSON" + b"\x00" + json_data
+            # 对于未知的非容器类型，尝试简单序列化，如抛出异常，再使用复杂序列化
+            try:
+                json_data = json.dumps(value).encode("utf-8")
+                cls._simple_serializable_types.add(vt)
+                return b"JSON" + b"\x00" + json_data
+            except TypeError:
+                cls._complex_serializable_types.add(vt)
+                return b"PICKLE" + b"\x00" + pickle.dumps(value)
+        # 针对容器类型，每次尝试简单序列化，不使用缓存
+        else:
+            try:
+                json_data = json.dumps(value).encode("utf-8")
+                return b"JSON" + b"\x00" + json_data
+            except TypeError:
+                return b"PICKLE" + b"\x00" + pickle.dumps(value)
+
+    @classmethod
+    def deserialize(cls, value: bytes) -> Any:
+        """
+        将二进制数据反序列化为原始值，根据格式标识区分序列化方式
+        """
+        format_marker, data = value.split(b"\x00", 1)
+        if format_marker == b"JSON":
+            return json.loads(data.decode("utf-8"))
+        elif format_marker == b"PICKLE":
+            return pickle.loads(data)
+        else:
+            raise ValueError("Unknown serialization format")
+
+    # @staticmethod
+    # def serialize(value: Any) -> bytes:
+    #     return msgpack.packb(value, use_bin_type=True)
+    #
+    # @staticmethod
+    # def deserialize(value: bytes) -> Any:
+    #     return msgpack.unpackb(value, raw=False)
+
+    def get_redis_key(self, region: str, key: str) -> str:
+        """
+        获取缓存 Key
+        """
+        # 使用 region 作为缓存键的一部分
+        region = self.get_region(quote(region))
+        return f"{region}:key:{quote(key)}"
+
+    def set(self, key: str, value: Any, ttl: Optional[int] = None, 
+            region: Optional[str] = DEFAULT_CACHE_REGION, **kwargs) -> None:
+        """
+        设置缓存
+
+        :param key: 缓存的键
+        :param value: 缓存的值
+        :param ttl: 缓存的存活时间，单位秒如果未传入则使用默认值
+        :param region: 缓存的区
+        :param kwargs: kwargs
+        """
+        try:
+            ttl = ttl or self.ttl
+            redis_key = self.get_redis_key(region, key)
+            # 对值进行序列化
+            serialized_value = self.serialize(value)
+            kwargs.pop("maxsize", None)
+            self.client.set(redis_key, serialized_value, ex=ttl, **kwargs)
+        except Exception as e:
+            logger.error(f"Failed to set key: {key} in region: {region}, error: {e}")
+
+    def exists(self, key: str, region: Optional[str] = DEFAULT_CACHE_REGION) -> bool:
+        """
+        判断缓存键是否存在
+
+        :param key: 缓存的键
+        :param region: 缓存的区
+        :return: 存在返回 True，否则返回 False
+        """
+        try:
+            redis_key = self.get_redis_key(region, key)
+            return self.client.exists(redis_key) == 1
+        except Exception as e:
+            logger.error(f"Failed to exists key: {key} region: {region}, error: {e}")
+            return False
+
+    def get(self, key: str, region: Optional[str] = DEFAULT_CACHE_REGION) -> Optional[Any]:
+        """
+        获取缓存的值
+
+        :param key: 缓存的键
+        :param region: 缓存的区
+        :return: 返回缓存的值，如果缓存不存在返回 None
+        """
+        try:
+            redis_key = self.get_redis_key(region, key)
+            value = self.client.get(redis_key)
+            if value is not None:
+                return self.deserialize(value)  # noqa
+            return None
+        except Exception as e:
+            logger.error(f"Failed to get key: {key} in region: {region}, error: {e}")
+            return None
+
+    def delete(self, key: str, region: Optional[str] = DEFAULT_CACHE_REGION) -> None:
+        """
+        删除缓存
+
+        :param key: 缓存的键
+        :param region: 缓存的区
+        """
+        try:
+            redis_key = self.get_redis_key(region, key)
+            self.client.delete(redis_key)
+        except Exception as e:
+            logger.error(f"Failed to delete key: {key} in region: {region}, error: {e}")
+
+    def clear(self, region: Optional[str] = None) -> None:
+        """
+        清除指定区域的缓存或全部缓存
+
+        :param region: 缓存的区
+        """
+        try:
+            if region:
+                cache_region = self.get_region(quote(region))
+                redis_key = f"{cache_region}:key:*"
+                # self.client.delete(*self.client.keys(redis_key))
+                with self.client.pipeline() as pipe:
+                    for key in self.client.scan_iter(redis_key):
+                        pipe.delete(key)
+                    pipe.execute()
+                logger.info(f"Cleared Redis cache for region: {region}")
+            else:
+                self.client.flushdb()
+                logger.info("Cleared all Redis cache")
+        except Exception as e:
+            logger.error(f"Failed to clear cache, region: {region}, error: {e}")
+
+    def close(self) -> None:
+        """
+        关闭 Redis 客户端的连接池
+        """
+        if self.client:
+            self.client.close()
+
+
+def get_cache_backend(maxsize: Optional[int] = 1000, ttl: Optional[int] = 1800) -> CacheBackend:
+    """
+    根据配置获取缓存后端实例
+
+    :param maxsize: 缓存的最大条目数
+    :param ttl: 缓存的默认存活时间，单位秒
+    :return: 返回缓存后端实例
+    """
+    cache_type = settings.CACHE_BACKEND_TYPE
+    logger.debug(f"Cache backend type from settings: {cache_type}")
+
+    if cache_type == "redis":
+        redis_url = settings.CACHE_BACKEND_URL
+        if redis_url:
+            try:
+                logger.debug(f"Attempting to use RedisBackend with URL: {redis_url}, TTL: {ttl}")
+                return RedisBackend(redis_url=redis_url, ttl=ttl)
+            except RuntimeError:
+                logger.warning("Falling back to CacheToolsBackend due to Redis connection failure.")
+        else:
+            logger.debug("Cache backend type is redis, but no valid REDIS_URL found. "
+                         "Falling back to CacheToolsBackend.")
+
+    # 如果不是 Redis，回退到内存缓存
+    logger.debug(f"Using CacheToolsBackend with default maxsize: {maxsize}, TTL: {ttl}")
+    return CacheToolsBackend(maxsize=maxsize, ttl=ttl)
+
+
+def cached(region: Optional[str] = None, maxsize: Optional[int] = 1000, ttl: Optional[int] = 1800,
+           skip_none: Optional[bool] = True, skip_empty: Optional[bool] = False):
+    """
+    自定义缓存装饰器，支持为每个 key 动态传递 maxsize 和 ttl
+
+    :param region: 缓存的区
+    :param maxsize: 缓存的最大条目数，默认值为 1000
+    :param ttl: 缓存的存活时间，单位秒，默认值为 1800
+    :param skip_none: 跳过 None 缓存，默认为 True
+    :param skip_empty: 跳过空值缓存（如 None, [], {}, "", set()），默认为 False
+    :return: 装饰器函数
+    """
+
+    def should_cache(value: Any) -> bool:
+        """
+        判断是否应该缓存结果，如果返回值是 None 或空值则不缓存
+
+        :param value: 要判断的缓存值
+        :return: 是否缓存结果
+        """
+        if skip_none and value is None:
+            return False
+        # if skip_empty and value in [None, [], {}, "", set()]:
+        if skip_empty and not value:
+            return False
+        return True
+
+    def is_valid_cache_value(cache_key: str, cached_value: Any, cache_region: str) -> bool:
+        """
+        判断指定的值是否为一个有效的缓存值
+
+        :param cache_key: 缓存的键
+        :param cached_value: 缓存的值
+        :param cache_region: 缓存的区
+        :return: 若值是有效的缓存值返回 True，否则返回 False
+        """
+        # 如果 skip_none 为 False，且 value 为 None，需要判断缓存实际是否存在
+        if not skip_none and cached_value is None:
+            if not cache_backend.exists(key=cache_key, region=cache_region):
+                return False
+        return True
+
+    def decorator(func):
+
+        # 获取缓存区
+        cache_region = region if region is not None else f"{func.__module__}.{func.__name__}"
+
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            # 获取缓存键
+            cache_key = cache_backend.get_cache_key(func, args, kwargs)
+            # 尝试获取缓存
+            cached_value = cache_backend.get(cache_key, region=cache_region)
+            if should_cache(cached_value) and is_valid_cache_value(cache_key, cached_value, cache_region):
+                return cached_value
+            # 执行函数并缓存结果
+            result = func(*args, **kwargs)
+            # 判断是否需要缓存
+            if not should_cache(result):
+                return result
+            # 设置缓存（如果有传入的 maxsize 和 ttl，则覆盖默认值）
+            cache_backend.set(cache_key, result, ttl=ttl, maxsize=maxsize, region=cache_region)
+            return result
+
+        def cache_clear():
+            """
+            清理缓存区
+            """
+            # 清理缓存区
+            cache_backend.clear(region=cache_region)
+
+        wrapper.cache_region = cache_region
+        wrapper.cache_clear = cache_clear
+        return wrapper
+
+    return decorator
+
+
+# 缓存后端实例
+cache_backend = get_cache_backend()
+
+
+def close_cache() -> None:
+    """
+    关闭缓存后端连接并清理资源
+    """
+    try:
+        if cache_backend:
+            cache_backend.close()
+            logger.info("Cache backend closed successfully.")
+    except Exception as e:
+        logger.info(f"Error while closing cache backend: {e}")

app/core/config.py

@@ -71,6 +71,12 @@ class ConfigModel(BaseModel):
     DB_TIMEOUT: int = 60
     # SQLite 是否启用 WAL 模式，默认关闭
     DB_WAL_ENABLE: bool = False
+    # 缓存类型，支持 cachetools 和 redis，默认使用 cachetools
+    CACHE_BACKEND_TYPE: str = "cachetools"
+    # 缓存连接字符串，仅外部缓存（如 Redis、Memcached）需要
+    CACHE_BACKEND_URL: Optional[str] = None
+    # Redis 缓存最大内存限制，未配置时，如开启大内存模式时为 "1024mb"，未开启时为 "256mb"
+    CACHE_REDIS_MAXMEMORY: Optional[str] = None
     # 配置文件目录
     CONFIG_DIR: Optional[str] = None
     # 超级管理员
@@ -103,6 +109,10 @@ class ConfigModel(BaseModel):
     FANART_ENABLE: bool = True
     # Fanart API Key
     FANART_API_KEY: str = "d2d31f9ecabea050fc7d68aa3146015f"
+    # 115 AppId
+    U115_APP_ID: str = "100196807"
+    # Alipan AppId
+    ALIPAN_APP_ID: str = "ac1bf04dc9fd4d9aaabb65b4a668d403"
     # 元数据识别缓存过期时间（小时）
     META_CACHE_EXPIRE: int = 0
     # 电视剧动漫的分类genre_ids
@@ -112,7 +122,7 @@ class ConfigModel(BaseModel):
     # 自动检查和更新站点资源包（站点索引、认证等）
     AUTO_UPDATE_RESOURCE: bool = True
     # 是否启用DOH解析域名
-    DOH_ENABLE: bool = True
+    DOH_ENABLE: bool = False
     # 使用 DOH 解析的域名列表
     DOH_DOMAINS: str = ("api.themoviedb.org,"
                         "api.tmdb.org,"
@@ -202,7 +212,8 @@ class ConfigModel(BaseModel):
     PLUGIN_MARKET: str = ("https://github.com/jxxghp/MoviePilot-Plugins,"
                           "https://github.com/thsrite/MoviePilot-Plugins,"
                           "https://github.com/honue/MoviePilot-Plugins,"
-                          "https://github.com/InfinityPacer/MoviePilot-Plugins")
+                          "https://github.com/InfinityPacer/MoviePilot-Plugins,"
+                          "https://github.com/DDS-Derek/MoviePilot-Plugins")
     # 插件安装数据共享
     PLUGIN_STATISTIC_SHARE: bool = True
     # 是否开启插件热加载
@@ -230,11 +241,18 @@ class ConfigModel(BaseModel):
                                  "doubanio.com",
                                  "lain.bgm.tv",
                                  "raw.githubusercontent.com",
-                                 "github.com"]
+                                 "github.com",
+                                 "thetvdb.com",
+                                 "cctvpic.com",
+                                 "iqiyipic.com",
+                                 "hdslb.com",
+                                 "cmvideo.cn",
+                                 "ykimg.com",
+                                 "qpic.cn"]
     )
     # 允许的图片文件后缀格式
     SECURITY_IMAGE_SUFFIXES: List[str] = Field(
-        default_factory=lambda: [".jpg", ".jpeg", ".png", ".webp", ".gif", ".svg"]
+        default_factory=lambda: [".jpg", ".jpeg", ".png", ".webp", ".gif", ".svg", ".avif"]
     )
     # 重命名时支持的S0别名
     RENAME_FORMAT_S0_NAMES: List[str] = Field(
@@ -242,6 +260,8 @@ class ConfigModel(BaseModel):
     )
     # 启用分词搜索
     TOKENIZED_SEARCH: bool = False
+    # 为指定默认字幕添加.default后缀
+    DEFAULT_SUB: Optional[str] = "zh-cn"
 
 
 class Settings(BaseSettings, ConfigModel, LogConfigModel):
@@ -348,10 +368,10 @@ class Settings(BaseSettings, ConfigModel, LogConfigModel):
                 raise ValueError(f"配置项 '{field_name}' 的值 '{value}' 无法转换成正确的类型") from e
             logger.error(
                 f"配置项 '{field_name}' 的值 '{value}' 无法转换成正确的类型，使用默认值 '{default}'，错误信息: {e}")
-            return default, True
+        return default, True
 
     @validator('*', pre=True, always=True)
-    def generic_type_validator(cls, value: Any, field): # noqa
+    def generic_type_validator(cls, value: Any, field):  # noqa
         """
         通用校验器，尝试将配置值转换为期望的类型
         """
@@ -592,6 +612,8 @@ class GlobalVar(object):
     STOP_EVENT: threading.Event = threading.Event()
     # webpush订阅
     SUBSCRIPTIONS: List[dict] = []
+    # 需应急停止的工作流
+    EMERGENCY_STOP_WORKFLOWS: List[int] = []
 
     def stop_system(self):
         """
@@ -618,6 +640,26 @@ class GlobalVar(object):
         """
         self.SUBSCRIPTIONS.append(subscription)
 
+    def stop_workflow(self, workflow_id: int):
+        """
+        停止工作流
+        """
+        if workflow_id not in self.EMERGENCY_STOP_WORKFLOWS:
+            self.EMERGENCY_STOP_WORKFLOWS.append(workflow_id)
+
+    def workflow_resume(self, workflow_id: int):
+        """
+        恢复工作流
+        """
+        if workflow_id in self.EMERGENCY_STOP_WORKFLOWS:
+            self.EMERGENCY_STOP_WORKFLOWS.remove(workflow_id)
+
+    def is_workflow_stopped(self, workflow_id: int):
+        """
+        是否停止工作流
+        """
+        return self.is_system_stopped or workflow_id in self.EMERGENCY_STOP_WORKFLOWS
+
 
 # 实例化配置
 settings = Settings()

app/core/context.py

@@ -1,7 +1,7 @@
 import re
 from dataclasses import dataclass, field
 from datetime import datetime
-from typing import List, Dict, Any, Tuple
+from typing import List, Dict, Any, Tuple, Optional
 
 from app.core.config import settings
 from app.core.meta import MetaBase
@@ -37,7 +37,7 @@ class TorrentInfo:
     # 详情页面
     page_url: str = None
     # 种子大小
-    size: float = 0
+    size: float = 0.0
     # 做种者
     seeders: int = 0
     # 下载者
@@ -193,7 +193,7 @@ class MediaInfo:
     # LOGO
     logo_path: str = None
     # 评分
-    vote_average: float = 0
+    vote_average: float = 0.0
     # 描述
     overview: str = None
     # 风格ID
@@ -262,6 +262,12 @@ class MediaInfo:
     runtime: int = None
     # 下一集
     next_episode_to_air: dict = field(default_factory=dict)
+    # 内容分级
+    content_rating: str = None
+    # 全部剧集组
+    episode_groups: List[dict] = field(default_factory=list)
+    # 剧集组
+    episode_group: str = None
 
     def __post_init__(self):
         # 设置媒体信息
@@ -452,6 +458,10 @@ class MediaInfo:
                     air_date = seainfo.get("air_date")
                     if air_date:
                         self.season_years[season] = air_date[:4]
+            # 剧集组
+            if info.get("episode_groups"):
+                self.episode_groups = info.pop("episode_groups").get("results") or []
+
         # 海报
         if info.get('poster_path'):
             self.poster_path = f"https://{settings.TMDB_IMAGE_DOMAIN}/t/p/original{info.get('poster_path')}"
@@ -712,7 +722,7 @@ class MediaInfo:
             return self.backdrop_path.replace("original", "w500")
         return default or ""
 
-    def get_message_image(self, default: bool = None):
+    def get_message_image(self, default: Optional[bool] = None):
         """
         返回消息图片地址
         """
@@ -720,7 +730,7 @@ class MediaInfo:
             return self.backdrop_path.replace("original", "w500")
         return self.get_poster_image(default=default)
 
-    def get_poster_image(self, default: bool = None):
+    def get_poster_image(self, default: Optional[bool] = None):
         """
         返回海报图片地址
         """
@@ -728,7 +738,7 @@ class MediaInfo:
             return self.poster_path.replace("original", "w500")
         return default or ""
 
-    def get_overview_string(self, max_len: int = 140):
+    def get_overview_string(self, max_len: Optional[int] = 140):
         """
         返回带限定长度的简介信息
         :param max_len: 内容长度
@@ -771,6 +781,7 @@ class MediaInfo:
         self.spoken_languages = []
         self.networks = []
         self.next_episode_to_air = {}
+        self.episode_groups = []
 
 
 @dataclass

app/core/event.py

@@ -31,7 +31,7 @@ class Event:
 
     def __init__(self, event_type: Union[EventType, ChainEventType],
                  event_data: Optional[Union[Dict, ChainEventData]] = None,
-                 priority: int = DEFAULT_EVENT_PRIORITY):
+                 priority: Optional[int] = DEFAULT_EVENT_PRIORITY):
         """
         :param event_type: 事件的类型，支持 EventType 或 ChainEventType
         :param event_data: 可选，事件携带的数据，默认为空字典
@@ -130,7 +130,7 @@ class EventManager(metaclass=Singleton):
             )
 
     def send_event(self, etype: Union[EventType, ChainEventType], data: Optional[Union[Dict, ChainEventData]] = None,
-                   priority: int = DEFAULT_EVENT_PRIORITY) -> Optional[Event]:
+                   priority: Optional[int] = DEFAULT_EVENT_PRIORITY) -> Optional[Event]:
         """
         发送事件，根据事件类型决定是广播事件还是链式事件
         :param etype: 事件类型 (EventType 或 ChainEventType)
@@ -147,7 +147,7 @@ class EventManager(metaclass=Singleton):
             logger.error(f"Unknown event type: {etype}")
 
     def add_event_listener(self, event_type: Union[EventType, ChainEventType], handler: Callable,
-                           priority: int = DEFAULT_EVENT_PRIORITY):
+                           priority: Optional[int] = DEFAULT_EVENT_PRIORITY):
         """
         注册事件处理器，将处理器添加到对应的事件订阅列表中
         :param event_type: 事件类型 (EventType 或 ChainEventType)
@@ -506,7 +506,7 @@ class EventManager(metaclass=Singleton):
         )
 
     def register(self, etype: Union[EventType, ChainEventType, List[Union[EventType, ChainEventType]], type],
-                 priority: int = DEFAULT_EVENT_PRIORITY):
+                 priority: Optional[int] = DEFAULT_EVENT_PRIORITY):
         """
         事件注册装饰器，用于将函数注册为事件的处理器
         :param etype:

app/core/meta/metabase.py

@@ -69,7 +69,7 @@ class MetaBase(object):
     _subtitle_flag = False
     _title_episodel_re = r"Episode\s+(\d{1,4})"
     _subtitle_season_re = r"(?<![全共]\s*)[第\s]+([0-9一二三四五六七八九十S\-]+)\s*季(?!\s*[全共])"
-    _subtitle_season_all_re = r"[全共]\s*([0-9一二三四五六七八九十]+)\s*季|([0-9一二三四五六七八九十]+)\s*季\s*全"
+    _subtitle_season_all_re = r"[全共]\s*([0-9一二三四五六七八九十]+)\s*季"
     _subtitle_episode_re = r"(?<![全共]\s*)[第\s]+([0-9一二三四五六七八九十百零EP]+)\s*[集话話期幕](?!\s*[全共])"
     _subtitle_episode_between_re = r"[第]*\s*([0-9一二三四五六七八九十百零]+)\s*[集话話期幕]?\s*-\s*第*\s*([0-9一二三四五六七八九十百零]+)\s*[集话話期幕]"
     _subtitle_episode_all_re = r"([0-9一二三四五六七八九十百零]+)\s*集\s*全|[全共]\s*([0-9一二三四五六七八九十百零]+)\s*[集话話期幕]"
@@ -247,7 +247,7 @@ class MetaBase(object):
                 self.type = MediaType.TV
                 self._subtitle_flag = True
                 return
-            # x集全
+            # x集全/全x集
             episode_all_str = re.search(r'%s' % self._subtitle_episode_all_re, title_text, re.IGNORECASE)
             if episode_all_str:
                 episode_all = episode_all_str.group(1)
@@ -259,8 +259,6 @@ class MetaBase(object):
                     except Exception as err:
                         logger.debug(f'识别集失败：{str(err)} - {traceback.format_exc()}')
                         return
-                    self.begin_episode = None
-                    self.end_episode = None
                     self.type = MediaType.TV
                     self._subtitle_flag = True
                 return

app/core/meta/metavideo.py

@@ -172,7 +172,7 @@ class MetaVideo(MetaBase):
         return None
 
     @staticmethod
-    def __is_pinyin(name_str: str) -> bool:
+    def __is_pinyin(name_str: Optional[str]) -> bool:
         """
         判断是否拼音
         """
@@ -183,7 +183,7 @@ class MetaVideo(MetaBase):
                 return False
         return True
 
-    def __fix_name(self, name: str):
+    def __fix_name(self, name: Optional[str]):
         """
         去掉名字中不需要的干扰字符
         """
@@ -207,7 +207,7 @@ class MetaVideo(MetaBase):
                 name = None
         return name
 
-    def __init_name(self, token: str):
+    def __init_name(self, token: Optional[str]):
         """
         识别名称
         """

app/core/meta/releasegroup.py

@@ -15,32 +15,32 @@ class ReleaseGroupsMatcher(metaclass=Singleton):
         "0ff": ['FF(?:(?:A|WE)B|CD|E(?:DU|B)|TV)'],
         "1pt": [],
         "52pt": [],
-        "audiences": ['Audies', 'AD(?:Audio|E(?:|book)|Music|Web)'],
+        "audiences": ['Audies', 'AD(?:Audio|E(?:book|)|Music|Web)'],
         "azusa": [],
         "beitai": ['BeiTai'],
         "btschool": ['Bts(?:CHOOL|HD|PAD|TV)', 'Zone'],
         "carpt": ['CarPT'],
-        "chdbits": ['CHD(?:|Bits|PAD|(?:|HK)TV|WEB)', 'StBOX', 'OneHD', 'Lee', 'xiaopie'],
+        "chdbits": ['CHD(?:Bits|PAD|(?:|HK)TV|WEB|)', 'StBOX', 'OneHD', 'Lee', 'xiaopie'],
         "discfan": [],
         "dragonhd": [],
         "eastgame": ['(?:(?:iNT|(?:HALFC|Mini(?:S|H|FH)D))-|)TLF'],
         "filelist": [],
         "gainbound": ['(?:DG|GBWE)B'],
-        "hares": ['Hares(?:|(?:M|T)V|Web)'],
+        "hares": ['Hares(?:(?:M|T)V|Web|)'],
         "hd4fans": [],
         "hdarea": ['HDA(?:pad|rea|TV)', 'EPiC'],
         "hdatmos": [],
         "hdbd": [],
-        "hdchina": ['HDC(?:|hina|TV)', 'k9611', 'tudou', 'iHD'],
+        "hdchina": ['HDC(?:hina|TV|)', 'k9611', 'tudou', 'iHD'],
         "hddolby": ['D(?:ream|BTV)', '(?:HD|QHstudI)o'],
-        "hdfans": ['beAst(?:|TV)'],
-        "hdhome": ['HDH(?:|ome|Pad|TV|WEB)'],
-        "hdpt": ['HDPT(?:|Web)'],
-        "hdsky": ['HDS(?:|ky|TV|Pad|WEB)', 'AQLJ'],
+        "hdfans": ['beAst(?:TV|)'],
+        "hdhome": ['HDH(?:ome|Pad|TV|WEB|)'],
+        "hdpt": ['HDPT(?:Web|)'],
+        "hdsky": ['HDS(?:ky|TV|Pad|WEB|)', 'AQLJ'],
         "hdtime": [],
         "HDU": [],
         "hdvideo": [],
-        "hdzone": ['HDZ(?:|one)'],
+        "hdzone": ['HDZ(?:one|)'],
         "hhanclub": ['HHWEB'],
         "hitpt": [],
         "htpt": ['HTPT'],
@@ -48,34 +48,36 @@ class ReleaseGroupsMatcher(metaclass=Singleton):
         "joyhd": [],
         "keepfrds": ['FRDS', 'Yumi', 'cXcY'],
         "lemonhd": ['L(?:eague(?:(?:C|H)D|(?:M|T)V|NF|WEB)|HD)', 'i18n', 'CiNT'],
-        "mteam": ['MTeam(?:|TV)', 'MPAD'],
+        "mteam": ['MTeam(?:TV|)', 'MPAD'],
         "nanyangpt": [],
         "nicept": [],
         "oshen": [],
         "ourbits": ['Our(?:Bits|TV)', 'FLTTH', 'Ao', 'PbK', 'MGs', 'iLove(?:HD|TV)'],
         "piggo": ['PiGo(?:NF|(?:H|WE)B)'],
         "ptchina": [],
-        "pterclub": ['PTer(?:|DIY|Game|(?:M|T)V|WEB)'],
-        "pthome": ['PTH(?:|Audio|eBook|music|ome|tv|WEB)'],
+        "pterclub": ['PTer(?:DIY|Game|(?:M|T)V|WEB|)'],
+        "pthome": ['PTH(?:Audio|eBook|music|ome|tv|WEB|)'],
         "ptmsg": [],
         "ptsbao": ['PTsbao', 'OPS', 'F(?:Fans(?:AIeNcE|BD|D(?:VD|IY)|TV|WEB)|HDMv)', 'SGXT'],
         "pttime": [],
         "putao": ['PuTao'],
         "soulvoice": [],
-        "springsunday": ['CMCT(?:|V)'],
-        "sharkpt": ['Shark(?:|WEB|DIY|TV|MV)'],
+        "springsunday": ['CMCT(?:V|)'],
+        "sharkpt": ['Shark(?:WEB|DIY|TV|MV|)'],
         "tccf": [],
         "tjupt": ['TJUPT'],
         "totheglory": ['TTG', 'WiKi', 'NGB', 'DoA', '(?:ARi|ExRE)N'],
         "U2": [],
         "ultrahd": [],
-        "others": ['B(?:MDru|eyondHD|TN)', 'C(?:fandora|trlhd|MRG)', 'DON', 'EVO', 'FLUX', 'HONE(?:|yG)',
-                   'N(?:oGroup|T(?:b|G))', 'PandaMoon', 'SMURF', 'T(?:EPES|aengoo|rollHD )'],
+        "others": ['B(?:MDru|eyondHD|TN)', 'C(?:fandora|trlhd|MRG)', 'DON', 'EVO', 'FLUX', 'HONE(?:yG|)',
+                   'N(?:oGroup|T(?:b|G))', 'PandaMoon', 'SMURF', 'T(?:EPES|aengoo|rollHD )',],
         "anime": ['ANi', 'HYSUB', 'KTXP', 'LoliHouse', 'MCE', 'Nekomoe kissaten', 'SweetSub', 'MingY',
                   '(?:Lilith|NC)-Raws', '织梦字幕组', '枫叶字幕组', '猎户手抄部', '喵萌奶茶屋', '漫猫字幕社',
                   '霜庭云花Sub', '北宇治字幕组', '氢气烤肉架', '云歌字幕组', '萌樱字幕组', '极影字幕社',
                   '悠哈璃羽字幕社',
-                  '❀拨雪寻春❀', '沸羊羊(?:制作|字幕组)', '(?:桜|樱)都字幕组']
+                  '❀拨雪寻春❀', '沸羊羊(?:制作|字幕组)', '(?:桜|樱)都字幕组'],
+        "forge": ['FROG(?:E|Web|)'],
+        "ubits": ['UB(?:its|WEB|TV)'],
     }
 
     def __init__(self):
@@ -97,13 +99,15 @@ class ReleaseGroupsMatcher(metaclass=Singleton):
         if not groups:
             # 自定义组
             custom_release_groups = self.systemconfig.get(SystemConfigKey.CustomReleaseGroups)
+            if isinstance(custom_release_groups, list):
+                custom_release_groups = list(filter(None, custom_release_groups))
             if custom_release_groups:
                 custom_release_groups_str = '|'.join(custom_release_groups)
                 groups = f"{self.__release_groups}|{custom_release_groups_str}"
             else:
                 groups = self.__release_groups
         title = f"{title} "
-        groups_re = re.compile(r"(?<=[-@\[￡【&])(?:%s)(?=[@.\s\]\[】&])" % groups, re.I)
+        groups_re = re.compile(r"(?<=[-@\[￡【&])(?:%s)(?=[@.\s\S\]\[】&])" % groups, re.I)
         # 处理一个制作组识别多次的情况，保留顺序
         unique_groups = []
         for item in re.findall(groups_re, title):

app/core/metainfo.py

@@ -1,5 +1,5 @@
 from pathlib import Path
-from typing import Tuple, List
+from typing import Tuple, List, Optional
 
 import regex as re
 
@@ -10,7 +10,7 @@ from app.log import logger
 from app.schemas.types import MediaType
 
 
-def MetaInfo(title: str, subtitle: str = None, custom_words: List[str] = None) -> MetaBase:
+def MetaInfo(title: str, subtitle: Optional[str] = None, custom_words: List[str] = None) -> MetaBase:
     """
     根据标题和副标题识别元数据
     :param title: 标题、种子名、文件名
@@ -92,7 +92,8 @@ def is_anime(name: str) -> bool:
         return True
     if re.search(r'\s+-\s+[\dv]{1,4}\s+', name, re.IGNORECASE):
         return True
-    if re.search(r"S\d{2}\s*-\s*S\d{2}|S\d{2}|\s+S\d{1,2}|EP?\d{2,4}\s*-\s*EP?\d{2,4}|EP?\d{2,4}|\s+EP?\d{1,4}", name,
+    if re.search(r"S\d{2}\s*-\s*S\d{2}|S\d{2}|\s+S\d{1,2}|EP?\d{2,4}\s*-\s*EP?\d{2,4}|EP?\d{2,4}|\s+EP?\d{1,4}",
+                 name,
                  re.IGNORECASE):
         return False
     if re.search(r'\[[+0-9XVPI-]+]\s*\[', name, re.IGNORECASE):
@@ -133,13 +134,10 @@ def find_metainfo(title: str) -> Tuple[str, dict]:
         # 查找媒体类型
         mtype = re.findall(r'(?<=type=)\w+', result)
         if mtype:
-            match mtype[0]:
-                case "movie":
-                    metainfo['type'] = MediaType.MOVIE
-                case "tv":
-                    metainfo['type'] = MediaType.TV
-                case _:
-                    pass
+            if mtype[0] == "movies":
+                metainfo['type'] = MediaType.MOVIE
+            elif mtype[0] == "tv":
+                metainfo['type'] = MediaType.TV
         # 查找季信息
         begin_season = re.findall(r'(?<=s=)\d+', result)
         if begin_season and begin_season[0].isdigit():

app/core/module.py

@@ -121,7 +121,7 @@ class ModuleManager(metaclass=Singleton):
         获取实现了同一方法的模块列表
         """
         if not self._running_modules:
-            return []
+            return
         for _, module in self._running_modules.items():
             if hasattr(module, method) \
                     and ObjectUtils.check_method(getattr(module, method)):
@@ -132,7 +132,7 @@ class ModuleManager(metaclass=Singleton):
         获取指定类型的模块列表
         """
         if not self._running_modules:
-            return []
+            return
         for _, module in self._running_modules.items():
             if hasattr(module, 'get_type') \
                     and module.get_type() == module_type:
@@ -143,7 +143,7 @@ class ModuleManager(metaclass=Singleton):
         获取指定子类型的模块
         """
         if not self._running_modules:
-            return []
+            return
         for _, module in self._running_modules.items():
             if hasattr(module, 'get_subtype') \
                     and module.get_subtype() == module_subtype:

app/core/plugin.py

@@ -111,7 +111,7 @@ class PluginManager(metaclass=Singleton):
         # 启动插件
         self.start()
 
-    def start(self, pid: str = None):
+    def start(self, pid: Optional[str] = None):
         """
         启动加载插件
         :param pid: 插件ID，为空加载所有插件
@@ -194,7 +194,7 @@ class PluginManager(metaclass=Singleton):
             # 禁用插件类的事件处理器
             eventmanager.disable_event_handler(type(plugin))
 
-    def stop(self, pid: str = None):
+    def stop(self, pid: Optional[str] = None):
         """
         停止插件服务
         :param pid: 插件ID，为空停止所有插件
@@ -431,7 +431,7 @@ class PluginManager(metaclass=Singleton):
             return plugin.get_page() or []
         return []
 
-    def get_plugin_dashboard(self, pid: str, key: str = None, **kwargs) -> Optional[schemas.PluginDashboard]:
+    def get_plugin_dashboard(self, pid: str, key: Optional[str] = None, **kwargs) -> Optional[schemas.PluginDashboard]:
         """
         获取插件仪表盘
         :param pid: 插件ID
@@ -781,7 +781,7 @@ class PluginManager(metaclass=Singleton):
             logger.debug(f"获取插件是否在本地包中存在失败，{e}")
             return False
 
-    def get_plugins_from_market(self, market: str, package_version: str = None) -> Optional[List[schemas.Plugin]]:
+    def get_plugins_from_market(self, market: str, package_version: Optional[str] = None) -> Optional[List[schemas.Plugin]]:
         """
         从指定的市场获取插件信息
         :param market: 市场的 URL 或标识
@@ -793,10 +793,9 @@ class PluginManager(metaclass=Singleton):
         # 已安装插件
         installed_apps = self.systemconfig.get(SystemConfigKey.UserInstalledPlugins) or []
         # 获取在线插件
-        online_plugins = self.pluginhelper.get_plugins(market, package_version) or {}
-        if not online_plugins:
-            if not package_version:
-                logger.warning(f"获取插件库失败：{market}，请检查 GitHub 网络连接")
+        online_plugins = self.pluginhelper.get_plugins(market, package_version)
+        if online_plugins is None:
+            logger.warning(f"获取{package_version if package_version else ''}插件库失败：{market}，请检查 GitHub 网络连接")
             return []
         ret_plugins = []
         add_time = len(online_plugins)

app/core/security.py

@@ -1,10 +1,11 @@
 import base64
+import datetime
 import hashlib
 import hmac
 import json
 import os
 import traceback
-from datetime import datetime, timedelta
+from datetime import timedelta
 from typing import Any, Union, Annotated, Optional
 
 import jwt
@@ -43,9 +44,9 @@ api_key_query = APIKeyQuery(name="apikey", auto_error=False, scheme_name="api_ke
 def create_access_token(
         userid: Union[str, Any],
         username: str,
-        super_user: bool = False,
+        super_user: Optional[bool] = False,
         expires_delta: Optional[timedelta] = None,
-        level: int = 1,
+        level: Optional[int] = 1,
         purpose: Optional[str] = "authentication"
 ) -> str:
     """
@@ -69,13 +70,13 @@ def create_access_token(
     if expires_delta is not None:
         if expires_delta.total_seconds() <= 0:
             raise ValueError("过期时间必须为正数")
-        expire = datetime.utcnow() + expires_delta
+        expire = datetime.datetime.now(datetime.UTC) + expires_delta
     else:
-        expire = datetime.utcnow() + default_expire
+        expire = datetime.datetime.now(datetime.UTC) + default_expire
 
     to_encode = {
         "exp": expire,
-        "iat": datetime.utcnow(),
+        "iat": datetime.datetime.now(datetime.UTC),
         "sub": str(userid),
         "username": username,
         "super_user": super_user,
@@ -102,7 +103,7 @@ def __set_or_refresh_resource_token_cookie(request: Request, response: Response,
             decoded_token = jwt.decode(resource_token, settings.RESOURCE_SECRET_KEY, algorithms=[ALGORITHM])
             exp = decoded_token.get("exp")
             if exp:
-                remaining_time = datetime.utcfromtimestamp(exp) - datetime.utcnow()
+                remaining_time = datetime.datetime.fromtimestamp(exp, tz=datetime.UTC) - datetime.datetime.now(datetime.UTC)
                 # 根据剩余时长提前刷新令牌
                 if remaining_time < timedelta(seconds=(settings.RESOURCE_ACCESS_TOKEN_EXPIRE_SECONDS / 3)):
                     raise jwt.ExpiredSignatureError
@@ -135,7 +136,7 @@ def __set_or_refresh_resource_token_cookie(request: Request, response: Response,
     )
 
 
-def __verify_token(token: str, purpose: str = "authentication") -> schemas.TokenPayload:
+def __verify_token(token: str, purpose: Optional[str] = "authentication") -> schemas.TokenPayload:
     """
     使用 JWT Token 进行身份认证并解析 Token 的内容
     :param token: JWT 令牌
@@ -175,7 +176,7 @@ def __verify_token(token: str, purpose: str = "authentication") -> schemas.Token
 def verify_token(
         request: Request,
         response: Response,
-        token: str = Security(oauth2_scheme)
+        token: Annotated[str, Security(oauth2_scheme)]
 ) -> schemas.TokenPayload:
     """
     验证 JWT 令牌并自动处理 resource_token 写入
@@ -195,7 +196,7 @@ def verify_token(
 
 
 def verify_resource_token(
-        resource_token: str = Security(resource_token_cookie)
+        resource_token: Annotated[str, Security(resource_token_cookie)]
 ) -> schemas.TokenPayload:
     """
     验证资源访问令牌（从 Cookie 中获取）
@@ -248,7 +249,7 @@ def __verify_key(key: str, expected_key: str, key_type: str) -> str:
     return key
 
 
-def verify_apitoken(token: str = Security(__get_api_token)) -> str:
+def verify_apitoken(token: Annotated[str, Security(__get_api_token)]) -> str:
     """
     使用 API Token 进行身份认证
     :param token: API Token，从 URL 查询参数中获取
@@ -257,7 +258,7 @@ def verify_apitoken(token: str = Security(__get_api_token)) -> str:
     return __verify_key(token, settings.API_TOKEN, "API_TOKEN")
 
 
-def verify_apikey(apikey: str = Security(__get_api_key)) -> str:
+def verify_apikey(apikey: Annotated[str, Security(__get_api_key)]) -> str:
     """
     使用 API Key 进行身份认证
     :param apikey: API Key，从 URL 查询参数或请求头中获取

app/core/workflow.py

@@ -0,0 +1,112 @@
+from time import sleep
+from typing import Dict, Any, Tuple, List
+
+from app.core.config import global_vars
+from app.helper.module import ModuleHelper
+from app.log import logger
+from app.schemas import Action, ActionContext
+from app.utils.singleton import Singleton
+
+
+class WorkFlowManager(metaclass=Singleton):
+    """
+    工作流管理器
+    """
+
+    # 所有动作定义
+    _actions: Dict[str, Any] = {}
+
+    def __init__(self):
+        self.init()
+
+    def init(self):
+        """
+        初始化
+        """
+
+        def filter_func(obj: Any):
+            """
+            过滤函数，确保只加载新定义的类
+            """
+            if not isinstance(obj, type):
+                return False
+            if not hasattr(obj, 'execute') or not hasattr(obj, "name"):
+                return False
+            if obj.__name__ == "BaseAction":
+                return False
+            return obj.__module__.startswith("app.actions")
+
+        # 加载所有动作
+        self._actions = {}
+        actions = ModuleHelper.load(
+            "app.actions",
+            filter_func=lambda _, obj: filter_func(obj)
+        )
+        for action in actions:
+            logger.debug(f"加载动作: {action.__name__}")
+            try:
+                self._actions[action.__name__] = action
+            except Exception as err:
+                logger.error(f"加载动作失败: {action.__name__} - {err}")
+
+    def stop(self):
+        """
+        停止
+        """
+        pass
+
+    def excute(self, workflow_id: int, action: Action,
+               context: ActionContext = None) -> Tuple[bool, str, ActionContext]:
+        """
+        执行工作流动作
+        """
+        if not context:
+            context = ActionContext()
+        if action.type in self._actions:
+            # 实例化之前，清理掉类对象的数据
+
+            # 实例化
+            action_obj = self._actions[action.type](action.id)
+            # 执行
+            logger.info(f"执行动作: {action.id} - {action.name}")
+            try:
+                result_context = action_obj.execute(workflow_id, action.data, context)
+            except Exception as err:
+                logger.error(f"{action.name} 执行失败: {err}")
+                return False, f"{err}", context
+            loop = action.data.get("loop")
+            loop_interval = action.data.get("loop_interval")
+            if loop and loop_interval:
+                while not action_obj.done:
+                    if global_vars.is_workflow_stopped(workflow_id):
+                        break
+                    # 等待
+                    logger.info(f"{action.name} 等待 {loop_interval} 秒后继续执行 ...")
+                    sleep(loop_interval)
+                    # 执行
+                    logger.info(f"继续执行动作: {action.id} - {action.name}")
+                    result_context = action_obj.execute(workflow_id, action.data, result_context)
+            if action_obj.success:
+                logger.info(f"{action.name} 执行成功")
+            else:
+                logger.error(f"{action.name} 执行失败！")
+            return action_obj.success, action_obj.message, result_context
+        else:
+            logger.error(f"未找到动作: {action.type} - {action.name}")
+            return False, " ", context
+
+    def list_actions(self) -> List[dict]:
+        """
+        获取所有动作
+        """
+        return [
+            {
+                "type": key,
+                "name": action.name,
+                "description": action.description,
+                "data": {
+                    "label": action.name,
+                    **action.data
+                }
+            } for key, action in self._actions.items()
+        ]

app/db/downloadhistory_oper.py

@@ -1,4 +1,4 @@
-from typing import List
+from typing import List, Optional
 
 from app.db import DbOper
 from app.db.models.downloadhistory import DownloadHistory, DownloadFiles
@@ -51,7 +51,7 @@ class DownloadHistoryOper(DbOper):
         """
         DownloadFiles.truncate(self._db)
 
-    def get_files_by_hash(self, download_hash: str, state: int = None) -> List[DownloadFiles]:
+    def get_files_by_hash(self, download_hash: str, state: Optional[int] = None) -> List[DownloadFiles]:
         """
         按Hash查询下载文件记录
         :param download_hash: 数据key
@@ -97,7 +97,7 @@ class DownloadHistoryOper(DbOper):
             return fileinfo.download_hash
         return ""
 
-    def list_by_page(self, page: int = 1, count: int = 30) -> List[DownloadHistory]:
+    def list_by_page(self, page: Optional[int] = 1, count: Optional[int] = 30) -> List[DownloadHistory]:
         """
         分页查询下载历史
         """
@@ -109,8 +109,8 @@ class DownloadHistoryOper(DbOper):
         """
         DownloadHistory.truncate(self._db)
 
-    def get_last_by(self, mtype=None, title: str = None, year: str = None,
-                    season: str = None, episode: str = None, tmdbid=None) -> List[DownloadHistory]:
+    def get_last_by(self, mtype=None, title: Optional[str] = None, year: Optional[str] = None,
+                    season: Optional[str] = None, episode: Optional[str] = None, tmdbid=None) -> List[DownloadHistory]:
         """
         按类型、标题、年份、季集查询下载记录
         """
@@ -122,7 +122,7 @@ class DownloadHistoryOper(DbOper):
                                            episode=episode,
                                            tmdbid=tmdbid)
 
-    def list_by_user_date(self, date: str, username: str = None) -> List[DownloadHistory]:
+    def list_by_user_date(self, date: str, username: Optional[str] = None) -> List[DownloadHistory]:
         """
         查询某用户某时间之前的下载历史
         """
@@ -130,7 +130,7 @@ class DownloadHistoryOper(DbOper):
                                                  date=date,
                                                  username=username)
 
-    def list_by_date(self, date: str, type: str, tmdbid: str, seasons: str = None) -> List[DownloadHistory]:
+    def list_by_date(self, date: str, type: str, tmdbid: str, seasons: Optional[str] = None) -> List[DownloadHistory]:
         """
         查询某时间之后的下载历史
         """
@@ -140,7 +140,7 @@ class DownloadHistoryOper(DbOper):
                                             tmdbid=tmdbid,
                                             seasons=seasons)
 
-    def list_by_type(self, mtype: str, days: int = 7) -> List[DownloadHistory]:
+    def list_by_type(self, mtype: str, days: Optional[int] = 7) -> List[DownloadHistory]:
         """
         获取指定类型的下载历史
         """

app/db/message_oper.py

@@ -18,14 +18,14 @@ class MessageOper(DbOper):
 
     def add(self,
             channel: MessageChannel = None,
-            source: str = None,
+            source: Optional[str] = None,
             mtype: NotificationType = None,
-            title: str = None,
-            text: str = None,
-            image: str = None,
-            link: str = None,
-            userid: str = None,
-            action: int = 1,
+            title: Optional[str] = None,
+            text: Optional[str] = None,
+            image: Optional[str] = None,
+            link: Optional[str] = None,
+            userid: Optional[str] = None,
+            action: Optional[int] = 1,
             note: Union[list, dict] = None,
             **kwargs):
         """
@@ -62,7 +62,7 @@ class MessageOper(DbOper):
 
         Message(**kwargs).create(self._db)
 
-    def list_by_page(self, page: int = 1, count: int = 30) -> Optional[str]:
+    def list_by_page(self, page: Optional[int] = 1, count: Optional[int] = 30) -> Optional[str]:
         """
         获取媒体服务器数据ID
         """

app/db/models/__init__.py

@@ -8,3 +8,4 @@ from .systemconfig import SystemConfig
 from .transferhistory import TransferHistory
 from .user import User
 from .userconfig import UserConfig
+from .workflow import Workflow

app/db/models/downloadhistory.py

@@ -1,4 +1,5 @@
 import time
+from typing import Optional
 
 from sqlalchemy import Column, Integer, String, Sequence, JSON
 from sqlalchemy.orm import Session
@@ -51,6 +52,8 @@ class DownloadHistory(Base):
     note = Column(JSON)
     # 自定义媒体类别
     media_category = Column(String)
+    # 剧集组
+    episode_group = Column(String)
 
     @staticmethod
     @db_query
@@ -67,7 +70,7 @@ class DownloadHistory(Base):
 
     @staticmethod
     @db_query
-    def list_by_page(db: Session, page: int = 1, count: int = 30):
+    def list_by_page(db: Session, page: Optional[int] = 1, count: Optional[int] = 30):
         result = db.query(DownloadHistory).offset((page - 1) * count).limit(count).all()
         return list(result)
 
@@ -78,8 +81,9 @@ class DownloadHistory(Base):
 
     @staticmethod
     @db_query
-    def get_last_by(db: Session, mtype: str = None, title: str = None, year: int = None, season: str = None,
-                    episode: str = None, tmdbid: int = None):
+    def get_last_by(db: Session, mtype: Optional[str] = None, title: Optional[str] = None, 
+                    year: Optional[str] = None, season: Optional[str] = None,
+                    episode: Optional[str] = None, tmdbid: Optional[int] = None):
         """
         据tmdbid、season、season_episode查询转移记录
         """
@@ -123,7 +127,7 @@ class DownloadHistory(Base):
 
     @staticmethod
     @db_query
-    def list_by_user_date(db: Session, date: str, username: str = None):
+    def list_by_user_date(db: Session, date: str, username: Optional[str] = None):
         """
         查询某用户某时间之后的下载历史
         """
@@ -138,7 +142,7 @@ class DownloadHistory(Base):
 
     @staticmethod
     @db_query
-    def list_by_date(db: Session, date: str, type: str, tmdbid: str, seasons: str = None):
+    def list_by_date(db: Session, date: str, type: str, tmdbid: str, seasons: Optional[str] = None):
         """
         查询某时间之后的下载历史
         """
@@ -187,7 +191,7 @@ class DownloadFiles(Base):
 
     @staticmethod
     @db_query
-    def get_by_hash(db: Session, download_hash: str, state: int = None):
+    def get_by_hash(db: Session, download_hash: str, state: Optional[int] = None):
         if state:
             result = db.query(DownloadFiles).filter(DownloadFiles.download_hash == download_hash,
                                                     DownloadFiles.state == state).all()

app/db/models/message.py

@@ -1,3 +1,5 @@
+from typing import Optional
+
 from sqlalchemy import Column, Integer, String, Sequence, JSON
 from sqlalchemy.orm import Session
 
@@ -34,7 +36,7 @@ class Message(Base):
 
     @staticmethod
     @db_query
-    def list_by_page(db: Session, page: int = 1, count: int = 30):
+    def list_by_page(db: Session, page: Optional[int] = 1, count: Optional[int] = 30):
         result = db.query(Message).order_by(Message.reg_time.desc()).offset((page - 1) * count).limit(
             count).all()
         result.sort(key=lambda x: x.reg_time, reverse=False)

app/db/models/siteuserdata.py

@@ -1,4 +1,5 @@
 from datetime import datetime
+from typing import Optional
 
 from sqlalchemy import Column, Integer, String, Sequence, Float, JSON, func, or_
 from sqlalchemy.orm import Session
@@ -54,7 +55,7 @@ class SiteUserData(Base):
 
     @staticmethod
     @db_query
-    def get_by_domain(db: Session, domain: str, workdate: str = None, worktime: str = None):
+    def get_by_domain(db: Session, domain: str, workdate: Optional[str] = None, worktime: Optional[str] = None):
         if workdate and worktime:
             return db.query(SiteUserData).filter(SiteUserData.domain == domain,
                                                  SiteUserData.updated_day == workdate,

app/db/models/subscribe.py

@@ -1,4 +1,5 @@
 import time
+from typing import Optional
 
 from sqlalchemy import Column, Integer, String, Sequence, Float, JSON
 from sqlalchemy.orm import Session
@@ -24,6 +25,7 @@ class Subscribe(Base):
     tvdbid = Column(Integer)
     doubanid = Column(String, index=True)
     bangumiid = Column(Integer, index=True)
+    mediaid = Column(String, index=True)
     # 季号
     season = Column(Integer)
     # 海报
@@ -82,10 +84,12 @@ class Subscribe(Base):
     media_category = Column(String)
     # 过滤规则组
     filter_groups = Column(JSON, default=list)
+    # 选择的剧集组
+    episode_group = Column(String)
 
     @staticmethod
     @db_query
-    def exists(db: Session, tmdbid: int = None, doubanid: str = None, season: int = None):
+    def exists(db: Session, tmdbid: Optional[int] = None, doubanid: Optional[str] = None, season: Optional[int] = None):
         if tmdbid:
             if season:
                 return db.query(Subscribe).filter(Subscribe.tmdbid == tmdbid,
@@ -109,7 +113,15 @@ class Subscribe(Base):
 
     @staticmethod
     @db_query
-    def get_by_tmdbid(db: Session, tmdbid: int, season: int = None):
+    def get_by_title(db: Session, title: str, season: Optional[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
+    @db_query
+    def get_by_tmdbid(db: Session, tmdbid: int, season: Optional[int] = None):
         if season:
             result = db.query(Subscribe).filter(Subscribe.tmdbid == tmdbid,
                                                 Subscribe.season == season).all()
@@ -117,14 +129,6 @@ class Subscribe(Base):
             result = db.query(Subscribe).filter(Subscribe.tmdbid == tmdbid).all()
         return list(result)
 
-    @staticmethod
-    @db_query
-    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
     @db_query
     def get_by_doubanid(db: Session, doubanid: str):
@@ -135,6 +139,11 @@ class Subscribe(Base):
     def get_by_bangumiid(db: Session, bangumiid: int):
         return db.query(Subscribe).filter(Subscribe.bangumiid == bangumiid).first()
 
+    @staticmethod
+    @db_query
+    def get_by_mediaid(db: Session, mediaid: str):
+        return db.query(Subscribe).filter(Subscribe.mediaid == mediaid).first()
+
     @db_update
     def delete_by_tmdbid(self, db: Session, tmdbid: int, season: int):
         subscrbies = self.get_by_tmdbid(db, tmdbid, season)
@@ -149,9 +158,16 @@ class Subscribe(Base):
             subscribe.delete(db, subscribe.id)
         return True
 
+    @db_update
+    def delete_by_mediaid(self, db: Session, mediaid: str):
+        subscribe = self.get_by_mediaid(db, mediaid)
+        if subscribe:
+            subscribe.delete(db, subscribe.id)
+        return True
+
     @staticmethod
     @db_query
-    def list_by_username(db: Session, username: str, state: str = None, mtype: str = None):
+    def list_by_username(db: Session, username: str, state: Optional[str] = None, mtype: Optional[str] = None):
         if mtype:
             if state:
                 result = db.query(Subscribe).filter(Subscribe.state == state,

app/db/models/subscribehistory.py

@@ -1,3 +1,5 @@
+from typing import Optional
+
 from sqlalchemy import Column, Integer, String, Sequence, Float, JSON
 from sqlalchemy.orm import Session
 
@@ -22,6 +24,7 @@ class SubscribeHistory(Base):
     tvdbid = Column(Integer)
     doubanid = Column(String, index=True)
     bangumiid = Column(Integer, index=True)
+    mediaid = Column(String, index=True)
     # 季号
     season = Column(Integer)
     # 海报
@@ -66,13 +69,27 @@ class SubscribeHistory(Base):
     media_category = Column(String)
     # 过滤规则组
     filter_groups = Column(JSON, default=list)
+    # 剧集组
+    episode_group = Column(String)
 
     @staticmethod
     @db_query
-    def list_by_type(db: Session, mtype: str, page: int = 1, count: int = 30):
+    def list_by_type(db: Session, mtype: str, page: Optional[int] = 1, count: Optional[int] = 30):
         result = db.query(SubscribeHistory).filter(
             SubscribeHistory.type == mtype
         ).order_by(
-                SubscribeHistory.date.desc()
+            SubscribeHistory.date.desc()
         ).offset((page - 1) * count).limit(count).all()
         return list(result)
+
+    @staticmethod
+    @db_query
+    def exists(db: Session, tmdbid: Optional[int] = None, doubanid: Optional[str] = None, season: Optional[int] = None):
+        if tmdbid:
+            if season:
+                return db.query(SubscribeHistory).filter(SubscribeHistory.tmdbid == tmdbid,
+                                                         SubscribeHistory.season == season).first()
+            return db.query(SubscribeHistory).filter(SubscribeHistory.tmdbid == tmdbid).first()
+        elif doubanid:
+            return db.query(SubscribeHistory).filter(SubscribeHistory.doubanid == doubanid).first()
+        return None

app/db/models/transferhistory.py

@@ -1,4 +1,5 @@
 import time
+from typing import Optional
 
 from sqlalchemy import Column, Integer, String, Sequence, Boolean, func, or_, JSON
 from sqlalchemy.orm import Session
@@ -55,10 +56,12 @@ class TransferHistory(Base):
     date = Column(String, index=True)
     # 文件清单，以JSON存储
     files = Column(JSON, default=list)
+    # 剧集组
+    episode_group = Column(String)
 
     @staticmethod
     @db_query
-    def list_by_title(db: Session, title: str, page: int = 1, count: int = 30, status: bool = None):
+    def list_by_title(db: Session, title: str, page: Optional[int] = 1, count: Optional[int] = 30, status: bool = None):
         if status is not None:
             result = db.query(TransferHistory).filter(
                 TransferHistory.status == status
@@ -77,7 +80,7 @@ class TransferHistory(Base):
 
     @staticmethod
     @db_query
-    def list_by_page(db: Session, page: int = 1, count: int = 30, status: bool = None):
+    def list_by_page(db: Session, page: Optional[int] = 1, count: Optional[int] = 30, status: bool = None):
         if status is not None:
             result = db.query(TransferHistory).filter(
                 TransferHistory.status == status
@@ -97,7 +100,7 @@ class TransferHistory(Base):
 
     @staticmethod
     @db_query
-    def get_by_src(db: Session, src: str, storage: str = None):
+    def get_by_src(db: Session, src: str, storage: Optional[str] = None):
         if storage:
             return db.query(TransferHistory).filter(TransferHistory.src == src,
                                                     TransferHistory.src_storage == storage).first()
@@ -117,7 +120,7 @@ class TransferHistory(Base):
 
     @staticmethod
     @db_query
-    def statistic(db: Session, days: int = 7):
+    def statistic(db: Session, days: Optional[int] = 7):
         """
         统计最近days天的下载历史数量，按日期分组返回每日数量
         """
@@ -150,8 +153,8 @@ class TransferHistory(Base):
 
     @staticmethod
     @db_query
-    def list_by(db: Session, mtype: str = None, title: str = None, year: str = None, season: str = None,
-                episode: str = None, tmdbid: int = None, dest: str = None):
+    def list_by(db: Session, mtype: Optional[str] = None, title: Optional[str] = None, year: Optional[str] = None, season: Optional[str] = None,
+                episode: Optional[str] = None, tmdbid: Optional[int] = None, dest: Optional[str] = None):
         """
         据tmdbid、season、season_episode查询转移记录
         tmdbid + mtype 或 title + year 必输
@@ -218,7 +221,7 @@ class TransferHistory(Base):
 
     @staticmethod
     @db_query
-    def get_by_type_tmdbid(db: Session, mtype: str = None, tmdbid: int = None):
+    def get_by_type_tmdbid(db: Session, mtype: Optional[str] = None, tmdbid: Optional[int] = None):
         """
         据tmdbid、type查询转移记录
         """
@@ -227,7 +230,7 @@ class TransferHistory(Base):
 
     @staticmethod
     @db_update
-    def update_download_hash(db: Session, historyid: int = None, download_hash: str = None):
+    def update_download_hash(db: Session, historyid: Optional[int] = None, download_hash: Optional[str] = None):
         db.query(TransferHistory).filter(TransferHistory.id == historyid).update(
             {
                 "download_hash": download_hash

app/db/models/workflow.py

@@ -0,0 +1,103 @@
+from datetime import datetime
+from typing import Optional
+
+from sqlalchemy import Column, Integer, JSON, Sequence, String, and_
+
+from app.db import Base, db_query, db_update
+
+
+class Workflow(Base):
+    """
+    工作流表
+    """
+    # ID
+    id = Column(Integer, Sequence('id'), primary_key=True, index=True)
+    # 名称
+    name = Column(String, index=True, nullable=False)
+    # 描述
+    description = Column(String)
+    # 定时器
+    timer = Column(String)
+    # 状态：W-等待 R-运行中 P-暂停 S-成功 F-失败
+    state = Column(String, nullable=False, index=True, default='W')
+    # 已执行动作（,分隔）
+    current_action = Column(String)
+    # 任务执行结果
+    result = Column(String)
+    # 已执行次数
+    run_count = Column(Integer, default=0)
+    # 任务列表
+    actions = Column(JSON, default=list)
+    # 任务流
+    flows = Column(JSON, default=list)
+    # 执行上下文
+    context = Column(JSON, default=dict)
+    # 创建时间
+    add_time = Column(String, default=datetime.now().strftime('%Y-%m-%d %H:%M:%S'))
+    # 最后执行时间
+    last_time = Column(String)
+
+    @staticmethod
+    @db_query
+    def get_enabled_workflows(db):
+        return db.query(Workflow).filter(Workflow.state != 'P').all()
+
+    @staticmethod
+    @db_query
+    def get_by_name(db, name: str):
+        return db.query(Workflow).filter(Workflow.name == name).first()
+
+    @staticmethod
+    @db_update
+    def update_state(db, wid: int, state: str):
+        db.query(Workflow).filter(Workflow.id == wid).update({"state": state})
+        return True
+
+    @staticmethod
+    @db_update
+    def start(db, wid: int):
+        db.query(Workflow).filter(Workflow.id == wid).update({
+            "state": 'R'
+        })
+        return True
+
+    @staticmethod
+    @db_update
+    def fail(db, wid: int, result: str):
+        db.query(Workflow).filter(and_(Workflow.id == wid, Workflow.state != "P")).update({
+            "state": 'F',
+            "result": result,
+            "last_time": datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+        })
+        return True
+
+    @staticmethod
+    @db_update
+    def success(db, wid: int, result: Optional[str] = None):
+        db.query(Workflow).filter(and_(Workflow.id == wid, Workflow.state != "P")).update({
+            "state": 'S',
+            "result": result,
+            "run_count": Workflow.run_count + 1,
+            "last_time": datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+        })
+        return True
+
+    @staticmethod
+    @db_update
+    def reset(db, wid: int, reset_count: Optional[bool] = False):
+        db.query(Workflow).filter(Workflow.id == wid).update({
+            "state": 'W',
+            "result": None,
+            "current_action": None,
+            "run_count": 0 if reset_count else Workflow.run_count,
+        })
+        return True
+
+    @staticmethod
+    @db_update
+    def update_current_action(db, wid: int, action_id: str, context: dict):
+        db.query(Workflow).filter(Workflow.id == wid).update({
+            "current_action": Workflow.current_action + f",{action_id}" if Workflow.current_action else action_id,
+            "context": context
+        })
+        return True

app/db/plugindata_oper.py

@@ -1,4 +1,4 @@
-from typing import Any
+from typing import Any, Optional
 
 from app.db import DbOper
 from app.db.models.plugindata import PluginData
@@ -24,7 +24,7 @@ class PluginDataOper(DbOper):
         else:
             PluginData(plugin_id=plugin_id, key=key, value=value).create(self._db)
 
-    def get_data(self, plugin_id: str, key: str = None) -> Any:
+    def get_data(self, plugin_id: str, key: Optional[str] = None) -> Any:
         """
         获取插件数据
         :param plugin_id: 插件id
@@ -38,7 +38,7 @@ class PluginDataOper(DbOper):
         else:
             return PluginData.get_plugin_data(self._db, plugin_id)
 
-    def del_data(self, plugin_id: str, key: str = None) -> Any:
+    def del_data(self, plugin_id: str, key: Optional[str] = None) -> Any:
         """
         删除插件数据
         :param plugin_id: 插件id

app/db/site_oper.py

@@ -1,5 +1,5 @@
 from datetime import datetime
-from typing import List, Tuple
+from typing import List, Tuple, Optional
 
 from app.db import DbOper
 from app.db.models import SiteIcon
@@ -121,7 +121,8 @@ class SiteOper(DbOper):
         siteuserdatas = SiteUserData.get_by_domain(self._db, domain=domain, workdate=current_day)
         if siteuserdatas:
             # 存在则更新
-            siteuserdatas[0].update(self._db, payload)
+            if not payload.get("err_msg"):
+                siteuserdatas[0].update(self._db, payload)
         else:
             # 不存在则插入
             SiteUserData(**payload).create(self._db)
@@ -133,7 +134,7 @@ class SiteOper(DbOper):
         """
         return SiteUserData.list(self._db)
 
-    def get_userdata_by_domain(self, domain: str, workdate: str = None) -> List[SiteUserData]:
+    def get_userdata_by_domain(self, domain: str, workdate: Optional[str] = None) -> List[SiteUserData]:
         """
         获取站点用户数据
         """
@@ -172,7 +173,7 @@ class SiteOper(DbOper):
             })
         return True
 
-    def success(self, domain: str, seconds: int = None):
+    def success(self, domain: str, seconds: Optional[int] = None):
         """
         站点访问成功
         """

app/db/subscribe_oper.py

@@ -1,5 +1,5 @@
 import time
-from typing import Tuple, List
+from typing import Tuple, List, Optional
 
 from app.core.context import MediaInfo
 from app.db import DbOper
@@ -20,21 +20,24 @@ class SubscribeOper(DbOper):
                                      tmdbid=mediainfo.tmdb_id,
                                      doubanid=mediainfo.douban_id,
                                      season=kwargs.get('season'))
+        kwargs.update({
+            "name": mediainfo.title,
+            "year": mediainfo.year,
+            "type": mediainfo.type.value,
+            "tmdbid": mediainfo.tmdb_id,
+            "imdbid": mediainfo.imdb_id,
+            "tvdbid": mediainfo.tvdb_id,
+            "doubanid": mediainfo.douban_id,
+            "bangumiid": mediainfo.bangumi_id,
+            "episode_group": mediainfo.episode_group,
+            "poster": mediainfo.get_poster_image(),
+            "backdrop": mediainfo.get_backdrop_image(),
+            "vote": mediainfo.vote_average,
+            "description": mediainfo.overview,
+            "date": time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
+        })
         if not subscribe:
-            subscribe = Subscribe(name=mediainfo.title,
-                                  year=mediainfo.year,
-                                  type=mediainfo.type.value,
-                                  tmdbid=mediainfo.tmdb_id,
-                                  imdbid=mediainfo.imdb_id,
-                                  tvdbid=mediainfo.tvdb_id,
-                                  doubanid=mediainfo.douban_id,
-                                  bangumiid=mediainfo.bangumi_id,
-                                  poster=mediainfo.get_poster_image(),
-                                  backdrop=mediainfo.get_backdrop_image(),
-                                  vote=mediainfo.vote_average,
-                                  description=mediainfo.overview,
-                                  date=time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()),
-                                  **kwargs)
+            subscribe = Subscribe(**kwargs)
             subscribe.create(self._db)
             # 查询订阅
             subscribe = Subscribe.exists(self._db,
@@ -45,7 +48,7 @@ class SubscribeOper(DbOper):
         else:
             return subscribe.id, "订阅已存在"
 
-    def exists(self, tmdbid: int = None, doubanid: str = None, season: int = None) -> bool:
+    def exists(self, tmdbid: Optional[int] = None, doubanid: Optional[str] = None, season: Optional[int] = None) -> bool:
         """
         判断是否存在
         """
@@ -64,7 +67,7 @@ class SubscribeOper(DbOper):
         """
         return Subscribe.get(self._db, rid=sid)
 
-    def list(self, state: str = None) -> List[Subscribe]:
+    def list(self, state: Optional[str] = None) -> List[Subscribe]:
         """
         获取订阅列表
         """
@@ -87,19 +90,19 @@ class SubscribeOper(DbOper):
             subscribe.update(self._db, payload)
         return subscribe
 
-    def list_by_tmdbid(self, tmdbid: int, season: int = None) -> List[Subscribe]:
+    def list_by_tmdbid(self, tmdbid: int, season: Optional[int] = None) -> List[Subscribe]:
         """
         获取指定tmdb_id的订阅
         """
         return Subscribe.get_by_tmdbid(self._db, tmdbid=tmdbid, season=season)
 
-    def list_by_username(self, username: str, state: str = None, mtype: str = None) -> List[Subscribe]:
+    def list_by_username(self, username: str, state: Optional[str] = None, mtype: Optional[str] = None) -> List[Subscribe]:
         """
         获取指定用户的订阅
         """
         return Subscribe.list_by_username(self._db, username=username, state=state, mtype=mtype)
 
-    def list_by_type(self, mtype: str, days: int = 7) -> Subscribe:
+    def list_by_type(self, mtype: str, days: Optional[int] = 7) -> Subscribe:
         """
         获取指定类型的订阅
         """
@@ -118,3 +121,16 @@ class SubscribeOper(DbOper):
             kwargs.pop("id")
         subscribe = SubscribeHistory(**kwargs)
         subscribe.create(self._db)
+
+    def exist_history(self, tmdbid: Optional[int] = None, doubanid: Optional[str] = None, season: Optional[int] = None):
+        """
+        判断是否存在订阅历史
+        """
+        if tmdbid:
+            if season:
+                return True if SubscribeHistory.exists(self._db, tmdbid=tmdbid, season=season) else False
+            else:
+                return True if SubscribeHistory.exists(self._db, tmdbid=tmdbid) else False
+        elif doubanid:
+            return True if SubscribeHistory.exists(self._db, doubanid=doubanid) else False
+        return False

app/db/transferhistory_oper.py

@@ -1,5 +1,5 @@
 import time
-from typing import Any, List
+from typing import Any, List, Optional
 
 from app.core.context import MediaInfo
 from app.core.meta import MetaBase
@@ -27,7 +27,7 @@ class TransferHistoryOper(DbOper):
         """
         return TransferHistory.list_by_title(self._db, title)
 
-    def get_by_src(self, src: str, storage: str = None) -> TransferHistory:
+    def get_by_src(self, src: str, storage: Optional[str] = None) -> TransferHistory:
         """
         按源查询转移记录
         :param src: 数据key
@@ -58,14 +58,15 @@ class TransferHistoryOper(DbOper):
         })
         TransferHistory(**kwargs).create(self._db)
 
-    def statistic(self, days: int = 7) -> List[Any]:
+    def statistic(self, days: Optional[int] = 7) -> List[Any]:
         """
         统计最近days天的下载历史数量
         """
         return TransferHistory.statistic(self._db, days)
 
-    def get_by(self, title: str = None, year: str = None, mtype: str = None,
-               season: str = None, episode: str = None, tmdbid: int = None, dest: str = None) -> List[TransferHistory]:
+    def get_by(self, title: Optional[str] = None, year: Optional[str] = None, mtype: Optional[str] = None,
+               season: Optional[str] = None, episode: Optional[str] = None, tmdbid: Optional[int] = None,
+               dest: Optional[str] = None) -> List[TransferHistory]:
         """
         按类型、标题、年份、季集查询转移记录
         """
@@ -78,7 +79,7 @@ class TransferHistoryOper(DbOper):
                                        episode=episode,
                                        tmdbid=tmdbid)
 
-    def get_by_type_tmdbid(self, mtype: str = None, tmdbid: int = None) -> TransferHistory:
+    def get_by_type_tmdbid(self, mtype: Optional[str] = None, tmdbid: Optional[int] = None) -> TransferHistory:
         """
         按类型、tmdb查询转移记录
         """
@@ -120,7 +121,7 @@ class TransferHistoryOper(DbOper):
 
     def add_success(self, fileitem: FileItem, mode: str, meta: MetaBase,
                     mediainfo: MediaInfo, transferinfo: TransferInfo,
-                    downloader: str = None, download_hash: str = None):
+                    downloader: Optional[str] = None, download_hash: Optional[str] = None):
         """
         新增转移成功历史记录
         """
@@ -150,7 +151,7 @@ class TransferHistoryOper(DbOper):
         )
 
     def add_fail(self, fileitem: FileItem, mode: str, meta: MetaBase, mediainfo: MediaInfo = None,
-                 transferinfo: TransferInfo = None, downloader: str = None, download_hash: str = None):
+                 transferinfo: TransferInfo = None, downloader: Optional[str] = None, download_hash: Optional[str] = None):
         """
         新增转移失败历史记录
         """
@@ -176,6 +177,7 @@ class TransferHistoryOper(DbOper):
                 image=mediainfo.get_poster_image(),
                 downloader=downloader,
                 download_hash=download_hash,
+                episode_group=mediainfo.episode_group,
                 status=0,
                 errmsg=transferinfo.message or '未知错误',
                 files=transferinfo.file_list

app/db/user_oper.py

@@ -1,4 +1,4 @@
-from typing import Optional
+from typing import Optional, List
 
 from fastapi import Depends, HTTPException
 from sqlalchemy.orm import Session
@@ -51,6 +51,12 @@ class UserOper(DbOper):
     用户管理
     """
 
+    def list(self) -> List[User]:
+        """
+        获取用户列表
+        """
+        return User.list(self._db)
+
     def add(self, **kwargs):
         """
         新增用户
@@ -67,27 +73,6 @@ class UserOper(DbOper):
     def get_permissions(self, name: str) -> dict:
         """
         获取用户权限
-        {
-            "admin": "管理员",
-            "usermanage": "用户管理",
-            "dashboard": "仪表板",
-            "ranking": "推荐榜单",
-            "resource": {
-                "search": "搜索站点资源",
-                "download": "下载站点资源",
-            },
-            "subscribe": {
-                "request": "提交订阅请求",
-                "autopass": "订阅请求自动批准"
-                "approve": "审批订阅请求",
-                "calendar": "查看订阅日历",
-                "manage": "管理所有订阅"
-            },
-            "downloading": {
-                "view": "查看正在下载任务",
-                "manager": "管理正在下载任务"
-            }
-        }
         """
         user = User.get_by_name(self._db, name)
         if user:
@@ -111,3 +96,16 @@ class UserOper(DbOper):
         if settings:
             return settings.get(key)
         return None
+
+    def get_name(self, **kwargs) -> Optional[str]:
+        """
+        根据绑定账号获取用户名称
+        """
+        users = self.list()
+        for user in users:
+            user_setting = user.settings
+            if user_setting:
+                for k, v in kwargs.items():
+                    if user_setting.get(k) == str(v):
+                        return user.name
+        return None

app/db/workflow_oper.py

@@ -0,0 +1,68 @@
+from typing import List, Tuple, Optional
+
+from app.db import DbOper
+from app.db.models.workflow import Workflow
+
+
+class WorkflowOper(DbOper):
+    """
+    工作流管理
+    """
+
+    def add(self, **kwargs) -> Tuple[bool, str]:
+        """
+        新增工作流
+        """
+        wf = Workflow(**kwargs)
+        if not wf.get_by_name(self._db, kwargs.get("name")):
+            wf.create(self._db)
+            return True, "新增工作流成功"
+        return False, "工作流已存在"
+
+    def get(self, wid: int) -> Workflow:
+        """
+        查询单个工作流
+        """
+        return Workflow.get(self._db, wid)
+
+    def list_enabled(self) -> List[Workflow]:
+        """
+        获取启用的工作流列表
+        """
+        return Workflow.get_enabled_workflows(self._db)
+
+    def get_by_name(self, name: str) -> Workflow:
+        """
+        按名称获取工作流
+        """
+        return Workflow.get_by_name(self._db, name)
+
+    def start(self, wid: int) -> bool:
+        """
+        启动
+        """
+        return Workflow.start(self._db, wid)
+
+    def success(self, wid: int, result: Optional[str] = None) -> bool:
+        """
+        成功
+        """
+        return Workflow.success(self._db, wid, result)
+
+    def fail(self, wid: int, result: str) -> bool:
+        """
+        失败
+        """
+        return Workflow.fail(self._db, wid, result)
+
+    def step(self, wid: int, action_id: str, context: dict) -> bool:
+        """
+        步进
+        """
+        return Workflow.update_current_action(self._db, wid, action_id, context)
+
+    def reset(self, wid: int, reset_count: bool = False) -> bool:
+        """
+        重置
+        """
+        return Workflow.reset(self._db, wid, reset_count=reset_count)

app/helper/browser.py

@@ -1,4 +1,4 @@
-from typing import Callable, Any
+from typing import Callable, Any, Optional
 
 from playwright.sync_api import sync_playwright, Page
 from cf_clearance import sync_cf_retry, sync_stealth
@@ -20,11 +20,11 @@ class PlaywrightHelper:
 
     def action(self, url: str,
                callback: Callable,
-               cookies: str = None,
-               ua: str = None,
-               proxies: dict = None,
-               headless: bool = False,
-               timeout: int = 30) -> Any:
+               cookies: Optional[str] = None,
+               ua: Optional[str] = None,
+               proxies: Optional[dict] = None,
+               headless: Optional[bool] = False,
+               timeout: Optional[int] = 30) -> Any:
         """
         访问网页，接收Page对象并执行操作
         :param url: 网页地址
@@ -57,11 +57,11 @@ class PlaywrightHelper:
         return None
 
     def get_page_source(self, url: str,
-                        cookies: str = None,
-                        ua: str = None,
-                        proxies: dict = None,
-                        headless: bool = False,
-                        timeout: int = 20) -> str:
+                        cookies: Optional[str] = None,
+                        ua: Optional[str] = None,
+                        proxies: Optional[dict] = None,
+                        headless: Optional[bool] = False,
+                        timeout: Optional[int] = 20) -> Optional[str]:
         """
         获取网页源码
         :param url: 网页地址

app/helper/cookie.py

@@ -73,8 +73,8 @@ class CookieHelper:
                            url: str,
                            username: str,
                            password: str,
-                           two_step_code: str = None,
-                           proxies: dict = None) -> Tuple[Optional[str], Optional[str], str]:
+                           two_step_code: Optional[str] = None,
+                           proxies: Optional[dict] = None) -> Tuple[Optional[str], Optional[str], str]:
         """
         获取站点cookie和ua
         :param url: 站点地址

app/helper/directory.py

@@ -49,9 +49,9 @@ class DirectoryHelper:
         """
         return [d for d in self.get_library_dirs() if d.library_storage == "local"]
 
-    def get_dir(self, media: MediaInfo, include_unsorted: bool = False,
-                storage: str = None, src_path: Path = None,
-                target_storage: str = None, dest_path: Path = None
+    def get_dir(self, media: MediaInfo, include_unsorted: Optional[bool] = False,
+                storage: Optional[str] = None, src_path: Path = None,
+                target_storage: Optional[str] = None, dest_path: Path = None
                 ) -> Optional[schemas.TransferDirectoryConf]:
         """
         根据媒体信息获取下载目录、媒体库目录配置

app/helper/display.py

@@ -24,4 +24,3 @@ class DisplayHelper(metaclass=Singleton):
             logger.info("正在停止虚拟显示...")
             self._display.stop()
             logger.info("虚拟显示已停止")
-

app/helper/doh.py

@@ -129,7 +129,7 @@ def doh_query_json(resolver: str, host: str) -> Optional[str]:
             if response.status != 200:
                 return None
             response_body = response.read().decode("utf-8")
-            logger.debug("<==  body: %s", response_body)
+            logger.debug("<== body: %s", response_body)
             answer = json.loads(response_body)["Answer"]
             return answer[0]["data"]
     except Exception as e:

app/helper/format.py

@@ -10,8 +10,8 @@ class FormatParser(object):
     _key = ""
     _split_chars = r"\.|\s+|\(|\)|\[|]|-|\+|【|】|/|～|;|&|\||#|_|「|」|~"
 
-    def __init__(self, eformat: str, details: str = None, part: str = None,
-                 offset: str = None, key: str = "ep"):
+    def __init__(self, eformat: str, details: Optional[str] = None, part: Optional[str] = None,
+                 offset: Optional[str] = None, key: Optional[str] = "ep"):
         """
         :params eformat: 格式化字符串
         :params details: 格式化详情
@@ -99,7 +99,7 @@ class FormatParser(object):
                     # `details` 格式为 `X`
                     start_ep = self.__offset.replace("EP", str(self._start_ep))
                     return int(eval(start_ep)), None, self.part
-            else:
+            elif not self._format:
                 # `details` 格式为 `X,X`
                 start_ep = self.__offset.replace("EP", str(self._start_ep))
                 end_ep = self.__offset.replace("EP", str(self._end_ep))

app/helper/message.py

@@ -1,9 +1,154 @@
+from __future__ import annotations
+
 import json
 import queue
+import threading
 import time
-from typing import Optional, Any, Union
+from datetime import datetime
+from typing import Any, Union
+from typing import List, Optional, Callable
 
-from app.utils.singleton import Singleton
+from app.core.config import global_vars
+from app.db.systemconfig_oper import SystemConfigOper
+from app.schemas.types import SystemConfigKey
+from app.utils.singleton import Singleton, SingletonClass
+from app.log import logger
+
+
+class MessageQueueManager(metaclass=SingletonClass):
+    """
+    消息发送队列管理器
+    """
+
+    schedule_periods: List[tuple[int, int, int, int]] = []
+
+    def __init__(
+            self,
+            send_callback: Optional[Callable] = None,
+            check_interval: Optional[int] = 10
+    ) -> None:
+        """
+        消息队列管理器初始化
+
+        :param send_callback: 实际发送消息的回调函数
+        :param check_interval: 时间检查间隔（秒）
+        """
+        self.init_config()
+
+        self.queue: queue.Queue[Any] = queue.Queue()
+        self.send_callback = send_callback
+        self.check_interval = check_interval
+
+        self._running = True
+        self.thread = threading.Thread(target=self._monitor_loop, daemon=True)
+        self.thread.start()
+
+    def init_config(self):
+        """
+        初始化配置
+        """
+        self.schedule_periods = self._parse_schedule(
+            SystemConfigOper().get(SystemConfigKey.NotificationSendTime)
+        )
+
+    @staticmethod
+    def _parse_schedule(periods: Union[list, dict]) -> List[tuple[int, int, int, int]]:
+        """
+        将字符串时间格式转换为分钟数元组
+        """
+        parsed = []
+        if not periods:
+            return parsed
+        if not isinstance(periods, list):
+            periods = [periods]
+        for period in periods:
+            if not period:
+                continue
+            if not period.get('start') or not period.get('end'):
+                continue
+            start_h, start_m = map(int, period['start'].split(':'))
+            end_h, end_m = map(int, period['end'].split(':'))
+            parsed.append((start_h, start_m, end_h, end_m))
+        return parsed
+
+    @staticmethod
+    def _time_to_minutes(time_str: str) -> int:
+        """
+        将 'HH:MM' 格式转换为分钟数
+        """
+        hours, minutes = map(int, time_str.split(':'))
+        return hours * 60 + minutes
+
+    def _is_in_scheduled_time(self, current_time: datetime) -> bool:
+        """
+        检查当前时间是否在允许发送的时间段内
+        """
+        if not self.schedule_periods:
+            return True
+        current_minutes = current_time.hour * 60 + current_time.minute
+        for period in self.schedule_periods:
+            s_h, s_m, e_h, e_m = period
+            start = s_h * 60 + s_m
+            end = e_h * 60 + e_m
+
+            if start <= end:
+                if start <= current_minutes <= end:
+                    return True
+            else:
+                if current_minutes >= start or current_minutes <= end:
+                    return True
+        return False
+
+    def send_message(self, *args, **kwargs) -> None:
+        """
+        发送消息（立即发送或加入队列）
+        """
+        if self._is_in_scheduled_time(datetime.now()):
+            self._send(*args, **kwargs)
+        else:
+            self.queue.put({
+                "args": args,
+                "kwargs": kwargs
+            })
+            logger.info(f"消息已加入队列，当前队列长度：{self.queue.qsize()}")
+
+    def _send(self, *args, **kwargs) -> None:
+        """
+        实际发送消息（可通过回调函数自定义）
+        """
+        if self.send_callback:
+            try:
+                logger.info(f"发送消息：{kwargs}")
+                self.send_callback(*args, **kwargs)
+            except Exception as e:
+                logger.error(f"发送消息错误：{str(e)}")
+
+    def _monitor_loop(self) -> None:
+        """
+        后台线程循环检查时间并处理队列
+        """
+        while self._running:
+            current_time = datetime.now()
+            if self._is_in_scheduled_time(current_time):
+                while not self.queue.empty():
+                    if global_vars.is_system_stopped:
+                        break
+                    if not self._is_in_scheduled_time(datetime.now()):
+                        break
+                    try:
+                        message = self.queue.get_nowait()
+                        self._send(*message['args'], **message['kwargs'])
+                        logger.info(f"队列剩余消息：{self.queue.qsize()}")
+                    except queue.Empty:
+                        break
+            time.sleep(self.check_interval)
+
+    def stop(self) -> None:
+        """
+        停止队列管理器
+        """
+        self._running = False
+        self.thread.join()
 
 
 class MessageHelper(metaclass=Singleton):

app/helper/module.py

@@ -3,18 +3,26 @@ import importlib
 import pkgutil
 import traceback
 from pathlib import Path
-from typing import List, Any
+from typing import List, Any, Callable
 
 from app.log import logger
 
 
+FilterFuncType = Callable[[str, Any], bool]
+
+def _default_filter(name: str, obj: Any) -> bool:
+    """
+    默认过滤器
+    """
+    return True
+
 class ModuleHelper:
     """
     模块动态加载
     """
 
     @classmethod
-    def load(cls, package_path: str, filter_func=lambda name, obj: True) -> List[Any]:
+    def load(cls, package_path: str, filter_func: FilterFuncType = _default_filter) -> List[Any]:
         """
         导入模块
         :param package_path: 父包名
@@ -23,6 +31,7 @@ class ModuleHelper:
         """
 
         submodules: list = []
+        loaded_modules = set()
         packages = importlib.import_module(package_path)
         for importer, package_name, _ in pkgutil.iter_modules(packages.__path__):
             try:
@@ -35,6 +44,9 @@ class ModuleHelper:
                     if name.startswith('_'):
                         continue
                     if isinstance(obj, type) and filter_func(name, obj):
+                        if name in loaded_modules:
+                            continue
+                        loaded_modules.add(name)
                         submodules.append(obj)
             except Exception as err:
                 logger.debug(f'加载模块 {package_name} 失败：{str(err)} - {traceback.format_exc()}')
@@ -42,7 +54,7 @@ class ModuleHelper:
         return submodules
 
     @classmethod
-    def load_with_pre_filter(cls, package_path: str, filter_func=lambda name, obj: True) -> List[Any]:
+    def load_with_pre_filter(cls, package_path: str, filter_func: FilterFuncType = _default_filter) -> List[Any]:
         """
         导入子模块
         :param package_path: 父包名
@@ -64,13 +76,12 @@ class ModuleHelper:
 
         def reload_sub_modules(parent_module, parent_module_name):
             """重新加载一级子模块"""
-            for sub_importer, sub_module_name, sub_is_pkg in pkgutil.walk_packages(parent_module.__path__):
-                full_sub_module_name = f'{parent_module_name}.{sub_module_name}'
+            for sub_importer, sub_module_name, sub_is_pkg in pkgutil.walk_packages(parent_module.__path__, parent_module_name+'.'):
                 try:
-                    full_sub_module = importlib.import_module(full_sub_module_name)
+                    full_sub_module = importlib.import_module(sub_module_name)
                     importlib.reload(full_sub_module)
                 except Exception as sub_err:
-                    logger.debug(f'加载子模块 {full_sub_module_name} 失败：{str(sub_err)} - {traceback.format_exc()}')
+                    logger.debug(f'加载子模块 {sub_module_name} 失败：{str(sub_err)} - {traceback.format_exc()}')
 
         # 遍历包中的所有子模块
         for importer, package_name, is_pkg in pkgutil.iter_modules(packages.__path__):

app/helper/ocr.py

@@ -1,4 +1,5 @@
 import base64
+from typing import Optional
 
 from app.core.config import settings
 from app.utils.http import RequestUtils
@@ -8,7 +9,8 @@ class OcrHelper:
 
     _ocr_b64_url = f"{settings.OCR_HOST}/captcha/base64"
 
-    def get_captcha_text(self, image_url=None, image_b64=None, cookie=None, ua=None):
+    def get_captcha_text(self, image_url: Optional[str] = None, image_b64: Optional[str] = None, 
+                         cookie: Optional[str] = None, ua: Optional[str] = None):
         """
         根据图片地址，获取验证码图片，并识别内容
         :param image_url: 图片地址

app/helper/plugin.py

@@ -4,11 +4,11 @@ import traceback
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Tuple, Set
 
-from cachetools import TTLCache, cached
 from packaging.specifiers import SpecifierSet, InvalidSpecifier
 from packaging.version import Version, InvalidVersion
 from pkg_resources import Requirement, working_set
 
+from app.core.cache import cached
 from app.core.config import settings
 from app.db.systemconfig_oper import SystemConfigOper
 from app.log import logger
@@ -38,32 +38,35 @@ class PluginHelper(metaclass=Singleton):
                 if self.install_report():
                     self.systemconfig.set(SystemConfigKey.PluginInstallReport, "1")
 
-    @cached(cache=TTLCache(maxsize=1000, ttl=1800))
-    def get_plugins(self, repo_url: str, package_version: str = None) -> Dict[str, dict]:
+    @cached(maxsize=1000, ttl=1800)
+    def get_plugins(self, repo_url: str, package_version: Optional[str] = None) -> Optional[Dict[str, dict]]:
         """
         获取Github所有最新插件列表
         :param repo_url: Github仓库地址
         :param package_version: 首选插件版本 (如 "v2", "v3")，如果不指定则获取 v1 版本
         """
         if not repo_url:
-            return {}
+            return None
 
         user, repo = self.get_repo_info(repo_url)
         if not user or not repo:
-            return {}
+            return None
 
         raw_url = self._base_url.format(user=user, repo=repo)
         package_url = f"{raw_url}package.{package_version}.json" if package_version else f"{raw_url}package.json"
 
         res = self.__request_with_fallback(package_url, headers=settings.REPO_GITHUB_HEADERS(repo=f"{user}/{repo}"))
+        if res is None:
+            return None
         if res:
             try:
                 return json.loads(res.text)
             except json.JSONDecodeError:
                 logger.error(f"插件包数据解析失败：{res.text}")
+                return None
         return {}
 
-    def get_plugin_package_version(self, pid: str, repo_url: str, package_version: str = None) -> Optional[str]:
+    def get_plugin_package_version(self, pid: str, repo_url: str, package_version: Optional[str] = None) -> Optional[str]:
         """
         检查并获取指定插件的可用版本，支持多版本优先级加载和版本兼容性检测
         1. 如果未指定版本，则使用系统配置的默认版本（通过 settings.VERSION_FLAG 设置）
@@ -113,7 +116,7 @@ class PluginHelper(metaclass=Singleton):
             return None, None
         return user, repo
 
-    @cached(cache=TTLCache(maxsize=1, ttl=1800))
+    @cached(maxsize=1, ttl=1800)
     def get_statistic(self) -> Dict:
         """
         获取插件安装统计
@@ -154,7 +157,7 @@ class PluginHelper(metaclass=Singleton):
                                            json={"plugins": [{"plugin_id": plugin} for plugin in plugins]})
         return True if res else False
 
-    def install(self, pid: str, repo_url: str, package_version: str = None, force_install: bool = False) \
+    def install(self, pid: str, repo_url: str, package_version: Optional[str] = None, force_install: bool = False) \
             -> Tuple[bool, str]:
         """
         安装插件，包括依赖安装和文件下载，相关资源支持自动降级策略
@@ -257,7 +260,7 @@ class PluginHelper(metaclass=Singleton):
         self.install_reg(pid)
         return True, ""
 
-    def __get_file_list(self, pid: str, user_repo: str, package_version: str = None) -> \
+    def __get_file_list(self, pid: str, user_repo: str, package_version: Optional[str] = None) -> \
             Tuple[Optional[list], Optional[str]]:
         """
         获取插件的文件列表
@@ -292,7 +295,7 @@ class PluginHelper(metaclass=Singleton):
             return None, "插件数据解析失败"
 
     def __download_files(self, pid: str, file_list: List[dict], user_repo: str,
-                         package_version: str = None, skip_requirements: bool = False) -> Tuple[bool, str]:
+                         package_version: Optional[str] = None, skip_requirements: bool = False) -> Tuple[bool, str]:
         """
         下载插件文件
         :param pid: 插件 ID
@@ -445,58 +448,6 @@ class PluginHelper(metaclass=Singleton):
         if plugin_dir.exists():
             shutil.rmtree(plugin_dir, ignore_errors=True)
 
-    @staticmethod
-    def __pip_uninstall_and_install_with_fallback(requirements_file: Path) -> Tuple[bool, str]:
-        """
-        先卸载 requirements.txt 中的依赖，再按照自动降级策略重新安装，不使用 PIP 缓存
-
-        :param requirements_file: 依赖的 requirements.txt 文件路径
-        :return: (是否成功, 错误信息)
-        """
-        # 读取 requirements.txt 文件中的依赖列表
-        try:
-            with open(requirements_file, "r", encoding="utf-8") as f:
-                dependencies = [line.strip() for line in f if line.strip() and not line.startswith("#")]
-        except Exception as e:
-            return False, f"无法读取 requirements.txt 文件：{str(e)}"
-
-        # 1. 先卸载所有依赖包
-        for dep in dependencies:
-            pip_uninstall_command = ["pip", "uninstall", "-y", dep]
-            logger.debug(f"尝试卸载依赖：{dep}，命令：{' '.join(pip_uninstall_command)}")
-            success, message = SystemUtils.execute_with_subprocess(pip_uninstall_command)
-            if success:
-                logger.debug(f"依赖 {dep} 卸载成功，输出：{message}")
-            else:
-                error_message = f"卸载依赖 {dep} 失败，错误信息：{message}"
-                logger.error(error_message)
-
-        # 2. 重新安装所有依赖，使用自动降级策略
-        strategies = []
-
-        # 添加策略到列表中
-        if settings.PIP_PROXY:
-            strategies.append(("镜像站",
-                               ["pip", "install", "-r", str(requirements_file),
-                                "-i", settings.PIP_PROXY, "--no-cache-dir"]))
-        if settings.PROXY_HOST:
-            strategies.append(("代理",
-                               ["pip", "install", "-r", str(requirements_file),
-                                "--proxy", settings.PROXY_HOST, "--no-cache-dir"]))
-        strategies.append(("直连", ["pip", "install", "-r", str(requirements_file), "--no-cache-dir"]))
-
-        # 遍历策略进行安装
-        for strategy_name, pip_command in strategies:
-            logger.debug(f"[PIP] 尝试使用策略：{strategy_name} 安装依赖，命令：{' '.join(pip_command)}")
-            success, message = SystemUtils.execute_with_subprocess(pip_command)
-            if success:
-                logger.debug(f"[PIP] 策略：{strategy_name} 安装依赖成功，输出：{message}")
-                return True, message
-            else:
-                logger.error(f"[PIP] 策略：{strategy_name} 安装依赖失败，错误信息：{message}")
-
-        return False, "[PIP] 所有策略均安装依赖失败，请检查网络连接或 PIP 配置"
-
     @staticmethod
     def __pip_install_with_fallback(requirements_file: Path) -> Tuple[bool, str]:
         """
@@ -529,7 +480,7 @@ class PluginHelper(metaclass=Singleton):
     @staticmethod
     def __request_with_fallback(url: str,
                                 headers: Optional[dict] = None,
-                                timeout: int = 60,
+                                timeout: Optional[int] = 60,
                                 is_api: bool = False) -> Optional[Any]:
         """
         使用自动降级策略，请求资源，优先级依次为镜像站、代理、直连