py2docfx 0.1.16.dev2064350__py3-none-any.whl → 0.1.17__py3-none-any.whl

py2docfx/venv/venv1/Lib/site-packages/setuptools/tests/fixtures.py

@@ -1,13 +1,20 @@
 import contextlib
+import io
 import os
 import subprocess
 import sys
+import tarfile
+import time
 from pathlib import Path
 
+import jaraco.path
 import path
 import pytest
 
+from setuptools._normalization import safer_name
+
 from . import contexts, environment
+from .textwrap import DALS
 
 
 @pytest.fixture
@@ -60,6 +67,12 @@ def sample_project(tmp_path):
     return tmp_path / 'sampleproject'
 
 
+@pytest.fixture
+def sample_project_cwd(sample_project):
+    with path.Path(sample_project):
+        yield
+
+
 # sdist and wheel artifacts should be stable across a round of tests
 # so we can build them once per session and use the files as "readonly"
 
@@ -155,3 +168,225 @@ def bare_venv(tmp_path):
     env.create_opts = ['--no-setuptools', '--no-pip', '--no-wheel', '--no-seed']
     env.ensure_env()
     return env
+
+
+def make_sdist(dist_path, files):
+    """
+    Create a simple sdist tarball at dist_path, containing the files
+    listed in ``files`` as ``(filename, content)`` tuples.
+    """
+
+    # Distributions with only one file don't play well with pip.
+    assert len(files) > 1
+    with tarfile.open(dist_path, 'w:gz') as dist:
+        for filename, content in files:
+            file_bytes = io.BytesIO(content.encode('utf-8'))
+            file_info = tarfile.TarInfo(name=filename)
+            file_info.size = len(file_bytes.getvalue())
+            file_info.mtime = int(time.time())
+            dist.addfile(file_info, fileobj=file_bytes)
+
+
+def make_trivial_sdist(dist_path, distname, version):
+    """
+    Create a simple sdist tarball at dist_path, containing just a simple
+    setup.py.
+    """
+
+    make_sdist(
+        dist_path,
+        [
+            (
+                'setup.py',
+                DALS(
+                    f"""\
+             import setuptools
+             setuptools.setup(
+                 name={distname!r},
+                 version={version!r}
+             )
+         """
+                ),
+            ),
+            ('setup.cfg', ''),
+        ],
+    )
+
+
+def make_nspkg_sdist(dist_path, distname, version):
+    """
+    Make an sdist tarball with distname and version which also contains one
+    package with the same name as distname.  The top-level package is
+    designated a namespace package).
+    """
+    # Assert that the distname contains at least one period
+    assert '.' in distname
+
+    parts = distname.split('.')
+    nspackage = parts[0]
+
+    packages = ['.'.join(parts[:idx]) for idx in range(1, len(parts) + 1)]
+
+    setup_py = DALS(
+        f"""\
+        import setuptools
+        setuptools.setup(
+            name={distname!r},
+            version={version!r},
+            packages={packages!r},
+            namespace_packages=[{nspackage!r}]
+        )
+    """
+    )
+
+    init = "__import__('pkg_resources').declare_namespace(__name__)"
+
+    files = [('setup.py', setup_py), (os.path.join(nspackage, '__init__.py'), init)]
+    for package in packages[1:]:
+        filename = os.path.join(*(package.split('.') + ['__init__.py']))
+        files.append((filename, ''))
+
+    make_sdist(dist_path, files)
+
+
+def make_python_requires_sdist(dist_path, distname, version, python_requires):
+    make_sdist(
+        dist_path,
+        [
+            (
+                'setup.py',
+                DALS(
+                    """\
+                import setuptools
+                setuptools.setup(
+                  name={name!r},
+                  version={version!r},
+                  python_requires={python_requires!r},
+                )
+                """
+                ).format(
+                    name=distname, version=version, python_requires=python_requires
+                ),
+            ),
+            ('setup.cfg', ''),
+        ],
+    )
+
+
+def create_setup_requires_package(
+    path,
+    distname='foobar',
+    version='0.1',
+    make_package=make_trivial_sdist,
+    setup_py_template=None,
+    setup_attrs=None,
+    use_setup_cfg=(),
+):
+    """Creates a source tree under path for a trivial test package that has a
+    single requirement in setup_requires--a tarball for that requirement is
+    also created and added to the dependency_links argument.
+
+    ``distname`` and ``version`` refer to the name/version of the package that
+    the test package requires via ``setup_requires``.  The name of the test
+    package itself is just 'test_pkg'.
+    """
+
+    normalized_distname = safer_name(distname)
+    test_setup_attrs = {
+        'name': 'test_pkg',
+        'version': '0.0',
+        'setup_requires': [f'{normalized_distname}=={version}'],
+        'dependency_links': [os.path.abspath(path)],
+    }
+    if setup_attrs:
+        test_setup_attrs.update(setup_attrs)
+
+    test_pkg = os.path.join(path, 'test_pkg')
+    os.mkdir(test_pkg)
+
+    # setup.cfg
+    if use_setup_cfg:
+        options = []
+        metadata = []
+        for name in use_setup_cfg:
+            value = test_setup_attrs.pop(name)
+            if name in 'name version'.split():
+                section = metadata
+            else:
+                section = options
+            if isinstance(value, (tuple, list)):
+                value = ';'.join(value)
+            section.append(f'{name}: {value}')
+        test_setup_cfg_contents = DALS(
+            """
+            [metadata]
+            {metadata}
+            [options]
+            {options}
+            """
+        ).format(
+            options='\n'.join(options),
+            metadata='\n'.join(metadata),
+        )
+    else:
+        test_setup_cfg_contents = ''
+    with open(os.path.join(test_pkg, 'setup.cfg'), 'w', encoding="utf-8") as f:
+        f.write(test_setup_cfg_contents)
+
+    # setup.py
+    if setup_py_template is None:
+        setup_py_template = DALS(
+            """\
+            import setuptools
+            setuptools.setup(**%r)
+        """
+        )
+    with open(os.path.join(test_pkg, 'setup.py'), 'w', encoding="utf-8") as f:
+        f.write(setup_py_template % test_setup_attrs)
+
+    foobar_path = os.path.join(path, f'{normalized_distname}-{version}.tar.gz')
+    make_package(foobar_path, distname, version)
+
+    return test_pkg
+
+
+@pytest.fixture
+def pbr_package(tmp_path, monkeypatch, venv):
+    files = {
+        "pyproject.toml": DALS(
+            """
+            [build-system]
+            requires = ["setuptools"]
+            build-backend = "setuptools.build_meta"
+            """
+        ),
+        "setup.py": DALS(
+            """
+            __import__('setuptools').setup(
+                pbr=True,
+                setup_requires=["pbr"],
+            )
+            """
+        ),
+        "setup.cfg": DALS(
+            """
+            [metadata]
+            name = mypkg
+
+            [files]
+            packages =
+                mypkg
+            """
+        ),
+        "mypkg": {
+            "__init__.py": "",
+            "hello.py": "print('Hello world!')",
+        },
+        "other": {"test.txt": "Another file in here."},
+    }
+    venv.run(["python", "-m", "pip", "install", "pbr"])
+    prefix = tmp_path / 'mypkg'
+    prefix.mkdir()
+    jaraco.path.build(files, prefix=prefix)
+    monkeypatch.setenv('PBR_VERSION', "0.42")
+    return prefix

