更新 version.py

- 修复媒体服务器库存检索问题
- 继续优化搜索页面

.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.lite

@@ -0,0 +1,93 @@
+FROM python:3.11.4-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 \
+    && 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 \
+        /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.11`、`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, cache_local=False)
+            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,45 +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("/subjects", summary="搜索Bangumi", response_model=List[schemas.MediaInfo])
-def bangumi_subjects(type: int = 2,
-                     cat: int = None,
-                     sort: str = 'rank',
-                     year: int = None,
-                     page: int = 1,
-                     count: int = 30,
-                     _: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    搜索Bangumi
-    """
-    return RecommendChain().bangumi_discover(type=type, cat=cat, sort=sort, year=year,
-                                             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演职员表
@@ -52,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推荐
@@ -75,8 +49,8 @@ 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,
-                           count: int = 20,
+                           page: Optional[int] = 1,
+                           count: Optional[int] = 20,
                            _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     根据人物ID查询人物参演作品

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,90 @@ def category(_: schemas.TokenPayload = Depends(verify_token)) -> Any:
     return MediaChain().media_category() or {}
 
 
+@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 chain.recommend import RecommendChain
+from 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)
             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)
     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)
             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)
     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)
             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)
             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)
+                elif event_data.convert_type == "douban":
+                    torrents = SearchChain().search_by_id(doubanid=search_id,
+                                                          mtype=media_type, area=area, season=media_season)
+        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)
+                else:
+                    torrents = SearchChain().search_by_id(doubanid=mediainfo.douban_id,
+                                                          mtype=media_type, area=area, season=media_season)
+    # 返回搜索结果
     if not torrents:
         return schemas.Response(success=False, message="未搜索到任何资源")
     else:
@@ -88,14 +146,15 @@ 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)
     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
@@ -44,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）
     """
@@ -82,6 +82,7 @@ def create_subscribe(
                                         season=subscribe_in.season,
                                         doubanid=subscribe_in.doubanid,
                                         bangumiid=subscribe_in.bangumiid,
+                                        mediaid=subscribe_in.mediaid,
                                         username=current_user.name,
                                         best_version=subscribe_in.best_version,
                                         save_path=subscribe_in.save_path,
@@ -164,14 +165,13 @@ def update_subscribe_status(
 @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:]
@@ -192,6 +192,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)
@@ -290,7 +294,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:
@@ -311,6 +315,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)
         # 发送事件
@@ -323,7 +331,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网络勾子通知订阅
     """
@@ -377,8 +385,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:
     """
@@ -403,9 +411,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:
     """
     查询热门订阅
@@ -524,7 +532,7 @@ def followed_subscribers(_: schemas.TokenPayload = Depends(verify_token)) -> Any
 
 @router.post("/follow", summary="Follow订阅分享人", response_model=schemas.Response)
 def follow_subscriber(
-        share_uid: str = None,
+        share_uid: Optional[str] = None,
         _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     Follow订阅分享人
@@ -538,7 +546,7 @@ def follow_subscriber(
 
 @router.delete("/follow", summary="取消Follow订阅分享人", response_model=schemas.Response)
 def unfollow_subscriber(
-        share_uid: str = None,
+        share_uid: Optional[str] = None,
         _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     取消Follow订阅分享人
@@ -552,9 +560,9 @@ def unfollow_subscriber(
 
 @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,7 +24,7 @@ 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
@@ -50,7 +51,6 @@ def fetch_image(
     """
     处理图片缓存逻辑，支持HTTP缓存和磁盘缓存
     """
-
     if not url:
         raise HTTPException(status_code=404, detail="URL not provided")
 
@@ -68,6 +68,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 +92,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 +141,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 +158,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:
     """
@@ -283,7 +288,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 +310,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 +382,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 +480,7 @@ def reload_module(_: User = Depends(get_current_active_superuser)):
     """
     重新加载模块（仅管理员）
     """
+    MessageQueueManager().init_config()
     ModuleManager().reload()
     Scheduler().init()
     Monitor().init()
@@ -494,7 +501,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,65 +113,6 @@ 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 = "",
-                with_keywords: str = "",
-                with_watch_providers: str = "",
-                vote_average: float = 0,
-                vote_count: int = 0,
-                release_date: 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,
-                                        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("/tvs", summary="TMDB剧集", response_model=List[schemas.MediaInfo])
-def tmdb_tvs(sort_by: str = "popularity.desc",
-             with_genres: str = "",
-             with_original_language: str = "",
-             with_keywords: str = "",
-             with_watch_providers: str = "",
-             vote_average: float = 0,
-             vote_count: int = 0,
-             release_date: 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,
-                                     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("/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,
                          _: schemas.TokenPayload = Depends(verify_token)) -> Any:

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:
     """
@@ -165,7 +165,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剧集订阅
     """
@@ -689,7 +689,7 @@ def arr_update_series(tv: schemas.SonarrSeries) -> Any:
 
 
 @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,10 @@ 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,
                         cache: bool = True) -> Optional[MediaInfo]:
         """
         识别媒体信息，不含Fanart图片
@@ -173,8 +175,8 @@ class ChainBase(metaclass=ABCMeta):
         return self.run_module("recognize_media", meta=meta, mtype=mtype,
                                tmdbid=tmdbid, doubanid=doubanid, bangumiid=bangumiid, 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 +190,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 +211,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 +226,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 +245,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 +310,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 +325,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 +351,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 +361,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 +382,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 +395,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 +423,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 +432,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 +442,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 +451,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 +461,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 +470,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 +495,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())
@@ -542,13 +544,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:
         """
