AutoCython-zhang 2.3.5__tar.gz → 2.3.7__tar.gz

{autocython_zhang-2.3.5 → autocython_zhang-2.3.7}/AutoCython/_version.py

@@ -2,4 +2,4 @@
 # -*- coding: utf-8 -*-
 """版本号模块 - 单一版本号来源"""
 
-__version__ = "2.3.5"
+__version__ = "2.3.7"

{autocython_zhang-2.3.5 → autocython_zhang-2.3.7}/AutoCython/obfuscate.py

@@ -1,4 +1,8 @@
-"""AST 混淆模块：去 docstring、去 annotation、局部变量重命名、字符串加密、常量折叠、控制流平坦化、虚假分支"""
+"""AST 混淆模块：去 docstring、局部变量重命名、字符串加密、常量折叠、控制流平坦化、虚假分支。
+
+注解（annotation）默认完整保留，以兼容 FastAPI/Pydantic/dataclass/attrs 等依赖运行时
+``__annotations__`` 的框架；字符串与常量混淆会跳过 annotation 子树。
+"""
 import ast
 import copy
 import hashlib
@@ -6,6 +10,16 @@ import random
 
 _UNSAFE_CALLS = frozenset({'globals', 'locals', 'eval', 'exec', 'vars'})
 _PATTERN_SKIP_ATTR = '_autocython_skip_literal_obf'
+_SCOPE_BOUNDARY_NODES = (
+    ast.FunctionDef,
+    ast.AsyncFunctionDef,
+    ast.ClassDef,
+    ast.Lambda,
+    ast.ListComp,
+    ast.SetComp,
+    ast.DictComp,
+    ast.GeneratorExp,
+)
 
 
 def _has_unsafe_call(node):
@@ -21,14 +35,18 @@ def _has_unsafe_call(node):
 
 
 def _walk_no_nested_scope(body):
-    """遍历 body 中的节点，不穿透嵌套函数/类定义"""
+    """遍历 body 中的节点，不穿透嵌套词法作用域。
+
+    Python 3 中 lambda 与各类 comprehension 也会创建独立词法作用域。
+    局部变量重命名若穿透这些节点，容易把 ``lambda e: ...`` 的参数
+    与外层 ``for e in ...`` 的重命名混在一起，生成
+    ``free variable ... referenced before assignment`` 一类运行时错误。
+    """
     for node in body:
         yield node
-        if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)):
+        if isinstance(node, _SCOPE_BOUNDARY_NODES):
             continue
         for child in ast.iter_child_nodes(node):
-            if isinstance(child, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)):
-                continue
             yield from _walk_no_nested_scope([child])
 
 
@@ -49,6 +67,34 @@ def _mark_pattern_constants(pattern):
             setattr(child, _PATTERN_SKIP_ATTR, True)
 
 
+def _mark_annotation_constants(tree):
+    """标记 annotation 子树内常量，避免字符串加密/常量折叠改变运行时注解语义。"""
+
+    def mark(node):
+        if node is None:
+            return
+        for child in ast.walk(node):
+            if isinstance(child, ast.Constant):
+                setattr(child, _PATTERN_SKIP_ATTR, True)
+
+    def mark_arg_annotations(args):
+        all_args = args.posonlyargs + args.args + args.kwonlyargs
+        if args.vararg:
+            all_args.append(args.vararg)
+        if args.kwarg:
+            all_args.append(args.kwarg)
+        for arg in all_args:
+            mark(arg.annotation)
+
+    for node in ast.walk(tree):
+        if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+            mark_arg_annotations(node.args)
+            mark(node.returns)
+        elif isinstance(node, ast.AnnAssign):
+            mark(node.annotation)
+    return tree
+
+
 class _DocstringRemover(ast.NodeTransformer):
     """移除 module/class/function 首部的 docstring"""
 
@@ -74,80 +120,151 @@ class _DocstringRemover(ast.NodeTransformer):
         return self._strip_docstring(node)
 
 
