fix #4902

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

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

app/chain/__init__.py

@@ -105,7 +105,7 @@ class ChainBase(metaclass=ABCMeta):
         """
         异步删除缓存，同时删除Redis和本地缓存
         """
-        pass
+        await self.async_filecache.delete(filename)
 
     @staticmethod
     def __is_valid_empty(ret):

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):
         """
@@ -349,51 +364,60 @@ class MediaChain(ChainBase):
                                      overwrite=overwrite)
             else:
                 if file_list:
-                    # 1. 收集fileitem和file_list中每个文件之间所有子目录
-                    all_dirs = set()
-                    root_path = Path(fileitem.path)
+                    # 如果是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)
+                        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
+                        # 收集所有目录（包括所有层级）
+                        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)} 个目录")
+                        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}")
+                        # 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}")
+                        # 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} ...")
@@ -417,20 +441,6 @@ class MediaChain(ChainBase):
 
         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):
             """
             列出下级文件
@@ -521,7 +531,7 @@ class MediaChain(ChainBase):
                 # 电影目录
                 if recursive:
                     # 处理文件
-                    if is_bluray_folder(fileitem):
+                    if self.is_bluray_folder(fileitem):
                         # 原盘目录
                         if scraping_switchs.get('movie_nfo', True):
                             nfo_path = filepath / (filepath.name + ".nfo")
@@ -541,6 +551,9 @@ class MediaChain(ChainBase):
                         # 处理目录内的文件
                         files = __list_files(_fileitem=fileitem)
                         for file in files:
+                            if file.type == "dir":
+                                # 电影不处理子目录
+                                continue
                             self.scrape_metadata(fileitem=file,
                                                  mediainfo=mediainfo,
                                                  init_folder=False,
@@ -640,6 +653,9 @@ class MediaChain(ChainBase):
                 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,

app/chain/transfer.py

@@ -591,7 +591,7 @@ class TransferChain(ChainBase, metaclass=Singleton):
                                     text=__process_msg,
                                     data={
                                         "current": Path(fileitem.path).as_posix(),
-                                        "finished":finished_files
+                                        "finished": finished_files
                                     })
                     # 整理
                     state, err_msg = self.__handle_transfer(task=task, callback=item.callback)
@@ -1471,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

@@ -114,7 +114,7 @@ class ConfigModel(BaseModel):
     # 数据库连接池获取连接的超时时间（秒）
     DB_POOL_TIMEOUT: int = 30
     # SQLite 连接池大小
-    DB_SQLITE_POOL_SIZE: int = 30
+    DB_SQLITE_POOL_SIZE: int = 10
     # SQLite 连接池溢出数量
     DB_SQLITE_MAX_OVERFLOW: int = 50
     # PostgreSQL 主机地址
@@ -128,7 +128,7 @@ class ConfigModel(BaseModel):
     # PostgreSQL 密码
     DB_POSTGRESQL_PASSWORD: str = "moviepilot"
     # PostgreSQL 连接池大小
-    DB_POSTGRESQL_POOL_SIZE: int = 30
+    DB_POSTGRESQL_POOL_SIZE: int = 10
     # PostgreSQL 连接池溢出数量
     DB_POSTGRESQL_MAX_OVERFLOW: int = 50
 
@@ -249,6 +249,8 @@ class ConfigModel(BaseModel):
     SUBSCRIBE_STATISTIC_SHARE: bool = True
     # 订阅搜索开关
     SUBSCRIBE_SEARCH: bool = False
+    # 订阅搜索时间间隔（小时）
+    SUBSCRIBE_SEARCH_INTERVAL: int = 24
     # 检查本地媒体库是否存在资源开关
     LOCAL_EXISTS_SEARCH: bool = False
 
@@ -358,8 +360,6 @@ class ConfigModel(BaseModel):
     # ==================== 性能配置 ====================
     # 大内存模式
     BIG_MEMORY_MODE: bool = False
