crawlo 1.0.9__py3-none-any.whl → 1.1.1__py3-none-any.whl

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,32 +1,32 @@
-#!/usr/bin/python
-# -*- coding:UTF-8 -*-
-from crawlo.event import spider_opened
-
-
-class DefaultHeaderMiddleware(object):
-
-    def __init__(self, user_agent, headers, spider):
-        self.user_agent = user_agent
-        self.headers = headers
-        self.spider = spider
-
-    @classmethod
-    def create_instance(cls, crawler):
-        o = cls(
-            user_agent=crawler.settings.get('USER_AGENT'),
-            headers=crawler.settings.get_dict('DEFAULT_HEADERS'),
-            spider=crawler.spider
-        )
-        crawler.subscriber.subscribe(o.spider_opened, event=spider_opened)
-        return o
-
-    async def spider_opened(self):
-        self.user_agent = getattr(self.spider, 'user_agent', self.user_agent)
-        self.headers = getattr(self.spider, 'headers', self.headers)
-        if self.user_agent:
-            self.headers.setdefault('User-Agent', self.user_agent)
-
-    def process_request(self, request, _spider):
-        if self.headers:
-            for key, value in self.headers.items():
-                request.headers.setdefault(key, value)
+#!/usr/bin/python
+# -*- coding:UTF-8 -*-
+from crawlo.event import spider_opened
+
+
+class DefaultHeaderMiddleware(object):
+
+    def __init__(self, user_agent, headers, spider):
+        self.user_agent = user_agent
+        self.headers = headers
+        self.spider = spider
+
+    @classmethod
+    def create_instance(cls, crawler):
+        o = cls(
+            user_agent=crawler.settings.get('USER_AGENT'),
+            headers=crawler.settings.get_dict('DEFAULT_HEADERS'),
+            spider=crawler.spider
+        )
+        crawler.subscriber.subscribe(o.spider_opened, event=spider_opened)
+        return o
+
+    async def spider_opened(self):
+        self.user_agent = getattr(self.spider, 'user_agent', self.user_agent)
+        self.headers = getattr(self.spider, 'headers', self.headers)
+        if self.user_agent:
+            self.headers.setdefault('User-Agent', self.user_agent)
+
+    def process_request(self, request, _spider):
+        if self.headers:
+            for key, value in self.headers.items():
+                request.headers.setdefault(key, value)

crawlo/middleware/download_delay.py

@@ -1,28 +1,28 @@
-#!/usr/bin/python
-# -*- coding:UTF-8 -*-
-from asyncio import sleep
-from random import uniform
-from crawlo.utils.log import get_logger
-from crawlo.exceptions import NotConfiguredError
-
-
-class DownloadDelayMiddleware(object):
-
-    def __init__(self, settings, log_level):
-        self.delay = settings.get_float("DOWNLOAD_DELAY")
-        if not self.delay:
-            raise NotConfiguredError
-        self.randomness = settings.get_bool("RANDOMNESS")
-        self.floor, self.upper = settings.get_list("RANDOM_RANGE")
-        self.logger = get_logger(self.__class__.__name__, log_level)
-
-    @classmethod
-    def create_instance(cls, crawler):
-        o = cls(settings=crawler.settings, log_level=crawler.settings.get('LOG_LEVEL'))
-        return o
-
-    async def process_request(self, _request, _spider):
-        if self.randomness:
-            await sleep(uniform(self.delay * self.floor, self.delay * self.upper))
-        else:
-            await sleep(self.delay)
+#!/usr/bin/python
+# -*- coding:UTF-8 -*-
+from asyncio import sleep
+from random import uniform
+from crawlo.utils.log import get_logger
+from crawlo.exceptions import NotConfiguredError
+
+
+class DownloadDelayMiddleware(object):
+
+    def __init__(self, settings, log_level):
+        self.delay = settings.get_float("DOWNLOAD_DELAY")
+        if not self.delay:
+            raise NotConfiguredError
+        self.randomness = settings.get_bool("RANDOMNESS")
+        self.floor, self.upper = settings.get_list("RANDOM_RANGE")
+        self.logger = get_logger(self.__class__.__name__, log_level)
+
+    @classmethod
+    def create_instance(cls, crawler):
+        o = cls(settings=crawler.settings, log_level=crawler.settings.get('LOG_LEVEL'))
+        return o
+
+    async def process_request(self, _request, _spider):
+        if self.randomness:
+            await sleep(uniform(self.delay * self.floor, self.delay * self.upper))
+        else:
+            await sleep(self.delay)

crawlo/middleware/middleware_manager.py

