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

py2docfx/venv/template/Lib/site-packages/pip/_internal/locations/_sysconfig.py

@@ -1,213 +0,0 @@
-import logging
-import os
-import sys
-import sysconfig
-import typing
-
-from pip._internal.exceptions import InvalidSchemeCombination, UserInstallationInvalid
-from pip._internal.models.scheme import SCHEME_KEYS, Scheme
-from pip._internal.utils.virtualenv import running_under_virtualenv
-
-from .base import change_root, get_major_minor_version, is_osx_framework
-
-logger = logging.getLogger(__name__)
-
-
-# Notes on _infer_* functions.
-# Unfortunately ``get_default_scheme()`` didn't exist before 3.10, so there's no
-# way to ask things like "what is the '_prefix' scheme on this platform". These
-# functions try to answer that with some heuristics while accounting for ad-hoc
-# platforms not covered by CPython's default sysconfig implementation. If the
-# ad-hoc implementation does not fully implement sysconfig, we'll fall back to
-# a POSIX scheme.
-
-_AVAILABLE_SCHEMES = set(sysconfig.get_scheme_names())
-
-_PREFERRED_SCHEME_API = getattr(sysconfig, "get_preferred_scheme", None)
-
-
-def _should_use_osx_framework_prefix() -> bool:
-    """Check for Apple's ``osx_framework_library`` scheme.
-
-    Python distributed by Apple's Command Line Tools has this special scheme
-    that's used when:
-
-    * This is a framework build.
-    * We are installing into the system prefix.
-
-    This does not account for ``pip install --prefix`` (also means we're not
-    installing to the system prefix), which should use ``posix_prefix``, but
-    logic here means ``_infer_prefix()`` outputs ``osx_framework_library``. But
-    since ``prefix`` is not available for ``sysconfig.get_default_scheme()``,
-    which is the stdlib replacement for ``_infer_prefix()``, presumably Apple
-    wouldn't be able to magically switch between ``osx_framework_library`` and
-    ``posix_prefix``. ``_infer_prefix()`` returning ``osx_framework_library``
-    means its behavior is consistent whether we use the stdlib implementation
-    or our own, and we deal with this special case in ``get_scheme()`` instead.
-    """
-    return (
-        "osx_framework_library" in _AVAILABLE_SCHEMES
-        and not running_under_virtualenv()
-        and is_osx_framework()
-    )
-
-
-def _infer_prefix() -> str:
-    """Try to find a prefix scheme for the current platform.
-
-    This tries:
-
-    * A special ``osx_framework_library`` for Python distributed by Apple's
-      Command Line Tools, when not running in a virtual environment.
-    * Implementation + OS, used by PyPy on Windows (``pypy_nt``).
-    * Implementation without OS, used by PyPy on POSIX (``pypy``).
-    * OS + "prefix", used by CPython on POSIX (``posix_prefix``).
-    * Just the OS name, used by CPython on Windows (``nt``).
-
-    If none of the above works, fall back to ``posix_prefix``.
-    """
-    if _PREFERRED_SCHEME_API:
-        return _PREFERRED_SCHEME_API("prefix")
-    if _should_use_osx_framework_prefix():
-        return "osx_framework_library"
-    implementation_suffixed = f"{sys.implementation.name}_{os.name}"
-    if implementation_suffixed in _AVAILABLE_SCHEMES:
-        return implementation_suffixed
-    if sys.implementation.name in _AVAILABLE_SCHEMES:
-        return sys.implementation.name
-    suffixed = f"{os.name}_prefix"
-    if suffixed in _AVAILABLE_SCHEMES:
-        return suffixed
-    if os.name in _AVAILABLE_SCHEMES:  # On Windows, prefx is just called "nt".
-        return os.name
-    return "posix_prefix"
-
-
-def _infer_user() -> str:
-    """Try to find a user scheme for the current platform."""
-    if _PREFERRED_SCHEME_API:
-        return _PREFERRED_SCHEME_API("user")
-    if is_osx_framework() and not running_under_virtualenv():
-        suffixed = "osx_framework_user"
-    else:
-        suffixed = f"{os.name}_user"
-    if suffixed in _AVAILABLE_SCHEMES:
-        return suffixed
-    if "posix_user" not in _AVAILABLE_SCHEMES:  # User scheme unavailable.
-        raise UserInstallationInvalid()
-    return "posix_user"
-
-
-def _infer_home() -> str:
-    """Try to find a home for the current platform."""
-    if _PREFERRED_SCHEME_API:
-        return _PREFERRED_SCHEME_API("home")
-    suffixed = f"{os.name}_home"
-    if suffixed in _AVAILABLE_SCHEMES:
-        return suffixed
-    return "posix_home"
-
-
-# Update these keys if the user sets a custom home.
-_HOME_KEYS = [
-    "installed_base",
-    "base",
-    "installed_platbase",
-    "platbase",
-    "prefix",
-    "exec_prefix",
-]
-if sysconfig.get_config_var("userbase") is not None:
-    _HOME_KEYS.append("userbase")
-
-
-def get_scheme(
-    dist_name: str,
-    user: bool = False,
-    home: typing.Optional[str] = None,
-    root: typing.Optional[str] = None,
-    isolated: bool = False,
-    prefix: typing.Optional[str] = None,
-) -> Scheme:
-    """
-    Get the "scheme" corresponding to the input parameters.
-
-    :param dist_name: the name of the package to retrieve the scheme for, used
-        in the headers scheme path
-    :param user: indicates to use the "user" scheme
-    :param home: indicates to use the "home" scheme
-    :param root: root under which other directories are re-based
-    :param isolated: ignored, but kept for distutils compatibility (where
-        this controls whether the user-site pydistutils.cfg is honored)
-    :param prefix: indicates to use the "prefix" scheme and provides the
-        base directory for the same
-    """
-    if user and prefix:
-        raise InvalidSchemeCombination("--user", "--prefix")
-    if home and prefix:
-        raise InvalidSchemeCombination("--home", "--prefix")
-
-    if home is not None:
-        scheme_name = _infer_home()
-    elif user:
-        scheme_name = _infer_user()
-    else:
-        scheme_name = _infer_prefix()
-
-    # Special case: When installing into a custom prefix, use posix_prefix
-    # instead of osx_framework_library. See _should_use_osx_framework_prefix()
-    # docstring for details.
-    if prefix is not None and scheme_name == "osx_framework_library":
-        scheme_name = "posix_prefix"
-
-    if home is not None:
-        variables = {k: home for k in _HOME_KEYS}
-    elif prefix is not None:
-        variables = {k: prefix for k in _HOME_KEYS}
-    else:
-        variables = {}
-
-    paths = sysconfig.get_paths(scheme=scheme_name, vars=variables)
-
-    # Logic here is very arbitrary, we're doing it for compatibility, don't ask.
-    # 1. Pip historically uses a special header path in virtual environments.
-    # 2. If the distribution name is not known, distutils uses 'UNKNOWN'. We
-    #    only do the same when not running in a virtual environment because
-    #    pip's historical header path logic (see point 1) did not do this.
-    if running_under_virtualenv():
-        if user:
-            base = variables.get("userbase", sys.prefix)
-        else:
-            base = variables.get("base", sys.prefix)
-        python_xy = f"python{get_major_minor_version()}"
-        paths["include"] = os.path.join(base, "include", "site", python_xy)
-    elif not dist_name:
-        dist_name = "UNKNOWN"
-
-    scheme = Scheme(
-        platlib=paths["platlib"],
-        purelib=paths["purelib"],
-        headers=os.path.join(paths["include"], dist_name),
-        scripts=paths["scripts"],
-        data=paths["data"],
-    )
-    if root is not None:
-        for key in SCHEME_KEYS:
-            value = change_root(root, getattr(scheme, key))
-            setattr(scheme, key, value)
-    return scheme
-
-
-def get_bin_prefix() -> str:
-    # Forcing to use /usr/local/bin for standard macOS framework installs.
-    if sys.platform[:6] == "darwin" and sys.prefix[:16] == "/System/Library/":
-        return "/usr/local/bin"
-    return sysconfig.get_paths()["scripts"]
-
-
-def get_purelib() -> str:
-    return sysconfig.get_paths()["purelib"]
-
-
-def get_platlib() -> str:
-    return sysconfig.get_paths()["platlib"]

