crawlo 1.2.5__tar.gz → 1.2.6__tar.gz

{crawlo-1.2.5/crawlo.egg-info → crawlo-1.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: crawlo
-Version: 1.2.5
+Version: 1.2.6
 Summary: Crawlo 是一款基于异步IO的高性能Python爬虫框架，支持分布式抓取。
 Home-page: https://github.com/crawl-coder/Crawlo.git
 Author: crawl-coder

crawlo-1.2.6/crawlo/__version__.py

@@ -0,0 +1 @@
+__version__ = "1.2.6"

{crawlo-1.2.5 → crawlo-1.2.6}/crawlo/core/engine.py

@@ -88,8 +88,9 @@ class Engine(object):
         self.downloader = downloader_cls(self.crawler)
         if hasattr(self.downloader, 'open'):
             if asyncio.iscoroutinefunction(self.downloader.open):
-                await self.downloader.open()
+                self.downloader.open()
             else:
+                # DownloaderBase.open() 是同步方法，直接调用而不是await
                 self.downloader.open()
 
         self.processor = Processor(self.crawler)
@@ -97,6 +98,7 @@ class Engine(object):
             if asyncio.iscoroutinefunction(self.processor.open):
                 await self.processor.open()
             else:
+                # Processor.open() 是同步方法
                 self.processor.open()
 
         self.start_requests = iter(spider.start_requests())

crawlo-1.2.6/crawlo/core/scheduler.py

@@ -0,0 +1,240 @@
+#!/usr/bin/python
+# -*- coding:UTF-8 -*-
+from typing import Optional, Callable
+import traceback
+
+from crawlo.utils.log import get_logger
+from crawlo.utils.request import set_request
+from crawlo.utils.request_serializer import RequestSerializer
+from crawlo.utils.error_handler import ErrorHandler
+from crawlo.queue.queue_manager import QueueManager, QueueConfig, QueueType
+from crawlo.project import load_class, common_call
+
+
+class Scheduler:
+    def __init__(self, crawler, dupe_filter, stats, log_level, priority):
+        self.crawler = crawler
+        self.queue_manager: Optional[QueueManager] = None
+        self.request_serializer = RequestSerializer()  # 专门处理序列化
+
+        self.logger = get_logger(name=self.__class__.__name__, level=log_level)
+        self.error_handler = ErrorHandler(self.__class__.__name__, log_level)
+        self.stats = stats
+        self.dupe_filter = dupe_filter
+        self.priority = priority
+
+    @classmethod
+    def create_instance(cls, crawler):
+        filter_cls = load_class(crawler.settings.get('FILTER_CLASS'))
+        o = cls(
+            crawler=crawler,
+            dupe_filter=filter_cls.create_instance(crawler),
+            stats=crawler.stats,
+            log_level=crawler.settings.get('LOG_LEVEL'),
+            priority=crawler.settings.get('DEPTH_PRIORITY')
+        )
+        return o
+
+    async def open(self):
+        """初始化调度器和队列"""
+        self.logger.info("开始初始化调度器...")
+        try:
+            # 创建队列配置
+            queue_config = QueueConfig.from_settings(self.crawler.settings)
+            
+            # 创建队列管理器
+            self.queue_manager = QueueManager(queue_config)
+            
+            # 初始化队列
+            self.logger.info("开始初始化队列管理器...")
+            needs_config_update = await self.queue_manager.initialize()
+            
+            self.logger.info(f"队列初始化完成，needs_config_update: {needs_config_update}")
+            self.logger.info(f"当前队列类型: {self.queue_manager._queue_type}")
+            
+            # 检查是否需要更新过滤器配置
+            if needs_config_update:
+                # 如果返回True，说明队列类型发生了变化，需要检查当前队列类型来决定更新方向
+                self.logger.info("需要更新配置...")
+                if self.queue_manager._queue_type == QueueType.REDIS:
+                    self.logger.info("更新为Redis配置...")
+                    self._update_filter_config_for_redis()
+                else:
+                    self.logger.info("更新为内存配置...")
+                    self._update_filter_config_if_needed()
+            else:
+                # 检查是否需要更新配置（即使队列管理器没有要求更新）
+                self.logger.debug("检查是否需要更新配置...")
+                if self.queue_manager._queue_type == QueueType.REDIS:
+                    # 检查当前过滤器是否为内存过滤器
+                    current_filter_class = self.crawler.settings.get('FILTER_CLASS', '')
+                    if 'memory_filter' in current_filter_class:
+                        self.logger.info("检测到需要更新为Redis配置...")
+                        self._update_filter_config_for_redis()
+                elif self.queue_manager._queue_type == QueueType.MEMORY:
+                    # 检查当前过滤器是否为Redis过滤器
+                    current_filter_class = self.crawler.settings.get('FILTER_CLASS', '')
+                    if 'aioredis_filter' in current_filter_class or 'redis_filter' in current_filter_class:
+                        self.logger.info("检测到需要更新为内存配置...")
+                        self._update_filter_config_if_needed()
+            
+            # 只有在确实需要更新配置时才重新创建过滤器实例
+            # 检查是否真的进行了配置更新
+            filter_updated = (
+                (self.queue_manager._queue_type == QueueType.REDIS and 'memory_filter' in self.crawler.settings.get('FILTER_CLASS', '')) or
+                (self.queue_manager._queue_type == QueueType.MEMORY and ('aioredis_filter' in self.crawler.settings.get('FILTER_CLASS', '') or 'redis_filter' in self.crawler.settings.get('FILTER_CLASS', '')))
+            )
+            
+            if needs_config_update or filter_updated:
+                # 重新创建过滤器实例，确保使用更新后的配置
+                self.logger.debug("重新创建过滤器实例...")
+                filter_cls = load_class(self.crawler.settings.get('FILTER_CLASS'))
+                self.dupe_filter = filter_cls.create_instance(self.crawler)
+                self.logger.info(f"✅ 过滤器实例已更新为: {type(self.dupe_filter).__name__}")
+            else:
+                self.logger.debug("过滤器配置无需更新，跳过重新创建")
+            
+            # 输出队列状态和配置信息
+            status = self.queue_manager.get_status()
+            current_filter = self.crawler.settings.get('FILTER_CLASS')
+            current_dedup_pipeline = self.crawler.settings.get('DEFAULT_DEDUP_PIPELINE')
+            
+            self.logger.info(f'队列类型: {status["type"]}, 状态: {status["health"]}')
+            self.logger.info(f'当前过滤器: {type(self.dupe_filter).__name__} ({current_filter})')
+            self.logger.info(f'当前去重管道: {current_dedup_pipeline}')
+            self.logger.info("调度器初始化完成")
+        except Exception as e:
+            self.logger.error(f"❌ 调度器初始化失败: {e}")
+            self.logger.debug(f"详细错误信息:\n{traceback.format_exc()}")
+            raise
+    
+    def _update_filter_config_if_needed(self):
+        """如果队列类型切换到内存模式，则更新过滤器配置"""
+        if self.queue_manager and self.queue_manager._queue_type == QueueType.MEMORY:
+            # 检查当前过滤器是否为Redis过滤器
+            current_filter_class = self.crawler.settings.get('FILTER_CLASS', '')
+            if 'aioredis_filter' in current_filter_class or 'redis_filter' in current_filter_class:
+                # 更新为内存过滤器
+                self.crawler.settings.set('FILTER_CLASS', 'crawlo.filters.memory_filter.MemoryFilter')
+                self.logger.info("✅ 已更新过滤器配置为内存模式")
+            
+            # 检查当前去重管道是否为Redis去重管道
+            current_dedup_pipeline = self.crawler.settings.get('DEFAULT_DEDUP_PIPELINE', '')
+            if 'redis_dedup_pipeline' in current_dedup_pipeline:
+                # 更新为内存去重管道
+                self.crawler.settings.set('DEFAULT_DEDUP_PIPELINE', 'crawlo.pipelines.memory_dedup_pipeline.MemoryDedupPipeline')
+                # 同时更新PIPELINES列表中的去重管道
+                pipelines = self.crawler.settings.get('PIPELINES', [])
+                if current_dedup_pipeline in pipelines:
+                    # 找到并替换Redis去重管道为内存去重管道
+                    index = pipelines.index(current_dedup_pipeline)
+                    pipelines[index] = 'crawlo.pipelines.memory_dedup_pipeline.MemoryDedupPipeline'
+                    self.crawler.settings.set('PIPELINES', pipelines)
+                self.logger.info("✅ 已更新去重管道配置为内存模式")
+    
+    def _update_filter_config_for_redis(self):
+        """如果队列类型是Redis，则更新过滤器配置为Redis实现"""
+        if self.queue_manager and self.queue_manager._queue_type == QueueType.REDIS:
+            # 检查当前过滤器是否为内存过滤器
+            current_filter_class = self.crawler.settings.get('FILTER_CLASS', '')
+            if 'memory_filter' in current_filter_class:
+                # 更新为Redis过滤器
+                self.crawler.settings.set('FILTER_CLASS', 'crawlo.filters.aioredis_filter.AioRedisFilter')
+                self.logger.info("✅ 已更新过滤器配置为Redis模式")
+            
+            # 检查当前去重管道是否为内存去重管道
+            current_dedup_pipeline = self.crawler.settings.get('DEFAULT_DEDUP_PIPELINE', '')
+            if 'memory_dedup_pipeline' in current_dedup_pipeline:
+                # 更新为Redis去重管道
+                self.crawler.settings.set('DEFAULT_DEDUP_PIPELINE', 'crawlo.pipelines.redis_dedup_pipeline.RedisDedupPipeline')
+                # 同时更新PIPELINES列表中的去重管道
+                pipelines = self.crawler.settings.get('PIPELINES', [])
+                if current_dedup_pipeline in pipelines:
+                    # 找到并替换内存去重管道为Redis去重管道
+                    index = pipelines.index(current_dedup_pipeline)
+                    pipelines[index] = 'crawlo.pipelines.redis_dedup_pipeline.RedisDedupPipeline'
+                    self.crawler.settings.set('PIPELINES', pipelines)
+                self.logger.info("✅ 已更新去重管道配置为Redis模式")
+
+    async def next_request(self):
+        """获取下一个请求"""
+        if not self.queue_manager:
+            return None
+            
+        try:
+            request = await self.queue_manager.get()
+            
+            # 恢复 callback（从 Redis 队列取出时）
+            if request:
+                spider = getattr(self.crawler, 'spider', None)
+                request = self.request_serializer.restore_after_deserialization(request, spider)
+            
+            return request
+        except Exception as e:
+            self.error_handler.handle_error(
+                e, 
+                context="获取下一个请求失败", 
+                raise_error=False
+            )
+            return None
+
+    async def enqueue_request(self, request):
+        """将请求加入队列"""
+        if not request.dont_filter and await common_call(self.dupe_filter.requested, request):
+            self.dupe_filter.log_stats(request)
+            return False
+
+        if not self.queue_manager:
+            self.logger.error("队列管理器未初始化")
+            return False
+
+        set_request(request, self.priority)
+        
+        try:
+            # 使用统一的队列接口
+            success = await self.queue_manager.put(request, priority=getattr(request, 'priority', 0))
+            
+            if success:
+                self.logger.debug(f"✅ 请求入队成功: {request.url}")
+            
+            return success
+        except Exception as e:
+            self.error_handler.handle_error(
+                e, 
+                context="请求入队失败", 
+                raise_error=False
+            )
+            return False
+
+    def idle(self) -> bool:
+        """检查队列是否为空"""
+        return len(self) == 0
+
+    async def async_idle(self) -> bool:
+        """异步检查队列是否为空（更精确）"""
+        if not self.queue_manager:
+            return True
+        # 使用队列管理器的异步empty方法
+        return await self.queue_manager.async_empty()
+
+    async def close(self):
+        """关闭调度器"""
+        try:
+            if isinstance(closed := getattr(self.dupe_filter, 'closed', None), Callable):
+                await closed()
+            
+            if self.queue_manager:
+                await self.queue_manager.close()
+        except Exception as e:
+            self.error_handler.handle_error(
+                e, 
+                context="关闭调度器失败", 
+                raise_error=False
+            )
+
+    def __len__(self):
+        """获取队列大小"""
+        if not self.queue_manager:
+            return 0
+        # 返回同步的近似值，实际大小需要异步获取
+        return 0 if self.queue_manager.empty() else 1

{crawlo-1.2.5 → crawlo-1.2.6}/crawlo/filters/aioredis_filter.py

@@ -1,18 +1,6 @@
-#!/usr/bin/python
-# -*- coding:UTF-8 -*-
-"""
-Redis 过滤器实现
-=================
-提供基于 Redis 的分布式请求去重功能。
-
-特点:
-- 分布式支持: 多节点共享去重数据
-- TTL 支持: 自动过期清理
-- 高性能: 使用 Redis pipeline 优化
-- 容错设计: 网络异常自动重试
-"""
-import redis.asyncio as aioredis
 from typing import Optional
+import redis.asyncio as aioredis
+
 from crawlo.filters import BaseFilter
 from crawlo.utils.log import get_logger
 from crawlo.utils.request import request_fingerprint
@@ -70,6 +58,9 @@ class AioRedisFilter(BaseFilter):
         # 性能计数器
         self._redis_operations = 0
         self._pipeline_operations = 0
+        
+        # 连接状态标记，避免重复尝试连接失败的Redis
+        self._connection_failed = False
 
     @classmethod
     def create_instance(cls, crawler) -> 'BaseFilter':
@@ -123,8 +114,17 @@ class AioRedisFilter(BaseFilter):
 
     async def _get_redis_client(self):
         """获取Redis客户端实例（延迟初始化）"""
+        # 如果之前连接失败，直接返回None
+        if self._connection_failed:
+            return None
+            
         if self.redis is None and self._redis_pool is not None:
-            self.redis = await self._redis_pool.get_connection()
+            try:
+                self.redis = await self._redis_pool.get_connection()
+            except Exception as e:
+                self._connection_failed = True
+                self.logger.error(f"Redis连接失败，将使用本地去重: {e}")
+                return None
         return self.redis
 
     async def requested(self, request) -> bool:
@@ -136,13 +136,17 @@ class AioRedisFilter(BaseFilter):
         """
         try:
             # 确保Redis客户端已初始化
-            await self._get_redis_client()
+            redis_client = await self._get_redis_client()
+            
+            # 如果Redis不可用，返回False表示不重复（避免丢失请求）
+            if redis_client is None:
+                return False
             
             fp = str(request_fingerprint(request))
             self._redis_operations += 1
 
             # 使用 pipeline 优化性能
-            pipe = self.redis.pipeline()
+            pipe = redis_client.pipeline()
             pipe.sismember(self.redis_key, fp)
             
             results = await pipe.execute()
@@ -173,12 +177,16 @@ class AioRedisFilter(BaseFilter):
         """
         try:
             # 确保Redis客户端已初始化
-            await self._get_redis_client()
+            redis_client = await self._get_redis_client()
+            
+            # 如果Redis不可用，返回False表示添加失败
+            if redis_client is None:
+                return False
             
             fp = str(fp)
             
             # 使用 pipeline 优化性能
-            pipe = self.redis.pipeline()
+            pipe = redis_client.pipeline()
             pipe.sadd(self.redis_key, fp)
             
             if self.ttl and self.ttl > 0:
@@ -197,85 +205,30 @@ class AioRedisFilter(BaseFilter):
         except Exception as e:
             self.logger.error(f"添加指纹失败: {fp[:20]}... - {e}")
             return False
-    
-    def __contains__(self, item: str) -> bool:
+
+    async def __contains__(self, fp: str) -> bool:
         """
-        同步版本的包含检查（不推荐在异步环境中使用）
+        检查指纹是否存在于Redis集合中
         
-        :param item: 要检查的指纹
-        :return: 是否已存在
+        :param fp: 请求指纹字符串
+        :return: 是否存在
         """
-        # 这是一个同步方法，不能直接调用异步Redis操作
-        # 建议使用 requested() 方法替代
-        raise NotImplementedError("请使用 requested() 方法进行异步检查")
-
-    async def get_stats(self) -> dict:
-        """获取过滤器详细统计信息"""
         try:
             # 确保Redis客户端已初始化
-            await self._get_redis_client()
-            
-            count = await self.redis.scard(self.redis_key)
+            redis_client = await self._get_redis_client()
             
-            # 获取TTL信息
-            ttl_info = "TTL未设置"
-            if self.ttl:
-                remaining_ttl = await self.redis.ttl(self.redis_key)
-                if remaining_ttl > 0:
-                    ttl_info = f"剩余 {remaining_ttl} 秒"
-                else:
-                    ttl_info = f"配置 {self.ttl} 秒"
-            
-            stats = {
-                'filter_type': 'AioRedisFilter',
-                '指纹总数': count,
-                'Redis键名': self.redis_key,
-                'TTL配置': ttl_info,
-                'Redis操作数': self._redis_operations,
-                'Pipeline操作数': self._pipeline_operations,
-                '性能优化率': f"{self._pipeline_operations / max(1, self._redis_operations) * 100:.1f}%"
-            }
-            
-            # 合并基类统计
-            base_stats = super().get_stats()
-            stats.update(base_stats)
-            
-            return stats
+            # 如果Redis不可用，返回False表示不存在
+            if redis_client is None:
+                return False
             
+            # 检查指纹是否存在
+            exists = await redis_client.sismember(self.redis_key, str(fp))
+            return exists
         except Exception as e:
-            self.logger.error(f"获取统计信息失败: {e}")
-            return super().get_stats()
-
-    async def clear_all(self) -> int:
-        """清空所有指纹数据"""
-        try:
-            # 确保Redis客户端已初始化
-            await self._get_redis_client()
-            
-            deleted = await self.redis.delete(self.redis_key)
-            self.logger.info(f"已清除指纹数: {deleted}")
-            return deleted
-        except Exception as e:
-            self.logger.error("清空指纹失败")
-            raise
+            self.logger.error(f"检查指纹存在性失败: {fp[:20]}... - {e}")
+            # 在网络异常时返回False，避免丢失请求
+            return False
 
-    async def closed(self, reason: Optional[str] = None) -> None:
-        """爬虫关闭时的清理操作"""
-        try:
-            # 确保Redis客户端已初始化
-            await self._get_redis_client()
-            
-            if self.cleanup_fp:
-                deleted = await self.redis.delete(self.redis_key)
-                self.logger.info(f"爬虫关闭清理: 已删除{deleted}个指纹")
-            else:
-                count = await self.redis.scard(self.redis_key)
-                ttl_info = f"{self.ttl}秒" if self.ttl else "持久化"
-                self.logger.info(f"保留指纹数: {count} (TTL: {ttl_info})")
-        finally:
-            await self._close_redis()
 
-    async def _close_redis(self) -> None:
-        """安全关闭Redis连接"""
-        # 连接池会自动管理连接，这里不需要显式关闭
-        self.logger.debug("Redis连接已释放")
+# 为了兼容性，确保导出类
+__all__ = ['AioRedisFilter']

{crawlo-1.2.5 → crawlo-1.2.6}/crawlo/queue/queue_manager.py

@@ -4,11 +4,11 @@
 统一的队列管理器
 提供简洁、一致的队列接口，自动处理不同队列类型的差异
 """
-from typing import Optional, Dict, Any, Union
-from enum import Enum
+import os
 import asyncio
 import traceback
-import os
+from typing import Optional, Dict, Any, Union
+from enum import Enum
 
 from crawlo.utils.log import get_logger
 from crawlo.utils.request_serializer import RequestSerializer
@@ -103,11 +103,24 @@ class QueueManager:
             self._queue_type = queue_type
             
             # 测试队列健康状态
-            await self._health_check()
+            health_check_result = await self._health_check()
             
             self.logger.info(f"✅ 队列初始化成功: {queue_type.value}")
-            self.logger.info(f"📊 队列配置: {self._get_queue_info()}")
-            return True
+            # 只在调试模式下输出详细配置信息
+            self.logger.debug(f"📊 队列配置: {self._get_queue_info()}")
+            
+            # 如果健康检查返回True，表示队列类型发生了切换，需要更新配置
+            if health_check_result:
+                return True
+            
+            # 如果队列类型是Redis，检查是否需要更新配置
+            if queue_type == QueueType.REDIS:
+                # 这个检查需要在调度器中进行，因为队列管理器无法访问crawler.settings
+                # 但我们不需要总是返回True，只有在确实需要更新时才返回True
+                # 调度器会进行更详细的检查
+                pass
+            
+            return False  # 默认不需要更新配置
             
         except Exception as e:
             # 记录详细的错误信息和堆栈跟踪
@@ -265,7 +278,15 @@ class QueueManager:
                 raise RuntimeError("Redis 队列不可用：未安装 redis 依赖")
             if not self.config.redis_url:
                 raise RuntimeError("Redis 队列不可用：未配置 REDIS_URL")
-            return QueueType.REDIS
+            # 测试 Redis 连接
+            try:
+                test_queue = RedisPriorityQueue(self.config.redis_url)
+                await test_queue.connect()
+                await test_queue.close()
+                return QueueType.REDIS
+            except Exception as e:
+                # 如果强制使用Redis但连接失败，则抛出异常
+                raise RuntimeError(f"Redis 队列不可用：无法连接到 Redis ({e})")
         
         elif self.config.queue_type == QueueType.MEMORY:
             return QueueType.MEMORY
@@ -307,7 +328,7 @@ class QueueManager:
         else:
             raise ValueError(f"不支持的队列类型: {queue_type}")
     
-    async def _health_check(self) -> None:
+    async def _health_check(self) -> bool:
         """健康检查"""
         try:
             if self._queue_type == QueueType.REDIS:
@@ -317,9 +338,27 @@ class QueueManager:
             else:
                 # 内存队列总是健康的
                 self._health_status = "healthy"
+                return False  # 内存队列不需要更新配置
         except Exception as e:
             self.logger.warning(f"队列健康检查失败: {e}")
             self._health_status = "unhealthy"
+            # 如果是Redis队列且健康检查失败，尝试切换到内存队列
+            if self._queue_type == QueueType.REDIS and self.config.queue_type == QueueType.AUTO:
+                self.logger.info("Redis队列不可用，尝试切换到内存队列...")
+                try:
+                    await self._queue.close()
+                except:
+                    pass
+                self._queue = None
+                # 重新创建内存队列
+                self._queue = await self._create_queue(QueueType.MEMORY)
+                self._queue_type = QueueType.MEMORY
+                self._queue_semaphore = asyncio.Semaphore(self.config.max_queue_size)
+                self._health_status = "healthy"
+                self.logger.info("✅ 已切换到内存队列")
+                # 返回一个信号，表示需要更新过滤器和去重管道配置
+                return True
+        return False
     
     def _get_queue_info(self) -> Dict[str, Any]:
         """获取队列配置信息"""

{crawlo-1.2.5 → crawlo-1.2.6}/crawlo/queue/redis_priority_queue.py

@@ -77,7 +77,13 @@ class RedisPriorityQueue:
         """异步连接 Redis，支持重试"""
         async with self._lock:
             if self._redis is not None:
-                return self._redis
+                # 如果已经连接，测试连接是否仍然有效
+                try:
+                    await self._redis.ping()
+                    return self._redis
+                except Exception:
+                    # 连接失效，重新连接
+                    self._redis = None
 
             for attempt in range(max_retries):
                 try:
@@ -97,7 +103,8 @@ class RedisPriorityQueue:
                     
                     # 测试连接
                     await self._redis.ping()
-                    logger.info(f"✅ Redis 连接成功 (Module: {self.module_name})")
+                    # 只在调试模式下输出详细连接信息
+                    logger.debug(f"✅ Redis 连接成功 (Module: {self.module_name})")
                     return self._redis
                 except Exception as e:
                     error_msg = f"⚠️ Redis 连接失败 (尝试 {attempt + 1}/{max_retries}, Module: {self.module_name}): {e}"

{crawlo-1.2.5 → crawlo-1.2.6}/crawlo/settings/default_settings.py

@@ -3,7 +3,6 @@
 默认配置文件
 包含 Crawlo 框架的所有默认设置项
 """
-import os
 
 # 添加环境变量配置工具导入
 from crawlo.utils.env_config import get_redis_config, get_runtime_config
@@ -13,9 +12,6 @@ from crawlo.utils.env_config import get_redis_config, get_runtime_config
 # 项目名称（用于日志、Redis Key 等标识）
 PROJECT_NAME = get_runtime_config()['PROJECT_NAME']
 
-# 框架版本
-VERSION = 1.0
-
 # 运行模式：standalone/distributed/auto
 RUN_MODE = get_runtime_config()['CRAWLO_MODE']
 
@@ -46,9 +42,11 @@ SCHEDULER_QUEUE_NAME = f"crawlo:{PROJECT_NAME}:queue:requests"
 # 队列类型：memory/redis/auto
 QUEUE_TYPE = 'auto'
 
-# 明确配置默认去重管道和过滤器，避免冗余的if-else判断
-DEFAULT_DEDUP_PIPELINE = 'crawlo.pipelines.memory_dedup_pipeline.MemoryDedupPipeline'
-FILTER_CLASS = 'crawlo.filters.memory_filter.MemoryFilter'
+
+# 默认使用内存过滤器和去重管道，确保在无Redis环境下也能正常运行
+# 在auto模式下，如果Redis可用，框架会自动更新为Redis实现以提供更好的去重能力
+DEFAULT_DEDUP_PIPELINE = 'crawlo.pipelines.memory_dedup_pipeline.MemoryDedupPipeline' 
+FILTER_CLASS = 'crawlo.filters.memory_filter.MemoryFilter'  
 
 # --- Redis 过滤器配置 ---
 # 使用环境变量配置工具获取 Redis 配置

{crawlo-1.2.5 → crawlo-1.2.6}/crawlo/templates/project/settings.py.tmpl

@@ -75,43 +75,6 @@ INTERVAL = 5
 DEPTH_PRIORITY = 1
 MAX_RUNNING_SPIDERS = 3
 
-# ============================== 运行模式选择 ==============================
-# 运行模式：'standalone'(单机), 'distributed'(分布式), 'auto'(自动检测)
-# 
-# 三种运行模式的最佳使用场景：
-# 
-# 1. standalone（单机模式）：
-#    - 适用场景：开发调试、小规模数据采集、个人项目
-#    - 特点：简单易用，资源占用少，无需额外依赖
-#    - 配置建议：
-#      * QUEUE_TYPE = 'auto'（自动选择队列类型）
-#      * FILTER_CLASS = 'crawlo.filters.memory_filter.MemoryFilter'（内存过滤器）
-#      * DEFAULT_DEDUP_PIPELINE = 'crawlo.pipelines.memory_dedup_pipeline.MemoryDedupPipeline'（内存去重）
-#    - 混合配置（推荐）：
-#      * QUEUE_TYPE = 'auto'（自动选择）
-#      * FILTER_CLASS = 'crawlo.filters.aioredis_filter.AioRedisFilter'（Redis过滤器）
-#      * DEFAULT_DEDUP_PIPELINE = 'crawlo.pipelines.redis_dedup_pipeline.RedisDedupPipeline'（Redis去重）
-#      * 优势：享受Redis去重的持久性，同时保持部署简单
-#
-# 2. distributed（分布式模式）：
-#    - 适用场景：大规模数据采集、多节点协同工作、高并发需求
-#    - 特点：支持多节点扩展，高并发处理能力，需要Redis支持
-#    - 配置建议：
-#      * QUEUE_TYPE = 'redis'（Redis队列）
-#      * FILTER_CLASS = 'crawlo.filters.aioredis_filter.AioRedisFilter'（Redis过滤器）
-#      * DEFAULT_DEDUP_PIPELINE = 'crawlo.pipelines.redis_dedup_pipeline.RedisDedupPipeline'（Redis去重）
-#    - 部署要求：需要配置Redis服务器连接参数
-#
-# 3. auto（自动检测模式）：
-#    - 适用场景：希望根据环境自动选择最佳运行方式
-#    - 特点：智能检测环境配置，自动选择运行模式
-#    - 配置建议：
-#      * 框架会根据Redis可用性自动选择队列类型
-#      * 默认使用内存过滤器和去重管道
-#    - 适用情况：需要在不同环境中使用同一套配置
-
-RUN_MODE = 'standalone'  # 默认单机模式，简单易用
-
 # ============================== 队列配置（支持分布式） ==============================
 
 # 队列类型：'auto'（自动选择）, 'memory'（内存队列）, 'redis'（分布式队列）
@@ -157,8 +120,9 @@ MONGO_USE_BATCH = False  # 是否启用批量插入
 REQUEST_DIR = '.'
 
 # 明确配置默认去重管道和过滤器，避免冗余的if-else判断
-DEFAULT_DEDUP_PIPELINE = 'crawlo.pipelines.memory_dedup_pipeline.MemoryDedupPipeline'
-FILTER_CLASS = 'crawlo.filters.memory_filter.MemoryFilter'
+# 在单机模式下，如果Redis可用则使用Redis去重，否则使用内存去重
+DEFAULT_DEDUP_PIPELINE = 'crawlo.pipelines.redis_dedup_pipeline.RedisDedupPipeline'
+FILTER_CLASS = 'crawlo.filters.aioredis_filter.AioRedisFilter'
 
 # --- Redis 配置（用于分布式去重和队列） ---
 REDIS_HOST = os.getenv('REDIS_HOST', '127.0.0.1')