-    # FastApi性能监控
-    PERFORMANCE_MONITOR_ENABLE: bool = False
     # 是否启用编码探测的性能模式
     ENCODING_DETECTION_PERFORMANCE_MODE: bool = True
     # 编码探测的最低置信度阈值
@@ -663,7 +663,7 @@ 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
             )
@@ -674,7 +674,7 @@ 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
         )

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

@@ -21,7 +21,7 @@ from app.core.config import settings
 from app.core.event import eventmanager, Event
 from app.db.plugindata_oper import PluginDataOper
 from app.db.systemconfig_oper import SystemConfigOper
-from app.helper.plugin import PluginHelper, PluginMemoryMonitor
+from app.helper.plugin import PluginHelper
 from app.helper.sites import SitesHelper  # noqa
 from app.log import logger
 from app.schemas.types import EventType, SystemConfigKey
@@ -98,8 +98,6 @@ class PluginManager(metaclass=Singleton):
         self._config_key: str = "plugin.%s"
         # 监听器
         self._observer: Observer = None
-        # 内存监控器
-        self._memory_monitor = PluginMemoryMonitor()
         # 开发者模式监测插件修改
         if settings.DEV or settings.PLUGIN_AUTO_RELOAD:
             self.__start_monitor()
@@ -865,28 +863,6 @@ class PluginManager(metaclass=Singleton):
         """
         return list(self._running_plugins.keys())
 
-    def get_plugin_memory_stats(self, pid: Optional[str] = None) -> List[Dict[str, Any]]:
-        """
-        获取插件内存统计信息
-        :param pid: 插件ID，为空则获取所有插件
-        :return: 内存统计信息列表
-        """
-        if pid:
-            plugin_instance = self._running_plugins.get(pid)
-            if plugin_instance:
-                return [self._memory_monitor.get_plugin_memory_usage(pid, plugin_instance)]
-            else:
-                return []
-        else:
-            return self._memory_monitor.get_all_plugins_memory_usage(self._running_plugins)
-
-    def clear_plugin_memory_cache(self, pid: Optional[str] = None):
-        """
-        清除插件内存统计缓存
-        :param pid: 插件ID，为空则清除所有缓存
-        """
-        self._memory_monitor.clear_cache(pid)
-
     def get_online_plugins(self, force: bool = False) -> List[schemas.Plugin]:
         """
         获取所有在线插件信息

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/plugin.py

@@ -4,11 +4,10 @@ import json
 import shutil
 import site
 import sys
-import time
 import traceback
 import zipfile
 from pathlib import Path
-from typing import Dict, List, Optional, Tuple, Set, Callable, Awaitable, Any
+from typing import Dict, List, Optional, Tuple, Set, Callable, Awaitable
 
 import aiofiles
 import aioshutil
@@ -25,7 +24,6 @@ from app.db.systemconfig_oper import SystemConfigOper
 from app.log import logger
 from app.schemas.types import SystemConfigKey
 from app.utils.http import RequestUtils, AsyncRequestUtils
-from app.utils.memory import MemoryCalculator
 from app.utils.singleton import WeakSingleton
 from app.utils.system import SystemUtils
 from app.utils.url import UrlUtils
@@ -459,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 = []
 
         # 添加策略到列表中
@@ -610,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 '连接失败'}"
 
@@ -1525,15 +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}"
 
+        # 使用资产的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=settings.REPO_GITHUB_HEADERS(repo=user_repo))
+                                                       headers=headers,
+                                                       is_api=True)
         if res is None or res.status_code != 200:
             return False, f"下载资产失败：{res.status_code if res else '连接失败'}"
 
@@ -1571,87 +1591,3 @@ class PluginHelper(metaclass=WeakSingleton):
         except Exception as e:
             logger.error(f"解压 Release 压缩包失败：{e}")
             return False, f"解压 Release 压缩包失败：{e}"