@@ -560,7 +562,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:
         """
@@ -572,9 +574,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/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,13 @@ 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,
+                        media_category: Optional[str] = None,
+                        label: Optional[str] = None) -> Optional[str]:
         """
         下载及发送通知
         :param context: 资源上下文
@@ -222,6 +223,7 @@ class DownloadChain(ChainBase):
         :param userid: 用户ID
         :param username: 调用下载的用户名/插件名
         :param media_category: 自定义媒体类别
+        :param label: 自定义标签
         """
         # 发送资源下载事件，允许外部拦截下载
         event_data = ResourceDownloadEventData(
@@ -310,6 +312,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
@@ -415,13 +418,13 @@ 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,
+                       media_category: Optional[str] = None,
+                       downloader: Optional[str] = None
                        ) -> Tuple[List[Context], Dict[Union[int, str], Dict[int, NotExistMediaInfo]]]:
         """
         根据缺失数据，自动种子列表中组合择优下载
@@ -930,7 +933,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 +967,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: 元数据
@@ -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()

app/chain/mediaserver.py

@@ -1,5 +1,5 @@
 import threading
-from typing import List, Union, Optional, Generator
+from typing import List, Union, Optional, Generator, Any
 
 from app.chain import ChainBase
 from app.core.cache import cached
@@ -21,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]:
         """
         获取媒体服务器项目列表，支持分页和不分页逻辑，默认不分页获取所有数据
 
@@ -81,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(maxsize=1, ttl=3600)
-    def get_latest_wallpapers(self, server: str = None, count: int = 10,
-                              remote: bool = True, username: str = None) -> List[str]:
+    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/recommend.py

@@ -1,8 +1,9 @@
 import io
 import tempfile
 from pathlib import Path
-from typing import Any, List
+from typing import List, Optional
 
+import pillow_avif  # noqa 用于自动注册AVIF支持
 from PIL import Image
 
 from app.chain import ChainBase
@@ -116,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}")
@@ -157,15 +162,15 @@ class RecommendChain(ChainBase, metaclass=Singleton):
 
     @log_execution_time(logger=logger)
     @cached(ttl=recommend_ttl, region=recommend_cache_region)
-    def tmdb_movies(self, sort_by: str = "popularity.desc",
-                    with_genres: str = "",
-                    with_original_language: str = "",
-                    with_keywords: str = "",
-                    with_watch_providers: str = "",
-                    vote_average: float = 0,
-                    vote_count: int = 0,
-                    release_date: str = "",
-                    page: int = 1) -> List[dict]:
+    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热门电影
         """
@@ -183,15 +188,15 @@ class RecommendChain(ChainBase, metaclass=Singleton):
 
     @log_execution_time(logger=logger)
     @cached(ttl=recommend_ttl, region=recommend_cache_region)
