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

crawlo/initialization/core.py

@@ -0,0 +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
+            self._is_ready = False

crawlo/initialization/phases.py

@@ -0,0 +1,149 @@
+#!/usr/bin/python
+# -*- coding: UTF-8 -*-
+"""
+初始化阶段定义
+"""
+
+from enum import Enum
+from dataclasses import dataclass
+from typing import List, Optional
+
+
+class InitializationPhase(Enum):
+    """初始化阶段枚举"""
+    
+    # 阶段0：准备阶段
+    PREPARING = "preparing"
+    
+    # 阶段1：日志系统初始化
+    LOGGING = "logging"
+    
+    # 阶段2：配置系统初始化  
+    SETTINGS = "settings"
+    
+    # 阶段3：核心组件初始化
+    CORE_COMPONENTS = "core_components"
+    
+    # 阶段4：扩展组件初始化
+    EXTENSIONS = "extensions"
+    
+    # 阶段5：框架启动日志记录
+    FRAMEWORK_STARTUP_LOG = "framework_startup_log"
+    
+    # 阶段6：完成
+    COMPLETED = "completed"
+    
+    # 错误状态
+    ERROR = "error"
+
+
+@dataclass
+class PhaseResult:
+    """阶段执行结果"""
+    phase: InitializationPhase
+    success: bool
+    duration: float = 0.0
+    error: Optional[Exception] = None
+    artifacts: dict = None  # 阶段产生的工件
+    
+    def __post_init__(self):
+        if self.artifacts is None:
+            self.artifacts = {}
+
+
+@dataclass 
+class PhaseDefinition:
+    """阶段定义"""
+    phase: InitializationPhase
+    name: str
+    description: str
+    dependencies: List[InitializationPhase] = None
+    optional: bool = False
+    timeout: float = 30.0  # 超时时间（秒）
+    
+    def __post_init__(self):
+        if self.dependencies is None:
+            self.dependencies = []
+
+
+# 预定义的初始化阶段
+PHASE_DEFINITIONS = [
+    PhaseDefinition(
+        phase=InitializationPhase.PREPARING,
+        name="准备阶段",
+        description="初始化基础环境和检查前置条件",
+        dependencies=[],
+        timeout=5.0
+    ),
+    PhaseDefinition(
+        phase=InitializationPhase.LOGGING,
+        name="日志系统",
+        description="配置和初始化日志系统",
+        dependencies=[],  # 移除对PREPARING的依赖
+        timeout=10.0
+    ),
+    PhaseDefinition(
+        phase=InitializationPhase.SETTINGS,
+        name="配置系统", 
+        description="加载和验证配置",
+        dependencies=[InitializationPhase.LOGGING],
+        timeout=15.0
+    ),
+    PhaseDefinition(
+        phase=InitializationPhase.CORE_COMPONENTS,
+        name="核心组件",
+        description="初始化框架核心组件",
+        dependencies=[InitializationPhase.SETTINGS],
+        timeout=20.0
+    ),
+    PhaseDefinition(
+        phase=InitializationPhase.EXTENSIONS,
+        name="扩展组件",
+        description="加载和初始化扩展组件",
+        dependencies=[InitializationPhase.CORE_COMPONENTS],
+        optional=True,
+        timeout=15.0
+    ),
+    PhaseDefinition(
+        phase=InitializationPhase.FRAMEWORK_STARTUP_LOG,
+        name="框架启动日志",
+        description="记录框架启动相关信息",
+        dependencies=[InitializationPhase.LOGGING, InitializationPhase.SETTINGS],
+        timeout=5.0
+    ),
+    PhaseDefinition(
+        phase=InitializationPhase.COMPLETED,
+        name="初始化完成",
+        description="框架初始化完成",
+        dependencies=[
+            InitializationPhase.CORE_COMPONENTS,
+            InitializationPhase.FRAMEWORK_STARTUP_LOG
+        ],  # Extensions是可选的
+        timeout=5.0
+    )
+]
+
+
+def get_phase_definition(phase: InitializationPhase) -> Optional[PhaseDefinition]:
+    """获取阶段定义"""
+    for definition in PHASE_DEFINITIONS:
+        if definition.phase == phase:
+            return definition
+    return None
+
+
+def get_execution_order() -> List[InitializationPhase]:
+    """获取执行顺序"""
+    return [definition.phase for definition in PHASE_DEFINITIONS]
+
+
+def validate_dependencies() -> bool:
+    """验证阶段依赖关系的正确性"""
+    phases = {definition.phase for definition in PHASE_DEFINITIONS}
+    
+    for definition in PHASE_DEFINITIONS:
+        for dependency in definition.dependencies:
+            if dependency not in phases:
+                return False
+    
+    return True

crawlo/initialization/registry.py

