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

py2docfx/venv/template/Lib/site-packages/setuptools/_distutils/tests/__init__.py

@@ -1,42 +0,0 @@
-"""
-Test suite for distutils.
-
-Tests for the command classes in the distutils.command package are
-included in distutils.tests as well, instead of using a separate
-distutils.command.tests package, since command identification is done
-by import rather than matching pre-defined names.
-"""
-
-import shutil
-from typing import Sequence
-
-
-def missing_compiler_executable(cmd_names: Sequence[str] = []):  # pragma: no cover
-    """Check if the compiler components used to build the interpreter exist.
-
-    Check for the existence of the compiler executables whose names are listed
-    in 'cmd_names' or all the compiler executables when 'cmd_names' is empty
-    and return the first missing executable or None when none is found
-    missing.
-
-    """
-    from distutils import ccompiler, errors, sysconfig
-
-    compiler = ccompiler.new_compiler()
-    sysconfig.customize_compiler(compiler)
-    if compiler.compiler_type == "msvc":
-        # MSVC has no executables, so check whether initialization succeeds
-        try:
-            compiler.initialize()
-        except errors.DistutilsPlatformError:
-            return "msvc"
-    for name in compiler.executables:
-        if cmd_names and name not in cmd_names:
-            continue
-        cmd = getattr(compiler, name)
-        if cmd_names:
-            assert cmd is not None, f"the '{name}' executable is not configured"
-        elif not cmd:
-            continue
-        if shutil.which(cmd[0]) is None:
-            return cmd[0]

py2docfx/venv/template/Lib/site-packages/setuptools/_distutils/tests/compat/py38.py

@@ -1,50 +0,0 @@
-# flake8: noqa
-
-import contextlib
-import builtins
-import sys
-
-from test.support import requires_zlib
-import test.support
-
-
-ModuleNotFoundError = getattr(builtins, 'ModuleNotFoundError', ImportError)
-
-try:
-    from test.support.warnings_helper import check_warnings
-except (ModuleNotFoundError, ImportError):
-    from test.support import check_warnings
-
-
-try:
-    from test.support.os_helper import (
-        rmtree,
-        EnvironmentVarGuard,
-        unlink,
-        skip_unless_symlink,
-        temp_dir,
-    )
-except (ModuleNotFoundError, ImportError):
-    from test.support import (
-        rmtree,
-        EnvironmentVarGuard,
-        unlink,
-        skip_unless_symlink,
-        temp_dir,
-    )
-
-
-try:
-    from test.support.import_helper import (
-        DirsOnSysPath,
-        CleanImport,
-    )
-except (ModuleNotFoundError, ImportError):
-    from test.support import (
-        DirsOnSysPath,
-        CleanImport,
-    )
-
-
-if sys.version_info < (3, 9):
-    requires_zlib = lambda: test.support.requires_zlib

py2docfx/venv/template/Lib/site-packages/setuptools/_distutils/tests/support.py

