reproto 0.1.2__py3-none-any.whl → 0.1.4__py3-none-any.whl

utils/type_index.py

@@ -10,7 +10,14 @@ Author: AI Assistant
 from pathlib import Path
 from typing import Dict, List, Optional, Set
 import threading
-from utils.logger import get_logger
+
+# 智能导入：同时支持相对导入（包环境）和绝对导入（开发环境）
+try:
+    # 相对导入（包环境）
+    from .logger import get_logger
+except ImportError:
+    # 绝对导入（开发环境）
+    from utils.logger import get_logger
 
 
 class TypeMatchingIndex:

utils/version_checker.py

@@ -0,0 +1,311 @@
+"""
+通用版本检测模块
+
+支持检测Python包的新版本并提供用户友好的提示信息
+设计为通用模块，可以被其他Python库复用
+
+支持的版本源：
+- PyPI (Python Package Index)
+
+Author: AI Assistant
+"""
+
+import json
+import time
+import threading
+from typing import Optional, Callable
+from pathlib import Path
+from urllib.request import urlopen, Request
+from urllib.error import URLError, HTTPError
+from packaging import version
+import tempfile
+import importlib.metadata
+
+# 智能导入：同时支持相对导入（包环境）和绝对导入（开发环境）
+try:
+    # 相对导入（包环境）
+    from .logger import get_logger
+except ImportError:
+    # 绝对导入（开发环境）
+    from utils.logger import get_logger
+
+
+def get_package_version(package_name: str) -> Optional[str]:
+    """
+    动态获取已安装包的版本号
+    
+    Args:
+        package_name: 包名
+        
+    Returns:
+        包版本号，如果获取失败则返回None
+    """
+    try:
+        return importlib.metadata.version(package_name)
+    except importlib.metadata.PackageNotFoundError:
+        return None
+
+
+class VersionChecker:
+    """
+    通用版本检测器
+    
+    功能：
+    - 支持PyPI版本源
+    - 异步检测，不阻塞主程序
+    - 智能缓存，避免频繁请求
+    - 可配置的检测间隔和提示样式
+    - 动态获取当前版本
+    """
+    
+    def __init__(self, 
+                 package_name: str,
+                 current_version: Optional[str] = None,
+                 cache_duration: int = 3600,  # 缓存1小时
+                 timeout: int = 5,            # 请求超时5秒
+                 silent_mode: bool = False):  # 静默模式
+        """
+        初始化版本检测器
+        
+        Args:
+            package_name: 包名
+            current_version: 当前版本，如果为None则自动获取
+            cache_duration: 缓存持续时间（秒）
+            timeout: 网络请求超时时间（秒）
+            silent_mode: 是否启用静默模式（不打印日志）
+        """
+        self.package_name = package_name
+        self.current_version = current_version or get_package_version(package_name) or "0.0.0"
+        self.cache_duration = cache_duration
+        self.timeout = timeout
+        self.silent_mode = silent_mode
+        
+        # 缓存配置
+        self.cache_dir = Path(tempfile.gettempdir()) / f".{package_name}_version_cache"
+        self.cache_file = self.cache_dir / "latest_version.json"
+        
+        # 日志配置
+        self.logger = get_logger("version_checker") if not silent_mode else None
+    
+    def check_version_async(self, 
+                           callback: Optional[Callable] = None,
+                           show_notification: bool = True):
+        """
+        异步检测版本更新
+        
+        Args:
+            callback: 检测完成后的回调函数
+            show_notification: 是否显示更新提示
+        """
+        def _check():
+            try:
+                latest_version = self.check_version_sync()
+                if latest_version and self._is_newer_version(latest_version):
+                    if show_notification:
+                        self._show_update_notification(latest_version)
+                    if callback:
+                        callback(True, latest_version)
+                else:
+                    if callback:
+                        callback(False, latest_version)
+            except Exception as e:
+                if not self.silent_mode and self.logger:
+                    self.logger.debug(f"版本检测失败: {e}")
+                if callback:
+                    callback(False, None)
+        
+        thread = threading.Thread(target=_check, daemon=True)
+        thread.start()
+    
+    def check_version_sync(self) -> Optional[str]:
+        """
+        同步检测版本更新
+        
+        Returns:
+            最新版本号，如果检测失败则返回None
+        """
+        # 检查缓存
+        cached_version = self._get_cached_version()
+        if cached_version:
+            return cached_version
+        
+        # 从PyPI获取最新版本
+        try:
+            latest_version = self._check_pypi_version()
+            if latest_version:
+                self._cache_version(latest_version)
+            return latest_version
+        except Exception as e:
+            if not self.silent_mode and self.logger:
+                self.logger.debug(f"从PyPI检测版本失败: {e}")
+        
+        return None
+    
+    def _check_pypi_version(self) -> Optional[str]:
+        """从PyPI检测最新版本"""
+        url = f"https://pypi.org/pypi/{self.package_name}/json"
+        
+        try:
+            request = Request(url, headers={'User-Agent': f'{self.package_name}-version-checker'})
+            with urlopen(request, timeout=self.timeout) as response:
+                data = json.loads(response.read().decode())
+                return data['info']['version']
+        except (URLError, HTTPError, KeyError, json.JSONDecodeError):
+            return None
+    
+    def _is_newer_version(self, latest_version: str) -> bool:
+        """检查是否有新版本"""
+        try:
+            return version.parse(latest_version) > version.parse(self.current_version)
+        except Exception:
+            # 如果版本解析失败，使用字符串比较
+            return latest_version != self.current_version
+    
+    def _get_cached_version(self) -> Optional[str]:
+        """获取缓存的版本信息"""
+        try:
+            if not self.cache_file.exists():
+                return None
+            
+            with open(self.cache_file, 'r', encoding='utf-8') as f:
+                cache_data = json.load(f)
+            
+            # 检查缓存是否过期
+            cache_time = cache_data.get('timestamp', 0)
+            if time.time() - cache_time > self.cache_duration:
+                return None
+            
+            return cache_data.get('version')
+        except (FileNotFoundError, json.JSONDecodeError, KeyError):
+            return None
+    
+    def _cache_version(self, latest_version: str):
+        """缓存版本信息"""
+        try:
+            self.cache_dir.mkdir(exist_ok=True)
+            
+            cache_data = {
+                'version': latest_version,
+                'timestamp': time.time()
+            }
+            
+            with open(self.cache_file, 'w', encoding='utf-8') as f:
+                json.dump(cache_data, f)
+        except Exception:
+            pass  # 缓存失败不影响主功能
+    
+    def _show_update_notification(self, latest_version: str):
+        """显示更新通知"""
+        if self.silent_mode:
+            return
+        
+        print(f"\n🎉 {self.package_name} 有新版本可用!")
+        print(f"   当前版本: {self.current_version}")
+        print(f"   最新版本: {latest_version}")
+        print(f"   更新命令: pip install --upgrade {self.package_name}")
+        print()
+    
+    def clear_cache(self):
+        """清除版本缓存"""
+        try:
+            if self.cache_file.exists():
+                self.cache_file.unlink()
+        except Exception:
+            pass
+
+
+def create_version_checker(package_name: str, 
+                          current_version: Optional[str] = None,
+                          **kwargs) -> VersionChecker:
+    """
+    创建版本检测器的便捷函数
+    
+    Args:
+        package_name: 包名
+        current_version: 当前版本，如果为None则自动获取
+        **kwargs: 其他配置参数
+        
+    Returns:
+        VersionChecker实例
+    """
+    return VersionChecker(package_name, current_version, **kwargs)
+
+
+def check_pypi_version(package_name: str, 
+                      current_version: Optional[str] = None,
+                      show_notification: bool = True,
+                      silent_mode: bool = False) -> Optional[str]:
+    """
+    快速检测PyPI版本的便捷函数
+    
+    Args:
+        package_name: 包名
+        current_version: 当前版本，如果为None则自动获取
+        show_notification: 是否显示通知
+        silent_mode: 是否静默模式
+        
+    Returns:
+        最新版本号，如果检测失败则返回None
+    """
+    checker = VersionChecker(package_name, current_version, silent_mode=silent_mode)
+    latest_version = checker.check_version_sync()
+    
+    if latest_version and checker._is_newer_version(latest_version) and show_notification:
+        checker._show_update_notification(latest_version)
+    
+    return latest_version
+
+
+def check_reproto_version(current_version: Optional[str] = None, 
+                         show_notification: bool = True,
+                         silent_mode: bool = False) -> Optional[str]:
+    """
+    检测reproto包的PyPI版本更新
+    
+    这是专门为reproto项目设计的便捷函数，使用PyPI作为版本源
+    
+    Args:
+        current_version: 当前版本，如果为None则自动获取
+        show_notification: 是否显示更新通知，默认True
+        silent_mode: 是否静默模式，默认False
+        
+    Returns:
+        最新版本号，如果检测失败则返回None
+    """
+    return check_pypi_version(
+        package_name="reproto",
+        current_version=current_version,
+        show_notification=show_notification,
+        silent_mode=silent_mode
+    )
+
+
+def check_version_on_startup(current_version: Optional[str] = None):
+    """
+    在程序启动时异步检测版本更新
+    
+    这个函数专门用于在reproto启动时进行版本检测，
+    采用异步方式，不会阻塞主程序启动
+    
+    Args:
+        current_version: 当前版本号，如果为None则自动获取
+    """
+    # 获取当前版本
+    actual_version = current_version or get_package_version("reproto") or "0.0.0"
+    
+    def version_callback(has_update: bool, latest_version: Optional[str]):
+        if has_update and latest_version:
+            print(f"\n💡 提示：reproto有新版本 {latest_version} 可用")
+            print(f"   当前版本：{actual_version}")
+            print(f"   更新命令：pip install --upgrade reproto\n")
+    
+    checker = create_version_checker(
+        package_name="reproto",
+        current_version=actual_version,
+        silent_mode=True  # 静默模式，只在有更新时通过回调显示
+    )
+    
+    checker.check_version_async(
+        callback=version_callback,
+        show_notification=False  # 使用自定义回调，不使用默认通知
+    ) 