-
-
-class PluginMemoryMonitor:
-    """
-    插件内存监控器
-    """
-
-    def __init__(self):
-        self._calculator = MemoryCalculator()
-        self._cache = {}
-        self._cache_ttl = 300  # 缓存5分钟
-
-    def get_plugin_memory_usage(self, plugin_id: str, plugin_instance: Any) -> Dict[str, Any]:
-        """
-        获取插件内存使用情况
-        :param plugin_id: 插件ID
-        :param plugin_instance: 插件实例
-        :return: 内存使用信息
-        """
-        # 检查缓存
-        if self._is_cache_valid(plugin_id):
-            return self._cache[plugin_id]
-
-        # 计算内存使用
-        memory_info = self._calculator.calculate_object_memory(plugin_instance)
-
-        # 添加插件信息
-        result = {
-            'plugin_id': plugin_id,
-            'plugin_name': getattr(plugin_instance, 'plugin_name', 'Unknown'),
-            'plugin_version': getattr(plugin_instance, 'plugin_version', 'Unknown'),
-            'timestamp': time.time(),
-            **memory_info
-        }
-
-        # 更新缓存
-        self._cache[plugin_id] = result
-        return result
-
-    def get_all_plugins_memory_usage(self, plugins: Dict[str, Any]) -> List[Dict[str, Any]]:
-        """
-        获取所有插件的内存使用情况
-        :param plugins: 插件实例字典
-        :return: 内存使用信息列表
-        """
-        results = []
-        for plugin_id, plugin_instance in plugins.items():
-            if plugin_instance:
-                try:
-                    memory_info = self.get_plugin_memory_usage(plugin_id, plugin_instance)
-                    results.append(memory_info)
-                except Exception as e:
-                    logger.error(f"获取插件 {plugin_id} 内存使用情况失败：{str(e)}")
-                    results.append({
-                        'plugin_id': plugin_id,
-                        'plugin_name': getattr(plugin_instance, 'plugin_name', 'Unknown'),
-                        'error': str(e),
-                        'total_memory_bytes': 0,
-                        'total_memory_mb': 0,
-                        'object_count': 0,
-                        'calculation_time_ms': 0
-                    })
-
-        # 按内存使用量排序
-        results.sort(key=lambda x: x.get('total_memory_bytes', 0), reverse=True)
-        return results
-
-    def _is_cache_valid(self, plugin_id: str) -> bool:
-        """
-        检查缓存是否有效
-        """
-        if plugin_id not in self._cache:
-            return False
-        return time.time() - self._cache[plugin_id]['timestamp'] < self._cache_ttl
-
-    def clear_cache(self, plugin_id: Optional[str] = None):
-        """
-        清除缓存
-        :param plugin_id: 插件ID，为空则清除所有缓存
-        """
-        if plugin_id:
-            self._cache.pop(plugin_id, None)
-        else:
-            self._cache.clear()

app/helper/redis.py

@@ -17,6 +17,11 @@ 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:
     """
@@ -96,9 +101,9 @@ class RedisHelper(metaclass=Singleton):
                 self.client = redis.Redis.from_url(
                     self.redis_url,
                     decode_responses=False,
-                    socket_timeout=30,
-                    socket_connect_timeout=5,
-                    health_check_interval=60,
+                    socket_timeout=_socket_timeout,
+                    socket_connect_timeout=_socket_connect_timeout,
+                    health_check_interval=_health_check_interval,
                 )
                 # 测试连接，确保Redis可用
                 self.client.ping()
@@ -317,10 +322,6 @@ class AsyncRedisHelper(metaclass=Singleton):
     - 所有操作都是异步的
     """
 
