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

crawlo/templates/project/middlewares.py.tmpl

@@ -1,87 +1,111 @@
-# -*- coding: UTF-8 -*-
-"""
-{{project_name}}.middlewares
-============================
-自定义中间件，用于在请求/响应/异常处理过程中插入自定义逻辑。
-"""
-
-import random
-from crawlo import Request, Response
-from crawlo.utils.log import get_logger
-from crawlo.exceptions import IgnoreRequest
-
-
-class RandomUserAgentMiddleware:
-    """随机 User-Agent 中间件。"""
-    
-    def __init__(self):
-        self.logger = get_logger(self.__class__.__name__)
-        self.user_agents = [
-            'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36',
-            'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36',
-            'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:135.0) Gecko/20100101 Firefox/135.0',
-            'Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:135.0) Gecko/20100101 Firefox/135.0',
-        ]
-    
-    def process_request(self, request, spider):
-        if 'User-Agent' not in request.headers:
-            ua = random.choice(self.user_agents)
-            request.headers['User-Agent'] = ua
-        return None
-
-
-class CustomDownloaderMiddleware:
-    """自定义下载器中间件示例。"""
-
-    def __init__(self):
-        self.logger = get_logger(self.__class__.__name__)
-
-    def process_request(self, request, spider):
-        """在请求被下载器执行前调用。"""
-        # 示例：添加自定义请求头
-        # request.headers['Custom-Header'] = 'Custom-Value'
-        # 示例：设置代理
-        # request.meta['proxy'] = 'http://proxy.example.com:8080'
-        return None
-
-    def process_response(self, request, response, spider):
-        """在响应被 Spider 处理前调用。"""
-        # 示例：检查响应状态
-        if response.status_code == 403:
-            self.logger.warning(f"访问被拒绝: {request.url}")
-        return response
-
-    def process_exception(self, request, exception, spider):
-        """在下载或处理过程中发生异常时调用。"""
-        self.logger.error(f"请求异常: {request.url} - {exception}")
-        return None
-
-
-class CustomSpiderMiddleware:
-    """
-Spider 中间件示例。
-    """
-
-    def __init__(self):
-        self.logger = get_logger(self.__class__.__name__)
-
-    def process_spider_input(self, response, spider):
-        """在 Spider 的 parse 方法被调用前调用。"""
-        # 可以用来验证响应
-        pass
-
-    def process_spider_output(self, response, result, spider):
-        """在 Spider 的 parse 方法返回结果后调用。"""
-        # 可以用来过滤或修改结果
-        for item in result:
-            yield item
-
-    def process_spider_exception(self, response, exception, spider):
-        """在 Spider 的 parse 方法抛出异常时调用。"""
-        self.logger.error(f"Spider 异常: {response.url} - {exception}")
-        pass
-
-    def process_start_requests(self, start_requests, spider):
-        """在 Spider 的 start_requests 生成器被消费时调用。"""
-        for request in start_requests:
-            yield request
+# -*- coding: UTF-8 -*-
+"""
+{{project_name}}.middlewares
+============================
+自定义中间件，用于在请求/响应/异常处理过程中插入自定义逻辑。
+
+这是一个简单的示例中间件，您可以根据需要添加更多中间件。
+"""
+
+import random
+from crawlo import Request, Response
+from crawlo.utils.log import get_logger
+from crawlo.exceptions import IgnoreRequest
+
+
+class ExampleMiddleware:
+    """
+    示例中间件，演示如何处理请求、响应和异常。
+    
+    此中间件会：
+    1. 为请求添加随机 User-Agent
+    2. 记录请求和响应信息
+    3. 处理异常情况
+    """
+    
+    def __init__(self):
+        self.logger = get_logger(self.__class__.__name__)
+        self.user_agents = [
+            'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36',
+            'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36',
+            'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:135.0) Gecko/20100101 Firefox/135.0',
+            'Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:135.0) Gecko/20100101 Firefox/135.0',
+        ]
+
+    def process_request(self, request, spider):
+        """
+        在请求被下载器执行前调用。
+        
+        Args:
+            request: 请求对象
+            spider: 爬虫实例
+            
+        Returns:
+            None: 继续处理请求
+            Response: 返回响应对象（短路处理）
+            Request: 返回新请求对象（替换原请求）
+        """
+        # 为请求添加随机 User-Agent
+        if 'User-Agent' not in request.headers:
+            ua = random.choice(self.user_agents)
+            request.headers['User-Agent'] = ua
+            self.logger.debug(f"为请求 {request.url} 设置 User-Agent: {ua[:50]}...")
+        
+        return None
+
+    def process_response(self, request, response, spider):
+        """
+        在响应被 Spider 处理前调用。
+        
+        Args:
+            request: 原始请求对象
+            response: 响应对象
+            spider: 爬虫实例
+            
+        Returns:
+            Response: 处理后的响应对象
+        """
+        # 记录响应信息
+        self.logger.info(f"收到响应: {request.url} - 状态码: {response.status_code}")
+        
+        # 可以在这里处理特殊状态码
+        if response.status_code == 403:
+            self.logger.warning(f"访问被拒绝: {request.url}")
+        
+        return response
+
+    def process_exception(self, request, exception, spider):
+        """
+        在下载或处理过程中发生异常时调用。
+        
+        Args:
+            request: 请求对象
+            exception: 异常对象
+            spider: 爬虫实例
+            
+        Returns:
+            None: 异常将继续传播
+            Response: 返回响应对象（处理异常）
+            Request: 返回新请求对象（重试请求）
+        """
+        self.logger.error(f"请求异常: {request.url} - {exception}")
+        return None
+
+
+# ======================== 使用说明 ========================
+# 
+# 在 settings.py 中启用中间件：
+# MIDDLEWARES = [
+#     '{{project_name}}.middlewares.ExampleMiddleware',
+# ]
+# 
+# 您可以根据需要添加更多中间件，例如：
+# 1. 请求处理中间件（修改请求头、设置代理等）
+# 2. 响应处理中间件（解析、过滤等）
+# 3. 异常处理中间件（重试、记录等）
+# 
+# 每个中间件可以实现以下方法：
+# - process_request: 处理请求
+# - process_response: 处理响应
+# - process_exception: 处理异常
+# ======================== 使用说明 ========================

