pipdeptree -p ABC以及pipdeptree -j

from pip._internal.metadata import pkg_resources
dists = pkg_resources.Environment.from_paths(None).iter_installed_distributions(            local_only=local_only,            skip=(),            user_only=user_only,        )

from pip._vendor.pkg_resources import DistInfoDistribution
def requires(self) -> list[Requirement]:    return self._obj.requires()  # type: ignore[no-untyped-call,no-any-return]

{        "package": {            "key": "adal",            "package_name": "adal",            "installed_version": "1.2.7"        },        "dependencies": [            {                "key": "cryptography",                "package_name": "cryptography",                "installed_version": "41.0.4",                "required_version": ">=1.1.0"            },            {                "key": "pyjwt",                "package_name": "PyJWT",                "installed_version": "2.6.0",                "required_version": ">=1.0.0,<3"            },            {                "key": "python-dateutil",                "package_name": "python-dateutil",                "installed_version": "2.8.2",                "required_version": ">=2.1.0,<3"            },            {                "key": "requests",                "package_name": "requests",                "installed_version": "2.28.2",                "required_version": ">=2.0.0,<3"            }        ]    },

import jsonimport subprocessimport re
FILTERED_DEPENDENCIES = ['python3']
def extract_package_name(dep):    match = re.match(r'.*python3(?:\.\d+)?dist\(([^)]+)\).*', dep)    if match:        return match.group(1)    return dep.split(' ')[0]
def get_package_dependencies(package_name):
    package_name = get_rpmname(package_name)
    print(package_name)    try:        command = f'rpm-dep -i {package_name} -q'        subprocess.run(command.split())        parse_cmd = f"jq -r '.next[] | .pkg_name' dep_tree__{package_name}__install.json | sort | uniq"        output = subprocess.getoutput(parse_cmd)        dependencies = output.strip().split('\n')        return dependencies    except subprocess.CalledProcessError:        return []
def get_rpmname(py_name):    if not py_name.startswith("python-"):        # try python3dist(ABC)        command = f"dnf repoquery --whatprovides 'python3dist({py_name})' --latest-limit 1 --queryformat '%{{NAME}}' -q"        output = subprocess.getoutput(command)
        # try python-ABC        if output == "":            # try lower case            command = f"dnf repoquery --whatprovides 'python3dist({py_name.lower()})' --latest-limit 1 --queryformat '%{{NAME}}' -q"            output = subprocess.getoutput(command)            # last chance            if output == "":                py_name = f"python3-{py_name}"                info_command = f'dnf info python3-{py_name}'                info_result = subprocess.run(info_command.split(), stderr=subprocess.DEVNULL, stdout=subprocess.PIPE, text=True)                if info_result.returncode != 0:                    py_name = "ERROR"        else:            py_name = output
    else:        py_name = py_name[7:]        info_command = f'dnf info python3-{py_name}'        info_result = subprocess.run(info_command.split(), stderr=subprocess.DEVNULL, stdout=subprocess.PIPE, text=True)        if info_result.returncode != 0:            py_name = "ERROR"        else:            py_name = f"python3-{py_name}"
    return py_name

def check_dependencies(package_data):    package_name = package_data['package']['key']    local_dependencies = [get_rpmname(dep['key']) for dep in package_data['dependencies']]    repo_dependencies = get_package_dependencies(package_name)
    missing_dependencies = list(set(repo_dependencies) - set(local_dependencies))    extra_dependencies = list(set(local_dependencies) - set(repo_dependencies))
    #print(local_dependencies)    #print(repo_dependencies)
    # 过滤 FILTERED_DEPENDENCIES 列表中的依赖项    missing_dependencies = [dep for dep in missing_dependencies if dep not in FILTERED_DEPENDENCIES]    extra_dependencies = [dep for dep in extra_dependencies if dep not in FILTERED_DEPENDENCIES]
    print(missing_dependencies)    print(extra_dependencies)
    return {        'package_name': get_rpmname(package_name),        'missing_dependencies': missing_dependencies,        'extra_dependencies': extra_dependencies    }
def main():    with open('packages.json', 'r') as file:        packages_data = json.load(file)
    result = []    for package_data in packages_data:        package_result = check_dependencies(package_data)        result.append(package_result)
    with open('result.json', 'w') as file:        json.dump(result, file, indent=2)
