[0-9]+(?:\.[0-9]+)*) # release segment
(?P # pre-release
[-_\.]?
- (?P(a|b|c|rc|alpha|beta|pre|preview))
+ (?Palpha|a|beta|b|preview|pre|c|rc)
[-_\.]?
(?P[0-9]+)?
)?
@@ -253,17 +145,61 @@ VERSION_PATTERN = r"""
(?:\+(?P[a-z0-9]+(?:[-_\.][a-z0-9]+)*))? # local version
"""
+VERSION_PATTERN = _VERSION_PATTERN
+"""
+A string containing the regular expression used to match a valid version.
+
+The pattern is not anchored at either end, and is intended for embedding in larger
+expressions (for example, matching a version number as part of a file name). The
+regular expression should be compiled with the ``re.VERBOSE`` and ``re.IGNORECASE``
+flags set.
+
+:meta hide-value:
+"""
+
class Version(_BaseVersion):
+ """This class abstracts handling of a project's versions.
+
+ A :class:`Version` instance is comparison aware and can be compared and
+ sorted using the standard Python interfaces.
+
+ >>> v1 = Version("1.0a5")
+ >>> v2 = Version("1.0")
+ >>> v1
+
+ >>> v2
+
+ >>> v1 < v2
+ True
+ >>> v1 == v2
+ False
+ >>> v1 > v2
+ False
+ >>> v1 >= v2
+ False
+ >>> v1 <= v2
+ True
+ """
_regex = re.compile(r"^\s*" + VERSION_PATTERN + r"\s*$", re.VERBOSE | re.IGNORECASE)
+ _key: CmpKey
def __init__(self, version: str) -> None:
+ """Initialize a Version object.
+
+ :param version:
+ The string representation of a version which will be parsed and normalized
+ before use.
+ :raises InvalidVersion:
+ If the ``version`` does not conform to PEP 440 in any way then this
+ exception will be raised.
+ """
# Validate the version and parse it into pieces
match = self._regex.search(version)
if not match:
- raise InvalidVersion(f"Invalid version: '{version}'")
+ raise InvalidVersion(f"Invalid version: {version!r}")
# Store the parsed out pieces of the version
self._version = _Version(
@@ -288,9 +224,19 @@ class Version(_BaseVersion):
)
def __repr__(self) -> str:
+ """A representation of the Version that shows all internal state.
+
+ >>> Version('1.0.0')
+
+ """
return f""
def __str__(self) -> str:
+ """A string representation of the version that can be round-tripped.
+
+ >>> str(Version("1.0a5"))
+ '1.0a5'
+ """
parts = []
# Epoch
@@ -320,29 +266,77 @@ class Version(_BaseVersion):
@property
def epoch(self) -> int:
- _epoch: int = self._version.epoch
- return _epoch
+ """The epoch of the version.
+
+ >>> Version("2.0.0").epoch
+ 0
+ >>> Version("1!2.0.0").epoch
+ 1
+ """
+ return self._version.epoch
@property
- def release(self) -> Tuple[int, ...]:
- _release: Tuple[int, ...] = self._version.release
- return _release
+ def release(self) -> tuple[int, ...]:
+ """The components of the "release" segment of the version.
+
+ >>> Version("1.2.3").release
+ (1, 2, 3)
+ >>> Version("2.0.0").release
+ (2, 0, 0)
+ >>> Version("1!2.0.0.post0").release
+ (2, 0, 0)
+
+ Includes trailing zeroes but not the epoch or any pre-release / development /
+ post-release suffixes.
+ """
+ return self._version.release
@property
- def pre(self) -> Optional[Tuple[str, int]]:
- _pre: Optional[Tuple[str, int]] = self._version.pre
- return _pre
+ def pre(self) -> tuple[str, int] | None:
+ """The pre-release segment of the version.
+
+ >>> print(Version("1.2.3").pre)
+ None
+ >>> Version("1.2.3a1").pre
+ ('a', 1)
+ >>> Version("1.2.3b1").pre
+ ('b', 1)
+ >>> Version("1.2.3rc1").pre
+ ('rc', 1)
+ """
+ return self._version.pre
@property
- def post(self) -> Optional[int]:
+ def post(self) -> int | None:
+ """The post-release number of the version.
+
+ >>> print(Version("1.2.3").post)
+ None
+ >>> Version("1.2.3.post1").post
+ 1
+ """
return self._version.post[1] if self._version.post else None
@property
- def dev(self) -> Optional[int]:
+ def dev(self) -> int | None:
+ """The development number of the version.
+
+ >>> print(Version("1.2.3").dev)
+ None
+ >>> Version("1.2.3.dev1").dev
+ 1
+ """
return self._version.dev[1] if self._version.dev else None
@property
- def local(self) -> Optional[str]:
+ def local(self) -> str | None:
+ """The local version segment of the version.
+
+ >>> print(Version("1.2.3").local)
+ None
+ >>> Version("1.2.3+abc").local
+ 'abc'
+ """
if self._version.local:
return ".".join(str(x) for x in self._version.local)
else:
@@ -350,10 +344,31 @@ class Version(_BaseVersion):
@property
def public(self) -> str:
+ """The public portion of the version.
+
+ >>> Version("1.2.3").public
+ '1.2.3'
+ >>> Version("1.2.3+abc").public
+ '1.2.3'
+ >>> Version("1!1.2.3dev1+abc").public
+ '1!1.2.3.dev1'
+ """
return str(self).split("+", 1)[0]
@property
def base_version(self) -> str:
+ """The "base version" of the version.
+
+ >>> Version("1.2.3").base_version
+ '1.2.3'
+ >>> Version("1.2.3+abc").base_version
+ '1.2.3'
+ >>> Version("1!1.2.3dev1+abc").base_version
+ '1!1.2.3'
+
+ The "base version" is the public version of the project without any pre or post
+ release markers.
+ """
parts = []
# Epoch
@@ -367,33 +382,95 @@ class Version(_BaseVersion):
@property
def is_prerelease(self) -> bool:
+ """Whether this version is a pre-release.
+
+ >>> Version("1.2.3").is_prerelease
+ False
+ >>> Version("1.2.3a1").is_prerelease
+ True
+ >>> Version("1.2.3b1").is_prerelease
+ True
+ >>> Version("1.2.3rc1").is_prerelease
+ True
+ >>> Version("1.2.3dev1").is_prerelease
+ True
+ """
return self.dev is not None or self.pre is not None
@property
def is_postrelease(self) -> bool:
+ """Whether this version is a post-release.
+
+ >>> Version("1.2.3").is_postrelease
+ False
+ >>> Version("1.2.3.post1").is_postrelease
+ True
+ """
return self.post is not None
@property
def is_devrelease(self) -> bool:
+ """Whether this version is a development release.
+
+ >>> Version("1.2.3").is_devrelease
+ False
+ >>> Version("1.2.3.dev1").is_devrelease
+ True
+ """
return self.dev is not None
@property
def major(self) -> int:
+ """The first item of :attr:`release` or ``0`` if unavailable.
+
+ >>> Version("1.2.3").major
+ 1
+ """
return self.release[0] if len(self.release) >= 1 else 0
@property
def minor(self) -> int:
+ """The second item of :attr:`release` or ``0`` if unavailable.
+
+ >>> Version("1.2.3").minor
+ 2
+ >>> Version("1").minor
+ 0
+ """
return self.release[1] if len(self.release) >= 2 else 0
@property
def micro(self) -> int:
+ """The third item of :attr:`release` or ``0`` if unavailable.
+
+ >>> Version("1.2.3").micro
+ 3
+ >>> Version("1").micro
+ 0
+ """
return self.release[2] if len(self.release) >= 3 else 0
-def _parse_letter_version(
- letter: str, number: Union[str, bytes, SupportsInt]
-) -> Optional[Tuple[str, int]]:
+class _TrimmedRelease(Version):
+ @property
+ def release(self) -> tuple[int, ...]:
+ """
+ Release segment without any trailing zeros.
+ >>> _TrimmedRelease('1.0.0').release
+ (1,)
+ >>> _TrimmedRelease('0.0').release
+ (0,)
+ """
+ rel = super().release
+ nonzeros = (index for index, val in enumerate(rel) if val)
+ last_nonzero = max(nonzeros, default=0)
+ return rel[: last_nonzero + 1]
+
+
+def _parse_letter_version(
+ letter: str | None, number: str | bytes | SupportsInt | None
+) -> tuple[str, int] | None:
if letter:
# We consider there to be an implicit 0 in a pre-release if there is
# not a numeral associated with it.
@@ -416,7 +493,9 @@ def _parse_letter_version(
letter = "post"
return letter, int(number)
- if not letter and number:
+
+ assert not letter
+ if number:
# We assume if we are given a number, but we are not given a letter
# then this is using the implicit post release syntax (e.g. 1.0-1)
letter = "post"
@@ -429,7 +508,7 @@ def _parse_letter_version(
_local_version_separators = re.compile(r"[\._-]")
-def _parse_local_version(local: str) -> Optional[LocalType]:
+def _parse_local_version(local: str | None) -> LocalType | None:
"""
Takes a string like abc.1.twelve and turns it into ("abc", 1, "twelve").
"""
@@ -443,13 +522,12 @@ def _parse_local_version(local: str) -> Optional[LocalType]:
def _cmpkey(
epoch: int,
- release: Tuple[int, ...],
- pre: Optional[Tuple[str, int]],
- post: Optional[Tuple[str, int]],
- dev: Optional[Tuple[str, int]],
- local: Optional[Tuple[SubLocalType]],
+ release: tuple[int, ...],
+ pre: tuple[str, int] | None,
+ post: tuple[str, int] | None,
+ dev: tuple[str, int] | None,
+ local: LocalType | None,
) -> CmpKey:
-
# When we compare a release version, we want to compare it with all of the
# trailing zeros removed. So we'll use a reverse the list, drop all the now
# leading zeros until we come to something non zero, then take the rest
@@ -464,7 +542,7 @@ def _cmpkey(
# if there is not a pre or a post segment. If we have one of those then
# the normal sorting rules will handle this case correctly.
if pre is None and post is None and dev is not None:
- _pre: PrePostDevType = NegativeInfinity
+ _pre: CmpPrePostDevType = NegativeInfinity
# Versions without a pre-release (except as noted above) should sort after
# those with one.
elif pre is None:
@@ -474,21 +552,21 @@ def _cmpkey(
# Versions without a post segment should sort before those with one.
if post is None:
- _post: PrePostDevType = NegativeInfinity
+ _post: CmpPrePostDevType = NegativeInfinity
else:
_post = post
# Versions without a development segment should sort after those with one.
if dev is None:
- _dev: PrePostDevType = Infinity
+ _dev: CmpPrePostDevType = Infinity
else:
_dev = dev
if local is None:
# Versions without a local segment should sort before those with one.
- _local: LocalType = NegativeInfinity
+ _local: CmpLocalType = NegativeInfinity
else:
# Versions with a local segment need that segment parsed to implement
# the sorting rules in PEP440.
diff --git a/venv/Lib/site-packages/pip/_vendor/pep517/__init__.py b/venv/Lib/site-packages/pip/_vendor/pep517/__init__.py
deleted file mode 100644
index 2b6b885..0000000
--- a/venv/Lib/site-packages/pip/_vendor/pep517/__init__.py
+++ /dev/null
@@ -1,6 +0,0 @@
-"""Wrappers to build Python packages using PEP 517 hooks
-"""
-
-__version__ = '0.12.0'
-
-from .wrappers import * # noqa: F401, F403
diff --git a/venv/Lib/site-packages/pip/_vendor/pep517/__pycache__/__init__.cpython-310.pyc b/venv/Lib/site-packages/pip/_vendor/pep517/__pycache__/__init__.cpython-310.pyc
deleted file mode 100644
index 8670ad5..0000000
Binary files a/venv/Lib/site-packages/pip/_vendor/pep517/__pycache__/__init__.cpython-310.pyc and /dev/null differ
diff --git a/venv/Lib/site-packages/pip/_vendor/pep517/__pycache__/build.cpython-310.pyc b/venv/Lib/site-packages/pip/_vendor/pep517/__pycache__/build.cpython-310.pyc
deleted file mode 100644
index 89b94c7..0000000
Binary files a/venv/Lib/site-packages/pip/_vendor/pep517/__pycache__/build.cpython-310.pyc and /dev/null differ
diff --git a/venv/Lib/site-packages/pip/_vendor/pep517/__pycache__/check.cpython-310.pyc b/venv/Lib/site-packages/pip/_vendor/pep517/__pycache__/check.cpython-310.pyc
deleted file mode 100644
index b682e05..0000000
Binary files a/venv/Lib/site-packages/pip/_vendor/pep517/__pycache__/check.cpython-310.pyc and /dev/null differ
diff --git a/venv/Lib/site-packages/pip/_vendor/pep517/__pycache__/colorlog.cpython-310.pyc b/venv/Lib/site-packages/pip/_vendor/pep517/__pycache__/colorlog.cpython-310.pyc
deleted file mode 100644
index 9145515..0000000
Binary files a/venv/Lib/site-packages/pip/_vendor/pep517/__pycache__/colorlog.cpython-310.pyc and /dev/null differ
diff --git a/venv/Lib/site-packages/pip/_vendor/pep517/__pycache__/compat.cpython-310.pyc b/venv/Lib/site-packages/pip/_vendor/pep517/__pycache__/compat.cpython-310.pyc
deleted file mode 100644
index 906056f..0000000
Binary files a/venv/Lib/site-packages/pip/_vendor/pep517/__pycache__/compat.cpython-310.pyc and /dev/null differ
diff --git a/venv/Lib/site-packages/pip/_vendor/pep517/__pycache__/dirtools.cpython-310.pyc b/venv/Lib/site-packages/pip/_vendor/pep517/__pycache__/dirtools.cpython-310.pyc
deleted file mode 100644
index 1783841..0000000
Binary files a/venv/Lib/site-packages/pip/_vendor/pep517/__pycache__/dirtools.cpython-310.pyc and /dev/null differ
diff --git a/venv/Lib/site-packages/pip/_vendor/pep517/__pycache__/envbuild.cpython-310.pyc b/venv/Lib/site-packages/pip/_vendor/pep517/__pycache__/envbuild.cpython-310.pyc
deleted file mode 100644
index 274add1..0000000
Binary files a/venv/Lib/site-packages/pip/_vendor/pep517/__pycache__/envbuild.cpython-310.pyc and /dev/null differ
diff --git a/venv/Lib/site-packages/pip/_vendor/pep517/__pycache__/meta.cpython-310.pyc b/venv/Lib/site-packages/pip/_vendor/pep517/__pycache__/meta.cpython-310.pyc
deleted file mode 100644
index dcb7a29..0000000
Binary files a/venv/Lib/site-packages/pip/_vendor/pep517/__pycache__/meta.cpython-310.pyc and /dev/null differ
diff --git a/venv/Lib/site-packages/pip/_vendor/pep517/__pycache__/wrappers.cpython-310.pyc b/venv/Lib/site-packages/pip/_vendor/pep517/__pycache__/wrappers.cpython-310.pyc
deleted file mode 100644
index 421193d..0000000
Binary files a/venv/Lib/site-packages/pip/_vendor/pep517/__pycache__/wrappers.cpython-310.pyc and /dev/null differ
diff --git a/venv/Lib/site-packages/pip/_vendor/pep517/build.py b/venv/Lib/site-packages/pip/_vendor/pep517/build.py
deleted file mode 100644
index bc463b2..0000000
--- a/venv/Lib/site-packages/pip/_vendor/pep517/build.py
+++ /dev/null
@@ -1,127 +0,0 @@
-"""Build a project using PEP 517 hooks.
-"""
-import argparse
-import io
-import logging
-import os
-import shutil
-
-from .envbuild import BuildEnvironment
-from .wrappers import Pep517HookCaller
-from .dirtools import tempdir, mkdir_p
-from .compat import FileNotFoundError, toml_load
-
-log = logging.getLogger(__name__)
-
-
-def validate_system(system):
- """
- Ensure build system has the requisite fields.
- """
- required = {'requires', 'build-backend'}
- if not (required <= set(system)):
- message = "Missing required fields: {missing}".format(
- missing=required-set(system),
- )
- raise ValueError(message)
-
-
-def load_system(source_dir):
- """
- Load the build system from a source dir (pyproject.toml).
- """
- pyproject = os.path.join(source_dir, 'pyproject.toml')
- with io.open(pyproject, 'rb') as f:
- pyproject_data = toml_load(f)
- return pyproject_data['build-system']
-
-
-def compat_system(source_dir):
- """
- Given a source dir, attempt to get a build system backend
- and requirements from pyproject.toml. Fallback to
- setuptools but only if the file was not found or a build
- system was not indicated.
- """
- try:
- system = load_system(source_dir)
- except (FileNotFoundError, KeyError):
- system = {}
- system.setdefault(
- 'build-backend',
- 'setuptools.build_meta:__legacy__',
- )
- system.setdefault('requires', ['setuptools', 'wheel'])
- return system
-
-
-def _do_build(hooks, env, dist, dest):
- get_requires_name = 'get_requires_for_build_{dist}'.format(**locals())
- get_requires = getattr(hooks, get_requires_name)
- reqs = get_requires({})
- log.info('Got build requires: %s', reqs)
-
- env.pip_install(reqs)
- log.info('Installed dynamic build dependencies')
-
- with tempdir() as td:
- log.info('Trying to build %s in %s', dist, td)
- build_name = 'build_{dist}'.format(**locals())
- build = getattr(hooks, build_name)
- filename = build(td, {})
- source = os.path.join(td, filename)
- shutil.move(source, os.path.join(dest, os.path.basename(filename)))
-
-
-def build(source_dir, dist, dest=None, system=None):
- system = system or load_system(source_dir)
- dest = os.path.join(source_dir, dest or 'dist')
- mkdir_p(dest)
-
- validate_system(system)
- hooks = Pep517HookCaller(
- source_dir, system['build-backend'], system.get('backend-path')
- )
-
- with BuildEnvironment() as env:
- env.pip_install(system['requires'])
- _do_build(hooks, env, dist, dest)
-
-
-parser = argparse.ArgumentParser()
-parser.add_argument(
- 'source_dir',
- help="A directory containing pyproject.toml",
-)
-parser.add_argument(
- '--binary', '-b',
- action='store_true',
- default=False,
-)
-parser.add_argument(
- '--source', '-s',
- action='store_true',
- default=False,
-)
-parser.add_argument(
- '--out-dir', '-o',
- help="Destination in which to save the builds relative to source dir",
-)
-
-
-def main(args):
- log.warning('pep517.build is deprecated. '
- 'Consider switching to https://pypi.org/project/build/')
-
- # determine which dists to build
- dists = list(filter(None, (
- 'sdist' if args.source or not args.binary else None,
- 'wheel' if args.binary or not args.source else None,
- )))
-
- for dist in dists:
- build(args.source_dir, dist, args.out_dir)
-
-
-if __name__ == '__main__':
- main(parser.parse_args())
diff --git a/venv/Lib/site-packages/pip/_vendor/pep517/check.py b/venv/Lib/site-packages/pip/_vendor/pep517/check.py
deleted file mode 100644
index bf3c722..0000000
--- a/venv/Lib/site-packages/pip/_vendor/pep517/check.py
+++ /dev/null
@@ -1,207 +0,0 @@
-"""Check a project and backend by attempting to build using PEP 517 hooks.
-"""
-import argparse
-import io
-import logging
-import os
-from os.path import isfile, join as pjoin
-import shutil
-from subprocess import CalledProcessError
-import sys
-import tarfile
-from tempfile import mkdtemp
-import zipfile
-
-from .colorlog import enable_colourful_output
-from .compat import TOMLDecodeError, toml_load
-from .envbuild import BuildEnvironment
-from .wrappers import Pep517HookCaller
-
-log = logging.getLogger(__name__)
-
-
-def check_build_sdist(hooks, build_sys_requires):
- with BuildEnvironment() as env:
- try:
- env.pip_install(build_sys_requires)
- log.info('Installed static build dependencies')
- except CalledProcessError:
- log.error('Failed to install static build dependencies')
- return False
-
- try:
- reqs = hooks.get_requires_for_build_sdist({})
- log.info('Got build requires: %s', reqs)
- except Exception:
- log.error('Failure in get_requires_for_build_sdist', exc_info=True)
- return False
-
- try:
- env.pip_install(reqs)
- log.info('Installed dynamic build dependencies')
- except CalledProcessError:
- log.error('Failed to install dynamic build dependencies')
- return False
-
- td = mkdtemp()
- log.info('Trying to build sdist in %s', td)
- try:
- try:
- filename = hooks.build_sdist(td, {})
- log.info('build_sdist returned %r', filename)
- except Exception:
- log.info('Failure in build_sdist', exc_info=True)
- return False
-
- if not filename.endswith('.tar.gz'):
- log.error(
- "Filename %s doesn't have .tar.gz extension", filename)
- return False
-
- path = pjoin(td, filename)
- if isfile(path):
- log.info("Output file %s exists", path)
- else:
- log.error("Output file %s does not exist", path)
- return False
-
- if tarfile.is_tarfile(path):
- log.info("Output file is a tar file")
- else:
- log.error("Output file is not a tar file")
- return False
-
- finally:
- shutil.rmtree(td)
-
- return True
-
-
-def check_build_wheel(hooks, build_sys_requires):
- with BuildEnvironment() as env:
- try:
- env.pip_install(build_sys_requires)
- log.info('Installed static build dependencies')
- except CalledProcessError:
- log.error('Failed to install static build dependencies')
- return False
-
- try:
- reqs = hooks.get_requires_for_build_wheel({})
- log.info('Got build requires: %s', reqs)
- except Exception:
- log.error('Failure in get_requires_for_build_sdist', exc_info=True)
- return False
-
- try:
- env.pip_install(reqs)
- log.info('Installed dynamic build dependencies')
- except CalledProcessError:
- log.error('Failed to install dynamic build dependencies')
- return False
-
- td = mkdtemp()
- log.info('Trying to build wheel in %s', td)
- try:
- try:
- filename = hooks.build_wheel(td, {})
- log.info('build_wheel returned %r', filename)
- except Exception:
- log.info('Failure in build_wheel', exc_info=True)
- return False
-
- if not filename.endswith('.whl'):
- log.error("Filename %s doesn't have .whl extension", filename)
- return False
-
- path = pjoin(td, filename)
- if isfile(path):
- log.info("Output file %s exists", path)
- else:
- log.error("Output file %s does not exist", path)
- return False
-
- if zipfile.is_zipfile(path):
- log.info("Output file is a zip file")
- else:
- log.error("Output file is not a zip file")
- return False
-
- finally:
- shutil.rmtree(td)
-
- return True
-
-
-def check(source_dir):
- pyproject = pjoin(source_dir, 'pyproject.toml')
- if isfile(pyproject):
- log.info('Found pyproject.toml')
- else:
- log.error('Missing pyproject.toml')
- return False
-
- try:
- with io.open(pyproject, 'rb') as f:
- pyproject_data = toml_load(f)
- # Ensure the mandatory data can be loaded
- buildsys = pyproject_data['build-system']
- requires = buildsys['requires']
- backend = buildsys['build-backend']
- backend_path = buildsys.get('backend-path')
- log.info('Loaded pyproject.toml')
- except (TOMLDecodeError, KeyError):
- log.error("Invalid pyproject.toml", exc_info=True)
- return False
-
- hooks = Pep517HookCaller(source_dir, backend, backend_path)
-
- sdist_ok = check_build_sdist(hooks, requires)
- wheel_ok = check_build_wheel(hooks, requires)
-
- if not sdist_ok:
- log.warning('Sdist checks failed; scroll up to see')
- if not wheel_ok:
- log.warning('Wheel checks failed')
-
- return sdist_ok
-
-
-def main(argv=None):
- log.warning('pep517.check is deprecated. '
- 'Consider switching to https://pypi.org/project/build/')
-
- ap = argparse.ArgumentParser()
- ap.add_argument(
- 'source_dir',
- help="A directory containing pyproject.toml")
- args = ap.parse_args(argv)
-
- enable_colourful_output()
-
- ok = check(args.source_dir)
-
- if ok:
- print(ansi('Checks passed', 'green'))
- else:
- print(ansi('Checks failed', 'red'))
- sys.exit(1)
-
-
-ansi_codes = {
- 'reset': '\x1b[0m',
- 'bold': '\x1b[1m',
- 'red': '\x1b[31m',
- 'green': '\x1b[32m',
-}
-
-
-def ansi(s, attr):
- if os.name != 'nt' and sys.stdout.isatty():
- return ansi_codes[attr] + str(s) + ansi_codes['reset']
- else:
- return str(s)
-
-
-if __name__ == '__main__':
- main()
diff --git a/venv/Lib/site-packages/pip/_vendor/pep517/colorlog.py b/venv/Lib/site-packages/pip/_vendor/pep517/colorlog.py
deleted file mode 100644
index 69c8a59..0000000
--- a/venv/Lib/site-packages/pip/_vendor/pep517/colorlog.py
+++ /dev/null
@@ -1,115 +0,0 @@
-"""Nicer log formatting with colours.
-
-Code copied from Tornado, Apache licensed.
-"""
-# Copyright 2012 Facebook
-#
-# Licensed under the Apache License, Version 2.0 (the "License"); you may
-# not use this file except in compliance with the License. You may obtain
-# a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-# License for the specific language governing permissions and limitations
-# under the License.
-
-import logging
-import sys
-
-try:
- import curses
-except ImportError:
- curses = None
-
-
-def _stderr_supports_color():
- color = False
- if curses and hasattr(sys.stderr, 'isatty') and sys.stderr.isatty():
- try:
- curses.setupterm()
- if curses.tigetnum("colors") > 0:
- color = True
- except Exception:
- pass
- return color
-
-
-class LogFormatter(logging.Formatter):
- """Log formatter with colour support
- """
- DEFAULT_COLORS = {
- logging.INFO: 2, # Green
- logging.WARNING: 3, # Yellow
- logging.ERROR: 1, # Red
- logging.CRITICAL: 1,
- }
-
- def __init__(self, color=True, datefmt=None):
- r"""
- :arg bool color: Enables color support.
- :arg string fmt: Log message format.
- It will be applied to the attributes dict of log records. The
- text between ``%(color)s`` and ``%(end_color)s`` will be colored
- depending on the level if color support is on.
- :arg dict colors: color mappings from logging level to terminal color
- code
- :arg string datefmt: Datetime format.
- Used for formatting ``(asctime)`` placeholder in ``prefix_fmt``.
- .. versionchanged:: 3.2
- Added ``fmt`` and ``datefmt`` arguments.
- """
- logging.Formatter.__init__(self, datefmt=datefmt)
- self._colors = {}
- if color and _stderr_supports_color():
- # The curses module has some str/bytes confusion in
- # python3. Until version 3.2.3, most methods return
- # bytes, but only accept strings. In addition, we want to
- # output these strings with the logging module, which
- # works with unicode strings. The explicit calls to
- # unicode() below are harmless in python2 but will do the
- # right conversion in python 3.
- fg_color = (curses.tigetstr("setaf") or
- curses.tigetstr("setf") or "")
- if (3, 0) < sys.version_info < (3, 2, 3):
- fg_color = str(fg_color, "ascii")
-
- for levelno, code in self.DEFAULT_COLORS.items():
- self._colors[levelno] = str(
- curses.tparm(fg_color, code), "ascii")
- self._normal = str(curses.tigetstr("sgr0"), "ascii")
-
- scr = curses.initscr()
- self.termwidth = scr.getmaxyx()[1]
- curses.endwin()
- else:
- self._normal = ''
- # Default width is usually 80, but too wide is
- # worse than too narrow
- self.termwidth = 70
-
- def formatMessage(self, record):
- mlen = len(record.message)
- right_text = '{initial}-{name}'.format(initial=record.levelname[0],
- name=record.name)
- if mlen + len(right_text) < self.termwidth:
- space = ' ' * (self.termwidth - (mlen + len(right_text)))
- else:
- space = ' '
-
- if record.levelno in self._colors:
- start_color = self._colors[record.levelno]
- end_color = self._normal
- else:
- start_color = end_color = ''
-
- return record.message + space + start_color + right_text + end_color
-
-
-def enable_colourful_output(level=logging.INFO):
- handler = logging.StreamHandler()
- handler.setFormatter(LogFormatter())
- logging.root.addHandler(handler)
- logging.root.setLevel(level)
diff --git a/venv/Lib/site-packages/pip/_vendor/pep517/compat.py b/venv/Lib/site-packages/pip/_vendor/pep517/compat.py
deleted file mode 100644
index 730ef5f..0000000
--- a/venv/Lib/site-packages/pip/_vendor/pep517/compat.py
+++ /dev/null
@@ -1,51 +0,0 @@
-"""Python 2/3 compatibility"""
-import io
-import json
-import sys
-
-
-# Handle reading and writing JSON in UTF-8, on Python 3 and 2.
-
-if sys.version_info[0] >= 3:
- # Python 3
- def write_json(obj, path, **kwargs):
- with open(path, 'w', encoding='utf-8') as f:
- json.dump(obj, f, **kwargs)
-
- def read_json(path):
- with open(path, 'r', encoding='utf-8') as f:
- return json.load(f)
-
-else:
- # Python 2
- def write_json(obj, path, **kwargs):
- with open(path, 'wb') as f:
- json.dump(obj, f, encoding='utf-8', **kwargs)
-
- def read_json(path):
- with open(path, 'rb') as f:
- return json.load(f)
-
-
-# FileNotFoundError
-
-try:
- FileNotFoundError = FileNotFoundError
-except NameError:
- FileNotFoundError = IOError
-
-
-if sys.version_info < (3, 6):
- from toml import load as _toml_load # noqa: F401
-
- def toml_load(f):
- w = io.TextIOWrapper(f, encoding="utf8", newline="")
- try:
- return _toml_load(w)
- finally:
- w.detach()
-
- from toml import TomlDecodeError as TOMLDecodeError # noqa: F401
-else:
- from pip._vendor.tomli import load as toml_load # noqa: F401
- from pip._vendor.tomli import TOMLDecodeError # noqa: F401
diff --git a/venv/Lib/site-packages/pip/_vendor/pep517/dirtools.py b/venv/Lib/site-packages/pip/_vendor/pep517/dirtools.py
deleted file mode 100644
index 58c6ca0..0000000
--- a/venv/Lib/site-packages/pip/_vendor/pep517/dirtools.py
+++ /dev/null
@@ -1,44 +0,0 @@
-import os
-import io
-import contextlib
-import tempfile
-import shutil
-import errno
-import zipfile
-
-
-@contextlib.contextmanager
-def tempdir():
- """Create a temporary directory in a context manager."""
- td = tempfile.mkdtemp()
- try:
- yield td
- finally:
- shutil.rmtree(td)
-
-
-def mkdir_p(*args, **kwargs):
- """Like `mkdir`, but does not raise an exception if the
- directory already exists.
- """
- try:
- return os.mkdir(*args, **kwargs)
- except OSError as exc:
- if exc.errno != errno.EEXIST:
- raise
-
-
-def dir_to_zipfile(root):
- """Construct an in-memory zip file for a directory."""
- buffer = io.BytesIO()
- zip_file = zipfile.ZipFile(buffer, 'w')
- for root, dirs, files in os.walk(root):
- for path in dirs:
- fs_path = os.path.join(root, path)
- rel_path = os.path.relpath(fs_path, root)
- zip_file.writestr(rel_path + '/', '')
- for path in files:
- fs_path = os.path.join(root, path)
- rel_path = os.path.relpath(fs_path, root)
- zip_file.write(fs_path, rel_path)
- return zip_file
diff --git a/venv/Lib/site-packages/pip/_vendor/pep517/envbuild.py b/venv/Lib/site-packages/pip/_vendor/pep517/envbuild.py
deleted file mode 100644
index fe8873c..0000000
--- a/venv/Lib/site-packages/pip/_vendor/pep517/envbuild.py
+++ /dev/null
@@ -1,171 +0,0 @@
-"""Build wheels/sdists by installing build deps to a temporary environment.
-"""
-
-import io
-import os
-import logging
-import shutil
-from subprocess import check_call
-import sys
-from sysconfig import get_paths
-from tempfile import mkdtemp
-
-from .compat import toml_load
-from .wrappers import Pep517HookCaller, LoggerWrapper
-
-log = logging.getLogger(__name__)
-
-
-def _load_pyproject(source_dir):
- with io.open(
- os.path.join(source_dir, 'pyproject.toml'),
- 'rb',
- ) as f:
- pyproject_data = toml_load(f)
- buildsys = pyproject_data['build-system']
- return (
- buildsys['requires'],
- buildsys['build-backend'],
- buildsys.get('backend-path'),
- )
-
-
-class BuildEnvironment(object):
- """Context manager to install build deps in a simple temporary environment
-
- Based on code I wrote for pip, which is MIT licensed.
- """
- # Copyright (c) 2008-2016 The pip developers (see AUTHORS.txt file)
- #
- # Permission is hereby granted, free of charge, to any person obtaining
- # a copy of this software and associated documentation files (the
- # "Software"), to deal in the Software without restriction, including
- # without limitation the rights to use, copy, modify, merge, publish,
- # distribute, sublicense, and/or sell copies of the Software, and to
- # permit persons to whom the Software is furnished to do so, subject to
- # the following conditions:
- #
- # The above copyright notice and this permission notice shall be
- # included in all copies or substantial portions of the Software.
- #
- # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- # MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- # NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- # LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
- path = None
-
- def __init__(self, cleanup=True):
- self._cleanup = cleanup
-
- def __enter__(self):
- self.path = mkdtemp(prefix='pep517-build-env-')
- log.info('Temporary build environment: %s', self.path)
-
- self.save_path = os.environ.get('PATH', None)
- self.save_pythonpath = os.environ.get('PYTHONPATH', None)
-
- install_scheme = 'nt' if (os.name == 'nt') else 'posix_prefix'
- install_dirs = get_paths(install_scheme, vars={
- 'base': self.path,
- 'platbase': self.path,
- })
-
- scripts = install_dirs['scripts']
- if self.save_path:
- os.environ['PATH'] = scripts + os.pathsep + self.save_path
- else:
- os.environ['PATH'] = scripts + os.pathsep + os.defpath
-
- if install_dirs['purelib'] == install_dirs['platlib']:
- lib_dirs = install_dirs['purelib']
- else:
- lib_dirs = install_dirs['purelib'] + os.pathsep + \
- install_dirs['platlib']
- if self.save_pythonpath:
- os.environ['PYTHONPATH'] = lib_dirs + os.pathsep + \
- self.save_pythonpath
- else:
- os.environ['PYTHONPATH'] = lib_dirs
-
- return self
-
- def pip_install(self, reqs):
- """Install dependencies into this env by calling pip in a subprocess"""
- if not reqs:
- return
- log.info('Calling pip to install %s', reqs)
- cmd = [
- sys.executable, '-m', 'pip', 'install', '--ignore-installed',
- '--prefix', self.path] + list(reqs)
- check_call(
- cmd,
- stdout=LoggerWrapper(log, logging.INFO),
- stderr=LoggerWrapper(log, logging.ERROR),
- )
-
- def __exit__(self, exc_type, exc_val, exc_tb):
- needs_cleanup = (
- self._cleanup and
- self.path is not None and
- os.path.isdir(self.path)
- )
- if needs_cleanup:
- shutil.rmtree(self.path)
-
- if self.save_path is None:
- os.environ.pop('PATH', None)
- else:
- os.environ['PATH'] = self.save_path
-
- if self.save_pythonpath is None:
- os.environ.pop('PYTHONPATH', None)
- else:
- os.environ['PYTHONPATH'] = self.save_pythonpath
-
-
-def build_wheel(source_dir, wheel_dir, config_settings=None):
- """Build a wheel from a source directory using PEP 517 hooks.
-
- :param str source_dir: Source directory containing pyproject.toml
- :param str wheel_dir: Target directory to create wheel in
- :param dict config_settings: Options to pass to build backend
-
- This is a blocking function which will run pip in a subprocess to install
- build requirements.
- """
- if config_settings is None:
- config_settings = {}
- requires, backend, backend_path = _load_pyproject(source_dir)
- hooks = Pep517HookCaller(source_dir, backend, backend_path)
-
- with BuildEnvironment() as env:
- env.pip_install(requires)
- reqs = hooks.get_requires_for_build_wheel(config_settings)
- env.pip_install(reqs)
- return hooks.build_wheel(wheel_dir, config_settings)
-
-
-def build_sdist(source_dir, sdist_dir, config_settings=None):
- """Build an sdist from a source directory using PEP 517 hooks.
-
- :param str source_dir: Source directory containing pyproject.toml
- :param str sdist_dir: Target directory to place sdist in
- :param dict config_settings: Options to pass to build backend
-
- This is a blocking function which will run pip in a subprocess to install
- build requirements.
- """
- if config_settings is None:
- config_settings = {}
- requires, backend, backend_path = _load_pyproject(source_dir)
- hooks = Pep517HookCaller(source_dir, backend, backend_path)
-
- with BuildEnvironment() as env:
- env.pip_install(requires)
- reqs = hooks.get_requires_for_build_sdist(config_settings)
- env.pip_install(reqs)
- return hooks.build_sdist(sdist_dir, config_settings)
diff --git a/venv/Lib/site-packages/pip/_vendor/pep517/in_process/__init__.py b/venv/Lib/site-packages/pip/_vendor/pep517/in_process/__init__.py
deleted file mode 100644
index c932313..0000000
--- a/venv/Lib/site-packages/pip/_vendor/pep517/in_process/__init__.py
+++ /dev/null
@@ -1,17 +0,0 @@
-"""This is a subpackage because the directory is on sys.path for _in_process.py
-
-The subpackage should stay as empty as possible to avoid shadowing modules that
-the backend might import.
-"""
-from os.path import dirname, abspath, join as pjoin
-from contextlib import contextmanager
-
-try:
- import importlib.resources as resources
-
- def _in_proc_script_path():
- return resources.path(__package__, '_in_process.py')
-except ImportError:
- @contextmanager
- def _in_proc_script_path():
- yield pjoin(dirname(abspath(__file__)), '_in_process.py')
diff --git a/venv/Lib/site-packages/pip/_vendor/pep517/in_process/__pycache__/__init__.cpython-310.pyc b/venv/Lib/site-packages/pip/_vendor/pep517/in_process/__pycache__/__init__.cpython-310.pyc
deleted file mode 100644
index 16a84c1..0000000
Binary files a/venv/Lib/site-packages/pip/_vendor/pep517/in_process/__pycache__/__init__.cpython-310.pyc and /dev/null differ
diff --git a/venv/Lib/site-packages/pip/_vendor/pep517/in_process/__pycache__/_in_process.cpython-310.pyc b/venv/Lib/site-packages/pip/_vendor/pep517/in_process/__pycache__/_in_process.cpython-310.pyc
deleted file mode 100644
index 2c2941c..0000000
Binary files a/venv/Lib/site-packages/pip/_vendor/pep517/in_process/__pycache__/_in_process.cpython-310.pyc and /dev/null differ
diff --git a/venv/Lib/site-packages/pip/_vendor/pep517/meta.py b/venv/Lib/site-packages/pip/_vendor/pep517/meta.py
deleted file mode 100644
index d525de5..0000000
--- a/venv/Lib/site-packages/pip/_vendor/pep517/meta.py
+++ /dev/null
@@ -1,92 +0,0 @@
-"""Build metadata for a project using PEP 517 hooks.
-"""
-import argparse
-import logging
-import os
-import shutil
-import functools
-
-try:
- import importlib.metadata as imp_meta
-except ImportError:
- import importlib_metadata as imp_meta
-
-try:
- from zipfile import Path
-except ImportError:
- from zipp import Path
-
-from .envbuild import BuildEnvironment
-from .wrappers import Pep517HookCaller, quiet_subprocess_runner
-from .dirtools import tempdir, mkdir_p, dir_to_zipfile
-from .build import validate_system, load_system, compat_system
-
-log = logging.getLogger(__name__)
-
-
-def _prep_meta(hooks, env, dest):
- reqs = hooks.get_requires_for_build_wheel({})
- log.info('Got build requires: %s', reqs)
-
- env.pip_install(reqs)
- log.info('Installed dynamic build dependencies')
-
- with tempdir() as td:
- log.info('Trying to build metadata in %s', td)
- filename = hooks.prepare_metadata_for_build_wheel(td, {})
- source = os.path.join(td, filename)
- shutil.move(source, os.path.join(dest, os.path.basename(filename)))
-
-
-def build(source_dir='.', dest=None, system=None):
- system = system or load_system(source_dir)
- dest = os.path.join(source_dir, dest or 'dist')
- mkdir_p(dest)
- validate_system(system)
- hooks = Pep517HookCaller(
- source_dir, system['build-backend'], system.get('backend-path')
- )
-
- with hooks.subprocess_runner(quiet_subprocess_runner):
- with BuildEnvironment() as env:
- env.pip_install(system['requires'])
- _prep_meta(hooks, env, dest)
-
-
-def build_as_zip(builder=build):
- with tempdir() as out_dir:
- builder(dest=out_dir)
- return dir_to_zipfile(out_dir)
-
-
-def load(root):
- """
- Given a source directory (root) of a package,
- return an importlib.metadata.Distribution object
- with metadata build from that package.
- """
- root = os.path.expanduser(root)
- system = compat_system(root)
- builder = functools.partial(build, source_dir=root, system=system)
- path = Path(build_as_zip(builder))
- return imp_meta.PathDistribution(path)
-
-
-parser = argparse.ArgumentParser()
-parser.add_argument(
- 'source_dir',
- help="A directory containing pyproject.toml",
-)
-parser.add_argument(
- '--out-dir', '-o',
- help="Destination in which to save the builds relative to source dir",
-)
-
-
-def main():
- args = parser.parse_args()
- build(args.source_dir, args.out_dir)
-
-
-if __name__ == '__main__':
- main()
diff --git a/venv/Lib/site-packages/pip/_vendor/pep517/wrappers.py b/venv/Lib/site-packages/pip/_vendor/pep517/wrappers.py
deleted file mode 100644
index e031ed7..0000000
--- a/venv/Lib/site-packages/pip/_vendor/pep517/wrappers.py
+++ /dev/null
@@ -1,375 +0,0 @@
-import threading
-from contextlib import contextmanager
-import os
-from os.path import abspath, join as pjoin
-import shutil
-from subprocess import check_call, check_output, STDOUT
-import sys
-from tempfile import mkdtemp
-
-from . import compat
-from .in_process import _in_proc_script_path
-
-__all__ = [
- 'BackendUnavailable',
- 'BackendInvalid',
- 'HookMissing',
- 'UnsupportedOperation',
- 'default_subprocess_runner',
- 'quiet_subprocess_runner',
- 'Pep517HookCaller',
-]
-
-
-@contextmanager
-def tempdir():
- td = mkdtemp()
- try:
- yield td
- finally:
- shutil.rmtree(td)
-
-
-class BackendUnavailable(Exception):
- """Will be raised if the backend cannot be imported in the hook process."""
- def __init__(self, traceback):
- self.traceback = traceback
-
-
-class BackendInvalid(Exception):
- """Will be raised if the backend is invalid."""
- def __init__(self, backend_name, backend_path, message):
- self.backend_name = backend_name
- self.backend_path = backend_path
- self.message = message
-
-
-class HookMissing(Exception):
- """Will be raised on missing hooks."""
- def __init__(self, hook_name):
- super(HookMissing, self).__init__(hook_name)
- self.hook_name = hook_name
-
-
-class UnsupportedOperation(Exception):
- """May be raised by build_sdist if the backend indicates that it can't."""
- def __init__(self, traceback):
- self.traceback = traceback
-
-
-def default_subprocess_runner(cmd, cwd=None, extra_environ=None):
- """The default method of calling the wrapper subprocess."""
- env = os.environ.copy()
- if extra_environ:
- env.update(extra_environ)
-
- check_call(cmd, cwd=cwd, env=env)
-
-
-def quiet_subprocess_runner(cmd, cwd=None, extra_environ=None):
- """A method of calling the wrapper subprocess while suppressing output."""
- env = os.environ.copy()
- if extra_environ:
- env.update(extra_environ)
-
- check_output(cmd, cwd=cwd, env=env, stderr=STDOUT)
-
-
-def norm_and_check(source_tree, requested):
- """Normalise and check a backend path.
-
- Ensure that the requested backend path is specified as a relative path,
- and resolves to a location under the given source tree.
-
- Return an absolute version of the requested path.
- """
- if os.path.isabs(requested):
- raise ValueError("paths must be relative")
-
- abs_source = os.path.abspath(source_tree)
- abs_requested = os.path.normpath(os.path.join(abs_source, requested))
- # We have to use commonprefix for Python 2.7 compatibility. So we
- # normalise case to avoid problems because commonprefix is a character
- # based comparison :-(
- norm_source = os.path.normcase(abs_source)
- norm_requested = os.path.normcase(abs_requested)
- if os.path.commonprefix([norm_source, norm_requested]) != norm_source:
- raise ValueError("paths must be inside source tree")
-
- return abs_requested
-
-
-class Pep517HookCaller(object):
- """A wrapper around a source directory to be built with a PEP 517 backend.
-
- :param source_dir: The path to the source directory, containing
- pyproject.toml.
- :param build_backend: The build backend spec, as per PEP 517, from
- pyproject.toml.
- :param backend_path: The backend path, as per PEP 517, from pyproject.toml.
- :param runner: A callable that invokes the wrapper subprocess.
- :param python_executable: The Python executable used to invoke the backend
-
- The 'runner', if provided, must expect the following:
-
- - cmd: a list of strings representing the command and arguments to
- execute, as would be passed to e.g. 'subprocess.check_call'.
- - cwd: a string representing the working directory that must be
- used for the subprocess. Corresponds to the provided source_dir.
- - extra_environ: a dict mapping environment variable names to values
- which must be set for the subprocess execution.
- """
- def __init__(
- self,
- source_dir,
- build_backend,
- backend_path=None,
- runner=None,
- python_executable=None,
- ):
- if runner is None:
- runner = default_subprocess_runner
-
- self.source_dir = abspath(source_dir)
- self.build_backend = build_backend
- if backend_path:
- backend_path = [
- norm_and_check(self.source_dir, p) for p in backend_path
- ]
- self.backend_path = backend_path
- self._subprocess_runner = runner
- if not python_executable:
- python_executable = sys.executable
- self.python_executable = python_executable
-
- @contextmanager
- def subprocess_runner(self, runner):
- """A context manager for temporarily overriding the default subprocess
- runner.
- """
- prev = self._subprocess_runner
- self._subprocess_runner = runner
- try:
- yield
- finally:
- self._subprocess_runner = prev
-
- def _supported_features(self):
- """Return the list of optional features supported by the backend."""
- return self._call_hook('_supported_features', {})
-
- def get_requires_for_build_wheel(self, config_settings=None):
- """Identify packages required for building a wheel
-
- Returns a list of dependency specifications, e.g.::
-
- ["wheel >= 0.25", "setuptools"]
-
- This does not include requirements specified in pyproject.toml.
- It returns the result of calling the equivalently named hook in a
- subprocess.
- """
- return self._call_hook('get_requires_for_build_wheel', {
- 'config_settings': config_settings
- })
-
- def prepare_metadata_for_build_wheel(
- self, metadata_directory, config_settings=None,
- _allow_fallback=True):
- """Prepare a ``*.dist-info`` folder with metadata for this project.
-
- Returns the name of the newly created folder.
-
- If the build backend defines a hook with this name, it will be called
- in a subprocess. If not, the backend will be asked to build a wheel,
- and the dist-info extracted from that (unless _allow_fallback is
- False).
- """
- return self._call_hook('prepare_metadata_for_build_wheel', {
- 'metadata_directory': abspath(metadata_directory),
- 'config_settings': config_settings,
- '_allow_fallback': _allow_fallback,
- })
-
- def build_wheel(
- self, wheel_directory, config_settings=None,
- metadata_directory=None):
- """Build a wheel from this project.
-
- Returns the name of the newly created file.
-
- In general, this will call the 'build_wheel' hook in the backend.
- However, if that was previously called by
- 'prepare_metadata_for_build_wheel', and the same metadata_directory is
- used, the previously built wheel will be copied to wheel_directory.
- """
- if metadata_directory is not None:
- metadata_directory = abspath(metadata_directory)
- return self._call_hook('build_wheel', {
- 'wheel_directory': abspath(wheel_directory),
- 'config_settings': config_settings,
- 'metadata_directory': metadata_directory,
- })
-
- def get_requires_for_build_editable(self, config_settings=None):
- """Identify packages required for building an editable wheel
-
- Returns a list of dependency specifications, e.g.::
-
- ["wheel >= 0.25", "setuptools"]
-
- This does not include requirements specified in pyproject.toml.
- It returns the result of calling the equivalently named hook in a
- subprocess.
- """
- return self._call_hook('get_requires_for_build_editable', {
- 'config_settings': config_settings
- })
-
- def prepare_metadata_for_build_editable(
- self, metadata_directory, config_settings=None,
- _allow_fallback=True):
- """Prepare a ``*.dist-info`` folder with metadata for this project.
-
- Returns the name of the newly created folder.
-
- If the build backend defines a hook with this name, it will be called
- in a subprocess. If not, the backend will be asked to build an editable
- wheel, and the dist-info extracted from that (unless _allow_fallback is
- False).
- """
- return self._call_hook('prepare_metadata_for_build_editable', {
- 'metadata_directory': abspath(metadata_directory),
- 'config_settings': config_settings,
- '_allow_fallback': _allow_fallback,
- })
-
- def build_editable(
- self, wheel_directory, config_settings=None,
- metadata_directory=None):
- """Build an editable wheel from this project.
-
- Returns the name of the newly created file.
-
- In general, this will call the 'build_editable' hook in the backend.
- However, if that was previously called by
- 'prepare_metadata_for_build_editable', and the same metadata_directory
- is used, the previously built wheel will be copied to wheel_directory.
- """
- if metadata_directory is not None:
- metadata_directory = abspath(metadata_directory)
- return self._call_hook('build_editable', {
- 'wheel_directory': abspath(wheel_directory),
- 'config_settings': config_settings,
- 'metadata_directory': metadata_directory,
- })
-
- def get_requires_for_build_sdist(self, config_settings=None):
- """Identify packages required for building a wheel
-
- Returns a list of dependency specifications, e.g.::
-
- ["setuptools >= 26"]
-
- This does not include requirements specified in pyproject.toml.
- It returns the result of calling the equivalently named hook in a
- subprocess.
- """
- return self._call_hook('get_requires_for_build_sdist', {
- 'config_settings': config_settings
- })
-
- def build_sdist(self, sdist_directory, config_settings=None):
- """Build an sdist from this project.
-
- Returns the name of the newly created file.
-
- This calls the 'build_sdist' backend hook in a subprocess.
- """
- return self._call_hook('build_sdist', {
- 'sdist_directory': abspath(sdist_directory),
- 'config_settings': config_settings,
- })
-
- def _call_hook(self, hook_name, kwargs):
- # On Python 2, pytoml returns Unicode values (which is correct) but the
- # environment passed to check_call needs to contain string values. We
- # convert here by encoding using ASCII (the backend can only contain
- # letters, digits and _, . and : characters, and will be used as a
- # Python identifier, so non-ASCII content is wrong on Python 2 in
- # any case).
- # For backend_path, we use sys.getfilesystemencoding.
- if sys.version_info[0] == 2:
- build_backend = self.build_backend.encode('ASCII')
- else:
- build_backend = self.build_backend
- extra_environ = {'PEP517_BUILD_BACKEND': build_backend}
-
- if self.backend_path:
- backend_path = os.pathsep.join(self.backend_path)
- if sys.version_info[0] == 2:
- backend_path = backend_path.encode(sys.getfilesystemencoding())
- extra_environ['PEP517_BACKEND_PATH'] = backend_path
-
- with tempdir() as td:
- hook_input = {'kwargs': kwargs}
- compat.write_json(hook_input, pjoin(td, 'input.json'),
- indent=2)
-
- # Run the hook in a subprocess
- with _in_proc_script_path() as script:
- python = self.python_executable
- self._subprocess_runner(
- [python, abspath(str(script)), hook_name, td],
- cwd=self.source_dir,
- extra_environ=extra_environ
- )
-
- data = compat.read_json(pjoin(td, 'output.json'))
- if data.get('unsupported'):
- raise UnsupportedOperation(data.get('traceback', ''))
- if data.get('no_backend'):
- raise BackendUnavailable(data.get('traceback', ''))
- if data.get('backend_invalid'):
- raise BackendInvalid(
- backend_name=self.build_backend,
- backend_path=self.backend_path,
- message=data.get('backend_error', '')
- )
- if data.get('hook_missing'):
- raise HookMissing(data.get('missing_hook_name') or hook_name)
- return data['return_val']
-
-
-class LoggerWrapper(threading.Thread):
- """
- Read messages from a pipe and redirect them
- to a logger (see python's logging module).
- """
-
- def __init__(self, logger, level):
- threading.Thread.__init__(self)
- self.daemon = True
-
- self.logger = logger
- self.level = level
-
- # create the pipe and reader
- self.fd_read, self.fd_write = os.pipe()
- self.reader = os.fdopen(self.fd_read)
-
- self.start()
-
- def fileno(self):
- return self.fd_write
-
- @staticmethod
- def remove_newline(msg):
- return msg[:-1] if msg.endswith(os.linesep) else msg
-
- def run(self):
- for line in self.reader:
- self._write(self.remove_newline(line))
-
- def _write(self, message):
- self.logger.log(self.level, message)
diff --git a/venv/Lib/site-packages/pip/_vendor/pkg_resources/__init__.py b/venv/Lib/site-packages/pip/_vendor/pkg_resources/__init__.py
index 4cd562c..57ce7f1 100644
--- a/venv/Lib/site-packages/pip/_vendor/pkg_resources/__init__.py
+++ b/venv/Lib/site-packages/pip/_vendor/pkg_resources/__init__.py
@@ -1,4 +1,6 @@
-# coding: utf-8
+# TODO: Add Generic type annotations to initialized collections.
+# For now we'd simply use implicit Any/Unknown which would add redundant annotations
+# mypy: disable-error-code="var-annotated"
"""
Package resource API
--------------------
@@ -13,16 +15,41 @@ The package resource API is designed to work with normal filesystem packages,
.egg files, and unpacked .egg files. It can also work in a limited way with
.zip files and with custom PEP 302 loaders that support the ``get_data()``
method.
+
+This module is deprecated. Users are directed to :mod:`importlib.resources`,
+:mod:`importlib.metadata` and :pypi:`packaging` instead.
"""
-from __future__ import absolute_import
+from __future__ import annotations
import sys
+
+if sys.version_info < (3, 8): # noqa: UP036 # Check for unsupported versions
+ raise RuntimeError("Python 3.8 or later is required")
+
import os
import io
import time
import re
import types
+from typing import (
+ Any,
+ Literal,
+ Dict,
+ Iterator,
+ Mapping,
+ MutableSequence,
+ NamedTuple,
+ NoReturn,
+ Tuple,
+ Union,
+ TYPE_CHECKING,
+ Protocol,
+ Callable,
+ Iterable,
+ TypeVar,
+ overload,
+)
import zipfile
import zipimport
import warnings
@@ -37,84 +64,83 @@ import email.parser
import errno
import tempfile
import textwrap
-import itertools
import inspect
import ntpath
import posixpath
+import importlib
+import importlib.abc
+import importlib.machinery
from pkgutil import get_importer
-try:
- import _imp
-except ImportError:
- # Python 3.2 compatibility
- import imp as _imp
-
-try:
- FileExistsError
-except NameError:
- FileExistsError = OSError
-
-from pip._vendor import six
-from pip._vendor.six.moves import urllib, map, filter
+import _imp
# capture these to bypass sandboxing
from os import utime
+from os import open as os_open
+from os.path import isdir, split
+
try:
from os import mkdir, rename, unlink
+
WRITE_SUPPORT = True
except ImportError:
# no write support, probably under GAE
WRITE_SUPPORT = False
-from os import open as os_open
-from os.path import isdir, split
+from pip._internal.utils._jaraco_text import (
+ yield_lines,
+ drop_comment,
+ join_continuation,
+)
+from pip._vendor.packaging import markers as _packaging_markers
+from pip._vendor.packaging import requirements as _packaging_requirements
+from pip._vendor.packaging import utils as _packaging_utils
+from pip._vendor.packaging import version as _packaging_version
+from pip._vendor.platformdirs import user_cache_dir as _user_cache_dir
-try:
- import importlib.machinery as importlib_machinery
- # access attribute to force import under delayed import mechanisms.
- importlib_machinery.__name__
-except ImportError:
- importlib_machinery = None
-
-from . import py31compat
-from pip._vendor import platformdirs
-from pip._vendor import packaging
-__import__('pip._vendor.packaging.version')
-__import__('pip._vendor.packaging.specifiers')
-__import__('pip._vendor.packaging.requirements')
-__import__('pip._vendor.packaging.markers')
+if TYPE_CHECKING:
+ from _typeshed import BytesPath, StrPath, StrOrBytesPath
+ from pip._vendor.typing_extensions import Self
-__metaclass__ = type
+# Patch: Remove deprecation warning from vendored pkg_resources.
+# Setting PYTHONWARNINGS=error to verify builds produce no warnings
+# causes immediate exceptions.
+# See https://github.com/pypa/pip/issues/12243
-if (3, 0) < sys.version_info < (3, 5):
- raise RuntimeError("Python 3.5 or later is required")
+_T = TypeVar("_T")
+_DistributionT = TypeVar("_DistributionT", bound="Distribution")
+# Type aliases
+_NestedStr = Union[str, Iterable[Union[str, Iterable["_NestedStr"]]]]
+_InstallerTypeT = Callable[["Requirement"], "_DistributionT"]
+_InstallerType = Callable[["Requirement"], Union["Distribution", None]]
+_PkgReqType = Union[str, "Requirement"]
+_EPDistType = Union["Distribution", _PkgReqType]
+_MetadataType = Union["IResourceProvider", None]
+_ResolvedEntryPoint = Any # Can be any attribute in the module
+_ResourceStream = Any # TODO / Incomplete: A readable file-like object
+# Any object works, but let's indicate we expect something like a module (optionally has __loader__ or __file__)
+_ModuleLike = Union[object, types.ModuleType]
+# Any: Should be _ModuleLike but we end up with issues where _ModuleLike doesn't have _ZipLoaderModule's __loader__
+_ProviderFactoryType = Callable[[Any], "IResourceProvider"]
+_DistFinderType = Callable[[_T, str, bool], Iterable["Distribution"]]
+_NSHandlerType = Callable[[_T, str, str, types.ModuleType], Union[str, None]]
+_AdapterT = TypeVar(
+ "_AdapterT", _DistFinderType[Any], _ProviderFactoryType, _NSHandlerType[Any]
+)
-if six.PY2:
- # Those builtin exceptions are only defined in Python 3
- PermissionError = None
- NotADirectoryError = None
-# declare some globals that will be defined later to
-# satisfy the linters.
-require = None
-working_set = None
-add_activation_listener = None
-resources_stream = None
-cleanup_resources = None
-resource_dir = None
-resource_stream = None
-set_extraction_path = None
-resource_isdir = None
-resource_string = None
-iter_entry_points = None
-resource_listdir = None
-resource_filename = None
-resource_exists = None
-_distribution_finders = None
-_namespace_handlers = None
-_namespace_packages = None
+# Use _typeshed.importlib.LoaderProtocol once available https://github.com/python/typeshed/pull/11890
+class _LoaderProtocol(Protocol):
+ def load_module(self, fullname: str, /) -> types.ModuleType: ...
+
+
+class _ZipLoaderModule(Protocol):
+ __loader__: zipimport.zipimporter
+
+
+_PEP440_FALLBACK = re.compile(r"^v?(?P(?:[0-9]+!)?[0-9]+(?:\.[0-9]+)*)", re.I)
class PEP440Warning(RuntimeWarning):
@@ -124,22 +150,18 @@ class PEP440Warning(RuntimeWarning):
"""
-def parse_version(v):
- try:
- return packaging.version.Version(v)
- except packaging.version.InvalidVersion:
- return packaging.version.LegacyVersion(v)
+parse_version = _packaging_version.Version
-_state_vars = {}
+_state_vars: dict[str, str] = {}
-def _declare_state(vartype, **kw):
- globals().update(kw)
- _state_vars.update(dict.fromkeys(kw, vartype))
+def _declare_state(vartype: str, varname: str, initial_value: _T) -> _T:
+ _state_vars[varname] = vartype
+ return initial_value
-def __getstate__():
+def __getstate__() -> dict[str, Any]:
state = {}
g = globals()
for k, v in _state_vars.items():
@@ -147,7 +169,7 @@ def __getstate__():
return state
-def __setstate__(state):
+def __setstate__(state: dict[str, Any]) -> dict[str, Any]:
g = globals()
for k, v in state.items():
g['_sset_' + _state_vars[k]](k, g[k], v)
@@ -178,10 +200,10 @@ def get_supported_platform():
"""Return this platform's maximum compatible version.
distutils.util.get_platform() normally reports the minimum version
- of Mac OS X that would be required to *use* extensions produced by
+ of macOS that would be required to *use* extensions produced by
distutils. But what we want when checking compatibility is to know the
- version of Mac OS X that we are *running*. To allow usage of packages that
- explicitly require a newer version of Mac OS X, we must also know the
+ version of macOS that we are *running*. To allow usage of packages that
+ explicitly require a newer version of macOS, we must also know the
current version of the OS.
If this condition occurs for any other platform with a version in its
@@ -191,60 +213,96 @@ def get_supported_platform():
m = macosVersionString.match(plat)
if m is not None and sys.platform == "darwin":
try:
- plat = 'macosx-%s-%s' % ('.'.join(_macosx_vers()[:2]), m.group(3))
+ plat = 'macosx-%s-%s' % ('.'.join(_macos_vers()[:2]), m.group(3))
except ValueError:
- # not Mac OS X
+ # not macOS
pass
return plat
__all__ = [
# Basic resource access and distribution/entry point discovery
- 'require', 'run_script', 'get_provider', 'get_distribution',
- 'load_entry_point', 'get_entry_map', 'get_entry_info',
+ 'require',
+ 'run_script',
+ 'get_provider',
+ 'get_distribution',
+ 'load_entry_point',
+ 'get_entry_map',
+ 'get_entry_info',
'iter_entry_points',
- 'resource_string', 'resource_stream', 'resource_filename',
- 'resource_listdir', 'resource_exists', 'resource_isdir',
-
+ 'resource_string',
+ 'resource_stream',
+ 'resource_filename',
+ 'resource_listdir',
+ 'resource_exists',
+ 'resource_isdir',
# Environmental control
- 'declare_namespace', 'working_set', 'add_activation_listener',
- 'find_distributions', 'set_extraction_path', 'cleanup_resources',
+ 'declare_namespace',
+ 'working_set',
+ 'add_activation_listener',
+ 'find_distributions',
+ 'set_extraction_path',
+ 'cleanup_resources',
'get_default_cache',
-
# Primary implementation classes
- 'Environment', 'WorkingSet', 'ResourceManager',
- 'Distribution', 'Requirement', 'EntryPoint',
-
+ 'Environment',
+ 'WorkingSet',
+ 'ResourceManager',
+ 'Distribution',
+ 'Requirement',
+ 'EntryPoint',
# Exceptions
- 'ResolutionError', 'VersionConflict', 'DistributionNotFound',
- 'UnknownExtra', 'ExtractionError',
-
+ 'ResolutionError',
+ 'VersionConflict',
+ 'DistributionNotFound',
+ 'UnknownExtra',
+ 'ExtractionError',
# Warnings
'PEP440Warning',
-
# Parsing functions and string utilities
- 'parse_requirements', 'parse_version', 'safe_name', 'safe_version',
- 'get_platform', 'compatible_platforms', 'yield_lines', 'split_sections',
- 'safe_extra', 'to_filename', 'invalid_marker', 'evaluate_marker',
-
+ 'parse_requirements',
+ 'parse_version',
+ 'safe_name',
+ 'safe_version',
+ 'get_platform',
+ 'compatible_platforms',
+ 'yield_lines',
+ 'split_sections',
+ 'safe_extra',
+ 'to_filename',
+ 'invalid_marker',
+ 'evaluate_marker',
# filesystem utilities
- 'ensure_directory', 'normalize_path',
-
+ 'ensure_directory',
+ 'normalize_path',
# Distribution "precedence" constants
- 'EGG_DIST', 'BINARY_DIST', 'SOURCE_DIST', 'CHECKOUT_DIST', 'DEVELOP_DIST',
-
+ 'EGG_DIST',
+ 'BINARY_DIST',
+ 'SOURCE_DIST',
+ 'CHECKOUT_DIST',
+ 'DEVELOP_DIST',
# "Provider" interfaces, implementations, and registration/lookup APIs
- 'IMetadataProvider', 'IResourceProvider', 'FileMetadata',
- 'PathMetadata', 'EggMetadata', 'EmptyProvider', 'empty_provider',
- 'NullProvider', 'EggProvider', 'DefaultProvider', 'ZipProvider',
- 'register_finder', 'register_namespace_handler', 'register_loader_type',
- 'fixup_namespace_packages', 'get_importer',
-
+ 'IMetadataProvider',
+ 'IResourceProvider',
+ 'FileMetadata',
+ 'PathMetadata',
+ 'EggMetadata',
+ 'EmptyProvider',
+ 'empty_provider',
+ 'NullProvider',
+ 'EggProvider',
+ 'DefaultProvider',
+ 'ZipProvider',
+ 'register_finder',
+ 'register_namespace_handler',
+ 'register_loader_type',
+ 'fixup_namespace_packages',
+ 'get_importer',
# Warnings
'PkgResourcesDeprecationWarning',
-
# Deprecated/backward compatibility only
- 'run_main', 'AvailableDistributions',
+ 'run_main',
+ 'AvailableDistributions',
]
@@ -266,17 +324,17 @@ class VersionConflict(ResolutionError):
_template = "{self.dist} is installed but {self.req} is required"
@property
- def dist(self):
+ def dist(self) -> Distribution:
return self.args[0]
@property
- def req(self):
+ def req(self) -> Requirement:
return self.args[1]
def report(self):
return self._template.format(**locals())
- def with_context(self, required_by):
+ def with_context(self, required_by: set[Distribution | str]):
"""
If required_by is non-empty, return a version of self that is a
ContextualVersionConflict.
@@ -296,22 +354,24 @@ class ContextualVersionConflict(VersionConflict):
_template = VersionConflict._template + ' by {self.required_by}'
@property
- def required_by(self):
+ def required_by(self) -> set[str]:
return self.args[2]
class DistributionNotFound(ResolutionError):
"""A requested distribution was not found"""
- _template = ("The '{self.req}' distribution was not found "
- "and is required by {self.requirers_str}")
+ _template = (
+ "The '{self.req}' distribution was not found "
+ "and is required by {self.requirers_str}"
+ )
@property
- def req(self):
+ def req(self) -> Requirement:
return self.args[0]
@property
- def requirers(self):
+ def requirers(self) -> set[str] | None:
return self.args[1]
@property
@@ -331,7 +391,7 @@ class UnknownExtra(ResolutionError):
"""Distribution doesn't have an "extra feature" of the given name"""
-_provider_factories = {}
+_provider_factories: dict[type[_ModuleLike], _ProviderFactoryType] = {}
PY_MAJOR = '{}.{}'.format(*sys.version_info)
EGG_DIST = 3
@@ -341,7 +401,9 @@ CHECKOUT_DIST = 0
DEVELOP_DIST = -1
-def register_loader_type(loader_type, provider_factory):
+def register_loader_type(
+ loader_type: type[_ModuleLike], provider_factory: _ProviderFactoryType
+):
"""Register `provider_factory` to make providers for `loader_type`
`loader_type` is the type or class of a PEP 302 ``module.__loader__``,
@@ -351,7 +413,11 @@ def register_loader_type(loader_type, provider_factory):
_provider_factories[loader_type] = provider_factory
-def get_provider(moduleOrReq):
+@overload
+def get_provider(moduleOrReq: str) -> IResourceProvider: ...
+@overload
+def get_provider(moduleOrReq: Requirement) -> Distribution: ...
+def get_provider(moduleOrReq: str | Requirement) -> IResourceProvider | Distribution:
"""Return an IResourceProvider for the named module or requirement"""
if isinstance(moduleOrReq, Requirement):
return working_set.find(moduleOrReq) or require(str(moduleOrReq))[0]
@@ -364,23 +430,21 @@ def get_provider(moduleOrReq):
return _find_adapter(_provider_factories, loader)(module)
-def _macosx_vers(_cache=[]):
- if not _cache:
- version = platform.mac_ver()[0]
- # fallback for MacPorts
- if version == '':
- plist = '/System/Library/CoreServices/SystemVersion.plist'
- if os.path.exists(plist):
- if hasattr(plistlib, 'readPlist'):
- plist_content = plistlib.readPlist(plist)
- if 'ProductVersion' in plist_content:
- version = plist_content['ProductVersion']
-
- _cache.append(version.split('.'))
- return _cache[0]
+@functools.lru_cache(maxsize=None)
+def _macos_vers():
+ version = platform.mac_ver()[0]
+ # fallback for MacPorts
+ if version == '':
+ plist = '/System/Library/CoreServices/SystemVersion.plist'
+ if os.path.exists(plist):
+ with open(plist, 'rb') as fh:
+ plist_content = plistlib.load(fh)
+ if 'ProductVersion' in plist_content:
+ version = plist_content['ProductVersion']
+ return version.split('.')
-def _macosx_arch(machine):
+def _macos_arch(machine):
return {'PowerPC': 'ppc', 'Power_Macintosh': 'ppc'}.get(machine, machine)
@@ -388,18 +452,19 @@ def get_build_platform():
"""Return this platform's string for platform-specific distributions
XXX Currently this is the same as ``distutils.util.get_platform()``, but it
- needs some hacks for Linux and Mac OS X.
+ needs some hacks for Linux and macOS.
"""
from sysconfig import get_platform
plat = get_platform()
if sys.platform == "darwin" and not plat.startswith('macosx-'):
try:
- version = _macosx_vers()
+ version = _macos_vers()
machine = os.uname()[4].replace(" ", "_")
return "macosx-%d.%d-%s" % (
- int(version[0]), int(version[1]),
- _macosx_arch(machine),
+ int(version[0]),
+ int(version[1]),
+ _macos_arch(machine),
)
except ValueError:
# if someone is running a non-Mac darwin system, this will fall
@@ -414,7 +479,7 @@ darwinVersionString = re.compile(r"darwin-(\d+)\.(\d+)\.(\d+)-(.*)")
get_platform = get_build_platform
-def compatible_platforms(provided, required):
+def compatible_platforms(provided: str | None, required: str | None):
"""Can code for the `provided` platform run on the `required` platform?
Returns true if either platform is ``None``, or the platforms are equal.
@@ -425,7 +490,7 @@ def compatible_platforms(provided, required):
# easy case
return True
- # Mac OS X special cases
+ # macOS special cases
reqMac = macosVersionString.match(required)
if reqMac:
provMac = macosVersionString.match(provided)
@@ -434,20 +499,23 @@ def compatible_platforms(provided, required):
if not provMac:
# this is backwards compatibility for packages built before
# setuptools 0.6. All packages built after this point will
- # use the new macosx designation.
+ # use the new macOS designation.
provDarwin = darwinVersionString.match(provided)
if provDarwin:
dversion = int(provDarwin.group(1))
macosversion = "%s.%s" % (reqMac.group(1), reqMac.group(2))
- if dversion == 7 and macosversion >= "10.3" or \
- dversion == 8 and macosversion >= "10.4":
+ if (
+ dversion == 7
+ and macosversion >= "10.3"
+ or dversion == 8
+ and macosversion >= "10.4"
+ ):
return True
- # egg isn't macosx or legacy darwin
+ # egg isn't macOS or legacy darwin
return False
# are they the same major version and machine type?
- if provMac.group(1) != reqMac.group(1) or \
- provMac.group(3) != reqMac.group(3):
+ if provMac.group(1) != reqMac.group(1) or provMac.group(3) != reqMac.group(3):
return False
# is the required OS major update >= the provided one?
@@ -460,104 +528,109 @@ def compatible_platforms(provided, required):
return False
-def run_script(dist_spec, script_name):
- """Locate distribution `dist_spec` and run its `script_name` script"""
- ns = sys._getframe(1).f_globals
- name = ns['__name__']
- ns.clear()
- ns['__name__'] = name
- require(dist_spec)[0].run_script(script_name, ns)
-
-
-# backward compatibility
-run_main = run_script
-
-
-def get_distribution(dist):
+@overload
+def get_distribution(dist: _DistributionT) -> _DistributionT: ...
+@overload
+def get_distribution(dist: _PkgReqType) -> Distribution: ...
+def get_distribution(dist: Distribution | _PkgReqType) -> Distribution:
"""Return a current distribution object for a Requirement or string"""
- if isinstance(dist, six.string_types):
+ if isinstance(dist, str):
dist = Requirement.parse(dist)
if isinstance(dist, Requirement):
- dist = get_provider(dist)
+ # Bad type narrowing, dist has to be a Requirement here, so get_provider has to return Distribution
+ dist = get_provider(dist) # type: ignore[assignment]
if not isinstance(dist, Distribution):
- raise TypeError("Expected string, Requirement, or Distribution", dist)
+ raise TypeError("Expected str, Requirement, or Distribution", dist)
return dist
-def load_entry_point(dist, group, name):
+def load_entry_point(dist: _EPDistType, group: str, name: str) -> _ResolvedEntryPoint:
"""Return `name` entry point of `group` for `dist` or raise ImportError"""
return get_distribution(dist).load_entry_point(group, name)
-def get_entry_map(dist, group=None):
+@overload
+def get_entry_map(
+ dist: _EPDistType, group: None = None
+) -> dict[str, dict[str, EntryPoint]]: ...
+@overload
+def get_entry_map(dist: _EPDistType, group: str) -> dict[str, EntryPoint]: ...
+def get_entry_map(dist: _EPDistType, group: str | None = None):
"""Return the entry point map for `group`, or the full entry map"""
return get_distribution(dist).get_entry_map(group)
-def get_entry_info(dist, group, name):
+def get_entry_info(dist: _EPDistType, group: str, name: str):
"""Return the EntryPoint object for `group`+`name`, or ``None``"""
return get_distribution(dist).get_entry_info(group, name)
-class IMetadataProvider:
- def has_metadata(name):
+class IMetadataProvider(Protocol):
+ def has_metadata(self, name: str) -> bool:
"""Does the package's distribution contain the named metadata?"""
- def get_metadata(name):
+ def get_metadata(self, name: str) -> str:
"""The named metadata resource as a string"""
- def get_metadata_lines(name):
+ def get_metadata_lines(self, name: str) -> Iterator[str]:
"""Yield named metadata resource as list of non-blank non-comment lines
- Leading and trailing whitespace is stripped from each line, and lines
- with ``#`` as the first non-blank character are omitted."""
+ Leading and trailing whitespace is stripped from each line, and lines
+ with ``#`` as the first non-blank character are omitted."""
- def metadata_isdir(name):
+ def metadata_isdir(self, name: str) -> bool:
"""Is the named metadata a directory? (like ``os.path.isdir()``)"""
- def metadata_listdir(name):
+ def metadata_listdir(self, name: str) -> list[str]:
"""List of metadata names in the directory (like ``os.listdir()``)"""
- def run_script(script_name, namespace):
+ def run_script(self, script_name: str, namespace: dict[str, Any]) -> None:
"""Execute the named script in the supplied namespace dictionary"""
-class IResourceProvider(IMetadataProvider):
+class IResourceProvider(IMetadataProvider, Protocol):
"""An object that provides access to package resources"""
- def get_resource_filename(manager, resource_name):
+ def get_resource_filename(
+ self, manager: ResourceManager, resource_name: str
+ ) -> str:
"""Return a true filesystem path for `resource_name`
- `manager` must be an ``IResourceManager``"""
+ `manager` must be a ``ResourceManager``"""
- def get_resource_stream(manager, resource_name):
+ def get_resource_stream(
+ self, manager: ResourceManager, resource_name: str
+ ) -> _ResourceStream:
"""Return a readable file-like object for `resource_name`
- `manager` must be an ``IResourceManager``"""
+ `manager` must be a ``ResourceManager``"""
- def get_resource_string(manager, resource_name):
- """Return a string containing the contents of `resource_name`
+ def get_resource_string(
+ self, manager: ResourceManager, resource_name: str
+ ) -> bytes:
+ """Return the contents of `resource_name` as :obj:`bytes`
- `manager` must be an ``IResourceManager``"""
+ `manager` must be a ``ResourceManager``"""
- def has_resource(resource_name):
+ def has_resource(self, resource_name: str) -> bool:
"""Does the package contain the named resource?"""
- def resource_isdir(resource_name):
+ def resource_isdir(self, resource_name: str) -> bool:
"""Is the named resource a directory? (like ``os.path.isdir()``)"""
- def resource_listdir(resource_name):
+ def resource_listdir(self, resource_name: str) -> list[str]:
"""List of resource names in the directory (like ``os.listdir()``)"""
class WorkingSet:
"""A collection of active distributions on sys.path (or a similar list)"""
- def __init__(self, entries=None):
+ def __init__(self, entries: Iterable[str] | None = None):
"""Create working set from list of path entries (default=sys.path)"""
- self.entries = []
+ self.entries: list[str] = []
self.entry_keys = {}
self.by_key = {}
+ self.normalized_to_canonical_keys = {}
self.callbacks = []
if entries is None:
@@ -608,7 +681,7 @@ class WorkingSet:
sys.path[:] = ws.entries
return ws
- def add_entry(self, entry):
+ def add_entry(self, entry: str):
"""Add a path item to ``.entries``, finding any distributions on it
``find_distributions(entry, True)`` is used to find distributions
@@ -623,11 +696,11 @@ class WorkingSet:
for dist in find_distributions(entry, True):
self.add(dist, entry, False)
- def __contains__(self, dist):
+ def __contains__(self, dist: Distribution) -> bool:
"""True if `dist` is the active distribution for its project"""
return self.by_key.get(dist.key) == dist
- def find(self, req):
+ def find(self, req: Requirement) -> Distribution | None:
"""Find a distribution matching requirement `req`
If there is an active distribution for the requested project, this
@@ -638,12 +711,20 @@ class WorkingSet:
is returned.
"""
dist = self.by_key.get(req.key)
+
+ if dist is None:
+ canonical_key = self.normalized_to_canonical_keys.get(req.key)
+
+ if canonical_key is not None:
+ req.key = canonical_key
+ dist = self.by_key.get(canonical_key)
+
if dist is not None and dist not in req:
# XXX add more info
raise VersionConflict(dist, req)
return dist
- def iter_entry_points(self, group, name=None):
+ def iter_entry_points(self, group: str, name: str | None = None):
"""Yield entry point objects from `group` matching `name`
If `name` is None, yields all entry points in `group` from all
@@ -657,7 +738,7 @@ class WorkingSet:
if name is None or name == entry.name
)
- def run_script(self, requires, script_name):
+ def run_script(self, requires: str, script_name: str):
"""Locate distribution for `requires` and run `script_name` script"""
ns = sys._getframe(1).f_globals
name = ns['__name__']
@@ -665,13 +746,13 @@ class WorkingSet:
ns['__name__'] = name
self.require(requires)[0].run_script(script_name, ns)
- def __iter__(self):
+ def __iter__(self) -> Iterator[Distribution]:
"""Yield distributions for non-duplicate projects in the working set
The yield order is the order in which the items' path entries were
added to the working set.
"""
- seen = {}
+ seen = set()
for item in self.entries:
if item not in self.entry_keys:
# workaround a cache issue
@@ -679,10 +760,16 @@ class WorkingSet:
for key in self.entry_keys[item]:
if key not in seen:
- seen[key] = 1
+ seen.add(key)
yield self.by_key[key]
- def add(self, dist, entry=None, insert=True, replace=False):
+ def add(
+ self,
+ dist: Distribution,
+ entry: str | None = None,
+ insert: bool = True,
+ replace: bool = False,
+ ):
"""Add `dist` to working set, associated with `entry`
If `entry` is unspecified, it defaults to the ``.location`` of `dist`.
@@ -706,14 +793,50 @@ class WorkingSet:
return
self.by_key[dist.key] = dist
+ normalized_name = _packaging_utils.canonicalize_name(dist.key)
+ self.normalized_to_canonical_keys[normalized_name] = dist.key
if dist.key not in keys:
keys.append(dist.key)
if dist.key not in keys2:
keys2.append(dist.key)
self._added_new(dist)
- def resolve(self, requirements, env=None, installer=None,
- replace_conflicting=False, extras=None):
+ @overload
+ def resolve(
+ self,
+ requirements: Iterable[Requirement],
+ env: Environment | None,
+ installer: _InstallerTypeT[_DistributionT],
+ replace_conflicting: bool = False,
+ extras: tuple[str, ...] | None = None,
+ ) -> list[_DistributionT]: ...
+ @overload
+ def resolve(
+ self,
+ requirements: Iterable[Requirement],
+ env: Environment | None = None,
+ *,
+ installer: _InstallerTypeT[_DistributionT],
+ replace_conflicting: bool = False,
+ extras: tuple[str, ...] | None = None,
+ ) -> list[_DistributionT]: ...
+ @overload
+ def resolve(
+ self,
+ requirements: Iterable[Requirement],
+ env: Environment | None = None,
+ installer: _InstallerType | None = None,
+ replace_conflicting: bool = False,
+ extras: tuple[str, ...] | None = None,
+ ) -> list[Distribution]: ...
+ def resolve(
+ self,
+ requirements: Iterable[Requirement],
+ env: Environment | None = None,
+ installer: _InstallerType | None | _InstallerTypeT[_DistributionT] = None,
+ replace_conflicting: bool = False,
+ extras: tuple[str, ...] | None = None,
+ ) -> list[Distribution] | list[_DistributionT]:
"""List all distributions needed to (recursively) meet `requirements`
`requirements` must be a sequence of ``Requirement`` objects. `env`,
@@ -741,7 +864,7 @@ class WorkingSet:
# set up the stack
requirements = list(requirements)[::-1]
# set of processed requirements
- processed = {}
+ processed = set()
# key -> dist
best = {}
to_activate = []
@@ -762,33 +885,9 @@ class WorkingSet:
if not req_extras.markers_pass(req, extras):
continue
- dist = best.get(req.key)
- if dist is None:
- # Find the best distribution and add it to the map
- dist = self.by_key.get(req.key)
- if dist is None or (dist not in req and replace_conflicting):
- ws = self
- if env is None:
- if dist is None:
- env = Environment(self.entries)
- else:
- # Use an empty environment and workingset to avoid
- # any further conflicts with the conflicting
- # distribution
- env = Environment([])
- ws = WorkingSet([])
- dist = best[req.key] = env.best_match(
- req, ws, installer,
- replace_conflicting=replace_conflicting
- )
- if dist is None:
- requirers = required_by.get(req, None)
- raise DistributionNotFound(req, requirers)
- to_activate.append(dist)
- if dist not in req:
- # Oops, the "best" so far conflicts with a dependency
- dependent_req = required_by[req]
- raise VersionConflict(dist, req).with_context(dependent_req)
+ dist = self._resolve_dist(
+ req, best, replace_conflicting, env, installer, required_by, to_activate
+ )
# push the new requirements onto the stack
new_requirements = dist.requires(req.extras)[::-1]
@@ -799,13 +898,77 @@ class WorkingSet:
required_by[new_requirement].add(req.project_name)
req_extras[new_requirement] = req.extras
- processed[req] = True
+ processed.add(req)
# return list of distros to activate
return to_activate
+ def _resolve_dist(
+ self, req, best, replace_conflicting, env, installer, required_by, to_activate
+ ) -> Distribution:
+ dist = best.get(req.key)
+ if dist is None:
+ # Find the best distribution and add it to the map
+ dist = self.by_key.get(req.key)
+ if dist is None or (dist not in req and replace_conflicting):
+ ws = self
+ if env is None:
+ if dist is None:
+ env = Environment(self.entries)
+ else:
+ # Use an empty environment and workingset to avoid
+ # any further conflicts with the conflicting
+ # distribution
+ env = Environment([])
+ ws = WorkingSet([])
+ dist = best[req.key] = env.best_match(
+ req, ws, installer, replace_conflicting=replace_conflicting
+ )
+ if dist is None:
+ requirers = required_by.get(req, None)
+ raise DistributionNotFound(req, requirers)
+ to_activate.append(dist)
+ if dist not in req:
+ # Oops, the "best" so far conflicts with a dependency
+ dependent_req = required_by[req]
+ raise VersionConflict(dist, req).with_context(dependent_req)
+ return dist
+
+ @overload
def find_plugins(
- self, plugin_env, full_env=None, installer=None, fallback=True):
+ self,
+ plugin_env: Environment,
+ full_env: Environment | None,
+ installer: _InstallerTypeT[_DistributionT],
+ fallback: bool = True,
+ ) -> tuple[list[_DistributionT], dict[Distribution, Exception]]: ...
+ @overload
+ def find_plugins(
+ self,
+ plugin_env: Environment,
+ full_env: Environment | None = None,
+ *,
+ installer: _InstallerTypeT[_DistributionT],
+ fallback: bool = True,
+ ) -> tuple[list[_DistributionT], dict[Distribution, Exception]]: ...
+ @overload
+ def find_plugins(
+ self,
+ plugin_env: Environment,
+ full_env: Environment | None = None,
+ installer: _InstallerType | None = None,
+ fallback: bool = True,
+ ) -> tuple[list[Distribution], dict[Distribution, Exception]]: ...
+ def find_plugins(
+ self,
+ plugin_env: Environment,
+ full_env: Environment | None = None,
+ installer: _InstallerType | None | _InstallerTypeT[_DistributionT] = None,
+ fallback: bool = True,
+ ) -> tuple[
+ list[Distribution] | list[_DistributionT],
+ dict[Distribution, Exception],
+ ]:
"""Find all activatable distributions in `plugin_env`
Example usage::
@@ -844,8 +1007,8 @@ class WorkingSet:
# scan project names in alphabetic order
plugin_projects.sort()
- error_info = {}
- distributions = {}
+ error_info: dict[Distribution, Exception] = {}
+ distributions: dict[Distribution, Exception | None] = {}
if full_env is None:
env = Environment(self.entries)
@@ -858,9 +1021,7 @@ class WorkingSet:
list(map(shadow_set.add, self))
for project_name in plugin_projects:
-
for dist in plugin_env[project_name]:
-
req = [dist.as_requirement()]
try:
@@ -883,12 +1044,12 @@ class WorkingSet:
# success, no need to try any more versions of this project
break
- distributions = list(distributions)
- distributions.sort()
+ sorted_distributions = list(distributions)
+ sorted_distributions.sort()
- return distributions, error_info
+ return sorted_distributions, error_info
- def require(self, *requirements):
+ def require(self, *requirements: _NestedStr):
"""Ensure that distributions matching `requirements` are activated
`requirements` must be a string or a (possibly-nested) sequence
@@ -904,7 +1065,9 @@ class WorkingSet:
return needed
- def subscribe(self, callback, existing=True):
+ def subscribe(
+ self, callback: Callable[[Distribution], object], existing: bool = True
+ ):
"""Invoke `callback` for all distributions
If `existing=True` (default),
@@ -924,24 +1087,28 @@ class WorkingSet:
def __getstate__(self):
return (
- self.entries[:], self.entry_keys.copy(), self.by_key.copy(),
- self.callbacks[:]
+ self.entries[:],
+ self.entry_keys.copy(),
+ self.by_key.copy(),
+ self.normalized_to_canonical_keys.copy(),
+ self.callbacks[:],
)
- def __setstate__(self, e_k_b_c):
- entries, keys, by_key, callbacks = e_k_b_c
+ def __setstate__(self, e_k_b_n_c):
+ entries, keys, by_key, normalized_to_canonical_keys, callbacks = e_k_b_n_c
self.entries = entries[:]
self.entry_keys = keys.copy()
self.by_key = by_key.copy()
+ self.normalized_to_canonical_keys = normalized_to_canonical_keys.copy()
self.callbacks = callbacks[:]
-class _ReqExtras(dict):
+class _ReqExtras(Dict["Requirement", Tuple[str, ...]]):
"""
Map each requirement to the extras that demanded it.
"""
- def markers_pass(self, req, extras=None):
+ def markers_pass(self, req: Requirement, extras: tuple[str, ...] | None = None):
"""
Evaluate markers for req against each extra that
demanded it.
@@ -960,8 +1127,11 @@ class Environment:
"""Searchable snapshot of distributions on a search path"""
def __init__(
- self, search_path=None, platform=get_supported_platform(),
- python=PY_MAJOR):
+ self,
+ search_path: Iterable[str] | None = None,
+ platform: str | None = get_supported_platform(),
+ python: str | None = PY_MAJOR,
+ ):
"""Snapshot distributions available on a search path
Any distributions found on `search_path` are added to the environment.
@@ -983,7 +1153,7 @@ class Environment:
self.python = python
self.scan(search_path)
- def can_add(self, dist):
+ def can_add(self, dist: Distribution):
"""Is distribution `dist` acceptable for this environment?
The distribution must match the platform and python version
@@ -997,11 +1167,11 @@ class Environment:
)
return py_compat and compatible_platforms(dist.platform, self.platform)
- def remove(self, dist):
+ def remove(self, dist: Distribution):
"""Remove `dist` from the environment"""
self._distmap[dist.key].remove(dist)
- def scan(self, search_path=None):
+ def scan(self, search_path: Iterable[str] | None = None):
"""Scan `search_path` for distributions usable in this environment
Any distributions found are added to the environment.
@@ -1016,7 +1186,7 @@ class Environment:
for dist in find_distributions(item):
self.add(dist)
- def __getitem__(self, project_name):
+ def __getitem__(self, project_name: str) -> list[Distribution]:
"""Return a newest-to-oldest list of distributions for `project_name`
Uses case-insensitive `project_name` comparison, assuming all the
@@ -1027,17 +1197,37 @@ class Environment:
distribution_key = project_name.lower()
return self._distmap.get(distribution_key, [])
- def add(self, dist):
- """Add `dist` if we ``can_add()`` it and it has not already been added
- """
+ def add(self, dist: Distribution):
+ """Add `dist` if we ``can_add()`` it and it has not already been added"""
if self.can_add(dist) and dist.has_version():
dists = self._distmap.setdefault(dist.key, [])
if dist not in dists:
dists.append(dist)
dists.sort(key=operator.attrgetter('hashcmp'), reverse=True)
+ @overload
def best_match(
- self, req, working_set, installer=None, replace_conflicting=False):
+ self,
+ req: Requirement,
+ working_set: WorkingSet,
+ installer: _InstallerTypeT[_DistributionT],
+ replace_conflicting: bool = False,
+ ) -> _DistributionT: ...
+ @overload
+ def best_match(
+ self,
+ req: Requirement,
+ working_set: WorkingSet,
+ installer: _InstallerType | None = None,
+ replace_conflicting: bool = False,
+ ) -> Distribution | None: ...
+ def best_match(
+ self,
+ req: Requirement,
+ working_set: WorkingSet,
+ installer: _InstallerType | None | _InstallerTypeT[_DistributionT] = None,
+ replace_conflicting: bool = False,
+ ) -> Distribution | None:
"""Find distribution best matching `req` and usable on `working_set`
This calls the ``find(req)`` method of the `working_set` to see if a
@@ -1064,7 +1254,32 @@ class Environment:
# try to download/install
return self.obtain(req, installer)
- def obtain(self, requirement, installer=None):
+ @overload
+ def obtain(
+ self,
+ requirement: Requirement,
+ installer: _InstallerTypeT[_DistributionT],
+ ) -> _DistributionT: ...
+ @overload
+ def obtain(
+ self,
+ requirement: Requirement,
+ installer: Callable[[Requirement], None] | None = None,
+ ) -> None: ...
+ @overload
+ def obtain(
+ self,
+ requirement: Requirement,
+ installer: _InstallerType | None = None,
+ ) -> Distribution | None: ...
+ def obtain(
+ self,
+ requirement: Requirement,
+ installer: Callable[[Requirement], None]
+ | _InstallerType
+ | None
+ | _InstallerTypeT[_DistributionT] = None,
+ ) -> Distribution | None:
"""Obtain a distribution matching `requirement` (e.g. via download)
Obtain a distro that matches requirement (e.g. via download). In the
@@ -1073,16 +1288,15 @@ class Environment:
None is returned instead. This method is a hook that allows subclasses
to attempt other ways of obtaining a distribution before falling back
to the `installer` argument."""
- if installer is not None:
- return installer(requirement)
+ return installer(requirement) if installer else None
- def __iter__(self):
+ def __iter__(self) -> Iterator[str]:
"""Yield the unique project names of the available distributions"""
for key in self._distmap.keys():
if self[key]:
yield key
- def __iadd__(self, other):
+ def __iadd__(self, other: Distribution | Environment):
"""In-place addition of a distribution or environment"""
if isinstance(other, Distribution):
self.add(other)
@@ -1094,7 +1308,7 @@ class Environment:
raise TypeError("Can't add %r to environment" % (other,))
return self
- def __add__(self, other):
+ def __add__(self, other: Distribution | Environment):
"""Add an environment or distribution to an environment"""
new = self.__class__([], platform=None, python=None)
for env in self, other:
@@ -1121,55 +1335,61 @@ class ExtractionError(RuntimeError):
The exception instance that caused extraction to fail
"""
+ manager: ResourceManager
+ cache_path: str
+ original_error: BaseException | None
+
class ResourceManager:
"""Manage resource extraction and packages"""
- extraction_path = None
+
+ extraction_path: str | None = None
def __init__(self):
self.cached_files = {}
- def resource_exists(self, package_or_requirement, resource_name):
+ def resource_exists(self, package_or_requirement: _PkgReqType, resource_name: str):
"""Does the named resource exist?"""
return get_provider(package_or_requirement).has_resource(resource_name)
- def resource_isdir(self, package_or_requirement, resource_name):
+ def resource_isdir(self, package_or_requirement: _PkgReqType, resource_name: str):
"""Is the named resource an existing directory?"""
- return get_provider(package_or_requirement).resource_isdir(
- resource_name
- )
+ return get_provider(package_or_requirement).resource_isdir(resource_name)
- def resource_filename(self, package_or_requirement, resource_name):
+ def resource_filename(
+ self, package_or_requirement: _PkgReqType, resource_name: str
+ ):
"""Return a true filesystem path for specified resource"""
return get_provider(package_or_requirement).get_resource_filename(
self, resource_name
)
- def resource_stream(self, package_or_requirement, resource_name):
+ def resource_stream(self, package_or_requirement: _PkgReqType, resource_name: str):
"""Return a readable file-like object for specified resource"""
return get_provider(package_or_requirement).get_resource_stream(
self, resource_name
)
- def resource_string(self, package_or_requirement, resource_name):
- """Return specified resource as a string"""
+ def resource_string(
+ self, package_or_requirement: _PkgReqType, resource_name: str
+ ) -> bytes:
+ """Return specified resource as :obj:`bytes`"""
return get_provider(package_or_requirement).get_resource_string(
self, resource_name
)
- def resource_listdir(self, package_or_requirement, resource_name):
+ def resource_listdir(self, package_or_requirement: _PkgReqType, resource_name: str):
"""List the contents of the named resource directory"""
- return get_provider(package_or_requirement).resource_listdir(
- resource_name
- )
+ return get_provider(package_or_requirement).resource_listdir(resource_name)
- def extraction_error(self):
+ def extraction_error(self) -> NoReturn:
"""Give an error message for problems extracting file(s)"""
old_exc = sys.exc_info()[1]
cache_path = self.extraction_path or get_default_cache()
- tmpl = textwrap.dedent("""
+ tmpl = textwrap.dedent(
+ """
Can't extract file(s) to egg cache
The following error occurred while trying to extract file(s)
@@ -1184,14 +1404,15 @@ class ResourceManager:
Perhaps your account does not have write access to this directory?
You can change the cache directory by setting the PYTHON_EGG_CACHE
environment variable to point to an accessible directory.
- """).lstrip()
+ """
+ ).lstrip()
err = ExtractionError(tmpl.format(**locals()))
err.manager = self
err.cache_path = cache_path
err.original_error = old_exc
raise err
- def get_cache_path(self, archive_name, names=()):
+ def get_cache_path(self, archive_name: str, names: Iterable[StrPath] = ()):
"""Return absolute location in cache for `archive_name` and `names`
The parent directory of the resulting path will be created if it does
@@ -1213,7 +1434,7 @@ class ResourceManager:
self._warn_unsafe_extraction_path(extract_path)
- self.cached_files[target_path] = 1
+ self.cached_files[target_path] = True
return target_path
@staticmethod
@@ -1234,15 +1455,16 @@ class ResourceManager:
mode = os.stat(path).st_mode
if mode & stat.S_IWOTH or mode & stat.S_IWGRP:
msg = (
- "%s is writable by group/others and vulnerable to attack "
- "when "
- "used with get_resource_filename. Consider a more secure "
+ "Extraction path is writable by group/others "
+ "and vulnerable to attack when "
+ "used with get_resource_filename ({path}). "
+ "Consider a more secure "
"location (set with .set_extraction_path or the "
- "PYTHON_EGG_CACHE environment variable)." % path
- )
+ "PYTHON_EGG_CACHE environment variable)."
+ ).format(**locals())
warnings.warn(msg, UserWarning)
- def postprocess(self, tempname, filename):
+ def postprocess(self, tempname: StrOrBytesPath, filename: StrOrBytesPath):
"""Perform any platform-specific postprocessing of `tempname`
This is where Mac header rewrites should be done; other platforms don't
@@ -1262,7 +1484,7 @@ class ResourceManager:
mode = ((os.stat(tempname).st_mode) | 0o555) & 0o7777
os.chmod(tempname, mode)
- def set_extraction_path(self, path):
+ def set_extraction_path(self, path: str):
"""Set the base path where resources will be extracted to, if needed.
If you do not call this routine before any extractions take place, the
@@ -1282,13 +1504,11 @@ class ResourceManager:
``cleanup_resources()``.)
"""
if self.cached_files:
- raise ValueError(
- "Can't change extraction path, files already extracted"
- )
+ raise ValueError("Can't change extraction path, files already extracted")
self.extraction_path = path
- def cleanup_resources(self, force=False):
+ def cleanup_resources(self, force: bool = False) -> list[str]:
"""
Delete all extracted resource files and directories, returning a list
of the file and directory names that could not be successfully removed.
@@ -1300,21 +1520,19 @@ class ResourceManager:
directory used for extractions.
"""
# XXX
+ return []
-def get_default_cache():
+def get_default_cache() -> str:
"""
Return the ``PYTHON_EGG_CACHE`` environment variable
or a platform-relevant user cache dir for an app
named "Python-Eggs".
"""
- return (
- os.environ.get('PYTHON_EGG_CACHE')
- or platformdirs.user_cache_dir(appname='Python-Eggs')
- )
+ return os.environ.get('PYTHON_EGG_CACHE') or _user_cache_dir(appname='Python-Eggs')
-def safe_name(name):
+def safe_name(name: str):
"""Convert an arbitrary string to a standard distribution name
Any runs of non-alphanumeric/. characters are replaced with a single '-'.
@@ -1322,19 +1540,51 @@ def safe_name(name):
return re.sub('[^A-Za-z0-9.]+', '-', name)
-def safe_version(version):
+def safe_version(version: str):
"""
Convert an arbitrary string to a standard version string
"""
try:
# normalize the version
- return str(packaging.version.Version(version))
- except packaging.version.InvalidVersion:
+ return str(_packaging_version.Version(version))
+ except _packaging_version.InvalidVersion:
version = version.replace(' ', '.')
return re.sub('[^A-Za-z0-9.]+', '-', version)
-def safe_extra(extra):
+def _forgiving_version(version):
+ """Fallback when ``safe_version`` is not safe enough
+ >>> parse_version(_forgiving_version('0.23ubuntu1'))
+
+ >>> parse_version(_forgiving_version('0.23-'))
+
+ >>> parse_version(_forgiving_version('0.-_'))
+
+ >>> parse_version(_forgiving_version('42.+?1'))
+
+ >>> parse_version(_forgiving_version('hello world'))
+
+ """
+ version = version.replace(' ', '.')
+ match = _PEP440_FALLBACK.search(version)
+ if match:
+ safe = match["safe"]
+ rest = version[len(safe) :]
+ else:
+ safe = "0"
+ rest = version
+ local = f"sanitized.{_safe_segment(rest)}".strip(".")
+ return f"{safe}.dev0+{local}"
+
+
+def _safe_segment(segment):
+ """Convert an arbitrary string into a safe segment"""
+ segment = re.sub('[^A-Za-z0-9.]+', '-', segment)
+ segment = re.sub('-[^A-Za-z0-9]+', '-', segment)
+ return re.sub(r'\.[^A-Za-z0-9]+', '.', segment).strip(".-")
+
+
+def safe_extra(extra: str):
"""Convert an arbitrary string to a standard 'extra' name
Any runs of non-alphanumeric characters are replaced with a single '_',
@@ -1343,7 +1593,7 @@ def safe_extra(extra):
return re.sub('[^A-Za-z0-9.-]+', '_', extra).lower()
-def to_filename(name):
+def to_filename(name: str):
"""Convert a project or version name to its filename-escaped form
Any '-' characters are currently replaced with '_'.
@@ -1351,7 +1601,7 @@ def to_filename(name):
return name.replace('-', '_')
-def invalid_marker(text):
+def invalid_marker(text: str):
"""
Validate text as a PEP 508 environment marker; return an exception
if invalid or False otherwise.
@@ -1365,7 +1615,7 @@ def invalid_marker(text):
return False
-def evaluate_marker(text, extra=None):
+def evaluate_marker(text: str, extra: str | None = None) -> bool:
"""
Evaluate a PEP 508 environment marker.
Return a boolean indicating the marker result in this environment.
@@ -1374,52 +1624,52 @@ def evaluate_marker(text, extra=None):
This implementation uses the 'pyparsing' module.
"""
try:
- marker = packaging.markers.Marker(text)
+ marker = _packaging_markers.Marker(text)
return marker.evaluate()
- except packaging.markers.InvalidMarker as e:
- raise SyntaxError(e)
+ except _packaging_markers.InvalidMarker as e:
+ raise SyntaxError(e) from e
class NullProvider:
"""Try to implement resources and metadata for arbitrary PEP 302 loaders"""
- egg_name = None
- egg_info = None
- loader = None
+ egg_name: str | None = None
+ egg_info: str | None = None
+ loader: _LoaderProtocol | None = None
- def __init__(self, module):
+ def __init__(self, module: _ModuleLike):
self.loader = getattr(module, '__loader__', None)
self.module_path = os.path.dirname(getattr(module, '__file__', ''))
- def get_resource_filename(self, manager, resource_name):
+ def get_resource_filename(self, manager: ResourceManager, resource_name: str):
return self._fn(self.module_path, resource_name)
- def get_resource_stream(self, manager, resource_name):
+ def get_resource_stream(self, manager: ResourceManager, resource_name: str):
return io.BytesIO(self.get_resource_string(manager, resource_name))
- def get_resource_string(self, manager, resource_name):
+ def get_resource_string(
+ self, manager: ResourceManager, resource_name: str
+ ) -> bytes:
return self._get(self._fn(self.module_path, resource_name))
- def has_resource(self, resource_name):
+ def has_resource(self, resource_name: str):
return self._has(self._fn(self.module_path, resource_name))
def _get_metadata_path(self, name):
return self._fn(self.egg_info, name)
- def has_metadata(self, name):
+ def has_metadata(self, name: str) -> bool:
if not self.egg_info:
- return self.egg_info
+ return False
path = self._get_metadata_path(name)
return self._has(path)
- def get_metadata(self, name):
+ def get_metadata(self, name: str):
if not self.egg_info:
return ""
path = self._get_metadata_path(name)
value = self._get(path)
- if six.PY2:
- return value
try:
return value.decode('utf-8')
except UnicodeDecodeError as exc:
@@ -1428,62 +1678,72 @@ class NullProvider:
exc.reason += ' in {} file at path: {}'.format(name, path)
raise
- def get_metadata_lines(self, name):
+ def get_metadata_lines(self, name: str) -> Iterator[str]:
return yield_lines(self.get_metadata(name))
- def resource_isdir(self, resource_name):
+ def resource_isdir(self, resource_name: str):
return self._isdir(self._fn(self.module_path, resource_name))
- def metadata_isdir(self, name):
- return self.egg_info and self._isdir(self._fn(self.egg_info, name))
+ def metadata_isdir(self, name: str) -> bool:
+ return bool(self.egg_info and self._isdir(self._fn(self.egg_info, name)))
- def resource_listdir(self, resource_name):
+ def resource_listdir(self, resource_name: str):
return self._listdir(self._fn(self.module_path, resource_name))
- def metadata_listdir(self, name):
+ def metadata_listdir(self, name: str) -> list[str]:
if self.egg_info:
return self._listdir(self._fn(self.egg_info, name))
return []
- def run_script(self, script_name, namespace):
+ def run_script(self, script_name: str, namespace: dict[str, Any]):
script = 'scripts/' + script_name
if not self.has_metadata(script):
raise ResolutionError(
- "Script {script!r} not found in metadata at {self.egg_info!r}"
- .format(**locals()),
+ "Script {script!r} not found in metadata at {self.egg_info!r}".format(
+ **locals()
+ ),
)
+
script_text = self.get_metadata(script).replace('\r\n', '\n')
script_text = script_text.replace('\r', '\n')
script_filename = self._fn(self.egg_info, script)
namespace['__file__'] = script_filename
if os.path.exists(script_filename):
- source = open(script_filename).read()
+ source = _read_utf8_with_fallback(script_filename)
code = compile(source, script_filename, 'exec')
exec(code, namespace, namespace)
else:
from linecache import cache
+
cache[script_filename] = (
- len(script_text), 0, script_text.split('\n'), script_filename
+ len(script_text),
+ 0,
+ script_text.split('\n'),
+ script_filename,
)
script_code = compile(script_text, script_filename, 'exec')
exec(script_code, namespace, namespace)
- def _has(self, path):
+ def _has(self, path) -> bool:
raise NotImplementedError(
"Can't perform this operation for unregistered loader type"
)
- def _isdir(self, path):
+ def _isdir(self, path) -> bool:
raise NotImplementedError(
"Can't perform this operation for unregistered loader type"
)
- def _listdir(self, path):
+ def _listdir(self, path) -> list[str]:
raise NotImplementedError(
"Can't perform this operation for unregistered loader type"
)
- def _fn(self, base, resource_name):
+ def _fn(self, base: str | None, resource_name: str):
+ if base is None:
+ raise TypeError(
+ "`base` parameter in `_fn` is `None`. Either override this method or check the parameter first."
+ )
self._validate_resource_path(resource_name)
if resource_name:
return os.path.join(base, *resource_name.split('/'))
@@ -1493,7 +1753,7 @@ class NullProvider:
def _validate_resource_path(path):
"""
Validate the resource paths according to the docs.
- https://setuptools.readthedocs.io/en/latest/pkg_resources.html#basic-resource-access
+ https://setuptools.pypa.io/en/latest/pkg_resources.html#basic-resource-access
>>> warned = getfixture('recwarn')
>>> warnings.simplefilter('always')
@@ -1543,9 +1803,10 @@ is not allowed.
AttributeError: ...
"""
invalid = (
- os.path.pardir in path.split(posixpath.sep) or
- posixpath.isabs(path) or
- ntpath.isabs(path)
+ os.path.pardir in path.split(posixpath.sep)
+ or posixpath.isabs(path)
+ or ntpath.isabs(path)
+ or path.startswith("\\")
)
if not invalid:
return
@@ -1553,20 +1814,20 @@ is not allowed.
msg = "Use of .. or absolute path in a resource path is not allowed."
# Aggressively disallow Windows absolute paths
- if ntpath.isabs(path) and not posixpath.isabs(path):
+ if (path.startswith("\\") or ntpath.isabs(path)) and not posixpath.isabs(path):
raise ValueError(msg)
# for compatibility, warn; in future
# raise ValueError(msg)
- warnings.warn(
+ issue_warning(
msg[:-1] + " and will raise exceptions in a future release.",
DeprecationWarning,
- stacklevel=4,
)
- def _get(self, path):
- if hasattr(self.loader, 'get_data'):
- return self.loader.get_data(path)
+ def _get(self, path) -> bytes:
+ if hasattr(self.loader, 'get_data') and self.loader:
+ # Already checked get_data exists
+ return self.loader.get_data(path) # type: ignore[attr-defined]
raise NotImplementedError(
"Can't perform this operation for loaders without 'get_data()'"
)
@@ -1575,52 +1836,64 @@ is not allowed.
register_loader_type(object, NullProvider)
+def _parents(path):
+ """
+ yield all parents of path including path
+ """
+ last = None
+ while path != last:
+ yield path
+ last = path
+ path, _ = os.path.split(path)
+
+
class EggProvider(NullProvider):
"""Provider based on a virtual filesystem"""
- def __init__(self, module):
- NullProvider.__init__(self, module)
+ def __init__(self, module: _ModuleLike):
+ super().__init__(module)
self._setup_prefix()
def _setup_prefix(self):
- # we assume here that our metadata may be nested inside a "basket"
- # of multiple eggs; that's why we use module_path instead of .archive
- path = self.module_path
- old = None
- while path != old:
- if _is_egg_path(path):
- self.egg_name = os.path.basename(path)
- self.egg_info = os.path.join(path, 'EGG-INFO')
- self.egg_root = path
- break
- old = path
- path, base = os.path.split(path)
+ # Assume that metadata may be nested inside a "basket"
+ # of multiple eggs and use module_path instead of .archive.
+ eggs = filter(_is_egg_path, _parents(self.module_path))
+ egg = next(eggs, None)
+ egg and self._set_egg(egg)
+
+ def _set_egg(self, path: str):
+ self.egg_name = os.path.basename(path)
+ self.egg_info = os.path.join(path, 'EGG-INFO')
+ self.egg_root = path
class DefaultProvider(EggProvider):
"""Provides access to package resources in the filesystem"""
- def _has(self, path):
+ def _has(self, path) -> bool:
return os.path.exists(path)
- def _isdir(self, path):
+ def _isdir(self, path) -> bool:
return os.path.isdir(path)
def _listdir(self, path):
return os.listdir(path)
- def get_resource_stream(self, manager, resource_name):
+ def get_resource_stream(self, manager: object, resource_name: str):
return open(self._fn(self.module_path, resource_name), 'rb')
- def _get(self, path):
+ def _get(self, path) -> bytes:
with open(path, 'rb') as stream:
return stream.read()
@classmethod
def _register(cls):
- loader_names = 'SourceFileLoader', 'SourcelessFileLoader',
+ loader_names = (
+ 'SourceFileLoader',
+ 'SourcelessFileLoader',
+ )
for name in loader_names:
- loader_cls = getattr(importlib_machinery, name, type(None))
+ loader_cls = getattr(importlib.machinery, name, type(None))
register_loader_type(loader_cls, cls)
@@ -1630,12 +1903,13 @@ DefaultProvider._register()
class EmptyProvider(NullProvider):
"""Provider that returns nothing for all requests"""
- module_path = None
+ # A special case, we don't want all Providers inheriting from NullProvider to have a potentially None module_path
+ module_path: str | None = None # type: ignore[assignment]
_isdir = _has = lambda self, path: False
- def _get(self, path):
- return ''
+ def _get(self, path) -> bytes:
+ return b''
def _listdir(self, path):
return []
@@ -1647,13 +1921,14 @@ class EmptyProvider(NullProvider):
empty_provider = EmptyProvider()
-class ZipManifests(dict):
+class ZipManifests(Dict[str, "MemoizedZipManifests.manifest_mod"]):
"""
zip manifest builder
"""
+ # `path` could be `StrPath | IO[bytes]` but that violates the LSP for `MemoizedZipManifests.load`
@classmethod
- def build(cls, path):
+ def build(cls, path: str):
"""
Build a dictionary similar to the zipimport directory
caches, except instead of tuples, store ZipInfo objects.
@@ -1678,9 +1953,12 @@ class MemoizedZipManifests(ZipManifests):
"""
Memoized zipfile manifests.
"""
- manifest_mod = collections.namedtuple('manifest_mod', 'manifest mtime')
- def load(self, path):
+ class manifest_mod(NamedTuple):
+ manifest: dict[str, zipfile.ZipInfo]
+ mtime: float
+
+ def load(self, path: str) -> dict[str, zipfile.ZipInfo]: # type: ignore[override] # ZipManifests.load is a classmethod
"""
Load a manifest at path or return a suitable manifest already loaded.
"""
@@ -1697,11 +1975,13 @@ class MemoizedZipManifests(ZipManifests):
class ZipProvider(EggProvider):
"""Resource support for zips and eggs"""
- eagers = None
+ eagers: list[str] | None = None
_zip_manifests = MemoizedZipManifests()
+ # ZipProvider's loader should always be a zipimporter or equivalent
+ loader: zipimport.zipimporter
- def __init__(self, module):
- EggProvider.__init__(self, module)
+ def __init__(self, module: _ZipLoaderModule):
+ super().__init__(module)
self.zip_pre = self.loader.archive + os.sep
def _zipinfo_name(self, fspath):
@@ -1711,26 +1991,22 @@ class ZipProvider(EggProvider):
if fspath == self.loader.archive:
return ''
if fspath.startswith(self.zip_pre):
- return fspath[len(self.zip_pre):]
- raise AssertionError(
- "%s is not a subpath of %s" % (fspath, self.zip_pre)
- )
+ return fspath[len(self.zip_pre) :]
+ raise AssertionError("%s is not a subpath of %s" % (fspath, self.zip_pre))
def _parts(self, zip_path):
# Convert a zipfile subpath into an egg-relative path part list.
# pseudo-fs path
fspath = self.zip_pre + zip_path
if fspath.startswith(self.egg_root + os.sep):
- return fspath[len(self.egg_root) + 1:].split(os.sep)
- raise AssertionError(
- "%s is not a subpath of %s" % (fspath, self.egg_root)
- )
+ return fspath[len(self.egg_root) + 1 :].split(os.sep)
+ raise AssertionError("%s is not a subpath of %s" % (fspath, self.egg_root))
@property
def zipinfo(self):
return self._zip_manifests.load(self.loader.archive)
- def get_resource_filename(self, manager, resource_name):
+ def get_resource_filename(self, manager: ResourceManager, resource_name: str):
if not self.egg_name:
raise NotImplementedError(
"resource_filename() only supported for .egg, not .zip"
@@ -1752,26 +2028,26 @@ class ZipProvider(EggProvider):
timestamp = time.mktime(date_time)
return timestamp, size
- def _extract_resource(self, manager, zip_path):
-
+ # FIXME: 'ZipProvider._extract_resource' is too complex (12)
+ def _extract_resource(self, manager: ResourceManager, zip_path) -> str: # noqa: C901
if zip_path in self._index():
for name in self._index()[zip_path]:
- last = self._extract_resource(
- manager, os.path.join(zip_path, name)
- )
+ last = self._extract_resource(manager, os.path.join(zip_path, name))
# return the extracted directory name
return os.path.dirname(last)
timestamp, size = self._get_date_and_size(self.zipinfo[zip_path])
if not WRITE_SUPPORT:
- raise IOError('"os.rename" and "os.unlink" are not supported '
- 'on this platform')
- try:
-
- real_path = manager.get_cache_path(
- self.egg_name, self._parts(zip_path)
+ raise OSError(
+ '"os.rename" and "os.unlink" are not supported on this platform'
)
+ try:
+ if not self.egg_name:
+ raise OSError(
+ '"egg_name" is empty. This likely means no egg could be found from the "module_path".'
+ )
+ real_path = manager.get_cache_path(self.egg_name, self._parts(zip_path))
if self._is_current(real_path, zip_path):
return real_path
@@ -1788,7 +2064,7 @@ class ZipProvider(EggProvider):
try:
rename(tmpnam, real_path)
- except os.error:
+ except OSError:
if os.path.isfile(real_path):
if self._is_current(real_path, zip_path):
# the file became current since it was checked above,
@@ -1801,7 +2077,7 @@ class ZipProvider(EggProvider):
return real_path
raise
- except os.error:
+ except OSError:
# report a user-friendly error
manager.extraction_error()
@@ -1849,20 +2125,20 @@ class ZipProvider(EggProvider):
self._dirindex = ind
return ind
- def _has(self, fspath):
+ def _has(self, fspath) -> bool:
zip_path = self._zipinfo_name(fspath)
return zip_path in self.zipinfo or zip_path in self._index()
- def _isdir(self, fspath):
+ def _isdir(self, fspath) -> bool:
return self._zipinfo_name(fspath) in self._index()
def _listdir(self, fspath):
return list(self._index().get(self._zipinfo_name(fspath), ()))
- def _eager_to_zip(self, resource_name):
+ def _eager_to_zip(self, resource_name: str):
return self._zipinfo_name(self._fn(self.egg_root, resource_name))
- def _resource_to_zip(self, resource_name):
+ def _resource_to_zip(self, resource_name: str):
return self._zipinfo_name(self._fn(self.module_path, resource_name))
@@ -1881,33 +2157,32 @@ class FileMetadata(EmptyProvider):
the provided location.
"""
- def __init__(self, path):
+ def __init__(self, path: StrPath):
self.path = path
def _get_metadata_path(self, name):
return self.path
- def has_metadata(self, name):
+ def has_metadata(self, name: str) -> bool:
return name == 'PKG-INFO' and os.path.isfile(self.path)
- def get_metadata(self, name):
+ def get_metadata(self, name: str):
if name != 'PKG-INFO':
raise KeyError("No metadata except PKG-INFO is available")
- with io.open(self.path, encoding='utf-8', errors="replace") as f:
+ with open(self.path, encoding='utf-8', errors="replace") as f:
metadata = f.read()
self._warn_on_replacement(metadata)
return metadata
def _warn_on_replacement(self, metadata):
- # Python 2.7 compat for: replacement_char = '�'
- replacement_char = b'\xef\xbf\xbd'.decode('utf-8')
+ replacement_char = '�'
if replacement_char in metadata:
tmpl = "{self.path} could not be properly decoded in UTF-8"
msg = tmpl.format(**locals())
warnings.warn(msg)
- def get_metadata_lines(self, name):
+ def get_metadata_lines(self, name: str) -> Iterator[str]:
return yield_lines(self.get_metadata(name))
@@ -1931,7 +2206,7 @@ class PathMetadata(DefaultProvider):
dist = Distribution.from_filename(egg_path, metadata=metadata)
"""
- def __init__(self, path, egg_info):
+ def __init__(self, path: str, egg_info: str):
self.module_path = path
self.egg_info = egg_info
@@ -1939,7 +2214,7 @@ class PathMetadata(DefaultProvider):
class EggMetadata(ZipProvider):
"""Metadata provider for .egg files"""
- def __init__(self, importer):
+ def __init__(self, importer: zipimport.zipimporter):
"""Create a metadata provider from a zipimporter"""
self.zip_pre = importer.archive + os.sep
@@ -1951,10 +2226,12 @@ class EggMetadata(ZipProvider):
self._setup_prefix()
-_declare_state('dict', _distribution_finders={})
+_distribution_finders: dict[type, _DistFinderType[Any]] = _declare_state(
+ 'dict', '_distribution_finders', {}
+)
-def register_finder(importer_type, distribution_finder):
+def register_finder(importer_type: type[_T], distribution_finder: _DistFinderType[_T]):
"""Register `distribution_finder` to find distributions in sys.path items
`importer_type` is the type or class of a PEP 302 "Importer" (sys.path item
@@ -1964,14 +2241,16 @@ def register_finder(importer_type, distribution_finder):
_distribution_finders[importer_type] = distribution_finder
-def find_distributions(path_item, only=False):
+def find_distributions(path_item: str, only: bool = False):
"""Yield distributions accessible via `path_item`"""
importer = get_importer(path_item)
finder = _find_adapter(_distribution_finders, importer)
return finder(importer, path_item, only)
-def find_eggs_in_zip(importer, path_item, only=False):
+def find_eggs_in_zip(
+ importer: zipimport.zipimporter, path_item: str, only: bool = False
+) -> Iterator[Distribution]:
"""
Find eggs in zip files; possibly multiple nested eggs.
"""
@@ -1989,9 +2268,8 @@ def find_eggs_in_zip(importer, path_item, only=False):
if _is_egg_path(subitem):
subpath = os.path.join(path_item, subitem)
dists = find_eggs_in_zip(zipimport.zipimporter(subpath), subpath)
- for dist in dists:
- yield dist
- elif subitem.lower().endswith('.dist-info'):
+ yield from dists
+ elif subitem.lower().endswith(('.dist-info', '.egg-info')):
subpath = os.path.join(path_item, subitem)
submeta = EggMetadata(zipimport.zipimporter(subpath))
submeta.egg_info = subpath
@@ -2001,85 +2279,51 @@ def find_eggs_in_zip(importer, path_item, only=False):
register_finder(zipimport.zipimporter, find_eggs_in_zip)
-def find_nothing(importer, path_item, only=False):
+def find_nothing(
+ importer: object | None, path_item: str | None, only: bool | None = False
+):
return ()
register_finder(object, find_nothing)
-def _by_version_descending(names):
- """
- Given a list of filenames, return them in descending order
- by version number.
-
- >>> names = 'bar', 'foo', 'Python-2.7.10.egg', 'Python-2.7.2.egg'
- >>> _by_version_descending(names)
- ['Python-2.7.10.egg', 'Python-2.7.2.egg', 'foo', 'bar']
- >>> names = 'Setuptools-1.2.3b1.egg', 'Setuptools-1.2.3.egg'
- >>> _by_version_descending(names)
- ['Setuptools-1.2.3.egg', 'Setuptools-1.2.3b1.egg']
- >>> names = 'Setuptools-1.2.3b1.egg', 'Setuptools-1.2.3.post1.egg'
- >>> _by_version_descending(names)
- ['Setuptools-1.2.3.post1.egg', 'Setuptools-1.2.3b1.egg']
- """
- def _by_version(name):
- """
- Parse each component of the filename
- """
- name, ext = os.path.splitext(name)
- parts = itertools.chain(name.split('-'), [ext])
- return [packaging.version.parse(part) for part in parts]
-
- return sorted(names, key=_by_version, reverse=True)
-
-
-def find_on_path(importer, path_item, only=False):
+def find_on_path(importer: object | None, path_item, only=False):
"""Yield distributions accessible on a sys.path directory"""
path_item = _normalize_cached(path_item)
if _is_unpacked_egg(path_item):
yield Distribution.from_filename(
- path_item, metadata=PathMetadata(
- path_item, os.path.join(path_item, 'EGG-INFO')
- )
+ path_item,
+ metadata=PathMetadata(path_item, os.path.join(path_item, 'EGG-INFO')),
)
return
- entries = safe_listdir(path_item)
-
- # for performance, before sorting by version,
- # screen entries for only those that will yield
- # distributions
- filtered = (
- entry
- for entry in entries
- if dist_factory(path_item, entry, only)
- )
+ entries = (os.path.join(path_item, child) for child in safe_listdir(path_item))
# scan for .egg and .egg-info in directory
- path_item_entries = _by_version_descending(filtered)
- for entry in path_item_entries:
+ for entry in sorted(entries):
fullpath = os.path.join(path_item, entry)
factory = dist_factory(path_item, entry, only)
- for dist in factory(fullpath):
- yield dist
+ yield from factory(fullpath)
def dist_factory(path_item, entry, only):
- """
- Return a dist_factory for a path_item and entry
- """
+ """Return a dist_factory for the given entry."""
lower = entry.lower()
- is_meta = any(map(lower.endswith, ('.egg-info', '.dist-info')))
+ is_egg_info = lower.endswith('.egg-info')
+ is_dist_info = lower.endswith('.dist-info') and os.path.isdir(
+ os.path.join(path_item, entry)
+ )
+ is_meta = is_egg_info or is_dist_info
return (
distributions_from_metadata
- if is_meta else
- find_distributions
- if not only and _is_egg_path(entry) else
- resolve_egg_link
- if not only and lower.endswith('.egg-link') else
- NoDists()
+ if is_meta
+ else find_distributions
+ if not only and _is_egg_path(entry)
+ else resolve_egg_link
+ if not only and lower.endswith('.egg-link')
+ else NoDists()
)
@@ -2091,16 +2335,15 @@ class NoDists:
>>> list(NoDists()('anything'))
[]
"""
+
def __bool__(self):
return False
- if six.PY2:
- __nonzero__ = __bool__
def __call__(self, fullpath):
return iter(())
-def safe_listdir(path):
+def safe_listdir(path: StrOrBytesPath):
"""
Attempt to list contents of path, but suppress some exceptions.
"""
@@ -2111,28 +2354,26 @@ def safe_listdir(path):
except OSError as e:
# Ignore the directory if does not exist, not a directory or
# permission denied
- ignorable = (
- e.errno in (errno.ENOTDIR, errno.EACCES, errno.ENOENT)
- # Python 2 on Windows needs to be handled this way :(
- or getattr(e, "winerror", None) == 267
- )
- if not ignorable:
+ if e.errno not in (errno.ENOTDIR, errno.EACCES, errno.ENOENT):
raise
return ()
-def distributions_from_metadata(path):
+def distributions_from_metadata(path: str):
root = os.path.dirname(path)
if os.path.isdir(path):
if len(os.listdir(path)) == 0:
# empty metadata dir; skip
return
- metadata = PathMetadata(root, path)
+ metadata: _MetadataType = PathMetadata(root, path)
else:
metadata = FileMetadata(path)
entry = os.path.basename(path)
yield Distribution.from_location(
- root, entry, metadata, precedence=DEVELOP_DIST,
+ root,
+ entry,
+ metadata,
+ precedence=DEVELOP_DIST,
)
@@ -2140,11 +2381,10 @@ def non_empty_lines(path):
"""
Yield non-empty lines from file at path
"""
- with open(path) as f:
- for line in f:
- line = line.strip()
- if line:
- yield line
+ for line in _read_utf8_with_fallback(path).splitlines():
+ line = line.strip()
+ if line:
+ yield line
def resolve_egg_link(path):
@@ -2154,23 +2394,28 @@ def resolve_egg_link(path):
"""
referenced_paths = non_empty_lines(path)
resolved_paths = (
- os.path.join(os.path.dirname(path), ref)
- for ref in referenced_paths
+ os.path.join(os.path.dirname(path), ref) for ref in referenced_paths
)
dist_groups = map(find_distributions, resolved_paths)
return next(dist_groups, ())
-register_finder(pkgutil.ImpImporter, find_on_path)
+if hasattr(pkgutil, 'ImpImporter'):
+ register_finder(pkgutil.ImpImporter, find_on_path)
-if hasattr(importlib_machinery, 'FileFinder'):
- register_finder(importlib_machinery.FileFinder, find_on_path)
+register_finder(importlib.machinery.FileFinder, find_on_path)
-_declare_state('dict', _namespace_handlers={})
-_declare_state('dict', _namespace_packages={})
+_namespace_handlers: dict[type, _NSHandlerType[Any]] = _declare_state(
+ 'dict', '_namespace_handlers', {}
+)
+_namespace_packages: dict[str | None, list[str]] = _declare_state(
+ 'dict', '_namespace_packages', {}
+)
-def register_namespace_handler(importer_type, namespace_handler):
+def register_namespace_handler(
+ importer_type: type[_T], namespace_handler: _NSHandlerType[_T]
+):
"""Register `namespace_handler` to declare namespace packages
`importer_type` is the type or class of a PEP 302 "Importer" (sys.path item
@@ -2195,10 +2440,16 @@ def _handle_ns(packageName, path_item):
if importer is None:
return None
- # capture warnings due to #1111
- with warnings.catch_warnings():
- warnings.simplefilter("ignore")
- loader = importer.find_module(packageName)
+ # use find_spec (PEP 451) and fall-back to find_module (PEP 302)
+ try:
+ spec = importer.find_spec(packageName)
+ except AttributeError:
+ # capture warnings due to #1111
+ with warnings.catch_warnings():
+ warnings.simplefilter("ignore")
+ loader = importer.find_module(packageName)
+ else:
+ loader = spec.loader if spec else None
if loader is None:
return None
@@ -2214,12 +2465,12 @@ def _handle_ns(packageName, path_item):
if subpath is not None:
path = module.__path__
path.append(subpath)
- loader.load_module(packageName)
+ importlib.import_module(packageName)
_rebuild_mod_path(path, packageName, module)
return subpath
-def _rebuild_mod_path(orig_path, package_name, module):
+def _rebuild_mod_path(orig_path, package_name, module: types.ModuleType):
"""
Rebuild module.__path__ ensuring that all entries are ordered
corresponding to their sys.path order
@@ -2253,15 +2504,24 @@ def _rebuild_mod_path(orig_path, package_name, module):
module.__path__ = new_path
-def declare_namespace(packageName):
+def declare_namespace(packageName: str):
"""Declare that package 'packageName' is a namespace package"""
+ msg = (
+ f"Deprecated call to `pkg_resources.declare_namespace({packageName!r})`.\n"
+ "Implementing implicit namespace packages (as specified in PEP 420) "
+ "is preferred to `pkg_resources.declare_namespace`. "
+ "See https://setuptools.pypa.io/en/latest/references/"
+ "keywords.html#keyword-namespace-packages"
+ )
+ warnings.warn(msg, DeprecationWarning, stacklevel=2)
+
_imp.acquire_lock()
try:
if packageName in _namespace_packages:
return
- path = sys.path
+ path: MutableSequence[str] = sys.path
parent, _, _ = packageName.rpartition('.')
if parent:
@@ -2270,8 +2530,8 @@ def declare_namespace(packageName):
__import__(parent)
try:
path = sys.modules[parent].__path__
- except AttributeError:
- raise TypeError("Not a package:", parent)
+ except AttributeError as e:
+ raise TypeError("Not a package:", parent) from e
# Track what packages are namespaces, so when new path items are added,
# they can be updated
@@ -2287,7 +2547,7 @@ def declare_namespace(packageName):
_imp.release_lock()
-def fixup_namespace_packages(path_item, parent=None):
+def fixup_namespace_packages(path_item: str, parent: str | None = None):
"""Ensure that previously-declared namespace packages include path_item"""
_imp.acquire_lock()
try:
@@ -2299,7 +2559,12 @@ def fixup_namespace_packages(path_item, parent=None):
_imp.release_lock()
-def file_ns_handler(importer, path_item, packageName, module):
+def file_ns_handler(
+ importer: object,
+ path_item: StrPath,
+ packageName: str,
+ module: types.ModuleType,
+):
"""Compute an ns-package subpath for a filesystem or zipfile importer"""
subpath = os.path.join(path_item, packageName.split('.')[-1])
@@ -2312,26 +2577,35 @@ def file_ns_handler(importer, path_item, packageName, module):
return subpath
-register_namespace_handler(pkgutil.ImpImporter, file_ns_handler)
+if hasattr(pkgutil, 'ImpImporter'):
+ register_namespace_handler(pkgutil.ImpImporter, file_ns_handler)
+
register_namespace_handler(zipimport.zipimporter, file_ns_handler)
-
-if hasattr(importlib_machinery, 'FileFinder'):
- register_namespace_handler(importlib_machinery.FileFinder, file_ns_handler)
+register_namespace_handler(importlib.machinery.FileFinder, file_ns_handler)
-def null_ns_handler(importer, path_item, packageName, module):
+def null_ns_handler(
+ importer: object,
+ path_item: str | None,
+ packageName: str | None,
+ module: _ModuleLike | None,
+):
return None
register_namespace_handler(object, null_ns_handler)
-def normalize_path(filename):
+@overload
+def normalize_path(filename: StrPath) -> str: ...
+@overload
+def normalize_path(filename: BytesPath) -> bytes: ...
+def normalize_path(filename: StrOrBytesPath):
"""Normalize a file/dir name for comparison purposes"""
return os.path.normcase(os.path.realpath(os.path.normpath(_cygwin_patch(filename))))
-def _cygwin_patch(filename): # pragma: nocover
+def _cygwin_patch(filename: StrOrBytesPath): # pragma: nocover
"""
Contrary to POSIX 2008, on Cygwin, getcwd (3) contains
symlink components. Using
@@ -2342,28 +2616,42 @@ def _cygwin_patch(filename): # pragma: nocover
return os.path.abspath(filename) if sys.platform == 'cygwin' else filename
-def _normalize_cached(filename, _cache={}):
- try:
- return _cache[filename]
- except KeyError:
- _cache[filename] = result = normalize_path(filename)
- return result
+if TYPE_CHECKING:
+ # https://github.com/python/mypy/issues/16261
+ # https://github.com/python/typeshed/issues/6347
+ @overload
+ def _normalize_cached(filename: StrPath) -> str: ...
+ @overload
+ def _normalize_cached(filename: BytesPath) -> bytes: ...
+ def _normalize_cached(filename: StrOrBytesPath) -> str | bytes: ...
+else:
+
+ @functools.lru_cache(maxsize=None)
+ def _normalize_cached(filename):
+ return normalize_path(filename)
def _is_egg_path(path):
"""
Determine if given path appears to be an egg.
"""
- return path.lower().endswith('.egg')
+ return _is_zip_egg(path) or _is_unpacked_egg(path)
+
+
+def _is_zip_egg(path):
+ return (
+ path.lower().endswith('.egg')
+ and os.path.isfile(path)
+ and zipfile.is_zipfile(path)
+ )
def _is_unpacked_egg(path):
"""
Determine if given path appears to be an unpacked egg.
"""
- return (
- _is_egg_path(path) and
- os.path.isfile(os.path.join(path, 'EGG-INFO', 'PKG-INFO'))
+ return path.lower().endswith('.egg') and os.path.isfile(
+ os.path.join(path, 'EGG-INFO', 'PKG-INFO')
)
@@ -2375,20 +2663,6 @@ def _set_parent_ns(packageName):
setattr(sys.modules[parent], name, sys.modules[packageName])
-def yield_lines(strs):
- """Yield non-empty/non-comment lines of a string or sequence"""
- if isinstance(strs, six.string_types):
- for s in strs.splitlines():
- s = s.strip()
- # skip blank lines/comments
- if s and not s.startswith('#'):
- yield s
- else:
- for ss in strs:
- for s in yield_lines(ss):
- yield s
-
-
MODULE = re.compile(r"\w+(\.\w+)*$").match
EGG_NAME = re.compile(
r"""
@@ -2407,7 +2681,14 @@ EGG_NAME = re.compile(
class EntryPoint:
"""Object representing an advertised importable object"""
- def __init__(self, name, module_name, attrs=(), extras=(), dist=None):
+ def __init__(
+ self,
+ name: str,
+ module_name: str,
+ attrs: Iterable[str] = (),
+ extras: Iterable[str] = (),
+ dist: Distribution | None = None,
+ ):
if not MODULE(module_name):
raise ValueError("Invalid module name", module_name)
self.name = name
@@ -2427,7 +2708,26 @@ class EntryPoint:
def __repr__(self):
return "EntryPoint.parse(%r)" % str(self)
- def load(self, require=True, *args, **kwargs):
+ @overload
+ def load(
+ self,
+ require: Literal[True] = True,
+ env: Environment | None = None,
+ installer: _InstallerType | None = None,
+ ) -> _ResolvedEntryPoint: ...
+ @overload
+ def load(
+ self,
+ require: Literal[False],
+ *args: Any,
+ **kwargs: Any,
+ ) -> _ResolvedEntryPoint: ...
+ def load(
+ self,
+ require: bool = True,
+ *args: Environment | _InstallerType | None,
+ **kwargs: Environment | _InstallerType | None,
+ ) -> _ResolvedEntryPoint:
"""
Require packages for this EntryPoint, then resolve it.
"""
@@ -2439,10 +2739,12 @@ class EntryPoint:
stacklevel=2,
)
if require:
- self.require(*args, **kwargs)
+ # We could pass `env` and `installer` directly,
+ # but keeping `*args` and `**kwargs` for backwards compatibility
+ self.require(*args, **kwargs) # type: ignore
return self.resolve()
- def resolve(self):
+ def resolve(self) -> _ResolvedEntryPoint:
"""
Resolve the entry point from its module and attrs.
"""
@@ -2450,11 +2752,16 @@ class EntryPoint:
try:
return functools.reduce(getattr, self.attrs, module)
except AttributeError as exc:
- raise ImportError(str(exc))
+ raise ImportError(str(exc)) from exc
- def require(self, env=None, installer=None):
- if self.extras and not self.dist:
- raise UnknownExtra("Can't require() without a distribution", self)
+ def require(
+ self,
+ env: Environment | None = None,
+ installer: _InstallerType | None = None,
+ ):
+ if not self.dist:
+ error_cls = UnknownExtra if self.extras else AttributeError
+ raise error_cls("Can't require() without a distribution", self)
# Get the requirements for this entry point with all its extras and
# then resolve them. We have to pass `extras` along when resolving so
@@ -2475,7 +2782,7 @@ class EntryPoint:
)
@classmethod
- def parse(cls, src, dist=None):
+ def parse(cls, src: str, dist: Distribution | None = None):
"""Parse a single entry point from string `src`
Entry point syntax follows the form::
@@ -2500,15 +2807,20 @@ class EntryPoint:
return ()
req = Requirement.parse('x' + extras_spec)
if req.specs:
- raise ValueError()
+ raise ValueError
return req.extras
@classmethod
- def parse_group(cls, group, lines, dist=None):
+ def parse_group(
+ cls,
+ group: str,
+ lines: _NestedStr,
+ dist: Distribution | None = None,
+ ):
"""Parse an entry point group"""
if not MODULE(group):
raise ValueError("Invalid group name", group)
- this = {}
+ this: dict[str, Self] = {}
for line in yield_lines(lines):
ep = cls.parse(line, dist)
if ep.name in this:
@@ -2517,14 +2829,19 @@ class EntryPoint:
return this
@classmethod
- def parse_map(cls, data, dist=None):
+ def parse_map(
+ cls,
+ data: str | Iterable[str] | dict[str, str | Iterable[str]],
+ dist: Distribution | None = None,
+ ):
"""Parse a map of entry point groups"""
+ _data: Iterable[tuple[str | None, str | Iterable[str]]]
if isinstance(data, dict):
- data = data.items()
+ _data = data.items()
else:
- data = split_sections(data)
- maps = {}
- for group, lines in data:
+ _data = split_sections(data)
+ maps: dict[str, dict[str, Self]] = {}
+ for group, lines in _data:
if group is None:
if not lines:
continue
@@ -2536,22 +2853,15 @@ class EntryPoint:
return maps
-def _remove_md5_fragment(location):
- if not location:
- return ''
- parsed = urllib.parse.urlparse(location)
- if parsed[-1].startswith('md5='):
- return urllib.parse.urlunparse(parsed[:-1] + ('',))
- return location
-
-
def _version_from_file(lines):
"""
Given an iterable of lines from a Metadata file, return
the value of the Version field, if present, or None otherwise.
"""
+
def is_version_line(line):
return line.lower().startswith('version:')
+
version_lines = filter(is_version_line, lines)
line = next(iter(version_lines), '')
_, _, value = line.partition(':')
@@ -2560,12 +2870,19 @@ def _version_from_file(lines):
class Distribution:
"""Wrap an actual or potential sys.path entry w/metadata"""
+
PKG_INFO = 'PKG-INFO'
def __init__(
- self, location=None, metadata=None, project_name=None,
- version=None, py_version=PY_MAJOR, platform=None,
- precedence=EGG_DIST):
+ self,
+ location: str | None = None,
+ metadata: _MetadataType = None,
+ project_name: str | None = None,
+ version: str | None = None,
+ py_version: str | None = PY_MAJOR,
+ platform: str | None = None,
+ precedence: int = EGG_DIST,
+ ):
self.project_name = safe_name(project_name or 'Unknown')
if version is not None:
self._version = safe_version(version)
@@ -2576,7 +2893,13 @@ class Distribution:
self._provider = metadata or empty_provider
@classmethod
- def from_location(cls, location, basename, metadata=None, **kw):
+ def from_location(
+ cls,
+ location: str,
+ basename: StrPath,
+ metadata: _MetadataType = None,
+ **kw: int, # We could set `precedence` explicitly, but keeping this as `**kw` for full backwards and subclassing compatibility
+ ) -> Distribution:
project_name, version, py_version, platform = [None] * 4
basename, ext = os.path.splitext(basename)
if ext.lower() in _distributionImpl:
@@ -2588,8 +2911,13 @@ class Distribution:
'name', 'ver', 'pyver', 'plat'
)
return cls(
- location, metadata, project_name=project_name, version=version,
- py_version=py_version, platform=platform, **kw
+ location,
+ metadata,
+ project_name=project_name,
+ version=version,
+ py_version=py_version,
+ platform=platform,
+ **kw,
)._reload_version()
def _reload_version(self):
@@ -2598,10 +2926,10 @@ class Distribution:
@property
def hashcmp(self):
return (
- self.parsed_version,
+ self._forgiving_parsed_version,
self.precedence,
self.key,
- _remove_md5_fragment(self.location),
+ self.location,
self.py_version or '',
self.platform or '',
)
@@ -2609,25 +2937,25 @@ class Distribution:
def __hash__(self):
return hash(self.hashcmp)
- def __lt__(self, other):
+ def __lt__(self, other: Distribution):
return self.hashcmp < other.hashcmp
- def __le__(self, other):
+ def __le__(self, other: Distribution):
return self.hashcmp <= other.hashcmp
- def __gt__(self, other):
+ def __gt__(self, other: Distribution):
return self.hashcmp > other.hashcmp
- def __ge__(self, other):
+ def __ge__(self, other: Distribution):
return self.hashcmp >= other.hashcmp
- def __eq__(self, other):
+ def __eq__(self, other: object):
if not isinstance(other, self.__class__):
# It's not a Distribution, so they are not equal
return False
return self.hashcmp == other.hashcmp
- def __ne__(self, other):
+ def __ne__(self, other: object):
return not self == other
# These properties have to be lazy so that we don't have to load any
@@ -2645,48 +2973,55 @@ class Distribution:
@property
def parsed_version(self):
if not hasattr(self, "_parsed_version"):
- self._parsed_version = parse_version(self.version)
+ try:
+ self._parsed_version = parse_version(self.version)
+ except _packaging_version.InvalidVersion as ex:
+ info = f"(package: {self.project_name})"
+ if hasattr(ex, "add_note"):
+ ex.add_note(info) # PEP 678
+ raise
+ raise _packaging_version.InvalidVersion(f"{str(ex)} {info}") from None
return self._parsed_version
- def _warn_legacy_version(self):
- LV = packaging.version.LegacyVersion
- is_legacy = isinstance(self._parsed_version, LV)
- if not is_legacy:
- return
+ @property
+ def _forgiving_parsed_version(self):
+ try:
+ return self.parsed_version
+ except _packaging_version.InvalidVersion as ex:
+ self._parsed_version = parse_version(_forgiving_version(self.version))
- # While an empty version is technically a legacy version and
- # is not a valid PEP 440 version, it's also unlikely to
- # actually come from someone and instead it is more likely that
- # it comes from setuptools attempting to parse a filename and
- # including it in the list. So for that we'll gate this warning
- # on if the version is anything at all or not.
- if not self.version:
- return
+ notes = "\n".join(getattr(ex, "__notes__", [])) # PEP 678
+ msg = f"""!!\n\n
+ *************************************************************************
+ {str(ex)}\n{notes}
- tmpl = textwrap.dedent("""
- '{project_name} ({version})' is being parsed as a legacy,
- non PEP 440,
- version. You may find odd behavior and sort order.
- In particular it will be sorted as less than 0.0. It
- is recommended to migrate to PEP 440 compatible
- versions.
- """).strip().replace('\n', ' ')
+ This is a long overdue deprecation.
+ For the time being, `pkg_resources` will use `{self._parsed_version}`
+ as a replacement to avoid breaking existing environments,
+ but no future compatibility is guaranteed.
- warnings.warn(tmpl.format(**vars(self)), PEP440Warning)
+ If you maintain package {self.project_name} you should implement
+ the relevant changes to adequate the project to PEP 440 immediately.
+ *************************************************************************
+ \n\n!!
+ """
+ warnings.warn(msg, DeprecationWarning)
+
+ return self._parsed_version
@property
def version(self):
try:
return self._version
- except AttributeError:
+ except AttributeError as e:
version = self._get_version()
if version is None:
path = self._get_metadata_path_for_display(self.PKG_INFO)
- msg = (
- "Missing 'Version:' header and/or {} file at path: {}"
- ).format(self.PKG_INFO, path)
- raise ValueError(msg, self)
+ msg = ("Missing 'Version:' header and/or {} file at path: {}").format(
+ self.PKG_INFO, path
+ )
+ raise ValueError(msg, self) from e
return version
@@ -2703,19 +3038,18 @@ class Distribution:
return self.__dep_map
@staticmethod
- def _filter_extras(dm):
+ def _filter_extras(dm: dict[str | None, list[Requirement]]):
"""
Given a mapping of extras to dependencies, strip off
environment markers and filter out any dependencies
not matching the markers.
"""
for extra in list(filter(None, dm)):
- new_extra = extra
+ new_extra: str | None = extra
reqs = dm.pop(extra)
new_extra, _, marker = extra.partition(':')
fails_marker = marker and (
- invalid_marker(marker)
- or not evaluate_marker(marker)
+ invalid_marker(marker) or not evaluate_marker(marker)
)
if fails_marker:
reqs = []
@@ -2731,18 +3065,18 @@ class Distribution:
dm.setdefault(extra, []).extend(parse_requirements(reqs))
return dm
- def requires(self, extras=()):
+ def requires(self, extras: Iterable[str] = ()):
"""List of Requirements needed for this distro if `extras` are used"""
dm = self._dep_map
- deps = []
+ deps: list[Requirement] = []
deps.extend(dm.get(None, ()))
for ext in extras:
try:
deps.extend(dm[safe_extra(ext)])
- except KeyError:
+ except KeyError as e:
raise UnknownExtra(
"%s has no such extra feature %r" % (self, ext)
- )
+ ) from e
return deps
def _get_metadata_path_for_display(self, name):
@@ -2764,21 +3098,18 @@ class Distribution:
def _get_metadata(self, name):
if self.has_metadata(name):
- for line in self.get_metadata_lines(name):
- yield line
+ yield from self.get_metadata_lines(name)
def _get_version(self):
lines = self._get_metadata(self.PKG_INFO)
- version = _version_from_file(lines)
+ return _version_from_file(lines)
- return version
-
- def activate(self, path=None, replace=False):
+ def activate(self, path: list[str] | None = None, replace: bool = False):
"""Ensure distribution is importable on `path` (default=sys.path)"""
if path is None:
path = sys.path
self.insert_on(path, replace=replace)
- if path is sys.path:
+ if path is sys.path and self.location is not None:
fixup_namespace_packages(self.location)
for pkg in self._get_metadata('namespace_packages.txt'):
if pkg in sys.modules:
@@ -2787,8 +3118,9 @@ class Distribution:
def egg_name(self):
"""Return what this distribution's standard .egg filename should be"""
filename = "%s-%s-py%s" % (
- to_filename(self.project_name), to_filename(self.version),
- self.py_version or PY_MAJOR
+ to_filename(self.project_name),
+ to_filename(self.version),
+ self.py_version or PY_MAJOR,
)
if self.platform:
@@ -2817,57 +3149,62 @@ class Distribution:
def __dir__(self):
return list(
- set(super(Distribution, self).__dir__())
- | set(
- attr for attr in self._provider.__dir__()
- if not attr.startswith('_')
- )
+ set(super().__dir__())
+ | set(attr for attr in self._provider.__dir__() if not attr.startswith('_'))
)
- if not hasattr(object, '__dir__'):
- # python 2.7 not supported
- del __dir__
-
@classmethod
- def from_filename(cls, filename, metadata=None, **kw):
+ def from_filename(
+ cls,
+ filename: StrPath,
+ metadata: _MetadataType = None,
+ **kw: int, # We could set `precedence` explicitly, but keeping this as `**kw` for full backwards and subclassing compatibility
+ ):
return cls.from_location(
- _normalize_cached(filename), os.path.basename(filename), metadata,
- **kw
+ _normalize_cached(filename), os.path.basename(filename), metadata, **kw
)
def as_requirement(self):
"""Return a ``Requirement`` that matches this distribution exactly"""
- if isinstance(self.parsed_version, packaging.version.Version):
+ if isinstance(self.parsed_version, _packaging_version.Version):
spec = "%s==%s" % (self.project_name, self.parsed_version)
else:
spec = "%s===%s" % (self.project_name, self.parsed_version)
return Requirement.parse(spec)
- def load_entry_point(self, group, name):
+ def load_entry_point(self, group: str, name: str) -> _ResolvedEntryPoint:
"""Return the `name` entry point of `group` or raise ImportError"""
ep = self.get_entry_info(group, name)
if ep is None:
raise ImportError("Entry point %r not found" % ((group, name),))
return ep.load()
- def get_entry_map(self, group=None):
+ @overload
+ def get_entry_map(self, group: None = None) -> dict[str, dict[str, EntryPoint]]: ...
+ @overload
+ def get_entry_map(self, group: str) -> dict[str, EntryPoint]: ...
+ def get_entry_map(self, group: str | None = None):
"""Return the entry point map for `group`, or the full entry map"""
- try:
- ep_map = self._ep_map
- except AttributeError:
- ep_map = self._ep_map = EntryPoint.parse_map(
+ if not hasattr(self, "_ep_map"):
+ self._ep_map = EntryPoint.parse_map(
self._get_metadata('entry_points.txt'), self
)
if group is not None:
- return ep_map.get(group, {})
- return ep_map
+ return self._ep_map.get(group, {})
+ return self._ep_map
- def get_entry_info(self, group, name):
+ def get_entry_info(self, group: str, name: str):
"""Return the EntryPoint object for `group`+`name`, or ``None``"""
return self.get_entry_map(group).get(name)
- def insert_on(self, path, loc=None, replace=False):
+ # FIXME: 'Distribution.insert_on' is too complex (13)
+ def insert_on( # noqa: C901
+ self,
+ path: list[str],
+ loc=None,
+ replace: bool = False,
+ ):
"""Ensure self.location is on path
If replace=False (default):
@@ -2943,14 +3280,18 @@ class Distribution:
nsp = dict.fromkeys(self._get_metadata('namespace_packages.txt'))
loc = normalize_path(self.location)
for modname in self._get_metadata('top_level.txt'):
- if (modname not in sys.modules or modname in nsp
- or modname in _namespace_packages):
+ if (
+ modname not in sys.modules
+ or modname in nsp
+ or modname in _namespace_packages
+ ):
continue
if modname in ('pkg_resources', 'setuptools', 'site'):
continue
fn = getattr(sys.modules[modname], '__file__', None)
- if fn and (normalize_path(fn).startswith(loc) or
- fn.startswith(self.location)):
+ if fn and (
+ normalize_path(fn).startswith(loc) or fn.startswith(self.location)
+ ):
continue
issue_warning(
"Module %s was already imported from %s, but %s is being added"
@@ -2963,15 +3304,19 @@ class Distribution:
except ValueError:
issue_warning("Unbuilt egg for " + repr(self))
return False
+ except SystemError:
+ # TODO: remove this except clause when python/cpython#103632 is fixed.
+ return False
return True
- def clone(self, **kw):
+ def clone(self, **kw: str | int | IResourceProvider | None):
"""Copy this distribution, substituting in any changed keyword args"""
names = 'project_name version py_version platform location precedence'
for attr in names.split():
kw.setdefault(attr, getattr(self, attr, None))
kw.setdefault('metadata', self._provider)
- return self.__class__(**kw)
+ # Unsafely unpacking. But keeping **kw for backwards and subclassing compatibility
+ return self.__class__(**kw) # type:ignore[arg-type]
@property
def extras(self):
@@ -3002,6 +3347,7 @@ class DistInfoDistribution(Distribution):
Wrap an actual or potential sys.path entry
w/metadata, .dist-info style.
"""
+
PKG_INFO = 'METADATA'
EQEQ = re.compile(r"([\(,])\s*(\d.*?)\s*([,\)])")
@@ -3023,11 +3369,11 @@ class DistInfoDistribution(Distribution):
self.__dep_map = self._compute_dependencies()
return self.__dep_map
- def _compute_dependencies(self):
+ def _compute_dependencies(self) -> dict[str | None, list[Requirement]]:
"""Recompute this distribution's dependencies."""
- dm = self.__dep_map = {None: []}
+ self.__dep_map: dict[str | None, list[Requirement]] = {None: []}
- reqs = []
+ reqs: list[Requirement] = []
# Including any condition expressions
for req in self._parsed_pkg_info.get_all('Requires-Dist') or []:
reqs.extend(parse_requirements(req))
@@ -3037,14 +3383,16 @@ class DistInfoDistribution(Distribution):
if not req.marker or req.marker.evaluate({'extra': extra}):
yield req
- common = frozenset(reqs_for_extra(None))
- dm[None].extend(common)
+ common = types.MappingProxyType(dict.fromkeys(reqs_for_extra(None)))
+ self.__dep_map[None].extend(common)
for extra in self._parsed_pkg_info.get_all('Provides-Extra') or []:
s_extra = safe_extra(extra.strip())
- dm[s_extra] = list(frozenset(reqs_for_extra(extra)) - common)
+ self.__dep_map[s_extra] = [
+ r for r in reqs_for_extra(extra) if r not in common
+ ]
- return dm
+ return self.__dep_map
_distributionImpl = {
@@ -3067,46 +3415,29 @@ def issue_warning(*args, **kw):
warnings.warn(stacklevel=level + 1, *args, **kw)
-class RequirementParseError(ValueError):
- def __str__(self):
- return ' '.join(self.args)
-
-
-def parse_requirements(strs):
- """Yield ``Requirement`` objects for each specification in `strs`
+def parse_requirements(strs: _NestedStr):
+ """
+ Yield ``Requirement`` objects for each specification in `strs`.
`strs` must be a string, or a (possibly-nested) iterable thereof.
"""
- # create a steppable iterator, so we can handle \-continuations
- lines = iter(yield_lines(strs))
-
- for line in lines:
- # Drop comments -- a hash without a space may be in a URL.
- if ' #' in line:
- line = line[:line.find(' #')]
- # If there is a line continuation, drop it, and append the next line.
- if line.endswith('\\'):
- line = line[:-2].strip()
- try:
- line += next(lines)
- except StopIteration:
- return
- yield Requirement(line)
+ return map(Requirement, join_continuation(map(drop_comment, yield_lines(strs))))
-class Requirement(packaging.requirements.Requirement):
- def __init__(self, requirement_string):
+class RequirementParseError(_packaging_requirements.InvalidRequirement):
+ "Compatibility wrapper for InvalidRequirement"
+
+
+class Requirement(_packaging_requirements.Requirement):
+ def __init__(self, requirement_string: str):
"""DO NOT CALL THIS UNDOCUMENTED METHOD; use Requirement.parse()!"""
- try:
- super(Requirement, self).__init__(requirement_string)
- except packaging.requirements.InvalidRequirement as e:
- raise RequirementParseError(str(e))
+ super().__init__(requirement_string)
self.unsafe_name = self.name
project_name = safe_name(self.name)
self.project_name, self.key = project_name, project_name.lower()
- self.specs = [
- (spec.operator, spec.version) for spec in self.specifier]
- self.extras = tuple(map(safe_extra, self.extras))
+ self.specs = [(spec.operator, spec.version) for spec in self.specifier]
+ # packaging.requirements.Requirement uses a set for its extras. We use a variable-length tuple
+ self.extras: tuple[str] = tuple(map(safe_extra, self.extras))
self.hashCmp = (
self.key,
self.url,
@@ -3116,16 +3447,13 @@ class Requirement(packaging.requirements.Requirement):
)
self.__hash = hash(self.hashCmp)
- def __eq__(self, other):
- return (
- isinstance(other, Requirement) and
- self.hashCmp == other.hashCmp
- )
+ def __eq__(self, other: object):
+ return isinstance(other, Requirement) and self.hashCmp == other.hashCmp
def __ne__(self, other):
return not self == other
- def __contains__(self, item):
+ def __contains__(self, item: Distribution | str | tuple[str, ...]) -> bool:
if isinstance(item, Distribution):
if item.key != self.key:
return False
@@ -3144,8 +3472,8 @@ class Requirement(packaging.requirements.Requirement):
return "Requirement.parse(%r)" % str(self)
@staticmethod
- def parse(s):
- req, = parse_requirements(s)
+ def parse(s: str | Iterable[str]):
+ (req,) = parse_requirements(s)
return req
@@ -3159,24 +3487,27 @@ def _always_object(classes):
return classes
-def _find_adapter(registry, ob):
+def _find_adapter(registry: Mapping[type, _AdapterT], ob: object) -> _AdapterT:
"""Return an adapter factory for `ob` from `registry`"""
types = _always_object(inspect.getmro(getattr(ob, '__class__', type(ob))))
for t in types:
if t in registry:
return registry[t]
+ # _find_adapter would previously return None, and immediately be called.
+ # So we're raising a TypeError to keep backward compatibility if anyone depended on that behaviour.
+ raise TypeError(f"Could not find adapter for {registry} and {ob}")
-def ensure_directory(path):
+def ensure_directory(path: StrOrBytesPath):
"""Ensure that the parent directory of `path` exists"""
dirname = os.path.dirname(path)
- py31compat.makedirs(dirname, exist_ok=True)
+ os.makedirs(dirname, exist_ok=True)
def _bypass_ensure_directory(path):
"""Sandbox-bypassing version of ensure_directory()"""
if not WRITE_SUPPORT:
- raise IOError('"os.mkdir" not supported on this platform.')
+ raise OSError('"os.mkdir" not supported on this platform.')
dirname, filename = split(path)
if dirname and filename and not isdir(dirname):
_bypass_ensure_directory(dirname)
@@ -3186,7 +3517,7 @@ def _bypass_ensure_directory(path):
pass
-def split_sections(s):
+def split_sections(s: _NestedStr) -> Iterator[tuple[str | None, list[str]]]:
"""Split a string or iterable thereof into (section, content) pairs
Each ``section`` is a stripped version of the section header ("[section]")
@@ -3230,6 +3561,47 @@ def _mkstemp(*args, **kw):
warnings.filterwarnings("ignore", category=PEP440Warning, append=True)
+class PkgResourcesDeprecationWarning(Warning):
+ """
+ Base class for warning about deprecations in ``pkg_resources``
+
+ This class is not derived from ``DeprecationWarning``, and as such is
+ visible by default.
+ """
+
+
+# Ported from ``setuptools`` to avoid introducing an import inter-dependency:
+_LOCALE_ENCODING = "locale" if sys.version_info >= (3, 10) else None
+
+
+def _read_utf8_with_fallback(file: str, fallback_encoding=_LOCALE_ENCODING) -> str:
+ """See setuptools.unicode_utils._read_utf8_with_fallback"""
+ try:
+ with open(file, "r", encoding="utf-8") as f:
+ return f.read()
+ except UnicodeDecodeError: # pragma: no cover
+ msg = f"""\
+ ********************************************************************************
+ `encoding="utf-8"` fails with {file!r}, trying `encoding={fallback_encoding!r}`.
+
+ This fallback behaviour is considered **deprecated** and future versions of
+ `setuptools/pkg_resources` may not implement it.
+
+ Please encode {file!r} with "utf-8" to ensure future builds will succeed.
+
+ If this file was produced by `setuptools` itself, cleaning up the cached files
+ and re-building/re-installing the package with a newer version of `setuptools`
+ (e.g. by updating `build-system.requires` in its `pyproject.toml`)
+ might solve the problem.
+ ********************************************************************************
+ """
+ # TODO: Add a deadline?
+ # See comment in setuptools.unicode_utils._Utf8EncodingNeeded
+ warnings.warn(msg, PkgResourcesDeprecationWarning, stacklevel=2)
+ with open(file, "r", encoding=fallback_encoding) as f:
+ return f.read()
+
+
# from jaraco.functools 1.3
def _call_aside(f, *args, **kwargs):
f(*args, **kwargs)
@@ -3261,8 +3633,7 @@ def _initialize_master_working_set():
Invocation by other packages is unsupported and done
at their own risk.
"""
- working_set = WorkingSet._build_master()
- _declare_state('object', working_set=working_set)
+ working_set = _declare_state('object', 'working_set', WorkingSet._build_master())
require = working_set.require
iter_entry_points = working_set.iter_entry_points
@@ -3274,10 +3645,7 @@ def _initialize_master_working_set():
# ensure that all distributions added to the working set in the future
# (e.g. by calling ``require()``) will get activated as well,
# with higher priority (replace=True).
- tuple(
- dist.activate(replace=False)
- for dist in working_set
- )
+ tuple(dist.activate(replace=False) for dist in working_set)
add_activation_listener(
lambda dist: dist.activate(replace=True),
existing=False,
@@ -3287,10 +3655,22 @@ def _initialize_master_working_set():
list(map(working_set.add_entry, sys.path))
globals().update(locals())
-class PkgResourcesDeprecationWarning(Warning):
- """
- Base class for warning about deprecations in ``pkg_resources``
- This class is not derived from ``DeprecationWarning``, and as such is
- visible by default.
- """
+if TYPE_CHECKING:
+ # All of these are set by the @_call_aside methods above
+ __resource_manager = ResourceManager() # Won't exist at runtime
+ resource_exists = __resource_manager.resource_exists
+ resource_isdir = __resource_manager.resource_isdir
+ resource_filename = __resource_manager.resource_filename
+ resource_stream = __resource_manager.resource_stream
+ resource_string = __resource_manager.resource_string
+ resource_listdir = __resource_manager.resource_listdir
+ set_extraction_path = __resource_manager.set_extraction_path
+ cleanup_resources = __resource_manager.cleanup_resources
+
+ working_set = WorkingSet()
+ require = working_set.require
+ iter_entry_points = working_set.iter_entry_points
+ add_activation_listener = working_set.subscribe
+ run_script = working_set.run_script
+ run_main = run_script
diff --git a/venv/Lib/site-packages/pip/_vendor/pkg_resources/__pycache__/__init__.cpython-310.pyc b/venv/Lib/site-packages/pip/_vendor/pkg_resources/__pycache__/__init__.cpython-310.pyc
index c04c687..03ff44c 100644
Binary files a/venv/Lib/site-packages/pip/_vendor/pkg_resources/__pycache__/__init__.cpython-310.pyc and b/venv/Lib/site-packages/pip/_vendor/pkg_resources/__pycache__/__init__.cpython-310.pyc differ
diff --git a/venv/Lib/site-packages/pip/_vendor/pkg_resources/__pycache__/py31compat.cpython-310.pyc b/venv/Lib/site-packages/pip/_vendor/pkg_resources/__pycache__/py31compat.cpython-310.pyc
deleted file mode 100644
index 7c81fb9..0000000
Binary files a/venv/Lib/site-packages/pip/_vendor/pkg_resources/__pycache__/py31compat.cpython-310.pyc and /dev/null differ
diff --git a/venv/Lib/site-packages/pip/_vendor/pkg_resources/py31compat.py b/venv/Lib/site-packages/pip/_vendor/pkg_resources/py31compat.py
deleted file mode 100644
index a2d3007..0000000
--- a/venv/Lib/site-packages/pip/_vendor/pkg_resources/py31compat.py
+++ /dev/null
@@ -1,23 +0,0 @@
-import os
-import errno
-import sys
-
-from pip._vendor import six
-
-
-def _makedirs_31(path, exist_ok=False):
- try:
- os.makedirs(path)
- except OSError as exc:
- if not exist_ok or exc.errno != errno.EEXIST:
- raise
-
-
-# rely on compatibility behavior until mode considerations
-# and exists_ok considerations are disentangled.
-# See https://github.com/pypa/setuptools/pull/1083#issuecomment-315168663
-needs_makedirs = (
- six.PY2 or
- (3, 4) <= sys.version_info < (3, 4, 1)
-)
-makedirs = _makedirs_31 if needs_makedirs else os.makedirs
diff --git a/venv/Lib/site-packages/pip/_vendor/platformdirs/__init__.py b/venv/Lib/site-packages/pip/_vendor/platformdirs/__init__.py
index 9d513dc..edc21fa 100644
--- a/venv/Lib/site-packages/pip/_vendor/platformdirs/__init__.py
+++ b/venv/Lib/site-packages/pip/_vendor/platformdirs/__init__.py
@@ -1,45 +1,52 @@
"""
-Utilities for determining application-specific dirs. See for details and
-usage.
+Utilities for determining application-specific dirs.
+
+See for details and usage.
+
"""
+
from __future__ import annotations
import os
import sys
-from pathlib import Path
from typing import TYPE_CHECKING
-if TYPE_CHECKING:
- from pip._vendor.typing_extensions import Literal # pragma: no cover
-
from .api import PlatformDirsABC
-from .version import __version__, __version_info__
+from .version import __version__
+from .version import __version_tuple__ as __version_info__
+
+if TYPE_CHECKING:
+ from pathlib import Path
+ from typing import Literal
+
+if sys.platform == "win32":
+ from pip._vendor.platformdirs.windows import Windows as _Result
+elif sys.platform == "darwin":
+ from pip._vendor.platformdirs.macos import MacOS as _Result
+else:
+ from pip._vendor.platformdirs.unix import Unix as _Result
def _set_platform_dir_class() -> type[PlatformDirsABC]:
- if sys.platform == "win32":
- from pip._vendor.platformdirs.windows import Windows as Result
- elif sys.platform == "darwin":
- from pip._vendor.platformdirs.macos import MacOS as Result
- else:
- from pip._vendor.platformdirs.unix import Unix as Result
-
if os.getenv("ANDROID_DATA") == "/data" and os.getenv("ANDROID_ROOT") == "/system":
+ if os.getenv("SHELL") or os.getenv("PREFIX"):
+ return _Result
- if os.getenv("SHELL") is not None:
- return Result
-
- from pip._vendor.platformdirs.android import _android_folder
+ from pip._vendor.platformdirs.android import _android_folder # noqa: PLC0415
if _android_folder() is not None:
- from pip._vendor.platformdirs.android import Android
+ from pip._vendor.platformdirs.android import Android # noqa: PLC0415
- return Android # return to avoid redefinition of result
+ return Android # return to avoid redefinition of a result
- return Result
+ return _Result
-PlatformDirs = _set_platform_dir_class() #: Currently active platform
+if TYPE_CHECKING:
+ # Work around mypy issue: https://github.com/python/mypy/issues/10962
+ PlatformDirs = _Result
+else:
+ PlatformDirs = _set_platform_dir_class() #: Currently active platform
AppDirs = PlatformDirs #: Backwards compatibility with appdirs
@@ -47,294 +54,578 @@ def user_data_dir(
appname: str | None = None,
appauthor: str | None | Literal[False] = None,
version: str | None = None,
- roaming: bool = False,
+ roaming: bool = False, # noqa: FBT001, FBT002
+ ensure_exists: bool = False, # noqa: FBT001, FBT002
) -> str:
"""
:param appname: See `appname `.
:param appauthor: See `appauthor `.
:param version: See `version `.
- :param roaming: See `roaming `.
+ :param roaming: See `roaming `.
+ :param ensure_exists: See `ensure_exists `.
:returns: data directory tied to the user
"""
- return PlatformDirs(appname=appname, appauthor=appauthor, version=version, roaming=roaming).user_data_dir
+ return PlatformDirs(
+ appname=appname,
+ appauthor=appauthor,
+ version=version,
+ roaming=roaming,
+ ensure_exists=ensure_exists,
+ ).user_data_dir
def site_data_dir(
appname: str | None = None,
appauthor: str | None | Literal[False] = None,
version: str | None = None,
- multipath: bool = False,
+ multipath: bool = False, # noqa: FBT001, FBT002
+ ensure_exists: bool = False, # noqa: FBT001, FBT002
) -> str:
"""
:param appname: See `appname `.
:param appauthor: See `appauthor `.
:param version: See `version `.
:param multipath: See `roaming `.
+ :param ensure_exists: See `ensure_exists `.
:returns: data directory shared by users
"""
- return PlatformDirs(appname=appname, appauthor=appauthor, version=version, multipath=multipath).site_data_dir
+ return PlatformDirs(
+ appname=appname,
+ appauthor=appauthor,
+ version=version,
+ multipath=multipath,
+ ensure_exists=ensure_exists,
+ ).site_data_dir
def user_config_dir(
appname: str | None = None,
appauthor: str | None | Literal[False] = None,
version: str | None = None,
- roaming: bool = False,
+ roaming: bool = False, # noqa: FBT001, FBT002
+ ensure_exists: bool = False, # noqa: FBT001, FBT002
) -> str:
"""
:param appname: See `appname `.
:param appauthor: See `appauthor `.
:param version: See `version `.
- :param roaming: See `roaming `.
+ :param roaming: See `roaming `.
+ :param ensure_exists: See `ensure_exists `.
:returns: config directory tied to the user
"""
- return PlatformDirs(appname=appname, appauthor=appauthor, version=version, roaming=roaming).user_config_dir
+ return PlatformDirs(
+ appname=appname,
+ appauthor=appauthor,
+ version=version,
+ roaming=roaming,
+ ensure_exists=ensure_exists,
+ ).user_config_dir
def site_config_dir(
appname: str | None = None,
appauthor: str | None | Literal[False] = None,
version: str | None = None,
- multipath: bool = False,
+ multipath: bool = False, # noqa: FBT001, FBT002
+ ensure_exists: bool = False, # noqa: FBT001, FBT002
) -> str:
"""
:param appname: See `appname `.
:param appauthor: See `appauthor `.
:param version: See `version `.
:param multipath: See `roaming `.
+ :param ensure_exists: See `ensure_exists `.
:returns: config directory shared by the users
"""
- return PlatformDirs(appname=appname, appauthor=appauthor, version=version, multipath=multipath).site_config_dir
+ return PlatformDirs(
+ appname=appname,
+ appauthor=appauthor,
+ version=version,
+ multipath=multipath,
+ ensure_exists=ensure_exists,
+ ).site_config_dir
def user_cache_dir(
appname: str | None = None,
appauthor: str | None | Literal[False] = None,
version: str | None = None,
- opinion: bool = True,
+ opinion: bool = True, # noqa: FBT001, FBT002
+ ensure_exists: bool = False, # noqa: FBT001, FBT002
) -> str:
"""
:param appname: See `appname `.
:param appauthor: See `appauthor `.
:param version: See `version `.
:param opinion: See `roaming `.
+ :param ensure_exists: See `ensure_exists `.
:returns: cache directory tied to the user
"""
- return PlatformDirs(appname=appname, appauthor=appauthor, version=version, opinion=opinion).user_cache_dir
+ return PlatformDirs(
+ appname=appname,
+ appauthor=appauthor,
+ version=version,
+ opinion=opinion,
+ ensure_exists=ensure_exists,
+ ).user_cache_dir
+
+
+def site_cache_dir(
+ appname: str | None = None,
+ appauthor: str | None | Literal[False] = None,
+ version: str | None = None,
+ opinion: bool = True, # noqa: FBT001, FBT002
+ ensure_exists: bool = False, # noqa: FBT001, FBT002
+) -> str:
+ """
+ :param appname: See `appname `.
+ :param appauthor: See `appauthor `.
+ :param version: See `version `.
+ :param opinion: See `opinion `.
+ :param ensure_exists: See `ensure_exists `.
+ :returns: cache directory tied to the user
+ """
+ return PlatformDirs(
+ appname=appname,
+ appauthor=appauthor,
+ version=version,
+ opinion=opinion,
+ ensure_exists=ensure_exists,
+ ).site_cache_dir
def user_state_dir(
appname: str | None = None,
appauthor: str | None | Literal[False] = None,
version: str | None = None,
- roaming: bool = False,
+ roaming: bool = False, # noqa: FBT001, FBT002
+ ensure_exists: bool = False, # noqa: FBT001, FBT002
) -> str:
"""
:param appname: See `appname `.
:param appauthor: See `appauthor `.
:param version: See `version `.
- :param roaming: See `roaming `.
+ :param roaming: See `roaming `.
+ :param ensure_exists: See `ensure_exists `.
:returns: state directory tied to the user
"""
- return PlatformDirs(appname=appname, appauthor=appauthor, version=version, roaming=roaming).user_state_dir
+ return PlatformDirs(
+ appname=appname,
+ appauthor=appauthor,
+ version=version,
+ roaming=roaming,
+ ensure_exists=ensure_exists,
+ ).user_state_dir
def user_log_dir(
appname: str | None = None,
appauthor: str | None | Literal[False] = None,
version: str | None = None,
- opinion: bool = True,
+ opinion: bool = True, # noqa: FBT001, FBT002
+ ensure_exists: bool = False, # noqa: FBT001, FBT002
) -> str:
"""
:param appname: See `appname `.
:param appauthor: See `appauthor `.
:param version: See `version `.
:param opinion: See `roaming `.
+ :param ensure_exists: See `ensure_exists `.
:returns: log directory tied to the user
"""
- return PlatformDirs(appname=appname, appauthor=appauthor, version=version, opinion=opinion).user_log_dir
+ return PlatformDirs(
+ appname=appname,
+ appauthor=appauthor,
+ version=version,
+ opinion=opinion,
+ ensure_exists=ensure_exists,
+ ).user_log_dir
def user_documents_dir() -> str:
- """
- :returns: documents directory tied to the user
- """
+ """:returns: documents directory tied to the user"""
return PlatformDirs().user_documents_dir
+def user_downloads_dir() -> str:
+ """:returns: downloads directory tied to the user"""
+ return PlatformDirs().user_downloads_dir
+
+
+def user_pictures_dir() -> str:
+ """:returns: pictures directory tied to the user"""
+ return PlatformDirs().user_pictures_dir
+
+
+def user_videos_dir() -> str:
+ """:returns: videos directory tied to the user"""
+ return PlatformDirs().user_videos_dir
+
+
+def user_music_dir() -> str:
+ """:returns: music directory tied to the user"""
+ return PlatformDirs().user_music_dir
+
+
+def user_desktop_dir() -> str:
+ """:returns: desktop directory tied to the user"""
+ return PlatformDirs().user_desktop_dir
+
+
def user_runtime_dir(
appname: str | None = None,
appauthor: str | None | Literal[False] = None,
version: str | None = None,
- opinion: bool = True,
+ opinion: bool = True, # noqa: FBT001, FBT002
+ ensure_exists: bool = False, # noqa: FBT001, FBT002
) -> str:
"""
:param appname: See `appname `.
:param appauthor: See `appauthor `.
:param version: See `version `.
:param opinion: See `opinion `.
+ :param ensure_exists: See `ensure_exists `.
:returns: runtime directory tied to the user
"""
- return PlatformDirs(appname=appname, appauthor=appauthor, version=version, opinion=opinion).user_runtime_dir
+ return PlatformDirs(
+ appname=appname,
+ appauthor=appauthor,
+ version=version,
+ opinion=opinion,
+ ensure_exists=ensure_exists,
+ ).user_runtime_dir
+
+
+def site_runtime_dir(
+ appname: str | None = None,
+ appauthor: str | None | Literal[False] = None,
+ version: str | None = None,
+ opinion: bool = True, # noqa: FBT001, FBT002
+ ensure_exists: bool = False, # noqa: FBT001, FBT002
+) -> str:
+ """
+ :param appname: See `appname `.
+ :param appauthor: See `appauthor `.
+ :param version: See `version `.
+ :param opinion: See `opinion `.
+ :param ensure_exists: See `ensure_exists `.
+ :returns: runtime directory shared by users
+ """
+ return PlatformDirs(
+ appname=appname,
+ appauthor=appauthor,
+ version=version,
+ opinion=opinion,
+ ensure_exists=ensure_exists,
+ ).site_runtime_dir
def user_data_path(
appname: str | None = None,
appauthor: str | None | Literal[False] = None,
version: str | None = None,
- roaming: bool = False,
+ roaming: bool = False, # noqa: FBT001, FBT002
+ ensure_exists: bool = False, # noqa: FBT001, FBT002
) -> Path:
"""
:param appname: See `appname `.
:param appauthor: See `appauthor `.
:param version: See `version `.
- :param roaming: See `roaming `.
+ :param roaming: See `roaming `.
+ :param ensure_exists: See `ensure_exists `.
:returns: data path tied to the user
"""
- return PlatformDirs(appname=appname, appauthor=appauthor, version=version, roaming=roaming).user_data_path
+ return PlatformDirs(
+ appname=appname,
+ appauthor=appauthor,
+ version=version,
+ roaming=roaming,
+ ensure_exists=ensure_exists,
+ ).user_data_path
def site_data_path(
appname: str | None = None,
appauthor: str | None | Literal[False] = None,
version: str | None = None,
- multipath: bool = False,
+ multipath: bool = False, # noqa: FBT001, FBT002
+ ensure_exists: bool = False, # noqa: FBT001, FBT002
) -> Path:
"""
:param appname: See `appname `.
:param appauthor: See `appauthor `.
:param version: See `version `.
:param multipath: See `multipath `.
+ :param ensure_exists: See `ensure_exists `.
:returns: data path shared by users
"""
- return PlatformDirs(appname=appname, appauthor=appauthor, version=version, multipath=multipath).site_data_path
+ return PlatformDirs(
+ appname=appname,
+ appauthor=appauthor,
+ version=version,
+ multipath=multipath,
+ ensure_exists=ensure_exists,
+ ).site_data_path
def user_config_path(
appname: str | None = None,
appauthor: str | None | Literal[False] = None,
version: str | None = None,
- roaming: bool = False,
+ roaming: bool = False, # noqa: FBT001, FBT002
+ ensure_exists: bool = False, # noqa: FBT001, FBT002
) -> Path:
"""
:param appname: See `appname `.
:param appauthor: See `appauthor `.
:param version: See `version `.
- :param roaming: See `roaming `.
+ :param roaming: See `roaming `.
+ :param ensure_exists: See `ensure_exists `.
:returns: config path tied to the user
"""
- return PlatformDirs(appname=appname, appauthor=appauthor, version=version, roaming=roaming).user_config_path
+ return PlatformDirs(
+ appname=appname,
+ appauthor=appauthor,
+ version=version,
+ roaming=roaming,
+ ensure_exists=ensure_exists,
+ ).user_config_path
def site_config_path(
appname: str | None = None,
appauthor: str | None | Literal[False] = None,
version: str | None = None,
- multipath: bool = False,
+ multipath: bool = False, # noqa: FBT001, FBT002
+ ensure_exists: bool = False, # noqa: FBT001, FBT002
) -> Path:
"""
:param appname: See `appname `.
:param appauthor: See `appauthor `.
:param version: See `version `.
:param multipath: See `roaming `.
+ :param ensure_exists: See `ensure_exists `.
:returns: config path shared by the users
"""
- return PlatformDirs(appname=appname, appauthor=appauthor, version=version, multipath=multipath).site_config_path
+ return PlatformDirs(
+ appname=appname,
+ appauthor=appauthor,
+ version=version,
+ multipath=multipath,
+ ensure_exists=ensure_exists,
+ ).site_config_path
-def user_cache_path(
+def site_cache_path(
appname: str | None = None,
appauthor: str | None | Literal[False] = None,
version: str | None = None,
- opinion: bool = True,
-) -> Path:
- """
- :param appname: See `appname `.
- :param appauthor: See `appauthor `.
- :param version: See `version `.
- :param opinion: See `roaming `.
- :returns: cache path tied to the user
- """
- return PlatformDirs(appname=appname, appauthor=appauthor, version=version, opinion=opinion).user_cache_path
-
-
-def user_state_path(
- appname: str | None = None,
- appauthor: str | None | Literal[False] = None,
- version: str | None = None,
- roaming: bool = False,
-) -> Path:
- """
- :param appname: See `appname `.
- :param appauthor: See `appauthor `.
- :param version: See `version `.
- :param roaming: See `roaming `.
- :returns: state path tied to the user
- """
- return PlatformDirs(appname=appname, appauthor=appauthor, version=version, roaming=roaming).user_state_path
-
-
-def user_log_path(
- appname: str | None = None,
- appauthor: str | None | Literal[False] = None,
- version: str | None = None,
- opinion: bool = True,
-) -> Path:
- """
- :param appname: See `appname `.
- :param appauthor: See `appauthor `.
- :param version: See `version `.
- :param opinion: See `roaming `.
- :returns: log path tied to the user
- """
- return PlatformDirs(appname=appname, appauthor=appauthor, version=version, opinion=opinion).user_log_path
-
-
-def user_documents_path() -> Path:
- """
- :returns: documents path tied to the user
- """
- return PlatformDirs().user_documents_path
-
-
-def user_runtime_path(
- appname: str | None = None,
- appauthor: str | None | Literal[False] = None,
- version: str | None = None,
- opinion: bool = True,
+ opinion: bool = True, # noqa: FBT001, FBT002
+ ensure_exists: bool = False, # noqa: FBT001, FBT002
) -> Path:
"""
:param appname: See `appname `.
:param appauthor: See `appauthor `.
:param version: See `version `.
:param opinion: See `opinion `.
+ :param ensure_exists: See `ensure_exists `.
+ :returns: cache directory tied to the user
+ """
+ return PlatformDirs(
+ appname=appname,
+ appauthor=appauthor,
+ version=version,
+ opinion=opinion,
+ ensure_exists=ensure_exists,
+ ).site_cache_path
+
+
+def user_cache_path(
+ appname: str | None = None,
+ appauthor: str | None | Literal[False] = None,
+ version: str | None = None,
+ opinion: bool = True, # noqa: FBT001, FBT002
+ ensure_exists: bool = False, # noqa: FBT001, FBT002
+) -> Path:
+ """
+ :param appname: See `appname `.
+ :param appauthor: See `appauthor `.
+ :param version: See `version `.
+ :param opinion: See `roaming `.
+ :param ensure_exists: See `ensure_exists `.
+ :returns: cache path tied to the user
+ """
+ return PlatformDirs(
+ appname=appname,
+ appauthor=appauthor,
+ version=version,
+ opinion=opinion,
+ ensure_exists=ensure_exists,
+ ).user_cache_path
+
+
+def user_state_path(
+ appname: str | None = None,
+ appauthor: str | None | Literal[False] = None,
+ version: str | None = None,
+ roaming: bool = False, # noqa: FBT001, FBT002
+ ensure_exists: bool = False, # noqa: FBT001, FBT002
+) -> Path:
+ """
+ :param appname: See `appname `.
+ :param appauthor: See `appauthor `.
+ :param version: See `version `.
+ :param roaming: See `roaming `.
+ :param ensure_exists: See `ensure_exists `.
+ :returns: state path tied to the user
+ """
+ return PlatformDirs(
+ appname=appname,
+ appauthor=appauthor,
+ version=version,
+ roaming=roaming,
+ ensure_exists=ensure_exists,
+ ).user_state_path
+
+
+def user_log_path(
+ appname: str | None = None,
+ appauthor: str | None | Literal[False] = None,
+ version: str | None = None,
+ opinion: bool = True, # noqa: FBT001, FBT002
+ ensure_exists: bool = False, # noqa: FBT001, FBT002
+) -> Path:
+ """
+ :param appname: See `appname `.
+ :param appauthor: See `appauthor `.
+ :param version: See `version `.
+ :param opinion: See `roaming `.
+ :param ensure_exists: See `ensure_exists `.
+ :returns: log path tied to the user
+ """
+ return PlatformDirs(
+ appname=appname,
+ appauthor=appauthor,
+ version=version,
+ opinion=opinion,
+ ensure_exists=ensure_exists,
+ ).user_log_path
+
+
+def user_documents_path() -> Path:
+ """:returns: documents a path tied to the user"""
+ return PlatformDirs().user_documents_path
+
+
+def user_downloads_path() -> Path:
+ """:returns: downloads path tied to the user"""
+ return PlatformDirs().user_downloads_path
+
+
+def user_pictures_path() -> Path:
+ """:returns: pictures path tied to the user"""
+ return PlatformDirs().user_pictures_path
+
+
+def user_videos_path() -> Path:
+ """:returns: videos path tied to the user"""
+ return PlatformDirs().user_videos_path
+
+
+def user_music_path() -> Path:
+ """:returns: music path tied to the user"""
+ return PlatformDirs().user_music_path
+
+
+def user_desktop_path() -> Path:
+ """:returns: desktop path tied to the user"""
+ return PlatformDirs().user_desktop_path
+
+
+def user_runtime_path(
+ appname: str | None = None,
+ appauthor: str | None | Literal[False] = None,
+ version: str | None = None,
+ opinion: bool = True, # noqa: FBT001, FBT002
+ ensure_exists: bool = False, # noqa: FBT001, FBT002
+) -> Path:
+ """
+ :param appname: See `appname `.
+ :param appauthor: See `appauthor `.
+ :param version: See `version `.
+ :param opinion: See `opinion `.
+ :param ensure_exists: See `ensure_exists `.
:returns: runtime path tied to the user
"""
- return PlatformDirs(appname=appname, appauthor=appauthor, version=version, opinion=opinion).user_runtime_path
+ return PlatformDirs(
+ appname=appname,
+ appauthor=appauthor,
+ version=version,
+ opinion=opinion,
+ ensure_exists=ensure_exists,
+ ).user_runtime_path
+
+
+def site_runtime_path(
+ appname: str | None = None,
+ appauthor: str | None | Literal[False] = None,
+ version: str | None = None,
+ opinion: bool = True, # noqa: FBT001, FBT002
+ ensure_exists: bool = False, # noqa: FBT001, FBT002
+) -> Path:
+ """
+ :param appname: See `appname `.
+ :param appauthor: See `appauthor `.
+ :param version: See `version `.
+ :param opinion: See `opinion `.
+ :param ensure_exists: See `ensure_exists `.
+ :returns: runtime path shared by users
+ """
+ return PlatformDirs(
+ appname=appname,
+ appauthor=appauthor,
+ version=version,
+ opinion=opinion,
+ ensure_exists=ensure_exists,
+ ).site_runtime_path
__all__ = [
+ "AppDirs",
+ "PlatformDirs",
+ "PlatformDirsABC",
"__version__",
"__version_info__",
- "PlatformDirs",
- "AppDirs",
- "PlatformDirsABC",
- "user_data_dir",
- "user_config_dir",
- "user_cache_dir",
- "user_state_dir",
- "user_log_dir",
- "user_documents_dir",
- "user_runtime_dir",
- "site_data_dir",
+ "site_cache_dir",
+ "site_cache_path",
"site_config_dir",
- "user_data_path",
- "user_config_path",
- "user_cache_path",
- "user_state_path",
- "user_log_path",
- "user_documents_path",
- "user_runtime_path",
- "site_data_path",
"site_config_path",
+ "site_data_dir",
+ "site_data_path",
+ "site_runtime_dir",
+ "site_runtime_path",
+ "user_cache_dir",
+ "user_cache_path",
+ "user_config_dir",
+ "user_config_path",
+ "user_data_dir",
+ "user_data_path",
+ "user_desktop_dir",
+ "user_desktop_path",
+ "user_documents_dir",
+ "user_documents_path",
+ "user_downloads_dir",
+ "user_downloads_path",
+ "user_log_dir",
+ "user_log_path",
+ "user_music_dir",
+ "user_music_path",
+ "user_pictures_dir",
+ "user_pictures_path",
+ "user_runtime_dir",
+ "user_runtime_path",
+ "user_state_dir",
+ "user_state_path",
+ "user_videos_dir",
+ "user_videos_path",
]
diff --git a/venv/Lib/site-packages/pip/_vendor/platformdirs/__main__.py b/venv/Lib/site-packages/pip/_vendor/platformdirs/__main__.py
index 9c54bfb..fa8a677 100644
--- a/venv/Lib/site-packages/pip/_vendor/platformdirs/__main__.py
+++ b/venv/Lib/site-packages/pip/_vendor/platformdirs/__main__.py
@@ -1,3 +1,5 @@
+"""Main entry point."""
+
from __future__ import annotations
from pip._vendor.platformdirs import PlatformDirs, __version__
@@ -9,37 +11,44 @@ PROPS = (
"user_state_dir",
"user_log_dir",
"user_documents_dir",
+ "user_downloads_dir",
+ "user_pictures_dir",
+ "user_videos_dir",
+ "user_music_dir",
"user_runtime_dir",
"site_data_dir",
"site_config_dir",
+ "site_cache_dir",
+ "site_runtime_dir",
)
def main() -> None:
+ """Run the main entry point."""
app_name = "MyApp"
app_author = "MyCompany"
- print(f"-- platformdirs {__version__} --")
+ print(f"-- platformdirs {__version__} --") # noqa: T201
- print("-- app dirs (with optional 'version')")
+ print("-- app dirs (with optional 'version')") # noqa: T201
dirs = PlatformDirs(app_name, app_author, version="1.0")
for prop in PROPS:
- print(f"{prop}: {getattr(dirs, prop)}")
+ print(f"{prop}: {getattr(dirs, prop)}") # noqa: T201
- print("\n-- app dirs (without optional 'version')")
+ print("\n-- app dirs (without optional 'version')") # noqa: T201
dirs = PlatformDirs(app_name, app_author)
for prop in PROPS:
- print(f"{prop}: {getattr(dirs, prop)}")
+ print(f"{prop}: {getattr(dirs, prop)}") # noqa: T201
- print("\n-- app dirs (without optional 'appauthor')")
+ print("\n-- app dirs (without optional 'appauthor')") # noqa: T201
dirs = PlatformDirs(app_name)
for prop in PROPS:
- print(f"{prop}: {getattr(dirs, prop)}")
+ print(f"{prop}: {getattr(dirs, prop)}") # noqa: T201
- print("\n-- app dirs (with disabled 'appauthor')")
+ print("\n-- app dirs (with disabled 'appauthor')") # noqa: T201
dirs = PlatformDirs(app_name, appauthor=False)
for prop in PROPS:
- print(f"{prop}: {getattr(dirs, prop)}")
+ print(f"{prop}: {getattr(dirs, prop)}") # noqa: T201
if __name__ == "__main__":
diff --git a/venv/Lib/site-packages/pip/_vendor/platformdirs/__pycache__/__init__.cpython-310.pyc b/venv/Lib/site-packages/pip/_vendor/platformdirs/__pycache__/__init__.cpython-310.pyc
index 54d2ade..904bf7d 100644
Binary files a/venv/Lib/site-packages/pip/_vendor/platformdirs/__pycache__/__init__.cpython-310.pyc and b/venv/Lib/site-packages/pip/_vendor/platformdirs/__pycache__/__init__.cpython-310.pyc differ
diff --git a/venv/Lib/site-packages/pip/_vendor/platformdirs/__pycache__/__main__.cpython-310.pyc b/venv/Lib/site-packages/pip/_vendor/platformdirs/__pycache__/__main__.cpython-310.pyc
index 8c6b60f..c4f83d8 100644
Binary files a/venv/Lib/site-packages/pip/_vendor/platformdirs/__pycache__/__main__.cpython-310.pyc and b/venv/Lib/site-packages/pip/_vendor/platformdirs/__pycache__/__main__.cpython-310.pyc differ
diff --git a/venv/Lib/site-packages/pip/_vendor/platformdirs/__pycache__/android.cpython-310.pyc b/venv/Lib/site-packages/pip/_vendor/platformdirs/__pycache__/android.cpython-310.pyc
index dbd5000..351470d 100644
Binary files a/venv/Lib/site-packages/pip/_vendor/platformdirs/__pycache__/android.cpython-310.pyc and b/venv/Lib/site-packages/pip/_vendor/platformdirs/__pycache__/android.cpython-310.pyc differ
diff --git a/venv/Lib/site-packages/pip/_vendor/platformdirs/__pycache__/api.cpython-310.pyc b/venv/Lib/site-packages/pip/_vendor/platformdirs/__pycache__/api.cpython-310.pyc
index 229843d..3884dd9 100644
Binary files a/venv/Lib/site-packages/pip/_vendor/platformdirs/__pycache__/api.cpython-310.pyc and b/venv/Lib/site-packages/pip/_vendor/platformdirs/__pycache__/api.cpython-310.pyc differ
diff --git a/venv/Lib/site-packages/pip/_vendor/platformdirs/__pycache__/macos.cpython-310.pyc b/venv/Lib/site-packages/pip/_vendor/platformdirs/__pycache__/macos.cpython-310.pyc
index 590aeb8..ed8b092 100644
Binary files a/venv/Lib/site-packages/pip/_vendor/platformdirs/__pycache__/macos.cpython-310.pyc and b/venv/Lib/site-packages/pip/_vendor/platformdirs/__pycache__/macos.cpython-310.pyc differ
diff --git a/venv/Lib/site-packages/pip/_vendor/platformdirs/__pycache__/unix.cpython-310.pyc b/venv/Lib/site-packages/pip/_vendor/platformdirs/__pycache__/unix.cpython-310.pyc
index 90bc2cd..c254c73 100644
Binary files a/venv/Lib/site-packages/pip/_vendor/platformdirs/__pycache__/unix.cpython-310.pyc and b/venv/Lib/site-packages/pip/_vendor/platformdirs/__pycache__/unix.cpython-310.pyc differ
diff --git a/venv/Lib/site-packages/pip/_vendor/platformdirs/__pycache__/version.cpython-310.pyc b/venv/Lib/site-packages/pip/_vendor/platformdirs/__pycache__/version.cpython-310.pyc
index c800cd4..67d57f9 100644
Binary files a/venv/Lib/site-packages/pip/_vendor/platformdirs/__pycache__/version.cpython-310.pyc and b/venv/Lib/site-packages/pip/_vendor/platformdirs/__pycache__/version.cpython-310.pyc differ
diff --git a/venv/Lib/site-packages/pip/_vendor/platformdirs/__pycache__/windows.cpython-310.pyc b/venv/Lib/site-packages/pip/_vendor/platformdirs/__pycache__/windows.cpython-310.pyc
index 6a6ede1..fae4728 100644
Binary files a/venv/Lib/site-packages/pip/_vendor/platformdirs/__pycache__/windows.cpython-310.pyc and b/venv/Lib/site-packages/pip/_vendor/platformdirs/__pycache__/windows.cpython-310.pyc differ
diff --git a/venv/Lib/site-packages/pip/_vendor/platformdirs/android.py b/venv/Lib/site-packages/pip/_vendor/platformdirs/android.py
index eda8093..7004a85 100644
--- a/venv/Lib/site-packages/pip/_vendor/platformdirs/android.py
+++ b/venv/Lib/site-packages/pip/_vendor/platformdirs/android.py
@@ -1,19 +1,23 @@
+"""Android."""
+
from __future__ import annotations
import os
import re
import sys
from functools import lru_cache
-from typing import cast
+from typing import TYPE_CHECKING, cast
from .api import PlatformDirsABC
class Android(PlatformDirsABC):
"""
- Follows the guidance `from here `_. Makes use of the
- `appname ` and
- `version `.
+ Follows the guidance `from here `_.
+
+ Makes use of the `appname `, `version
+ `, `ensure_exists `.
+
"""
@property
@@ -29,7 +33,8 @@ class Android(PlatformDirsABC):
@property
def user_config_dir(self) -> str:
"""
- :return: config directory tied to the user, e.g. ``/data/user///shared_prefs/``
+ :return: config directory tied to the user, e.g. \
+ ``/data/user///shared_prefs/``
"""
return self._append_app_name_and_version(cast(str, _android_folder()), "shared_prefs")
@@ -40,9 +45,14 @@ class Android(PlatformDirsABC):
@property
def user_cache_dir(self) -> str:
- """:return: cache directory tied to the user, e.g. e.g. ``/data/user///cache/``"""
+ """:return: cache directory tied to the user, e.g.,``/data/user///cache/``"""
return self._append_app_name_and_version(cast(str, _android_folder()), "cache")
+ @property
+ def site_cache_dir(self) -> str:
+ """:return: cache directory shared by users, same as `user_cache_dir`"""
+ return self.user_cache_dir
+
@property
def user_state_dir(self) -> str:
""":return: state directory tied to the user, same as `user_data_dir`"""
@@ -56,16 +66,39 @@ class Android(PlatformDirsABC):
"""
path = self.user_cache_dir
if self.opinion:
- path = os.path.join(path, "log")
+ path = os.path.join(path, "log") # noqa: PTH118
return path
@property
def user_documents_dir(self) -> str:
- """
- :return: documents directory tied to the user e.g. ``/storage/emulated/0/Documents``
- """
+ """:return: documents directory tied to the user e.g. ``/storage/emulated/0/Documents``"""
return _android_documents_folder()
+ @property
+ def user_downloads_dir(self) -> str:
+ """:return: downloads directory tied to the user e.g. ``/storage/emulated/0/Downloads``"""
+ return _android_downloads_folder()
+
+ @property
+ def user_pictures_dir(self) -> str:
+ """:return: pictures directory tied to the user e.g. ``/storage/emulated/0/Pictures``"""
+ return _android_pictures_folder()
+
+ @property
+ def user_videos_dir(self) -> str:
+ """:return: videos directory tied to the user e.g. ``/storage/emulated/0/DCIM/Camera``"""
+ return _android_videos_folder()
+
+ @property
+ def user_music_dir(self) -> str:
+ """:return: music directory tied to the user e.g. ``/storage/emulated/0/Music``"""
+ return _android_music_folder()
+
+ @property
+ def user_desktop_dir(self) -> str:
+ """:return: desktop directory tied to the user e.g. ``/storage/emulated/0/Desktop``"""
+ return "/storage/emulated/0/Desktop"
+
@property
def user_runtime_dir(self) -> str:
"""
@@ -74,21 +107,43 @@ class Android(PlatformDirsABC):
"""
path = self.user_cache_dir
if self.opinion:
- path = os.path.join(path, "tmp")
+ path = os.path.join(path, "tmp") # noqa: PTH118
return path
+ @property
+ def site_runtime_dir(self) -> str:
+ """:return: runtime directory shared by users, same as `user_runtime_dir`"""
+ return self.user_runtime_dir
+
@lru_cache(maxsize=1)
-def _android_folder() -> str | None:
- """:return: base folder for the Android OS or None if cannot be found"""
- try:
- # First try to get path to android app via pyjnius
- from jnius import autoclass
+def _android_folder() -> str | None: # noqa: C901
+ """:return: base folder for the Android OS or None if it cannot be found"""
+ result: str | None = None
+ # type checker isn't happy with our "import android", just don't do this when type checking see
+ # https://stackoverflow.com/a/61394121
+ if not TYPE_CHECKING:
+ try:
+ # First try to get a path to android app using python4android (if available)...
+ from android import mActivity # noqa: PLC0415
- Context = autoclass("android.content.Context") # noqa: N806
- result: str | None = Context.getFilesDir().getParentFile().getAbsolutePath()
- except Exception:
- # if fails find an android folder looking path on the sys.path
+ context = cast("android.content.Context", mActivity.getApplicationContext()) # noqa: F821
+ result = context.getFilesDir().getParentFile().getAbsolutePath()
+ except Exception: # noqa: BLE001
+ result = None
+ if result is None:
+ try:
+ # ...and fall back to using plain pyjnius, if python4android isn't available or doesn't deliver any useful
+ # result...
+ from jnius import autoclass # noqa: PLC0415
+
+ context = autoclass("android.content.Context")
+ result = context.getFilesDir().getParentFile().getAbsolutePath()
+ except Exception: # noqa: BLE001
+ result = None
+ if result is None:
+ # and if that fails, too, find an android folder looking at path on the sys.path
+ # warning: only works for apps installed under /data, not adopted storage etc.
pattern = re.compile(r"/data/(data|user/\d+)/(.+)/files")
for path in sys.path:
if pattern.match(path):
@@ -96,6 +151,16 @@ def _android_folder() -> str | None:
break
else:
result = None
+ if result is None:
+ # one last try: find an android folder looking at path on the sys.path taking adopted storage paths into
+ # account
+ pattern = re.compile(r"/mnt/expand/[a-fA-F0-9-]{36}/(data|user/\d+)/(.+)/files")
+ for path in sys.path:
+ if pattern.match(path):
+ result = path.split("/files")[0]
+ break
+ else:
+ result = None
return result
@@ -104,17 +169,81 @@ def _android_documents_folder() -> str:
""":return: documents folder for the Android OS"""
# Get directories with pyjnius
try:
- from jnius import autoclass
+ from jnius import autoclass # noqa: PLC0415
- Context = autoclass("android.content.Context") # noqa: N806
- Environment = autoclass("android.os.Environment") # noqa: N806
- documents_dir: str = Context.getExternalFilesDir(Environment.DIRECTORY_DOCUMENTS).getAbsolutePath()
- except Exception:
+ context = autoclass("android.content.Context")
+ environment = autoclass("android.os.Environment")
+ documents_dir: str = context.getExternalFilesDir(environment.DIRECTORY_DOCUMENTS).getAbsolutePath()
+ except Exception: # noqa: BLE001
documents_dir = "/storage/emulated/0/Documents"
return documents_dir
+@lru_cache(maxsize=1)
+def _android_downloads_folder() -> str:
+ """:return: downloads folder for the Android OS"""
+ # Get directories with pyjnius
+ try:
+ from jnius import autoclass # noqa: PLC0415
+
+ context = autoclass("android.content.Context")
+ environment = autoclass("android.os.Environment")
+ downloads_dir: str = context.getExternalFilesDir(environment.DIRECTORY_DOWNLOADS).getAbsolutePath()
+ except Exception: # noqa: BLE001
+ downloads_dir = "/storage/emulated/0/Downloads"
+
+ return downloads_dir
+
+
+@lru_cache(maxsize=1)
+def _android_pictures_folder() -> str:
+ """:return: pictures folder for the Android OS"""
+ # Get directories with pyjnius
+ try:
+ from jnius import autoclass # noqa: PLC0415
+
+ context = autoclass("android.content.Context")
+ environment = autoclass("android.os.Environment")
+ pictures_dir: str = context.getExternalFilesDir(environment.DIRECTORY_PICTURES).getAbsolutePath()
+ except Exception: # noqa: BLE001
+ pictures_dir = "/storage/emulated/0/Pictures"
+
+ return pictures_dir
+
+
+@lru_cache(maxsize=1)
+def _android_videos_folder() -> str:
+ """:return: videos folder for the Android OS"""
+ # Get directories with pyjnius
+ try:
+ from jnius import autoclass # noqa: PLC0415
+
+ context = autoclass("android.content.Context")
+ environment = autoclass("android.os.Environment")
+ videos_dir: str = context.getExternalFilesDir(environment.DIRECTORY_DCIM).getAbsolutePath()
+ except Exception: # noqa: BLE001
+ videos_dir = "/storage/emulated/0/DCIM/Camera"
+
+ return videos_dir
+
+
+@lru_cache(maxsize=1)
+def _android_music_folder() -> str:
+ """:return: music folder for the Android OS"""
+ # Get directories with pyjnius
+ try:
+ from jnius import autoclass # noqa: PLC0415
+
+ context = autoclass("android.content.Context")
+ environment = autoclass("android.os.Environment")
+ music_dir: str = context.getExternalFilesDir(environment.DIRECTORY_MUSIC).getAbsolutePath()
+ except Exception: # noqa: BLE001
+ music_dir = "/storage/emulated/0/Music"
+
+ return music_dir
+
+
__all__ = [
"Android",
]
diff --git a/venv/Lib/site-packages/pip/_vendor/platformdirs/api.py b/venv/Lib/site-packages/pip/_vendor/platformdirs/api.py
index 6f6e2c2..18d660e 100644
--- a/venv/Lib/site-packages/pip/_vendor/platformdirs/api.py
+++ b/venv/Lib/site-packages/pip/_vendor/platformdirs/api.py
@@ -1,28 +1,29 @@
+"""Base API."""
+
from __future__ import annotations
import os
-import sys
from abc import ABC, abstractmethod
from pathlib import Path
+from typing import TYPE_CHECKING
-if sys.version_info >= (3, 8): # pragma: no branch
- from typing import Literal # pragma: no cover
+if TYPE_CHECKING:
+ from typing import Iterator, Literal
-class PlatformDirsABC(ABC):
- """
- Abstract base class for platform directories.
- """
+class PlatformDirsABC(ABC): # noqa: PLR0904
+ """Abstract base class for platform directories."""
- def __init__(
+ def __init__( # noqa: PLR0913, PLR0917
self,
appname: str | None = None,
appauthor: str | None | Literal[False] = None,
version: str | None = None,
- roaming: bool = False,
- multipath: bool = False,
- opinion: bool = True,
- ):
+ roaming: bool = False, # noqa: FBT001, FBT002
+ multipath: bool = False, # noqa: FBT001, FBT002
+ opinion: bool = True, # noqa: FBT001, FBT002
+ ensure_exists: bool = False, # noqa: FBT001, FBT002
+ ) -> None:
"""
Create a new platform directory.
@@ -32,30 +33,49 @@ class PlatformDirsABC(ABC):
:param roaming: See `roaming`.
:param multipath: See `multipath`.
:param opinion: See `opinion`.
+ :param ensure_exists: See `ensure_exists`.
+
"""
self.appname = appname #: The name of application.
self.appauthor = appauthor
"""
- The name of the app author or distributing body for this application. Typically, it is the owning company name.
- Defaults to `appname`. You may pass ``False`` to disable it.
+ The name of the app author or distributing body for this application.
+
+ Typically, it is the owning company name. Defaults to `appname`. You may pass ``False`` to disable it.
+
"""
self.version = version
"""
- An optional version path element to append to the path. You might want to use this if you want multiple versions
- of your app to be able to run independently. If used, this would typically be ``