-    def tmdb_tvs(self, sort_by: str = "popularity.desc",
-                 with_genres: str = "",
-                 with_original_language: str = "zh|en|ja|ko",
-                 with_keywords: str = "",
-                 with_watch_providers: str = "",
-                 vote_average: float = 0,
-                 vote_count: int = 0,
-                 release_date: str = "",
-                 page: int = 1) -> List[dict]:
+    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热门电视剧
         """
@@ -209,7 +214,7 @@ class RecommendChain(ChainBase, metaclass=Singleton):
 
     @log_execution_time(logger=logger)
     @cached(ttl=recommend_ttl, region=recommend_cache_region)
-    def tmdb_trending(self, page: int = 1) -> List[dict]:
+    def tmdb_trending(self, page: Optional[int] = 1) -> List[dict]:
         """
         TMDB流行趋势
         """
@@ -218,7 +223,7 @@ class RecommendChain(ChainBase, metaclass=Singleton):
 
     @log_execution_time(logger=logger)
     @cached(ttl=recommend_ttl, region=recommend_cache_region)
-    def bangumi_calendar(self, page: int = 1, count: int = 30) -> List[dict]:
+    def bangumi_calendar(self, page: Optional[int] = 1, count: Optional[int] = 30) -> List[dict]:
         """
         Bangumi每日放送
         """
@@ -227,24 +232,7 @@ class RecommendChain(ChainBase, metaclass=Singleton):
 
     @log_execution_time(logger=logger)
     @cached(ttl=recommend_ttl, region=recommend_cache_region)
-    def bangumi_discover(self, type: int = 2,
-                         cat: int = None,
-                         sort: str = 'rank',
-                         year: int = None,
-                         count: int = 30,
-                         page: int = 1) -> List[dict]:
-        """
-        搜索Bangumi
-        """
-        medias = self.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 []
-
-    @log_execution_time(logger=logger)
-    @cached(ttl=recommend_ttl, region=recommend_cache_region)
-    def douban_movie_showing(self, page: int = 1, count: int = 30) -> List[dict]:
+    def douban_movie_showing(self, page: Optional[int] = 1, count: Optional[int] = 30) -> List[dict]:
         """
         豆瓣正在热映
         """
@@ -253,7 +241,8 @@ class RecommendChain(ChainBase, metaclass=Singleton):
 
     @log_execution_time(logger=logger)
     @cached(ttl=recommend_ttl, region=recommend_cache_region)
-    def douban_movies(self, sort: str = "R", tags: str = "", page: int = 1, count: int = 30) -> List[dict]:
+    def douban_movies(self, sort: Optional[str] = "R", tags: Optional[str] = "",
+                      page: Optional[int] = 1, count: Optional[int] = 30) -> List[dict]:
         """
         豆瓣最新电影
         """
@@ -263,7 +252,8 @@ class RecommendChain(ChainBase, metaclass=Singleton):
 
     @log_execution_time(logger=logger)
     @cached(ttl=recommend_ttl, region=recommend_cache_region)
-    def douban_tvs(self, sort: str = "R", tags: str = "", page: int = 1, count: int = 30) -> List[dict]:
+    def douban_tvs(self, sort: Optional[str] = "R", tags: Optional[str] = "",
+                   page: Optional[int] = 1, count: Optional[int] = 30) -> List[dict]:
         """
         豆瓣最新电视剧
         """
@@ -273,7 +263,7 @@ class RecommendChain(ChainBase, metaclass=Singleton):
 
     @log_execution_time(logger=logger)
     @cached(ttl=recommend_ttl, region=recommend_cache_region)
-    def douban_movie_top250(self, page: int = 1, count: int = 30) -> List[dict]:
+    def douban_movie_top250(self, page: Optional[int] = 1, count: Optional[int] = 30) -> List[dict]:
         """
         豆瓣电影TOP250
         """
@@ -282,7 +272,7 @@ class RecommendChain(ChainBase, metaclass=Singleton):
 
     @log_execution_time(logger=logger)
     @cached(ttl=recommend_ttl, region=recommend_cache_region)
-    def douban_tv_weekly_chinese(self, page: int = 1, count: int = 30) -> List[dict]:
+    def douban_tv_weekly_chinese(self, page: Optional[int] = 1, count: Optional[int] = 30) -> List[dict]:
         """
         豆瓣国产剧集榜
         """
@@ -291,7 +281,7 @@ class RecommendChain(ChainBase, metaclass=Singleton):
 
     @log_execution_time(logger=logger)
     @cached(ttl=recommend_ttl, region=recommend_cache_region)
-    def douban_tv_weekly_global(self, page: int = 1, count: int = 30) -> List[dict]:
+    def douban_tv_weekly_global(self, page: Optional[int] = 1, count: Optional[int] = 30) -> List[dict]:
         """
         豆瓣全球剧集榜
         """
@@ -300,7 +290,7 @@ class RecommendChain(ChainBase, metaclass=Singleton):
 
     @log_execution_time(logger=logger)
     @cached(ttl=recommend_ttl, region=recommend_cache_region)
-    def douban_tv_animation(self, page: int = 1, count: int = 30) -> List[dict]:
+    def douban_tv_animation(self, page: Optional[int] = 1, count: Optional[int] = 30) -> List[dict]:
         """
         豆瓣热门动漫
         """
@@ -309,7 +299,7 @@ class RecommendChain(ChainBase, metaclass=Singleton):
 
     @log_execution_time(logger=logger)
     @cached(ttl=recommend_ttl, region=recommend_cache_region)
-    def douban_movie_hot(self, page: int = 1, count: int = 30) -> List[dict]:
+    def douban_movie_hot(self, page: Optional[int] = 1, count: Optional[int] = 30) -> List[dict]:
         """
         豆瓣热门电影
         """
@@ -318,7 +308,7 @@ class RecommendChain(ChainBase, metaclass=Singleton):
 
     @log_execution_time(logger=logger)
     @cached(ttl=recommend_ttl, region=recommend_cache_region)
-    def douban_tv_hot(self, page: int = 1, count: int = 30) -> List[dict]:
+    def douban_tv_hot(self, page: Optional[int] = 1, count: Optional[int] = 30) -> List[dict]:
         """
         豆瓣热门电视剧
         """

app/chain/search.py

@@ -34,15 +34,17 @@ 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) -> 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列表
         """
         mediainfo = self.recognize_media(tmdbid=tmdbid, doubanid=doubanid, mtype=mtype)
         if not mediainfo:
@@ -55,25 +57,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)
         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] = True) -> 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 +85,9 @@ 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:
+            bytes_results = pickle.dumps(contexts)
+            self.save_cache(bytes_results, 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

@@ -6,7 +6,6 @@ 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 +52,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 +138,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 +159,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]:
@@ -182,9 +190,11 @@ class SiteChain(ChainBase):
             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:
+            state = False
+            message = "鉴权已过期或无效"
             user_info = res.json() or {}
             if user_info.get("data"):
                 # 更新最后访问时间
@@ -203,7 +213,9 @@ class SiteChain(ChainBase):
             elif user_info.get("message"):
                 # 使用馒头的错误提示
                 message = user_info.get("message")
-        return state, message
+            return state, message
+        else:
+            return False, f"错误：{res.status_code} {res.reason}"
 
     @staticmethod
     def __yema_test(site: Site) -> Tuple[bool, str]:
@@ -223,11 +235,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 +252,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 +599,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 +644,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 +669,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 +695,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 +724,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 +794,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

@@ -28,7 +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.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
 
 
@@ -55,21 +56,44 @@ 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,
+            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:
@@ -82,27 +106,41 @@ 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信息，不使用缓存
+                # 使用TMDBID识别
                 mediainfo = self.recognize_media(meta=metainfo, mtype=mtype, tmdbid=tmdbid, 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)
+
         # 识别失败
         if not mediainfo:
             logger.warn(f'未识别到媒体信息，标题：{title}，tmdbid：{tmdbid}，doubanid：{doubanid}')
             return None, "未识别到媒体信息"
+
         # 总集数
         if mediainfo.type == MediaType.TV:
             if not season:
@@ -137,6 +175,7 @@ class SubscribeChain(ChainBase, metaclass=Singleton):
         else:
             # 避免season为0的问题
             season = None
+
         # 更新媒体图片
         self.obtain_images(mediainfo=mediainfo)
         # 合并信息
@@ -144,6 +183,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(
@@ -235,7 +275,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，有值时只处理该订阅
@@ -290,7 +330,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:
@@ -386,7 +427,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]]):
         """
         更新订阅已下载资源的优先级
         """
@@ -411,7 +452,7 @@ 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, schemas.NotExistMediaInfo]] = None,
-                                force: bool = False):
+                                force: Optional[bool] = False):
         """
         判断是否应完成订阅
         """
@@ -844,7 +885,7 @@ class SubscribeChain(ChainBase, metaclass=Singleton):
                     logger.error(f'follow用户分享订阅 {title} 添加失败：{message}')
         logger.info(f'follow用户分享订阅刷新完成，共添加 {success_count} 个订阅')
 
-    def __update_subscribe_note(self, subscribe: Subscribe, downloads: List[Context]):
+    def __update_subscribe_note(self, subscribe: Subscribe, downloads: Optional[List[Context]]):
         """
         更新已下载信息到note字段
         """
@@ -903,7 +944,7 @@ class SubscribeChain(ChainBase, metaclass=Singleton):
     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):
         """
         更新订阅剩余集数及时间
         """
@@ -973,7 +1014,7 @@ 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):
         """
         查询订阅并发送消息
         """
@@ -1001,7 +1042,7 @@ class SubscribeChain(ChainBase, metaclass=Singleton):
                                                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):
         """
         删除订阅
         """
@@ -1036,8 +1077,8 @@ class SubscribeChain(ChainBase, metaclass=Singleton):
                                  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, schemas.NotExistMediaInfo]]]:
         """
@@ -1222,7 +1263,7 @@ class SubscribeChain(ChainBase, metaclass=Singleton):
         订阅相关的下载和文件信息
         """
         if not subscribe:
-            return
+            return None
 
         # 返回订阅数据
         subscribe_info = schemas.SubscrbieInfo()
@@ -1328,7 +1369,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. 查询缺失的媒体信息

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

@@ -23,7 +23,7 @@ class TmdbChain(ChainBase, metaclass=Singleton):
                       vote_average: float,
                       vote_count: int,
                       release_date: str,
-                      page: int = 1) -> Optional[List[MediaInfo]]:
+                      page: Optional[int] = 1) -> Optional[List[MediaInfo]]:
         """
         :param mtype:  媒体类型
         :param sort_by:  排序方式
@@ -48,7 +48,7 @@ class TmdbChain(ChainBase, metaclass=Singleton):
                                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: 第几页
@@ -106,7 +106,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
@@ -114,7 +114,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
@@ -129,7 +129,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
@@ -152,7 +152,7 @@ class TmdbChain(ChainBase, metaclass=Singleton):
         return None
 
     @cached(maxsize=1, ttl=3600)
-    def get_trending_wallpapers(self, num: int = 10) -> List[str]:
+    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:
         """
         获取某项任务总大小
         """
@@ -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]:
         """
         获取季集清单
         """
@@ -606,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]]:
         """
         处理整理任务
         """
@@ -670,13 +670,18 @@ class TransferChain(ChainBase, metaclass=Singleton):
                 self.jobview.add_task(task, state=curr_task.state if curr_task else "waiting")
 
             # 获取集数据
-            if not task.episodes_info and task.mediainfo.type == MediaType.TV:
-                if task.meta.begin_season is None:
-                    task.meta.begin_season = 1
-                task.mediainfo.season = task.mediainfo.season or task.meta.begin_season
+            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=task.mediainfo.season
+                    season=season_num
                 )
 
             # 查询整理目标目录
@@ -902,13 +907,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: 文件项
@@ -929,6 +934,7 @@ class TransferChain(ChainBase, metaclass=Singleton):
         :param force: 是否强制整理
         :param background: 是否后台运行
         :param manual: 是否手动整理
+        :param continue_callback: 继续处理回调
         返回：成功标识，错误信息
         """
 