-    # 类型缓存集合，针对非容器简单类型
-    _complex_serializable_types = set()
-    _simple_serializable_types = set()
-
     def __init__(self):
         """
         初始化异步Redis助手实例
@@ -337,9 +338,9 @@ class AsyncRedisHelper(metaclass=Singleton):
                 self.client = Redis.from_url(
                     self.redis_url,
                     decode_responses=False,
-                    socket_timeout=30,
-                    socket_connect_timeout=5,
-                    health_check_interval=60,
+                    socket_timeout=_socket_timeout,
+                    socket_connect_timeout=_socket_connect_timeout,
+                    health_check_interval=_health_check_interval,
                 )
                 # 测试连接，确保Redis可用
                 await self.client.ping()

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/system.py

@@ -1,3 +1,7 @@
+import os
+import signal
+import threading
+import time
 from pathlib import Path
 from typing import Tuple
 
@@ -69,6 +73,34 @@ class SystemHelper:
             logger.debug(f"获取容器ID失败: {str(e)}")
         return container_id.strip() if container_id else None
 
+    @staticmethod
+    def _check_restart_policy() -> bool:
+        """
+        检查当前容器是否配置了自动重启策略
+        """
+        try:
+            # 获取当前容器ID
+            container_id = SystemHelper._get_container_id()
+            if not container_id:
+                return False
+
+            # 创建 Docker 客户端
+            client = docker.DockerClient(base_url=settings.DOCKER_CLIENT_API)
+            # 获取容器信息
+            container = client.containers.get(container_id)
+            restart_policy = container.attrs.get('HostConfig', {}).get('RestartPolicy', {})
+            policy_name = restart_policy.get('Name', 'no')
+            # 检查是否有有效的重启策略
+            auto_restart_policies = ['always', 'unless-stopped', 'on-failure']
+            has_restart_policy = policy_name in auto_restart_policies
+
+            logger.info(f"容器重启策略: {policy_name}, 支持自动重启: {has_restart_policy}")
+            return has_restart_policy
+
+        except Exception as e:
+            logger.warning(f"检查重启策略失败: {str(e)}")
+            return False
+
     @staticmethod
     def restart() -> Tuple[bool, str]:
         """
@@ -77,8 +109,45 @@ class SystemHelper:
         if not SystemUtils.is_docker():
             return False, "非Docker环境，无法重启！"
 
-        logger.info("正在重启容器...")
-        return SystemHelper._docker_api_restart()
+        try:
+            # 检查容器是否配置了自动重启策略
+            has_restart_policy = SystemHelper._check_restart_policy()
+            if has_restart_policy:
+                # 有重启策略，使用优雅退出方式
+                logger.info("检测到容器配置了自动重启策略，使用优雅重启方式...")
+                # 启动优雅退出超时监控
+                SystemHelper._start_graceful_shutdown_monitor()
+                # 发送SIGTERM信号给当前进程，触发优雅停止
+                os.kill(os.getpid(), signal.SIGTERM)
+                return True, ""
+            else:
+                # 没有重启策略，使用Docker API强制重启
+                logger.info("容器未配置自动重启策略，使用Docker API重启...")
+                return SystemHelper._docker_api_restart()
+        except Exception as err:
+            logger.error(f"重启失败: {str(err)}")
+            # 降级为Docker API重启
+            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/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/filemanager/storages/alipan.py

@@ -251,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

app/modules/filemanager/storages/alist.py

@@ -615,6 +615,9 @@ class Alist(StorageBase, metaclass=WeakSingleton):
                     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} 上传已取消！")

app/modules/filemanager/storages/local.py

@@ -246,6 +246,17 @@ class LocalStorage(StorageBase):
             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,
@@ -258,8 +269,15 @@ class LocalStorage(StorageBase):
         try:
             src = Path(fileitem.path)
             dest = path / new_name
-            if self._copy_with_progress(src, dest):
-                return True
+            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
@@ -276,10 +294,20 @@ class LocalStorage(StorageBase):
         try:
             src = Path(fileitem.path)
             dest = path / new_name
-            if self._copy_with_progress(src, dest):
-                # 复制成功删除源文件
-                src.unlink()
+            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

app/modules/filemanager/storages/u115.py

@@ -46,6 +46,9 @@ class U115Pan(StorageBase, metaclass=WeakSingleton):
     # 文件块大小，默认10MB
     chunk_size = 10 * 1024 * 1024
 
