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

crawlo/utils/date_tools.py

@@ -1,177 +1,177 @@
-#!/usr/bin/python
-# -*- coding:UTF-8 -*-
-"""
-# @Time    :    2025-05-17 10:20
-# @Author  :   crawl-coder
-# @Desc    :   时间工具
-"""
-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 normalize_time(time_str: str) -> Optional[datetime]:
-    """
-    尝试使用常见格式解析时间字符串。
-
-    :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
-    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日'))
+#!/usr/bin/python
+# -*- coding:UTF-8 -*-
+"""
+# @Time    :    2025-05-17 10:20
+# @Author  :   crawl-coder
+# @Desc    :   时间工具
+"""
+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 normalize_time(time_str: str) -> Optional[datetime]:
+    """
+    尝试使用常见格式解析时间字符串。
+
+    :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
+    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,82 +1,82 @@
-# -*- 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__}'
-        )
-
-    try:
-        if isgenerator(func):
-            # 同步生成器处理
-            for item in func:
-                yield _set_meta(item)
-        else:
-            # 异步生成器处理
-            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
-
+# -*- 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__}'
+        )
+
+    try:
+        if isgenerator(func):
+            # 同步生成器处理
+            for item in func:
+                yield _set_meta(item)
+        else:
+            # 异步生成器处理
+            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/log.py

@@ -1,39 +1,39 @@
-#!/usr/bin/python
-# -*- coding:UTF-8 -*-
-"""
-# @Time    :    2024-04-11 09:03
-# @Author  :   oscar
-# @Desc    :   None
-"""
-from logging import Formatter, StreamHandler, Logger, INFO
-
-LOG_FORMAT = '%(asctime)s - [%(name)s] - %(levelname)s： %(message)s'
-
-
-class LoggerManager(object):
-    logger_cache = {}
-
-    def __init__(self):
-        pass
-
-    @classmethod
-    def get_logger(cls, name: str = 'default', level=None, log_format: str = LOG_FORMAT):
-        key = (name, level)
-
-        def gen_logger():
-            log_formatter = Formatter(log_format)
-            handler = StreamHandler()
-            handler.setFormatter(log_formatter)
-            handler.setLevel(level or INFO)
-
-            _logger = Logger(name=name)
-            _logger.addHandler(handler)
-            _logger.setLevel(level or INFO)
-            cls.logger_cache[key] = _logger
-            return _logger
-
-        return cls.logger_cache.get(key, None) or gen_logger()
-
-
-get_logger = LoggerManager.get_logger
-
+#!/usr/bin/python
+# -*- coding:UTF-8 -*-
+"""
+# @Time    :    2024-04-11 09:03
+# @Author  :   oscar
+# @Desc    :   None
+"""
+from logging import Formatter, StreamHandler, Logger, INFO
+
+LOG_FORMAT = '%(asctime)s - [%(name)s] - %(levelname)s： %(message)s'
+
+
+class LoggerManager(object):
+    logger_cache = {}
+
+    def __init__(self):
+        pass
+
+    @classmethod
+    def get_logger(cls, name: str = 'default', level=None, log_format: str = LOG_FORMAT):
+        key = (name, level)
+
+        def gen_logger():
+            log_formatter = Formatter(log_format)
+            handler = StreamHandler()
+            handler.setFormatter(log_formatter)
+            handler.setLevel(level or INFO)
+
+            _logger = Logger(name=name)
+            _logger.addHandler(handler)
+            _logger.setLevel(level or INFO)
+            cls.logger_cache[key] = _logger
+            return _logger
+
+        return cls.logger_cache.get(key, None) or gen_logger()
+
+
+get_logger = LoggerManager.get_logger
+