@@ -1,134 +0,0 @@
-"""Support code for distutils test cases."""
-
-import itertools
-import os
-import pathlib
-import shutil
-import sys
-import sysconfig
-import tempfile
-from distutils.core import Distribution
-
-import pytest
-from more_itertools import always_iterable
-
-
-@pytest.mark.usefixtures('distutils_managed_tempdir')
-class TempdirManager:
-    """
-    Mix-in class that handles temporary directories for test cases.
-    """
-
-    def mkdtemp(self):
-        """Create a temporary directory that will be cleaned up.
-
-        Returns the path of the directory.
-        """
-        d = tempfile.mkdtemp()
-        self.tempdirs.append(d)
-        return d
-
-    def write_file(self, path, content='xxx'):
-        """Writes a file in the given path.
-
-        path can be a string or a sequence.
-        """
-        pathlib.Path(*always_iterable(path)).write_text(content, encoding='utf-8')
-
-    def create_dist(self, pkg_name='foo', **kw):
-        """Will generate a test environment.
-
-        This function creates:
-         - a Distribution instance using keywords
-         - a temporary directory with a package structure
-
-        It returns the package directory and the distribution
-        instance.
-        """
-        tmp_dir = self.mkdtemp()
-        pkg_dir = os.path.join(tmp_dir, pkg_name)
-        os.mkdir(pkg_dir)
-        dist = Distribution(attrs=kw)
-
-        return pkg_dir, dist
-
-
-class DummyCommand:
-    """Class to store options for retrieval via set_undefined_options()."""
-
-    def __init__(self, **kwargs):
-        vars(self).update(kwargs)
-
-    def ensure_finalized(self):
-        pass
-
-
-def copy_xxmodule_c(directory):
-    """Helper for tests that need the xxmodule.c source file.
-
-    Example use:
-
-        def test_compile(self):
-            copy_xxmodule_c(self.tmpdir)
-            self.assertIn('xxmodule.c', os.listdir(self.tmpdir))
-
-    If the source file can be found, it will be copied to *directory*.  If not,
-    the test will be skipped.  Errors during copy are not caught.
-    """
-    shutil.copy(_get_xxmodule_path(), os.path.join(directory, 'xxmodule.c'))
-
-
-def _get_xxmodule_path():
-    source_name = 'xxmodule.c' if sys.version_info > (3, 9) else 'xxmodule-3.8.c'
-    return os.path.join(os.path.dirname(__file__), source_name)
-
-
-def fixup_build_ext(cmd):
-    """Function needed to make build_ext tests pass.
-
-    When Python was built with --enable-shared on Unix, -L. is not enough to
-    find libpython<blah>.so, because regrtest runs in a tempdir, not in the
-    source directory where the .so lives.
-
-    When Python was built with in debug mode on Windows, build_ext commands
-    need their debug attribute set, and it is not done automatically for
-    some reason.
-
-    This function handles both of these things.  Example use:
-
-        cmd = build_ext(dist)
-        support.fixup_build_ext(cmd)
-        cmd.ensure_finalized()
-
-    Unlike most other Unix platforms, Mac OS X embeds absolute paths
-    to shared libraries into executables, so the fixup is not needed there.
-    """
-    if os.name == 'nt':
-        cmd.debug = sys.executable.endswith('_d.exe')
-    elif sysconfig.get_config_var('Py_ENABLE_SHARED'):
-        # To further add to the shared builds fun on Unix, we can't just add
-        # library_dirs to the Extension() instance because that doesn't get
-        # plumbed through to the final compiler command.
-        runshared = sysconfig.get_config_var('RUNSHARED')
-        if runshared is None:
-            cmd.library_dirs = ['.']
-        else:
-            if sys.platform == 'darwin':
-                cmd.library_dirs = []
-            else:
-                name, equals, value = runshared.partition('=')
-                cmd.library_dirs = [d for d in value.split(os.pathsep) if d]
-
-
-def combine_markers(cls):
-    """
-    pytest will honor markers as found on the class, but when
-    markers are on multiple subclasses, only one appears. Use
-    this decorator to combine those markers.
-    """
-    cls.pytestmark = [
-        mark
-        for base in itertools.chain([cls], cls.__bases__)
-        for mark in getattr(base, 'pytestmark', [])
-    ]
-    return cls

py2docfx/venv/template/Lib/site-packages/setuptools/_distutils/tests/test_archive_util.py

