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

crawlo/middleware/middleware_manager.py

@@ -1,136 +1,136 @@
-#!/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.class_loader 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._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:
-            # 恢复INFO级别日志，保留关键的启用信息
-            self.logger.info(f'Enabled middlewares:\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)
+#!/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.class_loader 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._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:
+            # 恢复INFO级别日志，保留关键的启用信息
+            self.logger.info(f'Enabled middlewares:\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

crawlo/middleware/offsite.py

@@ -1,124 +1,124 @@
-#!/usr/bin/python
-# -*- coding:UTF-8 -*-
-"""
-OffsiteMiddleware 中间件
-用于过滤掉不在指定域名范围内的请求
-"""
-import re
-from urllib.parse import urlparse
-
-from crawlo.utils.log import get_logger
-from crawlo.exceptions import IgnoreRequestError
-
-
-class OffsiteMiddleware:
-    """
-    OffsiteMiddleware 中间件
-    用于过滤掉不在指定域名范围内的请求，防止爬虫爬取到不相关的网站
-    """
-
-    def __init__(self, stats, log_level, allowed_domains=None):
-        self.logger = get_logger(self.__class__.__name__, log_level)
-        self.stats = stats
-        self.allowed_domains = allowed_domains or []
-
-    @classmethod
-    def create_instance(cls, crawler):
-        """
-        创建中间件实例
-        从爬虫设置中获取允许的域名列表
-        """
-        # 优先使用 Spider 实例的 allowed_domains，回退到全局设置中的 ALLOWED_DOMAINS
-        allowed_domains = []
-        
-        # 检查当前爬虫实例是否有 allowed_domains 属性
-        if hasattr(crawler, 'spider') and crawler.spider and hasattr(crawler.spider, 'allowed_domains'):
-            allowed_domains = getattr(crawler.spider, 'allowed_domains', [])
-        
-        # 如果 Spider 实例没有设置 allowed_domains，则从全局设置中获取
-        if not allowed_domains:
-            allowed_domains = crawler.settings.get_list('ALLOWED_DOMAINS')
-        
-        # 如果没有配置允许的域名，则禁用此中间件
-        if not allowed_domains:
-            from crawlo.exceptions import NotConfiguredError
-            raise NotConfiguredError("未配置ALLOWED_DOMAINS，OffsiteMiddleware已禁用")
-            
-        o = cls(
-            stats=crawler.stats, 
-            log_level=crawler.settings.get('LOG_LEVEL'),
-            allowed_domains=allowed_domains
-        )
-        
-        # 编译域名正则表达式以提高性能
-        o._compile_domains()
-        
-        # 使用中间件自己的logger而不是crawler.logger
-        o.logger.debug(f"OffsiteMiddleware 已启用，允许的域名: {allowed_domains}")
-        return o
-
-    def _compile_domains(self):
-        """
-        编译域名正则表达式
-        """
-        self._domain_regexes = []
-        for domain in self.allowed_domains:
-            # 转义域名中的特殊字符
-            escaped_domain = re.escape(domain)
-            # 创建匹配域名的正则表达式（支持子域名）
-            regex = re.compile(r'(^|.*\.)' + escaped_domain + '$', re.IGNORECASE)
-            self._domain_regexes.append(regex)
-
-    def _is_offsite_request(self, request):
-        """
-        判断请求是否为站外请求
-        """
-        try:
-            parsed_url = urlparse(request.url)
-            hostname = parsed_url.hostname
-            
-            if not hostname:
-                return True  # 无效URL
-                
-            # 检查是否匹配允许的域名
-            for regex in self._domain_regexes:
-                if regex.match(hostname):
-                    return False  # 匹配允许的域名
-                    
-            return True  # 不匹配任何允许的域名
-        except Exception:
-            # URL解析失败，视为站外请求
-            return True
-
-    async def process_request(self, request, spider):
-        """
-        处理请求，过滤站外请求
-        """
-        if self._is_offsite_request(request):
-            # 记录被过滤的请求
-            self.stats.inc_value('offsite_request_count')
-            
-            # 记录被过滤的域名
-            try:
-                parsed_url = urlparse(request.url)
-                hostname = parsed_url.hostname or "unknown"
-                self.stats.inc_value(f'offsite_request_count/{hostname}')
-            except:
-                self.stats.inc_value('offsite_request_count/invalid_url')
-            
-            self.logger.debug(f"过滤站外请求: {request.url}")
-            
-            # 抛出异常以忽略该请求
-            raise IgnoreRequestError(f"站外请求被过滤: {request.url}")
-            
-        return None
-
-    def process_exception(self, request, exception, spider):
-        """
-        处理异常
-        """
-        # 如果是IgnoreRequestError且是我们产生的，则处理它
-        if isinstance(exception, IgnoreRequestError) and "站外请求被过滤" in str(exception):
-            self.logger.debug(f"已过滤站外请求: {request.url}")
-            return True  # 表示异常已被处理
+#!/usr/bin/python
+# -*- coding:UTF-8 -*-
+"""
+OffsiteMiddleware 中间件
+用于过滤掉不在指定域名范围内的请求
+"""
+import re
+from urllib.parse import urlparse
+
+from crawlo.utils.log import get_logger
+from crawlo.exceptions import IgnoreRequestError
+
+
+class OffsiteMiddleware:
+    """
+    OffsiteMiddleware 中间件
+    用于过滤掉不在指定域名范围内的请求，防止爬虫爬取到不相关的网站
+    """
+
+    def __init__(self, stats, log_level, allowed_domains=None):
+        self.logger = get_logger(self.__class__.__name__, log_level)
+        self.stats = stats
+        self.allowed_domains = allowed_domains or []
+
+    @classmethod
+    def create_instance(cls, crawler):
+        """
+        创建中间件实例
+        从爬虫设置中获取允许的域名列表
+        """
+        # 优先使用 Spider 实例的 allowed_domains，回退到全局设置中的 ALLOWED_DOMAINS
+        allowed_domains = []
+        
+        # 检查当前爬虫实例是否有 allowed_domains 属性
+        if hasattr(crawler, 'spider') and crawler.spider and hasattr(crawler.spider, 'allowed_domains'):
+            allowed_domains = getattr(crawler.spider, 'allowed_domains', [])
+        
+        # 如果 Spider 实例没有设置 allowed_domains，则从全局设置中获取
+        if not allowed_domains:
+            allowed_domains = crawler.settings.get_list('ALLOWED_DOMAINS')
+        
+        # 如果没有配置允许的域名，则禁用此中间件
+        if not allowed_domains:
+            from crawlo.exceptions import NotConfiguredError
+            raise NotConfiguredError("未配置ALLOWED_DOMAINS，OffsiteMiddleware已禁用")
+            
+        o = cls(
+            stats=crawler.stats, 
+            log_level=crawler.settings.get('LOG_LEVEL'),
+            allowed_domains=allowed_domains
+        )
+        
+        # 编译域名正则表达式以提高性能
+        o._compile_domains()
+        
+        # 使用中间件自己的logger而不是crawler.logger
+        o.logger.debug(f"OffsiteMiddleware 已启用，允许的域名: {allowed_domains}")
+        return o
+
+    def _compile_domains(self):
+        """
+        编译域名正则表达式
+        """
+        self._domain_regexes = []
+        for domain in self.allowed_domains:
+            # 转义域名中的特殊字符
+            escaped_domain = re.escape(domain)
+            # 创建匹配域名的正则表达式（支持子域名）
+            regex = re.compile(r'(^|.*\.)' + escaped_domain + '$', re.IGNORECASE)
+            self._domain_regexes.append(regex)
+
+    def _is_offsite_request(self, request):
+        """
+        判断请求是否为站外请求
+        """
+        try:
+            parsed_url = urlparse(request.url)
+            hostname = parsed_url.hostname
+            
+            if not hostname:
+                return True  # 无效URL
+                
+            # 检查是否匹配允许的域名
+            for regex in self._domain_regexes:
+                if regex.match(hostname):
+                    return False  # 匹配允许的域名
+                    
+            return True  # 不匹配任何允许的域名
+        except Exception:
+            # URL解析失败，视为站外请求
+            return True
+
+    async def process_request(self, request, spider):
+        """
+        处理请求，过滤站外请求
+        """
+        if self._is_offsite_request(request):
+            # 记录被过滤的请求
+            self.stats.inc_value('offsite_request_count')
+            
+            # 记录被过滤的域名
+            try:
+                parsed_url = urlparse(request.url)
+                hostname = parsed_url.hostname or "unknown"
+                self.stats.inc_value(f'offsite_request_count/{hostname}')
+            except:
+                self.stats.inc_value('offsite_request_count/invalid_url')
+            
+            self.logger.debug(f"过滤站外请求: {request.url}")
+            
+            # 抛出异常以忽略该请求
+            raise IgnoreRequestError(f"站外请求被过滤: {request.url}")
+            
+        return None
+
+    def process_exception(self, request, exception, spider):
+        """
+        处理异常
+        """
+        # 如果是IgnoreRequestError且是我们产生的，则处理它
+        if isinstance(exception, IgnoreRequestError) and "站外请求被过滤" in str(exception):
+            self.logger.debug(f"已过滤站外请求: {request.url}")
+            return True  # 表示异常已被处理
         return None