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

crawlo/extension/performance_profiler.py

@@ -1,134 +1,134 @@
-#!/usr/bin/python
-# -*- coding:UTF-8 -*-
-import io
-import os
-import pstats
-import asyncio
-import cProfile
-from typing import Any, Optional
-
-from crawlo.utils.log import get_logger
-from crawlo.utils.error_handler import ErrorHandler
-from crawlo.event import spider_opened, spider_closed
-
-
-class PerformanceProfilerExtension:
-    """
-    性能分析扩展
-    在爬虫运行期间进行性能分析，帮助优化爬虫性能
-    """
-
-    def __init__(self, crawler: Any):
-        self.settings = crawler.settings
-        self.logger = get_logger(self.__class__.__name__, crawler.settings.get('LOG_LEVEL'))
-        self.error_handler = ErrorHandler(self.__class__.__name__, crawler.settings.get('LOG_LEVEL'))
-        
-        # 获取配置参数
-        self.enabled = self.settings.get_bool('PERFORMANCE_PROFILER_ENABLED', False)
-        self.output_dir = self.settings.get('PERFORMANCE_PROFILER_OUTPUT_DIR', 'profiling')
-        self.interval = self.settings.get_int('PERFORMANCE_PROFILER_INTERVAL', 300)  # 默认5分钟
-        
-        self.profiler: Optional[cProfile.Profile] = None
-        self.task: Optional[asyncio.Task] = None
-        
-        # 创建输出目录
-        if self.enabled:
-            os.makedirs(self.output_dir, exist_ok=True)
-
-    @classmethod
-    def create_instance(cls, crawler: Any) -> 'PerformanceProfilerExtension':
-        # 只有当配置启用时才创建实例
-        if not crawler.settings.get_bool('PERFORMANCE_PROFILER_ENABLED', False):
-            from crawlo.exceptions import NotConfigured
-            raise NotConfigured("PerformanceProfilerExtension: PERFORMANCE_PROFILER_ENABLED is False")
-        
-        o = cls(crawler)
-        if o.enabled:
-            crawler.subscriber.subscribe(o.spider_opened, event=spider_opened)
-            crawler.subscriber.subscribe(o.spider_closed, event=spider_closed)
-        return o
-
-    async def spider_opened(self) -> None:
-        """爬虫启动时开始性能分析"""
-        if not self.enabled:
-            return
-            
-        try:
-            self.profiler = cProfile.Profile()
-            self.profiler.enable()
-            
-            # 启动定期保存分析结果的任务
-            self.task = asyncio.create_task(self._periodic_save())
-            
-            self.logger.info("Performance profiler started.")
-        except Exception as e:
-            self.error_handler.handle_error(
-                e, 
-                context="启动性能分析器失败", 
-                raise_error=False
-            )
-
-    async def spider_closed(self) -> None:
-        """爬虫关闭时停止性能分析并保存结果"""
-        if not self.enabled or not self.profiler:
-            return
-            
-        try:
-            # 停止定期保存任务
-            if self.task:
-                self.task.cancel()
-                try:
-                    await self.task
-                except asyncio.CancelledError:
-                    pass
-            
-            # 停止分析器并保存最终结果
-            self.profiler.disable()
-            
-            # 保存分析结果
-            await self._save_profile("final")
-            self.logger.info("Performance profiler stopped and results saved.")
-        except Exception as e:
-            self.error_handler.handle_error(
-                e, 
-                context="停止性能分析器失败", 
-                raise_error=False
-            )
-
-    async def _periodic_save(self) -> None:
-        """定期保存分析结果"""
-        counter = 1
-        while True:
-            try:
-                await asyncio.sleep(self.interval)
-                if self.profiler:
-                    # 临时禁用分析器以保存结果
-                    self.profiler.disable()
-                    await self._save_profile(f"periodic_{counter}")
-                    counter += 1
-                    # 重新启用分析器
-                    self.profiler.enable()
-            except asyncio.CancelledError:
-                break
-            except Exception as e:
-                self.logger.error(f"Error in periodic profiling save: {e}")
-
-    async def _save_profile(self, name: str) -> None:
-        """保存分析结果到文件"""
-        try:
-            # 创建内存中的字符串流
-            s = io.StringIO()
-            ps = pstats.Stats(self.profiler, stream=s)
-            
-            # 排序并打印统计信息
-            ps.sort_stats('cumulative')
-            ps.print_stats()
-            
-            # 保存到文件
-            filename = os.path.join(self.output_dir, f'profile_{name}.txt')
-            with open(filename, 'w', encoding='utf-8') as f:
-                f.write(s.getvalue())
-            
-            self.logger.info(f"Performance profile saved to {filename}")
-        except Exception as e:
+#!/usr/bin/python
+# -*- coding:UTF-8 -*-
+import io
+import os
+import pstats
+import asyncio
+import cProfile
+from typing import Any, Optional
+
+from crawlo.utils.log import get_logger
+from crawlo.utils.error_handler import ErrorHandler
+from crawlo.event import spider_opened, spider_closed
+
+
+class PerformanceProfilerExtension:
+    """
+    性能分析扩展
+    在爬虫运行期间进行性能分析，帮助优化爬虫性能
+    """
+
+    def __init__(self, crawler: Any):
+        self.settings = crawler.settings
+        self.logger = get_logger(self.__class__.__name__, crawler.settings.get('LOG_LEVEL'))
+        self.error_handler = ErrorHandler(self.__class__.__name__, crawler.settings.get('LOG_LEVEL'))
+        
+        # 获取配置参数
+        self.enabled = self.settings.get_bool('PERFORMANCE_PROFILER_ENABLED', False)
+        self.output_dir = self.settings.get('PERFORMANCE_PROFILER_OUTPUT_DIR', 'profiling')
+        self.interval = self.settings.get_int('PERFORMANCE_PROFILER_INTERVAL', 300)  # 默认5分钟
+        
+        self.profiler: Optional[cProfile.Profile] = None
+        self.task: Optional[asyncio.Task] = None
+        
+        # 创建输出目录
+        if self.enabled:
+            os.makedirs(self.output_dir, exist_ok=True)
+
+    @classmethod
+    def create_instance(cls, crawler: Any) -> 'PerformanceProfilerExtension':
+        # 只有当配置启用时才创建实例
+        if not crawler.settings.get_bool('PERFORMANCE_PROFILER_ENABLED', False):
+            from crawlo.exceptions import NotConfigured
+            raise NotConfigured("PerformanceProfilerExtension: PERFORMANCE_PROFILER_ENABLED is False")
+        
+        o = cls(crawler)
+        if o.enabled:
+            crawler.subscriber.subscribe(o.spider_opened, event=spider_opened)
+            crawler.subscriber.subscribe(o.spider_closed, event=spider_closed)
+        return o
+
+    async def spider_opened(self) -> None:
+        """爬虫启动时开始性能分析"""
+        if not self.enabled:
+            return
+            
+        try:
+            self.profiler = cProfile.Profile()
+            self.profiler.enable()
+            
+            # 启动定期保存分析结果的任务
+            self.task = asyncio.create_task(self._periodic_save())
+            
+            self.logger.info("Performance profiler started.")
+        except Exception as e:
+            self.error_handler.handle_error(
+                e, 
+                context="启动性能分析器失败", 
+                raise_error=False
+            )
+
+    async def spider_closed(self) -> None:
+        """爬虫关闭时停止性能分析并保存结果"""
+        if not self.enabled or not self.profiler:
+            return
+            
+        try:
+            # 停止定期保存任务
+            if self.task:
+                self.task.cancel()
+                try:
+                    await self.task
+                except asyncio.CancelledError:
+                    pass
+            
+            # 停止分析器并保存最终结果
+            self.profiler.disable()
+            
+            # 保存分析结果
+            await self._save_profile("final")
+            self.logger.info("Performance profiler stopped and results saved.")
+        except Exception as e:
+            self.error_handler.handle_error(
+                e, 
+                context="停止性能分析器失败", 
+                raise_error=False
+            )
+
+    async def _periodic_save(self) -> None:
+        """定期保存分析结果"""
+        counter = 1
+        while True:
+            try:
+                await asyncio.sleep(self.interval)
+                if self.profiler:
+                    # 临时禁用分析器以保存结果
+                    self.profiler.disable()
+                    await self._save_profile(f"periodic_{counter}")
+                    counter += 1
+                    # 重新启用分析器
+                    self.profiler.enable()
+            except asyncio.CancelledError:
+                break
+            except Exception as e:
+                self.logger.error(f"Error in periodic profiling save: {e}")
+
+    async def _save_profile(self, name: str) -> None:
+        """保存分析结果到文件"""
+        try:
+            # 创建内存中的字符串流
+            s = io.StringIO()
+            ps = pstats.Stats(self.profiler, stream=s)
+            
+            # 排序并打印统计信息
+            ps.sort_stats('cumulative')
+            ps.print_stats()
+            
+            # 保存到文件
+            filename = os.path.join(self.output_dir, f'profile_{name}.txt')
+            with open(filename, 'w', encoding='utf-8') as f:
+                f.write(s.getvalue())
+            
+            self.logger.info(f"Performance profile saved to {filename}")
+        except Exception as e:
             self.logger.error(f"Error saving performance profile: {e}")

