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

crawlo/logging/factory.py

@@ -0,0 +1,129 @@
+#!/usr/bin/python
+# -*- coding: UTF-8 -*-
+"""
+日志器工厂 - 创建和缓存Logger实例
+"""
+
+import logging
+import os
+import threading
+from logging.handlers import RotatingFileHandler
+from typing import Dict, Optional
+from weakref import WeakValueDictionary
+
+from .manager import get_config, is_configured, configure
+from .config import LogConfig
+
+
+class LoggerFactory:
+    """
+    Logger工厂类 - 负责创建和缓存Logger实例
+    
+    特点：
+    1. 使用WeakValueDictionary避免内存泄漏
+    2. 线程安全的Logger创建
+    3. 自动配置管理
+    4. 简单的缓存策略
+    """
+    
+    # Logger缓存 - 使用弱引用避免内存泄漏
+    _logger_cache: WeakValueDictionary = WeakValueDictionary()
+    _cache_lock = threading.RLock()
+    
+    @classmethod
+    def get_logger(cls, name: str = 'crawlo') -> logging.Logger:
+        """
+        获取Logger实例
+        
+        Args:
+            name: Logger名称
+            
+        Returns:
+            logging.Logger: 配置好的Logger实例
+        """
+        # 确保日志系统已配置
+        if not is_configured():
+            configure()  # 使用默认配置
+        
+        # 检查缓存
+        with cls._cache_lock:
+            if name in cls._logger_cache:
+                return cls._logger_cache[name]
+            
+            # 创建新的Logger
+            logger = cls._create_logger(name)
+            cls._logger_cache[name] = logger
+            return logger
+    
+    @classmethod
+    def _create_logger(cls, name: str) -> logging.Logger:
+        """创建新的Logger实例"""
+        config = get_config()
+        if not config:
+            raise RuntimeError("Log system not configured")
+        
+        # 创建Logger
+        logger = logging.getLogger(name)
+        logger.setLevel(logging.DEBUG)  # Logger本身设为最低级别
+        
+        # 清除现有handlers（避免重复添加）
+        logger.handlers.clear()
+        
+        # 获取模块级别
+        module_level = config.get_module_level(name)
+        level = getattr(logging, module_level.upper(), logging.INFO)
+        
+        # 创建formatter
+        formatter = logging.Formatter(config.format)
+        
+        # 添加控制台Handler
+        if config.console_enabled:
+            console_handler = logging.StreamHandler()
+            console_handler.setFormatter(formatter)
+            console_handler.setLevel(level)
+            logger.addHandler(console_handler)
+        
+        # 添加文件Handler
+        if config.file_enabled and config.file_path:
+            try:
+                # 确保日志目录存在
+                log_dir = os.path.dirname(config.file_path)
+                if log_dir and not os.path.exists(log_dir):
+                    os.makedirs(log_dir, exist_ok=True)
+                
+                file_handler = RotatingFileHandler(
+                    filename=config.file_path,
+                    maxBytes=config.max_bytes,
+                    backupCount=config.backup_count,
+                    encoding=config.encoding
+                )
+                file_handler.setFormatter(formatter)
+                file_handler.setLevel(level)
+                logger.addHandler(file_handler)
+            except Exception as e:
+                # 文件Handler创建失败时，至少保证控制台输出
+                pass
+        
+        # 防止向上传播（避免重复输出）
+        logger.propagate = False
+        
+        return logger
+    
+    @classmethod
+    def clear_cache(cls):
+        """清空Logger缓存"""
+        with cls._cache_lock:
+            cls._logger_cache.clear()
+    
+    @classmethod
+    def refresh_loggers(cls, new_config: LogConfig):
+        """刷新所有缓存的Logger（配置更新时使用）"""
+        with cls._cache_lock:
+            # 清空缓存，强制重新创建
+            cls._logger_cache.clear()
+
+
+# 便捷函数
+def get_logger(name: str = 'crawlo') -> logging.Logger:
+    """获取Logger实例的便捷函数"""
+    return LoggerFactory.get_logger(name)

crawlo/logging/manager.py