+    # 流控重试间隔时间
+    retry_delay = 70
+
     def __init__(self):
         super().__init__()
         self._auth_state = {}
@@ -195,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,
@@ -205,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
@@ -228,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)
@@ -254,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
@@ -430,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}")
@@ -782,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:
@@ -812,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/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/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
@@ -134,23 +135,41 @@ class CategoryHelper(metaclass=WeakSingleton):
                     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/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/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 app.core.cache import TTLCache, FileCache
 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
@@ -26,6 +25,7 @@ from app.schemas import ConfigChangeEventData
 from app.schemas import FileItem
 from app.schemas.types import SystemConfigKey, EventType
 from app.utils.singleton import SingletonClass
+from app.utils.system import SystemUtils
 
 lock = Lock()
 snapshot_lock = Lock()
@@ -355,7 +355,8 @@ class Monitor(metaclass=SingletonClass):
 
         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]:
         """
         判断是否应该使用轮询模式
@@ -369,7 +370,7 @@ class Monitor(metaclass=SingletonClass):
             return True, "用户配置为兼容模式"
 
         # 检查网络文件系统
-        if self.is_network_filesystem(directory):
+        if SystemUtils.is_network_filesystem(directory):
             return True, "检测到网络文件系统，建议使用兼容模式"
 
         max_watches = limits.get('max_user_watches')
@@ -377,45 +378,6 @@ class Monitor(metaclass=SingletonClass):
             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):
         """
         启动监控

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.debug("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.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,5 +1,6 @@
 import asyncio
 import inspect
+import multiprocessing
 import threading
 import traceback
 from datetime import datetime, timedelta
@@ -23,8 +24,8 @@ from app.core.config import settings
 from app.core.event import eventmanager, Event
 from app.core.plugin import PluginManager
 from app.db.systemconfig_oper import SystemConfigOper
-from app.helper.sites import SitesHelper  # noqa
 from app.helper.message import MessageHelper
+from app.helper.sites import SitesHelper  # noqa
 from app.helper.wallpaper import WallpaperHelper
 from app.log import logger
 from app.schemas import Notification, NotificationType, Workflow, ConfigChangeEventData
@@ -71,7 +72,8 @@ class Scheduler(metaclass=SingletonClass):
             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()
@@ -94,17 +96,17 @@ class Scheduler(metaclass=SingletonClass):
                 "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": "订阅搜索补全",
@@ -125,47 +127,47 @@ class Scheduler(metaclass=SingletonClass):
                 "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,
+                    "running": False
                 },
                 "plugin_market_refresh": {
                     "name": "插件市场缓存",
@@ -249,7 +251,7 @@ class Scheduler(metaclass=SingletonClass):
                     "interval",
                     id="subscribe_search",
                     name="订阅搜索补全",
-                    hours=24,
+                    hours=settings.SUBSCRIBE_SEARCH_INTERVAL,
                     kwargs={
                         'job_id': 'subscribe_search'
                     }
@@ -417,9 +419,6 @@ class Scheduler(metaclass=SingletonClass):
             # 初始化插件服务
             self.init_plugin_jobs()
 
-            # 打印服务
-            self._scheduler.print_jobs()
-
             # 启动定时服务
             self._scheduler.start()
 
@@ -469,9 +468,18 @@ class Scheduler(metaclass=SingletonClass):
             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()}")

app/utils/memory.py