crawlo/extension/request_recorder.py

@@ -1,108 +1,108 @@
-#!/usr/bin/python
-# -*- coding:UTF-8 -*-
-import os
-import json
-from typing import Any
-from datetime import datetime
-
-from crawlo import event
-from crawlo.utils.log import get_logger
-
-
-class RequestRecorderExtension:
-    """
-    请求记录扩展
-    记录所有发送的请求信息到文件，便于调试和分析
-    """
-
-    def __init__(self, crawler: Any):
-        self.settings = crawler.settings
-        self.logger = get_logger(self.__class__.__name__, crawler.settings.get('LOG_LEVEL'))
-        
-        # 获取配置参数
-        self.enabled = self.settings.get_bool('REQUEST_RECORDER_ENABLED', False)
-        self.output_dir = self.settings.get('REQUEST_RECORDER_OUTPUT_DIR', 'requests_log')
-        self.max_file_size = self.settings.get_int('REQUEST_RECORDER_MAX_FILE_SIZE', 10 * 1024 * 1024)  # 默认10MB
-        
-        # 创建输出目录
-        if self.enabled:
-            os.makedirs(self.output_dir, exist_ok=True)
-            
-        self.current_file = None
-        self.current_file_size = 0
-
-    @classmethod
-    def create_instance(cls, crawler: Any) -> 'RequestRecorderExtension':
-        # 只有当配置启用时才创建实例
-        if not crawler.settings.get_bool('REQUEST_RECORDER_ENABLED', False):
-            from crawlo.exceptions import NotConfigured
-            raise NotConfigured("RequestRecorderExtension: REQUEST_RECORDER_ENABLED is False")
-        
-        o = cls(crawler)
-        if o.enabled:
-            crawler.subscriber.subscribe(o.request_scheduled, event=event.request_scheduled)
-            crawler.subscriber.subscribe(o.response_received, event=event.response_received)
-            crawler.subscriber.subscribe(o.spider_closed, event=event.spider_closed)
-        return o
-
-    async def request_scheduled(self, request: Any, spider: Any) -> None:
-        """记录调度的请求"""
-        if not self.enabled:
-            return
-            
-        try:
-            request_info = {
-                'timestamp': datetime.now().isoformat(),
-                'type': 'request',
-                'url': request.url,
-                'method': request.method,
-                'headers': dict(request.headers),
-                'meta': getattr(request, 'meta', {}),
-            }
-            
-            await self._write_record(request_info)
-        except Exception as e:
-            self.logger.error(f"Error recording request: {e}")
-
-    async def response_received(self, response: Any, spider: Any) -> None:
-        """记录接收到的响应"""
-        if not self.enabled:
-            return
-            
-        try:
-            response_info = {
-                'timestamp': datetime.now().isoformat(),
-                'type': 'response',
-                'url': response.url,
-                'status_code': response.status_code,
-                'headers': dict(response.headers),
-            }
-            
-            await self._write_record(response_info)
-        except Exception as e:
-            self.logger.error(f"Error recording response: {e}")
-
-    async def spider_closed(self, spider: Any) -> None:
-        """爬虫关闭时清理资源"""
-        if self.current_file:
-            self.current_file.close()
-            self.current_file = None
-        self.logger.info("Request recorder closed.")
-
-    async def _write_record(self, record: dict) -> None:
-        """写入记录到文件"""
-        # 检查是否需要创建新文件
-        if not self.current_file or self.current_file_size > self.max_file_size:
-            if self.current_file:
-                self.current_file.close()
-            
-            timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
-            filename = os.path.join(self.output_dir, f'requests_{timestamp}.jsonl')
-            self.current_file = open(filename, 'a', encoding='utf-8')
-            self.current_file_size = 0
-        
-        # 写入记录
-        line = json.dumps(record, ensure_ascii=False) + '\n'
-        self.current_file.write(line)
-        self.current_file.flush()
+#!/usr/bin/python
+# -*- coding:UTF-8 -*-
+import os
+import json
+from typing import Any
+from datetime import datetime
+
+from crawlo import event
+from crawlo.utils.log import get_logger
+
+
+class RequestRecorderExtension:
+    """
+    请求记录扩展
+    记录所有发送的请求信息到文件，便于调试和分析
+    """
+
+    def __init__(self, crawler: Any):
+        self.settings = crawler.settings
+        self.logger = get_logger(self.__class__.__name__, crawler.settings.get('LOG_LEVEL'))
+        
+        # 获取配置参数
+        self.enabled = self.settings.get_bool('REQUEST_RECORDER_ENABLED', False)
+        self.output_dir = self.settings.get('REQUEST_RECORDER_OUTPUT_DIR', 'requests_log')
+        self.max_file_size = self.settings.get_int('REQUEST_RECORDER_MAX_FILE_SIZE', 10 * 1024 * 1024)  # 默认10MB
+        
+        # 创建输出目录
+        if self.enabled:
+            os.makedirs(self.output_dir, exist_ok=True)
+            
+        self.current_file = None
+        self.current_file_size = 0
+
+    @classmethod
+    def create_instance(cls, crawler: Any) -> 'RequestRecorderExtension':
+        # 只有当配置启用时才创建实例
+        if not crawler.settings.get_bool('REQUEST_RECORDER_ENABLED', False):
+            from crawlo.exceptions import NotConfigured
+            raise NotConfigured("RequestRecorderExtension: REQUEST_RECORDER_ENABLED is False")
+        
+        o = cls(crawler)
+        if o.enabled:
+            crawler.subscriber.subscribe(o.request_scheduled, event=event.request_scheduled)
+            crawler.subscriber.subscribe(o.response_received, event=event.response_received)
+            crawler.subscriber.subscribe(o.spider_closed, event=event.spider_closed)
+        return o
+
+    async def request_scheduled(self, request: Any, spider: Any) -> None:
+        """记录调度的请求"""
+        if not self.enabled:
+            return
+            
+        try:
+            request_info = {
+                'timestamp': datetime.now().isoformat(),
+                'type': 'request',
+                'url': request.url,
+                'method': request.method,
+                'headers': dict(request.headers),
+                'meta': getattr(request, 'meta', {}),
+            }
+            
+            await self._write_record(request_info)
+        except Exception as e:
+            self.logger.error(f"Error recording request: {e}")
+
+    async def response_received(self, response: Any, spider: Any) -> None:
+        """记录接收到的响应"""
+        if not self.enabled:
+            return
+            
+        try:
+            response_info = {
+                'timestamp': datetime.now().isoformat(),
+                'type': 'response',
+                'url': response.url,
+                'status_code': response.status_code,
+                'headers': dict(response.headers),
+            }
+            
+            await self._write_record(response_info)
+        except Exception as e:
+            self.logger.error(f"Error recording response: {e}")
+
+    async def spider_closed(self, spider: Any) -> None:
+        """爬虫关闭时清理资源"""
+        if self.current_file:
+            self.current_file.close()
+            self.current_file = None
+        self.logger.info("Request recorder closed.")
+
+    async def _write_record(self, record: dict) -> None:
+        """写入记录到文件"""
+        # 检查是否需要创建新文件
+        if not self.current_file or self.current_file_size > self.max_file_size:
+            if self.current_file:
+                self.current_file.close()
+            
+            timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
+            filename = os.path.join(self.output_dir, f'requests_{timestamp}.jsonl')
+            self.current_file = open(filename, 'a', encoding='utf-8')
+            self.current_file_size = 0
+        
+        # 写入记录
+        line = json.dumps(record, ensure_ascii=False) + '\n'
+        self.current_file.write(line)
+        self.current_file.flush()
         self.current_file_size += len(line.encode('utf-8'))

