crawlo 1.4.5__py3-none-any.whl → 1.4.7__py3-none-any.whl

crawlo/logging/sampler.py

@@ -1,167 +0,0 @@
-#!/usr/bin/python
-# -*- coding: UTF-8 -*-
-"""
-日志采样器
-用于在高负载时减少日志输出
-"""
-
-import random
-import time
-import threading
-from typing import Dict, Set
-from collections import defaultdict
-
-
-class LogSampler:
-    """
-    日志采样器
-    支持多种采样策略以减少日志输出量
-    """
-    
-    def __init__(self):
-        self._lock = threading.RLock()
-        self._sample_rates: Dict[str, float] = {}  # logger_name -> sample_rate
-        self._rate_limiters: Dict[str, TokenBucket] = {}  # logger_name -> rate_limiter
-        self._message_counts: Dict[str, Dict[str, int]] = defaultdict(lambda: defaultdict(int))
-        self._time_windows: Dict[str, Dict[str, float]] = defaultdict(lambda: defaultdict(float))
-        
-    def set_sample_rate(self, logger_name: str, rate: float):
-        """
-        设置采样率
-        
-        Args:
-            logger_name: Logger名称
-            rate: 采样率 (0.0-1.0)，1.0表示全部记录，0.0表示不记录
-        """
-        with self._lock:
-            self._sample_rates[logger_name] = max(0.0, min(1.0, rate))
-            
-    def set_rate_limit(self, logger_name: str, messages_per_second: float):
-        """
-        设置速率限制
-        
-        Args:
-            logger_name: Logger名称
-            messages_per_second: 每秒最大消息数
-        """
-        with self._lock:
-            self._rate_limiters[logger_name] = TokenBucket(messages_per_second, messages_per_second)
-            
-    def should_log(self, logger_name: str, message: str = None, level: str = None) -> bool:
-        """
-        判断是否应该记录日志
-        
-        Args:
-            logger_name: Logger名称
-            message: 日志消息（用于去重）
-            level: 日志级别
-            
-        Returns:
-            是否应该记录日志
-        """
-        with self._lock:
-            # 检查采样率
-            if logger_name in self._sample_rates:
-                sample_rate = self._sample_rates[logger_name]
-                if random.random() > sample_rate:
-                    return False
-                    
-            # 检查速率限制
-            if logger_name in self._rate_limiters:
-                if not self._rate_limiters[logger_name].consume(1):
-                    return False
-                    
-            # 检查消息去重（相同消息在短时间内只记录一次）
-            if message:
-                key = f"{level}:{message}" if level else message
-                current_time = time.time()
-                
-                # 如果距离上次记录超过60秒，重置计数
-                if current_time - self._time_windows[logger_name][key] > 60:
-                    self._message_counts[logger_name][key] = 0
-                    self._time_windows[logger_name][key] = current_time
-                    
-                # 限制相同消息的记录次数
-                if self._message_counts[logger_name][key] >= 5:  # 最多记录5次相同消息
-                    return False
-                    
-                self._message_counts[logger_name][key] += 1
-                
-            return True
-            
-    def reset(self):
-        """重置采样器状态"""
-        with self._lock:
-            self._sample_rates.clear()
-            self._rate_limiters.clear()
-            self._message_counts.clear()
-            self._time_windows.clear()
-
-
-class TokenBucket:
-    """
-    令牌桶算法实现
-    用于速率限制
-    """
-    
-    def __init__(self, rate: float, capacity: float):
-        """
-        初始化令牌桶
-        
-        Args:
-            rate: 每秒生成的令牌数
-            capacity: 桶的最大容量
-        """
-        self._rate = rate
-        self._capacity = capacity
-        self._tokens = capacity
-        self._last_time = time.time()
-        self._lock = threading.Lock()
-        
-    def consume(self, tokens: float) -> bool:
-        """
-        消费令牌
-        
-        Args:
-            tokens: 要消费的令牌数
-            
-        Returns:
-            是否消费成功
-        """
-        with self._lock:
-            current_time = time.time()
-            # 补充令牌
-            elapsed = current_time - self._last_time
-            self._tokens = min(self._capacity, self._tokens + elapsed * self._rate)
-            self._last_time = current_time
-            
-            # 尝试消费令牌
-            if self._tokens >= tokens:
-                self._tokens -= tokens
-                return True
-            else:
-                return False
-
-
-# 全局实例
-_log_sampler = LogSampler()
-
-
-def get_sampler() -> LogSampler:
-    """获取日志采样器实例"""
-    return _log_sampler
-
-
-def should_log(logger_name: str, message: str = None, level: str = None) -> bool:
-    """
-    判断是否应该记录日志的便捷函数
-    
-    Args:
-        logger_name: Logger名称
-        message: 日志消息
-        level: 日志级别
-        
-    Returns:
-        是否应该记录日志
-    """
-    return get_sampler().should_log(logger_name, message, level)