@@ -0,0 +1,146 @@
+#!/usr/bin/python
+# -*- coding: UTF-8 -*-
+"""
+初始化器注册表 - 管理所有初始化器的注册和执行
+"""
+
+import threading
+from typing import Dict, Optional, Callable, List
+from .context import InitializationContext
+from .phases import InitializationPhase, PhaseResult
+
+
+class Initializer:
+    """初始化器基类"""
+    
+    def __init__(self, phase: InitializationPhase):
+        self._phase = phase
+    
+    @property
+    def phase(self) -> InitializationPhase:
+        """获取初始化阶段"""
+        return self._phase
+    
+    def initialize(self, context: InitializationContext) -> PhaseResult:
+        """执行初始化 - 子类必须实现"""
+        raise NotImplementedError("Subclasses must implement initialize method")
+
+
+class BaseInitializer(Initializer):
+    """基础初始化器类 - 为向后兼容保留"""
+    
+    def __init__(self, phase: InitializationPhase):
+        super().__init__(phase)
+    
+    def _create_result(self, success: bool, duration: float = 0.0, 
+                      artifacts: Optional[Dict] = None, error: Optional[Exception] = None) -> PhaseResult:
+        """创建初始化结果"""
+        return PhaseResult(
+            phase=self.phase,
+            success=success,
+            duration=duration,
+            artifacts=artifacts or {},
+            error=error
+        )
+
+
+class InitializerRegistry:
+    """
+    初始化器注册表 - 管理所有初始化器的注册和执行
+    
+    特点：
+    1. 线程安全的注册和执行
+    2. 支持函数式和类式初始化器
+    3. 统一的结果处理
+    """
+    
+    def __init__(self):
+        self._initializers: Dict[InitializationPhase, Initializer] = {}
+        self._lock = threading.RLock()
+    
+    def register(self, initializer: Initializer):
+        """注册初始化器"""
+        with self._lock:
+            phase = initializer.phase
+            if phase in self._initializers:
+                raise ValueError(f"Initializer for phase {phase} already registered")
+            self._initializers[phase] = initializer
+    
+    def register_function(self, phase: InitializationPhase, 
+                         init_func: Callable[[InitializationContext], PhaseResult]):
+        """注册函数式初始化器"""
+        
+        class FunctionInitializer:
+            def __init__(self, phase: InitializationPhase, func: Callable):
+                self._phase = phase
+                self._func = func
+            
+            @property  
+            def phase(self) -> InitializationPhase:
+                return self._phase
+            
+            def initialize(self, context: InitializationContext) -> PhaseResult:
+                return self._func(context)
+        
+        self.register(FunctionInitializer(phase, init_func))
+    
+    def get_initializer(self, phase: InitializationPhase) -> Optional[Initializer]:
+        """获取指定阶段的初始化器"""
+        with self._lock:
+            return self._initializers.get(phase)
+    
+    def get_all_phases(self) -> List[InitializationPhase]:
+        """获取所有已注册的阶段"""
+        with self._lock:
+            return list(self._initializers.keys())
+    
+    def has_initializer(self, phase: InitializationPhase) -> bool:
+        """检查是否有指定阶段的初始化器"""
+        with self._lock:
+            return phase in self._initializers
+    
+    def clear(self):
+        """清空注册表"""
+        with self._lock:
+            self._initializers.clear()
+    
+    def execute_phase(self, phase: InitializationPhase, 
+                     context: InitializationContext) -> PhaseResult:
+        """执行指定阶段的初始化"""
+        initializer = self.get_initializer(phase)
+        if not initializer:
+            error = ValueError(f"No initializer registered for phase {phase}")
+            return PhaseResult(
+                phase=phase,
+                success=False,
+                error=error
+            )
+        
+        try:
+            return initializer.initialize(context)
+        except Exception as e:
+            return PhaseResult(
+                phase=phase,
+                success=False,
+                error=e
+            )
+
+
+# 全局注册表实例
+_global_registry = InitializerRegistry()
+
+
+def get_global_registry() -> InitializerRegistry:
+    """获取全局注册表"""
+    return _global_registry
+
+
+def register_initializer(initializer: Initializer):
+    """注册初始化器到全局注册表"""
+    _global_registry.register(initializer)
+
+
+def register_phase_function(phase: InitializationPhase, 
+                           init_func: Callable[[InitializationContext], PhaseResult]):
+    """注册函数式初始化器到全局注册表"""
+    _global_registry.register_function(phase, init_func)

crawlo/items/__init__.py

@@ -1,23 +1,23 @@
-#!/usr/bin/python
-# -*- coding: UTF-8 -*-
-"""
-crawlo.items 包
-===============
-提供 Item 和 Field 类用于数据定义和验证。
-"""
-from .items import Item
-from .fields import Field
-from .base import ItemMeta
-
-from crawlo.exceptions import ItemInitError, ItemAttributeError
-
-__all__ = [
-    'Item',
-    'Field',
-    'ItemMeta',
-    'ItemInitError',
-    'ItemAttributeError'
-]
-
-
-
+#!/usr/bin/python
+# -*- coding: UTF-8 -*-
+"""
+crawlo.items 包
+===============
+提供 Item 和 Field 类用于数据定义和验证。
+"""
+from .items import Item
+from .fields import Field
+from .base import ItemMeta
+
+from crawlo.exceptions import ItemInitError, ItemAttributeError
+
+__all__ = [
+    'Item',
+    'Field',
+    'ItemMeta',
+    'ItemInitError',
+    'ItemAttributeError'
+]
+
+
+