py2docfx/venv/venv1/Lib/site-packages/setuptools/tests/integration/test_pbr.py

@@ -0,0 +1,20 @@
+import subprocess
+
+import pytest
+
+
+@pytest.mark.uses_network
+def test_pbr_integration(pbr_package, venv):
+    """Ensure pbr packages install."""
+    cmd = [
+        'python',
+        '-m',
+        'pip',
+        '-v',
+        'install',
+        '--no-build-isolation',
+        pbr_package,
+    ]
+    venv.run(cmd, stderr=subprocess.STDOUT)
+    out = venv.run(["python", "-c", "import mypkg.hello"])
+    assert "Hello world!" in out

py2docfx/venv/venv1/Lib/site-packages/setuptools/tests/test_build_meta.py

@@ -936,30 +936,6 @@ class TestBuildMetaLegacyBackend(TestBuildMetaBackend):
         build_backend.build_sdist("temp")
 
 
-def test_legacy_editable_install(venv, tmpdir, tmpdir_cwd):
-    pyproject = """
-    [build-system]
-    requires = ["setuptools"]
-    build-backend = "setuptools.build_meta"
-    [project]
-    name = "myproj"
-    version = "42"
-    """
-    path.build({"pyproject.toml": DALS(pyproject), "mymod.py": ""})
-
-    # First: sanity check
-    cmd = ["pip", "install", "--no-build-isolation", "-e", "."]
-    output = venv.run(cmd, cwd=tmpdir).lower()
-    assert "running setup.py develop for myproj" not in output
-    assert "created wheel for myproj" in output
-
-    # Then: real test
-    env = {**os.environ, "SETUPTOOLS_ENABLE_FEATURES": "legacy-editable"}
-    cmd = ["pip", "install", "--no-build-isolation", "-e", "."]
-    output = venv.run(cmd, cwd=tmpdir, env=env).lower()
-    assert "running setup.py develop for myproj" in output
-
-
 @pytest.mark.filterwarnings("ignore::setuptools.SetuptoolsDeprecationWarning")
 def test_sys_exit_0_in_setuppy(monkeypatch, tmp_path):
     """Setuptools should be resilient to setup.py with ``sys.exit(0)`` (#3973)."""

