Python to C++11 Converter Skill 详细设计文档

版本: v1.0.0
日期: 2026-03-26
作者: Vincent Wei

---

目录

1. 系统概述
2. 架构设计
3. 模块详细设计
4. 数据流设计
5. API接口设计
6. 转换规则引擎
7. 类型系统设计
8. 代码生成策略
9. 错误处理机制
10. 性能优化设计
11. 扩展性设计
12. 安全性设计
13. 测试策略
14. 部署方案

---

1. 系统概述

1.1 项目背景

Python作为动态类型语言，在开发效率上具有优势，但在性能关键场景下，C++11仍是首选。本项目旨在提供智能化的Python到C++11代码转换工具，降低跨语言迁移成本。

1.2 设计目标

1.3 技术选型

组件	技术栈	选型理由
核心转换引擎	GLM-4 API	智能代码理解和生成能力
CLI工具	Python 3	跨平台、易部署
API包装器	TypeScript	与Next.js无缝集成
配置格式	JSON	易于解析和扩展

---

2. 架构设计

2.1 整体架构

1. ┌─────────────────────────────────────────────────────────────────────┐
2. │ Python to C++11 Converter │
3. ├─────────────────────────────────────────────────────────────────────┤
4. │ │
5. │ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │
6. │ │ CLI Layer │ │ API Layer │ │ SDK Layer │ │
7. │ │ (convert) │ │ (wrapper) │ │ (future) │ │
8. │ └──────┬──────┘ └──────┬──────┘ └──────┬──────┘ │
9. │ │ │ │ │
10. │ └────────────────┼────────────────┘ │
11. │ │ │
12. │ ▼ │
13. │ ┌─────────────────────────────────────────────────────────────┐ │
14. │ │ Conversion Engine │ │
15. │ ├─────────────────────────────────────────────────────────────┤ │
16. │ │ ┌───────────┐ ┌───────────┐ ┌───────────┐ ┌──────────┐ │ │
17. │ │ │ Input │─▶│ Analysis │─▶│ Transform │─▶│ Output │ │ │
18. │ │ │ Parser │ │ Engine │ │ Engine │ │ Generator│ │ │
19. │ │ └───────────┘ └───────────┘ └───────────┘ └──────────┘ │ │
20. │ └─────────────────────────────────────────────────────────────┘ │
21. │ │ │
22. │ ▼ │
23. │ ┌─────────────────────────────────────────────────────────────┐ │
24. │ │ Rule Engine │ │
25. │ ├─────────────────────────────────────────────────────────────┤ │
26. │ │ Type Rules │ Syntax Rules │ Semantic Rules │ Best Practices│ │
27. │ └─────────────────────────────────────────────────────────────┘ │
28. │ │ │
29. │ ▼ │
30. │ ┌─────────────────────────────────────────────────────────────┐ │
31. │ │ GLM-4 API Client │ │
32. │ ├─────────────────────────────────────────────────────────────┤ │
33. │ │ Request Builder │ Response Parser │ Error Handler │ Cache │ │
34. │ └─────────────────────────────────────────────────────────────┘ │
35. │ │
36. └─────────────────────────────────────────────────────────────────────┘

2.2 分层架构说明

表现层 (Presentation Layer)

• CLI Interface: 命令行工具，支持文件I/O和管道操作
• API Interface: REST API，用于Web服务集成
• SDK Interface: 编程接口，用于应用内嵌集成

业务层 (Business Layer)

• Conversion Engine: 核心转换引擎
• Rule Engine: 转换规则管理和执行
• Analysis Engine: Python代码静态分析

数据层 (Data Layer)

• GLM-4 API Client: 智能转换服务客户端
• Cache Manager: 结果缓存管理
• Config Manager: 配置管理

---

3. 模块详细设计

3.1 输入解析模块 (InputParser)

职责: 解析Python源代码，提取结构化信息