core/bytecode_parser.py

@@ -1,274 +0,0 @@
-from typing import List, Dict, Tuple
-import re
-from ..models import FieldDefinition, OneofDefinition
-from utils.type_utils import naming_converter
-
-class BytecodeParser:
-    """
-    重新设计的 Protobuf info_string 解析器，基于对 Google Protobuf Lite 格式的深入理解。
-    
-    info_string 格式分析：
-    - 前面是头部信息（版本、字段数量等）
-    - 后面是字段描述符，每个字段用特定格式编码
-    - '<' 字符表示 oneof 字段
-    - 数字表示字段标签
-    """
-
-    def __init__(self, info_bytes: bytes, objects: List[str]):
-        """
-        初始化解析器。
-
-        参数:
-            info_bytes (bytes): 从 info_string 编码而来的字节数组。
-            objects (List[str]): 作为符号表的 objects 数组。
-        """
-        self.info_string = info_bytes.decode('utf-8')
-        self.objects = objects
-        # print(f"  > 原始 info_string: {repr(self.info_string)}")
-        # print(f"  > 对象数组: {self.objects}")
-
-    def parse(self) -> Tuple[List[FieldDefinition], Dict[str, OneofDefinition]]:
-        """
-        解析 info_string 并返回字段定义。
-        
-        基于观察到的模式：
-        - SearchResult: "\\u0000\\u0002\\u0001\\u0000\\u0001\\u0002\\u0002\\u0000\\u0000\\u0000\\u0001<\\u0000\\u0002<\\u0000"
-        - ContactPhone: "\\u0000\\u0003\\u0001\\u0000\\u0001\\u0003\\u0003\\u0000\\u0000\\u0000\\u0001<\\u0000\\u0002<\\u0000\\u0003<\\u0000"
-        """
-        fields: List[FieldDefinition] = []
-        oneofs: Dict[str, OneofDefinition] = {}
-        
-        # 尝试解析字段描述符部分
-        # 寻找 '<' 字符，它们标识 oneof 字段
-        field_descriptors = self._extract_field_descriptors()
-        
-        if not field_descriptors:
-            return fields, oneofs
-            
-        # 确定 oneof 名称（从 objects 数组中）
-        oneof_name = self._determine_oneof_name()
-        
-        if oneof_name:
-            # 这是一个 oneof 结构
-            oneof_def = OneofDefinition(name=oneof_name)
-            
-            for i, desc in enumerate(field_descriptors):
-                if desc.get('is_oneof'):
-                    field_tag = desc['tag']
-                    field_type = self._determine_field_type(i + 2)  # objects[2], objects[3], etc.
-                    field_name = self._generate_field_name(field_type, field_tag)
-                    
-                    field = FieldDefinition(
-                        name=field_name,
-                        type=field_type,
-                        tag=field_tag,
-                        rule="optional"
-                    )
-                    oneof_def.fields.append(field)
-            
-            oneofs[oneof_name] = oneof_def
-        else:
-            # 常规字段结构
-            for i, desc in enumerate(field_descriptors):
-                field_tag = desc['tag']
-                # 对于常规字段，从 objects 数组中获取字段名
-                if field_tag - 1 < len(self.objects):
-                    raw_field_name = self.objects[field_tag - 1]  # tag 从 1 开始，数组从 0 开始
-                    field_name = self._clean_field_name(raw_field_name)
-                else:
-                    field_name = f"field_{field_tag}"
-                
-                # 尝试推断字段类型
-                field_type = self._infer_field_type(desc, field_tag)
-                
-                # 检查是否是 repeated 字段
-                if field_type.startswith("repeated "):
-                    rule = "repeated"
-                    field_type = field_type[9:]  # 移除 "repeated " 前缀
-                else:
-                    rule = "optional"
-                
-                field = FieldDefinition(
-                    name=field_name,
-                    type=field_type,
-                    tag=field_tag,
-                    rule=rule
-                )
-                fields.append(field)
-        
-        return fields, oneofs
-
-    def _extract_field_descriptors(self) -> List[Dict]:
-        """
-        从 info_string 中提取字段描述符。
-        
-        基于观察：
-        - 字段描述符通常在字符串的后半部分
-        - '<' 字符标识 oneof 字段
-        - 数字字符表示字段标签
-        """
-        descriptors = []
-        
-        # 先打印原始字符串的字符分析
-        # print(f"  > 字符串分析:")
-        # for i, char in enumerate(self.info_string):
-        #     if ord(char) > 32:  # 可打印字符
-        #         print(f"    位置 {i}: '{char}' (ord={ord(char)})")
-        #     else:
-        #         print(f"    位置 {i}: \\x{ord(char):02x}")
-        
-        # 寻找 '<' 字符的位置
-        oneof_positions = []
-        for i, char in enumerate(self.info_string):
-            if char == '<':
-                oneof_positions.append(i)
-                
-        # print(f"  > 找到 oneof 标记位置: {oneof_positions}")
-        
-        # 对于每个 '<' 字符，查找前面的数字作为字段标签
-        for pos in oneof_positions:
-            # 查找 '<' 前面的字符
-            if pos > 0:
-                prev_char = self.info_string[pos - 1]
-                prev_byte = ord(prev_char)
-                # print(f"    '<' 前面的字节: \\x{prev_byte:02x} (值={prev_byte})")
-                
-                # 检查是否是有效的字段标签（1-15 是常见范围）
-                if 1 <= prev_byte <= 15:
-                    tag = prev_byte
-                    descriptors.append({
-                        'tag': tag,
-                        'is_oneof': True,
-                        'position': pos
-                    })
-                    # print(f"    发现 oneof 字段: tag={tag}, 位置={pos}")
-        
-        # 如果没有找到 oneof 字段，尝试寻找普通字段
-        if not descriptors:
-            # 寻找可能的字段标签模式
-            # 对于非 oneof 字段，我们需要查找其他模式
-            # print(f"  > 没有找到 oneof 字段，尝试寻找常规字段...")
-            
-            # 查找特殊字符 'Ȉ' (ord=520) 这似乎是字段标记
-            for i, char in enumerate(self.info_string):
-                if ord(char) == 520:  # 'Ȉ' 字符
-                    # 查找前面的字节作为字段标签
-                    if i > 0:
-                        prev_byte = ord(self.info_string[i - 1])
-                        if 1 <= prev_byte <= 50:  # 扩大范围以捕获更多字段
-                            descriptors.append({
-                                'tag': prev_byte,
-                                'is_oneof': False,
-                                'position': i
-                            })
-                            # print(f"    发现常规字段: tag={prev_byte}, 位置={i}")
-            
-            # 如果还是没有找到，尝试其他数字模式
-            if not descriptors:
-                for i, char in enumerate(self.info_string):
-                    byte_val = ord(char)
-                    if 1 <= byte_val <= 20 and byte_val <= len(self.objects):  # 可能的字段标签
-                        # 检查前后上下文以确认这是字段标签
-                        if i < len(self.info_string) - 1:
-                            next_char = self.info_string[i + 1]
-                            # 如果下一个字符是特殊标记，这可能是字段标签
-                            if ord(next_char) in [50, 60, 520, 27]:  # 各种字段类型标记
-                                descriptors.append({
-                                    'tag': byte_val,
-                                    'is_oneof': False,
-                                    'position': i
-                                })
-                                # print(f"    发现可能的字段: tag={byte_val}, 位置={i}")
-        
-        return descriptors
-
-    def _determine_oneof_name(self) -> str:
-        """
-        从 objects 数组确定 oneof 的名称。
-        
-        观察：
-        - objects[0] 通常是 oneof 字段名（如 "result_", "sealedValue_"）
-        - objects[1] 通常是 case 字段名（如 "resultCase_", "sealedValueCase_"）
-        """
-        if len(self.objects) >= 2:
-            field_name = self.objects[0]
-            case_name = self.objects[1]
-            
-            # 检查是否符合 oneof 模式
-            if (field_name.endswith('_') and 
-                case_name.endswith('Case_') and 
-                case_name.startswith(field_name[:-1])):
-                
-                # 从字段名生成 oneof 名称
-                base_name = field_name[:-1]  # 移除末尾的 '_'
-                return self._to_snake_case(base_name)
-        
-        return ""
-
-    def _determine_field_type(self, object_index: int) -> str:
-        """
-        从 objects 数组确定字段类型。
-        """
-        if object_index < len(self.objects):
-            obj = self.objects[object_index]
-            if obj.endswith('.class'):
-                # 移除 '.class' 后缀，提取类名
-                class_name = obj[:-6]
-                # 提取最后一部分作为类型名
-                return class_name.split('.')[-1]
-            else:
-                return obj
-        return "unknown"
-
-    def _generate_field_name(self, field_type: str, field_tag: int) -> str:
-        """
-        根据字段类型和标签生成字段名称。
-        """
-        # 将类型名转换为 snake_case
-        name = self._to_snake_case(field_type)
-        return name
-
-    def _to_snake_case(self, name: str) -> str:
-        """
-        将 CamelCase 转换为 snake_case。
-        """
-        return naming_converter.to_snake_case(name)
-
-    def _clean_field_name(self, name: str) -> str:
-        """
-        清理字段名称，去除不必要的后缀或前缀。
-        """
-        # 去除末尾的下划线
-        if name.endswith('_'):
-            name = name[:-1]
-        # 转换为 snake_case
-        return self._to_snake_case(name)
-
-    def _infer_field_type(self, desc: Dict, field_tag: int) -> str:
-        """
-        根据字段描述符推断字段类型。
-        """
-        # 检查 info_string 中字段标签后面的字节来推断类型
-        position = desc.get('position', -1)
-        if position > 0 and position < len(self.info_string) - 1:
-            # 查看字段标签后面的字节
-            next_byte = ord(self.info_string[position + 1])
-            
-            # 根据字节值推断类型
-            if next_byte == 27:  # 0x1B - repeated message
-                # 查找对应的类类型
-                if field_tag < len(self.objects):
-                    class_obj = self.objects[field_tag]  # objects[1] 对应 tag=1
-                    if class_obj.endswith('.class'):
-                        class_name = class_obj[:-6].split('.')[-1]
-                        return f"repeated {class_name}"
-                return "repeated message"
-            elif next_byte == 520:  # 'Ȉ' - string field
-                return "string"
-            elif next_byte == 12:  # 0x0C - enum
-                return "int32"  # 枚举通常映射为 int32
-            elif next_byte == 50:  # '2' - 可能是某种数字类型
-                return "int32"
-            
-        # 默认返回 string
-        return "string"