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/contexts.py

@@ -1,145 +0,0 @@
-import tempfile
-import os
-import shutil
-import sys
-import contextlib
-import site
-import io
-
-from filelock import FileLock
-
-
-@contextlib.contextmanager
-def tempdir(cd=lambda dir: None, **kwargs):
-    temp_dir = tempfile.mkdtemp(**kwargs)
-    orig_dir = os.getcwd()
-    try:
-        cd(temp_dir)
-        yield temp_dir
-    finally:
-        cd(orig_dir)
-        shutil.rmtree(temp_dir)
-
-
-@contextlib.contextmanager
-def environment(**replacements):
-    """
-    In a context, patch the environment with replacements. Pass None values
-    to clear the values.
-    """
-    saved = dict((key, os.environ[key]) for key in replacements if key in os.environ)
-
-    # remove values that are null
-    remove = (key for (key, value) in replacements.items() if value is None)
-    for key in list(remove):
-        os.environ.pop(key, None)
-        replacements.pop(key)
-
-    os.environ.update(replacements)
-
-    try:
-        yield saved
-    finally:
-        for key in replacements:
-            os.environ.pop(key, None)
-        os.environ.update(saved)
-
-
-@contextlib.contextmanager
-def quiet():
-    """
-    Redirect stdout/stderr to StringIO objects to prevent console output from
-    distutils commands.
-    """
-
-    old_stdout = sys.stdout
-    old_stderr = sys.stderr
-    new_stdout = sys.stdout = io.StringIO()
-    new_stderr = sys.stderr = io.StringIO()
-    try:
-        yield new_stdout, new_stderr
-    finally:
-        new_stdout.seek(0)
-        new_stderr.seek(0)
-        sys.stdout = old_stdout
-        sys.stderr = old_stderr
-
-
-@contextlib.contextmanager
-def save_user_site_setting():
-    saved = site.ENABLE_USER_SITE
-    try:
-        yield saved
-    finally:
-        site.ENABLE_USER_SITE = saved
-
-
-@contextlib.contextmanager
-def save_pkg_resources_state():
-    import pkg_resources
-
-    pr_state = pkg_resources.__getstate__()
-    # also save sys.path
-    sys_path = sys.path[:]
-    try:
-        yield pr_state, sys_path
-    finally:
-        sys.path[:] = sys_path
-        pkg_resources.__setstate__(pr_state)
-
-
-@contextlib.contextmanager
-def suppress_exceptions(*excs):
-    try:
-        yield
-    except excs:
-        pass
-
-
-def multiproc(request):
-    """
-    Return True if running under xdist and multiple
-    workers are used.
-    """
-    try:
-        worker_id = request.getfixturevalue('worker_id')
-    except Exception:
-        return False
-    return worker_id != 'master'
-
-
-@contextlib.contextmanager
-def session_locked_tmp_dir(request, tmp_path_factory, name):
-    """Uses a file lock to guarantee only one worker can access a temp dir"""
-    # get the temp directory shared by all workers
-    base = tmp_path_factory.getbasetemp()
-    shared_dir = base.parent if multiproc(request) else base
-
-    locked_dir = shared_dir / name
-    with FileLock(locked_dir.with_suffix(".lock")):
-        # ^-- prevent multiple workers to access the directory at once
-        locked_dir.mkdir(exist_ok=True, parents=True)
-        yield locked_dir
-
-
-@contextlib.contextmanager
-def save_paths():
-    """Make sure ``sys.path``, ``sys.meta_path`` and ``sys.path_hooks`` are preserved"""
-    prev = sys.path[:], sys.meta_path[:], sys.path_hooks[:]
-
-    try:
-        yield
-    finally:
-        sys.path, sys.meta_path, sys.path_hooks = prev
-
-
-@contextlib.contextmanager
-def save_sys_modules():
-    """Make sure initial ``sys.modules`` is preserved"""
-    prev_modules = sys.modules
-
-    try:
-        sys.modules = sys.modules.copy()
-        yield
-    finally:
-        sys.modules = prev_modules

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

