PyPI - py2docfx - Versions diffs - 0.1.11.dev1830301__py3-none-any.whl → 0.1.11.dev1859874__py3-none-any.whl - Mend

py2docfx 0.1.11.dev1830301py3-none-any.whl → 0.1.11.dev1859874py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (2002) hide show

py2docfx/venv/template/Lib/site-packages/setuptools/tests/test_dist.py DELETED Viewed

@@ -1,281 +0,0 @@
-import collections
-import re
-import os
-import urllib.request
-import urllib.parse
-from distutils.errors import DistutilsSetupError
-from setuptools.dist import (
-    check_package_data,
-    check_specifier,
-)
-from setuptools import Distribution
-from .textwrap import DALS
-from .test_easy_install import make_nspkg_sdist
-from .test_find_packages import ensure_files
-import pytest
-def test_dist_fetch_build_egg(tmpdir):
-    """
-    Check multiple calls to `Distribution.fetch_build_egg` work as expected.
-    """
-    index = tmpdir.mkdir('index')
-    index_url = urllib.parse.urljoin('file://', urllib.request.pathname2url(str(index)))
-    def sdist_with_index(distname, version):
-        dist_dir = index.mkdir(distname)
-        dist_sdist = '%s-%s.tar.gz' % (distname, version)
-        make_nspkg_sdist(str(dist_dir.join(dist_sdist)), distname, version)
-        with dist_dir.join('index.html').open('w') as fp:
-            fp.write(
-                DALS(
-                    """
-                <!DOCTYPE html><html><body>
-                <a href="{dist_sdist}" rel="internal">{dist_sdist}</a><br/>
-                </body></html>
-                """
-                ).format(dist_sdist=dist_sdist)
-            )
-    sdist_with_index('barbazquux', '3.2.0')
-    sdist_with_index('barbazquux-runner', '2.11.1')
-    with tmpdir.join('setup.cfg').open('w') as fp:
-        fp.write(
-            DALS(
-                """
-            [easy_install]
-            index_url = {index_url}
-            """
-            ).format(index_url=index_url)
-        )
-    reqs = """
-    barbazquux-runner
-    barbazquux
-    """.split()
-    with tmpdir.as_cwd():
-        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
-EXAMPLE_BASE_INFO = dict(
-    name="package",
-    version="0.0.1",
-    author="Foo Bar",
-    author_email="foo@bar.net",
-    long_description="Long\ndescription",
-    description="Short description",
-    keywords=["one", "two"],
-)
-def test_provides_extras_deterministic_order():
-    extras = collections.OrderedDict()
-    extras['a'] = ['foo']
-    extras['b'] = ['bar']
-    attrs = dict(extras_require=extras)
-    dist = Distribution(attrs)
-    assert dist.metadata.provides_extras == ['a', 'b']
-    attrs['extras_require'] = collections.OrderedDict(
-        reversed(list(attrs['extras_require'].items()))
-    )
-    dist = Distribution(attrs)
-    assert dist.metadata.provides_extras == ['b', 'a']
-CHECK_PACKAGE_DATA_TESTS = (
-    # Valid.
-    (
-        {
-            '': ['*.txt', '*.rst'],
-            'hello': ['*.msg'],
-        },
-        None,
-    ),
-    # Not a dictionary.
-    (
-        (
-            ('', ['*.txt', '*.rst']),
-            ('hello', ['*.msg']),
-        ),
-        (
-            "'package_data' must be a dictionary mapping package"
-            " names to lists of string wildcard patterns"
-        ),
-    ),
-    # Invalid key type.
-    (
-        {
-            400: ['*.txt', '*.rst'],
-        },
-        ("keys of 'package_data' dict must be strings (got 400)"),
-    ),
-    # Invalid value type.
-    (
-        {
-            'hello': '*.msg',
-        },
-        (
-            "\"values of 'package_data' dict\" "
-            "must be a list of strings (got '*.msg')"
-        ),
-    ),
-    # Invalid value type (generators are single use)
-    (
-        {
-            'hello': (x for x in "generator"),
-        },
-        (
-            "\"values of 'package_data' dict\" must be a list of strings "
-            "(got <generator object"
-        ),
-    ),
-)
-@pytest.mark.parametrize('package_data, expected_message', CHECK_PACKAGE_DATA_TESTS)
-def test_check_package_data(package_data, expected_message):
-    if expected_message is None:
-        assert check_package_data(None, 'package_data', package_data) is None
-    else:
-        with pytest.raises(DistutilsSetupError, match=re.escape(expected_message)):
-            check_package_data(None, 'package_data', package_data)
-def test_check_specifier():
-    # valid specifier value
-    attrs = {'name': 'foo', 'python_requires': '>=3.0, !=3.1'}
-    dist = Distribution(attrs)
-    check_specifier(dist, attrs, attrs['python_requires'])
-    # invalid specifier value
-    attrs = {'name': 'foo', 'python_requires': ['>=3.0', '!=3.1']}
-    with pytest.raises(DistutilsSetupError):
-        dist = Distribution(attrs)
-def test_metadata_name():
-    with pytest.raises(DistutilsSetupError, match='missing.*name'):
-        Distribution()._validate_metadata()
-@pytest.mark.parametrize(
-    "dist_name, py_module",
-    [
-        ("my.pkg", "my_pkg"),
-        ("my-pkg", "my_pkg"),
-        ("my_pkg", "my_pkg"),
-        ("pkg", "pkg"),
-    ],
-)
-def test_dist_default_py_modules(tmp_path, dist_name, py_module):
-    (tmp_path / f"{py_module}.py").touch()
-    (tmp_path / "setup.py").touch()
-    (tmp_path / "noxfile.py").touch()
-    # ^-- make sure common tool files are ignored
-    attrs = {**EXAMPLE_BASE_INFO, "name": dist_name, "src_root": str(tmp_path)}
-    # Find `py_modules` corresponding to dist_name if not given
-    dist = Distribution(attrs)
-    dist.set_defaults()
-    assert dist.py_modules == [py_module]
-    # When `py_modules` is given, don't do anything
-    dist = Distribution({**attrs, "py_modules": ["explicity_py_module"]})
-    dist.set_defaults()
-    assert dist.py_modules == ["explicity_py_module"]
-    # When `packages` is given, don't do anything
-    dist = Distribution({**attrs, "packages": ["explicity_package"]})
-    dist.set_defaults()
-    assert not dist.py_modules
-@pytest.mark.parametrize(
-    "dist_name, package_dir, package_files, packages",
-    [
-        ("my.pkg", None, ["my_pkg/__init__.py", "my_pkg/mod.py"], ["my_pkg"]),
-        ("my-pkg", None, ["my_pkg/__init__.py", "my_pkg/mod.py"], ["my_pkg"]),
-        ("my_pkg", None, ["my_pkg/__init__.py", "my_pkg/mod.py"], ["my_pkg"]),
-        ("my.pkg", None, ["my/pkg/__init__.py"], ["my", "my.pkg"]),
-        (
-            "my_pkg",
-            None,
-            ["src/my_pkg/__init__.py", "src/my_pkg2/__init__.py"],
-            ["my_pkg", "my_pkg2"],
-        ),
-        (
-            "my_pkg",
-            {"pkg": "lib", "pkg2": "lib2"},
-            ["lib/__init__.py", "lib/nested/__init__.pyt", "lib2/__init__.py"],
-            ["pkg", "pkg.nested", "pkg2"],
-        ),
-    ],
-)
-def test_dist_default_packages(
-    tmp_path, dist_name, package_dir, package_files, packages
-):
-    ensure_files(tmp_path, package_files)
-    (tmp_path / "setup.py").touch()
-    (tmp_path / "noxfile.py").touch()
-    # ^-- should not be included by default
-    attrs = {
-        **EXAMPLE_BASE_INFO,
-        "name": dist_name,
-        "src_root": str(tmp_path),
-        "package_dir": package_dir,
-    }
-    # Find `packages` either corresponding to dist_name or inside src
-    dist = Distribution(attrs)
-    dist.set_defaults()
-    assert not dist.py_modules
-    assert not dist.py_modules
-    assert set(dist.packages) == set(packages)
-    # When `py_modules` is given, don't do anything
-    dist = Distribution({**attrs, "py_modules": ["explicit_py_module"]})
-    dist.set_defaults()
-    assert not dist.packages
-    assert set(dist.py_modules) == {"explicit_py_module"}
-    # When `packages` is given, don't do anything
-    dist = Distribution({**attrs, "packages": ["explicit_package"]})
-    dist.set_defaults()
-    assert not dist.py_modules
-    assert set(dist.packages) == {"explicit_package"}
-@pytest.mark.parametrize(
-    "dist_name, package_dir, package_files",
-    [
-        ("my.pkg.nested", None, ["my/pkg/nested/__init__.py"]),
-        ("my.pkg", None, ["my/pkg/__init__.py", "my/pkg/file.py"]),
-        ("my_pkg", None, ["my_pkg.py"]),
-        ("my_pkg", None, ["my_pkg/__init__.py", "my_pkg/nested/__init__.py"]),
-        ("my_pkg", None, ["src/my_pkg/__init__.py", "src/my_pkg/nested/__init__.py"]),
-        (
-            "my_pkg",
-            {"my_pkg": "lib", "my_pkg.lib2": "lib2"},
-            ["lib/__init__.py", "lib/nested/__init__.pyt", "lib2/__init__.py"],
-        ),
-        # Should not try to guess a name from multiple py_modules/packages
-        ("UNKNOWN", None, ["src/mod1.py", "src/mod2.py"]),
-        ("UNKNOWN", None, ["src/pkg1/__ini__.py", "src/pkg2/__init__.py"]),
-    ],
-)
-def test_dist_default_name(tmp_path, dist_name, package_dir, package_files):
-    """Make sure dist.name is discovered from packages/py_modules"""
-    ensure_files(tmp_path, package_files)
-    attrs = {
-        **EXAMPLE_BASE_INFO,
-        "src_root": "/".join(os.path.split(tmp_path)),  # POSIX-style
-        "package_dir": package_dir,
-    }
-    del attrs["name"]
-    dist = Distribution(attrs)
-    dist.set_defaults()
-    assert dist.py_modules or dist.packages
-    assert dist.get_name() == dist_name

