crawlo 1.1.3__py3-none-any.whl → 1.1.5__py3-none-any.whl

crawlo/templates/project/pipelines.py.tmpl

@@ -5,338 +5,94 @@
 数据管道，用于处理 Spider 返回的 Item。
 例如：清理、验证、去重、保存到数据库等。
 
-支持异步并发处理和多种存储后端。
+这是一个简单的示例管道，您可以根据需要添加更多管道。
 """
 
 import json
-import asyncio
-from typing import Dict, Any
 from datetime import datetime
 from crawlo.exceptions import DropItem
 from crawlo.utils.log import get_logger
 
 
-class ValidationPipeline:
+class ExamplePipeline:
     """
-    数据验证管道。
+    示例管道，演示如何处理数据项。
     
-    验证必要字段是否存在，过滤无效数据。
+    此管道会：
+    1. 验证必要字段
+    2. 清理数据
+    3. 添加时间戳
+    4. 记录处理日志
     """
     
     def __init__(self):
         self.logger = get_logger(self.__class__.__name__)
-        # 必要字段列表（根据实际需要修改）
-        self.required_fields = ['title', 'url']
-    
+        self.item_count = 0
+
     def process_item(self, item, spider):
-        """验证数据项。"""
-        # 检查必要字段
-        for field in self.required_fields:
-            if not item.get(field):
-                raise DropItem(f"缺少必要字段: {field}")
+        """
+        处理数据项。
+        
+        Args:
+            item: 要处理的数据项
+            spider: 爬虫实例
+            
+        Returns:
+            处理后的数据项
+            
+        Raises:
+            DropItem: 如果数据项无效则抛出此异常
+        """
+        # 验证必要字段
+        if not item.get('title') or not item.get('url'):
+            raise DropItem("缺少必要字段: title 或 url")
         
         # 数据清理
-        if 'title' in item:
-            item['title'] = str(item['title']).strip()
+        item['title'] = str(item['title']).strip()
         
-        # 添加时间戳
-        item['crawled_at'] = datetime.now().isoformat()
+        # 添加处理时间戳
+        item['processed_at'] = datetime.now().isoformat()
         
-        self.logger.debug(f"数据验证通过: {item.get('url', 'Unknown URL')}")
-        return item
-
-
-class PrintItemPipeline:
-    """
-    简单的打印管道，用于调试。
-    """
-    
-    def __init__(self):
-        self.logger = get_logger(self.__class__.__name__)
-        self.item_count = 0
-
-    def process_item(self, item, spider):
-        """打印数据项。"""
+        # 计数器
         self.item_count += 1
-        self.logger.info(f"[第{self.item_count}个数据] {json.dumps(dict(item), ensure_ascii=False, indent=2)}")
-        return item
-
-
-class DuplicatesPipeline:
-    """
-    去重管道。
-    
-    基于指定字段进行去重，防止重复数据。
-    """
-    
-    def __init__(self):
-        self.logger = get_logger(self.__class__.__name__)
-        self.seen = set()
-        # 去重字段（可以是 'url', 'id', 或其他唯一标识）
-        self.duplicate_field = 'url'
-        self.drop_count = 0
-
-    def process_item(self, item, spider):
-        """检查并去除重复数据。"""
-        identifier = item.get(self.duplicate_field)
         
-        if not identifier:
-            self.logger.warning(f"数据项缺少去重字段 '{self.duplicate_field}'，跳过去重检查")
-            return item
+        # 记录日志
+        self.logger.info(f"处理第 {self.item_count} 个数据项: {item['title']}")
         
-        if identifier in self.seen:
-            self.drop_count += 1
-            self.logger.debug(f"发现重复数据: {identifier} (已过滤{self.drop_count}个)")
-            raise DropItem(f"重复数据: {identifier}")
-        
-        self.seen.add(identifier)
         return item
-    
-    def close_spider(self, spider):
-        """爬虫结束时输出统计信息。"""
-        self.logger.info(f"去重管道统计: 已过滤{self.drop_count}个重复数据，唯一数据{len(self.seen)}个")
-
 
-class JsonFilesPipeline:
-    """
-    JSON 文件存储管道。
-    
-    将每个数据项保存为单独的 JSON 文件。
-    """
-    
-    def __init__(self, output_dir='output'):
-        self.logger = get_logger(self.__class__.__name__)
-        self.output_dir = output_dir
-        self.file_count = 0
-    
-    @classmethod
-    def from_crawler(cls, crawler):
-        """从爬虫配置创建管道实例。"""
-        output_dir = crawler.settings.get('JSON_OUTPUT_DIR', 'output')
-        return cls(output_dir=output_dir)
-    
     def open_spider(self, spider):
-        """爬虫启动时创建输出目录。"""
-        import os
-        os.makedirs(self.output_dir, exist_ok=True)
-        self.logger.info(f"JSON 文件将保存到: {self.output_dir}")
-    
-    def process_item(self, item, spider):
-        """将数据项保存为 JSON 文件。"""
-        self.file_count += 1
-        filename = f"{spider.name}_{self.file_count:06d}.json"
-        filepath = f"{self.output_dir}/{filename}"
-        
-        with open(filepath, 'w', encoding='utf-8') as f:
-            json.dump(dict(item), f, ensure_ascii=False, indent=2)
+        """
+        爬虫启动时调用。
         