@@ -1,386 +0,0 @@
-"""Tests for distutils.archive_util."""
-
-import functools
-import operator
-import os
-import pathlib
-import sys
-import tarfile
-import warnings
-from distutils import archive_util
-from distutils.archive_util import (
-    ARCHIVE_FORMATS,
-    check_archive_formats,
-    make_archive,
-    make_tarball,
-    make_zipfile,
-)
-from distutils.spawn import spawn
-from distutils.tests import support
-from os.path import splitdrive
-
-import path
-import pytest
-from test.support import patch
-
-from .compat.py38 import check_warnings
-from .unix_compat import UID_0_SUPPORT, grp, pwd, require_uid_0, require_unix_id
-
-
-def can_fs_encode(filename):
-    """
-    Return True if the filename can be saved in the file system.
-    """
-    if os.path.supports_unicode_filenames:
-        return True
-    try:
-        filename.encode(sys.getfilesystemencoding())
-    except UnicodeEncodeError:
-        return False
-    return True
-
-
-def all_equal(values):
-    return functools.reduce(operator.eq, values)
-
-
-def same_drive(*paths):
-    return all_equal(pathlib.Path(path).drive for path in paths)
-
-
-class ArchiveUtilTestCase(support.TempdirManager):
-    @pytest.mark.usefixtures('needs_zlib')
-    def test_make_tarball(self, name='archive'):
-        # creating something to tar
-        tmpdir = self._create_files()
-        self._make_tarball(tmpdir, name, '.tar.gz')
-        # trying an uncompressed one
-        self._make_tarball(tmpdir, name, '.tar', compress=None)
-
-    @pytest.mark.usefixtures('needs_zlib')
-    def test_make_tarball_gzip(self):
-        tmpdir = self._create_files()
-        self._make_tarball(tmpdir, 'archive', '.tar.gz', compress='gzip')
-
-    def test_make_tarball_bzip2(self):
-        pytest.importorskip('bz2')
-        tmpdir = self._create_files()
-        self._make_tarball(tmpdir, 'archive', '.tar.bz2', compress='bzip2')
-
-    def test_make_tarball_xz(self):
-        pytest.importorskip('lzma')
-        tmpdir = self._create_files()
-        self._make_tarball(tmpdir, 'archive', '.tar.xz', compress='xz')
-
-    @pytest.mark.skipif("not can_fs_encode('årchiv')")
-    def test_make_tarball_latin1(self):
-        """
-        Mirror test_make_tarball, except filename contains latin characters.
-        """
-        self.test_make_tarball('årchiv')  # note this isn't a real word
-
-    @pytest.mark.skipif("not can_fs_encode('のアーカイブ')")
-    def test_make_tarball_extended(self):
-        """
-        Mirror test_make_tarball, except filename contains extended
-        characters outside the latin charset.
-        """
-        self.test_make_tarball('のアーカイブ')  # japanese for archive
-
-    def _make_tarball(self, tmpdir, target_name, suffix, **kwargs):
-        tmpdir2 = self.mkdtemp()
-        if same_drive(tmpdir, tmpdir2):
-            pytest.skip("source and target should be on same drive")
-
-        base_name = os.path.join(tmpdir2, target_name)
-
-        # working with relative paths to avoid tar warnings
-        with path.Path(tmpdir):
-            make_tarball(splitdrive(base_name)[1], 'dist', **kwargs)
-
-        # check if the compressed tarball was created
-        tarball = base_name + suffix
-        assert os.path.exists(tarball)
-        assert self._tarinfo(tarball) == self._created_files
-
-    def _tarinfo(self, path):
-        tar = tarfile.open(path)
-        try:
-            names = tar.getnames()
-            names.sort()
-            return names
-        finally:
-            tar.close()
-
-    _zip_created_files = [
-        'dist/',
-        'dist/file1',
-        'dist/file2',
-        'dist/sub/',
-        'dist/sub/file3',
-        'dist/sub2/',
-    ]
-    _created_files = [p.rstrip('/') for p in _zip_created_files]
-
-    def _create_files(self):
-        # creating something to tar
-        tmpdir = self.mkdtemp()
-        dist = os.path.join(tmpdir, 'dist')
-        os.mkdir(dist)
-        self.write_file([dist, 'file1'], 'xxx')
-        self.write_file([dist, 'file2'], 'xxx')
-        os.mkdir(os.path.join(dist, 'sub'))
-        self.write_file([dist, 'sub', 'file3'], 'xxx')
-        os.mkdir(os.path.join(dist, 'sub2'))
-        return tmpdir
-
-    @pytest.mark.usefixtures('needs_zlib')
-    @pytest.mark.skipif("not (shutil.which('tar') and shutil.which('gzip'))")
-    def test_tarfile_vs_tar(self):
-        tmpdir = self._create_files()
-        tmpdir2 = self.mkdtemp()
-        base_name = os.path.join(tmpdir2, 'archive')
-        old_dir = os.getcwd()
-        os.chdir(tmpdir)
-        try:
-            make_tarball(base_name, 'dist')
-        finally:
-            os.chdir(old_dir)
-
-        # check if the compressed tarball was created
-        tarball = base_name + '.tar.gz'
-        assert os.path.exists(tarball)
-
-        # now create another tarball using `tar`
-        tarball2 = os.path.join(tmpdir, 'archive2.tar.gz')
-        tar_cmd = ['tar', '-cf', 'archive2.tar', 'dist']
-        gzip_cmd = ['gzip', '-f', '-9', 'archive2.tar']
-        old_dir = os.getcwd()
-        os.chdir(tmpdir)
-        try:
-            spawn(tar_cmd)
-            spawn(gzip_cmd)
-        finally:
-            os.chdir(old_dir)
-
-        assert os.path.exists(tarball2)
-        # let's compare both tarballs
-        assert self._tarinfo(tarball) == self._created_files
-        assert self._tarinfo(tarball2) == self._created_files
-
-        # trying an uncompressed one
-        base_name = os.path.join(tmpdir2, 'archive')
-        old_dir = os.getcwd()
-        os.chdir(tmpdir)
-        try:
-            make_tarball(base_name, 'dist', compress=None)
-        finally:
-            os.chdir(old_dir)
-        tarball = base_name + '.tar'
-        assert os.path.exists(tarball)
-
-        # now for a dry_run
-        base_name = os.path.join(tmpdir2, 'archive')
-        old_dir = os.getcwd()
-        os.chdir(tmpdir)
-        try:
-            make_tarball(base_name, 'dist', compress=None, dry_run=True)
-        finally:
-            os.chdir(old_dir)
-        tarball = base_name + '.tar'
-        assert os.path.exists(tarball)
-
-    @pytest.mark.skipif("not shutil.which('compress')")
-    def test_compress_deprecated(self):
-        tmpdir = self._create_files()
-        base_name = os.path.join(self.mkdtemp(), 'archive')
-
-        # using compress and testing the DeprecationWarning
-        old_dir = os.getcwd()
-        os.chdir(tmpdir)
-        try:
-            with check_warnings() as w:
-                warnings.simplefilter("always")
-                make_tarball(base_name, 'dist', compress='compress')
-        finally:
-            os.chdir(old_dir)
-        tarball = base_name + '.tar.Z'
-        assert os.path.exists(tarball)
-        assert len(w.warnings) == 1
-
-        # same test with dry_run
-        os.remove(tarball)
-        old_dir = os.getcwd()
-        os.chdir(tmpdir)
-        try:
-            with check_warnings() as w:
-                warnings.simplefilter("always")
-                make_tarball(base_name, 'dist', compress='compress', dry_run=True)
-        finally:
-            os.chdir(old_dir)
-        assert not os.path.exists(tarball)
-        assert len(w.warnings) == 1
-
-    @pytest.mark.usefixtures('needs_zlib')
-    def test_make_zipfile(self):
-        zipfile = pytest.importorskip('zipfile')
-        # creating something to tar
-        tmpdir = self._create_files()
-        base_name = os.path.join(self.mkdtemp(), 'archive')
-        with path.Path(tmpdir):
-            make_zipfile(base_name, 'dist')
-
-        # check if the compressed tarball was created
-        tarball = base_name + '.zip'
-        assert os.path.exists(tarball)
-        with zipfile.ZipFile(tarball) as zf:
-            assert sorted(zf.namelist()) == self._zip_created_files
-
-    def test_make_zipfile_no_zlib(self):
-        zipfile = pytest.importorskip('zipfile')
-        patch(self, archive_util.zipfile, 'zlib', None)  # force zlib ImportError
-
-        called = []
-        zipfile_class = zipfile.ZipFile
-
-        def fake_zipfile(*a, **kw):
-            if kw.get('compression', None) == zipfile.ZIP_STORED:
-                called.append((a, kw))
-            return zipfile_class(*a, **kw)
-
-        patch(self, archive_util.zipfile, 'ZipFile', fake_zipfile)
-
-        # create something to tar and compress
-        tmpdir = self._create_files()
-        base_name = os.path.join(self.mkdtemp(), 'archive')
-        with path.Path(tmpdir):
-            make_zipfile(base_name, 'dist')
-
-        tarball = base_name + '.zip'
-        assert called == [((tarball, "w"), {'compression': zipfile.ZIP_STORED})]
-        assert os.path.exists(tarball)
-        with zipfile.ZipFile(tarball) as zf:
-            assert sorted(zf.namelist()) == self._zip_created_files
-
-    def test_check_archive_formats(self):
-        assert check_archive_formats(['gztar', 'xxx', 'zip']) == 'xxx'
-        assert (
-            check_archive_formats(['gztar', 'bztar', 'xztar', 'ztar', 'tar', 'zip'])
-            is None
-        )
-
-    def test_make_archive(self):
-        tmpdir = self.mkdtemp()
-        base_name = os.path.join(tmpdir, 'archive')
-        with pytest.raises(ValueError):
-            make_archive(base_name, 'xxx')
-
-    def test_make_archive_cwd(self):
-        current_dir = os.getcwd()
-
-        def _breaks(*args, **kw):
-            raise RuntimeError()
-
-        ARCHIVE_FORMATS['xxx'] = (_breaks, [], 'xxx file')
-        try:
-            try:
-                make_archive('xxx', 'xxx', root_dir=self.mkdtemp())
-            except Exception:
-                pass
-            assert os.getcwd() == current_dir
-        finally:
-            ARCHIVE_FORMATS.pop('xxx')
-
-    def test_make_archive_tar(self):
-        base_dir = self._create_files()
-        base_name = os.path.join(self.mkdtemp(), 'archive')
-        res = make_archive(base_name, 'tar', base_dir, 'dist')
-        assert os.path.exists(res)
-        assert os.path.basename(res) == 'archive.tar'
-        assert self._tarinfo(res) == self._created_files
-
-    @pytest.mark.usefixtures('needs_zlib')
-    def test_make_archive_gztar(self):
-        base_dir = self._create_files()
-        base_name = os.path.join(self.mkdtemp(), 'archive')
-        res = make_archive(base_name, 'gztar', base_dir, 'dist')
-        assert os.path.exists(res)
-        assert os.path.basename(res) == 'archive.tar.gz'
-        assert self._tarinfo(res) == self._created_files
-
-    def test_make_archive_bztar(self):
-        pytest.importorskip('bz2')
-        base_dir = self._create_files()
-        base_name = os.path.join(self.mkdtemp(), 'archive')
-        res = make_archive(base_name, 'bztar', base_dir, 'dist')
-        assert os.path.exists(res)
-        assert os.path.basename(res) == 'archive.tar.bz2'
-        assert self._tarinfo(res) == self._created_files
-
-    def test_make_archive_xztar(self):
-        pytest.importorskip('lzma')
-        base_dir = self._create_files()
-        base_name = os.path.join(self.mkdtemp(), 'archive')
-        res = make_archive(base_name, 'xztar', base_dir, 'dist')
-        assert os.path.exists(res)
-        assert os.path.basename(res) == 'archive.tar.xz'
-        assert self._tarinfo(res) == self._created_files
-
-    def test_make_archive_owner_group(self):
-        # testing make_archive with owner and group, with various combinations
-        # this works even if there's not gid/uid support
-        if UID_0_SUPPORT:
-            group = grp.getgrgid(0)[0]
-            owner = pwd.getpwuid(0)[0]
-        else:
-            group = owner = 'root'
-
-        base_dir = self._create_files()
-        root_dir = self.mkdtemp()
-        base_name = os.path.join(self.mkdtemp(), 'archive')
-        res = make_archive(
-            base_name, 'zip', root_dir, base_dir, owner=owner, group=group
-        )
-        assert os.path.exists(res)
-
-        res = make_archive(base_name, 'zip', root_dir, base_dir)
-        assert os.path.exists(res)
-
-        res = make_archive(
-            base_name, 'tar', root_dir, base_dir, owner=owner, group=group
-        )
-        assert os.path.exists(res)
-
-        res = make_archive(
-            base_name, 'tar', root_dir, base_dir, owner='kjhkjhkjg', group='oihohoh'
-        )
-        assert os.path.exists(res)
-
-    @pytest.mark.usefixtures('needs_zlib')
-    @require_unix_id
-    @require_uid_0
-    def test_tarfile_root_owner(self):
-        tmpdir = self._create_files()
-        base_name = os.path.join(self.mkdtemp(), 'archive')
-        old_dir = os.getcwd()
-        os.chdir(tmpdir)
-        group = grp.getgrgid(0)[0]
-        owner = pwd.getpwuid(0)[0]
-        try:
-            archive_name = make_tarball(
-                base_name, 'dist', compress=None, owner=owner, group=group
-            )
-        finally:
-            os.chdir(old_dir)
-
-        # check if the compressed tarball was created
-        assert os.path.exists(archive_name)
-
-        # now checks the rights
-        archive = tarfile.open(archive_name)
-        try:
-            for member in archive.getmembers():
-                assert member.uid == 0
-                assert member.gid == 0
-        finally:
-            archive.close()