py2docfx/venv/template/Lib/site-packages/setuptools/tests/test_dist_info.py DELETED Viewed

@@ -1,210 +0,0 @@
-"""Test .dist-info style distributions."""
-import pathlib
-import re
-import shutil
-import subprocess
-import sys
-from functools import partial
-import pytest
-import pkg_resources
-from setuptools.archive_util import unpack_archive
-from .textwrap import DALS
-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.
-        """
-        config = "[metadata]\nname=proj\nversion=42\n[egg_info]\ntag_build=invalid!!!\n"
-        (tmp_path / "setup.cfg").write_text(config, encoding="utf-8")
-        msg = re.compile("invalid version", re.M | re.I)
-        proc = run_command_inner("dist_info", cwd=tmp_path, check=False)
-        assert proc.returncode
-        assert msg.search(proc.stdout)
-        assert not list(tmp_path.glob("*.dist-info"))
-    def test_tag_arguments(self, tmp_path):
-        config = """
-        [metadata]
-        name=proj
-        version=42
-        [egg_info]
-        tag_date=1
-        tag_build=.post
-        """
-        (tmp_path / "setup.cfg").write_text(config, encoding="utf-8")
-        print(run_command("dist_info", "--no-date", cwd=tmp_path))
-        dist_info = next(tmp_path.glob("*.dist-info"))
-        assert dist_info.name.startswith("proj-42")
-        shutil.rmtree(dist_info)
-        print(run_command("dist_info", "--tag-build", ".a", cwd=tmp_path))
-        dist_info = next(tmp_path.glob("*.dist-info"))
-        assert dist_info.name.startswith("proj-42a")
-    @pytest.mark.parametrize("keep_egg_info", (False, True))
-    def test_output_dir(self, tmp_path, keep_egg_info):
-        config = "[metadata]\nname=proj\nversion=42\n"
-        (tmp_path / "setup.cfg").write_text(config, encoding="utf-8")
-        out = tmp_path / "__out"
-        out.mkdir()
-        opts = ["--keep-egg-info"] if keep_egg_info else []
-        run_command("dist_info", "--output-dir", out, *opts, cwd=tmp_path)
-        assert len(list(out.glob("*.dist-info"))) == 1
-        assert len(list(tmp_path.glob("*.dist-info"))) == 0
-        expected_egg_info = int(keep_egg_info)
-        assert len(list(out.glob("*.egg-info"))) == expected_egg_info
-        assert len(list(tmp_path.glob("*.egg-info"))) == 0
-        assert len(list(out.glob("*.__bkp__"))) == 0
-        assert len(list(tmp_path.glob("*.__bkp__"))) == 0
-class TestWheelCompatibility:
-    """Make sure the .dist-info directory produced with the ``dist_info`` command
-    is the same as the one produced by ``bdist_wheel``.
-    """
-    SETUPCFG = DALS(
-        """
-    [metadata]
-    name = {name}
-    version = {version}
-    [options]
-    install_requires =
-        foo>=12; sys_platform != "linux"
-    [options.extras_require]
-    test = pytest
-    [options.entry_points]
-    console_scripts =
-        executable-name = my_package.module:function
-    discover =
-        myproj = my_package.other_module:function
-    """
-    )
-    EGG_INFO_OPTS = [
-        # Related: #3088 #2872
-        ("", ""),
-        (".post", "[egg_info]\ntag_build = post\n"),
-        (".post", "[egg_info]\ntag_build = .post\n"),
-        (".post", "[egg_info]\ntag_build = post\ntag_date = 1\n"),
-        (".dev", "[egg_info]\ntag_build = .dev\n"),
-        (".dev", "[egg_info]\ntag_build = .dev\ntag_date = 1\n"),
-        ("a1", "[egg_info]\ntag_build = .a1\n"),
-        ("+local", "[egg_info]\ntag_build = +local\n"),
-    ]
-    @pytest.mark.parametrize("name", "my-proj my_proj my.proj My.Proj".split())
-    @pytest.mark.parametrize("version", ["0.42.13"])
-    @pytest.mark.parametrize("suffix, cfg", EGG_INFO_OPTS)
-    def test_dist_info_is_the_same_as_in_wheel(
-        self, name, version, tmp_path, suffix, cfg
-    ):
-        config = self.SETUPCFG.format(name=name, version=version) + cfg
-        for i in "dir_wheel", "dir_dist":
-            (tmp_path / i).mkdir()
-            (tmp_path / i / "setup.cfg").write_text(config, encoding="utf-8")
-        run_command("bdist_wheel", cwd=tmp_path / "dir_wheel")
-        wheel = next(tmp_path.glob("dir_wheel/dist/*.whl"))
-        unpack_archive(wheel, tmp_path / "unpack")
-        wheel_dist_info = next(tmp_path.glob("unpack/*.dist-info"))
-        run_command("dist_info", cwd=tmp_path / "dir_dist")
-        dist_info = next(tmp_path.glob("dir_dist/*.dist-info"))
-        assert dist_info.name == wheel_dist_info.name
-        assert dist_info.name.startswith(f"{name.replace('-', '_')}-{version}{suffix}")
-        for file in "METADATA", "entry_points.txt":
-            assert read(dist_info / file) == read(wheel_dist_info / file)
-def run_command_inner(*cmd, **kwargs):
-    opts = {
-        "stderr": subprocess.STDOUT,
-        "stdout": subprocess.PIPE,
-        "text": True,
-        "encoding": "utf-8",
-        "check": True,
-        **kwargs,
-    }
-    cmd = [sys.executable, "-c", "__import__('setuptools').setup()", *map(str, cmd)]
-    return subprocess.run(cmd, **opts)
-def run_command(*args, **kwargs):
-    return run_command_inner(*args, **kwargs).stdout

py2docfx/venv/template/Lib/site-packages/setuptools/tests/test_distutils_adoption.py DELETED Viewed

@@ -1,160 +0,0 @@
-import os
-import sys
-import platform
-import textwrap
-import pytest
-IS_PYPY = '__pypy__' in sys.builtin_module_names
-_TEXT_KWARGS = {"text": True, "encoding": "utf-8"}  # For subprocess.run
-def win_sr(env):
-    """
-    On Windows, SYSTEMROOT must be present to avoid
-    > Fatal Python error: _Py_HashRandomization_Init: failed to
-    > get random numbers to initialize Python
-    """
-    if env and platform.system() == 'Windows':
-        env['SYSTEMROOT'] = os.environ['SYSTEMROOT']
-    return env
-def find_distutils(venv, imports='distutils', env=None, **kwargs):
-    py_cmd = 'import {imports}; print(distutils.__file__)'.format(**locals())
-    cmd = ['python', '-c', py_cmd]
-    return venv.run(cmd, env=win_sr(env), **_TEXT_KWARGS, **kwargs)
-def count_meta_path(venv, env=None):
-    py_cmd = textwrap.dedent(
-        """
-        import sys
-        is_distutils = lambda finder: finder.__class__.__name__ == "DistutilsMetaFinder"
-        print(len(list(filter(is_distutils, sys.meta_path))))
-        """
-    )
-    cmd = ['python', '-c', py_cmd]
-    return int(venv.run(cmd, env=win_sr(env), **_TEXT_KWARGS))
-skip_without_stdlib_distutils = pytest.mark.skipif(
-    sys.version_info >= (3, 12),
-    reason='stdlib distutils is removed from Python 3.12+',
-)
-@skip_without_stdlib_distutils
-def test_distutils_stdlib(venv):
-    """
-    Ensure stdlib distutils is used when appropriate.
-    """
-    env = dict(SETUPTOOLS_USE_DISTUTILS='stdlib')
-    assert venv.name not in find_distutils(venv, env=env).split(os.sep)
-    assert count_meta_path(venv, env=env) == 0
-def test_distutils_local_with_setuptools(venv):
-    """
-    Ensure local distutils is used when appropriate.
-    """
-    env = dict(SETUPTOOLS_USE_DISTUTILS='local')
-    loc = find_distutils(venv, imports='setuptools, distutils', env=env)
-    assert venv.name in loc.split(os.sep)
-    assert count_meta_path(venv, env=env) <= 1
-@pytest.mark.xfail('IS_PYPY', reason='pypy imports distutils on startup')
-def test_distutils_local(venv):
-    """
-    Even without importing, the setuptools-local copy of distutils is
-    preferred.
-    """
-    env = dict(SETUPTOOLS_USE_DISTUTILS='local')
-    assert venv.name in find_distutils(venv, env=env).split(os.sep)
-    assert count_meta_path(venv, env=env) <= 1
-def test_pip_import(venv):
-    """
-    Ensure pip can be imported.
-    Regression test for #3002.
-    """
-    cmd = ['python', '-c', 'import pip']
-    venv.run(cmd, **_TEXT_KWARGS)
-def test_distutils_has_origin():
-    """
-    Distutils module spec should have an origin. #2990.
-    """
-    assert __import__('distutils').__spec__.origin
-ENSURE_IMPORTS_ARE_NOT_DUPLICATED = r"""
-# Depending on the importlib machinery and _distutils_hack, some imports are
-# duplicated resulting in different module objects being loaded, which prevents
-# patches as shown in #3042.
-# This script provides a way of verifying if this duplication is happening.
-from distutils import cmd
-import distutils.command.sdist as sdist
-# import last to prevent caching
-from distutils import {imported_module}
-for mod in (cmd, sdist):
-    assert mod.{imported_module} == {imported_module}, (
-        f"\n{{mod.dir_util}}\n!=\n{{{imported_module}}}"
-    )
-print("success")
-"""
-@pytest.mark.parametrize(
-    "distutils_version, imported_module",
-    [
-        pytest.param("stdlib", "dir_util", marks=skip_without_stdlib_distutils),
-        pytest.param("stdlib", "file_util", marks=skip_without_stdlib_distutils),
-        pytest.param("stdlib", "archive_util", marks=skip_without_stdlib_distutils),
-        ("local", "dir_util"),
-        ("local", "file_util"),
-        ("local", "archive_util"),
-    ],
-)
-def test_modules_are_not_duplicated_on_import(
-    distutils_version, imported_module, tmpdir_cwd, venv
-):
-    env = dict(SETUPTOOLS_USE_DISTUTILS=distutils_version)
-    script = ENSURE_IMPORTS_ARE_NOT_DUPLICATED.format(imported_module=imported_module)
-    cmd = ['python', '-c', script]
-    output = venv.run(cmd, env=win_sr(env), **_TEXT_KWARGS).strip()
-    assert output == "success"
-ENSURE_LOG_IMPORT_IS_NOT_DUPLICATED = r"""
-import types
-import distutils.dist as dist
-from distutils import log
-if isinstance(dist.log, types.ModuleType):
-    assert dist.log == log, f"\n{dist.log}\n!=\n{log}"
-print("success")
-"""
-@pytest.mark.parametrize(
-    "distutils_version",
-    [
-        "local",
-        pytest.param("stdlib", marks=skip_without_stdlib_distutils),
-    ],
-)
-def test_log_module_is_not_duplicated_on_import(distutils_version, tmpdir_cwd, venv):
-    env = dict(SETUPTOOLS_USE_DISTUTILS=distutils_version)
-    cmd = ['python', '-c', ENSURE_LOG_IMPORT_IS_NOT_DUPLICATED]
-    output = venv.run(cmd, env=win_sr(env), **_TEXT_KWARGS).strip()
-    assert output == "success"

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

py2docfx 0.1.11.dev1830301py3-none-any.whl → 0.1.11.dev1859874py3-none-any.whl