crawlo 1.0.0__py3-none-any.whl → 1.0.1__py3-none-any.whl

crawlo/utils/date_tools.py

@@ -5,16 +5,173 @@
 # @Author  :   crawl-coder
 # @Desc    :   时间工具
 """
-from datetime import datetime
+import dateparser
+from typing import Optional, Union
+from datetime import datetime, timedelta
+from dateutil.relativedelta import relativedelta
 
+# 常见时间格式列表
+COMMON_FORMATS = [
+    "%Y-%m-%d %H:%M:%S",
+    "%Y/%m/%d %H:%M:%S",
+    "%d-%m-%Y %H:%M:%S",
+    "%d/%m/%Y %H:%M:%S",
+    "%Y-%m-%d",
+    "%Y/%m/%d",
+    "%d-%m-%Y",
+    "%d/%m/%Y",
+    "%b %d, %Y",  # Jan 01, 2023
+    "%B %d, %Y",  # January 01, 2023
+    "%Y年%m月%d日",  # 2023年01月01日
+    "%Y年%m月%d日 %H时%M分%S秒",  # 2023年01月01日 12时30分45秒
+    "%a %b %d %H:%M:%S %Y",  # Wed Jan 01 12:00:00 2020
+    "%a, %d %b %Y %H:%M:%S",  # Wed, 01 Jan 2020 12:00:00
+    "%Y-%m-%dT%H:%M:%S.%f",  # ✅ 新增：ISO 8601 格式（带毫秒）
+]
 
-def now():
-    return datetime.now().strftime('%Y-%m-%d %H:%M:%S')
 
+def normalize_time(time_str: str) -> Optional[datetime]:
+    """
+    尝试使用常见格式解析时间字符串。
 
