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

crawlo/middleware/__init__.py

@@ -1,24 +1,87 @@
-#!/usr/bin/python
-# -*- coding:UTF-8 -*-
-from typing import TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from crawlo import Request, Response
-
-
-class BaseMiddleware(object):
-    def process_request(self, request, spider) -> 'None | Request | Response':
-        # 请求预处理
-        pass
-
-    def process_response(self, request, response, spider) -> 'Request | Response':
-        # 响应预处理
-        pass
-
-    def process_exception(self, request, exp, spider) -> 'None | Request | Response':
-        # 异常预处理
-        pass
-
-    @classmethod
-    def create_instance(cls, crawler):
-        return cls()
+#!/usr/bin/python
+# -*- coding:UTF-8 -*-
+from typing import TYPE_CHECKING, Optional, Union
+
+if TYPE_CHECKING:
+    from crawlo import Request, Response
+
+
+class BaseMiddleware:
+    """中间件基类
+    
+    定义了中间件的标准接口，所有自定义中间件都应该继承此类。
+    
+    中间件处理流程：
+    1. process_request: 请求发送前处理
+    2. process_response: 响应接收后处理
+    3. process_exception: 异常发生时处理
+    """
+    
+    def process_request(
+        self, 
+        request: 'Request', 
+        spider
+    ) -> Optional[Union['Request', 'Response']]:
+        """处理请求
+        
+        Args:
+            request: 待处理的请求对象
+            spider: 当前爬虫实例
+            
+        Returns:
+            None: 继续处理
+            Request: 替换原请求
+            Response: 跳过下载，直接返回响应
+        """
+        pass
+
+    def process_response(
+        self, 
+        request: 'Request', 
+        response: 'Response', 
+        spider
+    ) -> Union['Request', 'Response']:
+        """处理响应
+        
+        Args:
+            request: 原始请求对象
+            response: 接收到的响应对象
+            spider: 当前爬虫实例
+            
+        Returns:
+            Request: 重新发起请求
+            Response: 返回响应（可能是修改后的）
+        """
+        return response
+
+    def process_exception(
+        self, 
+        request: 'Request', 
+        exp: Exception, 
+        spider
+    ) -> Optional[Union['Request', 'Response']]:
+        """处理异常
+        
+        Args:
+            request: 发生异常的请求
+            exp: 捕获的异常对象
+            spider: 当前爬虫实例
+            
+        Returns:
+            None: 继续传递异常
+            Request: 重新发起请求
+            Response: 返回响应
+        """
+        pass
+
+    @classmethod
+    def create_instance(cls, crawler):
+        """创建中间件实例
+        
+        Args:
+            crawler: Crawler实例，包含settings等配置
+            
+        Returns:
+            中间件实例
+        """
+        return cls()

crawlo/middleware/default_header.py