@@ -1,95 +0,0 @@
-import os
-import sys
-import subprocess
-import unicodedata
-from subprocess import Popen as _Popen, PIPE as _PIPE
-
-import jaraco.envs
-
-
-class VirtualEnv(jaraco.envs.VirtualEnv):
-    name = '.env'
-    # Some version of PyPy will import distutils on startup, implicitly
-    # importing setuptools, and thus leading to BackendInvalid errors
-    # when upgrading Setuptools. Bypass this behavior by avoiding the
-    # early availability and need to upgrade.
-    create_opts = ['--no-setuptools']
-
-    def run(self, cmd, *args, **kwargs):
-        cmd = [self.exe(cmd[0])] + cmd[1:]
-        kwargs = {"cwd": self.root, "encoding": "utf-8", **kwargs}  # Allow overriding
-        # In some environments (eg. downstream distro packaging), where:
-        # - tox isn't used to run tests and
-        # - PYTHONPATH is set to point to a specific setuptools codebase and
-        # - no custom env is explicitly set by a test
-        # PYTHONPATH will leak into the spawned processes.
-        # In that case tests look for module in the wrong place (on PYTHONPATH).
-        # Unless the test sets its own special env, pass a copy of the existing
-        # environment with removed PYTHONPATH to the subprocesses.
-        if "env" not in kwargs:
-            env = dict(os.environ)
-            if "PYTHONPATH" in env:
-                del env["PYTHONPATH"]
-            kwargs["env"] = env
-        return subprocess.check_output(cmd, *args, **kwargs)
-
-
-def _which_dirs(cmd):
-    result = set()
-    for path in os.environ.get('PATH', '').split(os.pathsep):
-        filename = os.path.join(path, cmd)
-        if os.access(filename, os.X_OK):
-            result.add(path)
-    return result
-
-
-def run_setup_py(cmd, pypath=None, path=None, data_stream=0, env=None):
-    """
-    Execution command for tests, separate from those used by the
-    code directly to prevent accidental behavior issues
-    """
-    if env is None:
-        env = dict()
-        for envname in os.environ:
-            env[envname] = os.environ[envname]
-
-    # override the python path if needed
-    if pypath is not None:
-        env["PYTHONPATH"] = pypath
-
-    # override the execution path if needed
-    if path is not None:
-        env["PATH"] = path
-    if not env.get("PATH", ""):
-        env["PATH"] = _which_dirs("tar").union(_which_dirs("gzip"))
-        env["PATH"] = os.pathsep.join(env["PATH"])
-
-    cmd = [sys.executable, "setup.py"] + list(cmd)
-
-    # https://bugs.python.org/issue8557
-    shell = sys.platform == 'win32'
-
-    try:
-        proc = _Popen(
-            cmd,
-            stdout=_PIPE,
-            stderr=_PIPE,
-            shell=shell,
-            env=env,
-            encoding="utf-8",
-        )
-
-        if isinstance(data_stream, tuple):
-            data_stream = slice(*data_stream)
-        data = proc.communicate()[data_stream]
-    except OSError:
-        return 1, ''
-
-    # decode the console string if needed
-    if hasattr(data, "decode"):
-        # use the default encoding
-        data = data.decode()
-        data = unicodedata.normalize('NFC', data)
-
-    # communicate calls wait()
-    return proc.returncode, data

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