1. class InputParser:
2. """
3. 输入解析器
4.  
5. 职责:
6. 1. 验证输入代码语法
7. 2. 提取代码结构信息
8. 3. 识别代码特征（类、函数、导入等）
9. """
10.  
11. def parse(self, source_code: str) -> ParsedInput:
12. """
13. 解析Python源代码
14.  
15. Args:
16. source_code: Python源代码字符串
17.  
18. Returns:
19. ParsedInput: 解析结果对象
20. """
21.  
22. def extract_metadata(self, source_code: str) -> CodeMetadata:
23. """
24. 提取代码元数据
25.  
26. Returns:
27. CodeMetadata: 包含imports, classes, functions, globals, dependencies
28. """

数据结构:

1. @dataclass
2. class ParsedInput:
3. """解析后的输入数据"""
4. source_code: str # 原始代码
5. metadata: CodeMetadata # 代码元数据
6. features: List[CodeFeature] # 代码特征
7. complexity: ComplexityMetrics # 复杂度指标
8.  
9. @dataclass
10. class CodeMetadata:
11. """代码元数据"""
12. imports: List[ImportInfo] # 导入信息
13. classes: List[ClassInfo] # 类定义
14. functions: List[FunctionInfo] # 函数定义
15. variables: List[VariableInfo] # 变量定义
16. type_annotations: Dict[str, str] # 类型注解

3.2 分析引擎模块 (AnalysisEngine)

职责: 深度分析Python代码，理解语义和上下文

1. class AnalysisEngine:
2. """
3. 分析引擎
4.  
5. 职责:
6. 1. 类型推断
7. 2. 依赖分析
8. 3. 控制流分析
9. 4. 数据流分析
10. """
11.  
12. def analyze(self, parsed_input: ParsedInput) -> AnalysisResult:
13. """执行代码分析"""
14.  
15. def infer_type(self, expression: str, context: TypeContext) -> TypeInfo:
16. """类型推断"""
17.  
18. def build_call_graph(self, functions: List[FunctionInfo]) -> CallGraph:
19. """构建调用图"""

3.3 转换引擎模块 (TransformEngine)

职责: 执行Python到C++的转换逻辑

1. class TransformEngine:
2. """
3. 转换引擎
4.  
5. 职责:
6. 1. 应用转换规则
7. 2. 处理特殊情况
8. 3. 协调各子模块
9. """
10.  
11. def transform(self, analysis_result: AnalysisResult,
12. config: ConversionConfig) -> TransformResult:
13. """执行转换"""
14.  
15. def apply_rules(self, feature: CodeFeature,
16. context: TransformContext) -> TransformAction:
17. """应用转换规则"""

3.4 输出生成模块 (OutputGenerator)

职责: 生成格式化的C++代码

1. class OutputGenerator:
2. """
3. 输出生成器
4.  
5. 职责:
6. 1. 代码格式化
7. 2. 头文件管理
8. 3. 注释添加
9. 4. 代码组织
10. """
11.  
12. def generate(self, transform_result: TransformResult,
13. config: OutputConfig) -> str:
14. """生成C++代码"""
15.  
16. def format_code(self, cpp_code: str) -> str:
17. """格式化代码"""
18.  
19. def organize_headers(self, used_features: Set[str]) -> List[str]:
20. """组织头文件"""

---

4. 数据流设计

4.1 主数据流

