hutool-python 1.0.0__py3-none-any.whl

hutool/core/util/re_util.py

@@ -0,0 +1,231 @@
+"""正则表达式工具类，对应 Java cn.hutool.core.util.ReUtil"""
+
+import re
+from typing import List, Optional
+
+
+class ReUtil:
+    """正则表达式工具类，对应 Java cn.hutool.core.util.ReUtil
+
+    提供常用的正则匹配、提取、替换、分割等静态方法。
+    """
+
+    @staticmethod
+    def is_match(pattern: str, content: str) -> bool:
+        """给定内容是否匹配正则（全匹配）
+
+        :param pattern: 正则表达式
+        :param content: 被匹配的内容
+        :return: 是否全匹配
+        """
+        return re.fullmatch(pattern, content) is not None
+
+    @staticmethod
+    def contains(pattern: str, content: str) -> bool:
+        """给定内容是否包含正则匹配
+
+        :param pattern: 正则表达式
+        :param content: 被匹配的内容
+        :return: 是否包含匹配
+        """
+        return re.search(pattern, content) is not None
+
+    @staticmethod
+    def get(pattern: str, content: str, group_index: int = 0) -> Optional[str]:
+        """获得匹配的字符串，group_index=0 返回整个匹配
+
+        :param pattern: 正则表达式
+        :param content: 被匹配的内容
+        :param group_index: 匹配组索引，0表示整个匹配
+        :return: 匹配的字符串，无匹配返回 None
+        """
+        match = re.search(pattern, content)
+        if match is None:
+            return None
+        try:
+            return match.group(group_index)
+        except IndexError:
+            return None
+
+    @staticmethod
+    def get_all(pattern: str, content: str, group_index: int = 0) -> List[str]:
+        """获得所有匹配的字符串列表
+
+        :param pattern: 正则表达式
+        :param content: 被匹配的内容
+        :param group_index: 匹配组索引，0表示整个匹配
+        :return: 所有匹配的字符串列表
+        """
+        results: List[str] = []
+        for match in re.finditer(pattern, content):
+            try:
+                results.append(match.group(group_index))
+            except IndexError:
+                pass
+        return results
+
+    @staticmethod
+    def get_all_groups(pattern: str, content: str) -> List[List[str]]:
+        """获得所有匹配，每个匹配返回所有分组
+
+        :param pattern: 正则表达式
+        :param content: 被匹配的内容
+        :return: 二维列表，外层为每个匹配，内层为该匹配的所有捕获组（group(1) 至 group(N)）
+        """
+        results: List[List[str]] = []
+        for match in re.finditer(pattern, content):
+            results.append(list(match.groups(default="")))
+        return results
+
+    @staticmethod
+    def match_all(pattern: str, content: str) -> List[str]:
+        """获得匹配的全部内容（等价于 get_all group_index=0）
+
+        :param pattern: 正则表达式
+        :param content: 被匹配的内容
+        :return: 所有完整匹配的字符串列表
+        """
+        return ReUtil.get_all(pattern, content, group_index=0)
+
+    @staticmethod
+    def replace_all(content: str, pattern: str, replacement: str) -> str:
+        """替换所有匹配
+
+        :param content: 被替换的内容
+        :param pattern: 正则表达式
+        :param replacement: 替换字符串，可使用 \\1 \\2 等反向引用
+        :return: 替换后的字符串
+        """
+        return re.sub(pattern, replacement, content)
+
+    @staticmethod
+    def replace_first(content: str, pattern: str, replacement: str) -> str:
+        """替换第一个匹配
+
+        :param content: 被替换的内容
+        :param pattern: 正则表达式
+        :param replacement: 替换字符串，可使用 \\1 \\2 等反向引用
+        :return: 替换后的字符串
+        """
+        return re.sub(pattern, replacement, content, count=1)
+
+    @staticmethod
+    def extract(pattern: str, content: str, template: str) -> Optional[str]:
+        """提取匹配内容并按模板重组
+
+        例如::
+
+            extract(r"(\\d+)-(\\d+)", "123-456", "$2-$1")  -> "456-123"
+            extract(r"(\\w+)@(\\w+)", "user@host", "$1")    -> "user"
+
+        :param pattern: 正则表达式，应包含分组
+        :param content: 被匹配的内容
+        :param template: 模板字符串，使用 $1 $2 等引用分组
+        :return: 按模板重组后的字符串，无匹配返回 None
+        """
+        match = re.search(pattern, content)
+        if match is None:
+            return None
+        return ReUtil._apply_template(match, template)
+
+    @staticmethod
+    def extract_multi(pattern: str, content: str, template: str) -> List[str]:
+        """提取所有匹配内容并按模板重组
+
+        :param pattern: 正则表达式，应包含分组
+        :param content: 被匹配的内容
+        :param template: 模板字符串，使用 $1 $2 等引用分组
+        :return: 所有按模板重组后的字符串列表
+        """
+        results: List[str] = []
+        for match in re.finditer(pattern, content):
+            results.append(ReUtil._apply_template(match, template))
+        return results
+
+    @staticmethod
+    def count(pattern: str, content: str) -> int:
+        """统计匹配次数
+
+        :param pattern: 正则表达式
+        :param content: 被匹配的内容
+        :return: 匹配次数
+        """
+        return len(re.findall(pattern, content))
+
+    @staticmethod
+    def split(content: str, pattern: str) -> List[str]:
+        """按正则分割字符串
+
+        :param content: 被分割的字符串
+        :param pattern: 分隔符正则表达式
+        :return: 分割后的字符串列表
+        """
+        return re.split(pattern, content)
+
+    @staticmethod
+    def del_all(pattern: str, content: str) -> str:
+        """删除所有匹配内容
+
+        :param pattern: 正则表达式
+        :param content: 被处理的字符串
+        :return: 删除匹配内容后的字符串
+        """
+        return re.sub(pattern, "", content)
+
+    @staticmethod
+    def escape(characters: str) -> str:
+        """转义正则特殊字符
+
+        :param characters: 需要转义的字符串
+        :return: 转义后的字符串
+        """
+        return re.escape(characters)
+
+    @staticmethod
+    def get_group0(pattern: str, content: str) -> Optional[str]:
+        """获取第一个匹配的第 0 组（整个匹配）
+
+        :param pattern: 正则表达式
+        :param content: 被匹配的内容
+        :return: 整个匹配的字符串，无匹配返回 None
+        """
+        return ReUtil.get(pattern, content, group_index=0)
+
+    @staticmethod
+    def get_group1(pattern: str, content: str) -> Optional[str]:
+        """获取第一个匹配的第 1 组
+
+        :param pattern: 正则表达式
+        :param content: 被匹配的内容
+        :return: 第 1 组匹配的字符串，无匹配返回 None
+        """
+        return ReUtil.get(pattern, content, group_index=1)
+
+    # ------------------------------------------------------------------
+    # 内部辅助方法
+    # ------------------------------------------------------------------
+
+    @staticmethod
+    def _apply_template(match: re.Match, template: str) -> str:
+        """将匹配对象按模板重组
+
+        模板中 $n（n 为数字）会被替换为对应的捕获组内容。
+        $$ 会被替换为字面量 $。
+
+        :param match: 正则匹配对象
+        :param template: 模板字符串
+        :return: 重组后的字符串
+        """
+
+        def _replace_ref(m: re.Match) -> str:
+            token = m.group(0)
+            if token == "$$":
+                return "$"
+            # $0, $1, $2, ...
+            idx = int(token[1:])
+            try:
+                return match.group(idx) if match.group(idx) is not None else ""
+            except IndexError:
+                return ""
+
+        return re.sub(r"\$\$|\$\d+", _replace_ref, template)

