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

crawlo/utils/concurrency_manager.py

@@ -1,125 +1,125 @@
-import os
-import platform
-import logging
-from typing import Optional
-
-try:
-    import psutil  # 用于获取系统资源信息的第三方库
-except ImportError:
-    psutil = None  # 如果psutil不可用则设为None
-
-logger = logging.getLogger(__name__)
-
-
-def calculate_optimal_concurrency(user_specified: Optional[int] = None, use_logical_cores: bool = True) -> int:
-    """
-    基于系统资源计算最优并发数，或使用用户指定值
-
-    参数:
-        user_specified: 用户指定的并发数（优先使用）
-        use_logical_cores: 是否使用逻辑CPU核心数（超线程），默认为True
-
-    返回:
-        计算得出的最优并发数
-
-    说明:
-        1. 优先使用用户指定的并发数
-        2. 根据操作系统类型采用不同的计算策略：
-           - Windows: 保守计算，避免内存压力
-           - macOS: 平衡资源使用
-           - Linux: 充分利用服务器资源
-           - 其他系统: 使用合理默认值
-        3. 使用可用内存和CPU核心数进行计算
-        4. 提供psutil不可用时的备用方案
-    """
-    # 优先使用用户指定的并发数
-    if user_specified is not None:
-        logger.info(f"使用用户指定的并发数: {user_specified}")
-        return user_specified
-
-    try:
-        current_os = platform.system()  # 获取当前操作系统类型
-        logger.debug(f"检测到操作系统: {current_os}")
-
-        # 获取CPU核心数（根据参数决定是否使用逻辑核心）
-        cpu_count = psutil.cpu_count(logical=use_logical_cores) or 1 if psutil else os.cpu_count() or 1
-
-        # 根据操作系统类型选择不同的计算方法
-        if current_os == "Windows":
-            concurrency = _get_concurrency_for_windows(cpu_count, use_logical_cores)
-        elif current_os == "Darwin":  # macOS系统
-            concurrency = _get_concurrency_for_macos(cpu_count, use_logical_cores)
-        elif current_os == "Linux":
-            concurrency = _get_concurrency_for_linux(cpu_count, use_logical_cores)
-        else:  # 其他操作系统
-            concurrency = _get_concurrency_default(cpu_count)
-
-        logger.info(f"计算得到最大并发数: {concurrency}")
-        return concurrency
-
-    except Exception as e:
-        logger.warning(f"动态计算并发数失败: {str(e)}，使用默认值50")
-        return 50  # 计算失败时的安全默认值
-
-
-def _get_concurrency_for_windows(cpu_count: int, use_logical_cores: bool) -> int:
-    """Windows系统专用的并发数计算逻辑"""
-    if psutil:
-        # 计算可用内存（GB）
-        available_memory = psutil.virtual_memory().available / (1024 ** 3)
-        # 内存计算：每4GB可用内存分配10个并发
-        mem_based = int((available_memory / 4) * 10)
-        # CPU计算：使用逻辑核心时乘数较大
-        cpu_based = cpu_count * (5 if use_logical_cores else 3)
-        # 取5-100之间的值，选择内存和CPU限制中较小的
-        return max(5, min(100, mem_based, cpu_based))
-    else:
-        # 无psutil时的备用方案
-        return min(50, cpu_count * 5)
-
-
-def _get_concurrency_for_macos(cpu_count: int, use_logical_cores: bool) -> int:
-    """macOS系统专用的并发数计算逻辑"""
-    if psutil:
-        available_memory = psutil.virtual_memory().available / (1024 ** 3)
-        # 内存计算：每3GB可用内存分配10个并发
-        mem_based = int((available_memory / 3) * 10)
-        # CPU计算：使用逻辑核心时乘数较大
-        cpu_based = cpu_count * (6 if use_logical_cores else 4)
-        # 取5-120之间的值
-        return max(5, min(120, mem_based, cpu_based))
-    else:
-        try:
-            # macOS备用方案：使用系统命令获取物理CPU核心数
-            import subprocess
-            output = subprocess.check_output(["sysctl", "hw.physicalcpu"])
-            cpu_count = int(output.split()[1])
-            return min(60, cpu_count * 5)
-        except:
-            return 40  # Mac电脑的合理默认值
-
-
-def _get_concurrency_for_linux(cpu_count: int, use_logical_cores: bool) -> int:
-    """Linux系统专用的并发数计算逻辑（更激进）"""
-    if psutil:
-        available_memory = psutil.virtual_memory().available / (1024 ** 3)
-        # 内存计算：每1.5GB可用内存分配10个并发
-        mem_based = int((available_memory / 1.5) * 10)
-        # CPU计算：服务器环境使用更大的乘数
-        cpu_based = cpu_count * (8 if use_logical_cores else 5)
-        # 取5-200之间的值
-        return max(5, min(200, mem_based, cpu_based))
-    else:
-        try:
-            # Linux备用方案：解析/proc/cpuinfo文件
-            with open("/proc/cpuinfo") as f:
-                cpu_count = f.read().count("processor\t:")
-                if cpu_count > 0:
-                    return min(200, cpu_count * 8)
-        except:
-            return 50  # Linux服务器的合理默认值
-
-
-def _get_concurrency_default(cpu_count: int) -> int:
-    """未知操作系统的默认计算逻辑"""
+import os
+import platform
+import logging
+from typing import Optional
+
+try:
+    import psutil  # 用于获取系统资源信息的第三方库
+except ImportError:
+    psutil = None  # 如果psutil不可用则设为None
+
+logger = logging.getLogger(__name__)
+
+
+def calculate_optimal_concurrency(user_specified: Optional[int] = None, use_logical_cores: bool = True) -> int:
+    """
+    基于系统资源计算最优并发数，或使用用户指定值
+
+    参数:
+        user_specified: 用户指定的并发数（优先使用）
+        use_logical_cores: 是否使用逻辑CPU核心数（超线程），默认为True
+
+    返回:
+        计算得出的最优并发数
+
+    说明:
+        1. 优先使用用户指定的并发数
+        2. 根据操作系统类型采用不同的计算策略：
+           - Windows: 保守计算，避免内存压力
+           - macOS: 平衡资源使用
+           - Linux: 充分利用服务器资源
+           - 其他系统: 使用合理默认值
+        3. 使用可用内存和CPU核心数进行计算
+        4. 提供psutil不可用时的备用方案
+    """
+    # 优先使用用户指定的并发数
+    if user_specified is not None:
+        logger.info(f"使用用户指定的并发数: {user_specified}")
+        return user_specified
+
+    try:
+        current_os = platform.system()  # 获取当前操作系统类型
+        logger.debug(f"检测到操作系统: {current_os}")
+
+        # 获取CPU核心数（根据参数决定是否使用逻辑核心）
+        cpu_count = psutil.cpu_count(logical=use_logical_cores) or 1 if psutil else os.cpu_count() or 1
+
+        # 根据操作系统类型选择不同的计算方法
+        if current_os == "Windows":
+            concurrency = _get_concurrency_for_windows(cpu_count, use_logical_cores)
+        elif current_os == "Darwin":  # macOS系统
+            concurrency = _get_concurrency_for_macos(cpu_count, use_logical_cores)
+        elif current_os == "Linux":
+            concurrency = _get_concurrency_for_linux(cpu_count, use_logical_cores)
+        else:  # 其他操作系统
+            concurrency = _get_concurrency_default(cpu_count)
+
+        logger.info(f"计算得到最大并发数: {concurrency}")
+        return concurrency
+
+    except Exception as e:
+        logger.warning(f"动态计算并发数失败: {str(e)}，使用默认值50")
+        return 50  # 计算失败时的安全默认值
+
+
+def _get_concurrency_for_windows(cpu_count: int, use_logical_cores: bool) -> int:
+    """Windows系统专用的并发数计算逻辑"""
+    if psutil:
+        # 计算可用内存（GB）
+        available_memory = psutil.virtual_memory().available / (1024 ** 3)
+        # 内存计算：每4GB可用内存分配10个并发
+        mem_based = int((available_memory / 4) * 10)
+        # CPU计算：使用逻辑核心时乘数较大
+        cpu_based = cpu_count * (5 if use_logical_cores else 3)
+        # 取5-100之间的值，选择内存和CPU限制中较小的
+        return max(5, min(100, mem_based, cpu_based))
+    else:
+        # 无psutil时的备用方案
+        return min(50, cpu_count * 5)
+
+
+def _get_concurrency_for_macos(cpu_count: int, use_logical_cores: bool) -> int:
+    """macOS系统专用的并发数计算逻辑"""
+    if psutil:
+        available_memory = psutil.virtual_memory().available / (1024 ** 3)
+        # 内存计算：每3GB可用内存分配10个并发
+        mem_based = int((available_memory / 3) * 10)
+        # CPU计算：使用逻辑核心时乘数较大
+        cpu_based = cpu_count * (6 if use_logical_cores else 4)
+        # 取5-120之间的值
+        return max(5, min(120, mem_based, cpu_based))
+    else:
+        try:
+            # macOS备用方案：使用系统命令获取物理CPU核心数
+            import subprocess
+            output = subprocess.check_output(["sysctl", "hw.physicalcpu"])
+            cpu_count = int(output.split()[1])
+            return min(60, cpu_count * 5)
+        except:
+            return 40  # Mac电脑的合理默认值
+
+
+def _get_concurrency_for_linux(cpu_count: int, use_logical_cores: bool) -> int:
+    """Linux系统专用的并发数计算逻辑（更激进）"""
+    if psutil:
+        available_memory = psutil.virtual_memory().available / (1024 ** 3)
+        # 内存计算：每1.5GB可用内存分配10个并发
+        mem_based = int((available_memory / 1.5) * 10)
+        # CPU计算：服务器环境使用更大的乘数
+        cpu_based = cpu_count * (8 if use_logical_cores else 5)
+        # 取5-200之间的值
+        return max(5, min(200, mem_based, cpu_based))
+    else:
+        try:
+            # Linux备用方案：解析/proc/cpuinfo文件
+            with open("/proc/cpuinfo") as f:
+                cpu_count = f.read().count("processor\t:")
+                if cpu_count > 0:
+                    return min(200, cpu_count * 8)
+        except:
+            return 50  # Linux服务器的合理默认值
+
+
+def _get_concurrency_default(cpu_count: int) -> int:
+    """未知操作系统的默认计算逻辑"""
     return min(50, cpu_count * 5)  # 保守的默认计算方式