1. ┌─────────────┐
2. │ Python Code │
3. └──────┬──────┘
4. │
5. ▼
6. ┌──────────────────────────────────────┐
7. │ Stage 1: Parsing │
8. │ Input: str (Python source) │
9. │ Output: ParsedInput │
10. └──────────────────┬───────────────────┘
11. │
12. ▼
13. ┌──────────────────────────────────────┐
14. │ Stage 2: Analysis │
15. │ Input: ParsedInput │
16. │ Output: AnalysisResult │
17. │ - type_map │
18. │ - call_graph │
19. │ - control_flow │
20. └──────────────────┬───────────────────┘
21. │
22. ▼
23. ┌──────────────────────────────────────┐
24. │ Stage 3: Transform │
25. │ Input: AnalysisResult + Config │
26. │ Output: TransformResult │
27. │ - cpp_ast │
28. │ - headers │
29. │ - notes │
30. └──────────────────┬───────────────────┘
31. │
32. ▼
33. ┌──────────────────────────────────────┐
34. │ Stage 4: Generate │
35. │ Input: TransformResult + Config │
36. │ Output: str (C++ source) │
37. └──────────────────┬───────────────────┘
38. │
39. ▼
40. ┌─────────────┐
41. │ C++ Code │
42. └─────────────┘

4.2 GLM-4 API 调用流程

1. Build Prompt
2. │
3. ├─▶ System Prompt: 专业的Python到C++11转换专家指令
4. │
5. └─▶ User Prompt: Python代码 + 转换选项
6. │
7. ▼
8. API Request
9. │
10. ├─▶ model: "glm-4"
11. ├─▶ messages: [system, user]
12. ├─▶ temperature: 0.3
13. └─▶ max_tokens: 4096
14. │
15. ▼
16. GLM-4 Processing
17. │
18. ├─▶ Parse Code
19. ├─▶ Apply Rules
20. └─▶ Generate C++
21. │
22. ▼
23. API Response
24. │
25. └─▶ Extract C++ Code
26. │
27. ├─▶ Strip Markdown
28. └─▶ Validate

---

5. API接口设计

5.1 REST API 设计

端点 1: 代码转换

1. POST /api/convert
2. Content-Type: application/json
3.  
4. Request Body:
5. {
6. "pythonCode": "string",
7. "options": {
8. "useSmartPointers": true,
9. "useOptional": true,
10. "useAuto": true,
11. "addComments": true,
12. "preserveDocstrings": true,
13. "useNamespaces": true,
14. "includeHeaders": true
15. }
16. }
17.  
18. Response Body:
19. {
20. "success": true,
21. "cppCode": "string",
22. "conversionNotes": ["..."],
23. "headersIncluded": ["<vector>"],
24. "warnings": [],
25. "metadata": {
26. "originalLines": 10,
27. "generatedLines": 15,
28. "conversionTimeMs": 2500
29. }
30. }

5.2 TypeScript SDK 接口

1. export interface PythonToCppConverter {
2. convert(code: string, options?: ConversionOptions): Promise<ConversionResult>;
3. convertBatch(files: CodeFile[], options?: ConversionOptions): Promise<BatchResult>;
4. convertStream(code: string, options?: ConversionOptions): AsyncIterable<ConversionChunk>;
5. validate(cppCode: string): Promise<ValidationResult>;
6. }
7.  
8. export interface ConversionOptions {
9. useSmartPointers?: boolean;
10. useOptional?: boolean;
11. useAuto?: boolean;
12. addComments?: boolean;
13. preserveDocstrings?: boolean;
14. useNamespaces?: boolean;
15. includeHeaders?: boolean;
16. outputFormat?: 'compact' | 'readable' | 'documented';
17. cppStandard?: 'c++11' | 'c++14' | 'c++17' | 'c++20';
18. }

5.3 CLI 接口设计

1. # 基本用法
2. python convert.py --input input.py --output output.cpp
3.  
4. # 完整参数
5. python convert.py \
6. --input input.py \
7. --output output.cpp \
8. --use-smart-pointers \
9. --add-comments \
10. --verbose \
11. --api-key <key>
12.  
13. # 管道模式
14. cat script.py | python convert.py > output.cpp
15.  
16. # 批量模式
17. python convert.py --batch --input-dir ./src --output-dir ./cpp_src

---

6. 转换规则引擎

6.1 规则定义格式