-def date_delta(start, end):
-    start = datetime.strptime(start, '%Y-%m-%d %H:%M:%S')
-    end = datetime.strptime(end, '%Y-%m-%d %H:%M:%S')
+    :param time_str: 时间字符串（如 "2023-01-01 12:00:00"）
+    :return: 解析成功返回 datetime 对象，失败返回 None 或抛出异常（可选）
+    """
+    for fmt in COMMON_FORMATS:
+        try:
+            return datetime.strptime(time_str, fmt)
+        except ValueError:
+            continue
+    raise ValueError(f"无法解析时间字符串：{time_str}")
+
+
+def get_current_time(fmt: str = '%Y-%m-%d %H:%M:%S'):
+    """
+    获取当前时间，根据是否传入格式化参数决定返回类型
+    :param fmt: 格式化字符串，如 "%Y-%m-%d %H:%M:%S"
+    :return: datetime 或 str
+    """
+    dt = datetime.now()
+    if fmt is not None:
+        return dt.strftime(fmt)
+    return dt
+
+
+def time_diff_seconds(start_time: str, end_time: str, fmt: str = '%Y-%m-%d %H:%M:%S'):
+    """
+        计算两个时间字符串之间的秒数差。
+
+        :param start_time: 起始时间字符串
+        :param end_time: 结束时间字符串
+        :param fmt: 时间格式，默认为 '%Y-%m-%d %H:%M:%S'
+        :return: 秒数差（总是正整数）
+        """
+    start = datetime.strptime(start_time, fmt)
+    end = datetime.strptime(end_time, fmt)
     delta = end - start
-    seconds = delta.total_seconds()
-    return int(seconds)
+    return int(delta.total_seconds())
+
+
+TimeType = Union[str, datetime]
+
+
+def time_diff(start: TimeType, end: TimeType, fmt: str = None, unit='seconds', auto_parse=True) -> Optional[int]:
+    """
+    计算两个时间之间的差值（支持字符串或 datetime）。
+
+    :param start: 起始时间（字符串或 datetime）
+    :param end: 结束时间（字符串或 datetime）
+    :param fmt: 时间格式（如果传入字符串且 auto_parse=False 时需要）
+    :param unit: 单位（seconds, minutes, hours, days）
+    :param auto_parse: 是否自动尝试解析任意格式的字符串（推荐开启）
+    :return: 差值整数（根据 unit 返回），失败返回 None
+    """
+
+    def ensure_datetime(t):
+        if isinstance(t, datetime):
+            return t
+        elif isinstance(t, str):
+            if auto_parse:
+                parsed = normalize_time(t)
+                if parsed:
+                    return parsed
+            if fmt:
+                return datetime.strptime(t, fmt)
+            raise ValueError("字符串时间未提供格式，或无法自动解析")
+        else:
+            raise TypeError(f"不支持的时间类型: {type(t)}")
+
+    start_dt = ensure_datetime(start)
+    end_dt = ensure_datetime(end)
+
+    delta = (end_dt - start_dt)
+    abs_seconds = int(abs(delta.total_seconds()))
+
+    if unit == 'seconds':
+        return abs_seconds
+    elif unit == 'minutes':
+        return abs_seconds // 60
+    elif unit == 'hours':
+        return abs_seconds // 3600
+    elif unit == 'days':
+        return abs_seconds // 86400
+    else:
+        raise ValueError(f"Unsupported unit: {unit}")
+
+
+def format_datetime(dt, fmt="%Y-%m-%d %H:%M:%S"):
+    """格式化时间"""
+    return dt.strftime(fmt)
+
+
+def parse_datetime(s, fmt="%Y-%m-%d %H:%M:%S"):
+    """将字符串解析为 datetime 对象"""
+    return datetime.strptime(s, fmt)
+
+
+def datetime_to_timestamp(dt):
+    """将 datetime 转换为时间戳"""
+    return dt.timestamp()
+
+
+def timestamp_to_datetime(ts):
+    """将时间戳转换为 datetime"""
+    return datetime.fromtimestamp(ts)
+
+
+def add_days(dt, days=0):
+    """日期加减（天）"""
+    return dt + timedelta(days=days)
+
+
+def add_months(dt, months=0):
+    """日期加减（月）"""
+    return dt + relativedelta(months=months)
+
+
+def days_between(dt1, dt2):
+    """计算两个日期之间的天数差"""
+    return abs((dt2 - dt1).days)
+
+
+def is_leap_year(year):
+    """判断是否是闰年"""
+    return (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0)
+
+
+def parse_relative_time(time_str: str) -> str:
+    """
+    解析相对时间字符串（如 "3分钟前"、"昨天"）为 datetime 对象。
+    """
+    dt = dateparser.parse(time_str)
+    return dt.isoformat()
+
+
+if __name__ == '__main__':
+    print(normalize_time(parse_relative_time("30分钟前")))
+    print(parse_relative_time("昨天"))
+    print(parse_relative_time("10小时前"))
+    print(parse_relative_time("1个月前"))
+    print(parse_relative_time("10天前"))
+    print(parse_relative_time("2024年1月1日"))
+    print(parse_relative_time('2025年5月30日'))

crawlo/utils/func_tools.py

@@ -1,22 +1,82 @@
-#!/usr/bin/python
-# -*- coding:UTF-8 -*-
-from typing import Callable
+# -*- coding: UTF-8 -*-
+from typing import Union, AsyncGenerator, Generator
 from inspect import isgenerator, isasyncgen
+from crawlo import Response, Request, Item
 from crawlo.exceptions import TransformTypeError
 
+T = Union[Request, Item]
+
+
+async def transform(
+        func: Union[Generator[T, None, None], AsyncGenerator[T, None]],
+        response: Response
+) -> AsyncGenerator[Union[T, Exception], None]:
+    """
+    转换回调函数的输出为统一异步生成器
+
+    Args:
+        func: 同步或异步生成器函数
+        response: 当前响应对象
+
+    Yields:
+        Union[T, Exception]: 生成请求/Item或异常对象
+
+    Raises:
+        TransformTypeError: 当输入类型不符合要求时
+    """
+
+    def _set_meta(obj: T) -> T:
+        """统一设置请求的depth元数据"""
+        if isinstance(obj, Request):
+            obj.meta.setdefault('depth', response.meta.get('depth', 0))
+        return obj
+
+    # 类型检查前置
+    if not (isgenerator(func) or isasyncgen(func)):
+        raise TransformTypeError(
+            f'Callback must return generator or async generator, got {type(func).__name__}'
+        )
 
-async def transform(func: Callable):
     try:
         if isgenerator(func):
-            for f in func:
-                yield f
-        elif isasyncgen(func):
-            async for f in func:
-                yield f
+            # 同步生成器处理
+            for item in func:
+                yield _set_meta(item)
         else:
-            raise TransformTypeError(
-                f'callback return type error: {type(func)} must be `generator` or `async generator`'
-            )
-    except Exception as exp:
-        yield exp
+            # 异步生成器处理
+            async for item in func:
+                yield _set_meta(item)
+
+    except Exception as e:
+        yield e
+
+# #!/usr/bin/python
+# # -*- coding:UTF-8 -*-
+# from typing import Callable, Union
+# from inspect import isgenerator, isasyncgen
+# from crawlo import Response, Request, Item
+# from crawlo.exceptions import TransformTypeError
+#
+#
+# T = Union[Request, Item]
+#
+#
+# async def transform(func: Callable, response: Response):
+#     def set_request(t: T) -> T:
+#         if isinstance(t, Request):
+#             t.meta['depth'] = response.meta['depth']
+#         return t
+#     try:
+#         if isgenerator(func):
+#             for f in func:
+#                 yield set_request(f)
+#         elif isasyncgen(func):
+#             async for f in func:
+#                 yield set_request(f)
+#         else:
+#             raise TransformTypeError(
+#                 f'callback return type error: {type(func)} must be `generator` or `async generator`'
+#             )
+#     except Exception as exp:
+#         yield exp
 

crawlo/utils/pqueue.py

@@ -1,16 +1,174 @@
-#!/usr/bin/python
 # -*- coding:UTF-8 -*-
+import sys
 import asyncio
-from asyncio import PriorityQueue, TimeoutError
+import warnings
+from urllib.parse import urlparse
+from asyncio import PriorityQueue
+from redis.asyncio import from_url
+from typing import Any, Optional, Dict, Annotated
+from pydantic import (
+    BaseModel,
+    Field,
+    model_validator
+)
+
+from crawlo import Request
+from crawlo.settings.default_settings import REDIS_URL
 
 
 class SpiderPriorityQueue(PriorityQueue):
-    def __init__(self, maxsize=0):
-        super(SpiderPriorityQueue, self).__init__(maxsize=maxsize)
+    """带超时功能的异步优先级队列"""
+
+    def __init__(self, maxsize: int = 0) -> None:
+        """初始化队列，maxsize为0表示无大小限制"""
+        super().__init__(maxsize)
+
+    async def get(self, timeout: float = 0.1) -> Optional[Request]:
+        """
+        异步获取队列元素，带超时功能
+
+        Args:
+            timeout: 超时时间（秒），默认0.1秒
 