@@ -0,0 +1,112 @@
+#!/usr/bin/python
+# -*- coding: UTF-8 -*-
+"""
+日志管理器 - 核心组件
+"""
+
+import threading
+from typing import Optional, Any
+from .config import LogConfig
+
+
+class LogManager:
+    """
+    日志管理器 - 单例模式
+    
+    职责：
+    1. 全局日志配置管理
+    2. 配置状态跟踪
+    3. 线程安全的配置更新
+    """
+    
+    _instance: Optional['LogManager'] = None
+    _lock = threading.Lock()
+    
+    def __new__(cls) -> 'LogManager':
+        if cls._instance is None:
+            with cls._lock:
+                if cls._instance is None:
+                    cls._instance = super(LogManager, cls).__new__(cls)
+                    cls._instance._initialized = False
+        return cls._instance
+    
+    def __init__(self):
+        if hasattr(self, '_initialized') and self._initialized:
+            return
+            
+        self._config: Optional[LogConfig] = None
+        self._configured = False
+        self._config_lock = threading.RLock()
+        self._initialized = True
+    
+    @property
+    def config(self) -> Optional[LogConfig]:
+        """获取当前配置"""
+        with self._config_lock:
+            return self._config
+    
+    @property
+    def is_configured(self) -> bool:
+        """检查是否已配置"""
+        return self._configured
+    
+    def configure(self, settings=None, **kwargs) -> LogConfig:
+        """
+        配置日志系统
+        
+        Args:
+            settings: 配置对象或None
+            **kwargs: 关键字参数配置
+            
+        Returns:
+            LogConfig: 生效的配置对象
+        """
+        with self._config_lock:
+            # 总是重新配置，即使已经配置过
+            # 从不同来源创建配置
+            if settings is not None:
+                # 检查settings是否已经是LogConfig对象
+                if isinstance(settings, LogConfig):
+                    config = settings
+                else:
+                    config = LogConfig.from_settings(settings)
+            elif kwargs:
+                config = LogConfig.from_dict(kwargs)
+            else:
+                config = LogConfig()  # 使用默认配置
+            
+            # 验证配置
+            if not config.validate():
+                raise ValueError("Invalid log configuration")
+            
+            self._config = config
+            self._configured = True
+            
+            return config
+    
+    def reset(self):
+        """重置配置（主要用于测试）"""
+        with self._config_lock:
+            self._config = None
+            self._configured = False
+
+
+# 全局实例
+_log_manager = LogManager()
+
+# 模块级便捷函数
+def configure(settings=None, **kwargs) -> LogConfig:
+    """配置日志系统"""
+    return _log_manager.configure(settings, **kwargs)
+
+def is_configured() -> bool:
+    """检查是否已配置"""
+    return _log_manager.is_configured
+
+def get_config() -> Optional[LogConfig]:
+    """获取当前配置"""
+    return _log_manager.config
+
+def reset():
+    """重置配置"""
+    _log_manager.reset()

crawlo/middleware/middleware_manager.py

@@ -8,7 +8,7 @@ from typing import List, Dict, Callable, Optional
 
 from crawlo import Request, Response
 from crawlo.utils.log import get_logger
-from crawlo.project import load_class
+from crawlo.utils.class_loader import load_class
 from crawlo.middleware import BaseMiddleware
 from crawlo.project import common_call
 from crawlo.event import ignore_request, response_received

crawlo/middleware/offsite.py

@@ -54,7 +54,7 @@ class OffsiteMiddleware:
         o._compile_domains()
         
         # 使用中间件自己的logger而不是crawler.logger
-        o.logger.info(f"OffsiteMiddleware已启用，允许的域名: {allowed_domains}")
+        o.logger.debug(f"OffsiteMiddleware 已启用，允许的域名: {allowed_domains}")
         return o
 
     def _compile_domains(self):

crawlo/mode_manager.py

@@ -26,7 +26,26 @@ class ModeManager:
     """运行模式管理器"""
 
     def __init__(self):
-        pass
+        # 延迟初始化logger，避免循环依赖
+        self._logger = None
+        self._debug("运行模式管理器初始化完成")
+    
+    def _get_logger(self):
+        """延迟获取logger实例"""
+        if self._logger is None:
+            try:
+                from crawlo.utils.log import get_logger
+                self._logger = get_logger(__name__)
+            except Exception:
+                # 如果日志系统尚未初始化，返回None
+                pass
+        return self._logger
+    
+    def _debug(self, message: str):
+        """调试日志"""
+        logger = self._get_logger()
+        if logger:
+            logger.debug(message)
 
     @staticmethod
     def get_standalone_settings() -> Dict[str, Any]:
@@ -94,12 +113,14 @@ class ModeManager:
         Returns:
             Dict[str, Any]: 配置字典
         """
+        self._debug(f"解析运行模式: {mode}")
         mode = RunMode(mode.lower())
         mode_info = None
 
         if mode == RunMode.STANDALONE:
             mode_info = "使用单机模式 - 简单快速，适合开发和中小规模爬取"
             settings = self.get_standalone_settings()
+            self._debug("应用单机模式配置")
 
         elif mode == RunMode.DISTRIBUTED:
             mode_info = "使用分布式模式 - 支持多节点扩展，适合大规模爬取"
@@ -110,10 +131,12 @@ class ModeManager:
                 redis_db=kwargs.get('redis_db', 0),  # 添加 redis_db 参数
                 project_name=kwargs.get('project_name', 'crawlo')
             )
+            self._debug("应用分布式模式配置")
 
         elif mode == RunMode.AUTO:
             mode_info = "使用自动检测模式 - 智能选择最佳运行方式"
             settings = self.get_auto_settings()
+            self._debug("应用自动检测模式配置")
 
         else:
             raise ValueError(f"不支持的运行模式: {mode}")
@@ -122,10 +145,12 @@ class ModeManager:
         user_settings = {k: v for k, v in kwargs.items()
                          if k not in ['redis_host', 'redis_port', 'redis_password', 'project_name']}
         settings.update(user_settings)
+        self._debug(f"合并用户自定义配置: {list(user_settings.keys())}")
 
         # 将模式信息添加到配置中，供后续使用
         settings['_mode_info'] = mode_info
 
+        self._debug(f"运行模式解析完成: {mode}")
         return settings
 
     def from_environment(self) -> Dict[str, Any]:

crawlo/pipelines/pipeline_manager.py

@@ -6,7 +6,8 @@ from asyncio import create_task
 
 from crawlo.utils.log import get_logger
 from crawlo.event import item_successful, item_discard
-from crawlo.project import load_class, common_call
+from crawlo.utils.class_loader import load_class
+from crawlo.project import common_call
 from crawlo.exceptions import PipelineInitError, ItemDiscard, InvalidOutputError
 
 

crawlo/project.py

@@ -7,10 +7,28 @@ from inspect import iscoroutinefunction
 from typing import Callable, Optional, Any
 
 from crawlo.settings.setting_manager import SettingManager
-from crawlo.utils.log import get_logger, LoggerManager
+from crawlo.utils.log import get_logger
 
 # 使用全局logger，避免每个模块都创建自己的延迟初始化函数
-logger = get_logger(__name__)
+# 延迟获取logger，确保在日志系统配置之后获取
+_logger = None
+
+
+def logger():
+    """延迟获取logger实例，确保在日志系统配置之后获取"""
+    global _logger
+    if _logger is None:
+        _logger = get_logger(__name__)
+    return _logger
+
+
+# 添加一个临时的日志函数，用于在日志系统配置之前输出信息
+def _temp_debug(message):
+    """临时调试函数，在日志系统配置之前使用"""
+    # 直接输出到控制台，避免循环依赖
+    import os
+    if os.environ.get('CRAWLO_DEBUG'):
+        print(f"[CRAWLO_DEBUG] {message}")
 
 
 def load_class(path: str) -> Any:
@@ -23,12 +41,9 @@ def load_class(path: str) -> Any:
     Returns:
         加载的类对象
     """
-    try:
-        module_path, class_name = path.rsplit('.', 1)
-        module = importlib.import_module(module_path)
-        return getattr(module, class_name)
-    except (ValueError, ImportError, AttributeError) as e:
-        raise ImportError(f"无法加载类 '{path}': {e}")
+    # 使用工具模块的实现，避免循环依赖
+    from crawlo.utils.class_loader import load_class as _load_class
+    return _load_class(path)
 
 
 def merge_settings(spider, settings):
