tretool 0.2.1__py3-none-any.whl → 1.0.0__py3-none-any.whl

tretool/platformlib.py

@@ -2,331 +2,486 @@ import os
 import sys
 import ctypes
 import platform
-from typing import (Any, Dict, List, Union, SupportsIndex)
-
-
-def get_python_dll() -> ctypes.PyDLL:
-    """内部函数：获取 Python DLL 句柄"""
-    is_64bit = ctypes.sizeof(ctypes.c_void_p) == 8
-    dll_suffix = '_d' if hasattr(sys, 'gettotalrefcount') else ''
-    dll_name = f"python{''.join(map(str, sys.version_info[:2]))}{dll_suffix}.dll"
-    return ctypes.PyDLL(dll_name)
-
-
-def get_python_version() -> str:
-    """
-    获取 Python 版本号
-    返回格式：'major.minor.micro'
-    """
-    try:
-        dll = get_python_dll()
-        Py_GetVersion = dll.Py_GetVersion
-        Py_GetVersion.restype = ctypes.c_char_p
-        return Py_GetVersion().decode('ascii').split()[0]
-    except Exception as e:
-        return f'Error: {str(e)}'
-
-
-def get_python_build() -> str:
-    """
-    获取 Python 构建信息
-    返回格式：如 "v3.9.7:8d82e9e9b3, Aug 31 2021, 13:28:12"
-    """
-    try:
-        dll = get_python_dll()
-        Py_GetVersion = dll.Py_GetVersion
-        Py_GetVersion.restype = ctypes.c_char_p
-        version_info = Py_GetVersion().decode('ascii')
-        return f"v{version_info.split('(', 1)[1].split(')')[0]}"
-    except Exception as e:
-        return f'Error: {str(e)}'
-
-
-def get_python_compiler() -> str:
-    """
-    获取 Python 编译器信息
-    返回格式：如 "[GCC 8.4.0]"
+import time
+import warnings
+import threading
+import subprocess
+import re
+import json
+from typing import (Any, Dict, List, Union, SupportsIndex, Optional, Tuple)
+from enum import Enum, auto
+from dataclasses import dataclass
+from pathlib import Path
+from collections import defaultdict
+
+class PlatformType(Enum):
+    """平台类型枚举"""
+    WINDOWS = auto()
+    LINUX = auto()
+    MACOS = auto()
+    UNIX = auto()  # 其他UNIX系统
+    JAVA = auto()  # Jython环境
+    UNKNOWN = auto()
+
+class PythonImplementation(Enum):
+    """Python实现枚举"""
+    CPYTHON = auto()
+    PYPY = auto()
+    IRONPYTHON = auto()
+    JYTHON = auto()
+    UNKNOWN = auto()
+
+class ByteOrder(Enum):
+    """字节序枚举"""
+    LITTLE_ENDIAN = auto()
+    BIG_ENDIAN = auto()
+    UNKNOWN = auto()
+
+@dataclass(frozen=True)
+class SystemInfo:
+    """系统信息数据类"""
+    system: str
+    release: str
+    version: str
+    machine: str
+    processor: str
+    platform_type: PlatformType
+    byte_order: ByteOrder
+
+@dataclass(frozen=True)
+class PythonBuildInfo:
+    """Python构建信息数据类"""
+    version: str
+    version_tuple: Tuple[int, int, int]
+    build_number: str
+    build_date: str
+    compiler: str
+    build_options: Dict[str, bool]
+    is_debug: bool
+    is_wide_unicode: bool
+    git_info: Optional[Tuple[str, str]] = None  # (commit_hash, branch)
+
+@dataclass(frozen=True)
+class PythonRuntimeInfo:
+    """Python运行时信息数据类"""
+    executable: str
+    path: str
+    flags: Dict[str, Any]
+    byte_order: ByteOrder
+    max_unicode: int
+    implementation: PythonImplementation
+    dll_path: Optional[str] = None
+    prefix: Optional[str] = None
+    base_prefix: Optional[str] = None
+
+@dataclass(frozen=True)
+class EnvironmentInfo:
+    """环境信息数据类"""
+    system: SystemInfo
+    python_build: PythonBuildInfo
+    python_runtime: PythonRuntimeInfo
+    environment_vars: Dict[str, str]
+    python_paths: Dict[str, List[str]]
+    installed_packages: Dict[str, str]
+
+class EnvironmentInspector:
     """