py2docfx/venv/template/Lib/site-packages/setuptools/_distutils/tests/test_bdist.py

@@ -1,47 +0,0 @@
-"""Tests for distutils.command.bdist."""
-
-from distutils.command.bdist import bdist
-from distutils.tests import support
-
-
-class TestBuild(support.TempdirManager):
-    def test_formats(self):
-        # let's create a command and make sure
-        # we can set the format
-        dist = self.create_dist()[1]
-        cmd = bdist(dist)
-        cmd.formats = ['gztar']
-        cmd.ensure_finalized()
-        assert cmd.formats == ['gztar']
-
-        # what formats does bdist offer?
-        formats = [
-            'bztar',
-            'gztar',
-            'rpm',
-            'tar',
-            'xztar',
-            'zip',
-            'ztar',
-        ]
-        found = sorted(cmd.format_commands)
-        assert found == formats
-
-    def test_skip_build(self):
-        # bug #10946: bdist --skip-build should trickle down to subcommands
-        dist = self.create_dist()[1]
-        cmd = bdist(dist)
-        cmd.skip_build = True
-        cmd.ensure_finalized()
-        dist.command_obj['bdist'] = cmd
-
-        names = [
-            'bdist_dumb',
-        ]  # bdist_rpm does not support --skip-build
-
-        for name in names:
-            subcmd = cmd.get_finalized_command(name)
-            if getattr(subcmd, '_unsupported', False):
-                # command is not supported on this build
-                continue
-            assert subcmd.skip_build, f'{name} should take --skip-build from bdist'