@@ -1,157 +0,0 @@
-import os
-import contextlib
-import sys
-import subprocess
-from pathlib import Path
-
-import pytest
-import path
-
-from . import contexts, environment
-
-
-@pytest.fixture
-def user_override(monkeypatch):
-    """
-    Override site.USER_BASE and site.USER_SITE with temporary directories in
-    a context.
-    """
-    with contexts.tempdir() as user_base:
-        monkeypatch.setattr('site.USER_BASE', user_base)
-        with contexts.tempdir() as user_site:
-            monkeypatch.setattr('site.USER_SITE', user_site)
-            with contexts.save_user_site_setting():
-                yield
-
-
-@pytest.fixture
-def tmpdir_cwd(tmpdir):
-    with tmpdir.as_cwd() as orig:
-        yield orig
-
-
-@pytest.fixture(autouse=True, scope="session")
-def workaround_xdist_376(request):
-    """
-    Workaround pytest-dev/pytest-xdist#376
-
-    ``pytest-xdist`` tends to inject '' into ``sys.path``,
-    which may break certain isolation expectations.
-    Remove the entry so the import
-    machinery behaves the same irrespective of xdist.
-    """
-    if not request.config.pluginmanager.has_plugin('xdist'):
-        return
-
-    with contextlib.suppress(ValueError):
-        sys.path.remove('')
-
-
-@pytest.fixture
-def sample_project(tmp_path):
-    """
-    Clone the 'sampleproject' and return a path to it.
-    """
-    cmd = ['git', 'clone', 'https://github.com/pypa/sampleproject']
-    try:
-        subprocess.check_call(cmd, cwd=str(tmp_path))
-    except Exception:
-        pytest.skip("Unable to clone sampleproject")
-    return tmp_path / 'sampleproject'
-
-
-# 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"
-
-# In the case of setuptools, building the wheel without sdist may cause
-# it to contain the `build` directory, and therefore create situations with
-# `setuptools/build/lib/build/lib/...`. To avoid that, build both artifacts at once.
-
-
-def _build_distributions(tmp_path_factory, request):
-    with contexts.session_locked_tmp_dir(
-        request, tmp_path_factory, "dist_build"
-    ) as tmp:  # pragma: no cover
-        sdist = next(tmp.glob("*.tar.gz"), None)
-        wheel = next(tmp.glob("*.whl"), None)
-        if sdist and wheel:
-            return (sdist, wheel)
-
-        # Sanity check: should not create recursive setuptools/build/lib/build/lib/...
-        assert not Path(request.config.rootdir, "build/lib/build").exists()
-
-        subprocess.check_output([
-            sys.executable,
-            "-m",
-            "build",
-            "--outdir",
-            str(tmp),
-            str(request.config.rootdir),
-        ])
-
-        # Sanity check: should not create recursive setuptools/build/lib/build/lib/...
-        assert not Path(request.config.rootdir, "build/lib/build").exists()
-
-        return next(tmp.glob("*.tar.gz")), next(tmp.glob("*.whl"))
-
-
-@pytest.fixture(scope="session")
-def setuptools_sdist(tmp_path_factory, request):
-    prebuilt = os.getenv("PRE_BUILT_SETUPTOOLS_SDIST")
-    if prebuilt and os.path.exists(prebuilt):  # pragma: no cover
-        return Path(prebuilt).resolve()
-
-    sdist, _ = _build_distributions(tmp_path_factory, request)
-    return sdist
-
-
-@pytest.fixture(scope="session")
-def setuptools_wheel(tmp_path_factory, request):
-    prebuilt = os.getenv("PRE_BUILT_SETUPTOOLS_WHEEL")
-    if prebuilt and os.path.exists(prebuilt):  # pragma: no cover
-        return Path(prebuilt).resolve()
-
-    _, wheel = _build_distributions(tmp_path_factory, request)
-    return wheel
-
-
-@pytest.fixture
-def venv(tmp_path, setuptools_wheel):
-    """Virtual env with the version of setuptools under test installed"""
-    env = environment.VirtualEnv()
-    env.root = path.Path(tmp_path / 'venv')
-    env.create_opts = ['--no-setuptools', '--wheel=bundle']
-    # TODO: Use `--no-wheel` when setuptools implements its own bdist_wheel
-    env.req = str(setuptools_wheel)
-    # In some environments (eg. downstream distro packaging),
-    # where tox isn't used to run tests and PYTHONPATH is set to point to
-    # a specific setuptools codebase, PYTHONPATH will leak into the spawned
-    # processes.
-    # env.create() should install the just created setuptools
-    # wheel, but it doesn't if it finds another existing matching setuptools
-    # installation present on PYTHONPATH:
-    # `setuptools is already installed with the same version as the provided
-    # wheel. Use --force-reinstall to force an installation of the wheel.`
-    # This prevents leaking PYTHONPATH to the created environment.
-    with contexts.environment(PYTHONPATH=None):
-        return env.create()
-
-
-@pytest.fixture
-def venv_without_setuptools(tmp_path):
-    """Virtual env without any version of setuptools installed"""
-    env = environment.VirtualEnv()
-    env.root = path.Path(tmp_path / 'venv_without_setuptools')
-    env.create_opts = ['--no-setuptools', '--no-wheel']
-    env.ensure_env()
-    return env
-
-
-@pytest.fixture
-def bare_venv(tmp_path):
-    """Virtual env without any common packages installed"""
-    env = environment.VirtualEnv()
-    env.root = path.Path(tmp_path / 'bare_venv')
-    env.create_opts = ['--no-setuptools', '--no-pip', '--no-wheel', '--no-seed']
-    env.ensure_env()
-    return env