@@ -1,135 +1,135 @@
-#!/usr/bin/python
-# -*- coding:UTF-8 -*-
-from pprint import pformat
-from types import MethodType
-from asyncio import create_task
-from collections import defaultdict
-from typing import List, Dict, Callable, Optional
-
-from crawlo import Request, Response
-from crawlo.utils.log import get_logger
-from crawlo.utils.project import load_class
-from crawlo.middleware import BaseMiddleware
-from crawlo.utils.project import common_call
-from crawlo.event import ignore_request, response_received
-from crawlo.exceptions import MiddlewareInitError, InvalidOutputError, RequestMethodError, IgnoreRequestError, \
-    NotConfiguredError
-
-
-class MiddlewareManager:
-
-    def __init__(self, crawler):
-        self.crawler = crawler
-        self.logger = get_logger(self.__class__.__name__, crawler.settings.get('LOG_LEVEL'))
-        self.middlewares: List = []
-        self.methods: Dict[str, List[MethodType]] = defaultdict(list)
-        middlewares = self.crawler.settings.get_list('MIDDLEWARES')
-        self._add_middleware(middlewares)
-        self._add_method()
-
-        self.download_method: Callable = crawler.engine.downloader.download
-        self._stats = crawler.stats
-
-    async def _process_request(self, request: Request):
-        for method in self.methods['process_request']:
-            result = await common_call(method, request, self.crawler.spider)
-            if result is None:
-                continue
-            if isinstance(result, (Request, Response)):
-                return result
-            raise InvalidOutputError(
-                f"{method.__self__.__class__.__name__}. must return None or Request or Response, got {type(result).__name__}"
-            )
-        return await self.download_method(request)
-
-    async def _process_response(self, request: Request, response: Response):
-        for method in reversed(self.methods['process_response']):
-            try:
-                response = await common_call(method, request, response, self.crawler.spider)
-            except IgnoreRequestError as exp:
-                create_task(self.crawler.subscriber.notify(ignore_request, exp, request, self.crawler.spider))
-            if isinstance(response, Request):
-                return response
-            if isinstance(response, Response):
-                continue
-            raise InvalidOutputError(
-                f"{method.__self__.__class__.__name__}. must return Request or Response, got {type(response).__name__}"
-            )
-        return response
-
-    async def _process_exception(self, request: Request, exp: Exception):
-        for method in self.methods['process_exception']:
-            response = await common_call(method, request, exp, self.crawler.spider)
-            if response is None:
-                continue
-            if isinstance(response, (Request, Response)):
-                return response
-            if response:
-                break
-            raise InvalidOutputError(
-                f"{method.__self__.__class__.__name__}. must return None or Request or Response, got {type(response).__name__}"
-            )
-        else:
-            raise exp
-
-    async def download(self, request) -> Optional[Response]:
-        """ called in the download method. """
-        try:
-            response = await self._process_request(request)
-        except KeyError:
-            raise RequestMethodError(f"{request.method.lower()} is not supported")
-        except IgnoreRequestError as exp:
-            create_task(self.crawler.subscriber.notify(ignore_request, exp, request, self.crawler.spider))
-            response = await self._process_exception(request, exp)
-        except Exception as exp:
-            self._stats.inc_value(f'download_error/{exp.__class__.__name__}')
-            response = await self._process_exception(request, exp)
-        else:
-            create_task(self.crawler.subscriber.notify(response_received, response, self.crawler.spider))
-            # self.crawler.stats.inc_value('response_received_count')
-        if isinstance(response, Response):
-            response = await self._process_response(request, response)
-        if isinstance(response, Request):
-            await self.crawler.engine.enqueue_request(request)
-            return None
-        return response
-
-    @classmethod
-    def create_instance(cls, *args, **kwargs):
-        return cls(*args, **kwargs)
-
-    def _add_middleware(self, middlewares):
-        enabled_middlewares = [m for m in middlewares if self._validate_middleware(m)]
-        if enabled_middlewares:
-            self.logger.info(f'enabled middleware：\n {pformat(enabled_middlewares)}')
-
-    def _validate_middleware(self, middleware):
-        middleware_cls = load_class(middleware)
-        if not hasattr(middleware_cls, 'create_instance'):
-            raise MiddlewareInitError(
-                f"Middleware init failed, must inherit from `BaseMiddleware` or have a `create_instance` method"
-            )
-        try:
-            instance = middleware_cls.create_instance(self.crawler)
-            self.middlewares.append(instance)
-            return True
-        except NotConfiguredError:
-            return False
-
-    def _add_method(self):
-        for middleware in self.middlewares:
-            if hasattr(middleware, 'process_request'):
-                if self._validate_middleware_method(method_name='process_request', middleware=middleware):
-                    self.methods['process_request'].append(middleware.process_request)
-            if hasattr(middleware, 'process_response'):
-                if self._validate_middleware_method(method_name='process_response', middleware=middleware):
-                    self.methods['process_response'].append(middleware.process_response)
-            if hasattr(middleware, 'process_exception'):
-                if self._validate_middleware_method(method_name='process_exception', middleware=middleware):
-                    self.methods['process_exception'].append(middleware.process_exception)
-
-    @staticmethod
-    def _validate_middleware_method(method_name, middleware) -> bool:
-        method = getattr(type(middleware), method_name)
-        base_method = getattr(BaseMiddleware, method_name)
-        return False if method == base_method else True
+#!/usr/bin/python
+# -*- coding:UTF-8 -*-
+from pprint import pformat
+from types import MethodType
+from asyncio import create_task
+from collections import defaultdict
+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.middleware import BaseMiddleware
+from crawlo.project import common_call
+from crawlo.event import ignore_request, response_received
+from crawlo.exceptions import MiddlewareInitError, InvalidOutputError, RequestMethodError, IgnoreRequestError, \
+    NotConfiguredError
+
+
+class MiddlewareManager:
+
+    def __init__(self, crawler):
+        self.crawler = crawler
+        self.logger = get_logger(self.__class__.__name__, crawler.settings.get('LOG_LEVEL'))
+        self.middlewares: List = []
+        self.methods: Dict[str, List[MethodType]] = defaultdict(list)
+        middlewares = self.crawler.settings.get_list('MIDDLEWARES')
+        self._add_middleware(middlewares)
+        self._add_method()
+
+        self.download_method: Callable = crawler.engine.downloader.download
+        self._stats = crawler.stats
+
+    async def _process_request(self, request: Request):
+        for method in self.methods['process_request']:
+            result = await common_call(method, request, self.crawler.spider)
+            if result is None:
+                continue
+            if isinstance(result, (Request, Response)):
+                return result
+            raise InvalidOutputError(
+                f"{method.__self__.__class__.__name__}. must return None or Request or Response, got {type(result).__name__}"
+            )
+        return await self.download_method(request)
+
+    async def _process_response(self, request: Request, response: Response):
+        for method in reversed(self.methods['process_response']):
+            try:
+                response = await common_call(method, request, response, self.crawler.spider)
+            except IgnoreRequestError as exp:
+                create_task(self.crawler.subscriber.notify(ignore_request, exp, request, self.crawler.spider))
+            if isinstance(response, Request):
+                return response
+            if isinstance(response, Response):
+                continue
+            raise InvalidOutputError(
+                f"{method.__self__.__class__.__name__}. must return Request or Response, got {type(response).__name__}"
+            )
+        return response
+
+    async def _process_exception(self, request: Request, exp: Exception):
+        for method in self.methods['process_exception']:
+            response = await common_call(method, request, exp, self.crawler.spider)
+            if response is None:
+                continue
+            if isinstance(response, (Request, Response)):
+                return response
+            if response:
+                break
+            raise InvalidOutputError(
+                f"{method.__self__.__class__.__name__}. must return None or Request or Response, got {type(response).__name__}"
+            )
+        else:
+            raise exp
+
+    async def download(self, request) -> Optional[Response]:
+        """ called in the download method. """
+        try:
+            response = await self._process_request(request)
+        except KeyError:
+            raise RequestMethodError(f"{request.method.lower()} is not supported")
+        except IgnoreRequestError as exp:
+            create_task(self.crawler.subscriber.notify(ignore_request, exp, request, self.crawler.spider))
+            response = await self._process_exception(request, exp)
+        except Exception as exp:
+            self._stats.inc_value(f'download_error/{exp.__class__.__name__}')
+            response = await self._process_exception(request, exp)
+        else:
+            create_task(self.crawler.subscriber.notify(response_received, response, self.crawler.spider))
+            # self.crawler.stats.inc_value('response_received_count')
+        if isinstance(response, Response):
+            response = await self._process_response(request, response)
+        if isinstance(response, Request):
+            await self.crawler.engine.enqueue_request(request)
+            return None
+        return response
+
+    @classmethod
+    def create_instance(cls, *args, **kwargs):
+        return cls(*args, **kwargs)
+
+    def _add_middleware(self, middlewares):
+        enabled_middlewares = [m for m in middlewares if self._validate_middleware(m)]
+        if enabled_middlewares:
+            self.logger.info(f'enabled middleware：\n {pformat(enabled_middlewares)}')
+
+    def _validate_middleware(self, middleware):
+        middleware_cls = load_class(middleware)
+        if not hasattr(middleware_cls, 'create_instance'):
+            raise MiddlewareInitError(
+                f"Middleware init failed, must inherit from `BaseMiddleware` or have a `create_instance` method"
+            )
+        try:
+            instance = middleware_cls.create_instance(self.crawler)
+            self.middlewares.append(instance)
+            return True
+        except NotConfiguredError:
+            return False
+
+    def _add_method(self):
+        for middleware in self.middlewares:
+            if hasattr(middleware, 'process_request'):
+                if self._validate_middleware_method(method_name='process_request', middleware=middleware):
+                    self.methods['process_request'].append(middleware.process_request)
+            if hasattr(middleware, 'process_response'):
+                if self._validate_middleware_method(method_name='process_response', middleware=middleware):
+                    self.methods['process_response'].append(middleware.process_response)
+            if hasattr(middleware, 'process_exception'):
+                if self._validate_middleware_method(method_name='process_exception', middleware=middleware):
+                    self.methods['process_exception'].append(middleware.process_exception)
+
+    @staticmethod
+    def _validate_middleware_method(method_name, middleware) -> bool:
+        method = getattr(type(middleware), method_name)
+        base_method = getattr(BaseMiddleware, method_name)
+        return False if method == base_method else True