@@ -994,6 +1000,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 \
@@ -1114,6 +1122,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)
@@ -1143,7 +1153,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|类型
         """
@@ -1185,7 +1195,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
@@ -1236,20 +1246,20 @@ 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,
+                        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: 文件项
@@ -1324,7 +1334,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

@@ -273,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):
         """
         运行定时服务
         """
@@ -339,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:
         """
         注册单个命令
         """
@@ -352,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

@@ -1,6 +1,7 @@
 import inspect
 import json
 import pickle
+import threading
 from abc import ABC, abstractmethod
 from functools import wraps
 from typing import Any, Dict, Optional
@@ -16,6 +17,8 @@ from app.log import logger
 # 默认缓存区
 DEFAULT_CACHE_REGION = "DEFAULT"
 
+lock = threading.Lock()
+
 
 class CacheBackend(ABC):
     """
@@ -23,7 +26,7 @@ class CacheBackend(ABC):
     """
 
     @abstractmethod
-    def set(self, key: str, value: Any, ttl: int, region: str = DEFAULT_CACHE_REGION, **kwargs) -> None:
+    def set(self, key: str, value: Any, ttl: int, region: Optional[str] = DEFAULT_CACHE_REGION, **kwargs) -> None:
         """
         设置缓存
 
@@ -36,7 +39,7 @@ class CacheBackend(ABC):
         pass
 
     @abstractmethod
-    def exists(self, key: str, region: str = DEFAULT_CACHE_REGION) -> bool:
+    def exists(self, key: str, region: Optional[str] = DEFAULT_CACHE_REGION) -> bool:
         """
         判断缓存键是否存在
 
@@ -47,7 +50,7 @@ class CacheBackend(ABC):
         pass
 
     @abstractmethod
-    def get(self, key: str, region: str = DEFAULT_CACHE_REGION) -> Any:
+    def get(self, key: str, region: Optional[str] = DEFAULT_CACHE_REGION) -> Any:
         """
         获取缓存
 
@@ -58,7 +61,7 @@ class CacheBackend(ABC):
         pass
 
     @abstractmethod
-    def delete(self, key: str, region: str = DEFAULT_CACHE_REGION) -> None:
+    def delete(self, key: str, region: Optional[str] = DEFAULT_CACHE_REGION) -> None:
         """
         删除缓存
 
@@ -84,7 +87,7 @@ class CacheBackend(ABC):
         pass
 
     @staticmethod
-    def get_region(region: str = DEFAULT_CACHE_REGION):
+    def get_region(region: Optional[str] = DEFAULT_CACHE_REGION):
         """
         获取缓存的区
         """
@@ -128,7 +131,7 @@ class CacheToolsBackend(CacheBackend):
     - 不支持按 `key` 独立隔离 TTL 和 Maxsize，仅支持作用于 region 级别
     """
 
-    def __init__(self, maxsize: int = 1000, ttl: int = 1800):
+    def __init__(self, maxsize: Optional[int] = 1000, ttl: Optional[int] = 1800):
         """
         初始化缓存实例
 
@@ -147,7 +150,8 @@ class CacheToolsBackend(CacheBackend):
         region = self.get_region(region)
         return self._region_caches.get(region)
 
-    def set(self, key: str, value: Any, ttl: int = None, region: str = DEFAULT_CACHE_REGION, **kwargs) -> None:
+    def set(self, key: str, value: Any, ttl: Optional[int] = None, 
+            region: Optional[str] = DEFAULT_CACHE_REGION, **kwargs) -> None:
         """
         设置缓存值支持每个 key 独立配置 TTL 和 Maxsize
 
@@ -163,9 +167,10 @@ class CacheToolsBackend(CacheBackend):
         # 如果该 key 尚未有缓存实例，则创建一个新的 TTLCache 实例
         region_cache = self._region_caches.setdefault(region, TTLCache(maxsize=maxsize, ttl=ttl))
         # 设置缓存值
-        region_cache[key] = value
+        with lock:
+            region_cache[key] = value
 
-    def exists(self, key: str, region: str = DEFAULT_CACHE_REGION) -> bool:
+    def exists(self, key: str, region: Optional[str] = DEFAULT_CACHE_REGION) -> bool:
         """
         判断缓存键是否存在
 
@@ -178,7 +183,7 @@ class CacheToolsBackend(CacheBackend):
             return False
         return key in region_cache
 
-    def get(self, key: str, region: str = DEFAULT_CACHE_REGION) -> Any:
+    def get(self, key: str, region: Optional[str] = DEFAULT_CACHE_REGION) -> Any:
         """
         获取缓存的值
 
@@ -191,7 +196,7 @@ class CacheToolsBackend(CacheBackend):
             return None
         return region_cache.get(key)
 