if __name__ == '__main__':    main()

import astimport importlib.metadataimport importlib.resourcesimport jsonimport osimport sysimport re
# 获取内置模块列表builtin_modules = set(sys.builtin_module_names)
def get_standard_library_modules():    lib_path = os.path.dirname(os.__file__)    modules = []
    def add_module(root, file):        module_path = os.path.relpath(os.path.join(root, file), lib_path)        module_name = os.path.splitext(module_path.replace(os.path.sep, '.'))[0]        if module_name.endswith('.__init__'):            module_name = module_name[:-9]        modules.append(module_name)
    for root, dirs, files in os.walk(lib_path):        if 'site-packages' in dirs:            dirs.remove('site-packages')        if root == lib_path:            # 获取第一层的所有 .py 文件名            for file in files:                if file.endswith('.py'):                    add_module(root, file)
        # 处理带有 __init__.py 文件的目录链        if '__init__.py' in files:            add_module(root, '__init__.py')
    return modules
# 添加一些常见的标准库模块builtin_modules.update(get_standard_library_modules())

def parse_imports(file_path):    with open(file_path, 'r') as file:        content = file.read()
    # 移除所有单行注释    content = re.sub(r'#.*', '', content)
    # 移除所有多行注释    content = re.sub(r'""".*?"""', '', content, flags=re.DOTALL)
    # 匹配 import 和 from import 语句    import_re = re.compile(r'(?:from\s+([.\w]+)(?:\s+import\s+[\w, ()]+)|import\s+([\w, ()]+))')    matches = import_re.findall(content)
    imports = []    for match in matches:        # match 是一个元组，其中一个元素是空字符串，另一个元素是模块名        module_names = match[0] if match[0] else match[1]        # 如果模块名以'.'开头，说明是相对导入，我们忽略它        if not module_names.startswith('.'):            module_names = module_names.split(',')            for module_name in module_names:                # 处理别名导入的情况                module_name = module_name.strip().split(' as ')[0].split('.')[0]                if module_name not in builtin_modules and not module_name.startswith('_'):                    imports.append(module_name)
    return imports
def get_package_imports():    package_imports = {}
    dists = importlib.metadata.distributions()    for dist in dists:        package_name = dist.metadata['Name']        try:            package_dir = importlib.resources.files(package_name)            if package_dir is not None:                package_imports[package_name] = {}                for root, dirs, files in os.walk(str(package_dir)):                    for file in files:                        if file.endswith('.py'):                            file_path = os.path.join(root, file)                            imports = parse_imports(file_path)                            # 去重并筛除当前包名                            imports = list(set(imports))                            if package_name in imports:                                imports.remove(package_name)                            package_imports[package_name][file_path] = imports        except:            pass
    return package_imports
# 获取所有包的import信息package_imports = get_package_imports()
# 转换为JSON格式并打印json_data = json.dumps(package_imports, indent=4)print(json_data)
# 读取package.json文件with open('packages.json', 'r') as file:    package_data = json.load(file)
# 检查每个包的imports是否都在dependencies中for package in package_data:    package_name = package['package']['package_name']    if package_name in package_imports:        dependencies = {dep['package_name'] for dep in package['dependencies']}        for file_path, imports in package_imports[package_name].items():            for import_name in imports:                if import_name not in dependencies:                    print(f'In package {package_name}, file {file_path} imports {import_name} which is not in dependencies.')                else:                    print(f'In package {package_name}, file {file_path} imports {import_name} is found in pipdeptree.')

tooz==4.2.0├── fasteners [required: >=0.7, installed: 0.19]├── futurist [required: >=1.2.0, installed: 2.4.1]├── msgpack [required: >=0.4.0, installed: 1.0.5]├── oslo.serialization [required: >=1.10.0, installed: 5.0.0]├── oslo.utils [required: >=4.7.0, installed: 6.0.1]├── pbr [required: >=1.6, installed: 5.11.1]├── stevedore [required: >=1.16.0, installed: 4.0.2]├── tenacity [required: >=5.0.0, installed: 8.2.3]└── voluptuous [required: >=0.8.9, installed: 0.13.1]
In package tooz, file /usr/lib/python3.11/site-packages/tooz/drivers/etcd3.py imports oslo_utils which is not in dependencies.