@@ -1,178 +0,0 @@
-import sys
-import time
-from collections import deque
-from typing import Any, Dict, Set
-
-from app.log import logger
-
-
-class MemoryCalculator:
-    """
-    内存计算器，用于递归计算对象的内存占用
-    """
-
-    def __init__(self):
-        # 缓存已计算的对象ID，避免重复计算
-        self._calculated_ids: Set[int] = set()
-        # 最大递归深度，防止无限递归
-        self._max_depth = 10
-        # 最大对象数量，防止计算过多对象
-        self._max_objects = 10000
-
-    def calculate_object_memory(self, obj: Any, max_depth: int = None, max_objects: int = None) -> Dict[str, Any]:
-        """
-        计算对象的内存占用
-        :param obj: 要计算的对象
-        :param max_depth: 最大递归深度
-        :param max_objects: 最大对象数量
-        :return: 内存统计信息
-        """
-        if max_depth is None:
-            max_depth = self._max_depth
-        if max_objects is None:
-            max_objects = self._max_objects
-
-        # 重置缓存
-        self._calculated_ids.clear()
-
-        start_time = time.time()
-        object_details = []
-
-        try:
-            # 递归计算内存
-            memory_info = self._calculate_recursive(obj, depth=0, max_depth=max_depth,
-                                                    max_objects=max_objects, object_count=0)
-            total_memory = memory_info['total_memory']
-            object_count = memory_info['object_count']
-            object_details = memory_info['object_details']
-
-        except Exception as e:
-            logger.error(f"计算对象内存时出错：{str(e)}")
-            total_memory = 0
-            object_count = 0
-
-        calculation_time = time.time() - start_time
-
-        return {
-            'total_memory_bytes': total_memory,
-            'total_memory_mb': round(total_memory / (1024 * 1024), 2),
-            'object_count': object_count,
-            'calculation_time_ms': round(calculation_time * 1000, 2),
-            'object_details': object_details[:10]  # 只返回前10个最大的对象
-        }
-
-    def _calculate_recursive(self, obj: Any, depth: int, max_depth: int,
-                             max_objects: int, object_count: int) -> Dict[str, Any]:
-        """
-        递归计算对象内存
-        """
-        if depth > max_depth or object_count > max_objects:
-            return {
-                'total_memory': 0,
-                'object_count': object_count,
-                'object_details': []
-            }
-
-        total_memory = 0
-        object_details = []
-
-        # 获取对象ID，避免重复计算
-        obj_id = id(obj)
-        if obj_id in self._calculated_ids:
-            return {
-                'total_memory': 0,
-                'object_count': object_count,
-                'object_details': []
-            }
-
-        self._calculated_ids.add(obj_id)
-        object_count += 1
-
-        try:
-            # 计算对象本身的内存
-            obj_memory = sys.getsizeof(obj)
-            total_memory += obj_memory
-
-            # 记录大对象
-            if obj_memory > 1024:  # 大于1KB的对象
-                object_details.append({
-                    'type': type(obj).__name__,
-                    'memory_bytes': obj_memory,
-                    'memory_mb': round(obj_memory / (1024 * 1024), 2),
-                    'depth': depth
-                })
-
-            # 递归计算容器对象的内容
-            if depth < max_depth:
-                container_memory = self._calculate_container_memory(
-                    obj, depth + 1, max_depth, max_objects, object_count
-                )
-                total_memory += container_memory['total_memory']
-                object_count = container_memory['object_count']
-                object_details.extend(container_memory['object_details'])
-
-        except Exception as e:
-            logger.debug(f"计算对象 {type(obj).__name__} 内存时出错：{str(e)}")
-
-        return {
-            'total_memory': total_memory,
-            'object_count': object_count,
-            'object_details': object_details
-        }
-
-    def _calculate_container_memory(self, obj: Any, depth: int, max_depth: int,
-                                    max_objects: int, object_count: int) -> Dict[str, Any]:
-        """
-        计算容器对象的内存
-        """
-        total_memory = 0
-        object_details = []
-
-        try:
-            # 处理不同类型的容器
-            if isinstance(obj, (list, tuple, deque)):
-                for item in obj:
-                    if object_count > max_objects:
-                        break
-                    item_memory = self._calculate_recursive(item, depth, max_depth, max_objects, object_count)
-                    total_memory += item_memory['total_memory']
-                    object_count = item_memory['object_count']
-                    object_details.extend(item_memory['object_details'])
-
-            elif isinstance(obj, dict):
-                for key, value in obj.items():
-                    if object_count > max_objects:
-                        break
-                    # 计算key的内存
-                    key_memory = self._calculate_recursive(key, depth, max_depth, max_objects, object_count)
-                    total_memory += key_memory['total_memory']
-                    object_count = key_memory['object_count']
-                    object_details.extend(key_memory['object_details'])
-
-                    # 计算value的内存
-                    value_memory = self._calculate_recursive(value, depth, max_depth, max_objects, object_count)
-                    total_memory += value_memory['total_memory']
-                    object_count = value_memory['object_count']
-                    object_details.extend(value_memory['object_details'])
-
-            elif hasattr(obj, '__dict__'):
-                # 处理有__dict__属性的对象
-                for attr_name, attr_value in obj.__dict__.items():
-                    if object_count > max_objects:
-                        break
-                    # 跳过一些特殊属性
-                    if attr_name.startswith('_') and attr_name not in ['_calculated_ids']:
-                        continue
-                    attr_memory = self._calculate_recursive(attr_value, depth, max_depth, max_objects, object_count)
-                    total_memory += attr_memory['total_memory']
-                    object_count = attr_memory['object_count']
-                    object_details.extend(attr_memory['object_details'])
-
-        except Exception as e:
-            logger.debug(f"计算容器对象 {type(obj).__name__} 内存时出错：{str(e)}")
-
-        return {
-            'total_memory': total_memory,
-            'object_count': object_count,
-            'object_details': object_details
-        }