-class _AnnotationRemover(ast.NodeTransformer):
-    """清除非类体内的变量注解。
-    保留函数参数/返回值注解和类体内注解赋值，
-    因为 FastAPI/Pydantic/dataclass/attrs 等框架在运行时依赖 __annotations__。"""
+def _collect_names(nodes, ctx_type, *, skip_nested=True):
+    """收集一组节点中的 Name；默认不穿透新的词法作用域。"""
+    names = set()
+    walker = _walk_no_nested_scope(nodes) if skip_nested else ast.walk(ast.Module(body=list(nodes), type_ignores=[]))
+    for child in walker:
+        if isinstance(child, ast.Name) and isinstance(child.ctx, ctx_type):
+            names.add(child.id)
+    return names
+
+
+def _collect_argument_names(args):
+    """收集函数/lambda 参数名。"""
+    names = set()
+    for arg in args.args + args.posonlyargs + args.kwonlyargs:
+        names.add(arg.arg)
+    if args.vararg:
+        names.add(args.vararg.arg)
+    if args.kwarg:
+        names.add(args.kwarg.arg)
+    return names
+
+
+def _collect_argument_expression_nodes(args):
+    """收集默认值与注解表达式，它们在外层作用域求值。"""
+    nodes = []
+    nodes.extend(args.defaults)
+    nodes.extend(default for default in args.kw_defaults if default is not None)
+    all_args = args.posonlyargs + args.args + args.kwonlyargs
+    if args.vararg:
+        all_args.append(args.vararg)
+    if args.kwarg:
+        all_args.append(args.kwarg)
+    for arg in all_args:
+        if arg.annotation is not None:
+            nodes.append(arg.annotation)
+    return nodes
+
+
+def _collect_nonlocal_global_names(body):
+    """收集当前作用域直接声明的 nonlocal/global 名称。"""
+    nonlocal_names = set()
+    global_names = set()
+    for child in _walk_no_nested_scope(body):
+        if isinstance(child, ast.Nonlocal):
+            nonlocal_names.update(child.names)
+        elif isinstance(child, ast.Global):
+            global_names.update(child.names)
+    return nonlocal_names, global_names
+
+
+def _collect_direct_bound_names(body):
+    """收集当前作用域直接绑定的名称，不穿透嵌套作用域。"""
+    bound = _collect_names(body, ast.Store)
+    for child in _walk_no_nested_scope(body):
+        if isinstance(child, ast.ExceptHandler) and child.name:
+            bound.add(child.name)
+        elif isinstance(child, (ast.Import, ast.ImportFrom)):
+            for alias in child.names:
+                bound.add(alias.asname or alias.name.split('.', 1)[0])
+    return bound
+
+
+def _collect_load_names_no_nested(nodes):
+    """收集 Load 名称，不穿透嵌套作用域。"""
+    return _collect_names(nodes, ast.Load)
+
+
+def _collect_nested_scope_nodes(body):
+    """收集 body 中的直接/间接嵌套词法作用域节点。"""
+    nested = []
+    for node in body:
+        if isinstance(node, _SCOPE_BOUNDARY_NODES):
+            nested.append(node)
+            continue
+        for child in ast.iter_child_nodes(node):
+            if isinstance(child, _SCOPE_BOUNDARY_NODES):
+                nested.append(child)
+            else:
+                nested.extend(_collect_nested_scope_nodes([child]))
+    return nested
 
-    def __init__(self):
-        self._scope_stack = ['module']
 
-    def visit_FunctionDef(self, node):
-        self._scope_stack.append('function')
-        self.generic_visit(node)
-        self._scope_stack.pop()
-        return node
+def _collect_function_like_free_refs(node, local_names):
+    """收集嵌套函数/lambda 中引用的外层变量名。"""
+    body = node.body if isinstance(node.body, list) else [node.body]
+    param_names = _collect_argument_names(node.args)
+    nonlocal_names, global_names = _collect_nonlocal_global_names(body)
+    nested_locals = _collect_direct_bound_names(body)
+    nested_locals.update(param_names)
+    nested_locals -= nonlocal_names
 
-    visit_AsyncFunctionDef = visit_FunctionDef
+    free = set()
+    outer_expr_nodes = _collect_argument_expression_nodes(node.args)
+    if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+        outer_expr_nodes.extend(node.decorator_list)
+        if node.returns is not None:
+            outer_expr_nodes.append(node.returns)
+    free.update(_collect_load_names_no_nested(outer_expr_nodes) & local_names)
+
+    for name in _collect_load_names_no_nested(body):
+        if name in local_names and name not in nested_locals and name not in global_names:
+            free.add(name)
+
+    free.update(_collect_nested_free_refs(body, local_names))
+    return free
 
-    def visit_ClassDef(self, node):
-        self._scope_stack.append('class')
-        self.generic_visit(node)
-        self._scope_stack.pop()
-        if not node.body:
-            node.body.append(ast.Pass())
-        return node
 