crawlo/middleware/simple_proxy.py

@@ -1,65 +0,0 @@
-#!/usr/bin/python
-# -*- coding: UTF-8 -*-
-"""
-简化版代理中间件
-提供基础的代理功能，避免过度复杂的实现
-"""
-import random
-from typing import Optional, List
-
-from crawlo import Request, Response
-from crawlo.exceptions import NotConfiguredError
-from crawlo.utils.log import get_logger
-
-
-class SimpleProxyMiddleware:
-    """简化版代理中间件"""
-
-    def __init__(self, settings, log_level):
-        self.logger = get_logger(self.__class__.__name__, log_level)
-
-        # 获取代理列表
-        self.proxies: List[str] = settings.get("PROXY_LIST", [])
-        self.enabled = settings.get_bool("PROXY_ENABLED", False)
-
-        if not self.enabled:
-            self.logger.info("SimpleProxyMiddleware disabled")
-            return
-
-        if not self.proxies:
-            raise NotConfiguredError("PROXY_LIST not configured, SimpleProxyMiddleware disabled")
-
-        self.logger.info(f"SimpleProxyMiddleware enabled with {len(self.proxies)} proxies")
-
-    @classmethod
-    def create_instance(cls, crawler):
-        return cls(settings=crawler.settings, log_level=crawler.settings.get("LOG_LEVEL"))
-
-    async def process_request(self, request: Request, spider) -> Optional[Request]:
-        """为请求分配代理"""
-        if not self.enabled:
-            return None
-
-        if request.proxy:
-            # 请求已指定代理，不覆盖
-            return None
-
-        if self.proxies:
-            # 随机选择一个代理
-            proxy = random.choice(self.proxies)
-            request.proxy = proxy
-            self.logger.debug(f"Assigned proxy {proxy} to {request.url}")
-
-        return None
-
-    def process_response(self, request: Request, response: Response, spider) -> Response:
-        """处理响应"""
-        if request.proxy:
-            self.logger.debug(f"Proxy request successful: {request.proxy} | {request.url}")
-        return response
-
-    def process_exception(self, request: Request, exception: Exception, spider) -> Optional[Request]:
-        """处理异常"""
-        if request.proxy:
-            self.logger.warning(f"Proxy request failed: {request.proxy} | {request.url} | {repr(exception)}")
-        return None

crawlo/tools/authenticated_proxy.py