py2docfx/venv/venv1/Lib/site-packages/setuptools/tests/test_develop.py

@@ -1,7 +1,6 @@
 """develop tests"""
 
 import os
-import pathlib
 import platform
 import subprocess
 import sys
@@ -9,8 +8,6 @@ import sys
 import pytest
 
 from setuptools._path import paths_on_pythonpath
-from setuptools.command.develop import develop
-from setuptools.dist import Distribution
 
 from . import contexts, namespaces
 
@@ -51,67 +48,6 @@ def test_env(tmpdir, temp_user):
         yield target
 
 
-class TestDevelop:
-    in_virtualenv = hasattr(sys, 'real_prefix')
-    in_venv = hasattr(sys, 'base_prefix') and sys.base_prefix != sys.prefix
-
-    def test_console_scripts(self, tmpdir):
-        """
-        Test that console scripts are installed and that they reference
-        only the project by name and not the current version.
-        """
-        pytest.skip(
-            "TODO: needs a fixture to cause 'develop' "
-            "to be invoked without mutating environment."
-        )
-        settings = dict(
-            name='foo',
-            packages=['foo'],
-            version='0.0',
-            entry_points={
-                'console_scripts': [
-                    'foocmd = foo:foo',
-                ],
-            },
-        )
-        dist = Distribution(settings)
-        dist.script_name = 'setup.py'
-        cmd = develop(dist)
-        cmd.ensure_finalized()
-        cmd.install_dir = tmpdir
-        cmd.run()
-        # assert '0.0' not in foocmd_text
-
-    @pytest.mark.xfail(reason="legacy behavior retained for compatibility #4167")
-    def test_egg_link_filename(self):
-        settings = dict(
-            name='Foo $$$ Bar_baz-bing',
-        )
-        dist = Distribution(settings)
-        cmd = develop(dist)
-        cmd.ensure_finalized()
-        link = pathlib.Path(cmd.egg_link)
-        assert link.suffix == '.egg-link'
-        assert link.stem == 'Foo_Bar_baz_bing'
-
-
-class TestResolver:
-    """
-    TODO: These tests were written with a minimal understanding
-    of what _resolve_setup_path is intending to do. Come up with
-    more meaningful cases that look like real-world scenarios.
-    """
-
-    def test_resolve_setup_path_cwd(self):
-        assert develop._resolve_setup_path('.', '.', '.') == '.'
-
-    def test_resolve_setup_path_one_dir(self):
-        assert develop._resolve_setup_path('pkgs', '.', 'pkgs') == '../'
-
-    def test_resolve_setup_path_one_dir_trailing_slash(self):
-        assert develop._resolve_setup_path('pkgs/', '.', 'pkgs') == '../'
-
-
 class TestNamespaces:
     @staticmethod
     def install_develop(src_dir, target):