In package urllib3, file /usr/lib/python3.11/site-packages/urllib3/response.py imports brotli which is not in dependencies.
try:    try:        import brotlicffi as brotli    except ImportError:        import brotliexcept ImportError:    brotli = None

In package zake, file /usr/lib/python3.11/site-packages/zake/test.py imports testtools which is not in dependencies.

In package urllib3, file /usr/lib/python3.11/site-packages/urllib3/contrib/appengine.py imports google which is not in dependencies.In package urllib3, file /usr/lib/python3.11/site-packages/urllib3/contrib/socks.py imports socks which is not in dependencies.In package urllib3, file /usr/lib/python3.11/site-packages/urllib3/contrib/pyopenssl.py imports OpenSSL which is not in dependencies.In package urllib3, file /usr/lib/python3.11/site-packages/urllib3/contrib/pyopenssl.py imports idna which is not in dependencies.In package urllib3, file /usr/lib/python3.11/site-packages/urllib3/contrib/pyopenssl.py imports cryptography which is not in dependencies.In package urllib3, file /usr/lib/python3.11/site-packages/urllib3/contrib/ntlmpool.py imports ntlm which is not in dependencies.

tox==4.10.0├── cachetools [required: Any, installed: 5.3.1]├── chardet [required: >=5.2, installed: 5.2.0]├── colorama [required: >=0.4.6, installed: 0.4.6]├── filelock [required: Any, installed: 3.12.4]├── packaging [required: Any, installed: 23.1]├── platformdirs [required: Any, installed: 2.5.4]├── pluggy [required: Any, installed: 1.3.0]├── pyproject-api [required: Any, installed: 1.5.1]│   └── packaging [required: >=23, installed: 23.1]└── virtualenv [required: >=20, installed: 20.21.1]    ├── distlib [required: >=0.3.6,<1, installed: 0.3.7]    ├── filelock [required: >=3.4.1,<4, installed: 3.12.4]    └── platformdirs [required: >=2.4,<4, installed: 2.5.4]In package tox, file /usr/lib/python3.11/site-packages/tox/tox_env/python/virtual_env/package/pyproject.py imports tomli which is not in dependencies.n package tox, file /usr/lib/python3.11/site-packages/tox/execute/local_sub_process/read_via_thread_unix.py imports select which is not in dependencies.

In package tooz, file /usr/lib/python3.11/site-packages/tooz/drivers/pgsql.py imports psycopg2 which is not in dependencies.In package tooz, file /usr/lib/python3.11/site-packages/tooz/drivers/mysql.py imports pymysql which is not in dependencies.

{    "package_name": "python3-cheroot",    "missing_dependencies": [      "python3-six",      "python3-pyOpenSSL"    ],    "extra_dependencies": []  },

Warning!! Cyclic dependencies found:* sphinxcontrib-serializinghtml => Sphinx => sphinxcontrib-serializinghtml* sphinxcontrib-htmlhelp => Sphinx => sphinxcontrib-htmlhelp* sphinxcontrib-qthelp => Sphinx => sphinxcontrib-qthelp* sphinxcontrib-applehelp => Sphinx => sphinxcontrib-applehelp* sphinxcontrib-devhelp => Sphinx => sphinxcontrib-devhelp* Sphinx => sphinxcontrib-applehelp => Sphinx

from pip._vendor.pkg_resources import DistInfoDistribution

def __init__(self, obj: Distribution, req: ReqPackage | None = None) -> None:        super().__init__(obj.metadata["Name"])

from pip._vendor.pkg_resources import Requirement

def __init__(self, obj: Requirement, dist: DistPackage | None = None) -> None:        super().__init__(obj.name)

iter_installed_distributions(local_only: bool = True, skip: Container[str] = {'python', 'wsgiref', 'argparse'}, include_editables: bool = True, editables_only: bool = False, user_only: bool = False) -> Iterator[pip._internal.metadata.base.BaseDistribution] method of pip._internal.metadata.pkg_resources.Environment instance    Return a list of installed distributions.

from pip._internal.metadata import pkg_resourcesdists = pkg_resources.Environment.from_paths(None).iter_installed_distributions(            local_only=local_only,            skip=(),            user_only=user_only,        )

