crawlo 1.2.7__py3-none-any.whl → 1.2.9__py3-none-any.whl

crawlo/items/fields.py

@@ -1,53 +1,53 @@
-#!/usr/bin/python
-# -*- coding: UTF-8 -*-
-"""
-Field 类定义
-"""
-from typing import Any, Optional, Type
-
-
-class Field:
-    """
-    字段定义类，用于定义 Item 的字段属性和验证规则
-    """
-    def __init__(
-        self,
-        nullable: bool = True,
-        *,
-        default: Any = None,
-        field_type: Optional[Type] = None,
-        max_length: Optional[int] = None,
-        description: str = ""
-    ):
-        self.nullable = nullable
-        self.default = default
-        self.field_type = field_type
-        self.max_length = max_length
-        self.description = description
-
-    def validate(self, value: Any, field_name: str = "") -> Any:
-        """
-        验证字段值是否符合规则
-        """
-        if value is None or (isinstance(value, str) and value.strip() == ""):
-            if self.default is not None:
-                return self.default
-            elif not self.nullable:
-                raise ValueError(
-                    f"字段 '{field_name}' 不允许为空。"
-                )
-
-        if value is not None and not (isinstance(value, str) and value.strip() == ""):
-            if self.field_type and not isinstance(value, self.field_type):
-                raise TypeError(
-                    f"字段 '{field_name}' 类型错误：期望类型 {self.field_type}, 得到 {type(value)}，值：{value!r}"
-                )
-            if self.max_length and len(str(value)) > self.max_length:
-                raise ValueError(
-                    f"字段 '{field_name}' 长度超限：最大长度 {self.max_length}，当前长度 {len(str(value))}，值：{value!r}"
-                )
-
-        return value
-
-    def __repr__(self):
+#!/usr/bin/python
+# -*- coding: UTF-8 -*-
+"""
+Field 类定义
+"""
+from typing import Any, Optional, Type
+
+
+class Field:
+    """
+    字段定义类，用于定义 Item 的字段属性和验证规则
+    """
+    def __init__(
+        self,
+        nullable: bool = True,
+        *,
+        default: Any = None,
+        field_type: Optional[Type] = None,
+        max_length: Optional[int] = None,
+        description: str = ""
+    ):
+        self.nullable = nullable
+        self.default = default
+        self.field_type = field_type
+        self.max_length = max_length
+        self.description = description
+
+    def validate(self, value: Any, field_name: str = "") -> Any:
+        """
+        验证字段值是否符合规则
+        """
+        if value is None or (isinstance(value, str) and value.strip() == ""):
+            if self.default is not None:
+                return self.default
+            elif not self.nullable:
+                raise ValueError(
+                    f"字段 '{field_name}' 不允许为空。"
+                )
+
+        if value is not None and not (isinstance(value, str) and value.strip() == ""):
+            if self.field_type and not isinstance(value, self.field_type):
+                raise TypeError(
+                    f"字段 '{field_name}' 类型错误：期望类型 {self.field_type}, 得到 {type(value)}，值：{value!r}"
+                )
+            if self.max_length and len(str(value)) > self.max_length:
+                raise ValueError(
+                    f"字段 '{field_name}' 长度超限：最大长度 {self.max_length}，当前长度 {len(str(value))}，值：{value!r}"
+                )
+
+        return value
+
+    def __repr__(self):
         return f"<Field nullable={self.nullable} type={self.field_type} default={self.default}>"

crawlo/items/items.py