@@ -134,6 +70,7 @@ class TestNamespaces:
         platform.python_implementation() == 'PyPy',
         reason="https://github.com/pypa/setuptools/issues/1202",
     )
+    @pytest.mark.uses_network
     def test_namespace_package_importable(self, tmpdir):
         """
         Installing two packages sharing the same namespace, one installed

py2docfx/venv/venv1/Lib/site-packages/setuptools/tests/test_dist.py

@@ -8,7 +8,7 @@ import pytest
 from setuptools import Distribution
 from setuptools.dist import check_package_data, check_specifier
 
-from .test_easy_install import make_trivial_sdist
+from .fixtures import make_trivial_sdist
 from .test_find_packages import ensure_files
 from .textwrap import DALS
 
@@ -56,7 +56,7 @@ def test_dist_fetch_build_egg(tmpdir):
         dist = Distribution()
         dist.parse_config_files()
         resolved_dists = [dist.fetch_build_egg(r) for r in reqs]
-    assert [dist.key for dist in resolved_dists if dist] == reqs
+    assert [dist.name for dist in resolved_dists if dist] == reqs
 
 
 EXAMPLE_BASE_INFO = dict(

py2docfx/venv/venv1/Lib/site-packages/setuptools/tests/test_dist_info.py

@@ -9,7 +9,6 @@ from functools import partial
 
 import pytest
 
-import pkg_resources
 from setuptools.archive_util import unpack_archive
 
 from .textwrap import DALS
@@ -18,68 +17,6 @@ read = partial(pathlib.Path.read_text, encoding="utf-8")
 
 
 class TestDistInfo:
-    metadata_base = DALS(
-        """
-        Metadata-Version: 1.2
-        Requires-Dist: splort (==4)
-        Provides-Extra: baz
-        Requires-Dist: quux (>=1.1); extra == 'baz'
-        """
-    )
-
-    @classmethod
-    def build_metadata(cls, **kwargs):
-        lines = ('{key}: {value}\n'.format(**locals()) for key, value in kwargs.items())
-        return cls.metadata_base + ''.join(lines)
-
-    @pytest.fixture
-    def metadata(self, tmpdir):
-        dist_info_name = 'VersionedDistribution-2.718.dist-info'
-        versioned = tmpdir / dist_info_name
-        versioned.mkdir()
-        filename = versioned / 'METADATA'
-        content = self.build_metadata(
-            Name='VersionedDistribution',
-        )
-        filename.write_text(content, encoding='utf-8')
-
-        dist_info_name = 'UnversionedDistribution.dist-info'
-        unversioned = tmpdir / dist_info_name
-        unversioned.mkdir()
-        filename = unversioned / 'METADATA'
-        content = self.build_metadata(
-            Name='UnversionedDistribution',
-            Version='0.3',
-        )
-        filename.write_text(content, encoding='utf-8')
-
-        return str(tmpdir)
-
-    def test_distinfo(self, metadata):
-        dists = dict(
-            (d.project_name, d) for d in pkg_resources.find_distributions(metadata)
-        )
-
-        assert len(dists) == 2, dists
-
-        unversioned = dists['UnversionedDistribution']
-        versioned = dists['VersionedDistribution']
-
-        assert versioned.version == '2.718'  # from filename
-        assert unversioned.version == '0.3'  # from METADATA
-
-    def test_conditional_dependencies(self, metadata):
-        specs = 'splort==4', 'quux>=1.1'
-        requires = list(map(pkg_resources.Requirement.parse, specs))
-
-        for d in pkg_resources.find_distributions(metadata):
-            assert d.requires() == requires[:1]
-            assert d.requires(extras=('baz',)) == [
-                requires[0],
-                pkg_resources.Requirement.parse('quux>=1.1;extra=="baz"'),
-            ]
-            assert d.extras == ['baz']
-
     def test_invalid_version(self, tmp_path):
         """
         Supplying an invalid version crashes dist_info.

py2docfx/venv/venv1/Lib/site-packages/setuptools/tests/test_editable_install.py