hutool/core/util/reflect_util.py

@@ -0,0 +1,135 @@
+import inspect
+from typing import Any, Dict, List, Type
+
+
+class ReflectUtil:
+    """反射工具类
+
+    提供对Python对象的反射操作，包括获取/设置字段值、调用方法、
+    获取字段和方法信息等。
+    """
+
+    @staticmethod
+    def get_field_value(obj: Any, field_name: str) -> Any:
+        """获取字段值
+
+        :param obj: 对象
+        :param field_name: 字段名
+        :return: 字段值
+        :raises AttributeError: 字段不存在
+        """
+        return getattr(obj, field_name)
+
+    @staticmethod
+    def set_field_value(obj: Any, field_name: str, value: Any) -> None:
+        """设置字段值
+
+        如果字段不存在则动态添加。
+
+        :param obj: 对象
+        :param field_name: 字段名
+        :param value: 字段值
+        """
+        setattr(obj, field_name, value)
+
+    @staticmethod
+    def invoke(obj: Any, method_name: str, *args: Any, **kwargs: Any) -> Any:
+        """调用方法
+
+        :param obj: 对象
+        :param method_name: 方法名
+        :param args: 位置参数
+        :param kwargs: 关键字参数
+        :return: 方法返回值
+        :raises AttributeError: 方法不存在
+        :raises TypeError: 方法不可调用
+        """
+        method = getattr(obj, method_name)
+        if not callable(method):
+            raise TypeError(f"属性 '{method_name}' 不可调用")
+        return method(*args, **kwargs)
+
+    @staticmethod
+    def get_fields(obj: Any) -> Dict[str, Any]:
+        """获取所有字段
+
+        返回对象的所有非方法属性及其值的字典。
+
+        :param obj: 对象
+        :return: 字段名到字段值的字典
+        """
+        result = {}
+        for name, value in inspect.getmembers(obj):
+            if not name.startswith("_") and not callable(value):
+                result[name] = value
+        return result
+
+    @staticmethod
+    def get_methods(obj: Any) -> List[str]:
+        """获取所有方法名
+
+        返回对象中不以单下划线开头的方法名称列表。
+
+        :param obj: 对象或类
+        :return: 方法名列表
+        """
+        return [name for name, value in inspect.getmembers(obj) if not name.startswith("_") and callable(value)]
+
+    @staticmethod
+    def has_field(obj: Any, field_name: str) -> bool:
+        """是否有指定字段
+
+        :param obj: 对象
+        :param field_name: 字段名
+        :return: 是否存在该字段
+        """
+        if not hasattr(obj, field_name):
+            return False
+        return not callable(getattr(obj, field_name))
+
+    @staticmethod
+    def has_method(obj: Any, method_name: str) -> bool:
+        """是否有指定方法
+
+        :param obj: 对象或类
+        :param method_name: 方法名
+        :return: 是否存在该方法
+        """
+        attr = getattr(obj, method_name, None)
+        return attr is not None and callable(attr)
+
+    @staticmethod
+    def get_annotations(obj: Any) -> Dict[str, Any]:
+        """获取类型注解
+
+        获取对象（类或函数）的类型注解信息。
+
+        :param obj: 类或函数
+        :return: 类型注解字典
+        """
+        if isinstance(obj, type):
+            return getattr(obj, "__annotations__", {})
+        return getattr(obj, "__annotations__", {})
+
+    @staticmethod
+    def new_instance(cls: Type, *args: Any, **kwargs: Any) -> Any:
+        """创建实例
+
+        :param cls: 类
+        :param args: 位置参数
+        :param kwargs: 关键字参数
+        :return: 创建的实例
+        """
+        return cls(*args, **kwargs)
+
+    @staticmethod
+    def get_super_class(cls: Type) -> Type:
+        """获取父类
+
+        :param cls: 类
+        :return: 父类，如果没有父类则返回object
+        """
+        bases = cls.__bases__
+        if bases:
+            return bases[0]
+        return object