py2docfx/venv/template/Lib/site-packages/pip/_internal/locations/base.py

@@ -1,81 +0,0 @@
-import functools
-import os
-import site
-import sys
-import sysconfig
-import typing
-
-from pip._internal.exceptions import InstallationError
-from pip._internal.utils import appdirs
-from pip._internal.utils.virtualenv import running_under_virtualenv
-
-# Application Directories
-USER_CACHE_DIR = appdirs.user_cache_dir("pip")
-
-# FIXME doesn't account for venv linked to global site-packages
-site_packages: str = sysconfig.get_path("purelib")
-
-
-def get_major_minor_version() -> str:
-    """
-    Return the major-minor version of the current Python as a string, e.g.
-    "3.7" or "3.10".
-    """
-    return "{}.{}".format(*sys.version_info)
-
-
-def change_root(new_root: str, pathname: str) -> str:
-    """Return 'pathname' with 'new_root' prepended.
-
-    If 'pathname' is relative, this is equivalent to os.path.join(new_root, pathname).
-    Otherwise, it requires making 'pathname' relative and then joining the
-    two, which is tricky on DOS/Windows and Mac OS.
-
-    This is borrowed from Python's standard library's distutils module.
-    """
-    if os.name == "posix":
-        if not os.path.isabs(pathname):
-            return os.path.join(new_root, pathname)
-        else:
-            return os.path.join(new_root, pathname[1:])
-
-    elif os.name == "nt":
-        (drive, path) = os.path.splitdrive(pathname)
-        if path[0] == "\\":
-            path = path[1:]
-        return os.path.join(new_root, path)
-
-    else:
-        raise InstallationError(
-            f"Unknown platform: {os.name}\n"
-            "Can not change root path prefix on unknown platform."
-        )
-
-
-def get_src_prefix() -> str:
-    if running_under_virtualenv():
-        src_prefix = os.path.join(sys.prefix, "src")
-    else:
-        # FIXME: keep src in cwd for now (it is not a temporary folder)
-        try:
-            src_prefix = os.path.join(os.getcwd(), "src")
-        except OSError:
-            # In case the current working directory has been renamed or deleted
-            sys.exit("The folder you are executing pip from can no longer be found.")
-
-    # under macOS + virtualenv sys.prefix is not properly resolved
-    # it is something like /path/to/python/bin/..
-    return os.path.abspath(src_prefix)
-
-
-try:
-    # Use getusersitepackages if this is present, as it ensures that the
-    # value is initialised properly.
-    user_site: typing.Optional[str] = site.getusersitepackages()
-except AttributeError:
-    user_site = site.USER_SITE
-
-
-@functools.lru_cache(maxsize=None)
-def is_osx_framework() -> bool:
-    return bool(sysconfig.get_config_var("PYTHONFRAMEWORK"))