(myenv) [root@linux ~]# python3 -c "import sys;print(sys.path)"['', '/usr/lib64/python311.zip', '/usr/lib64/python3.11', '/usr/lib64/python3.11/lib-dynload', '/root/myenv/lib64/python3.11/site-packages', '/root/myenv/lib/python3.11/site-packages'](myenv) [root@linux ~]# python3 -c "import sys;print(sys.prefix)"/root/myenv(myenv) [root@linux ~]# python3 -c "import sys;print(sys.base_prefix)"/usr(myenv) [root@linux ~]#

def _running_under_venv() -> bool:    """Checks if sys.base_prefix and sys.prefix match.
    This handles PEP 405 compliant virtual environments.    """    return sys.prefix != getattr(sys, "base_prefix", sys.prefix)

def _running_under_legacy_virtualenv() -> bool:    """Checks if sys.real_prefix is set.
    This handles virtual environments created with pypa's virtualenv.    """    # pypa/virtualenv case    return hasattr(sys, "real_prefix")

def running_under_virtualenv() -> bool:    """True if we're running inside a virtual environment, False otherwise."""    return _running_under_venv() or _running_under_legacy_virtualenv()

in_venv = sys.prefix != sys.base_prefix
    if local_only and in_venv:        venv_site_packages = site.getsitepackages([sys.prefix])        return list(distributions(path=venv_site_packages))

def distributions(**kwargs):    """Get all ``Distribution`` instances in the current environment.
    :return: An iterable of ``Distribution`` instances.    """    return Distribution.discover(**kwargs)

[root@linux ~]# python3 -c "import sys; print(sys.meta_path)"[<_distutils_hack.DistutilsMetaFinder object at 0x7f124cd15bd0>, <class '_frozen_importlib.BuiltinImporter'>, <class '_frozen_importlib.FrozenImporter'>, <class '_frozen_importlib_external.PathFinder'>]

if user_only:        return list(distributions(path=[site.getusersitepackages()]))

@property    def requires(self):        """Generated requirements specified for this Distribution"""        reqs = self._read_dist_info_reqs() or self._read_egg_info_reqs()        return reqs and list(reqs)

def requires(self) -> list[Requirement]:        req_list = []        req_name_list = []        if self._obj.requires:            for r in self._obj.requires:                req = Requirement(r)                is_extra_req = req.marker and contains_extra(str(req.marker))                if not is_extra_req and req.name not in req_name_list:                    req_list.append(req)                    req_name_list.append(req.name)        return req_list

"pytest ; extra == 'tests'"

pip install CT3[markdown]

Provides-Extra: filtersRequires-Dist: markdown ; extra == 'filters'Provides-Extra: markdownRequires-Dist: markdown ; extra == 'markdown'

@property    def editable(self) -> bool:        return bool(self.editable_project_location)
    @property    def direct_url(self) -> DirectUrl | None:        direct_url_metadata_name = "direct_url.json"        result = None
        try:            j_content = self._obj.read_text(direct_url_metadata_name)        except FileNotFoundError:  # pragma: no cover            return result        try:            if j_content:                result = DirectUrl.from_json(j_content)
        except (            UnicodeDecodeError,            json.JSONDecodeError,            DirectUrlValidationError,        ):            return result        return result
    @property    def raw_name(self) -> str:        return self.project_name
    @property    def editable_project_location(self) -> str | None:        direct_url = self.direct_url        if direct_url and direct_url.is_local_editable():            from pip._internal.utils.urls import url_to_path  # noqa: PLC2701, PLC0415
            return url_to_path(direct_url.url)
        result = None        egg_link_path = egg_link_path_from_sys_path(self.raw_name)        if egg_link_path:            with Path(egg_link_path).open("r") as f:                result = f.readline().rstrip()        return result

# pip install -e munkres-1.1.4/

# ls /usr/local/lib/python3.11/site-packages/munkres-1.1.4.dist-info/INSTALLER  LICENSE.md  METADATA  RECORD  REQUESTED  WHEEL  direct_url.json  top_level.txt

{"dir_info": {"editable": true}, "url": "file:///data/gitee/python-munkres/munkres-1.1.4"}