@@ -1,241 +0,0 @@
-#!/usr/bin/python
-# -*- coding: UTF-8 -*-
-"""
-带认证代理工具
-=============
-支持带用户名密码认证的代理和非认证代理的统一处理工具
-
-功能特性:
-- 支持HTTP/HTTPS/SOCKS代理
-- 支持带认证和不带认证的代理
-- 统一的代理格式处理
-- 代理有效性检测
-"""
-
-from typing import Dict, Any, Optional, Union
-from urllib.parse import urlparse, urlunparse
-
-
-class AuthenticatedProxy:
-    """带认证代理处理类"""
-
-    def __init__(self, proxy_url: str):
-        """
-        初始化代理对象
-        
-        Args:
-            proxy_url (str): 代理URL，支持带认证信息的格式
-                - 带认证: http://username:password@proxy.example.com:8080
-                - 无认证: http://proxy.example.com:8080
-        """
-        self.proxy_url = proxy_url
-        self.parsed = urlparse(proxy_url)
-        
-        # 提取认证信息
-        self.username = self.parsed.username
-        self.password = self.parsed.password
-        
-        # 构造不带认证信息的URL
-        self.clean_url = urlunparse((
-            self.parsed.scheme,
-            f"{self.parsed.hostname}:{self.parsed.port}" if self.parsed.port else self.parsed.hostname,
-            self.parsed.path,
-            self.parsed.params,
-            self.parsed.query,
-            self.parsed.fragment
-        ))
-        
-        # 构造下载器兼容的代理字典
-        self.proxy_dict = {
-            "http": self.clean_url,
-            "https": self.clean_url
-        }
-        
-        # 如果有认证信息，构造认证字符串
-        if self.username and self.password:
-            self.auth_string = f"{self.username}:{self.password}"
-        else:
-            self.auth_string = None
-
-    def get_proxy_for_downloader(self) -> Union[str, Dict[str, str]]:
-        """
-        获取适用于下载器的代理配置
-        
-        Returns:
-            Union[str, Dict[str, str]]: 代理配置
-                - 对于AioHttp/CurlCffi: 返回字典格式 {"http": "...", "https": "..."}
-                - 对于HttpX: 可以直接使用字符串或字典格式
-        """
-        return self.proxy_dict
-
-    def get_auth_credentials(self) -> Optional[Dict[str, str]]:
-        """
-        获取认证凭据
-        
-        Returns:
-            Optional[Dict[str, str]]: 认证凭据 {"username": "...", "password": "..."}
-        """
-        if self.username and self.password:
-            return {
-                "username": self.username,
-                "password": self.password
-            }
-        return None
-
-    def get_auth_header(self) -> Optional[str]:
-        """
-        获取Basic Auth认证头
-        
-        Returns:
-            Optional[str]: Basic Auth头信息
-        """
-        if self.username and self.password:
-            import base64
-            credentials = f"{self.username}:{self.password}"
-            encoded = base64.b64encode(credentials.encode()).decode()
-            return f"Basic {encoded}"
-        return None
-
-    def is_valid(self) -> bool:
-        """
-        检查代理URL是否有效
-        
-        Returns:
-            bool: 代理URL是否有效
-        """
-        # 检查协议
-        if self.parsed.scheme not in ["http", "https", "socks4", "socks5"]:
-            return False
-            
-        # 检查主机名
-        if not self.parsed.hostname:
-            return False
-            
-        # 检查端口（如果指定）
-        if self.parsed.port and (self.parsed.port < 1 or self.parsed.port > 65535):
-            return False
-            
-        return True
-
-    def __str__(self) -> str:
-        return self.proxy_url
-
-    def __repr__(self) -> str:
-        return f"AuthenticatedProxy(url='{self.proxy_url}', username={self.username is not None})"
-
-
-def create_proxy_config(proxy_url: str) -> Dict[str, Any]:
-    """
-    创建代理配置，兼容各种下载器
-    
-    Args:
-        proxy_url (str): 代理URL
-        
-    Returns:
-        Dict[str, Any]: 代理配置字典
-    """
-    proxy = AuthenticatedProxy(proxy_url)
-    
-    if not proxy.is_valid():
-        raise ValueError(f"Invalid proxy URL: {proxy_url}")
-    
-    config = {
-        "url": proxy.clean_url,
-        "proxy_dict": proxy.proxy_dict,
-        "has_auth": proxy.auth_string is not None
-    }
-    
-    if proxy.auth_string:
-        config["auth"] = proxy.get_auth_credentials()
-        config["auth_header"] = proxy.get_auth_header()
-        
-    return config
-
-
-def format_proxy_for_request(proxy_config: Dict[str, Any], downloader_type: str = "aiohttp") -> Dict[str, Any]:
-    """
-    格式化代理配置以适配特定下载器
-    
-    Args:
-        proxy_config (Dict[str, Any]): 代理配置
-        downloader_type (str): 下载器类型 (aiohttp, httpx, curl_cffi)
-        
-    Returns:
-        Dict[str, Any]: 适配下载器的代理配置
-    """
-    formatted = {}
-    
-    if downloader_type.lower() == "aiohttp":
-        # AioHttp使用proxy和proxy_auth参数
-        formatted["proxy"] = proxy_config["url"]
-        if proxy_config.get("has_auth") and proxy_config.get("auth"):
-            from aiohttp import BasicAuth
-            auth = proxy_config["auth"]
-            formatted["proxy_auth"] = BasicAuth(auth["username"], auth["password"])
-            
-    elif downloader_type.lower() == "httpx":
-        # HttpX可以直接使用代理URL字符串或字典
-        formatted["proxy"] = proxy_config["url"]
-        
-    elif downloader_type.lower() == "curl_cffi":
-        # CurlCffi使用proxies字典
-        formatted["proxies"] = proxy_config["proxy_dict"]
-        # 认证信息包含在URL中或通过headers传递
-        if proxy_config.get("auth_header"):
-            formatted["headers"] = {"Proxy-Authorization": proxy_config["auth_header"]}
-            
-    return formatted
-
-
-# 便捷函数
-def parse_proxy_url(proxy_url: str) -> Dict[str, Any]:
-    """
-    解析代理URL并返回详细信息
-    
-    Args:
-        proxy_url (str): 代理URL
-        
-    Returns:
-        Dict[str, Any]: 代理详细信息
-    """
-    return create_proxy_config(proxy_url)
-
-
-def validate_proxy_url(proxy_url: str) -> bool:
-    """
-    验证代理URL是否有效
-    
-    Args:
-        proxy_url (str): 代理URL
-        
-    Returns:
-        bool: 是否有效
-    """
-    try:
-        proxy = AuthenticatedProxy(proxy_url)
-        return proxy.is_valid()
-    except:
-        return False
-
-
-def get_proxy_info(proxy_url: str) -> Dict[str, Any]:
-    """
-    获取代理详细信息
-    
-    Args:
-        proxy_url (str): 代理URL
-        
-    Returns:
-        Dict[str, Any]: 代理详细信息
-    """
-    proxy = AuthenticatedProxy(proxy_url)
-    return {
-        "original_url": proxy.proxy_url,
-        "clean_url": proxy.clean_url,
-        "scheme": proxy.parsed.scheme,
-        "hostname": proxy.parsed.hostname,
-        "port": proxy.parsed.port,
-        "has_auth": proxy.auth_string is not None,
-        "username": proxy.username,
-        "is_valid": proxy.is_valid()
-    }

