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

crawlo/templates/project/pipelines.py.tmpl

@@ -5,332 +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
         
-        if identifier in self.seen:
-            self.drop_count += 1
-            self.logger.debug(f"发现重复数据: {identifier} (已过滤{self.drop_count}个)")
-            raise DropItem(f"重复数据: {identifier}")
+        # 记录日志
+        self.logger.info(f"处理第 {self.item_count} 个数据项: {item['title']}")
         
-        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',
 # ]
 # 
-# 相关配置：
-# JSON_OUTPUT_DIR = 'output'          # JSON 文件输出目录
-# DATABASE_TYPE = 'mysql'             # 数据库类型: mysql/mongodb
-# MYSQL_TABLE = '{{project_name}}_data'  # MySQL 表名
+# 您可以根据需要添加更多管道，例如：
+# 1. 数据验证管道
+# 2. 去重管道
+# 3. 数据存储管道（数据库、文件等）
+# 4. 数据转换管道
+# 
+# 每个管道都应该实现 process_item 方法，
+# 可选实现 open_spider 和 close_spider 方法。
 # ======================== 使用说明 ========================

crawlo/templates/project/run.py.tmpl

@@ -10,6 +10,7 @@
     python run.py spider_name                     # 单机模式运行
     python run.py spider_name --distributed       # 分布式模式运行
     python run.py spider_name --env production    # 使用预设配置
+    python run.py all                             # 运行所有爬虫
 
 🔧 高级选项:
     python run.py spider_name --dry-run           # 干运行（不执行实际爬取）
@@ -50,6 +51,7 @@ def create_parser():
   python run.py my_spider --distributed      # 分布式模式
   python run.py my_spider --env production   # 生产环境配置
   python run.py spider1 spider2              # 运行多个爬虫
+  python run.py all                          # 运行所有爬虫
   python run.py my_spider --dry-run          # 测试模式
         """
     )
@@ -58,7 +60,7 @@ def create_parser():
     parser.add_argument(
         'spiders', 
         nargs='*',
-        help='要运行的爬虫名称（可指定多个）'
+        help='要运行的爬虫名称（可指定多个，"all"表示运行所有爬虫）'
     )
     
     # 运行模式选择
@@ -212,12 +214,23 @@ async def main():
         # 应用配置并启动
         process = CrawlerProcess(settings=config.to_dict())
         
-        # TODO: 在这里添加你的爬虫导入
-        # from {{project_name}}.spiders.example_spider import ExampleSpider
-        # spider_classes = {'example_spider': ExampleSpider}
-        
-        # 运行指定爬虫
-        await process.crawl(args.spiders)
+        # 检查是否要运行所有爬虫
+        if 'all' in [s.lower() for s in args.spiders]:
+            # 获取所有已注册的爬虫名称
+            spider_names = process.get_spider_names()
+            if not spider_names:
+                print("❌ 未找到任何爬虫")
+                print("💡 请确保:")
+                print("  • 爬虫定义在 'spiders/' 目录中")
+                print("  • 爬虫类有 'name' 属性")
+                return 1
+            
+            print(f"📋 找到 {len(spider_names)} 个爬虫: {', '.join(spider_names)}")
+            # 运行所有爬虫
+            await process.crawl(spider_names)
+        else:
+            # 运行指定爬虫
+            await process.crawl(args.spiders)
         
         print("\n✅ 所有爬虫执行完成")
         

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
@@ -120,6 +120,7 @@ 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_USE_BATCH = False  # 是否启用批量插入
 
 # MySQL 连接池
 MYSQL_FLUSH_INTERVAL = 5
@@ -129,10 +130,12 @@ MYSQL_ECHO = 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  # 是否启用批量插入
 
 # ============================== 去重过滤配置 ==============================
 
@@ -177,6 +180,9 @@ MIDDLEWARES = [
 # ============================== 数据管道配置 ==============================
 
 PIPELINES = [
+    # 根据运行模式自动选择默认去重管道
+    # 单机模式：crawlo.pipelines.MemoryDedupPipeline
+    # 分布式模式：crawlo.pipelines.RedisDedupPipeline
     'crawlo.pipelines.console_pipeline.ConsolePipeline',
     # '{{project_name}}.pipelines.DatabasePipeline',        # 自定义数据库管道
     # 'crawlo.pipelines.mysql_pipeline.AsyncmyMySQLPipeline',  # MySQL 存储
@@ -189,8 +195,34 @@ 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'

crawlo/templates/spider/spider.py.tmpl

@@ -139,40 +139,4 @@ class {{class_name}}(Spider):
         #     'publish_time': response.xpath('//time/@datetime').get(),
         # }
         
-        pass
-
-    def parse_error(self, failure):
-        """
-        处理请求失败的方法（可选）。
-        
-        当请求失败时会被调用。
-        """
-        self.logger.error(f'请求失败: {failure.request.url} - {failure.value}')
-        
-        # 可以选择重试或记录失败信息
-        # yield {
-        #     'error_url': failure.request.url,
-        #     'error_message': str(failure.value),
-        #     'error_type': failure.type.__name__,
-        # }
-
-    def spider_opened(self, spider):
-        """
-        爬虫启动时的回调方法（可选）。
-        """
-        self.logger.info(f'爬虫 {spider.name} 已启动')
-        
-        # 初始化操作，例如连接数据库、加载配置等
-        # self.database = self.connect_database()
-        # self.cookies = self.load_cookies()
-
-    def spider_closed(self, spider, reason):
-        """
-        爬虫关闭时的回调方法（可选）。
-        """
-        self.logger.info(f'爬虫 {spider.name} 已关闭，原因: {reason}')
-        
-        # 清理操作，例如关闭数据库连接、保存状态等
-        # if hasattr(self, 'database'):
-        #     self.database.close()
-        # self.save_cookies()
+        pass