py2docfx/venv/template/Lib/site-packages/pip/_internal/main.py

@@ -1,12 +0,0 @@
-from typing import List, Optional
-
-
-def main(args: Optional[List[str]] = None) -> int:
-    """This is preserved for old console scripts that may still be referencing
-    it.
-
-    For additional details, see https://github.com/pypa/pip/issues/7498.
-    """
-    from pip._internal.utils.entrypoints import _wrapper
-
-    return _wrapper(args)

py2docfx/venv/template/Lib/site-packages/pip/_internal/metadata/__init__.py

@@ -1,128 +0,0 @@
-import contextlib
-import functools
-import os
-import sys
-from typing import TYPE_CHECKING, List, Optional, Type, cast
-
-from pip._internal.utils.misc import strtobool
-
-from .base import BaseDistribution, BaseEnvironment, FilesystemWheel, MemoryWheel, Wheel
-
-if TYPE_CHECKING:
-    from typing import Literal, Protocol
-else:
-    Protocol = object
-
-__all__ = [
-    "BaseDistribution",
-    "BaseEnvironment",
-    "FilesystemWheel",
-    "MemoryWheel",
-    "Wheel",
-    "get_default_environment",
-    "get_environment",
-    "get_wheel_distribution",
-    "select_backend",
-]
-
-
-def _should_use_importlib_metadata() -> bool:
-    """Whether to use the ``importlib.metadata`` or ``pkg_resources`` backend.
-
-    By default, pip uses ``importlib.metadata`` on Python 3.11+, and
-    ``pkg_resourcess`` otherwise. This can be overridden by a couple of ways:
-
-    * If environment variable ``_PIP_USE_IMPORTLIB_METADATA`` is set, it
-      dictates whether ``importlib.metadata`` is used, regardless of Python
-      version.
-    * On Python 3.11+, Python distributors can patch ``importlib.metadata``
-      to add a global constant ``_PIP_USE_IMPORTLIB_METADATA = False``. This
-      makes pip use ``pkg_resources`` (unless the user set the aforementioned
-      environment variable to *True*).
-    """
-    with contextlib.suppress(KeyError, ValueError):
-        return bool(strtobool(os.environ["_PIP_USE_IMPORTLIB_METADATA"]))
-    if sys.version_info < (3, 11):
-        return False
-    import importlib.metadata
-
-    return bool(getattr(importlib.metadata, "_PIP_USE_IMPORTLIB_METADATA", True))
-
-
-class Backend(Protocol):
-    NAME: 'Literal["importlib", "pkg_resources"]'
-    Distribution: Type[BaseDistribution]
-    Environment: Type[BaseEnvironment]
-
-
-@functools.lru_cache(maxsize=None)
-def select_backend() -> Backend:
-    if _should_use_importlib_metadata():
-        from . import importlib
-
-        return cast(Backend, importlib)
-    from . import pkg_resources
-
-    return cast(Backend, pkg_resources)
-
-
-def get_default_environment() -> BaseEnvironment:
-    """Get the default representation for the current environment.
-
-    This returns an Environment instance from the chosen backend. The default
-    Environment instance should be built from ``sys.path`` and may use caching
-    to share instance state accorss calls.
-    """
-    return select_backend().Environment.default()
-
-
-def get_environment(paths: Optional[List[str]]) -> BaseEnvironment:
-    """Get a representation of the environment specified by ``paths``.
-
-    This returns an Environment instance from the chosen backend based on the
-    given import paths. The backend must build a fresh instance representing
-    the state of installed distributions when this function is called.
-    """
-    return select_backend().Environment.from_paths(paths)
-
-
-def get_directory_distribution(directory: str) -> BaseDistribution:
-    """Get the distribution metadata representation in the specified directory.
-
-    This returns a Distribution instance from the chosen backend based on
-    the given on-disk ``.dist-info`` directory.
-    """
-    return select_backend().Distribution.from_directory(directory)
-
-
-def get_wheel_distribution(wheel: Wheel, canonical_name: str) -> BaseDistribution:
-    """Get the representation of the specified wheel's distribution metadata.
-
-    This returns a Distribution instance from the chosen backend based on
-    the given wheel's ``.dist-info`` directory.
-
-    :param canonical_name: Normalized project name of the given wheel.
-    """
-    return select_backend().Distribution.from_wheel(wheel, canonical_name)
-
-
-def get_metadata_distribution(
-    metadata_contents: bytes,
-    filename: str,
-    canonical_name: str,
-) -> BaseDistribution:
-    """Get the dist representation of the specified METADATA file contents.
-
-    This returns a Distribution instance from the chosen backend sourced from the data
-    in `metadata_contents`.
-
-    :param metadata_contents: Contents of a METADATA file within a dist, or one served
-                              via PEP 658.
-    :param filename: Filename for the dist this metadata represents.
-    :param canonical_name: Normalized project name of the given dist.
-    """
-    return select_backend().Distribution.from_metadata_file_contents(
-        metadata_contents,
-        filename,
-        canonical_name,
-    )