app/utils/string.py

@@ -938,3 +938,19 @@ class StringUtils:
         if isinstance(content, bytes) and content.startswith(b"magnet:"):
             return True
         return False
+
+    @staticmethod
+    def natural_sort_key(text: str) -> List[Union[int, str]]:
+        """
+        自然排序
+        将字符串拆分为数字和非数字部分，数字部分转换为整数，非数字部分转换为小写字母
+        :param text: 要处理的字符串
+        :return 用于排序的数字和字符串列表
+        """
+        if text is None:
+            return []
+
+        if not isinstance(text, str):
+            text = str(text)
+
+        return [int(part) if part.isdigit() else part.lower() for part in re.split(r'(\d+)', text)]

app/utils/system.py

@@ -527,6 +527,45 @@ class SystemUtils:
             print(f"Error occurred: {e}")
             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:
+            print(f"Error occurred: {e}")
+        return False
+
     @staticmethod
     def is_same_disk(src: Path, dest: Path) -> bool:
         """

config/category.yaml

@@ -8,6 +8,7 @@
 #   `release_year` 发行年份，格式：YYYY，电影实际对应`release_date`字段，电视剧实际对应`first_air_date`字段，支持范围设定，如：`YYYY-YYYY`
 #   themoviedb 详情API返回的其它一级字段
 # 4. 配置多项条件时需要同时满足，一个条件需要匹配多个值是使用`,`分隔
+# 5. !条件值表示排除该值
 
 # 配置电影的分类策略
 movie:

docker/cert.sh

@@ -31,23 +31,34 @@ if [ "${ENABLE_SSL}" = "true" ] && \
     if [ ! -d "/config/acme.sh" ]; then
         INFO "→ 安装acme.sh..."
 
-        # 生成安装参数
-        INSTALL_ARGS=(
-            "--install-online"
-            "--home" "/config/acme.sh"
-            "--config-home" "/config/acme.sh/data"
-            "--cert-home" "/config/certs"
-        )
+        # 设置安装环境变量
+        export LE_WORKING_DIR="/config/acme.sh"
+        export LE_CONFIG_HOME="/config/acme.sh/data"
+        export LE_CERT_HOME="/config/certs"
 
-        # 添加邮箱参数（如果设置）
+        # 执行官方安装命令（添加错误处理）
+        INFO "正在下载并安装 acme.sh..."
+        
+        # 构建安装命令
+        INSTALL_CMD="curl -sSL https://get.acme.sh | sh -s -- --install-online"
         if [ -n "${SSL_EMAIL}" ]; then
-            INSTALL_ARGS+=("--accountemail" "${SSL_EMAIL}")
+            INSTALL_CMD="${INSTALL_CMD} --accountemail ${SSL_EMAIL}"
         else
             WARN "未设置SSL_EMAIL，建议配置邮箱用于证书过期提醒"
         fi
+        
+        if ! eval "${INSTALL_CMD}"; then
+            ERROR "acme.sh 安装失败"
+            exit 1
+        fi
 
-        # 执行官方安装命令
-        curl -sSL https://get.acme.sh | sh -s -- "${INSTALL_ARGS[@]}"
+        # 验证安装是否成功
+        if [ ! -f "/config/acme.sh/acme.sh" ]; then
+            ERROR "acme.sh 安装后文件不存在，安装可能失败"
+            exit 1
+        fi
+
+        INFO "acme.sh 安装成功"
     fi
 
     # 签发证书（仅当证书不存在时）
@@ -77,17 +88,24 @@ if [ "${ENABLE_SSL}" = "true" ] && \
             fi
         done
 
-        # 签发证书
-        /config/acme.sh/acme.sh --issue \
+        # 签发证书（添加错误处理）
+        INFO "正在签发证书..."
+        if ! /config/acme.sh/acme.sh --issue \
             --dns "${DNS_PROVIDER}" \
             --domain "${SSL_DOMAIN}" \
             --key-file /config/certs/"${SSL_DOMAIN}"/privkey.pem \
             --fullchain-file /config/certs/"${SSL_DOMAIN}"/fullchain.pem \
             --reloadcmd "nginx -s reload" \
-            --force
+            --force; then
+            ERROR "证书签发失败"
+            exit 1
+        fi
 
         # 创建稳定符号链接
         ln -sf /config/certs/"${SSL_DOMAIN}" /config/certs/latest
+        INFO "证书签发成功"
+    else
+        INFO "证书已存在，跳过签发步骤"
     fi
 
     # 配置自动更新任务
@@ -98,4 +116,12 @@ if [ "${ENABLE_SSL}" = "true" ] && \
 
 elif [ "${ENABLE_SSL}" = "true" ] && [ "${AUTO_ISSUE_CERT}" = "true" ] && [ -z "${SSL_DOMAIN}" ]; then
     WARN "已启用自动签发证书但未设置SSL_DOMAIN，跳过证书管理"
+elif [ "${ENABLE_SSL}" = "true" ] && [ "${AUTO_ISSUE_CERT}" = "false" ]; then
+    INFO "SSL已启用但自动签发证书已禁用，将使用手动配置的证书"
+    # 检查证书文件是否存在
+    if [ -f "/config/certs/latest/fullchain.pem" ] && [ -f "/config/certs/latest/privkey.pem" ]; then
+        INFO "检测到证书文件，SSL配置正常"
+    else
+        WARN "未检测到证书文件，请确保手动配置了正确的证书路径"
+    fi
 fi

docker/entrypoint.sh

@@ -183,8 +183,8 @@ if [ "${ENABLE_SSL}" = "true" ]; then
         include /etc/nginx/mime.types;
         default_type application/octet-stream;
 
-        listen 443 ssl;
-        listen [::]:443 ssl;
+        listen ${SSL_NGINX_PORT:-443} ssl;
+        listen [::]:${SSL_NGINX_PORT:-443} ssl;
         server_name ${SSL_DOMAIN:-moviepilot};
 
         # SSL证书路径

requirements.in

@@ -76,6 +76,4 @@ setuptools~=78.1.0
 pympler~=1.1
 smbprotocol~=1.15.0
 setproctitle~=1.3.6
-httpx[socks]~=0.28.1
-prometheus-client~=0.22.1
-prometheus-fastapi-instrumentator~=7.1.0
+httpx[socks]~=0.28.1

version.py

@@ -1,2 +1,2 @@
-APP_VERSION = 'v2.7.7'
-FRONTEND_VERSION = 'v2.7.7'
+APP_VERSION = 'v2.7.9'
+FRONTEND_VERSION = 'v2.7.9'