@@ -42,7 +57,7 @@ def merge_settings(spider, settings):
     spider_name = getattr(spider, 'name', 'UnknownSpider')
     # 检查 settings 是否为 SettingManager 实例
     if not hasattr(settings, 'update_attributes'):
-        logger.error(f"merge_settings 接收到的 settings 不是 SettingManager 实例: {type(settings)}")
+        _temp_debug(f"merge_settings 接收到的 settings 不是 SettingManager 实例: {type(settings)}")
         # 如果是字典，创建一个新的 SettingManager 实例
         if isinstance(settings, dict):
             from crawlo.settings.setting_manager import SettingManager
@@ -50,14 +65,14 @@ def merge_settings(spider, settings):
             new_settings.update_attributes(settings)
             settings = new_settings
         else:
-            logger.error("无法处理的 settings 类型")
+            _temp_debug("无法处理的 settings 类型")
             return
-            
+
     if hasattr(spider, 'custom_settings'):
         custom_settings = getattr(spider, 'custom_settings')
         settings.update_attributes(custom_settings)
     else:
-        logger.debug(f"爬虫 '{spider_name}' 无 custom_settings，跳过合并")
+        _temp_debug(f"爬虫 '{spider_name}' 无 custom_settings，跳过合并")
 
 
 async def common_call(func: Callable, *args, **kwargs):
@@ -85,7 +100,7 @@ def _get_settings_module_from_cfg(cfg_path: str) -> str:
         config.read(cfg_path, encoding="utf-8")
         if config.has_section("settings") and config.has_option("settings", "default"):
             module_path = config.get("settings", "default")
-            logger.debug(f"📄 从 crawlo.cfg 加载 settings 模块: {module_path}")
+            _temp_debug(f"📄 从 crawlo.cfg 加载 settings 模块: {module_path}")
             return module_path
         else:
             raise RuntimeError(f"配置文件缺少 [settings] 或 default 选项: {cfg_path}")