-    def visit_AnnAssign(self, node):
-        self.generic_visit(node)
-        # 类体内的注解赋值必须保留（Pydantic/dataclass 等框架依赖 __annotations__）
-        if self._scope_stack[-1] == 'class':
-            return node
-        if node.value is not None:
-            return ast.Assign(targets=[node.target], value=node.value,
-                              lineno=node.lineno, col_offset=node.col_offset)
-        return None  # 纯注解无赋值，直接删除
+def _collect_class_free_refs(node, local_names):
+    """收集嵌套类体中直接引用的外层变量名。"""
+    free = set()
+    outer_expr_nodes = list(node.decorator_list)
+    outer_expr_nodes.extend(node.bases)
+    outer_expr_nodes.extend(keyword.value for keyword in node.keywords)
+    free.update(_collect_load_names_no_nested(outer_expr_nodes) & local_names)
+
+    for name in _collect_load_names_no_nested(node.body):
+        if name in local_names:
+            free.add(name)
+    free.update(_collect_nested_free_refs(node.body, local_names))
+    return free
+
+
+def _collect_comprehension_free_refs(node, local_names):
+    """保守收集 comprehension 中对外层变量的引用。
+
+    comprehension 是隐式函数作用域；为避免 Cython/CPython 闭包细节差异，
+    只要其中出现外层局部名，就将该外层名排除出重命名集合。
+    """
+    free = set()
+    for child in ast.walk(node):
+        if isinstance(child, ast.Name) and isinstance(child.ctx, ast.Load) and child.id in local_names:
+            free.add(child.id)
+    return free
 
 
 def _collect_nested_free_refs(body, local_names):
-    """收集嵌套函数/类中引用的外层变量名（闭包变量）"""
+    """收集嵌套词法作用域中引用的外层变量名（闭包变量）"""
     free = set()
-    for node in body:
-        if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
-            # 嵌套函数自己的局部名
-            nested_locals = set()
-            # nonlocal/global 声明的变量不是局部变量
-            nonlocal_names = set()
-            for child in _walk_no_nested_scope(node.body):
-                if isinstance(child, (ast.Nonlocal, ast.Global)):
-                    nonlocal_names.update(child.names)
-            for arg in node.args.args + node.args.posonlyargs + node.args.kwonlyargs:
-                nested_locals.add(arg.arg)
-            if node.args.vararg:
-                nested_locals.add(node.args.vararg.arg)
-            if node.args.kwarg:
-                nested_locals.add(node.args.kwarg.arg)
-            for child in _walk_no_nested_scope(node.body):
-                if isinstance(child, ast.Name) and isinstance(child.ctx, ast.Store):
-                    if child.id not in nonlocal_names:
-                        nested_locals.add(child.id)
-            # 嵌套函数中读取的、属于外层 local_names 且不被自身遮蔽的名字
-            for child in ast.walk(node):
-                if isinstance(child, ast.Name) and child.id in local_names and child.id not in nested_locals:
-                    free.add(child.id)
+    for node in _collect_nested_scope_nodes(body):
+        if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef, ast.Lambda)):
+            free.update(_collect_function_like_free_refs(node, local_names))
         elif isinstance(node, ast.ClassDef):
-            # 类体中直接引用的外层变量
-            for child in _walk_no_nested_scope(node.body):
-                if isinstance(child, ast.Name) and child.id in local_names and isinstance(child.ctx, ast.Load):
-                    free.add(child.id)
-            free |= _collect_nested_free_refs(node.body, local_names)
-        else:
-            # 递归搜索所有子节点中的嵌套函数/类（穿透 Try/With/For/If 等）
-            for child in ast.walk(node):
-                if child is node:
-                    continue
-                if isinstance(child, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)):
-                    free |= _collect_nested_free_refs([child], local_names)
+            free.update(_collect_class_free_refs(node, local_names))
+        elif isinstance(node, (ast.ListComp, ast.SetComp, ast.DictComp, ast.GeneratorExp)):
+            free.update(_collect_comprehension_free_refs(node, local_names))
     return free
 
 
@@ -167,26 +284,20 @@ class _LocalVarRenamer(ast.NodeTransformer):
 
         # 收集参数名（不重命名）
         param_names = set()