-    try:
-        dll = get_python_dll()
-        Py_GetVersion = dll.Py_GetVersion
-        Py_GetVersion.restype = ctypes.c_char_p
-        version_info = Py_GetVersion().decode('ascii')
-        return version_info.split('[')[1].split(']')[0]
-    except Exception as e:
-        return f'Error: {str(e)}'
-
-
-def get_python_path() -> str:
-    """
-    获取 Python 安装根目录（如 C:\\Python39）
-    """
-    try:
-        return sys.executable.rsplit('\\', 1)[0]
+    终极Python环境检测工具
     
-    except Exception as e:
-        return f'Error: {str(e)}'
-
-
-def get_python_executable() -> str:
-    """
-    获取 Python 解释器路径
+    特性:
+    - 全面的系统信息检测
+    - 详细的Python构建和运行时信息
+    - 线程安全设计
+    - 类型安全接口
+    - 跨平台支持
+    - 智能缓存机制
+    - 依赖包检测
     """
-    try:
-        return sys.executable
-    except Exception as e:
-        return f'Error: {str(e)}'
-
-
-def get_python_flags() -> Dict[str, bool]:
-    """
-    获取 Python 编译标志
-    返回字典包含：
-    - debug: 是否是调试版本
-    - utf8_mode: 是否启用UTF-8模式
-    """
-    try:
-        flags = {
-            'debug': hasattr(sys, 'gettotalrefcount'),
-            'utf8_mode': sys.flags.utf8_mode
-        }
-        return flags
-    except Exception as e:
-        return {'error': str(e)}
-
-
-def get_python_implementation() -> str:
-    """
-    获取更友好的实现名称
-    """
-    impl = sys.implementation.name
-    return {
-        'cpython': 'CPython',
-        'pypy': 'PyPy',
-        'ironpython': 'IronPython',
-        'jython': 'Jython'
-    }.get(impl, impl.capitalize())
-
-
-def get_full_python_info() -> Dict[str, str]:
-    """
-    获取完整的 Python 信息
-    返回包含所有信息的字典
-    """
-    return {
-        'version': get_python_version(),
-        'build': get_python_build(),
-        'compiler': get_python_compiler(),
-        'path': get_python_path(),
-        'executable': get_python_executable(),
-        'flags': get_python_flags(),
-        'implementation': get_python_implementation()
-    }
-
-
-def uname():
-    return platform.uname()
-
-
-def get_system() -> str:
-    """
-    获取操作系统类型（增强版）
-    返回：
-        'Windows'/'Linux'/'Darwin'/'Java' 等友好名称
-    """
-    system = platform.uname().system
-    return {
-        'Linux': 'Linux',
-        'Darwin': 'macOS',
-        'Windows': 'Windows',
-        'Java': 'Java'
-    }.get(system, system)
-
-
-def release() -> str:
-    """
-    获取操作系统版本号（跨平台）
-    返回：
-        Linux: 内核版本 (如 '5.4.0-80-generic')
-        Windows: 版本号 (如 '10')
-        macOS: Darwin 版本 (如 '21.1.0')
-    """
-    try:
-        if hasattr(os, 'uname'):
-            return os.uname().release
-        return platform.release()
-    except Exception:
-        return "unknown"
-
-
-def machine() -> str:
-    """
-    获取系统架构（跨平台）
-    返回：
-        'x86_64'/'AMD64'/'arm64' 等标准架构名称
-    """
-    try:
-        if hasattr(os, 'uname'):
-            return os.uname().machine
-        return platform.machine()
-    except Exception:
+    
+    def __init__(self):
+        self._cache = {}
+        self._lock = threading.RLock()
+        self._package_cache = None
+        self._package_cache_time = 0
+        
+    def get_system_info(self, refresh: bool = False) -> SystemInfo:
+        """
+        获取系统信息
+        
+        参数:
+            refresh: 是否强制刷新缓存
+            
+        返回:
+            SystemInfo对象
+        """
+        with self._lock:
+            if not refresh and 'system_info' in self._cache:
+                return self._cache['system_info']
+            
+            uname = platform.uname()
+            system = uname.system
+            platform_type = self._determine_platform_type(system)
+            
+            info = SystemInfo(
+                system=system,
+                release=uname.release,
+                version=uname.version,
+                machine=uname.machine,
+                processor=uname.processor,
+                platform_type=platform_type,
+                byte_order=self._get_byteorder_enum()
+            )
+            
+            self._cache['system_info'] = info
+            return info
+    
+    def get_python_build_info(self, refresh: bool = False) -> PythonBuildInfo:
+        """
+        获取Python构建信息
+        
+        参数:
+            refresh: 是否强制刷新缓存
+            
+        返回:
+            PythonBuildInfo对象
+        """
+        with self._lock:
+            if not refresh and 'build_info' in self._cache:
+                return self._cache['build_info']
+            
+            version_tuple = (sys.version_info.major, sys.version_info.minor, sys.version_info.micro)
+            version = f"{version_tuple[0]}.{version_tuple[1]}.{version_tuple[2]}"
+            build_str = sys.version
+            build_parts = re.search(r'\((.+?)\)', build_str)
+            build_info = build_parts.group(1) if build_parts else "unknown"
+            
+            # 解析构建日期和编译器
+            build_date, compiler = self._parse_build_info(build_info)
+            
+            info = PythonBuildInfo(
+                version=version,
+                version_tuple=version_tuple,
+                build_number=self._get_build_number(),
+                build_date=build_date,
+                compiler=compiler,
+                build_options=self._parse_build_options(),
+                is_debug=self._is_debug_build(),
+                is_wide_unicode=sys.maxunicode > 0xFFFF,
+                git_info=self._get_git_info()
+            )
+            
+            self._cache['build_info'] = info
+            return info
+    
+    def get_python_runtime_info(self, refresh: bool = False) -> PythonRuntimeInfo:
+        """
+        获取Python运行时信息
+        
+        参数:
+            refresh: 是否强制刷新缓存
+            
+        返回:
+            PythonRuntimeInfo对象
+        """
+        with self._lock:
+            if not refresh and 'runtime_info' in self._cache:
+                return self._cache['runtime_info']
+            
+            impl = self._get_implementation()
+            dll_path = self._get_python_dll_path() if impl == PythonImplementation.CPYTHON else None
+            
+            info = PythonRuntimeInfo(
+                executable=sys.executable,
+                path=os.path.dirname(sys.executable),
+                flags=self._get_runtime_flags(),
+                byte_order=self._get_byteorder_enum(),
+                max_unicode=sys.maxunicode,
+                implementation=impl,
+                dll_path=dll_path,
+                prefix=sys.prefix,
+                base_prefix=getattr(sys, 'base_prefix', sys.prefix)
+            )
+            
+            self._cache['runtime_info'] = info
+            return info
+    
+    def get_installed_packages(self, refresh: bool = False) -> Dict[str, str]:
+        """
+        获取已安装的Python包列表
+        
+        参数:
+            refresh: 是否强制刷新缓存
+            
+        返回:
+            包名到版本的字典
+        """
+        with self._lock:
+            current_time = time.time()
+            if not refresh and self._package_cache and current_time - self._package_cache_time < 300:  # 5分钟缓存
+                return self._package_cache.copy()
+            
+            try:
+                # 使用pip list命令获取包列表
+                result = subprocess.run(
+                    [sys.executable, '-m', 'pip', 'list', '--format=json'],
+                    capture_output=True,
+                    text=True,
+                    check=True
+                )
+                packages = json.loads(result.stdout)
+                package_dict = {pkg['name']: pkg['version'] for pkg in packages}
+                
+                self._package_cache = package_dict
+                self._package_cache_time = current_time
+                return package_dict
+            except Exception as e:
+                warnings.warn(f"获取安装包列表失败: {str(e)}")
+                return {}
+    
+    def get_environment_info(self) -> EnvironmentInfo:
+        """
+        获取完整环境信息
+        
+        返回:
+            EnvironmentInfo对象
+        """
+        with self._lock:
+            return EnvironmentInfo(
+                system=self.get_system_info(),
+                python_build=self.get_python_build_info(),
+                python_runtime=self.get_python_runtime_info(),
+                environment_vars=self._get_environment_vars(),
+                python_paths=self._get_python_paths(),
+                installed_packages=self.get_installed_packages()
+            )
+    
+    def _get_byteorder_enum(self) -> ByteOrder:
+        """获取字节顺序枚举"""
+        byteorder = sys.byteorder
+        if byteorder == 'little':
+            return ByteOrder.LITTLE_ENDIAN
+        elif byteorder == 'big':
+            return ByteOrder.BIG_ENDIAN
+        else:
+            return ByteOrder.UNKNOWN
+    
+    def _determine_platform_type(self, system: str) -> PlatformType:
+        """确定平台类型"""
+        system_lower = system.lower()
+        if 'linux' in system_lower:
+            return PlatformType.LINUX
+        elif 'windows' in system_lower:
+            return PlatformType.WINDOWS
+        elif 'darwin' in system_lower or 'macos' in system_lower:
+            return PlatformType.MACOS
+        elif 'java' in system_lower:
+            return PlatformType.JAVA
+        elif any(unix in system_lower for unix in ['bsd', 'solaris', 'aix']):
+            return PlatformType.UNIX
+        else:
+            return PlatformType.UNKNOWN
+    
+    def _get_build_number(self) -> str:
+        """获取构建号"""
+        if hasattr(sys, 'version_info') and hasattr(sys.version_info, 'build'):
+            return str(sys.version_info.build[0])
         return "unknown"
