AutoCython-zhang 2.2.1__tar.gz → 2.3.0__tar.gz

autocython_zhang-2.3.0/AutoCython/AutoCython.py

@@ -0,0 +1,44 @@
+import os
+import sys
+from .run_tasks import run_tasks
+from .compile import compile_to_binary
+from .tools import parse_arguments, find_python_files
+from .tools import show_no_compilable_files, show_file_not_found, show_path_not_found
+
+def compile():
+    try:
+        args = parse_arguments()
+        obfuscate_seed = args.seed
+
+        if args.file:
+            if os.path.isfile(args.file):
+                compile_file = args.file
+                del_source = args.del_source
+                tasks = [
+                    # 函数, 位置参数, 关键字参数
+                    (compile_to_binary, compile_file, (compile_file, del_source, True, obfuscate_seed), {}),
+                ]
+                run_tasks(tasks, max_workers=1, raise_on_failure=True) # 执行编译
+            else:
+                show_file_not_found(args.file)
+        elif args.path:
+            if os.path.exists(args.path) and not os.path.isfile(args.path):
+                compile_file_list = find_python_files(args.path)
+                if compile_file_list:
+                    del_source = args.del_source
+                    tasks = []
+                    for compile_file in compile_file_list:
+                        tasks.append(
+                            # 函数, 位置参数, 关键字参数
+                            (compile_to_binary, compile_file, (compile_file, del_source, True, obfuscate_seed), {}),
+                        )
+                    run_tasks(tasks, max_workers=args.conc, raise_on_failure=True) # 执行编译
+                else:
+                    show_no_compilable_files(args.path)
+            else:
+                show_path_not_found(args.path)
+    except KeyboardInterrupt:
+        sys.exit(130)
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)

{autocython_zhang-2.2.1 → autocython_zhang-2.3.0}/AutoCython/_version.py

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

{autocython_zhang-2.2.1 → autocython_zhang-2.3.0}/AutoCython/compile.py

@@ -2,21 +2,37 @@ import os
 import sys
 import glob
 import shutil
+import platform
 import tempfile
 import subprocess
 