crawlo/tools/data_formatter.py

@@ -1,226 +0,0 @@
-#!/usr/bin/python
-# -*- coding: UTF-8 -*-
-"""
-# @Time    : 2025-09-10 22:00
-# @Author  : crawl-coder
-# @Desc    : 数据格式化工具
-"""
-import re
-from typing import Any, Optional, Union
-from decimal import Decimal, InvalidOperation
-
-
-class DataFormatter:
-    """
-    数据格式化工具类，提供各种数据格式化功能。
-    特别适用于爬虫中处理各种数据类型的格式化需求。
-    """
-
-    @staticmethod
-    def format_number(value: Any, 
-                      precision: int = 2, 
-                      thousand_separator: bool = False) -> Optional[str]:
-        """
-        格式化数字
-        
-        :param value: 数字值
-        :param precision: 小数点精度
-        :param thousand_separator: 是否使用千位分隔符
-        :return: 格式化后的数字字符串
-        """
-        if value is None:
-            return None
-            
-        try:
-            # 转换为Decimal以避免浮点数精度问题
-            decimal_value = Decimal(str(value))
-            
-            if thousand_separator:
-                # 使用千位分隔符
-                formatted = f"{decimal_value:,.{precision}f}"
-            else:
-                # 不使用千位分隔符
-                formatted = f"{decimal_value:.{precision}f}"
-                
-            return formatted
-        except (ValueError, InvalidOperation):
-            return None
-
-    @staticmethod
-    def format_currency(value: Any, 
-                        currency_symbol: str = "¥", 
-                        precision: int = 2) -> Optional[str]:
-        """
-        格式化货币
-        
-        :param value: 货币值
-        :param currency_symbol: 货币符号
-        :param precision: 小数点精度
-        :return: 格式化后的货币字符串
-        """
-        formatted_number = DataFormatter.format_number(value, precision, thousand_separator=True)
-        if formatted_number is None:
-            return None
-            
-        return f"{currency_symbol}{formatted_number}"
-
-    @staticmethod
-    def format_percentage(value: Any, 
-                          precision: int = 2, 
-                          multiply_100: bool = True) -> Optional[str]:
-        """
-        格式化百分比
-        
-        :param value: 百分比值
-        :param precision: 小数点精度
-        :param multiply_100: 是否乘以100（如果原始值是小数）
-        :return: 格式化后的百分比字符串
-        """
-        if value is None:
-            return None
-            
-        try:
-            decimal_value = Decimal(str(value))
-            
-            if multiply_100:
-                decimal_value *= 100
-                
-            formatted = f"{decimal_value:.{precision}f}%"
-            return formatted
-        except (ValueError, InvalidOperation):
-            return None
-
-    @staticmethod
-    def format_phone_number(phone: str, 
-                            country_code: str = "+86", 
-                            format_type: str = "international") -> Optional[str]:
-        """
-        格式化电话号码
-        
-        :param phone: 电话号码
-        :param country_code: 国家代码
-        :param format_type: 格式类型 ('international', 'domestic', 'plain')
-        :return: 格式化后的电话号码
-        """
-        if not isinstance(phone, str):
-            phone = str(phone)
-            
-        # 移除所有非数字字符
-        digits = re.sub(r'\D', '', phone)
-        
-        if not digits:
-            return None
-            
-        # 如果是11位中国手机号
-        if len(digits) == 11 and digits.startswith('1'):
-            if format_type == "international":
-                return f"{country_code} {digits[:3]} {digits[3:7]} {digits[7:]}"
-            elif format_type == "domestic":
-                return f"{digits[:3]}-{digits[3:7]}-{digits[7:]}"
-            else:  # plain
-                return digits
-        else:
-            # 其他情况简单处理
-            if format_type == "international" and country_code:
-                return f"{country_code} {digits}"
-            else:
-                return digits
-
-    @staticmethod
-    def format_chinese_id_card(id_card: str) -> Optional[str]:
-        """
-        格式化中国身份证号码（隐藏中间部分）
-        
-        :param id_card: 身份证号码
-        :return: 格式化后的身份证号码
-        """
-        if not isinstance(id_card, str):
-            id_card = str(id_card)
-            
-        # 移除空格
-        id_card = id_card.replace(" ", "")
-        
-        if len(id_card) == 18:
-            # 18位身份证号
-            return f"{id_card[:6]}********{id_card[-4:]}"
-        elif len(id_card) == 15:
-            # 15位身份证号
-            return f"{id_card[:6]}******{id_card[-3:]}"
-        else:
-            return None
-
-    @staticmethod
-    def capitalize_words(text: str, 
-                         delimiter: str = " ", 
-                         preserve_articles: bool = True) -> str:
-        """
-        单词首字母大写
-        
-        :param text: 文本
-        :param delimiter: 单词分隔符
-        :param preserve_articles: 是否保留冠词小写
-        :return: 首字母大写后的文本
-        """
-        if not isinstance(text, str):
-            return str(text)
-            
-        # 常见的冠词和介词
-        articles = {'a', 'an', 'the', 'and', 'or', 'but', 'in', 'on', 'at', 'to', 'for', 'of', 'with', 'by'}
-        
-        words = text.split(delimiter)
-        capitalized_words = []
-        
-        for i, word in enumerate(words):
-            if not word:
-                capitalized_words.append(word)
-                continue
-                
-            # 第一个单词和最后一个单词总是大写
-            if i == 0 or i == len(words) - 1 or not preserve_articles or word.lower() not in articles:
-                capitalized_words.append(word.capitalize())
-            else:
-                capitalized_words.append(word.lower())
-                
-        return delimiter.join(capitalized_words)
-
-
-# =======================对外接口=======================
-
-def format_number(value: Any, 
-                  precision: int = 2, 
-                  thousand_separator: bool = False) -> Optional[str]:
-    """格式化数字"""
-    return DataFormatter.format_number(value, precision, thousand_separator)
-
-
-def format_currency(value: Any, 
-                    currency_symbol: str = "¥", 
-                    precision: int = 2) -> Optional[str]:
-    """格式化货币"""
-    return DataFormatter.format_currency(value, currency_symbol, precision)
-
-
-def format_percentage(value: Any, 
-                      precision: int = 2, 
-                      multiply_100: bool = True) -> Optional[str]:
-    """格式化百分比"""
-    return DataFormatter.format_percentage(value, precision, multiply_100)
-
-
-def format_phone_number(phone: str, 
-                        country_code: str = "+86", 
-                        format_type: str = "international") -> Optional[str]:
-    """格式化电话号码"""
-    return DataFormatter.format_phone_number(phone, country_code, format_type)
-
-
-def format_chinese_id_card(id_card: str) -> Optional[str]:
-    """格式化中国身份证号码"""
-    return DataFormatter.format_chinese_id_card(id_card)
-
-
-def capitalize_words(text: str, 
-                     delimiter: str = " ", 
-                     preserve_articles: bool = True) -> str:
-    """单词首字母大写"""
-    return DataFormatter.capitalize_words(text, delimiter, preserve_articles)