crawlo 1.4.7__py3-none-any.whl → 1.4.8__py3-none-any.whl

crawlo/factories/registry.py

@@ -1,85 +1,85 @@
-#!/usr/bin/python
-# -*- coding: UTF-8 -*-
-"""
-组件注册表 - 管理所有组件的注册和创建
-"""
-
-import threading
-from typing import Dict, List, Type, Any, Optional
-
-from .base import ComponentFactory, ComponentSpec, DefaultComponentFactory
-
-
-class ComponentRegistry:
-    """
-    组件注册表
-    
-    职责：
-    1. 管理组件规范的注册
-    2. 根据类型查找合适的工厂
-    3. 处理依赖关系
-    4. 创建组件实例
-    """
-    
-    def __init__(self):
-        self._specs: Dict[str, ComponentSpec] = {}
-        self._factories: List[ComponentFactory] = []
-        self._default_factory = DefaultComponentFactory()
-        self._lock = threading.RLock()
-    
-    def register(self, spec: ComponentSpec):
-        """注册组件规范"""
-        with self._lock:
-            self._specs[spec.name] = spec
-    
-    def register_factory(self, factory: ComponentFactory):
-        """注册组件工厂"""
-        with self._lock:
-            self._factories.append(factory)
-    
-    def get_spec(self, name: str) -> Optional[ComponentSpec]:
-        """获取组件规范"""
-        with self._lock:
-            return self._specs.get(name)
-    
-    def get_factory(self, component_type: Type) -> ComponentFactory:
-        """获取支持指定类型的工厂"""
-        with self._lock:
-            for factory in self._factories:
-                if factory.supports(component_type):
-                    return factory
-            return self._default_factory
-    
-    def create(self, name: str, **kwargs) -> Any:
-        """创建组件实例"""
-        spec = self.get_spec(name)
-        if not spec:
-            raise ValueError(f"Component spec '{name}' not found")
-        
-        factory = self.get_factory(spec.component_type)
-        return factory.create(spec, **kwargs)
-    
-    def get(self, name: str, **kwargs) -> Any:
-        """获取组件实例（create的别名）"""
-        return self.create(name, **kwargs)
-    
-    def list_components(self) -> List[str]:
-        """列出所有已注册的组件"""
-        with self._lock:
-            return list(self._specs.keys())
-    
-    def clear(self):
-        """清空注册表"""
-        with self._lock:
-            self._specs.clear()
-            self._factories.clear()
-            self._default_factory.clear_singletons()
-
-
-# 全局组件注册表
-_global_registry = ComponentRegistry()
-
-
-def get_component_registry() -> ComponentRegistry:
-    """获取全局组件注册表"""
+#!/usr/bin/python
+# -*- coding: UTF-8 -*-
+"""
+组件注册表 - 管理所有组件的注册和创建
+"""
+
+import threading
+from typing import Dict, List, Type, Any, Optional
+
+from .base import ComponentFactory, ComponentSpec, DefaultComponentFactory
+
+
+class ComponentRegistry:
+    """
+    组件注册表
+    
+    职责：
+    1. 管理组件规范的注册
+    2. 根据类型查找合适的工厂
+    3. 处理依赖关系
+    4. 创建组件实例
+    """
+    
+    def __init__(self):
+        self._specs: Dict[str, ComponentSpec] = {}
+        self._factories: List[ComponentFactory] = []
+        self._default_factory = DefaultComponentFactory()
+        self._lock = threading.RLock()
+    
+    def register(self, spec: ComponentSpec):
+        """注册组件规范"""
+        with self._lock:
+            self._specs[spec.name] = spec
+    
+    def register_factory(self, factory: ComponentFactory):
+        """注册组件工厂"""
+        with self._lock:
+            self._factories.append(factory)
+    
+    def get_spec(self, name: str) -> Optional[ComponentSpec]:
+        """获取组件规范"""
+        with self._lock:
+            return self._specs.get(name)
+    
+    def get_factory(self, component_type: Type) -> ComponentFactory:
+        """获取支持指定类型的工厂"""
+        with self._lock:
+            for factory in self._factories:
+                if factory.supports(component_type):
+                    return factory
+            return self._default_factory
+    
+    def create(self, name: str, **kwargs) -> Any:
+        """创建组件实例"""
+        spec = self.get_spec(name)
+        if not spec:
+            raise ValueError(f"Component spec '{name}' not found")
+        
+        factory = self.get_factory(spec.component_type)
+        return factory.create(spec, **kwargs)
+    
+    def get(self, name: str, **kwargs) -> Any:
+        """获取组件实例（create的别名）"""
+        return self.create(name, **kwargs)
+    
+    def list_components(self) -> List[str]:
+        """列出所有已注册的组件"""
+        with self._lock:
+            return list(self._specs.keys())
+    
+    def clear(self):
+        """清空注册表"""
+        with self._lock:
+            self._specs.clear()
+            self._factories.clear()
+            self._default_factory.clear_singletons()
+
+
+# 全局组件注册表
+_global_registry = ComponentRegistry()
+
+
+def get_component_registry() -> ComponentRegistry:
+    """获取全局组件注册表"""
     return _global_registry

