如何通过命令行递归导入指定目录下的Python文件并处理依赖？

问题描述 #

执行myprog --tests-dir /my/dir命令时，需要递归遍历/my/dir目录，找出所有Python文件，按模块间的依赖顺序完成导入。例如给定目录结构：

/my/dir/a/__init__.py
/my/dir/a/x.py   (imports a.y)
/my/dir/a/y.py   (imports a)
/my/dir/a/b/__init__.py
/my/dir/a/b/z.py

最终需要按以下顺序导入：

import a
import a.y
import a.x
import a.b
import a.b.z

考虑使用PathFinder但不清楚实现细节，寻求可行方案。

解决方案 #

1. 将目标目录加入模块搜索路径 #

首先需要把/my/dir添加到sys.path，让Python能识别该目录下的包和模块：

import sys
from pathlib import Path

# 从命令行参数获取tests-dir路径（示例中直接指定）
tests_dir = Path("/my/dir").resolve()
# 将目标目录加入sys.path，确保Python能找到其中的包
sys.path.insert(0, str(tests_dir))

2. 递归收集所有可导入模块 #

遍历目录下所有.py文件，将文件路径转换为对应的模块名（如/my/dir/a/x.py → a.x），同时处理__init__.py对应的包名：

def collect_modules(root_dir):
    modules = []
    root = Path(root_dir)
    for py_path in root.rglob("*.py"):
        # 跳过缓存目录下的文件
        if "__pycache__" in py_path.parts:
            continue
        # 计算相对路径并转换为模块名
        rel_path = py_path.relative_to(root)
        module_parts = list(rel_path.parts)
        # 移除.py后缀
        module_parts[-1] = module_parts[-1].rstrip(".py")
        
        # 处理__init__.py：对应父目录作为包名
        if module_parts[-1] == "__init__":
            module_name = ".".join(module_parts[:-1])
            if module_name:  # 跳过根目录下的__init__.py（如果存在）
                modules.append(module_name)
        else:
            module_name = ".".join(module_parts)
            modules.append(module_name)
    return modules

# 调用函数获取所有模块列表
all_modules = collect_modules(tests_dir)

执行后会得到['a', 'a.x', 'a.y', 'a.b', 'a.b.z']这样的模块列表。

3. 解析模块间的依赖关系 #

用ast模块解析每个模块的代码，提取其依赖的其他模块（仅关注我们收集到的模块）：

import ast
import importlib.util

def get_module_dependencies(module_name, all_modules):
    dependencies = set()
    # 查找模块对应的文件路径
    spec = importlib.util.find_spec(module_name)
    if not spec or not spec.origin:
        return dependencies
    
    with open(spec.origin, "r", encoding="utf-8") as f:
        tree = ast.parse(f.read())
    
    # 遍历所有导入语句节点
    for node in ast.walk(tree):
        # 处理import ...语句
        if isinstance(node, ast.Import):
            for alias in node.names:
                # 拆分模块名，逐级检查是否在我们的模块列表中
                parts = alias.name.split(".")
                for i in range(1, len(parts)+1):
                    candidate = ".".join(parts[:i])
                    if candidate in all_modules:
                        dependencies.add(candidate)
        # 处理from ... import ...语句
        elif isinstance(node, ast.ImportFrom):
            # 处理绝对导入
            if node.module:
                parts = node.module.split(".")
                for i in range(1, len(parts)+1):
                    candidate = ".".join(parts[:i])
                    if candidate in all_modules:
                        dependencies.add(candidate)
            # 处理相对导入（如from . import y）
            elif node.level > 0:
                current_parts = module_name.split(".")
                parent_parts = current_parts[:-node.level]
                for alias in node.names:
                    candidate = ".".join(parent_parts + [alias.name])
                    if candidate in all_modules:
                        dependencies.add(candidate)
    # 排除模块自身
    dependencies.discard(module_name)
    return dependencies

# 生成所有模块的依赖映射
dependencies_map = {mod: get_module_dependencies(mod, all_modules) for mod in all_modules}

4. 拓扑排序生成导入顺序 #

通过Kahn算法对模块进行拓扑排序，确保依赖模块先被导入：

def topological_sort(modules, dependencies_map):
    # 计算每个模块的入度（依赖的模块数量）
    in_degree = {mod: 0 for mod in modules}
    for mod in modules:
        for dep in dependencies_map[mod]:
            in_degree[dep] += 1
    
    # 初始化队列：入度为0的模块（无依赖）
    queue = [mod for mod in modules if in_degree[mod] == 0]
    import_order = []
    
    while queue:
        current_mod = queue.pop(0)
        import_order.append(current_mod)
        # 更新依赖当前模块的其他模块的入度
        for neighbor in [m for m in modules if current_mod in dependencies_map.get(m, set())]:
            in_degree[neighbor] -= 1
            if in_degree[neighbor] == 0:
                queue.append(neighbor)
    
    # 检查是否存在循环依赖
    if len(import_order) != len(modules):
        raise ValueError("模块间存在循环依赖，无法生成合法导入顺序")
    return import_order

# 获取最终导入顺序
import_order = topological_sort(all_modules, dependencies_map)

对于示例中的模块，会得到['a', 'a.y', 'a.x', 'a.b', 'a.b.z']的顺序，符合需求。

5. 动态执行导入 #

最后按照排序后的顺序，用importlib动态导入模块：

import importlib

for module_name in import_order:
    importlib.import_module(module_name)

关于PathFinder的说明 #

PathFinder是Python标准库importlib._bootstrap_external中的底层类，负责从文件系统查找模块。本方案中importlib.util.find_spec和默认的导入机制已经间接使用了它的功能，无需手动实例化或操作PathFinder——只要将目标目录加入sys.path，Python的默认模块查找器就会处理路径解析。

内容的提问来源于stack exchange，提问作者Johannes Ernst