crawlo/factories/__init__.py

@@ -0,0 +1,28 @@
+#!/usr/bin/python
+# -*- coding: UTF-8 -*-
+"""
+Crawlo组件工厂系统
+==================
+
+提供统一的组件创建和依赖注入机制
+"""
+
+from .registry import ComponentRegistry, get_component_registry
+from .base import ComponentFactory, ComponentSpec
+from .crawler import CrawlerComponentFactory
+
+# 公共接口
+register_component = get_component_registry().register
+get_component = get_component_registry().get
+create_component = get_component_registry().create
+
+__all__ = [
+    'ComponentRegistry',
+    'ComponentFactory', 
+    'ComponentSpec',
+    'CrawlerComponentFactory',
+    'get_component_registry',
+    'register_component',
+    'get_component',
+    'create_component'
+]

crawlo/factories/base.py

@@ -0,0 +1,69 @@
+#!/usr/bin/python
+# -*- coding: UTF-8 -*-
+"""
+组件工厂基类和规范
+"""
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from typing import Type, Any, Dict, Optional, Callable
+
+
+@dataclass
+class ComponentSpec:
+    """组件规范 - 定义如何创建组件"""
+    
+    name: str
+    component_type: Type
+    factory_func: Callable[..., Any]
+    dependencies: list = None
+    singleton: bool = False
+    config_key: str = None
+    
+    def __post_init__(self):
+        if self.dependencies is None:
+            self.dependencies = []
+
+
+class ComponentFactory(ABC):
+    """组件工厂基类"""
+    
+    @abstractmethod
+    def create(self, spec: ComponentSpec, **kwargs) -> Any:
+        """创建组件实例"""
+        pass
+    
+    @abstractmethod
+    def supports(self, component_type: Type) -> bool:
+        """检查是否支持指定类型的组件"""
+        pass
+
+
+class DefaultComponentFactory(ComponentFactory):
+    """默认组件工厂实现"""
+    
+    def __init__(self):
+        self._instances: Dict[str, Any] = {}
+    
+    def create(self, spec: ComponentSpec, **kwargs) -> Any:
+        """创建组件实例"""
+        # 单例模式检查
+        if spec.singleton and spec.name in self._instances:
+            return self._instances[spec.name]
+        
+        # 调用工厂函数创建实例
+        instance = spec.factory_func(**kwargs)
+        
+        # 保存单例实例
+        if spec.singleton:
+            self._instances[spec.name] = instance
+        
+        return instance
+    
+    def supports(self, component_type: Type) -> bool:
+        """支持所有类型"""
+        return True
+    
+    def clear_singletons(self):
+        """清除单例实例（测试用）"""
+        self._instances.clear()