@@ -101,41 +116,41 @@ def _find_project_root(start_path: str = ".") -> Optional[str]:
         2. 存在 '__init__.py' 和 'settings.py'（即 Python 包）
     """
     path = os.path.abspath(start_path)
-    
+
     # 首先检查当前目录及其子目录
     for root, dirs, files in os.walk(path):
         if "crawlo.cfg" in files:
             cfg_path = os.path.join(root, "crawlo.cfg")
-            logger.debug(f"✅ 找到项目配置文件: {cfg_path}")
+            _temp_debug(f"✅ 找到项目配置文件: {cfg_path}")
             return root
-    
+
     # 向上查找直到找到 crawlo.cfg 或包含 settings.py 和 __init__.py 的目录
     original_path = path
     checked_paths = set()
-    
+
     while True:
         # 避免无限循环
         if path in checked_paths:
             break
         checked_paths.add(path)
-        
+
         # 检查 crawlo.cfg
         cfg_file = os.path.join(path, "crawlo.cfg")
         if os.path.isfile(cfg_file):
-            logger.debug(f"✅ 找到项目配置文件: {cfg_file}")
+            _temp_debug(f"✅ 找到项目配置文件: {cfg_file}")
             return path
 
         # 检查 settings.py 和 __init__.py
         settings_file = os.path.join(path, "settings.py")
         init_file = os.path.join(path, "__init__.py")
         if os.path.isfile(settings_file) and os.path.isfile(init_file):
-            logger.debug(f"✅ 找到项目模块: {path}")
+            _temp_debug(f"✅ 找到项目模块: {path}")
             # 即使找到了项目模块，也继续向上查找是否有 crawlo.cfg
             parent = os.path.dirname(path)
             if parent != path:
                 parent_cfg = os.path.join(parent, "crawlo.cfg")
                 if os.path.isfile(parent_cfg):
-                    logger.debug(f"✅ 在上层目录找到项目配置文件: {parent_cfg}")
+                    _temp_debug(f"✅ 在上层目录找到项目配置文件: {parent_cfg}")
                     return parent
             return path
 
@@ -156,22 +171,22 @@ def _find_project_root(start_path: str = ".") -> Optional[str]:
                 if path in checked_paths:
                     break
                 checked_paths.add(path)
-                
+
                 cfg_file = os.path.join(path, "crawlo.cfg")
                 if os.path.isfile(cfg_file):
-                    logger.debug(f"✅ 找到项目配置文件: {cfg_file}")
+                    _temp_debug(f"✅ 找到项目配置文件: {cfg_file}")
                     return path
 
                 settings_file = os.path.join(path, "settings.py")
                 init_file = os.path.join(path, "__init__.py")
                 if os.path.isfile(settings_file) and os.path.isfile(init_file):
-                    logger.debug(f"✅ 找到项目模块: {path}")
+                    _temp_debug(f"✅ 找到项目模块: {path}")
                     # 即使找到了项目模块，也继续向上查找是否有 crawlo.cfg
                     parent = os.path.dirname(path)
                     if parent != path:
                         parent_cfg = os.path.join(parent, "crawlo.cfg")
                         if os.path.isfile(parent_cfg):
-                            logger.debug(f"✅ 在上层目录找到项目配置文件: {parent_cfg}")
+                            _temp_debug(f"✅ 在上层目录找到项目配置文件: {parent_cfg}")
                             return parent
                     return path
 
@@ -193,22 +208,22 @@ def _find_project_root(start_path: str = ".") -> Optional[str]:
                 if path in checked_paths:
                     break
                 checked_paths.add(path)
-                
+
                 cfg_file = os.path.join(path, "crawlo.cfg")
                 if os.path.isfile(cfg_file):
-                    logger.debug(f"找到项目配置文件: {cfg_file}")
+                    _temp_debug(f"找到项目配置文件: {cfg_file}")
                     return path
 
                 settings_file = os.path.join(path, "settings.py")
                 init_file = os.path.join(path, "__init__.py")
                 if os.path.isfile(settings_file) and os.path.isfile(init_file):
-                    logger.debug(f"找到项目模块: {path}")
+                    _temp_debug(f"找到项目模块: {path}")
                     # 即使找到了项目模块，也继续向上查找是否有 crawlo.cfg
                     parent = os.path.dirname(path)
                     if parent != path:
                         parent_cfg = os.path.join(parent, "crawlo.cfg")
                         if os.path.isfile(parent_cfg):
-                            logger.debug(f"在上层目录找到项目配置文件: {parent_cfg}")
+                            _temp_debug(f"在上层目录找到项目配置文件: {parent_cfg}")
                             return parent
                     return path
 
@@ -219,13 +234,14 @@ def _find_project_root(start_path: str = ".") -> Optional[str]:
     except Exception:
         pass
 
-    logger.warning("未找到 Crawlo 项目根目录。请确保在包含 'crawlo.cfg' 或 'settings.py' 的目录运行。")
+    _temp_debug("未找到 Crawlo 项目根目录。请确保在包含 'crawlo.cfg' 或 'settings.py' 的目录运行。")
     return None
 
 
-def get_settings(custom_settings: Optional[dict] = None) -> SettingManager:
+def _load_project_settings(custom_settings: Optional[dict] = None) -> SettingManager:
     """
-    获取配置管理器实例（主入口函数）
+    内部函数：加载项目配置（不处理日志初始化）
+    这个函数专门负责配置加载逻辑，避免与初始化管理器产生循环依赖
 
     Args:
         custom_settings: 运行时自定义配置，会覆盖 settings.py