-
-
-def get_byteorder() -> str:
-    """
-    智能检测字节顺序（优先使用标准库）
-    """
-    try:
-        import sys
-        return sys.byteorder
-    except ImportError:
-        try:
-            import ctypes
-            num = 0x12345678
-            buf = (ctypes.c_byte * 4).from_buffer_copy(ctypes.c_uint32(num))
-            return 'big' if buf[0] == 0x12 else 'little'
-        except:
-            return 'unknown'
-
-
-def get_args(index: SupportsIndex = None) -> Union[List[str], str]:
-    """
-    获取命令行参数（支持索引访问）
     
-    参数：
-        index - 可选参数索引（支持负数索引）
+    def _parse_build_info(self, build_str: str) -> Tuple[str, str]:
+        """解析构建信息字符串"""
+        # 尝试解析日期和编译器
+        date_match = re.search(r'(\w{3} \d{1,2} \d{4},? \d{2}:\d{2}:\d{2})', build_str)
+        date = date_match.group(0) if date_match else "unknown"
         
-    返回：
-        当index为None时：返回完整参数列表['script.py', 'arg1', ...]
-        当指定index时：返回对应位置的参数值
+        compiler_match = re.search(r'\[(.*?)\]', build_str)
+        compiler = compiler_match.group(1) if compiler_match else "unknown"
         
-    异常：
-        IndexError - 当索引超出范围时引发
-    """
-    args = sys.argv
+        return date, compiler
     