-        self.logger.debug(f"已保存: {filepath}")
-        return item
-
+        Args:
+            spider: 爬虫实例
+        """
+        self.logger.info(f"管道已启动，准备处理爬虫 '{spider.name}' 的数据")
 
-class DatabasePipeline:
-    """
-    数据库存储管道示例。
-    
-    支持 MySQL 和 MongoDB，可根据需要选择。
-    """
-    
-    def __init__(self, database_type='mysql'):
-        self.logger = get_logger(self.__class__.__name__)
-        self.database_type = database_type
-        self.connection = None
-        self.batch_items = []
-        self.batch_size = 100  # 批量写入大小
-    
-    @classmethod
-    def from_crawler(cls, crawler):
-        """从爬虫配置创建管道实例。"""
-        db_type = crawler.settings.get('DATABASE_TYPE', 'mysql')
-        return cls(database_type=db_type)
-    
-    async def open_spider(self, spider):
-        """爬虫启动时连接数据库。"""
-        if self.database_type == 'mysql':
-            await self._connect_mysql(spider)
-        elif self.database_type == 'mongodb':
-            await self._connect_mongodb(spider)
-        else:
-            raise ValueError(f"不支持的数据库类型: {self.database_type}")
-    
-    async def _connect_mysql(self, spider):
-        """连接 MySQL 数据库。"""
-        try:
-            import aiomysql
-            
-            settings = spider.crawler.settings
-            self.connection = await aiomysql.connect(
-                host=settings.get('MYSQL_HOST', '127.0.0.1'),
-                port=settings.get('MYSQL_PORT', 3306),
-                user=settings.get('MYSQL_USER', 'root'),
-                password=settings.get('MYSQL_PASSWORD', ''),
-                db=settings.get('MYSQL_DB', '{{project_name}}'),
-                charset='utf8mb4',
-                autocommit=True
-            )
-            
-            # 创建表（如果不存在）
-            await self._create_mysql_table(spider)
-            self.logger.info("已连接到 MySQL 数据库")
-            
-        except ImportError:
-            self.logger.error("缺少 aiomysql 依赖，请安装: pip install aiomysql")
-            raise
-        except Exception as e:
-            self.logger.error(f"MySQL 连接失败: {e}")
-            raise
-    
-    async def _connect_mongodb(self, spider):
-        """连接 MongoDB 数据库。"""
-        try:
-            from motor.motor_asyncio import AsyncIOMotorClient
-            
-            settings = spider.crawler.settings
-            mongo_uri = settings.get('MONGO_URI', 'mongodb://localhost:27017')
-            
-            self.connection = AsyncIOMotorClient(mongo_uri)
-            self.database = self.connection[settings.get('MONGO_DATABASE', '{{project_name}}_db')]
-            self.collection = self.database[settings.get('MONGO_COLLECTION', '{{project_name}}_items')]
-            
-            self.logger.info("已连接到 MongoDB 数据库")
-            
-        except ImportError:
-            self.logger.error("缺少 motor 依赖，请安装: pip install motor")
-            raise
-        except Exception as e:
-            self.logger.error(f"MongoDB 连接失败: {e}")
-            raise
-    
-    async def _create_mysql_table(self, spider):
-        """创建 MySQL 表结构。"""
-        table_name = spider.crawler.settings.get('MYSQL_TABLE', '{{project_name}}_data')
-        
-        create_sql = f"""
-        CREATE TABLE IF NOT EXISTS `{table_name}` (
-            `id` bigint AUTO_INCREMENT PRIMARY KEY,
-            `title` varchar(500) DEFAULT NULL,
-            `url` varchar(1000) NOT NULL,
-            `content` text DEFAULT NULL,
-            `crawled_at` datetime DEFAULT CURRENT_TIMESTAMP,
-            `spider_name` varchar(100) DEFAULT NULL,
-            `extra_data` json DEFAULT NULL,
-            UNIQUE KEY `unique_url` (`url`(255)),
-            INDEX `idx_spider_name` (`spider_name`),
-            INDEX `idx_crawled_at` (`crawled_at`)
-        ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
+    def close_spider(self, spider):
         """
+        爬虫关闭时调用。
         
-        async with self.connection.cursor() as cursor:
-            await cursor.execute(create_sql)
-            self.logger.info(f"表 '{table_name}' 准备就绪")
-    
-    async def process_item(self, item, spider):
-        """处理数据项（批量存储）。"""
-        self.batch_items.append(dict(item))
-        
-        # 批量存储
-        if len(self.batch_items) >= self.batch_size:
-            await self._save_batch(spider)
-        
-        return item
-    
-    async def _save_batch(self, spider):
-        """批量保存数据。"""
-        if not self.batch_items:
-            return
-        
-        try:
-            if self.database_type == 'mysql':
-                await self._save_to_mysql(spider)
-            elif self.database_type == 'mongodb':
-                await self._save_to_mongodb(spider)
-            
-            self.logger.info(f"批量保存 {len(self.batch_items)} 条数据")
-            self.batch_items.clear()
-            
-        except Exception as e:
-            self.logger.error(f"批量保存失败: {e}")
-            # 可以选择重试或记录失败数据
-    
-    async def _save_to_mysql(self, spider):
-        """保存到 MySQL。"""
-        table_name = spider.crawler.settings.get('MYSQL_TABLE', '{{project_name}}_data')
-        
-        insert_sql = f"""
-        INSERT INTO `{table_name}` 
-        (`title`, `url`, `content`, `spider_name`, `extra_data`)
-        VALUES (%s, %s, %s, %s, %s)
-        ON DUPLICATE KEY UPDATE
-        `title` = VALUES(`title`),
-        `content` = VALUES(`content`),
-        `crawled_at` = CURRENT_TIMESTAMP
+        Args:
+            spider: 爬虫实例
         """
-        
-        async with self.connection.cursor() as cursor:
-            batch_data = []
-            for item in self.batch_items:
-                # 提取标准字段
-                title = item.get('title', '')[:500]  # 限制长度
-                url = item.get('url', '')
-                content = item.get('content', '')
-                
-                # 其他字段作为 JSON 存储
-                extra_fields = {k: v for k, v in item.items() 
-                              if k not in ['title', 'url', 'content']}
-                extra_data = json.dumps(extra_fields, ensure_ascii=False) if extra_fields else None
-                
-                batch_data.append((title, url, content, spider.name, extra_data))
-            
-            await cursor.executemany(insert_sql, batch_data)
-    
-    async def _save_to_mongodb(self, spider):
-        """保存到 MongoDB。"""
-        # 为每个数据项添加 spider_name
-        for item in self.batch_items:
-            item['spider_name'] = spider.name
-        
-        # 批量插入
-        await self.collection.insert_many(self.batch_items)
-    
-    async def close_spider(self, spider):
-        """爬虫结束时保存剩余数据并关闭连接。"""
-        # 保存剩余数据
-        if self.batch_items:
-            await self._save_batch(spider)
-        
-        # 关闭连接
-        if self.connection:
-            if self.database_type == 'mysql':
-                self.connection.close()
-            elif self.database_type == 'mongodb':
-                self.connection.close()
-            
-            self.logger.info("数据库连接已关闭")
+        self.logger.info(f"管道已关闭，共处理了 {self.item_count} 个数据项")
 
 
 # ======================== 使用说明 ========================
 # 
 # 在 settings.py 中启用管道：
 # PIPELINES = [
-#     '{{project_name}}.pipelines.ValidationPipeline',      # 数据验证
-#     '{{project_name}}.pipelines.DuplicatesPipeline',       # 去重过滤
-#     '{{project_name}}.pipelines.PrintItemPipeline',        # 打印输出（调试）
-#     '{{project_name}}.pipelines.JsonFilesPipeline',        # JSON 文件存储
-#     '{{project_name}}.pipelines.DatabasePipeline',         # 数据库存储
+#     '{{project_name}}.pipelines.ExamplePipeline',
 # ]
 # 
-# Crawlo 框架提供了多种内置的去重管道：
-# 1. crawlo.pipelines.MemoryDedupPipeline    - 内存去重（单机模式默认）
-# 2. crawlo.pipelines.RedisDedupPipeline     - Redis去重（分布式模式默认）
-# 3. crawlo.pipelines.BloomDedupPipeline     - Bloom Filter去重（大规模数据）
-# 4. crawlo.pipelines.DatabaseDedupPipeline  - 数据库去重（持久化）
+# 您可以根据需要添加更多管道，例如：
+# 1. 数据验证管道
+# 2. 去重管道
+# 3. 数据存储管道（数据库、文件等）
+# 4. 数据转换管道
 # 
-# 相关配置：
-# JSON_OUTPUT_DIR = 'output'          # JSON 文件输出目录
-# DATABASE_TYPE = 'mysql'             # 数据库类型: mysql/mongodb
-# MYSQL_TABLE = '{{project_name}}_data'  # MySQL 表名
+# 每个管道都应该实现 process_item 方法，
+# 可选实现 open_spider 和 close_spider 方法。
 # ======================== 使用说明 ========================

crawlo/templates/project/settings.py.tmpl

@@ -64,9 +64,9 @@ locals().update(CONFIG.to_dict())
 # ============================== 网络请求配置 ==============================
 
 # 下载器选择（推荐使用 CurlCffi，支持浏览器指纹模拟）
-DOWNLOADER = "crawlo.downloader.cffi_downloader.CurlCffiDownloader"  # 支持浏览器指纹
+DOWNLOADER = "crawlo.downloader.httpx_downloader.HttpXDownloader"     # HTTP/2 支持
+# DOWNLOADER = "crawlo.downloader.cffi_downloader.CurlCffiDownloader"  # 支持浏览器指纹
 # DOWNLOADER = "crawlo.downloader.aiohttp_downloader.AioHttpDownloader"  # 轻量级选择
-# DOWNLOADER = "crawlo.downloader.httpx_downloader.HttpXDownloader"     # HTTP/2 支持
 
 # 请求超时与安全
 DOWNLOAD_TIMEOUT = 30
@@ -89,26 +89,35 @@ ALLOWED_CODES = []
 CONNECTION_POOL_LIMIT = 50
 DOWNLOAD_MAXSIZE = 10 * 1024 * 1024    # 10MB
 DOWNLOAD_WARN_SIZE = 1024 * 1024       # 1MB
+DOWNLOAD_RETRY_TIMES = MAX_RETRY_TIMES  # 下载器内部重试次数（复用全局）
+
+# 下载统计配置
+DOWNLOADER_STATS = True  # 是否启用下载器统计功能
+DOWNLOAD_STATS = True  # 是否记录下载时间和大小统计
 
 # ============================== 并发与调度配置 ==============================
+
 CONCURRENCY = 8
 INTERVAL = 5
 DEPTH_PRIORITY = 1
 MAX_RUNNING_SPIDERS = 3
 
+# 运行模式选择：'standalone'(单机), 'distributed'(分布式), 'auto'(自动检测)
+RUN_MODE = 'standalone'  # 默认单机模式，简单易用
+
 # ============================== 队列配置（支持分布式） ==============================
 
 # 队列类型：'auto'（自动选择）, 'memory'（内存队列）, 'redis'（分布式队列）
 QUEUE_TYPE = 'auto'
 SCHEDULER_MAX_QUEUE_SIZE = 2000
-SCHEDULER_QUEUE_NAME = f'{{project_name}}:requests'
+SCHEDULER_QUEUE_NAME = f'crawlo:{{project_name}}:queue:requests'  # 使用统一命名规范
 QUEUE_MAX_RETRIES = 3
 QUEUE_TIMEOUT = 300
 
 # 大规模爬取优化
-LARGE_SCALE_BATCH_SIZE = 1000
-LARGE_SCALE_CHECKPOINT_INTERVAL = 5000
-LARGE_SCALE_MAX_MEMORY_USAGE = 500
+LARGE_SCALE_BATCH_SIZE = 1000  # 批处理大小
+LARGE_SCALE_CHECKPOINT_INTERVAL = 5000  # 进度保存间隔
+LARGE_SCALE_MAX_MEMORY_USAGE = 500  # 最大内存使用量（MB）
 
 # ============================== 数据存储配置 ==============================
 
@@ -120,24 +129,31 @@ MYSQL_PASSWORD = os.getenv('MYSQL_PASSWORD', '123456')
 MYSQL_DB = os.getenv('MYSQL_DB', '{{project_name}}')
 MYSQL_TABLE = '{{project_name}}_data'
 MYSQL_BATCH_SIZE = 100
-
-# MySQL 连接池
-MYSQL_FLUSH_INTERVAL = 5
-MYSQL_POOL_MIN = 5
-MYSQL_POOL_MAX = 20
-MYSQL_ECHO = False
+MYSQL_USE_BATCH = False  # 是否启用批量插入
 
 # --- MongoDB 配置 ---
 MONGO_URI = os.getenv('MONGO_URI', 'mongodb://localhost:27017')
-MONGO_DATABASE = f'{{project_name}}_db'
+MONGO_DATABASE = '{{project_name}}_db'
 MONGO_COLLECTION = '{{project_name}}_items'
 MONGO_MAX_POOL_SIZE = 200
 MONGO_MIN_POOL_SIZE = 20
+MONGO_BATCH_SIZE = 100  # 批量插入条数
+MONGO_USE_BATCH = False  # 是否启用批量插入
 
 # ============================== 去重过滤配置 ==============================
 
 REQUEST_DIR = '.'
 
+# 根据运行模式自动选择去重管道
+# 单机模式默认使用内存去重管道
+# 分布式模式默认使用Redis去重管道
+if RUN_MODE == 'distributed':
+    # 分布式模式下默认使用Redis去重管道
+    DEFAULT_DEDUP_PIPELINE = 'crawlo.pipelines.RedisDedupPipeline'
+else:
+    # 单机模式下默认使用内存去重管道
+    DEFAULT_DEDUP_PIPELINE = 'crawlo.pipelines.MemoryDedupPipeline'
+
 # 去重过滤器（推荐分布式项目使用 Redis 过滤器）
 FILTER_CLASS = 'crawlo.filters.memory_filter.MemoryFilter'
 # FILTER_CLASS = 'crawlo.filters.aioredis_filter.AioRedisFilter'  # 分布式去重
@@ -153,7 +169,13 @@ if REDIS_PASSWORD:
 else:
     REDIS_URL = f'redis://{REDIS_HOST}:{REDIS_PORT}/0'
 
-REDIS_KEY = f'{{project_name}}:fingerprint'
+# Redis key配置已移至各组件中，使用统一的命名规范
+# crawlo:{project_name}:filter:fingerprint (请求去重)
+# crawlo:{project_name}:item:fingerprint (数据项去重)
+# crawlo:{project_name}:queue:requests (请求队列)
+# crawlo:{project_name}:queue:processing (处理中队列)
+# crawlo:{project_name}:queue:failed (失败队列)
+
 REDIS_TTL = 0
 CLEANUP_FP = 0
 FILTER_DEBUG = True
@@ -176,24 +198,56 @@ MIDDLEWARES = [
 
 # ============================== 数据管道配置 ==============================
 
+# 数据处理管道（启用的存储方式）
 PIPELINES = [
-    # 根据运行模式自动选择默认去重管道
-    # 单机模式：crawlo.pipelines.MemoryDedupPipeline
-    # 分布式模式：crawlo.pipelines.RedisDedupPipeline
     'crawlo.pipelines.console_pipeline.ConsolePipeline',
     # '{{project_name}}.pipelines.DatabasePipeline',        # 自定义数据库管道
     # 'crawlo.pipelines.mysql_pipeline.AsyncmyMySQLPipeline',  # MySQL 存储
     # 'crawlo.pipelines.mongo_pipeline.MongoPipeline',      # MongoDB 存储
 ]
 
+# 根据运行模式自动配置默认去重管道
+if RUN_MODE == 'distributed':
+    # 分布式模式下添加Redis去重管道
+    PIPELINES.insert(0, DEFAULT_DEDUP_PIPELINE)
+else:
+    # 单机模式下添加内存去重管道
+    PIPELINES.insert(0, DEFAULT_DEDUP_PIPELINE)
+
 # ============================== 扩展组件 ==============================
 
 EXTENSIONS = [
     'crawlo.extension.log_interval.LogIntervalExtension',
     'crawlo.extension.log_stats.LogStats',
     'crawlo.extension.logging_extension.CustomLoggerExtension',
+    # 'crawlo.extension.memory_monitor.MemoryMonitorExtension',  # 内存监控
+    # 'crawlo.extension.request_recorder.RequestRecorderExtension',  # 请求记录
+    # 'crawlo.extension.performance_profiler.PerformanceProfilerExtension',  # 性能分析
+    # 'crawlo.extension.health_check.HealthCheckExtension',  # 健康检查
 ]
 
+# ============================== 扩展配置 ==============================
+
+# 内存监控扩展配置
+# MEMORY_MONITOR_ENABLED = True  # 是否启用内存监控
+# MEMORY_MONITOR_INTERVAL = 60  # 内存检查间隔（秒）
+# MEMORY_WARNING_THRESHOLD = 80.0  # 内存使用警告阈值（百分比）
+# MEMORY_CRITICAL_THRESHOLD = 90.0  # 内存使用严重阈值（百分比）
+
+# 请求记录扩展配置
+# REQUEST_RECORDER_ENABLED = True  # 是否启用请求记录
+# REQUEST_RECORDER_OUTPUT_DIR = 'requests_log'  # 请求记录输出目录
+# REQUEST_RECORDER_MAX_FILE_SIZE = 10 * 1024 * 1024  # 单个记录文件最大大小（字节）
+
+# 性能分析扩展配置
+# PERFORMANCE_PROFILER_ENABLED = True  # 是否启用性能分析
+# PERFORMANCE_PROFILER_OUTPUT_DIR = 'profiling'  # 性能分析输出目录
+# PERFORMANCE_PROFILER_INTERVAL = 300  # 定期保存分析结果间隔（秒）
+
+# 健康检查扩展配置
+# HEALTH_CHECK_ENABLED = True  # 是否启用健康检查
+# HEALTH_CHECK_INTERVAL = 60  # 健康检查间隔（秒）
+
 # ============================== 日志配置 ==============================
 
 LOG_LEVEL = 'INFO'
@@ -232,6 +286,28 @@ DEFAULT_REQUEST_HEADERS = {
     'Upgrade-Insecure-Requests': '1',
 }
 
+# ============================== 下载器优化配置 ==============================
+
+# 下载器健康检查
+DOWNLOADER_HEALTH_CHECK = True  # 是否启用下载器健康检查
+HEALTH_CHECK_INTERVAL = 60  # 健康检查间隔（秒）
+
+# 请求统计配置
+REQUEST_STATS_ENABLED = True  # 是否启用请求统计
+STATS_RESET_ON_START = False  # 启动时是否重置统计
+
+# HttpX 下载器专用配置
+HTTPX_HTTP2 = True  # 是否启用HTTP/2支持
+HTTPX_FOLLOW_REDIRECTS = True  # 是否自动跟随重定向
+
+# AioHttp 下载器专用配置
+AIOHTTP_AUTO_DECOMPRESS = True  # 是否自动解压响应
+AIOHTTP_FORCE_CLOSE = False  # 是否强制关闭连接
+
+# 通用优化配置
+CONNECTION_TTL_DNS_CACHE = 300  # DNS缓存TTL（秒）
+CONNECTION_KEEPALIVE_TIMEOUT = 15  # Keep-Alive超时（秒）
+
 # ============================== 开发与调试 ==============================
 
 # 开发模式配置