@@ -1,105 +1,105 @@
-#!/usr/bin/python
-# -*- coding: UTF-8 -*-
-"""
-Item 类定义
-"""
-from copy import deepcopy
-from pprint import pformat
-from typing import Any, Iterator, Dict
-from collections.abc import MutableMapping
-
-from .base import ItemMeta
-from crawlo.exceptions import ItemInitError, ItemAttributeError
-
-
-class Item(MutableMapping, metaclass=ItemMeta):
-    """
-    数据项基类，用于定义结构化数据
-    """
-    FIELDS: Dict[str, Any] = {}
-
-    def __init__(self, *args, **kwargs):
-        if args:
-            raise ItemInitError(f"{self.__class__.__name__} 不支持位置参数：{args}，请使用关键字参数初始化。")
-
-        self._values: Dict[str, Any] = {}
-
-        # 初始化字段，默认值填充
-        for field_name, field_obj in self.FIELDS.items():
-            if field_obj.default is not None:
-                self._values[field_name] = field_obj.default
-
-        # 覆盖默认值或设置新值
-        for key, value in kwargs.items():
-            self[key] = value
-
-    def __getitem__(self, item: str) -> Any:
-        return self._values[item]
-
-    def __setitem__(self, key: str, value: Any) -> None:
-        if key not in self.FIELDS:
-            raise KeyError(f"{self.__class__.__name__} 不包含字段：{key}")
-
-        field = self.FIELDS[key]
-        try:
-            validated_value = field.validate(value, field_name=key)
-            self._values[key] = validated_value
-        except Exception as e:
-            error_lines = [
-                "",
-                "【字段校验失败】",
-                f"字段名称: {key}",
-                f"数据类型: {type(value)}",
-                f"原始值:   {repr(value)}",
-                f"是否允许空值: {field.nullable}",
-                f"错误原因: {str(e)}",
-                ""
-            ]
-            detailed_error = "\n".join(error_lines)
-            raise type(e)(detailed_error) from e
-
-    def __delitem__(self, key: str) -> None:
-        del self._values[key]
-
-    def __setattr__(self, key: str, value: Any) -> None:
-        if not key.startswith("_"):
-            raise AttributeError(
-                f"设置字段值请使用 item[{key!r}] = {value!r}"
-            )
-        super().__setattr__(key, value)
-
-    def __getattr__(self, item: str) -> Any:
-        raise AttributeError(
-            f"{self.__class__.__name__} 不支持字段：{item}。"
-            f"请先在 `{self.__class__.__name__}` 中声明该字段，再通过 item[{item!r}] 获取。"
-        )
-
-    def __getattribute__(self, item: str) -> Any:
-        try:
-            field = super().__getattribute__("FIELDS")
-            if isinstance(field, dict) and item in field:
-                raise ItemAttributeError(
-                    f"获取字段值请使用 item[{item!r}]"
-                )
-        except AttributeError:
-            pass  # 如果 FIELDS 尚未定义，继续执行后续逻辑
-        return super().__getattribute__(item)
-
-    def __repr__(self) -> str:
-        return pformat(dict(self))
-
-    __str__ = __repr__
-
-    def __iter__(self) -> Iterator[str]:
-        return iter(self._values)
-
-    def __len__(self) -> int:
-        return len(self._values)
-
-    def to_dict(self) -> Dict[str, Any]:
-        """转换为字典"""
-        return dict(self)
-
-    def copy(self) -> "Item":
-        """深拷贝当前 Item"""
+#!/usr/bin/python
+# -*- coding: UTF-8 -*-
+"""
+Item 类定义
+"""
+from copy import deepcopy
+from pprint import pformat
+from typing import Any, Iterator, Dict
+from collections.abc import MutableMapping
+
+from .base import ItemMeta
+from crawlo.exceptions import ItemInitError, ItemAttributeError
+
+
+class Item(MutableMapping, metaclass=ItemMeta):
+    """
+    数据项基类，用于定义结构化数据
+    """
+    FIELDS: Dict[str, Any] = {}
+
+    def __init__(self, *args, **kwargs):
+        if args:
+            raise ItemInitError(f"{self.__class__.__name__} 不支持位置参数：{args}，请使用关键字参数初始化。")
+
+        self._values: Dict[str, Any] = {}
+
+        # 初始化字段，默认值填充
+        for field_name, field_obj in self.FIELDS.items():
+            if field_obj.default is not None:
+                self._values[field_name] = field_obj.default
+
+        # 覆盖默认值或设置新值
+        for key, value in kwargs.items():
+            self[key] = value
+
+    def __getitem__(self, item: str) -> Any:
+        return self._values[item]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        if key not in self.FIELDS:
+            raise KeyError(f"{self.__class__.__name__} 不包含字段：{key}")
+
+        field = self.FIELDS[key]
+        try:
+            validated_value = field.validate(value, field_name=key)
+            self._values[key] = validated_value
+        except Exception as e:
+            error_lines = [
+                "",
+                "【字段校验失败】",
+                f"字段名称: {key}",
+                f"数据类型: {type(value)}",
+                f"原始值:   {repr(value)}",
+                f"是否允许空值: {field.nullable}",
+                f"错误原因: {str(e)}",
+                ""
+            ]
+            detailed_error = "\n".join(error_lines)
+            raise type(e)(detailed_error) from e
+
+    def __delitem__(self, key: str) -> None:
+        del self._values[key]
+
+    def __setattr__(self, key: str, value: Any) -> None:
+        if not key.startswith("_"):
+            raise AttributeError(
+                f"设置字段值请使用 item[{key!r}] = {value!r}"
+            )
+        super().__setattr__(key, value)
+
+    def __getattr__(self, item: str) -> Any:
+        raise AttributeError(
+            f"{self.__class__.__name__} 不支持字段：{item}。"
+            f"请先在 `{self.__class__.__name__}` 中声明该字段，再通过 item[{item!r}] 获取。"
+        )
+
+    def __getattribute__(self, item: str) -> Any:
+        try:
+            field = super().__getattribute__("FIELDS")
+            if isinstance(field, dict) and item in field:
+                raise ItemAttributeError(
+                    f"获取字段值请使用 item[{item!r}]"
+                )
+        except AttributeError:
+            pass  # 如果 FIELDS 尚未定义，继续执行后续逻辑
+        return super().__getattribute__(item)
+
+    def __repr__(self) -> str:
+        return pformat(dict(self))
+
+    __str__ = __repr__
+
+    def __iter__(self) -> Iterator[str]:
+        return iter(self._values)
+
+    def __len__(self) -> int:
+        return len(self._values)
+
+    def to_dict(self) -> Dict[str, Any]:
+        """转换为字典"""
+        return dict(self)
+
+    def copy(self) -> "Item":
+        """深拷贝当前 Item"""
         return deepcopy(self)

crawlo/middleware/__init__.py

@@ -1,21 +1,21 @@
-#!/usr/bin/python
-# -*- coding:UTF-8 -*-
-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 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()

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.info(f"DefaultHeaderMiddleware已启用，配置详情: "
-                        f"默认请求头={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.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