-    async def get(self):
-        fut = super().get()
+        Returns:
+            队列元素(优先级, 值)或None(超时)
+        """
         try:
-            return await asyncio.wait_for(fut, timeout=0.1)
-        except TimeoutError:
+            # 根据Python版本选择超时实现方式
+            if sys.version_info >= (3, 11):
+                async with asyncio.timeout(timeout):
+                    return await super().get()
+            else:
+                return await asyncio.wait_for(super().get(), timeout=timeout)
+        except asyncio.TimeoutError:
             return None
+
+
+class TaskModel(BaseModel):
+    """爬虫任务数据模型 (完全兼容Pydantic V2)"""
+    url: Annotated[str, Field(min_length=1, max_length=2000, examples=["https://example.com"])]
+    meta: Dict[str, Any] = Field(default_factory=dict)
+    priority: Annotated[int, Field(default=0, ge=0, le=10, description="0=最高优先级")]
+
+    @classmethod
+    def validate_url(cls, v: str) -> str:
+        """验证URL格式"""
+        if not v.startswith(('http://', 'https://')):
+            raise ValueError('URL必须以 http:// 或 https:// 开头')
+
+        parsed = urlparse(v)
+        if not parsed.netloc:
+            raise ValueError('URL缺少有效域名')
+
+        return v.strip()
+
+    @model_validator(mode='after')
+    def validate_priority_logic(self) -> 'TaskModel':
+        """跨字段验证示例"""
+        if 'admin' in self.url and self.priority > 5:
+            self.priority = 5  # 自动调整管理页面的优先级
+        return self
+
+
+class DistributedPriorityQueue:
+    def __init__(
+            self,
+            redis_url: str,
+            queue_name: str = "spider_queue",
+            max_connections: int = 10,
+            health_check_interval: int = 30
+    ):
+        """
+        Args:
+            redis_url: redis://[:password]@host:port[/db]
+            queue_name: Redis有序集合键名
+            max_connections: 连接池大小
+            health_check_interval: 连接健康检查间隔(秒)
+        """
+        self.redis = from_url(
+            redis_url,
+            max_connections=max_connections,
+            health_check_interval=health_check_interval,
+            socket_keepalive=True,
+            decode_responses=True
+        )
+        self.queue_name = queue_name
+
+    async def put(self, task: TaskModel) -> bool:
+        """
+        添加任务到队列（使用Pydantic V2的model_dump_json）
+
+        Args:
+            task: 已验证的TaskModel实例
+
+        Returns:
+            bool: 是否成功添加 (Redis的ZADD返回添加数量)
+        """
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore", category=DeprecationWarning)
+            task_str = task.model_dump_json()  # 正确使用V2的序列化方法
+        return await self.redis.zadd(
+            self.queue_name,
+            {task_str: task.priority}
+        ) > 0
+
+    async def get(self, timeout: float = 1.0) -> Optional[TaskModel]:
+        """
+        获取优先级最高的任务（自动验证）
+
+        Args:
+            timeout: 阻塞超时时间(秒)
+
+        Returns:
+            TaskModel实例或None(超时/队列空)
+        """
+        try:
+            result = await self.redis.bzpopmax(
+                self.queue_name,
+                timeout=timeout
+            )
+            if result:
+                _, task_str, _ = result
+                with warnings.catch_warnings():
+                    warnings.simplefilter("ignore", category=DeprecationWarning)
+                    return TaskModel.model_validate_json(task_str)  # 正确使用V2的反序列化方法
+        except Exception as e:
+            print(f"任务获取失败: {type(e).__name__}: {e}")
+        return None
+
+    async def aclose(self):
+        """安全关闭连接"""
+        await self.redis.aclose()
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        await self.aclose()
+
+
+# 使用示例
+async def demo():
+    async with DistributedPriorityQueue(
+            REDIS_URL,
+            max_connections=20,
+            health_check_interval=10
+    ) as queue:
+        # 添加任务（自动触发验证）
+        task = TaskModel(
+            url="https://example.com/1",
+            priority=1,
+            meta={"depth": 2}
+        )
+
+        if await queue.put(task):
+            print(f"任务添加成功: {task.url}")
+
+        # 获取任务
+        if result := await queue.get(timeout=2.0):
+            print(f"获取任务: {result.url} (优先级={result.priority})")
+            print(f"元数据: {result.meta}")
+
+
+if __name__ == "__main__":
+    asyncio.run(demo())

crawlo/utils/project.py

@@ -17,8 +17,9 @@ def _get_closest(path='.'):
 def _init_env():
     closest = _get_closest()
     if closest:
-        project_dir = os.path.dirname(closest)
-        sys.path.append(project_dir)
+        sys.path.append(closest)
+        # project_dir = os.path.dirname(closest)
+        # sys.path.append(project_dir)
 
 
 def get_settings(settings='settings'):

crawlo/utils/request.py

@@ -0,0 +1,85 @@
+#!/usr/bin/python
+# -*- coding:UTF-8 -*-
+"""
+# @Time    :    2025-07-08 08:55
+# @Author  :   crawl-coder
+# @Desc    :   None
+"""
+import json
+import hashlib
+from typing import Any, Optional, Iterable, Union
+from w3lib.url import canonicalize_url
+
+from crawlo import Request
+
+
+def to_bytes(data: Any, encoding='utf-8') -> bytes:
+    """
+    将各种类型统一转换为 bytes。
+    支持 str, bytes, dict, None 及其他可转为字符串的类型。
+    """
+    if isinstance(data, bytes):
+        return data
+    if isinstance(data, str):
+        return data.encode(encoding)
+    if isinstance(data, dict):
+        return json.dumps(data, sort_keys=True, ensure_ascii=False).encode(encoding)
+    if data is None:
+        return b''
+    return str(data).encode(encoding)
+
+
+def request_fingerprint(
+        request: Request,
+        include_headers: Optional[Iterable[Union[bytes, str]]] = None
+) -> str:
+    """
+    生成请求指纹，基于方法、标准化 URL、body 和可选的 headers。
+    使用 SHA256 哈希算法以提高安全性。
+
+    :param request: Request 对象（需包含 method, url, body, headers）
+    :param include_headers: 指定要参与指纹计算的 header 名称列表（str 或 bytes）
+    :return: 请求指纹（hex string）
+    """
+    hash_func = hashlib.sha256()
+
+    # 基本字段
+    hash_func.update(to_bytes(request.method))
+    hash_func.update(to_bytes(canonicalize_url(request.url)))
+    hash_func.update(request.body or b'')
+
+    # 处理 headers
+    if include_headers:
+        headers = request.headers  # 假设 headers 是类似字典或 MultiDict 的结构
+        for header_name in include_headers:
+            name_bytes = to_bytes(header_name).lower()  # 统一转为小写进行匹配
+            value = b''
+
+            # 兼容 headers 的访问方式（如 MultiDict 或 dict）
+            if hasattr(headers, 'get_all'):
+                # 如 scrapy.http.Headers 的 get_all 方法
+                values = headers.get_all(name_bytes)
+                value = b';'.join(values) if values else b''
+            elif hasattr(headers, '__getitem__'):
+                # 如普通 dict
+                try:
+                    raw_value = headers[name_bytes]
+                    if isinstance(raw_value, list):
+                        value = b';'.join(to_bytes(v) for v in raw_value)
+                    else:
+                        value = to_bytes(raw_value)
+                except (KeyError, TypeError):
+                    value = b''
+            else:
+                value = b''
+
+            hash_func.update(name_bytes + b':' + value)
+
+    return hash_func.hexdigest()
+
+
+def set_request(request: Request, priority: int) -> None:
+    request.meta['depth'] = request.meta.setdefault('depth', 0) + 1
+    if priority:
+        request.priority -= request.meta['depth'] * priority
+

crawlo/utils/url.py

@@ -0,0 +1,40 @@
+from urllib.parse import urldefrag
+from w3lib.url import add_or_replace_parameter
+
+
+def escape_ajax(url: str) -> str:
+    """
+    根据Google AJAX爬取规范转换URL（处理哈希片段#!）：
+    https://developers.google.com/webmasters/ajax-crawling/docs/getting-started
+
+    规则说明：
+    1. 仅当URL包含 `#!` 时才转换（表示这是AJAX可爬取页面）
+    2. 将 `#!key=value` 转换为 `?_escaped_fragment_=key%3Dvalue`
+    3. 保留原始查询参数（如果有）
+
+    示例：
+    >>> escape_ajax("www.example.com/ajax.html#!key=value")
+    'www.example.com/ajax.html?_escaped_fragment_=key%3Dvalue'
+    >>> escape_ajax("www.example.com/ajax.html?k1=v1#!key=value")
+    'www.example.com/ajax.html?k1=v1&_escaped_fragment_=key%3Dvalue'
+    >>> escape_ajax("www.example.com/ajax.html#!")
+    'www.example.com/ajax.html?_escaped_fragment_='
+
+    非AJAX可爬取的URL（无#!）原样返回：
+    >>> escape_ajax("www.example.com/ajax.html#normal")
+    'www.example.com/ajax.html#normal'
+    """
+    # 分离URL的基础部分和哈希片段
+    de_frag, frag = urldefrag(url)
+
+    # 仅处理以"!"开头的哈希片段（Google规范）
+    if not frag.startswith("!"):
+        return url  # 不符合规则则原样返回
+
+    # 调用辅助函数添加 `_escaped_fragment_` 参数
+    return add_or_replace_parameter(de_frag, "_escaped_fragment_", frag[1:])
+
+
+if __name__ == '__main__':
+    f = escape_ajax('http://example.com/page#!')
+    print(f)

{crawlo-1.0.0.dist-info → crawlo-1.0.1.dist-info}/METADATA

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: crawlo
-Version: 1.0.0
-Summary: feapder是一款支持异步的python爬虫框架
+Version: 1.0.1
+Summary: Crawlo是一款支持异步的python爬虫框架
 Home-page: https://github.com/crawl-coder/Crawlo.git
 Author: crawl-coder
 Author-email: crawlo@qq.com