@@ -1,132 +1,132 @@
-#!/usr/bin/python
-# -*- coding:UTF-8 -*-
-"""
-DefaultHeaderMiddleware 中间件
-用于为所有请求添加默认请求头，支持随机更换User-Agent等功能
-"""
-
-import random
-from crawlo.utils.log import get_logger
-from crawlo.exceptions import NotConfiguredError
-# 导入User-Agent数据
-from crawlo.data.user_agents import get_user_agents
-
-
-class DefaultHeaderMiddleware(object):
-    """
-    DefaultHeaderMiddleware 中间件
-    用于为所有请求添加默认请求头，包括User-Agent等，支持随机更换功能
-    """
-
-    def __init__(self, settings, log_level):
-        """
-        初始化中间件
-        """
-        self.logger = get_logger(self.__class__.__name__, log_level)
-
-        # 获取默认请求头配置
-        self.headers = settings.get_dict('DEFAULT_REQUEST_HEADERS', {})
-
-        # 获取User-Agent配置
-        self.user_agent = settings.get('USER_AGENT')
-
-        # 获取随机User-Agent列表
-        self.user_agents = settings.get_list('USER_AGENTS', [])
-
-        # 获取随机请求头配置
-        self.random_headers = settings.get_dict('RANDOM_HEADERS', {})
-
-        # 获取随机性配置
-        self.randomness = settings.get_bool("RANDOMNESS", False)
-
-        # 检查是否启用随机User-Agent
-        self.random_user_agent_enabled = settings.get_bool("RANDOM_USER_AGENT_ENABLED", False)
-
-        # 获取User-Agent设备类型
-        self.user_agent_device_type = settings.get("USER_AGENT_DEVICE_TYPE", "all")
-
-        # 如果没有配置默认请求头、User-Agent且没有启用随机功能，则禁用此中间件
-        if not self.headers and not self.user_agent and not self.user_agents and not self.random_headers:
-            raise NotConfiguredError(
-                "未配置DEFAULT_REQUEST_HEADERS、USER_AGENT或随机头部配置，DefaultHeaderMiddleware已禁用")
-
-        # 如果配置了User-Agent，将其添加到默认请求头中
-        if self.user_agent:
-            self.headers.setdefault('User-Agent', self.user_agent)
-
-        # 如果启用了随机User-Agent但没有提供User-Agent列表，使用内置列表
-        if self.random_user_agent_enabled and not self.user_agents:
-            self.user_agents = get_user_agents(self.user_agent_device_type)
-
-        self.logger.debug(f"DefaultHeaderMiddleware已启用 [默认请求头={len(self.headers)}, "
-                          f"User-Agent列表={len(self.user_agents)}, "
-                          f"随机头部={len(self.random_headers)}, "
-                          f"随机功能={'启用' if self.randomness else '禁用'}]")
-
-    @classmethod
-    def create_instance(cls, crawler):
-        """
-        创建中间件实例
-        """
-        o = cls(
-            settings=crawler.settings,
-            log_level=crawler.settings.get('LOG_LEVEL')
-        )
-        return o
-
-    def _get_random_user_agent(self):
-        """
-        获取随机User-Agent
-        """
-        if self.user_agents:
-            return random.choice(self.user_agents)
-        return None
-
-    def _apply_random_headers(self, request):
-        """
-        应用随机请求头
-        """
-        if not self.random_headers:
-            return
-
-        for header_name, header_values in self.random_headers.items():
-            # 如果header_values是列表，随机选择一个值
-            if isinstance(header_values, (list, tuple)):
-                header_value = random.choice(header_values)
-            else:
-                header_value = header_values
-
-            # 只有当请求中没有该头部时才添加
-            if header_name not in request.headers:
-                request.headers[header_name] = header_value
-                self.logger.debug(f"为请求 {request.url} 添加随机头部: {header_name}={header_value[:50]}...")
-
-    def process_request(self, request, _spider):
-        """
-        处理请求，添加默认请求头
-        """
-        # 添加默认请求头
-        if self.headers:
-            added_headers = []
-            for key, value in self.headers.items():
-                # 只有当请求中没有该头部时才添加
-                if key not in request.headers:
-                    request.headers[key] = value
-                    added_headers.append(key)
-
-            # 记录添加的请求头（仅在调试模式下）
-            if added_headers and self.logger.isEnabledFor(10):  # DEBUG level
-                self.logger.debug(f"为请求 {request.url} 添加了 {len(added_headers)} 个默认请求头: {added_headers}")
-
-        # 处理随机User-Agent
-        if self.random_user_agent_enabled and 'User-Agent' not in request.headers:
-            random_ua = self._get_random_user_agent()
-            if random_ua:
-                request.headers['User-Agent'] = random_ua
-                self.logger.debug(f"为请求 {request.url} 设置随机User-Agent: {random_ua[:50]}...")
-
-        # 处理随机请求头
-        if self.randomness:
-            self._apply_random_headers(request)
-
-        return None
+#!/usr/bin/python
+# -*- coding:UTF-8 -*-
+"""
+DefaultHeaderMiddleware 中间件
+用于为所有请求添加默认请求头，支持随机更换User-Agent等功能
+"""
+
+import random
+from crawlo.logging import get_logger
+from crawlo.exceptions import NotConfiguredError
+# 导入User-Agent数据
+from crawlo.data.user_agents import get_user_agents
+
+
+class DefaultHeaderMiddleware(object):
+    """
+    DefaultHeaderMiddleware 中间件
+    用于为所有请求添加默认请求头，包括User-Agent等，支持随机更换功能
+    """
+
+    def __init__(self, settings, log_level):
+        """
+        初始化中间件
+        """
+        self.logger = get_logger(self.__class__.__name__)
+
+        # 获取默认请求头配置
+        self.headers = settings.get_dict('DEFAULT_REQUEST_HEADERS', {})
+
+        # 获取User-Agent配置
+        self.user_agent = settings.get('USER_AGENT')
+
+        # 获取随机User-Agent列表
+        self.user_agents = settings.get_list('USER_AGENTS', [])
+
+        # 获取随机请求头配置
+        self.random_headers = settings.get_dict('RANDOM_HEADERS', {})
+
+        # 获取随机性配置
+        self.randomness = settings.get_bool("RANDOMNESS", False)
+
+        # 检查是否启用随机User-Agent
+        self.random_user_agent_enabled = settings.get_bool("RANDOM_USER_AGENT_ENABLED", False)
+
+        # 获取User-Agent设备类型
+        self.user_agent_device_type = settings.get("USER_AGENT_DEVICE_TYPE", "all")
+
+        # 如果没有配置默认请求头、User-Agent且没有启用随机功能，则禁用此中间件
+        if not self.headers and not self.user_agent and not self.user_agents and not self.random_headers:
+            raise NotConfiguredError(
+                "未配置DEFAULT_REQUEST_HEADERS、USER_AGENT或随机头部配置，DefaultHeaderMiddleware已禁用")
+
+        # 如果配置了User-Agent，将其添加到默认请求头中
+        if self.user_agent:
+            self.headers.setdefault('User-Agent', self.user_agent)
+
+        # 如果启用了随机User-Agent但没有提供User-Agent列表，使用内置列表
+        if self.random_user_agent_enabled and not self.user_agents:
+            self.user_agents = get_user_agents(self.user_agent_device_type)
+
+        self.logger.debug(f"DefaultHeaderMiddleware已启用 [默认请求头={len(self.headers)}, "
+                          f"User-Agent列表={len(self.user_agents)}, "
+                          f"随机头部={len(self.random_headers)}, "
+                          f"随机功能={'启用' if self.randomness else '禁用'}]")
+
+    @classmethod
+    def create_instance(cls, crawler):
+        """
+        创建中间件实例
+        """
+        o = cls(
+            settings=crawler.settings,
+            log_level=crawler.settings.get('LOG_LEVEL')
+        )
+        return o
+
+    def _get_random_user_agent(self):
+        """
+        获取随机User-Agent
+        """
+        if self.user_agents:
+            return random.choice(self.user_agents)
+        return None
+
+    def _apply_random_headers(self, request):
+        """
+        应用随机请求头
+        """
+        if not self.random_headers:
+            return
+
+        for header_name, header_values in self.random_headers.items():
+            # 如果header_values是列表，随机选择一个值
+            if isinstance(header_values, (list, tuple)):
+                header_value = random.choice(header_values)
+            else:
+                header_value = header_values
+
+            # 只有当请求中没有该头部时才添加
+            if header_name not in request.headers:
+                request.headers[header_name] = header_value
+                self.logger.debug(f"为请求 {request.url} 添加随机头部: {header_name}={header_value[:50]}...")
+
+    def process_request(self, request, _spider):
+        """
+        处理请求，添加默认请求头
+        """
+        # 添加默认请求头
+        if self.headers:
+            added_headers = []
+            for key, value in self.headers.items():
+                # 只有当请求中没有该头部时才添加
+                if key not in request.headers:
+                    request.headers[key] = value
+                    added_headers.append(key)
+
+            # 记录添加的请求头（仅在调试模式下）
+            if added_headers and self.logger.isEnabledFor(10):  # DEBUG level
+                self.logger.debug(f"为请求 {request.url} 添加了 {len(added_headers)} 个默认请求头: {added_headers}")
+
+        # 处理随机User-Agent
+        if self.random_user_agent_enabled and 'User-Agent' not in request.headers:
+            random_ua = self._get_random_user_agent()
+            if random_ua:
+                request.headers['User-Agent'] = random_ua
+                self.logger.debug(f"为请求 {request.url} 设置随机User-Agent: {random_ua[:50]}...")
+
+        # 处理随机请求头
+        if self.randomness:
+            self._apply_random_headers(request)
+
+        return None

