tretool 0.2.1__py3-none-any.whl

tretool/platformlib.py

@@ -0,0 +1,332 @@
+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]"
+    """
+    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]
+    
+    except Exception as e:
+        return f'Error: {str(e)}'
+
+
+def get_python_executable() -> str:
+    """
+    获取 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:
+        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 - 可选参数索引（支持负数索引）
+        
+    返回：
+        当index为None时：返回完整参数列表['script.py', 'arg1', ...]
+        当指定index时：返回对应位置的参数值
+        
+    异常：
+        IndexError - 当索引超出范围时引发
+    """
+    args = sys.argv
+    
+    if index is None:
+        return args.copy()  # 返回副本避免外部修改
+    
+    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解释器的完整标志信息
+    
+    返回：
+        包含三个子字典的字典：
+        - 'runtime_flags': 运行时标志（来自sys.flags）
+        - 'build_info': 构建配置信息
+        - 'unicode_info': Unicode相关配置
+    
+    标志说明：
+        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 = {}
+    
+    # 常见构建选项检测
+    for opt in ['WITH_PYMALLOC', 'WITH_THREAD', 'PYTHONFRAMEWORK']:
+        options[opt] = opt in build_str
+    
+    # 检测内存分配器
+    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()
+        }
+    }

tretool/plugin.py

@@ -0,0 +1,348 @@
+"""
+### PyPlugin - Python 高级插件库
+##### 概述\n
+PyPlugin 是一个功能强大的 Python 插件系统框架，提供了完整的插件开发、加载和执行解决方案。该系统特别适合构建可扩展的应用程序，支持：
+
+- 插件生命周期管理：自动处理插件的加载、验证和执行
+
+- 智能依赖检查：支持版本规范的依赖管理 (package>=1.2.0)
+
+- 元数据验证：自动检查插件元数据的完整性和合理性
+
+- 优先级系统：数值越小优先级越高(1-100范围)
+
+- 彩色终端输出：使用 Rich 库提供直观的状态反馈
+"""
+
+import importlib
+
+from abc import ABC, abstractmethod
+from typing import Type, List, Dict, Any, overload, Union
+
+from rich import print as rich_print
+from packaging.version import parse as parse_version
+
+
+
+class PluginBase(ABC):
+    """插件基类，支持高级扩展功能"""
+    
+    # 类属性定义元数据（子类可覆盖）
+    metadata = {
+        "name": "Unnamed Plugin",
+        "version": "1.0.0",
+        "author": "Anonymous",
+        "description": "No description provided"
+    }
+    
+    # 定义插件依赖包（子类可覆盖）
+    required_packages: List[str] = []
+    
+    # 默认执行优先级（数值越小优先级越高）
+    priority: int = 10
+
+    
+
+    def __init__(self):
+        """初始化时自动检查依赖"""
+        self._check_metadata()
+
+        self._check_dependencies()
+        
+    def _check_dependencies(self):
+        """验证依赖包是否已安装，并检查版本要求"""
+        missing = []
+        invalid = []
+        version_issues = []
+        
+        # 处理特殊的依赖格式 (如 "package>=1.0")
+        dependencies = []
+        for dep in self.required_packages:
+            if isinstance(dep, str) and any(op in dep for op in [">", "<", "=", "!"]):
+                # 处理版本要求
+                try:
+                    pkg_name = dep.split('>')[0].split('<')[0].split('=')[0].split('!')[0].strip()
+                    dependencies.append((pkg_name, dep))
+                except Exception:
+                    dependencies.append((dep, None))
+            else:
+                dependencies.append((dep, None))
+        
+        for pkg, version_spec in dependencies:
+            try:
+                # 尝试导入模块
+                module = importlib.import_module(pkg)
+                
+                # 检查版本要求
+                if version_spec:
+                    if hasattr(module, "__version__"):
+                        installed_version = module.__version__
+                        
+                        # 解析版本规范
+                        if ">=" in version_spec:
+                            min_version = version_spec.split(">=")[1].strip()
+                            if parse_version(installed_version) < parse_version(min_version):
+                                version_issues.append(f"{pkg} (需要版本 >= {min_version}, 当前版本 {installed_version})")
+                        
+                        elif "<=" in version_spec:
+                            max_version = version_spec.split("<=")[1].strip()
+                            if parse_version(installed_version) > parse_version(max_version):
+                                version_issues.append(f"{pkg} (需要版本 <= {max_version}, 当前版本 {installed_version})")
+                        
+                        elif "==" in version_spec:
+                            exact_version = version_spec.split("==")[1].strip()
+                            if parse_version(installed_version) != parse_version(exact_version):
+                                version_issues.append(f"{pkg} (需要版本 == {exact_version}, 当前版本 {installed_version})")
+                        
+                        elif "!=" in version_spec:
+                            exclude_version = version_spec.split("!=")[1].strip()
+                            if parse_version(installed_version) == parse_version(exclude_version):
+                                version_issues.append(f"{pkg} (需要版本 != {exclude_version}, 当前版本 {installed_version})")
+                        
+                        elif ">" in version_spec:
+                            min_version = version_spec.split(">")[1].strip()
+                            if parse_version(installed_version) <= parse_version(min_version):
+                                version_issues.append(f"{pkg} (需要版本 > {min_version}, 当前版本 {installed_version})")
+                        
+                        elif "<" in version_spec:
+                            max_version = version_spec.split("<")[1].strip()
+                            if parse_version(installed_version) >= parse_version(max_version):
+                                version_issues.append(f"{pkg} (需要版本 < {max_version}, 当前版本 {installed_version})")
+            except ModuleNotFoundError:
+                invalid.append(f"{pkg} (Module not found)")
+            except ImportError:
+                missing.append(pkg)
+            except Exception as e:
+                invalid.append(f"{pkg} ({str(e)})")
+    
+        # 构建错误消息
+        error_msgs = []
+        if missing:
+            error_msgs.append(
+                f"缺少必要依赖包: {', '.join(missing)}\n"
+                f"请使用命令安装: pip install {' '.join(missing)}"
+            )
+        
+        if invalid:
+            error_msgs.append(
+                f"无效的依赖包: {', '.join(invalid)}\n"
+                f"请检查包名是否正确或尝试重新安装"
+            )
+        
+        if version_issues:
+            error_msgs.append(
+                f"版本不兼容的依赖包: {', '.join(version_issues)}\n"
+                f"请使用命令升级: pip install --upgrade {' '.join([v.split(' ')[0] for v in version_issues])}"
+            )
+        
+        if error_msgs:
+            raise ImportError("\n\n".join(error_msgs))
+
+    def _check_metadata(self):
+        """检查元数据是否被正确覆盖"""
+        default_meta = PluginBase.metadata
+        current_meta = self.metadata
+        
+        # 检查所有默认元数据字段是否存在
+        missing_fields = [field for field in default_meta if field not in current_meta]
+        
+        # 检查是否有字段使用默认值
+        default_values = [field for field in default_meta if current_meta.get(field) == default_meta[field]]
+        
+        if missing_fields:
+            rich_print(f"[yellow]⚠️ 元数据字段缺失: {', '.join(missing_fields)}[/yellow]")
+        
+        if default_values:
+            rich_print(f"[yellow]⚠️ 使用默认元数据值: {', '.join(default_values)}[/yellow]")
+        
+        # 检查关键字段是否有效
+        if current_meta.get("name") == "Unnamed Plugin":
+            rich_print("[yellow]⚠️ 插件名称未定义，使用默认名称[/yellow]")
+        
+        if current_meta.get("version") == "1.0.0":
+            rich_print("[yellow]⚠️ 插件版本未定义，使用默认版本[/yellow]")
+
+    def get_plugin_name(self):
+        return self.metadata['name']
+
+    @abstractmethod
+    def execute(self, data: Any) -> Any:
+        """插件核心处理方法"""
+        pass
+
+    @classmethod
+    def get_metadata(cls) -> Dict[str, str]:
+        """获取插件元数据"""
+        return cls.metadata.copy()
+
+
+
+# 全局插件注册表（保持按优先级排序）
+_PLUGIN_REGISTRY: List[PluginBase] = []
+
+
+
+def load_plugin(
+    plugin_class: Type[PluginBase],
+    priority: int = None,
+    verbose: bool = False
+) -> bool:
+    """
+    加载并验证插件类
+    
+    参数:
+        plugin_class: 必须继承自PluginBase的类
+        priority: 执行优先级（覆盖类默认值）
+        verbose: 是否显示加载详情
+        
+    返回:
+        bool: 是否成功加载
+    """
+    try:
+        # 类型验证
+        if not issubclass(plugin_class, PluginBase):
+            raise TypeError("必须继承自PluginBase")
+            
+        # 实例化插件（自动触发依赖检查）
+        instance = plugin_class()
+        
+        # 设置优先级
+        if priority is not None:
+            instance.priority = priority
+        else:
+            instance.priority = plugin_class.priority
+            
+        # 插入排序保持注册表有序
+        insert_pos = 0
+        while (insert_pos < len(_PLUGIN_REGISTRY) and 
+               _PLUGIN_REGISTRY[insert_pos].priority <= instance.priority):
+            insert_pos += 1
+            
+        _PLUGIN_REGISTRY.insert(insert_pos, instance)
+        
+        if verbose:
+            meta = plugin_class.get_metadata()
+            print(
+                f"✅ 成功加载插件: {meta['name']} v{meta['version']}\n"
+                f"   作者: {meta['author']}\n"
+                f"   优先级: {instance.priority}\n"
+                f"   依赖: {plugin_class.required_packages}"
+            )
+            
+        return True
+        
+    except Exception as e:
+        if verbose:
+            print(f"❌ 加载失败: {str(e)}")
+        return False
+
+
+
+@overload
+def execute_pipeline(data: List[Any] = None):
+    """按优先级顺序执行所有插件"""
+    ...
+
+
+@overload
+def execute_pipeline(data: Dict[str, Any] = None):
+    """按优先级顺序执行所有插件"""
+    ...
+
+
+def execute_pipeline(data: Any = None) -> dict:
+    """按优先级顺序执行所有插件"""
+    if isinstance(data, list):
+        res_dict = {}
+        for index, plugin in enumerate(_PLUGIN_REGISTRY):
+            result = plugin.execute(data[index])
+            res_dict[plugin.get_plugin_name()] = result
+        return res_dict
+    else:
+        res_dict = {}
+        for index, plugin in enumerate(_PLUGIN_REGISTRY):
+            result = plugin.execute(data[plugin.get_plugin_name()])
+            res_dict[plugin.get_plugin_name()] = result
+        return res_dict
+
+
+def execute_plugin_by_file(
+    filepath: str, 
+    data: Any = None,
+    plugin_class_name: str = None,
+    execute_all: bool = False
+) -> Union[Any, Dict[str, Any]]:
+    """
+    从Python文件加载并执行插件
+    
+    参数:
+        filepath: Python文件路径
+        data: 传递给插件的数据
+        plugin_class_name: 指定要执行的插件类名(可选)
+        execute_all: 是否执行文件中所有插件(默认False)
+        
+    返回:
+        单个插件结果 或 字典格式的{插件类名: 执行结果}
+        
+    异常:
+        ValueError: 当文件包含多个插件但未指定执行方式时
+        ImportError: 如果文件加载失败
+    """
+    import os
+    import importlib.util
+    from collections import OrderedDict
+
+    # 验证文件存在
+    if not os.path.exists(filepath):
+        raise FileNotFoundError(f"插件文件不存在: {filepath}")
+    
+    # 动态加载模块
+    module_name = os.path.splitext(os.path.basename(filepath))[0]
+    spec = importlib.util.spec_from_file_location(module_name, filepath)
+    if spec is None:
+        raise ImportError(f"无效的Python模块: {filepath}")
+    
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    
+    # 查找所有合法插件类
+    plugin_classes = OrderedDict()
+    for name, obj in module.__dict__.items():
+        if (isinstance(obj, type) and 
+            issubclass(obj, PluginBase) and 
+            obj != PluginBase):
+            plugin_classes[name] = obj
+    
+    # 处理插件类发现情况
+    if not plugin_classes:
+        raise AttributeError(f"文件中未找到有效的插件类(需继承PluginBase): {filepath}")
+    
+    # 多插件处理逻辑
+    if len(plugin_classes) > 1:
+        if not (plugin_class_name or execute_all):
+            raise ValueError(
+                f"文件中发现多个插件类: {list(plugin_classes.keys())}\n"
+                "请指定 plugin_class_name 或设置 execute_all=True"
+            )
+    
+    # 执行单个指定插件
+    if plugin_class_name:
+        if plugin_class_name not in plugin_classes:
+            raise KeyError(f"插件类 '{plugin_class_name}' 不存在，可选: {list(plugin_classes.keys())}")
+        
+        plugin_class = plugin_classes[plugin_class_name]
+        if load_plugin(plugin_class, verbose=True):
+            return plugin_class().execute(data)
+        raise RuntimeError(f"插件加载失败: {plugin_class_name}")
+    
+    # 执行所有插件
+    results = {}
+    for name, plugin_class in plugin_classes.items():
+        try:
+            if load_plugin(plugin_class, verbose=True):
+                results[name] = plugin_class().execute(data)
+        except Exception as e:
+            rich_print(f"[red]❌ 插件 {name} 执行失败: {str(e)}[/red]")
+            results[name] = {"error": str(e)}
+    
+    return results