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

crawlo/stats_collector.py

@@ -1,59 +1,73 @@
-#!/usr/bin/python
-# -*- coding:UTF-8 -*-
-"""
-# @Time    :    2025-05-17 09:57
-# @Author  :   crawl-coder
-# @Desc    :   统计信息收集器
-"""
-from pprint import pformat
-from crawlo.utils.log import get_logger
-
-
-class StatsCollector(object):
-
-    def __init__(self, crawler):
-        self.crawler = crawler
-        self._dump = self.crawler.settings.get_bool('STATS_DUMP')
-        self._stats = {}
-        self.logger = get_logger(self.__class__.__name__, "INFO")
-
-    def inc_value(self, key, count=1, start=0):
-        self._stats[key] = self._stats.setdefault(key, start) + count
-
-    def get_value(self, key, default=None):
-        return self._stats.get(key, default)
-
-    def get_stats(self):
-        return self._stats
-
-    def set_stats(self, stats):
-        self._stats = stats
-
-    def clear_stats(self):
-        self._stats.clear()
-
-    def close_spider(self, spider, reason):
-        self._stats['reason'] = reason
-
-        # 首选：使用 spider.name
-        # 次选：使用实例的类名
-        # 最后：使用一个完全未知的占位符
-        spider_name = (
-                getattr(spider, 'name', None) or
-                spider.__class__.__name__ or
-                '<Unknown>'
-        )
-
-        self._stats['spider_name'] = spider_name
-
-        if self._dump:
-            self.logger.info(f'{spider_name} stats: \n{pformat(self._stats)}')
-
-    def __getitem__(self, item):
-        return self._stats[item]
-
-    def __setitem__(self, key, value):
-        self._stats[key] = value
-
-    def __delitem__(self, key):
-        del self._stats[key]
+#!/usr/bin/python
+# -*- coding:UTF-8 -*-
+"""
+# @Time    :    2025-05-17 09:57
+# @Author  :   crawl-coder
+# @Desc    :   统计信息收集器
+"""
+from pprint import pformat
+from crawlo.utils.log import get_logger
+
+
+class StatsCollector(object):
+
+    def __init__(self, crawler):
+        self.crawler = crawler
+        self._dump = self.crawler.settings.get_bool('STATS_DUMP')
+        self._stats = {}
+        self.logger = get_logger(self.__class__.__name__, "INFO")
+
+    def inc_value(self, key, count=1, start=0):
+        self._stats[key] = self._stats.setdefault(key, start) + count
+
+    def get_value(self, key, default=None):
+        return self._stats.get(key, default)
+
+    def get_stats(self):
+        return self._stats
+
+    def set_stats(self, stats):
+        self._stats = stats
+
+    def clear_stats(self):
+        self._stats.clear()
+
+    def close_spider(self, spider, reason):
+        self._stats['reason'] = reason
+
+        # 首选：使用 spider.name
+        # 次选：使用实例的类名
+        # 最后：使用一个完全未知的占位符
+        spider_name = (
+                getattr(spider, 'name', None) or
+                spider.__class__.__name__ or
+                '<Unknown>'
+        )
+
+        self._stats['spider_name'] = spider_name
+
+    def __getitem__(self, item):
+        return self._stats[item]
+
+    def __setitem__(self, key, value):
+        self._stats[key] = value
+
+    def __delitem__(self, key):
+        del self._stats[key]
+
+    def close(self):
+        """关闭统计收集器并输出统计信息"""
+        if self._dump:
+            # 获取爬虫名称
+            spider_name = self._stats.get('spider_name', 'unknown')
+            
+            # 如果还没有设置爬虫名称，尝试从crawler中获取
+            if spider_name == 'unknown' and hasattr(self, 'crawler') and self.crawler:
+                spider = getattr(self.crawler, 'spider', None)
+                if spider and hasattr(spider, 'name'):
+                    spider_name = spider.name
+                    # 同时更新_stats中的spider_name
+                    self._stats['spider_name'] = spider_name
+            
+            # 输出统计信息（这是唯一输出统计信息的地方）
+            self.logger.info(f'{spider_name} stats: \n{pformat(self._stats)}')

crawlo/subscriber.py