running egg_infowriting munkres.egg-info/PKG-INFOwriting dependency_links to munkres.egg-info/dependency_links.txtwriting top-level names to munkres.egg-info/top_level.txtreading manifest file 'munkres.egg-info/SOURCES.txt'reading manifest template 'MANIFEST.in'adding license file 'LICENSE.md'writing manifest file 'munkres.egg-info/SOURCES.txt'running build_extCreating /usr/local/lib/python3.11/site-packages/munkres.egg-link (link to .)munkres 1.1.4 is already the active version in easy-install.pth
Installed /data/gitee/python-munkres/munkres-1.1.4Processing dependencies for munkres==1.1.4Finished processing dependencies for munkres==1.1.4

# cat /usr/local/lib/python3.11/site-packages/munkres.egg-link/data/gitee/python-munkres/munkres-1.1.4.

@property    def editable_project_location(self) -> str | None:        if self.direct_url:            from pip._internal.utils.urls import url_to_path  # noqa: PLC2701, PLC0415
            return url_to_path(self.direct_url)
        egg_link_path = egg_link_path_from_sys_path(self.raw_name)        if egg_link_path:            with Path(egg_link_path).open("r") as f:                location = f.readline().rstrip()            return location        return None

@property    def version_spec(self) -> str | None:        result = None        specs = sorted(map(str, self._obj.specifier), reverse=True)        if specs:            result = ",".join(specs)        return result

if ver_spec:            req_obj = SpecifierSet(ver_spec)        else:            return False
        return self.installed_version not in req_obj

foo.read_text = Mock(return_value=json_text)

foo = Mock(metadata={"Name": "foo"}, version="20.4.1")

def test_dist_package_render_as_root_with_frozen() -> None:    json_text = '{"dir_info": {"editable": true}, "url": "file:///A/B/foo"}'    foo = Mock(metadata={"Name": "foo"}, version="20.4.1")    foo.read_text = Mock(return_value=json_text)    dp = DistPackage(foo)    is_frozen = True    expect = "# Editable install with no version control (foo===20.4.1)\n-e /A/B/foo"    assert dp.render_as_root(frozen=is_frozen) == expect

-    result = ReqPackage(mocker.MagicMock(key="setuptools")).installed_version+    r = MagicMock()+    r.name = "setuptools"+    result = ReqPackage(r).installed_version

out, _ = capfd.readouterr()

-        expected = {"pip", "setuptools", "wheel"}+        expected = {"packaging", "pip", "setuptools", "wheel"}

packaging_src = getsourcefile(sys.modules["packaging"])assert packaging_src is not Nonepackaging_root = Path(packaging_src).parentcopytree(packaging_root, dest / "packaging")cmd = [str(py_path), "-m", "pipdeptree", *argv]env = os.environ.copy()return call(cmd, cwd=project, env=env)

By default, as initialized upon program startup, a potentially unsafe path is prepended to [`sys.path`](https://docs.python.org/3/library/sys.html#sys.path) (before the entries inserted as a result of [`PYTHONPATH`](https://docs.python.org/3/using/cmdline.html#envvar-PYTHONPATH)):- `python -m module` command line: prepend the current working directory.- `python script.py` command line: prepend the script’s directory. If it’s a symbolic link, resolve symbolic links.- `python -c code` and `python` (REPL) command lines: prepend an empty string, which means the current working directory.

def test_local_only(    tmp_path: Path,    monkeypatch: pytest.MonkeyPatch,    capfd: pytest.CaptureFixture[str],) -> None:    prefix = str(tmp_path / "venv")    result = virtualenv.cli_run([str(tmp_path / "venv"), "--activators", ""])    pip_path = str(result.creator.exe.parent / "pip")    subprocess.run(        [pip_path, "install", "wrapt", "--prefix", prefix],        stdout=subprocess.DEVNULL,        stderr=subprocess.DEVNULL,        check=False,    )    cmd = [str(result.creator.exe.parent / "python3")]    monkeypatch.chdir(tmp_path)    cmd += ["--local-only"]    monkeypatch.setattr(sys, "prefix", [str(tmp_path / "venv")])    monkeypatch.setattr(sys, "argv", cmd)    main()    out, _ = capfd.readouterr()    found = {i.split("==")[0] for i in out.splitlines()}    expected = {"wrapt", "pip", "setuptools", "wheel"}
    if sys.version_info >= (3, 12):        expected -= {"setuptools", "wheel"}  # pragma: no cover
    assert found == expected