-    if index is None:
-        return args.copy()  # 返回副本避免外部修改
+    def _parse_build_options(self) -> Dict[str, bool]:
+        """解析构建选项"""
+        build_str = sys.version
+        options = {}
+        
+        # 常见构建选项检测
+        common_options = [
+            'WITH_PYMALLOC', 'WITH_THREAD', 'PYTHONFRAMEWORK',
+            'WITH_DOC_STRINGS', 'WITH_VALGRIND', 'WITH_PYDEBUG'
+        ]
+        
+        for opt in common_options:
+            options[opt] = opt in build_str
+        
+        # 特殊选项检测
+        options['PYMALLOC'] = 'pymalloc' in build_str.lower()
+        options['DEBUG'] = 'debug' in build_str.lower()
+        
+        return options
     
-    try:
-        return args[index]  # 自动支持SupportsIndex类型
-    except IndexError:
-        raise IndexError(f"参数索引 {index} 超出范围 (参数总数: {len(args)})") from None
-
-
-def get_all_flags() -> Dict[str, Dict[str, Any]]:
-    """
-    获取Python解释器的完整标志信息
+    def _get_git_info(self) -> Optional[Tuple[str, str]]:
+        """获取Git版本信息"""
+        try:
+            # 检查是否有git信息
+            if not hasattr(sys, '_git'):
+                return None
+                
+            git_info = sys._git
+            return (git_info[0], git_info[1]) if git_info else None
+        except Exception:
+            return None
     
-    返回：
-        包含三个子字典的字典：
-        - 'runtime_flags': 运行时标志（来自sys.flags）
-        - 'build_info': 构建配置信息
-        - 'unicode_info': Unicode相关配置
+    def _is_debug_build(self) -> bool:
+        """检查是否是调试版本"""
+        return hasattr(sys, 'gettotalrefcount')
     
-    标志说明：
-        runtime_flags:
-            debug: 调试模式
-            inspect: 交互模式后进入检查模式
-            interactive: 交互模式
-            optimize: 优化级别 (0/1/2)
-            dont_write_bytecode: 不生成.pyc文件
-            no_user_site: 忽略用户site-packages
-            no_site: 忽略所有site-packages
-            ignore_environment: 忽略环境变量
-            verbose: 详细输出
-            bytes_warning: 字节警告
-            quiet: 安静模式
-            hash_randomization: 哈希随机化
-            isolated: 隔离模式
-            dev_mode: 开发模式
-            utf8_mode: UTF-8模式
-            warn_default_encoding: 默认编码警告
-            safe_path: 安全路径模式
-            int_max_str_digits: 整数字符串转换最大位数
-    """
-    return {
-        'runtime_flags': get_runtime_flags(),
-        'build_info': get_build_info(),
-        'unicode_info': get_unicode_info()
-    }
-
-
-def get_runtime_flags() -> Dict[str, Any]:
-    """获取sys.flags中的所有运行时标志"""
-    flags = sys.flags
-    return {
-        'debug': flags.debug,
-        'inspect': flags.inspect,
-        'interactive': flags.interactive,
-        'optimize': flags.optimize,
-        'dont_write_bytecode': flags.dont_write_bytecode,
-        'no_user_site': flags.no_user_site,
-        'no_site': flags.no_site,
-        'ignore_environment': flags.ignore_environment,
-        'verbose': flags.verbose,
-        'bytes_warning': flags.bytes_warning,
-        'quiet': flags.quiet,
-        'hash_randomization': flags.hash_randomization,
-        'isolated': flags.isolated,
-        'dev_mode': flags.dev_mode,
-        'utf8_mode': flags.utf8_mode,
-        'warn_default_encoding': getattr(flags, 'warn_default_encoding', 0),
-        'safe_path': getattr(flags, 'safe_path', False),
-        'int_max_str_digits': getattr(flags, 'int_max_str_digits', 0)
-    }
-
-
-def get_build_info() -> Dict[str, Any]:
-    """获取构建配置信息"""
-    return {
-        'debug_build': hasattr(sys, 'gettotalrefcount'),
-        'compiler': get_python_compiler(),
-        'build_options': parse_build_options(),
-        'platform': get_system(),
-        'implementation': get_python_implementation()
-    }
-
-
-def parse_build_options() -> Dict[str, bool]:
-    """从构建字符串解析编译选项"""
-    build_str = sys.version
-    options = {}
+    def _get_implementation(self) -> PythonImplementation:
+        """获取Python实现类型"""
+        impl = sys.implementation.name.lower()
+        if impl == 'cpython':
+            return PythonImplementation.CPYTHON
+        elif impl == 'pypy':
+            return PythonImplementation.PYPY
+        elif impl == 'ironpython':
+            return PythonImplementation.IRONPYTHON
+        elif impl == 'jython':
+            return PythonImplementation.JYTHON
+        else:
+            return PythonImplementation.UNKNOWN
     