@@ -21,7 +21,6 @@ from path import Path as _Path
 
 from setuptools._importlib import resources as importlib_resources
 from setuptools.command.editable_wheel import (
-    _DebuggingTips,
     _encode_pth,
     _find_namespaces,
     _find_package_roots,
@@ -1068,45 +1067,20 @@ def test_compat_install(tmp_path, venv):
     assert "cannot import name 'subpackage'" in out
 
 
-def test_pbr_integration(tmp_path, venv, editable_opts):
+@pytest.mark.uses_network
+def test_pbr_integration(pbr_package, venv, editable_opts):
     """Ensure editable installs work with pbr, issue #3500"""
-    files = {
-        "pyproject.toml": dedent(
-            """\
-            [build-system]
-            requires = ["setuptools"]
-            build-backend = "setuptools.build_meta"
-            """
-        ),
-        "setup.py": dedent(
-            """\
-            __import__('setuptools').setup(
-                pbr=True,
-                setup_requires=["pbr"],
-            )
-            """
-        ),
-        "setup.cfg": dedent(
-            """\
-            [metadata]
-            name = mypkg
-
-            [files]
-            packages =
-                mypkg
-            """
-        ),
-        "mypkg": {
-            "__init__.py": "",
-            "hello.py": "print('Hello world!')",
-        },
-        "other": {"test.txt": "Another file in here."},
-    }
-    venv.run(["python", "-m", "pip", "install", "pbr"])
-
-    with contexts.environment(PBR_VERSION="0.42"):
-        install_project("mypkg", venv, tmp_path, files, *editable_opts)
-
+    cmd = [
+        'python',
+        '-m',
+        'pip',
+        '-v',
+        'install',
+        '--editable',
+        pbr_package,
+        *editable_opts,
+    ]
+    venv.run(cmd, stderr=subprocess.STDOUT)
     out = venv.run(["python", "-c", "import mypkg.hello"])
     assert "Hello world!" in out
 
@@ -1227,9 +1201,9 @@ def test_debugging_tips(tmpdir_cwd, monkeypatch):
     simulated_failure = Mock(side_effect=SimulatedErr())
     monkeypatch.setattr(cmd, "get_finalized_command", simulated_failure)
 
-    expected_msg = "following steps are recommended to help debug"
-    with pytest.raises(SimulatedErr), pytest.warns(_DebuggingTips, match=expected_msg):
+    with pytest.raises(SimulatedErr) as ctx:
         cmd.run()
+    assert any('debugging-tips' in note for note in ctx.value.__notes__)
 
 
 @pytest.mark.filterwarnings("error")

py2docfx/venv/venv1/Lib/site-packages/setuptools/tests/test_egg_info.py

@@ -1287,10 +1287,11 @@ class TestWriteEntries:
         dist = Distribution({"name": "foo", "version": "0.0.1"})
         dist.entry_points = {"foo": "foo = invalid-identifier:foo"}
         cmd = dist.get_command_obj("egg_info")
-        expected_msg = r"Problems to parse .*invalid-identifier.*"
-        with pytest.raises(errors.OptionError, match=expected_msg) as ex:
+        expected_msg = r"(Invalid object reference|Problems to parse)"
+        with pytest.raises((errors.OptionError, ValueError), match=expected_msg) as ex:
             write_entries(cmd, "entry_points", "entry_points.txt")
             assert "ensure entry-point follows the spec" in ex.value.args[0]
+            assert "invalid-identifier" in str(ex.value)
 
     def test_valid_entry_point(self, tmpdir_cwd, env):
         dist = Distribution({"name": "foo", "version": "0.0.1"})

py2docfx/venv/venv1/Lib/site-packages/setuptools/tests/test_scripts.py

@@ -0,0 +1,12 @@
+from setuptools import _scripts
+
+
+class TestWindowsScriptWriter:
+    def test_header(self):
+        hdr = _scripts.WindowsScriptWriter.get_header('')
+        assert hdr.startswith('#!')
+        assert hdr.endswith('\n')
+        hdr = hdr.lstrip('#!')
+        hdr = hdr.rstrip('\n')
+        # header should not start with an escaped quote
+        assert not hdr.startswith('\\"')