-    def delete(self, key: str, region: str = DEFAULT_CACHE_REGION) -> None:
+    def delete(self, key: str, region: Optional[str] = DEFAULT_CACHE_REGION) -> None:
         """
         删除缓存
 
@@ -201,7 +206,8 @@ class CacheToolsBackend(CacheBackend):
         region_cache = self.__get_region_cache(region)
         if region_cache is None:
             return None
-        del region_cache[key]
+        with lock:
+            del region_cache[key]
 
     def clear(self, region: Optional[str] = None) -> None:
         """
@@ -213,12 +219,14 @@ class CacheToolsBackend(CacheBackend):
             # 清理指定缓存区
             region_cache = self.__get_region_cache(region)
             if region_cache:
-                region_cache.clear()
+                with lock:
+                    region_cache.clear()
                 logger.info(f"Cleared cache for region: {region}")
         else:
             # 清除所有区域的缓存
             for region_cache in self._region_caches.values():
-                region_cache.clear()
+                with lock:
+                    region_cache.clear()
             logger.info("Cleared all cache")
 
     def close(self) -> None:
@@ -246,7 +254,7 @@ class RedisBackend(CacheBackend):
     _complex_serializable_types = set()
     _simple_serializable_types = set()
 
-    def __init__(self, redis_url: str = "redis://localhost", ttl: int = 1800):
+    def __init__(self, redis_url: Optional[str] = "redis://localhost", ttl: Optional[int] = 1800):
         """
         初始化 Redis 缓存实例
 
@@ -271,7 +279,7 @@ class RedisBackend(CacheBackend):
             logger.error(f"Failed to connect to Redis: {e}")
             raise RuntimeError("Redis connection failed") from e
 
-    def set_memory_limit(self, policy: str = "allkeys-lru"):
+    def set_memory_limit(self, policy: Optional[str] = "allkeys-lru"):
         """
         动态设置 Redis 最大内存和内存淘汰策略
         :param policy: 淘汰策略（如 'allkeys-lru'）
@@ -349,7 +357,8 @@ class RedisBackend(CacheBackend):
         region = self.get_region(quote(region))
         return f"{region}:key:{quote(key)}"
 
-    def set(self, key: str, value: Any, ttl: int = None, region: str = DEFAULT_CACHE_REGION, **kwargs) -> None:
+    def set(self, key: str, value: Any, ttl: Optional[int] = None, 
+            region: Optional[str] = DEFAULT_CACHE_REGION, **kwargs) -> None:
         """
         设置缓存
 
@@ -369,7 +378,7 @@ class RedisBackend(CacheBackend):
         except Exception as e:
             logger.error(f"Failed to set key: {key} in region: {region}, error: {e}")
 
-    def exists(self, key: str, region: str = DEFAULT_CACHE_REGION) -> bool:
+    def exists(self, key: str, region: Optional[str] = DEFAULT_CACHE_REGION) -> bool:
         """
         判断缓存键是否存在
 
@@ -384,7 +393,7 @@ class RedisBackend(CacheBackend):
             logger.error(f"Failed to exists key: {key} region: {region}, error: {e}")
             return False
 
-    def get(self, key: str, region: str = DEFAULT_CACHE_REGION) -> Optional[Any]:
+    def get(self, key: str, region: Optional[str] = DEFAULT_CACHE_REGION) -> Optional[Any]:
         """
         获取缓存的值
 
@@ -402,7 +411,7 @@ class RedisBackend(CacheBackend):
             logger.error(f"Failed to get key: {key} in region: {region}, error: {e}")
             return None
 
-    def delete(self, key: str, region: str = DEFAULT_CACHE_REGION) -> None:
+    def delete(self, key: str, region: Optional[str] = DEFAULT_CACHE_REGION) -> None:
         """
         删除缓存
 
@@ -445,7 +454,7 @@ class RedisBackend(CacheBackend):
             self.client.close()
 
 
-def get_cache_backend(maxsize: int = 1000, ttl: int = 1800) -> CacheBackend:
+def get_cache_backend(maxsize: Optional[int] = 1000, ttl: Optional[int] = 1800) -> CacheBackend:
     """
     根据配置获取缓存后端实例
 
@@ -473,8 +482,8 @@ def get_cache_backend(maxsize: int = 1000, ttl: int = 1800) -> CacheBackend:
     return CacheToolsBackend(maxsize=maxsize, ttl=ttl)
 
 
-def cached(region: Optional[str] = None, maxsize: int = 1000, ttl: int = 1800,
-           skip_none: bool = True, skip_empty: bool = False):
+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
 
@@ -500,6 +509,21 @@ def cached(region: Optional[str] = None, maxsize: int = 1000, ttl: int = 1800,
             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):
 
         # 获取缓存区
@@ -511,7 +535,7 @@ def cached(region: Optional[str] = None, maxsize: int = 1000, ttl: int = 1800,
             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):
+            if should_cache(cached_value) and is_valid_cache_value(cache_key, cached_value, cache_region):
                 return cached_value
             # 执行函数并缓存结果
             result = func(*args, **kwargs)

app/core/config.py

@@ -109,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
@@ -118,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,"
@@ -236,11 +240,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(
@@ -248,6 +259,8 @@ class ConfigModel(BaseModel):
     )
     # 启用分词搜索
     TOKENIZED_SEARCH: bool = False
+    # 为指定默认字幕添加.default后缀
+    DEFAULT_SUB: Optional[str] = "zh-cn"
 
 
 class Settings(BaseSettings, ConfigModel, LogConfigModel):
@@ -354,7 +367,7 @@ 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
@@ -598,6 +611,8 @@ class GlobalVar(object):
     STOP_EVENT: threading.Event = threading.Event()
     # webpush订阅
     SUBSCRIPTIONS: List[dict] = []
+    # 需应急停止的工作流
+    EMERGENCY_STOP_WORKFLOWS: List[int] = []
 
     def stop_system(self):
         """