-    # 常见构建选项检测
-    for opt in ['WITH_PYMALLOC', 'WITH_THREAD', 'PYTHONFRAMEWORK']:
-        options[opt] = opt in build_str
+    def _get_runtime_flags(self) -> Dict[str, Any]:
+        """获取运行时标志"""
+        flags = sys.flags
+        return {
+            'debug': flags.debug,
+            'inspect': flags.inspect,
+            'interactive': flags.interactive,
+            'optimize': flags.optimize,
+            'dont_write_bytecode': flags.dont_write_bytecode,
+            'no_user_site': flags.no_user_site,
+            'no_site': flags.no_site,
+            'ignore_environment': flags.ignore_environment,
+            'verbose': flags.verbose,
+            'bytes_warning': flags.bytes_warning,
+            'quiet': flags.quiet,
+            'hash_randomization': flags.hash_randomization,
+            'isolated': flags.isolated,
+            'dev_mode': flags.dev_mode,
+            'utf8_mode': flags.utf8_mode,
+            'warn_default_encoding': getattr(flags, 'warn_default_encoding', 0),
+            'safe_path': getattr(flags, 'safe_path', False),
+            'int_max_str_digits': getattr(flags, 'int_max_str_digits', 0)
+        }
     
-    # 检测内存分配器
-    options['PYMALLOC'] = 'pymalloc' in build_str.lower()
-    return options
-
-
-def get_unicode_info() -> Dict[str, Any]:
-    """获取Unicode配置信息"""
-    return {
-        'maxunicode': sys.maxunicode,
-        'wide_build': sys.maxunicode > 0xFFFF,
-        'default_encoding': sys.getdefaultencoding(),
-        'filesystem_encoding': sys.getfilesystemencoding()
-    }
-
-
-def get_environment_report() -> Dict[str, Dict[str, str]]:
-    """生成完整的环境报告"""
-    return {
-        'python': {
-            'version': get_python_version(),
-            'build': get_python_build(),
-            'implementation': get_python_implementation(),
-            'compiler': get_python_compiler(),
-            'path': get_python_path(),
-            'executable': get_python_executable()
-        },
-        'runtime': {
-            'byteorder': get_byteorder(),
-            'flags': get_all_flags(),
-            'argv': get_args()
+    def _get_python_dll_path(self) -> Optional[str]:
+        """获取Python DLL路径"""
+        if platform.system() != 'Windows':
+            return None
+            
+        try:
+            # Windows上获取Python DLL路径
+            is_64bit = ctypes.sizeof(ctypes.c_void_p) == 8
+            is_debug = hasattr(sys, 'gettotalrefcount')
+            
+            versions = [
+                f"{sys.version_info.major}{sys.version_info.minor}",
+                f"{sys.version_info.major}.{sys.version_info.minor}"
+            ]
+            
+            suffixes = ['', '_d'] if is_debug else ['']
+            
+            for version in versions:
+                for suffix in suffixes:
+                    dll_name = f"python{version}{suffix}.dll"
+                    try:
+                        dll = ctypes.PyDLL(dll_name)
+                        return os.path.abspath(dll._name)
+                    except OSError:
+                        continue
+            
+            return None
+        except Exception:
+            return None
+    
+    def _get_environment_vars(self) -> Dict[str, str]:
+        """获取相关环境变量"""
+        relevant_vars = [
+            'PATH', 'PYTHONPATH', 'PYTHONHOME', 
+            'VIRTUAL_ENV', 'CONDA_PREFIX',
+            'LANG', 'LC_ALL', 'LC_CTYPE',
+            'PYTHONSTARTUP', 'PYTHONDEBUG',
+            'PYTHONINSPECT', 'PYTHONUNBUFFERED'
+        ]
+        return {var: os.getenv(var, '') for var in relevant_vars}
+    
+    def _get_python_paths(self) -> Dict[str, List[str]]:
+        """获取Python路径信息"""
+        return {
+            'sys.path': sys.path,
+            'module_search_paths': list(sys.path_importer_cache.keys()),
+            'stdlib_paths': self._get_stdlib_paths()
         }
-    }
+    
+    def _get_stdlib_paths(self) -> List[str]:
+        """获取标准库路径"""
+        stdlib_paths = []
+        for path in sys.path:
+            if 'site-packages' not in path and 'dist-packages' not in path:
+                stdlib_paths.append(path)
+        return stdlib_paths
+
+# 全局实例
+_inspector = EnvironmentInspector()
+
+# 便捷函数
+def get_system_info() -> SystemInfo:
+    """获取系统信息"""
+    return _inspector.get_system_info()
+
+def get_python_build_info() -> PythonBuildInfo:
+    """获取Python构建信息"""
+    return _inspector.get_python_build_info()
+
+def get_python_runtime_info() -> PythonRuntimeInfo:
+    """获取Python运行时信息"""
+    return _inspector.get_python_runtime_info()
+
+def get_installed_packages(refresh: bool = False) -> Dict[str, str]:
+    """获取已安装的Python包列表"""
+    return _inspector.get_installed_packages(refresh)
+
+def get_environment_info() -> EnvironmentInfo:
+    """获取完整环境信息"""
+    return _inspector.get_environment_info()
+
+def generate_environment_report(format: str = 'dict') -> Union[Dict[str, Any], str]:
+    """
+    生成环境报告
+    
+    参数:
+        format: 输出格式 ('dict', 'json', 'yaml')
+        
+    返回:
+        指定格式的报告
+    """
+    info = get_environment_info()
+    
+    def serialize(obj):
+        if isinstance(obj, (SystemInfo, PythonBuildInfo, PythonRuntimeInfo, EnvironmentInfo)):
+            return {k: serialize(v) for k, v in obj.__dict__.items() if not k.startswith('_')}
+        elif isinstance(obj, Enum):
+            return obj.name
+        elif isinstance(obj, tuple):
+            return list(obj)
+        return obj
+    
+    report_dict = serialize(info)
+    
+    if format == 'dict':
+        return report_dict
+    elif format == 'json':
+        return json.dumps(report_dict, indent=2)
+    elif format == 'yaml':
+        import yaml
+        return yaml.safe_dump(report_dict)
+    else:
+        raise ValueError(f"不支持的格式: {format}")