cli-ih 0.6.3.1__py3-none-any.whl → 0.7.0__py3-none-any.whl

venv/Lib/site-packages/pip/_vendor/tomli/_re.py

@@ -1,112 +0,0 @@
-# SPDX-License-Identifier: MIT
-# SPDX-FileCopyrightText: 2021 Taneli Hukkinen
-# Licensed to PSF under a Contributor Agreement.
-
-from __future__ import annotations
-
-from datetime import date, datetime, time, timedelta, timezone, tzinfo
-from functools import lru_cache
-import re
-from typing import Any, Final
-
-from ._types import ParseFloat
-
-# E.g.
-# - 00:32:00.999999
-# - 00:32:00
-_TIME_RE_STR: Final = (
-    r"([01][0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9])(?:\.([0-9]{1,6})[0-9]*)?"
-)
-
-RE_NUMBER: Final = re.compile(
-    r"""
-0
-(?:
-    x[0-9A-Fa-f](?:_?[0-9A-Fa-f])*   # hex
-    |
-    b[01](?:_?[01])*                 # bin
-    |
-    o[0-7](?:_?[0-7])*               # oct
-)
-|
-[+-]?(?:0|[1-9](?:_?[0-9])*)         # dec, integer part
-(?P<floatpart>
-    (?:\.[0-9](?:_?[0-9])*)?         # optional fractional part
-    (?:[eE][+-]?[0-9](?:_?[0-9])*)?  # optional exponent part
-)
-""",
-    flags=re.VERBOSE,
-)
-RE_LOCALTIME: Final = re.compile(_TIME_RE_STR)
-RE_DATETIME: Final = re.compile(
-    rf"""
-([0-9]{{4}})-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01])  # date, e.g. 1988-10-27
-(?:
-    [Tt ]
-    {_TIME_RE_STR}
-    (?:([Zz])|([+-])([01][0-9]|2[0-3]):([0-5][0-9]))?  # optional time offset
-)?
-""",
-    flags=re.VERBOSE,
-)
-
-
-def match_to_datetime(match: re.Match) -> datetime | date:
-    """Convert a `RE_DATETIME` match to `datetime.datetime` or `datetime.date`.
-
-    Raises ValueError if the match does not correspond to a valid date
-    or datetime.
-    """
-    (
-        year_str,
-        month_str,
-        day_str,
-        hour_str,
-        minute_str,
-        sec_str,
-        micros_str,
-        zulu_time,
-        offset_sign_str,
-        offset_hour_str,
-        offset_minute_str,
-    ) = match.groups()
-    year, month, day = int(year_str), int(month_str), int(day_str)
-    if hour_str is None:
-        return date(year, month, day)
-    hour, minute, sec = int(hour_str), int(minute_str), int(sec_str)
-    micros = int(micros_str.ljust(6, "0")) if micros_str else 0
-    if offset_sign_str:
-        tz: tzinfo | None = cached_tz(
-            offset_hour_str, offset_minute_str, offset_sign_str
-        )
-    elif zulu_time:
-        tz = timezone.utc
-    else:  # local date-time
-        tz = None
-    return datetime(year, month, day, hour, minute, sec, micros, tzinfo=tz)
-
-
-# No need to limit cache size. This is only ever called on input
-# that matched RE_DATETIME, so there is an implicit bound of
-# 24 (hours) * 60 (minutes) * 2 (offset direction) = 2880.
-@lru_cache(maxsize=None)
-def cached_tz(hour_str: str, minute_str: str, sign_str: str) -> timezone:
-    sign = 1 if sign_str == "+" else -1
-    return timezone(
-        timedelta(
-            hours=sign * int(hour_str),
-            minutes=sign * int(minute_str),
-        )
-    )
-
-
-def match_to_localtime(match: re.Match) -> time:
-    hour_str, minute_str, sec_str, micros_str = match.groups()
-    micros = int(micros_str.ljust(6, "0")) if micros_str else 0
-    return time(int(hour_str), int(minute_str), int(sec_str), micros)
-
-
-def match_to_number(match: re.Match, parse_float: ParseFloat) -> Any:
-    if match.group("floatpart"):
-        return parse_float(match.group())
-    return int(match.group(), 0)

venv/Lib/site-packages/pip/_vendor/tomli/_types.py

@@ -1,10 +0,0 @@
-# SPDX-License-Identifier: MIT
-# SPDX-FileCopyrightText: 2021 Taneli Hukkinen
-# Licensed to PSF under a Contributor Agreement.
-
-from typing import Any, Callable, Tuple
-
-# Type annotations
-ParseFloat = Callable[[str], Any]
-Key = Tuple[str, ...]
-Pos = int

venv/Lib/site-packages/pip/_vendor/tomli/py.typed

@@ -1 +0,0 @@
-# Marker file for PEP 561

venv/Lib/site-packages/pip/_vendor/tomli_w/__init__.py

