crawlo 1.3.2__py3-none-any.whl → 1.3.4__py3-none-any.whl

tests/baidu_test.py

@@ -0,0 +1,60 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+百度网站测试脚本
+测试Crawlo框架的基本功能
+"""
+import asyncio
+import sys
+import os
+
+# 添加项目根目录到Python路径
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..'))
+
+from crawlo import Spider, Request
+from crawlo.crawler import CrawlerProcess
+
+
+class BaiduSpider(Spider):
+    name = 'baidu_test'
+    
+    def start_requests(self):
+        # 测试百度首页
+        yield Request('https://www.baidu.com/', callback=self.parse_home)
+    
+    def parse_home(self, response):
+        self.logger.info(f"成功访问百度首页: {response.url}")
+        self.logger.info(f"响应状态码: {response.status_code}")
+        self.logger.info(f"页面标题: {response.xpath('//title/text()').get()}")
+        
+        # 测试提取一些链接
+        links = response.xpath('//a/@href').getall()[:5]  # 只取前5个链接
+        self.logger.info(f"提取到链接数量: {len(links)}")
+        
+        # 可以选择跟进一些链接进行测试
+        for i, link in enumerate(links):
+            if i >= 2:  # 只跟进前2个链接
+                break
+            # 确保链接是完整的URL
+            if link.startswith('http'):
+                yield Request(link, callback=self.parse_link)
+    
+    def parse_link(self, response):
+        self.logger.info(f"访问链接: {response.url}")
+        self.logger.info(f"响应状态码: {response.status_code}")
+
+
+async def main():
+    # 创建爬虫进程
+    process = CrawlerProcess(settings={
+        'CONCURRENCY': 4,  # 设置并发数
+        'DOWNLOAD_DELAY': 1,  # 设置下载延迟
+        'LOG_LEVEL': 'INFO',  # 设置日志级别
+    })
+    
+    # 运行爬虫
+    await process.crawl(BaiduSpider)
+
+
+if __name__ == '__main__':
+    asyncio.run(main())

tests/comprehensive_framework_test.py

@@ -0,0 +1,213 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+综合框架测试脚本
+全面测试框架的所有核心功能
+"""
+
+import sys
+import os
+import asyncio
+import time
+
+# 添加项目根目录到Python路径
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..'))
+
+from crawlo.spider import Spider
+from crawlo import Request
+
+
+class TestSpider(Spider):
+    """测试爬虫"""
+    name = 'framework_test_spider'
+    
+    def start_requests(self):
+        """发起测试请求"""
+        # 生成一些测试请求
+        for i in range(3):
+            yield Request(f'https://httpbin.org/get?page={i}', callback=self.parse)
+    
+    def parse(self, response):
+        """解析响应"""
+        print(f"成功获取响应: {response.url}")
+        print(f"状态码: {response.status_code}")
+        return []
+
+
+async def test_framework_initialization():
+    """测试框架初始化"""
+    print("测试框架初始化...")
+    
+    from crawlo.initialization import initialize_framework
+    
+    # 测试默认配置
+    settings = initialize_framework()
+    print(f"默认配置 - RUN_MODE: {settings.get('RUN_MODE')}")
+    print(f"默认配置 - QUEUE_TYPE: {settings.get('QUEUE_TYPE')}")
+    
+    # 测试自定义配置
+    custom_settings = {
+        'PROJECT_NAME': 'framework_test',
+        'SCHEDULER_MAX_QUEUE_SIZE': 50
+    }
+    
+    settings = initialize_framework(custom_settings)
+    print(f"自定义配置 - PROJECT_NAME: {settings.get('PROJECT_NAME')}")
+    print(f"自定义配置 - SCHEDULER_MAX_QUEUE_SIZE: {settings.get('SCHEDULER_MAX_QUEUE_SIZE')}")
+
+
+async def test_crawler_execution():
+    """测试爬虫执行"""
+    print("测试爬虫执行...")
+    
+    from crawlo.initialization import initialize_framework
+    from crawlo.crawler import CrawlerProcess
+    
+    # 初始化框架
+    settings = initialize_framework({
+        'PROJECT_NAME': 'framework_test'
+    })
+    
+    # 创建爬虫进程
+    process = CrawlerProcess(settings=settings)
+    
+    # 运行爬虫
+    await process.crawl(TestSpider)
+
+
+async def test_queue_system():
+    """测试队列系统"""
+    print("测试队列系统...")
+    
+    from crawlo.queue.queue_manager import QueueConfig, QueueManager
+    from crawlo import Request
+    
+    # 创建小队列配置进行测试
+    queue_config = QueueConfig(
+        queue_type='memory',
+        max_queue_size=5
+    )
+    
+    # 创建队列管理器
+    queue_manager = QueueManager(queue_config)
+    await queue_manager.initialize()
+    
+    # 测试添加请求
+    print("添加请求到队列...")
+    for i in range(3):
+        request = Request(f'https://example.com/test{i}')
+        await queue_manager.put(request)
+        print(f"添加请求 {i}")
+    
+    # 测试获取请求
+    print("从队列获取请求...")
+    for i in range(3):
+        request = await queue_manager.get(timeout=1.0)
+        if request:
+            print(f"获取请求: {request.url}")
+    
+    # 关闭队列
+    await queue_manager.close()
+
+
+async def test_spider_registry():
+    """测试爬虫注册系统"""
+    print("测试爬虫注册系统...")
+    
+    from crawlo.spider import get_global_spider_registry, is_spider_registered, get_spider_names
+    
+    # 检查测试爬虫是否已注册
+    spider_name = TestSpider.name
+    is_registered = is_spider_registered(spider_name)
+    print(f"爬虫 '{spider_name}' 是否已注册: {is_registered}")
+    
+    # 获取所有注册的爬虫名称
+    spider_names = get_spider_names()
+    print(f"所有注册的爬虫: {spider_names}")
+
+
+async def test_logging_system():
+    """测试日志系统"""
+    print("测试日志系统...")
+    
+    from crawlo.logging import get_logger, configure_logging
+    
+    # 配置日志系统
+    configure_logging({
+        'LOG_LEVEL': 'INFO',
+        'LOG_FILE': 'logs/test_framework.log'
+    })
+    
+    # 获取logger并记录日志
+    logger = get_logger('test_framework')
+    logger.info("这是测试日志信息")
+    logger.warning("这是测试警告信息")
+    logger.error("这是测试错误信息")
+
+
+async def test_settings_system():
+    """测试配置系统"""
+    print("测试配置系统...")
+    
+    from crawlo.settings.setting_manager import SettingManager
+    
+    # 创建配置管理器
+    settings = SettingManager()
+    
+    # 测试配置项
+    settings.set('TEST_KEY', 'test_value')
+    test_value = settings.get('TEST_KEY')
+    print(f"配置项 TEST_KEY 的值: {test_value}")
+    
+    # 测试不同类型的配置项
+    settings.set('TEST_INT', 42)
+    test_int = settings.get_int('TEST_INT')
+    print(f"配置项 TEST_INT 的值: {test_int}")
+    
+    settings.set('TEST_BOOL', True)
+    test_bool = settings.get_bool('TEST_BOOL')
+    print(f"配置项 TEST_BOOL 的值: {test_bool}")
+
+
+async def main():
+    """主函数"""
+    print("开始综合框架测试...")
+    print("=" * 50)
+    
+    try:
+        # 1. 测试框架初始化
+        await test_framework_initialization()
+        print()
+        
+        # 2. 测试配置系统
+        await test_settings_system()
+        print()
+        
+        # 3. 测试日志系统
+        await test_logging_system()
+        print()
+        
+        # 4. 测试队列系统
+        await test_queue_system()
+        print()
+        
+        # 5. 测试爬虫注册系统
+        await test_spider_registry()
+        print()
+        
+        # 6. 测试爬虫执行
+        await test_crawler_execution()
+        print()
+        
+        print("=" * 50)
+        print("所有测试通过！框架工作正常。")
+        
+    except Exception as e:
+        print("=" * 50)
+        print(f"测试失败: {e}")
+        import traceback
+        traceback.print_exc()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