@@ -233,7 +249,7 @@ def get_settings(custom_settings: Optional[dict] = None) -> SettingManager:
     Returns:
         SettingManager: 已加载配置的实例
     """
-    logger.debug("🚀 正在初始化 Crawlo 项目配置...")
+    _temp_debug("🚀 正在加载 Crawlo 项目配置...")
 
     # 1. 查找项目根
     project_root = _find_project_root()
@@ -250,21 +266,21 @@ def get_settings(custom_settings: Optional[dict] = None) -> SettingManager:
         # 推断：项目目录名.settings
         project_name = os.path.basename(project_root)
         settings_module_path = f"{project_name}.settings"
-        logger.warning(f"⚠️ 未找到 crawlo.cfg，推断 settings 模块为: {settings_module_path}")
+        _temp_debug(f"⚠️ 未找到 crawlo.cfg，推断 settings 模块为: {settings_module_path}")
 
     # 3. 注入 sys.path
     project_root_str = os.path.abspath(project_root)
     if project_root_str not in sys.path:
         sys.path.insert(0, project_root_str)
-        logger.debug(f"📁 项目根目录已加入 sys.path: {project_root_str}")
+        _temp_debug(f"📁 项目根目录已加入 sys.path: {project_root_str}")
 
     # 4. 加载 SettingManager
-    logger.debug(f"⚙️ 正在加载配置模块: {settings_module_path}")
+    _temp_debug(f"⚙️ 正在加载配置模块: {settings_module_path}")
     settings = SettingManager()
 
     try:
         settings.set_settings(settings_module_path)
-        logger.debug("✅ settings 模块加载成功")
+        _temp_debug("✅ settings 模块加载成功")
     except Exception as e:
         raise ImportError(f"加载 settings 模块失败 '{settings_module_path}': {e}")
 
@@ -279,19 +295,33 @@ def get_settings(custom_settings: Optional[dict] = None) -> SettingManager:
             # 只有当用户没有设置该配置项时才应用模式配置
             if key not in settings.attributes:
                 settings.set(key, value)
-        logger.debug(f"🔧 已应用 {run_mode} 模式配置")
+        _temp_debug(f"🔧 已应用 {run_mode} 模式配置")
 
     # 6. 合并运行时配置
     if custom_settings:
         settings.update_attributes(custom_settings)
-        logger.debug(f"🔧 已应用运行时自定义配置: {list(custom_settings.keys())}")
+        _temp_debug(f"🔧 已应用运行时自定义配置: {list(custom_settings.keys())}")
+
+    _temp_debug("🎉 Crawlo 项目配置加载完成！")
+    return settings
 
-    # 7. 显示核心配置摘要（INFO级别）
-    # _log_settings_summary(settings)
 
-    # 配置日志系统
-    LoggerManager.configure(settings)
+def get_settings(custom_settings: Optional[dict] = None) -> SettingManager:
+    """
+    获取配置管理器实例（主入口函数）
     
-    # 将项目初始化完成的消息改为DEBUG级别
-    logger.debug("🎉 Crawlo 项目配置初始化完成！")
-    return settings
+    注意：这个函数现在作为向后兼容的入口，实际的初始化逻辑已经移到
+    crawlo.core.framework_initializer 模块中。建议使用新的初始化方式：
+    
+    >>> from crawlo.core.framework_initializer import initialize_framework
+    >>> settings = initialize_framework(custom_settings)
+
+    Args:
+        custom_settings: 运行时自定义配置，会覆盖 settings.py
+
+    Returns:
+        SettingManager: 已加载配置的实例
+    """
+    # 使用新的统一初始化管理器
+    from crawlo.core.framework_initializer import initialize_framework
+    return initialize_framework(custom_settings)

crawlo/queue/pqueue.py

@@ -3,7 +3,7 @@ import json
 import sys
 import asyncio
 from asyncio import PriorityQueue
-from typing import Optional
+from typing import Optional, Tuple, Any
 
 
 from crawlo import Request
@@ -16,12 +16,12 @@ class SpiderPriorityQueue(PriorityQueue):
         """初始化队列，maxsize为0表示无大小限制"""
         super().__init__(maxsize)
 
-    async def get(self, timeout: float = 0.1) -> Optional[Request]:
+    async def get(self, timeout: float = 0.01) -> Optional[Any]:
         """
         异步获取队列元素，带超时功能
 
         Args:
-            timeout: 超时时间（秒），默认0.1秒
+            timeout: 超时时间（秒），默认0.01秒
 
         Returns:
             队列元素(优先级, 值)或None(超时)
@@ -30,8 +30,14 @@ class SpiderPriorityQueue(PriorityQueue):
             # 根据Python版本选择超时实现方式
             if sys.version_info >= (3, 11):
                 async with asyncio.timeout(timeout):
-                    return await super().get()
+                    item = await super().get()
+                    return item
             else:
-                return await asyncio.wait_for(super().get(), timeout=timeout)
+                item = await asyncio.wait_for(super().get(), timeout=timeout)
+                return item
         except asyncio.TimeoutError:
             return None
+
+    def qsize(self) -> int:
+        """获取队列大小"""
+        return super().qsize()