@@ -1,4 +0,0 @@
-__all__ = ("dumps", "dump")
-__version__ = "1.2.0"  # DO NOT EDIT THIS LINE MANUALLY. LET bump2version UTILITY DO IT
-
-from pip._vendor.tomli_w._writer import dump, dumps

venv/Lib/site-packages/pip/_vendor/tomli_w/_writer.py

@@ -1,229 +0,0 @@
-from __future__ import annotations
-
-from collections.abc import Mapping
-from datetime import date, datetime, time
-from types import MappingProxyType
-
-TYPE_CHECKING = False
-if TYPE_CHECKING:
-    from collections.abc import Generator
-    from decimal import Decimal
-    from typing import IO, Any, Final
-
-ASCII_CTRL = frozenset(chr(i) for i in range(32)) | frozenset(chr(127))
-ILLEGAL_BASIC_STR_CHARS = frozenset('"\\') | ASCII_CTRL - frozenset("\t")
-BARE_KEY_CHARS = frozenset(
-    "abcdefghijklmnopqrstuvwxyz" "ABCDEFGHIJKLMNOPQRSTUVWXYZ" "0123456789" "-_"
-)
-ARRAY_TYPES = (list, tuple)
-MAX_LINE_LENGTH = 100
-
-COMPACT_ESCAPES = MappingProxyType(
-    {
-        "\u0008": "\\b",  # backspace
-        "\u000A": "\\n",  # linefeed
-        "\u000C": "\\f",  # form feed
-        "\u000D": "\\r",  # carriage return
-        "\u0022": '\\"',  # quote
-        "\u005C": "\\\\",  # backslash
-    }
-)
-
-
-class Context:
-    def __init__(self, allow_multiline: bool, indent: int):
-        if indent < 0:
-            raise ValueError("Indent width must be non-negative")
-        self.allow_multiline: Final = allow_multiline
-        # cache rendered inline tables (mapping from object id to rendered inline table)
-        self.inline_table_cache: Final[dict[int, str]] = {}
-        self.indent_str: Final = " " * indent
-
-
-def dump(
-    obj: Mapping[str, Any],
-    fp: IO[bytes],
-    /,
-    *,
-    multiline_strings: bool = False,
-    indent: int = 4,
-) -> None:
-    ctx = Context(multiline_strings, indent)
-    for chunk in gen_table_chunks(obj, ctx, name=""):
-        fp.write(chunk.encode())
-
-
-def dumps(
-    obj: Mapping[str, Any], /, *, multiline_strings: bool = False, indent: int = 4
-) -> str:
-    ctx = Context(multiline_strings, indent)
-    return "".join(gen_table_chunks(obj, ctx, name=""))
-
-
-def gen_table_chunks(
-    table: Mapping[str, Any],
-    ctx: Context,
-    *,
-    name: str,
-    inside_aot: bool = False,
-) -> Generator[str, None, None]:
-    yielded = False
-    literals = []
-    tables: list[tuple[str, Any, bool]] = []  # => [(key, value, inside_aot)]
-    for k, v in table.items():
-        if isinstance(v, Mapping):
-            tables.append((k, v, False))
-        elif is_aot(v) and not all(is_suitable_inline_table(t, ctx) for t in v):
-            tables.extend((k, t, True) for t in v)
-        else:
-            literals.append((k, v))
-
-    if inside_aot or name and (literals or not tables):
-        yielded = True
-        yield f"[[{name}]]\n" if inside_aot else f"[{name}]\n"
-
-    if literals:
-        yielded = True
-        for k, v in literals:
-            yield f"{format_key_part(k)} = {format_literal(v, ctx)}\n"
-
-    for k, v, in_aot in tables:
-        if yielded:
-            yield "\n"
-        else:
-            yielded = True
-        key_part = format_key_part(k)
-        display_name = f"{name}.{key_part}" if name else key_part
-        yield from gen_table_chunks(v, ctx, name=display_name, inside_aot=in_aot)
-
-
-def format_literal(obj: object, ctx: Context, *, nest_level: int = 0) -> str:
-    if isinstance(obj, bool):
-        return "true" if obj else "false"
-    if isinstance(obj, (int, float, date, datetime)):
-        return str(obj)
-    if isinstance(obj, time):
-        if obj.tzinfo:
-            raise ValueError("TOML does not support offset times")
-        return str(obj)
-    if isinstance(obj, str):
-        return format_string(obj, allow_multiline=ctx.allow_multiline)
-    if isinstance(obj, ARRAY_TYPES):
-        return format_inline_array(obj, ctx, nest_level)
-    if isinstance(obj, Mapping):
-        return format_inline_table(obj, ctx)
-
-    # Lazy import to improve module import time
-    from decimal import Decimal
-
-    if isinstance(obj, Decimal):
-        return format_decimal(obj)
-    raise TypeError(
-        f"Object of type '{type(obj).__qualname__}' is not TOML serializable"
-    )
-
-
-def format_decimal(obj: Decimal) -> str:
-    if obj.is_nan():
-        return "nan"
-    if obj.is_infinite():
-        return "-inf" if obj.is_signed() else "inf"
-    dec_str = str(obj).lower()
-    return dec_str if "." in dec_str or "e" in dec_str else dec_str + ".0"
-
-
-def format_inline_table(obj: Mapping, ctx: Context) -> str:
-    # check cache first
-    obj_id = id(obj)
-    if obj_id in ctx.inline_table_cache:
-        return ctx.inline_table_cache[obj_id]
-
-    if not obj:
-        rendered = "{}"
-    else:
-        rendered = (
-            "{ "
-            + ", ".join(
-                f"{format_key_part(k)} = {format_literal(v, ctx)}"
-                for k, v in obj.items()
-            )
-            + " }"
-        )
-    ctx.inline_table_cache[obj_id] = rendered
-    return rendered
-
-
-def format_inline_array(obj: tuple | list, ctx: Context, nest_level: int) -> str:
-    if not obj:
-        return "[]"
-    item_indent = ctx.indent_str * (1 + nest_level)
-    closing_bracket_indent = ctx.indent_str * nest_level
-    return (
-        "[\n"
-        + ",\n".join(
-            item_indent + format_literal(item, ctx, nest_level=nest_level + 1)
-            for item in obj
-        )
-        + f",\n{closing_bracket_indent}]"
-    )
-
-
-def format_key_part(part: str) -> str:
-    try:
-        only_bare_key_chars = BARE_KEY_CHARS.issuperset(part)
-    except TypeError:
-        raise TypeError(
-            f"Invalid mapping key '{part}' of type '{type(part).__qualname__}'."
-            " A string is required."
-        ) from None
-
-    if part and only_bare_key_chars:
-        return part
-    return format_string(part, allow_multiline=False)
-
-
-def format_string(s: str, *, allow_multiline: bool) -> str:
-    do_multiline = allow_multiline and "\n" in s
-    if do_multiline:
-        result = '"""\n'
-        s = s.replace("\r\n", "\n")
-    else:
-        result = '"'
-
-    pos = seq_start = 0
-    while True:
-        try:
-            char = s[pos]
-        except IndexError:
-            result += s[seq_start:pos]
-            if do_multiline:
-                return result + '"""'
-            return result + '"'
-        if char in ILLEGAL_BASIC_STR_CHARS:
-            result += s[seq_start:pos]
-            if char in COMPACT_ESCAPES:
-                if do_multiline and char == "\n":
-                    result += "\n"
-                else:
-                    result += COMPACT_ESCAPES[char]
-            else:
-                result += "\\u" + hex(ord(char))[2:].rjust(4, "0")
-            seq_start = pos + 1
-        pos += 1
-
-
-def is_aot(obj: Any) -> bool:
-    """Decides if an object behaves as an array of tables (i.e. a nonempty list
-    of dicts)."""
-    return bool(
-        isinstance(obj, ARRAY_TYPES)
-        and obj
-        and all(isinstance(v, Mapping) for v in obj)
-    )
-
-
-def is_suitable_inline_table(obj: Mapping, ctx: Context) -> bool:
-    """Use heuristics to decide if the inline-style representation is a good
-    choice for a given table."""
-    rendered_inline = f"{ctx.indent_str}{format_inline_table(obj, ctx)},"
-    return len(rendered_inline) <= MAX_LINE_LENGTH and "\n" not in rendered_inline

