fix #4902

- 通过在插件中嵌入轮子来支持安装依赖项

.dockerignore

@@ -1,3 +1,84 @@
-# Ignore git
+# Git
 .github
-.git
+.git
+.gitignore
+
+# Documentation
+docs/
+README.md
+LICENSE
+
+# Development files
+.pylintrc
+*.pyc
+__pycache__/
+*.pyo
+*.pyd
+.Python
+*.so
+.pytest_cache/
+.coverage
+htmlcov/
+.tox/
+.nox/
+.hypothesis/
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Virtual environments
+venv/
+env/
+ENV/
+env.bak/
+venv.bak/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+
+# Logs
+*.log
+logs/
+
+# Temporary files
+*.tmp
+*.temp
+tmp/
+temp/
+
+# Database
+*.db
+*.sqlite
+*.sqlite3
+
+# Test files
+tests/
+test_*
+*_test.py
+
+# Build artifacts
+build/
+dist/
+*.egg-info/
+
+# Docker
+Dockerfile*
+docker-compose*
+.dockerignore
+
+# Other
+app.ico
+frozen.spec

.github/workflows/beta.yml

@@ -0,0 +1,60 @@
+name: MoviePilot Builder Beta
+on:
+  workflow_dispatch:
+
+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
+            ghcr.io/${{ github.repository }}
+          tags: |
+            type=raw,value=beta
+
+      - 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: Login GitHub Container Registry
+        uses: docker/login-action@v3
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Build Image
+        uses: docker/build-push-action@v5
+        with:
+          context: .
+          file: docker/Dockerfile
+          platforms: |
+            linux/amd64
+            linux/arm64/v8
+          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

.github/workflows/build.yml

@@ -27,6 +27,7 @@ jobs:
         with:
           images: |
             ${{ secrets.DOCKER_USERNAME }}/moviepilot-v2
+            ${{ secrets.DOCKER_USERNAME }}/moviepilot
             ghcr.io/${{ github.repository }}
           tags: |
             type=raw,value=${{ env.app_version }}

app/actions/invoke_plugin.py

@@ -56,7 +56,7 @@ class InvokePluginAction(BaseAction):
                 logger.error(f"插件不存在: {params.plugin_id}")
                 return context
             actions = plugin_actions[0].get("actions", [])
-            action = next((action for action in actions if action.action_id == params.action_id), None)
+            action = next((action for action in actions if action.get("action_id") == params.action_id), None)
             if not action or not action.get("func"):
                 logger.error(f"插件动作不存在: {params.plugin_id} - {params.action_id}")
                 return context

app/api/apiv1.py

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

app/api/endpoints/dashboard.py

@@ -123,7 +123,7 @@ async def schedule2(_: Annotated[str, Depends(verify_apitoken)]) -> Any:
     """
     查询下载器信息 API_TOKEN认证（?token=xxx）
     """
-    return schedule()
+    return await schedule()
 
 
 @router.get("/transfer", summary="文件整理统计", response_model=List[int])

app/api/endpoints/history.py

@@ -90,7 +90,7 @@ def delete_transfer_history(history_in: schemas.TransferHistory,
     # 册除媒体库文件
     if deletedest and history.dest_fileitem:
         dest_fileitem = schemas.FileItem(**history.dest_fileitem)
-        StorageChain().delete_media_file(fileitem=dest_fileitem, mtype=MediaType(history.type))
+        StorageChain().delete_media_file(dest_fileitem)
 
     # 删除源文件
     if deletesrc and history.src_fileitem:

app/api/endpoints/message.py

@@ -106,7 +106,7 @@ def wechat_verify(echostr: str, msg_signature: str, timestamp: Union[str, int],
         return str(err)
 
 
-async def vocechat_verify() -> Any:
+def vocechat_verify() -> Any:
     """
     VoceChat验证响应
     """

app/api/endpoints/monitoring.py

@@ -1,409 +0,0 @@
-from typing import Any, List
-
-from fastapi import APIRouter, Depends, Query
-from fastapi.responses import HTMLResponse
-
-from app import schemas
-from app.core.security import verify_apitoken
-from app.monitoring import monitor, get_metrics_response
-from app.schemas.monitoring import (
-    PerformanceSnapshot,
-    EndpointStats,
-    ErrorRequest,
-    MonitoringOverview
-)
-
-router = APIRouter()
-
-
-@router.get("/overview", summary="获取监控概览", response_model=schemas.MonitoringOverview)
-def get_overview(_: str = Depends(verify_apitoken)) -> Any:
-    """
-    获取完整的监控概览信息
-    """
-    # 获取性能快照
-    performance = monitor.get_performance_snapshot()
-
-    # 获取最活跃端点
-    top_endpoints = monitor.get_top_endpoints(limit=10)
-
-    # 获取最近错误
-    recent_errors = monitor.get_recent_errors(limit=20)
-
-    # 检查告警
-    alerts = monitor.check_alerts()
-
-    return MonitoringOverview(
-        performance=PerformanceSnapshot(
-            timestamp=performance.timestamp,
-            cpu_usage=performance.cpu_usage,
-            memory_usage=performance.memory_usage,
-            active_requests=performance.active_requests,
-            request_rate=performance.request_rate,
-            avg_response_time=performance.avg_response_time,
-            error_rate=performance.error_rate,
-            slow_requests=performance.slow_requests
-        ),
-        top_endpoints=[EndpointStats(**endpoint) for endpoint in top_endpoints],
-        recent_errors=[ErrorRequest(**error) for error in recent_errors],
-        alerts=alerts
-    )
-
-
-@router.get("/performance", summary="获取性能快照", response_model=schemas.PerformanceSnapshot)
-def get_performance(_: str = Depends(verify_apitoken)) -> Any:
-    """
-    获取当前性能快照
-    """
-    snapshot = monitor.get_performance_snapshot()
-    return PerformanceSnapshot(
-        timestamp=snapshot.timestamp,
-        cpu_usage=snapshot.cpu_usage,
-        memory_usage=snapshot.memory_usage,
-        active_requests=snapshot.active_requests,
-        request_rate=snapshot.request_rate,
-        avg_response_time=snapshot.avg_response_time,
-        error_rate=snapshot.error_rate,
-        slow_requests=snapshot.slow_requests
-    )
-
-
-@router.get("/endpoints", summary="获取端点统计", response_model=List[schemas.EndpointStats])
-def get_endpoints(
-        limit: int = Query(10, ge=1, le=50, description="返回的端点数量"),
-        _: str = Depends(verify_apitoken)
-) -> Any:
-    """
-    获取最活跃的API端点统计
-    """
-    endpoints = monitor.get_top_endpoints(limit=limit)
-    return [EndpointStats(**endpoint) for endpoint in endpoints]
-
-
-@router.get("/errors", summary="获取错误请求", response_model=List[schemas.ErrorRequest])
-def get_errors(
-        limit: int = Query(20, ge=1, le=100, description="返回的错误数量"),
-        _: str = Depends(verify_apitoken)
-) -> Any:
-    """
-    获取最近的错误请求记录
-    """
-    errors = monitor.get_recent_errors(limit=limit)
-    return [ErrorRequest(**error) for error in errors]
-
-
-@router.get("/alerts", summary="获取告警信息", response_model=List[str])
-def get_alerts(_: str = Depends(verify_apitoken)) -> Any:
-    """
-    获取当前告警信息
-    """
-    return monitor.check_alerts()
-
-
-@router.get("/metrics", summary="Prometheus指标")
-def get_prometheus_metrics(_: str = Depends(verify_apitoken)) -> Any:
-    """
-    获取Prometheus格式的监控指标
-    """
-    return get_metrics_response()
-
-
-@router.get("/dashboard", summary="监控仪表板", response_class=HTMLResponse)
-def get_dashboard(_: str = Depends(verify_apitoken)) -> Any:
-    """
-    获取实时监控仪表板HTML页面
-    """
-    return HTMLResponse(content="""
-    <!DOCTYPE html>
-    <html lang="zh-CN">
-    <head>
-        <meta charset="UTF-8">
-        <meta name="viewport" content="width=device-width, initial-scale=1.0">
-        <title>MoviePilot 性能监控仪表板</title>
-        <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
-        <style>
-            body {
-                font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
-                margin: 0;
-                padding: 20px;
-                background-color: #f5f5f5;
-            }
-            .container {
-                max-width: 1200px;
-                margin: 0 auto;
-            }
-            .header {
-                text-align: center;
-                margin-bottom: 30px;
-                color: #333;
-            }
-            .metrics-grid {
-                display: grid;
-                grid-template-columns: repeat(auto-fit, minmax(250px, 1fr));
-                gap: 20px;
-                margin-bottom: 30px;
-            }
-            .metric-card {
-                background: white;
-                padding: 20px;
-                border-radius: 10px;
-                box-shadow: 0 2px 10px rgba(0,0,0,0.1);
-                text-align: center;
-            }
-            .metric-value {
-                font-size: 2em;
-                font-weight: bold;
-                color: #2196F3;
-            }
-            .metric-label {
-                color: #666;
-                margin-top: 5px;
-            }
-            .chart-container {
-                background: white;
-                padding: 20px;
-                border-radius: 10px;
-                box-shadow: 0 2px 10px rgba(0,0,0,0.1);
-                margin-bottom: 20px;
-            }
-            .alerts {
-                background: #fff3cd;
-                border: 1px solid #ffeaa7;
-                border-radius: 5px;
-                padding: 15px;
-                margin-bottom: 20px;
-            }
-            .alert-item {
-                color: #856404;
-                margin: 5px 0;
-            }
-            .refresh-btn {
-                background: #2196F3;
-                color: white;
-                border: none;
-                padding: 10px 20px;
-                border-radius: 5px;
-                cursor: pointer;
-                margin-bottom: 20px;
-            }
-            .refresh-btn:hover {
-                background: #1976D2;
-            }
-        </style>
-    </head>
-    <body>
-        <div class="container">
-            <div class="header">
-                <h1>🎬 MoviePilot 性能监控仪表板</h1>
-                <button class="refresh-btn" onclick="refreshData()">刷新数据</button>
-            </div>
-            
-            <div id="alerts" class="alerts" style="display: none;">
-                <h3>⚠️ 告警信息</h3>
-                <div id="alerts-list"></div>
-            </div>
-            
-            <div class="metrics-grid">
-                <div class="metric-card">
-                    <div class="metric-value" id="cpu-usage">--</div>
-                    <div class="metric-label">CPU使用率 (%)</div>
-                </div>
-                <div class="metric-card">
-                    <div class="metric-value" id="memory-usage">--</div>
-                    <div class="metric-label">内存使用率 (%)</div>
-                </div>
-                <div class="metric-card">
-                    <div class="metric-value" id="active-requests">--</div>
-                    <div class="metric-label">活跃请求数</div>
-                </div>
-                <div class="metric-card">
-                    <div class="metric-value" id="request-rate">--</div>
-                    <div class="metric-label">请求率 (req/min)</div>
-                </div>
-                <div class="metric-card">
-                    <div class="metric-value" id="avg-response-time">--</div>
-                    <div class="metric-label">平均响应时间 (s)</div>
-                </div>
-                <div class="metric-card">
-                    <div class="metric-value" id="error-rate">--</div>
-                    <div class="metric-label">错误率 (%)</div>
-                </div>
-            </div>
-            
-            <div class="chart-container">
-                <h3>📊 性能趋势</h3>
-                <canvas id="performanceChart" width="400" height="200"></canvas>
-            </div>
-            
-            <div class="chart-container">
-                <h3>🔥 最活跃端点</h3>
-                <canvas id="endpointsChart" width="400" height="200"></canvas>
-            </div>
-        </div>
-        
-        <script>
-            let performanceChart, endpointsChart;
-            let performanceData = {
-                labels: [],
-                cpu: [],
-                memory: [],
-                requests: []
-            };
-            
-            // 初始化图表
-            function initCharts() {
-                const ctx1 = document.getElementById('performanceChart').getContext('2d');
-                performanceChart = new Chart(ctx1, {
-                    type: 'line',
-                    data: {
-                        labels: performanceData.labels,
-                        datasets: [{
-                            label: 'CPU使用率 (%)',
-                            data: performanceData.cpu,
-                            borderColor: '#2196F3',
-                            backgroundColor: 'rgba(33, 150, 243, 0.1)',
-                            tension: 0.4
-                        }, {
-                            label: '内存使用率 (%)',
-                            data: performanceData.memory,
-                            borderColor: '#4CAF50',
-                            backgroundColor: 'rgba(76, 175, 80, 0.1)',
-                            tension: 0.4
-                        }, {
-                            label: '活跃请求数',
-                            data: performanceData.requests,
-                            borderColor: '#FF9800',
-                            backgroundColor: 'rgba(255, 152, 0, 0.1)',
-                            tension: 0.4
-                        }]
-                    },
-                    options: {
-                        responsive: true,
-                        scales: {
-                            y: {
-                                beginAtZero: true
-                            }
-                        }
-                    }
-                });
-                
-                const ctx2 = document.getElementById('endpointsChart').getContext('2d');
-                endpointsChart = new Chart(ctx2, {
-                    type: 'bar',
-                    data: {
-                        labels: [],
-                        datasets: [{
-                            label: '请求数',
-                            data: [],
-                            backgroundColor: 'rgba(33, 150, 243, 0.8)'
-                        }]
-                    },
-                    options: {
-                        responsive: true,
-                        scales: {
-                            y: {
-                                beginAtZero: true
-                            }
-                        }
-                    }
-                });
-            }
-            
-            // 更新性能数据
-            function updatePerformanceData(data) {
-                const now = new Date().toLocaleTimeString();
-                
-                performanceData.labels.push(now);
-                performanceData.cpu.push(data.performance.cpu_usage);
-                performanceData.memory.push(data.performance.memory_usage);
-                performanceData.requests.push(data.performance.active_requests);
-                
-                // 保持最近20个数据点
-                if (performanceData.labels.length > 20) {
-                    performanceData.labels.shift();
-                    performanceData.cpu.shift();
-                    performanceData.memory.shift();
-                    performanceData.requests.shift();
-                }
-                
-                // 更新图表
-                performanceChart.data.labels = performanceData.labels;
-                performanceChart.data.datasets[0].data = performanceData.cpu;
-                performanceChart.data.datasets[1].data = performanceData.memory;
-                performanceChart.data.datasets[2].data = performanceData.requests;
-                performanceChart.update();
-                
-                // 更新端点图表
-                const endpointLabels = data.top_endpoints.map(e => e.endpoint.substring(0, 20));
-                const endpointData = data.top_endpoints.map(e => e.count);
-                
-                endpointsChart.data.labels = endpointLabels;
-                endpointsChart.data.datasets[0].data = endpointData;
-                endpointsChart.update();
-            }
-            
-            // 更新指标显示
-            function updateMetrics(data) {
-                document.getElementById('cpu-usage').textContent = data.performance.cpu_usage.toFixed(1);
-                document.getElementById('memory-usage').textContent = data.performance.memory_usage.toFixed(1);
-                document.getElementById('active-requests').textContent = data.performance.active_requests;
-                document.getElementById('request-rate').textContent = data.performance.request_rate.toFixed(0);
-                document.getElementById('avg-response-time').textContent = data.performance.avg_response_time.toFixed(3);
-                document.getElementById('error-rate').textContent = (data.performance.error_rate * 100).toFixed(2);
-            }
-            
-            // 更新告警
-            function updateAlerts(alerts) {
-                const alertsDiv = document.getElementById('alerts');
-                const alertsList = document.getElementById('alerts-list');
-                
-                if (alerts.length > 0) {
-                    alertsDiv.style.display = 'block';
-                    alertsList.innerHTML = alerts.map(alert => 
-                        `<div class="alert-item">⚠️ ${alert}</div>`
-                    ).join('');
-                } else {
-                    alertsDiv.style.display = 'none';
-                }
-            }
-            
-            // 获取URL中的token参数
-            function getTokenFromUrl() {
-                const urlParams = new URLSearchParams(window.location.search);
-                return urlParams.get('token');
-            }
-            
-            // 刷新数据
-            async function refreshData() {
-                try {
-                    const token = getTokenFromUrl();
-                    if (!token) {
-                        console.error('未找到token参数');
-                        return;
-                    }
-                    
-                    const response = await fetch(`/api/v1/monitoring/overview?token=${token}`);
-                    
-                    if (response.ok) {
-                        const data = await response.json();
-                        updateMetrics(data);
-                        updatePerformanceData(data);
-                        updateAlerts(data.alerts);
-                    }
-                } catch (error) {
-                    console.error('获取监控数据失败:', error);
-                }
-            }
-            
-            // 页面加载完成后初始化
-            document.addEventListener('DOMContentLoaded', function() {
-                initCharts();
-                refreshData();
-                
-                // 每5秒自动刷新
-                setInterval(refreshData, 5000);
-            });
-        </script>
-    </body>
-    </html>
-    """)

app/api/endpoints/plugin.py

@@ -3,7 +3,7 @@ import shutil
 from typing import Annotated, Any, List, Optional
 
 import aiofiles
-from aiopath import AsyncPath
+from anyio import Path as AsyncPath
 from fastapi import APIRouter, Depends, Header, HTTPException
 from fastapi.concurrency import run_in_threadpool
 from starlette import status
@@ -13,7 +13,7 @@ from app import schemas
 from app.command import Command
 from app.core.config import settings
 from app.core.plugin import PluginManager
-from app.core.security import verify_apikey, verify_token
+from app.core.security import verify_apikey, verify_token, verify_apitoken
 from app.db.models import User
 from app.db.systemconfig_oper import SystemConfigOper
 from app.db.user_oper import get_current_active_superuser, get_current_active_superuser_async
@@ -21,6 +21,7 @@ from app.factory import app
 from app.helper.plugin import PluginHelper
 from app.log import logger
 from app.scheduler import Scheduler
+from app.schemas.plugin import PluginMemoryInfo
 from app.schemas.types import SystemConfigKey
 
 PROTECTED_ROUTES = {"/api/v1/openapi.json", "/docs", "/docs/oauth2-redirect", "/redoc"}
@@ -463,6 +464,87 @@ async def update_folder_plugins(folder_name: str, plugin_ids: List[str],
     return schemas.Response(success=True, message=f"文件夹 '{folder_name}' 中的插件已更新")
 
 
+@router.post("/clone/{plugin_id}", summary="创建插件分身", response_model=schemas.Response)
+def clone_plugin(plugin_id: str,
+                 clone_data: dict,
+                 _: User = Depends(get_current_active_superuser)) -> Any:
+    """
+    创建插件分身
+    """
+    try:
+        success, message = PluginManager().clone_plugin(
+            plugin_id=plugin_id,
+            suffix=clone_data.get("suffix", ""),
+            name=clone_data.get("name", ""),
+            description=clone_data.get("description", ""),
+            version=clone_data.get("version", ""),
+            icon=clone_data.get("icon", "")
+        )
+
+        if success:
+            # 注册插件服务
+            reload_plugin(message)
+            # 将分身插件添加到原插件所在的文件夹中
+            _add_clone_to_plugin_folder(plugin_id, message)
+            return schemas.Response(success=True, message="插件分身创建成功")
+        else:
+            return schemas.Response(success=False, message=message)
+    except Exception as e:
+        logger.error(f"创建插件分身失败：{str(e)}")
+        return schemas.Response(success=False, message=f"创建插件分身失败：{str(e)}")
+
+
+@router.get("/memory", summary="插件内存使用统计", response_model=List[PluginMemoryInfo])
+def plugin_memory_stats(_: Annotated[str, Depends(verify_apitoken)]) -> Any:
+    """
+    获取所有插件的内存使用统计信息
+    """
+    try:
+        plugin_manager = PluginManager()
+        memory_stats = plugin_manager.get_plugin_memory_stats()
+        return memory_stats
+    except Exception as e:
+        logger.error(f"获取插件内存统计失败：{str(e)}")
+        raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                            detail=f"获取插件内存统计失败：{str(e)}")
+
+
+@router.get("/memory/{plugin_id}", summary="单个插件内存使用统计", response_model=PluginMemoryInfo)
+def plugin_memory_stat(plugin_id: str, _: Annotated[str, Depends(verify_apitoken)]) -> Any:
+    """
+    获取指定插件的内存使用统计信息
+    """
+    try:
+        plugin_manager = PluginManager()
+        memory_stats = plugin_manager.get_plugin_memory_stats(plugin_id)
+        if not memory_stats:
+            raise HTTPException(status_code=status.HTTP_404_NOT_FOUND,
+                                detail=f"插件 {plugin_id} 不存在或未运行")
+        return memory_stats[0]
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"获取插件 {plugin_id} 内存统计失败：{str(e)}")
+        raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                            detail=f"获取插件内存统计失败：{str(e)}")
+
+
+@router.delete("/memory/cache", summary="清除插件内存统计缓存")
+def clear_plugin_memory_cache(_: Annotated[str, Depends(verify_apitoken)],
+                              plugin_id: Optional[str] = None) -> Any:
+    """
+    清除插件内存统计缓存
+    """
+    try:
+        plugin_manager = PluginManager()
+        plugin_manager.clear_plugin_memory_cache(plugin_id)
+        message = f"已清除插件 {plugin_id} 的内存统计缓存" if plugin_id else "已清除所有插件的内存统计缓存"
+        return schemas.Response(success=True, message=message)
+    except Exception as e:
+        logger.error(f"清除插件内存统计缓存失败：{str(e)}")
+        return schemas.Response(success=False, message=f"清除缓存失败：{str(e)}")
+
+
 @router.get("/{plugin_id}", summary="获取插件配置")
 async def plugin_config(plugin_id: str,
                         _: User = Depends(get_current_active_superuser_async)) -> dict:
@@ -528,36 +610,6 @@ def uninstall_plugin(plugin_id: str,
     return schemas.Response(success=True)
 
 
-@router.post("/clone/{plugin_id}", summary="创建插件分身", response_model=schemas.Response)
-def clone_plugin(plugin_id: str,
-                 clone_data: dict,
-                 _: User = Depends(get_current_active_superuser)) -> Any:
-    """
-    创建插件分身
-    """
-    try:
-        success, message = PluginManager().clone_plugin(
-            plugin_id=plugin_id,
-            suffix=clone_data.get("suffix", ""),
-            name=clone_data.get("name", ""),
-            description=clone_data.get("description", ""),
-            version=clone_data.get("version", ""),
-            icon=clone_data.get("icon", "")
-        )
-
-        if success:
-            # 注册插件服务
-            reload_plugin(message)
-            # 将分身插件添加到原插件所在的文件夹中
-            _add_clone_to_plugin_folder(plugin_id, message)
-            return schemas.Response(success=True, message="插件分身创建成功")
-        else:
-            return schemas.Response(success=False, message=message)
-    except Exception as e:
-        logger.error(f"创建插件分身失败：{str(e)}")
-        return schemas.Response(success=False, message=f"创建插件分身失败：{str(e)}")
-
-
 def _add_clone_to_plugin_folder(original_plugin_id: str, clone_plugin_id: str):
     """
     将分身插件添加到原插件所在的文件夹中

app/api/endpoints/storage.py

@@ -15,6 +15,7 @@ from app.db.models import User
 from app.db.user_oper import get_current_active_superuser, get_current_active_superuser_async
 from app.helper.progress import ProgressHelper
 from app.schemas.types import ProgressKey
+from app.utils.string import StringUtils
 
 router = APIRouter()
 
@@ -80,7 +81,7 @@ def list_files(fileitem: schemas.FileItem,
     file_list = StorageChain().list_files(fileitem)
     if file_list:
         if sort == "name":
-            file_list.sort(key=lambda x: x.name or "")
+            file_list.sort(key=lambda x: StringUtils.natural_sort_key(x.name or ""))
         else:
             file_list.sort(key=lambda x: x.modify_time or datetime.min, reverse=True)
     return file_list
@@ -171,15 +172,14 @@ def rename(fileitem: schemas.FileItem,
         sub_files: List[schemas.FileItem] = StorageChain().list_files(fileitem)
         if sub_files:
             # 开始进度
-            progress = ProgressHelper()
-            progress.start(ProgressKey.BatchRename)
+            progress = ProgressHelper(ProgressKey.BatchRename)
+            progress.start()
             total = len(sub_files)
             handled = 0
             for sub_file in sub_files:
                 handled += 1
                 progress.update(value=handled / total * 100,
-                                text=f"正在处理 {sub_file.name} ...",
-                                key=ProgressKey.BatchRename)
+                                text=f"正在处理 {sub_file.name} ...")
                 if sub_file.type == "dir":
                     continue
                 if not sub_file.extension:
@@ -190,19 +190,19 @@ def rename(fileitem: schemas.FileItem,
                 meta = MetaInfoPath(sub_path)
                 mediainfo = transferchain.recognize_media(meta)
                 if not mediainfo:
-                    progress.end(ProgressKey.BatchRename)
+                    progress.end()
                     return schemas.Response(success=False, message=f"{sub_path.name} 未识别到媒体信息")
                 new_path = transferchain.recommend_name(meta=meta, mediainfo=mediainfo)
                 if not new_path:
-                    progress.end(ProgressKey.BatchRename)
+                    progress.end()
                     return schemas.Response(success=False, message=f"{sub_path.name} 未识别到新名称")
                 ret: schemas.Response = rename(fileitem=sub_file,
                                                new_name=Path(new_path).name,
                                                recursive=False)
                 if not ret.success:
-                    progress.end(ProgressKey.BatchRename)
+                    progress.end()
                     return schemas.Response(success=False, message=f"{sub_path.name} 重命名失败！")
-            progress.end(ProgressKey.BatchRename)
+            progress.end()
     # 重命名自己
     result = StorageChain().rename_file(fileitem, new_name)
     if result:

app/api/endpoints/subscribe.py

@@ -78,10 +78,14 @@ async def create_subscribe(
         title = None
     # 订阅用户
     subscribe_in.username = current_user.name
+    # 转化为字典
+    subscribe_dict = subscribe_in.dict()
+    if subscribe_in.id:
+        subscribe_dict.pop("id", None)
     sid, message = await SubscribeChain().async_add(mtype=mtype,
                                                     title=title,
                                                     exist_ok=True,
-                                                    **subscribe_in.dict())
+                                                    **subscribe_dict)
     return schemas.Response(
         success=bool(sid), message=message, data={"id": sid}
     )

app/api/endpoints/system.py

@@ -4,19 +4,20 @@ import json
 import re
 from collections import deque
 from datetime import datetime
+from pathlib import Path
 from typing import Optional, Union, Annotated
 
 import aiofiles
 import pillow_avif  # noqa 用于自动注册AVIF支持
 from PIL import Image
-from aiopath import AsyncPath
-from app.helper.sites import SitesHelper  # noqa  # noqa
+from anyio import Path as AsyncPath
 from fastapi import APIRouter, Body, Depends, HTTPException, Header, Request, Response
 from fastapi.responses import StreamingResponse
 
 from app import schemas
 from app.chain.search import SearchChain
 from app.chain.system import SystemChain
+from app.core.cache import AsyncFileCache
 from app.core.config import global_vars, settings
 from app.core.event import eventmanager
 from app.core.metainfo import MetaInfo
@@ -24,11 +25,13 @@ from app.core.module import ModuleManager
 from app.core.security import verify_apitoken, verify_resource_token, verify_token
 from app.db.models import User
 from app.db.systemconfig_oper import SystemConfigOper
-from app.db.user_oper import get_current_active_superuser, get_current_active_superuser_async
+from app.db.user_oper import get_current_active_superuser, get_current_active_superuser_async, \
+    get_current_active_user_async
 from app.helper.mediaserver import MediaServerHelper
 from app.helper.message import MessageHelper
 from app.helper.progress import ProgressHelper
 from app.helper.rule import RuleHelper
+from app.helper.sites import SitesHelper  # noqa  # noqa
 from app.helper.subscribe import SubscribeHelper
 from app.helper.system import SystemHelper
 from app.log import logger
@@ -47,7 +50,7 @@ router = APIRouter()
 async def fetch_image(
         url: str,
         proxy: bool = False,
-        use_disk_cache: bool = False,
+        use_cache: bool = False,
         if_none_match: Optional[str] = None,
         allowed_domains: Optional[set[str]] = None) -> Response:
     """
@@ -63,37 +66,31 @@ async def fetch_image(
     if not SecurityUtils.is_safe_url(url, allowed_domains):
         raise HTTPException(status_code=404, detail="Unsafe URL")
 
-    # 后续观察系统性能表现，如果发现磁盘缓存和HTTP缓存无法满足高并发情况下的响应速度需求，可以考虑重新引入内存缓存
-    cache_path: Optional[AsyncPath] = None
-    if use_disk_cache:
-        # 生成缓存路径
-        base_path = AsyncPath(settings.CACHE_PATH)
-        sanitized_path = SecurityUtils.sanitize_url_path(url)
-        cache_path = base_path / "images" / sanitized_path
-
+    # 缓存路径
+    sanitized_path = SecurityUtils.sanitize_url_path(url)
+    cache_path = Path("images") / sanitized_path
+    if not cache_path.suffix:
         # 没有文件类型，则添加后缀，在恶意文件类型和实际需求下的折衷选择
-        if not cache_path.suffix:
-            cache_path = cache_path.with_suffix(".jpg")
+        cache_path = cache_path.with_suffix(".jpg")
 
-        # 确保缓存路径和文件类型合法
-        if not await SecurityUtils.async_is_safe_path(base_path=base_path,
-                                                      user_path=cache_path,
-                                                      allowed_suffixes=settings.SECURITY_IMAGE_SUFFIXES):
-            raise HTTPException(status_code=400, detail="Invalid cache path or file type")
+    # 缓存对像，缓存过期时间为全局图片缓存天数
+    cache_backend = AsyncFileCache(base=settings.CACHE_PATH,
+                                   ttl=settings.GLOBAL_IMAGE_CACHE_DAYS * 24 * 3600)
 
-        # 目前暂不考虑磁盘缓存文件是否过期，后续通过缓存清理机制处理
-        if cache_path and await cache_path.exists():
-            try:
-                async with cache_path.open('rb') as f:
-                    content = await f.read()
-                etag = HashUtils.md5(content)
-                headers = RequestUtils.generate_cache_headers(etag, max_age=86400 * 7)
-                if if_none_match == etag:
-                    return Response(status_code=304, headers=headers)
-                return Response(content=content, media_type="image/jpeg", headers=headers)
-            except Exception as e:
-                # 如果读取磁盘缓存发生异常，这里仅记录日志，尝试再次请求远端进行处理
-                logger.debug(f"Failed to read cache file {cache_path}: {e}")
+    if use_cache:
+        content = await cache_backend.get(cache_path.as_posix(), region="images")
+        if content:
+            # 检查 If-None-Match
+            etag = HashUtils.md5(content)
+            headers = RequestUtils.generate_cache_headers(etag, max_age=86400 * 7)
+            if if_none_match == etag:
+                return Response(status_code=304, headers=headers)
+            # 返回缓存图片
+            return Response(
+                content=content,
+                media_type=UrlUtils.get_mime_type(url, "image/jpeg"),
+                headers=headers
+            )
 
     # 请求远程图片
     referer = "https://movie.douban.com/" if "doubanio.com" in url else None
@@ -111,22 +108,15 @@ async def fetch_image(
         logger.debug(f"Invalid image format for URL {url}: {e}")
         raise HTTPException(status_code=502, detail="Invalid image format")
 
+    # 获取请求响应头
     response_headers = response.headers
-
     cache_control_header = response_headers.get("Cache-Control", "")
     cache_directive, max_age = RequestUtils.parse_cache_control(cache_control_header)
 
-    # 如果需要使用磁盘缓存，则保存到磁盘
-    if use_disk_cache and cache_path:
-        try:
-            if not await cache_path.parent.exists():
-                await cache_path.parent.mkdir(parents=True, exist_ok=True)
-            async with aiofiles.tempfile.NamedTemporaryFile(dir=cache_path.parent, delete=False) as tmp_file:
-                await tmp_file.write(content)
-                temp_path = AsyncPath(tmp_file.name)
-            await temp_path.replace(cache_path)
-        except Exception as e:
-            logger.debug(f"Failed to write cache file {cache_path}: {e}")
+    # 保存缓存
+    if use_cache:
+        await cache_backend.set(cache_path.as_posix(), content, region="images")
+        logger.debug(f"Image cached at {cache_path.as_posix()}")
 
     # 检查 If-None-Match
     etag = HashUtils.md5(content)
@@ -134,8 +124,8 @@ async def fetch_image(
         headers = RequestUtils.generate_cache_headers(etag, cache_directive, max_age)
         return Response(status_code=304, headers=headers)
 
+    # 响应
     headers = RequestUtils.generate_cache_headers(etag, cache_directive, max_age)
-
     return Response(
         content=content,
         media_type=response_headers.get("Content-Type") or UrlUtils.get_mime_type(url, "image/jpeg"),
@@ -158,7 +148,7 @@ async def proxy_img(
     hosts = [config.config.get("host") for config in MediaServerHelper().get_configs().values() if
              config and config.config and config.config.get("host")]
     allowed_domains = set(settings.SECURITY_IMAGE_DOMAINS) | set(hosts)
-    return await fetch_image(url=imgurl, proxy=proxy, use_disk_cache=cache,
+    return await fetch_image(url=imgurl, proxy=proxy, use_cache=cache,
                              if_none_match=if_none_match, allowed_domains=allowed_domains)
 
 
@@ -173,7 +163,7 @@ async def cache_img(
     """
     # 如果没有启用全局图片缓存，则不使用磁盘缓存
     proxy = "doubanio.com" not in url
-    return await fetch_image(url=url, proxy=proxy, use_disk_cache=settings.GLOBAL_IMAGE_CACHE,
+    return await fetch_image(url=url, proxy=proxy, use_cache=settings.GLOBAL_IMAGE_CACHE,
                              if_none_match=if_none_match)
 
 
@@ -203,7 +193,7 @@ def get_global_setting(token: str):
 
 
 @router.get("/env", summary="查询系统配置", response_model=schemas.Response)
-async def get_env_setting(_: User = Depends(get_current_active_superuser_async)):
+async def get_env_setting(_: User = Depends(get_current_active_user_async)):
     """
     查询系统环境变量，包括当前版本号（仅管理员）
     """
@@ -264,14 +254,14 @@ async def get_progress(request: Request, process_type: str, _: schemas.TokenPayl
     """
     实时获取处理进度，返回格式为SSE
     """
-    progress = ProgressHelper()
+    progress = ProgressHelper(process_type)
 
     async def event_generator():
         try:
             while not global_vars.is_system_stopped:
                 if await request.is_disconnected():
                     break
-                detail = progress.get(process_type)
+                detail = progress.get()
                 yield f"data: {json.dumps(detail)}\n\n"
                 await asyncio.sleep(0.5)
         except asyncio.CancelledError:
@@ -282,7 +272,7 @@ async def get_progress(request: Request, process_type: str, _: schemas.TokenPayl
 
 @router.get("/setting/{key}", summary="查询系统设置", response_model=schemas.Response)
 async def get_setting(key: str,
-                      _: User = Depends(get_current_active_superuser_async)):
+                      _: User = Depends(get_current_active_user_async)):
     """
     查询系统设置（仅管理员）
     """
@@ -381,7 +371,7 @@ async def get_logging(request: Request, length: Optional[int] = 50, logfile: Opt
             file_size = file_stat.st_size
 
             # 读取历史日志
-            async with log_path.open(mode="r", encoding="utf-8", errors="ignore") as f:
+            async with aiofiles.open(log_path, mode="r", encoding="utf-8", errors="ignore") as f:
                 # 优化大文件读取策略
                 if file_size > 100 * 1024:
                     # 只读取最后100KB的内容
@@ -408,7 +398,7 @@ async def get_logging(request: Request, length: Optional[int] = 50, logfile: Opt
                 yield f"data: {line}\n\n"
 
             # 实时监听新日志
-            async with log_path.open(mode="r", encoding="utf-8", errors="ignore") as f:
+            async with aiofiles.open(log_path, mode="r", encoding="utf-8", errors="ignore") as f:
                 # 移动文件指针到文件末尾，继续监听新增内容
                 await f.seek(0, 2)
                 # 记录初始文件大小
@@ -445,7 +435,7 @@ async def get_logging(request: Request, length: Optional[int] = 50, logfile: Opt
             return Response(content="日志文件不存在！", media_type="text/plain")
         try:
             # 使用 aiofiles 异步读取文件
-            async with log_path.open(mode="r", encoding="utf-8", errors="ignore") as file:
+            async with aiofiles.open(log_path, mode="r", encoding="utf-8", errors="ignore") as file:
                 text = await file.read()
             # 倒序输出
             text = "\n".join(text.split("\n")[::-1])

app/api/endpoints/torrent.py

@@ -135,8 +135,8 @@ def refresh_cache(_: User = Depends(get_current_active_superuser)):
 
 @router.post("/cache/reidentify/{domain}/{torrent_hash}", summary="重新识别种子", response_model=schemas.Response)
 async def reidentify_cache(domain: str, torrent_hash: str,
-                     tmdbid: Optional[int] = None, doubanid: Optional[str] = None,
-                     _: User = Depends(get_current_active_superuser_async)):
+                           tmdbid: Optional[int] = None, doubanid: Optional[str] = None,
+                           _: User = Depends(get_current_active_superuser_async)):
     """
     重新识别指定的种子
     :param domain: 站点域名

app/api/endpoints/transfer.py

@@ -8,7 +8,7 @@ from app import schemas
 from app.chain.media import MediaChain
 from app.chain.storage import StorageChain
 from app.chain.transfer import TransferChain
-from app.core.config import settings
+from app.core.config import settings, global_vars
 from app.core.metainfo import MetaInfoPath
 from app.core.security import verify_token, verify_apitoken
 from app.db import get_db
@@ -75,6 +75,8 @@ async def remove_queue(fileitem: schemas.FileItem, _: schemas.TokenPayload = Dep
     :param _: Token校验
     """
     TransferChain().remove_from_queue(fileitem)
+    # 取消整理
+    global_vars.stop_transfer(fileitem.path)
     return schemas.Response(success=True)
 
 
@@ -109,7 +111,7 @@ def manual_transfer(transer_item: ManualTransferItem,
             if history.dest_fileitem:
                 # 删除旧的已整理文件
                 dest_fileitem = FileItem(**history.dest_fileitem)
-                state = StorageChain().delete_media_file(dest_fileitem, mtype=MediaType(history.type))
+                state = StorageChain().delete_media_file(dest_fileitem)
                 if not state:
                     return schemas.Response(success=False, message=f"{dest_fileitem.path} 删除失败")
 

app/api/servcookie.py

@@ -2,7 +2,8 @@ import gzip
 import json
 from typing import Annotated, Callable, Any, Dict, Optional
 
-from aiopath import AsyncPath
+import aiofiles
+from anyio import Path as AsyncPath
 from fastapi import APIRouter, Depends, HTTPException, Path, Request, Response
 from fastapi.responses import PlainTextResponse
 from fastapi.routing import APIRoute
@@ -67,9 +68,9 @@ async def update_cookie(req: schemas.CookieData):
     """
     file_path = AsyncPath(settings.COOKIE_PATH) / f"{req.uuid}.json"
     content = json.dumps({"encrypted": req.encrypted})
-    async with file_path.open(encoding="utf-8", mode="w") as file:
+    async with aiofiles.open(file_path, encoding="utf-8", mode="w") as file:
         await file.write(content)
-    async with file_path.open(encoding="utf-8", mode="r") as file:
+    async with aiofiles.open(file_path, encoding="utf-8", mode="r") as file:
         read_content = await file.read()
     if read_content == content:
         return {"action": "done"}
@@ -88,7 +89,7 @@ async def load_encrypt_data(uuid: str) -> Dict[str, Any]:
         raise HTTPException(status_code=404, detail="Item not found")
 
     # 读取文件
-    async with file_path.open(encoding="utf-8", mode="r") as file:
+    async with aiofiles.open(file_path, encoding="utf-8", mode="r") as file:
         read_content = await file.read()
     data = json.loads(read_content.encode("utf-8"))
     return data

app/chain/__init__.py

@@ -8,12 +8,10 @@ from pathlib import Path
 from typing import Optional, Any, Tuple, List, Set, Union, Dict
 
 from fastapi.concurrency import run_in_threadpool
-
-import aiofiles
-from aiopath import AsyncPath
 from qbittorrentapi import TorrentFilesList
 from transmission_rpc import File
 
+from app.core.cache import FileCache, AsyncFileCache
 from app.core.config import settings
 from app.core.context import Context, MediaInfo, TorrentInfo
 from app.core.event import EventManager
@@ -48,78 +46,66 @@ class ChainBase(metaclass=ABCMeta):
             send_callback=self.run_module
         )
         self.pluginmanager = PluginManager()
+        self.filecache = FileCache()
+        self.async_filecache = AsyncFileCache()
 
-    @staticmethod
-    def load_cache(filename: str) -> Any:
+    def load_cache(self, filename: str) -> Any:
         """
-        从本地加载缓存
+        加载缓存
         """
-        cache_path = settings.TEMP_PATH / filename
-        if cache_path.exists():
-            try:
-                with open(cache_path, 'rb') as f:
-                    return pickle.load(f)
-            except Exception as err:
-                logger.error(f"加载缓存 {filename} 出错：{str(err)}")
-        return None
+        content = self.filecache.get(filename)
+        if not content:
+            return None
+        try:
+            return pickle.loads(content)
+        except Exception as err:
+            logger.error(f"加载缓存 {filename} 出错：{str(err)}")
+            return None
 
-    @staticmethod
-    async def async_load_cache(filename: str) -> Any:
+    async def async_load_cache(self, filename: str) -> Any:
         """
-        异步从本地加载缓存
+        异步加载缓存
         """
-        cache_path = settings.TEMP_PATH / filename
-        if cache_path.exists():
-            try:
-                async with aiofiles.open(cache_path, 'rb') as f:
-                    content = await f.read()
-                    return pickle.loads(content)
-            except Exception as err:
-                logger.error(f"加载缓存 {filename} 出错：{str(err)}")
-        return None
+        content = await self.async_filecache.get(filename)
+        if not content:
+            return None
+        try:
+            return pickle.loads(content)
+        except Exception as err:
+            logger.error(f"异步加载缓存 {filename} 出错：{str(err)}")
+            return None
 
-    @staticmethod
-    async def async_save_cache(cache: Any, filename: str) -> None:
+    async def async_save_cache(self, cache: Any, filename: str) -> None:
         """
-        异步保存缓存到本地
+        异步保存缓存
         """
         try:
-            async with aiofiles.open(settings.TEMP_PATH / filename, 'wb') as f:
-                await f.write(pickle.dumps(cache))
+            await self.async_filecache.set(filename, pickle.dumps(cache))
         except Exception as err:
-            logger.error(f"保存缓存 {filename} 出错：{str(err)}")
+            logger.error(f"异步保存缓存 {filename} 出错：{str(err)}")
+            return
 
-    @staticmethod
-    def save_cache(cache: Any, filename: str) -> None:
+    def save_cache(self, cache: Any, filename: str) -> None:
         """
-        保存缓存到本地
+        保存缓存
         """
         try:
-            with open(settings.TEMP_PATH / filename, 'wb') as f:
-                pickle.dump(cache, f)  # noqa
+            self.filecache.set(filename, pickle.dumps(cache))
         except Exception as err:
             logger.error(f"保存缓存 {filename} 出错：{str(err)}")
+            return
 
-    @staticmethod
-    def remove_cache(filename: str) -> None:
+    def remove_cache(self, filename: str) -> None:
         """
-        删除本地缓存
+        删除缓存，同时删除Redis和本地缓存
         """
-        cache_path = settings.TEMP_PATH / filename
-        if cache_path.exists():
-            cache_path.unlink()
+        self.filecache.delete(filename)
 
-    @staticmethod
-    async def async_remove_cache(filename: str) -> None:
+    async def async_remove_cache(self, filename: str) -> None:
         """
-        异步删除本地缓存
+        异步删除缓存，同时删除Redis和本地缓存
         """
-        cache_path = AsyncPath(settings.TEMP_PATH) / filename
-        if await cache_path.exists():
-            try:
-                await cache_path.unlink()
-            except Exception as err:
-                logger.error(f"异步删除缓存 {filename} 出错：{str(err)}")
+        await self.async_filecache.delete(filename)
 
     @staticmethod
     def __is_valid_empty(ret):
@@ -700,13 +686,13 @@ class ChainBase(metaclass=ABCMeta):
         return self.run_module("filter_torrents", rule_groups=rule_groups,
                                torrent_list=torrent_list, mediainfo=mediainfo)
 
-    def download(self, content: Union[Path, str], download_dir: Path, cookie: str,
+    def download(self, content: Union[Path, str, bytes], download_dir: Path, cookie: str,
                  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]]:
         """
         根据种子文件，选择并添加下载任务
-        :param content:  种子文件地址或者磁力链接
+        :param content:  种子文件地址或者磁力链接或者种子内容
         :param download_dir:  下载目录
         :param cookie:  cookie
         :param episodes:  需要下载的集数
@@ -719,15 +705,16 @@ class ChainBase(metaclass=ABCMeta):
                                cookie=cookie, episodes=episodes, category=category, label=label,
                                downloader=downloader)
 
-    def download_added(self, context: Context, download_dir: Path, torrent_path: Path = None) -> None:
+    def download_added(self, context: Context, download_dir: Path, torrent_content: Union[str, bytes] = None) -> None:
         """
         添加下载任务成功后，从站点下载字幕，保存到下载目录
         :param context:  上下文，包括识别信息、媒体信息、种子信息
         :param download_dir:  下载目录
-        :param torrent_path:  种子文件地址
+        :param torrent_content:  种子内容，如果有则直接使用该内容，否则从context中获取种子文件路径
         :return: None，该方法可被多个模块同时处理
         """
-        return self.run_module("download_added", context=context, torrent_path=torrent_path,
+        return self.run_module("download_added", context=context,
+                               torrent_content=torrent_content,
                                download_dir=download_dir)
 
     def list_torrents(self, status: TorrentStatus = None,
@@ -923,12 +910,12 @@ class ChainBase(metaclass=ABCMeta):
                                        immediately=True if message.userid else False)
 
     async def async_post_message(self,
-                     message: Optional[Notification] = None,
-                     meta: Optional[MetaBase] = None,
-                     mediainfo: Optional[MediaInfo] = None,
-                     torrentinfo: Optional[TorrentInfo] = None,
-                     transferinfo: Optional[TransferInfo] = None,
-                     **kwargs) -> None:
+                                 message: Optional[Notification] = None,
+                                 meta: Optional[MetaBase] = None,
+                                 mediainfo: Optional[MediaInfo] = None,
+                                 torrentinfo: Optional[TorrentInfo] = None,
+                                 transferinfo: Optional[TransferInfo] = None,
+                                 **kwargs) -> None:
         """
         异步发送消息
         :param message:  Notification实例
@@ -991,15 +978,16 @@ class ChainBase(metaclass=ABCMeta):
                         break
                     # 按设定发送
                     await self.eventmanager.async_send_event(etype=EventType.NoticeMessage,
-                                                 data={**send_message.dict(), "type": send_message.mtype})
+                                                             data={**send_message.dict(), "type": send_message.mtype})
                     await self.messagequeue.async_send_message("post_message", message=send_message)
                 if not send_orignal:
                     return
         # 发送消息事件
-        await self.eventmanager.async_send_event(etype=EventType.NoticeMessage, data={**message.dict(), "type": message.mtype})
+        await self.eventmanager.async_send_event(etype=EventType.NoticeMessage,
+                                                 data={**message.dict(), "type": message.mtype})
         # 按原消息发送
         await self.messagequeue.async_send_message("post_message", message=message,
-                                       immediately=True if message.userid else False)
+                                                   immediately=True if message.userid else False)
 
     def post_medias_message(self, message: Notification, medias: List[MediaInfo]) -> None:
         """

app/chain/download.py

@@ -8,6 +8,7 @@ from typing import List, Optional, Tuple, Set, Dict, Union
 
 from app import schemas
 from app.chain import ChainBase
+from app.core.cache import FileCache
 from app.core.config import settings, global_vars
 from app.core.context import MediaInfo, TorrentInfo, Context
 from app.core.event import eventmanager, Event
@@ -35,10 +36,10 @@ class DownloadChain(ChainBase):
                          channel: MessageChannel = None,
                          source: Optional[str] = None,
                          userid: Union[str, int] = None
-                         ) -> Tuple[Optional[Union[Path, str]], str, list]:
+                         ) -> Tuple[Optional[Union[str, bytes]], str, list]:
         """
         下载种子文件，如果是磁力链，会返回磁力链接本身
-        :return: 种子路径，种子目录名，种子文件清单
+        :return: 种子内容，种子目录名，种子文件清单
         """
 
         def __get_redict_url(url: str, ua: Optional[str] = None, cookie: Optional[str] = None) -> Optional[str]:
@@ -117,7 +118,7 @@ class DownloadChain(ChainBase):
             logger.error(f"{torrent.title} 无法获取下载地址：{torrent.enclosure}！")
             return None, "", []
         # 下载种子文件
-        torrent_file, content, download_folder, files, error_msg = TorrentHelper().download_torrent(
+        _, content, download_folder, files, error_msg = TorrentHelper().download_torrent(
             url=torrent_url,
             cookie=site_cookie,
             ua=torrent.site_ua or settings.USER_AGENT,
@@ -127,7 +128,7 @@ class DownloadChain(ChainBase):
             # 磁力链
             return content, "", []
 
-        if not torrent_file:
+        if not content:
             logger.error(f"下载种子文件失败：{torrent.title} - {torrent_url}")
             self.post_message(Notification(
                 channel=channel,
@@ -139,9 +140,11 @@ class DownloadChain(ChainBase):
             return None, "", []
 
         # 返回 种子文件路径，种子目录名，种子文件清单
-        return torrent_file, download_folder, files
+        return content, download_folder, files
 
-    def download_single(self, context: Context, torrent_file: Path = None,
+    def download_single(self, context: Context,
+                        torrent_file: Path = None,
+                        torrent_content: Optional[Union[str, bytes]] = None,
                         episodes: Set[int] = None,
                         channel: MessageChannel = None,
                         source: Optional[str] = None,
@@ -154,6 +157,7 @@ class DownloadChain(ChainBase):
         下载及发送通知
         :param context: 资源上下文
         :param torrent_file: 种子文件路径
+        :param torrent_content: 种子内容（磁力链或种子文件内容）
         :param episodes: 需要下载的集数
         :param channel: 通知渠道
         :param source: 来源（消息通知、Subscribe、Manual等）
@@ -207,18 +211,26 @@ class DownloadChain(ChainBase):
         # 实际下载的集数
         download_episodes = StringUtils.format_ep(list(episodes)) if episodes else None
         _folder_name = ""
-        if not torrent_file:
+        if not torrent_file and not torrent_content:
             # 下载种子文件，得到的可能是文件也可能是磁力链
-            content, _folder_name, _file_list = self.download_torrent(_torrent,
-                                                                      channel=channel,
-                                                                      source=source,
-                                                                      userid=userid)
-            if not content:
-                return None
-        else:
-            content = torrent_file
-            # 获取种子文件的文件夹名和文件清单
-            _folder_name, _file_list = TorrentHelper().get_torrent_info(torrent_file)
+            torrent_content, _folder_name, _file_list = self.download_torrent(_torrent,
+                                                                              channel=channel,
+                                                                              source=source,
+                                                                              userid=userid)
+        elif torrent_file:
+            if torrent_file.exists():
+                torrent_content = torrent_file.read_bytes()
+            else:
+                # 缓存处理器
+                cache_backend = FileCache()
+                # 读取缓存的种子文件
+                torrent_content = cache_backend.get(torrent_file.as_posix(), region="torrents")
+
+        if not torrent_content:
+            return None
+
+        # 获取种子文件的文件夹名和文件清单
+        _folder_name, _file_list = TorrentHelper().get_fileinfo_from_torrent_content(torrent_content)
 
         # 下载目录
         if save_path:
@@ -249,7 +261,7 @@ class DownloadChain(ChainBase):
                 return None
 
         # 添加下载
-        result: Optional[tuple] = self.download(content=content,
+        result: Optional[tuple] = self.download(content=torrent_content,
                                                 cookie=_torrent.site_cookie,
                                                 episodes=episodes,
                                                 download_dir=download_dir,
@@ -346,7 +358,7 @@ class DownloadChain(ChainBase):
                 username=username,
             )
             # 下载成功后处理
-            self.download_added(context=context, download_dir=download_dir, torrent_path=torrent_file)
+            self.download_added(context=context, download_dir=download_dir, torrent_content=torrent_content)
             # 广播事件
             self.eventmanager.send_event(EventType.DownloadAdded, {
                 "hash": _hash,
@@ -560,7 +572,7 @@ class DownloadChain(ChainBase):
                                     logger.info(f"开始下载 {torrent.title} ...")
                                     download_id = self.download_single(
                                         context=context,
-                                        torrent_file=content if isinstance(content, Path) else None,
+                                        torrent_content=content,
                                         save_path=save_path,
                                         channel=channel,
                                         source=source,
@@ -727,7 +739,7 @@ class DownloadChain(ChainBase):
                             logger.info(f"开始下载 {torrent.title} ...")
                             download_id = self.download_single(
                                 context=context,
-                                torrent_file=content if isinstance(content, Path) else None,
+                                torrent_content=content,
                                 episodes=selected_episodes,
                                 save_path=save_path,
                                 channel=channel,

app/chain/media.py

@@ -310,6 +310,21 @@ class MediaChain(ChainBase):
             )
         return None
 
+    @staticmethod
+    def is_bluray_folder(fileitem: schemas.FileItem) -> bool:
+        """
+        判断是否为原盘目录
+        """
+        if not fileitem or fileitem.type != "dir":
+            return False
+        # 蓝光原盘目录必备的文件或文件夹
+        required_files = ['BDMV', 'CERTIFICATE']
+        # 检查目录下是否存在所需文件或文件夹
+        for item in StorageChain().list_files(fileitem):
+            if item.name in required_files:
+                return True
+        return False
+
     @eventmanager.register(EventType.MetadataScrape)
     def scrape_metadata_event(self, event: Event):
         """
@@ -318,11 +333,17 @@ class MediaChain(ChainBase):
         if not event:
             return
         event_data = event.event_data or {}
+        # 媒体根目录
         fileitem: FileItem = event_data.get("fileitem")
+        # 媒体文件列表
         file_list: List[str] = event_data.get("file_list", [])
+        # 媒体元数据
         meta: MetaBase = event_data.get("meta")
+        # 媒体信息
         mediainfo: MediaInfo = event_data.get("mediainfo")
+        # 是否覆盖
         overwrite = event_data.get("overwrite", False)
+        # 检查媒体根目录
         if not fileitem:
             return
 
@@ -342,31 +363,71 @@ class MediaChain(ChainBase):
                                      parent=storagechain.get_parent_item(fileitem),
                                      overwrite=overwrite)
             else:
-                # 检查目的目录下是否已经有nfo刮削文件
-                has_nfo_file = storagechain.any_files(fileitem, extensions=['.nfo'])
-                if has_nfo_file and file_list:
-                    logger.info(f"目录 {fileitem.path} 已有NFO文件，开始增量刮削...")
-                    for file_path in file_list:
-                        file_item = storagechain.get_file_item(storage=fileitem.storage,
-                                                               path=Path(file_path))
-                        if file_item:
-                            # 对于电视剧文件，应该保存到与视频文件相同的目录
-                            # 而不是电视剧根目录
-                            self.scrape_metadata(fileitem=file_item,
-                                                 mediainfo=mediainfo,
-                                                 init_folder=False,
-                                                 parent=None,  # 让函数内部自动获取正确的父目录
-                                                 overwrite=overwrite)
+                if file_list:
+                    # 如果是BDMV原盘目录，只对根目录进行刮削，不处理子目录
+                    if self.is_bluray_folder(fileitem):
+                        logger.info(f"检测到BDMV原盘目录，只对根目录进行刮削：{fileitem.path}")
+                        self.scrape_metadata(fileitem=fileitem,
+                                             mediainfo=mediainfo,
+                                             init_folder=True,
+                                             recursive=False,
+                                             overwrite=overwrite)
+                    else:
+                        # 1. 收集fileitem和file_list中每个文件之间所有子目录
+                        all_dirs = set()
+                        root_path = Path(fileitem.path)
+
+                        logger.debug(f"开始收集目录，根目录：{root_path}")
+                        # 收集根目录
+                        all_dirs.add(root_path)
+
+                        # 收集所有目录（包括所有层级）
+                        for sub_file in file_list:
+                            sub_path = Path(sub_file)
+                            # 收集从根目录到文件的所有父目录
+                            current_path = sub_path.parent
+                            while current_path != root_path and current_path.is_relative_to(root_path):
+                                all_dirs.add(current_path)
+                                current_path = current_path.parent
+
+                        logger.debug(f"共收集到 {len(all_dirs)} 个目录")
+
+                        # 2. 初始化一遍子目录，但不处理文件
+                        for sub_dir in all_dirs:
+                            sub_dir_item = storagechain.get_file_item(storage=fileitem.storage, path=sub_dir)
+                            if sub_dir_item:
+                                logger.info(f"为目录生成海报和nfo：{sub_dir}")
+                                # 初始化目录元数据，但不处理文件
+                                self.scrape_metadata(fileitem=sub_dir_item,
+                                                     mediainfo=mediainfo,
+                                                     init_folder=True,
+                                                     recursive=False,
+                                                     overwrite=overwrite)
+                            else:
+                                logger.warn(f"无法获取目录项：{sub_dir}")
+
+                        # 3. 刮削每个文件
+                        logger.info(f"开始刮削 {len(file_list)} 个文件")
+                        for sub_file_path in file_list:
+                            sub_file_item = storagechain.get_file_item(storage=fileitem.storage,
+                                                                       path=Path(sub_file_path))
+                            if sub_file_item:
+                                self.scrape_metadata(fileitem=sub_file_item,
+                                                     mediainfo=mediainfo,
+                                                     init_folder=False,
+                                                     overwrite=overwrite)
+                            else:
+                                logger.warn(f"无法获取文件项：{sub_file_path}")
                 else:
                     # 执行全量刮削
-                    logger.info(f"开始全量刮削目录 {fileitem.path} ...")
+                    logger.info(f"开始刮削目录 {fileitem.path} ...")
                     self.scrape_metadata(fileitem=fileitem, meta=meta, init_folder=True,
                                          mediainfo=mediainfo, overwrite=overwrite)
 
     def scrape_metadata(self, fileitem: schemas.FileItem,
                         meta: MetaBase = None, mediainfo: MediaInfo = None,
                         init_folder: bool = True, parent: schemas.FileItem = None,
-                        overwrite: bool = False):
+                        overwrite: bool = False, recursive: bool = True):
         """
         手动刮削媒体信息
         :param fileitem: 刮削目录或文件
@@ -375,24 +436,11 @@ class MediaChain(ChainBase):
         :param init_folder: 是否刮削根目录
         :param parent: 上级目录
         :param overwrite: 是否覆盖已有文件
+        :param recursive: 是否递归处理目录内文件
         """
 
         storagechain = StorageChain()
 
-        def is_bluray_folder(_fileitem: schemas.FileItem) -> bool:
-            """
-            判断是否为原盘目录
-            """
-            if not _fileitem or _fileitem.type != "dir":
-                return False
-            # 蓝光原盘目录必备的文件或文件夹
-            required_files = ['BDMV', 'CERTIFICATE']
-            # 检查目录下是否存在所需文件或文件夹
-            for item in storagechain.list_files(_fileitem):
-                if item.name in required_files:
-                    return True
-            return False
-
         def __list_files(_fileitem: schemas.FileItem):
             """
             列出下级文件
@@ -481,31 +529,36 @@ class MediaChain(ChainBase):
                     logger.info("电影NFO刮削已关闭，跳过")
             else:
                 # 电影目录
-                if is_bluray_folder(fileitem):
-                    # 原盘目录
-                    if scraping_switchs.get('movie_nfo', True):
-                        nfo_path = filepath / (filepath.name + ".nfo")
-                        if overwrite or not storagechain.get_file_item(storage=fileitem.storage, path=nfo_path):
-                            # 生成原盘nfo
-                            movie_nfo = self.metadata_nfo(meta=meta, mediainfo=mediainfo)
-                            if movie_nfo:
-                                # 保存或上传nfo文件到当前目录
-                                __save_file(_fileitem=fileitem, _path=nfo_path, _content=movie_nfo)
+                if recursive:
+                    # 处理文件
+                    if self.is_bluray_folder(fileitem):
+                        # 原盘目录
+                        if scraping_switchs.get('movie_nfo', True):
+                            nfo_path = filepath / (filepath.name + ".nfo")
+                            if overwrite or not storagechain.get_file_item(storage=fileitem.storage, path=nfo_path):
+                                # 生成原盘nfo
+                                movie_nfo = self.metadata_nfo(meta=meta, mediainfo=mediainfo)
+                                if movie_nfo:
+                                    # 保存或上传nfo文件到当前目录
+                                    __save_file(_fileitem=fileitem, _path=nfo_path, _content=movie_nfo)
+                                else:
+                                    logger.warn(f"{filepath.name} nfo文件生成失败！")
                             else:
-                                logger.warn(f"{filepath.name} nfo文件生成失败！")
+                                logger.info(f"已存在nfo文件：{nfo_path}")
                         else:
-                            logger.info(f"已存在nfo文件：{nfo_path}")
+                            logger.info("电影NFO刮削已关闭，跳过")
                     else:
-                        logger.info("电影NFO刮削已关闭，跳过")
-                else:
-                    # 处理目录内的文件
-                    files = __list_files(_fileitem=fileitem)
-                    for file in files:
-                        self.scrape_metadata(fileitem=file,
-                                             mediainfo=mediainfo,
-                                             init_folder=False,
-                                             parent=fileitem,
-                                             overwrite=overwrite)
+                        # 处理目录内的文件
+                        files = __list_files(_fileitem=fileitem)
+                        for file in files:
+                            if file.type == "dir":
+                                # 电影不处理子目录
+                                continue
+                            self.scrape_metadata(fileitem=file,
+                                                 mediainfo=mediainfo,
+                                                 init_folder=False,
+                                                 parent=fileitem,
+                                                 overwrite=overwrite)
                 # 生成目录内图片文件
                 if init_folder:
                     # 图片
@@ -597,13 +650,17 @@ class MediaChain(ChainBase):
                     logger.info("集缩略图刮削已关闭，跳过")
             else:
                 # 当前为电视剧目录，处理目录内的文件
-                files = __list_files(_fileitem=fileitem)
-                for file in files:
-                    self.scrape_metadata(fileitem=file,
-                                         mediainfo=mediainfo,
-                                         parent=fileitem if file.type == "file" else None,
-                                         init_folder=True if file.type == "dir" else False,
-                                         overwrite=overwrite)
+                if recursive:
+                    files = __list_files(_fileitem=fileitem)
+                    for file in files:
+                        if file.type == "dir" and not file.name.lower().startswith("season"):
+                            # 电视剧不处理非季子目录
+                            continue
+                        self.scrape_metadata(fileitem=file,
+                                             mediainfo=mediainfo,
+                                             parent=fileitem if file.type == "file" else None,
+                                             init_folder=True if file.type == "dir" else False,
+                                             overwrite=overwrite)
                 # 生成目录的nfo和图片
                 if init_folder:
                     # 识别文件夹名称

app/chain/recommend.py

@@ -1,48 +1,142 @@
-import asyncio
 import io
+from pathlib import Path
 from typing import List, Optional
 
-import aiofiles
 import pillow_avif  # noqa 用于自动注册AVIF支持
 from PIL import Image
-from aiopath import AsyncPath
 
 from app.chain import ChainBase
 from app.chain.bangumi import BangumiChain
 from app.chain.douban import DoubanChain
 from app.chain.tmdb import TmdbChain
-from app.core.cache import cache_backend, cached
+from app.core.cache import cached, FileCache
 from app.core.config import settings, global_vars
 from app.log import logger
 from app.schemas import MediaType
-from app.utils.asyncio import AsyncUtils
 from app.utils.common import log_execution_time
-from app.utils.http import AsyncRequestUtils
+from app.utils.http import RequestUtils
 from app.utils.security import SecurityUtils
 from app.utils.singleton import Singleton
 
-# 推荐相关的专用缓存
-recommend_ttl = 24 * 3600
-recommend_cache_region = "recommend"
-
 
 class RecommendChain(ChainBase, metaclass=Singleton):
     """
     推荐处理链，单例运行
     """
 
-    # 推荐数据的缓存页数
+    # 推荐缓存时间
+    recommend_ttl = 24 * 3600
+    # 推荐缓存页数
     cache_max_pages = 5
+    # 推荐缓存区域
+    recommend_cache_region = "recommend"
 
     def refresh_recommend(self):
         """
-        刷新推荐数据 - 同步包装器
+        刷新推荐
         """
+        logger.debug("Starting to refresh Recommend data.")
+
+        # 推荐来源方法
+        recommend_methods = [
+            self.tmdb_movies,
+            self.tmdb_tvs,
+            self.tmdb_trending,
+            self.bangumi_calendar,
+            self.douban_movie_showing,
+            self.douban_movies,
+            self.douban_tvs,
+            self.douban_movie_top250,
+            self.douban_tv_weekly_chinese,
+            self.douban_tv_weekly_global,
+            self.douban_tv_animation,
+            self.douban_movie_hot,
+            self.douban_tv_hot,
+        ]
+
+        # 缓存并刷新所有推荐数据
+        recommends = []
+        # 记录哪些方法已完成
+        methods_finished = set()
+        # 这里避免区间内连续调用相同来源，因此遍历方案为每页遍历所有推荐来源，再进行页数遍历
+        for page in range(1, self.cache_max_pages + 1):
+            for method in recommend_methods:
+                if global_vars.is_system_stopped:
+                    return
+                if method in methods_finished:
+                    continue
+                logger.debug(f"Fetch {method.__name__} data for page {page}.")
+                data = method(page=page)
+                if not data:
+                    logger.debug("All recommendation methods have finished fetching data. Ending pagination early.")
+                    methods_finished.add(method)
+                    continue
+                recommends.extend(data)
+            # 如果所有方法都已经完成，提前结束循环
+            if len(methods_finished) == len(recommend_methods):
+                break
+
+        # 缓存收集到的海报
+        self.__cache_posters(recommends)
+        logger.debug("Recommend data refresh completed.")
+
+    def __cache_posters(self, datas: List[dict]):
+        """
+        提取 poster_path 并缓存图片
+        :param datas: 数据列表
+        """
+        if not settings.GLOBAL_IMAGE_CACHE:
+            return
+
+        for data in datas:
+            if global_vars.is_system_stopped:
+                return
+            poster_path = data.get("poster_path")
+            if poster_path:
+                poster_url = poster_path.replace("original", "w500")
+                logger.debug(f"Caching poster image: {poster_url}")
+                self.__fetch_and_save_image(poster_url)
+
+    @staticmethod
+    def __fetch_and_save_image(url: str):
+        """
+        请求并保存图片
+        :param url: 图片路径
+        """
+        # 生成缓存路径
+        sanitized_path = SecurityUtils.sanitize_url_path(url)
+        cache_path = Path("images") / sanitized_path
+        # 没有文件类型，则添加后缀，在恶意文件类型和实际需求下的折衷选择
+        if not cache_path.suffix:
+            cache_path = cache_path.with_suffix(".jpg")
+
+        # 获取缓存后端，并设置缓存时间为全局配置的缓存天数
+        cache_backend = FileCache(base=settings.CACHE_PATH,
+                                  ttl=settings.GLOBAL_IMAGE_CACHE_DAYS * 24 * 3600)
+
+        # 本地存在缓存图片，则直接跳过
+        if cache_backend.get(cache_path.as_posix(), region="images"):
+            logger.debug(f"Cache hit: Image already exists at {cache_path}")
+            return
+
+        # 请求远程图片
+        referer = "https://movie.douban.com/" if "doubanio.com" in url else None
+        proxies = settings.PROXY if not referer else None
+        response = RequestUtils(ua=settings.NORMAL_USER_AGENT, proxies=proxies, referer=referer).get_res(url=url)
+        if not response:
+            logger.debug(f"Empty response for URL: {url}")
+            return
+
+        # 验证下载的内容是否为有效图片
         try:
-            AsyncUtils.run_async(self.async_refresh_recommend())
+            Image.open(io.BytesIO(response.content)).verify()
         except Exception as e:
-            logger.error(f"刷新推荐数据失败：{str(e)}")
-            raise
+            logger.debug(f"Invalid image format for URL {url}: {e}")
+            return
+
+        # 保存缓存
+        cache_backend.set(cache_path.as_posix(), response.content, region="images")
+        logger.debug(f"Successfully cached image at {cache_path} for URL: {url}")
 
     @log_execution_time(logger=logger)
     @cached(ttl=recommend_ttl, region=recommend_cache_region)
@@ -199,162 +293,6 @@ class RecommendChain(ChainBase, metaclass=Singleton):
         tvs = DoubanChain().tv_hot(page=page, count=count)
         return [media.to_dict() for media in tvs] if tvs else []
 
-    # 异步版本的方法
-    async def async_refresh_recommend(self):
-        """
-        异步刷新推荐
-        """
-        logger.debug("Starting to async refresh Recommend data.")
-        cache_backend.clear(region=recommend_cache_region)
-        logger.debug("Recommend Cache has been cleared.")
-
-        # 推荐来源方法
-        recommend_methods = [
-            self.async_tmdb_movies,
-            self.async_tmdb_tvs,
-            self.async_tmdb_trending,
-            self.async_bangumi_calendar,
-            self.async_douban_movie_showing,
-            self.async_douban_movies,
-            self.async_douban_tvs,
-            self.async_douban_movie_top250,
-            self.async_douban_tv_weekly_chinese,
-            self.async_douban_tv_weekly_global,
-            self.async_douban_tv_animation,
-            self.async_douban_movie_hot,
-            self.async_douban_tv_hot,
-        ]
-
-        # 缓存并刷新所有推荐数据
-        recommends = []
-        # 记录哪些方法已完成
-        methods_finished = set()
-        # 这里避免区间内连续调用相同来源，因此遍历方案为每页遍历所有推荐来源，再进行页数遍历
-        for page in range(1, self.cache_max_pages + 1):
-            # 为每个页面并发执行所有方法
-            tasks = []
-            for method in recommend_methods:
-                if global_vars.is_system_stopped:
-                    return
-                if method in methods_finished:
-                    continue
-                tasks.append(self._async_fetch_method_data(method, page, methods_finished))
-
-            # 并发执行所有任务
-            if tasks:
-                results = await asyncio.gather(*tasks, return_exceptions=True)
-                for result in results:
-                    if isinstance(result, list) and result:
-                        recommends.extend(result)
-
-            # 如果所有方法都已经完成，提前结束循环
-            if len(methods_finished) == len(recommend_methods):
-                break
-
-        # 缓存收集到的海报
-        await self.__async_cache_posters(recommends)
-        logger.debug("Async recommend data refresh completed.")
-
-    @staticmethod
-    async def _async_fetch_method_data(method, page: int, methods_finished: set):
-        """
-        异步获取方法数据的辅助函数
-        """
-        try:
-            logger.debug(f"Async fetch {method.__name__} data for page {page}.")
-            data = await method(page=page)
-            if not data:
-                logger.debug(f"Method {method.__name__} finished fetching data. Ending pagination early.")
-                methods_finished.add(method)
-                return []
-            return data
-        except Exception as e:
-            logger.error(f"Error fetching data from {method.__name__}: {e}")
-            methods_finished.add(method)
-            return []
-
-    async def __async_cache_posters(self, datas: List[dict]):
-        """
-        异步提取 poster_path 并缓存图片
-        :param datas: 数据列表
-        """
-        if not settings.GLOBAL_IMAGE_CACHE:
-            return
-
-        tasks = []
-        for data in datas:
-            if global_vars.is_system_stopped:
-                return
-            poster_path = data.get("poster_path")
-            if poster_path:
-                poster_url = poster_path.replace("original", "w500")
-                logger.debug(f"Async caching poster image: {poster_url}")
-                tasks.append(self.__async_fetch_and_save_image(poster_url))
-
-        # 并发缓存图片
-        if tasks:
-            await asyncio.gather(*tasks, return_exceptions=True)
-
-    @staticmethod
-    async def __async_fetch_and_save_image(url: str):
-        """
-        异步请求并保存图片
-        :param url: 图片路径
-        """
-        if not settings.GLOBAL_IMAGE_CACHE or not url:
-            return
-
-        # 生成缓存路径
-        base_path = AsyncPath(settings.CACHE_PATH)
-        sanitized_path = SecurityUtils.sanitize_url_path(url)
-        cache_path = base_path / "images" / sanitized_path
-
-        # 没有文件类型，则添加后缀，在恶意文件类型和实际需求下的折衷选择
-        if not cache_path.suffix:
-            cache_path = cache_path.with_suffix(".jpg")
-
-        # 确保缓存路径和文件类型合法
-        if not await SecurityUtils.async_is_safe_path(base_path=base_path,
-                                                      user_path=cache_path,
-                                                      allowed_suffixes=settings.SECURITY_IMAGE_SUFFIXES):
-            logger.debug(f"Invalid cache path or file type for URL: {url}, sanitized path: {sanitized_path}")
-            return
-
-        # 本地存在缓存图片，则直接跳过
-        if await cache_path.exists():
-            logger.debug(f"Cache hit: Image already exists at {cache_path}")
-            return
-
-        # 请求远程图片
-        referer = "https://movie.douban.com/" if "doubanio.com" in url else None
-        proxies = settings.PROXY if not referer else None
-        response = await AsyncRequestUtils(ua=settings.NORMAL_USER_AGENT,
-                                           proxies=proxies, referer=referer).get_res(url=url)
-        if not response:
-            logger.debug(f"Empty response for URL: {url}")
-            return
-
-        # 验证下载的内容是否为有效图片
-        try:
-            Image.open(io.BytesIO(response.content)).verify()
-        except Exception as e:
-            logger.debug(f"Invalid image format for URL {url}: {e}")
-            return
-
-        if not cache_path:
-            return
-
-        try:
-            if not await cache_path.parent.exists():
-                await cache_path.parent.mkdir(parents=True, exist_ok=True)
-            async with aiofiles.tempfile.NamedTemporaryFile(dir=cache_path.parent, delete=False) as tmp_file:
-                await tmp_file.write(response.content)
-                temp_path = AsyncPath(tmp_file.name)
-            await temp_path.replace(cache_path)
-            logger.debug(f"Successfully cached image at {cache_path} for URL: {url}")
-        except Exception as e:
-            logger.debug(f"Failed to write cache file {cache_path} for URL {url}: {e}")
-
     @log_execution_time(logger=logger)
     @cached(ttl=recommend_ttl, region=recommend_cache_region)
     async def async_tmdb_movies(self, sort_by: Optional[str] = "popularity.desc",

app/chain/search.py

@@ -1,8 +1,6 @@
 import asyncio
-import pickle
 import random
 import time
-import traceback
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from datetime import datetime
 from typing import Dict, Tuple
@@ -59,7 +57,7 @@ class SearchChain(ChainBase):
         results = self.process(mediainfo=mediainfo, sites=sites, area=area, no_exists=no_exists)
         # 保存到本地文件
         if cache_local:
-            self.save_cache(pickle.dumps(results), self.__result_temp_file)
+            self.save_cache(results, self.__result_temp_file)
         return results
 
     def search_by_title(self, title: str, page: Optional[int] = 0,
@@ -85,36 +83,20 @@ class SearchChain(ChainBase):
                             torrent_info=torrent) for torrent in torrents]
         # 保存到本地文件
         if cache_local:
-            self.save_cache(pickle.dumps(contexts), self.__result_temp_file)
+            self.save_cache(contexts, self.__result_temp_file)
         return contexts
 
     def last_search_results(self) -> List[Context]:
         """
         获取上次搜索结果
         """
-        # 读取本地文件缓存
-        content = self.load_cache(self.__result_temp_file)
-        if not content:
-            return []
-        try:
-            return pickle.loads(content)
-        except Exception as e:
-            logger.error(f'加载搜索结果失败：{str(e)} - {traceback.format_exc()}')
-            return []
+        return self.load_cache(self.__result_temp_file)
 
     async def async_last_search_results(self) -> List[Context]:
         """
         异步获取上次搜索结果
         """
-        # 读取本地文件缓存
-        content = await self.async_load_cache(self.__result_temp_file)
-        if not content:
-            return []
-        try:
-            return pickle.loads(content)
-        except Exception as e:
-            logger.error(f'加载搜索结果失败：{str(e)} - {traceback.format_exc()}')
-            return []
+        return await self.async_load_cache(self.__result_temp_file)
 
     async def async_search_by_id(self, tmdbid: Optional[int] = None, doubanid: Optional[str] = None,
                                  mtype: MediaType = None, area: Optional[str] = "title", season: Optional[int] = None,
@@ -143,7 +125,7 @@ class SearchChain(ChainBase):
         results = await self.async_process(mediainfo=mediainfo, sites=sites, area=area, no_exists=no_exists)
         # 保存到本地文件
         if cache_local:
-            await self.async_save_cache(pickle.dumps(results), self.__result_temp_file)
+            await self.async_save_cache(results, self.__result_temp_file)
         return results
 
     async def async_search_by_title(self, title: str, page: Optional[int] = 0,
@@ -169,7 +151,7 @@ class SearchChain(ChainBase):
                             torrent_info=torrent) for torrent in torrents]
         # 保存到本地文件
         if cache_local:
-            await self.async_save_cache(pickle.dumps(contexts), self.__result_temp_file)
+            await self.async_save_cache(contexts, self.__result_temp_file)
         return contexts
 
     @staticmethod
@@ -233,12 +215,11 @@ class SearchChain(ChainBase):
             return []
 
         # 开始新进度
-        progress = ProgressHelper()
-        progress.start(ProgressKey.Search)
+        progress = ProgressHelper(ProgressKey.Search)
+        progress.start()
 
         # 开始过滤
-        progress.update(value=0, text=f'开始过滤，总 {len(torrents)} 个资源，请稍候...',
-                        key=ProgressKey.Search)
+        progress.update(value=0, text=f'开始过滤，总 {len(torrents)} 个资源，请稍候...')
         # 匹配订阅附加参数
         if filter_params:
             logger.info(f'开始附加参数过滤，附加参数：{filter_params} ...')
@@ -256,7 +237,7 @@ class SearchChain(ChainBase):
             logger.info(f"过滤规则/剧集过滤完成，剩余 {len(torrents)} 个资源")
 
         # 过滤完成
-        progress.update(value=50, text=f'过滤完成，剩余 {len(torrents)} 个资源', key=ProgressKey.Search)
+        progress.update(value=50, text=f'过滤完成，剩余 {len(torrents)} 个资源')
 
         # 总数
         _total = len(torrents)
@@ -269,14 +250,13 @@ class SearchChain(ChainBase):
         try:
             # 英文标题应该在别名/原标题中，不需要再匹配
             logger.info(f"开始匹配结果 标题：{mediainfo.title}，原标题：{mediainfo.original_title}，别名：{mediainfo.names}")
-            progress.update(value=51, text=f'开始匹配，总 {_total} 个资源 ...', key=ProgressKey.Search)
+            progress.update(value=51, text=f'开始匹配，总 {_total} 个资源 ...')
             for torrent in torrents:
                 if global_vars.is_system_stopped:
                     break
                 _count += 1
                 progress.update(value=(_count / _total) * 96,
-                                text=f'正在匹配 {torrent.site_name}，已完成 {_count} / {_total} ...',
-                                key=ProgressKey.Search)
+                                text=f'正在匹配 {torrent.site_name}，已完成 {_count} / {_total} ...')
                 if not torrent.title:
                     continue
 
@@ -309,8 +289,7 @@ class SearchChain(ChainBase):
             # 匹配完成
             logger.info(f"匹配完成，共匹配到 {len(_match_torrents)} 个资源")
             progress.update(value=97,
-                            text=f'匹配完成，共匹配到 {len(_match_torrents)} 个资源',
-                            key=ProgressKey.Search)
+                            text=f'匹配完成，共匹配到 {len(_match_torrents)} 个资源')
 
             # 去掉mediainfo中多余的数据
             mediainfo.clear()
@@ -326,16 +305,14 @@ class SearchChain(ChainBase):
 
         # 排序
         progress.update(value=99,
-                        text=f'正在对 {len(contexts)} 个资源进行排序，请稍候...',
-                        key=ProgressKey.Search)
+                        text=f'正在对 {len(contexts)} 个资源进行排序，请稍候...')
         contexts = torrenthelper.sort_torrents(contexts)
 
         # 结束进度
         logger.info(f'搜索完成，共 {len(contexts)} 个资源')
         progress.update(value=100,
-                        text=f'搜索完成，共 {len(contexts)} 个资源',
-                        key=ProgressKey.Search)
-        progress.end(ProgressKey.Search)
+                        text=f'搜索完成，共 {len(contexts)} 个资源')
+        progress.end()
 
         # 去重后返回
         return self.__remove_duplicate(contexts)
@@ -539,8 +516,8 @@ class SearchChain(ChainBase):
             return []
 
         # 开始进度
-        progress = ProgressHelper()
-        progress.start(ProgressKey.Search)
+        progress = ProgressHelper(ProgressKey.Search)
+        progress.start()
         # 开始计时
         start_time = datetime.now()
         # 总数
@@ -549,8 +526,7 @@ class SearchChain(ChainBase):
         finish_count = 0
         # 更新进度
         progress.update(value=0,
-                        text=f"开始搜索，共 {total_num} 个站点 ...",
-                        key=ProgressKey.Search)
+                        text=f"开始搜索，共 {total_num} 个站点 ...")
         # 结果集
         results = []
         # 多线程
@@ -579,17 +555,15 @@ class SearchChain(ChainBase):
                     results.extend(result)
                 logger.info(f"站点搜索进度：{finish_count} / {total_num}")
                 progress.update(value=finish_count / total_num * 100,
-                                text=f"正在搜索{keyword or ''}，已完成 {finish_count} / {total_num} 个站点 ...",
-                                key=ProgressKey.Search)
+                                text=f"正在搜索{keyword or ''}，已完成 {finish_count} / {total_num} 个站点 ...")
         # 计算耗时
         end_time = datetime.now()
         # 更新进度
         progress.update(value=100,
-                        text=f"站点搜索完成，有效资源数：{len(results)}，总耗时 {(end_time - start_time).seconds} 秒",
-                        key=ProgressKey.Search)
+                        text=f"站点搜索完成，有效资源数：{len(results)}，总耗时 {(end_time - start_time).seconds} 秒")
         logger.info(f"站点搜索完成，有效资源数：{len(results)}，总耗时 {(end_time - start_time).seconds} 秒")
         # 结束进度
-        progress.end(ProgressKey.Search)
+        progress.end()
 
         # 返回
         return results
@@ -624,8 +598,8 @@ class SearchChain(ChainBase):
             return []
 
         # 开始进度
-        progress = ProgressHelper()
-        progress.start(ProgressKey.Search)
+        progress = ProgressHelper(ProgressKey.Search)
+        progress.start()
         # 开始计时
         start_time = datetime.now()
         # 总数
@@ -634,8 +608,7 @@ class SearchChain(ChainBase):
         finish_count = 0
         # 更新进度
         progress.update(value=0,
-                        text=f"开始搜索，共 {total_num} 个站点 ...",
-                        key=ProgressKey.Search)
+                        text=f"开始搜索，共 {total_num} 个站点 ...")
         # 结果集
         results = []
 
@@ -666,18 +639,16 @@ class SearchChain(ChainBase):
                 results.extend(result)
             logger.info(f"站点搜索进度：{finish_count} / {total_num}")
             progress.update(value=finish_count / total_num * 100,
-                            text=f"正在搜索{keyword or ''}，已完成 {finish_count} / {total_num} 个站点 ...",
-                            key=ProgressKey.Search)
+                            text=f"正在搜索{keyword or ''}，已完成 {finish_count} / {total_num} 个站点 ...")
 
         # 计算耗时
         end_time = datetime.now()
         # 更新进度
         progress.update(value=100,
-                        text=f"站点搜索完成，有效资源数：{len(results)}，总耗时 {(end_time - start_time).seconds} 秒",
-                        key=ProgressKey.Search)
+                        text=f"站点搜索完成，有效资源数：{len(results)}，总耗时 {(end_time - start_time).seconds} 秒")
         logger.info(f"站点搜索完成，有效资源数：{len(results)}，总耗时 {(end_time - start_time).seconds} 秒")
         # 结束进度
-        progress.end(ProgressKey.Search)
+        progress.end()
 
         # 返回
         return results

app/chain/site.py

@@ -313,11 +313,16 @@ class SiteChain(ChainBase):
         siteoper = SiteOper()
         rsshelper = RssHelper()
         for domain, cookie in cookies.items():
+            # 检查系统是否停止
+            if global_vars.is_system_stopped:
+                logger.info("系统正在停止，中断CookieCloud同步")
+                return False, "系统正在停止，同步被中断"
+                
             # 索引器信息
             indexer = siteshelper.get_indexer(domain)
             # 数据库的站点信息
             site_info = siteoper.get_by_domain(domain)
-            if site_info and site_info.is_active == 1:
+            if site_info and site_info.is_active:
                 # 站点已存在，检查站点连通性
                 status, msg = self.test(domain)
                 # 更新站点Cookie
@@ -330,7 +335,8 @@ class SiteChain(ChainBase):
                             url=site_info.url,
                             cookie=cookie,
                             ua=site_info.ua or settings.USER_AGENT,
-                            proxy=True if site_info.proxy else False
+                            proxy=True if site_info.proxy else False,
+                            timeout=site_info.timeout or 15
                         )
                         if rss_url:
                             logger.info(f"更新站点 {domain} RSS地址 ...")
@@ -558,13 +564,15 @@ class SiteChain(ChainBase):
         public = site_info.public
         proxies = settings.PROXY if site_info.proxy else None
         proxy_server = settings.PROXY_SERVER if site_info.proxy else None
+        timeout = site_info.timeout or 60
 
         # 访问链接
         if render:
             page_source = PlaywrightHelper().get_page_source(url=site_url,
                                                              cookies=site_cookie,
                                                              ua=ua,
-                                                             proxies=proxy_server)
+                                                             proxies=proxy_server,
+                                                             timeout=timeout)
             if not public and not SiteUtils.is_logged_in(page_source):
                 if under_challenge(page_source):
                     return False, f"无法通过Cloudflare！"
@@ -697,7 +705,8 @@ class SiteChain(ChainBase):
             username=username,
             password=password,
             two_step_code=two_step_code,
-            proxies=settings.PROXY_HOST if site_info.proxy else None
+            proxies=settings.PROXY_SERVER if site_info.proxy else None,
+            timeout=site_info.timeout or 60
         )
         if result:
             cookie, ua, msg = result

app/chain/storage.py

@@ -6,7 +6,6 @@ from app.chain import ChainBase
 from app.core.config import settings
 from app.helper.directory import DirectoryHelper
 from app.log import logger
-from app.schemas import MediaType
 
 
 class StorageChain(ChainBase):
@@ -134,8 +133,7 @@ class StorageChain(ChainBase):
         """
         return self.run_module("support_transtype", storage=storage)
 
-    def delete_media_file(self, fileitem: schemas.FileItem,
-                          mtype: MediaType = None, delete_self: bool = True) -> bool:
+    def delete_media_file(self, fileitem: schemas.FileItem, delete_self: bool = True) -> bool:
         """
         删除媒体文件，以及不含媒体文件的目录
         """
@@ -152,7 +150,8 @@ class StorageChain(ChainBase):
             return False
 
         media_exts = settings.RMT_MEDIAEXT + settings.DOWNLOAD_TMPEXT
-        if fileitem.path == "/" or len(Path(fileitem.path).parts) <= 2:
+        fileitem_path = Path(fileitem.path) if fileitem.path else Path("")
+        if len(fileitem_path.parts) <= 2:
             logger.warn(f"【{fileitem.storage}】{fileitem.path} 根目录或一级目录不允许删除")
             return False
         if fileitem.type == "dir":
@@ -162,13 +161,7 @@ class StorageChain(ChainBase):
                 if not self.delete_file(fileitem):
                     logger.warn(f"【{fileitem.storage}】{fileitem.path} 删除失败")
                     return False
-            elif self.any_files(fileitem, extensions=media_exts) is False:
-                logger.warn(f"【{fileitem.storage}】{fileitem.path} 不存在其它媒体文件，正在删除空目录")
-                if not self.delete_file(fileitem):
-                    logger.warn(f"【{fileitem.storage}】{fileitem.path} 删除失败")
-                    return False
-            # 不处理父目录
-            return True
+
         elif delete_self:
             # 本身是文件，需要删除文件
             logger.warn(f"正在删除文件【{fileitem.storage}】{fileitem.path}")
@@ -176,35 +169,43 @@ class StorageChain(ChainBase):
                 logger.warn(f"【{fileitem.storage}】{fileitem.path} 删除失败")
                 return False
 
-        if mtype:
-            # 重命名格式
-            rename_format = settings.RENAME_FORMAT(mtype)
-            media_path = DirectoryHelper.get_media_root_path(
-                rename_format, rename_path=Path(fileitem.path)
-            )
-            if not media_path:
-                return True
-            # 处理媒体文件根目录
-            dir_item = self.get_file_item(storage=fileitem.storage, path=media_path)
-        else:
-            # 处理上级目录
-            dir_item = self.get_parent_item(fileitem)
+        # 检查和删除上级空目录
+        dir_item = fileitem if fileitem.type == "dir" else self.get_parent_item(fileitem)
+        if not dir_item:
+            logger.warn(f"【{fileitem.storage}】{fileitem.path} 上级目录不存在")
+            return False
 
-        # 检查和删除上级目录
-        if dir_item and len(Path(dir_item.path).parts) > 2:
-            # 如何目录是所有下载目录、媒体库目录的上级，则不处理
-            for d in DirectoryHelper().get_dirs():
-                if d.download_path and Path(d.download_path).is_relative_to(Path(dir_item.path)):
-                    logger.debug(f"【{dir_item.storage}】{dir_item.path} 是下载目录本级或上级目录，不删除")
-                    return True
-                if d.library_path and Path(d.library_path).is_relative_to(Path(dir_item.path)):
-                    logger.debug(f"【{dir_item.storage}】{dir_item.path} 是媒体库目录本级或上级目录，不删除")
-                    return True
-            # 不存在其他媒体文件，删除空目录
-            if self.any_files(dir_item, extensions=media_exts) is False:
-                logger.warn(f"【{dir_item.storage}】{dir_item.path} 不存在其它媒体文件，正在删除空目录")
-                if not self.delete_file(dir_item):
-                    logger.warn(f"【{dir_item.storage}】{dir_item.path} 删除失败")
-                    return False
+        # 查找操作文件项匹配的配置目录(资源目录、媒体库目录)
+        associated_dir = max(
+            (
+                Path(p)
+                for d in DirectoryHelper().get_dirs()
+                for p in (d.download_path, d.library_path)
+                if p and fileitem_path.is_relative_to(p)
+            ),
+            key=lambda path: len(path.parts),
+            default=None,
+        )
+
+        while dir_item and len(Path(dir_item.path).parts) > 2:
+            # 目录是资源目录、媒体库目录的上级，则不处理
+            if associated_dir and associated_dir.is_relative_to(Path(dir_item.path)):
+                logger.debug(f"【{dir_item.storage}】{dir_item.path} 位于资源或媒体库目录结构中，不删除")
+                break
+
+            elif not associated_dir and self.list_files(dir_item, recursion=False):
+                logger.debug(f"【{dir_item.storage}】{dir_item.path} 不是空目录，不删除")
+                break
+
+            if self.any_files(dir_item, extensions=media_exts) is not False:
+                logger.debug(f"【{dir_item.storage}】{dir_item.path} 存在媒体文件，不删除")
+                break
+
+            # 删除空目录并继续处理父目录
+            logger.warn(f"【{dir_item.storage}】{dir_item.path} 不存在其它媒体文件，正在删除空目录")
+            if not self.delete_file(dir_item):
+                logger.warn(f"【{dir_item.storage}】{dir_item.path} 删除失败")
+                return False
+            dir_item = self.get_parent_item(dir_item)
 
         return True

app/chain/subscribe.py

@@ -1184,6 +1184,42 @@ class SubscribeChain(ChainBase):
                     logger.error(f'follow用户分享订阅 {title} 添加失败：{message}')
         logger.info(f'follow用户分享订阅刷新完成，共添加 {success_count} 个订阅')
 
+    async def cache_calendar(self):
+        """
+        预缓存订阅日历，实际上就是查询一遍所有订阅的媒体信息
+        前端请示是异常的，所以需要使用异步缓存方法
+        """
+        logger.info(f'开始预缓存订阅日历 ...')
+        for subscribe in await SubscribeOper().async_list():
+            if global_vars.is_system_stopped:
+                break
+            try:
+                mtype = MediaType(subscribe.type)
+            except ValueError:
+                logger.error(f'订阅 {subscribe.name} 类型错误：{subscribe.type}')
+                continue
+            # 识别媒体信息
+            if mtype == MediaType.MOVIE:
+                mediainfo: MediaInfo = await self.async_recognize_media(mtype=mtype,
+                                                                        tmdbid=subscribe.tmdbid,
+                                                                        doubanid=subscribe.doubanid,
+                                                                        bangumiid=subscribe.bangumiid,
+                                                                        episode_group=subscribe.episode_group,
+                                                                        cache=False)
+                if not mediainfo:
+                    logger.warn(
+                        f'未识别到媒体信息，标题：{subscribe.name}，tmdbid：{subscribe.tmdbid}，doubanid：{subscribe.doubanid}')
+                    continue
+            else:
+                episodes = await TmdbChain().async_tmdb_episodes(tmdbid=subscribe.tmdbid,
+                                                                 season=subscribe.season,
+                                                                 episode_group=subscribe.episode_group)
+                if not episodes:
+                    logger.warn(
+                        f'未识别到季集信息，标题：{subscribe.name}，tmdbid：{subscribe.tmdbid}，豆瓣ID：{subscribe.doubanid}，季：{subscribe.season}')
+                    continue
+        logger.info(f'订阅日历预缓存完成')
+
     @staticmethod
     def __update_subscribe_note(subscribe: Subscribe, downloads: Optional[List[Context]]):
         """

app/chain/torrents.py

@@ -340,7 +340,8 @@ class TorrentsChain(ChainBase):
                 url=site.get("url"),
                 cookie=site.get("cookie"),
                 ua=site.get("ua") or settings.USER_AGENT,
-                proxy=True if site.get("proxy") else False
+                proxy=True if site.get("proxy") else False,
+                timeout=site.get("timeout"),
             )
             if rss_url:
                 # 获取新的日期的passkey

app/chain/transfer.py

@@ -501,7 +501,8 @@ class TransferChain(ChainBase, metaclass=Singleton):
                     # 获取整理屏蔽词
                     transfer_exclude_words = SystemConfigOper().get(SystemConfigKey.TransferExcludeWords)
                     for t in tasks:
-                        if t.download_hash and self._can_delete_torrent(t.download_hash, t.downloader, transfer_exclude_words):
+                        if t.download_hash and self._can_delete_torrent(t.download_hash, t.downloader,
+                                                                        transfer_exclude_words):
                             if self.remove_torrents(t.download_hash, downloader=t.downloader):
                                 logger.info(f"移动模式删除种子成功：{t.download_hash}")
                         if t.fileitem:
@@ -554,8 +555,10 @@ class TransferChain(ChainBase, metaclass=Singleton):
         processed_num = 0
         # 失败数量
         fail_num = 0
+        # 已完成文件
+        finished_files = []
 
-        progress = ProgressHelper()
+        progress = ProgressHelper(ProgressKey.FileTransfer)
 
         while not global_vars.is_system_stopped:
             try:
@@ -570,7 +573,7 @@ class TransferChain(ChainBase, metaclass=Singleton):
                     if __queue_start:
                         logger.info("开始整理队列处理...")
                         # 启动进度
-                        progress.start(ProgressKey.FileTransfer)
+                        progress.start()
                         # 重置计数
                         processed_num = 0
                         fail_num = 0
@@ -578,8 +581,7 @@ class TransferChain(ChainBase, metaclass=Singleton):
                         __process_msg = f"开始整理队列处理，当前共 {total_num} 个文件 ..."
                         logger.info(__process_msg)
                         progress.update(value=0,
-                                        text=__process_msg,
-                                        key=ProgressKey.FileTransfer)
+                                        text=__process_msg)
                         # 队列已开始
                         __queue_start = False
                     # 更新进度
@@ -587,7 +589,10 @@ class TransferChain(ChainBase, metaclass=Singleton):
                     logger.info(__process_msg)
                     progress.update(value=processed_num / total_num * 100,
                                     text=__process_msg,
-                                    key=ProgressKey.FileTransfer)
+                                    data={
+                                        "current": Path(fileitem.path).as_posix(),
+                                        "finished": finished_files
+                                    })
                     # 整理
                     state, err_msg = self.__handle_transfer(task=task, callback=item.callback)
                     if not state:
@@ -595,20 +600,20 @@ class TransferChain(ChainBase, metaclass=Singleton):
                         fail_num += 1
                     # 更新进度
                     processed_num += 1
+                    finished_files.append(Path(fileitem.path).as_posix())
                     __process_msg = f"{fileitem.name} 整理完成"
                     logger.info(__process_msg)
-                    progress.update(value=processed_num / total_num * 100,
+                    progress.update(value=(processed_num / total_num) * 100,
                                     text=__process_msg,
-                                    key=ProgressKey.FileTransfer)
+                                    data={})
             except queue.Empty:
                 if not __queue_start:
                     # 结束进度
                     __end_msg = f"整理队列处理完成，共整理 {processed_num} 个文件，失败 {fail_num} 个"
                     logger.info(__end_msg)
                     progress.update(value=100,
-                                    text=__end_msg,
-                                    key=ProgressKey.FileTransfer)
-                    progress.end(ProgressKey.FileTransfer)
+                                    text=__end_msg)
+                    progress.end()
                     # 重置计数
                     processed_num = 0
                     fail_num = 0
@@ -1164,15 +1169,16 @@ class TransferChain(ChainBase, metaclass=Singleton):
             processed_num = 0
             # 失败数量
             fail_num = 0
+            # 已完成文件
+            finished_files = []
 
             # 启动进度
-            progress = ProgressHelper()
-            progress.start(ProgressKey.FileTransfer)
+            progress = ProgressHelper(ProgressKey.FileTransfer)
+            progress.start()
             __process_msg = f"开始整理，共 {total_num} 个文件 ..."
             logger.info(__process_msg)
             progress.update(value=0,
-                            text=__process_msg,
-                            key=ProgressKey.FileTransfer)
+                            text=__process_msg)
             try:
                 for transfer_task in transfer_tasks:
                     if global_vars.is_system_stopped:
@@ -1184,7 +1190,10 @@ class TransferChain(ChainBase, metaclass=Singleton):
                     logger.info(__process_msg)
                     progress.update(value=(processed_num + fail_num) / total_num * 100,
                                     text=__process_msg,
-                                    key=ProgressKey.FileTransfer)
+                                    data={
+                                        "current": Path(transfer_task.fileitem.path).as_posix(),
+                                        "finished": finished_files,
+                                    })
                     state, err_msg = self.__handle_transfer(
                         task=transfer_task,
                         callback=self.__default_callback
@@ -1196,6 +1205,8 @@ class TransferChain(ChainBase, metaclass=Singleton):
                         fail_num += 1
                     else:
                         processed_num += 1
+                    # 记录已完成
+                    finished_files.append(Path(transfer_task.fileitem.path).as_posix())
             finally:
                 transfer_tasks.clear()
                 del transfer_tasks
@@ -1205,8 +1216,8 @@ class TransferChain(ChainBase, metaclass=Singleton):
             logger.info(__end_msg)
             progress.update(value=100,
                             text=__end_msg,
-                            key=ProgressKey.FileTransfer)
-            progress.end(ProgressKey.FileTransfer)
+                            data={})
+            progress.end()
 
         error_msg = "、".join(err_msgs[:2]) + (f"，等{len(err_msgs)}个文件错误！" if len(err_msgs) > 2 else "")
         return all_success, error_msg
@@ -1351,12 +1362,7 @@ class TransferChain(ChainBase, metaclass=Singleton):
             else:
                 # 更新媒体图片
                 self.obtain_images(mediainfo=mediainfo)
-            # 开始进度
-            progress = ProgressHelper()
-            progress.start(ProgressKey.FileTransfer)
-            progress.update(value=0,
-                            text=f"开始整理 {fileitem.path} ...",
-                            key=ProgressKey.FileTransfer)
+
             # 开始整理
             state, errmsg = self.do_transfer(
                 fileitem=fileitem,
@@ -1377,7 +1383,6 @@ class TransferChain(ChainBase, metaclass=Singleton):
             if not state:
                 return False, errmsg
 
-            progress.end(ProgressKey.FileTransfer)
             logger.info(f"{fileitem.path} 整理完成")
             return True, ""
         else:
@@ -1435,7 +1440,6 @@ class TransferChain(ChainBase, metaclass=Singleton):
                 return True
         return False
 
-
     def _can_delete_torrent(self, download_hash: str, downloader: str, transfer_exclude_words) -> bool:
         """
         检查是否可以删除种子文件
@@ -1467,13 +1471,9 @@ class TransferChain(ChainBase, metaclass=Singleton):
             for file in torrent_files:
                 file_path = save_path / file.name
                 # 如果存在未被屏蔽的媒体文件，则不删除种子
-                if (
-                    file_path.suffix in self.all_exts
-                    and not self._is_blocked_by_exclude_words(
-                        str(file_path), transfer_exclude_words
-                    )
-                    and file_path.exists()
-                ):
+                if (file_path.suffix in self.all_exts
+                        and not self._is_blocked_by_exclude_words(str(file_path), transfer_exclude_words)
+                        and file_path.exists()):
                     return False
 
             # 所有媒体文件都被屏蔽或不存在，可以删除种子

app/core/config.py

@@ -8,6 +8,7 @@ import sys
 import threading
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Tuple, Type
+from urllib.parse import urlparse
 
 from dotenv import set_key
 from pydantic import BaseModel, BaseSettings, validator, Field
@@ -41,10 +42,6 @@ class SystemConfModel(BaseModel):
     scheduler: int = 0
     # 线程池大小
     threadpool: int = 0
-    # 数据库连接池大小
-    dbpool: int = 0
-    # 数据库连接池溢出数量
-    dbpooloverflow: int = 0
 
 
 class ConfigModel(BaseModel):
@@ -55,6 +52,7 @@ class ConfigModel(BaseModel):
     class Config:
         extra = "ignore"  # 忽略未定义的配置项
 
+    # ==================== 基础应用配置 ====================
     # 项目名称
     PROJECT_NAME: str = "MoviePilot"
     # 域名 格式；https://movie-pilot.org
@@ -63,6 +61,22 @@ class ConfigModel(BaseModel):
     API_V1_STR: str = "/api/v1"
     # 前端资源路径
     FRONTEND_PATH: str = "/public"
+    # 时区
+    TZ: str = "Asia/Shanghai"
+    # API监听地址
+    HOST: str = "0.0.0.0"
+    # API监听端口
+    PORT: int = 3001
+    # 前端监听端口
+    NGINX_PORT: int = 3000
+    # 配置文件目录
+    CONFIG_DIR: Optional[str] = None
+    # 是否调试模式
+    DEBUG: bool = False
+    # 是否开发模式
+    DEV: bool = False
+
+    # ==================== 安全认证配置 ====================
     # 密钥
     SECRET_KEY: str = secrets.token_urlsafe(32)
     # RESOURCE密钥
@@ -73,20 +87,24 @@ class ConfigModel(BaseModel):
     ACCESS_TOKEN_EXPIRE_MINUTES: int = 60 * 24 * 8
     # RESOURCE_TOKEN过期时间
     RESOURCE_ACCESS_TOKEN_EXPIRE_SECONDS: int = 60 * 30
-    # 时区
-    TZ: str = "Asia/Shanghai"
-    # API监听地址
-    HOST: str = "0.0.0.0"
-    # API监听端口
-    PORT: int = 3001
-    # 前端监听端口
-    NGINX_PORT: int = 3000
-    # 是否调试模式
-    DEBUG: bool = False
-    # 是否开发模式
-    DEV: bool = False
+    # 超级管理员
+    SUPERUSER: str = "admin"
+    # 辅助认证，允许通过外部服务进行认证、单点登录以及自动创建用户
+    AUXILIARY_AUTH_ENABLE: bool = False
+    # API密钥，需要更换
+    API_TOKEN: Optional[str] = None
+    # 用户认证站点
+    AUTH_SITE: str = ""
+
+    # ==================== 数据库配置 ====================
+    # 数据库类型，支持 sqlite 和 postgresql，默认使用 sqlite
+    DB_TYPE: str = "sqlite"
     # 是否在控制台输出 SQL 语句，默认关闭
     DB_ECHO: bool = False
+    # 数据库连接超时时间（秒），默认为 60 秒
+    DB_TIMEOUT: int = 60
+    # 是否启用 WAL 模式，仅适用于SQLite，默认开启
+    DB_WAL_ENABLE: bool = True
     # 数据库连接池类型，QueuePool, NullPool
     DB_POOL_TYPE: str = "QueuePool"
     # 是否在获取连接时进行预先 ping 操作
@@ -95,71 +113,44 @@ class ConfigModel(BaseModel):
     DB_POOL_RECYCLE: int = 300
     # 数据库连接池获取连接的超时时间（秒）
     DB_POOL_TIMEOUT: int = 30
-    # SQLite 的 busy_timeout 参数，默认为 60 秒
-    DB_TIMEOUT: int = 60
-    # SQLite 是否启用 WAL 模式，默认开启
-    DB_WAL_ENABLE: bool = True
+    # SQLite 连接池大小
+    DB_SQLITE_POOL_SIZE: int = 10
+    # SQLite 连接池溢出数量
+    DB_SQLITE_MAX_OVERFLOW: int = 50
+    # PostgreSQL 主机地址
+    DB_POSTGRESQL_HOST: str = "localhost"
+    # PostgreSQL 端口
+    DB_POSTGRESQL_PORT: int = 5432
+    # PostgreSQL 数据库名
+    DB_POSTGRESQL_DATABASE: str = "moviepilot"
+    # PostgreSQL 用户名
+    DB_POSTGRESQL_USERNAME: str = "moviepilot"
+    # PostgreSQL 密码
+    DB_POSTGRESQL_PASSWORD: str = "moviepilot"
+    # PostgreSQL 连接池大小
+    DB_POSTGRESQL_POOL_SIZE: int = 10
+    # PostgreSQL 连接池溢出数量
+    DB_POSTGRESQL_MAX_OVERFLOW: int = 50
+
+    # ==================== 缓存配置 ====================
     # 缓存类型，支持 cachetools 和 redis，默认使用 cachetools
     CACHE_BACKEND_TYPE: str = "cachetools"
     # 缓存连接字符串，仅外部缓存（如 Redis、Memcached）需要
-    CACHE_BACKEND_URL: Optional[str] = None
+    CACHE_BACKEND_URL: Optional[str] = "redis://localhost:6379"
     # Redis 缓存最大内存限制，未配置时，如开启大内存模式时为 "1024mb"，未开启时为 "256mb"
     CACHE_REDIS_MAXMEMORY: Optional[str] = None
-    # 配置文件目录
-    CONFIG_DIR: Optional[str] = None
-    # 超级管理员
-    SUPERUSER: str = "admin"
-    # 辅助认证，允许通过外部服务进行认证、单点登录以及自动创建用户
-    AUXILIARY_AUTH_ENABLE: bool = False
-    # API密钥，需要更换
-    API_TOKEN: Optional[str] = None
+    # 全局图片缓存，将媒体图片缓存到本地
+    GLOBAL_IMAGE_CACHE: bool = False
+    # 全局图片缓存保留天数
+    GLOBAL_IMAGE_CACHE_DAYS: int = 7
+    # 临时文件保留天数
+    TEMP_FILE_DAYS: int = 3
+    # 元数据识别缓存过期时间（小时），0为自动
+    META_CACHE_EXPIRE: int = 0
+
+    # ==================== 网络代理配置 ====================
     # 网络代理服务器地址
     PROXY_HOST: Optional[str] = None
-    # 登录页面电影海报,tmdb/bing/mediaserver
-    WALLPAPER: str = "tmdb"
-    # 自定义壁纸api地址
-    CUSTOMIZE_WALLPAPER_API_URL: Optional[str] = None
-    # 媒体搜索来源 themoviedb/douban/bangumi，多个用,分隔
-    SEARCH_SOURCE: str = "themoviedb,douban,bangumi"
-    # 媒体识别来源 themoviedb/douban
-    RECOGNIZE_SOURCE: str = "themoviedb"
-    # 刮削来源 themoviedb/douban
-    SCRAP_SOURCE: str = "themoviedb"
-    # 新增已入库媒体是否跟随TMDB信息变化
-    SCRAP_FOLLOW_TMDB: bool = True
-    # TMDB图片地址
-    TMDB_IMAGE_DOMAIN: str = "image.tmdb.org"
-    # TMDB API地址
-    TMDB_API_DOMAIN: str = "api.themoviedb.org"
-    # TMDB元数据语言
-    TMDB_LOCALE: str = "zh"
-    # 刮削使用TMDB原始语种图片
-    TMDB_SCRAP_ORIGINAL_IMAGE: bool = False
-    # TMDB API Key
-    TMDB_API_KEY: str = "db55323b8d3e4154498498a75642b381"
-    # TVDB API Key
-    TVDB_V4_API_KEY: str = "ed2aa66b-7899-4677-92a7-67bc9ce3d93a"
-    TVDB_V4_API_PIN: str = ""
-    # Fanart开关
-    FANART_ENABLE: bool = True
-    # Fanart语言
-    FANART_LANG: str = "zh,en"
-    # 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
-    ANIME_GENREIDS: List[int] = Field(default=[16])
-    # 用户认证站点
-    AUTH_SITE: str = ""
-    # 重启自动升级
-    MOVIEPILOT_AUTO_UPDATE: str = 'release'
-    # 自动检查和更新站点资源包（站点索引、认证等）
-    AUTO_UPDATE_RESOURCE: bool = True
     # 是否启用DOH解析域名
     DOH_ENABLE: bool = False
     # 使用 DOH 解析的域名列表
@@ -173,6 +164,55 @@ class ConfigModel(BaseModel):
                         "api.telegram.org")
     # DOH 解析服务器列表
     DOH_RESOLVERS: str = "1.0.0.1,1.1.1.1,9.9.9.9,149.112.112.112"
+
+    # ==================== 媒体元数据配置 ====================
+    # 媒体搜索来源 themoviedb/douban/bangumi，多个用,分隔
+    SEARCH_SOURCE: str = "themoviedb,douban,bangumi"
+    # 媒体识别来源 themoviedb/douban
+    RECOGNIZE_SOURCE: str = "themoviedb"
+    # 刮削来源 themoviedb/douban
+    SCRAP_SOURCE: str = "themoviedb"
+    # 电视剧动漫的分类genre_ids
+    ANIME_GENREIDS: List[int] = Field(default=[16])
+
+    # ==================== TMDB配置 ====================
+    # TMDB图片地址
+    TMDB_IMAGE_DOMAIN: str = "image.tmdb.org"
+    # TMDB API地址
+    TMDB_API_DOMAIN: str = "api.themoviedb.org"
+    # TMDB元数据语言
+    TMDB_LOCALE: str = "zh"
+    # 刮削使用TMDB原始语种图片
+    TMDB_SCRAP_ORIGINAL_IMAGE: bool = False
+    # TMDB API Key
+    TMDB_API_KEY: str = "db55323b8d3e4154498498a75642b381"
+
+    # ==================== TVDB配置 ====================
+    # TVDB API Key
+    TVDB_V4_API_KEY: str = "ed2aa66b-7899-4677-92a7-67bc9ce3d93a"
+    TVDB_V4_API_PIN: str = ""
+
+    # ==================== Fanart配置 ====================
+    # Fanart开关
+    FANART_ENABLE: bool = True
+    # Fanart语言
+    FANART_LANG: str = "zh,en"
+    # Fanart API Key
+    FANART_API_KEY: str = "d2d31f9ecabea050fc7d68aa3146015f"
+
+    # ==================== 云盘配置 ====================
+    # 115 AppId
+    U115_APP_ID: str = "100196807"
+    # Alipan AppId
+    ALIPAN_APP_ID: str = "ac1bf04dc9fd4d9aaabb65b4a668d403"
+
+    # ==================== 系统升级配置 ====================
+    # 重启自动升级
+    MOVIEPILOT_AUTO_UPDATE: str = 'release'
+    # 自动检查和更新站点资源包（站点索引、认证等）
+    AUTO_UPDATE_RESOURCE: bool = True
+
+    # ==================== 媒体文件格式配置 ====================
     # 支持的后缀格式
     RMT_MEDIAEXT: list = Field(
         default_factory=lambda: ['.mp4', '.mkv', '.ts', '.iso',
@@ -195,10 +235,12 @@ class ConfigModel(BaseModel):
                                  '.aifc', '.aiff', '.alac', '.adif', '.adts',
                                  '.flac', '.midi', '.opus', '.sfalc']
     )
-    # 下载器临时文件后缀
-    DOWNLOAD_TMPEXT: list = Field(default_factory=lambda: ['.!qb', '.part'])
+
+    # ==================== 媒体服务器配置 ====================
     # 媒体服务器同步间隔（小时）
     MEDIASERVER_SYNC_INTERVAL: int = 6
+
+    # ==================== 订阅配置 ====================
     # 订阅模式
     SUBSCRIBE_MODE: str = "spider"
     # RSS订阅模式刷新时间间隔（分钟）
@@ -207,24 +249,42 @@ class ConfigModel(BaseModel):
     SUBSCRIBE_STATISTIC_SHARE: bool = True
     # 订阅搜索开关
     SUBSCRIBE_SEARCH: bool = False
+    # 订阅搜索时间间隔（小时）
+    SUBSCRIBE_SEARCH_INTERVAL: int = 24
     # 检查本地媒体库是否存在资源开关
     LOCAL_EXISTS_SEARCH: bool = False
-    # 搜索多个名称
-    SEARCH_MULTIPLE_NAME: bool = False
-    # 最大搜索名称数量
-    MAX_SEARCH_NAME_LIMIT: int = 2
+
+    # ==================== 站点配置 ====================
     # 站点数据刷新间隔（小时）
     SITEDATA_REFRESH_INTERVAL: int = 6
     # 读取和发送站点消息
     SITE_MESSAGE: bool = True
     # 不能缓存站点资源的站点域名，多个使用,分隔
     NO_CACHE_SITE_KEY: str = "m-team"
+    # OCR服务器地址，用于识别站点验证码
+    OCR_HOST: str = "https://movie-pilot.org"
+    # 仿真类型：playwright 或 flaresolverr
+    BROWSER_EMULATION: str = "playwright"
+    # FlareSolverr 服务地址，例如 http://127.0.0.1:8191
+    FLARESOLVERR_URL: Optional[str] = None
+
+    # ==================== 搜索配置 ====================
+    # 搜索多个名称
+    SEARCH_MULTIPLE_NAME: bool = False
+    # 最大搜索名称数量
+    MAX_SEARCH_NAME_LIMIT: int = 2
+
+    # ==================== 下载配置 ====================
     # 种子标签
     TORRENT_TAG: str = "MOVIEPILOT"
     # 下载站点字幕
     DOWNLOAD_SUBTITLE: bool = True
     # 交互搜索自动下载用户ID，使用,分割
     AUTO_DOWNLOAD_USER: Optional[str] = None
+    # 下载器临时文件后缀
+    DOWNLOAD_TMPEXT: list = Field(default_factory=lambda: ['.!qb', '.part'])
+
+    # ==================== CookieCloud配置 ====================
     # CookieCloud是否启动本地服务
     COOKIECLOUD_ENABLE_LOCAL: Optional[bool] = False
     # CookieCloud服务器地址
@@ -237,6 +297,8 @@ class ConfigModel(BaseModel):
     COOKIECLOUD_INTERVAL: Optional[int] = 60 * 24
     # CookieCloud同步黑名单，多个域名,分割
     COOKIECLOUD_BLACKLIST: Optional[str] = None
+
+    # ==================== 整理配置 ====================
     # 电影重命名格式
     MOVIE_RENAME_FORMAT: str = "{{title}}{% if year %} ({{year}}){% endif %}" \
                                "/{{title}}{% if year %} ({{year}}){% endif %}{% if part %}-{{part}}{% endif %}{% if videoFormat %} - {{videoFormat}}{% endif %}" \
@@ -246,10 +308,24 @@ class ConfigModel(BaseModel):
                             "/Season {{season}}" \
                             "/{{title}} - {{season_episode}}{% if part %}-{{part}}{% endif %}{% if episode %} - 第 {{episode}} 集{% endif %}" \
                             "{{fileExt}}"
-    # OCR服务器地址
-    OCR_HOST: str = "https://movie-pilot.org"
+    # 重命名时支持的S0别名
+    RENAME_FORMAT_S0_NAMES: list = Field(default=["Specials", "SPs"])
+    # 为指定默认字幕添加.default后缀
+    DEFAULT_SUB: Optional[str] = "zh-cn"
+    # 新增已入库媒体是否跟随TMDB信息变化
+    SCRAP_FOLLOW_TMDB: bool = True
+
+    # ==================== 服务地址配置 ====================
     # 服务器地址，对应 https://github.com/jxxghp/MoviePilot-Server 项目
     MP_SERVER_HOST: str = "https://movie-pilot.org"
+
+    # ==================== 个性化 ====================
+    # 登录页面电影海报,tmdb/bing/mediaserver
+    WALLPAPER: str = "tmdb"
+    # 自定义壁纸api地址
+    CUSTOMIZE_WALLPAPER_API_URL: Optional[str] = None
+
+    # ==================== 插件配置 ====================
     # 插件市场仓库地址，多个地址使用,分隔，地址以/结尾
     PLUGIN_MARKET: str = ("https://github.com/jxxghp/MoviePilot-Plugins,"
                           "https://github.com/thsrite/MoviePilot-Plugins,"
@@ -270,6 +346,8 @@ class ConfigModel(BaseModel):
     PLUGIN_STATISTIC_SHARE: bool = True
     # 是否开启插件热加载
     PLUGIN_AUTO_RELOAD: bool = False
+
+    # ==================== Github & PIP ====================
     # Github token，提高请求api限流阈值 ghp_****
     GITHUB_TOKEN: Optional[str] = None
     # Github代理服务器，格式：https://mirror.ghproxy.com/
@@ -278,16 +356,16 @@ class ConfigModel(BaseModel):
     PIP_PROXY: Optional[str] = ''
     # 指定的仓库Github token，多个仓库使用,分隔，格式：{user1}/{repo1}:ghp_****,{user2}/{repo2}:github_pat_****
     REPO_GITHUB_TOKEN: Optional[str] = None
+
+    # ==================== 性能配置 ====================
     # 大内存模式
     BIG_MEMORY_MODE: bool = False
-    # FastApi性能监控
-    PERFORMANCE_MONITOR_ENABLE: bool = False
-    # 全局图片缓存，将媒体图片缓存到本地
-    GLOBAL_IMAGE_CACHE: bool = False
     # 是否启用编码探测的性能模式
     ENCODING_DETECTION_PERFORMANCE_MODE: bool = True
     # 编码探测的最低置信度阈值
     ENCODING_DETECTION_MIN_CONFIDENCE: float = 0.8
+
+    # ==================== 安全配置 ====================
     # 允许的图片缓存域名
     SECURITY_IMAGE_DOMAINS: list = Field(default=[
         "image.tmdb.org",
@@ -307,19 +385,21 @@ class ConfigModel(BaseModel):
     ])
     # 允许的图片文件后缀格式
     SECURITY_IMAGE_SUFFIXES: list = Field(default=[".jpg", ".jpeg", ".png", ".webp", ".gif", ".svg", ".avif"])
-    # 重命名时支持的S0别名
-    RENAME_FORMAT_S0_NAMES: list = Field(default=["Specials", "SPs"])
-    # 为指定默认字幕添加.default后缀
-    DEFAULT_SUB: Optional[str] = "zh-cn"
-    # Docker Client API地址
-    DOCKER_CLIENT_API: Optional[str] = "tcp://127.0.0.1:38379"
+
+    # ==================== 工作流配置 ====================
     # 工作流数据共享
     WORKFLOW_STATISTIC_SHARE: bool = True
+
+    # ==================== 存储配置 ====================
     # 对rclone进行快照对比时，是否检查文件夹的修改时间
     RCLONE_SNAPSHOT_CHECK_FOLDER_MODTIME = True
     # 对OpenList进行快照对比时，是否检查文件夹的修改时间
     OPENLIST_SNAPSHOT_CHECK_FOLDER_MODTIME = True
 
+    # ==================== Docker配置 ====================
+    # Docker Client API地址
+    DOCKER_CLIENT_API: Optional[str] = "tcp://127.0.0.1:38379"
+
 
 class Settings(BaseSettings, ConfigModel, LogConfigModel):
     """
@@ -583,11 +663,9 @@ class Settings(BaseSettings, ConfigModel, LogConfigModel):
                 douban=512,
                 bangumi=512,
                 fanart=512,
-                meta=(self.META_CACHE_EXPIRE or 24) * 3600,
+                meta=(self.META_CACHE_EXPIRE or 72) * 3600,
                 scheduler=100,
-                threadpool=100,
-                dbpool=100,
-                dbpooloverflow=50
+                threadpool=100
             )
         return SystemConfModel(
             torrents=100,
@@ -596,11 +674,9 @@ class Settings(BaseSettings, ConfigModel, LogConfigModel):
             douban=256,
             bangumi=256,
             fanart=128,
-            meta=(self.META_CACHE_EXPIRE or 2) * 3600,
+            meta=(self.META_CACHE_EXPIRE or 24) * 3600,
             scheduler=50,
-            threadpool=50,
-            dbpool=50,
-            dbpooloverflow=20
+            threadpool=50
         )
 
     @property
@@ -615,9 +691,22 @@ class Settings(BaseSettings, ConfigModel, LogConfigModel):
     @property
     def PROXY_SERVER(self):
         if self.PROXY_HOST:
-            return {
-                "server": self.PROXY_HOST
-            }
+            try:
+                parsed = urlparse(self.PROXY_HOST)
+                if not parsed.scheme:
+                    return {"server": self.PROXY_HOST}
+                host = parsed.hostname or ""
+                port = f":{parsed.port}" if parsed.port else ""
+                server = f"{parsed.scheme}://{host}{port}"
+                proxy = {"server": server}
+                if parsed.username:
+                    proxy["username"] = parsed.username
+                if parsed.password:
+                    proxy["password"] = parsed.password
+                return proxy
+            except Exception as err:
+                logger.error(f"解析代理服务器地址 '{self.PROXY_HOST}' 时出错: {err}")
+                return {"server": self.PROXY_HOST}
         return None
 
     @property
@@ -709,6 +798,8 @@ class GlobalVar(object):
     SUBSCRIPTIONS: List[dict] = []
     # 需应急停止的工作流
     EMERGENCY_STOP_WORKFLOWS: List[int] = []
+    # 需应急停止文件整理
+    EMERGENCY_STOP_TRANSFER: List[str] = []
 
     def stop_system(self):
         """
@@ -749,12 +840,30 @@ class GlobalVar(object):
         if workflow_id in self.EMERGENCY_STOP_WORKFLOWS:
             self.EMERGENCY_STOP_WORKFLOWS.remove(workflow_id)
 
-    def is_workflow_stopped(self, workflow_id: int):
+    def is_workflow_stopped(self, workflow_id: int) -> bool:
         """
         是否停止工作流
         """
         return self.is_system_stopped or workflow_id in self.EMERGENCY_STOP_WORKFLOWS
 
+    def stop_transfer(self, path: str):
+        """
+        停止文件整理
+        """
+        if path not in self.EMERGENCY_STOP_TRANSFER:
+            self.EMERGENCY_STOP_TRANSFER.append(path)
+
+    def is_transfer_stopped(self, path: str) -> bool:
+        """
+        是否停止文件整理
+        """
+        if self.is_system_stopped:
+            return True
+        if path in self.EMERGENCY_STOP_TRANSFER:
+            self.EMERGENCY_STOP_TRANSFER.remove(path)
+            return True
+        return False
+
 
 # 全局标识
 global_vars = GlobalVar()

app/core/context.py

@@ -483,7 +483,7 @@ class MediaInfo:
                 continue
             if current_value is None:
                 setattr(self, key, value)
-            elif type(current_value) == type(value):
+            elif type(current_value) is type(value):
                 setattr(self, key, value)
 
     def set_douban_info(self, info: dict):
@@ -624,7 +624,7 @@ class MediaInfo:
                 continue
             if current_value is None:
                 setattr(self, key, value)
-            elif type(current_value) == type(value):
+            elif type(current_value) is type(value):
                 setattr(self, key, value)
 
     def set_bangumi_info(self, info: dict):

app/core/event.py

@@ -450,10 +450,7 @@ class EventManager(metaclass=Singleton):
             logger.debug(f"Handler {self.__get_handler_identifier(handler)} is disabled. Skipping execution")
             return
 
-        try:
-            self.__invoke_handler_by_type_sync(handler, event)
-        except Exception as e:
-            self.__handle_event_error(event, handler, e)
+        self.__invoke_handler_by_type_sync(handler, event)
 
     async def __safe_invoke_handler_async(self, handler: Callable, event: Event):
         """
@@ -465,10 +462,7 @@ class EventManager(metaclass=Singleton):
             logger.debug(f"Handler {self.__get_handler_identifier(handler)} is disabled. Skipping execution")
             return
 
-        try:
-            await self.__invoke_handler_by_type_async(handler, event)
-        except Exception as e:
-            self.__handle_event_error(event, handler, e)
+        await self.__invoke_handler_by_type_async(handler, event)
 
     def __invoke_handler_by_type_sync(self, handler: Callable, event: Event):
         """
@@ -486,7 +480,17 @@ class EventManager(metaclass=Singleton):
 
         if class_name in plugin_manager.get_plugin_ids():
             # 插件处理器
-            plugin_manager.run_plugin_method(class_name, method_name, event)
+            plugin = plugin_manager.running_plugins.get(class_name)
+            if not plugin:
+                return
+            method = getattr(plugin, method_name, None)
+            if not method:
+                return
+            try:
+                method(event)
+            except Exception as e:
+                self.__handle_event_error(event=event, module_name=plugin.name,
+                                          class_name=class_name, method_name=method_name, e=e)
         elif class_name in module_manager.get_module_ids():
             # 模块处理器
             module = module_manager.get_running_module(class_name)
@@ -495,16 +499,24 @@ class EventManager(metaclass=Singleton):
             method = getattr(module, method_name, None)
             if not method:
                 return
-            method(event)
+            try:
+                method(event)
+            except Exception as e:
+                self.__handle_event_error(event=event, module_name=module.get_name(),
+                                          class_name=class_name, method_name=method_name, e=e)
         else:
             # 全局处理器
             class_obj = self.__get_class_instance(class_name)
             if not class_obj or not hasattr(class_obj, method_name):
                 return
-            method = getattr(class_obj, method_name)
+            method = getattr(class_obj, method_name, None)
             if not method:
                 return
-            method(event)
+            try:
+                method(event)
+            except Exception as e:
+                self.__handle_event_error(event=event, module_name=class_name,
+                                          class_name=class_name, method_name=method_name, e=e)
 
     async def __invoke_handler_by_type_async(self, handler: Callable, event: Event):
         """
@@ -537,52 +549,62 @@ class EventManager(metaclass=Singleton):
         names = handler.__qualname__.split(".")
         return names[0], names[1]
 
-    @staticmethod
-    async def __invoke_plugin_method_async(handler: Any, class_name: str, method_name: str, event: Event):
+    async def __invoke_plugin_method_async(self, handler: Any, class_name: str, method_name: str, event: Event):
         """
         异步调用插件方法
         """
         plugin = handler.running_plugins.get(class_name)
-        if plugin and hasattr(plugin, method_name):
-            method = getattr(plugin, method_name)
+        if not plugin:
+            return
+        method = getattr(plugin, method_name, None)
+        if not method:
+            return
+        try:
             if inspect.iscoroutinefunction(method):
                 await method(event)
             else:
                 # 插件同步函数在异步环境中运行，避免阻塞
                 await run_in_threadpool(method, event)
+        except Exception as e:
+            self.__handle_event_error(event=event, handler=handler, e=e, module_name=plugin.name)
 
-    @staticmethod
-    async def __invoke_module_method_async(handler: Any, class_name: str, method_name: str, event: Event):
+    async def __invoke_module_method_async(self, handler: Any, class_name: str, method_name: str, event: Event):
         """
         异步调用模块方法
         """
         module = handler.get_running_module(class_name)
         if not module:
             return
-
         method = getattr(module, method_name, None)
         if not method:
             return
-
-        if inspect.iscoroutinefunction(method):
-            await method(event)
-        else:
-            method(event)
+        try:
+            if inspect.iscoroutinefunction(method):
+                await method(event)
+            else:
+                method(event)
+        except Exception as e:
+            self.__handle_event_error(event=event, module_name=module.get_name(),
+                                      class_name=class_name, method_name=method_name, e=e)
 
     async def __invoke_global_method_async(self, class_name: str, method_name: str, event: Event):
         """
         异步调用全局对象方法
         """
         class_obj = self.__get_class_instance(class_name)
-        if not class_obj or not hasattr(class_obj, method_name):
+        if not class_obj:
             return
-
-        method = getattr(class_obj, method_name)
-
-        if inspect.iscoroutinefunction(method):
-            await method(event)
-        else:
-            method(event)
+        method = getattr(class_obj, method_name, None)
+        if not method:
+            return
+        try:
+            if inspect.iscoroutinefunction(method):
+                await method(event)
+            else:
+                method(event)
+        except Exception as e:
+            self.__handle_event_error(event=event, module_name=class_name,
+                                      class_name=class_name, method_name=method_name, e=e)
 
     @staticmethod
     def __get_class_instance(class_name: str):
@@ -609,7 +631,11 @@ class EventManager(metaclass=Singleton):
                 module_name = f"app.chain.{class_name[:-5].lower()}"
                 module = importlib.import_module(module_name)
             elif class_name.endswith("Helper"):
-                module_name = f"app.helper.{class_name[:-6].lower()}"
+                # 特殊处理 Async 类
+                if class_name.startswith("Async"):
+                    module_name = f"app.helper.{class_name[5:-6].lower()}"
+                else:
+                    module_name = f"app.helper.{class_name[:-6].lower()}"
                 module = importlib.import_module(module_name)
             else:
                 module_name = f"app.{class_name.lower()}"
@@ -649,18 +675,16 @@ class EventManager(metaclass=Singleton):
         """
         logger.debug(f"{stage} - {event}")
 
-    def __handle_event_error(self, event: Event, handler: Callable, e: Exception):
+    def __handle_event_error(self, event: Event, module_name: str,
+                             class_name: str, method_name: str, e: Exception):
         """
         全局错误处理器，用于处理事件处理中的异常
         """
-        logger.error(f"事件处理出错：{str(e)} - {traceback.format_exc()}")
-
-        names = handler.__qualname__.split(".")
-        class_name, method_name = names[0], names[1]
+        logger.error(f"{module_name} 事件处理出错：{str(e)} - {traceback.format_exc()}")
 
         # 发送系统错误通知
         from app.helper.message import MessageHelper
-        MessageHelper().put(title=f"{event.event_type} 事件处理出错",
+        MessageHelper().put(title=f"{module_name} 处理事件 {event.event_type} 时出错",
                             message=f"{class_name}.{method_name}：{str(e)}",
                             role="system")
         self.send_event(

app/core/meta/releasegroup.py

@@ -105,10 +105,11 @@ class ReleaseGroupsMatcher(metaclass=Singleton):
             else:
                 groups = self.__release_groups
         title = f"{title} "
-        groups_re = re.compile(r"(?<=[-@\[￡【&])(?:%s)(?=[@.\s\S\]\[】&])" % groups, re.I)
-        # 处理一个制作组识别多次的情况，保留顺序
+        groups_re = re.compile(r"(?<=[-@\[￡【&])(?:(?:%s))(?=[@.\s\S\]\[】&])" % groups, re.I)
         unique_groups = []
         for item in re.findall(groups_re, title):
-            if item not in unique_groups:
-                unique_groups.append(item)
+            item_str = item[0] if isinstance(item, tuple) else item
+            if item_str not in unique_groups:
+                unique_groups.append(item_str)
+
         return "@".join(unique_groups)

app/core/module.py

@@ -48,7 +48,7 @@ class ModuleManager(metaclass=Singleton):
                     # 通过模板开关控制加载
                     _module.init_module()
                     self._running_modules[module_id] = _module
-                    logger.info(f"Moudle Loaded：{module_id}")
+                    logger.debug(f"Moudle Loaded：{module_id}")
             except Exception as err:
                 logger.error(f"Load Moudle Error：{module_id}，{str(err)} - {traceback.format_exc()}", exc_info=True)
 
@@ -61,7 +61,7 @@ class ModuleManager(metaclass=Singleton):
             if hasattr(module, "stop"):
                 try:
                     module.stop()
-                    logger.info(f"Moudle Stoped：{module_id}")
+                    logger.debug(f"Moudle Stoped：{module_id}")
                 except Exception as err:
                     logger.error(f"Stop Moudle Error：{module_id}，{str(err)} - {traceback.format_exc()}", exc_info=True)
         logger.info("所有模块停止完成")

app/core/plugin.py

@@ -1165,6 +1165,7 @@ class PluginManager(metaclass=Singleton):
     async def async_get_online_plugins(self, force: bool = False) -> List[schemas.Plugin]:
         """
         异步获取所有在线插件信息
+        :param force: 是否强制刷新（忽略缓存）
         """
         if not settings.PLUGIN_MARKET:
             return []

app/core/security.py

@@ -252,19 +252,19 @@ def __verify_key(key: str, expected_key: str, key_type: str) -> str:
 def verify_apitoken(token: Annotated[str, Security(__get_api_token)]) -> str:
     """
     使用 API Token 进行身份认证
-    :param token: API Token，从 URL 查询参数中获取
+    :param token: API Token，从 URL 查询参数中获取 token=xxx
     :return: 返回校验通过的 API Token
     """
-    return __verify_key(token, settings.API_TOKEN, "API_TOKEN")
+    return __verify_key(token, settings.API_TOKEN, "token")
 
 
 def verify_apikey(apikey: Annotated[str, Security(__get_api_key)]) -> str:
     """
     使用 API Key 进行身份认证
-    :param apikey: API Key，从 URL 查询参数或请求头中获取
+    :param apikey: API Key，从 URL 查询参数中获取 apikey=xxx
     :return: 返回校验通过的 API Key
     """
-    return __verify_key(apikey, settings.API_TOKEN, "API_KEY")
+    return __verify_key(apikey, settings.API_TOKEN, "apikey")
 
 
 def verify_password(plain_password: str, hashed_password: str) -> bool:

app/db/__init__.py

@@ -1,19 +1,43 @@
 import asyncio
-from typing import Any, Generator, List, Optional, Self, Tuple, AsyncGenerator, Sequence, Union
+from typing import Any, Generator, List, Optional, Self, Tuple, AsyncGenerator, Union
 
-from sqlalchemy import NullPool, QueuePool, and_, create_engine, inspect, text, select, delete
+from sqlalchemy import NullPool, QueuePool, and_, create_engine, inspect, text, select, delete, Column, Integer, \
+    Sequence, Identity
 from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession, async_sessionmaker
 from sqlalchemy.orm import Session, as_declarative, declared_attr, scoped_session, sessionmaker
 
 from app.core.config import settings
 
 
+def get_id_column():
+    """
+    根据数据库类型返回合适的ID列定义
+    """
+    if settings.DB_TYPE.lower() == "postgresql":
+        # PostgreSQL使用SERIAL类型，让数据库自动处理序列
+        return Column(Integer, Identity(start=1, cycle=True), primary_key=True, index=True)
+    else:
+        # SQLite使用Sequence
+        return Column(Integer, Sequence('id'), primary_key=True, index=True)
+
+
 def _get_database_engine(is_async: bool = False):
     """
     获取数据库连接参数并设置WAL模式
     :param is_async: 是否创建异步引擎，True - 异步引擎, False - 同步引擎
     :return: 返回对应的数据库引擎
     """
+    # 根据数据库类型选择连接方式
+    if settings.DB_TYPE.lower() == "postgresql":
+        return _get_postgresql_engine(is_async)
+    else:
+        return _get_sqlite_engine(is_async)
+
+
+def _get_sqlite_engine(is_async: bool = False):
+    """
+    获取SQLite数据库引擎
+    """
     # 连接参数
     _connect_args = {
         "timeout": settings.DB_TIMEOUT,
@@ -40,9 +64,9 @@ def _get_database_engine(is_async: bool = False):
         # 当使用 QueuePool 时，添加 QueuePool 特有的参数
         if _pool_class == QueuePool:
             _db_kwargs.update({
-                "pool_size": settings.CONF.dbpool,
+                "pool_size": settings.DB_SQLITE_POOL_SIZE,
                 "pool_timeout": settings.DB_POOL_TIMEOUT,
-                "max_overflow": settings.CONF.dbpooloverflow
+                "max_overflow": settings.DB_SQLITE_MAX_OVERFLOW
             })
 
         # 创建数据库引擎
@@ -52,7 +76,7 @@ def _get_database_engine(is_async: bool = False):
         _journal_mode = "WAL" if settings.DB_WAL_ENABLE else "DELETE"
         with engine.connect() as connection:
             current_mode = connection.execute(text(f"PRAGMA journal_mode={_journal_mode};")).scalar()
-            print(f"Database journal mode set to: {current_mode}")
+            print(f"SQLite database journal mode set to: {current_mode}")
 
         return engine
     else:
@@ -78,12 +102,73 @@ def _get_database_engine(is_async: bool = False):
             async with async_engine.connect() as _connection:
                 result = await _connection.execute(text(f"PRAGMA journal_mode={_journal_mode};"))
                 _current_mode = result.scalar()
-                print(f"Async database journal mode set to: {_current_mode}")
+                print(f"Async SQLite database journal mode set to: {_current_mode}")
 
         try:
             asyncio.run(set_async_wal_mode())
         except Exception as e:
-            print(f"Failed to set async WAL mode: {e}")
+            print(f"Failed to set async SQLite WAL mode: {e}")
+
+        return async_engine
+
+
+def _get_postgresql_engine(is_async: bool = False):
+    """
+    获取PostgreSQL数据库引擎
+    """
+    # 构建PostgreSQL连接URL
+    if settings.DB_POSTGRESQL_PASSWORD:
+        db_url = f"postgresql://{settings.DB_POSTGRESQL_USERNAME}:{settings.DB_POSTGRESQL_PASSWORD}@{settings.DB_POSTGRESQL_HOST}:{settings.DB_POSTGRESQL_PORT}/{settings.DB_POSTGRESQL_DATABASE}"
+    else:
+        db_url = f"postgresql://{settings.DB_POSTGRESQL_USERNAME}@{settings.DB_POSTGRESQL_HOST}:{settings.DB_POSTGRESQL_PORT}/{settings.DB_POSTGRESQL_DATABASE}"
+
+    # PostgreSQL连接参数
+    _connect_args = {}
+
+    # 创建同步引擎
+    if not is_async:
+        # 根据池类型设置 poolclass 和相关参数
+        _pool_class = NullPool if settings.DB_POOL_TYPE == "NullPool" else QueuePool
+
+        # 数据库参数
+        _db_kwargs = {
+            "url": db_url,
+            "pool_pre_ping": settings.DB_POOL_PRE_PING,
+            "echo": settings.DB_ECHO,
+            "poolclass": _pool_class,
+            "pool_recycle": settings.DB_POOL_RECYCLE,
+            "connect_args": _connect_args
+        }
+
+        # 当使用 QueuePool 时，添加 QueuePool 特有的参数
+        if _pool_class == QueuePool:
+            _db_kwargs.update({
+                "pool_size": settings.DB_POSTGRESQL_POOL_SIZE,
+                "pool_timeout": settings.DB_POOL_TIMEOUT,
+                "max_overflow": settings.DB_POSTGRESQL_MAX_OVERFLOW
+            })
+
+        # 创建数据库引擎
+        engine = create_engine(**_db_kwargs)
+        print(f"PostgreSQL database connected to {settings.DB_POSTGRESQL_HOST}:{settings.DB_POSTGRESQL_PORT}/{settings.DB_POSTGRESQL_DATABASE}")
+
+        return engine
+    else:
+        # 构建异步PostgreSQL连接URL
+        async_db_url = f"postgresql+asyncpg://{settings.DB_POSTGRESQL_USERNAME}:{settings.DB_POSTGRESQL_PASSWORD}@{settings.DB_POSTGRESQL_HOST}:{settings.DB_POSTGRESQL_PORT}/{settings.DB_POSTGRESQL_DATABASE}"
+
+        # 数据库参数，只能使用 NullPool
+        _db_kwargs = {
+            "url": async_db_url,
+            "pool_pre_ping": settings.DB_POOL_PRE_PING,
+            "echo": settings.DB_ECHO,
+            "poolclass": NullPool,
+            "pool_recycle": settings.DB_POOL_RECYCLE,
+            "connect_args": _connect_args
+        }
+        # 创建异步数据库引擎
+        async_engine = create_async_engine(**_db_kwargs)
+        print(f"Async PostgreSQL database connected to {settings.DB_POSTGRESQL_HOST}:{settings.DB_POSTGRESQL_PORT}/{settings.DB_POSTGRESQL_DATABASE}")
 
         return async_engine
 

app/db/init.py

@@ -18,12 +18,22 @@ def update_db():
     """
     更新数据库
     """
-    db_location = settings.CONFIG_PATH / 'user.db'
     script_location = settings.ROOT_PATH / 'database'
     try:
         alembic_cfg = Config()
         alembic_cfg.set_main_option('script_location', str(script_location))
-        alembic_cfg.set_main_option('sqlalchemy.url', f"sqlite:///{db_location}")
+        
+        # 根据数据库类型设置不同的URL
+        if settings.DB_TYPE.lower() == "postgresql":
+            if settings.DB_POSTGRESQL_PASSWORD:
+                db_url = f"postgresql://{settings.DB_POSTGRESQL_USERNAME}:{settings.DB_POSTGRESQL_PASSWORD}@{settings.DB_POSTGRESQL_HOST}:{settings.DB_POSTGRESQL_PORT}/{settings.DB_POSTGRESQL_DATABASE}"
+            else:
+                db_url = f"postgresql://{settings.DB_POSTGRESQL_USERNAME}@{settings.DB_POSTGRESQL_HOST}:{settings.DB_POSTGRESQL_PORT}/{settings.DB_POSTGRESQL_DATABASE}"
+        else:
+            db_location = settings.CONFIG_PATH / 'user.db'
+            db_url = f"sqlite:///{db_location}"
+            
+        alembic_cfg.set_main_option('sqlalchemy.url', db_url)
         upgrade(alembic_cfg, 'head')
     except Exception as e:
         logger.error(f'数据库更新失败：{str(e)}')

app/db/models/downloadhistory.py

@@ -1,18 +1,18 @@
 import time
 from typing import Optional
 
-from sqlalchemy import Column, Integer, String, Sequence, JSON, select
+from sqlalchemy import Column, Integer, String, JSON, select
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.orm import Session
 
-from app.db import db_query, db_update, Base, async_db_query
+from app.db import db_query, db_update, get_id_column, Base, async_db_query
 
 
 class DownloadHistory(Base):
     """
     下载历史记录
     """
-    id = Column(Integer, Sequence('id'), primary_key=True, index=True)
+    id = get_id_column()
     # 保存路径
     path = Column(String, nullable=False, index=True)
     # 类型 电影/电视剧
@@ -188,7 +188,7 @@ class DownloadFiles(Base):
     """
     下载文件记录
     """
-    id = Column(Integer, Sequence('id'), primary_key=True, index=True)
+    id = get_id_column()
     # 下载器
     downloader = Column(String)
     # 下载任务Hash

app/db/models/mediaserver.py

@@ -1,19 +1,19 @@
 from datetime import datetime
 from typing import Optional
 
-from sqlalchemy import Column, Integer, String, Sequence, JSON
+from sqlalchemy import Column, Integer, String, JSON
 from sqlalchemy import select
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.orm import Session
 
-from app.db import db_query, db_update, async_db_query, Base
+from app.db import db_query, db_update, get_id_column, async_db_query, Base
 
 
 class MediaServerItem(Base):
     """
     媒体服务器媒体条目表
     """
-    id = Column(Integer, Sequence('id'), primary_key=True, index=True)
+    id = get_id_column()
     # 服务器类型
     server = Column(String)
     # 媒体库ID

app/db/models/message.py

@@ -1,17 +1,17 @@
 from typing import Optional
 
-from sqlalchemy import Column, Integer, String, Sequence, JSON, select
+from sqlalchemy import Column, Integer, String, JSON, select
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.orm import Session
 
-from app.db import db_query, Base, async_db_query
+from app.db import db_query, Base, get_id_column, async_db_query
 
 
 class Message(Base):
     """
     消息表
     """
-    id = Column(Integer, Sequence('id'), primary_key=True, index=True)
+    id = get_id_column()
     # 消息渠道
     channel = Column(String)
     # 消息来源

app/db/models/plugindata.py

@@ -1,14 +1,14 @@
-from sqlalchemy import Column, Integer, String, Sequence, JSON
+from sqlalchemy import Column, String, JSON
 from sqlalchemy.orm import Session
 
-from app.db import db_query, db_update, Base
+from app.db import db_query, db_update, get_id_column, Base
 
 
 class PluginData(Base):
     """
     插件数据表
     """
-    id = Column(Integer, Sequence('id'), primary_key=True, index=True)
+    id = get_id_column()
     plugin_id = Column(String, nullable=False, index=True)
     key = Column(String, index=True, nullable=False)
     value = Column(JSON)

app/db/models/site.py

@@ -1,17 +1,17 @@
 from datetime import datetime
 
-from sqlalchemy import Boolean, Column, Integer, String, Sequence, JSON, select, delete
+from sqlalchemy import Boolean, Column, Integer, String, JSON, select, delete
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.orm import Session
 
-from app.db import db_query, db_update, Base, async_db_query, async_db_update
+from app.db import db_query, db_update, Base, async_db_query, async_db_update, get_id_column
 
 
 class Site(Base):
     """
     站点表
     """
-    id = Column(Integer, Sequence('id'), primary_key=True, index=True)
+    id = get_id_column()
     # 站点名
     name = Column(String, nullable=False)
     # 域名Key
@@ -69,12 +69,12 @@ class Site(Base):
     @classmethod
     @db_query
     def get_actives(cls, db: Session):
-        return db.query(cls).filter(cls.is_active == 1).all()
+        return db.query(cls).filter(cls.is_active).all()
 
     @classmethod
     @async_db_query
     async def async_get_actives(cls, db: AsyncSession):
-        result = await db.execute(select(cls).where(cls.is_active == 1))
+        result = await db.execute(select(cls).where(cls.is_active))
         return result.scalars().all()
 
     @classmethod

app/db/models/siteicon.py

@@ -1,15 +1,15 @@
-from sqlalchemy import Column, Integer, String, Sequence, select
+from sqlalchemy import Column, String, select
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.orm import Session
 
-from app.db import db_query, Base, async_db_query
+from app.db import db_query, Base, get_id_column, async_db_query
 
 
 class SiteIcon(Base):
     """
     站点图标表
     """
-    id = Column(Integer, Sequence('id'), primary_key=True, index=True)
+    id = get_id_column()
     # 站点名称
     name = Column(String, nullable=False)
     # 域名Key

app/db/models/sitestatistic.py

@@ -1,17 +1,17 @@
 from datetime import datetime
 
-from sqlalchemy import Column, Integer, String, Sequence, JSON, select
+from sqlalchemy import Column, Integer, String, JSON, select
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.orm import Session
 
-from app.db import db_query, db_update, Base, async_db_query
+from app.db import db_query, db_update, get_id_column, Base, async_db_query
 
 
 class SiteStatistic(Base):
     """
     站点统计表
     """
-    id = Column(Integer, Sequence('id'), primary_key=True, index=True)
+    id = get_id_column()
     # 域名Key
     domain = Column(String, index=True)
     # 成功次数

app/db/models/siteuserdata.py

@@ -1,18 +1,18 @@
 from datetime import datetime
 from typing import Optional
 
-from sqlalchemy import Column, Integer, String, Sequence, Float, JSON, func, or_, select
+from sqlalchemy import Column, Integer, String, Float, JSON, func, or_, select
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.orm import Session
 
-from app.db import db_query, Base, async_db_query
+from app.db import db_query, Base, get_id_column, async_db_query
 
 
 class SiteUserData(Base):
     """
     站点数据表
     """
-    id = Column(Integer, Sequence('id'), primary_key=True, index=True)
+    id = get_id_column()
     # 站点域名
     domain = Column(String, index=True)
     # 站点名称
@@ -20,7 +20,7 @@ class SiteUserData(Base):
     # 用户名
     username = Column(String)
     # 用户ID
-    userid = Column(Integer)
+    userid = Column(String)
     # 用户等级
     user_level = Column(String)
     # 加入时间

app/db/models/subscribe.py

@@ -1,18 +1,18 @@
 import time
 from typing import Optional
 
-from sqlalchemy import Column, Integer, String, Sequence, Float, JSON, select
+from sqlalchemy import Column, Integer, String, Float, JSON, select
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.orm import Session
 
-from app.db import db_query, db_update, Base, async_db_query, async_db_update
+from app.db import db_query, db_update, get_id_column, Base, async_db_query, async_db_update
 
 
 class Subscribe(Base):
     """
     订阅表
     """
-    id = Column(Integer, Sequence('id'), primary_key=True, index=True)
+    id = get_id_column()
     # 标题
     name = Column(String, nullable=False, index=True)
     # 年份

app/db/models/subscribehistory.py

@@ -1,17 +1,17 @@
 from typing import Optional
 
-from sqlalchemy import Column, Integer, String, Sequence, Float, JSON, select
+from sqlalchemy import Column, Integer, String, Float, JSON, select
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.orm import Session
 
-from app.db import db_query, Base, async_db_query
+from app.db import db_query, Base, get_id_column, async_db_query
 
 
 class SubscribeHistory(Base):
     """
     订阅历史表
     """
-    id = Column(Integer, Sequence('id'), primary_key=True, index=True)
+    id = get_id_column()
     # 标题
     name = Column(String, nullable=False, index=True)
     # 年份

app/db/models/systemconfig.py

@@ -1,15 +1,15 @@
-from sqlalchemy import Column, Integer, String, Sequence, JSON, select
+from sqlalchemy import Column, String, JSON, select
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.orm import Session
 
-from app.db import db_query, db_update, Base, async_db_query
+from app.db import db_query, db_update, Base, async_db_query, get_id_column
 
 
 class SystemConfig(Base):
     """
     配置表
     """
-    id = Column(Integer, Sequence('id'), primary_key=True, index=True)
+    id = get_id_column()
     # 主键
     key = Column(String, index=True)
     # 值

app/db/models/transferhistory.py

@@ -1,18 +1,18 @@
 import time
 from typing import Optional
 
-from sqlalchemy import Column, Integer, String, Sequence, Boolean, func, or_, JSON, select
+from sqlalchemy import Column, Integer, String, Boolean, func, or_, JSON, select
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.orm import Session
 
-from app.db import db_query, db_update, Base, async_db_query
+from app.db import db_query, db_update, get_id_column, Base, async_db_query
 
 
 class TransferHistory(Base):
     """
     整理记录
     """
-    id = Column(Integer, Sequence('id'), primary_key=True, index=True)
+    id = get_id_column()
     # 源路径
     src = Column(String, index=True)
     # 源存储
@@ -65,76 +65,92 @@ class TransferHistory(Base):
     def list_by_title(cls, db: Session, title: str, page: Optional[int] = 1, count: Optional[int] = 30,
                       status: bool = None):
         if status is not None:
-            return db.query(cls).filter(
+            query = db.query(cls).filter(
                 cls.status == status
             ).order_by(
                 cls.date.desc()
-            ).offset((page - 1) * count).limit(count).all()
+            )
         else:
-            return db.query(cls).filter(or_(
+            query = db.query(cls).filter(or_(
                 cls.title.like(f'%{title}%'),
                 cls.src.like(f'%{title}%'),
                 cls.dest.like(f'%{title}%'),
             )).order_by(
                 cls.date.desc()
-            ).offset((page - 1) * count).limit(count).all()
+            )
+        
+        # 当count为负数时，不限制页数查询所有
+        if count >= 0:
+            query = query.offset((page - 1) * count).limit(count)
+        
+        return query.all()
 
     @classmethod
     @async_db_query
     async def async_list_by_title(cls, db: AsyncSession, title: str, page: Optional[int] = 1, count: Optional[int] = 30,
                                   status: bool = None):
         if status is not None:
-            result = await db.execute(
-                select(cls).filter(
-                    cls.status == status
-                ).order_by(
-                    cls.date.desc()
-                ).offset((page - 1) * count).limit(count)
+            query = select(cls).filter(
+                cls.status == status
+            ).order_by(
+                cls.date.desc()
             )
         else:
-            result = await db.execute(
-                select(cls).filter(or_(
-                    cls.title.like(f'%{title}%'),
-                    cls.src.like(f'%{title}%'),
-                    cls.dest.like(f'%{title}%'),
-                )).order_by(
-                    cls.date.desc()
-                ).offset((page - 1) * count).limit(count)
+            query = select(cls).filter(or_(
+                cls.title.like(f'%{title}%'),
+                cls.src.like(f'%{title}%'),
+                cls.dest.like(f'%{title}%'),
+            )).order_by(
+                cls.date.desc()
             )
+        
+        # 当count为负数时，不限制页数查询所有
+        if count >= 0:
+            query = query.offset((page - 1) * count).limit(count)
+        
+        result = await db.execute(query)
         return result.scalars().all()
 
     @classmethod
     @db_query
     def list_by_page(cls, db: Session, page: Optional[int] = 1, count: Optional[int] = 30, status: bool = None):
         if status is not None:
-            return db.query(cls).filter(
+            query = db.query(cls).filter(
                 cls.status == status
             ).order_by(
                 cls.date.desc()
-            ).offset((page - 1) * count).limit(count).all()
+            )
         else:
-            return db.query(cls).order_by(
+            query = db.query(cls).order_by(
                 cls.date.desc()
-            ).offset((page - 1) * count).limit(count).all()
+            )
+        
+        # 当count为负数时，不限制页数查询所有
+        if count >= 0:
+            query = query.offset((page - 1) * count).limit(count)
+        
+        return query.all()
 
     @classmethod
     @async_db_query
     async def async_list_by_page(cls, db: AsyncSession, page: Optional[int] = 1, count: Optional[int] = 30,
                                  status: bool = None):
         if status is not None:
-            result = await db.execute(
-                select(cls).filter(
-                    cls.status == status
-                ).order_by(
-                    cls.date.desc()
-                ).offset((page - 1) * count).limit(count)
+            query = select(cls).filter(
+                cls.status == status
+            ).order_by(
+                cls.date.desc()
             )
         else:
-            result = await db.execute(
-                select(cls).order_by(
-                    cls.date.desc()
-                ).offset((page - 1) * count).limit(count)
+            query = select(cls).order_by(
+                cls.date.desc()
             )
+        
+        # 当count为负数时，不限制页数查询所有
+        if count >= 0:
+            query = query.offset((page - 1) * count).limit(count)
+        
+        result = await db.execute(query)
         return result.scalars().all()
 
     @classmethod

app/db/models/user.py

@@ -1,8 +1,8 @@
-from sqlalchemy import Boolean, Column, Integer, JSON, Sequence, String, select
+from sqlalchemy import Boolean, Column, JSON, String, select
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.orm import Session
 
-from app.db import Base, db_query, db_update, async_db_query, async_db_update
+from app.db import Base, db_query, db_update, async_db_query, async_db_update, get_id_column
 
 
 class User(Base):
@@ -10,7 +10,7 @@ class User(Base):
     用户表
     """
     # ID
-    id = Column(Integer, Sequence('id'), primary_key=True, index=True)
+    id = get_id_column()
     # 用户名，唯一值
     name = Column(String, index=True, nullable=False)
     # 邮箱

app/db/models/userconfig.py

@@ -1,14 +1,14 @@
-from sqlalchemy import Column, Integer, String, Sequence, UniqueConstraint, Index, JSON
+from sqlalchemy import Column, String, UniqueConstraint, Index, JSON
 from sqlalchemy.orm import Session
 
-from app.db import db_query, db_update, Base
+from app.db import db_query, db_update, get_id_column, Base
 
 
 class UserConfig(Base):
     """
     用户配置表
     """
-    id = Column(Integer, Sequence('id'), primary_key=True, index=True)
+    id = get_id_column()
     # 用户名
     username = Column(String, index=True)
     # 配置键

app/db/models/workflow.py

@@ -1,10 +1,10 @@
 from datetime import datetime
 from typing import Optional
 
-from sqlalchemy import Column, Integer, JSON, Sequence, String, and_, or_, select
+from sqlalchemy import Column, Integer, JSON, String, and_, or_, select
 from sqlalchemy.ext.asyncio import AsyncSession
 
-from app.db import Base, db_query, db_update, async_db_query, async_db_update
+from app.db import Base, db_query, get_id_column, db_update, async_db_query, async_db_update
 
 
 class Workflow(Base):
@@ -12,7 +12,7 @@ class Workflow(Base):
     工作流表
     """
     # ID
-    id = Column(Integer, Sequence('id'), primary_key=True, index=True)
+    id = get_id_column()
     # 名称
     name = Column(String, index=True, nullable=False)
     # 描述

app/db/subscribe_oper.py

@@ -34,6 +34,7 @@ class SubscribeOper(DbOper):
             "backdrop": mediainfo.get_backdrop_image(),
             "vote": mediainfo.vote_average,
             "description": mediainfo.overview,
+            "search_imdbid": 1 if kwargs.get('search_imdbid') else 0,
             "date": time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
         })
         if not subscribe:
@@ -108,7 +109,7 @@ class SubscribeOper(DbOper):
         """
         获取订阅
         """
-        return await Subscribe.async_get(self._db, id=sid)
+        return await Subscribe.async_get(self._db, rid=sid)
 
     def list(self, state: Optional[str] = None) -> List[Subscribe]:
         """
@@ -118,6 +119,14 @@ class SubscribeOper(DbOper):
             return Subscribe.get_by_state(self._db, state)
         return Subscribe.list(self._db)
 
+    async def async_list(self, state: Optional[str] = None) -> List[Subscribe]:
+        """
+        异步获取订阅列表
+        """
+        if state:
+            return await Subscribe.async_get_by_state(self._db, state)
+        return await Subscribe.async_list(self._db)
+
     def delete(self, sid: int):
         """
         删除订阅

app/factory.py

@@ -2,7 +2,6 @@ from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
 
 from app.core.config import settings
-from app.monitoring import setup_prometheus_metrics
 from app.startup.lifecycle import lifespan
 
 
@@ -25,9 +24,6 @@ def create_app() -> FastAPI:
         allow_headers=["*"],
     )
 
-    # 设置性能监控
-    setup_prometheus_metrics(_app)
-
     return _app
 
 

app/helper/browser.py

@@ -1,9 +1,12 @@
+import uuid
 from typing import Callable, Any, Optional
 
 from cf_clearance import sync_cf_retry, sync_stealth
 from playwright.sync_api import sync_playwright, Page
 
+from app.core.config import settings
 from app.log import logger
+from app.utils.http import RequestUtils, cookie_parse
 
 
 class PlaywrightHelper:
@@ -19,13 +22,120 @@ class PlaywrightHelper:
         page.goto(url)
         return sync_cf_retry(page)[0]
 
+    @staticmethod
+    def __fs_cookie_str(cookies: list) -> str:
+        if not cookies:
+            return ""
+        return "; ".join([f"{c.get('name')}={c.get('value')}" for c in cookies if c and c.get('name') is not None])
+
+    @staticmethod
+    def __flaresolverr_request(url: str,
+                               cookies: Optional[str] = None,
+                               proxy_config: Optional[dict] = None,
+                               timeout: Optional[int] = 60) -> Optional[dict]:
+        """
+        调用 FlareSolverr 解决 Cloudflare 并返回 solution 结果
+        参考: https://github.com/FlareSolverr/FlareSolverr
+        """
+        if not settings.FLARESOLVERR_URL:
+            logger.warn("未配置 FLARESOLVERR_URL，无法使用 FlareSolverr")
+            return None
+
+        fs_api = settings.FLARESOLVERR_URL.rstrip("/") + "/v1"
+        session_id = None
+
+        try:
+            # 检查是否需要代理认证
+            need_proxy_auth = (proxy_config and proxy_config.get("server") and
+                               (proxy_config.get("username") or proxy_config.get("password")))
+
+            if need_proxy_auth:
+                # 使用 session 模式支持代理认证
+                logger.debug("检测到flaresolverr代理需要认证，使用 session 模式")
+
+                # 1. 创建会话
+                session_id = str(uuid.uuid4())
+                create_payload: dict = {
+                    "cmd": "sessions.create",
+                    "session": session_id
+                }
+
+                # 添加代理配置到会话创建请求
+                if proxy_config and proxy_config.get("server"):
+                    proxy_payload: dict = {"url": proxy_config["server"]}
+                    if proxy_config.get("username"):
+                        proxy_payload["username"] = proxy_config["username"]
+                    if proxy_config.get("password"):
+                        proxy_payload["password"] = proxy_config["password"]
+                    create_payload["proxy"] = proxy_payload
+
+                # 创建会话
+                create_result = RequestUtils(content_type="application/json",
+                                             timeout=timeout or 60).post_json(url=fs_api, json=create_payload)
+                if not create_result or create_result.get("status") != "ok":
+                    logger.error(
+                        f"创建 FlareSolverr 会话失败: {create_result.get('message') if create_result else '无响应'}")
+                    return None
+
+                # 2. 使用会话发送请求
+                request_payload = {
+                    "cmd": "request.get",
+                    "url": url,
+                    "session": session_id,
+                    "maxTimeout": int(timeout or 60) * 1000,
+                }
+            else:
+                # 使用普通模式（无代理认证）
+                request_payload = {
+                    "cmd": "request.get",
+                    "url": url,
+                    "maxTimeout": int(timeout or 60) * 1000,
+                }
+                # 添加代理配置（仅 URL，无认证）
+                if proxy_config and proxy_config.get("server"):
+                    request_payload["proxy"] = {"url": proxy_config["server"]}
+
+            # 将 cookies 以数组形式传递给 FlareSolverr
+            if cookies:
+                try:
+                    request_payload["cookies"] = cookie_parse(cookies, array=True)
+                except Exception as e:
+                    logger.debug(f"解析 cookies 失败，忽略: {str(e)}")
+
+            # 发送请求
+            data = RequestUtils(content_type="application/json",
+                                timeout=timeout or 60).post_json(url=fs_api, json=request_payload)
+            if not data:
+                logger.error("FlareSolverr 返回空响应")
+                return None
+            if data.get("status") != "ok":
+                logger.error(f"FlareSolverr 调用失败: {data.get('message')}")
+                return None
+            return data.get("solution")
+        except Exception as e:
+            logger.error(f"调用 FlareSolverr 失败: {str(e)}")
+            return None
+        finally:
+            # 清理会话
+            if session_id:
+                try:
+                    destroy_payload = {
+                        "cmd": "sessions.destroy",
+                        "session": session_id
+                    }
+                    RequestUtils(content_type="application/json",
+                                 timeout=10).post_json(url=fs_api, json=destroy_payload)
+                    logger.debug(f"已清理 FlareSolverr 会话: {session_id}")
+                except Exception as e:
+                    logger.warning(f"清理 FlareSolverr 会话失败: {str(e)}")
+
     def action(self, url: str,
                callback: Callable,
                cookies: Optional[str] = None,
                ua: Optional[str] = None,
                proxies: Optional[dict] = None,
                headless: Optional[bool] = False,
-               timeout: Optional[int] = 30) -> Any:
+               timeout: Optional[int] = 60) -> Any:
         """
         访问网页，接收Page对象并执行操作
         :param url: 网页地址
@@ -43,15 +153,30 @@ class PlaywrightHelper:
                 context = None
                 page = None
                 try:
+                    # 如果配置使用 FlareSolverr，先通过其获取清除后的 cookies 与 UA
+                    fs_cookie_header = None
+                    fs_ua = None
+                    if settings.BROWSER_EMULATION == "flaresolverr":
+                        solution = self.__flaresolverr_request(url=url, cookies=cookies,
+                                                               proxy_config=proxies, timeout=timeout)
+                        if solution:
+                            fs_cookie_header = self.__fs_cookie_str(solution.get("cookies", []))
+                            fs_ua = solution.get("userAgent")
+
                     browser = playwright[self.browser_type].launch(headless=headless)
-                    context = browser.new_context(user_agent=ua, proxy=proxies)
+                    context = browser.new_context(user_agent=fs_ua or ua, proxy=proxies)
                     page = context.new_page()
 
-                    if cookies:
-                        page.set_extra_http_headers({"cookie": cookies})
+                    # 优先使用 FlareSolverr 返回，其次使用入参
+                    merged_cookie = fs_cookie_header or cookies
+                    if merged_cookie:
+                        page.set_extra_http_headers({"cookie": merged_cookie})
 
-                    if not self.__pass_cloudflare(url, page):
-                        logger.warn("cloudflare challenge fail！")
+                    if settings.BROWSER_EMULATION == "playwright":
+                        if not self.__pass_cloudflare(url, page):
+                            logger.warn("cloudflare challenge fail！")
+                    else:
+                        page.goto(url)
                     page.wait_for_load_state("networkidle", timeout=timeout * 1000)
 
                     # 回调函数
@@ -76,7 +201,7 @@ class PlaywrightHelper:
                         ua: Optional[str] = None,
                         proxies: Optional[dict] = None,
                         headless: Optional[bool] = False,
-                        timeout: Optional[int] = 20) -> Optional[str]:
+                        timeout: Optional[int] = 60) -> Optional[str]:
         """
         获取网页源码
         :param url: 网页地址
@@ -87,6 +212,15 @@ class PlaywrightHelper:
         :param timeout: 超时时间
         """
         source = None
+        # 如果配置为 FlareSolverr，则直接调用获取页面源码
+        if settings.BROWSER_EMULATION == "flaresolverr":
+            try:
+                solution = self.__flaresolverr_request(url=url, cookies=cookies,
+                                                       proxy_config=proxies, timeout=timeout)
+                if solution:
+                    return solution.get("response")
+            except Exception as e:
+                logger.error(f"FlareSolverr 获取源码失败: {str(e)}")
         try:
             with sync_playwright() as playwright:
                 browser = None
@@ -121,13 +255,3 @@ class PlaywrightHelper:
             logger.error(f"Playwright初始化失败: {str(e)}")
 
         return source
-
-
-# 示例用法
-if __name__ == "__main__":
-    utils = PlaywrightHelper()
-    test_url = "https://piggo.me"
-    test_cookies = ""
-    test_user_agent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/93.0.4577.63 Safari/537.36"
-    source_code = utils.get_page_source(test_url, cookies=test_cookies, ua=test_user_agent)
-    print(source_code)

app/helper/cookie.py

@@ -74,7 +74,8 @@ class CookieHelper:
                            username: str,
                            password: str,
                            two_step_code: Optional[str] = None,
-                           proxies: Optional[dict] = None) -> Tuple[Optional[str], Optional[str], str]:
+                           proxies: Optional[dict] = None,
+                           timeout: int = None) -> Tuple[Optional[str], Optional[str], str]:
         """
         获取站点cookie和ua
         :param url: 站点地址
@@ -82,6 +83,7 @@ class CookieHelper:
         :param password: 密码
         :param two_step_code: 二步验证码或密钥
         :param proxies: 代理
+        :param timeout: 超时时间
         :return: cookie、ua、message
         """
 
@@ -230,7 +232,8 @@ class CookieHelper:
 
         return PlaywrightHelper().action(url=url,
                                          callback=__page_handler,
-                                         proxies=proxies)
+                                         proxies=proxies,
+                                         timeout=timeout)
 
     @staticmethod
     def __get_captcha_text(cookie: str, ua: str, code_url: str) -> str:

app/helper/message.py

@@ -10,9 +10,9 @@ from datetime import datetime
 from typing import Any, Literal, Optional, List, Dict, Union
 from typing import Callable
 
-from cachetools import TTLCache
 from jinja2 import Template
 
+from app.core.cache import TTLCache
 from app.core.config import global_vars
 from app.core.context import MediaInfo, TorrentInfo
 from app.core.meta import MetaBase
@@ -307,7 +307,7 @@ class TemplateHelper(metaclass=SingletonClass):
 
     def __init__(self):
         self.builder = TemplateContextBuilder()
-        self.cache = TTLCache(maxsize=100, ttl=600)
+        self.cache = TTLCache(region="notification", maxsize=100, ttl=600)
 
     @staticmethod
     def _generate_cache_key(cuntent: Union[str, dict]) -> str:
@@ -471,6 +471,13 @@ class TemplateHelper(metaclass=SingletonClass):
         except json.JSONDecodeError:
             return rendered
 
+    def close(self):
+        """
+        清理资源
+        """
+        if self.cache:
+            self.cache.close()
+
 
 class MessageTemplateHelper:
     """
@@ -704,6 +711,7 @@ class MessageQueueManager(metaclass=SingletonClass):
         停止队列管理器
         """
         self._running = False
+        logger.info("正在停止消息队列...")
         self.thread.join()
 
 
@@ -765,3 +773,13 @@ class MessageHelper(metaclass=Singleton):
             if not self.user_queue.empty():
                 return self.user_queue.get(block=False)
         return None
+
+
+def stop_message():
+    """
+    停止消息服务
+    """
+    # 停止消息队列
+    MessageQueueManager().stop()
+    # 关闭消息演染器
+    TemplateHelper().close()

app/helper/plugin.py

@@ -1,18 +1,18 @@
 import importlib
+import io
 import json
 import shutil
 import site
 import sys
 import traceback
+import zipfile
 from pathlib import Path
 from typing import Dict, List, Optional, Tuple, Set, Callable, Awaitable
-import zipfile
-import io
 
 import aiofiles
 import aioshutil
 import httpx
-from aiopath import AsyncPath
+from anyio import Path as AsyncPath
 from packaging.specifiers import SpecifierSet, InvalidSpecifier
 from packaging.version import Version, InvalidVersion
 from pkg_resources import Requirement, working_set
@@ -248,6 +248,7 @@ class PluginHelper(metaclass=WeakSingleton):
                 return False, f"未在插件清单中找到 {pid} 的版本号，无法进行 Release 安装"
             # 拼接 release_tag
             release_tag = f"{pid}_v{plugin_version}"
+
             # 使用 release 进行安装
             def prepare_release() -> Tuple[bool, str]:
                 return self.__install_from_release(
@@ -456,7 +457,18 @@ class PluginHelper(metaclass=WeakSingleton):
         :param requirements_file: 依赖的 requirements.txt 文件路径
         :return: (是否成功, 错误信息)
         """
-        base_cmd = [sys.executable, "-m", "pip", "install", "-r", str(requirements_file)]
+        wheels_dir = requirements_file.parent / "wheels"
+
+        find_links_option = []
+        if wheels_dir.is_dir():
+            # 如果目录存在，增加 --find-links 选项
+            logger.debug(f"[PIP] 发现插件内嵌的 wheels 目录: {wheels_dir}，将优先从本地安装。")
+            find_links_option = ["--find-links", str(wheels_dir)]
+        else:
+            # 如果不存在，选项为空列表，对后续命令无影响
+            logger.debug(f"[PIP] 未发现插件内嵌的 wheels 目录，将仅使用在线源。")
+
+        base_cmd = [sys.executable, "-m", "pip", "install"] + find_links_option + ["-r", str(requirements_file)]
         strategies = []
 
         # 添加策略到列表中
@@ -533,12 +545,12 @@ class PluginHelper(metaclass=WeakSingleton):
         return None
 
     def __get_plugin_meta(self, pid: str, repo_url: str,
-                           package_version: Optional[str]) -> dict:
+                          package_version: Optional[str]) -> dict:
         try:
             plugins = (
-                self.get_plugins(repo_url) if not package_version
-                else self.get_plugins(repo_url, package_version)
-            ) or {}
+                          self.get_plugins(repo_url) if not package_version
+                          else self.get_plugins(repo_url, package_version)
+                      ) or {}
             meta = plugins.get(pid)
             return meta if isinstance(meta, dict) else {}
         except Exception as e:
@@ -607,14 +619,19 @@ class PluginHelper(metaclass=WeakSingleton):
             asset = next((a for a in assets if a.get("name") == asset_name), None)
             if not asset:
                 return False, f"未找到资产文件：{asset_name}"
-            download_url = asset.get("browser_download_url")
-            if not download_url:
-                return False, "资产缺少下载地址"
+            asset_id = asset.get("id")
+            if not asset_id:
+                return False, "资产缺少ID信息"
+            # 构建资产的API下载URL
+            download_url = f"https://api.github.com/repos/{user_repo}/releases/assets/{asset_id}"
         except Exception as e:
             logger.error(f"解析 Release 信息失败：{e}")
             return False, f"解析 Release 信息失败：{e}"
 
-        res = self.__request_with_fallback(download_url, headers=settings.REPO_GITHUB_HEADERS(repo=user_repo))
+        # 使用资产的API端点下载，需要设置Accept头为application/octet-stream
+        headers = settings.REPO_GITHUB_HEADERS(repo=user_repo).copy()
+        headers["Accept"] = "application/octet-stream"
+        res = self.__request_with_fallback(download_url, headers=headers, is_api=True)
         if res is None or res.status_code != 200:
             return False, f"下载资产失败：{res.status_code if res else '连接失败'}"
 
@@ -908,10 +925,10 @@ class PluginHelper(metaclass=WeakSingleton):
         """
         # 异步版本直接调用不带缓存的版本（缓存在异步环境下可能有并发问题）
         if force:
-            return await self._async_get_plugins_uncached(repo_url, package_version)
+            await self._async_get_plugins_cached.cache_clear()
         return await self._async_get_plugins_cached(repo_url, package_version)
 
-    @cached(maxsize=64, ttl=1800)
+    @cached(maxsize=128, ttl=1800)
     async def _async_get_plugins_cached(self, repo_url: str,
                                         package_version: Optional[str] = None) -> Optional[Dict[str, dict]]:
         """
@@ -1393,6 +1410,7 @@ class PluginHelper(metaclass=WeakSingleton):
                 return False, f"未在插件清单中找到 {pid} 的版本号，无法进行 Release 安装"
             # 拼接 release_tag
             release_tag = f"{pid}_v{plugin_version}"
+
             # 使用 release 进行安装
             async def prepare_release() -> Tuple[bool, str]:
                 return await self.__async_install_from_release(
@@ -1411,9 +1429,9 @@ class PluginHelper(metaclass=WeakSingleton):
                                       package_version: Optional[str]) -> dict:
         try:
             plugins = (
-                await self.async_get_plugins(repo_url) if not package_version
-                else await self.async_get_plugins(repo_url, package_version)
-            ) or {}
+                          await self.async_get_plugins(repo_url) if not package_version
+                          else await self.async_get_plugins(repo_url, package_version)
+                      ) or {}
             meta = plugins.get(pid)
             return meta if isinstance(meta, dict) else {}
         except Exception as e:
@@ -1521,14 +1539,21 @@ class PluginHelper(metaclass=WeakSingleton):
             asset = next((a for a in assets if a.get("name") == asset_name), None)
             if not asset:
                 return False, f"未找到资产文件：{asset_name}"
-            download_url = asset.get("browser_download_url")
-            if not download_url:
-                return False, "资产缺少下载地址"
+            asset_id = asset.get("id")
+            if not asset_id:
+                return False, "资产缺少ID信息"
+            # 构建资产的API下载URL
+            download_url = f"https://api.github.com/repos/{user_repo}/releases/assets/{asset_id}"
         except Exception as e:
             logger.error(f"解析 Release 信息失败：{e}")
             return False, f"解析 Release 信息失败：{e}"
 
-        res = await self.__async_request_with_fallback(download_url, headers=settings.REPO_GITHUB_HEADERS(repo=user_repo))
+        # 使用资产的API端点下载，需要设置Accept头为application/octet-stream
+        headers = settings.REPO_GITHUB_HEADERS(repo=user_repo).copy()
+        headers["Accept"] = "application/octet-stream"
+        res = await self.__async_request_with_fallback(download_url,
+                                                       headers=headers,
+                                                       is_api=True)
         if res is None or res.status_code != 200:
             return False, f"下载资产失败：{res.status_code if res else '连接失败'}"
 

app/helper/progress.py

@@ -1,55 +1,76 @@
 from enum import Enum
 from typing import Union, Optional
 
+from app.core.cache import TTLCache
 from app.schemas.types import ProgressKey
 from app.utils.singleton import WeakSingleton
 
 
 class ProgressHelper(metaclass=WeakSingleton):
+    """
+    处理进度辅助类
+    """
 
-    def __init__(self):
-        self._process_detail = {}
-
-    def init_config(self):
-        pass
-
-    def __reset(self, key: Union[ProgressKey, str]):
+    def __init__(self, key: Union[ProgressKey, str]):
         if isinstance(key, Enum):
             key = key.value
-        self._process_detail[key] = {
+        self._key = key
+        self._progress = TTLCache(region="progress", maxsize=1024, ttl=24 * 60 * 60)
+
+    def __reset(self):
+        """
+        重置进度
+        """
+        self._progress[self._key] = {
             "enable": False,
             "value": 0,
-            "text": "请稍候..."
+            "text": "请稍候...",
+            "data": {}
         }
 
-    def start(self, key: Union[ProgressKey, str]):
-        self.__reset(key)
-        if isinstance(key, Enum):
-            key = key.value
-        self._process_detail[key]['enable'] = True
-
-    def end(self, key: Union[ProgressKey, str]):
-        if isinstance(key, Enum):
-            key = key.value
-        if not self._process_detail.get(key):
+    def start(self):
+        """
+        开始进度
+        """
+        self.__reset()
+        current = self._progress.get(self._key)
+        if not current:
             return
-        self._process_detail[key] = {
-            "enable": False,
-            "value": 100,
-            "text": "正在处理..."
-        }
+        current['enable'] = True
+        self._progress[self._key] = current
 
-    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'):
+    def end(self):
+        """
+        结束进度
+        """
+        current = self._progress.get(self._key)
+        if not current:
+            return
+        current.update(
+            {
+                "enable": False,
+                "value": 100,
+                "text": ""
+            }
+        )
+        self._progress[self._key] = current
+
+    def update(self, value: Union[float, int] = None, text: Optional[str] = None, data: dict = None):
+        """
+        更新进度
+        """
+        current = self._progress.get(self._key)
+        if not current or not current.get('enable'):
             return
         if value:
-            self._process_detail[key]['value'] = value
+            current['value'] = value
         if text:
-            self._process_detail[key]['text'] = text
+            current['text'] = text
+        if data:
+            if not current.get('data'):
+                current['data'] = {}
+            current['data'].update(data)
+        self._progress[self._key] = current
 
-    def get(self, key: Union[ProgressKey, str]) -> dict:
-        if isinstance(key, Enum):
-            key = key.value
-        return self._process_detail.get(key)
+    def get(self) -> dict:
+        return self._progress.get(self._key)

app/helper/redis.py

@@ -0,0 +1,548 @@
+import json
+import pickle
+from typing import Any, Optional, Generator, Tuple, AsyncGenerator, Union
+from urllib.parse import quote
+
+import redis
+from redis.asyncio import Redis
+
+from app.core.config import settings
+from app.core.event import eventmanager, Event
+from app.log import logger
+from app.schemas import ConfigChangeEventData
+from app.schemas.types import EventType
+from app.utils.singleton import Singleton
+
+# 类型缓存集合，针对非容器简单类型
+_complex_serializable_types = set()
+_simple_serializable_types = set()
+
+# 默认连接参数
+_socket_timeout = 30
+_socket_connect_timeout = 5
+_health_check_interval = 60
+
+
+def serialize(value: Any) -> bytes:
+    """
+    将值序列化为二进制数据，根据序列化方式标识格式
+    """
+
+    def _is_container_type(t):
+        """
+        判断是否为容器类型
+        """
+        return t in (list, dict, tuple, set)
+
+    vt = type(value)
+    # 针对非容器类型使用缓存策略
+    if not _is_container_type(vt):
+        # 如果已知需要复杂序列化
+        if vt in _complex_serializable_types:
+            return b"PICKLE" + b"\x00" + pickle.dumps(value)
+        # 如果已知可以简单序列化
+        if vt in _simple_serializable_types:
+            json_data = json.dumps(value).encode("utf-8")
+            return b"JSON" + b"\x00" + json_data
+        # 对于未知的非容器类型，尝试简单序列化，如抛出异常，再使用复杂序列化
+        try:
+            json_data = json.dumps(value).encode("utf-8")
+            _simple_serializable_types.add(vt)
+            return b"JSON" + b"\x00" + json_data
+        except TypeError:
+            _complex_serializable_types.add(vt)
+            return b"PICKLE" + b"\x00" + pickle.dumps(value)
+    else:
+        # 针对容器类型，每次尝试简单序列化，不使用缓存
+        try:
+            json_data = json.dumps(value).encode("utf-8")
+            return b"JSON" + b"\x00" + json_data
+        except TypeError:
+            return b"PICKLE" + b"\x00" + pickle.dumps(value)
+
+
+def deserialize(value: bytes) -> Any:
+    """
+    将二进制数据反序列化为原始值，根据格式标识区分序列化方式
+    """
+    format_marker, data = value.split(b"\x00", 1)
+    if format_marker == b"JSON":
+        return json.loads(data.decode("utf-8"))
+    elif format_marker == b"PICKLE":
+        return pickle.loads(data)
+    else:
+        raise ValueError("Unknown serialization format")
+
+
+class RedisHelper(metaclass=Singleton):
+    """
+    Redis连接和操作助手类，单例模式
+    
+    特性：
+    - 管理Redis连接池和客户端
+    - 提供序列化和反序列化功能
+    - 支持内存限制和淘汰策略设置
+    - 提供键名生成和区域管理功能
+    """
+
+    def __init__(self):
+        """
+        初始化Redis助手实例
+        """
+        self.redis_url = settings.CACHE_BACKEND_URL
+        self.client = None
+
+    def _connect(self):
+        """
+        建立Redis连接
+        """
+        try:
+            if self.client is None:
+                self.client = redis.Redis.from_url(
+                    self.redis_url,
+                    decode_responses=False,
+                    socket_timeout=_socket_timeout,
+                    socket_connect_timeout=_socket_connect_timeout,
+                    health_check_interval=_health_check_interval,
+                )
+                # 测试连接，确保Redis可用
+                self.client.ping()
+                logger.info(f"Successfully connected to Redis：{self.redis_url}")
+                self.set_memory_limit()
+        except Exception as e:
+            logger.error(f"Failed to connect to Redis: {e}")
+            self.client = None
+            raise RuntimeError("Redis connection failed") from e
+
+    @eventmanager.register(EventType.ConfigChanged)
+    def handle_config_changed(self, event: Event):
+        """
+        处理配置变更事件，更新Redis设置
+        :param event: 事件对象
+        """
+        if not event:
+            return
+        event_data: ConfigChangeEventData = event.event_data
+        if event_data.key not in ['CACHE_BACKEND_TYPE', 'CACHE_BACKEND_URL', 'CACHE_REDIS_MAXMEMORY']:
+            return
+        logger.info("配置变更，重连Redis...")
+        self.close()
+        self._connect()
+
+    def set_memory_limit(self, policy: Optional[str] = "allkeys-lru"):
+        """
+        动态设置Redis最大内存和内存淘汰策略
+        
+        :param policy: 淘汰策略（如'allkeys-lru'）
+        """
+        try:
+            # 如果有显式值，则直接使用，为0时说明不限制，如果未配置，开启BIG_MEMORY_MODE时为"1024mb"，未开启时为"256mb"
+            maxmemory = settings.CACHE_REDIS_MAXMEMORY or ("1024mb" if settings.BIG_MEMORY_MODE else "256mb")
+            self.client.config_set("maxmemory", maxmemory)
+            self.client.config_set("maxmemory-policy", policy)
+            logger.debug(f"Redis maxmemory set to {maxmemory}, policy: {policy}")
+        except Exception as e:
+            logger.error(f"Failed to set Redis maxmemory or policy: {e}")
+
+    @staticmethod
+    def __get_region(region: Optional[str] = None):
+        """
+        获取缓存的区
+        """
+        return f"region:{quote(region)}" if region else "region:DEFAULT"
+
+    def __make_redis_key(self, region: str, key: str) -> str:
+        """
+        获取缓存Key
+        """
+        # 使用region作为缓存键的一部分
+        region = self.__get_region(region)
+        return f"{region}:key:{quote(key)}"
+
+    @staticmethod
+    def __get_original_key(redis_key: Union[str, bytes]) -> str:
+        """
+        从Redis键中提取原始key
+        """
+        try:
+            if isinstance(redis_key, bytes):
+                redis_key = redis_key.decode("utf-8")
+            parts = redis_key.split(":key:")
+            return parts[-1]
+        except Exception as e:
+            logger.warn(f"Failed to parse redis key: {redis_key}, error: {e}")
+            return redis_key
+
+    def set(self, key: str, value: Any, ttl: Optional[int] = None,
+            region: Optional[str] = "DEFAULT", **kwargs) -> None:
+        """
+        设置缓存
+
+        :param key: 缓存的键
+        :param value: 缓存的值
+        :param ttl: 缓存的存活时间，单位秒
+        :param region: 缓存的区
+        :param kwargs: 其他参数
+        """
+        try:
+            self._connect()
+            redis_key = self.__make_redis_key(region, key)
+            # 对值进行序列化
+            serialized_value = serialize(value)
+            kwargs.pop("maxsize", None)
+            self.client.set(redis_key, serialized_value, ex=ttl, **kwargs)
+        except Exception as e:
+            logger.error(f"Failed to set key: {key} in region: {region}, error: {e}")
+
+    def exists(self, key: str, region: Optional[str] = "DEFAULT") -> bool:
+        """
+        判断缓存键是否存在
+
+        :param key: 缓存的键
+        :param region: 缓存的区
+        :return: 存在返回True，否则返回False
+        """
+        try:
+            self._connect()
+            redis_key = self.__make_redis_key(region, key)
+            return self.client.exists(redis_key) == 1
+        except Exception as e:
+            logger.error(f"Failed to exists key: {key} region: {region}, error: {e}")
+            return False
+
+    def get(self, key: str, region: Optional[str] = "DEFAULT") -> Optional[Any]:
+        """
+        获取缓存的值
+
+        :param key: 缓存的键
+        :param region: 缓存的区
+        :return: 返回缓存的值，如果缓存不存在返回None
+        """
+        try:
+            self._connect()
+            redis_key = self.__make_redis_key(region, key)
+            value = self.client.get(redis_key)
+            if value is not None:
+                return deserialize(value)
+            return None
+        except Exception as e:
+            logger.error(f"Failed to get key: {key} in region: {region}, error: {e}")
+            return None
+
+    def delete(self, key: str, region: Optional[str] = "DEFAULT") -> None:
+        """
+        删除缓存
+
+        :param key: 缓存的键
+        :param region: 缓存的区
+        """
+        try:
+            self._connect()
+            redis_key = self.__make_redis_key(region, key)
+            self.client.delete(redis_key)
+        except Exception as e:
+            logger.error(f"Failed to delete key: {key} in region: {region}, error: {e}")
+
+    def clear(self, region: Optional[str] = None) -> None:
+        """
+        清除指定区域的缓存或全部缓存
+
+        :param region: 缓存的区
+        """
+        try:
+            self._connect()
+            if region:
+                cache_region = self.__get_region(region)
+                redis_key = f"{cache_region}:key:*"
+                with self.client.pipeline() as pipe:
+                    for key in self.client.scan_iter(redis_key):
+                        pipe.delete(key)
+                    pipe.execute()
+                logger.info(f"Cleared Redis cache for region: {region}")
+            else:
+                self.client.flushdb()
+                logger.info("Cleared all Redis cache")
+        except Exception as e:
+            logger.error(f"Failed to clear cache, region: {region}, error: {e}")
+
+    def items(self, region: Optional[str] = None) -> Generator[Tuple[str, Any], None, None]:
+        """
+        获取指定区域的所有缓存键值对
+
+        :param region: 缓存的区
+        :return: 返回键值对生成器
+        """
+        try:
+            self._connect()
+            if region:
+                cache_region = self.__get_region(region)
+                redis_key = f"{cache_region}:key:*"
+                for key in self.client.scan_iter(redis_key):
+                    value = self.client.get(key)
+                    if value is not None:
+                        yield self.__get_original_key(key), deserialize(value)
+            else:
+                for key in self.client.scan_iter("*"):
+                    value = self.client.get(key)
+                    if value is not None:
+                        yield self.__get_original_key(key), deserialize(value)
+        except Exception as e:
+            logger.error(f"Failed to get items from Redis, region: {region}, error: {e}")
+
+    def test(self) -> bool:
+        """
+        测试Redis连接性
+        """
+        try:
+            self._connect()
+            return True
+        except Exception as e:
+            logger.error(f"Redis connection test failed: {e}")
+            return False
+
+    def close(self) -> None:
+        """
+        关闭Redis客户端的连接池
+        """
+        if self.client:
+            self.client.close()
+            self.client = None
+            logger.debug("Redis connection closed")
+
+
+class AsyncRedisHelper(metaclass=Singleton):
+    """
+    异步Redis连接和操作助手类，单例模式
+    
+    特性：
+    - 管理异步Redis连接池和客户端
+    - 提供序列化和反序列化功能
+    - 支持内存限制和淘汰策略设置
+    - 提供键名生成和区域管理功能
+    - 所有操作都是异步的
+    """
+
+    def __init__(self):
+        """
+        初始化异步Redis助手实例
+        """
+        self.redis_url = settings.CACHE_BACKEND_URL
+        self.client: Optional[Redis] = None
+
+    async def _connect(self):
+        """
+        建立异步Redis连接
+        """
+        try:
+            if self.client is None:
+                self.client = Redis.from_url(
+                    self.redis_url,
+                    decode_responses=False,
+                    socket_timeout=_socket_timeout,
+                    socket_connect_timeout=_socket_connect_timeout,
+                    health_check_interval=_health_check_interval,
+                )
+                # 测试连接，确保Redis可用
+                await self.client.ping()
+                logger.info(f"Successfully connected to Redis (async)：{self.redis_url}")
+                await self.set_memory_limit()
+        except Exception as e:
+            logger.error(f"Failed to connect to Redis (async): {e}")
+            self.client = None
+            raise RuntimeError("Redis async connection failed") from e
+
+    @eventmanager.register(EventType.ConfigChanged)
+    async def handle_config_changed(self, event: Event):
+        """
+        处理配置变更事件，更新Redis设置
+        :param event: 事件对象
+        """
+        if not event:
+            return
+        event_data: ConfigChangeEventData = event.event_data
+        if event_data.key not in ['CACHE_BACKEND_TYPE', 'CACHE_BACKEND_URL', 'CACHE_REDIS_MAXMEMORY']:
+            return
+        logger.info("配置变更，重连Redis (async)...")
+        await self.close()
+        await self._connect()
+
+    async def set_memory_limit(self, policy: Optional[str] = "allkeys-lru"):
+        """
+        动态设置Redis最大内存和内存淘汰策略
+        
+        :param policy: 淘汰策略（如'allkeys-lru'）
+        """
+        try:
+            # 如果有显式值，则直接使用，为0时说明不限制，如果未配置，开启BIG_MEMORY_MODE时为"1024mb"，未开启时为"256mb"
+            maxmemory = settings.CACHE_REDIS_MAXMEMORY or ("1024mb" if settings.BIG_MEMORY_MODE else "256mb")
+            await self.client.config_set("maxmemory", maxmemory)
+            await self.client.config_set("maxmemory-policy", policy)
+            logger.debug(f"Redis maxmemory set to {maxmemory}, policy: {policy} (async)")
+        except Exception as e:
+            logger.error(f"Failed to set Redis maxmemory or policy (async): {e}")
+
+    @staticmethod
+    def __get_region(region: Optional[str] = "DEFAULT"):
+        """
+        获取缓存的区
+        """
+        return f"region:{region}" if region else "region:default"
+
+    def __make_redis_key(self, region: str, key: str) -> str:
+        """
+        获取缓存Key
+        """
+        # 使用region作为缓存键的一部分
+        region = self.__get_region(region)
+        return f"{region}:key:{quote(key)}"
+
+    @staticmethod
+    def __get_original_key(redis_key: Union[str, bytes]) -> str:
+        """
+        从Redis键中提取原始key
+        """
+        try:
+            if isinstance(redis_key, bytes):
+                redis_key = redis_key.decode("utf-8")
+            parts = redis_key.split(":key:")
+            return parts[-1]
+        except Exception as e:
+            logger.warn(f"Failed to parse redis key: {redis_key}, error: {e}")
+            return redis_key
+
+    async def set(self, key: str, value: Any, ttl: Optional[int] = None,
+                  region: Optional[str] = "DEFAULT", **kwargs) -> None:
+        """
+        异步设置缓存
+
+        :param key: 缓存的键
+        :param value: 缓存的值
+        :param ttl: 缓存的存活时间，单位秒
+        :param region: 缓存的区
+        :param kwargs: 其他参数
+        """
+        try:
+            await self._connect()
+            redis_key = self.__make_redis_key(region, key)
+            # 对值进行序列化
+            serialized_value = serialize(value)
+            kwargs.pop("maxsize", None)
+            await self.client.set(redis_key, serialized_value, ex=ttl, **kwargs)
+        except Exception as e:
+            logger.error(f"Failed to set key (async): {key} in region: {region}, error: {e}")
+
+    async def exists(self, key: str, region: Optional[str] = "DEFAULT") -> bool:
+        """
+        异步判断缓存键是否存在
+
+        :param key: 缓存的键
+        :param region: 缓存的区
+        :return: 存在返回True，否则返回False
+        """
+        try:
+            await self._connect()
+            redis_key = self.__make_redis_key(region, key)
+            result = await self.client.exists(redis_key)
+            return result == 1
+        except Exception as e:
+            logger.error(f"Failed to exists key (async): {key} region: {region}, error: {e}")
+            return False
+
+    async def get(self, key: str, region: Optional[str] = "DEFAULT") -> Optional[Any]:
+        """
+        异步获取缓存的值
+
+        :param key: 缓存的键
+        :param region: 缓存的区
+        :return: 返回缓存的值，如果缓存不存在返回None
+        """
+        try:
+            await self._connect()
+            redis_key = self.__make_redis_key(region, key)
+            value = await self.client.get(redis_key)
+            if value is not None:
+                return deserialize(value)
+            return None
+        except Exception as e:
+            logger.error(f"Failed to get key (async): {key} in region: {region}, error: {e}")
+            return None
+
+    async def delete(self, key: str, region: Optional[str] = "DEFAULT") -> None:
+        """
+        异步删除缓存
+
+        :param key: 缓存的键
+        :param region: 缓存的区
+        """
+        try:
+            await self._connect()
+            redis_key = self.__make_redis_key(region, key)
+            await self.client.delete(redis_key)
+        except Exception as e:
+            logger.error(f"Failed to delete key (async): {key} in region: {region}, error: {e}")
+
+    async def clear(self, region: Optional[str] = None) -> None:
+        """
+        异步清除指定区域的缓存或全部缓存
+
+        :param region: 缓存的区
+        """
+        try:
+            await self._connect()
+            if region:
+                cache_region = self.__get_region(region)
+                redis_key = f"{cache_region}:key:*"
+                async with self.client.pipeline() as pipe:
+                    async for key in self.client.scan_iter(redis_key):
+                        await pipe.delete(key)
+                    await pipe.execute()
+                logger.info(f"Cleared Redis cache for region (async): {region}")
+            else:
+                await self.client.flushdb()
+                logger.info("Cleared all Redis cache (async)")
+        except Exception as e:
+            logger.error(f"Failed to clear cache (async), region: {region}, error: {e}")
+
+    async def items(self, region: Optional[str] = None) -> AsyncGenerator[Tuple[str, Any], None]:
+        """
+        获取指定区域的所有缓存键值对
+
+        :param region: 缓存的区
+        :return: 返回键值对生成器
+        """
+        try:
+            await self._connect()
+            if region:
+                cache_region = self.__get_region(region)
+                redis_key = f"{cache_region}:key:*"
+                async for key in self.client.scan_iter(redis_key):
+                    value = await self.client.get(key)
+                    if value is not None:
+                        yield self.__get_original_key(key), deserialize(value)
+            else:
+                async for key in self.client.scan_iter("*"):
+                    value = await self.client.get(key)
+                    if value is not None:
+                        yield self.__get_original_key(key), deserialize(value)
+        except Exception as e:
+            logger.error(f"Failed to get items from Redis, region: {region}, error: {e}")
+
+    async def test(self) -> bool:
+        """
+        异步测试Redis连接性
+        """
+        try:
+            await self._connect()
+            return True
+        except Exception as e:
+            logger.error(f"Redis async connection test failed: {e}")
+            return False
+
+    async def close(self) -> None:
+        """
+        关闭异步Redis客户端的连接池
+        """
+        if self.client:
+            await self.client.close()
+            self.client = None
+            logger.debug("Redis async connection closed")

app/helper/resource.py

@@ -8,7 +8,6 @@ from app.log import logger
 from app.utils.http import RequestUtils
 from app.utils.string import StringUtils
 from app.utils.system import SystemUtils
-from version import APP_VERSION
 
 
 class ResourceHelper:
@@ -59,12 +58,6 @@ class ResourceHelper:
                         if rtype == "auth":
                             # 站点认证资源
                             local_version = SitesHelper().auth_version
-                            # 阻断站点认证资源v2.3.0以下的版本直接更新，避免无限重启
-                            if StringUtils.compare_version(local_version, "<", "2.3.0"):
-                                continue
-                            # 阻断主程序版本v2.6.3以下的版本直接更新，避免搜索异常
-                            if StringUtils.compare_version(APP_VERSION, "<", "2.6.3"):
-                                continue
                         elif rtype == "sites":
                             # 站点索引资源
                             local_version = SitesHelper().indexer_version

app/helper/rss.py

@@ -429,13 +429,14 @@ class RssHelper:
 
         return ret_array
 
-    def get_rss_link(self, url: str, cookie: str, ua: str, proxy: bool = False) -> Tuple[str, str]:
+    def get_rss_link(self, url: str, cookie: str, ua: str, proxy: bool = False, timeout: int = None) -> Tuple[str, str]:
         """
         获取站点rss地址
         :param url: 站点地址
         :param cookie: 站点cookie
         :param ua: 站点ua
         :param proxy: 是否使用代理
+        :param timeout: 请求超时时间
         :return: rss地址、错误信息
         """
         try:
@@ -453,12 +454,13 @@ class RssHelper:
                     url=rss_url,
                     cookies=cookie,
                     ua=ua,
-                    proxies=settings.PROXY if proxy else None
+                    proxies=settings.PROXY_SERVER if proxy else None,
+                    timeout=timeout or 60
                 )
             else:
                 res = RequestUtils(
                     cookies=cookie,
-                    timeout=60,
+                    timeout=timeout or 30,
                     ua=ua,
                     proxies=settings.PROXY if proxy else None
                 ).post_res(url=rss_url, data=rss_params)

app/helper/subscribe.py

@@ -1,7 +1,7 @@
 from threading import Thread
 from typing import List, Tuple, Optional
 
-from app.core.cache import cached, cache_backend
+from app.core.cache import cached
 from app.core.config import settings
 from app.db.subscribe_oper import SubscribeOper
 from app.db.systemconfig_oper import SystemConfigOper
@@ -111,7 +111,12 @@ class SubscribeHelper(metaclass=WeakSingleton):
         if res and res.status_code == 200:
             # 清除缓存
             if clear_cache:
-                cache_backend.clear(region=self._shares_cache_region)
+                self.get_shares.cache_clear()
+                self.get_statistic.cache_clear()
+                self.get_share_statistics.cache_clear()
+                self.async_get_shares.cache_clear()
+                self.async_get_statistic.cache_clear()
+                self.async_get_share_statistics.cache_clear()
             return True, ""
         else:
             return False, res.json().get("message")

app/helper/system.py

@@ -1,5 +1,7 @@
 import os
 import signal
+import threading
+import time
 from pathlib import Path
 from typing import Tuple
 
@@ -41,8 +43,8 @@ class SystemHelper:
         判断是否可以内部重启
         """
         return (
-            Path("/var/run/docker.sock").exists()
-            or settings.DOCKER_CLIENT_API != "tcp://127.0.0.1:38379"
+                Path("/var/run/docker.sock").exists()
+                or settings.DOCKER_CLIENT_API != "tcp://127.0.0.1:38379"
         )
 
     @staticmethod
@@ -64,7 +66,7 @@ class SystemHelper:
                         if index_resolv_conf != -1:
                             index_second_slash = data.rfind(" ", 0, index_resolv_conf)
                             index_first_slash = (
-                                data.rfind("/", 0, index_second_slash) + 1
+                                    data.rfind("/", 0, index_second_slash) + 1
                             )
                             container_id = data[index_first_slash:index_second_slash]
         except Exception as e:
@@ -113,6 +115,8 @@ class SystemHelper:
             if has_restart_policy:
                 # 有重启策略，使用优雅退出方式
                 logger.info("检测到容器配置了自动重启策略，使用优雅重启方式...")
+                # 启动优雅退出超时监控
+                SystemHelper._start_graceful_shutdown_monitor()
                 # 发送SIGTERM信号给当前进程，触发优雅停止
                 os.kill(os.getpid(), signal.SIGTERM)
                 return True, ""
@@ -126,6 +130,25 @@ class SystemHelper:
             logger.warning("降级为Docker API重启...")
             return SystemHelper._docker_api_restart()
 
+    @staticmethod
+    def _start_graceful_shutdown_monitor():
+        """
+        启动优雅退出超时监控
+        如果30秒内进程没有退出，则使用Docker API强制重启
+        """
+
+        def monitor_thread():
+            time.sleep(30)  # 等待30秒
+            logger.warning("优雅退出超时30秒，使用Docker API强制重启...")
+            try:
+                SystemHelper._docker_api_restart()
+            except Exception as e:
+                logger.error(f"强制重启失败: {str(e)}")
+
+        # 在后台线程中启动监控
+        thread = threading.Thread(target=monitor_thread, daemon=True)
+        thread.start()
+
     @staticmethod
     def _docker_api_restart() -> Tuple[bool, str]:
         """

app/helper/torrent.py

@@ -6,6 +6,8 @@ from urllib.parse import unquote
 
 from torrentool.api import Torrent
 
+from app.core.cache import FileCache
+from app.core.cache import TTLCache
 from app.core.config import settings
 from app.core.context import Context, TorrentInfo, MediaInfo
 from app.core.meta import MetaBase
@@ -15,17 +17,16 @@ from app.db.systemconfig_oper import SystemConfigOper
 from app.log import logger
 from app.schemas.types import MediaType, SystemConfigKey
 from app.utils.http import RequestUtils
-from app.utils.singleton import WeakSingleton
 from app.utils.string import StringUtils
 
 
-class TorrentHelper(metaclass=WeakSingleton):
+class TorrentHelper:
     """
     种子帮助类
     """
 
     def __init__(self):
-        self._invalid_torrents = []
+        self._invalid_torrents = TTLCache(maxsize=128, ttl=3600 * 24)
 
     def download_torrent(self, url: str,
                          cookie: Optional[str] = None,
@@ -35,27 +36,29 @@ class TorrentHelper(metaclass=WeakSingleton):
             -> Tuple[Optional[Path], Optional[Union[str, bytes]], Optional[str], Optional[list], Optional[str]]:
         """
         把种子下载到本地
-        :return: 种子保存路径、种子内容、种子主目录、种子文件清单、错误信息
+        :return: 种子缓存相对路径【用于索引缓存】, 种子内容、种子主目录、种子文件清单、错误信息
         """
         if url.startswith("magnet:"):
             return None, url, "", [], f"磁力链接"
-        # 构建 torrent 种子文件的存储路径
-        file_path = (Path(settings.TEMP_PATH) / StringUtils.md5_hash(url)).with_suffix(".torrent")
-        if file_path.exists():
+        # 构建 torrent 种子文件的缓存路径
+        cache_path = Path(StringUtils.md5_hash(url)).with_suffix(".torrent")
+        # 缓存处理器
+        cache_backend = FileCache()
+        # 读取缓存的种子文件
+        torrent_content = cache_backend.get(cache_path.as_posix(), region="torrents")
+        if torrent_content:
+            # 缓存已存在
             try:
                 # 获取种子目录和文件清单
-                folder_name, file_list = self.get_torrent_info(file_path)
+                folder_name, file_list = self.get_fileinfo_from_torrent_content(torrent_content)
                 # 无法获取信息，则认为缓存文件无效
                 if not folder_name and not file_list:
                     raise ValueError("无效的缓存种子文件")
-                # 获取种子数据
-                content = file_path.read_bytes()
                 # 成功拿到种子数据
-                return file_path, content, folder_name, file_list, ""
+                return cache_path, torrent_content, folder_name, file_list, ""
             except Exception as err:
-                logger.error(f"处理缓存的种子文件 {file_path} 时出错: {err}，将重新下载")
-                file_path.unlink(missing_ok=True)
-        # 请求种子文件
+                logger.error(f"处理缓存的种子文件 {cache_path} 时出错: {err}，将重新下载")
+        # 下载种子文件
         req = RequestUtils(
             ua=ua,
             cookies=cookie,
@@ -74,11 +77,11 @@ class TorrentHelper(metaclass=WeakSingleton):
             ).get_res(url=url, allow_redirects=False)
         if req and req.status_code == 200:
             if not req.content:
-                return None, None, "", [], "未下载到种子数据"
+                return cache_path, None, "", [], "未下载到种子数据"
             # 解析内容格式
             if req.content.startswith(b"magnet:"):
                 # 磁力链接
-                return None, req.text, "", [], f"获取到磁力链接"
+                return cache_path, req.text, "", [], f"获取到磁力链接"
             if "下载种子文件".encode("utf-8") in req.content:
                 # 首次下载提示页面
                 skip_flag = False
@@ -116,34 +119,34 @@ class TorrentHelper(metaclass=WeakSingleton):
                 except Exception as err:
                     logger.warn(f"触发了站点首次种子下载，尝试自动跳过时出现错误：{str(err)}，链接：{url}")
                 if not skip_flag:
-                    return None, None, "", [], "种子数据有误，请确认链接是否正确，如为PT站点则需手工在站点下载一次种子"
+                    return cache_path, None, "", [], "种子数据有误，请确认链接是否正确，如为PT站点则需手工在站点下载一次种子"
             # 种子内容
             if req.content:
                 # 检查是不是种子文件，如果不是仍然抛出异常
                 try:
-                    # 保存到文件
-                    file_path.write_bytes(req.content)
                     # 获取种子目录和文件清单
-                    folder_name, file_list = self.get_torrent_info(file_path)
+                    folder_name, file_list = self.get_fileinfo_from_torrent_content(req.content)
+                    if file_list:
+                        # 保存到缓存
+                        cache_backend.set(cache_path.as_posix(), req.content, region="torrents")
                     # 成功拿到种子数据
-                    return file_path, req.content, folder_name, file_list, ""
+                    return cache_path, req.content, folder_name, file_list, ""
                 except Exception as err:
                     logger.error(f"种子文件解析失败：{str(err)}")
                 # 种子数据仍然错误
-                return None, None, "", [], "种子数据有误，请确认链接是否正确"
+                return cache_path, None, "", [], "种子数据有误，请确认链接是否正确"
             # 返回失败
-            return None, None, "", [], ""
+            return cache_path, None, "", [], ""
         elif req is None:
-            return None, None, "", [], "无法打开链接"
+            return cache_path, None, "", [], "无法打开链接"
         elif req.status_code == 429:
-            return None, None, "", [], "触发站点流控，请稍后重试"
+            return cache_path, None, "", [], "触发站点流控，请稍后重试"
         else:
             # 把错误的种子记下来，避免重复使用
             self.add_invalid(url)
-            return None, None, "", [], f"下载种子出错，状态码：{req.status_code}"
+            return cache_path, None, "", [], f"下载种子出错，状态码：{req.status_code}"
 
-    @staticmethod
-    def get_torrent_info(torrent_path: Path) -> Tuple[str, List[str]]:
+    def get_torrent_info(self, torrent_path: Path) -> Tuple[str, List[str]]:
         """
         获取种子文件的文件夹名和文件清单
         :param torrent_path: 种子文件路径
@@ -154,32 +157,65 @@ class TorrentHelper(metaclass=WeakSingleton):
         try:
             torrentinfo = Torrent.from_file(torrent_path)
             # 获取文件清单
-            if (not torrentinfo.files
-                    or (len(torrentinfo.files) == 1
-                        and torrentinfo.files[0].name == torrentinfo.name)):
-                # 单文件种子目录名返回空
-                folder_name = ""
-                # 单文件种子
-                file_list = [torrentinfo.name]
-            else:
-                # 目录名
-                folder_name = torrentinfo.name
-                # 文件清单，如果一级目录与种子名相同则去掉
-                file_list = []
-                for fileinfo in torrentinfo.files:
-                    file_path = Path(fileinfo.name)
-                    # 根路径
-                    root_path = file_path.parts[0]
-                    if root_path == folder_name:
-                        file_list.append(str(file_path.relative_to(root_path)))
-                    else:
-                        file_list.append(fileinfo.name)
-            logger.debug(f"解析种子：{torrent_path.name} => 目录：{folder_name}，文件清单：{file_list}")
-            return folder_name, file_list
+            return self.get_fileinfo_from_torrent(torrentinfo)
         except Exception as err:
             logger.error(f"种子文件解析失败：{str(err)}")
             return "", []
 
+    @staticmethod
+    def get_fileinfo_from_torrent(torrent: Torrent) -> Tuple[str, List[str]]:
+        """
+        从种子文件中获取文件清单
+        :param torrent: 种子文件对象
+        :return: 文件夹名、文件清单，单文件种子返回空文件夹名
+        """
+        if not torrent or not torrent.files:
+            return "", []
+        # 获取文件清单
+        if len(torrent.files) == 1 and torrent.files[0].name == torrent.name:
+            # 单文件种子目录名返回空
+            folder_name = ""
+            # 单文件种子
+            file_list = [torrent.name]
+        else:
+            # 目录名
+            folder_name = torrent.name
+            # 文件清单，如果一级目录与种子名相同则去掉
+            file_list = []
+            for fileinfo in torrent.files:
+                file_path = Path(fileinfo.name)
+                # 根路径
+                root_path = file_path.parts[0]
+                if root_path == folder_name:
+                    file_list.append(str(file_path.relative_to(root_path)))
+                else:
+                    file_list.append(fileinfo.name)
+        logger.debug(f"解析种子：{torrent.name} => 目录：{folder_name}，文件清单：{file_list}")
+        return folder_name, file_list
+
+    def get_fileinfo_from_torrent_content(self, torrent_content: Union[str, bytes]) -> Tuple[str, List[str]]:
+        """
+        从种子内容中获取文件夹名和文件清单
+        :param torrent_content: 种子内容
+        :return: 文件夹名、文件清单，单文件种子返回空文件夹名
+        """
+
+        if not torrent_content:
+            return "", []
+
+        # 检查是否为磁力链接
+        if StringUtils.is_magnet_link(torrent_content):
+            return "", []
+
+        try:
+            # 解析种子内容
+            torrentinfo = Torrent.from_string(torrent_content)
+            # 获取文件清单
+            return self.get_fileinfo_from_torrent(torrentinfo)
+        except Exception as err:
+            logger.error(f"种子内容解析失败：{str(err)}")
+            return "", []
+
     @staticmethod
     def get_url_filename(req: Any, url: str) -> str:
         """
@@ -316,7 +352,7 @@ class TorrentHelper(metaclass=WeakSingleton):
         添加无效种子
         """
         if url not in self._invalid_torrents:
-            self._invalid_torrents.append(url)
+            self._invalid_torrents[url] = True
 
     @staticmethod
     def match_torrent(mediainfo: MediaInfo, torrent_meta: MetaBase, torrent: TorrentInfo) -> bool:

app/helper/workflow.py

@@ -1,7 +1,7 @@
 import json
 from typing import List, Tuple, Optional
 
-from app.core.cache import cached, cache_backend
+from app.core.cache import cached
 from app.core.config import settings
 from app.db.models import Workflow
 from app.db.workflow_oper import WorkflowOper
@@ -89,7 +89,8 @@ class WorkflowHelper(metaclass=WeakSingleton):
         if success:
             # 清除缓存
             if clear_cache:
-                cache_backend.clear(region=self._shares_cache_region)
+                self.get_shares.cache_clear()
+                self.async_get_shares.cache_clear()
             return True, ""
         else:
             try:

app/modules/douban/__init__.py

@@ -938,6 +938,8 @@ class DoubanModule(_ModuleBase):
         """
         搜索人物信息
         """
+        if settings.SEARCH_SOURCE and "douban" not in settings.SEARCH_SOURCE:
+            return None
         if not name:
             return []
         result = self.doubanapi.person_search(keyword=name)
@@ -956,6 +958,8 @@ class DoubanModule(_ModuleBase):
         """
         搜索人物信息（异步版本）
         """
+        if settings.SEARCH_SOURCE and "douban" not in settings.SEARCH_SOURCE:
+            return None
         if not name:
             return []
         result = await self.doubanapi.async_person_search(keyword=name)

app/modules/douban/apiv2.py

@@ -154,6 +154,7 @@ class DoubanApi(metaclass=WeakSingleton):
     _api_url = "https://api.douban.com/v2"
 
     def __init__(self):
+        self.__clear_async_cache__ = False
         self._session = requests.Session()
 
     @classmethod
@@ -171,28 +172,24 @@ class DoubanApi(metaclass=WeakSingleton):
             ).digest()
         ).decode()
 
-    @cached(maxsize=settings.CONF.douban, ttl=settings.CONF.meta)
     def __invoke_recommend(self, url: str, **kwargs) -> dict:
         """
         推荐/发现类API
         """
         return self.__invoke(url, **kwargs)
 
-    @cached(maxsize=settings.CONF.douban, ttl=settings.CONF.meta)
     async def __async_invoke_recommend(self, url: str, **kwargs) -> dict:
         """
         推荐/发现类API（异步版本）
         """
         return await self.__async_invoke(url, **kwargs)
 
-    @cached(maxsize=settings.CONF.douban, ttl=settings.CONF.meta)
     def __invoke_search(self, url: str, **kwargs) -> dict:
         """
         搜索类API
         """
         return self.__invoke(url, **kwargs)
 
-    @cached(maxsize=settings.CONF.douban, ttl=settings.CONF.meta)
     async def __async_invoke_search(self, url: str, **kwargs) -> dict:
         """
         搜索类API（异步版本）
@@ -226,11 +223,9 @@ class DoubanApi(metaclass=WeakSingleton):
         """
         处理HTTP响应
         """
-        if resp is not None and resp.status_code == 400 and "rate_limit" in resp.text:
-            return resp.json()
-        return resp.json() if resp else {}
+        return resp.json() if resp is not None else None
 
-    @cached(maxsize=settings.CONF.douban, ttl=settings.CONF.meta)
+    @cached(maxsize=settings.CONF.douban, ttl=settings.CONF.meta, skip_none=True)
     def __invoke(self, url: str, **kwargs) -> dict:
         """
         GET请求
@@ -242,11 +237,14 @@ class DoubanApi(metaclass=WeakSingleton):
         ).get_res(url=req_url, params=params)
         return self._handle_response(resp)
 
-    @cached(maxsize=settings.CONF.douban, ttl=settings.CONF.meta)
+    @cached(maxsize=settings.CONF.douban, ttl=settings.CONF.meta, skip_none=True)
     async def __async_invoke(self, url: str, **kwargs) -> dict:
         """
         GET请求（异步版本）
         """
+        if self.__clear_async_cache__:
+            self.__clear_async_cache__ = False
+            await self.__async_invoke.cache_clear()
         req_url, params = self._prepare_get_request(url, **kwargs)
         resp = await AsyncRequestUtils(
             ua=choice(self._user_agents)
@@ -265,7 +263,7 @@ class DoubanApi(metaclass=WeakSingleton):
             params.pop('_ts')
         return req_url, params
 
-    @cached(maxsize=settings.CONF.douban, ttl=settings.CONF.meta)
+    @cached(maxsize=settings.CONF.douban, ttl=settings.CONF.meta, skip_none=True)
     def __post(self, url: str, **kwargs) -> dict:
         """
         POST请求
@@ -287,7 +285,7 @@ class DoubanApi(metaclass=WeakSingleton):
         ).post_res(url=req_url, data=params)
         return self._handle_response(resp)
 
-    @cached(maxsize=settings.CONF.douban, ttl=settings.CONF.meta)
+    @cached(maxsize=settings.CONF.douban, ttl=settings.CONF.meta, skip_none=True)
     async def __async_post(self, url: str, **kwargs) -> dict:
         """
         POST请求（异步版本）
@@ -866,8 +864,8 @@ class DoubanApi(metaclass=WeakSingleton):
         """
         清空LRU缓存
         """
-        # 尚未支持缓存清理
-        pass
+        self.__invoke.cache_clear()
+        self.__clear_async_cache__ = True
 
     def close(self):
         if self._session:

app/modules/douban/douban_cache.py

@@ -1,23 +1,19 @@
 import pickle
-import random
-import time
 import traceback
 from pathlib import Path
 from threading import RLock
 from typing import Optional
 
+from app.core.cache import TTLCache
 from app.core.config import settings
 from app.core.meta import MetaBase
 from app.core.metainfo import MetaInfo
 from app.log import logger
-from app.utils.singleton import WeakSingleton
 from app.schemas.types import MediaType
+from app.utils.singleton import WeakSingleton
 
 lock = RLock()
 
-CACHE_EXPIRE_TIMESTAMP_STR = "cache_expire_timestamp"
-EXPIRE_TIMESTAMP = settings.CONF.meta
-
 
 class DoubanCache(metaclass=WeakSingleton):
     """
@@ -30,18 +26,26 @@ class DoubanCache(metaclass=WeakSingleton):
     }
     """
     # TMDB缓存过期
-    _tmdb_cache_expire: bool = True
+    _douban_cache_expire: bool = True
 
     def __init__(self):
-        self._meta_path = settings.TEMP_PATH / "__douban_cache__"
-        self._meta_data = self.__load(self._meta_path)
+        self.maxsize = settings.CONF.douban
+        self.ttl = settings.CONF.meta
+        self.region = "__douban_cache__"
+        self._meta_filepath = settings.TEMP_PATH / self.region
+        # 初始化缓存
+        self._cache = TTLCache(region=self.region, maxsize=self.maxsize, ttl=self.ttl)
+        # 非Redis加载本地缓存数据
+        if not self._cache.is_redis():
+            for key, value in self.__load(self._meta_filepath).items():
+                self._cache.set(key, value)
 
     def clear(self):
         """
-        清空所有TMDB缓存
+        清空所有豆瓣缓存
         """
         with lock:
-            self._meta_data = {}
+            self._cache.clear()
 
     @staticmethod
     def __get_key(meta: MetaBase) -> str:
@@ -57,15 +61,7 @@ class DoubanCache(metaclass=WeakSingleton):
         """
         key = self.__get_key(meta)
         with lock:
-            info: dict = self._meta_data.get(key)
-            if info:
-                expire = info.get(CACHE_EXPIRE_TIMESTAMP_STR)
-                if not expire or int(time.time()) < expire:
-                    info[CACHE_EXPIRE_TIMESTAMP_STR] = int(time.time()) + EXPIRE_TIMESTAMP
-                    self._meta_data[key] = info
-                elif expire and self._tmdb_cache_expire:
-                    self.delete(key)
-            return info or {}
+            return self._cache.get(key) or {}
 
     def delete(self, key: str) -> dict:
         """
@@ -74,38 +70,26 @@ class DoubanCache(metaclass=WeakSingleton):
         @return: 被删除的缓存内容
         """
         with lock:
-            return self._meta_data.pop(key, {})
-
-    def delete_by_doubanid(self, doubanid: str) -> None:
-        """
-        清空对应豆瓣ID的所有缓存记录，以强制更新TMDB中最新的数据
-        """
-        for key in list(self._meta_data):
-            if self._meta_data.get(key, {}).get("id") == doubanid:
-                with lock:
-                    self._meta_data.pop(key)
-
-    def delete_unknown(self) -> None:
-        """
-        清除未识别的缓存记录，以便重新搜索TMDB
-        """
-        for key in list(self._meta_data):
-            if self._meta_data.get(key, {}).get("id") == "0":
-                with lock:
-                    self._meta_data.pop(key)
+            redis_data = self._cache.get(key)
+            if redis_data:
+                self._cache.delete(key)
+                return redis_data
+            return {}
 
     def modify(self, key: str, title: str) -> dict:
         """
-        删除缓存信息
+        修改缓存信息
         @param key: 缓存key
         @param title: 标题
         @return: 被修改后缓存内容
         """
         with lock:
-            if self._meta_data.get(key):
-                self._meta_data[key]['title'] = title
-                self._meta_data[key][CACHE_EXPIRE_TIMESTAMP_STR] = int(time.time()) + EXPIRE_TIMESTAMP
-            return self._meta_data.get(key)
+            redis_data = self._cache.get(key)
+            if redis_data:
+                redis_data["title"] = title
+                self._cache.set(key, redis_data)
+                return redis_data
+            return {}
 
     @staticmethod
     def __load(path: Path) -> dict:
@@ -117,119 +101,72 @@ class DoubanCache(metaclass=WeakSingleton):
                 with open(path, 'rb') as f:
                     data = pickle.load(f)
                 return data
-            return {}
         except Exception as e:
             logger.error(f"加载缓存失败: {str(e)} - {traceback.format_exc()}")
-            return {}
+        return {}
 
     def update(self, meta: MetaBase, info: dict) -> None:
         """
         新增或更新缓存条目
         """
-        with lock:
-            if info:
-                # 缓存标题
-                cache_title = info.get("title")
-                # 缓存年份
-                cache_year = info.get('year')
-                # 类型
-                if isinstance(info.get('media_type'), MediaType):
-                    mtype = info.get('media_type')
-                elif info.get("type"):
-                    mtype = MediaType.MOVIE if info.get("type") == "movie" else MediaType.TV
+        if info:
+            # 缓存标题
+            cache_title = info.get("title")
+            # 缓存年份
+            cache_year = info.get('year')
+            # 类型
+            if isinstance(info.get('media_type'), MediaType):
+                mtype = info.get('media_type')
+            elif info.get("type"):
+                mtype = MediaType.MOVIE if info.get("type") == "movie" else MediaType.TV
+            else:
+                meta = MetaInfo(cache_title)
+                if meta.begin_season:
+                    mtype = MediaType.TV
                 else:
-                    meta = MetaInfo(cache_title)
-                    if meta.begin_season:
-                        mtype = MediaType.TV
-                    else:
-                        mtype = MediaType.MOVIE
-                # 海报
-                poster_path = info.get("pic", {}).get("large")
-                if not poster_path and info.get("cover_url"):
-                    poster_path = info.get("cover_url")
-                if not poster_path and info.get("cover"):
-                    poster_path = info.get("cover").get("url")
+                    mtype = MediaType.MOVIE
+            # 海报
+            poster_path = info.get("pic", {}).get("large")
+            if not poster_path and info.get("cover_url"):
+                poster_path = info.get("cover_url")
+            if not poster_path and info.get("cover"):
+                poster_path = info.get("cover").get("url")
 
-                self._meta_data[self.__get_key(meta)] = {
-                        "id": info.get("id"),
-                        "type": mtype,
-                        "year": cache_year,
-                        "title": cache_title,
-                        "poster_path": poster_path,
-                        CACHE_EXPIRE_TIMESTAMP_STR: int(time.time()) + EXPIRE_TIMESTAMP
-                    }
-            elif info is not None:
-                # None时不缓存，此时代表网络错误，允许重复请求
-                self._meta_data[self.__get_key(meta)] = {'id': "0"}
+            with lock:
+                self._cache.set(self.__get_key(meta), {
+                    "id": info.get("id"),
+                    "type": mtype,
+                    "year": cache_year,
+                    "title": cache_title,
+                    "poster_path": poster_path
+                })
+
+        elif info is not None:
+            # None时不缓存，此时代表网络错误，允许重复请求
+            with lock:
+                self._cache.set(self.__get_key(meta), {
+                    "id": 0
+                })
 
     def save(self, force: Optional[bool] = False) -> None:
         """
         保存缓存数据到文件
         """
+        # Redis不需要保存到本地文件
+        if self._cache.is_redis():
+            return
 
-        meta_data = self.__load(self._meta_path)
-        new_meta_data = {k: v for k, v in self._meta_data.items() if v.get("id")}
+        # 本地文件
+        meta_data = self.__load(self._meta_filepath)
+        # 当前缓存数据（去除无法识别）
+        new_meta_data = {k: v for k, v in self._cache.items() if v.get("id")}
 
         if not force \
-                and not self._random_sample(new_meta_data) \
                 and meta_data.keys() == new_meta_data.keys():
             return
-
-        with open(self._meta_path, 'wb') as f:
-            pickle.dump(new_meta_data, f, pickle.HIGHEST_PROTOCOL) # noqa
-
-    def _random_sample(self, new_meta_data: dict) -> bool:
-        """
-        采样分析是否需要保存
-        """
-        ret = False
-        if len(new_meta_data) < 25:
-            keys = list(new_meta_data.keys())
-            for k in keys:
-                info = new_meta_data.get(k)
-                expire = info.get(CACHE_EXPIRE_TIMESTAMP_STR)
-                if not expire:
-                    ret = True
-                    info[CACHE_EXPIRE_TIMESTAMP_STR] = int(time.time()) + EXPIRE_TIMESTAMP
-                elif int(time.time()) >= expire:
-                    ret = True
-                    if self._tmdb_cache_expire:
-                        new_meta_data.pop(k)
-        else:
-            count = 0
-            keys = random.sample(sorted(new_meta_data.keys()), 25)
-            for k in keys:
-                info = new_meta_data.get(k)
-                expire = info.get(CACHE_EXPIRE_TIMESTAMP_STR)
-                if not expire:
-                    ret = True
-                    info[CACHE_EXPIRE_TIMESTAMP_STR] = int(time.time()) + EXPIRE_TIMESTAMP
-                elif int(time.time()) >= expire:
-                    ret = True
-                    if self._tmdb_cache_expire:
-                        new_meta_data.pop(k)
-                        count += 1
-            if count >= 5:
-                ret |= self._random_sample(new_meta_data)
-        return ret
-
-    def get_title(self, key: str) -> Optional[str]:
-        """
-        获取缓存的标题
-        """
-        cache_media_info = self._meta_data.get(key)
-        if not cache_media_info or not cache_media_info.get("id"):
-            return None
-        return cache_media_info.get("title")
-
-    def set_title(self, key: str, cn_title: str) -> None:
-        """
-        重新设置缓存标题
-        """
-        cache_media_info = self._meta_data.get(key)
-        if not cache_media_info:
-            return
-        self._meta_data[key]['title'] = cn_title
+        # 写入本地
+        with open(self._meta_filepath, 'wb') as f:
+            pickle.dump(new_meta_data, f, pickle.HIGHEST_PROTOCOL)  # noqa
 
     def __del__(self):
         self.save()

app/modules/emby/__init__.py

@@ -282,9 +282,8 @@ class EmbyModule(_ModuleBase, _MediaServerBase[Emby]):
             episodes=episodes
         ) for season, episodes in seasoninfo.items()]
 
-    def mediaserver_playing(self, server: str,
-                            count: Optional[int] = 20, username: Optional[str] = None) -> List[
-        schemas.MediaServerPlayItem]:
+    def mediaserver_playing(self, server: str, count: Optional[int] = 20,
+                            username: Optional[str] = None) -> List[schemas.MediaServerPlayItem]:
         """
         获取媒体服务器正在播放信息
         """
@@ -302,9 +301,8 @@ class EmbyModule(_ModuleBase, _MediaServerBase[Emby]):
             return None
         return server_obj.get_play_url(item_id)
 
-    def mediaserver_latest(self, server: Optional[str] = None,
-                           count: Optional[int] = 20, username: Optional[str] = None) -> List[
-        schemas.MediaServerPlayItem]:
+    def mediaserver_latest(self, server: Optional[str] = None, count: Optional[int] = 20,
+                           username: Optional[str] = None) -> List[schemas.MediaServerPlayItem]:
         """
         获取媒体服务器最新入库条目
         """

app/modules/emby/emby.py

@@ -167,7 +167,7 @@ class Emby:
                     image=image,
                     link=f'{self._playhost or self._host}web/index.html'
                          f'#!/videos?serverId={self.serverid}&parentId={library.get("Id")}',
-                    server_type= "emby"
+                    server_type="emby"
                 )
             )
         return libraries
@@ -497,7 +497,7 @@ class Emby:
                 logger.info(f"影片图片链接:{res.url}")
                 return res.url
             else:
-                logger.error("Items/Id/Images 未获取到返回数据或无该影片{}图片".format(image_type))
+                logger.info("Items/Id/Images 未获取到返回数据或无该影片{}图片".format(image_type))
                 return None
         except Exception as e:
             logger.error(f"连接Items/Id/Images出错：" + str(e))

app/modules/filemanager/storages/__init__.py

@@ -1,10 +1,39 @@
 from abc import ABCMeta, abstractmethod
 from pathlib import Path
-from typing import Optional, List, Dict, Tuple
+from typing import Optional, List, Dict, Tuple, Callable, Union
+
+from tqdm import tqdm
 
 from app import schemas
+from app.helper.progress import ProgressHelper
 from app.helper.storage import StorageHelper
 from app.log import logger
+from app.utils.crypto import HashUtils
+
+
+def transfer_process(path: str) -> Callable[[int | float], None]:
+    """
+    传输进度回调
+    """
+    pbar = tqdm(total=100, desc="整理进度", unit="%")
+    progress = ProgressHelper(HashUtils.md5(path))
+    progress.start()
+
+    def update_progress(percent: Union[int, float]) -> None:
+        """
+        更新进度百分比
+        """
+        percent_value = int(percent)
+        pbar.n = percent_value
+        # 更新进度
+        pbar.refresh()
+        progress.update(value=percent_value, text=f"{path} 进度：{percent_value}%")
+        # 完成时结束
+        if percent_value >= 100:
+            progress.end()
+            pbar.close()
+
+    return update_progress
 
 
 class StorageBase(metaclass=ABCMeta):

app/modules/filemanager/storages/alipan.py

@@ -1,6 +1,5 @@
 import base64
 import hashlib
-import io
 import secrets
 import threading
 import time
@@ -8,12 +7,12 @@ from pathlib import Path
 from typing import List, Optional, Tuple, Union
 
 import requests
-from tqdm import tqdm
 
 from app import schemas
-from app.core.config import settings
+from app.core.config import settings, global_vars
 from app.log import logger
 from app.modules.filemanager import StorageBase
+from app.modules.filemanager.storages import transfer_process
 from app.schemas.types import StorageSchema
 from app.utils.singleton import WeakSingleton
 from app.utils.string import StringUtils
@@ -46,6 +45,9 @@ class AliPan(StorageBase, metaclass=WeakSingleton):
     # 基础url
     base_url = "https://openapi.alipan.com"
 
+    # 文件块大小，默认10MB
+    chunk_size = 10 * 1024 * 1024
+
     def __init__(self):
         super().__init__()
         self._auth_state = {}
@@ -249,10 +251,15 @@ class AliPan(StorageBase, metaclass=WeakSingleton):
         # 检查会话
         self._check_session()
 
-        resp = self.session.request(
-            method, f"{self.base_url}{endpoint}",
-            **kwargs
-        )
+        try:
+            resp = self.session.request(
+                method, f"{self.base_url}{endpoint}",
+                **kwargs
+            )
+        except requests.exceptions.RequestException as e:
+            logger.error(f"【阿里云盘】{method} 请求 {endpoint} 网络错误: {str(e)}")
+            return None
+
         if resp is None:
             logger.warn(f"【阿里云盘】{method} 请求 {endpoint} 失败！")
             return None
@@ -580,29 +587,6 @@ class AliPan(StorageBase, metaclass=WeakSingleton):
             raise Exception(resp.get("message"))
         return resp
 
-    @staticmethod
-    def _log_progress(desc: str, total: int) -> tqdm:
-        """
-        创建一个可以输出到日志的进度条
-        """
-
-        class TqdmToLogger(io.StringIO):
-            def write(s, buf):  # noqa
-                buf = buf.strip('\r\n\t ')
-                if buf:
-                    logger.info(buf)
-
-        return tqdm(
-            total=total,
-            unit='B',
-            unit_scale=True,
-            desc=desc,
-            file=TqdmToLogger(),
-            mininterval=1.0,
-            maxinterval=5.0,
-            miniters=1
-        )
-
     def upload(self, target_dir: schemas.FileItem, local_path: Path,
                new_name: Optional[str] = None) -> Optional[schemas.FileItem]:
         """
@@ -643,21 +627,26 @@ class AliPan(StorageBase, metaclass=WeakSingleton):
 
         # 4. 初始化进度条
         logger.info(f"【阿里云盘】开始上传: {local_path} -> {target_path}，分片数：{len(part_info_list)}")
-        progress_bar = self._log_progress(f"【阿里云盘】{target_name} 上传进度", file_size)
+        progress_callback = transfer_process(local_path.as_posix())
 
         # 5. 分片上传循环
+        uploaded_size = 0
         with open(local_path, 'rb') as f:
             for part_info in part_info_list:
-                part_num = part_info['part_number']
+                if global_vars.is_transfer_stopped(local_path.as_posix()):
+                    logger.info(f"【阿里云盘】{target_name} 上传已取消！")
+                    return None
 
                 # 计算分片参数
+                part_num = part_info['part_number']
                 start = (part_num - 1) * chunk_size
                 end = min(start + chunk_size, file_size)
                 current_chunk_size = end - start
 
                 # 更新进度条（已存在的分片）
                 if part_num in uploaded_parts:
-                    progress_bar.update(current_chunk_size)
+                    uploaded_size += current_chunk_size
+                    progress_callback((uploaded_size * 100) / file_size)
                     continue
 
                 # 准备分片数据
@@ -675,7 +664,6 @@ class AliPan(StorageBase, metaclass=WeakSingleton):
                             upload_url = new_urls[0]['upload_url']
                         else:
                             upload_url = part_info['upload_url']
-
                         # 执行上传
                         logger.info(
                             f"【阿里云盘】开始 第{attempt + 1}次 上传 {target_name} 分片 {part_num} ...")
@@ -694,13 +682,13 @@ class AliPan(StorageBase, metaclass=WeakSingleton):
                 # 处理上传结果
                 if success:
                     uploaded_parts.add(part_num)
-                    progress_bar.update(current_chunk_size)
+                    uploaded_size += current_chunk_size
+                    progress_callback((uploaded_size * 100) / file_size)
                 else:
                     raise Exception(f"【阿里云盘】{target_name} 分片 {part_num} 上传失败！")
 
         # 6. 关闭进度条
-        if progress_bar:
-            progress_bar.close()
+        progress_callback(100)
 
         # 7. 完成上传
         result = self._complete_upload(drive_id=target_dir.drive_id, file_id=file_id, upload_id=upload_id)
@@ -712,7 +700,7 @@ class AliPan(StorageBase, metaclass=WeakSingleton):
 
     def download(self, fileitem: schemas.FileItem, path: Path = None) -> Optional[Path]:
         """
-        带限速处理的下载
+        带实时进度显示的下载
         """
         download_info = self._request_api(
             "POST",
@@ -723,14 +711,57 @@ class AliPan(StorageBase, metaclass=WeakSingleton):
             }
         )
         if not download_info:
+            logger.error(f"【阿里云盘】获取下载链接失败: {fileitem.name}")
             return None
+
         download_url = download_info.get("url")
+        if not download_url:
+            logger.error(f"【阿里云盘】下载链接为空: {fileitem.name}")
+            return None
+
         local_path = path or settings.TEMP_PATH / fileitem.name
-        with requests.get(download_url, stream=True) as r:
-            r.raise_for_status()
-            with open(local_path, "wb") as f:
-                for chunk in r.iter_content(chunk_size=8192):
-                    f.write(chunk)
+
+        # 获取文件大小
+        file_size = fileitem.size
+
+        # 初始化进度条
+        logger.info(f"【阿里云盘】开始下载: {fileitem.name} -> {local_path}")
+        progress_callback = transfer_process(Path(fileitem.path).as_posix())
+
+        try:
+            with requests.get(download_url, stream=True) as r:
+                r.raise_for_status()
+                downloaded_size = 0
+                with open(local_path, "wb") as f:
+                    for chunk in r.iter_content(chunk_size=self.chunk_size):
+                        if global_vars.is_transfer_stopped(fileitem.path):
+                            logger.info(f"【阿里云盘】{fileitem.path} 下载已取消！")
+                            return None
+                        if chunk:
+                            f.write(chunk)
+                            # 更新进度
+                            downloaded_size += len(chunk)
+                            if file_size:
+                                progress = (downloaded_size * 100) / file_size
+                                progress_callback(progress)
+
+                # 完成下载
+                progress_callback(100)
+                logger.info(f"【阿里云盘】下载完成: {fileitem.name}")
+
+        except requests.exceptions.RequestException as e:
+            logger.error(f"【阿里云盘】下载网络错误: {fileitem.name} - {str(e)}")
+            # 删除可能部分下载的文件
+            if local_path.exists():
+                local_path.unlink()
+            return None
+        except Exception as e:
+            logger.error(f"【阿里云盘】下载失败: {fileitem.name} - {str(e)}")
+            # 删除可能部分下载的文件
+            if local_path.exists():
+                local_path.unlink()
+            return None
+
         return local_path
 
     def check(self) -> bool:

app/modules/filemanager/storages/alist.py

@@ -1,4 +1,5 @@
 import json
+import time
 from datetime import datetime
 from pathlib import Path
 from typing import Optional, List
@@ -7,9 +8,9 @@ import requests
 
 from app import schemas
 from app.core.cache import cached
-from app.core.config import settings
+from app.core.config import settings, global_vars
 from app.log import logger
-from app.modules.filemanager.storages import StorageBase
+from app.modules.filemanager.storages import StorageBase, transfer_process
 from app.schemas.types import StorageSchema
 from app.utils.http import RequestUtils
 from app.utils.singleton import WeakSingleton
@@ -31,6 +32,7 @@ class Alist(StorageBase, metaclass=WeakSingleton):
         "move": "移动",
     }
 
+    # 快照检查目录修改时间
     snapshot_check_folder_modtime = settings.OPENLIST_SNAPSHOT_CHECK_FOLDER_MODTIME
 
     def __init__(self):
@@ -42,6 +44,17 @@ class Alist(StorageBase, metaclass=WeakSingleton):
         """
         self.__generate_token.cache_clear()  # noqa
 
+    def _delay_get_item(self, path: Path) -> Optional[schemas.FileItem]:
+        """
+        自动延迟重试 get_item 模块
+        """
+        for _ in range(2):
+            time.sleep(2)
+            fileitem = self.get_item(path)
+            if fileitem:
+                return fileitem
+        return None
+
     @property
     def __get_base_url(self) -> str:
         """
@@ -269,7 +282,7 @@ class Alist(StorageBase, metaclass=WeakSingleton):
             logger.warn(f'【OpenList】创建目录 {path} 失败，错误信息：{result["message"]}')
             return None
 
-        return self.get_item(path)
+        return self._delay_get_item(path)
 
     def get_folder(self, path: Path) -> Optional[schemas.FileItem]:
         """
@@ -560,6 +573,9 @@ class Alist(StorageBase, metaclass=WeakSingleton):
             r.raise_for_status()
             with open(local_path, "wb") as f:
                 for chunk in r.iter_content(chunk_size=8192):
+                    if global_vars.is_transfer_stopped(fileitem.path):
+                        logger.info(f"【OpenList】{fileitem.path} 下载已取消！")
+                        return None
                     f.write(chunk)
 
         if local_path.exists():
@@ -570,36 +586,84 @@ class Alist(StorageBase, metaclass=WeakSingleton):
             self, fileitem: schemas.FileItem, path: Path, new_name: Optional[str] = None, task: bool = False
     ) -> Optional[schemas.FileItem]:
         """
-        上传文件
+        上传文件（带进度）
         :param fileitem: 上传目录项
         :param path: 本地文件路径
         :param new_name: 上传后文件名
         :param task: 是否为任务，默认为False避免未完成上传时对文件进行操作
         """
-        encoded_path = UrlUtils.quote((Path(fileitem.path) / path.name).as_posix())
-        headers = self.__get_header_with_token()
-        headers.setdefault("Content-Type", "application/octet-stream")
-        headers.setdefault("As-Task", str(task).lower())
-        headers.setdefault("File-Path", encoded_path)
-        with open(path, "rb") as f:
-            resp = RequestUtils(headers=headers).put_res(
-                self.__get_api_url("/api/fs/put"),
-                data=f,
-            )
+        try:
+            # 获取文件大小
+            target_name = new_name or path.name
+            target_path = Path(fileitem.path) / target_name
 
-        if resp is None:
-            logger.warn(f"【OpenList】请求上传文件 {path} 失败")
+            # 初始化进度回调
+            progress_callback = transfer_process(path.as_posix())
+
+            # 准备上传请求
+            encoded_path = UrlUtils.quote(target_path.as_posix())
+            headers = self.__get_header_with_token()
+            headers.setdefault("Content-Type", "application/octet-stream")
+            headers.setdefault("As-Task", str(task).lower())
+            headers.setdefault("File-Path", encoded_path)
+
+            # 创建自定义的文件流，支持进度回调
+            class ProgressFileReader:
+                def __init__(self, file_path: Path, callback):
+                    self.file = open(file_path, 'rb')
+                    self.callback = callback
+                    self.uploaded_size = 0
+                    self.file_size = file_path.stat().st_size
+
+                def __len__(self) -> int:
+                    return self.file_size
+
+                def read(self, size=-1):
+                    if global_vars.is_transfer_stopped(path.as_posix()):
+                        logger.info(f"【OpenList】{path} 上传已取消！")
+                        return None
+                    chunk = self.file.read(size)
+                    if chunk:
+                        self.uploaded_size += len(chunk)
+                        if self.callback:
+                            percent = (self.uploaded_size * 100) / self.file_size
+                            self.callback(percent)
+                    return chunk
+
+                def close(self):
+                    self.file.close()
+
+            # 使用自定义文件流上传
+            progress_reader = ProgressFileReader(path, progress_callback)
+            try:
+                resp = RequestUtils(headers=headers).put_res(
+                    self.__get_api_url("/api/fs/put"),
+                    data=progress_reader,
+                )
+            finally:
+                progress_reader.close()
+
+            if resp is None:
+                logger.warn(f"【OpenList】请求上传文件 {path} 失败")
+                return None
+            if resp.status_code != 200:
+                logger.warn(f"【OpenList】请求上传文件 {path} 失败，状态码：{resp.status_code}")
+                return None
+
+            # 完成上传
+            progress_callback(100)
+
+            # 获取上传后的文件项
+            new_item = self._delay_get_item(target_path)
+            if new_item and new_name and new_name != path.name:
+                if self.rename(new_item, new_name):
+                    return self._delay_get_item(Path(new_item.path).with_name(new_name))
+
+            return new_item
+
+        except Exception as e:
+            logger.error(f"【OpenList】上传文件 {path} 失败：{e}")
             return None
-        if resp.status_code != 200:
-            logger.warn(f"【OpenList】请求上传文件 {path} 失败，状态码：{resp.status_code}")
-            return None
-
-        new_item = self.get_item(Path(fileitem.path) / path.name)
-        if new_item and new_name and new_name != path.name:
-            if self.rename(new_item, new_name):
-                return self.get_item(Path(new_item.path).with_name(new_name))
-
-        return new_item
 
     def detail(self, fileitem: schemas.FileItem) -> Optional[schemas.FileItem]:
         """
@@ -658,9 +722,9 @@ class Alist(StorageBase, metaclass=WeakSingleton):
             return False
         # 重命名
         if fileitem.name != new_name:
-            self.rename(
-                self.get_item(path / fileitem.name), new_name
-            )
+            new_item = self._delay_get_item(path / fileitem.name)
+            if new_item:
+                self.rename(new_item, new_name)
         return True
 
     def move(self, fileitem: schemas.FileItem, path: Path, new_name: str) -> bool:

app/modules/filemanager/storages/local.py

@@ -3,9 +3,10 @@ from pathlib import Path
 from typing import Optional, List
 
 from app import schemas
+from app.core.config import global_vars
 from app.helper.directory import DirectoryHelper
 from app.log import logger
-from app.modules.filemanager.storages import StorageBase
+from app.modules.filemanager.storages import StorageBase, transfer_process
 from app.schemas.types import StorageSchema
 from app.utils.system import SystemUtils
 
@@ -25,6 +26,9 @@ class LocalStorage(StorageBase):
         "softlink": "软链接"
     }
 
+    # 文件块大小，默认100MB
+    chunk_size = 100 * 1024 * 1024
+
     def init_storage(self):
         """
         初始化
@@ -95,7 +99,7 @@ class LocalStorage(StorageBase):
         # 遍历目录
         path_obj = Path(path)
         if not path_obj.exists():
-            logger.warn(f"【local】目录不存在：{path}")
+            logger.warn(f"【本地】目录不存在：{path}")
             return []
 
         # 如果是文件
@@ -167,7 +171,7 @@ class LocalStorage(StorageBase):
             else:
                 shutil.rmtree(path_obj, ignore_errors=True)
         except Exception as e:
-            logger.error(f"【local】删除文件失败：{e}")
+            logger.error(f"【本地】删除文件失败：{e}")
             return False
         return True
 
@@ -181,7 +185,7 @@ class LocalStorage(StorageBase):
         try:
             path_obj.rename(path_obj.parent / name)
         except Exception as e:
-            logger.error(f"【local】重命名文件失败：{e}")
+            logger.error(f"【本地】重命名文件失败：{e}")
             return False
         return True
 
@@ -191,21 +195,122 @@ class LocalStorage(StorageBase):
         """
         return Path(fileitem.path)
 
-    def upload(self, fileitem: schemas.FileItem, path: Path,
-               new_name: Optional[str] = None) -> Optional[schemas.FileItem]:
+    def _copy_with_progress(self, src: Path, dest: Path):
         """
-        上传文件
-        :param fileitem: 上传目录项
-        :param path: 本地文件路径
-        :param new_name: 上传后文件名
+        分块复制文件并回调进度
         """
-        dir_path = Path(fileitem.path)
-        target_path = dir_path / (new_name or path.name)
-        code, message = SystemUtils.move(path, target_path)
-        if code != 0:
-            logger.error(f"【local】移动文件失败：{message}")
-            return None
-        return self.get_item(target_path)
+        total_size = src.stat().st_size
+        copied_size = 0
+        progress_callback = transfer_process(src.as_posix())
+        try:
+            with open(src, "rb") as fsrc, open(dest, "wb") as fdst:
+                while True:
+                    if global_vars.is_transfer_stopped(src.as_posix()):
+                        logger.info(f"【本地】{src} 复制已取消！")
+                        return False
+                    buf = fsrc.read(self.chunk_size)
+                    if not buf:
+                        break
+                    fdst.write(buf)
+                    copied_size += len(buf)
+                    # 更新进度
+                    if progress_callback:
+                        percent = copied_size / total_size * 100
+                        progress_callback(percent)
+            # 保留文件时间戳、权限等信息
+            shutil.copystat(src, dest)
+            return True
+        except Exception as e:
+            logger.error(f"【本地】复制文件 {src} 失败：{e}")
+            return False
+        finally:
+            progress_callback(100)
+
+    def upload(
+            self,
+            fileitem: schemas.FileItem,
+            path: Path,
+            new_name: Optional[str] = None
+    ) -> Optional[schemas.FileItem]:
+        """
+        上传文件（带进度）
+        """
+        try:
+            dir_path = Path(fileitem.path)
+            target_path = dir_path / (new_name or path.name)
+            if self._copy_with_progress(path, target_path):
+                # 上传删除源文件
+                path.unlink()
+                return self.get_item(target_path)
+        except Exception as err:
+            logger.error(f"【本地】移动文件失败：{err}")
+        return None
+
+    @staticmethod
+    def __should_show_progress(src: Path, dest: Path):
+        """
+        是否显示进度条
+        """
+        src_isnetwork = SystemUtils.is_network_filesystem(src)
+        dest_isnetwork = SystemUtils.is_network_filesystem(dest)
+        if src_isnetwork and dest_isnetwork and SystemUtils.is_same_disk(src, dest):
+            return True
+        return False
+
+    def copy(
+            self,
+            fileitem: schemas.FileItem,
+            path: Path,
+            new_name: str
+    ) -> bool:
+        """
+        复制文件（带进度）
+        """
+        try:
+            src = Path(fileitem.path)
+            dest = path / new_name
+            if self.__should_show_progress(src, dest):
+                if self._copy_with_progress(src, dest):
+                    return True
+            else:
+                code, message = SystemUtils.copy(src, dest)
+                if code == 0:
+                    return True
+                else:
+                    logger.error(f"【本地】复制文件失败：{message}")
+        except Exception as err:
+            logger.error(f"【本地】复制文件失败：{err}")
+        return False
+
+    def move(
+            self,
+            fileitem: schemas.FileItem,
+            path: Path,
+            new_name: str
+    ) -> bool:
+        """
+        移动文件（带进度）
+        """
+        try:
+            src = Path(fileitem.path)
+            dest = path / new_name
+            if src == dest:
+                # 目标和源文件相同，直接返回成功，不做任何操作
+                return True
+            if self.__should_show_progress(src, dest):
+                if self._copy_with_progress(src, dest):
+                    # 复制成功删除源文件
+                    src.unlink()
+                    return True
+            else:
+                code, message = SystemUtils.move(src, dest)
+                if code == 0:
+                    return True
+                else:
+                    logger.error(f"【本地】移动文件失败：{message}")
+        except Exception as err:
+            logger.error(f"【本地】移动文件失败：{err}")
+        return False
 
     def link(self, fileitem: schemas.FileItem, target_file: Path) -> bool:
         """
@@ -214,7 +319,7 @@ class LocalStorage(StorageBase):
         file_path = Path(fileitem.path)
         code, message = SystemUtils.link(file_path, target_file)
         if code != 0:
-            logger.error(f"【local】硬链接文件失败：{message}")
+            logger.error(f"【本地】硬链接文件失败：{message}")
             return False
         return True
 
@@ -225,35 +330,7 @@ class LocalStorage(StorageBase):
         file_path = Path(fileitem.path)
         code, message = SystemUtils.softlink(file_path, target_file)
         if code != 0:
-            logger.error(f"【local】软链接文件失败：{message}")
-            return False
-        return True
-
-    def copy(self, fileitem: schemas.FileItem, path: Path, new_name: str) -> bool:
-        """
-        复制文件
-        :param fileitem: 文件项
-        :param path: 目标目录
-        :param new_name: 新文件名
-        """
-        file_path = Path(fileitem.path)
-        code, message = SystemUtils.copy(file_path, path / new_name)
-        if code != 0:
-            logger.error(f"【local】复制文件失败：{message}")
-            return False
-        return True
-
-    def move(self, fileitem: schemas.FileItem, path: Path, new_name: str) -> bool:
-        """
-        移动文件
-        :param fileitem: 文件项
-        :param path: 目标目录
-        :param new_name: 新文件名
-        """
-        file_path = Path(fileitem.path)
-        code, message = SystemUtils.move(file_path, path / new_name)
-        if code != 0:
-            logger.error(f"【local】移动文件失败：{message}")
+            logger.error(f"【本地】软链接文件失败：{message}")
             return False
         return True
 

app/modules/filemanager/storages/rclone.py

@@ -6,7 +6,7 @@ from typing import Optional, List
 from app import schemas
 from app.core.config import settings
 from app.log import logger
-from app.modules.filemanager.storages import StorageBase
+from app.modules.filemanager.storages import StorageBase, transfer_process
 from app.schemas.types import StorageSchema
 from app.utils.string import StringUtils
 from app.utils.system import SystemUtils
@@ -58,6 +58,41 @@ class Rclone(StorageBase):
         else:
             return None
 
+    @staticmethod
+    def __parse_rclone_progress(line: str) -> Optional[float]:
+        """
+        解析rclone进度输出
+        """
+        if not line:
+            return None
+        
+        line = line.strip()
+        
+        # 检查是否包含百分比
+        if '%' not in line:
+            return None
+            
+        try:
+            # 尝试多种进度输出格式
+            if 'ETA' in line:
+                # 格式: "Transferred: 1.234M / 5.678M, 22%, 1.234MB/s, ETA 2m3s"
+                percent_str = line.split('%')[0].split()[-1]
+                return float(percent_str)
+            elif 'Transferred:' in line and '100%' in line:
+                # 传输完成
+                return 100.0
+            else:
+                # 其他包含百分比的格式
+                parts = line.split()
+                for part in parts:
+                    if '%' in part:
+                        percent_str = part.replace('%', '')
+                        return float(percent_str)
+        except (ValueError, IndexError):
+            pass
+            
+        return None
+
     def __get_rcloneitem(self, item: dict, parent: Optional[str] = "/") -> schemas.FileItem:
         """
         获取rclone文件项
@@ -238,47 +273,115 @@ class Rclone(StorageBase):
 
     def download(self, fileitem: schemas.FileItem, path: Path = None) -> Optional[Path]:
         """
-        下载文件
+        带实时进度显示的下载
         """
-        path = (path or settings.TEMP_PATH) / fileitem.name
+        local_path = (path or settings.TEMP_PATH) / fileitem.name
+        
+        # 初始化进度条
+        logger.info(f"【rclone】开始下载: {fileitem.name} -> {local_path}")
+        progress_callback = transfer_process(Path(fileitem.path).as_posix())
+        
         try:
-            retcode = subprocess.run(
+            # 使用rclone的进度显示功能
+            process = subprocess.Popen(
                 [
                     'rclone', 'copyto',
+                    '--progress',  # 启用进度显示
+                    '--stats', '1s',  # 每秒更新一次统计信息
                     f'MP:{fileitem.path}',
-                    f'{path}'
+                    f'{local_path}'
                 ],
-                startupinfo=self.__get_hidden_shell()
-            ).returncode
+                stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT,
+                startupinfo=self.__get_hidden_shell(),
+                universal_newlines=True,
+                bufsize=1
+            )
+            
+            # 监控进度输出
+            last_progress = 0
+            for line in process.stdout:
+                if line:
+                    # 解析rclone的进度输出
+                    progress = self.__parse_rclone_progress(line)
+                    if progress is not None and progress > last_progress:
+                        progress_callback(progress)
+                        last_progress = progress
+                        if progress >= 100:
+                            break
+            
+            # 等待进程完成
+            retcode = process.wait()
             if retcode == 0:
-                return path
+                logger.info(f"【rclone】下载完成: {fileitem.name}")
+                return local_path
+            else:
+                logger.error(f"【rclone】下载失败: {fileitem.name}")
+                return None
+                
         except Exception as err:
-            logger.error(f"【rclone】复制文件失败：{err}")
-        return None
+            logger.error(f"【rclone】下载失败: {fileitem.name} - {err}")
+            # 删除可能部分下载的文件
+            if local_path.exists():
+                local_path.unlink()
+            return None
 
     def upload(self, fileitem: schemas.FileItem, path: Path,
                new_name: Optional[str] = None) -> Optional[schemas.FileItem]:
         """
-        上传文件
+        带实时进度显示的上传
         :param fileitem: 上传目录项
         :param path: 本地文件路径
         :param new_name: 上传后文件名
         """
+        target_name = new_name or path.name
+        new_path = Path(fileitem.path) / target_name
+        
+        # 初始化进度条
+        logger.info(f"【rclone】开始上传: {path} -> {new_path}")
+        progress_callback = transfer_process(path.as_posix())
+        
         try:
-            new_path = Path(fileitem.path) / (new_name or path.name)
-            retcode = subprocess.run(
+            # 使用rclone的进度显示功能
+            process = subprocess.Popen(
                 [
                     'rclone', 'copyto',
+                    '--progress',  # 启用进度显示
+                    '--stats', '1s',  # 每秒更新一次统计信息
                     path.as_posix(),
                     f'MP:{new_path}'
                 ],
-                startupinfo=self.__get_hidden_shell()
-            ).returncode
+                stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT,
+                startupinfo=self.__get_hidden_shell(),
+                universal_newlines=True,
+                bufsize=1
+            )
+            
+            # 监控进度输出
+            last_progress = 0
+            for line in process.stdout:
+                if line:
+                    # 解析rclone的进度输出
+                    progress = self.__parse_rclone_progress(line)
+                    if progress is not None and progress > last_progress:
+                        progress_callback(progress)
+                        last_progress = progress
+                        if progress >= 100:
+                            break
+            
+            # 等待进程完成
+            retcode = process.wait()
             if retcode == 0:
+                logger.info(f"【rclone】上传完成: {target_name}")
                 return self.get_item(new_path)
+            else:
+                logger.error(f"【rclone】上传失败: {target_name}")
+                return None
+                
         except Exception as err:
-            logger.error(f"【rclone】上传文件失败：{err}")
-        return None
+            logger.error(f"【rclone】上传失败: {target_name} - {err}")
+            return None
 
     def detail(self, fileitem: schemas.FileItem) -> Optional[schemas.FileItem]:
         """
@@ -307,20 +410,53 @@ class Rclone(StorageBase):
         :param path: 目标目录
         :param new_name: 新文件名
         """
+        target_path = path / new_name
+        
+        # 初始化进度条
+        logger.info(f"【rclone】开始移动: {fileitem.path} -> {target_path}")
+        progress_callback = transfer_process(Path(fileitem.path).as_posix())
+        
         try:
-            retcode = subprocess.run(
+            # 使用rclone的进度显示功能
+            process = subprocess.Popen(
                 [
                     'rclone', 'moveto',
+                    '--progress',  # 启用进度显示
+                    '--stats', '1s',  # 每秒更新一次统计信息
                     f'MP:{fileitem.path}',
-                    f'MP:{path / new_name}'
+                    f'MP:{target_path}'
                 ],
-                startupinfo=self.__get_hidden_shell()
-            ).returncode
+                stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT,
+                startupinfo=self.__get_hidden_shell(),
+                universal_newlines=True,
+                bufsize=1
+            )
+            
+            # 监控进度输出
+            last_progress = 0
+            for line in process.stdout:
+                if line:
+                    # 解析rclone的进度输出
+                    progress = self.__parse_rclone_progress(line)
+                    if progress is not None and progress > last_progress:
+                        progress_callback(progress)
+                        last_progress = progress
+                        if progress >= 100:
+                            break
+            
+            # 等待进程完成
+            retcode = process.wait()
             if retcode == 0:
+                logger.info(f"【rclone】移动完成: {fileitem.name}")
                 return True
+            else:
+                logger.error(f"【rclone】移动失败: {fileitem.name}")
+                return False
+                
         except Exception as err:
-            logger.error(f"【rclone】移动文件失败：{err}")
-        return False
+            logger.error(f"【rclone】移动失败: {fileitem.name} - {err}")
+            return False
 
     def copy(self, fileitem: schemas.FileItem, path: Path, new_name: str) -> bool:
         """
@@ -329,20 +465,53 @@ class Rclone(StorageBase):
         :param path: 目标目录
         :param new_name: 新文件名
         """
+        target_path = path / new_name
+        
+        # 初始化进度条
+        logger.info(f"【rclone】开始复制: {fileitem.path} -> {target_path}")
+        progress_callback = transfer_process(Path(fileitem.path).as_posix())
+        
         try:
-            retcode = subprocess.run(
+            # 使用rclone的进度显示功能
+            process = subprocess.Popen(
                 [
                     'rclone', 'copyto',
+                    '--progress',  # 启用进度显示
+                    '--stats', '1s',  # 每秒更新一次统计信息
                     f'MP:{fileitem.path}',
-                    f'MP:{path / new_name}'
+                    f'MP:{target_path}'
                 ],
-                startupinfo=self.__get_hidden_shell()
-            ).returncode
+                stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT,
+                startupinfo=self.__get_hidden_shell(),
+                universal_newlines=True,
+                bufsize=1
+            )
+            
+            # 监控进度输出
+            last_progress = 0
+            for line in process.stdout:
+                if line:
+                    # 解析rclone的进度输出
+                    progress = self.__parse_rclone_progress(line)
+                    if progress is not None and progress > last_progress:
+                        progress_callback(progress)
+                        last_progress = progress
+                        if progress >= 100:
+                            break
+            
+            # 等待进程完成
+            retcode = process.wait()
             if retcode == 0:
+                logger.info(f"【rclone】复制完成: {fileitem.name}")
                 return True
+            else:
+                logger.error(f"【rclone】复制失败: {fileitem.name}")
+                return False
+                
         except Exception as err:
-            logger.error(f"【rclone】复制文件失败：{err}")
-        return False
+            logger.error(f"【rclone】复制失败: {fileitem.name} - {err}")
+            return False
 
     def link(self, fileitem: schemas.FileItem, target_file: Path) -> bool:
         pass

app/modules/filemanager/storages/smb.py

@@ -8,9 +8,10 @@ from smbclient import ClientConfig, register_session, reset_connection_cache
 from smbprotocol.exceptions import SMBException, SMBResponseException, SMBAuthenticationError
 
 from app import schemas
-from app.core.config import settings
+from app.core.config import settings, global_vars
 from app.log import logger
 from app.modules.filemanager import StorageBase
+from app.modules.filemanager.storages import transfer_process
 from app.schemas.types import StorageSchema
 from app.utils.singleton import WeakSingleton
 
@@ -38,6 +39,9 @@ class SMB(StorageBase, metaclass=WeakSingleton):
         "copy": "复制",
     }
 
+    # 文件块大小，默认100MB
+    chunk_size = 100 * 1024 * 1024
+
     def __init__(self):
         super().__init__()
         self._connected = False
@@ -412,63 +416,99 @@ class SMB(StorageBase, metaclass=WeakSingleton):
 
     def download(self, fileitem: schemas.FileItem, path: Path = None) -> Optional[Path]:
         """
-        下载文件
+        带实时进度显示的下载
         """
+        local_path = path or settings.TEMP_PATH / fileitem.name
+        smb_path = self._normalize_path(fileitem.path)
         try:
             self._check_connection()
 
-            smb_path = self._normalize_path(fileitem.path)
-            local_path = path or settings.TEMP_PATH / fileitem.name
-
             # 确保本地目录存在
             local_path.parent.mkdir(parents=True, exist_ok=True)
 
+            # 获取文件大小
+            file_size = fileitem.size
+
+            # 初始化进度条
+            logger.info(f"【SMB】开始下载: {fileitem.name} -> {local_path}")
+            progress_callback = transfer_process(Path(fileitem.path).as_posix())
+
             # 使用更高效的文件传输方式
             with smbclient.open_file(smb_path, mode="rb") as src_file:
                 with open(local_path, "wb") as dst_file:
-                    # 使用更大的缓冲区提高性能
-                    buffer_size = 1024 * 1024  # 1MB
+                    downloaded_size = 0
                     while True:
-                        chunk = src_file.read(buffer_size)
+                        if global_vars.is_transfer_stopped(fileitem.path):
+                            logger.info(f"【SMB】{fileitem.path} 下载已取消！")
+                            return None
+                        chunk = src_file.read(self.chunk_size)
                         if not chunk:
                             break
                         dst_file.write(chunk)
+                        downloaded_size += len(chunk)
+                        # 更新进度
+                        if file_size:
+                            progress = (downloaded_size * 100) / file_size
+                            progress_callback(progress)
 
-            logger.info(f"【SMB】下载成功: {fileitem.path} -> {local_path}")
+            # 完成下载
+            progress_callback(100)
+            logger.info(f"【SMB】下载完成: {fileitem.name}")
             return local_path
+
         except Exception as e:
-            logger.error(f"【SMB】下载失败: {e}")
+            logger.error(f"【SMB】下载失败: {fileitem.name} - {e}")
+            # 删除可能部分下载的文件
+            if local_path.exists():
+                local_path.unlink()
             return None
 
     def upload(self, fileitem: schemas.FileItem, path: Path,
                new_name: Optional[str] = None) -> Optional[schemas.FileItem]:
         """
-        上传文件
+        带实时进度显示的上传
         """
+        target_name = new_name or path.name
+        target_path = Path(fileitem.path) / target_name
+        smb_path = self._normalize_path(str(target_path))
+
         try:
             self._check_connection()
 
-            target_name = new_name or path.name
-            target_path = Path(fileitem.path) / target_name
-            smb_path = self._normalize_path(str(target_path))
+            # 获取文件大小
+            file_size = path.stat().st_size
+
+            # 初始化进度条
+            logger.info(f"【SMB】开始上传: {path} -> {target_path}")
+            progress_callback = transfer_process(path.as_posix())
 
             # 使用更高效的文件传输方式
             with open(path, "rb") as src_file:
                 with smbclient.open_file(smb_path, mode="wb") as dst_file:
-                    # 使用更大的缓冲区提高性能
-                    buffer_size = 1024 * 1024  # 1MB
+                    uploaded_size = 0
                     while True:
-                        chunk = src_file.read(buffer_size)
+                        if global_vars.is_transfer_stopped(path.as_posix()):
+                            logger.info(f"【SMB】{path} 上传已取消！")
+                            return None
+                        chunk = src_file.read(self.chunk_size)
                         if not chunk:
                             break
                         dst_file.write(chunk)
+                        uploaded_size += len(chunk)
+                        # 更新进度
+                        if file_size:
+                            progress = (uploaded_size * 100) / file_size
+                            progress_callback(progress)
 
-            logger.info(f"【SMB】上传成功: {path} -> {target_path}")
+            # 完成上传
+            progress_callback(100)
+            logger.info(f"【SMB】上传完成: {target_name}")
 
             # 返回上传后的文件信息
             return self.get_item(target_path)
+
         except Exception as e:
-            logger.error(f"【SMB】上传失败: {e}")
+            logger.error(f"【SMB】上传失败: {target_name} - {e}")
             return None
 
     def copy(self, fileitem: schemas.FileItem, path: Path, new_name: str) -> bool:

app/modules/filemanager/storages/u115.py

@@ -1,6 +1,5 @@
 import base64
 import hashlib
-import io
 import secrets
 import threading
 import time
@@ -11,12 +10,12 @@ import oss2
 import requests
 from oss2 import SizedFileAdapter, determine_part_size
 from oss2.models import PartInfo
-from tqdm import tqdm
 
 from app import schemas
-from app.core.config import settings
+from app.core.config import settings, global_vars
 from app.log import logger
 from app.modules.filemanager import StorageBase
+from app.modules.filemanager.storages import transfer_process
 from app.schemas.types import StorageSchema
 from app.utils.singleton import WeakSingleton
 from app.utils.string import StringUtils
@@ -44,6 +43,12 @@ class U115Pan(StorageBase, metaclass=WeakSingleton):
     # 基础url
     base_url = "https://proapi.115.com"
 
+    # 文件块大小，默认10MB
+    chunk_size = 10 * 1024 * 1024
+
+    # 流控重试间隔时间
+    retry_delay = 70
+
     def __init__(self):
         super().__init__()
         self._auth_state = {}
@@ -193,6 +198,7 @@ class U115Pan(StorageBase, metaclass=WeakSingleton):
         result = resp.json()
         if result.get("code") != 0:
             logger.warn(f"【115】刷新 access_token 失败：{result.get('code')} - {result.get('message')}！")
+            return None
         return result.get("data")
 
     def _request_api(self, method: str, endpoint: str,
@@ -203,10 +209,15 @@ class U115Pan(StorageBase, metaclass=WeakSingleton):
         # 检查会话
         self._check_session()
 
-        resp = self.session.request(
-            method, f"{self.base_url}{endpoint}",
-            **kwargs
-        )
+        try:
+            resp = self.session.request(
+                method, f"{self.base_url}{endpoint}",
+                **kwargs
+            )
+        except requests.exceptions.RequestException as e:
+            logger.error(f"【115】{method} 请求 {endpoint} 网络错误: {str(e)}")
+            return None
+
         if resp is None:
             logger.warn(f"【115】{method} 请求 {endpoint} 失败！")
             return None
@@ -226,7 +237,18 @@ class U115Pan(StorageBase, metaclass=WeakSingleton):
         # 返回数据
         ret_data = resp.json()
         if ret_data.get("code") != 0:
-            logger.warn(f"【115】{method} 请求 {endpoint} 出错：{ret_data.get('message')}！")
+            error_msg = ret_data.get("message")
+            logger.warn(f"【115】{method} 请求 {endpoint} 出错：{error_msg}！")
+            retry_times = kwargs.get("retry_limit", 5)
+            if "已达到当前访问上限" in error_msg:
+                if retry_times <= 0:
+                    logger.error(f"【115】{method} 请求 {endpoint} 达到访问上限，重试次数用尽！")
+                    return None
+                kwargs["retry_limit"] = retry_times - 1
+                logger.info(f"【115】{method} 请求 {endpoint} 达到访问上限，等待 {self.retry_delay} 秒后重试...")
+                time.sleep(self.retry_delay)
+                return self._request_api(method, endpoint, result_key, **kwargs)
+            return None
 
         if result_key:
             return ret_data.get(result_key)
@@ -252,8 +274,8 @@ class U115Pan(StorageBase, metaclass=WeakSingleton):
         """
         自动延迟重试 get_item 模块
         """
-        for _ in range(2):
-            time.sleep(2)
+        for i in range(1, 4):
+            time.sleep(2 ** i)
             fileitem = self.get_item(path)
             if fileitem:
                 return fileitem
@@ -352,29 +374,6 @@ class U115Pan(StorageBase, metaclass=WeakSingleton):
             modify_time=int(time.time())
         )
 
-    @staticmethod
-    def _log_progress(desc: str, total: int) -> tqdm:
-        """
-        创建一个可以输出到日志的进度条
-        """
-
-        class TqdmToLogger(io.StringIO):
-            def write(s, buf):  # noqa
-                buf = buf.strip('\r\n\t ')
-                if buf:
-                    logger.info(buf)
-
-        return tqdm(
-            total=total,
-            unit='B',
-            unit_scale=True,
-            desc=desc,
-            file=TqdmToLogger(),
-            mininterval=1.0,
-            maxinterval=5.0,
-            miniters=1
-        )
-
     def upload(self, target_dir: schemas.FileItem, local_path: Path,
                new_name: Optional[str] = None) -> Optional[schemas.FileItem]:
         """
@@ -451,6 +450,9 @@ class U115Pan(StorageBase, metaclass=WeakSingleton):
             )
             if not init_resp:
                 return None
+            if not init_resp.get("state"):
+                logger.warn(f"【115】上传二次认证失败: {init_resp.get('error')}")
+                return None
             # 二次认证结果
             init_result = init_resp.get("data")
             logger.debug(f"【115】上传 Step 2 二次认证结果: {init_result}")
@@ -539,13 +541,7 @@ class U115Pan(StorageBase, metaclass=WeakSingleton):
 
         # 初始化进度条
         logger.info(f"【115】开始上传: {local_path} -> {target_path}，分片大小：{StringUtils.str_filesize(part_size)}")
-        progress_bar = tqdm(
-            total=file_size,
-            unit='B',
-            unit_scale=True,
-            desc="上传进度",
-            ascii=True
-        )
+        progress_callback = transfer_process(local_path.as_posix())
 
         # 初始化分片
         upload_id = bucket.init_multipart_upload(object_name,
@@ -559,6 +555,9 @@ class U115Pan(StorageBase, metaclass=WeakSingleton):
             part_number = 1
             offset = 0
             while offset < file_size:
+                if global_vars.is_transfer_stopped(local_path.as_posix()):
+                    logger.info(f"【115】{local_path} 上传已取消！")
+                    return None
                 num_to_upload = min(part_size, file_size - offset)
                 # 调用SizedFileAdapter(fileobj, size)方法会生成一个新的文件对象，重新计算起始追加位置。
                 logger.info(f"【115】开始上传 {target_name} 分片 {part_number}: {offset} -> {offset + num_to_upload}")
@@ -569,11 +568,11 @@ class U115Pan(StorageBase, metaclass=WeakSingleton):
                 offset += num_to_upload
                 part_number += 1
                 # 更新进度
-                progress_bar.update(num_to_upload)
+                progress = (offset * 100) / file_size
+                progress_callback(progress)
 
-        # 关闭进度条
-        if progress_bar:
-            progress_bar.close()
+        # 完成上传
+        progress_callback(100)
 
         # 请求头
         headers = {
@@ -601,11 +600,13 @@ class U115Pan(StorageBase, metaclass=WeakSingleton):
 
     def download(self, fileitem: schemas.FileItem, path: Path = None) -> Optional[Path]:
         """
-        带限速处理的下载
+        带实时进度显示的下载
         """
         detail = self.get_item(Path(fileitem.path))
         if not detail:
+            logger.error(f"【115】获取文件详情失败: {fileitem.name}")
             return None
+
         download_info = self._request_api(
             "POST",
             "/open/ufile/downurl",
@@ -615,14 +616,58 @@ class U115Pan(StorageBase, metaclass=WeakSingleton):
             }
         )
         if not download_info:
+            logger.error(f"【115】获取下载链接失败: {fileitem.name}")
             return None
+
         download_url = list(download_info.values())[0].get("url", {}).get("url")
+        if not download_url:
+            logger.error(f"【115】下载链接为空: {fileitem.name}")
+            return None
+
         local_path = path or settings.TEMP_PATH / fileitem.name
-        with self.session.get(download_url, stream=True) as r:
-            r.raise_for_status()
-            with open(local_path, "wb") as f:
-                for chunk in r.iter_content(chunk_size=8192):
-                    f.write(chunk)
+
+        # 获取文件大小
+        file_size = detail.size
+
+        # 初始化进度条
+        logger.info(f"【115】开始下载: {fileitem.name} -> {local_path}")
+        progress_callback = transfer_process(Path(fileitem.path).as_posix())
+
+        try:
+            with self.session.get(download_url, stream=True) as r:
+                r.raise_for_status()
+                downloaded_size = 0
+
+                with open(local_path, "wb") as f:
+                    for chunk in r.iter_content(chunk_size=self.chunk_size):
+                        if global_vars.is_transfer_stopped(fileitem.path):
+                            logger.info(f"【115】{fileitem.path} 下载已取消！")
+                            return None
+                        if chunk:
+                            f.write(chunk)
+                            downloaded_size += len(chunk)
+                            # 更新进度
+                            if file_size:
+                                progress = (downloaded_size * 100) / file_size
+                                progress_callback(progress)
+
+                # 完成下载
+                progress_callback(100)
+                logger.info(f"【115】下载完成: {fileitem.name}")
+
+        except requests.exceptions.RequestException as e:
+            logger.error(f"【115】下载网络错误: {fileitem.name} - {str(e)}")
+            # 删除可能部分下载的文件
+            if local_path.exists():
+                local_path.unlink()
+            return None
+        except Exception as e:
+            logger.error(f"【115】下载失败: {fileitem.name} - {str(e)}")
+            # 删除可能部分下载的文件
+            if local_path.exists():
+                local_path.unlink()
+            return None
+
         return local_path
 
     def check(self) -> bool:
@@ -760,8 +805,10 @@ class U115Pan(StorageBase, metaclass=WeakSingleton):
         if resp["state"]:
             new_path = Path(path) / fileitem.name
             new_item = self._delay_get_item(new_path)
-            self.rename(new_item, new_name)
-            return True
+            if not new_item:
+                return False
+            if self.rename(new_item, new_name):
+                return True
         return False
 
     def move(self, fileitem: schemas.FileItem, path: Path, new_name: str) -> bool:
@@ -790,8 +837,10 @@ class U115Pan(StorageBase, metaclass=WeakSingleton):
         if resp["state"]:
             new_path = Path(path) / fileitem.name
             new_file = self._delay_get_item(new_path)
-            self.rename(new_file, new_name)
-            return True
+            if not new_file:
+                return False
+            if self.rename(new_file, new_name):
+                return True
         return False
 
     def link(self, fileitem: schemas.FileItem, target_file: Path) -> bool:

app/modules/indexer/spider/haidan.py

@@ -85,7 +85,7 @@ class HaiDanSpider:
             categories = self._movie_category
 
         # 搜索类型
-        if keyword.startswith('tt'):
+        if keyword and keyword.startswith('tt'):
             search_area = '4'
         else:
             search_area = '0'

app/modules/indexer/spider/hddolby.py

@@ -183,8 +183,11 @@ class HddolbySpider:
             timeout=self._timeout
         ).post_res(url=self._searchurl, json=params)
         if res and res.status_code == 200:
-            results = res.json().get('data', []) or []
-            return False, self.__parse_result(results)
+            result = res.json()
+            if result.get("error"):
+                logger.warn(f"{self._name} 搜索失败，错误信息：{result.get('error').get('message')}")
+                return True, []
+            return False, self.__parse_result(result.get('data'))
         elif res is not None:
             logger.warn(f"{self._name} 搜索失败，错误码：{res.status_code}")
             return True, []
@@ -212,8 +215,11 @@ class HddolbySpider:
             timeout=self._timeout
         ).post_res(url=self._searchurl, json=params)
         if res and res.status_code == 200:
-            results = res.json().get('data', []) or []
-            return False, self.__parse_result(results)
+            result = res.json()
+            if result.get("error"):
+                logger.warn(f"{self._name} 搜索失败，错误信息：{result.get('error').get('message')}")
+                return True, []
+            return False, self.__parse_result(result.get('data'))
         elif res is not None:
             logger.warn(f"{self._name} 搜索失败，错误码：{res.status_code}")
             return True, []

app/modules/indexer/spider/mtorrent.py

@@ -127,6 +127,8 @@ class MTorrentSpider:
                 'labels': labels,
                 'category': category
             }
+            if discount_end_time := (result.get('status') or {}).get('discountEndTime'):
+                torrent['freedate'] = StringUtils.format_timestamp(discount_end_time)
             torrents.append(torrent)
         return torrents
 

app/modules/indexer/spider/tnode.py

@@ -5,13 +5,14 @@ from app.core.cache import cached
 from app.core.config import settings
 from app.log import logger
 from app.utils.http import RequestUtils, AsyncRequestUtils
-from app.utils.singleton import Singleton
+from app.utils.singleton import SingletonClass
 from app.utils.string import StringUtils
 
 
-class TNodeSpider(metaclass=Singleton):
+class TNodeSpider(metaclass=SingletonClass):
     _size = 100
     _timeout = 15
+    _proxy = None
     _baseurl = "%sapi/torrent/advancedSearch"
     _downloadurl = "%sapi/torrent/download/%s"
     _pageurl = "%storrent/info/%s"
@@ -53,7 +54,7 @@ class TNodeSpider(metaclass=Singleton):
         if res and 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)
+                return csrf_token.group(1)
         return None
 
     def __get_params(self, keyword: str = None, page: Optional[int] = 0) -> dict:
@@ -154,7 +155,7 @@ class TNodeSpider(metaclass=Singleton):
         # 发送请求
         res = await AsyncRequestUtils(
             headers={
-                'X-CSRF-TOKEN': _token,
+                'x-csrf-token': _token,
                 "Content-Type": "application/json; charset=utf-8",
                 "User-Agent": f"{self._ua}"
             },

app/modules/postgresql/__init__.py

@@ -0,0 +1,63 @@
+from typing import Tuple, Union
+
+from app.core.config import settings
+from app.db import SessionFactory
+from app.modules import _ModuleBase
+from app.schemas.types import ModuleType, OtherModulesType
+from sqlalchemy import text
+
+
+class PostgreSQLModule(_ModuleBase):
+    """
+    PostgreSQL 数据库模块
+    """
+
+    def init_module(self) -> None:
+        pass
+
+    @staticmethod
+    def get_name() -> str:
+        return "PostgreSQL"
+
+    @staticmethod
+    def get_type() -> ModuleType:
+        """
+        获取模块类型
+        """
+        return ModuleType.Other
+
+    @staticmethod
+    def get_subtype() -> OtherModulesType:
+        """
+        获取模块子类型
+        """
+        return OtherModulesType.PostgreSQL
+
+    @staticmethod
+    def get_priority() -> int:
+        """
+        获取模块优先级，数字越小优先级越高，只有同一接口下优先级才生效
+        """
+        return 0
+
+    def init_setting(self) -> Tuple[str, Union[str, bool]]:
+        pass
+
+    def stop(self) -> None:
+        pass
+
+    def test(self):
+        """
+        测试模块连接性
+        """
+        if settings.DB_TYPE != "postgresql":
+            return None
+        # 测试数据库连接
+        db = SessionFactory()
+        try:
+            db.execute(text("SELECT 1"))
+        except Exception as e:
+            return False, f"PostgreSQL连接失败：{e}"
+        finally:
+            db.close()
+        return True, ""

app/modules/qbittorrent/__init__.py

@@ -5,9 +5,10 @@ from qbittorrentapi import TorrentFilesList
 from torrentool.torrent import Torrent
 
 from app import schemas
+from app.core.cache import FileCache
 from app.core.config import settings
-from app.core.metainfo import MetaInfo
 from app.core.event import eventmanager, Event
+from app.core.metainfo import MetaInfo
 from app.log import logger
 from app.modules import _ModuleBase, _DownloaderBase
 from app.modules.qbittorrent.qbittorrent import Qbittorrent
@@ -92,12 +93,12 @@ class QbittorrentModule(_ModuleBase, _DownloaderBase[Qbittorrent]):
                 logger.info(f"Qbittorrent下载器 {name} 连接断开，尝试重连 ...")
                 server.reconnect()
 
-    def download(self, content: Union[Path, str], download_dir: Path, cookie: str,
+    def download(self, content: Union[Path, str, bytes], download_dir: Path, cookie: str,
                  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]]:
         """
         根据种子文件，选择并添加下载任务
-        :param content:  种子文件地址或者磁力链接
+        :param content:  种子文件地址或者磁力链接或者种子内容
         :param download_dir:  下载目录
         :param cookie:  cookie
         :param episodes:  需要下载的集数
@@ -107,25 +108,44 @@ class QbittorrentModule(_ModuleBase, _DownloaderBase[Qbittorrent]):
         :return: 下载器名称、种子Hash、种子文件布局、错误原因
         """
 
-        def __get_torrent_info() -> Tuple[str, int]:
+        def __get_torrent_info() -> Tuple[Optional[Torrent], Optional[bytes]]:
             """
             获取种子名称
             """
+            torrent_info, torrent_content = None, None
             try:
                 if isinstance(content, Path):
-                    torrentinfo = Torrent.from_file(content)
+                    if content.exists():
+                        torrent_content = content.read_bytes()
+                    else:
+                        # 读取缓存的种子文件
+                        torrent_content = FileCache().get(content.as_posix(), region="torrents")
                 else:
-                    torrentinfo = Torrent.from_string(content)
-                return torrentinfo.name, torrentinfo.total_size
+                    torrent_content = content
+
+                if torrent_content:
+                    # 检查是否为磁力链接
+                    if StringUtils.is_magnet_link(torrent_content):
+                        return None, torrent_content
+                    else:
+                        torrent_info = Torrent.from_string(torrent_content)
+
+                return torrent_info, torrent_content
             except Exception as e:
                 logger.error(f"获取种子名称失败：{e}")
-                return "", 0
+                return None, None
 
         if not content:
             return None, None, None, "下载内容为空"
-        if isinstance(content, Path) and not content.exists():
-            logger.error(f"种子文件不存在：{content}")
-            return None, None, None, f"种子文件不存在：{content}"
+
+        # 读取种子的名称
+        torrent, content = __get_torrent_info()
+        # 检查是否为磁力链接
+        is_magnet = isinstance(content, str) and content.startswith("magnet:") or isinstance(content,
+                                                                                             bytes) and content.startswith(
+            b"magnet:")
+        if not torrent and not is_magnet:
+            return None, None, None, f"添加种子任务失败：无法读取种子文件"
 
         # 获取下载器
         server: Qbittorrent = self.get_instance(downloader)
@@ -144,7 +164,7 @@ class QbittorrentModule(_ModuleBase, _DownloaderBase[Qbittorrent]):
         is_paused = True if episodes else False
         # 添加任务
         state = server.add_torrent(
-            content=content.read_bytes() if isinstance(content, Path) else content,
+            content=content,
             download_dir=str(download_dir),
             is_paused=is_paused,
             tag=tags,
@@ -157,10 +177,6 @@ class QbittorrentModule(_ModuleBase, _DownloaderBase[Qbittorrent]):
         torrent_layout = server.get_content_layout()
 
         if not state:
-            # 读取种子的名称
-            torrent_name, torrent_size = __get_torrent_info()
-            if not torrent_name:
-                return None, None, None, f"添加种子任务失败：无法读取种子文件"
             # 查询所有下载器的种子
             torrents, error = server.get_torrents()
             if error:
@@ -169,7 +185,8 @@ class QbittorrentModule(_ModuleBase, _DownloaderBase[Qbittorrent]):
                 try:
                     for torrent in torrents:
                         # 名称与大小相等则认为是同一个种子
-                        if torrent.get("name") == torrent_name and torrent.get("total_size") == torrent_size:
+                        if torrent.get("name") == torrent.name \
+                                and torrent.get("total_size") == torrent.total_size:
                             torrent_hash = torrent.get("hash")
                             torrent_tags = [str(tag).strip() for tag in torrent.get("tags").split(',')]
                             logger.warn(f"下载器中已存在该种子任务：{torrent_hash} - {torrent.get('name')}")
@@ -326,7 +343,7 @@ class QbittorrentModule(_ModuleBase, _DownloaderBase[Qbittorrent]):
                     del torrents
         else:
             return None
-        return ret_torrents # noqa
+        return ret_torrents  # noqa
 
     def transfer_completed(self, hashs: str, downloader: Optional[str] = None) -> None:
         """

app/modules/redis/__init__.py

@@ -0,0 +1,60 @@
+from typing import Tuple, Union
+
+from app.core.config import settings
+from app.helper.redis import RedisHelper
+from app.modules import _ModuleBase
+from app.schemas.types import ModuleType, OtherModulesType
+
+
+class RedisModule(_ModuleBase):
+    """
+    Redis 数据库模块
+    """
+
+    def init_module(self) -> None:
+        pass
+
+    @staticmethod
+    def get_name() -> str:
+        return "Redis缓存"
+
+    @staticmethod
+    def get_type() -> ModuleType:
+        """
+        获取模块类型
+        """
+        return ModuleType.Other
+
+    @staticmethod
+    def get_subtype() -> OtherModulesType:
+        """
+        获取模块子类型
+        """
+        return OtherModulesType.Redis
+
+    @staticmethod
+    def get_priority() -> int:
+        """
+        获取模块优先级，数字越小优先级越高，只有同一接口下优先级才生效
+        """
+        return 0
+
+    def init_setting(self) -> Tuple[str, Union[str, bool]]:
+        pass
+
+    def stop(self) -> None:
+        pass
+
+    def test(self):
+        """
+        测试模块连接性
+        """
+        if settings.CACHE_BACKEND_TYPE != "redis":
+            return None
+        redis_helper = RedisHelper()
+        try:
+            if redis_helper.test():
+                return True, ""
+            return False, "Redis连接失败，请检查配置"
+        finally:
+            redis_helper.close()

app/modules/slack/__init__.py

@@ -76,7 +76,7 @@ class SlackModule(_ModuleBase, _MessageBase[Slack]):
         for name, client in self.get_instances().items():
             state = client.get_state()
             if not state:
-                return False, f"Slack {name} 未就续"
+                return False, f"Slack {name} 未就绪"
         return True, ""
 
     def init_setting(self) -> Tuple[str, Union[str, bool]]:

app/modules/subtitle/__init__.py

@@ -63,19 +63,19 @@ class SubtitleModule(_ModuleBase):
     def test(self):
         pass
 
-    def download_added(self, context: Context, download_dir: Path, torrent_path: Path = None) -> None:
+    def download_added(self, context: Context, download_dir: Path, torrent_content: Union[str, bytes] = None):
         """
         添加下载任务成功后，从站点下载字幕，保存到下载目录
         :param context:  上下文，包括识别信息、媒体信息、种子信息
         :param download_dir:  下载目录
-        :param torrent_path:  种子文件地址
+        :param torrent_content: 种子内容，如果是种子文件，则为文件内容，否则为种子字符串
         :return: None，该方法可被多个模块同时处理
         """
         if not settings.DOWNLOAD_SUBTITLE:
-            return None
+            return
 
         # 没有种子文件不处理
-        if not torrent_path:
+        if not torrent_content:
             return
 
         # 没有详情页不处理
@@ -85,7 +85,7 @@ class SubtitleModule(_ModuleBase):
         # 字幕下载目录
         logger.info("开始从站点下载字幕：%s" % torrent.page_url)
         # 获取种子信息
-        folder_name, _ = TorrentHelper.get_torrent_info(torrent_path)
+        folder_name, _ = TorrentHelper().get_fileinfo_from_torrent_content(torrent_content)
         # 文件保存目录，如果是单文件种子，则folder_name是空，此时文件保存目录就是下载目录
         download_dir = download_dir / folder_name
         # 等待目录存在

app/modules/synologychat/__init__.py

@@ -70,7 +70,7 @@ class SynologyChatModule(_ModuleBase, _MessageBase[SynologyChat]):
         for name, client in self.get_instances().items():
             state = client.get_state()
             if not state:
-                return False, f"Synology Chat {name} 未就续"
+                return False, f"Synology Chat {name} 未就绪"
         return True, ""
 
     def init_setting(self) -> Tuple[str, Union[str, bool]]:

app/modules/telegram/__init__.py

@@ -81,7 +81,7 @@ class TelegramModule(_ModuleBase, _MessageBase[Telegram]):
         for name, client in self.get_instances().items():
             state = client.get_state()
             if not state:
-                return False, f"Telegram {name} 未就续"
+                return False, f"Telegram {name} 未就绪"
         return True, ""
 
     def init_setting(self) -> Tuple[str, Union[str, bool]]:

app/modules/themoviedb/__init__.py

@@ -639,6 +639,8 @@ class TheMovieDbModule(_ModuleBase):
         """
         搜索人物信息
         """
+        if settings.SEARCH_SOURCE and "themoviedb" not in settings.SEARCH_SOURCE:
+            return None
         if not name:
             return []
         results = self.tmdb.search_persons(name)
@@ -646,6 +648,19 @@ class TheMovieDbModule(_ModuleBase):
             return [MediaPerson(source='themoviedb', **person) for person in results]
         return []
 
+    async def async_search_persons(self, name: str) -> Optional[List[MediaPerson]]:
+        """
+        异步搜索人物信息
+        """
+        if settings.SEARCH_SOURCE and "themoviedb" not in settings.SEARCH_SOURCE:
+            return None
+        if not name:
+            return []
+        results = await self.tmdb.async_search_persons(name)
+        if results:
+            return [MediaPerson(source='themoviedb', **person) for person in results]
+        return []
+
     def search_collections(self, name: str) -> Optional[List[MediaInfo]]:
         """
         搜索集合信息

app/modules/themoviedb/category.py

@@ -108,6 +108,7 @@ class CategoryHelper(metaclass=WeakSingleton):
             return ""
         if not categorys:
             return ""
+
         for key, item in categorys.items():
             if not item:
                 return key
@@ -127,30 +128,48 @@ class CategoryHelper(metaclass=WeakSingleton):
                     continue
                 elif attr == "production_countries":
                     # 制片国家
-                    info_values = [str(val.get("iso_3166_1")).upper() for val in info_value] # type: ignore
+                    info_values = [str(val.get("iso_3166_1")).upper() for val in info_value]  # type: ignore
                 else:
                     if isinstance(info_value, list):
                         info_values = [str(val).upper() for val in info_value]
                     else:
                         info_values = [str(info_value).upper()]
 
-                if value.find(",") != -1:
-                    # , 分隔多个值
-                    values = [str(val).upper() for val in value.split(",") if val]
-                elif value.find("-") != -1:
-                    # - 表示范围，仅限于数字
-                    value_begin = value.split("-")[0]
-                    value_end = value.split("-")[1]
+                values = []
+                invert_values = []
+
+                # 如果有 "," 进行分割
+                values = [str(val) for val in value.split(",") if val]
+
+                expanded_values = []
+                for v in values:
+                    if "-" not in v:
+                        expanded_values.append(v)
+                        continue
+
+                    # - 表示范围
+                    value_begin, value_end = v.split("-", 1)
+
+                    prefix = ""
+                    if value_begin.startswith('!'):
+                        prefix = '!'
+                        value_begin = value_begin[1:]
+
                     if value_begin.isdigit() and value_end.isdigit():
                         # 数字范围
-                        values = [str(val) for val in range(int(value_begin), int(value_end) + 1)]
+                        expanded_values.extend(f"{prefix}{val}" for val in range(int(value_begin), int(value_end) + 1))
                     else:
                         # 字符串范围
-                        values = [str(value_begin), str(value_end)]
-                else:
-                    values = [str(value).upper()]
+                        expanded_values.extend([f"{prefix}{value_begin}", f"{prefix}{value_end}"])
 
-                if not set(values).intersection(set(info_values)):
+                values = list(map(str.upper, expanded_values))
+
+                invert_values = [val[1:] for val in values if val.startswith('!')]
+                values = [val for val in values if not val.startswith('!')]
+
+                if values and not set(values).intersection(set(info_values)):
+                    match_flag = False
+                if invert_values and set(invert_values).intersection(set(info_values)):
                     match_flag = False
             if match_flag:
                 return key

app/modules/themoviedb/tmdb_cache.py

@@ -1,22 +1,17 @@
 import pickle
-import random
-import time
 import traceback
 from pathlib import Path
 from threading import RLock
-from typing import Optional
 
+from app.core.cache import TTLCache
 from app.core.config import settings
 from app.core.meta import MetaBase
 from app.log import logger
-from app.utils.singleton import WeakSingleton
 from app.schemas.types import MediaType
+from app.utils.singleton import WeakSingleton
 
 lock = RLock()
 
-CACHE_EXPIRE_TIMESTAMP_STR = "cache_expire_timestamp"
-EXPIRE_TIMESTAMP = settings.CONF.meta
-
 
 class TmdbCache(metaclass=WeakSingleton):
     """
@@ -32,15 +27,23 @@ class TmdbCache(metaclass=WeakSingleton):
     _tmdb_cache_expire: bool = True
 
     def __init__(self):
-        self._meta_path = settings.TEMP_PATH / "__tmdb_cache__"
-        self._meta_data = self.__load(self._meta_path)
+        self.maxsize = settings.CONF.douban
+        self.ttl = settings.CONF.meta
+        self.region = "__tmdb_cache__"
+        self._meta_filepath = settings.TEMP_PATH / self.region
+        # 初始化缓存
+        self._cache = TTLCache(region=self.region, maxsize=self.maxsize, ttl=self.ttl)
+        # 非Redis加载本地缓存数据
+        if not self._cache.is_redis():
+            for key, value in self.__load(self._meta_filepath).items():
+                self._cache.set(key, value)
 
     def clear(self):
         """
         清空所有TMDB缓存
         """
         with lock:
-            self._meta_data = {}
+            self._cache.clear()
 
     @staticmethod
     def __get_key(meta: MetaBase) -> str:
@@ -54,16 +57,9 @@ class TmdbCache(metaclass=WeakSingleton):
         根据KEY值获取缓存值
         """
         key = self.__get_key(meta)
+
         with lock:
-            info: dict = self._meta_data.get(key)
-            if info:
-                expire = info.get(CACHE_EXPIRE_TIMESTAMP_STR)
-                if not expire or int(time.time()) < expire:
-                    info[CACHE_EXPIRE_TIMESTAMP_STR] = int(time.time()) + EXPIRE_TIMESTAMP
-                    self._meta_data[key] = info
-                elif expire and self._tmdb_cache_expire:
-                    self.delete(key)
-            return info or {}
+            return self._cache.get(key) or {}
 
     def delete(self, key: str) -> dict:
         """
@@ -72,38 +68,26 @@ class TmdbCache(metaclass=WeakSingleton):
         @return: 被删除的缓存内容
         """
         with lock:
-            return self._meta_data.pop(key, {})
-
-    def delete_by_tmdbid(self, tmdbid: int) -> None:
-        """
-        清空对应TMDBID的所有缓存记录，以强制更新TMDB中最新的数据
-        """
-        for key in list(self._meta_data):
-            if self._meta_data.get(key, {}).get("id") == tmdbid:
-                with lock:
-                    self._meta_data.pop(key)
-
-    def delete_unknown(self) -> None:
-        """
-        清除未识别的缓存记录，以便重新搜索TMDB
-        """
-        for key in list(self._meta_data):
-            if self._meta_data.get(key, {}).get("id") == 0:
-                with lock:
-                    self._meta_data.pop(key)
+            redis_data = self._cache.get(key)
+            if redis_data:
+                self._cache.delete(key)
+                return redis_data
+            return {}
 
     def modify(self, key: str, title: str) -> dict:
         """
-        删除缓存信息
+        修改缓存信息
         @param key: 缓存key
         @param title: 标题
         @return: 被修改后缓存内容
         """
         with lock:
-            if self._meta_data.get(key):
-                self._meta_data[key]['title'] = title
-                self._meta_data[key][CACHE_EXPIRE_TIMESTAMP_STR] = int(time.time()) + EXPIRE_TIMESTAMP
-            return self._meta_data.get(key)
+            redis_data = self._cache.get(key)
+            if redis_data:
+                redis_data['title'] = title
+                self._cache.set(key, redis_data)
+                return redis_data
+            return {}
 
     @staticmethod
     def __load(path: Path) -> dict:
@@ -115,106 +99,61 @@ class TmdbCache(metaclass=WeakSingleton):
                 with open(path, 'rb') as f:
                     data = pickle.load(f)
                 return data
-            return {}
         except Exception as e:
             logger.error(f'加载缓存失败：{str(e)} - {traceback.format_exc()}')
-            return {}
+        return {}
 
     def update(self, meta: MetaBase, info: dict) -> None:
         """
         新增或更新缓存条目
         """
-        with lock:
-            if info:
-                # 缓存标题
-                cache_title = info.get("title") \
-                    if info.get("media_type") == MediaType.MOVIE else info.get("name")
-                # 缓存年份
-                cache_year = info.get('release_date') \
-                    if info.get("media_type") == MediaType.MOVIE else info.get('first_air_date')
-                if cache_year:
-                    cache_year = cache_year[:4]
-                self._meta_data[self.__get_key(meta)] = {
+        key = self.__get_key(meta)
+        if info:
+            # 缓存标题
+            cache_title = info.get("title") \
+                if info.get("media_type") == MediaType.MOVIE else info.get("name")
+            # 缓存年份
+            cache_year = info.get('release_date') \
+                if info.get("media_type") == MediaType.MOVIE else info.get('first_air_date')
+            if cache_year:
+                cache_year = cache_year[:4]
+
+            with lock:
+                # 缓存数据
+                cache_data = {
                     "id": info.get("id"),
                     "type": info.get("media_type"),
                     "year": cache_year,
                     "title": cache_title,
                     "poster_path": info.get("poster_path"),
-                    "backdrop_path": info.get("backdrop_path"),
-                    CACHE_EXPIRE_TIMESTAMP_STR: int(time.time()) + EXPIRE_TIMESTAMP
+                    "backdrop_path": info.get("backdrop_path")
                 }
-            elif info is not None:
-                # None时不缓存，此时代表网络错误，允许重复请求
-                self._meta_data[self.__get_key(meta)] = {'id': 0}
+                self._cache.set(key, cache_data)
+
+        elif info is not None:
+            # None时不缓存，此时代表网络错误，允许重复请求
+            with lock:
+                self._cache.set(key, {"id": 0})
 
     def save(self, force: bool = False) -> None:
         """
         保存缓存数据到文件
         """
+        # Redis不需要保存到本地文件
+        if self._cache.is_redis():
+            return
 
-        meta_data = self.__load(self._meta_path)
-        new_meta_data = {k: v for k, v in self._meta_data.items() if v.get("id")}
+        # Redis不可用时，保存到本地文件
+        meta_data = self.__load(self._meta_filepath)
+        # 当前缓存，去除无法识别
+        new_meta_data = {k: v for k, v in self._cache.items() if v.get("id")}
 
         if not force \
-                and not self._random_sample(new_meta_data) \
                 and meta_data.keys() == new_meta_data.keys():
             return
 
-        with open(self._meta_path, 'wb') as f:
+        with open(self._meta_filepath, 'wb') as f:
             pickle.dump(new_meta_data, f, pickle.HIGHEST_PROTOCOL)  # type: ignore
 
-    def _random_sample(self, new_meta_data: dict) -> bool:
-        """
-        采样分析是否需要保存
-        """
-        ret = False
-        if len(new_meta_data) < 25:
-            keys = list(new_meta_data.keys())
-            for k in keys:
-                info = new_meta_data.get(k)
-                expire = info.get(CACHE_EXPIRE_TIMESTAMP_STR)
-                if not expire:
-                    ret = True
-                    info[CACHE_EXPIRE_TIMESTAMP_STR] = int(time.time()) + EXPIRE_TIMESTAMP
-                elif int(time.time()) >= expire:
-                    ret = True
-                    if self._tmdb_cache_expire:
-                        new_meta_data.pop(k)
-        else:
-            count = 0
-            keys = random.sample(sorted(new_meta_data.keys()), 25)
-            for k in keys:
-                info = new_meta_data.get(k)
-                expire = info.get(CACHE_EXPIRE_TIMESTAMP_STR)
-                if not expire:
-                    ret = True
-                    info[CACHE_EXPIRE_TIMESTAMP_STR] = int(time.time()) + EXPIRE_TIMESTAMP
-                elif int(time.time()) >= expire:
-                    ret = True
-                    if self._tmdb_cache_expire:
-                        new_meta_data.pop(k)
-                        count += 1
-            if count >= 5:
-                ret |= self._random_sample(new_meta_data)
-        return ret
-
-    def get_title(self, key: str) -> Optional[str]:
-        """
-        获取缓存的标题
-        """
-        cache_media_info = self._meta_data.get(key)
-        if not cache_media_info or not cache_media_info.get("id"):
-            return None
-        return cache_media_info.get("title")
-
-    def set_title(self, key: str, cn_title: str) -> None:
-        """
-        重新设置缓存标题
-        """
-        cache_media_info = self._meta_data.get(key)
-        if not cache_media_info:
-            return
-        self._meta_data[key]['title'] = cn_title
-
     def __del__(self):
         self.save()

app/modules/themoviedb/tmdbapi.py

@@ -348,9 +348,13 @@ class TmdbApi:
         处理网站搜索得到的链接
         """
         if len(tmdb_links) == 1:
+            tmdbid = self._parse_tmdb_id_from_link(tmdb_links[0])
+            if not tmdbid:
+                logger.warn(f"无法从链接解析TMDBID：{tmdb_links[0]}")
+                return {}
             tmdbinfo = get_info_func(
                 mtype=MediaType.TV if tmdb_links[0].startswith("/tv") else MediaType.MOVIE,
-                tmdbid=tmdb_links[0].split("/")[-1])
+                tmdbid=tmdbid)
             if tmdbinfo:
                 if mtype == MediaType.TV and tmdbinfo.get('media_type') != MediaType.TV:
                     return {}
@@ -368,9 +372,13 @@ class TmdbApi:
         处理网站搜索得到的链接（异步版本）
         """
         if len(tmdb_links) == 1:
+            tmdbid = self._parse_tmdb_id_from_link(tmdb_links[0])
+            if not tmdbid:
+                logger.warn(f"无法从链接解析TMDBID：{tmdb_links[0]}")
+                return {}
             tmdbinfo = await self.async_get_info(
                 mtype=MediaType.TV if tmdb_links[0].startswith("/tv") else MediaType.MOVIE,
-                tmdbid=int(tmdb_links[0].split("/")[-1]))
+                tmdbid=tmdbid)
             if tmdbinfo:
                 if mtype == MediaType.TV and tmdbinfo.get('media_type') != MediaType.TV:
                     return {}
@@ -382,6 +390,23 @@ class TmdbApi:
             logger.info("%s TMDB网站未查询到媒体信息！" % name)
         return {}
 
+    @staticmethod
+    def _parse_tmdb_id_from_link(link: str) -> Optional[int]:
+        """
+        从 TMDB 相对链接中解析数值 ID。
+        兼容格式：/movie/1195631-william-tell、/tv/65942-re、/tv/79744-the-rookie
+        """
+        if not link:
+            return None
+        match = re.match(r"^/[^/]+/(\d+)", link)
+        if match:
+            try:
+                return int(match.group(1))
+            except Exception as err:
+                logger.debug(f"解析TMDBID失败：{str(err)} - {traceback.format_exc()}")
+                return None
+        return None
+
     @staticmethod
     def __get_names(tmdb_info: dict) -> List[str]:
         """
@@ -808,7 +833,6 @@ class TmdbApi:
             return None
         # dict[地区:分级]
         ratings = {}
-        results = []
         if results := (tmdb_info.get("release_dates") or {}).get("results"):
             """
             [

app/modules/themoviedb/tmdbv3api/tmdb.py

@@ -43,6 +43,8 @@ class TMDb(object):
         self._timeout = 15
         self.obj_cached = obj_cached
 
+        self.__clear_async_cache__ = False
+
     @property
     def page(self):
         return self._page
@@ -125,14 +127,17 @@ class TMDb(object):
     def cache(self, cache):
         self._cache_enabled = bool(cache)
 
-    @cached(maxsize=settings.CONF.tmdb, ttl=settings.CONF.meta)
+    @cached(maxsize=settings.CONF.tmdb, ttl=settings.CONF.meta, skip_none=True)
     def cached_request(self, method, url, data, json,
                        _ts=datetime.strftime(datetime.now(), '%Y%m%d')):
         return self.request(method, url, data, json)
 
-    @cached(maxsize=settings.CONF.tmdb, ttl=settings.CONF.meta)
+    @cached(maxsize=settings.CONF.tmdb, ttl=settings.CONF.meta, skip_none=True)
     async def async_cached_request(self, method, url, data, json,
                                    _ts=datetime.strftime(datetime.now(), '%Y%m%d')):
+        if self.__clear_async_cache__:
+            self.__clear_async_cache__ = False
+            await self.async_cached_request.cache_clear()
         return await self.async_request(method, url, data, json)
 
     def request(self, method, url, data, json):
@@ -154,6 +159,7 @@ class TMDb(object):
         return req
 
     def cache_clear(self):
+        self.__clear_async_cache__ = True
         return self.cached_request.cache_clear()
 
     def _validate_api_key(self):

app/modules/thetvdb/tvdb_v4_official.py

@@ -7,6 +7,8 @@ import json
 import urllib.parse
 from http import HTTPStatus
 
+from app.core.cache import cached
+from app.core.config import settings
 from app.utils.http import RequestUtils
 
 
@@ -15,7 +17,7 @@ class Auth:
     TVDB认证类
     """
 
-    def __init__(self, url, apikey, pin="", proxy=None, timeout: int = 15):
+    def __init__(self, url: str, apikey: str, pin: str = "", proxy: dict = None, timeout: int = 15):
         login_info = {"apikey": apikey}
         if pin != "":
             login_info["pin"] = pin
@@ -35,13 +37,14 @@ class Auth:
                 result = response.json()
                 self.token = result["data"]["token"]
             else:
-                error_msg = f"登录失败，状态码: {response.status_code if response else 'None'}"
-                if response:
+                if response is not None:
                     try:
                         error_data = response.json()
                         error_msg = f"Code: {response.status_code}, {error_data.get('message', '未知错误')}"
                     except Exception as err:
                         error_msg = f"Code: {response.status_code}, 响应解析失败：{err}"
+                else:
+                    error_msg = "网络连接失败，未收到响应"
                 raise Exception(error_msg)
         except Exception as e:
             raise Exception(f"TVDB认证失败: {str(e)}")
@@ -58,13 +61,14 @@ class Request:
     请求处理类
     """
 
-    def __init__(self, auth_token, proxy=None, timeout=15):
+    def __init__(self, auth_token: str, proxy: dict = None, timeout: int = 15):
         self.auth_token = auth_token
         self.links = None
         self.proxy = proxy
         self.timeout = timeout
 
-    def make_request(self, url, if_modified_since=None):
+    @cached(maxsize=settings.CONF.tmdb, ttl=settings.CONF.meta, skip_none=True)
+    def make_request(self, url: str, if_modified_since: bool = None):
         """
         向指定的 URL 发起请求并返回数据
         """
@@ -118,7 +122,8 @@ class Url:
     def __init__(self):
         self.base_url = "https://api4.thetvdb.com/v4/"
 
-    def construct(self, url_sect, url_id=None, url_subsect=None, url_lang=None, **kwargs):
+    def construct(self, url_sect: str, url_id: int = None,
+                  url_subsect: str = None, url_lang: str = None, **kwargs):
         """
         构建API URL
         """
@@ -141,7 +146,7 @@ class TVDB:
     TVDB API主类
     """
 
-    def __init__(self, apikey: str, pin="", proxy=None, timeout: int = 15):
+    def __init__(self, apikey: str, pin: str = "", proxy: dict = None, timeout: int = 15):
         self.url = Url()
         login_url = self.url.construct("login")
         self.auth = Auth(login_url, apikey, pin, proxy, timeout)
@@ -154,126 +159,126 @@ class TVDB:
         """
         return self.request.links
 
-    def get_artwork_statuses(self, meta=None, if_modified_since=None) -> list:
+    def get_artwork_statuses(self, meta: str = None, if_modified_since: bool = None) -> list:
         """
         返回艺术图状态列表
         """
         url = self.url.construct("artwork/statuses", meta=meta)
         return self.request.make_request(url, if_modified_since)
 
-    def get_artwork_types(self, meta=None, if_modified_since=None) -> list:
+    def get_artwork_types(self, meta: str = None, if_modified_since: bool = None) -> list:
         """
         返回艺术图类型列表
         """
         url = self.url.construct("artwork/types", meta=meta)
         return self.request.make_request(url, if_modified_since)
 
-    def get_artwork(self, id: int, meta=None, if_modified_since=None) -> dict:
+    def get_artwork(self, id: int, meta: str = None, if_modified_since: bool = None) -> dict:
         """
         返回单个艺术图信息的字典
         """
         url = self.url.construct("artwork", id, meta=meta)
         return self.request.make_request(url, if_modified_since)
 
-    def get_artwork_extended(self, id: int, meta=None, if_modified_since=None) -> dict:
+    def get_artwork_extended(self, id: int, meta: str = None, if_modified_since: bool = None) -> dict:
         """
         返回单个艺术图的扩展信息字典
         """
         url = self.url.construct("artwork", id, "extended", meta=meta)
         return self.request.make_request(url, if_modified_since)
 
-    def get_all_awards(self, meta=None, if_modified_since=None) -> list:
+    def get_all_awards(self, meta: str = None, if_modified_since: bool = None) -> list:
         """
         返回奖项列表
         """
         url = self.url.construct("awards", meta=meta)
         return self.request.make_request(url, if_modified_since)
 
-    def get_award(self, id: int, meta=None, if_modified_since=None) -> dict:
+    def get_award(self, id: int, meta: str = None, if_modified_since: bool = None) -> dict:
         """
         返回单个奖项信息的字典
         """
         url = self.url.construct("awards", id, meta=meta)
         return self.request.make_request(url, if_modified_since)
 
-    def get_award_extended(self, id: int, meta=None, if_modified_since=None) -> dict:
+    def get_award_extended(self, id: int, meta: str = None, if_modified_since: bool = None) -> dict:
         """
         返回单个奖项的扩展信息字典
         """
         url = self.url.construct("awards", id, "extended", meta=meta)
         return self.request.make_request(url, if_modified_since)
 
-    def get_all_award_categories(self, meta=None, if_modified_since=None) -> list:
+    def get_all_award_categories(self, meta: str = None, if_modified_since: bool = None) -> list:
         """
         返回奖项类别列表
         """
         url = self.url.construct("awards/categories", meta=meta)
         return self.request.make_request(url, if_modified_since)
 
-    def get_award_category(self, id: int, meta=None, if_modified_since=None) -> dict:
+    def get_award_category(self, id: int, meta: str = None, if_modified_since: bool = None) -> dict:
         """
         返回单个奖项类别信息的字典
         """
         url = self.url.construct("awards/categories", id, meta=meta)
         return self.request.make_request(url, if_modified_since)
 
-    def get_award_category_extended(self, id: int, meta=None, if_modified_since=None) -> dict:
+    def get_award_category_extended(self, id: int, meta: str = None, if_modified_since: bool = None) -> dict:
         """
         返回单个奖项类别的扩展信息字典
         """
         url = self.url.construct("awards/categories", id, "extended", meta=meta)
         return self.request.make_request(url, if_modified_since)
 
-    def get_content_ratings(self, meta=None, if_modified_since=None) -> list:
+    def get_content_ratings(self, meta: str = None, if_modified_since: bool = None) -> list:
         """
         返回内容分级列表
         """
         url = self.url.construct("content/ratings", meta=meta)
         return self.request.make_request(url, if_modified_since)
 
-    def get_countries(self, meta=None, if_modified_since=None) -> list:
+    def get_countries(self, meta: str = None, if_modified_since: bool = None) -> list:
         """
         返回国家列表
         """
         url = self.url.construct("countries", meta=meta)
         return self.request.make_request(url, if_modified_since)
 
-    def get_all_companies(self, page=None, meta=None, if_modified_since=None) -> list:
+    def get_all_companies(self, page: int = None, meta: str = None, if_modified_since: bool = None) -> list:
         """
         返回公司列表 (可分页)
         """
         url = self.url.construct("companies", page=page, meta=meta)
         return self.request.make_request(url, if_modified_since)
 
-    def get_company_types(self, meta=None, if_modified_since=None) -> list:
+    def get_company_types(self, meta: str = None, if_modified_since: bool = None) -> list:
         """
         返回公司类型列表
         """
         url = self.url.construct("companies/types", meta=meta)
         return self.request.make_request(url, if_modified_since)
 
-    def get_company(self, id: int, meta=None, if_modified_since=None) -> dict:
+    def get_company(self, id: int, meta: str = None, if_modified_since: bool = None) -> dict:
         """
         返回单个公司信息的字典
         """
         url = self.url.construct("companies", id, meta=meta)
         return self.request.make_request(url, if_modified_since)
 
-    def get_all_series(self, page=None, meta=None, if_modified_since=None) -> list:
+    def get_all_series(self, page: int = None, meta: str = None, if_modified_since: bool = None) -> list:
         """
         返回剧集列表 (可分页)
         """
         url = self.url.construct("series", page=page, meta=meta)
         return self.request.make_request(url, if_modified_since)
 
-    def get_series(self, id: int, meta=None, if_modified_since=None) -> dict:
+    def get_series(self, id: int, meta: str = None, if_modified_since: bool = None) -> dict:
         """
         返回单个剧集信息的字典
         """
         url = self.url.construct("series", id, meta=meta)
         return self.request.make_request(url, if_modified_since)
 
-    def get_series_by_slug(self, slug: str, meta=None, if_modified_since=None) -> dict:
+    def get_series_by_slug(self, slug: str, meta: str = None, if_modified_since: bool = None) -> dict:
         """
         通过 slug (别名) 返回单个剧集信息的字典
         """
@@ -288,7 +293,7 @@ class TVDB:
         return self.request.make_request(url, if_modified_since)
 
     def get_series_episodes(self, id: int, season_type: str = "default", page: int = 0,
-                            lang: str = None, meta=None, if_modified_since=None, **kwargs) -> dict:
+                            lang: str = None, meta: str = None, if_modified_since: bool = None, **kwargs) -> dict:
         """
         返回指定剧集和季类型的各集信息字典 (可分页，可指定语言)
         """
@@ -297,7 +302,7 @@ class TVDB:
         )
         return self.request.make_request(url, if_modified_since)
 
-    def get_series_translation(self, id: int, lang: str, meta=None, if_modified_since=None) -> dict:
+    def get_series_translation(self, id: int, lang: str, meta: str = None, if_modified_since: bool = None) -> dict:
         """
         返回剧集的指定语言翻译信息字典
         """
@@ -318,21 +323,21 @@ class TVDB:
         url = self.url.construct("series", id, "nextAired")
         return self.request.make_request(url, if_modified_since)
 
-    def get_all_movies(self, page=None, meta=None, if_modified_since=None) -> list:
+    def get_all_movies(self, page: int = None, meta: str = None, if_modified_since: bool = None) -> list:
         """
         返回电影列表 (可分页)
         """
         url = self.url.construct("movies", page=page, meta=meta)
         return self.request.make_request(url, if_modified_since)
 
-    def get_movie(self, id: int, meta=None, if_modified_since=None) -> dict:
+    def get_movie(self, id: int, meta: str = None, if_modified_since: bool = None) -> dict:
         """
         返回单个电影信息的字典
         """
         url = self.url.construct("movies", id, meta=meta)
         return self.request.make_request(url, if_modified_since)
 
-    def get_movie_by_slug(self, slug: str, meta=None, if_modified_since=None) -> dict:
+    def get_movie_by_slug(self, slug: str, meta: str = None, if_modified_since: bool = None) -> dict:
         """
         通过 slug (别名) 返回单个电影信息的字典
         """
@@ -346,70 +351,70 @@ class TVDB:
         url = self.url.construct("movies", id, "extended", meta=meta, short=short)
         return self.request.make_request(url, if_modified_since)
 
-    def get_movie_translation(self, id: int, lang: str, meta=None, if_modified_since=None) -> dict:
+    def get_movie_translation(self, id: int, lang: str, meta: str = None, if_modified_since: bool = None) -> dict:
         """
         返回电影的指定语言翻译信息字典
         """
         url = self.url.construct("movies", id, "translations", lang, meta=meta)
         return self.request.make_request(url, if_modified_since)
 
-    def get_all_seasons(self, page=None, meta=None, if_modified_since=None) -> list:
+    def get_all_seasons(self, page: int = None, meta: str = None, if_modified_since: bool = None) -> list:
         """
         返回季列表 (可分页)
         """
         url = self.url.construct("seasons", page=page, meta=meta)
         return self.request.make_request(url, if_modified_since)
 
-    def get_season(self, id: int, meta=None, if_modified_since=None) -> dict:
+    def get_season(self, id: int, meta: str = None, if_modified_since: bool = None) -> dict:
         """
         返回单季信息的字典
         """
         url = self.url.construct("seasons", id, meta=meta)
         return self.request.make_request(url, if_modified_since)
 
-    def get_season_extended(self, id: int, meta=None, if_modified_since=None) -> dict:
+    def get_season_extended(self, id: int, meta: str = None, if_modified_since: bool = None) -> dict:
         """
         返回单季的扩展信息字典
         """
         url = self.url.construct("seasons", id, "extended", meta=meta)
         return self.request.make_request(url, if_modified_since)
 
-    def get_season_types(self, meta=None, if_modified_since=None) -> list:
+    def get_season_types(self, meta: str = None, if_modified_since: bool = None) -> list:
         """
         返回季类型列表
         """
         url = self.url.construct("seasons/types", meta=meta)
         return self.request.make_request(url, if_modified_since)
 
-    def get_season_translation(self, id: int, lang: str, meta=None, if_modified_since=None) -> dict:
+    def get_season_translation(self, id: int, lang: str, meta: str = None, if_modified_since: bool = None) -> dict:
         """
         返回季的指定语言翻译信息字典
         """
         url = self.url.construct("seasons", id, "translations", lang, meta=meta)
         return self.request.make_request(url, if_modified_since)
 
-    def get_all_episodes(self, page=None, meta=None, if_modified_since=None) -> list:
+    def get_all_episodes(self, page: int = None, meta: str = None, if_modified_since: bool = None) -> list:
         """
         返回集列表 (可分页)
         """
         url = self.url.construct("episodes", page=page, meta=meta)
         return self.request.make_request(url, if_modified_since)
 
-    def get_episode(self, id: int, meta=None, if_modified_since=None) -> dict:
+    def get_episode(self, id: int, meta: str = None, if_modified_since: bool = None) -> dict:
         """
         返回单集信息的字典
         """
         url = self.url.construct("episodes", id, meta=meta)
         return self.request.make_request(url, if_modified_since)
 
-    def get_episode_extended(self, id: int, meta=None, if_modified_since=None) -> dict:
+    def get_episode_extended(self, id: int, meta: str = None, if_modified_since: bool = None) -> dict:
         """
         返回单集的扩展信息字典
         """
         url = self.url.construct("episodes", id, "extended", meta=meta)
         return self.request.make_request(url, if_modified_since)
 
-    def get_episode_translation(self, id: int, lang: str, meta=None, if_modified_since=None) -> dict:
+    def get_episode_translation(self, id: int, lang: str, meta: str = None, if_modified_since: bool = None) -> dict:
         """
         返回单集的指定语言翻译信息字典
         """
@@ -419,70 +424,70 @@ class TVDB:
     # 兼容旧函数名。
     get_episodes_translation = get_episode_translation
 
-    def get_all_genders(self, meta=None, if_modified_since=None) -> list:
+    def get_all_genders(self, meta: str = None, if_modified_since: bool = None) -> list:
         """
         返回性别列表
         """
         url = self.url.construct("genders", meta=meta)
         return self.request.make_request(url, if_modified_since)
 
-    def get_all_genres(self, meta=None, if_modified_since=None) -> list:
+    def get_all_genres(self, meta: str = None, if_modified_since: bool = None) -> list:
         """
         返回类型（流派）列表
         """
         url = self.url.construct("genres", meta=meta)
         return self.request.make_request(url, if_modified_since)
 
-    def get_genre(self, id: int, meta=None, if_modified_since=None) -> dict:
+    def get_genre(self, id: int, meta: str = None, if_modified_since: bool = None) -> dict:
         """
         返回单个类型（流派）信息的字典
         """
         url = self.url.construct("genres", id, meta=meta)
         return self.request.make_request(url, if_modified_since)
 
-    def get_all_languages(self, meta=None, if_modified_since=None) -> list:
+    def get_all_languages(self, meta: str = None, if_modified_since: bool = None) -> list:
         """
         返回语言列表
         """
         url = self.url.construct("languages", meta=meta)
         return self.request.make_request(url, if_modified_since)
 
-    def get_all_people(self, page=None, meta=None, if_modified_since=None) -> list:
+    def get_all_people(self, page: int = None, meta: str = None, if_modified_since: bool = None) -> list:
         """
         返回人物列表 (可分页)
         """
         url = self.url.construct("people", page=page, meta=meta)
         return self.request.make_request(url, if_modified_since)
 
-    def get_person(self, id: int, meta=None, if_modified_since=None) -> dict:
+    def get_person(self, id: int, meta: str = None, if_modified_since: bool = None) -> dict:
         """
         返回单个人物信息的字典
         """
         url = self.url.construct("people", id, meta=meta)
         return self.request.make_request(url, if_modified_since)
 
-    def get_person_extended(self, id: int, meta=None, if_modified_since=None) -> dict:
+    def get_person_extended(self, id: int, meta: str = None, if_modified_since: bool = None) -> dict:
         """
         返回单个人物的扩展信息字典
         """
         url = self.url.construct("people", id, "extended", meta=meta)
         return self.request.make_request(url, if_modified_since)
 
-    def get_person_translation(self, id: int, lang: str, meta=None, if_modified_since=None) -> dict:
+    def get_person_translation(self, id: int, lang: str, meta: str = None, if_modified_since: bool = None) -> dict:
         """
         返回人物的指定语言翻译信息字典
         """
         url = self.url.construct("people", id, "translations", lang, meta=meta)
         return self.request.make_request(url, if_modified_since)
 
-    def get_character(self, id: int, meta=None, if_modified_since=None) -> dict:
+    def get_character(self, id: int, meta: str = None, if_modified_since: bool = None) -> dict:
         """
         返回角色信息的字典
         """
         url = self.url.construct("characters", id, meta=meta)
         return self.request.make_request(url, if_modified_since)
 
-    def get_people_types(self, meta=None, if_modified_since=None) -> list:
+    def get_people_types(self, meta: str = None, if_modified_since: bool = None) -> list:
         """
         返回人物类型列表
         """
@@ -492,7 +497,7 @@ class TVDB:
     # 兼容旧函数名
     get_all_people_types = get_people_types
 
-    def get_source_types(self, meta=None, if_modified_since=None) -> list:
+    def get_source_types(self, meta: str = None, if_modified_since: bool = None) -> list:
         """
         返回来源类型列表
         """
@@ -509,56 +514,56 @@ class TVDB:
         url = self.url.construct("updates", since=since, **kwargs)
         return self.request.make_request(url)
 
-    def get_all_tag_options(self, page=None, meta=None, if_modified_since=None) -> list:
+    def get_all_tag_options(self, page: int = None, meta: str = None, if_modified_since: bool = None) -> list:
         """
         返回标签选项列表 (可分页)
         """
         url = self.url.construct("tags/options", page=page, meta=meta)
         return self.request.make_request(url, if_modified_since)
 
-    def get_tag_option(self, id: int, meta=None, if_modified_since=None) -> dict:
+    def get_tag_option(self, id: int, meta: str = None, if_modified_since: bool = None) -> dict:
         """
         返回单个标签选项信息的字典
         """
         url = self.url.construct("tags/options", id, meta=meta)
         return self.request.make_request(url, if_modified_since)
 
-    def get_all_lists(self, page=None, meta=None) -> dict:
+    def get_all_lists(self, page: int = None, meta=None) -> dict:
         """
         返回所有公开的列表信息 (可分页)
         """
         url = self.url.construct("lists", page=page, meta=meta)
         return self.request.make_request(url)
 
-    def get_list(self, id: int, meta=None, if_modified_since=None) -> dict:
+    def get_list(self, id: int, meta: str = None, if_modified_since: bool = None) -> dict:
         """
         返回单个列表信息的字典
         """
         url = self.url.construct("lists", id, meta=meta)
         return self.request.make_request(url, if_modified_since)
 
-    def get_list_by_slug(self, slug: str, meta=None, if_modified_since=None) -> dict:
+    def get_list_by_slug(self, slug: str, meta: str = None, if_modified_since: bool = None) -> dict:
         """
         通过 slug (别名) 返回单个列表信息的字典
         """
         url = self.url.construct("lists/slug", slug, meta=meta)
         return self.request.make_request(url, if_modified_since)
 
-    def get_list_extended(self, id: int, meta=None, if_modified_since=None) -> dict:
+    def get_list_extended(self, id: int, meta: str = None, if_modified_since: bool = None) -> dict:
         """
         返回单个列表的扩展信息字典
         """
         url = self.url.construct("lists", id, "extended", meta=meta)
         return self.request.make_request(url, if_modified_since)
 
-    def get_list_translation(self, id: int, lang: str, meta=None, if_modified_since=None) -> dict:
+    def get_list_translation(self, id: int, lang: str, meta: str = None, if_modified_since: bool = None) -> dict:
         """
         返回列表的指定语言翻译信息字典
         """
         url = self.url.construct("lists", id, "translations", lang, meta=meta)
         return self.request.make_request(url, if_modified_since)
 
-    def get_inspiration_types(self, meta=None, if_modified_since=None) -> dict:
+    def get_inspiration_types(self, meta: str = None, if_modified_since: bool = None) -> dict:
         """
         返回灵感类型列表
         """

app/modules/transmission/__init__.py

@@ -5,9 +5,10 @@ from torrentool.torrent import Torrent
 from transmission_rpc import File
 
 from app import schemas
+from app.core.cache import FileCache
 from app.core.config import settings
-from app.core.metainfo import MetaInfo
 from app.core.event import eventmanager, Event
+from app.core.metainfo import MetaInfo
 from app.log import logger
 from app.modules import _ModuleBase, _DownloaderBase
 from app.modules.transmission.transmission import Transmission
@@ -93,12 +94,12 @@ class TransmissionModule(_ModuleBase, _DownloaderBase[Transmission]):
                 logger.info(f"Transmission下载器 {name} 连接断开，尝试重连 ...")
                 server.reconnect()
 
-    def download(self, content: Union[Path, str], download_dir: Path, cookie: str,
+    def download(self, content: Union[Path, str, bytes], download_dir: Path, cookie: str,
                  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]]:
         """
         根据种子文件，选择并添加下载任务
-        :param content:  种子文件地址或者磁力链接
+        :param content:  种子文件地址或者磁力链接或种子内容
         :param download_dir:  下载目录
         :param cookie:  cookie
         :param episodes:  需要下载的集数
@@ -108,24 +109,44 @@ class TransmissionModule(_ModuleBase, _DownloaderBase[Transmission]):
         :return: 下载器名称、种子Hash、种子文件布局、错误原因
         """
 
-        def __get_torrent_info() -> Tuple[str, int]:
+        def __get_torrent_info() -> Tuple[Optional[Torrent], Optional[bytes]]:
             """
             获取种子名称
             """
+            torrent_info, torrent_content = None, None
             try:
                 if isinstance(content, Path):
-                    torrentinfo = Torrent.from_file(content)
+                    if content.exists():
+                        torrent_content = content.read_bytes()
+                    else:
+                        # 读取缓存的种子文件
+                        torrent_content = FileCache().get(content.as_posix(), region="torrents")
                 else:
-                    torrentinfo = Torrent.from_string(content)
-                return torrentinfo.name, torrentinfo.total_size
+                    torrent_content = content
+
+                if torrent_content:
+                    # 检查是否为磁力链接
+                    if StringUtils.is_magnet_link(torrent_content):
+                        return None, torrent_content
+                    else:
+                        torrent_info = Torrent.from_string(torrent_content)
+
+                return torrent_info, torrent_content
             except Exception as e:
                 logger.error(f"获取种子名称失败：{e}")
-                return "", 0
+                return None, None
 
         if not content:
             return None, None, None, "下载内容为空"
-        if isinstance(content, Path) and not content.exists():
-            return None, None,  None, f"种子文件不存在：{content}"
+
+        # 读取种子的名称
+        torrent, content = __get_torrent_info()
+        # 检查是否为磁力链接
+        is_magnet = isinstance(content, str) and content.startswith("magnet:") or isinstance(content,
+                                                                                             bytes) and content.startswith(
+            b"magnet:")
+        if not torrent and not is_magnet:
+            return None, None, None, f"添加种子任务失败：无法读取种子文件"
 
         # 获取下载器
         server: Transmission = self.get_instance(downloader)
@@ -144,7 +165,7 @@ class TransmissionModule(_ModuleBase, _DownloaderBase[Transmission]):
             labels = None
         # 添加任务
         torrent = server.add_torrent(
-            content=content.read_bytes() if isinstance(content, Path) else content,
+            content=content,
             download_dir=str(download_dir),
             is_paused=is_paused,
             labels=labels,
@@ -154,10 +175,6 @@ class TransmissionModule(_ModuleBase, _DownloaderBase[Transmission]):
         torrent_layout = "Original"
 
         if not torrent:
-            # 读取种子的名称
-            torrent_name, torrent_size = __get_torrent_info()
-            if not torrent_name:
-                return None, None, None, f"添加种子任务失败：无法读取种子文件"
             # 查询所有下载器的种子
             torrents, error = server.get_torrents()
             if error:
@@ -166,7 +183,7 @@ class TransmissionModule(_ModuleBase, _DownloaderBase[Transmission]):
                 try:
                     for torrent in torrents:
                         # 名称与大小相等则认为是同一个种子
-                        if torrent.name == torrent_name and torrent.total_size == torrent_size:
+                        if torrent.name == torrent.name and torrent.total_size == torrent.total_size:
                             torrent_hash = torrent.hashString
                             logger.warn(f"下载器中已存在该种子任务：{torrent_hash} - {torrent.name}")
                             # 给种子打上标签
@@ -314,7 +331,7 @@ class TransmissionModule(_ModuleBase, _DownloaderBase[Transmission]):
                     del torrents
         else:
             return None
-        return ret_torrents # noqa
+        return ret_torrents  # noqa
 
     def transfer_completed(self, hashs: str, downloader: Optional[str] = None) -> None:
         """

app/modules/vocechat/__init__.py

@@ -71,7 +71,7 @@ class VoceChatModule(_ModuleBase, _MessageBase[VoceChat]):
         for name, client in self.get_instances().items():
             state = client.get_state()
             if not state:
-                return False, f"VoceChat {name} 未就续"
+                return False, f"VoceChat {name} 未就绪"
         return True, ""
 
     def init_setting(self) -> Tuple[str, Union[str, bool]]:

app/modules/wechat/__init__.py

@@ -75,7 +75,7 @@ class WechatModule(_ModuleBase, _MessageBase[WeChat]):
         for name, client in self.get_instances().items():
             state = client.get_state()
             if not state:
-                return False, f"企业微信 {name} 未就续"
+                return False, f"企业微信 {name} 未就绪"
         return True, ""
 
     def init_setting(self) -> Tuple[str, Union[str, bool]]:

app/monitor.py

@@ -1,7 +1,6 @@
 import json
 import platform
 import re
-import subprocess
 import threading
 import time
 import traceback
@@ -10,13 +9,13 @@ from threading import Lock
 from typing import Any, Optional, Dict, List
 
 from apscheduler.schedulers.background import BackgroundScheduler
-from cachetools import TTLCache
 from watchdog.events import FileSystemEventHandler, FileSystemMovedEvent, FileSystemEvent
 from watchdog.observers.polling import PollingObserver
 
 from app.chain import ChainBase
 from app.chain.storage import StorageChain
 from app.chain.transfer import TransferChain
+from app.core.cache import TTLCache, FileCache
 from app.core.config import settings
 from app.core.event import Event, eventmanager
 from app.helper.directory import DirectoryHelper
@@ -25,7 +24,8 @@ from app.log import logger
 from app.schemas import ConfigChangeEventData
 from app.schemas import FileItem
 from app.schemas.types import SystemConfigKey, EventType
-from app.utils.singleton import Singleton
+from app.utils.singleton import SingletonClass
+from app.utils.system import SystemUtils
 
 lock = Lock()
 snapshot_lock = Lock()
@@ -54,7 +54,7 @@ class FileMonitorHandler(FileSystemEventHandler):
                                     file_size=Path(event.dest_path).stat().st_size)
 
 
-class Monitor(metaclass=Singleton):
+class Monitor(metaclass=SingletonClass):
     """
     目录监控处理链，单例模式
     """
@@ -67,17 +67,14 @@ class Monitor(metaclass=Singleton):
         self._observers = []
         # 定时服务
         self._scheduler = None
-        # 存储快照缓存目录
-        self._snapshot_cache_dir = None
         # 存储过照间隔（分钟）
         self._snapshot_interval = 5
         # TTL缓存，10秒钟有效
-        self._cache = TTLCache(maxsize=1024, ttl=10)
+        self._cache = TTLCache(region="monitor", maxsize=1024, ttl=10)
+        # 快照文件缓存
+        self._snapshot_cache = FileCache(base=settings.CACHE_PATH / "snapshots")
         # 监控的文件扩展名
         self.all_exts = settings.RMT_MEDIAEXT
-        # 初始化快照缓存目录
-        self._snapshot_cache_dir = settings.TEMP_PATH / "snapshots"
-        self._snapshot_cache_dir.mkdir(exist_ok=True)
         # 启动目录监控和文件整理
         self.init()
 
@@ -98,14 +95,13 @@ class Monitor(metaclass=Singleton):
     def save_snapshot(self, storage: str, snapshot: Dict, file_count: int = 0,
                       last_snapshot_time: Optional[float] = None):
         """
-        保存快照到文件
+        保存快照到文件缓存
         :param storage: 存储名称
         :param snapshot: 快照数据
         :param last_snapshot_time: 上次快照时间戳
         :param file_count: 文件数量，用于调整监控间隔
         """
         try:
-            cache_file = self._snapshot_cache_dir / f"{storage}_snapshot.json"
             snapshot_time = max((item.get('modify_time', 0) for item in snapshot.values()), default=None)
             if snapshot_time is None:
                 snapshot_time = last_snapshot_time or time.time()
@@ -114,9 +110,11 @@ class Monitor(metaclass=Singleton):
                 'file_count': file_count,
                 'snapshot': snapshot
             }
-            with open(cache_file, 'w', encoding='utf-8') as f:
-                json.dump(snapshot_data, f, ensure_ascii=False, indent=2)  # noqa
-            logger.debug(f"快照已保存到 {cache_file}")
+            # 使用FileCache保存快照数据
+            cache_key = f"{storage}_snapshot"
+            snapshot_json = json.dumps(snapshot_data, ensure_ascii=False, indent=2)
+            self._snapshot_cache.set(cache_key, snapshot_json.encode('utf-8'), region="snapshots")
+            logger.debug(f"快照已保存到缓存: {storage}")
         except Exception as e:
             logger.error(f"保存快照失败: {e}")
 
@@ -127,9 +125,9 @@ class Monitor(metaclass=Singleton):
         :return: 是否成功
         """
         try:
-            cache_file = self._snapshot_cache_dir / f"{storage}_snapshot.json"
-            if cache_file.exists():
-                cache_file.unlink()
+            cache_key = f"{storage}_snapshot"
+            if self._snapshot_cache.exists(cache_key, region="snapshots"):
+                self._snapshot_cache.delete(cache_key, region="snapshots")
                 logger.info(f"快照已重置: {storage}")
                 return True
             logger.debug(f"快照文件不存在，无需重置: {storage}")
@@ -187,18 +185,18 @@ class Monitor(metaclass=Singleton):
 
     def load_snapshot(self, storage: str) -> Optional[Dict]:
         """
-        从文件加载快照
+        从文件缓存加载快照
         :param storage: 存储名称
         :return: 快照数据或None
         """
         try:
-            cache_file = self._snapshot_cache_dir / f"{storage}_snapshot.json"
-            if cache_file.exists():
-                with open(cache_file, 'r', encoding='utf-8') as f:
-                    data = json.load(f)
-                    logger.debug(f"成功加载快照: {cache_file}, 包含 {len(data.get('snapshot', {}))} 个文件")
-                    return data
-            logger.debug(f"快照文件不存在: {cache_file}")
+            cache_key = f"{storage}_snapshot"
+            snapshot_data = self._snapshot_cache.get(cache_key, region="snapshots")
+            if snapshot_data:
+                data = json.loads(snapshot_data.decode('utf-8'))
+                logger.debug(f"成功加载快照: {storage}, 包含 {len(data.get('snapshot', {}))} 个文件")
+                return data
+            logger.debug(f"快照文件不存在: {storage}")
             return None
         except Exception as e:
             logger.error(f"加载快照失败: {e}")
@@ -357,7 +355,8 @@ class Monitor(metaclass=Singleton):
 
         return tips
 
-    def should_use_polling(self, directory: Path, monitor_mode: str,
+    @staticmethod
+    def should_use_polling(directory: Path, monitor_mode: str,
                            file_count: int, limits: dict) -> tuple[bool, str]:
         """
         判断是否应该使用轮询模式
@@ -371,7 +370,7 @@ class Monitor(metaclass=Singleton):
             return True, "用户配置为兼容模式"
 
         # 检查网络文件系统
-        if self.is_network_filesystem(directory):
+        if SystemUtils.is_network_filesystem(directory):
             return True, "检测到网络文件系统，建议使用兼容模式"
 
         max_watches = limits.get('max_user_watches')
@@ -379,45 +378,6 @@ class Monitor(metaclass=Singleton):
             return True, f"目录文件数量({file_count})接近系统限制({max_watches})"
         return False, "使用快速模式"
 
-    @staticmethod
-    def is_network_filesystem(directory: Path) -> bool:
-        """
-        检测是否为网络文件系统
-        :param directory: 目录路径
-        :return: 是否为网络文件系统
-        """
-        try:
-            system = platform.system()
-            if system == 'Linux':
-                # 检查挂载信息
-                result = subprocess.run(['df', '-T', str(directory)],
-                                        capture_output=True, text=True, timeout=5)
-                if result.returncode == 0:
-                    output = result.stdout.lower()
-                    # 以下本地文件系统含有fuse关键字
-                    local_fs = [
-                        "fuse.shfs",  # Unraid
-                        "zfuse.zfsv",  # 极空间(zfuse.zfsv2、zfuse.zfsv3、...)
-                        # TBD
-                    ]
-                    if any(fs in output for fs in local_fs):
-                        return False
-                    network_fs = ['nfs', 'cifs', 'smbfs', 'fuse', 'sshfs', 'ftpfs']
-                    return any(fs in output for fs in network_fs)
-            elif system == 'Darwin':
-                # macOS 检查
-                result = subprocess.run(['df', '-T', str(directory)],
-                                        capture_output=True, text=True, timeout=5)
-                if result.returncode == 0:
-                    output = result.stdout.lower()
-                    return 'nfs' in output or 'smbfs' in output
-            elif system == 'Windows':
-                # Windows 检查网络驱动器
-                return str(directory).startswith('\\\\')
-        except Exception as e:
-            logger.debug(f"检测网络文件系统时出错: {e}")
-        return False
-
     def init(self):
         """
         启动监控
@@ -768,7 +728,7 @@ class Monitor(metaclass=Singleton):
 
     def stop(self):
         """
-        退出插件
+        退出监控
         """
         self._event.set()
         if self._observers:
@@ -791,4 +751,8 @@ class Monitor(metaclass=Singleton):
                 except Exception as e:
                     logger.error(f"停止定时服务出现了错误：{e}")
             self._scheduler = None
+        if self._cache:
+            self._cache.close()
+        if self._snapshot_cache:
+            self._snapshot_cache.close()
         self._event.clear()

app/monitoring.py

@@ -1,340 +0,0 @@
-import threading
-import time
-from collections import defaultdict, deque
-from dataclasses import dataclass
-from datetime import datetime, timedelta
-from typing import Dict, List, Any
-
-import psutil
-from fastapi import Request, Response
-from fastapi.responses import PlainTextResponse
-from prometheus_client import Counter, Histogram, Gauge, generate_latest, CONTENT_TYPE_LATEST
-from prometheus_fastapi_instrumentator import Instrumentator
-
-from app.core.config import settings
-from app.log import logger
-
-
-@dataclass
-class RequestMetrics:
-    """
-    请求指标数据类
-    """
-    path: str
-    method: str
-    status_code: int
-    response_time: float
-    timestamp: datetime
-    client_ip: str
-    user_agent: str
-
-
-@dataclass
-class PerformanceSnapshot:
-    """
-    性能快照数据类
-    """
-    timestamp: datetime
-    cpu_usage: float
-    memory_usage: float
-    active_requests: int
-    request_rate: float
-    avg_response_time: float
-    error_rate: float
-    slow_requests: int
-
-
-class FastAPIMonitor:
-    """
-    FastAPI性能监控器
-    """
-
-    def __init__(self, max_history: int = 1000, window_size: int = 60):
-        self.max_history = max_history
-        self.window_size = window_size  # 秒
-
-        # 请求历史记录
-        self.request_history: deque = deque(maxlen=max_history)
-
-        # 实时统计
-        self.active_requests = 0
-        self.total_requests = 0
-        self.error_requests = 0
-        self.slow_requests = 0  # 响应时间超过1秒的请求
-
-        # 时间窗口统计
-        self.window_requests: deque = deque(maxlen=window_size)
-        self.window_response_times: deque = deque(maxlen=window_size)
-
-        # 线程锁
-        self._lock = threading.Lock()
-
-        # 性能阈值
-        self.slow_request_threshold = 1.0  # 1秒
-        self.error_threshold = 0.05  # 5%
-        self.cpu_threshold = 80.0  # 80%
-        self.memory_threshold = 80.0  # 80%
-
-        # 告警状态
-        self.alerts: List[str] = []
-
-        logger.info("FastAPI性能监控器已初始化")
-
-    def record_request(self, request: Request, response: Response, response_time: float):
-        """
-        记录请求指标
-        """
-        with self._lock:
-            # 创建请求指标
-            metrics = RequestMetrics(
-                path=str(request.url.path),
-                method=request.method,
-                status_code=response.status_code,
-                response_time=response_time,
-                timestamp=datetime.now(),
-                client_ip=request.client.host if request.client else "unknown",
-                user_agent=request.headers.get("user-agent", "unknown")
-            )
-
-            # 添加到历史记录
-            self.request_history.append(metrics)
-
-            # 更新统计
-            self.total_requests += 1
-            if response.status_code >= 400:
-                self.error_requests += 1
-            if response_time > self.slow_request_threshold:
-                self.slow_requests += 1
-
-            # 添加到时间窗口
-            self.window_requests.append(metrics)
-            self.window_response_times.append(response_time)
-
-    def start_request(self):
-        """
-        开始处理请求
-        """
-        with self._lock:
-            self.active_requests += 1
-
-    def end_request(self):
-        """
-        结束处理请求
-        """
-        with self._lock:
-            self.active_requests = max(0, self.active_requests - 1)
-
-    def get_performance_snapshot(self) -> PerformanceSnapshot:
-        """
-        获取性能快照
-        """
-        with self._lock:
-            now = datetime.now()
-
-            # 计算请求率（每分钟）
-            recent_requests = [
-                req for req in self.window_requests
-                if now - req.timestamp < timedelta(seconds=self.window_size)
-            ]
-            request_rate = len(recent_requests) / (self.window_size / 60)
-
-            # 计算平均响应时间
-            recent_response_times = [
-                rt for rt in self.window_response_times
-                if len(self.window_response_times) > 0
-            ]
-            avg_response_time = sum(recent_response_times) / len(recent_response_times) if recent_response_times else 0
-
-            # 计算错误率
-            error_rate = self.error_requests / self.total_requests if self.total_requests > 0 else 0
-
-            # 系统资源使用率
-            cpu_usage = psutil.cpu_percent(interval=0.1)
-            memory_usage = psutil.virtual_memory().percent
-
-            return PerformanceSnapshot(
-                timestamp=now,
-                cpu_usage=cpu_usage,
-                memory_usage=memory_usage,
-                active_requests=self.active_requests,
-                request_rate=request_rate,
-                avg_response_time=avg_response_time,
-                error_rate=error_rate,
-                slow_requests=self.slow_requests
-            )
-
-    def get_top_endpoints(self, limit: int = 10) -> List[Dict[str, Any]]:
-        """
-        获取最活跃的端点
-        """
-        with self._lock:
-            endpoint_stats = defaultdict(lambda: {
-                'count': 0,
-                'total_time': 0,
-                'errors': 0,
-                'avg_time': 0
-            })
-
-            for req in self.request_history:
-                key = f"{req.method} {req.path}"
-                endpoint_stats[key]['count'] += 1
-                endpoint_stats[key]['total_time'] += req.response_time
-                if req.status_code >= 400:
-                    endpoint_stats[key]['errors'] += 1
-
-            # 计算平均时间
-            for stats in endpoint_stats.values():
-                if stats['count'] > 0:
-                    stats['avg_time'] = stats['total_time'] / stats['count']
-
-            # 按请求数量排序
-            sorted_endpoints = sorted(
-                [{'endpoint': k, **v} for k, v in endpoint_stats.items()],
-                key=lambda x: x['count'],
-                reverse=True
-            )
-
-            return sorted_endpoints[:limit]
-
-    def get_recent_errors(self, limit: int = 20) -> List[Dict[str, Any]]:
-        """
-        获取最近的错误请求
-        """
-        with self._lock:
-            errors = [
-                {
-                    'timestamp': req.timestamp.isoformat(),
-                    'method': req.method,
-                    'path': req.path,
-                    'status_code': req.status_code,
-                    'response_time': req.response_time,
-                    'client_ip': req.client_ip
-                }
-                for req in self.request_history
-                if req.status_code >= 400
-            ]
-            return errors[-limit:]
-
-    def check_alerts(self) -> List[str]:
-        """
-        检查告警条件
-        """
-        snapshot = self.get_performance_snapshot()
-        alerts = []
-
-        if snapshot.error_rate > self.error_threshold:
-            alerts.append(f"错误率过高: {snapshot.error_rate:.2%}")
-
-        if snapshot.cpu_usage > self.cpu_threshold:
-            alerts.append(f"CPU使用率过高: {snapshot.cpu_usage:.1f}%")
-
-        if snapshot.memory_usage > self.memory_threshold:
-            alerts.append(f"内存使用率过高: {snapshot.memory_usage:.1f}%")
-
-        if snapshot.avg_response_time > self.slow_request_threshold:
-            alerts.append(f"平均响应时间过长: {snapshot.avg_response_time:.2f}s")
-
-        if snapshot.request_rate > 1000:  # 每分钟1000请求
-            alerts.append(f"请求率过高: {snapshot.request_rate:.0f} req/min")
-
-        self.alerts = alerts
-        return alerts
-
-
-# 全局监控实例
-monitor = FastAPIMonitor()
-
-
-def setup_prometheus_metrics(app):
-    """
-    设置Prometheus指标
-    """
-
-    if not settings.PERFORMANCE_MONITOR_ENABLE:
-        return
-
-    # 创建Prometheus指标
-    request_counter = Counter(
-        "http_requests_total",
-        "Total number of HTTP requests",
-        ["method", "endpoint", "status"]
-    )
-
-    request_duration = Histogram(
-        "http_request_duration_seconds",
-        "HTTP request duration in seconds",
-        ["method", "endpoint"]
-    )
-
-    active_requests = Gauge(
-        "http_active_requests",
-        "Number of active HTTP requests"
-    )
-
-    # 自定义指标收集函数
-    def custom_metrics(request: Request, response: Response, response_time: float):
-        request_counter.labels(
-            method=request.method,
-            endpoint=request.url.path,
-            status=response.status_code
-        ).inc()
-
-        request_duration.labels(
-            method=request.method,
-            endpoint=request.url.path
-        ).observe(response_time)
-
-        active_requests.set(monitor.active_requests)
-
-    # 设置Prometheus监控
-    Instrumentator().instrument(app).expose(app, include_in_schema=False, should_gzip=True)
-
-    # 添加自定义指标
-    @app.middleware("http")
-    async def monitor_middleware(request: Request, call_next):
-        start_time = time.time()
-
-        # 开始请求
-        monitor.start_request()
-
-        try:
-            response = await call_next(request)
-            response_time = time.time() - start_time
-
-            # 记录请求指标
-            monitor.record_request(request, response, response_time)
-
-            # 更新Prometheus指标
-            custom_metrics(request, response, response_time)
-
-            return response
-        except Exception as e:
-            response_time = time.time() - start_time
-            logger.error(f"请求处理异常: {e}")
-
-            # 创建错误响应
-            response = Response(
-                content=str(e),
-                status_code=500,
-                media_type="text/plain"
-            )
-
-            # 记录错误请求
-            monitor.record_request(request, response, response_time)
-
-            return response
-        finally:
-            # 结束请求
-            monitor.end_request()
-
-    logger.info("Prometheus指标监控已设置")
-
-
-def get_metrics_response():
-    """
-    获取Prometheus指标响应
-    """
-    return PlainTextResponse(
-        generate_latest(),
-        media_type=CONTENT_TYPE_LATEST
-    )

app/scheduler.py

@@ -1,3 +1,6 @@
+import asyncio
+import inspect
+import multiprocessing
 import threading
 import traceback
 from datetime import datetime, timedelta
@@ -18,7 +21,7 @@ from app.chain.subscribe import SubscribeChain
 from app.chain.transfer import TransferChain
 from app.chain.workflow import WorkflowChain
 from app.core.config import settings
-from app.core.event import EventManager, eventmanager, Event
+from app.core.event import eventmanager, Event
 from app.core.plugin import PluginManager
 from app.db.systemconfig_oper import SystemConfigOper
 from app.helper.message import MessageHelper
@@ -27,7 +30,7 @@ from app.helper.wallpaper import WallpaperHelper
 from app.log import logger
 from app.schemas import Notification, NotificationType, Workflow, ConfigChangeEventData
 from app.schemas.types import EventType, SystemConfigKey
-from app.utils.singleton import Singleton
+from app.utils.singleton import SingletonClass
 from app.utils.timer import TimerUtils
 
 lock = threading.Lock()
@@ -37,7 +40,7 @@ class SchedulerChain(ChainBase):
     pass
 
 
-class Scheduler(metaclass=Singleton):
+class Scheduler(metaclass=SingletonClass):
     """
     定时任务管理
     """
@@ -55,6 +58,8 @@ class Scheduler(metaclass=Singleton):
         self._auth_count = 0
         # 用户认证失败消息发送
         self._auth_message = False
+        # 当前事件循环
+        self.loop = asyncio.get_event_loop()
         self.init()
 
     @eventmanager.register(EventType.ConfigChanged)
@@ -67,7 +72,8 @@ class Scheduler(metaclass=Singleton):
             return
         event_data: ConfigChangeEventData = event.event_data
         if event_data.key not in ['DEV', 'COOKIECLOUD_INTERVAL', 'MEDIASERVER_SYNC_INTERVAL', 'SUBSCRIBE_SEARCH',
-                                  'SUBSCRIBE_MODE', 'SUBSCRIBE_RSS_INTERVAL', 'SITEDATA_REFRESH_INTERVAL']:
+                                  'SUBSCRIBE_SEARCH_INTERVAL', 'SUBSCRIBE_MODE', 'SUBSCRIBE_RSS_INTERVAL',
+                                  'SITEDATA_REFRESH_INTERVAL']:
             return
         logger.info(f"配置项 {event_data.key} 变更，重新初始化定时服务...")
         self.init()
@@ -90,17 +96,17 @@ class Scheduler(metaclass=Singleton):
                 "cookiecloud": {
                     "name": "同步CookieCloud站点",
                     "func": SiteChain().sync_cookies,
-                    "running": False,
+                    "running": False
                 },
                 "mediaserver_sync": {
                     "name": "同步媒体服务器",
                     "func": MediaServerChain().sync,
-                    "running": False,
+                    "running": False
                 },
                 "subscribe_tmdb": {
                     "name": "订阅元数据更新",
                     "func": SubscribeChain().check,
-                    "running": False,
+                    "running": False
                 },
                 "subscribe_search": {
                     "name": "订阅搜索补全",
@@ -121,47 +127,60 @@ class Scheduler(metaclass=Singleton):
                 "subscribe_refresh": {
                     "name": "订阅刷新",
                     "func": SubscribeChain().refresh,
-                    "running": False,
+                    "running": False
                 },
                 "subscribe_follow": {
                     "name": "关注的订阅分享",
                     "func": SubscribeChain().follow,
-                    "running": False,
+                    "running": False
                 },
                 "transfer": {
                     "name": "下载文件整理",
                     "func": TransferChain().process,
-                    "running": False,
+                    "running": False
                 },
                 "clear_cache": {
                     "name": "缓存清理",
                     "func": self.clear_cache,
-                    "running": False,
+                    "running": False
                 },
                 "user_auth": {
                     "name": "用户认证检查",
                     "func": self.user_auth,
-                    "running": False,
+                    "running": False
                 },
                 "scheduler_job": {
                     "name": "公共定时服务",
                     "func": SchedulerChain().scheduler_job,
-                    "running": False,
+                    "running": False
                 },
                 "random_wallpager": {
                     "name": "壁纸缓存",
                     "func": WallpaperHelper().get_wallpapers,
-                    "running": False,
+                    "running": False
                 },
                 "sitedata_refresh": {
                     "name": "站点数据刷新",
                     "func": SiteChain().refresh_userdatas,
-                    "running": False,
+                    "running": False
                 },
                 "recommend_refresh": {
                     "name": "推荐缓存",
                     "func": RecommendChain().refresh_recommend,
+                    "running": False
+                },
+                "plugin_market_refresh": {
+                    "name": "插件市场缓存",
+                    "func": PluginManager().async_get_online_plugins,
                     "running": False,
+                    "kwargs": {
+                        "force": True
+                    }
+                },
+                "subscribe_calendar_cache": {
+                    "name": "订阅日历缓存",
+                    "func": SubscribeChain().cache_calendar,
+                    "running": False
                 }
             }
 
@@ -180,7 +199,7 @@ class Scheduler(metaclass=Singleton):
                     id="cookiecloud",
                     name="同步CookieCloud站点",
                     minutes=int(settings.COOKIECLOUD_INTERVAL),
-                    next_run_time=datetime.now(pytz.timezone(settings.TZ)) + timedelta(minutes=1),
+                    next_run_time=datetime.now(pytz.timezone(settings.TZ)) + timedelta(minutes=5),
                     kwargs={
                         'job_id': 'cookiecloud'
                     }
@@ -195,7 +214,7 @@ class Scheduler(metaclass=Singleton):
                     id="mediaserver_sync",
                     name="同步媒体服务器",
                     hours=int(settings.MEDIASERVER_SYNC_INTERVAL),
-                    next_run_time=datetime.now(pytz.timezone(settings.TZ)) + timedelta(minutes=5),
+                    next_run_time=datetime.now(pytz.timezone(settings.TZ)) + timedelta(minutes=10),
                     kwargs={
                         'job_id': 'mediaserver_sync'
                     }
@@ -232,7 +251,7 @@ class Scheduler(metaclass=Singleton):
                     "interval",
                     id="subscribe_search",
                     name="订阅搜索补全",
-                    hours=24,
+                    hours=settings.SUBSCRIBE_SEARCH_INTERVAL,
                     kwargs={
                         'job_id': 'subscribe_search'
                     }
@@ -301,7 +320,7 @@ class Scheduler(metaclass=Singleton):
                 id="random_wallpager",
                 name="壁纸缓存",
                 minutes=30,
-                next_run_time=datetime.now(pytz.timezone(settings.TZ)) + timedelta(seconds=3),
+                next_run_time=datetime.now(pytz.timezone(settings.TZ)) + timedelta(seconds=1),
                 kwargs={
                     'job_id': 'random_wallpager'
                 }
@@ -363,21 +382,43 @@ class Scheduler(metaclass=Singleton):
                 id="recommend_refresh",
                 name="推荐缓存",
                 hours=24,
-                next_run_time=datetime.now(pytz.timezone(settings.TZ)) + timedelta(seconds=3),
+                next_run_time=datetime.now(pytz.timezone(settings.TZ)) + timedelta(seconds=5),
                 kwargs={
                     'job_id': 'recommend_refresh'
                 }
             )
 
+            # 插件市场缓存
+            self._scheduler.add_job(
+                self.start,
+                "interval",
+                id="plugin_market_refresh",
+                name="插件市场缓存",
+                minutes=30,
+                kwargs={
+                    'job_id': 'plugin_market_refresh'
+                }
+            )
+
+            # 订阅日历缓存
+            self._scheduler.add_job(
+                self.start,
+                "interval",
+                id="subscribe_calendar_cache",
+                name="订阅日历缓存",
+                hours=6,
+                next_run_time=datetime.now(pytz.timezone(settings.TZ)) + timedelta(minutes=2),
+                kwargs={
+                    'job_id': 'subscribe_calendar_cache'
+                }
+            )
+
             # 初始化工作流服务
             self.init_workflow_jobs()
 
             # 初始化插件服务
             self.init_plugin_jobs()
 
-            # 打印服务
-            self._scheduler.print_jobs()
-
             # 启动定时服务
             self._scheduler.start()
 
@@ -390,7 +431,7 @@ class Scheduler(metaclass=Singleton):
             if not job:
                 return None
             if job.get("running"):
-                logger.warning(f"定时任务 {job_id} - {job.get("name")} 正在运行 ...")
+                logger.warning(f"定时任务 {job_id} - {job.get('name')} 正在运行 ...")
                 return None
             self._jobs[job_id]["running"] = True
         return job
@@ -409,6 +450,13 @@ class Scheduler(metaclass=Singleton):
         """
         启动定时服务
         """
+
+        def __start_coro(coro):
+            """
+            启动协程
+            """
+            return asyncio.run_coroutine_threadsafe(coro, self.loop)
+
         # 获取定时任务
         job = self.__prepare_job(job_id)
         if not job:
@@ -417,7 +465,22 @@ class Scheduler(metaclass=Singleton):
         try:
             if not kwargs:
                 kwargs = job.get("kwargs") or {}
-            job["func"](*args, **kwargs)
+            func = job.get("func")
+            if not func:
+                return
+            # 是否多进程运行
+            run_in_process = job.get("run_in_process", False)
+            if inspect.iscoroutinefunction(func):
+                # 协程函数
+                __start_coro(func(*args, **kwargs))
+            elif run_in_process:
+                # 多进程运行
+                p = multiprocessing.Process(target=func, args=args, kwargs=kwargs)
+                p.start()
+                p.join()
+            else:
+                # 普通函数
+                job["func"](*args, **kwargs)
         except Exception as e:
             logger.error(f"定时任务 {job.get('name')} 执行失败：{str(e)} - {traceback.format_exc()}")
             MessageHelper().put(title=f"{job.get('name')} 执行失败",
@@ -519,7 +582,7 @@ class Scheduler(metaclass=Singleton):
                             except JobLookupError:
                                 pass
                     if job_removed:
-                        logger.info(f"移除插件服务({plugin_name})：{service.get('name')}")
+                        logger.info(f"移除插件服务({plugin_name})：{service.get('name')}")  # noqa
                 except Exception as e:
                     logger.error(f"移除插件服务失败：{str(e)} - {job_id}: {service}")
                     SchedulerChain().messagehelper.put(title=f"插件 {plugin_name} 服务移除失败",