diff --git a/llmeval-env/lib/python3.10/site-packages/pip/_vendor/packaging/__about__.py b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/packaging/__about__.py new file mode 100644 index 0000000000000000000000000000000000000000..3551bc2d29846441299cf57b397b02fc164c99b9 --- /dev/null +++ b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/packaging/__about__.py @@ -0,0 +1,26 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +__all__ = [ + "__title__", + "__summary__", + "__uri__", + "__version__", + "__author__", + "__email__", + "__license__", + "__copyright__", +] + +__title__ = "packaging" +__summary__ = "Core utilities for Python packages" +__uri__ = "https://github.com/pypa/packaging" + +__version__ = "21.3" + +__author__ = "Donald Stufft and individual contributors" +__email__ = "donald@stufft.io" + +__license__ = "BSD-2-Clause or Apache-2.0" +__copyright__ = "2014-2019 %s" % __author__ diff --git a/llmeval-env/lib/python3.10/site-packages/pip/_vendor/packaging/markers.py b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/packaging/markers.py new file mode 100644 index 0000000000000000000000000000000000000000..540e7a4dc79d02a820e291b57c43335d5aa25a41 --- /dev/null +++ b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/packaging/markers.py @@ -0,0 +1,304 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +import operator +import os +import platform +import sys +from typing import Any, Callable, Dict, List, Optional, Tuple, Union + +from pip._vendor.pyparsing import ( # noqa: N817 + Forward, + Group, + Literal as L, + ParseException, + ParseResults, + QuotedString, + ZeroOrMore, + stringEnd, + stringStart, +) + +from .specifiers import InvalidSpecifier, Specifier + +__all__ = [ + "InvalidMarker", + "UndefinedComparison", + "UndefinedEnvironmentName", + "Marker", + "default_environment", +] + +Operator = Callable[[str, str], bool] + + +class InvalidMarker(ValueError): + """ + An invalid marker was found, users should refer to PEP 508. + """ + + +class UndefinedComparison(ValueError): + """ + An invalid operation was attempted on a value that doesn't support it. + """ + + +class UndefinedEnvironmentName(ValueError): + """ + A name was attempted to be used that does not exist inside of the + environment. + """ + + +class Node: + def __init__(self, value: Any) -> None: + self.value = value + + def __str__(self) -> str: + return str(self.value) + + def __repr__(self) -> str: + return f"<{self.__class__.__name__}('{self}')>" + + def serialize(self) -> str: + raise NotImplementedError + + +class Variable(Node): + def serialize(self) -> str: + return str(self) + + +class Value(Node): + def serialize(self) -> str: + return f'"{self}"' + + +class Op(Node): + def serialize(self) -> str: + return str(self) + + +VARIABLE = ( + L("implementation_version") + | L("platform_python_implementation") + | L("implementation_name") + | L("python_full_version") + | L("platform_release") + | L("platform_version") + | L("platform_machine") + | L("platform_system") + | L("python_version") + | L("sys_platform") + | L("os_name") + | L("os.name") # PEP-345 + | L("sys.platform") # PEP-345 + | L("platform.version") # PEP-345 + | L("platform.machine") # PEP-345 + | L("platform.python_implementation") # PEP-345 + | L("python_implementation") # undocumented setuptools legacy + | L("extra") # PEP-508 +) +ALIASES = { + "os.name": "os_name", + "sys.platform": "sys_platform", + "platform.version": "platform_version", + "platform.machine": "platform_machine", + "platform.python_implementation": "platform_python_implementation", + "python_implementation": "platform_python_implementation", +} +VARIABLE.setParseAction(lambda s, l, t: Variable(ALIASES.get(t[0], t[0]))) + +VERSION_CMP = ( + L("===") | L("==") | L(">=") | L("<=") | L("!=") | L("~=") | L(">") | L("<") +) + +MARKER_OP = VERSION_CMP | L("not in") | L("in") +MARKER_OP.setParseAction(lambda s, l, t: Op(t[0])) + +MARKER_VALUE = QuotedString("'") | QuotedString('"') +MARKER_VALUE.setParseAction(lambda s, l, t: Value(t[0])) + +BOOLOP = L("and") | L("or") + +MARKER_VAR = VARIABLE | MARKER_VALUE + +MARKER_ITEM = Group(MARKER_VAR + MARKER_OP + MARKER_VAR) +MARKER_ITEM.setParseAction(lambda s, l, t: tuple(t[0])) + +LPAREN = L("(").suppress() +RPAREN = L(")").suppress() + +MARKER_EXPR = Forward() +MARKER_ATOM = MARKER_ITEM | Group(LPAREN + MARKER_EXPR + RPAREN) +MARKER_EXPR << MARKER_ATOM + ZeroOrMore(BOOLOP + MARKER_EXPR) + +MARKER = stringStart + MARKER_EXPR + stringEnd + + +def _coerce_parse_result(results: Union[ParseResults, List[Any]]) -> List[Any]: + if isinstance(results, ParseResults): + return [_coerce_parse_result(i) for i in results] + else: + return results + + +def _format_marker( + marker: Union[List[str], Tuple[Node, ...], str], first: Optional[bool] = True +) -> str: + + assert isinstance(marker, (list, tuple, str)) + + # Sometimes we have a structure like [[...]] which is a single item list + # where the single item is itself it's own list. In that case we want skip + # the rest of this function so that we don't get extraneous () on the + # outside. + if ( + isinstance(marker, list) + and len(marker) == 1 + and isinstance(marker[0], (list, tuple)) + ): + return _format_marker(marker[0]) + + if isinstance(marker, list): + inner = (_format_marker(m, first=False) for m in marker) + if first: + return " ".join(inner) + else: + return "(" + " ".join(inner) + ")" + elif isinstance(marker, tuple): + return " ".join([m.serialize() for m in marker]) + else: + return marker + + +_operators: Dict[str, Operator] = { + "in": lambda lhs, rhs: lhs in rhs, + "not in": lambda lhs, rhs: lhs not in rhs, + "<": operator.lt, + "<=": operator.le, + "==": operator.eq, + "!=": operator.ne, + ">=": operator.ge, + ">": operator.gt, +} + + +def _eval_op(lhs: str, op: Op, rhs: str) -> bool: + try: + spec = Specifier("".join([op.serialize(), rhs])) + except InvalidSpecifier: + pass + else: + return spec.contains(lhs) + + oper: Optional[Operator] = _operators.get(op.serialize()) + if oper is None: + raise UndefinedComparison(f"Undefined {op!r} on {lhs!r} and {rhs!r}.") + + return oper(lhs, rhs) + + +class Undefined: + pass + + +_undefined = Undefined() + + +def _get_env(environment: Dict[str, str], name: str) -> str: + value: Union[str, Undefined] = environment.get(name, _undefined) + + if isinstance(value, Undefined): + raise UndefinedEnvironmentName( + f"{name!r} does not exist in evaluation environment." + ) + + return value + + +def _evaluate_markers(markers: List[Any], environment: Dict[str, str]) -> bool: + groups: List[List[bool]] = [[]] + + for marker in markers: + assert isinstance(marker, (list, tuple, str)) + + if isinstance(marker, list): + groups[-1].append(_evaluate_markers(marker, environment)) + elif isinstance(marker, tuple): + lhs, op, rhs = marker + + if isinstance(lhs, Variable): + lhs_value = _get_env(environment, lhs.value) + rhs_value = rhs.value + else: + lhs_value = lhs.value + rhs_value = _get_env(environment, rhs.value) + + groups[-1].append(_eval_op(lhs_value, op, rhs_value)) + else: + assert marker in ["and", "or"] + if marker == "or": + groups.append([]) + + return any(all(item) for item in groups) + + +def format_full_version(info: "sys._version_info") -> str: + version = "{0.major}.{0.minor}.{0.micro}".format(info) + kind = info.releaselevel + if kind != "final": + version += kind[0] + str(info.serial) + return version + + +def default_environment() -> Dict[str, str]: + iver = format_full_version(sys.implementation.version) + implementation_name = sys.implementation.name + return { + "implementation_name": implementation_name, + "implementation_version": iver, + "os_name": os.name, + "platform_machine": platform.machine(), + "platform_release": platform.release(), + "platform_system": platform.system(), + "platform_version": platform.version(), + "python_full_version": platform.python_version(), + "platform_python_implementation": platform.python_implementation(), + "python_version": ".".join(platform.python_version_tuple()[:2]), + "sys_platform": sys.platform, + } + + +class Marker: + def __init__(self, marker: str) -> None: + try: + self._markers = _coerce_parse_result(MARKER.parseString(marker)) + except ParseException as e: + raise InvalidMarker( + f"Invalid marker: {marker!r}, parse error at " + f"{marker[e.loc : e.loc + 8]!r}" + ) + + def __str__(self) -> str: + return _format_marker(self._markers) + + def __repr__(self) -> str: + return f"" + + def evaluate(self, environment: Optional[Dict[str, str]] = None) -> bool: + """Evaluate a marker. + + Return the boolean from evaluating the given marker against the + environment. environment is an optional argument to override all or + part of the determined environment. + + The environment is determined from the current Python process. + """ + current_environment = default_environment() + if environment is not None: + current_environment.update(environment) + + return _evaluate_markers(self._markers, current_environment) diff --git a/llmeval-env/lib/python3.10/site-packages/pip/_vendor/packaging/requirements.py b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/packaging/requirements.py new file mode 100644 index 0000000000000000000000000000000000000000..1eab7dd66d9bfdefea1a0e159303f1c09fa16d67 --- /dev/null +++ b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/packaging/requirements.py @@ -0,0 +1,146 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +import re +import string +import urllib.parse +from typing import List, Optional as TOptional, Set + +from pip._vendor.pyparsing import ( # noqa + Combine, + Literal as L, + Optional, + ParseException, + Regex, + Word, + ZeroOrMore, + originalTextFor, + stringEnd, + stringStart, +) + +from .markers import MARKER_EXPR, Marker +from .specifiers import LegacySpecifier, Specifier, SpecifierSet + + +class InvalidRequirement(ValueError): + """ + An invalid requirement was found, users should refer to PEP 508. + """ + + +ALPHANUM = Word(string.ascii_letters + string.digits) + +LBRACKET = L("[").suppress() +RBRACKET = L("]").suppress() +LPAREN = L("(").suppress() +RPAREN = L(")").suppress() +COMMA = L(",").suppress() +SEMICOLON = L(";").suppress() +AT = L("@").suppress() + +PUNCTUATION = Word("-_.") +IDENTIFIER_END = ALPHANUM | (ZeroOrMore(PUNCTUATION) + ALPHANUM) +IDENTIFIER = Combine(ALPHANUM + ZeroOrMore(IDENTIFIER_END)) + +NAME = IDENTIFIER("name") +EXTRA = IDENTIFIER + +URI = Regex(r"[^ ]+")("url") +URL = AT + URI + +EXTRAS_LIST = EXTRA + ZeroOrMore(COMMA + EXTRA) +EXTRAS = (LBRACKET + Optional(EXTRAS_LIST) + RBRACKET)("extras") + +VERSION_PEP440 = Regex(Specifier._regex_str, re.VERBOSE | re.IGNORECASE) +VERSION_LEGACY = Regex(LegacySpecifier._regex_str, re.VERBOSE | re.IGNORECASE) + +VERSION_ONE = VERSION_PEP440 ^ VERSION_LEGACY +VERSION_MANY = Combine( + VERSION_ONE + ZeroOrMore(COMMA + VERSION_ONE), joinString=",", adjacent=False +)("_raw_spec") +_VERSION_SPEC = Optional((LPAREN + VERSION_MANY + RPAREN) | VERSION_MANY) +_VERSION_SPEC.setParseAction(lambda s, l, t: t._raw_spec or "") + +VERSION_SPEC = originalTextFor(_VERSION_SPEC)("specifier") +VERSION_SPEC.setParseAction(lambda s, l, t: t[1]) + +MARKER_EXPR = originalTextFor(MARKER_EXPR())("marker") +MARKER_EXPR.setParseAction( + lambda s, l, t: Marker(s[t._original_start : t._original_end]) +) +MARKER_SEPARATOR = SEMICOLON +MARKER = MARKER_SEPARATOR + MARKER_EXPR + +VERSION_AND_MARKER = VERSION_SPEC + Optional(MARKER) +URL_AND_MARKER = URL + Optional(MARKER) + +NAMED_REQUIREMENT = NAME + Optional(EXTRAS) + (URL_AND_MARKER | VERSION_AND_MARKER) + +REQUIREMENT = stringStart + NAMED_REQUIREMENT + stringEnd +# pyparsing isn't thread safe during initialization, so we do it eagerly, see +# issue #104 +REQUIREMENT.parseString("x[]") + + +class Requirement: + """Parse a requirement. + + Parse a given requirement string into its parts, such as name, specifier, + URL, and extras. Raises InvalidRequirement on a badly-formed requirement + string. + """ + + # TODO: Can we test whether something is contained within a requirement? + # If so how do we do that? Do we need to test against the _name_ of + # the thing as well as the version? What about the markers? + # TODO: Can we normalize the name and extra name? + + def __init__(self, requirement_string: str) -> None: + try: + req = REQUIREMENT.parseString(requirement_string) + except ParseException as e: + raise InvalidRequirement( + f'Parse error at "{ requirement_string[e.loc : e.loc + 8]!r}": {e.msg}' + ) + + self.name: str = req.name + if req.url: + parsed_url = urllib.parse.urlparse(req.url) + if parsed_url.scheme == "file": + if urllib.parse.urlunparse(parsed_url) != req.url: + raise InvalidRequirement("Invalid URL given") + elif not (parsed_url.scheme and parsed_url.netloc) or ( + not parsed_url.scheme and not parsed_url.netloc + ): + raise InvalidRequirement(f"Invalid URL: {req.url}") + self.url: TOptional[str] = req.url + else: + self.url = None + self.extras: Set[str] = set(req.extras.asList() if req.extras else []) + self.specifier: SpecifierSet = SpecifierSet(req.specifier) + self.marker: TOptional[Marker] = req.marker if req.marker else None + + def __str__(self) -> str: + parts: List[str] = [self.name] + + if self.extras: + formatted_extras = ",".join(sorted(self.extras)) + parts.append(f"[{formatted_extras}]") + + if self.specifier: + parts.append(str(self.specifier)) + + if self.url: + parts.append(f"@ {self.url}") + if self.marker: + parts.append(" ") + + if self.marker: + parts.append(f"; {self.marker}") + + return "".join(parts) + + def __repr__(self) -> str: + return f"" diff --git a/llmeval-env/lib/python3.10/site-packages/pip/_vendor/packaging/tags.py b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/packaging/tags.py new file mode 100644 index 0000000000000000000000000000000000000000..9a3d25a71c75c975291cf987001ecd6882d6417d --- /dev/null +++ b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/packaging/tags.py @@ -0,0 +1,487 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +import logging +import platform +import sys +import sysconfig +from importlib.machinery import EXTENSION_SUFFIXES +from typing import ( + Dict, + FrozenSet, + Iterable, + Iterator, + List, + Optional, + Sequence, + Tuple, + Union, + cast, +) + +from . import _manylinux, _musllinux + +logger = logging.getLogger(__name__) + +PythonVersion = Sequence[int] +MacVersion = Tuple[int, int] + +INTERPRETER_SHORT_NAMES: Dict[str, str] = { + "python": "py", # Generic. + "cpython": "cp", + "pypy": "pp", + "ironpython": "ip", + "jython": "jy", +} + + +_32_BIT_INTERPRETER = sys.maxsize <= 2 ** 32 + + +class Tag: + """ + A representation of the tag triple for a wheel. + + Instances are considered immutable and thus are hashable. Equality checking + is also supported. + """ + + __slots__ = ["_interpreter", "_abi", "_platform", "_hash"] + + def __init__(self, interpreter: str, abi: str, platform: str) -> None: + self._interpreter = interpreter.lower() + self._abi = abi.lower() + self._platform = platform.lower() + # The __hash__ of every single element in a Set[Tag] will be evaluated each time + # that a set calls its `.disjoint()` method, which may be called hundreds of + # times when scanning a page of links for packages with tags matching that + # Set[Tag]. Pre-computing the value here produces significant speedups for + # downstream consumers. + self._hash = hash((self._interpreter, self._abi, self._platform)) + + @property + def interpreter(self) -> str: + return self._interpreter + + @property + def abi(self) -> str: + return self._abi + + @property + def platform(self) -> str: + return self._platform + + def __eq__(self, other: object) -> bool: + if not isinstance(other, Tag): + return NotImplemented + + return ( + (self._hash == other._hash) # Short-circuit ASAP for perf reasons. + and (self._platform == other._platform) + and (self._abi == other._abi) + and (self._interpreter == other._interpreter) + ) + + def __hash__(self) -> int: + return self._hash + + def __str__(self) -> str: + return f"{self._interpreter}-{self._abi}-{self._platform}" + + def __repr__(self) -> str: + return f"<{self} @ {id(self)}>" + + +def parse_tag(tag: str) -> FrozenSet[Tag]: + """ + Parses the provided tag (e.g. `py3-none-any`) into a frozenset of Tag instances. + + Returning a set is required due to the possibility that the tag is a + compressed tag set. + """ + tags = set() + interpreters, abis, platforms = tag.split("-") + for interpreter in interpreters.split("."): + for abi in abis.split("."): + for platform_ in platforms.split("."): + tags.add(Tag(interpreter, abi, platform_)) + return frozenset(tags) + + +def _get_config_var(name: str, warn: bool = False) -> Union[int, str, None]: + value = sysconfig.get_config_var(name) + if value is None and warn: + logger.debug( + "Config variable '%s' is unset, Python ABI tag may be incorrect", name + ) + return value + + +def _normalize_string(string: str) -> str: + return string.replace(".", "_").replace("-", "_") + + +def _abi3_applies(python_version: PythonVersion) -> bool: + """ + Determine if the Python version supports abi3. + + PEP 384 was first implemented in Python 3.2. + """ + return len(python_version) > 1 and tuple(python_version) >= (3, 2) + + +def _cpython_abis(py_version: PythonVersion, warn: bool = False) -> List[str]: + py_version = tuple(py_version) # To allow for version comparison. + abis = [] + version = _version_nodot(py_version[:2]) + debug = pymalloc = ucs4 = "" + with_debug = _get_config_var("Py_DEBUG", warn) + has_refcount = hasattr(sys, "gettotalrefcount") + # Windows doesn't set Py_DEBUG, so checking for support of debug-compiled + # extension modules is the best option. + # https://github.com/pypa/pip/issues/3383#issuecomment-173267692 + has_ext = "_d.pyd" in EXTENSION_SUFFIXES + if with_debug or (with_debug is None and (has_refcount or has_ext)): + debug = "d" + if py_version < (3, 8): + with_pymalloc = _get_config_var("WITH_PYMALLOC", warn) + if with_pymalloc or with_pymalloc is None: + pymalloc = "m" + if py_version < (3, 3): + unicode_size = _get_config_var("Py_UNICODE_SIZE", warn) + if unicode_size == 4 or ( + unicode_size is None and sys.maxunicode == 0x10FFFF + ): + ucs4 = "u" + elif debug: + # Debug builds can also load "normal" extension modules. + # We can also assume no UCS-4 or pymalloc requirement. + abis.append(f"cp{version}") + abis.insert( + 0, + "cp{version}{debug}{pymalloc}{ucs4}".format( + version=version, debug=debug, pymalloc=pymalloc, ucs4=ucs4 + ), + ) + return abis + + +def cpython_tags( + python_version: Optional[PythonVersion] = None, + abis: Optional[Iterable[str]] = None, + platforms: Optional[Iterable[str]] = None, + *, + warn: bool = False, +) -> Iterator[Tag]: + """ + Yields the tags for a CPython interpreter. + + The tags consist of: + - cp-- + - cp-abi3- + - cp-none- + - cp-abi3- # Older Python versions down to 3.2. + + If python_version only specifies a major version then user-provided ABIs and + the 'none' ABItag will be used. + + If 'abi3' or 'none' are specified in 'abis' then they will be yielded at + their normal position and not at the beginning. + """ + if not python_version: + python_version = sys.version_info[:2] + + interpreter = f"cp{_version_nodot(python_version[:2])}" + + if abis is None: + if len(python_version) > 1: + abis = _cpython_abis(python_version, warn) + else: + abis = [] + abis = list(abis) + # 'abi3' and 'none' are explicitly handled later. + for explicit_abi in ("abi3", "none"): + try: + abis.remove(explicit_abi) + except ValueError: + pass + + platforms = list(platforms or platform_tags()) + for abi in abis: + for platform_ in platforms: + yield Tag(interpreter, abi, platform_) + if _abi3_applies(python_version): + yield from (Tag(interpreter, "abi3", platform_) for platform_ in platforms) + yield from (Tag(interpreter, "none", platform_) for platform_ in platforms) + + if _abi3_applies(python_version): + for minor_version in range(python_version[1] - 1, 1, -1): + for platform_ in platforms: + interpreter = "cp{version}".format( + version=_version_nodot((python_version[0], minor_version)) + ) + yield Tag(interpreter, "abi3", platform_) + + +def _generic_abi() -> Iterator[str]: + abi = sysconfig.get_config_var("SOABI") + if abi: + yield _normalize_string(abi) + + +def generic_tags( + interpreter: Optional[str] = None, + abis: Optional[Iterable[str]] = None, + platforms: Optional[Iterable[str]] = None, + *, + warn: bool = False, +) -> Iterator[Tag]: + """ + Yields the tags for a generic interpreter. + + The tags consist of: + - -- + + The "none" ABI will be added if it was not explicitly provided. + """ + if not interpreter: + interp_name = interpreter_name() + interp_version = interpreter_version(warn=warn) + interpreter = "".join([interp_name, interp_version]) + if abis is None: + abis = _generic_abi() + platforms = list(platforms or platform_tags()) + abis = list(abis) + if "none" not in abis: + abis.append("none") + for abi in abis: + for platform_ in platforms: + yield Tag(interpreter, abi, platform_) + + +def _py_interpreter_range(py_version: PythonVersion) -> Iterator[str]: + """ + Yields Python versions in descending order. + + After the latest version, the major-only version will be yielded, and then + all previous versions of that major version. + """ + if len(py_version) > 1: + yield f"py{_version_nodot(py_version[:2])}" + yield f"py{py_version[0]}" + if len(py_version) > 1: + for minor in range(py_version[1] - 1, -1, -1): + yield f"py{_version_nodot((py_version[0], minor))}" + + +def compatible_tags( + python_version: Optional[PythonVersion] = None, + interpreter: Optional[str] = None, + platforms: Optional[Iterable[str]] = None, +) -> Iterator[Tag]: + """ + Yields the sequence of tags that are compatible with a specific version of Python. + + The tags consist of: + - py*-none- + - -none-any # ... if `interpreter` is provided. + - py*-none-any + """ + if not python_version: + python_version = sys.version_info[:2] + platforms = list(platforms or platform_tags()) + for version in _py_interpreter_range(python_version): + for platform_ in platforms: + yield Tag(version, "none", platform_) + if interpreter: + yield Tag(interpreter, "none", "any") + for version in _py_interpreter_range(python_version): + yield Tag(version, "none", "any") + + +def _mac_arch(arch: str, is_32bit: bool = _32_BIT_INTERPRETER) -> str: + if not is_32bit: + return arch + + if arch.startswith("ppc"): + return "ppc" + + return "i386" + + +def _mac_binary_formats(version: MacVersion, cpu_arch: str) -> List[str]: + formats = [cpu_arch] + if cpu_arch == "x86_64": + if version < (10, 4): + return [] + formats.extend(["intel", "fat64", "fat32"]) + + elif cpu_arch == "i386": + if version < (10, 4): + return [] + formats.extend(["intel", "fat32", "fat"]) + + elif cpu_arch == "ppc64": + # TODO: Need to care about 32-bit PPC for ppc64 through 10.2? + if version > (10, 5) or version < (10, 4): + return [] + formats.append("fat64") + + elif cpu_arch == "ppc": + if version > (10, 6): + return [] + formats.extend(["fat32", "fat"]) + + if cpu_arch in {"arm64", "x86_64"}: + formats.append("universal2") + + if cpu_arch in {"x86_64", "i386", "ppc64", "ppc", "intel"}: + formats.append("universal") + + return formats + + +def mac_platforms( + version: Optional[MacVersion] = None, arch: Optional[str] = None +) -> Iterator[str]: + """ + Yields the platform tags for a macOS system. + + The `version` parameter is a two-item tuple specifying the macOS version to + generate platform tags for. The `arch` parameter is the CPU architecture to + generate platform tags for. Both parameters default to the appropriate value + for the current system. + """ + version_str, _, cpu_arch = platform.mac_ver() + if version is None: + version = cast("MacVersion", tuple(map(int, version_str.split(".")[:2]))) + else: + version = version + if arch is None: + arch = _mac_arch(cpu_arch) + else: + arch = arch + + if (10, 0) <= version and version < (11, 0): + # Prior to Mac OS 11, each yearly release of Mac OS bumped the + # "minor" version number. The major version was always 10. + for minor_version in range(version[1], -1, -1): + compat_version = 10, minor_version + binary_formats = _mac_binary_formats(compat_version, arch) + for binary_format in binary_formats: + yield "macosx_{major}_{minor}_{binary_format}".format( + major=10, minor=minor_version, binary_format=binary_format + ) + + if version >= (11, 0): + # Starting with Mac OS 11, each yearly release bumps the major version + # number. The minor versions are now the midyear updates. + for major_version in range(version[0], 10, -1): + compat_version = major_version, 0 + binary_formats = _mac_binary_formats(compat_version, arch) + for binary_format in binary_formats: + yield "macosx_{major}_{minor}_{binary_format}".format( + major=major_version, minor=0, binary_format=binary_format + ) + + if version >= (11, 0): + # Mac OS 11 on x86_64 is compatible with binaries from previous releases. + # Arm64 support was introduced in 11.0, so no Arm binaries from previous + # releases exist. + # + # However, the "universal2" binary format can have a + # macOS version earlier than 11.0 when the x86_64 part of the binary supports + # that version of macOS. + if arch == "x86_64": + for minor_version in range(16, 3, -1): + compat_version = 10, minor_version + binary_formats = _mac_binary_formats(compat_version, arch) + for binary_format in binary_formats: + yield "macosx_{major}_{minor}_{binary_format}".format( + major=compat_version[0], + minor=compat_version[1], + binary_format=binary_format, + ) + else: + for minor_version in range(16, 3, -1): + compat_version = 10, minor_version + binary_format = "universal2" + yield "macosx_{major}_{minor}_{binary_format}".format( + major=compat_version[0], + minor=compat_version[1], + binary_format=binary_format, + ) + + +def _linux_platforms(is_32bit: bool = _32_BIT_INTERPRETER) -> Iterator[str]: + linux = _normalize_string(sysconfig.get_platform()) + if is_32bit: + if linux == "linux_x86_64": + linux = "linux_i686" + elif linux == "linux_aarch64": + linux = "linux_armv7l" + _, arch = linux.split("_", 1) + yield from _manylinux.platform_tags(linux, arch) + yield from _musllinux.platform_tags(arch) + yield linux + + +def _generic_platforms() -> Iterator[str]: + yield _normalize_string(sysconfig.get_platform()) + + +def platform_tags() -> Iterator[str]: + """ + Provides the platform tags for this installation. + """ + if platform.system() == "Darwin": + return mac_platforms() + elif platform.system() == "Linux": + return _linux_platforms() + else: + return _generic_platforms() + + +def interpreter_name() -> str: + """ + Returns the name of the running interpreter. + """ + name = sys.implementation.name + return INTERPRETER_SHORT_NAMES.get(name) or name + + +def interpreter_version(*, warn: bool = False) -> str: + """ + Returns the version of the running interpreter. + """ + version = _get_config_var("py_version_nodot", warn=warn) + if version: + version = str(version) + else: + version = _version_nodot(sys.version_info[:2]) + return version + + +def _version_nodot(version: PythonVersion) -> str: + return "".join(map(str, version)) + + +def sys_tags(*, warn: bool = False) -> Iterator[Tag]: + """ + Returns the sequence of tag triples for the running interpreter. + + The order of the sequence corresponds to priority order for the + interpreter, from most to least important. + """ + + interp_name = interpreter_name() + if interp_name == "cp": + yield from cpython_tags(warn=warn) + else: + yield from generic_tags() + + if interp_name == "pp": + yield from compatible_tags(interpreter="pp3") + else: + yield from compatible_tags() diff --git a/llmeval-env/lib/python3.10/site-packages/pip/_vendor/platformdirs/__init__.py b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/platformdirs/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..089b515743624b052d65c0e61d425ba765c2f9fd --- /dev/null +++ b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/platformdirs/__init__.py @@ -0,0 +1,331 @@ +""" +Utilities for determining application-specific dirs. See for details and +usage. +""" +from __future__ import annotations + +import importlib +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__ + + +def _set_platform_dir_class() -> type[PlatformDirsABC]: + if os.getenv("ANDROID_DATA") == "/data" and os.getenv("ANDROID_ROOT") == "/system": + module, name = "pip._vendor.platformdirs.android", "Android" + elif sys.platform == "win32": + module, name = "pip._vendor.platformdirs.windows", "Windows" + elif sys.platform == "darwin": + module, name = "pip._vendor.platformdirs.macos", "MacOS" + else: + module, name = "pip._vendor.platformdirs.unix", "Unix" + result: type[PlatformDirsABC] = getattr(importlib.import_module(module), name) + return result + + +PlatformDirs = _set_platform_dir_class() #: Currently active platform +AppDirs = PlatformDirs #: Backwards compatibility with appdirs + + +def user_data_dir( + appname: str | None = None, + appauthor: str | None | Literal[False] = None, + version: str | None = None, + roaming: bool = False, +) -> str: + """ + :param appname: See `appname `. + :param appauthor: See `appauthor `. + :param version: See `version `. + :param roaming: See `roaming `. + :returns: data directory tied to the user + """ + return PlatformDirs(appname=appname, appauthor=appauthor, version=version, roaming=roaming).user_data_dir + + +def site_data_dir( + appname: str | None = None, + appauthor: str | None | Literal[False] = None, + version: str | None = None, + multipath: bool = False, +) -> str: + """ + :param appname: See `appname `. + :param appauthor: See `appauthor `. + :param version: See `version `. + :param multipath: See `roaming `. + :returns: data directory shared by users + """ + return PlatformDirs(appname=appname, appauthor=appauthor, version=version, multipath=multipath).site_data_dir + + +def user_config_dir( + appname: str | None = None, + appauthor: str | None | Literal[False] = None, + version: str | None = None, + roaming: bool = False, +) -> str: + """ + :param appname: See `appname `. + :param appauthor: See `appauthor `. + :param version: See `version `. + :param roaming: See `roaming `. + :returns: config directory tied to the user + """ + return PlatformDirs(appname=appname, appauthor=appauthor, version=version, roaming=roaming).user_config_dir + + +def site_config_dir( + appname: str | None = None, + appauthor: str | None | Literal[False] = None, + version: str | None = None, + multipath: bool = False, +) -> str: + """ + :param appname: See `appname `. + :param appauthor: See `appauthor `. + :param version: See `version `. + :param multipath: See `roaming `. + :returns: config directory shared by the users + """ + return PlatformDirs(appname=appname, appauthor=appauthor, version=version, multipath=multipath).site_config_dir + + +def user_cache_dir( + appname: str | None = None, + appauthor: str | None | Literal[False] = None, + version: str | None = None, + opinion: bool = True, +) -> str: + """ + :param appname: See `appname `. + :param appauthor: See `appauthor `. + :param version: See `version `. + :param opinion: See `roaming `. + :returns: cache directory tied to the user + """ + return PlatformDirs(appname=appname, appauthor=appauthor, version=version, opinion=opinion).user_cache_dir + + +def user_state_dir( + appname: str | None = None, + appauthor: str | None | Literal[False] = None, + version: str | None = None, + roaming: bool = False, +) -> str: + """ + :param appname: See `appname `. + :param appauthor: See `appauthor `. + :param version: See `version `. + :param roaming: See `roaming `. + :returns: state directory tied to the user + """ + return PlatformDirs(appname=appname, appauthor=appauthor, version=version, roaming=roaming).user_state_dir + + +def user_log_dir( + appname: str | None = None, + appauthor: str | None | Literal[False] = None, + version: str | None = None, + opinion: bool = True, +) -> str: + """ + :param appname: See `appname `. + :param appauthor: See `appauthor `. + :param version: See `version `. + :param opinion: See `roaming `. + :returns: log directory tied to the user + """ + return PlatformDirs(appname=appname, appauthor=appauthor, version=version, opinion=opinion).user_log_dir + + +def user_documents_dir() -> str: + """ + :returns: documents directory tied to the user + """ + return PlatformDirs().user_documents_dir + + +def user_runtime_dir( + appname: str | None = None, + appauthor: str | None | Literal[False] = None, + version: str | None = None, + opinion: bool = True, +) -> str: + """ + :param appname: See `appname `. + :param appauthor: See `appauthor `. + :param version: See `version `. + :param opinion: See `opinion `. + :returns: runtime directory tied to the user + """ + return PlatformDirs(appname=appname, appauthor=appauthor, version=version, opinion=opinion).user_runtime_dir + + +def user_data_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: data path tied to the user + """ + return PlatformDirs(appname=appname, appauthor=appauthor, version=version, roaming=roaming).user_data_path + + +def site_data_path( + appname: str | None = None, + appauthor: str | None | Literal[False] = None, + version: str | None = None, + multipath: bool = False, +) -> Path: + """ + :param appname: See `appname `. + :param appauthor: See `appauthor `. + :param version: See `version `. + :param multipath: See `multipath `. + :returns: data path shared by users + """ + return PlatformDirs(appname=appname, appauthor=appauthor, version=version, multipath=multipath).site_data_path + + +def user_config_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: config path tied to the user + """ + return PlatformDirs(appname=appname, appauthor=appauthor, version=version, roaming=roaming).user_config_path + + +def site_config_path( + appname: str | None = None, + appauthor: str | None | Literal[False] = None, + version: str | None = None, + multipath: bool = False, +) -> Path: + """ + :param appname: See `appname `. + :param appauthor: See `appauthor `. + :param version: See `version `. + :param multipath: See `roaming `. + :returns: config path shared by the users + """ + return PlatformDirs(appname=appname, appauthor=appauthor, version=version, multipath=multipath).site_config_path + + +def user_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, +) -> Path: + """ + :param appname: See `appname `. + :param appauthor: See `appauthor `. + :param version: See `version `. + :param opinion: See `opinion `. + :returns: runtime path tied to the user + """ + return PlatformDirs(appname=appname, appauthor=appauthor, version=version, opinion=opinion).user_runtime_path + + +__all__ = [ + "__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_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", +] diff --git a/llmeval-env/lib/python3.10/site-packages/pip/_vendor/platformdirs/__main__.py b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/platformdirs/__main__.py new file mode 100644 index 0000000000000000000000000000000000000000..9c54bfb438d241ad17ce15d1e1346200ddf46b1c --- /dev/null +++ b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/platformdirs/__main__.py @@ -0,0 +1,46 @@ +from __future__ import annotations + +from pip._vendor.platformdirs import PlatformDirs, __version__ + +PROPS = ( + "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_config_dir", +) + + +def main() -> None: + app_name = "MyApp" + app_author = "MyCompany" + + print(f"-- platformdirs {__version__} --") + + print("-- app dirs (with optional 'version')") + dirs = PlatformDirs(app_name, app_author, version="1.0") + for prop in PROPS: + print(f"{prop}: {getattr(dirs, prop)}") + + print("\n-- app dirs (without optional 'version')") + dirs = PlatformDirs(app_name, app_author) + for prop in PROPS: + print(f"{prop}: {getattr(dirs, prop)}") + + print("\n-- app dirs (without optional 'appauthor')") + dirs = PlatformDirs(app_name) + for prop in PROPS: + print(f"{prop}: {getattr(dirs, prop)}") + + print("\n-- app dirs (with disabled 'appauthor')") + dirs = PlatformDirs(app_name, appauthor=False) + for prop in PROPS: + print(f"{prop}: {getattr(dirs, prop)}") + + +if __name__ == "__main__": + main() diff --git a/llmeval-env/lib/python3.10/site-packages/pip/_vendor/platformdirs/__pycache__/__init__.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/platformdirs/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1d5ec9e64da2c17cf0d0deb214802a6037f3e37b Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/platformdirs/__pycache__/__init__.cpython-310.pyc differ diff --git a/llmeval-env/lib/python3.10/site-packages/pip/_vendor/platformdirs/__pycache__/__main__.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/platformdirs/__pycache__/__main__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3ef278e440341cace81020e6d742347a0578f779 Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/platformdirs/__pycache__/__main__.cpython-310.pyc differ diff --git a/llmeval-env/lib/python3.10/site-packages/pip/_vendor/platformdirs/__pycache__/android.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/platformdirs/__pycache__/android.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5f666054d39ef679cae6299307bca55082158998 Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/platformdirs/__pycache__/android.cpython-310.pyc differ diff --git a/llmeval-env/lib/python3.10/site-packages/pip/_vendor/platformdirs/__pycache__/api.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/platformdirs/__pycache__/api.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3180e5e6f3d943a11f3d84ef833b6177290707a9 Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/platformdirs/__pycache__/api.cpython-310.pyc differ diff --git a/llmeval-env/lib/python3.10/site-packages/pip/_vendor/platformdirs/__pycache__/macos.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/platformdirs/__pycache__/macos.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9f3a6d69377569ad5adf7c6d99f90748b3ca12cd Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/platformdirs/__pycache__/macos.cpython-310.pyc differ diff --git a/llmeval-env/lib/python3.10/site-packages/pip/_vendor/platformdirs/__pycache__/unix.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/platformdirs/__pycache__/unix.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ad0af9cab0130d684df20302c12c6b320afb05d8 Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/platformdirs/__pycache__/unix.cpython-310.pyc differ diff --git a/llmeval-env/lib/python3.10/site-packages/pip/_vendor/platformdirs/__pycache__/windows.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/platformdirs/__pycache__/windows.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..95844aa6af1ec73dfedf88a80a1b1e7291694cc0 Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/platformdirs/__pycache__/windows.cpython-310.pyc differ diff --git a/llmeval-env/lib/python3.10/site-packages/pip/_vendor/platformdirs/android.py b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/platformdirs/android.py new file mode 100644 index 0000000000000000000000000000000000000000..a68405871f2991c4cfa6a36c1f6bc87e8b258299 --- /dev/null +++ b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/platformdirs/android.py @@ -0,0 +1,119 @@ +from __future__ import annotations + +import os +import re +import sys +from functools import lru_cache + +from .api import PlatformDirsABC + + +class Android(PlatformDirsABC): + """ + Follows the guidance `from here `_. Makes use of the + `appname ` and + `version `. + """ + + @property + def user_data_dir(self) -> str: + """:return: data directory tied to the user, e.g. ``/data/user///files/``""" + return self._append_app_name_and_version(_android_folder(), "files") + + @property + def site_data_dir(self) -> str: + """:return: data directory shared by users, same as `user_data_dir`""" + return self.user_data_dir + + @property + def user_config_dir(self) -> str: + """ + :return: config directory tied to the user, e.g. ``/data/user///shared_prefs/`` + """ + return self._append_app_name_and_version(_android_folder(), "shared_prefs") + + @property + def site_config_dir(self) -> str: + """:return: config directory shared by the users, same as `user_config_dir`""" + return self.user_config_dir + + @property + def user_cache_dir(self) -> str: + """:return: cache directory tied to the user, e.g. e.g. ``/data/user///cache/``""" + return self._append_app_name_and_version(_android_folder(), "cache") + + @property + def user_state_dir(self) -> str: + """:return: state directory tied to the user, same as `user_data_dir`""" + return self.user_data_dir + + @property + def user_log_dir(self) -> str: + """ + :return: log directory tied to the user, same as `user_cache_dir` if not opinionated else ``log`` in it, + e.g. ``/data/user///cache//log`` + """ + path = self.user_cache_dir + if self.opinion: + path = os.path.join(path, "log") + return path + + @property + def user_documents_dir(self) -> str: + """ + :return: documents directory tied to the user e.g. ``/storage/emulated/0/Documents`` + """ + return _android_documents_folder() + + @property + def user_runtime_dir(self) -> str: + """ + :return: runtime directory tied to the user, same as `user_cache_dir` if not opinionated else ``tmp`` in it, + e.g. ``/data/user///cache//tmp`` + """ + path = self.user_cache_dir + if self.opinion: + path = os.path.join(path, "tmp") + return path + + +@lru_cache(maxsize=1) +def _android_folder() -> str: + """:return: base folder for the Android OS""" + try: + # First try to get path to android app via pyjnius + from jnius import autoclass + + Context = autoclass("android.content.Context") # noqa: N806 + result: str = Context.getFilesDir().getParentFile().getAbsolutePath() + except Exception: + # if fails find an android folder looking path on the sys.path + pattern = re.compile(r"/data/(data|user/\d+)/(.+)/files") + for path in sys.path: + if pattern.match(path): + result = path.split("/files")[0] + break + else: + raise OSError("Cannot find path to android app folder") + return result + + +@lru_cache(maxsize=1) +def _android_documents_folder() -> str: + """:return: documents folder for the Android OS""" + # Get directories with pyjnius + try: + from jnius import autoclass + + 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: + documents_dir = "/storage/emulated/0/Documents" + + return documents_dir + + +__all__ = [ + "Android", +] diff --git a/llmeval-env/lib/python3.10/site-packages/pip/_vendor/platformdirs/api.py b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/platformdirs/api.py new file mode 100644 index 0000000000000000000000000000000000000000..6f6e2c2c69d25dba4d1038a2d548fbf68017f91b --- /dev/null +++ b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/platformdirs/api.py @@ -0,0 +1,156 @@ +from __future__ import annotations + +import os +import sys +from abc import ABC, abstractmethod +from pathlib import Path + +if sys.version_info >= (3, 8): # pragma: no branch + from typing import Literal # pragma: no cover + + +class PlatformDirsABC(ABC): + """ + Abstract base class for platform directories. + """ + + def __init__( + self, + appname: str | None = None, + appauthor: str | None | Literal[False] = None, + version: str | None = None, + roaming: bool = False, + multipath: bool = False, + opinion: bool = True, + ): + """ + Create a new platform directory. + + :param appname: See `appname`. + :param appauthor: See `appauthor`. + :param version: See `version`. + :param roaming: See `roaming`. + :param multipath: See `multipath`. + :param opinion: See `opinion`. + """ + 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. + """ + 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 ``.``. + """ + self.roaming = roaming + """ + Whether to use the roaming appdata directory on Windows. That means that for users on a Windows network setup + for roaming profiles, this user data will be synced on login (see + `here `_). + """ + self.multipath = multipath + """ + An optional parameter only applicable to Unix/Linux which indicates that the entire list of data dirs should be + returned. By default, the first item would only be returned. + """ + self.opinion = opinion #: A flag to indicating to use opinionated values. + + def _append_app_name_and_version(self, *base: str) -> str: + params = list(base[1:]) + if self.appname: + params.append(self.appname) + if self.version: + params.append(self.version) + return os.path.join(base[0], *params) + + @property + @abstractmethod + def user_data_dir(self) -> str: + """:return: data directory tied to the user""" + + @property + @abstractmethod + def site_data_dir(self) -> str: + """:return: data directory shared by users""" + + @property + @abstractmethod + def user_config_dir(self) -> str: + """:return: config directory tied to the user""" + + @property + @abstractmethod + def site_config_dir(self) -> str: + """:return: config directory shared by the users""" + + @property + @abstractmethod + def user_cache_dir(self) -> str: + """:return: cache directory tied to the user""" + + @property + @abstractmethod + def user_state_dir(self) -> str: + """:return: state directory tied to the user""" + + @property + @abstractmethod + def user_log_dir(self) -> str: + """:return: log directory tied to the user""" + + @property + @abstractmethod + def user_documents_dir(self) -> str: + """:return: documents directory tied to the user""" + + @property + @abstractmethod + def user_runtime_dir(self) -> str: + """:return: runtime directory tied to the user""" + + @property + def user_data_path(self) -> Path: + """:return: data path tied to the user""" + return Path(self.user_data_dir) + + @property + def site_data_path(self) -> Path: + """:return: data path shared by users""" + return Path(self.site_data_dir) + + @property + def user_config_path(self) -> Path: + """:return: config path tied to the user""" + return Path(self.user_config_dir) + + @property + def site_config_path(self) -> Path: + """:return: config path shared by the users""" + return Path(self.site_config_dir) + + @property + def user_cache_path(self) -> Path: + """:return: cache path tied to the user""" + return Path(self.user_cache_dir) + + @property + def user_state_path(self) -> Path: + """:return: state path tied to the user""" + return Path(self.user_state_dir) + + @property + def user_log_path(self) -> Path: + """:return: log path tied to the user""" + return Path(self.user_log_dir) + + @property + def user_documents_path(self) -> Path: + """:return: documents path tied to the user""" + return Path(self.user_documents_dir) + + @property + def user_runtime_path(self) -> Path: + """:return: runtime path tied to the user""" + return Path(self.user_runtime_dir) diff --git a/llmeval-env/lib/python3.10/site-packages/pip/_vendor/platformdirs/macos.py b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/platformdirs/macos.py new file mode 100644 index 0000000000000000000000000000000000000000..a01337c7764e1e1aba1f3ba378a1c9241f31806d --- /dev/null +++ b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/platformdirs/macos.py @@ -0,0 +1,64 @@ +from __future__ import annotations + +import os + +from .api import PlatformDirsABC + + +class MacOS(PlatformDirsABC): + """ + Platform directories for the macOS operating system. Follows the guidance from `Apple documentation + `_. + Makes use of the `appname ` and + `version `. + """ + + @property + def user_data_dir(self) -> str: + """:return: data directory tied to the user, e.g. ``~/Library/Application Support/$appname/$version``""" + return self._append_app_name_and_version(os.path.expanduser("~/Library/Application Support/")) + + @property + def site_data_dir(self) -> str: + """:return: data directory shared by users, e.g. ``/Library/Application Support/$appname/$version``""" + return self._append_app_name_and_version("/Library/Application Support") + + @property + def user_config_dir(self) -> str: + """:return: config directory tied to the user, e.g. ``~/Library/Preferences/$appname/$version``""" + return self._append_app_name_and_version(os.path.expanduser("~/Library/Preferences/")) + + @property + def site_config_dir(self) -> str: + """:return: config directory shared by the users, e.g. ``/Library/Preferences/$appname``""" + return self._append_app_name_and_version("/Library/Preferences") + + @property + def user_cache_dir(self) -> str: + """:return: cache directory tied to the user, e.g. ``~/Library/Caches/$appname/$version``""" + return self._append_app_name_and_version(os.path.expanduser("~/Library/Caches")) + + @property + def user_state_dir(self) -> str: + """:return: state directory tied to the user, same as `user_data_dir`""" + return self.user_data_dir + + @property + def user_log_dir(self) -> str: + """:return: log directory tied to the user, e.g. ``~/Library/Logs/$appname/$version``""" + return self._append_app_name_and_version(os.path.expanduser("~/Library/Logs")) + + @property + def user_documents_dir(self) -> str: + """:return: documents directory tied to the user, e.g. ``~/Documents``""" + return os.path.expanduser("~/Documents") + + @property + def user_runtime_dir(self) -> str: + """:return: runtime directory tied to the user, e.g. ``~/Library/Caches/TemporaryItems/$appname/$version``""" + return self._append_app_name_and_version(os.path.expanduser("~/Library/Caches/TemporaryItems")) + + +__all__ = [ + "MacOS", +] diff --git a/llmeval-env/lib/python3.10/site-packages/pip/_vendor/platformdirs/unix.py b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/platformdirs/unix.py new file mode 100644 index 0000000000000000000000000000000000000000..2fbd4d4f367863ff0cf635fddc5f6e44383e7d94 --- /dev/null +++ b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/platformdirs/unix.py @@ -0,0 +1,181 @@ +from __future__ import annotations + +import os +import sys +from configparser import ConfigParser +from pathlib import Path + +from .api import PlatformDirsABC + +if sys.platform.startswith("linux"): # pragma: no branch # no op check, only to please the type checker + from os import getuid +else: + + def getuid() -> int: + raise RuntimeError("should only be used on Linux") + + +class Unix(PlatformDirsABC): + """ + On Unix/Linux, we follow the + `XDG Basedir Spec `_. The spec allows + overriding directories with environment variables. The examples show are the default values, alongside the name of + the environment variable that overrides them. Makes use of the + `appname `, + `version `, + `multipath `, + `opinion `. + """ + + @property + def user_data_dir(self) -> str: + """ + :return: data directory tied to the user, e.g. ``~/.local/share/$appname/$version`` or + ``$XDG_DATA_HOME/$appname/$version`` + """ + path = os.environ.get("XDG_DATA_HOME", "") + if not path.strip(): + path = os.path.expanduser("~/.local/share") + return self._append_app_name_and_version(path) + + @property + def site_data_dir(self) -> str: + """ + :return: data directories shared by users (if `multipath ` is + enabled and ``XDG_DATA_DIR`` is set and a multi path the response is also a multi path separated by the OS + path separator), e.g. ``/usr/local/share/$appname/$version`` or ``/usr/share/$appname/$version`` + """ + # XDG default for $XDG_DATA_DIRS; only first, if multipath is False + path = os.environ.get("XDG_DATA_DIRS", "") + if not path.strip(): + path = f"/usr/local/share{os.pathsep}/usr/share" + return self._with_multi_path(path) + + def _with_multi_path(self, path: str) -> str: + path_list = path.split(os.pathsep) + if not self.multipath: + path_list = path_list[0:1] + path_list = [self._append_app_name_and_version(os.path.expanduser(p)) for p in path_list] + return os.pathsep.join(path_list) + + @property + def user_config_dir(self) -> str: + """ + :return: config directory tied to the user, e.g. ``~/.config/$appname/$version`` or + ``$XDG_CONFIG_HOME/$appname/$version`` + """ + path = os.environ.get("XDG_CONFIG_HOME", "") + if not path.strip(): + path = os.path.expanduser("~/.config") + return self._append_app_name_and_version(path) + + @property + def site_config_dir(self) -> str: + """ + :return: config directories shared by users (if `multipath ` + is enabled and ``XDG_DATA_DIR`` is set and a multi path the response is also a multi path separated by the OS + path separator), e.g. ``/etc/xdg/$appname/$version`` + """ + # XDG default for $XDG_CONFIG_DIRS only first, if multipath is False + path = os.environ.get("XDG_CONFIG_DIRS", "") + if not path.strip(): + path = "/etc/xdg" + return self._with_multi_path(path) + + @property + def user_cache_dir(self) -> str: + """ + :return: cache directory tied to the user, e.g. ``~/.cache/$appname/$version`` or + ``~/$XDG_CACHE_HOME/$appname/$version`` + """ + path = os.environ.get("XDG_CACHE_HOME", "") + if not path.strip(): + path = os.path.expanduser("~/.cache") + return self._append_app_name_and_version(path) + + @property + def user_state_dir(self) -> str: + """ + :return: state directory tied to the user, e.g. ``~/.local/state/$appname/$version`` or + ``$XDG_STATE_HOME/$appname/$version`` + """ + path = os.environ.get("XDG_STATE_HOME", "") + if not path.strip(): + path = os.path.expanduser("~/.local/state") + return self._append_app_name_and_version(path) + + @property + def user_log_dir(self) -> str: + """ + :return: log directory tied to the user, same as `user_data_dir` if not opinionated else ``log`` in it + """ + path = self.user_cache_dir + if self.opinion: + path = os.path.join(path, "log") + return path + + @property + def user_documents_dir(self) -> str: + """ + :return: documents directory tied to the user, e.g. ``~/Documents`` + """ + documents_dir = _get_user_dirs_folder("XDG_DOCUMENTS_DIR") + if documents_dir is None: + documents_dir = os.environ.get("XDG_DOCUMENTS_DIR", "").strip() + if not documents_dir: + documents_dir = os.path.expanduser("~/Documents") + + return documents_dir + + @property + def user_runtime_dir(self) -> str: + """ + :return: runtime directory tied to the user, e.g. ``/run/user/$(id -u)/$appname/$version`` or + ``$XDG_RUNTIME_DIR/$appname/$version`` + """ + path = os.environ.get("XDG_RUNTIME_DIR", "") + if not path.strip(): + path = f"/run/user/{getuid()}" + return self._append_app_name_and_version(path) + + @property + def site_data_path(self) -> Path: + """:return: data path shared by users. Only return first item, even if ``multipath`` is set to ``True``""" + return self._first_item_as_path_if_multipath(self.site_data_dir) + + @property + def site_config_path(self) -> Path: + """:return: config path shared by the users. Only return first item, even if ``multipath`` is set to ``True``""" + return self._first_item_as_path_if_multipath(self.site_config_dir) + + def _first_item_as_path_if_multipath(self, directory: str) -> Path: + if self.multipath: + # If multipath is True, the first path is returned. + directory = directory.split(os.pathsep)[0] + return Path(directory) + + +def _get_user_dirs_folder(key: str) -> str | None: + """Return directory from user-dirs.dirs config file. See https://freedesktop.org/wiki/Software/xdg-user-dirs/""" + user_dirs_config_path = os.path.join(Unix().user_config_dir, "user-dirs.dirs") + if os.path.exists(user_dirs_config_path): + parser = ConfigParser() + + with open(user_dirs_config_path) as stream: + # Add fake section header, so ConfigParser doesn't complain + parser.read_string(f"[top]\n{stream.read()}") + + if key not in parser["top"]: + return None + + path = parser["top"][key].strip('"') + # Handle relative home paths + path = path.replace("$HOME", os.path.expanduser("~")) + return path + + return None + + +__all__ = [ + "Unix", +] diff --git a/llmeval-env/lib/python3.10/site-packages/pip/_vendor/platformdirs/version.py b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/platformdirs/version.py new file mode 100644 index 0000000000000000000000000000000000000000..175ded8561778e5fa29fd33ec09727db7a2b31bb --- /dev/null +++ b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/platformdirs/version.py @@ -0,0 +1,4 @@ +""" Version information """ + +__version__ = "2.4.1" +__version_info__ = (2, 4, 1) diff --git a/llmeval-env/lib/python3.10/site-packages/pip/_vendor/platformdirs/windows.py b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/platformdirs/windows.py new file mode 100644 index 0000000000000000000000000000000000000000..ef972bdf29ce91b5abe3714eb92587458cf3f03c --- /dev/null +++ b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/platformdirs/windows.py @@ -0,0 +1,182 @@ +from __future__ import annotations + +import ctypes +import os +from functools import lru_cache +from typing import Callable + +from .api import PlatformDirsABC + + +class Windows(PlatformDirsABC): + """`MSDN on where to store app data files + `_. + Makes use of the + `appname `, + `appauthor `, + `version `, + `roaming `, + `opinion `.""" + + @property + def user_data_dir(self) -> str: + """ + :return: data directory tied to the user, e.g. + ``%USERPROFILE%\\AppData\\Local\\$appauthor\\$appname`` (not roaming) or + ``%USERPROFILE%\\AppData\\Roaming\\$appauthor\\$appname`` (roaming) + """ + const = "CSIDL_APPDATA" if self.roaming else "CSIDL_LOCAL_APPDATA" + path = os.path.normpath(get_win_folder(const)) + return self._append_parts(path) + + def _append_parts(self, path: str, *, opinion_value: str | None = None) -> str: + params = [] + if self.appname: + if self.appauthor is not False: + author = self.appauthor or self.appname + params.append(author) + params.append(self.appname) + if opinion_value is not None and self.opinion: + params.append(opinion_value) + if self.version: + params.append(self.version) + return os.path.join(path, *params) + + @property + def site_data_dir(self) -> str: + """:return: data directory shared by users, e.g. ``C:\\ProgramData\\$appauthor\\$appname``""" + path = os.path.normpath(get_win_folder("CSIDL_COMMON_APPDATA")) + return self._append_parts(path) + + @property + def user_config_dir(self) -> str: + """:return: config directory tied to the user, same as `user_data_dir`""" + return self.user_data_dir + + @property + def site_config_dir(self) -> str: + """:return: config directory shared by the users, same as `site_data_dir`""" + return self.site_data_dir + + @property + def user_cache_dir(self) -> str: + """ + :return: cache directory tied to the user (if opinionated with ``Cache`` folder within ``$appname``) e.g. + ``%USERPROFILE%\\AppData\\Local\\$appauthor\\$appname\\Cache\\$version`` + """ + path = os.path.normpath(get_win_folder("CSIDL_LOCAL_APPDATA")) + return self._append_parts(path, opinion_value="Cache") + + @property + def user_state_dir(self) -> str: + """:return: state directory tied to the user, same as `user_data_dir`""" + return self.user_data_dir + + @property + def user_log_dir(self) -> str: + """ + :return: log directory tied to the user, same as `user_data_dir` if not opinionated else ``Logs`` in it + """ + path = self.user_data_dir + if self.opinion: + path = os.path.join(path, "Logs") + return path + + @property + def user_documents_dir(self) -> str: + """ + :return: documents directory tied to the user e.g. ``%USERPROFILE%\\Documents`` + """ + return os.path.normpath(get_win_folder("CSIDL_PERSONAL")) + + @property + def user_runtime_dir(self) -> str: + """ + :return: runtime directory tied to the user, e.g. + ``%USERPROFILE%\\AppData\\Local\\Temp\\$appauthor\\$appname`` + """ + path = os.path.normpath(os.path.join(get_win_folder("CSIDL_LOCAL_APPDATA"), "Temp")) + return self._append_parts(path) + + +def get_win_folder_from_env_vars(csidl_name: str) -> str: + """Get folder from environment variables.""" + if csidl_name == "CSIDL_PERSONAL": # does not have an environment name + return os.path.join(os.path.normpath(os.environ["USERPROFILE"]), "Documents") + + env_var_name = { + "CSIDL_APPDATA": "APPDATA", + "CSIDL_COMMON_APPDATA": "ALLUSERSPROFILE", + "CSIDL_LOCAL_APPDATA": "LOCALAPPDATA", + }.get(csidl_name) + if env_var_name is None: + raise ValueError(f"Unknown CSIDL name: {csidl_name}") + result = os.environ.get(env_var_name) + if result is None: + raise ValueError(f"Unset environment variable: {env_var_name}") + return result + + +def get_win_folder_from_registry(csidl_name: str) -> str: + """Get folder from the registry. + + This is a fallback technique at best. I'm not sure if using the + registry for this guarantees us the correct answer for all CSIDL_* + names. + """ + shell_folder_name = { + "CSIDL_APPDATA": "AppData", + "CSIDL_COMMON_APPDATA": "Common AppData", + "CSIDL_LOCAL_APPDATA": "Local AppData", + "CSIDL_PERSONAL": "Personal", + }.get(csidl_name) + if shell_folder_name is None: + raise ValueError(f"Unknown CSIDL name: {csidl_name}") + + import winreg + + key = winreg.OpenKey(winreg.HKEY_CURRENT_USER, r"Software\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders") + directory, _ = winreg.QueryValueEx(key, shell_folder_name) + return str(directory) + + +def get_win_folder_via_ctypes(csidl_name: str) -> str: + """Get folder with ctypes.""" + csidl_const = { + "CSIDL_APPDATA": 26, + "CSIDL_COMMON_APPDATA": 35, + "CSIDL_LOCAL_APPDATA": 28, + "CSIDL_PERSONAL": 5, + }.get(csidl_name) + if csidl_const is None: + raise ValueError(f"Unknown CSIDL name: {csidl_name}") + + buf = ctypes.create_unicode_buffer(1024) + windll = getattr(ctypes, "windll") # noqa: B009 # using getattr to avoid false positive with mypy type checker + windll.shell32.SHGetFolderPathW(None, csidl_const, None, 0, buf) + + # Downgrade to short path name if it has highbit chars. + if any(ord(c) > 255 for c in buf): + buf2 = ctypes.create_unicode_buffer(1024) + if windll.kernel32.GetShortPathNameW(buf.value, buf2, 1024): + buf = buf2 + + return buf.value + + +def _pick_get_win_folder() -> Callable[[str], str]: + if hasattr(ctypes, "windll"): + return get_win_folder_via_ctypes + try: + import winreg # noqa: F401 + except ImportError: + return get_win_folder_from_env_vars + else: + return get_win_folder_from_registry + + +get_win_folder = lru_cache(maxsize=None)(_pick_get_win_folder()) + +__all__ = [ + "Windows", +] diff --git a/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/__main__.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/__main__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..66277839acdc4b0acb2804e9350dddf66b6a9da8 Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/__main__.cpython-310.pyc differ diff --git a/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_emoji_codes.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_emoji_codes.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..269b242a82c2ccb99cafbd1f2ee319646d34c0a2 Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_emoji_codes.cpython-310.pyc differ diff --git a/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_emoji_replace.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_emoji_replace.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..71b966b919fcc0803b531d3279b7178ec69602ee Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_emoji_replace.cpython-310.pyc differ diff --git a/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_extension.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_extension.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3bb823d750d64818093020f6caf5cf68c4c8730e Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_extension.cpython-310.pyc differ diff --git a/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_inspect.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_inspect.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..77b3b8763b86ae3e71dc67cecc1d3e5faca6a557 Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_inspect.cpython-310.pyc differ diff --git a/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_log_render.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_log_render.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a3ba0bc0f4a84a7453401bf874af9fd6887392c7 Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_log_render.cpython-310.pyc differ diff --git a/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_loop.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_loop.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..16ced6d7077e9209fef60abb100295d9ebe0a9ff Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_loop.cpython-310.pyc differ diff --git a/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_lru_cache.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_lru_cache.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..56410bfc03d860d2eddd6820b1a2d2a07a1b53ed Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_lru_cache.cpython-310.pyc differ diff --git a/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_palettes.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_palettes.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..cb82e0b59894fc0155f0fa9ab982ba8aa1710bf8 Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_palettes.cpython-310.pyc differ diff --git a/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_pick.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_pick.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d05a85aee92eb9085107637334b14ec1a37cfe33 Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_pick.cpython-310.pyc differ diff --git a/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_ratio.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_ratio.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a873077906336f19a45597ee12c2843676fdb0eb Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_ratio.cpython-310.pyc differ diff --git a/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_spinners.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_spinners.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e4ba045d93e0f8d4ae98db2dacf73d1bb5da9a55 Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_spinners.cpython-310.pyc differ diff --git a/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_stack.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_stack.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..03df89f2ecbad9c8e859c02eacedf859461126ed Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_stack.cpython-310.pyc differ diff --git a/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_timer.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_timer.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7aeac41cd33fdfc68b571c3502068cc2e67e445e Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_timer.cpython-310.pyc differ diff --git a/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_windows.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_windows.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c8eca613f5e68a77f562826b9d6c977c82c7a9d7 Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_windows.cpython-310.pyc differ diff --git a/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_wrap.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_wrap.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a5aa259fb5d0cf11787fe0db2b34fb01fa7b7337 Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/_wrap.cpython-310.pyc differ diff --git a/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/abc.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/abc.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1b55534203b29d5fff8209f988bc93224288f876 Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/abc.cpython-310.pyc differ diff --git a/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/align.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/align.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..41d9747f730391fabb1ba14510bf07de999b0f2f Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/align.cpython-310.pyc differ diff --git a/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/ansi.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/ansi.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..710641d2cfcfd2a50854ee2970c86f4dfba0351d Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/ansi.cpython-310.pyc differ diff --git a/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/box.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/box.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f5413d8d0fe1b88062b94c6b64951b2e59065608 Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/box.cpython-310.pyc differ diff --git a/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/cells.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/cells.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..33b8e22fea4ba3325ea944fb310a385581eb5c3b Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/cells.cpython-310.pyc differ diff --git a/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/color.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/color.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ce0230cbae4df96d0fd4d8b772e667a60d63a76b Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/color.cpython-310.pyc differ diff --git a/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/color_triplet.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/color_triplet.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4ff3cf0ce14d42e81f918a4d78f6a9284ab0a7fa Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/color_triplet.cpython-310.pyc differ diff --git a/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/columns.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/columns.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f513ea4acf846c2cdc4714e8cec2abb894916804 Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/columns.cpython-310.pyc differ diff --git a/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/console.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/console.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3e8a6a54d57bd096b843075cac7556c2ed978cc5 Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/console.cpython-310.pyc differ diff --git a/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/containers.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/containers.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d584c75a098d3689b6fe1fb4e5b821dedc4bda88 Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/containers.cpython-310.pyc differ diff --git a/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/control.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/control.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..764e3a7d904118a55a8e0ca2195f003b9bb2bd9d Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/control.cpython-310.pyc differ diff --git a/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/default_styles.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/default_styles.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..48570e5f7cb83c9211b6de14d72a9054bfe75bde Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/default_styles.cpython-310.pyc differ diff --git a/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/diagnose.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/diagnose.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f2f028a076aa6c9515eb0500dc87af6bd8693673 Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/diagnose.cpython-310.pyc differ diff --git a/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/emoji.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/emoji.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..06ebe8778d518fc155f0b0617242b35f4101b088 Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/emoji.cpython-310.pyc differ diff --git a/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/errors.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/errors.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c30a66cff2613aee1ac7dc27668b448e6389368e Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/errors.cpython-310.pyc differ diff --git a/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/filesize.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/filesize.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..349ba1a60c14073db1b8a7ce8d12008d2173423e Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/filesize.cpython-310.pyc differ diff --git a/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/highlighter.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/highlighter.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c1e1ceab3a613cdfd4afe393c272f21d123670e2 Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/highlighter.cpython-310.pyc differ diff --git a/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/json.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/json.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0229ad7842e36132f663281bf497b030288809ec Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/json.cpython-310.pyc differ diff --git a/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/jupyter.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/jupyter.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..683d054fca352f189ec2134d35482c12918010f5 Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/jupyter.cpython-310.pyc differ diff --git a/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/live.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/live.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0000485dbbd4aeb7fa19b9941321c460de6f4883 Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/live.cpython-310.pyc differ diff --git a/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/live_render.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/live_render.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ae090f1170c7ae80a1060fb047a89a0f06ee87f7 Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/live_render.cpython-310.pyc differ diff --git a/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/logging.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/logging.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9ef56f67d34600a471db93148f48956bc77dc0f5 Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/logging.cpython-310.pyc differ diff --git a/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/markup.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/markup.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a8c773099b3e9860dc0748d3a42bb1a545dc1135 Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/markup.cpython-310.pyc differ diff --git a/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/measure.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/measure.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..098f16f1ee42d047368c92c0d04e4053c1afd187 Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/measure.cpython-310.pyc differ diff --git a/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/padding.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/padding.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..98fccb7e6d376e267ecdc8088a1733353d2ea934 Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/padding.cpython-310.pyc differ diff --git a/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/progress.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/progress.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f81895c962867d7db97aa3d750e0df71c8074906 Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/progress.cpython-310.pyc differ diff --git a/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/progress_bar.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/progress_bar.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c7bef3f0e4090bb2a2267fe2dbac0c3565982dcf Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/progress_bar.cpython-310.pyc differ diff --git a/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/prompt.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/prompt.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..025da91b0ed030ab6fc861d8717c6a3553c8f003 Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/prompt.cpython-310.pyc differ diff --git a/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/region.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/region.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b42db657f286759785b1550ecfae21af9d1a2c3a Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/region.cpython-310.pyc differ diff --git a/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/rule.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/rule.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..793b664bcd6f937d26d79bb3f13b1586f5546109 Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/rule.cpython-310.pyc differ diff --git a/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/screen.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/screen.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..78952de0cd2670ad53b0768540545a30655b1067 Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/screen.cpython-310.pyc differ diff --git a/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/segment.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/segment.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ad86d2c2501864c8b039aea027176cc490a5039d Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/segment.cpython-310.pyc differ diff --git a/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/spinner.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/spinner.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..de4e0bf43f0e880d2d0f217599b106015b92d944 Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/spinner.cpython-310.pyc differ diff --git a/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/status.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/status.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..97e972648027d789d78bfd1c781aa136b27e2952 Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/status.cpython-310.pyc differ diff --git a/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/styled.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/styled.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a4254b5097dfe7f590c3409a4ebc6d21070deeeb Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/styled.cpython-310.pyc differ diff --git a/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/syntax.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/syntax.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..92e52dc30599a01616ba30cf8d62840b6a109ae5 Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/syntax.cpython-310.pyc differ diff --git a/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/table.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/table.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..39b3ce6238a80520157d50f8db053508dfcd6a3e Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/table.cpython-310.pyc differ diff --git a/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/terminal_theme.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/terminal_theme.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..568b0b251c812ff16ccbe149b619d5e272f5cd44 Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/terminal_theme.cpython-310.pyc differ diff --git a/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/text.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/text.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..14c374c47276be93ae9a819866af16bce9d4bf42 Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/text.cpython-310.pyc differ diff --git a/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/tree.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/tree.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d3e8988afb63b0c87051dc15363d020f726290f0 Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/tree.cpython-310.pyc differ