crawlo/items/base.py

@@ -1,22 +1,23 @@
-#!/usr/bin/python
-# -*- coding: UTF-8 -*-
-"""
-基础元类定义
-"""
-from abc import ABCMeta
-from .fields import Field
-
-class ItemMeta(ABCMeta):
-    def __new__(mcs, name, bases, attrs):
-        fields = {}
-        cls_attrs = {}
-
-        for attr_name, attr_value in attrs.items():
-            if isinstance(attr_value, Field):
-                fields[attr_name] = attr_value
-            else:
-                cls_attrs[attr_name] = attr_value
-
-        cls_instance = super().__new__(mcs, name, bases, cls_attrs)
-        cls_instance.FIELDS = fields
-        return cls_instance
+#!/usr/bin/python
+# -*- coding: UTF-8 -*-
+"""
+基础元类定义
+"""
+from abc import ABCMeta
+from .fields import Field
+
+
+class ItemMeta(ABCMeta):
+    def __new__(mcs, name, bases, attrs):
+        fields = {}
+        cls_attrs = {}
+
+        for attr_name, attr_value in attrs.items():
+            if isinstance(attr_value, Field):
+                fields[attr_name] = attr_value
+            else:
+                cls_attrs[attr_name] = attr_value
+
+        cls_instance = super().__new__(mcs, name, bases, cls_attrs)
+        cls_instance.FIELDS = fields
+        return cls_instance

crawlo/items/fields.py

@@ -1,53 +1,53 @@
-#!/usr/bin/python
-# -*- coding: UTF-8 -*-
-"""
-Field 类定义
-"""
-from typing import Any, Optional, Type
-
-
-class Field:
-    """
-    字段定义类，用于定义 Item 的字段属性和验证规则
-    """
-    def __init__(
-        self,
-        nullable: bool = True,
-        *,
-        default: Any = None,
-        field_type: Optional[Type] = None,
-        max_length: Optional[int] = None,
-        description: str = ""
-    ):
-        self.nullable = nullable
-        self.default = default
-        self.field_type = field_type
-        self.max_length = max_length
-        self.description = description
-
-    def validate(self, value: Any, field_name: str = "") -> Any:
-        """
-        验证字段值是否符合规则
-        """
-        if value is None or (isinstance(value, str) and value.strip() == ""):
-            if self.default is not None:
-                return self.default
-            elif not self.nullable:
-                raise ValueError(
-                    f"字段 '{field_name}' 不允许为空。"
-                )
-
-        if value is not None and not (isinstance(value, str) and value.strip() == ""):
-            if self.field_type and not isinstance(value, self.field_type):
-                raise TypeError(
-                    f"字段 '{field_name}' 类型错误：期望类型 {self.field_type}, 得到 {type(value)}，值：{value!r}"
-                )
-            if self.max_length and len(str(value)) > self.max_length:
-                raise ValueError(
-                    f"字段 '{field_name}' 长度超限：最大长度 {self.max_length}，当前长度 {len(str(value))}，值：{value!r}"
-                )
-
-        return value
-
-    def __repr__(self):
+#!/usr/bin/python
+# -*- coding: UTF-8 -*-
+"""
+Field 类定义
+"""
+from typing import Any, Optional, Type
+
+
+class Field:
+    """
+    字段定义类，用于定义 Item 的字段属性和验证规则
+    """
+    def __init__(
+        self,
+        nullable: bool = True,
+        *,
+        default: Any = None,
+        field_type: Optional[Type] = None,
+        max_length: Optional[int] = None,
+        description: str = ""
+    ):
+        self.nullable = nullable
+        self.default = default
+        self.field_type = field_type
+        self.max_length = max_length
+        self.description = description
+
+    def validate(self, value: Any, field_name: str = "") -> Any:
+        """
+        验证字段值是否符合规则
+        """
+        if value is None or (isinstance(value, str) and value.strip() == ""):
+            if self.default is not None:
+                return self.default
+            elif not self.nullable:
+                raise ValueError(
+                    f"字段 '{field_name}' 不允许为空。"
+                )
+
+        if value is not None and not (isinstance(value, str) and value.strip() == ""):
+            if self.field_type and not isinstance(value, self.field_type):
+                raise TypeError(
+                    f"字段 '{field_name}' 类型错误：期望类型 {self.field_type}, 得到 {type(value)}，值：{value!r}"
+                )
+            if self.max_length and len(str(value)) > self.max_length:
+                raise ValueError(
+                    f"字段 '{field_name}' 长度超限：最大长度 {self.max_length}，当前长度 {len(str(value))}，值：{value!r}"
+                )
+
+        return value
+
+    def __repr__(self):
         return f"<Field nullable={self.nullable} type={self.field_type} default={self.default}>"