crawlo 1.0.2__py3-none-any.whl → 1.0.3__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,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日'))