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

crawlo/task_manager.py

@@ -1,139 +1,139 @@
-#!/usr/bin/python
-# -*- coding:UTF-8 -*-
-import asyncio
-from asyncio import Task, Future, Semaphore
-from typing import Set, Final
-from collections import deque
-import time
-from crawlo.utils.log import get_logger
-
-
-class DynamicSemaphore(Semaphore):
-    """支持动态调整的信号量"""
-    
-    def __init__(self, initial_value: int = 8):
-        super().__init__(initial_value)
-        self._initial_value = initial_value
-        self._current_value = initial_value
-        self._response_times = deque(maxlen=10)  # 存储最近10次响应时间
-        self._last_adjust_time = time.time()
-        
-    def record_response_time(self, response_time: float):
-        """记录响应时间"""
-        self._response_times.append(response_time)
-        
-    def adjust_concurrency(self):
-        """根据响应时间动态调整并发数"""
-        current_time = time.time()
-        # 限制调整频率，至少间隔1秒（从2秒减少到1秒）
-        if current_time - self._last_adjust_time < 1:
-            return
-            
-        self._last_adjust_time = current_time
-        
-        if len(self._response_times) < 2:  # 从3减少到2
-            return
-            
-        # 计算平均响应时间
-        avg_response_time = sum(self._response_times) / len(self._response_times)
-        
-        # 根据响应时间调整并发数
-        if avg_response_time < 0.2:  # 响应很快，增加并发（从0.3降到0.2）
-            new_concurrency = min(self._current_value + 5, self._initial_value * 3)  # 增加幅度从3提高到5，最大值从2倍提高到3倍
-        elif avg_response_time > 1.0:  # 响应较慢，减少并发（从1.5降到1.0）
-            new_concurrency = max(self._current_value - 5, max(1, self._initial_value // 3))  # 减少幅度从3提高到5，最小值从一半降低到三分之一
-        else:
-            return  # 保持当前并发数
-            
-        # 只有当变化较大时才调整
-        if abs(new_concurrency - self._current_value) > 1:
-            self._adjust_semaphore_value(new_concurrency)
-    
-    def _adjust_semaphore_value(self, new_value: int):
-        """调整信号量的值"""
-        if new_value > self._current_value:
-            # 增加信号量
-            for _ in range(new_value - self._current_value):
-                self.release()
-        elif new_value < self._current_value:
-            # 减少信号量，这里只是记录新的目标值
-            # 实际减少会在acquire时处理
-            pass
-            
-        self._current_value = new_value
-        # 注意：Python的Semaphore没有直接修改内部计数器的方法
-        # 所以我们只能通过release()来增加，减少则需要在acquire时控制
-
-
-class TaskManager:
-
-    def __init__(self, total_concurrency: int = 8):
-        self.current_task: Final[Set] = set()
-        # 使用动态信号量替代普通信号量
-        self.semaphore: DynamicSemaphore = DynamicSemaphore(max(1, total_concurrency))
-        self.logger = get_logger(self.__class__.__name__)
-        
-        # 异常统计
-        self._exception_count = 0
-        self._total_tasks = 0
-
-    async def create_task(self, coroutine) -> Task:
-        # 等待信号量，控制并发数
-        await self.semaphore.acquire()
-        
-        task = asyncio.create_task(coroutine)
-        self.current_task.add(task)
-        self._total_tasks += 1
-
-        def done_callback(_future: Future) -> None:
-            try:
-                self.current_task.discard(task)  # 使用discard而不是remove，避免KeyError
-                
-                # 获取任务结果或异常 - 这是关键，必须调用result()或exception()来"获取"异常
-                try:
-                    # 尝试获取结果，如果有异常会被抛出
-                    result = _future.result()
-                    # 如果成功完成，可以在这里记录成功统计
-                except Exception as exception:
-                    # 异常被正确"获取"了，不会再出现"never retrieved"警告
-                    self._exception_count += 1
-                    
-                    # 记录异常详情
-                    self.logger.error(
-                        f"Task completed with exception: {type(exception).__name__}: {exception}"
-                    )
-                    self.logger.debug("Task exception details:", exc_info=exception)
-                    
-                    # 可以在这里添加更多的异常处理逻辑，如发送到监控系统
-                    
-            except Exception as e:
-                # 防止回调函数本身出现异常
-                self.logger.error(f"Error in task done callback: {e}")
-            finally:
-                # 确保信号量始终被释放
-                self.semaphore.release()
-                
-                # 定期调整并发数（从每3个任务调整一次改为每2个任务调整一次）
-                if self._total_tasks % 2 == 0:
-                    self.semaphore.adjust_concurrency()
-
-        task.add_done_callback(done_callback)
-
-        return task
-
-    def all_done(self) -> bool:
-        return len(self.current_task) == 0
-    
-    def record_response_time(self, response_time: float):
-        """记录任务的响应时间，用于动态调整并发数"""
-        self.semaphore.record_response_time(response_time)
-    
-    def get_stats(self) -> dict:
-        """获取任务管理器统计信息"""
-        return {
-            'active_tasks': len(self.current_task),
-            'total_tasks': self._total_tasks,
-            'exception_count': self._exception_count,
-            'success_rate': (self._total_tasks - self._exception_count) / max(1, self._total_tasks) * 100,
-            'current_concurrency': self.semaphore._current_value
+#!/usr/bin/python
+# -*- coding:UTF-8 -*-
+import asyncio
+from asyncio import Task, Future, Semaphore
+from typing import Set, Final
+from collections import deque
+import time
+from crawlo.utils.log import get_logger
+
+
+class DynamicSemaphore(Semaphore):
+    """支持动态调整的信号量"""
+    
+    def __init__(self, initial_value: int = 8):
+        super().__init__(initial_value)
+        self._initial_value = initial_value
+        self._current_value = initial_value
+        self._response_times = deque(maxlen=10)  # 存储最近10次响应时间
+        self._last_adjust_time = time.time()
+        
+    def record_response_time(self, response_time: float):
+        """记录响应时间"""
+        self._response_times.append(response_time)
+        
+    def adjust_concurrency(self):
+        """根据响应时间动态调整并发数"""
+        current_time = time.time()
+        # 限制调整频率，至少间隔1秒（从2秒减少到1秒）
+        if current_time - self._last_adjust_time < 1:
+            return
+            
+        self._last_adjust_time = current_time
+        
+        if len(self._response_times) < 2:  # 从3减少到2
+            return
+            
+        # 计算平均响应时间
+        avg_response_time = sum(self._response_times) / len(self._response_times)
+        
+        # 根据响应时间调整并发数
+        if avg_response_time < 0.2:  # 响应很快，增加并发（从0.3降到0.2）
+            new_concurrency = min(self._current_value + 5, self._initial_value * 3)  # 增加幅度从3提高到5，最大值从2倍提高到3倍
+        elif avg_response_time > 1.0:  # 响应较慢，减少并发（从1.5降到1.0）
+            new_concurrency = max(self._current_value - 5, max(1, self._initial_value // 3))  # 减少幅度从3提高到5，最小值从一半降低到三分之一
+        else:
+            return  # 保持当前并发数
+            
+        # 只有当变化较大时才调整
+        if abs(new_concurrency - self._current_value) > 1:
+            self._adjust_semaphore_value(new_concurrency)
+    
+    def _adjust_semaphore_value(self, new_value: int):
+        """调整信号量的值"""
+        if new_value > self._current_value:
+            # 增加信号量
+            for _ in range(new_value - self._current_value):
+                self.release()
+        elif new_value < self._current_value:
+            # 减少信号量，这里只是记录新的目标值
+            # 实际减少会在acquire时处理
+            pass
+            
+        self._current_value = new_value
+        # 注意：Python的Semaphore没有直接修改内部计数器的方法
+        # 所以我们只能通过release()来增加，减少则需要在acquire时控制
+
+
+class TaskManager:
+
+    def __init__(self, total_concurrency: int = 8):
+        self.current_task: Final[Set] = set()
+        # 使用动态信号量替代普通信号量
+        self.semaphore: DynamicSemaphore = DynamicSemaphore(max(1, total_concurrency))
+        self.logger = get_logger(self.__class__.__name__)
+        
+        # 异常统计
+        self._exception_count = 0
+        self._total_tasks = 0
+
+    async def create_task(self, coroutine) -> Task:
+        # 等待信号量，控制并发数
+        await self.semaphore.acquire()
+        
+        task = asyncio.create_task(coroutine)
+        self.current_task.add(task)
+        self._total_tasks += 1
+
+        def done_callback(_future: Future) -> None:
+            try:
+                self.current_task.discard(task)  # 使用discard而不是remove，避免KeyError
+                
+                # 获取任务结果或异常 - 这是关键，必须调用result()或exception()来"获取"异常
+                try:
+                    # 尝试获取结果，如果有异常会被抛出
+                    result = _future.result()
+                    # 如果成功完成，可以在这里记录成功统计
+                except Exception as exception:
+                    # 异常被正确"获取"了，不会再出现"never retrieved"警告
+                    self._exception_count += 1
+                    
+                    # 记录异常详情
+                    self.logger.error(
+                        f"Task completed with exception: {type(exception).__name__}: {exception}"
+                    )
+                    self.logger.debug("Task exception details:", exc_info=exception)
+                    
+                    # 可以在这里添加更多的异常处理逻辑，如发送到监控系统
+                    
+            except Exception as e:
+                # 防止回调函数本身出现异常
+                self.logger.error(f"Error in task done callback: {e}")
+            finally:
+                # 确保信号量始终被释放
+                self.semaphore.release()
+                
+                # 定期调整并发数（从每3个任务调整一次改为每2个任务调整一次）
+                if self._total_tasks % 2 == 0:
+                    self.semaphore.adjust_concurrency()
+
+        task.add_done_callback(done_callback)
+
+        return task
+
+    def all_done(self) -> bool:
+        return len(self.current_task) == 0
+    
+    def record_response_time(self, response_time: float):
+        """记录任务的响应时间，用于动态调整并发数"""
+        self.semaphore.record_response_time(response_time)
+    
+    def get_stats(self) -> dict:
+        """获取任务管理器统计信息"""
+        return {
+            'active_tasks': len(self.current_task),
+            'total_tasks': self._total_tasks,
+            'exception_count': self._exception_count,
+            'success_rate': (self._total_tasks - self._exception_count) / max(1, self._total_tasks) * 100,
+            'current_concurrency': self.semaphore._current_value
         }

crawlo/templates/crawlo.cfg.tmpl

@@ -1,11 +1,11 @@
-# crawlo.cfg
-# 项目的配置文件。
-
-[settings]
-# 指定 settings 模块的导入路径
-default = {{project_name}}.settings
-
-[deploy]
-# （可选）用于部署配置
-# url = http://localhost:6800/
+# crawlo.cfg
+# 项目的配置文件。
+
+[settings]
+# 指定 settings 模块的导入路径
+default = {{project_name}}.settings
+
+[deploy]
+# （可选）用于部署配置
+# url = http://localhost:6800/
 # project = {{project_name}}

crawlo/templates/project/__init__.py.tmpl

@@ -1,4 +1,4 @@
-# -*- coding: UTF-8 -*-
-"""
-{{project_name}} 项目包
+# -*- coding: UTF-8 -*-
+"""
+{{project_name}} 项目包
 """

crawlo/templates/project/items.py.tmpl

@@ -1,18 +1,18 @@
-# -*- coding: UTF-8 -*-
-"""
-{{project_name}}.items
-======================
-定义你抓取的数据结构。
-"""
-
-from crawlo.items import Item, Field
-
-
-class ExampleItem(Item):
-    """
-    一个示例数据项。
-    """
-    id = Field()
-    # price = Field()
-    # description = Field()
+# -*- coding: UTF-8 -*-
+"""
+{{project_name}}.items
+======================
+定义你抓取的数据结构。
+"""
+
+from crawlo.items import Item, Field
+
+
+class ExampleItem(Item):
+    """
+    一个示例数据项。
+    """
+    id = Field()
+    # price = Field()
+    # description = Field()
     pass

crawlo/templates/project/middlewares.py.tmpl

@@ -1,119 +1,119 @@
-# -*- coding: UTF-8 -*-
-"""
-{{project_name}}.middlewares
-============================
-自定义中间件，用于在请求/响应/异常处理过程中插入自定义逻辑。
-
-这是一个简单的示例中间件，您可以根据需要添加更多中间件。
-"""
-
-import random
-from crawlo import Request, Response
-from crawlo.utils.log import get_logger
-
-
-class ExampleMiddleware:
-    """
-    示例中间件，演示如何处理请求、响应和异常。
-    
-    此中间件会：
-    1. 为请求添加随机 User-Agent
-    2. 记录请求和响应信息
-    3. 处理异常情况
-    """
-    
-    def __init__(self):
-        self.logger = get_logger(self.__class__.__name__)
-        self.user_agents = [
-            'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36',
-            'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36',
-            'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:135.0) Gecko/20100101 Firefox/135.0',
-            'Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:135.0) Gecko/20100101 Firefox/135.0',
-        ]
-
-    def process_request(self, request, spider):
-        """
-        在请求被下载器执行前调用。
-        
-        Args:
-            request: 请求对象
-            spider: 爬虫实例
-            
-        Returns:
-            None: 继续处理请求
-            Response: 返回响应对象（短路处理）
-            Request: 返回新请求对象（替换原请求）
-        """
-        # 为请求添加随机 User-Agent
-        if 'User-Agent' not in request.headers:
-            ua = random.choice(self.user_agents)
-            request.headers['User-Agent'] = ua
-            self.logger.debug(f"为请求 {request.url} 设置 User-Agent: {ua[:50]}...")
-        
-        return None
-
-    def process_response(self, request, response, spider):
-        """
-        在响应被 Spider 处理前调用。
-        
-        Args:
-            request: 原始请求对象
-            response: 响应对象
-            spider: 爬虫实例
-            
-        Returns:
-            Response: 处理后的响应对象
-        """
-        # 记录响应信息
-        self.logger.info(f"收到响应: {request.url} - 状态码: {response.status_code}")
-        
-        # 可以在这里处理特殊状态码
-        if response.status_code == 403:
-            self.logger.warning(f"访问被拒绝: {request.url}")
-        
-        return response
-
-    def process_exception(self, request, exception, spider):
-        """
-        在下载或处理过程中发生异常时调用。
-        
-        Args:
-            request: 请求对象
-            exception: 异常对象
-            spider: 爬虫实例
-            
-        Returns:
-            None: 异常将继续传播
-            Response: 返回响应对象（处理异常）
-            Request: 返回新请求对象（重试请求）
-        """
-        self.logger.error(f"请求异常: {request.url} - {exception}")
-        return None
-
-
-# ======================== 使用说明 ========================
-# 
-# 在 settings.py 中启用中间件：
-# MIDDLEWARES = [
-#     '{{project_name}}.middlewares.ExampleMiddleware',
-# ]
-# 
-# 您可以根据需要添加更多中间件，例如：
-# 1. 请求处理中间件（修改请求头、设置代理等）
-# 2. 响应处理中间件（解析、过滤等）
-# 3. 异常处理中间件（重试、记录等）
-# 
-# 每个中间件可以实现以下方法：
-# - process_request: 处理请求
-# - process_response: 处理响应
-# - process_exception: 处理异常
-# 
-# 注意：Crawlo框架提供了许多内置中间件，您可以直接使用：
-# - DownloadDelayMiddleware: 控制请求延迟
-# - ResponseCodeMiddleware: 处理HTTP状态码并记录统计信息
-# - ResponseFilterMiddleware: 过滤特定状态码的响应
-# - DefaultHeaderMiddleware: 添加默认请求头
-# - ProxyMiddleware: 设置代理
-# - RetryMiddleware: 处理重试逻辑
-# - OffsiteMiddleware: 过滤站外请求
+# -*- coding: UTF-8 -*-
+"""
+{{project_name}}.middlewares
+============================
+自定义中间件，用于在请求/响应/异常处理过程中插入自定义逻辑。
+
+这是一个简单的示例中间件，您可以根据需要添加更多中间件。
+"""
+
+import random
+from crawlo import Request, Response
+from crawlo.utils.log import get_logger
+
+
+class ExampleMiddleware:
+    """
+    示例中间件，演示如何处理请求、响应和异常。
+    
+    此中间件会：
+    1. 为请求添加随机 User-Agent
+    2. 记录请求和响应信息
+    3. 处理异常情况
+    """
+    
+    def __init__(self):
+        self.logger = get_logger(self.__class__.__name__)
+        self.user_agents = [
+            'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36',
+            'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36',
+            'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:135.0) Gecko/20100101 Firefox/135.0',
+            'Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:135.0) Gecko/20100101 Firefox/135.0',
+        ]
+
+    def process_request(self, request, spider):
+        """
+        在请求被下载器执行前调用。
+        
+        Args:
+            request: 请求对象
+            spider: 爬虫实例
+            
+        Returns:
+            None: 继续处理请求
+            Response: 返回响应对象（短路处理）
+            Request: 返回新请求对象（替换原请求）
+        """
+        # 为请求添加随机 User-Agent
+        if 'User-Agent' not in request.headers:
+            ua = random.choice(self.user_agents)
+            request.headers['User-Agent'] = ua
+            self.logger.debug(f"为请求 {request.url} 设置 User-Agent: {ua[:50]}...")
+        
+        return None
+
+    def process_response(self, request, response, spider):
+        """
+        在响应被 Spider 处理前调用。
+        
+        Args:
+            request: 原始请求对象
+            response: 响应对象
+            spider: 爬虫实例
+            
+        Returns:
+            Response: 处理后的响应对象
+        """
+        # 记录响应信息
+        self.logger.info(f"收到响应: {request.url} - 状态码: {response.status_code}")
+        
+        # 可以在这里处理特殊状态码
+        if response.status_code == 403:
+            self.logger.warning(f"访问被拒绝: {request.url}")
+        
+        return response
+
+    def process_exception(self, request, exception, spider):
+        """
+        在下载或处理过程中发生异常时调用。
+        
+        Args:
+            request: 请求对象
+            exception: 异常对象
+            spider: 爬虫实例
+            
+        Returns:
+            None: 异常将继续传播
+            Response: 返回响应对象（处理异常）
+            Request: 返回新请求对象（重试请求）
+        """
+        self.logger.error(f"请求异常: {request.url} - {exception}")
+        return None
+
+
+# ======================== 使用说明 ========================
+# 
+# 在 settings.py 中启用中间件：
+# MIDDLEWARES = [
+#     '{{project_name}}.middlewares.ExampleMiddleware',
+# ]
+# 
+# 您可以根据需要添加更多中间件，例如：
+# 1. 请求处理中间件（修改请求头、设置代理等）
+# 2. 响应处理中间件（解析、过滤等）
+# 3. 异常处理中间件（重试、记录等）
+# 
+# 每个中间件可以实现以下方法：
+# - process_request: 处理请求
+# - process_response: 处理响应
+# - process_exception: 处理异常
+# 
+# 注意：Crawlo框架提供了许多内置中间件，您可以直接使用：
+# - DownloadDelayMiddleware: 控制请求延迟
+# - ResponseCodeMiddleware: 处理HTTP状态码并记录统计信息
+# - ResponseFilterMiddleware: 过滤特定状态码的响应
+# - DefaultHeaderMiddleware: 添加默认请求头
+# - ProxyMiddleware: 设置代理
+# - RetryMiddleware: 处理重试逻辑
+# - OffsiteMiddleware: 过滤站外请求
 # ======================== 使用说明 ========================