@@ -624,6 +639,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
@@ -714,7 +714,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):
         """
         返回消息图片地址
         """
@@ -722,7 +722,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):
         """
         返回海报图片地址
         """
@@ -730,7 +730,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: 内容长度

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/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

@@ -70,7 +70,7 @@ class ReleaseGroupsMatcher(metaclass=Singleton):
         "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 )'],
+                   'N(?:oGroup|T(?:b|G))', 'PandaMoon', 'SMURF', 'T(?:EPES|aengoo|rollHD )', 'UBWEB'],
         "anime": ['ANi', 'HYSUB', 'KTXP', 'LoliHouse', 'MCE', 'Nekomoe kissaten', 'SweetSub', 'MingY',
                   '(?:Lilith|NC)-Raws', '织梦字幕组', '枫叶字幕组', '猎户手抄部', '喵萌奶茶屋', '漫猫字幕社',
                   '霜庭云花Sub', '北宇治字幕组', '氢气烤肉架', '云歌字幕组', '萌樱字幕组', '极影字幕社',

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
@@ -67,7 +68,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 +79,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 +125,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 +140,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 +189,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)
     # 海报
@@ -85,7 +87,7 @@ class Subscribe(Base):
 
     @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 +111,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 +127,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 +137,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 +156,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)
     # 海报
@@ -69,7 +72,7 @@ class SubscribeHistory(Base):
 
     @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(
@@ -79,7 +82,7 @@ class SubscribeHistory(Base):
 
     @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(SubscribeHistory).filter(SubscribeHistory.tmdbid == tmdbid,

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
@@ -58,7 +59,7 @@ class TransferHistory(Base):
 
     @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 +78,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 +98,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 +118,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 +151,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 +219,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 +228,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
@@ -45,7 +45,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 +64,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 +87,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:
         """
         获取指定类型的订阅
         """
@@ -119,7 +119,7 @@ class SubscribeOper(DbOper):
         subscribe = SubscribeHistory(**kwargs)
         subscribe.create(self._db)
 
-    def exist_history(self, tmdbid: int = None, doubanid: str = None, season: int = None):
+    def exist_history(self, tmdbid: Optional[int] = None, doubanid: Optional[str] = None, season: Optional[int] = None):
         """
         判断是否存在订阅历史
         """

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):
         """
         新增转移失败历史记录
         """

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: 格式化详情

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: 父包名

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

@@ -39,7 +39,7 @@ class PluginHelper(metaclass=Singleton):
                     self.systemconfig.set(SystemConfigKey.PluginInstallReport, "1")
 
     @cached(maxsize=1000, ttl=1800)
-    def get_plugins(self, repo_url: str, package_version: str = None) -> Optional[Dict[str, dict]]:
+    def get_plugins(self, repo_url: str, package_version: Optional[str] = None) -> Optional[Dict[str, dict]]:
         """
         获取Github所有最新插件列表
         :param repo_url: Github仓库地址
@@ -63,9 +63,10 @@ class PluginHelper(metaclass=Singleton):
                 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 设置）
@@ -156,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]:
         """
         安装插件，包括依赖安装和文件下载，相关资源支持自动降级策略
@@ -259,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]]:
         """
         获取插件的文件列表
@@ -294,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
@@ -447,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]:
         """
@@ -531,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]:
         """
         使用自动降级策略，请求资源，优先级依次为镜像站、代理、直连

app/helper/progress.py

@@ -1,5 +1,5 @@
 from enum import Enum
-from typing import Union, Dict
+from typing import Union, Dict, Optional
 
 from app.schemas.types import ProgressKey
 from app.utils.singleton import Singleton
@@ -40,7 +40,7 @@ class ProgressHelper(metaclass=Singleton):
             "text": "正在处理..."
         }
 
-    def update(self, key: Union[ProgressKey, str], value: float = None, text: str = None):
+    def update(self, key: Union[ProgressKey, str], value: Union[float, int] = None, text: Optional[str] = None):
         if isinstance(key, Enum):
             key = key.value
         if not self._process_detail.get(key, {}).get('enable'):

app/helper/rss.py

@@ -1,7 +1,7 @@
 import re
 import traceback
 import xml.dom.minidom
-from typing import List, Tuple, Union
+from typing import List, Tuple, Union, Optional
 from urllib.parse import urljoin
 
 import chardet
@@ -225,27 +225,27 @@ class RssHelper:
     }
 
     @staticmethod
-    def parse(url, proxy: bool = False, timeout: int = 15, headers: dict = None) -> Union[List[dict], None]:
+    def parse(url, proxy: bool = False, timeout: Optional[int] = 15, headers: dict = None) -> Union[List[dict], None, bool]:
         """
         解析RSS订阅URL，获取RSS中的种子信息
         :param url: RSS地址
         :param proxy: 是否使用代理
         :param timeout: 请求超时
         :param headers: 自定义请求头
