reproto 0.1.1__py3-none-any.whl → 0.1.3__py3-none-any.whl

main.py

@@ -16,17 +16,33 @@ Author: AI Assistant
 
 import sys
 import argparse
+import traceback
 from pathlib import Path
 
-# 导入项目模块
+# 确保项目根目录在Python路径中
 import os
 sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
-from core.reconstructor import ProtoReconstructor
-from utils.logger import setup_logger, get_logger
 
+# 智能导入：同时支持相对导入（包环境）和绝对导入（开发环境）
+try:
+    # 相对导入（包环境）
+    from .core.reconstructor import ProtoReconstructor
+    from .utils.logger import setup_logger, get_logger
+    from .utils.report_utils import print_results_summary
+except ImportError:
+    # 绝对导入（开发环境）
+    from core.reconstructor import ProtoReconstructor
+    from utils.logger import setup_logger, get_logger
+    from utils.report_utils import print_results_summary
 
-def parse_arguments():
-    """解析命令行参数"""
+
+def parse_arguments() -> argparse.Namespace:
+    """
+    解析命令行参数
+    
+    Returns:
+        解析后的命令行参数对象
+    """
     parser = argparse.ArgumentParser(
         description='从JADX反编译的Java源码重构Protobuf .proto文件',
         formatter_class=argparse.RawDescriptionHelpFormatter,
@@ -72,8 +88,19 @@ def parse_arguments():
     return parser.parse_args()
 
 
-def validate_arguments(args):
-    """验证命令行参数"""
+def validate_arguments(args: argparse.Namespace) -> tuple[Path, str, Path]:
+    """
+    验证命令行参数的有效性
+    
+    Args:
+        args: 解析后的命令行参数
+        
+    Returns:
+        验证后的路径元组: (sources_path, root_class, output_path)
+        
+    Raises:
+        SystemExit: 当参数无效时退出程序
+    """
     logger = get_logger("main")
     
     # 验证源码目录
@@ -92,13 +119,13 @@ def validate_arguments(args):
         logger.error("应该是完整的类名，如: com.example.Model")
         sys.exit(1)
     
-    # 输出目录可以不存在，会自动创建
+    # 验证输出目录
     output_path = Path(args.output_dir)
     if output_path.exists() and not output_path.is_dir():
         logger.error(f"输出路径存在但不是目录: {output_path}")
         sys.exit(1)
     
-    # 验证日志目录
+    # 创建日志目录
     log_path = Path(args.log_dir)
     try:
         log_path.mkdir(parents=True, exist_ok=True)
@@ -109,11 +136,19 @@ def validate_arguments(args):
     return sources_path.resolve(), args.root_class, output_path.resolve()
 
 
-def main():
-    """主函数"""
+def main() -> None:
+    """
+    主函数：协调整个重构过程
+    
+    处理流程：
+    1. 解析和验证命令行参数
+    2. 初始化日志系统
+    3. 创建重构器并执行重构
+    4. 输出结果统计信息
+    """
     args = None
     try:
-        # 解析参数
+        # 解析和验证参数
         args = parse_arguments()
         
         # 初始化日志系统
@@ -130,62 +165,25 @@ def main():
         logger.info(f"📁 日志目录: {args.log_dir}")
         logger.info(f"🎯 根类: {root_class}")
         
-        # 创建重构器并执行
+        # 创建重构器并执行重构
         reconstructor = ProtoReconstructor(sources_dir, output_dir)
         reconstructor._verbose = args.verbose  # 传递verbose标志
         results = reconstructor.reconstruct_from_root(root_class)
         
-        # 输出详细的结果统计
-        if results:
-            # 统计成功和失败的数量
-            success_count = len(results)
-            failed_count = len(reconstructor.failed_classes) if hasattr(reconstructor, 'failed_classes') else 0
-            total_attempted = success_count + failed_count
-            
-            logger.success("✅ 重构完成!")
-            logger.info(f"📊 处理统计: 共尝试处理 {total_attempted} 个类型")
-            
-            message_count = sum(1 for r in results.values() if hasattr(r, 'fields'))
-            enum_count = sum(1 for r in results.values() if hasattr(r, 'values'))
-            
-            logger.info(f"   - ✅ 成功: {success_count} 个 (消息: {message_count}, 枚举: {enum_count})")
-            
-            # 显示失败的类
-            if hasattr(reconstructor, 'failed_classes') and reconstructor.failed_classes:
-                logger.warning(f"   - ❌ 失败: {failed_count} 个")
-                for failed_class, reason in reconstructor.failed_classes.items():
-                    logger.warning(f"     • {failed_class}: {reason}")
-            
-            # 显示跳过的类
-            if hasattr(reconstructor, 'skipped_classes') and reconstructor.skipped_classes:
-                skipped_count = len(reconstructor.skipped_classes)
-                logger.info(f"   - ⏭️  跳过: {skipped_count} 个 (基础类型或已处理)")
-                if args.verbose:
-                    for skipped_class, reason in reconstructor.skipped_classes.items():
-                        logger.info(f"     • {skipped_class}: {reason}")
-        else:
-            logger.error("❌ 没有生成任何proto文件!")
-            logger.error("请检查:")
-            logger.error("  1. 根类名是否正确")
-            logger.error("  2. Java源码目录是否包含对应的文件")
-            logger.error("  3. 类是否为protobuf消息类")
-            
-            # 显示详细的失败信息
-            if hasattr(reconstructor, 'failed_classes') and reconstructor.failed_classes:
-                logger.error("失败的类:")
-                for failed_class, reason in reconstructor.failed_classes.items():
-                    logger.error(f"  • {failed_class}: {reason}")
-            
-            sys.exit(1)
+        # 输出结果统计
+        print_results_summary(reconstructor, results, logger, args.verbose)
         
     except KeyboardInterrupt:
+        # 处理用户中断
         if args:
             logger = get_logger("main")
             logger.warning("⚠️  操作被用户中断")
         else:
             print("\n⚠️  操作被用户中断")
         sys.exit(1)
+        
     except Exception as e:
+        # 处理其他异常
         if args:
             logger = get_logger("main")
             logger.error(f"❌ 重构失败: {e}")
@@ -194,7 +192,6 @@ def main():
         else:
             print(f"\n❌ 重构失败: {e}")
             if hasattr(args, 'verbose') and args.verbose:
-                import traceback
                 traceback.print_exc()
         sys.exit(1)
 

models/__init__.py

@@ -1,27 +1,34 @@
-from dataclasses import dataclass, field
-from typing import List, Dict, Set
+"""
+模型定义模块
 
-@dataclass
-class FieldDefinition:
-    """表示一个 Protobuf 消息中的字段。"""
-    name: str
-    type: str
-    tag: int
-    rule: str # "optional", "repeated", or "oneof"
+包含Protobuf消息、字段、枚举等数据结构的定义
+所有具体的类定义都在相应的子模块中
+"""
 
-@dataclass
-class OneofDefinition:
-    """表示一个 Protobuf oneof 块。"""
-    name: str
-    fields: List[FieldDefinition] = field(default_factory=list)
+# 智能导入：同时支持相对导入（包环境）和绝对导入（开发环境）
+try:
+    # 相对导入（包环境）
+    from .message_definition import (
+        MessageDefinition, 
+        FieldDefinition, 
+        OneofDefinition, 
+        EnumDefinition, 
+        EnumValueDefinition
+    )
+except ImportError:
+    # 绝对导入（开发环境）
+    from models.message_definition import (
+        MessageDefinition, 
+        FieldDefinition, 
+        OneofDefinition, 
+        EnumDefinition, 
+        EnumValueDefinition
+    )
 
-@dataclass
-class MessageDefinition:
-    """表示一个完整的 Protobuf 消息的定义。"""
-    name: str
-    package: str
-    info_string: str = ""
-    objects: List[str] = field(default_factory=list)
-    fields: List[FieldDefinition] = field(default_factory=list)
-    oneofs: Dict[str, OneofDefinition] = field(default_factory=dict)
-    dependencies: Set[str] = field(default_factory=set) 
+__all__ = [
+    'MessageDefinition',
+    'FieldDefinition', 
+    'OneofDefinition',
+    'EnumDefinition',
+    'EnumValueDefinition'
+] 

parsing/__init__.py

@@ -1,3 +1,25 @@
+"""
+解析器模块
+
+包含各种源码解析器：
+- Java解析器：解析Java源码，提取字段标签和类型信息
+- 枚举解析器：专门处理Java枚举类的解析
+"""
+
+# 智能导入：同时支持相对导入（包环境）和绝对导入（开发环境）
+try:
+    # 相对导入（包环境）
+    from .java_parser import JavaParser
+    from .enum_parser import EnumParser
+except ImportError:
+    # 绝对导入（开发环境）
+    from parsing.java_parser import JavaParser
+    from parsing.enum_parser import EnumParser
+
+__all__ = [
+    'JavaParser',
+    'EnumParser'
+]
 
 
 

parsing/enum_parser.py

@@ -8,8 +8,16 @@
 import re
 import os
 from typing import List, Optional, Dict, Tuple
-from models.message_definition import EnumDefinition, EnumValueDefinition
-from utils.logger import get_logger
+
+# 智能导入：同时支持相对导入（包环境）和绝对导入（开发环境）
+try:
+    # 相对导入（包环境）
+    from ..models.message_definition import EnumDefinition, EnumValueDefinition
+    from ..utils.logger import get_logger
+except ImportError:
+    # 绝对导入（开发环境）
+    from models.message_definition import EnumDefinition, EnumValueDefinition
+    from utils.logger import get_logger
 
 
 class EnumParser:

parsing/java_parser.py

@@ -11,7 +11,13 @@ import re
 from pathlib import Path
 from typing import Optional, Tuple, List
 
-from utils.logger import get_logger
+# 智能导入：同时支持相对导入（包环境）和绝对导入（开发环境）
+try:
+    # 相对导入（包环境）
+    from ..utils.logger import get_logger
+except ImportError:
+    # 绝对导入（开发环境）
+    from utils.logger import get_logger
 
 
 class JavaParser:
@@ -27,12 +33,13 @@ class JavaParser:
         self.logger = get_logger("java_parser")
         
         # 匹配newMessageInfo调用的正则表达式
-        # 格式：GeneratedMessageLite.newMessageInfo(DEFAULT_INSTANCE, "字节码", new Object[]{对象数组})
+        # 格式1：GeneratedMessageLite.newMessageInfo(DEFAULT_INSTANCE, "字节码", new Object[]{对象数组})
+        # 格式2：GeneratedMessageLite.newMessageInfo(DEFAULT_INSTANCE, "字节码", null)
         self.new_message_info_pattern = re.compile(
             r'GeneratedMessageLite\.newMessageInfo\(\s*'
             r'DEFAULT_INSTANCE\s*,\s*'
             r'"([^"]*)",\s*'  # 捕获字节码字符串
-            r'new\s+Object\[\]\s*\{([^}]*)\}',  # 捕获对象数组
+            r'(?:new\s+Object\[\]\s*\{([^}]*)\}|null)',  # 捕获对象数组或null
             re.DOTALL
         )
     
@@ -50,17 +57,26 @@ class JavaParser:
             # 读取Java文件内容
             content = java_file_path.read_text(encoding='utf-8')
             
-            # 查找newMessageInfo调用
-            match = self.new_message_info_pattern.search(content)
-            if not match:
+            # 查找所有newMessageInfo调用
+            matches = self.new_message_info_pattern.findall(content)
+            if not matches:
                 return None, None
             
-            # 提取字节码字符串和对象数组字符串
-            info_string = match.group(1)
-            objects_str = match.group(2)
+            # 获取主类的字段标签
+            main_class_field_tags = self._extract_field_number_constants(content)
             
-            # 解析对象数组
-            objects_array = self._parse_objects_array(objects_str)
+            # 根据字段匹配选择正确的newMessageInfo调用
+            best_match = self._select_main_class_message_info(matches, main_class_field_tags)
+            if not best_match:
+                return None, None
+            
+            info_string, objects_str = best_match
+            
+            # 解析对象数组（允许null/空对象数组）
+            if objects_str and objects_str.strip():
+                objects_array = self._parse_objects_array(objects_str)
+            else:
+                objects_array = []  # 空消息的情况（null或空字符串）
             
             return info_string, objects_array
             
@@ -68,6 +84,142 @@ class JavaParser:
             self.logger.error(f"❌ 解析Java文件失败 {java_file_path}: {e}")
             return None, None
     
+    def parse_inner_class_from_file(self, java_file_path: Path, inner_class_name: str) -> Tuple[Optional[str], Optional[List[str]]]:
+        """
+        从外部类文件中解析指定的内部类的protobuf信息
+        
+        Args:
+            java_file_path: 外部类Java文件路径
+            inner_class_name: 内部类名（如"SkipRecovery"）
+            
+        Returns:
+            Tuple[字节码字符串, 对象数组] 或 (None, None) 如果解析失败
+        """
+        try:
+            # 读取Java文件内容
+            content = java_file_path.read_text(encoding='utf-8')
+            
+            # 提取指定内部类的内容
+            inner_class_content = self._extract_inner_class_content(content, inner_class_name)
+            if not inner_class_content:
+                self.logger.error(f"❌ 在文件 {java_file_path} 中找不到内部类: {inner_class_name}")
+                return None, None
+            
+            # 在内部类内容中查找newMessageInfo调用
+            matches = self.new_message_info_pattern.findall(inner_class_content)
+            if not matches:
+                self.logger.debug(f"  🔍 内部类 {inner_class_name} 中没有找到newMessageInfo调用")
+                return None, None
+            
+            # 对于内部类，通常只有一个newMessageInfo调用
+            info_string, objects_str = matches[0]
+            
+            # 解析对象数组（允许null/空对象数组）
+            if objects_str and objects_str.strip():
+                objects_array = self._parse_objects_array(objects_str)
+            else:
+                objects_array = []  # 空消息的情况（null或空字符串）
+            
+            # 为内部类单独提取字段标签
+            self._extract_inner_class_field_tags(java_file_path, inner_class_name, inner_class_content)
+            
+            self.logger.info(f"  ✅ 成功解析内部类 {inner_class_name}: {len(objects_array)} 个对象")
+            return info_string, objects_array
+            
+        except Exception as e:
+            self.logger.error(f"❌ 解析内部类失败 {inner_class_name} from {java_file_path}: {e}")
+            return None, None
+    
+    def _extract_inner_class_content(self, content: str, inner_class_name: str) -> Optional[str]:
+        """
+        从Java文件内容中提取指定内部类的内容
+        
+        Args:
+            content: Java文件内容
+            inner_class_name: 内部类名
+            
+        Returns:
+            内部类的内容，如果找不到则返回None
+        """
+        # 查找内部类定义的开始
+        # 匹配模式：public static final class InnerClassName extends ...
+        class_pattern = rf'public\s+static\s+final\s+class\s+{re.escape(inner_class_name)}\s+extends\s+'
+        match = re.search(class_pattern, content)
+        
+        if not match:
+            # 尝试更宽松的匹配
+            class_pattern = rf'class\s+{re.escape(inner_class_name)}\s+extends\s+'
+            match = re.search(class_pattern, content)
+            
+        if not match:
+            return None
+        
+        # 找到类定义的开始位置
+        class_start = match.start()
+        
+        # 从类定义开始位置往前找到第一个'{'
+        content_from_class = content[class_start:]
+        brace_start = content_from_class.find('{')
+        if brace_start == -1:
+            return None
+        
+        # 从第一个'{'开始，找到匹配的'}'
+        start_pos = class_start + brace_start + 1
+        brace_count = 1
+        pos = start_pos
+        
+        while pos < len(content) and brace_count > 0:
+            if content[pos] == '{':
+                brace_count += 1
+            elif content[pos] == '}':
+                brace_count -= 1
+            pos += 1
+        
+        if brace_count == 0:
+            # 找到了匹配的结束位置
+            inner_class_content = content[start_pos:pos-1]
+            return inner_class_content
+        
+        return None
+    
+    def _extract_inner_class_field_tags(self, java_file_path: Path, inner_class_name: str, inner_class_content: str) -> None:
+        """
+        为内部类提取字段标签，并缓存到文件系统中
+        
+        Args:
+            java_file_path: Java文件路径
+            inner_class_name: 内部类名
+            inner_class_content: 内部类的源码内容
+        """
+        # 从内部类内容中提取字段标签
+        field_tags = self._extract_field_tags_from_source(inner_class_content)
+        
+        if field_tags:
+            # 创建内部类的虚拟文件路径，用于缓存字段标签
+            # 如：Service$CompleteOnboardingRequest.java -> Service$CompleteOnboardingRequest$InstallationInfo.java
+            virtual_file_path = java_file_path.parent / f"{java_file_path.stem}${inner_class_name}.java"
+            
+            # 将字段标签缓存到虚拟文件路径
+            self._cache_field_tags(virtual_file_path, field_tags)
+            
+            self.logger.debug(f"  🏷️ 为内部类 {inner_class_name} 提取了 {len(field_tags)} 个字段标签")
+        else:
+            self.logger.debug(f"  🔍 内部类 {inner_class_name} 没有字段标签")
+    
+    def _cache_field_tags(self, file_path: Path, field_tags: dict) -> None:
+        """
+        缓存字段标签到内存中，供后续使用
+        
+        Args:
+            file_path: 文件路径（可能是虚拟路径）
+            field_tags: 字段标签字典
+        """
+        # 使用简单的内存缓存
+        if not hasattr(self, '_field_tags_cache'):
+            self._field_tags_cache = {}
+        
+        self._field_tags_cache[str(file_path)] = field_tags
+    
     def _parse_objects_array(self, objects_str: str) -> List[str]:
         """
         解析Java对象数组字符串
@@ -183,6 +335,85 @@ class JavaParser:
         
         return part if part else None
     
+    def _select_main_class_message_info(self, matches: List[tuple], main_class_field_tags: dict) -> Optional[tuple]:
+        """
+        根据字段匹配选择主类的newMessageInfo调用
+        
+        Args:
+            matches: 所有newMessageInfo匹配结果 [(info_string, objects_str), ...]
+            main_class_field_tags: 主类字段标签 {const_name: tag_value}
+            
+        Returns:
+            主类的newMessageInfo匹配结果或None
+        """
+        if not matches:
+            return None
+        
+        if len(matches) == 1:
+            return matches[0]
+        
+        # 从主类字段标签生成期望的字段名列表
+        expected_fields = set()
+        for const_name in main_class_field_tags.keys():
+            field_name = self._const_name_to_field_name(const_name)
+            expected_fields.add(field_name)
+        
+        self.logger.debug(f"  🔍 主类期望字段: {expected_fields}")
+        
+        best_match = None
+        best_score = 0
+        
+        for info_string, objects_str in matches:
+            # 解析对象数组（允许null/空对象数组）
+            if objects_str and objects_str.strip():
+                objects_array = self._parse_objects_array(objects_str)
+            else:
+                objects_array = []  # 空消息的情况（null或空字符串）
+            
+            # 计算匹配分数
+            score = self._calculate_field_match_score(objects_array, expected_fields)
+            
+            self.logger.debug(f"  📊 对象数组 {objects_array[:3]}... 匹配分数: {score}")
+            
+            if score > best_score:
+                best_score = score
+                best_match = (info_string, objects_str)
+        
+        if best_match:
+            self.logger.info(f"  ✅ 选择主类newMessageInfo，匹配分数: {best_score}")
+        else:
+            self.logger.warning(f"  ⚠️  无法找到匹配的主类newMessageInfo")
+        
+        return best_match
+    
+    def _calculate_field_match_score(self, objects_array: List[str], expected_fields: set) -> int:
+        """
+        计算对象数组与期望字段的匹配分数
+        
+        Args:
+            objects_array: 解析后的对象数组
+            expected_fields: 期望的字段名集合
+            
+        Returns:
+            匹配分数（匹配的字段数量）
+        """
+        if not objects_array or not expected_fields:
+            return 0
+        
+        match_count = 0
+        
+        for obj in objects_array:
+            # 检查是否是字段名（以_结尾的字符串）
+            if obj.endswith('_'):
+                if obj in expected_fields:
+                    match_count += 1
+            # 检查是否是类引用（不以_结尾，可能是oneof字段的类型）
+            elif not obj.endswith('_'):
+                # 类引用也算作有效匹配，但权重较低
+                match_count += 0.5
+        
+        return int(match_count)
+    
     def parse_enum_file(self, java_file_path: Path) -> Optional[List[tuple]]:
         """
         解析Java枚举文件，提取枚举值和数值
@@ -369,6 +600,18 @@ class JavaParser:
             字段标签映射 {field_name: tag} 或 None 如果解析失败
         """
         try:
+            # 首先检查是否有缓存的字段标签（用于内部类）
+            if hasattr(self, '_field_tags_cache'):
+                cache_key = str(java_file_path)
+                if cache_key in self._field_tags_cache:
+                    self.logger.debug(f"  🎯 使用缓存的字段标签: {java_file_path}")
+                    return self._field_tags_cache[cache_key]
+            
+            # 检查文件是否存在（虚拟文件路径不存在）
+            if not java_file_path.exists():
+                self.logger.debug(f"  📁 文件不存在，跳过字段标签提取: {java_file_path}")
+                return None
+            
             # 读取Java文件内容
             content = java_file_path.read_text(encoding='utf-8')
             
@@ -451,7 +694,7 @@ class JavaParser:
     
     def _extract_field_number_constants(self, content: str) -> dict:
         """
-        提取所有FIELD_NUMBER常量
+        提取主类的FIELD_NUMBER常量（排除内部类）
         
         Args:
             content: Java文件内容
@@ -459,19 +702,65 @@ class JavaParser:
         Returns:
             常量名到值的映射 {const_name: value}
         """
+        # 首先找到主类的定义范围
+        main_class_content = self._extract_main_class_content(content)
+        
         field_tag_pattern = re.compile(
             r'\s*public\s+static\s+final\s+int\s+'  # 允许行首有空白字符
             r'([A-Z0-9_]+)_FIELD_NUMBER\s*=\s*(\d+)\s*;'  # 允许常量名包含数字
         )
         
         constants = {}
-        for match in field_tag_pattern.finditer(content):
+        for match in field_tag_pattern.finditer(main_class_content):
             const_name = match.group(1)
             tag_value = int(match.group(2))
             constants[const_name] = tag_value
         
         return constants
     
+    def _extract_main_class_content(self, content: str) -> str:
+        """
+        提取主类的内容，排除内部类定义
+        
+        Args:
+            content: Java文件内容
+            
+        Returns:
+            主类内容（不包括内部类）
+        """
+        # 找到主类的开始位置
+        main_class_pattern = re.compile(
+            r'public\s+final\s+class\s+\w+(?:\$\w+)?\s+extends\s+GeneratedMessageLite.*?\{',
+            re.DOTALL
+        )
+        
+        main_class_match = main_class_pattern.search(content)
+        if not main_class_match:
+            # 如果找不到主类定义，返回整个内容作为回退
+            return content
+        
+        main_class_start = main_class_match.end()
+        
+        # 找到第一个内部类的开始位置
+        inner_class_pattern = re.compile(
+            r'\n\s*public\s+(?:static\s+)?(?:final\s+)?class\s+\w+\s+extends\s+',
+            re.MULTILINE
+        )
+        
+        # 从主类开始位置搜索内部类
+        content_from_main_class = content[main_class_start:]
+        inner_class_match = inner_class_pattern.search(content_from_main_class)
+        
+        if inner_class_match:
+            # 如果找到内部类，只返回主类部分
+            inner_class_start = main_class_start + inner_class_match.start()
+            main_class_content = content[:inner_class_start]
+        else:
+            # 如果没有内部类，返回整个内容
+            main_class_content = content
+        
+        return main_class_content
+    
     def _generate_possible_constant_names(self, field_name: str) -> List[str]:
         """
         根据字段名生成可能的常量名

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "reproto"
-version = "0.1.1"
+version = "0.1.3"
 description = "一个强大的逆向工程工具, 能够从任何使用Google Protobuf Lite的Android应用中自动重构出完整的.proto文件结构."
 readme = "README.md"
 license = "Proprietary"