venv/Lib/site-packages/pip/_vendor/tomli_w/py.typed

@@ -1 +0,0 @@
-# Marker file for PEP 561

venv/Lib/site-packages/pip/_vendor/truststore/__init__.py

@@ -1,36 +0,0 @@
-"""Verify certificates using native system trust stores"""
-
-import sys as _sys
-
-if _sys.version_info < (3, 10):
-    raise ImportError("truststore requires Python 3.10 or later")
-
-# Detect Python runtimes which don't implement SSLObject.get_unverified_chain() API
-# This API only became public in Python 3.13 but was available in CPython and PyPy since 3.10.
-if _sys.version_info < (3, 13) and _sys.implementation.name not in ("cpython", "pypy"):
-    try:
-        import ssl as _ssl
-    except ImportError:
-        raise ImportError("truststore requires the 'ssl' module")
-    else:
-        _sslmem = _ssl.MemoryBIO()
-        _sslobj = _ssl.create_default_context().wrap_bio(
-            _sslmem,
-            _sslmem,
-        )
-        try:
-            while not hasattr(_sslobj, "get_unverified_chain"):
-                _sslobj = _sslobj._sslobj  # type: ignore[attr-defined]
-        except AttributeError:
-            raise ImportError(
-                "truststore requires peer certificate chain APIs to be available"
-            ) from None
-
-        del _ssl, _sslobj, _sslmem  # noqa: F821
-
-from ._api import SSLContext, extract_from_ssl, inject_into_ssl  # noqa: E402
-
-del _api, _sys  # type: ignore[name-defined] # noqa: F821
-
-__all__ = ["SSLContext", "inject_into_ssl", "extract_from_ssl"]
-__version__ = "0.10.1"