py2docfx 0.1.11.dev1830301__py3-none-any.whl → 0.1.11.dev1860114__py3-none-any.whl

py2docfx/venv/template/Lib/site-packages/setuptools/tests/config/test_apply_pyprojecttoml.py

@@ -1,466 +0,0 @@
-"""Make sure that applying the configuration from pyproject.toml is equivalent to
-applying a similar configuration from setup.cfg
-
-To run these tests offline, please have a look on ``./downloads/preload.py``
-"""
-
-from __future__ import annotations
-
-import io
-import re
-import tarfile
-from inspect import cleandoc
-from pathlib import Path
-from unittest.mock import Mock
-
-import pytest
-from ini2toml.api import LiteTranslator
-
-from packaging.metadata import Metadata
-
-import setuptools  # noqa ensure monkey patch to metadata
-from setuptools.dist import Distribution
-from setuptools.config import setupcfg, pyprojecttoml
-from setuptools.config import expand
-from setuptools.config._apply_pyprojecttoml import _MissingDynamic, _some_attrgetter
-from setuptools.command.egg_info import write_requirements
-from setuptools.errors import RemovedConfigError
-
-from .downloads import retrieve_file, urls_from_file
-
-
-HERE = Path(__file__).parent
-EXAMPLES_FILE = "setupcfg_examples.txt"
-
-
-def makedist(path, **attrs):
-    return Distribution({"src_root": path, **attrs})
-
-
-@pytest.mark.parametrize("url", urls_from_file(HERE / EXAMPLES_FILE))
-@pytest.mark.filterwarnings("ignore")
-@pytest.mark.uses_network
-def test_apply_pyproject_equivalent_to_setupcfg(url, monkeypatch, tmp_path):
-    monkeypatch.setattr(expand, "read_attr", Mock(return_value="0.0.1"))
-    setupcfg_example = retrieve_file(url)
-    pyproject_example = Path(tmp_path, "pyproject.toml")
-    setupcfg_text = setupcfg_example.read_text(encoding="utf-8")
-    toml_config = LiteTranslator().translate(setupcfg_text, "setup.cfg")
-    pyproject_example.write_text(toml_config, encoding="utf-8")
-
-    dist_toml = pyprojecttoml.apply_configuration(makedist(tmp_path), pyproject_example)
-    dist_cfg = setupcfg.apply_configuration(makedist(tmp_path), setupcfg_example)
-
-    pkg_info_toml = core_metadata(dist_toml)
-    pkg_info_cfg = core_metadata(dist_cfg)
-    assert pkg_info_toml == pkg_info_cfg
-
-    if any(getattr(d, "license_files", None) for d in (dist_toml, dist_cfg)):
-        assert set(dist_toml.license_files) == set(dist_cfg.license_files)
-
-    if any(getattr(d, "entry_points", None) for d in (dist_toml, dist_cfg)):
-        print(dist_cfg.entry_points)
-        ep_toml = {
-            (k, *sorted(i.replace(" ", "") for i in v))
-            for k, v in dist_toml.entry_points.items()
-        }
-        ep_cfg = {
-            (k, *sorted(i.replace(" ", "") for i in v))
-            for k, v in dist_cfg.entry_points.items()
-        }
-        assert ep_toml == ep_cfg
-
-    if any(getattr(d, "package_data", None) for d in (dist_toml, dist_cfg)):
-        pkg_data_toml = {(k, *sorted(v)) for k, v in dist_toml.package_data.items()}
-        pkg_data_cfg = {(k, *sorted(v)) for k, v in dist_cfg.package_data.items()}
-        assert pkg_data_toml == pkg_data_cfg
-
-    if any(getattr(d, "data_files", None) for d in (dist_toml, dist_cfg)):
-        data_files_toml = {(k, *sorted(v)) for k, v in dist_toml.data_files}
-        data_files_cfg = {(k, *sorted(v)) for k, v in dist_cfg.data_files}
-        assert data_files_toml == data_files_cfg
-
-    assert set(dist_toml.install_requires) == set(dist_cfg.install_requires)
-    if any(getattr(d, "extras_require", None) for d in (dist_toml, dist_cfg)):
-        extra_req_toml = {(k, *sorted(v)) for k, v in dist_toml.extras_require.items()}
-        extra_req_cfg = {(k, *sorted(v)) for k, v in dist_cfg.extras_require.items()}
-        assert extra_req_toml == extra_req_cfg
-
-
-PEP621_EXAMPLE = """\
-[project]
-name = "spam"
-version = "2020.0.0"
-description = "Lovely Spam! Wonderful Spam!"
-readme = "README.rst"
-requires-python = ">=3.8"
-license = {file = "LICENSE.txt"}
-keywords = ["egg", "bacon", "sausage", "tomatoes", "Lobster Thermidor"]
-authors = [
-  {email = "hi@pradyunsg.me"},
-  {name = "Tzu-Ping Chung"}
-]
-maintainers = [
-  {name = "Brett Cannon", email = "brett@python.org"},
-  {name = "John X. Ãørçeč", email = "john@utf8.org"},
-  {name = "Γαμα קּ 東", email = "gama@utf8.org"},
-]
-classifiers = [
-  "Development Status :: 4 - Beta",
-  "Programming Language :: Python"
-]
-
-dependencies = [
-  "httpx",
-  "gidgethub[httpx]>4.0.0",
-  "django>2.1; os_name != 'nt'",
-  "django>2.0; os_name == 'nt'"
-]
-
-[project.optional-dependencies]
-test = [
-  "pytest < 5.0.0",
-  "pytest-cov[all]"
-]
-
-[project.urls]
-homepage = "http://example.com"
-documentation = "http://readthedocs.org"
-repository = "http://github.com"
-changelog = "http://github.com/me/spam/blob/master/CHANGELOG.md"
-
-[project.scripts]
-spam-cli = "spam:main_cli"
-
-[project.gui-scripts]
-spam-gui = "spam:main_gui"
-
-[project.entry-points."spam.magical"]
-tomatoes = "spam:main_tomatoes"
-"""
-
-PEP621_INTERNATIONAL_EMAIL_EXAMPLE = """\
-[project]
-name = "spam"
-version = "2020.0.0"
-authors = [
-  {email = "hi@pradyunsg.me"},
-  {name = "Tzu-Ping Chung"}
-]
-maintainers = [
-  {name = "Степан Бандера", email = "криївка@оун-упа.укр"},
-]
-"""
-
-PEP621_EXAMPLE_SCRIPT = """
-def main_cli(): pass
-def main_gui(): pass
-def main_tomatoes(): pass
-"""
-
-
-def _pep621_example_project(
-    tmp_path,
-    readme="README.rst",
-    pyproject_text=PEP621_EXAMPLE,
-):
-    pyproject = tmp_path / "pyproject.toml"
-    text = pyproject_text
-    replacements = {'readme = "README.rst"': f'readme = "{readme}"'}
-    for orig, subst in replacements.items():
-        text = text.replace(orig, subst)
-    pyproject.write_text(text, encoding="utf-8")
-
-    (tmp_path / readme).write_text("hello world", encoding="utf-8")
-    (tmp_path / "LICENSE.txt").write_text("--- LICENSE stub ---", encoding="utf-8")
-    (tmp_path / "spam.py").write_text(PEP621_EXAMPLE_SCRIPT, encoding="utf-8")
-    return pyproject
-
-
-def test_pep621_example(tmp_path):
-    """Make sure the example in PEP 621 works"""
-    pyproject = _pep621_example_project(tmp_path)
-    dist = pyprojecttoml.apply_configuration(makedist(tmp_path), pyproject)
-    assert dist.metadata.license == "--- LICENSE stub ---"
-    assert set(dist.metadata.license_files) == {"LICENSE.txt"}
-
-
-@pytest.mark.parametrize(
-    "readme, ctype",
-    [
-        ("Readme.txt", "text/plain"),
-        ("readme.md", "text/markdown"),
-        ("text.rst", "text/x-rst"),
-    ],
-)
-def test_readme_content_type(tmp_path, readme, ctype):
-    pyproject = _pep621_example_project(tmp_path, readme)
-    dist = pyprojecttoml.apply_configuration(makedist(tmp_path), pyproject)
-    assert dist.metadata.long_description_content_type == ctype
-
-
-def test_undefined_content_type(tmp_path):
-    pyproject = _pep621_example_project(tmp_path, "README.tex")
-    with pytest.raises(ValueError, match="Undefined content type for README.tex"):
-        pyprojecttoml.apply_configuration(makedist(tmp_path), pyproject)
-
-
-def test_no_explicit_content_type_for_missing_extension(tmp_path):
-    pyproject = _pep621_example_project(tmp_path, "README")
-    dist = pyprojecttoml.apply_configuration(makedist(tmp_path), pyproject)
-    assert dist.metadata.long_description_content_type is None
-
-
-@pytest.mark.parametrize(
-    ('pyproject_text', 'expected_maintainers_meta_value'),
-    (
-        pytest.param(
-            PEP621_EXAMPLE,
-            (
-                'Brett Cannon <brett@python.org>, "John X. Ãørçeč" <john@utf8.org>, '
-                'Γαμα קּ 東 <gama@utf8.org>'
-            ),
-            id='non-international-emails',
-        ),
-        pytest.param(
-            PEP621_INTERNATIONAL_EMAIL_EXAMPLE,
-            'Степан Бандера <криївка@оун-упа.укр>',
-            marks=pytest.mark.xfail(
-                reason="CPython's `email.headerregistry.Address` only supports "
-                'RFC 5322, as of Nov 10, 2022 and latest Python 3.11.0',
-                strict=True,
-            ),
-            id='international-email',
-        ),
-    ),
-)
-def test_utf8_maintainer_in_metadata(  # issue-3663
-    expected_maintainers_meta_value,
-    pyproject_text,
-    tmp_path,
-):
-    pyproject = _pep621_example_project(
-        tmp_path,
-        "README",
-        pyproject_text=pyproject_text,
-    )
-    dist = pyprojecttoml.apply_configuration(makedist(tmp_path), pyproject)
-    assert dist.metadata.maintainer_email == expected_maintainers_meta_value
-    pkg_file = tmp_path / "PKG-FILE"
-    with open(pkg_file, "w", encoding="utf-8") as fh:
-        dist.metadata.write_pkg_file(fh)
-    content = pkg_file.read_text(encoding="utf-8")
-    assert f"Maintainer-email: {expected_maintainers_meta_value}" in content
-
-
-class TestLicenseFiles:
-    # TODO: After PEP 639 is accepted, we have to move the license-files
-    #       to the `project` table instead of `tool.setuptools`
-
-    def base_pyproject(self, tmp_path, additional_text):
-        pyproject = _pep621_example_project(tmp_path, "README")
-        text = pyproject.read_text(encoding="utf-8")
-
-        # Sanity-check
-        assert 'license = {file = "LICENSE.txt"}' in text
-        assert "[tool.setuptools]" not in text
-
-        text = f"{text}\n{additional_text}\n"
-        pyproject.write_text(text, encoding="utf-8")
-        return pyproject
-
-    def test_both_license_and_license_files_defined(self, tmp_path):
-        setuptools_config = '[tool.setuptools]\nlicense-files = ["_FILE*"]'
-        pyproject = self.base_pyproject(tmp_path, setuptools_config)
-
-        (tmp_path / "_FILE.txt").touch()
-        (tmp_path / "_FILE.rst").touch()
-
-        # Would normally match the `license_files` patterns, but we want to exclude it
-        # by being explicit. On the other hand, contents should be added to `license`
-        license = tmp_path / "LICENSE.txt"
-        license.write_text("LicenseRef-Proprietary\n", encoding="utf-8")
-
-        dist = pyprojecttoml.apply_configuration(makedist(tmp_path), pyproject)
-        assert set(dist.metadata.license_files) == {"_FILE.rst", "_FILE.txt"}
-        assert dist.metadata.license == "LicenseRef-Proprietary\n"
-
-    def test_default_patterns(self, tmp_path):
-        setuptools_config = '[tool.setuptools]\nzip-safe = false'
-        # ^ used just to trigger section validation
-        pyproject = self.base_pyproject(tmp_path, setuptools_config)
-
-        license_files = "LICENCE-a.html COPYING-abc.txt AUTHORS-xyz NOTICE,def".split()
-
-        for fname in license_files:
-            (tmp_path / fname).write_text(f"{fname}\n", encoding="utf-8")
-
-        dist = pyprojecttoml.apply_configuration(makedist(tmp_path), pyproject)
-        assert (tmp_path / "LICENSE.txt").exists()  # from base example
-        assert set(dist.metadata.license_files) == {*license_files, "LICENSE.txt"}
-
-
-class TestDeprecatedFields:
-    def test_namespace_packages(self, tmp_path):
-        pyproject = tmp_path / "pyproject.toml"
-        config = """
-        [project]
-        name = "myproj"
-        version = "42"
-        [tool.setuptools]
-        namespace-packages = ["myproj.pkg"]
-        """
-        pyproject.write_text(cleandoc(config), encoding="utf-8")
-        with pytest.raises(RemovedConfigError, match="namespace-packages"):
-            pyprojecttoml.apply_configuration(makedist(tmp_path), pyproject)
-
-
-class TestPresetField:
-    def pyproject(self, tmp_path, dynamic, extra_content=""):
-        content = f"[project]\nname = 'proj'\ndynamic = {dynamic!r}\n"
-        if "version" not in dynamic:
-            content += "version = '42'\n"
-        file = tmp_path / "pyproject.toml"
-        file.write_text(content + extra_content, encoding="utf-8")
-        return file
-
-    @pytest.mark.parametrize(
-        "attr, field, value",
-        [
-            ("classifiers", "classifiers", ["Private :: Classifier"]),
-            ("entry_points", "scripts", {"console_scripts": ["foobar=foobar:main"]}),
-            ("entry_points", "gui-scripts", {"gui_scripts": ["bazquux=bazquux:main"]}),
-            pytest.param(
-                *("install_requires", "dependencies", ["six"]),
-                marks=[
-                    pytest.mark.filterwarnings("ignore:.*install_requires. overwritten")
-                ],
-            ),
-        ],
-    )
-    def test_not_listed_in_dynamic(self, tmp_path, attr, field, value):
-        """Setuptools cannot set a field if not listed in ``dynamic``"""
-        pyproject = self.pyproject(tmp_path, [])
-        dist = makedist(tmp_path, **{attr: value})
-        msg = re.compile(f"defined outside of `pyproject.toml`:.*{field}", re.S)
-        with pytest.warns(_MissingDynamic, match=msg):
-            dist = pyprojecttoml.apply_configuration(dist, pyproject)
-
-        dist_value = _some_attrgetter(f"metadata.{attr}", attr)(dist)
-        assert not dist_value
-
-    @pytest.mark.parametrize(
-        "attr, field, value",
-        [
-            ("install_requires", "dependencies", []),
-            ("extras_require", "optional-dependencies", {}),
-            ("install_requires", "dependencies", ["six"]),
-            ("classifiers", "classifiers", ["Private :: Classifier"]),
-        ],
-    )
-    def test_listed_in_dynamic(self, tmp_path, attr, field, value):
-        pyproject = self.pyproject(tmp_path, [field])
-        dist = makedist(tmp_path, **{attr: value})
-        dist = pyprojecttoml.apply_configuration(dist, pyproject)
-        dist_value = _some_attrgetter(f"metadata.{attr}", attr)(dist)
-        assert dist_value == value
-
-    def test_warning_overwritten_dependencies(self, tmp_path):
-        src = "[project]\nname='pkg'\nversion='0.1'\ndependencies=['click']\n"
-        pyproject = tmp_path / "pyproject.toml"
-        pyproject.write_text(src, encoding="utf-8")
-        dist = makedist(tmp_path, install_requires=["wheel"])
-        with pytest.warns(match="`install_requires` overwritten"):
-            dist = pyprojecttoml.apply_configuration(dist, pyproject)
-        assert "wheel" not in dist.install_requires
-
-    def test_optional_dependencies_dont_remove_env_markers(self, tmp_path):
-        """
-        Internally setuptools converts dependencies with markers to "extras".
-        If ``install_requires`` is given by ``setup.py``, we have to ensure that
-        applying ``optional-dependencies`` does not overwrite the mandatory
-        dependencies with markers (see #3204).
-        """
-        # If setuptools replace its internal mechanism that uses `requires.txt`
-        # this test has to be rewritten to adapt accordingly
-        extra = "\n[project.optional-dependencies]\nfoo = ['bar>1']\n"
-        pyproject = self.pyproject(tmp_path, ["dependencies"], extra)
-        install_req = ['importlib-resources (>=3.0.0) ; python_version < "3.7"']
-        dist = makedist(tmp_path, install_requires=install_req)
-        dist = pyprojecttoml.apply_configuration(dist, pyproject)
-        assert "foo" in dist.extras_require
-        egg_info = dist.get_command_obj("egg_info")
-        write_requirements(egg_info, tmp_path, tmp_path / "requires.txt")
-        reqs = (tmp_path / "requires.txt").read_text(encoding="utf-8")
-        assert "importlib-resources" in reqs
-        assert "bar" in reqs
-        assert ':python_version < "3.7"' in reqs
-
-    @pytest.mark.parametrize(
-        "field,group", [("scripts", "console_scripts"), ("gui-scripts", "gui_scripts")]
-    )
-    @pytest.mark.filterwarnings("error")
-    def test_scripts_dont_require_dynamic_entry_points(self, tmp_path, field, group):
-        # Issue 3862
-        pyproject = self.pyproject(tmp_path, [field])
-        dist = makedist(tmp_path, entry_points={group: ["foobar=foobar:main"]})
-        dist = pyprojecttoml.apply_configuration(dist, pyproject)
-        assert group in dist.entry_points
-
-
-class TestMeta:
-    def test_example_file_in_sdist(self, setuptools_sdist):
-        """Meta test to ensure tests can run from sdist"""
-        with tarfile.open(setuptools_sdist) as tar:
-            assert any(name.endswith(EXAMPLES_FILE) for name in tar.getnames())
-
-
-class TestInteropCommandLineParsing:
-    def test_version(self, tmp_path, monkeypatch, capsys):
-        # See pypa/setuptools#4047
-        # This test can be removed once the CLI interface of setup.py is removed
-        monkeypatch.chdir(tmp_path)
-        toml_config = """
-        [project]
-        name = "test"
-        version = "42.0"
-        """
-        pyproject = Path(tmp_path, "pyproject.toml")
-        pyproject.write_text(cleandoc(toml_config), encoding="utf-8")
-        opts = {"script_args": ["--version"]}
-        dist = pyprojecttoml.apply_configuration(Distribution(opts), pyproject)
-        dist.parse_command_line()  # <-- there should be no exception here.
-        captured = capsys.readouterr()
-        assert "42.0" in captured.out
-
-
-# --- Auxiliary Functions ---
-
-
-def core_metadata(dist) -> str:
-    with io.StringIO() as buffer:
-        dist.metadata.write_pkg_file(buffer)
-        pkg_file_txt = buffer.getvalue()
-
-    # Make sure core metadata is valid
-    Metadata.from_email(pkg_file_txt, validate=True)  # can raise exceptions
-
-    skip_prefixes: tuple[str, ...] = ()
-    skip_lines = set()
-    # ---- DIFF NORMALISATION ----
-    # PEP 621 is very particular about author/maintainer metadata conversion, so skip
-    skip_prefixes += ("Author:", "Author-email:", "Maintainer:", "Maintainer-email:")
-    # May be redundant with Home-page
-    skip_prefixes += ("Project-URL: Homepage,", "Home-page:")
-    # May be missing in original (relying on default) but backfilled in the TOML
-    skip_prefixes += ("Description-Content-Type:",)
-    # Remove empty lines
-    skip_lines.add("")
-
-    result = []
-    for line in pkg_file_txt.splitlines():
-        if line.startswith(skip_prefixes) or line in skip_lines:
-            continue
-        result.append(line + "\n")
-
-    return "".join(result)