1. rules:
2. - id: "type-int-conversion"
3. name: "整数类型转换"
4. category: "type"
5. priority: 100
6. condition:
7. python_type: "int"
8. action:
9. cpp_type: "int64_t"
10. headers: ["<cstdint>"]
11.  
12. - id: "list-to-vector"
13. name: "列表转向量"
14. category: "container"
15. priority: 90
16. condition:
17. python_type: "list"
18. action:
19. cpp_type: "std::vector<{element_type}>"
20. headers: ["<vector>"]

6.2 核心转换规则表

Python特性	C++11转换	规则ID	优先级	头文件
int	int64_t	type-int	100	<cstdint>
float	double	type-float	100	-
str	std::string	type-str	100	<string>
bool	bool	type-bool	100	-
list	std::vector<T>	container-list	90	<vector>
dict	std::unordered_map<K,V>	container-dict	90	<unordered_map>
set	std::unordered_set<T>	container-set	90	<unordered_set>
tuple	std::tuple<Args...>	container-tuple	90	<tuple>
lambda	[](){}	expr-lambda	80	<functional>
def	函数声明	func-def	70	-
class	类声明	class-def	70	-
for...in	range-based for	loop-for	60	-
try/except	try/catch	except	60	<stdexcept>
with	RAII	raii	50	-
yield	迭代器类	generator	40	-

---

7. 类型系统设计

7.1 Python类型到C++类型映射

1. interface TypeMapping {
2. primitiveTypes: {
3. 'int': 'int64_t',
4. 'float': 'double',
5. 'str': 'std::string',
6. 'bool': 'bool',
7. 'None': 'nullptr',
8. 'bytes': 'std::vector<uint8_t>',
9. };
10.  
11. containerTypes: {
12. 'list<T>': 'std::vector<T>',
13. 'dict<K,V>': 'std::unordered_map<K,V>',
14. 'set<T>': 'std::unordered_set<T>',
15. 'tuple<T...>': 'std::tuple<T...>',
16. };
17.  
18. specialTypes: {
19. 'Optional<T>': 'std::optional<T>',
20. 'Union<T,U>': 'std::variant<T,U>',
21. 'Callable<Args,Ret>': 'std::function<Ret(Args...)>',
22. 'Any': 'auto',
23. };
24. }

7.2 类型推断算法

1. 算法: 类型推断
2.  
3. function inferType(expression, context):
4. // 1. 检查显式类型注解
5. if expression has type annotation:
6. return mapType(expression.annotation)
7.  
8. // 2. 根据表达式类型推断
9. switch expression.type:
10. case Literal:
11. return inferLiteralType(expression.value)
12.  
13. case Variable:
14. return context.getVariableType(expression.name)
15.  
16. case BinaryOp:
17. leftType = inferType(expression.left, context)
18. rightType = inferType(expression.right, context)
19. return inferBinaryOpType(leftType, rightType, expression.op)
20.  
21. case FunctionCall:
22. funcType = inferType(expression.func, context)
23. return funcType.returnType
24.  
25. case ListLiteral:
26. elementType = unifyTypes([...])
27. return f"std::vector<{elementType}>"
28.  
29. // 3. 默认返回auto
30. return "auto"

---

8. 代码生成策略

8.1 代码组织策略

1. // 生成的C++代码结构模板
2.  
3. // ========== 1. 头文件部分 ==========
4. #include <algorithm>
5. #include <chrono>
6. #include <functional>
7. #include <iostream>
8. #include <memory>
9. #include <string>
10. #include <unordered_map>
11. #include <vector>
12.  
13. // ========== 2. 命名空间部分 ==========
14. namespace python_converted {
15.  
16. // ========== 3. 前向声明部分 ==========
17. class MyClass;
18. void helper_function();
19.  
20. // ========== 4. 常量定义部分 ==========
21. const int kMaxSize = 100;
22. constexpr double kPi = 3.14159265358979;
23.  
24. // ========== 5. 类型定义部分 ==========
25. using StringMap = std::unordered_map<std::string, std::string>;
26.  
27. // ========== 6. 类定义部分 ==========
28. class MyClass {
29. public:
30. MyClass();
31. ~MyClass();
32. void public_method();
33. private:
34. int private_member_;
35. void private_method();
36. };
37.  
38. // ========== 7. 函数实现部分 ==========
39. void MyClass::public_method() { /* ... */ }
40.  
41. // ========== 8. 工具函数部分 ==========
42. void helper_function() { /* ... */ }
43.  
44. } // namespace python_converted
45.  
46. // ========== 9. main函数（可选） ==========
47. int main(int argc, char* argv[]) {
48. return 0;
49. }