py2docfx/venv/template/Lib/site-packages/setuptools/tests/integration/helpers.py

@@ -1,77 +0,0 @@
-"""Reusable functions and classes for different types of integration tests.
-
-For example ``Archive`` can be used to check the contents of distribution built
-with setuptools, and ``run`` will always try to be as verbose as possible to
-facilitate debugging.
-"""
-
-import os
-import subprocess
-import tarfile
-from zipfile import ZipFile
-from pathlib import Path
-
-
-def run(cmd, env=None):
-    r = subprocess.run(
-        cmd,
-        capture_output=True,
-        text=True,
-        encoding="utf-8",
-        env={**os.environ, **(env or {})},
-        # ^-- allow overwriting instead of discarding the current env
-    )
-
-    out = r.stdout + "\n" + r.stderr
-    # pytest omits stdout/err by default, if the test fails they help debugging
-    print("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~")
-    print(f"Command: {cmd}\nreturn code: {r.returncode}\n\n{out}")
-
-    if r.returncode == 0:
-        return out
-    raise subprocess.CalledProcessError(r.returncode, cmd, r.stdout, r.stderr)
-
-
-class Archive:
-    """Compatibility layer for ZipFile/Info and TarFile/Info"""
-
-    def __init__(self, filename):
-        self._filename = filename
-        if filename.endswith("tar.gz"):
-            self._obj = tarfile.open(filename, "r:gz")
-        elif filename.endswith("zip"):
-            self._obj = ZipFile(filename)
-        else:
-            raise ValueError(f"{filename} doesn't seem to be a zip or tar.gz")
-
-    def __iter__(self):
-        if hasattr(self._obj, "infolist"):
-            return iter(self._obj.infolist())
-        return iter(self._obj)
-
-    def get_name(self, zip_or_tar_info):
-        if hasattr(zip_or_tar_info, "filename"):
-            return zip_or_tar_info.filename
-        return zip_or_tar_info.name
-
-    def get_content(self, zip_or_tar_info):
-        if hasattr(self._obj, "extractfile"):
-            content = self._obj.extractfile(zip_or_tar_info)
-            if content is None:
-                msg = f"Invalid {zip_or_tar_info.name} in {self._filename}"
-                raise ValueError(msg)
-            return str(content.read(), "utf-8")
-        return str(self._obj.read(zip_or_tar_info), "utf-8")
-
-
-def get_sdist_members(sdist_path):
-    with tarfile.open(sdist_path, "r:gz") as tar:
-        files = [Path(f) for f in tar.getnames()]
-    # remove root folder
-    relative_files = ("/".join(f.parts[1:]) for f in files)
-    return {f for f in relative_files if f}
-
-
-def get_wheel_members(wheel_path):
-    with ZipFile(wheel_path) as zipfile:
-        return set(zipfile.namelist())

py2docfx/venv/template/Lib/site-packages/setuptools/tests/integration/test_pip_install_sdist.py