py2docfx/venv/template/Lib/site-packages/setuptools/tests/config/test_expand.py

@@ -1,220 +0,0 @@
-import os
-import sys
-from pathlib import Path
-
-import pytest
-
-from distutils.errors import DistutilsOptionError
-from setuptools.config import expand
-from setuptools.discovery import find_package_path
-
-
-def write_files(files, root_dir):
-    for file, content in files.items():
-        path = root_dir / file
-        path.parent.mkdir(exist_ok=True, parents=True)
-        path.write_text(content, encoding="utf-8")
-
-
-def test_glob_relative(tmp_path, monkeypatch):
-    files = {
-        "dir1/dir2/dir3/file1.txt",
-        "dir1/dir2/file2.txt",
-        "dir1/file3.txt",
-        "a.ini",
-        "b.ini",
-        "dir1/c.ini",
-        "dir1/dir2/a.ini",
-    }
-
-    write_files({k: "" for k in files}, tmp_path)
-    patterns = ["**/*.txt", "[ab].*", "**/[ac].ini"]
-    monkeypatch.chdir(tmp_path)
-    assert set(expand.glob_relative(patterns)) == files
-    # Make sure the same APIs work outside cwd
-    assert set(expand.glob_relative(patterns, tmp_path)) == files
-
-
-def test_read_files(tmp_path, monkeypatch):
-    dir_ = tmp_path / "dir_"
-    (tmp_path / "_dir").mkdir(exist_ok=True)
-    (tmp_path / "a.txt").touch()
-    files = {"a.txt": "a", "dir1/b.txt": "b", "dir1/dir2/c.txt": "c"}
-    write_files(files, dir_)
-
-    secrets = Path(str(dir_) + "secrets")
-    secrets.mkdir(exist_ok=True)
-    write_files({"secrets.txt": "secret keys"}, secrets)
-
-    with monkeypatch.context() as m:
-        m.chdir(dir_)
-        assert expand.read_files(list(files)) == "a\nb\nc"
-
-        cannot_access_msg = r"Cannot access '.*\.\..a\.txt'"
-        with pytest.raises(DistutilsOptionError, match=cannot_access_msg):
-            expand.read_files(["../a.txt"])
-
-        cannot_access_secrets_msg = r"Cannot access '.*secrets\.txt'"
-        with pytest.raises(DistutilsOptionError, match=cannot_access_secrets_msg):
-            expand.read_files(["../dir_secrets/secrets.txt"])
-
-    # Make sure the same APIs work outside cwd
-    assert expand.read_files(list(files), dir_) == "a\nb\nc"
-    with pytest.raises(DistutilsOptionError, match=cannot_access_msg):
-        expand.read_files(["../a.txt"], dir_)
-
-
-class TestReadAttr:
-    @pytest.mark.parametrize(
-        "example",
-        [
-            # No cookie means UTF-8:
-            b"__version__ = '\xc3\xa9'\nraise SystemExit(1)\n",
-            # If a cookie is present, honor it:
-            b"# -*- coding: utf-8 -*-\n__version__ = '\xc3\xa9'\nraise SystemExit(1)\n",
-            b"# -*- coding: latin1 -*-\n__version__ = '\xe9'\nraise SystemExit(1)\n",
-        ],
-    )
-    def test_read_attr_encoding_cookie(self, example, tmp_path):
-        (tmp_path / "mod.py").write_bytes(example)
-        assert expand.read_attr('mod.__version__', root_dir=tmp_path) == 'é'
-
-    def test_read_attr(self, tmp_path, monkeypatch):
-        files = {
-            "pkg/__init__.py": "",
-            "pkg/sub/__init__.py": "VERSION = '0.1.1'",
-            "pkg/sub/mod.py": (
-                "VALUES = {'a': 0, 'b': {42}, 'c': (0, 1, 1)}\nraise SystemExit(1)"
-            ),
-        }
-        write_files(files, tmp_path)
-
-        with monkeypatch.context() as m:
-            m.chdir(tmp_path)
-            # Make sure it can read the attr statically without evaluating the module
-            assert expand.read_attr('pkg.sub.VERSION') == '0.1.1'
-            values = expand.read_attr('lib.mod.VALUES', {'lib': 'pkg/sub'})
-
-        assert values['a'] == 0
-        assert values['b'] == {42}
-
-        # Make sure the same APIs work outside cwd
-        assert expand.read_attr('pkg.sub.VERSION', root_dir=tmp_path) == '0.1.1'
-        values = expand.read_attr('lib.mod.VALUES', {'lib': 'pkg/sub'}, tmp_path)
-        assert values['c'] == (0, 1, 1)
-
-    @pytest.mark.parametrize(
-        "example",
-        [
-            "VERSION: str\nVERSION = '0.1.1'\nraise SystemExit(1)\n",
-            "VERSION: str = '0.1.1'\nraise SystemExit(1)\n",
-        ],
-    )
-    def test_read_annotated_attr(self, tmp_path, example):
-        files = {
-            "pkg/__init__.py": "",
-            "pkg/sub/__init__.py": example,
-        }
-        write_files(files, tmp_path)
-        # Make sure this attribute can be read statically
-        assert expand.read_attr('pkg.sub.VERSION', root_dir=tmp_path) == '0.1.1'
-
-    def test_import_order(self, tmp_path):
-        """
-        Sometimes the import machinery will import the parent package of a nested
-        module, which triggers side-effects and might create problems (see issue #3176)
-
-        ``read_attr`` should bypass these limitations by resolving modules statically
-        (via ast.literal_eval).
-        """
-        files = {
-            "src/pkg/__init__.py": "from .main import func\nfrom .about import version",
-            "src/pkg/main.py": "import super_complicated_dep\ndef func(): return 42",
-            "src/pkg/about.py": "version = '42'",
-        }
-        write_files(files, tmp_path)
-        attr_desc = "pkg.about.version"
-        package_dir = {"": "src"}
-        # `import super_complicated_dep` should not run, otherwise the build fails
-        assert expand.read_attr(attr_desc, package_dir, tmp_path) == "42"
-
-
-@pytest.mark.parametrize(
-    'package_dir, file, module, return_value',
-    [
-        ({"": "src"}, "src/pkg/main.py", "pkg.main", 42),
-        ({"pkg": "lib"}, "lib/main.py", "pkg.main", 13),
-        ({}, "single_module.py", "single_module", 70),
-        ({}, "flat_layout/pkg.py", "flat_layout.pkg", 836),
-    ],
-)
-def test_resolve_class(monkeypatch, tmp_path, package_dir, file, module, return_value):
-    monkeypatch.setattr(sys, "modules", {})  # reproducibility
-    files = {file: f"class Custom:\n    def testing(self): return {return_value}"}
-    write_files(files, tmp_path)
-    cls = expand.resolve_class(f"{module}.Custom", package_dir, tmp_path)
-    assert cls().testing() == return_value
-
-
-@pytest.mark.parametrize(
-    'args, pkgs',
-    [
-        ({"where": ["."], "namespaces": False}, {"pkg", "other"}),
-        ({"where": [".", "dir1"], "namespaces": False}, {"pkg", "other", "dir2"}),
-        ({"namespaces": True}, {"pkg", "other", "dir1", "dir1.dir2"}),
-        ({}, {"pkg", "other", "dir1", "dir1.dir2"}),  # default value for `namespaces`
-    ],
-)
-def test_find_packages(tmp_path, args, pkgs):
-    files = {
-        "pkg/__init__.py",
-        "other/__init__.py",
-        "dir1/dir2/__init__.py",
-    }
-    write_files({k: "" for k in files}, tmp_path)
-
-    package_dir = {}
-    kwargs = {"root_dir": tmp_path, "fill_package_dir": package_dir, **args}
-    where = kwargs.get("where", ["."])
-    assert set(expand.find_packages(**kwargs)) == pkgs
-    for pkg in pkgs:
-        pkg_path = find_package_path(pkg, package_dir, tmp_path)
-        assert os.path.exists(pkg_path)
-
-    # Make sure the same APIs work outside cwd
-    where = [
-        str((tmp_path / p).resolve()).replace(os.sep, "/")  # ensure posix-style paths
-        for p in args.pop("where", ["."])
-    ]
-
-    assert set(expand.find_packages(where=where, **args)) == pkgs
-
-
-@pytest.mark.parametrize(
-    "files, where, expected_package_dir",
-    [
-        (["pkg1/__init__.py", "pkg1/other.py"], ["."], {}),
-        (["pkg1/__init__.py", "pkg2/__init__.py"], ["."], {}),
-        (["src/pkg1/__init__.py", "src/pkg1/other.py"], ["src"], {"": "src"}),
-        (["src/pkg1/__init__.py", "src/pkg2/__init__.py"], ["src"], {"": "src"}),
-        (
-            ["src1/pkg1/__init__.py", "src2/pkg2/__init__.py"],
-            ["src1", "src2"],
-            {"pkg1": "src1/pkg1", "pkg2": "src2/pkg2"},
-        ),
-        (
-            ["src/pkg1/__init__.py", "pkg2/__init__.py"],
-            ["src", "."],
-            {"pkg1": "src/pkg1"},
-        ),
-    ],
-)
-def test_fill_package_dir(tmp_path, files, where, expected_package_dir):
-    write_files({k: "" for k in files}, tmp_path)
-    pkg_dir = {}
-    kwargs = {"root_dir": tmp_path, "fill_package_dir": pkg_dir, "namespaces": False}
-    pkgs = expand.find_packages(where=where, **kwargs)
-    assert set(pkg_dir.items()) == set(expected_package_dir.items())
-    for pkg in pkgs:
-        pkg_path = find_package_path(pkg, pkg_dir, tmp_path)
-        assert os.path.exists(pkg_path)