8.2 命名转换策略

Python风格	C++风格	示例
snake_case (函数)	camelCase	get_value → getValue
snake_case (成员)	snakecase	count → count_
PascalCase (类)	PascalCase	MyClass → MyClass
UPPER_CASE (常量)	kUpperCase	MAX_SIZE → kMaxSize

8.3 注释生成策略

1. /**
2. * Python文档字符串转换规则:
3. *
4. * Python:
5. * """Calculate the sum.
6. *
7. * Args:
8. * a: First number
9. * b: Second number
10. * """
11. *
12. * C++:
13. * /**
14. * * Calculate the sum.
15. * *
16. * * @param a First number
17. * * @param b Second number
18. * * @return Sum of a and b
19. * */
20. */

---

9. 错误处理机制

9.1 错误分类

类别	错误类型	可恢复	处理策略
输入错误	INPUT_INVALID	否	返回错误信息
输入错误	INPUT_SYNTAX_ERROR	否	提示修正语法
转换错误	TYPE_INFERENCE_FAILED	是	使用auto + TODO注释
转换错误	UNSUPPORTED_FEATURE	是	生成占位代码
API错误	API_CONNECTION_ERROR	是	重试(最多3次)
API错误	API_TIMEOUT	是	增加超时时间
API错误	API_RATE_LIMIT	是	等待后重试
输出错误	OUTPUT_GENERATION_FAILED	否	返回详细错误

9.2 错误恢复示例

1. # 类型推断失败
2. Python: x = some_unknown_function()
3. C++: auto x = some_unknown_function(); // TODO: 确认类型
4.  
5. # 不支持的特性
6. Python: exec("print('hello')")
7. C++: // TODO: Python exec() 暂不支持转换
8. // 建议替代方案: 直接调用函数

---

10. 性能优化设计

10.1 性能指标

指标	目标值	测量方法
单文件转换延迟	< 5秒 (100行)	端到端计时
API调用延迟	< 3秒	API计时
内存占用	< 200MB	进程内存监控
并发处理能力	10个请求/秒	压力测试

10.2 缓存策略

1. class CacheManager:
2. """
3. 三级缓存:
4. 1. 代码哈希缓存: 避免重复转换
5. 2. API响应缓存: 缓存GLM-4响应
6. 3. 类型推断缓存: 缓存类型推断结果
7. """
8.  
9. def get_cached_result(self, python_code: str) -> Optional[str]:
10. cache_key = compute_hash(python_code)
11. return cache.get(cache_key)

10.3 性能基准

测试场景	代码行数	平均延迟	内存占用
简单函数	10行	0.5s	50MB
中等复杂度	100行	2s	100MB
复杂类结构	500行	8s	180MB
大型模块	1000行	20s	250MB

---

11. 扩展性设计

11.1 插件系统

1. class PluginSystem:
2. """
3. 支持的扩展点:
4. 1. PreProcessor: 输入预处理
5. 2. Analyzer: 自定义分析
6. 3. Transformer: 自定义转换
7. 4. PostProcessor: 输出后处理
8. 5. Validator: 自定义验证
9. """
10.  
11. def register_plugin(self, plugin: Plugin) -> None:
12. self.plugins[plugin.extension_point].append(plugin)
13.  
14. def execute_plugins(self, extension_point: str, data: Any) -> Any:
15. for plugin in self.plugins.get(extension_point, []):
16. data = plugin.execute(data)
17. return data