-        :return: 种子信息列表，如为None代表Rss过期
+        :return: 种子信息列表，如为None代表Rss过期，如果为False则为错误
         """
         # 开始处理
         ret_array: list = []
         if not url:
-            return []
+            return False
         try:
             ret = RequestUtils(proxies=settings.PROXY if proxy else None,
                                timeout=timeout, headers=headers).get_res(url)
             if not ret:
-                return []
+                return False
         except Exception as err:
             logger.error(f"获取RSS失败：{str(err)} - {traceback.format_exc()}")
-            return []
+            return False
         if ret:
             ret_xml = ""
             try:
@@ -301,6 +301,8 @@ class RssHelper:
                         if pubdate:
                             # 转换为时间
                             pubdate = StringUtils.get_time(pubdate)
+                        # 获取豆瓣昵称
+                        nickname = DomUtils.tag_value(item, "dc:createor", default="")
                         # 返回对象
                         tmp_dict = {'title': title,
                                     'enclosure': enclosure,
@@ -308,6 +310,9 @@ class RssHelper:
                                     'description': description,
                                     'link': link,
                                     'pubdate': pubdate}
+                        # 如果豆瓣昵称不为空，返回数据增加豆瓣昵称，供doubansync插件获取
+                        if nickname:
+                            tmp_dict['nickname'] = nickname
                         ret_array.append(tmp_dict)
                     except Exception as e1:
                         logger.debug(f"解析RSS失败：{str(e1)} - {traceback.format_exc()}")
@@ -322,6 +327,7 @@ class RssHelper:
                 ]
                 if ret_xml in _rss_expired_msg:
                     return None
+                return False
         return ret_array
 
     def get_rss_link(self, url: str, cookie: str, ua: str, proxy: bool = False) -> Tuple[str, str]:

app/helper/rule.py

@@ -33,7 +33,7 @@ class RuleHelper:
                 return group
         return None
 
-    def get_rule_group_by_media(self, media: MediaInfo, group_names: list = None) -> List[FilterRuleGroup]:
+    def get_rule_group_by_media(self, media: MediaInfo = None, group_names: list = None) -> List[FilterRuleGroup]:
         """
         根据媒体信息获取规则组
         """
@@ -44,9 +44,9 @@ class RuleHelper:
         for group in rule_groups:
             if not group.media_type:
                 ret_groups.append(group)
-            elif not group.category and group.media_type == media.type.value:
+            elif media and not group.category and group.media_type == media.type.value:
                 ret_groups.append(group)
-            elif group.category == media.category:
+            elif media and group.category == media.category:
                 ret_groups.append(group)
         return ret_groups
 

app/helper/subscribe.py

@@ -1,5 +1,5 @@
 from threading import Thread
-from typing import List, Tuple
+from typing import List, Tuple, Optional
 
 from app.core.cache import cached, cache_backend
 from app.core.config import settings
@@ -41,7 +41,7 @@ class SubscribeHelper(metaclass=Singleton):
                     self.systemconfig.set(SystemConfigKey.SubscribeReport, "1")
 
     @cached(maxsize=20, ttl=1800)
-    def get_statistic(self, stype: str, page: int = 1, count: int = 30) -> List[dict]:
+    def get_statistic(self, stype: str, page: Optional[int] = 1, count: Optional[int] = 30) -> List[dict]:
         """
         获取订阅统计数据
         """
@@ -182,7 +182,7 @@ class SubscribeHelper(metaclass=Singleton):
             return False, res.json().get("message")
 
     @cached(region=_shares_cache_region)
-    def get_shares(self, name: str = None, page: int = 1, count: int = 30) -> List[dict]:
+    def get_shares(self, name: Optional[str] = None, page: Optional[int] = 1, count: Optional[int] = 30) -> List[dict]:
         """
         获取订阅分享数据
         """

app/helper/thread.py

@@ -1,4 +1,5 @@
 from concurrent.futures import ThreadPoolExecutor
+from typing import Optional
 
 from app.utils.singleton import Singleton
 
@@ -7,7 +8,7 @@ class ThreadHelper(metaclass=Singleton):
     """
     线程池管理
     """
-    def __init__(self, max_workers=50):
+    def __init__(self, max_workers: Optional[int] = 50):
         self.pool = ThreadPoolExecutor(max_workers=max_workers)
 
     def submit(self, func, *args, **kwargs):