py2docfx/venv/template/Lib/site-packages/pip/_internal/metadata/_json.py

@@ -1,84 +0,0 @@
-# Extracted from https://github.com/pfmoore/pkg_metadata
-
-from email.header import Header, decode_header, make_header
-from email.message import Message
-from typing import Any, Dict, List, Union
-
-METADATA_FIELDS = [
-    # Name, Multiple-Use
-    ("Metadata-Version", False),
-    ("Name", False),
-    ("Version", False),
-    ("Dynamic", True),
-    ("Platform", True),
-    ("Supported-Platform", True),
-    ("Summary", False),
-    ("Description", False),
-    ("Description-Content-Type", False),
-    ("Keywords", False),
-    ("Home-page", False),
-    ("Download-URL", False),
-    ("Author", False),
-    ("Author-email", False),
-    ("Maintainer", False),
-    ("Maintainer-email", False),
-    ("License", False),
-    ("Classifier", True),
-    ("Requires-Dist", True),
-    ("Requires-Python", False),
-    ("Requires-External", True),
-    ("Project-URL", True),
-    ("Provides-Extra", True),
-    ("Provides-Dist", True),
-    ("Obsoletes-Dist", True),
-]
-
-
-def json_name(field: str) -> str:
-    return field.lower().replace("-", "_")
-
-
-def msg_to_json(msg: Message) -> Dict[str, Any]:
-    """Convert a Message object into a JSON-compatible dictionary."""
-
-    def sanitise_header(h: Union[Header, str]) -> str:
-        if isinstance(h, Header):
-            chunks = []
-            for bytes, encoding in decode_header(h):
-                if encoding == "unknown-8bit":
-                    try:
-                        # See if UTF-8 works
-                        bytes.decode("utf-8")
-                        encoding = "utf-8"
-                    except UnicodeDecodeError:
-                        # If not, latin1 at least won't fail
-                        encoding = "latin1"
-                chunks.append((bytes, encoding))
-            return str(make_header(chunks))
-        return str(h)
-
-    result = {}
-    for field, multi in METADATA_FIELDS:
-        if field not in msg:
-            continue
-        key = json_name(field)
-        if multi:
-            value: Union[str, List[str]] = [
-                sanitise_header(v) for v in msg.get_all(field)  # type: ignore
-            ]
-        else:
-            value = sanitise_header(msg.get(field))  # type: ignore
-            if key == "keywords":
-                # Accept both comma-separated and space-separated
-                # forms, for better compatibility with old data.
-                if "," in value:
-                    value = [v.strip() for v in value.split(",")]
-                else:
-                    value = value.split()
-        result[key] = value
-
-    payload = msg.get_payload()
-    if payload:
-        result["description"] = payload
-
-    return result