-        for arg in node.args.args + node.args.posonlyargs + node.args.kwonlyargs:
-            param_names.add(arg.arg)
-        if node.args.vararg:
-            param_names.add(node.args.vararg.arg)
-        if node.args.kwarg:
-            param_names.add(node.args.kwarg.arg)
+        param_names.update(_collect_argument_names(node.args))
 
         # 收集局部赋值目标（不穿透嵌套作用域）
         local_names = set()
         # 排除 nonlocal/global 声明的变量
-        nonlocal_names = set()
+        nonlocal_names, global_names = _collect_nonlocal_global_names(node.body)
+        excluded_scope_names = nonlocal_names | global_names
         for child in _walk_no_nested_scope(node.body):
-            if isinstance(child, (ast.Nonlocal, ast.Global)):
-                nonlocal_names.update(child.names)
             if isinstance(child, ast.Name) and isinstance(child.ctx, ast.Store):
                 name = child.id
-                if (name not in param_names and name != 'self' and name != 'cls'
+                if (name not in param_names and name not in excluded_scope_names
+                        and name != 'self' and name != 'cls'
                         and not name.startswith('__')):
                     local_names.add(name)
-        local_names -= nonlocal_names
 
         if not local_names:
             self.generic_visit(node)
@@ -482,8 +593,9 @@ class _OpaquePredicateInserter(ast.NodeTransformer):
 
 
 def obfuscate_source(source_code: str, seed=None) -> str:
-    """对源码执行七重 AST 变换：去 docstring、去 annotation、局部变量重命名、
+    """对源码执行六重 AST 变换：去 docstring、局部变量重命名、
     字符串加密、常量折叠、控制流平坦化、虚假分支。
+    函数、类和局部变量 annotation 默认保留。
     ast.unparse() 天然丢弃所有注释。
 
     :param seed: 随机种子；传入后可复现混淆结果
@@ -493,10 +605,10 @@ def obfuscate_source(source_code: str, seed=None) -> str:
     rng = random.Random(seed) if seed is not None else random
     tree = ast.parse(source_code)
     tree = _DocstringRemover().visit(tree)
-    tree = _AnnotationRemover().visit(tree)
     tree = _LocalVarRenamer().visit(tree)
     tree = _ControlFlowFlattener(rng=rng).visit(tree)
     tree = _OpaquePredicateInserter(rng=rng).visit(tree)
+    tree = _mark_annotation_constants(tree)
     tree = _StringEncryptor(rng=rng).visit(tree)
     tree = _ConstantFoldingObfuscator(rng=rng).visit(tree)
     ast.fix_missing_locations(tree)

{autocython_zhang-2.3.5 → autocython_zhang-2.3.7}/AutoCython_zhang.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: AutoCython-zhang
-Version: 2.3.5
+Version: 2.3.7
 Summary: 自动Cython，使用Cython批量编译.py文件为.pyd文件！
 Author-email: zhang_gavin <qq814608@163.com>
 License-Expression: MIT
@@ -20,7 +20,7 @@ Dynamic: license-file
 
 # AutoCython
 
-> 自动将 Python 源码编译为 Cython 二进制扩展（`.so`/`.pyd`），支持七重 AST 混淆、并发编译、跨平台运行。
+> 自动将 Python 源码编译为 Cython 二进制扩展（`.so`/`.pyd`），支持六重 AST 混淆、并发编译、跨平台运行。
 
 [![PyPI](https://img.shields.io/pypi/v/AutoCython-zhang)](https://pypi.org/project/AutoCython-zhang/)
 [![Python](https://img.shields.io/pypi/pyversions/AutoCython-zhang)](https://pypi.org/project/AutoCython-zhang/)
@@ -33,7 +33,7 @@ AutoCython 是一个 Python 源码保护工具，通过 Cython 编译 + AST 混
 ## 特性
 
 - **一键编译** — 单文件 (`-f`) 或整目录 (`-p`) 批量编译为 `.so`/`.pyd`
-- **七重 AST 混淆** — docstring 移除、注解清除、局部变量重命名、字符串 XOR 加密、常量折叠、控制流平坦化、虚假分支注入
+- **六重 AST 混淆** — docstring 移除、局部变量重命名、字符串 XOR 加密、常量折叠、控制流平坦化、虚假分支注入；默认完整保留运行时 annotation，兼容 FastAPI / Pydantic / dataclass
 - **并发编译** — 基于 `ThreadPoolExecutor` 的多线程并行编译，可配置并发数
 - **实时进度面板** — 基于 Rich 的实时任务状态表格、进度条、耗时统计
 - **跨平台** — 支持 Linux、macOS、Windows，自动适配 `.so`/`.pyd` 扩展名
@@ -108,7 +108,7 @@ print(f"生成: {output}")
 |------|------|------|
 | `compile()` | `AutoCython.AutoCython` | 主入口：解析参数并调度编译任务 |
 | `compile_to_binary()` | `AutoCython.compile` | 将单个 `.py` 文件编译为二进制扩展 |
-| `obfuscate_source()` | `AutoCython.obfuscate` | 对源码执行七重 AST 混淆变换 |
+| `obfuscate_source()` | `AutoCython.obfuscate` | 对源码执行六重 AST 混淆变换，并保留运行时 annotation |
 | `run_tasks()` | `AutoCython.run_tasks` | 并发任务执行引擎（含实时进度面板） |
 | `find_python_files()` | `AutoCython.tools` | 递归扫描目录下的可编译 `.py` 文件 |
 | `parse_arguments()` | `AutoCython.tools` | CLI 参数解析（中英双语） |
@@ -124,7 +124,7 @@ AutoCython/
 │   ├── _version.py          # 单一版本号来源
 │   ├── AutoCython.py        # 主编译调度逻辑
 │   ├── compile.py           # Cython 编译核心（临时目录隔离）
-│   ├── obfuscate.py         # 七重 AST 混淆引擎
+│   ├── obfuscate.py         # 六重 AST 混淆引擎
 │   ├── run_tasks.py         # 并发任务执行 + Rich 实时面板
 │   └── tools.py             # CLI 参数解析、文件扫描、国际化
 ├── tests/

{autocython_zhang-2.3.5 → autocython_zhang-2.3.7}/AutoCython_zhang.egg-info/top_level.txt

@@ -1,3 +1,2 @@
 AutoCython
 dist
-release_dist

{autocython_zhang-2.3.5 → autocython_zhang-2.3.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: AutoCython-zhang
-Version: 2.3.5
+Version: 2.3.7
 Summary: 自动Cython，使用Cython批量编译.py文件为.pyd文件！
 Author-email: zhang_gavin <qq814608@163.com>
 License-Expression: MIT
@@ -20,7 +20,7 @@ Dynamic: license-file
 
 # AutoCython
 
-> 自动将 Python 源码编译为 Cython 二进制扩展（`.so`/`.pyd`），支持七重 AST 混淆、并发编译、跨平台运行。
+> 自动将 Python 源码编译为 Cython 二进制扩展（`.so`/`.pyd`），支持六重 AST 混淆、并发编译、跨平台运行。
 
 [![PyPI](https://img.shields.io/pypi/v/AutoCython-zhang)](https://pypi.org/project/AutoCython-zhang/)
 [![Python](https://img.shields.io/pypi/pyversions/AutoCython-zhang)](https://pypi.org/project/AutoCython-zhang/)
@@ -33,7 +33,7 @@ AutoCython 是一个 Python 源码保护工具，通过 Cython 编译 + AST 混
 ## 特性
 
 - **一键编译** — 单文件 (`-f`) 或整目录 (`-p`) 批量编译为 `.so`/`.pyd`
-- **七重 AST 混淆** — docstring 移除、注解清除、局部变量重命名、字符串 XOR 加密、常量折叠、控制流平坦化、虚假分支注入
+- **六重 AST 混淆** — docstring 移除、局部变量重命名、字符串 XOR 加密、常量折叠、控制流平坦化、虚假分支注入；默认完整保留运行时 annotation，兼容 FastAPI / Pydantic / dataclass
 - **并发编译** — 基于 `ThreadPoolExecutor` 的多线程并行编译，可配置并发数
 - **实时进度面板** — 基于 Rich 的实时任务状态表格、进度条、耗时统计
 - **跨平台** — 支持 Linux、macOS、Windows，自动适配 `.so`/`.pyd` 扩展名
@@ -108,7 +108,7 @@ print(f"生成: {output}")
 |------|------|------|
 | `compile()` | `AutoCython.AutoCython` | 主入口：解析参数并调度编译任务 |
 | `compile_to_binary()` | `AutoCython.compile` | 将单个 `.py` 文件编译为二进制扩展 |
-| `obfuscate_source()` | `AutoCython.obfuscate` | 对源码执行七重 AST 混淆变换 |
+| `obfuscate_source()` | `AutoCython.obfuscate` | 对源码执行六重 AST 混淆变换，并保留运行时 annotation |
 | `run_tasks()` | `AutoCython.run_tasks` | 并发任务执行引擎（含实时进度面板） |
 | `find_python_files()` | `AutoCython.tools` | 递归扫描目录下的可编译 `.py` 文件 |
 | `parse_arguments()` | `AutoCython.tools` | CLI 参数解析（中英双语） |
@@ -124,7 +124,7 @@ AutoCython/
 │   ├── _version.py          # 单一版本号来源
 │   ├── AutoCython.py        # 主编译调度逻辑
 │   ├── compile.py           # Cython 编译核心（临时目录隔离）
-│   ├── obfuscate.py         # 七重 AST 混淆引擎
+│   ├── obfuscate.py         # 六重 AST 混淆引擎
 │   ├── run_tasks.py         # 并发任务执行 + Rich 实时面板
 │   └── tools.py             # CLI 参数解析、文件扫描、国际化
 ├── tests/

{autocython_zhang-2.3.5 → autocython_zhang-2.3.7}/README.md

@@ -1,6 +1,6 @@
 # AutoCython
 
-> 自动将 Python 源码编译为 Cython 二进制扩展（`.so`/`.pyd`），支持七重 AST 混淆、并发编译、跨平台运行。
+> 自动将 Python 源码编译为 Cython 二进制扩展（`.so`/`.pyd`），支持六重 AST 混淆、并发编译、跨平台运行。
 
 [![PyPI](https://img.shields.io/pypi/v/AutoCython-zhang)](https://pypi.org/project/AutoCython-zhang/)
 [![Python](https://img.shields.io/pypi/pyversions/AutoCython-zhang)](https://pypi.org/project/AutoCython-zhang/)
@@ -13,7 +13,7 @@ AutoCython 是一个 Python 源码保护工具，通过 Cython 编译 + AST 混
 ## 特性
 
 - **一键编译** — 单文件 (`-f`) 或整目录 (`-p`) 批量编译为 `.so`/`.pyd`
-- **七重 AST 混淆** — docstring 移除、注解清除、局部变量重命名、字符串 XOR 加密、常量折叠、控制流平坦化、虚假分支注入
+- **六重 AST 混淆** — docstring 移除、局部变量重命名、字符串 XOR 加密、常量折叠、控制流平坦化、虚假分支注入；默认完整保留运行时 annotation，兼容 FastAPI / Pydantic / dataclass
 - **并发编译** — 基于 `ThreadPoolExecutor` 的多线程并行编译，可配置并发数
 - **实时进度面板** — 基于 Rich 的实时任务状态表格、进度条、耗时统计
 - **跨平台** — 支持 Linux、macOS、Windows，自动适配 `.so`/`.pyd` 扩展名
@@ -88,7 +88,7 @@ print(f"生成: {output}")
 |------|------|------|
 | `compile()` | `AutoCython.AutoCython` | 主入口：解析参数并调度编译任务 |
 | `compile_to_binary()` | `AutoCython.compile` | 将单个 `.py` 文件编译为二进制扩展 |
-| `obfuscate_source()` | `AutoCython.obfuscate` | 对源码执行七重 AST 混淆变换 |
+| `obfuscate_source()` | `AutoCython.obfuscate` | 对源码执行六重 AST 混淆变换，并保留运行时 annotation |
 | `run_tasks()` | `AutoCython.run_tasks` | 并发任务执行引擎（含实时进度面板） |
 | `find_python_files()` | `AutoCython.tools` | 递归扫描目录下的可编译 `.py` 文件 |
 | `parse_arguments()` | `AutoCython.tools` | CLI 参数解析（中英双语） |
@@ -104,7 +104,7 @@ AutoCython/
 │   ├── _version.py          # 单一版本号来源
 │   ├── AutoCython.py        # 主编译调度逻辑
 │   ├── compile.py           # Cython 编译核心（临时目录隔离）
-│   ├── obfuscate.py         # 七重 AST 混淆引擎
+│   ├── obfuscate.py         # 六重 AST 混淆引擎
 │   ├── run_tasks.py         # 并发任务执行 + Rich 实时面板
 │   └── tools.py             # CLI 参数解析、文件扫描、国际化
 ├── tests/

{autocython_zhang-2.3.5 → autocython_zhang-2.3.7}/pyproject.toml

@@ -42,7 +42,7 @@ markers = [
 
 [tool.setuptools.packages.find]
 where = ["."]
-exclude = ["tests*"]
+exclude = ["tests*", "build*"]
 
 [tool.setuptools.dynamic]
 version = {attr = "AutoCython._version.__version__"}