crawlo/utils/date_tools.py

@@ -1,177 +1,233 @@
-#!/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, Literal
+from datetime import datetime, timedelta
+from dateutil.relativedelta import relativedelta
+
+# 支持的单位类型
+TimeUnit = Literal["seconds", "minutes", "hours", "days"]
+# 时间输入类型
+TimeType = Union[str, datetime]
+
+# 常见时间格式列表（作为 dateparser 的后备方案）
+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",
+    "%B %d, %Y",
+    "%Y年%m月%d日",
+    "%Y年%m月%d日 %H时%M分%S秒",
+    "%a %b %d %H:%M:%S %Y",
+    "%a, %d %b %Y %H:%M:%S",
+    "%Y-%m-%dT%H:%M:%S.%f",
+    "%Y-%m-%dT%H:%M:%S",
+]
+
+
+class TimeUtils:
+    """
+    时间处理工具类，提供日期解析、格式化、计算等一站式服务。
+    特别适用于爬虫中处理多语言、多格式、相对时间的场景。
+    """
+
+    @staticmethod
+    def _try_strptime(time_str: str) -> Optional[datetime]:
+        """尝试使用预定义格式解析，作为 dateparser 的后备"""
+        for fmt in COMMON_FORMATS:
+            try:
+                return datetime.strptime(time_str.strip(), fmt)
+            except ValueError:
+                continue
+        return None
+
+    @classmethod
+    def parse(cls, time_input: TimeType, *, default: Optional[datetime] = None) -> Optional[datetime]:
+        """
+        智能解析时间输入（字符串或 datetime）。
+
+        :param time_input: 时间字符串（支持各种语言、格式、相对时间）或 datetime 对象
+        :param default: 解析失败时返回的默认值
+        :return: 解析成功返回 datetime，失败返回 default
+        """
+        if isinstance(time_input, datetime):
+            return time_input
+
+        if not isinstance(time_input, str) or not time_input.strip():
+            return default
+
+        # 1. 优先使用 dateparser（支持多语言和相对时间）
+        try:
+            parsed = dateparser.parse(time_input.strip())
+            if parsed:
+                return parsed
+        except Exception:
+            pass  # 忽略异常，尝试后备方案
+
+        # 2. 尝试使用常见格式解析
+        try:
+            parsed = cls._try_strptime(time_input)
+            if parsed:
+                return parsed
+        except Exception:
+            pass
+
+        return default
+
+    @classmethod
+    def format(cls, dt: TimeType, fmt: str = "%Y-%m-%d %H:%M:%S") -> Optional[str]:
+        """
+        格式化时间。
+
+        :param dt: datetime 对象或可解析的字符串
+        :param fmt: 输出格式
+        :return: 格式化后的字符串，失败返回 None
+        """
+        if isinstance(dt, str):
+            dt = cls.parse(dt)
+            if dt is None:
+                return None
+        try:
+            return dt.strftime(fmt)
+        except Exception:
+            return None
+
+    @classmethod
+    def to_timestamp(cls, dt: TimeType) -> Optional[float]:
+        """转换为时间戳（秒级）"""
+        if isinstance(dt, str):
+            dt = cls.parse(dt)
+            if dt is None:
+                return None
+        try:
+            return dt.timestamp()
+        except Exception:
+            return None
+
+    @classmethod
+    def from_timestamp(cls, ts: float) -> Optional[datetime]:
+        """从时间戳创建 datetime"""
+        try:
+            return datetime.fromtimestamp(ts)
+        except Exception:
+            return None
+
+    @classmethod
+    def diff(cls, start: TimeType, end: TimeType, unit: TimeUnit = "seconds") -> Optional[int]:
+        """
+        计算两个时间的差值（自动解析字符串）。
+
+        :param start: 起始时间
+        :param end: 结束时间
+        :param unit: 单位 ('seconds', 'minutes', 'hours', 'days')
+        :return: 差值（绝对值），失败返回 None
+        """
+        start_dt = cls.parse(start)
+        end_dt = cls.parse(end)
+        if not start_dt or not end_dt:
+            return None
+
+        delta = abs((end_dt - start_dt).total_seconds())
+
+        unit_map = {
+            "seconds": 1,
+            "minutes": 60,
+            "hours": 3600,
+            "days": 86400,
+        }
+        return int(delta // unit_map.get(unit, 1))
+
+    @classmethod
+    def add_days(cls, dt: TimeType, days: int) -> Optional[datetime]:
+        """日期加减（天）"""
+        dt = cls.parse(dt)
+        if dt is None:
+            return None
+        return dt + timedelta(days=days)
+
+    @classmethod
+    def add_months(cls, dt: TimeType, months: int) -> Optional[datetime]:
+        """日期加减（月）"""
+        dt = cls.parse(dt)
+        if dt is None:
+            return None
+        return dt + relativedelta(months=months)
+
+    @classmethod
+    def days_between(cls, dt1: TimeType, dt2: TimeType) -> Optional[int]:
+        """计算两个日期之间的天数差"""
+        return cls.diff(dt1, dt2, "days")
+
+    @classmethod
+    def is_leap_year(cls, year: int) -> bool:
+        """判断是否是闰年"""
+        return (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0)
+
+    @classmethod
+    def now(cls, fmt: Optional[str] = None) -> Union[datetime, str]:
+        """
+        获取当前时间。
+
+        :param fmt: 如果提供，则返回格式化字符串；否则返回 datetime 对象。
+        :return: datetime 或 str
+        """
+        dt = datetime.now()
+        if fmt is not None:
+            return dt.strftime(fmt)
+        return dt
+
+    @classmethod
+    def iso_format(cls, dt: TimeType) -> Optional[str]:
+        """返回 ISO 8601 格式字符串"""
+        dt = cls.parse(dt)
+        if dt is None:
+            return None
+        return dt.isoformat()
+
+
+# =======================对外接口=======================
+
+def parse_time(time_input: TimeType, default: Optional[datetime] = None) -> Optional[datetime]:
+    """解析时间字符串或对象"""
+    return TimeUtils.parse(time_input, default=default)
+
+
+def format_time(dt: TimeType, fmt: str = "%Y-%m-%d %H:%M:%S") -> Optional[str]:
+    """格式化时间"""
+    return TimeUtils.format(dt, fmt)
+
+
+def time_diff(start: TimeType, end: TimeType, unit: TimeUnit = "seconds") -> Optional[int]:
+    """计算时间差"""
+    return TimeUtils.diff(start, end, unit)
+
+
+def to_timestamp(dt: TimeType) -> Optional[float]:
+    """转时间戳"""
+    return TimeUtils.to_timestamp(dt)
+
+
+def to_datetime(ts: float) -> Optional[datetime]:
+    """从时间戳转 datetime"""
+    return TimeUtils.from_timestamp(ts)
+
+
+def now(fmt: Optional[str] = None) -> Union[datetime, str]:
+    """获取当前时间"""
+    return TimeUtils.now(fmt)
+
+
+if __name__ == '__main__':
+    get_current_time = now(fmt="%Y-%m-%d %H:%M:%S")
+    print(get_current_time)