tests/comprehensive_test.py

@@ -0,0 +1,82 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+综合测试脚本
+测试Crawlo框架的所有优化功能
+"""
+import asyncio
+import sys
+import os
+
+# 添加项目根目录到Python路径
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..'))
+
+from crawlo import Spider, Request
+from crawlo.crawler import CrawlerProcess
+
+
+class ComprehensiveSpider(Spider):
+    name = 'comprehensive_test'
+    
+    def start_requests(self):
+        # 测试多个URL
+        urls = [
+            'https://www.baidu.com/',
+            'https://www.baidu.com/s?wd=python',
+            'https://www.baidu.com/s?wd=爬虫',
+            'https://www.baidu.com/s?wd=框架',
+            'https://www.baidu.com/s?wd=异步',
+        ]
+        
+        for i, url in enumerate(urls):
+            # 设置不同的优先级
+            priority = -i  # 负数表示优先级，数值越小优先级越高
+            yield Request(url, callback=self.parse, priority=priority)
+    
+    def parse(self, response):
+        self.logger.info(f"访问URL: {response.url}")
+        self.logger.info(f"响应状态码: {response.status_code}")
+        self.logger.info(f"页面标题: {response.xpath('//title/text()').get()}")
+        
+        # 提取一些链接用于进一步测试
+        links = response.xpath('//a/@href').getall()[:3]  # 只取前3个链接
+        
+        # 跟进链接，设置不同的深度
+        for link in links:
+            if link.startswith('http'):
+                # 创建新的请求，增加深度
+                meta = response.meta.copy()
+                meta['depth'] = meta.get('depth', 0) + 1
+                yield Request(link, callback=self.parse_link, meta=meta)
+    
+    def parse_link(self, response):
+        self.logger.info(f"跟进链接: {response.url}")
+        self.logger.info(f"响应状态码: {response.status_code}")
+        self.logger.info(f"页面深度: {response.meta.get('depth', 0)}")
+
+
+async def main():
+    # 创建爬虫进程
+    process = CrawlerProcess(settings={
+        'CONCURRENCY': 4,  # 设置并发数
+        'DOWNLOAD_DELAY': 0.5,  # 设置下载延迟
+        'LOG_LEVEL': 'INFO',  # 设置日志级别
+        'SCHEDULER_MAX_QUEUE_SIZE': 100,  # 设置队列最大大小
+    })
+    
+    # 运行爬虫
+    await process.crawl(ComprehensiveSpider)
+    
+    # 输出统计信息
+    if hasattr(process, 'get_metrics'):
+        metrics = process.get_metrics()
+        print(f"\n=== 爬虫统计信息 ===")
+        print(f"总执行时间: {metrics.get('total_duration', 0):.2f}秒")
+        print(f"总请求数: {metrics.get('total_requests', 0)}")
+        print(f"成功请求数: {metrics.get('total_success', 0)}")
+        print(f"错误请求数: {metrics.get('total_errors', 0)}")
+        print(f"平均成功率: {metrics.get('average_success_rate', 0):.2f}%")
+
+
+if __name__ == '__main__':
+    asyncio.run(main())

tests/comprehensive_testing_summary.md

@@ -0,0 +1,187 @@
+# 综合测试工作总结报告
+
+## 概述
+
+本次测试工作旨在为Crawlo框架中未充分测试的功能模块创建完整的测试用例，以提高框架的稳定性和可靠性。通过系统性的分析和测试，我们成功为多个核心组件创建了全面的测试覆盖。
+
+## 已完成的测试工作
+
+### 1. 工厂模式相关模块测试
+
+**测试文件**: `tests/test_factories.py`
+
+**覆盖组件**:
+- `ComponentRegistry` - 组件注册表
+- `ComponentFactory` - 组件工厂基类
+- `DefaultComponentFactory` - 默认组件工厂
+- `CrawlerComponentFactory` - Crawler组件工厂
+
+**测试内容**:
+- 组件规范的创建和注册
+- 默认组件工厂的单例模式支持
+- 组件注册表的注册和创建功能
+- 全局组件注册表的使用
+- Crawler组件工厂的依赖检查和创建功能
+
+**测试结果**: 所有10个测试用例全部通过
+
+### 2. 批处理工具测试
+
+**测试文件**: `tests/test_batch_processor.py`
+
+**覆盖组件**:
+- `BatchProcessor` - 批处理处理器
+- `RedisBatchProcessor` - Redis批处理处理器
+- `batch_process` - 便捷批处理函数
+
+**测试内容**:
+- 批处理器的初始化和配置
+- 同步和异步批处理功能
+- 分批处理大量数据的能力
+- 异常处理和错误恢复
+- Redis批处理器的批量设置、获取和删除操作
+- 便捷批处理函数的使用
+
+**测试结果**: 所有12个测试用例全部通过
+
+### 3. 受控爬虫混入类测试
+
+**测试文件**: `tests/test_controlled_spider_mixin.py`
+
+**覆盖组件**:
+- `ControlledRequestMixin` - 受控请求生成混入类
+- `AsyncControlledRequestMixin` - 异步受控请求混入类
+
+**测试内容**:
+- 混入类的初始化和配置
+- 配置参数的修改和验证
+- 生成统计信息的获取
+
+**测试结果**: 所有5个测试用例全部通过
+
+### 4. 大规模配置工具测试
+
+**测试文件**: `tests/test_large_scale_config.py`
+
+**覆盖组件**:
+- `LargeScaleConfig` - 大规模爬虫配置类
+- `apply_large_scale_config` - 应用大规模配置函数
+
+**测试内容**:
+- 保守配置、平衡配置、激进配置和内存优化配置的验证
+- 不同并发数下的配置参数计算
+- 配置应用功能的测试
+- 无效配置类型的错误处理
+
+**测试结果**: 所有6个测试用例全部通过
+
+### 5. 大规模爬虫辅助工具测试
+
+**测试文件**: `tests/test_large_scale_helper.py`
+
+**覆盖组件**:
+- `LargeScaleHelper` - 大规模爬虫辅助类
+- `ProgressManager` - 进度管理器
+- `MemoryOptimizer` - 内存优化器
+- `DataSourceAdapter` - 数据源适配器
+- `LargeScaleSpiderMixin` - 大规模爬虫混入类
+
+**测试内容**:
+- 批次迭代器与不同数据源的兼容性
+- 进度保存和加载功能
+- 内存优化器的基本功能
+- 文件数据源适配器的使用
+- 混入类的初始化和属性验证
+
+**测试结果**: 所有13个测试用例全部通过
+
+### 6. 增强错误处理工具综合测试
+
+**测试文件**: `tests/test_enhanced_error_handler_comprehensive.py`
+
+**覆盖组件**:
+- `ErrorContext` - 错误上下文信息
+- `DetailedException` - 详细异常基类
+- `EnhancedErrorHandler` - 增强错误处理器
+- `handle_exception` 装饰器
+
+**测试内容**:
+- 错误上下文的创建和字符串表示
+- 详细异常的初始化和信息封装
+- 增强错误处理器的错误处理、安全调用和历史记录功能
+- 异常处理装饰器对同步和异步函数的支持
+- 详细异常与装饰器的集成使用
+
+**测试结果**: 所有15个测试用例全部通过
+
+## 总体测试统计
+
+| 模块 | 测试文件 | 测试用例数 | 通过数 | 通过率 |
+|------|----------|------------|--------|--------|
+| 工厂模式 | test_factories.py | 10 | 10 | 100% |
+| 批处理工具 | test_batch_processor.py | 12 | 12 | 100% |
+| 受控爬虫混入类 | test_controlled_spider_mixin.py | 5 | 5 | 100% |
+| 大规模配置工具 | test_large_scale_config.py | 6 | 6 | 100% |
+| 大规模爬虫辅助工具 | test_large_scale_helper.py | 13 | 13 | 100% |
+| 增强错误处理工具 | test_enhanced_error_handler_comprehensive.py | 15 | 15 | 100% |
+| **总计** | **6个文件** | **61** | **61** | **100%** |
+
+## 未完成的测试工作
+
+### 性能监控工具测试
+
+**模块路径**: `crawlo/utils/performance_monitor.py`
+
+**问题**: 依赖psutil模块，当前环境中未安装
+
+**建议**: 在安装psutil模块后，运行现有的测试文件 `tests/test_performance_monitor.py` 来验证性能监控工具的功能。
+
+## 测试质量评估
+
+### 代码覆盖率
+
+通过本次测试工作，我们为以下核心组件提供了全面的测试覆盖：
+
+1. **工厂模式**: 框架的核心组件创建机制
+2. **批处理工具**: 大规模数据处理的关键组件
+3. **受控爬虫混入类**: 解决大量请求生成时并发控制问题的组件
+4. **大规模配置工具**: 针对大规模爬取场景的配置管理组件
+5. **大规模爬虫辅助工具**: 处理大规模爬取场景的辅助组件
+6. **增强错误处理工具**: 系统稳定性的关键组件
+
+### 测试类型覆盖
+
+我们的测试涵盖了以下多个方面：
+
+1. **单元测试**: 针对每个类的方法进行独立测试
+2. **集成测试**: 测试模块间的协作
+3. **异常处理测试**: 验证边界条件和异常情况
+4. **配置测试**: 测试不同配置参数的有效性
+5. **mock测试**: 使用mock对象模拟外部依赖
+
+## 建议和后续工作
+
+### 1. 环境完善
+
+建议安装psutil模块以完成性能监控工具的测试：
+```bash
+pip install psutil
+```
+
+### 2. 持续集成
+
+建议将这些测试用例集成到持续集成(CI)流程中，确保每次代码变更都能自动运行测试。
+
+### 3. 性能测试
+
+建议为批处理工具和大规模处理工具添加性能测试，验证其在实际使用中的性能表现。
+
+### 4. 集成测试扩展
+
+建议创建更多的集成测试，验证这些组件在真实爬虫场景中的协同工作能力。
+
+## 结论
+
+通过本次系统性的测试工作，我们成功为Crawlo框架的多个核心组件创建了全面的测试覆盖，显著提高了框架的稳定性和可靠性。这些测试用例不仅验证了现有功能的正确性，也为未来的功能扩展和重构提供了安全保障。
+
+建议团队继续维护和完善这些测试用例，确保框架的长期健康发展。

tests/debug_configure.py

@@ -0,0 +1,70 @@
+#!/usr/bin/env python
+# -*- coding: UTF-8 -*-
+"""
+逐步调试LoggerManager.configure
+"""
+import sys
+import os
+sys.path.insert(0, '/')
+
+from crawlo.utils.log import LoggerManager
+
+print("=== 逐步调试LoggerManager.configure ===")
+
+print("1. 检查初始状态")
+print(f"   _early_initialized: {LoggerManager._early_initialized}")
+print(f"   _configured: {LoggerManager._configured}")
+
+print("2. 调用early_initialize")
+LoggerManager.early_initialize()
+print(f"   _early_initialized: {LoggerManager._early_initialized}")
+
+print("3. 进入configure - 开始")
+# 模拟configure方法的各个步骤
+with LoggerManager._config_lock:
+    print("   获得锁")
+    
+    if LoggerManager._configured:
+        print("   已配置，直接返回")
+    else:
+        print("   开始配置...")
+        
+        # 更新状态
+        print("   设置_log_state")
+        from crawlo.utils.log import _log_state
+        _log_state['current_step'] = 'basic_setup'
+        
+        print("   处理参数")
+        kwargs = {'LOG_LEVEL': 'INFO', 'LOG_FILE': 'test.log'}
+        get_val = lambda k, d=None: kwargs.get(k, d)
+        
+        filename = get_val('LOG_FILE')
+        level = get_val('LOG_LEVEL', None)
+        if level is None:
+            level = 'INFO'
+        
+        print(f"     filename: {filename}")
+        print(f"     level: {level}")
+        
+        print("   设置默认值")
+        LoggerManager._default_filename = filename
+        LoggerManager._default_level = LoggerManager._to_level(level)
+        LoggerManager._default_file_level = LoggerManager._to_level(level)
+        LoggerManager._default_console_level = LoggerManager._default_level
+        
+        print("   清空缓存")
+        LoggerManager.logger_cache.clear()
+        
+        print("   设置已配置状态")
+        LoggerManager._configured = True
+        _log_state['current_step'] = 'full_config'
+        
+        print("   配置完成")
+
+print("4. 测试创建logger")
+from crawlo.utils.log import get_logger
+logger = get_logger('test')
+print(f"   Logger: {logger}")
+print(f"   Handlers: {len(logger.handlers)}")
+
+print("=== 调试完成 ===")

tests/debug_framework_logger.py

@@ -0,0 +1,85 @@
+#!/usr/bin/env python
+# -*- coding: UTF-8 -*-
+"""
+调试框架logger配置
+"""
+import sys
+import os
+sys.path.insert(0, '/')
+
+from crawlo.core.framework_initializer import initialize_framework, get_framework_initializer
+from crawlo.utils.log import get_logger, LoggerManager
+import logging
+
+def debug_framework_logger():
+    print("=== 调试框架logger配置 ===")
+    
+    # 1. 初始化框架，模拟ofweek_standalone的配置
+    print("1. 初始化框架...")
+    custom_settings = {
+        'LOG_LEVEL': 'INFO',
+        'LOG_FILE': 'logs/debug_framework.log',
+        'PROJECT_NAME': 'debug_test',
+        'RUN_MODE': 'standalone'
+    }
+    
+    # 确保日志目录存在
+    os.makedirs('../logs', exist_ok=True)
+    
+    settings = initialize_framework(custom_settings)
+    print(f"   LOG_LEVEL: {settings.get('LOG_LEVEL')}")
+    print(f"   LOG_FILE: {settings.get('LOG_FILE')}")
+    
+    # 2. 获取框架初始化管理器
+    init_manager = get_framework_initializer()
+    print(f"   框架是否就绪: {init_manager.is_ready}")
+    print(f"   初始化阶段: {init_manager.phase}")
+    
+    # 3. 测试框架logger
+    framework_logger = init_manager.logger
+    print(f"   框架logger: {framework_logger}")
+    if framework_logger:
+        print(f"     名称: {framework_logger.name}")
+        print(f"     级别: {framework_logger.level} ({logging.getLevelName(framework_logger.level)})")
+        print(f"     处理器数量: {len(framework_logger.handlers)}")
+        
+        for i, handler in enumerate(framework_logger.handlers):
+            handler_type = type(handler).__name__
+            handler_level = handler.level
+            print(f"       处理器{i}: {handler_type}, 级别: {handler_level} ({logging.getLevelName(handler_level)})")
+            if hasattr(handler, 'baseFilename'):
+                print(f"         文件: {handler.baseFilename}")
+    
+    # 4. 手动创建一个crawlo.framework logger对比
+    manual_logger = get_logger('crawlo.framework')
+    print(f"   手动创建的logger: {manual_logger}")
+    if manual_logger:
+        print(f"     名称: {manual_logger.name}")
+        print(f"     级别: {manual_logger.level} ({logging.getLevelName(manual_logger.level)})")
+        print(f"     处理器数量: {len(manual_logger.handlers)}")
+        
+        for i, handler in enumerate(manual_logger.handlers):
+            handler_type = type(handler).__name__
+            handler_level = handler.level
+            print(f"       处理器{i}: {handler_type}, 级别: {handler_level} ({logging.getLevelName(handler_level)})")
+            if hasattr(handler, 'baseFilename'):
+                print(f"         文件: {handler.baseFilename}")
+    
+    # 5. 测试日志输出
+    print("2. 测试日志输出...")
+    
+    if framework_logger:
+        framework_logger.info("这是框架logger测试消息 - INFO级别")
+        framework_logger.debug("这是框架logger测试消息 - DEBUG级别")
+    
+    if manual_logger:
+        manual_logger.info("这是手动logger测试消息 - INFO级别")
+        manual_logger.debug("这是手动logger测试消息 - DEBUG级别")
+    
+    # 6. 检查是否同一个实例
+    print(f"3. 是否同一实例: {framework_logger is manual_logger}")
+    
+    print("=== 调试完成 ===")
+
+if __name__ == "__main__":
+    debug_framework_logger()