hutool/core/util/runtime_util.py

@@ -0,0 +1,89 @@
+"""运行时工具类"""
+
+from __future__ import annotations
+
+import os
+import subprocess
+import sys
+from typing import List, Optional
+
+
+class RuntimeUtil:
+    """运行时工具类"""
+
+    @staticmethod
+    def exec(command: str, timeout: Optional[int] = None) -> str:
+        """执行系统命令，返回输出"""
+        result = subprocess.run(
+            command,
+            shell=True,
+            capture_output=True,
+            text=True,
+            timeout=timeout,
+        )
+        return result.stdout
+
+    @staticmethod
+    def exec_lines(command: str, timeout: Optional[int] = None) -> List[str]:
+        """执行系统命令，返回输出行列表"""
+        output = RuntimeUtil.exec(command, timeout=timeout)
+        lines = output.splitlines()
+        # 去除末尾空行
+        while lines and not lines[-1].strip():
+            lines.pop()
+        return lines
+
+    @staticmethod
+    def get_pid() -> int:
+        """获取当前进程PID"""
+        return os.getpid()
+
+    @staticmethod
+    def get_memory_info() -> dict:
+        """获取内存信息（单位字节）
+        返回 {'total': ..., 'available': ..., 'used': ...}
+        使用 /proc/meminfo (Linux) 或 psutil 回退
+        """
+        # 尝试使用 psutil（跨平台）
+        try:
+            import psutil  # type: ignore
+
+            mem = psutil.virtual_memory()
+            return {
+                "total": mem.total,
+                "available": mem.available,
+                "used": mem.used,
+            }
+        except ImportError:
+            pass
+
+        # Linux 回退：读取 /proc/meminfo
+        if sys.platform.startswith("linux"):
+            meminfo = {}
+            try:
+                with open("/proc/meminfo") as f:
+                    for line in f:
+                        parts = line.split(":")
+                        if len(parts) == 2:
+                            key = parts[0].strip()
+                            val = parts[1].strip().split()[0]
+                            meminfo[key] = int(val) * 1024  # kB -> bytes
+                total = meminfo.get("MemTotal", 0)
+                available = meminfo.get("MemAvailable", meminfo.get("MemFree", 0))
+                return {
+                    "total": total,
+                    "available": available,
+                    "used": total - available,
+                }
+            except OSError:
+                pass
+
+        return {"total": 0, "available": 0, "used": 0}
+
+    @staticmethod
+    def get_available_processors() -> int:
+        """获取可用CPU核心数"""
+        try:
+            return os.cpu_count() or 1
+        except Exception:
+            return 1