11.2 自定义规则扩展

1. # YAML规则文件示例
2. rules:
3. - id: "custom-rule-1"
4. name: "自定义转换规则"
5. condition:
6. python_pattern: "custom_function"
7. action:
8. cpp_template: "customCppFunction({args})"

11.3 多语言支持

1. class LanguageAdapter:
2. """语言适配器基类"""
3.  
4. @abstractmethod
5. def get_type_mapping(self) -> Dict[str, str]:
6. """获取类型映射"""
7. pass
8.  
9. @abstractmethod
10. def get_syntax_rules(self) -> List[Rule]:
11. """获取语法规则"""
12. pass
13.  
14. # 扩展到Rust
15. class RustAdapter(LanguageAdapter):
16. def get_type_mapping(self) -> Dict[str, str]:
17. return {
18. 'int': 'i64',
19. 'float': 'f64',
20. 'str': 'String',
21. 'list': 'Vec<T>',
22. }

---

12. 安全性设计

12.1 API密钥安全

1. class SecureConfig:
2. """
3. API密钥获取优先级:
4. 1. 环境变量 GLM_API_KEY
5. 2. 配置文件 ~/.python-to-cpp/config
6. 3. 运行时参数
7.  
8. 注意: 永远不要在日志中暴露密钥
9. """
10.  
11. def get_api_key(self) -> str:
12. # 1. 检查环境变量
13. key = os.environ.get('GLM_API_KEY')
14. if key:
15. return key
16.  
17. # 2. 检查配置文件
18. config_path = Path.home() / '.python-to-cpp' / 'config'
19. if config_path.exists():
20. config = json.loads(config_path.read_text())
21. return config.get('api_key')
22.  
23. raise ConfigurationError("API密钥未配置")

12.2 输入验证

1. class InputValidator:
2. """输入验证器"""
3.  
4. def validate(self, python_code: str) -> ValidationResult:
5. result = ValidationResult()
6.  
7. # 长度检查
8. if len(python_code) > 100000: # 100KB
9. result.add_error("代码长度超过限制")
10.  
11. # 敏感内容检测
12. sensitive_patterns = [
13. r'password\s*=',
14. r'api_key\s*=',
15. r'secret\s*=',
16. ]
17. for pattern in sensitive_patterns:
18. if re.search(pattern, python_code, re.IGNORECASE):
19. result.add_warning(f"检测到可能的敏感内容")
20.  
21. return result

12.3 输出清理

1. class OutputSanitizer:
2. """输出清理器"""
3.  
4. def sanitize(self, cpp_code: str) -> str:
5. # 移除可能的shell命令注入
6. dangerous_patterns = [
7. r'system\s*\(',
8. r'popen\s*\(',
9. r'exec[vl]?[pe]?\s*\(',
10. ]
11.  
12. for pattern in dangerous_patterns:
13. cpp_code = re.sub(pattern, '/* removed */', cpp_code)
14.  
15. return cpp_code

---

13. 测试策略

13.1 测试层次

1. ┌─────────────────────────────────────┐
2. │ E2E Tests (端到端测试) │
3. │ - 完整转换流程测试 │
4. └─────────────────────────────────────┘
5. │
6. ┌─────────────────────────────────────┐
7. │ Integration Tests (集成测试) │
8. │ - API集成测试 │
9. │ - 模块间交互测试 │
10. └─────────────────────────────────────┘
11. │
12. ┌─────────────────────────────────────┐
13. │ Unit Tests (单元测试) │
14. │ - 每个函数/类独立测试 │
15. │ - 边界条件测试 │
16. └─────────────────────────────────────┘
17. │
18. ┌─────────────────────────────────────┐
19. │ Property Tests (属性测试) │
20. │ - 随机生成测试用例 │
21. │ - 不变量验证 │
22. └─────────────────────────────────────┘

13.2 测试用例分类