crawlo/factories/utils.py

@@ -1,135 +1,135 @@
-#!/usr/bin/python
-# -*- coding: UTF-8 -*-
-"""
-工厂工具模块 - 提供通用的组件注册和创建工具
-"""
-
-from typing import Any, Callable, List, Optional, Type, Union
-from .base import ComponentSpec
-from .registry import get_component_registry
-
-
-def register_component(
-    name: str,
-    component_type: Union[Type, str],
-    factory_func: Callable[..., Any],
-    dependencies: Optional[List[str]] = None,
-    singleton: bool = False,
-    config_key: Optional[str] = None
-) -> None:
-    """
-    注册组件的便捷函数
-    
-    Args:
-        name: 组件名称
-        component_type: 组件类型
-        factory_func: 工厂函数
-        dependencies: 依赖列表
-        singleton: 是否单例
-        config_key: 配置键名
-    """
-    registry = get_component_registry()
-    
-    # 如果component_type是字符串，创建一个动态类型
-    if isinstance(component_type, str):
-        component_type = type(component_type, (), {})
-    
-    spec_kwargs = {
-        'name': name,
-        'component_type': component_type,
-        'factory_func': factory_func,
-        'dependencies': dependencies or [],
-        'singleton': singleton
-    }
-    
-    # 只有当config_key不为None时才添加
-    if config_key is not None:
-        spec_kwargs['config_key'] = config_key
-    
-    spec = ComponentSpec(**spec_kwargs)
-    
-    registry.register(spec)
-
-
-def register_components(component_list: List[dict]) -> None:
-    """
-    批量注册组件
-    
-    Args:
-        component_list: 组件定义列表，每个元素是一个包含组件信息的字典
-    """
-    for component_info in component_list:
-        register_component(**component_info)
-
-
-def create_component_factory(
-    component_name: str,
-    module_path: str,
-    class_name: str,
-    dependencies: Optional[List[str]] = None,
-    singleton: bool = False
-) -> Callable[..., Any]:
-    """
-    创建组件工厂函数的便捷函数
-    
-    Args:
-        component_name: 组件名称（用于错误信息）
-        module_path: 模块路径
-        class_name: 类名
-        dependencies: 依赖列表
-        singleton: 是否单例
-        
-    Returns:
-        工厂函数
-    """
-    def factory_func(*args, **kwargs):
-        try:
-            # 动态导入模块
-            module = __import__(module_path, fromlist=[class_name])
-            component_class = getattr(module, class_name)
-            
-            # 检查是否需要调用create_instance方法
-            if hasattr(component_class, 'create_instance'):
-                return component_class.create_instance(*args, **kwargs)
-            else:
-                return component_class(*args, **kwargs)
-        except Exception as e:
-            raise RuntimeError(f"Failed to create {component_name}: {e}")
-    
-    return factory_func
-
-
-def create_crawler_component_factory(
-    component_name: str,
-    module_path: str,
-    class_name: str
-) -> Callable[..., Any]:
-    """
-    创建需要crawler依赖的组件工厂函数
-    
-    Args:
-        component_name: 组件名称
-        module_path: 模块路径
-        class_name: 类名
-        
-    Returns:
-        工厂函数
-    """
-    def factory_func(crawler=None, **kwargs):
-        if crawler is None:
-            raise ValueError(f"Crawler instance required for component {component_name}")
-        
-        try:
-            # 动态导入模块
-            module = __import__(module_path, fromlist=[class_name])
-            component_class = getattr(module, class_name)
-            
-            # 检查是否需要调用create_instance方法
-            if hasattr(component_class, 'create_instance'):
-                return component_class.create_instance(crawler, **kwargs)
-            else:
-                return component_class(crawler, **kwargs)
-        except Exception as e:
-            raise RuntimeError(f"Failed to create {component_name}: {e}")
-    
+#!/usr/bin/python
+# -*- coding: UTF-8 -*-
+"""
+工厂工具模块 - 提供通用的组件注册和创建工具
+"""
+
+from typing import Any, Callable, List, Optional, Type, Union
+from .base import ComponentSpec
+from .registry import get_component_registry
+
+
+def register_component(
+    name: str,
+    component_type: Union[Type, str],
+    factory_func: Callable[..., Any],
+    dependencies: Optional[List[str]] = None,
+    singleton: bool = False,
+    config_key: Optional[str] = None
+) -> None:
+    """
+    注册组件的便捷函数
+    
+    Args:
+        name: 组件名称
+        component_type: 组件类型
+        factory_func: 工厂函数
+        dependencies: 依赖列表
+        singleton: 是否单例
+        config_key: 配置键名
+    """
+    registry = get_component_registry()
+    
+    # 如果component_type是字符串，创建一个动态类型
+    if isinstance(component_type, str):
+        component_type = type(component_type, (), {})
+    
+    spec_kwargs = {
+        'name': name,
+        'component_type': component_type,
+        'factory_func': factory_func,
+        'dependencies': dependencies or [],
+        'singleton': singleton
+    }
+    
+    # 只有当config_key不为None时才添加
+    if config_key is not None:
+        spec_kwargs['config_key'] = config_key
+    
+    spec = ComponentSpec(**spec_kwargs)
+    
+    registry.register(spec)
+
+
+def register_components(component_list: List[dict]) -> None:
+    """
+    批量注册组件
+    
+    Args:
+        component_list: 组件定义列表，每个元素是一个包含组件信息的字典
+    """
+    for component_info in component_list:
+        register_component(**component_info)
+
+
+def create_component_factory(
+    component_name: str,
+    module_path: str,
+    class_name: str,
+    dependencies: Optional[List[str]] = None,
+    singleton: bool = False
+) -> Callable[..., Any]:
+    """
+    创建组件工厂函数的便捷函数
+    
+    Args:
+        component_name: 组件名称（用于错误信息）
+        module_path: 模块路径
+        class_name: 类名
+        dependencies: 依赖列表
+        singleton: 是否单例
+        
+    Returns:
+        工厂函数
+    """
+    def factory_func(*args, **kwargs):
+        try:
+            # 动态导入模块
+            module = __import__(module_path, fromlist=[class_name])
+            component_class = getattr(module, class_name)
+            
+            # 检查是否需要调用create_instance方法
+            if hasattr(component_class, 'create_instance'):
+                return component_class.create_instance(*args, **kwargs)
+            else:
+                return component_class(*args, **kwargs)
+        except Exception as e:
+            raise RuntimeError(f"Failed to create {component_name}: {e}")
+    
+    return factory_func
+
+
+def create_crawler_component_factory(
+    component_name: str,
+    module_path: str,
+    class_name: str
+) -> Callable[..., Any]:
+    """
+    创建需要crawler依赖的组件工厂函数
+    
+    Args:
+        component_name: 组件名称
+        module_path: 模块路径
+        class_name: 类名
+        
+    Returns:
+        工厂函数
+    """
+    def factory_func(crawler=None, **kwargs):
+        if crawler is None:
+            raise ValueError(f"Crawler instance required for component {component_name}")
+        
+        try:
+            # 动态导入模块
+            module = __import__(module_path, fromlist=[class_name])
+            component_class = getattr(module, class_name)
+            
+            # 检查是否需要调用create_instance方法
+            if hasattr(component_class, 'create_instance'):
+                return component_class.create_instance(crawler, **kwargs)
+            else:
+                return component_class(crawler, **kwargs)
+        except Exception as e:
+            raise RuntimeError(f"Failed to create {component_name}: {e}")
+    
     return factory_func