crawlo/templates/project/pipelines.py.tmpl

@@ -1,342 +1,98 @@
-# -*- coding: UTF-8 -*-
-"""
-{{project_name}}.pipelines
-==========================
-数据管道，用于处理 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:
-    """
-    数据验证管道。
-    
-    验证必要字段是否存在，过滤无效数据。
-    """
-    
-    def __init__(self):
-        self.logger = get_logger(self.__class__.__name__)
-        # 必要字段列表（根据实际需要修改）
-        self.required_fields = ['title', 'url']
-    
-    def process_item(self, item, spider):
-        """验证数据项。"""
-        # 检查必要字段
-        for field in self.required_fields:
-            if not item.get(field):
-                raise DropItem(f"缺少必要字段: {field}")
-        
-        # 数据清理
-        if 'title' in item:
-            item['title'] = str(item['title']).strip()
-        
-        # 添加时间戳
-        item['crawled_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
-        
-        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
-
-
-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;
-        """
-        
-        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
-        """
-        
-        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("数据库连接已关闭")
-
-
-# ======================== 使用说明 ========================
-# 
-# 在 settings.py 中启用管道：
-# PIPELINES = [
-#     '{{project_name}}.pipelines.ValidationPipeline',      # 数据验证
-#     '{{project_name}}.pipelines.DuplicatesPipeline',       # 去重过滤
-#     '{{project_name}}.pipelines.PrintItemPipeline',        # 打印输出（调试）
-#     '{{project_name}}.pipelines.JsonFilesPipeline',        # JSON 文件存储
-#     '{{project_name}}.pipelines.DatabasePipeline',         # 数据库存储
-# ]
-# 
-# Crawlo 框架提供了多种内置的去重管道：
-# 1. crawlo.pipelines.MemoryDedupPipeline    - 内存去重（单机模式默认）
-# 2. crawlo.pipelines.RedisDedupPipeline     - Redis去重（分布式模式默认）
-# 3. crawlo.pipelines.BloomDedupPipeline     - Bloom Filter去重（大规模数据）
-# 4. crawlo.pipelines.DatabaseDedupPipeline  - 数据库去重（持久化）
-# 
-# 相关配置：
-# JSON_OUTPUT_DIR = 'output'          # JSON 文件输出目录
-# DATABASE_TYPE = 'mysql'             # 数据库类型: mysql/mongodb
-# MYSQL_TABLE = '{{project_name}}_data'  # MySQL 表名
+# -*- coding: UTF-8 -*-
+"""
+{{project_name}}.pipelines
+==========================
+数据管道，用于处理 Spider 返回的 Item。
+例如：清理、验证、去重、保存到数据库等。
+
+这是一个简单的示例管道，您可以根据需要添加更多管道。
+"""
+
+import json
+from datetime import datetime
+from crawlo.exceptions import DropItem
+from crawlo.utils.log import get_logger
+
+
+class ExamplePipeline:
+    """
+    示例管道，演示如何处理数据项。
+    
+    此管道会：
+    1. 验证必要字段
+    2. 清理数据
+    3. 添加时间戳
+    4. 记录处理日志
+    """
+    
+    def __init__(self):
+        self.logger = get_logger(self.__class__.__name__)
+        self.item_count = 0
+
+    def process_item(self, item, spider):
+        """
+        处理数据项。
+        
+        Args:
+            item: 要处理的数据项
+            spider: 爬虫实例
+            
+        Returns:
+            处理后的数据项
+            
+        Raises:
+            DropItem: 如果数据项无效则抛出此异常
+        """
+        # 验证必要字段
+        if not item.get('title') or not item.get('url'):
+            raise DropItem("缺少必要字段: title 或 url")
+        
+        # 数据清理
+        item['title'] = str(item['title']).strip()
+        
+        # 添加处理时间戳
+        item['processed_at'] = datetime.now().isoformat()
+        
+        # 计数器
+        self.item_count += 1
+        
+        # 记录日志
+        self.logger.info(f"处理第 {self.item_count} 个数据项: {item['title']}")
+        
+        return item
+
+    def open_spider(self, spider):
+        """
+        爬虫启动时调用。
+        
+        Args:
+            spider: 爬虫实例
+        """
+        self.logger.info(f"管道已启动，准备处理爬虫 '{spider.name}' 的数据")
+
+    def close_spider(self, spider):
+        """
+        爬虫关闭时调用。
+        
+        Args:
+            spider: 爬虫实例
+        """
+        self.logger.info(f"管道已关闭，共处理了 {self.item_count} 个数据项")
+
+
+# ======================== 使用说明 ========================
+# 
+# 在 settings.py 中启用管道：
+# PIPELINES = [
+#     '{{project_name}}.pipelines.ExamplePipeline',
+# ]
+# 
+# 您可以根据需要添加更多管道，例如：
+# 1. 数据验证管道
+# 2. 去重管道
+# 3. 数据存储管道（数据库、文件等）
+# 4. 数据转换管道
+# 
+# 每个管道都应该实现 process_item 方法，
+# 可选实现 open_spider 和 close_spider 方法。
 # ======================== 使用说明 ========================