类别	数量	覆盖内容
基本类型转换	20+	int, float, str, bool等
容器转换	15+	list, dict, set, tuple
函数转换	25+	普通函数, lambda, 递归
类转换	20+	类定义, 继承, 方法
控制流	15+	if, for, while, try
高级特性	15+	装饰器, 生成器, 异步
边界情况	10+	空代码, 超长代码等
错误处理	10+	各类错误场景

---

14. 部署方案

14.1 部署架构

1. ┌───────────────────────────────────────────┐
2. │ 负载均衡器 │
3. │ (Nginx / AWS ALB) │
4. └───────────────────┬───────────────────────┘
5. │
6. ┌───────────────┼───────────────┐
7. │ │ │
8. ▼ ▼ ▼
9. ┌────────┐ ┌────────┐ ┌────────┐
10. │Inst #1 │ │Inst #2 │ │Inst #3 │
11. └───┬────┘ └───┬────┘ └───┬────┘
12. │ │ │
13. └─────────────┼─────────────┘
14. │
15. ▼
16. ┌─────────────────┐
17. │ Redis Cache │
18. └─────────────────┘

14.2 Docker部署

1. FROM python:3.11-slim
2.  
3. RUN pip install requests pyyaml
4.  
5. COPY . /app
6. WORKDIR /app
7.  
8. ENV GLM_API_KEY=""
9. ENV LOG_LEVEL="INFO"
10.  
11. HEALTHCHECK --interval=30s --timeout=10s \
12. CMD curl -f http://localhost:3000/health || exit 1
13.  
14. CMD ["python", "scripts/server.py"]

14.3 Kubernetes部署

1. apiVersion: apps/v1
2. kind: Deployment
3. metadata:
4. name: python-to-cpp-converter
5. spec:
6. replicas: 3
7. template:
8. spec:
9. containers:
10. - name: converter
11. image: python-to-cpp:latest
12. ports:
13. - containerPort: 3000
14. env:
15. - name: GLM_API_KEY
16. valueFrom:
17. secretKeyRef:
18. name: api-secrets
19. key: glm-api-key
20. resources:
21. requests:
22. memory: "256Mi"
23. cpu: "500m"
24. limits:
25. memory: "512Mi"
26. cpu: "1000m"

14.4 监控指标

指标名称	类型	描述
conversion_requests_total	Counter	总转换请求数
conversion_duration_seconds	Histogram	转换耗时分布
conversion_errors_total	Counter	转换错误总数
api_calls_total	Counter	API调用总数

---

附录

A. 配置文件模板

1. {
2. "version": "1.0",
3. "api": {
4. "key": "${GLM_API_KEY}",
5. "url": "https://open.bigmodel.cn/api/paas/v4/chat/completions",
6. "model": "glm-4",
7. "timeout": 60,
8. "retry": 3
9. },
10. "conversion": {
11. "useSmartPointers": true,
12. "useOptional": true,
13. "useAuto": true,
14. "addComments": true,
15. "preserveDocstrings": true,
16. "useNamespaces": true,
17. "includeHeaders": true
18. },
19. "cache": {
20. "enabled": true,
21. "maxSize": 1000,
22. "ttl": 3600
23. }
24. }

B. 错误代码表

错误代码	描述	解决方案
E001	输入代码为空	提供有效的Python代码
E002	Python语法错误	修正Python语法
E003	类型推断失败	添加类型注解
E004	不支持的特性	查看支持列表
E101	API连接失败	检查网络连接
E102	API超时	增加超时时间
E103	API限流	稍后重试
E104	API密钥无效	检查API密钥配置

C. 依赖列表

1. Python 3.8+
2. requests >= 2.28.0
3. PyYAML >= 6.0
4. typing_extensions >= 4.0
5.  
6. Node.js 18+ (用于TypeScript API)
7. typescript >= 5.0

---

文档结束

版本: v1.0.0
最后更新: 2026-03-26