@@ -1,225 +0,0 @@
-# https://github.com/python/mypy/issues/16936
-# mypy: disable-error-code="has-type"
-"""Integration tests for setuptools that focus on building packages via pip.
-
-The idea behind these tests is not to exhaustively check all the possible
-combinations of packages, operating systems, supporting libraries, etc, but
-rather check a limited number of popular packages and how they interact with
-the exposed public API. This way if any change in API is introduced, we hope to
-identify backward compatibility problems before publishing a release.
-
-The number of tested packages is purposefully kept small, to minimise duration
-and the associated maintenance cost (changes in the way these packages define
-their build process may require changes in the tests).
-"""
-
-import json
-import os
-import shutil
-import sys
-from enum import Enum
-from glob import glob
-from hashlib import md5
-from urllib.request import urlopen
-
-import pytest
-from packaging.requirements import Requirement
-
-from .helpers import Archive, run
-
-pytestmark = pytest.mark.integration
-
-
-(LATEST,) = Enum("v", "LATEST")  # type: ignore[misc] # https://github.com/python/mypy/issues/16936
-"""Default version to be checked"""
-# There are positive and negative aspects of checking the latest version of the
-# packages.
-# The main positive aspect is that the latest version might have already
-# removed the use of APIs deprecated in previous releases of setuptools.
-
-
-# Packages to be tested:
-# (Please notice the test environment cannot support EVERY library required for
-# compiling binary extensions. In Ubuntu/Debian nomenclature, we only assume
-# that `build-essential`, `gfortran` and `libopenblas-dev` are installed,
-# due to their relevance to the numerical/scientific programming ecosystem)
-EXAMPLES = [
-    ("pip", LATEST),  # just in case...
-    ("pytest", LATEST),  # uses setuptools_scm
-    ("mypy", LATEST),  # custom build_py + ext_modules
-    # --- Popular packages: https://hugovk.github.io/top-pypi-packages/ ---
-    ("botocore", LATEST),
-    ("kiwisolver", LATEST),  # build_ext
-    ("brotli", LATEST),  # not in the list but used by urllib3
-    ("pyyaml", LATEST),  # cython + custom build_ext + custom distclass
-    ("charset-normalizer", LATEST),  # uses mypyc, used by aiohttp
-    ("protobuf", LATEST),
-    ("requests", LATEST),
-    ("celery", LATEST),
-    # When adding packages to this list, make sure they expose a `__version__`
-    # attribute, or modify the tests below
-]
-
-
-# Some packages have "optional" dependencies that modify their build behaviour
-# and are not listed in pyproject.toml, others still use `setup_requires`
-EXTRA_BUILD_DEPS = {
-    "pyyaml": ("Cython<3.0",),  # constraint to avoid errors
-    "charset-normalizer": ("mypy>=1.4.1",),  # no pyproject.toml available
-}
-
-EXTRA_ENV_VARS = {
-    "pyyaml": {"PYYAML_FORCE_CYTHON": "1"},
-    "charset-normalizer": {"CHARSET_NORMALIZER_USE_MYPYC": "1"},
-}
-
-IMPORT_NAME = {
-    "pyyaml": "yaml",
-    "protobuf": "google.protobuf",
-}
-
-
-VIRTUALENV = (sys.executable, "-m", "virtualenv")
-
-
-# By default, pip will try to build packages in isolation (PEP 517), which
-# means it will download the previous stable version of setuptools.
-# `pip` flags can avoid that (the version of setuptools under test
-# should be the one to be used)
-INSTALL_OPTIONS = (
-    "--ignore-installed",
-    "--no-build-isolation",
-    # Omit "--no-binary :all:" the sdist is supplied directly.
-    # Allows dependencies as wheels.
-)
-# The downside of `--no-build-isolation` is that pip will not download build
-# dependencies. The test script will have to also handle that.
-
-
-@pytest.fixture
-def venv_python(tmp_path):
-    run([*VIRTUALENV, str(tmp_path / ".venv")])
-    possible_path = (str(p.parent) for p in tmp_path.glob(".venv/*/python*"))
-    return shutil.which("python", path=os.pathsep.join(possible_path))
-
-
-@pytest.fixture(autouse=True)
-def _prepare(tmp_path, venv_python, monkeypatch, request):
-    download_path = os.getenv("DOWNLOAD_PATH", str(tmp_path))
-    os.makedirs(download_path, exist_ok=True)
-
-    # Environment vars used for building some of the packages
-    monkeypatch.setenv("USE_MYPYC", "1")
-
-    def _debug_info():
-        # Let's provide the maximum amount of information possible in the case
-        # it is necessary to debug the tests directly from the CI logs.
-        print("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~")
-        print("Temporary directory:")
-        map(print, tmp_path.glob("*"))
-        print("Virtual environment:")
-        run([venv_python, "-m", "pip", "freeze"])
-
-    request.addfinalizer(_debug_info)
-
-
-@pytest.mark.parametrize('package, version', EXAMPLES)
-@pytest.mark.uses_network
-def test_install_sdist(package, version, tmp_path, venv_python, setuptools_wheel):
-    venv_pip = (venv_python, "-m", "pip")
-    sdist = retrieve_sdist(package, version, tmp_path)
-    deps = build_deps(package, sdist)
-    if deps:
-        print("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~")
-        print("Dependencies:", deps)
-        run([*venv_pip, "install", *deps])
-
-    # Use a virtualenv to simulate PEP 517 isolation
-    # but install fresh setuptools wheel to ensure the version under development
-    env = EXTRA_ENV_VARS.get(package, {})
-    run([*venv_pip, "install", "wheel", "-I", setuptools_wheel])
-    run([*venv_pip, "install", *INSTALL_OPTIONS, sdist], env)
-
-    # Execute a simple script to make sure the package was installed correctly
-    pkg = IMPORT_NAME.get(package, package).replace("-", "_")
-    script = f"import {pkg}; print(getattr({pkg}, '__version__', 0))"
-    run([venv_python, "-c", script])
-
-
-# ---- Helper Functions ----
-
-
-def retrieve_sdist(package, version, tmp_path):
-    """Either use cached sdist file or download it from PyPI"""
-    # `pip download` cannot be used due to
-    # https://github.com/pypa/pip/issues/1884
-    # https://discuss.python.org/t/pep-625-file-name-of-a-source-distribution/4686
-    # We have to find the correct distribution file and download it
-    download_path = os.getenv("DOWNLOAD_PATH", str(tmp_path))
-    dist = retrieve_pypi_sdist_metadata(package, version)
-
-    # Remove old files to prevent cache to grow indefinitely
-    for file in glob(os.path.join(download_path, f"{package}*")):
-        if dist["filename"] != file:
-            os.unlink(file)
-
-    dist_file = os.path.join(download_path, dist["filename"])
-    if not os.path.exists(dist_file):
-        download(dist["url"], dist_file, dist["md5_digest"])
-    return dist_file
-
-
-def retrieve_pypi_sdist_metadata(package, version):
-    # https://warehouse.pypa.io/api-reference/json.html
-    id_ = package if version is LATEST else f"{package}/{version}"
-    with urlopen(f"https://pypi.org/pypi/{id_}/json") as f:
-        metadata = json.load(f)
-
-    if metadata["info"]["yanked"]:
-        raise ValueError(f"Release for {package} {version} was yanked")
-
-    version = metadata["info"]["version"]
-    release = metadata["releases"][version] if version is LATEST else metadata["urls"]
-    (sdist,) = filter(lambda d: d["packagetype"] == "sdist", release)
-    return sdist
-
-
-def download(url, dest, md5_digest):
-    with urlopen(url) as f:
-        data = f.read()
-
-    assert md5(data).hexdigest() == md5_digest
-
-    with open(dest, "wb") as f:
-        f.write(data)
-
-    assert os.path.exists(dest)
-
-
-def build_deps(package, sdist_file):
-    """Find out what are the build dependencies for a package.
-
-    "Manually" install them, since pip will not install build
-    deps with `--no-build-isolation`.
-    """
-    import tomli as toml
-
-    # delay importing, since pytest discovery phase may hit this file from a
-    # testenv without tomli
-
-    archive = Archive(sdist_file)
-    info = toml.loads(_read_pyproject(archive))
-    deps = info.get("build-system", {}).get("requires", [])
-    deps += EXTRA_BUILD_DEPS.get(package, [])
-    # Remove setuptools from requirements (and deduplicate)
-    requirements = {Requirement(d).name: d for d in deps}
-    return [v for k, v in requirements.items() if k != "setuptools"]
-
-
-def _read_pyproject(archive):
-    contents = (
-        archive.get_content(member)
-        for member in archive
-        if os.path.basename(archive.get_name(member)) == "pyproject.toml"
-    )
-    return next(contents, "")