crawlo/middleware/download_delay.py

@@ -1,105 +1,105 @@
-#!/usr/bin/python
-# -*- coding:UTF-8 -*-
-"""
-DownloadDelayMiddleware 中间件
-用于控制请求之间的延迟时间，支持固定延迟和随机延迟
-"""
-
-from asyncio import sleep
-from random import uniform
-from crawlo.utils.log import get_logger
-from crawlo.exceptions import NotConfiguredError
-
-
-class DownloadDelayMiddleware(object):
-    """
-    DownloadDelayMiddleware 中间件
-    用于控制请求之间的延迟时间，支持固定延迟和随机延迟
-    
-    功能特性:
-    - 支持固定延迟时间
-    - 支持随机延迟时间
-    - 提供详细的日志信息
-    - 记录延迟统计信息
-    """
-
-    def __init__(self, settings, log_level, stats=None):
-        """
-        初始化中间件
-        
-        Args:
-            settings: 设置管理器
-            log_level: 日志级别
-            stats: 统计信息收集器（可选）
-        """
-        self.delay = settings.get_float("DOWNLOAD_DELAY")
-        if not self.delay:
-            raise NotConfiguredError("DOWNLOAD_DELAY not set or is zero")
-            
-        self.randomness = settings.get_bool("RANDOMNESS", False)
-        
-        # 安全地获取随机范围配置
-        random_range = settings.get_list("RANDOM_RANGE")
-        if len(random_range) >= 2:
-            try:
-                self.floor = float(random_range[0])
-                self.upper = float(random_range[1])
-            except (ValueError, TypeError):
-                # 如果配置无效，使用默认值
-                self.floor, self.upper = 0.5, 1.5
-        else:
-            # 如果配置不完整，使用默认值
-            self.floor, self.upper = 0.5, 1.5
-            
-        self.logger = get_logger(self.__class__.__name__, log_level)
-        self.stats = stats
-
-    @classmethod
-    def create_instance(cls, crawler):
-        """
-        创建中间件实例
-        
-        Args:
-            crawler: 爬虫实例
-            
-        Returns:
-            DownloadDelayMiddleware: 中间件实例
-        """
-        o = cls(
-            settings=crawler.settings, 
-            log_level=crawler.settings.get('LOG_LEVEL'),
-            stats=getattr(crawler, 'stats', None)
-        )
-        return o
-
-    async def process_request(self, _request, _spider):
-        """
-        处理请求，添加延迟
-        
-        Args:
-            _request: 请求对象
-            _spider: 爬虫实例
-        """
-        if self.randomness:
-            # 计算随机延迟时间
-            delay_time = uniform(self.delay * self.floor, self.delay * self.upper)
-            await sleep(delay_time)
-            
-            # 记录统计信息
-            if self.stats:
-                self.stats.inc_value('download_delay/random_count')
-                self.stats.inc_value('download_delay/random_total_time', delay_time)
-                
-            # 记录日志
-            self.logger.debug(f"应用随机延迟: {delay_time:.2f}秒 (范围: {self.delay * self.floor:.2f} - {self.delay * self.upper:.2f})")
-        else:
-            # 应用固定延迟
-            await sleep(self.delay)
-            
-            # 记录统计信息
-            if self.stats:
-                self.stats.inc_value('download_delay/fixed_count')
-                self.stats.inc_value('download_delay/fixed_total_time', self.delay)
-                
-            # 记录日志
+#!/usr/bin/python
+# -*- coding:UTF-8 -*-
+"""
+DownloadDelayMiddleware 中间件
+用于控制请求之间的延迟时间，支持固定延迟和随机延迟
+"""
+
+from asyncio import sleep
+from random import uniform
+from crawlo.logging import get_logger
+from crawlo.exceptions import NotConfiguredError
+
+
+class DownloadDelayMiddleware(object):
+    """
+    DownloadDelayMiddleware 中间件
+    用于控制请求之间的延迟时间，支持固定延迟和随机延迟
+    
+    功能特性:
+    - 支持固定延迟时间
+    - 支持随机延迟时间
+    - 提供详细的日志信息
+    - 记录延迟统计信息
+    """
+
+    def __init__(self, settings, log_level, stats=None):
+        """
+        初始化中间件
+        
+        Args:
+            settings: 设置管理器
+            log_level: 日志级别
+            stats: 统计信息收集器（可选）
+        """
+        self.delay = settings.get_float("DOWNLOAD_DELAY")
+        if not self.delay:
+            raise NotConfiguredError("DOWNLOAD_DELAY not set or is zero")
+            
+        self.randomness = settings.get_bool("RANDOMNESS", False)
+        
+        # 安全地获取随机范围配置
+        random_range = settings.get_list("RANDOM_RANGE")
+        if len(random_range) >= 2:
+            try:
+                self.floor = float(random_range[0])
+                self.upper = float(random_range[1])
+            except (ValueError, TypeError):
+                # 如果配置无效，使用默认值
+                self.floor, self.upper = 0.5, 1.5
+        else:
+            # 如果配置不完整，使用默认值
+            self.floor, self.upper = 0.5, 1.5
+            
+        self.logger = get_logger(self.__class__.__name__)
+        self.stats = stats
+
+    @classmethod
+    def create_instance(cls, crawler):
+        """
+        创建中间件实例
+        
+        Args:
+            crawler: 爬虫实例
+            
+        Returns:
+            DownloadDelayMiddleware: 中间件实例
+        """
+        o = cls(
+            settings=crawler.settings, 
+            log_level=crawler.settings.get('LOG_LEVEL'),
+            stats=getattr(crawler, 'stats', None)
+        )
+        return o
+
+    async def process_request(self, _request, _spider):
+        """
+        处理请求，添加延迟
+        
+        Args:
+            _request: 请求对象
+            _spider: 爬虫实例
+        """
+        if self.randomness:
+            # 计算随机延迟时间
+            delay_time = uniform(self.delay * self.floor, self.delay * self.upper)
+            await sleep(delay_time)
+            
+            # 记录统计信息
+            if self.stats:
+                self.stats.inc_value('download_delay/random_count')
+                self.stats.inc_value('download_delay/random_total_time', delay_time)
+                
+            # 记录日志
+            self.logger.debug(f"应用随机延迟: {delay_time:.2f}秒 (范围: {self.delay * self.floor:.2f} - {self.delay * self.upper:.2f})")
+        else:
+            # 应用固定延迟
+            await sleep(self.delay)
+            
+            # 记录统计信息
+            if self.stats:
+                self.stats.inc_value('download_delay/fixed_count')
+                self.stats.inc_value('download_delay/fixed_total_time', self.delay)
+                
+            # 记录日志
             self.logger.debug(f"应用固定延迟: {self.delay:.2f}秒")