crawlo 1.4.2__py3-none-any.whl → 1.4.3__py3-none-any.whl

crawlo/initialization/context.py

@@ -1,142 +1,142 @@
-#!/usr/bin/python
-# -*- coding: UTF-8 -*-
-"""
-初始化上下文 - 保存初始化过程中的状态和数据
-"""
-
-import time
-import threading
-from typing import Dict, Any, List, Optional
-from dataclasses import dataclass, field
-
-from .phases import InitializationPhase, PhaseResult
-
-
-@dataclass
-class InitializationContext:
-    """
-    初始化上下文
-    
-    保存初始化过程中的状态、数据和结果
-    """
-    
-    # 基本信息
-    start_time: float = field(default_factory=time.time)
-    end_time: Optional[float] = None
-    
-    # 当前状态
-    current_phase: InitializationPhase = InitializationPhase.PREPARING
-    completed_phases: List[InitializationPhase] = field(default_factory=list)
-    failed_phases: List[InitializationPhase] = field(default_factory=list)
-    
-    # 阶段结果
-    phase_results: Dict[InitializationPhase, PhaseResult] = field(default_factory=dict)
-    
-    # 共享数据
-    shared_data: Dict[str, Any] = field(default_factory=dict)
-    
-    # 配置信息
-    settings: Optional[Any] = None
-    custom_settings: Optional[Dict[str, Any]] = None
-    
-    # 错误信息
-    errors: List[str] = field(default_factory=list)
-    warnings: List[str] = field(default_factory=list)
-    
-    # 线程安全
-    _lock: threading.RLock = field(default_factory=threading.RLock, init=False)
-    
-    def set_current_phase(self, phase: InitializationPhase):
-        """设置当前阶段"""
-        with self._lock:
-            self.current_phase = phase
-    
-    def mark_phase_completed(self, phase: InitializationPhase, result: PhaseResult):
-        """标记阶段完成"""
-        with self._lock:
-            if result.success:
-                self.completed_phases.append(phase)
-            else:
-                self.failed_phases.append(phase)
-            
-            self.phase_results[phase] = result
-    
-    def add_shared_data(self, key: str, value: Any):
-        """添加共享数据"""
-        with self._lock:
-            self.shared_data[key] = value
-    
-    def get_shared_data(self, key: str, default=None):
-        """获取共享数据"""
-        with self._lock:
-            return self.shared_data.get(key, default)
-    
-    def add_error(self, message: str):
-        """添加错误信息"""
-        with self._lock:
-            self.errors.append(message)
-    
-    def add_warning(self, message: str):
-        """添加警告信息"""
-        with self._lock:
-            self.warnings.append(message)
-    
-    def is_phase_completed(self, phase: InitializationPhase) -> bool:
-        """检查阶段是否完成"""
-        with self._lock:
-            return phase in self.completed_phases
-    
-    def is_phase_failed(self, phase: InitializationPhase) -> bool:
-        """检查阶段是否失败"""
-        with self._lock:
-            return phase in self.failed_phases
-    
-    def get_phase_result(self, phase: InitializationPhase) -> Optional[PhaseResult]:
-        """获取阶段结果"""
-        with self._lock:
-            return self.phase_results.get(phase)
-    
-    def get_total_duration(self) -> float:
-        """获取总耗时"""
-        end = self.end_time or time.time()
-        return end - self.start_time
-    
-    def get_phase_durations(self) -> Dict[InitializationPhase, float]:
-        """获取各阶段耗时"""
-        with self._lock:
-            return {
-                phase: result.duration 
-                for phase, result in self.phase_results.items()
-            }
-    
-    def get_success_rate(self) -> float:
-        """获取成功率"""
-        with self._lock:
-            total = len(self.completed_phases) + len(self.failed_phases)
-            if total == 0:
-                return 0.0
-            return len(self.completed_phases) / total * 100
-    
-    def finish(self):
-        """标记初始化完成"""
-        with self._lock:
-            self.end_time = time.time()
-    
-    def to_dict(self) -> Dict[str, Any]:
-        """转换为字典格式"""
-        with self._lock:
-            return {
-                'start_time': self.start_time,
-                'end_time': self.end_time,
-                'total_duration': self.get_total_duration(),
-                'current_phase': self.current_phase.value,
-                'completed_phases': [p.value for p in self.completed_phases],
-                'failed_phases': [p.value for p in self.failed_phases],
-                'success_rate': self.get_success_rate(),
-                'error_count': len(self.errors),
-                'warning_count': len(self.warnings),
-                'phase_durations': {
-                    p.value: duration 
-                    for p, duration in self.get_phase_durations().items()
-                }
+#!/usr/bin/python
+# -*- coding: UTF-8 -*-
+"""
+初始化上下文 - 保存初始化过程中的状态和数据
+"""
+
+import time
+import threading
+from typing import Dict, Any, List, Optional
+from dataclasses import dataclass, field
+
+from .phases import InitializationPhase, PhaseResult
+
+
+@dataclass
+class InitializationContext:
+    """
+    初始化上下文
+    
+    保存初始化过程中的状态、数据和结果
+    """
+    
+    # 基本信息
+    start_time: float = field(default_factory=time.time)
+    end_time: Optional[float] = None
+    
+    # 当前状态
+    current_phase: InitializationPhase = InitializationPhase.PREPARING
+    completed_phases: List[InitializationPhase] = field(default_factory=list)
+    failed_phases: List[InitializationPhase] = field(default_factory=list)
+    
+    # 阶段结果
+    phase_results: Dict[InitializationPhase, PhaseResult] = field(default_factory=dict)
+    
+    # 共享数据
+    shared_data: Dict[str, Any] = field(default_factory=dict)
+    
+    # 配置信息
+    settings: Optional[Any] = None
+    custom_settings: Optional[Dict[str, Any]] = None
+    
+    # 错误信息
+    errors: List[str] = field(default_factory=list)
+    warnings: List[str] = field(default_factory=list)
+    
+    # 线程安全
+    _lock: threading.RLock = field(default_factory=threading.RLock, init=False)
+    
+    def set_current_phase(self, phase: InitializationPhase):
+        """设置当前阶段"""
+        with self._lock:
+            self.current_phase = phase
+    
+    def mark_phase_completed(self, phase: InitializationPhase, result: PhaseResult):
+        """标记阶段完成"""
+        with self._lock:
+            if result.success:
+                self.completed_phases.append(phase)
+            else:
+                self.failed_phases.append(phase)
+            
+            self.phase_results[phase] = result
+    
+    def add_shared_data(self, key: str, value: Any):
+        """添加共享数据"""
+        with self._lock:
+            self.shared_data[key] = value
+    
+    def get_shared_data(self, key: str, default=None):
+        """获取共享数据"""
+        with self._lock:
+            return self.shared_data.get(key, default)
+    
+    def add_error(self, message: str):
+        """添加错误信息"""
+        with self._lock:
+            self.errors.append(message)
+    
+    def add_warning(self, message: str):
+        """添加警告信息"""
+        with self._lock:
+            self.warnings.append(message)
+    
+    def is_phase_completed(self, phase: InitializationPhase) -> bool:
+        """检查阶段是否完成"""
+        with self._lock:
+            return phase in self.completed_phases
+    
+    def is_phase_failed(self, phase: InitializationPhase) -> bool:
+        """检查阶段是否失败"""
+        with self._lock:
+            return phase in self.failed_phases
+    
+    def get_phase_result(self, phase: InitializationPhase) -> Optional[PhaseResult]:
+        """获取阶段结果"""
+        with self._lock:
+            return self.phase_results.get(phase)
+    
+    def get_total_duration(self) -> float:
+        """获取总耗时"""
+        end = self.end_time or time.time()
+        return end - self.start_time
+    
+    def get_phase_durations(self) -> Dict[InitializationPhase, float]:
+        """获取各阶段耗时"""
+        with self._lock:
+            return {
+                phase: result.duration 
+                for phase, result in self.phase_results.items()
+            }
+    
+    def get_success_rate(self) -> float:
+        """获取成功率"""
+        with self._lock:
+            total = len(self.completed_phases) + len(self.failed_phases)
+            if total == 0:
+                return 0.0
+            return len(self.completed_phases) / total * 100
+    
+    def finish(self):
+        """标记初始化完成"""
+        with self._lock:
+            self.end_time = time.time()
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """转换为字典格式"""
+        with self._lock:
+            return {
+                'start_time': self.start_time,
+                'end_time': self.end_time,
+                'total_duration': self.get_total_duration(),
+                'current_phase': self.current_phase.value,
+                'completed_phases': [p.value for p in self.completed_phases],
+                'failed_phases': [p.value for p in self.failed_phases],
+                'success_rate': self.get_success_rate(),
+                'error_count': len(self.errors),
+                'warning_count': len(self.warnings),
+                'phase_durations': {
+                    p.value: duration 
+                    for p, duration in self.get_phase_durations().items()
+                }
             }

crawlo/initialization/core.py

@@ -1,194 +1,194 @@
-#!/usr/bin/python
-# -*- coding: UTF-8 -*-
-"""
-核心初始化器 - 协调整个初始化过程
-"""
-
-import time
-import threading
-from typing import Optional, Any
-
-from .context import InitializationContext  
-from .phases import InitializationPhase, PhaseResult, get_execution_order, get_phase_definition
-from .registry import get_global_registry, BaseInitializer, register_initializer
-from .built_in import register_built_in_initializers
-
-
-class CoreInitializer:
-    """
-    核心初始化器 - 协调整个框架的初始化过程
-    
-    职责：
-    1. 管理初始化阶段的执行顺序
-    2. 处理阶段间的依赖关系
-    3. 提供统一的初始化入口
-    4. 错误处理和降级策略
-    """
-    
-    _instance: Optional['CoreInitializer'] = None
-    _lock = threading.Lock()
-    
-    def __new__(cls) -> 'CoreInitializer':
-        if cls._instance is None:
-            with cls._lock:
-                if cls._instance is None:
-                    cls._instance = super(CoreInitializer, cls).__new__(cls)
-                    cls._instance._initialized = False
-        return cls._instance
-    
-    def __init__(self):
-        if hasattr(self, '_initialized') and self._initialized:
-            return
-            
-        self._context: Optional[InitializationContext] = None
-        self._is_ready = False
-        self._init_lock = threading.RLock()
-        
-        # 注册内置初始化器
-        register_built_in_initializers()
-        
-        self._initialized = True
-    
-    @property
-    def context(self) -> Optional[InitializationContext]:
-        """获取初始化上下文"""
-        return self._context
-    
-    @property  
-    def is_ready(self) -> bool:
-        """检查框架是否已准备就绪"""
-        return self._is_ready
-    
-    def initialize(self, settings=None, **kwargs) -> Any:
-        """
-        执行框架初始化
-        
-        Args:
-            settings: 配置对象
-            **kwargs: 额外的配置参数
-            
-        Returns:
-            初始化后的配置管理器
-        """
-        with self._init_lock:
-            # 如果已经初始化完成，直接返回
-            if self._is_ready and self._context and self._context.settings:
-                return self._context.settings
-            
-            # 创建初始化上下文
-            context = InitializationContext()
-            context.custom_settings = kwargs
-            self._context = context
-            
-            try:
-                # 执行初始化阶段
-                self._execute_initialization_phases(context)
-                
-                # 检查关键阶段是否完成
-                if not context.is_phase_completed(InitializationPhase.SETTINGS):
-                    raise RuntimeError("Settings initialization failed")
-                
-                self._is_ready = True
-                context.finish()
-                
-                return context.settings
-                
-            except Exception as e:
-                context.add_error(f"Framework initialization failed: {e}")
-                context.finish()
-                
-                # 降级策略
-                return self._fallback_initialization(settings, **kwargs)
-    
-    def _execute_initialization_phases(self, context: InitializationContext):
-        """执行初始化阶段"""
-        registry = get_global_registry()
-        execution_order = get_execution_order()
-        
-        # 只执行已注册的阶段
-        registered_phases = set(registry.get_all_phases())
-        
-        for phase in execution_order:
-            if phase == InitializationPhase.ERROR:
-                continue
-                
-            # 只执行已注册的阶段
-            if phase not in registered_phases:
-                continue
-                
-            context.set_current_phase(phase)
-            
-            # 检查依赖关系
-            if not self._check_dependencies(phase, context):
-                phase_def = get_phase_definition(phase)
-                if not (phase_def and phase_def.optional):
-                    raise RuntimeError(f"Dependencies not satisfied for phase {phase}")
-                else:
-                    # 可选阶段，跳过
-                    continue
-            
-            # 执行阶段
-            start_time = time.time()
-            try:
-                result = registry.execute_phase(phase, context)
-                result.duration = time.time() - start_time
-                
-                context.mark_phase_completed(phase, result)
-                
-                if not result.success and not self._is_phase_optional(phase):
-                    raise RuntimeError(f"Phase {phase} failed: {result.error}")
-                    
-            except Exception as e:
-                duration = time.time() - start_time
-                result = PhaseResult(
-                    phase=phase,
-                    success=False,
-                    duration=duration,
-                    error=e
-                )
-                context.mark_phase_completed(phase, result)
-                
-                if not self._is_phase_optional(phase):
-                    raise
-    
-    def _check_dependencies(self, phase: InitializationPhase, 
-                          context: InitializationContext) -> bool:
-        """检查阶段依赖关系"""
-        phase_def = get_phase_definition(phase)
-        if not phase_def:
-            return True
-        
-        for dependency in phase_def.dependencies:
-            if not context.is_phase_completed(dependency):
-                return False
-        
-        return True
-    
-    def _is_phase_optional(self, phase: InitializationPhase) -> bool:
-        """检查阶段是否可选"""
-        phase_def = get_phase_definition(phase)
-        return phase_def.optional if phase_def else False
-    
-    def _fallback_initialization(self, settings=None, **kwargs):
-        """降级初始化策略"""
-        try:
-            # 尝试创建基本的配置管理器
-            from crawlo.settings.setting_manager import SettingManager
-            
-            if settings:
-                return settings
-            else:
-                fallback_settings = SettingManager()
-                if kwargs:
-                    fallback_settings.update_attributes(kwargs)
-                return fallback_settings
-                
-        except Exception:
-            # 如果连降级都失败，返回None
-            return None
-    
-    def reset(self):
-        """重置初始化状态（主要用于测试）"""
-        with self._init_lock:
-            self._context = None
+#!/usr/bin/python
+# -*- coding: UTF-8 -*-
+"""
+核心初始化器 - 协调整个初始化过程
+"""
+
+import time
+import threading
+from typing import Optional, Any
+
+from .context import InitializationContext  
+from .phases import InitializationPhase, PhaseResult, get_execution_order, get_phase_definition
+from .registry import get_global_registry, BaseInitializer, register_initializer
+from .built_in import register_built_in_initializers
+
+
+class CoreInitializer:
+    """
+    核心初始化器 - 协调整个框架的初始化过程
+    
+    职责：
+    1. 管理初始化阶段的执行顺序
+    2. 处理阶段间的依赖关系
+    3. 提供统一的初始化入口
+    4. 错误处理和降级策略
+    """
+    
+    _instance: Optional['CoreInitializer'] = None
+    _lock = threading.Lock()
+    
+    def __new__(cls) -> 'CoreInitializer':
+        if cls._instance is None:
+            with cls._lock:
+                if cls._instance is None:
+                    cls._instance = super(CoreInitializer, cls).__new__(cls)
+                    cls._instance._initialized = False
+        return cls._instance
+    
+    def __init__(self):
+        if hasattr(self, '_initialized') and self._initialized:
+            return
+            
+        self._context: Optional[InitializationContext] = None
+        self._is_ready = False
+        self._init_lock = threading.RLock()
+        
+        # 注册内置初始化器
+        register_built_in_initializers()
+        
+        self._initialized = True
+    
+    @property
+    def context(self) -> Optional[InitializationContext]:
+        """获取初始化上下文"""
+        return self._context
+    
+    @property  
+    def is_ready(self) -> bool:
+        """检查框架是否已准备就绪"""
+        return self._is_ready
+    
+    def initialize(self, settings=None, **kwargs) -> Any:
+        """
+        执行框架初始化
+        
+        Args:
+            settings: 配置对象
+            **kwargs: 额外的配置参数
+            
+        Returns:
+            初始化后的配置管理器
+        """
+        with self._init_lock:
+            # 如果已经初始化完成，直接返回
+            if self._is_ready and self._context and self._context.settings:
+                return self._context.settings
+            
+            # 创建初始化上下文
+            context = InitializationContext()
+            context.custom_settings = kwargs
+            self._context = context
+            
+            try:
+                # 执行初始化阶段
+                self._execute_initialization_phases(context)
+                
+                # 检查关键阶段是否完成
+                if not context.is_phase_completed(InitializationPhase.SETTINGS):
+                    raise RuntimeError("Settings initialization failed")
+                
+                self._is_ready = True
+                context.finish()
+                
+                return context.settings
+                
+            except Exception as e:
+                context.add_error(f"Framework initialization failed: {e}")
+                context.finish()
+                
+                # 降级策略
+                return self._fallback_initialization(settings, **kwargs)
+    
+    def _execute_initialization_phases(self, context: InitializationContext):
+        """执行初始化阶段"""
+        registry = get_global_registry()
+        execution_order = get_execution_order()
+        
+        # 只执行已注册的阶段
+        registered_phases = set(registry.get_all_phases())
+        
+        for phase in execution_order:
+            if phase == InitializationPhase.ERROR:
+                continue
+                
+            # 只执行已注册的阶段
+            if phase not in registered_phases:
+                continue
+                
+            context.set_current_phase(phase)
+            
+            # 检查依赖关系
+            if not self._check_dependencies(phase, context):
+                phase_def = get_phase_definition(phase)
+                if not (phase_def and phase_def.optional):
+                    raise RuntimeError(f"Dependencies not satisfied for phase {phase}")
+                else:
+                    # 可选阶段，跳过
+                    continue
+            
+            # 执行阶段
+            start_time = time.time()
+            try:
+                result = registry.execute_phase(phase, context)
+                result.duration = time.time() - start_time
+                
+                context.mark_phase_completed(phase, result)
+                
+                if not result.success and not self._is_phase_optional(phase):
+                    raise RuntimeError(f"Phase {phase} failed: {result.error}")
+                    
+            except Exception as e:
+                duration = time.time() - start_time
+                result = PhaseResult(
+                    phase=phase,
+                    success=False,
+                    duration=duration,
+                    error=e
+                )
+                context.mark_phase_completed(phase, result)
+                
+                if not self._is_phase_optional(phase):
+                    raise
+    
+    def _check_dependencies(self, phase: InitializationPhase, 
+                          context: InitializationContext) -> bool:
+        """检查阶段依赖关系"""
+        phase_def = get_phase_definition(phase)
+        if not phase_def:
+            return True
+        
+        for dependency in phase_def.dependencies:
+            if not context.is_phase_completed(dependency):
+                return False
+        
+        return True
+    
+    def _is_phase_optional(self, phase: InitializationPhase) -> bool:
+        """检查阶段是否可选"""
+        phase_def = get_phase_definition(phase)
+        return phase_def.optional if phase_def else False
+    
+    def _fallback_initialization(self, settings=None, **kwargs):
+        """降级初始化策略"""
+        try:
+            # 尝试创建基本的配置管理器
+            from crawlo.settings.setting_manager import SettingManager
+            
+            if settings:
+                return settings
+            else:
+                fallback_settings = SettingManager()
+                if kwargs:
+                    fallback_settings.update_attributes(kwargs)
+                return fallback_settings
+                
+        except Exception:
+            # 如果连降级都失败，返回None
+            return None
+    
+    def reset(self):
+        """重置初始化状态（主要用于测试）"""
+        with self._init_lock:
+            self._context = None
             self._is_ready = False