@@ -1,130 +1,130 @@
-#!/usr/bin/python
-# -*- coding:UTF-8 -*-
-import asyncio
-from collections import defaultdict
-from inspect import iscoroutinefunction
-from typing import Dict, Callable, Coroutine, Any, TypeAlias, List, Tuple
-
-
-class ReceiverTypeError(TypeError):
-    """当订阅的接收者不是一个协程函数时抛出。"""
-    pass
-
-
-ReceiverCoroutine: TypeAlias = Callable[..., Coroutine[Any, Any, Any]]
-
-
-class Subscriber:
-    """
-    一个支持异步协程的发布/订阅（Pub/Sub）模式实现。
-
-    这个类允许你注册（订阅）协程函数来监听特定事件，并在事件发生时
-    以并发的方式异步地通知所有订阅者。
-    """
-
-    def __init__(self):
-        """初始化一个空的订阅者字典。"""
-        # 使用弱引用字典避免内存泄漏
-        self._subscribers: Dict[str, Dict[ReceiverCoroutine, int]] = defaultdict(dict)
-        # 用于缓存排序后的订阅者列表，提高频繁事件的处理性能
-        self._sorted_subscribers_cache: Dict[str, List[Tuple[ReceiverCoroutine, int]]] = {}
-
-    def subscribe(self, receiver: ReceiverCoroutine, *, event: str, priority: int = 0) -> None:
-        """
-        订阅一个事件。
-
-        Args:
-            receiver: 一个协程函数 (例如 async def my_func(...))。
-            event: 要订阅的事件名称。
-            priority: 订阅者优先级，数值越小优先级越高，默认为0。
-
-        Raises:
-            ReceiverTypeError: 如果提供的 `receiver` 不是一个协程函数。
-        """
-        if not iscoroutinefunction(receiver):
-            raise ReceiverTypeError(f"接收者 '{receiver.__qualname__}' 必须是一个协程函数。")
-        
-        # 使用弱引用避免内存泄漏
-        self._subscribers[event][receiver] = priority
-        # 清除缓存
-        self._sorted_subscribers_cache.pop(event, None)
-
-    def unsubscribe(self, receiver: ReceiverCoroutine, *, event: str) -> None:
-        """
-        取消订阅一个事件。
-
-        如果事件或接收者不存在，将静默处理。
-
-        Args:
-            receiver: 要取消订阅的协程函数。
-            event: 事件名称。
-        """
-        if event in self._subscribers:
-            self._subscribers[event].pop(receiver, None)
-            # 清除缓存
-            self._sorted_subscribers_cache.pop(event, None)
-
-    def _get_sorted_subscribers(self, event: str) -> List[Tuple[ReceiverCoroutine, int]]:
-        """
-        获取按优先级排序的订阅者列表。
-        
-        Args:
-            event: 事件名称。
-            
-        Returns:
-            按优先级排序的订阅者列表。
-        """
-        # 检查缓存
-        if event in self._sorted_subscribers_cache:
-            return self._sorted_subscribers_cache[event]
-        
-        # 获取有效的订阅者（使用弱引用检查）
-        valid_subscribers = {}
-        for receiver, priority in list(self._subscribers[event].items()):
-            # 检查弱引用是否仍然有效
-            if isinstance(receiver, Callable):
-                valid_subscribers[receiver] = priority
-        
-        # 更新订阅者字典
-        self._subscribers[event] = valid_subscribers
-        
-        # 按优先级排序（数值小的优先级高）
-        sorted_subscribers = sorted(valid_subscribers.items(), key=lambda x: x[1])
-        # 缓存结果
-        self._sorted_subscribers_cache[event] = sorted_subscribers
-        
-        return sorted_subscribers
-
-    async def notify(self, event: str, *args, **kwargs) -> List[Any]:
-        """
-        异步地、并发地通知所有订阅了该事件的接收者。
-
-        此方法会等待所有订阅者任务完成后再返回，并收集所有结果或异常。
-        订阅者按优先级顺序执行，优先级高的先执行。
-
-        Args:
-            event: 要触发的事件名称。
-            *args: 传递给接收者的位置参数。
-            **kwargs: 传递给接收者的关键字参数。
-
-        Returns:
-            一个列表，包含每个订阅者任务的返回结果或在执行期间捕获的异常。
-        """
-        sorted_subscribers = self._get_sorted_subscribers(event)
-        if not sorted_subscribers:
-            return []
-
-        # 为频繁触发的事件重用任务对象以提高性能
-        tasks = []
-        for receiver, _ in sorted_subscribers:
-            try:
-                # 创建任务并添加到列表
-                task = asyncio.create_task(receiver(*args, **kwargs))
-                tasks.append(task)
-            except Exception as e:
-                # 如果创建任务失败，记录异常并继续处理其他订阅者
-                tasks.append(asyncio.Future())  # 添加一个已完成的Future表示错误
-                tasks[-1].set_exception(e)
-
-        # 并发执行所有任务并返回结果列表（包括异常）
+#!/usr/bin/python
+# -*- coding:UTF-8 -*-
+import asyncio
+from collections import defaultdict
+from inspect import iscoroutinefunction
+from typing import Dict, Callable, Coroutine, Any, TypeAlias, List, Tuple
+
+
+class ReceiverTypeError(TypeError):
+    """当订阅的接收者不是一个协程函数时抛出。"""
+    pass
+
+
+ReceiverCoroutine: TypeAlias = Callable[..., Coroutine[Any, Any, Any]]
+
+
+class Subscriber:
+    """
+    一个支持异步协程的发布/订阅（Pub/Sub）模式实现。
+
+    这个类允许你注册（订阅）协程函数来监听特定事件，并在事件发生时
+    以并发的方式异步地通知所有订阅者。
+    """
+
+    def __init__(self):
+        """初始化一个空的订阅者字典。"""
+        # 使用弱引用字典避免内存泄漏
+        self._subscribers: Dict[str, Dict[ReceiverCoroutine, int]] = defaultdict(dict)
+        # 用于缓存排序后的订阅者列表，提高频繁事件的处理性能
+        self._sorted_subscribers_cache: Dict[str, List[Tuple[ReceiverCoroutine, int]]] = {}
+
+    def subscribe(self, receiver: ReceiverCoroutine, *, event: str, priority: int = 0) -> None:
+        """
+        订阅一个事件。
+
+        Args:
+            receiver: 一个协程函数 (例如 async def my_func(...))。
+            event: 要订阅的事件名称。
+            priority: 订阅者优先级，数值越小优先级越高，默认为0。
+
+        Raises:
+            ReceiverTypeError: 如果提供的 `receiver` 不是一个协程函数。
+        """
+        if not iscoroutinefunction(receiver):
+            raise ReceiverTypeError(f"接收者 '{receiver.__qualname__}' 必须是一个协程函数。")
+        
+        # 使用弱引用避免内存泄漏
+        self._subscribers[event][receiver] = priority
+        # 清除缓存
+        self._sorted_subscribers_cache.pop(event, None)
+
+    def unsubscribe(self, receiver: ReceiverCoroutine, *, event: str) -> None:
+        """
+        取消订阅一个事件。
+
+        如果事件或接收者不存在，将静默处理。
+
+        Args:
+            receiver: 要取消订阅的协程函数。
+            event: 事件名称。
+        """
+        if event in self._subscribers:
+            self._subscribers[event].pop(receiver, None)
+            # 清除缓存
+            self._sorted_subscribers_cache.pop(event, None)
+
+    def _get_sorted_subscribers(self, event: str) -> List[Tuple[ReceiverCoroutine, int]]:
+        """
+        获取按优先级排序的订阅者列表。
+        
+        Args:
+            event: 事件名称。
+            
+        Returns:
+            按优先级排序的订阅者列表。
+        """
+        # 检查缓存
+        if event in self._sorted_subscribers_cache:
+            return self._sorted_subscribers_cache[event]
+        
+        # 获取有效的订阅者（使用弱引用检查）
+        valid_subscribers = {}
+        for receiver, priority in list(self._subscribers[event].items()):
+            # 检查弱引用是否仍然有效
+            if isinstance(receiver, Callable):
+                valid_subscribers[receiver] = priority
+        
+        # 更新订阅者字典
+        self._subscribers[event] = valid_subscribers
+        
+        # 按优先级排序（数值小的优先级高）
+        sorted_subscribers = sorted(valid_subscribers.items(), key=lambda x: x[1])
+        # 缓存结果
+        self._sorted_subscribers_cache[event] = sorted_subscribers
+        
+        return sorted_subscribers
+
+    async def notify(self, event: str, *args, **kwargs) -> List[Any]:
+        """
+        异步地、并发地通知所有订阅了该事件的接收者。
+
+        此方法会等待所有订阅者任务完成后再返回，并收集所有结果或异常。
+        订阅者按优先级顺序执行，优先级高的先执行。
+
+        Args:
+            event: 要触发的事件名称。
+            *args: 传递给接收者的位置参数。
+            **kwargs: 传递给接收者的关键字参数。
+
+        Returns:
+            一个列表，包含每个订阅者任务的返回结果或在执行期间捕获的异常。
+        """
+        sorted_subscribers = self._get_sorted_subscribers(event)
+        if not sorted_subscribers:
+            return []
+
+        # 为频繁触发的事件重用任务对象以提高性能
+        tasks = []
+        for receiver, _ in sorted_subscribers:
+            try:
+                # 创建任务并添加到列表
+                task = asyncio.create_task(receiver(*args, **kwargs))
+                tasks.append(task)
+            except Exception as e:
+                # 如果创建任务失败，记录异常并继续处理其他订阅者
+                tasks.append(asyncio.Future())  # 添加一个已完成的Future表示错误
+                tasks[-1].set_exception(e)
+
+        # 并发执行所有任务并返回结果列表（包括异常）
         return await asyncio.gather(*tasks, return_exceptions=True)

crawlo/task_manager.py

@@ -1,30 +1,139 @@
-#!/usr/bin/python
-# -*- coding:UTF-8 -*-
-import asyncio
-from asyncio import Task, Future, Semaphore
-from typing import Set, Final
-
-
-class TaskManager:
-
-    def __init__(self, total_concurrency: int = 8):
-        self.current_task: Final[Set] = set()
-        self.semaphore: Semaphore = Semaphore(total_concurrency)
-
-    async def create_task(self, coroutine) -> Task:
-        # 等待信号量，控制并发数
-        await self.semaphore.acquire()
-        
-        task = asyncio.create_task(coroutine)
-        self.current_task.add(task)
-
-        def done_callback(_future: Future) -> None:
-            self.current_task.remove(task)
-            self.semaphore.release()
-
-        task.add_done_callback(done_callback)
-
-        return task
-
-    def all_done(self) -> bool:
-        return len(self.current_task) == 0
+#!/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