+from .obfuscate import obfuscate_source
+
+
+def _strip_binary(path):
+    """strip 符号表，失败静默"""
+    try:
+        if sys.platform.startswith('win'):
+            return
+        cmd = ['strip', '-x' if sys.platform == 'darwin' else '--strip-all', path]
+        subprocess.run(cmd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+    except Exception:
+        pass
+
 def get_platform_extension() -> str:
     """返回当前平台的扩展名"""
     if sys.platform.startswith('win'):
         return '.pyd'
     return '.so'
 
-def compile_to_binary(file_path: str, del_source=False):
+def compile_to_binary(file_path: str, del_source=False, obfuscate=True, obfuscate_seed=None):
     """
     将指定的 Python 文件（.py）通过 Cython 编译为二进制扩展文件
 
     :param file_path: Python 文件路径（可以是相对路径或绝对路径）
     :param del_source: 是否删除源代码
+    :param obfuscate: 是否在编译前混淆源码（默认True）
+    :param obfuscate_seed: 混淆随机种子（None 表示不固定）
     :return: 生成的二进制文件路径（与输入保持相同的路径类型）
     """
     # 保存原始路径类型（相对/绝对）
@@ -36,6 +52,10 @@ def compile_to_binary(file_path: str, del_source=False):
     if ext != ".py":
         raise ValueError(f"ValueError: The file {file_path} is not a valid Python file (.py)!")
 
+    # 连字符文件名转下划线（Cython 模块名不允许连字符）
+    safe_module_name = module_name.replace('-', '_')
+    safe_file_name = safe_module_name + ext
+
     # 获取平台特定扩展名
     target_ext = get_platform_extension()
 
@@ -43,10 +63,21 @@ def compile_to_binary(file_path: str, del_source=False):
     temp_dir = tempfile.mkdtemp()
 
     try:
-        # 将目标文件复制到临时目录
-        temp_file_path = os.path.join(temp_dir, file_name)
+        # 将目标文件复制到临时目录（使用安全文件名）
+        temp_file_path = os.path.join(temp_dir, safe_file_name)
         shutil.copy2(abs_file_path, temp_file_path)
 
+        # 混淆源码（失败则用原始源码）
+        if obfuscate:
+            try:
+                with open(temp_file_path, 'r', encoding='utf-8') as f:
+                    original_source = f.read()
+                obfuscated = obfuscate_source(original_source, seed=obfuscate_seed)
+                with open(temp_file_path, 'w', encoding='utf-8') as f:
+                    f.write(obfuscated)
+            except Exception:
+                pass
+
         # 创建临时的 setup.py 文件
         setup_code = f"""
 from setuptools import setup
@@ -58,13 +89,13 @@ compiler_directives = {{
     'annotation_typing': False,
     'always_allow_keywords': True,
     'binding': True,
-    'embedsignature': True,
+    'embedsignature': False,
     'wraparound': False,
 }}
 
 setup(
     ext_modules=cythonize(
-        {repr(file_name)},
+        {repr(safe_file_name)},
         compiler_directives=compiler_directives,
         force=True
     )
@@ -76,30 +107,34 @@ setup(
 
         # 执行编译命令
         command = [sys.executable, "setup.py", "build_ext", "--inplace"]
-        result = subprocess.run(
-            command,
-            cwd=temp_dir,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE
-        )
+        try:
+            result = subprocess.run(
+                command,
+                cwd=temp_dir,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                timeout=300
+            )
+        except subprocess.TimeoutExpired:
+            raise RuntimeError(f"Compilation timed out after 300s: {file_path}")
 
         if result.returncode != 0:
             error_msg = result.stderr.decode('utf-8', errors='replace')
             raise RuntimeError(f"Compilation failed: {error_msg}")
 
         # 查找生成的二进制文件
-        pattern = os.path.join(temp_dir, f"{module_name}*{target_ext}")
+        pattern = os.path.join(temp_dir, f"{safe_module_name}*{target_ext}")
         matches = glob.glob(pattern)
 
         if not matches:
-            pattern = os.path.join(temp_dir, f"*{module_name}*{target_ext}")
+            pattern = os.path.join(temp_dir, f"*{safe_module_name}*{target_ext}")
             matches = glob.glob(pattern)
 
         if not matches:
             raise FileNotFoundError(f"FileNotFoundError: The file {file_path} is not a valid Python file (.py)! Generated file {target_ext} not found, in {temp_dir} possible file: {os.listdir(temp_dir)}")
 
         # 取最新生成的文件
-        generated_file = max(matches, key=os.path.getctime)
+        generated_file = max(matches, key=os.path.getmtime)
 
         # 获取源文件的目录（使用原始路径类型）
         if is_absolute:
@@ -116,9 +151,14 @@ setup(
         output_file_name = os.path.basename(generated_file)
         output_path = os.path.join(output_dir, output_file_name)
 
-        # 移动文件
+        # 移动文件（先删除已存在的目标）
+        if os.path.exists(output_path):
+            os.remove(output_path)
         shutil.move(generated_file, output_path)
 
+        # strip 符号表
+        _strip_binary(output_path)
+
         if del_source:
             os.remove(file_path)
 
@@ -129,7 +169,7 @@ setup(
         shutil.rmtree(temp_dir, ignore_errors=True)
 
 # 测试函数
-if __name__ == "__main__":
+if __name__ == "__main__":  # pragma: no cover
     # 替换为你的 Python 文件路径
     target_file = "test/example.py"  # 请确保文件路径正确
 
@@ -137,4 +177,4 @@ if __name__ == "__main__":
         output_file = compile_to_binary(target_file)
         print(output_file)
     except Exception as e:
-        print(e)
+        print(e)

autocython_zhang-2.3.0/AutoCython/obfuscate.py

@@ -0,0 +1,469 @@
+"""AST 混淆模块：去 docstring、去 annotation、局部变量重命名、字符串加密、常量折叠、控制流平坦化、虚假分支"""
+import ast
+import copy
+import hashlib
+import random
+
+_UNSAFE_CALLS = frozenset({'globals', 'locals', 'eval', 'exec', 'vars'})
+
+
+def _has_unsafe_call(node):
+    """检查函数体是否包含 globals()/locals()/eval()/exec()/vars() 调用"""
+    for child in ast.walk(node):
+        if isinstance(child, ast.Call) and isinstance(child.func, ast.Name) and child.func.id in _UNSAFE_CALLS:
+            return True
+    return False
+
+
+def _walk_no_nested_scope(body):
+    """遍历 body 中的节点，不穿透嵌套函数/类定义"""
+    for node in body:
+        yield node
+        if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)):
+            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])
+
+
+class _DocstringRemover(ast.NodeTransformer):
+    """移除 module/class/function 首部的 docstring"""
+
+    def _strip_docstring(self, node):
+        if (node.body and isinstance(node.body[0], ast.Expr)
+                and isinstance(node.body[0].value, (ast.Constant, ast.Str))):
+            node.body.pop(0)
+            if not node.body:
+                node.body.append(ast.Pass())
+        return node
+
+    def visit_Module(self, node):
+        self.generic_visit(node)
+        return self._strip_docstring(node)
+
+    def visit_FunctionDef(self, node):
+        self.generic_visit(node)
+        return self._strip_docstring(node)
+
+    visit_AsyncFunctionDef = visit_FunctionDef
+
+    def visit_ClassDef(self, node):
+        self.generic_visit(node)
+        return self._strip_docstring(node)
+
+
+class _AnnotationRemover(ast.NodeTransformer):
+    """清除函数参数和返回值的类型注解，以及变量注解"""
+
+    def visit_FunctionDef(self, node):
+        self.generic_visit(node)
+        node.returns = None
+        for arg in node.args.args + node.args.posonlyargs + node.args.kwonlyargs:
+            arg.annotation = None
+        if node.args.vararg:
+            node.args.vararg.annotation = None
+        if node.args.kwarg:
+            node.args.kwarg.annotation = None
+        return node
+
+    visit_AsyncFunctionDef = visit_FunctionDef
+
+    def visit_ClassDef(self, node):
+        self.generic_visit(node)
+        if not node.body:
+            node.body.append(ast.Pass())
+        return node
+
+    def visit_AnnAssign(self, node):
+        self.generic_visit(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_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)
+        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)
+    return free
+
+
+def _hash_name(name, salt):
+    """基于原名+salt生成短 hash 标识符，避免明显的序号模式"""
+    h = hashlib.md5(f'{salt}:{name}'.encode()).hexdigest()[:8]
+    return f'_{h}'
+
+
+class _LocalVarRenamer(ast.NodeTransformer):
+    """函数作用域内的局部变量重命名为 hash-based 短标识符"""
+
+    def _rename_function(self, node):
+        if _has_unsafe_call(node):
+            self.generic_visit(node)
+            return node
+
+        # 收集参数名（不重命名）
+        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)
+
+        # 收集局部赋值目标（不穿透嵌套作用域）
+        local_names = 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)
+            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'
+                        and not name.startswith('__')):
+                    local_names.add(name)
+        local_names -= nonlocal_names
+
+        if not local_names:
+            self.generic_visit(node)
+            return node
+
+        # 排除被嵌套函数引用的闭包变量（重命名会破坏语义）
+        closure_refs = _collect_nested_free_refs(node.body, local_names)
+        local_names -= closure_refs
+
+        if not local_names:
+            self.generic_visit(node)
+            return node
+
+        # 构建重命名映射（hash-based，用函数名做 salt 防跨函数碰撞）
+        salt = getattr(node, 'name', '')
+        rename_map = {name: _hash_name(name, salt) for name in sorted(local_names)}
+        # 碰撞检测：若有重复值，回退加序号
+        seen = {}
+        for name in sorted(local_names):
+            h = rename_map[name]
+            if h in seen:
+                rename_map[name] = f'{h}{len(seen)}'
+            seen[h] = name
+
+        # 应用重命名（不穿透嵌套作用域）
+        for child in _walk_no_nested_scope(node.body):
+            if isinstance(child, ast.Name) and child.id in rename_map:
+                child.id = rename_map[child.id]
+
+        # 递归处理嵌套函数/类（它们有自己的作用域）
+        self.generic_visit(node)
+        return node
+
+    def visit_FunctionDef(self, node):
+        return self._rename_function(node)
+
+    visit_AsyncFunctionDef = visit_FunctionDef
+
+
+class _StringEncryptor(ast.NodeTransformer):
+    """将字符串常量替换为 XOR 解密表达式"""
+
+    def __init__(self, rng=None):
+        self._rng = rng or random
+        self._key = self._rng.randint(1, 255)
+
+    def visit_JoinedStr(self, node):
+        return node  # 不处理 f-string
+
+    def visit_Constant(self, node):
+        v = node.value
+        if not isinstance(v, str) or len(v) <= 1:
+            return node
+        key = self._key
+        enc = bytes(b ^ key for b in v.encode('utf-8'))
+        # bytes(enc_literal).translate(bytes.maketrans(range(256), bytes(b^KEY for b in range(256)))).decode()
+        # 简化为：直接存加密后的 bytes 常量，用 translate 解密
+        # 构建 XOR 转换表作为常量
+        table_bytes = bytes(b ^ key for b in range(256))
+        return ast.Call(
+            func=ast.Attribute(
+                value=ast.Call(
+                    func=ast.Attribute(
+                        value=ast.Constant(value=enc),
+                        attr='translate',
+                        ctx=ast.Load(),
+                    ),
+                    args=[ast.Call(
+                        func=ast.Attribute(
+                            value=ast.Name(id='bytes', ctx=ast.Load()),
+                            attr='maketrans',
+                            ctx=ast.Load(),
+                        ),
+                        args=[
+                            ast.Constant(value=bytes(range(256))),
+                            ast.Constant(value=table_bytes),
+                        ],
+                        keywords=[],
+                    )],
+                    keywords=[],
+                ),
+                attr='decode',
+                ctx=ast.Load(),
+            ),
+            args=[],
+            keywords=[],
+        )
+
+
+class _ConstantFoldingObfuscator(ast.NodeTransformer):
+    """将整数常量拆分为算术表达式"""
+
+    def __init__(self, rng=None):
+        self._rng = rng or random
+
+    def visit_Constant(self, node):
+        v = node.value
+        if isinstance(v, bool) or not isinstance(v, int):
+            return node
+        if v in (0, 1) or v < 0 or v > 10000:
+            return node
+        return self._decompose_2layer(v)
+
+    def _decompose_1layer(self, n):
+        if n <= 1:
+            return ast.Constant(value=n)
+        # 尝试找因子
+        for d in range(2, min(int(n**0.5) + 1, 100)):
+            if n % d == 0:
+                return ast.BinOp(
+                    left=ast.Constant(value=d),
+                    op=ast.Mult(),
+                    right=ast.Constant(value=n // d),
+                )
+        # 加法拆分
+        a = self._rng.randint(1, n - 1)
+        return ast.BinOp(
+            left=ast.Constant(value=a),
+            op=ast.Add(),
+            right=ast.Constant(value=n - a),
+        )
+
+    def _decompose_2layer(self, n):
+        a = self._rng.randint(1, n - 1)
+        b = n - a
+        return ast.BinOp(
+            left=self._decompose_1layer(a),
+            op=ast.Add(),
+            right=self._decompose_1layer(b),
+        )
+
+
+class _ControlFlowFlattener(ast.NodeTransformer):
+    """将函数体转换为 while True + 状态机调度"""
+
+    def __init__(self, rng=None):
+        self._rng = rng or random
+
+    def visit_FunctionDef(self, node):
+        self.generic_visit(node)  # 先递归处理嵌套
+        if self._should_skip(node):
+            return node
+        node.body = self._flatten_body(node.body)
+        return node
+
+    visit_AsyncFunctionDef = visit_FunctionDef
+
+    def _should_skip(self, node):
+        if isinstance(node, ast.AsyncFunctionDef):
+            return True
+        if _has_unsafe_call(node):
+            return True
+        if len(node.body) < 3:
+            return True
+        for child in ast.walk(node):
+            if isinstance(child, (ast.Yield, ast.YieldFrom)):
+                return True
+            # nonlocal/global 变量在状态机分支中会被 Cython 误判为未赋值
+            if isinstance(child, (ast.Nonlocal, ast.Global)):
+                return True
+        # comprehension 在 while True 状态机内会触发 Cython ControlFlowAnalysis crash
+        for child in ast.walk(node):
+            if child is node:
+                continue
+            if isinstance(child, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)):
+                continue
+            if isinstance(child, (ast.ListComp, ast.SetComp, ast.DictComp, ast.GeneratorExp)):
+                return True
+        return False
+
+    def _flatten_body(self, stmts):
+        states = self._rng.sample(range(100, 999), len(stmts) + 1)
+        # states[0] = 初始, states[1..n] = 各语句, states[-1] = 终止(break)
+        state_var = '_s'
+        cases = []
+        for i, stmt in enumerate(stmts):
+            test = ast.Compare(
+                left=ast.Name(id=state_var, ctx=ast.Load()),
+                ops=[ast.Eq()],
+                comparators=[ast.Constant(value=states[i])],
+            )
+            body = [stmt]
+            # return 语句不追加状态转移
+            if not isinstance(stmt, ast.Return):
+                if i < len(stmts) - 1:
+                    body.append(ast.Assign(
+                        targets=[ast.Name(id=state_var, ctx=ast.Store())],
+                        value=ast.Constant(value=states[i + 1]),
+                    ))
+                else:
+                    body.append(ast.Break())
+            cases.append((test, body))
+
+        # 构建 if/elif 链
+        if_node = None
+        for test, body in reversed(cases):
+            if if_node is None:
+                if_node = ast.If(test=test, body=body, orelse=[])
+            else:
+                if_node = ast.If(test=test, body=body, orelse=[if_node])
+
+        return [
+            ast.Assign(
+                targets=[ast.Name(id=state_var, ctx=ast.Store())],
+                value=ast.Constant(value=states[0]),
+            ),
+            ast.While(
+                test=ast.Constant(value=True),
+                body=[if_node],
+                orelse=[],
+            ),
+        ]
+
+
+class _OpaquePredicateInserter(ast.NodeTransformer):
+    """在函数体中插入永真/永假虚假分支"""
+
+    _PREDICATES_TRUE = [
+        # n * n >= 0
+        lambda: ast.Compare(
+            left=ast.BinOp(
+                left=ast.Constant(value=7),
+                op=ast.Mult(),
+                right=ast.Constant(value=7),
+            ),
+            ops=[ast.GtE()],
+            comparators=[ast.Constant(value=0)],
+        ),
+        # isinstance(1, int)
+        lambda: ast.Call(
+            func=ast.Name(id='isinstance', ctx=ast.Load()),
+            args=[ast.Constant(value=1), ast.Name(id='int', ctx=ast.Load())],
+            keywords=[],
+        ),
+        # len([0]) > 0
+        lambda: ast.Compare(
+            left=ast.Call(
+                func=ast.Name(id='len', ctx=ast.Load()),
+                args=[ast.List(elts=[ast.Constant(value=0)], ctx=ast.Load())],
+                keywords=[],
+            ),
+            ops=[ast.Gt()],
+            comparators=[ast.Constant(value=0)],
+        ),
+    ]
+
+    _DEAD_CODE = [
+        lambda: ast.Assign(
+            targets=[ast.Name(id='_', ctx=ast.Store())],
+            value=ast.Constant(value=0),
+        ),
+        lambda: ast.Pass(),
+    ]
+
+    def __init__(self, rng=None):
+        self._rng = rng or random
+
+    def visit_FunctionDef(self, node):
+        self.generic_visit(node)
+        if _has_unsafe_call(node):
+            return node
+        node.body = self._insert_predicates(node.body)
+        return node
+
+    visit_AsyncFunctionDef = visit_FunctionDef
+
+    def _insert_predicates(self, stmts):
+        result = []
+        for stmt in stmts:
+            result.append(stmt)
+            if self._rng.random() < 0.3:
+                pred = self._rng.choice(self._PREDICATES_TRUE)()
+                dead = self._rng.choice(self._DEAD_CODE)()
+                if self._rng.random() < 0.5:
+                    # 永真分支：真分支有原始无害代码，假分支有死代码
+                    result.append(ast.If(test=pred, body=[ast.Pass()], orelse=[dead]))
+                else:
+                    # 永假分支（取反）
+                    result.append(ast.If(
+                        test=ast.UnaryOp(op=ast.Not(), operand=pred),
+                        body=[dead],
+                        orelse=[],
+                    ))
+        return result
+
+
+def obfuscate_source(source_code: str, seed=None) -> str:
+    """对源码执行七重 AST 变换：去 docstring、去 annotation、局部变量重命名、
+    字符串加密、常量折叠、控制流平坦化、虚假分支。
+    ast.unparse() 天然丢弃所有注释。
+
+    :param seed: 随机种子；传入后可复现混淆结果
+    """
+    if not source_code.strip():
+        return source_code
+    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 = _StringEncryptor(rng=rng).visit(tree)
+    tree = _ConstantFoldingObfuscator(rng=rng).visit(tree)
+    ast.fix_missing_locations(tree)
+    return ast.unparse(tree)

{autocython_zhang-2.2.1 → autocython_zhang-2.3.0}/AutoCython/run_tasks.py

@@ -1,6 +1,5 @@
 import os
 import time
-import locale
 import platform
 import threading
 import concurrent.futures
@@ -12,29 +11,17 @@ from rich.spinner import Spinner
 from rich.columns import Columns
 from rich.progress import Progress, BarColumn, TimeRemainingColumn, TimeElapsedColumn
 
-def get_system_language():
-    """
-    获取系统语言，兼容 Python 3.11+
+from .tools import get_system_language
 
-    :return: 'zh' 或 'en'
-    """
-    try:
-        # Python 3.11+ 推荐方式
-        lang = locale.getlocale()[0]
-        if lang is None:
-            # 回退到环境变量
-            lang = os.environ.get('LANG', os.environ.get('LANGUAGE', ''))
-        return 'zh' if lang and lang.startswith('zh') else 'en'
-    except Exception:
-        return 'en'
-
-def run_tasks(task_list, max_workers=2, language=None):
+
+def run_tasks(task_list, max_workers=2, language=None, raise_on_failure=False):
     """
     并发执行任务列表并实时显示状态
 
     :param task_list: 任务列表，每个元素是 (函数, 位置参数元组, 关键字参数字典)
     :param max_workers: 最大并发线程数
     :param language: 显示语言 ('en' 或 'zh', 默认根据系统语言自动判断)
+    :param raise_on_failure: 若存在失败任务，是否抛出 RuntimeError
     """
     print("""\n █████╗ ██╗   ██╗████████╗ ██████╗  ██████╗██╗   ██╗████████╗██╗  ██╗ ██████╗ ███╗   ██╗
 ██╔══██╗██║   ██║╚══██╔══╝██╔═══██╗██╔════╝╚██╗ ██╔╝╚══██╔══╝██║  ██║██╔═══██╗████╗  ██║
@@ -47,7 +34,7 @@ def run_tasks(task_list, max_workers=2, language=None):
     print(f"{platform.system()} {platform.version()} {platform.machine()} | {platform.python_implementation()} {platform.python_version()} {platform.python_compiler()} | {bit_architecture}")
 
     # 获取系统默认区域设置
-    language = get_system_language()
+    language = language or get_system_language()
 
     # 中英文文本映射
     TEXT_MAP = {
@@ -267,13 +254,24 @@ def run_tasks(task_list, max_workers=2, language=None):
 
     # 最终汇总信息
     total_elapsed = time.time() - start_time
-    success_count = sum(1 for t in task_status if t["status"] == "success")
-    failure_count = sum(1 for t in task_status if t["status"] == "failed")
+    success_count = sum(1 for ts in task_status if ts["status"] == "success")
+    failure_count = sum(1 for ts in task_status if ts["status"] == "failed")
 
     console.print(t['succeeded'].format(success_count) + t['failed'].format(failure_count) + t['total_time'].format(total_elapsed) + t['all_completed'])
 
+    summary = {
+        "total": total_tasks,
+        "succeeded": success_count,
+        "failed": failure_count,
+        "elapsed": total_elapsed,
+        "tasks": task_status,
+    }
+    if raise_on_failure and failure_count > 0:
+        raise RuntimeError(f"{failure_count} task(s) failed")
+    return summary
+
 # 示例使用方式
-if __name__ == "__main__":
+if __name__ == "__main__":  # pragma: no cover
     # 示例任务函数
     def task_success(seconds):
         time.sleep(seconds)

{autocython_zhang-2.2.1 → autocython_zhang-2.3.0}/AutoCython/tools.py

@@ -35,8 +35,13 @@ def find_python_files(path):
         return any(marker in line for marker in exclude_markers)
 
     valid_py_files = []
+    skip_dirs = {
+        "__pycache__", "venv", ".venv", "build", "dist",
+        "node_modules", ".git", ".eggs",
+    }
 
     for root, dirs, files in os.walk(path):
+        dirs[:] = [d for d in dirs if d not in skip_dirs and not d.endswith(".egg-info")]
         for file in files:
             if file == "__init__.py":
                 continue
@@ -80,6 +85,7 @@ def parse_arguments():
             'path_help': 'Compile directory path',
             'conc_help': 'Compile concurrency count (default: 2)',
             'del_help': 'Remove source code after compilation (default: False)',
+            'seed_help': 'Set obfuscation random seed for reproducible output',
             'help_help': 'Show help message',
             'version_help': 'Show program version',
             'version_text': f'v{__version__}',
@@ -92,6 +98,7 @@ def parse_arguments():
             'path_help': '编译目录路径',
             'conc_help': '编译并发数（默认：2）',
             'del_help': '编译后删除源代码（默认：False）',
+            'seed_help': '设置混淆随机种子（用于可复现构建）',
             'help_help': '显示帮助信息',
             'version_help': '显示程序版本',
             'version_text': f'v{__version__}',
@@ -105,9 +112,7 @@ def parse_arguments():
     class CustomParser(argparse.ArgumentParser):
         def error(self, message):
             self.print_usage(sys.stderr)
-            required_args = [f'--{a.dest}' for a in self._actions if a.required]
-            err_msg = msg['required_error'].format(', '.join(required_args))
-            sys.stderr.write(f'error: {err_msg}\n')
+            sys.stderr.write(f'error: {message}\n')
             sys.exit(2)
 
     # 配置参数解析器
@@ -118,14 +123,15 @@ def parse_arguments():
         formatter_class=argparse.RawTextHelpFormatter
     )
 
-    # 添加参数定义
-    required_group = parser.add_argument_group('required arguments')
-    required_group.add_argument('-f', '--file', type=str, help=msg['file_help'])
-    required_group.add_argument('-p', '--path', type=str, help=msg['path_help'])
+    # 添加参数定义（文件与目录互斥）
+    input_group = parser.add_mutually_exclusive_group(required=False)
+    input_group.add_argument('-f', '--file', type=str, help=msg['file_help'])
+    input_group.add_argument('-p', '--path', type=str, help=msg['path_help'])
 
     optional_group = parser.add_argument_group('optional arguments')
     optional_group.add_argument('-c', '--conc', type=int, default=2, help=msg['conc_help'])
     optional_group.add_argument('-d', '--del', dest='del_source', action='store_true', help=msg['del_help'])
+    optional_group.add_argument('--seed', type=int, default=None, help=msg['seed_help'])
     optional_group.add_argument('-h', '--help', action='store_true', help=msg['help_help'])
     optional_group.add_argument('-v', '--version', action='store_true', help=msg['version_help'])
 
@@ -143,7 +149,8 @@ def parse_arguments():
 
     if not args.file and not args.path:
         parser.print_help()
-        sys.exit(0)
+        print(f"\nerror: {msg['required_error'].format('-f/--file, -p/--path')}", file=sys.stderr)
+        sys.exit(2)
 
     return args
 
@@ -171,7 +178,7 @@ def show_path_not_found(path):
     else:
         print(f"Path {path} does not exist!")
 
-if __name__ == "__main__":
+if __name__ == "__main__":  # pragma: no cover
     args = parse_arguments()
     print(f"文件: {args.file}")
     print(f"路径: {args.path}")

{autocython_zhang-2.2.1 → autocython_zhang-2.3.0}/AutoCython_zhang.egg-info/PKG-INFO

@@ -1,37 +1,16 @@
 Metadata-Version: 2.4
 Name: AutoCython-zhang
-Version: 2.2.1
+Version: 2.3.0
 Summary: 自动Cython，使用Cython批量编译.py文件为.pyd文件！
 Author-email: zhang_gavin <qq814608@163.com>
-License: MIT License
-        
-        Copyright (c) [2024] [JianJun]
-        
-        Permission is hereby granted, free of charge, to any person obtaining a copy
-        of this software and associated documentation files (the "Software"), to deal
-        in the Software without restriction, including without limitation the rights
-        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-        copies of the Software, and to permit persons to whom the Software is
-        furnished to do so, subject to the following conditions:
-        
-        The above copyright notice and this permission notice shall be included in all
-        copies or substantial portions of the Software.
-        
-        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-        SOFTWARE.
-        
+License-Expression: MIT
 Project-URL: homepage, https://github.com/zhang0281/AutoCython
 Project-URL: repository, https://github.com/zhang0281/AutoCython
 Project-URL: documentation, https://github.com/zhang0281/AutoCython#readme
 Keywords: cython,compile,pyd,pyc,python,autopyd
 Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: setuptools
@@ -76,8 +55,11 @@ AutoCython -f test.py
 AutoCython -p D:/python_code/ProjectPath
 
 # 编译后删除源代码 (默认不删除)
-AutoCython -d True -f test.py
-AutoCython -d True -p D:/python_code/ProjectPath
+AutoCython -d -f test.py
+AutoCython -d -p D:/python_code/ProjectPath
+
+# 指定混淆随机种子（可复现构建）
+AutoCython --seed 2025 -f test.py
 ```
 
 ### 编译界面
@@ -90,6 +72,36 @@ AutoCython -d True -p D:/python_code/ProjectPath
 # 此文件将跳过编译处理
 ```
 
+## 🧪 测试
+```bash
+# 运行全部测试
+pytest
+
+# 只运行单元测试
+pytest -m unit
+
+# 只运行集成测试 (kd_dist)
+pytest -m integ
+
+# 排除集成测试（快速验证）
+pytest -m "not integ"
+```
+
+### kd-dist 集成测试配置
+```bash
+# 指定真实项目根目录（未设置则自动探测）
+export KD_DIST_ROOT=/path/to/kd-dist
+
+# 开启严格文件计数阈值校验（默认关闭）
+export KD_DIST_STRICT_COUNTS=1
+
+# 输出 kd-dist 分层测试 JSON 报告
+export KD_DIST_REPORT_PATH=.pytest_cache/kd_dist_report.json
+```
+
+`tests/kd_dist/manifest.json` 用于定义 import policy 与行为等价用例，  
+`tests/kd_dist/known_failures.json` 用于记录已知 Cython 不兼容文件（xfail 治理）。
+
 ## ⚠️ 常见问题解决
 
 一般是源代码中有 Cython 不支持的语句, 或者文件名不支持等.

{autocython_zhang-2.2.1 → autocython_zhang-2.3.0}/AutoCython_zhang.egg-info/SOURCES.txt

@@ -1,10 +1,12 @@
 LICENSE
+MANIFEST.in
 README.md
 pyproject.toml
 AutoCython/AutoCython.py
 AutoCython/__init__.py
 AutoCython/_version.py
 AutoCython/compile.py
+AutoCython/obfuscate.py
 AutoCython/run_tasks.py
 AutoCython/tools.py
 AutoCython_zhang.egg-info/PKG-INFO

{autocython_zhang-2.2.1 → autocython_zhang-2.3.0}/AutoCython_zhang.egg-info/top_level.txt

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

autocython_zhang-2.3.0/MANIFEST.in

@@ -0,0 +1,2 @@
+global-exclude tests/*
+prune tests

{autocython_zhang-2.2.1 → autocython_zhang-2.3.0}/PKG-INFO

@@ -1,37 +1,16 @@
 Metadata-Version: 2.4
 Name: AutoCython-zhang
-Version: 2.2.1
+Version: 2.3.0
 Summary: 自动Cython，使用Cython批量编译.py文件为.pyd文件！
 Author-email: zhang_gavin <qq814608@163.com>
-License: MIT License
-        
-        Copyright (c) [2024] [JianJun]
-        
-        Permission is hereby granted, free of charge, to any person obtaining a copy
-        of this software and associated documentation files (the "Software"), to deal
-        in the Software without restriction, including without limitation the rights
-        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-        copies of the Software, and to permit persons to whom the Software is
-        furnished to do so, subject to the following conditions:
-        
-        The above copyright notice and this permission notice shall be included in all
-        copies or substantial portions of the Software.
-        
-        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-        SOFTWARE.
-        
+License-Expression: MIT
 Project-URL: homepage, https://github.com/zhang0281/AutoCython
 Project-URL: repository, https://github.com/zhang0281/AutoCython
 Project-URL: documentation, https://github.com/zhang0281/AutoCython#readme
 Keywords: cython,compile,pyd,pyc,python,autopyd
 Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: setuptools
@@ -76,8 +55,11 @@ AutoCython -f test.py
 AutoCython -p D:/python_code/ProjectPath
 
 # 编译后删除源代码 (默认不删除)
-AutoCython -d True -f test.py
-AutoCython -d True -p D:/python_code/ProjectPath
+AutoCython -d -f test.py
+AutoCython -d -p D:/python_code/ProjectPath
+
+# 指定混淆随机种子（可复现构建）
+AutoCython --seed 2025 -f test.py
 ```
 
 ### 编译界面
@@ -90,6 +72,36 @@ AutoCython -d True -p D:/python_code/ProjectPath
 # 此文件将跳过编译处理
 ```
 
+## 🧪 测试
+```bash
+# 运行全部测试
+pytest
+
+# 只运行单元测试
+pytest -m unit
+
+# 只运行集成测试 (kd_dist)
+pytest -m integ
+
+# 排除集成测试（快速验证）
+pytest -m "not integ"
+```
+
+### kd-dist 集成测试配置
+```bash
+# 指定真实项目根目录（未设置则自动探测）
+export KD_DIST_ROOT=/path/to/kd-dist
+
+# 开启严格文件计数阈值校验（默认关闭）
+export KD_DIST_STRICT_COUNTS=1
+
+# 输出 kd-dist 分层测试 JSON 报告
+export KD_DIST_REPORT_PATH=.pytest_cache/kd_dist_report.json
+```
+
+`tests/kd_dist/manifest.json` 用于定义 import policy 与行为等价用例，  
+`tests/kd_dist/known_failures.json` 用于记录已知 Cython 不兼容文件（xfail 治理）。
+
 ## ⚠️ 常见问题解决
 
 一般是源代码中有 Cython 不支持的语句, 或者文件名不支持等.

{autocython_zhang-2.2.1 → autocython_zhang-2.3.0}/README.md

@@ -35,8 +35,11 @@ AutoCython -f test.py
 AutoCython -p D:/python_code/ProjectPath
 
 # 编译后删除源代码 (默认不删除)
-AutoCython -d True -f test.py
-AutoCython -d True -p D:/python_code/ProjectPath
+AutoCython -d -f test.py
+AutoCython -d -p D:/python_code/ProjectPath
+
+# 指定混淆随机种子（可复现构建）
+AutoCython --seed 2025 -f test.py
 ```
 
 ### 编译界面
@@ -49,6 +52,36 @@ AutoCython -d True -p D:/python_code/ProjectPath
 # 此文件将跳过编译处理
 ```
 
+## 🧪 测试
+```bash
+# 运行全部测试
+pytest
+
+# 只运行单元测试
+pytest -m unit
+
+# 只运行集成测试 (kd_dist)
+pytest -m integ
+
+# 排除集成测试（快速验证）
+pytest -m "not integ"
+```
+
+### kd-dist 集成测试配置
+```bash
+# 指定真实项目根目录（未设置则自动探测）
+export KD_DIST_ROOT=/path/to/kd-dist
+
+# 开启严格文件计数阈值校验（默认关闭）
+export KD_DIST_STRICT_COUNTS=1
+
+# 输出 kd-dist 分层测试 JSON 报告
+export KD_DIST_REPORT_PATH=.pytest_cache/kd_dist_report.json
+```
+
+`tests/kd_dist/manifest.json` 用于定义 import policy 与行为等价用例，  
+`tests/kd_dist/known_failures.json` 用于记录已知 Cython 不兼容文件（xfail 治理）。
+
 ## ⚠️ 常见问题解决
 
 一般是源代码中有 Cython 不支持的语句, 或者文件名不支持等.
@@ -64,4 +97,4 @@ AutoCython -d True -p D:/python_code/ProjectPath
 2. 20221123 可以通过文件头手动指定不编译的文件
 3. 20230306 更新可以指定命令行头如 `Python310` 以此支持非Widnows系统下编译
 4. 20230324 更新文档
-5. 20240506 修复编译失败时遗漏复原 \_\_init\_\_.py 的问题
+5. 20240506 修复编译失败时遗漏复原 \_\_init\_\_.py 的问题

{autocython_zhang-2.2.1 → autocython_zhang-2.3.0}/pyproject.toml

@@ -5,14 +5,15 @@ build-backend = "setuptools.build_meta"
 [project]
 name = "AutoCython-zhang"
 dynamic = ["version"]
+requires-python = ">=3.9"
 authors = [{name = "zhang_gavin", email = "qq814608@163.com"}]
 description = "自动Cython，使用Cython批量编译.py文件为.pyd文件！"
 readme = "README.md"
-license = {file = "LICENSE"}
+license = "MIT"
+license-files = ["LICENSE"]
 keywords = ["cython", "compile", "pyd", "pyc", "python", "autopyd"]
 classifiers = [
     "Programming Language :: Python :: 3",
-    "License :: OSI Approved :: MIT License",
     "Operating System :: OS Independent",
 ]
 dependencies = [
@@ -29,5 +30,19 @@ documentation = "https://github.com/zhang0281/AutoCython#readme"
 [project.scripts]
 AutoCython = "AutoCython:main"
 
+[tool.pytest.ini_options]
+addopts = "-n auto --dist=load"
+markers = [
+    "unit: 单元测试",
+    "integ: 集成测试 (kd_dist)",
+    "kd_compile_plain: kd-dist 纯编译矩阵测试",
+    "kd_compile_obfuscate: kd-dist 混淆编译矩阵测试",
+    "kd_behavior: kd-dist 行为等价测试",
+]
+
+[tool.setuptools.packages.find]
+where = ["."]
+exclude = ["tests*"]
+
 [tool.setuptools.dynamic]
 version = {attr = "AutoCython._version.__version__"}

autocython_zhang-2.2.1/AutoCython/AutoCython.py

@@ -1,36 +0,0 @@
-import os
-from .run_tasks import run_tasks
-from .compile import compile_to_binary
-from .tools import parse_arguments, find_python_files
-from .tools import show_no_compilable_files, show_file_not_found, show_path_not_found
-
-def compile():
-    args = parse_arguments()
-
-    if args.file:
-        if os.path.isfile(args.file):
-            compile_file = args.file
-            del_source = args.del_source
-            tasks = [
-                # 函数, 位置参数, 关键字参数
-                (compile_to_binary, compile_file, (compile_file, del_source), {}),
-            ]
-            run_tasks(tasks, max_workers=1) # 执行编译
-        else:
-            show_file_not_found(args.file)
-    elif args.path:
-        if os.path.exists(args.path) and not os.path.isfile(args.path):
-            compile_file_list = find_python_files(args.path)
-            if compile_file_list:
-                del_source = args.del_source
-                tasks = []
-                for compile_file in compile_file_list:
-                    tasks.append(
-                        # 函数, 位置参数, 关键字参数
-                        (compile_to_binary, compile_file, (compile_file, del_source), {}),
-                    )
-                run_tasks(tasks, max_workers=args.conc) # 执行编译
-            else:
-                show_no_compilable_files(args.path)
-        else:
-            show_path_not_found(args.path)