venv

.venv/lib/python3.12/site-packages/pip/_vendor/cachecontrol/__init__.py

@@ -6,9 +6,10 @@
 
 Make it easy to import from cachecontrol without long namespaces.
 """
+
 __author__ = "Eric Larson"
 __email__ = "eric@ionrock.org"
-__version__ = "0.14.0"
+__version__ = "0.14.1"
 
 from pip._vendor.cachecontrol.adapter import CacheControlAdapter
 from pip._vendor.cachecontrol.controller import CacheController

.venv/lib/python3.12/site-packages/pip/_vendor/cachecontrol/adapter.py

@@ -77,7 +77,7 @@ class CacheControlAdapter(HTTPAdapter):
 
         return resp
 
-    def build_response(
+    def build_response(  # type: ignore[override]
         self,
         request: PreparedRequest,
         response: HTTPResponse,
@@ -143,7 +143,7 @@ class CacheControlAdapter(HTTPAdapter):
                         _update_chunk_length, response
                     )
 
-        resp: Response = super().build_response(request, response)  # type: ignore[no-untyped-call]
+        resp: Response = super().build_response(request, response)
 
         # See if we should invalidate the cache.
         if request.method in self.invalidating_methods and resp.ok:

.venv/lib/python3.12/site-packages/pip/_vendor/cachecontrol/cache.py

@@ -6,6 +6,7 @@
 The cache object API for implementing caches. The default is a thread
 safe in-memory dictionary.
 """
+
 from __future__ import annotations
 
 from threading import Lock

.venv/lib/python3.12/site-packages/pip/_vendor/cachecontrol/caches/file_cache.py

@@ -6,7 +6,7 @@ from __future__ import annotations
 import hashlib
 import os
 from textwrap import dedent
-from typing import IO, TYPE_CHECKING, Union
+from typing import IO, TYPE_CHECKING
 from pathlib import Path
 
 from pip._vendor.cachecontrol.cache import BaseCache, SeparateBodyBaseCache

.venv/lib/python3.12/site-packages/pip/_vendor/cachecontrol/controller.py

@@ -5,6 +5,7 @@
 """
 The httplib2 algorithms ported for use with requests.
 """
+
 from __future__ import annotations
 
 import calendar

.venv/lib/python3.12/site-packages/pip/_vendor/cachecontrol/filewrapper.py

@@ -38,10 +38,10 @@ class CallbackFileWrapper:
         self.__callback = callback
 
     def __getattr__(self, name: str) -> Any:
-        # The vaguaries of garbage collection means that self.__fp is
+        # The vagaries of garbage collection means that self.__fp is
         # not always set.  By using __getattribute__ and the private
         # name[0] allows looking up the attribute value and raising an
-        # AttributeError when it doesn't exist. This stop thigns from
+        # AttributeError when it doesn't exist. This stop things from
         # infinitely recursing calls to getattr in the case where
         # self.__fp hasn't been set.
         #

.venv/lib/python3.12/site-packages/pip/_vendor/cachecontrol/heuristics.py

@@ -68,7 +68,10 @@ class OneDayCache(BaseHeuristic):
 
         if "expires" not in response.headers:
             date = parsedate(response.headers["date"])
-            expires = expire_after(timedelta(days=1), date=datetime(*date[:6], tzinfo=timezone.utc))  # type: ignore[index,misc]
+            expires = expire_after(
+                timedelta(days=1),
+                date=datetime(*date[:6], tzinfo=timezone.utc),  # type: ignore[index,misc]
+            )
             headers["expires"] = datetime_to_header(expires)
             headers["cache-control"] = "public"
         return headers

.venv/lib/python3.12/site-packages/pip/_vendor/idna/__init__.py

@@ -1,4 +1,3 @@
-from .package_data import __version__
 from .core import (
     IDNABidiError,
     IDNAError,
@@ -20,8 +19,10 @@ from .core import (
     valid_string_length,
 )
 from .intranges import intranges_contain
+from .package_data import __version__
 
 __all__ = [
+    "__version__",
     "IDNABidiError",
     "IDNAError",
     "InvalidCodepoint",

.venv/lib/python3.12/site-packages/pip/_vendor/idna/codec.py

@@ -1,49 +1,51 @@
-from .core import encode, decode, alabel, ulabel, IDNAError
 import codecs
 import re
-from typing import Any, Tuple, Optional
+from typing import Any, Optional, Tuple
+
+from .core import IDNAError, alabel, decode, encode, ulabel
+
+_unicode_dots_re = re.compile("[\u002e\u3002\uff0e\uff61]")
 
-_unicode_dots_re = re.compile('[\u002e\u3002\uff0e\uff61]')
 
 class Codec(codecs.Codec):
-
-    def encode(self, data: str, errors: str = 'strict') -> Tuple[bytes, int]:
-        if errors != 'strict':
-            raise IDNAError('Unsupported error handling \"{}\"'.format(errors))
+    def encode(self, data: str, errors: str = "strict") -> Tuple[bytes, int]:
+        if errors != "strict":
+            raise IDNAError('Unsupported error handling "{}"'.format(errors))
 
         if not data:
             return b"", 0
 
         return encode(data), len(data)
 
-    def decode(self, data: bytes, errors: str = 'strict') -> Tuple[str, int]:
-        if errors != 'strict':
-            raise IDNAError('Unsupported error handling \"{}\"'.format(errors))
+    def decode(self, data: bytes, errors: str = "strict") -> Tuple[str, int]:
+        if errors != "strict":
+            raise IDNAError('Unsupported error handling "{}"'.format(errors))
 
         if not data:
-            return '', 0
+            return "", 0
 
         return decode(data), len(data)
 
+
 class IncrementalEncoder(codecs.BufferedIncrementalEncoder):
     def _buffer_encode(self, data: str, errors: str, final: bool) -> Tuple[bytes, int]:
-        if errors != 'strict':
-            raise IDNAError('Unsupported error handling \"{}\"'.format(errors))
+        if errors != "strict":
+            raise IDNAError('Unsupported error handling "{}"'.format(errors))
 
         if not data:
-            return b'', 0
+            return b"", 0
 
         labels = _unicode_dots_re.split(data)
-        trailing_dot = b''
+        trailing_dot = b""
         if labels:
             if not labels[-1]:
-                trailing_dot = b'.'
+                trailing_dot = b"."
                 del labels[-1]
             elif not final:
                 # Keep potentially unfinished label until the next call
                 del labels[-1]
                 if labels:
-                    trailing_dot = b'.'
+                    trailing_dot = b"."
 
         result = []
         size = 0
@@ -54,32 +56,33 @@ class IncrementalEncoder(codecs.BufferedIncrementalEncoder):
             size += len(label)
 
         # Join with U+002E
-        result_bytes = b'.'.join(result) + trailing_dot
+        result_bytes = b".".join(result) + trailing_dot
         size += len(trailing_dot)
         return result_bytes, size
 
+
 class IncrementalDecoder(codecs.BufferedIncrementalDecoder):
     def _buffer_decode(self, data: Any, errors: str, final: bool) -> Tuple[str, int]:
-        if errors != 'strict':
-            raise IDNAError('Unsupported error handling \"{}\"'.format(errors))
+        if errors != "strict":
+            raise IDNAError('Unsupported error handling "{}"'.format(errors))
 
         if not data:
-            return ('', 0)
+            return ("", 0)
 
         if not isinstance(data, str):
-            data = str(data, 'ascii')
+            data = str(data, "ascii")
 
         labels = _unicode_dots_re.split(data)
-        trailing_dot = ''
+        trailing_dot = ""
         if labels:
             if not labels[-1]:
-                trailing_dot = '.'
+                trailing_dot = "."
                 del labels[-1]
             elif not final:
                 # Keep potentially unfinished label until the next call
                 del labels[-1]
                 if labels:
-                    trailing_dot = '.'
+                    trailing_dot = "."
 
         result = []
         size = 0
@@ -89,7 +92,7 @@ class IncrementalDecoder(codecs.BufferedIncrementalDecoder):
                 size += 1
             size += len(label)
 
-        result_str = '.'.join(result) + trailing_dot
+        result_str = ".".join(result) + trailing_dot
         size += len(trailing_dot)
         return (result_str, size)
 
@@ -103,7 +106,7 @@ class StreamReader(Codec, codecs.StreamReader):
 
 
 def search_function(name: str) -> Optional[codecs.CodecInfo]:
-    if name != 'idna2008':
+    if name != "idna2008":
         return None
     return codecs.CodecInfo(
         name=name,
@@ -115,4 +118,5 @@ def search_function(name: str) -> Optional[codecs.CodecInfo]:
         streamreader=StreamReader,
     )
 
+
 codecs.register(search_function)

.venv/lib/python3.12/site-packages/pip/_vendor/idna/compat.py

@@ -1,13 +1,15 @@
-from .core import *
-from .codec import *
 from typing import Any, Union
 
+from .core import decode, encode
+
+
 def ToASCII(label: str) -> bytes:
     return encode(label)
 
+
 def ToUnicode(label: Union[bytes, bytearray]) -> str:
     return decode(label)
 
-def nameprep(s: Any) -> None:
-    raise NotImplementedError('IDNA 2008 does not utilise nameprep protocol')
 
+def nameprep(s: Any) -> None:
+    raise NotImplementedError("IDNA 2008 does not utilise nameprep protocol")

.venv/lib/python3.12/site-packages/pip/_vendor/idna/core.py

@@ -1,31 +1,37 @@
-from . import idnadata
 import bisect
-import unicodedata
 import re
-from typing import Union, Optional
+import unicodedata
+from typing import Optional, Union
+
+from . import idnadata
 from .intranges import intranges_contain
 
 _virama_combining_class = 9
-_alabel_prefix = b'xn--'
-_unicode_dots_re = re.compile('[\u002e\u3002\uff0e\uff61]')
+_alabel_prefix = b"xn--"
+_unicode_dots_re = re.compile("[\u002e\u3002\uff0e\uff61]")
+
 
 class IDNAError(UnicodeError):
-    """ Base exception for all IDNA-encoding related problems """
+    """Base exception for all IDNA-encoding related problems"""
+
     pass
 
 
 class IDNABidiError(IDNAError):
-    """ Exception when bidirectional requirements are not satisfied """
+    """Exception when bidirectional requirements are not satisfied"""
+
     pass
 
 
 class InvalidCodepoint(IDNAError):
-    """ Exception when a disallowed or unallocated codepoint is used """
+    """Exception when a disallowed or unallocated codepoint is used"""
+
     pass
 
 
 class InvalidCodepointContext(IDNAError):
-    """ Exception when the codepoint is not valid in the context it is used """
+    """Exception when the codepoint is not valid in the context it is used"""
+
     pass
 
 
@@ -33,17 +39,20 @@ def _combining_class(cp: int) -> int:
     v = unicodedata.combining(chr(cp))
     if v == 0:
         if not unicodedata.name(chr(cp)):
-            raise ValueError('Unknown character in unicodedata')
+            raise ValueError("Unknown character in unicodedata")
     return v
 
+
 def _is_script(cp: str, script: str) -> bool:
     return intranges_contain(ord(cp), idnadata.scripts[script])
 
+
 def _punycode(s: str) -> bytes:
-    return s.encode('punycode')
+    return s.encode("punycode")
+
 
 def _unot(s: int) -> str:
-    return 'U+{:04X}'.format(s)
+    return "U+{:04X}".format(s)
 
 
 def valid_label_length(label: Union[bytes, str]) -> bool:
@@ -61,96 +70,106 @@ def valid_string_length(label: Union[bytes, str], trailing_dot: bool) -> bool:
 def check_bidi(label: str, check_ltr: bool = False) -> bool:
     # Bidi rules should only be applied if string contains RTL characters
     bidi_label = False
-    for (idx, cp) in enumerate(label, 1):
+    for idx, cp in enumerate(label, 1):
         direction = unicodedata.bidirectional(cp)
-        if direction == '':
+        if direction == "":
             # String likely comes from a newer version of Unicode
-            raise IDNABidiError('Unknown directionality in label {} at position {}'.format(repr(label), idx))
-        if direction in ['R', 'AL', 'AN']:
+            raise IDNABidiError("Unknown directionality in label {} at position {}".format(repr(label), idx))
+        if direction in ["R", "AL", "AN"]:
             bidi_label = True
     if not bidi_label and not check_ltr:
         return True
 
     # Bidi rule 1
     direction = unicodedata.bidirectional(label[0])
-    if direction in ['R', 'AL']:
+    if direction in ["R", "AL"]:
         rtl = True
-    elif direction == 'L':
+    elif direction == "L":
         rtl = False
     else:
-        raise IDNABidiError('First codepoint in label {} must be directionality L, R or AL'.format(repr(label)))
+        raise IDNABidiError("First codepoint in label {} must be directionality L, R or AL".format(repr(label)))
 
     valid_ending = False
-    number_type = None  # type: Optional[str]
-    for (idx, cp) in enumerate(label, 1):
+    number_type: Optional[str] = None
+    for idx, cp in enumerate(label, 1):
         direction = unicodedata.bidirectional(cp)
 
         if rtl:
             # Bidi rule 2
-            if not direction in ['R', 'AL', 'AN', 'EN', 'ES', 'CS', 'ET', 'ON', 'BN', 'NSM']:
-                raise IDNABidiError('Invalid direction for codepoint at position {} in a right-to-left label'.format(idx))
+            if direction not in [
+                "R",
+                "AL",
+                "AN",
+                "EN",
+                "ES",
+                "CS",
+                "ET",
+                "ON",
+                "BN",
+                "NSM",
+            ]:
+                raise IDNABidiError("Invalid direction for codepoint at position {} in a right-to-left label".format(idx))
             # Bidi rule 3
-            if direction in ['R', 'AL', 'EN', 'AN']:
+            if direction in ["R", "AL", "EN", "AN"]:
                 valid_ending = True
-            elif direction != 'NSM':
+            elif direction != "NSM":
                 valid_ending = False
             # Bidi rule 4
-            if direction in ['AN', 'EN']:
+            if direction in ["AN", "EN"]:
                 if not number_type:
                     number_type = direction
                 else:
                     if number_type != direction:
-                        raise IDNABidiError('Can not mix numeral types in a right-to-left label')
+                        raise IDNABidiError("Can not mix numeral types in a right-to-left label")
         else:
             # Bidi rule 5
-            if not direction in ['L', 'EN', 'ES', 'CS', 'ET', 'ON', 'BN', 'NSM']:
-                raise IDNABidiError('Invalid direction for codepoint at position {} in a left-to-right label'.format(idx))
+            if direction not in ["L", "EN", "ES", "CS", "ET", "ON", "BN", "NSM"]:
+                raise IDNABidiError("Invalid direction for codepoint at position {} in a left-to-right label".format(idx))
             # Bidi rule 6
-            if direction in ['L', 'EN']:
+            if direction in ["L", "EN"]:
                 valid_ending = True
-            elif direction != 'NSM':
+            elif direction != "NSM":
                 valid_ending = False
 
     if not valid_ending:
-        raise IDNABidiError('Label ends with illegal codepoint directionality')
+        raise IDNABidiError("Label ends with illegal codepoint directionality")
 
     return True
 
 
 def check_initial_combiner(label: str) -> bool:
-    if unicodedata.category(label[0])[0] == 'M':
-        raise IDNAError('Label begins with an illegal combining character')
+    if unicodedata.category(label[0])[0] == "M":
+        raise IDNAError("Label begins with an illegal combining character")
     return True
 
 
 def check_hyphen_ok(label: str) -> bool:
-    if label[2:4] == '--':
-        raise IDNAError('Label has disallowed hyphens in 3rd and 4th position')
-    if label[0] == '-' or label[-1] == '-':
-        raise IDNAError('Label must not start or end with a hyphen')
+    if label[2:4] == "--":
+        raise IDNAError("Label has disallowed hyphens in 3rd and 4th position")
+    if label[0] == "-" or label[-1] == "-":
+        raise IDNAError("Label must not start or end with a hyphen")
     return True
 
 
 def check_nfc(label: str) -> None:
-    if unicodedata.normalize('NFC', label) != label:
-        raise IDNAError('Label must be in Normalization Form C')
+    if unicodedata.normalize("NFC", label) != label:
+        raise IDNAError("Label must be in Normalization Form C")
 
 
 def valid_contextj(label: str, pos: int) -> bool:
     cp_value = ord(label[pos])
 
-    if cp_value == 0x200c:
-
+    if cp_value == 0x200C:
         if pos > 0:
             if _combining_class(ord(label[pos - 1])) == _virama_combining_class:
                 return True
 
         ok = False
-        for i in range(pos-1, -1, -1):
+        for i in range(pos - 1, -1, -1):
             joining_type = idnadata.joining_types.get(ord(label[i]))
-            if joining_type == ord('T'):
+            if joining_type == ord("T"):
                 continue
-            elif joining_type in [ord('L'), ord('D')]:
+            elif joining_type in [ord("L"), ord("D")]:
                 ok = True
                 break
             else:
@@ -160,63 +179,61 @@ def valid_contextj(label: str, pos: int) -> bool:
             return False
 
         ok = False
-        for i in range(pos+1, len(label)):
+        for i in range(pos + 1, len(label)):
             joining_type = idnadata.joining_types.get(ord(label[i]))
-            if joining_type == ord('T'):
+            if joining_type == ord("T"):
                 continue
-            elif joining_type in [ord('R'), ord('D')]:
+            elif joining_type in [ord("R"), ord("D")]:
                 ok = True
                 break
             else:
                 break
         return ok
 
-    if cp_value == 0x200d:
-
+    if cp_value == 0x200D:
         if pos > 0:
             if _combining_class(ord(label[pos - 1])) == _virama_combining_class:
                 return True
         return False
 
     else:
-
         return False
 
 
 def valid_contexto(label: str, pos: int, exception: bool = False) -> bool:
     cp_value = ord(label[pos])
 
-    if cp_value == 0x00b7:
-        if 0 < pos < len(label)-1:
-            if ord(label[pos - 1]) == 0x006c and ord(label[pos + 1]) == 0x006c:
+    if cp_value == 0x00B7:
+        if 0 < pos < len(label) - 1:
+            if ord(label[pos - 1]) == 0x006C and ord(label[pos + 1]) == 0x006C:
                 return True
         return False
 
     elif cp_value == 0x0375:
-        if pos < len(label)-1 and len(label) > 1:
-            return _is_script(label[pos + 1], 'Greek')
+        if pos < len(label) - 1 and len(label) > 1:
+            return _is_script(label[pos + 1], "Greek")
         return False
 
-    elif cp_value == 0x05f3 or cp_value == 0x05f4:
+    elif cp_value == 0x05F3 or cp_value == 0x05F4:
         if pos > 0:
-            return _is_script(label[pos - 1], 'Hebrew')
+            return _is_script(label[pos - 1], "Hebrew")
         return False
 
-    elif cp_value == 0x30fb:
+    elif cp_value == 0x30FB:
         for cp in label:
-            if cp == '\u30fb':
+            if cp == "\u30fb":
                 continue
-            if _is_script(cp, 'Hiragana') or _is_script(cp, 'Katakana') or _is_script(cp, 'Han'):
+            if _is_script(cp, "Hiragana") or _is_script(cp, "Katakana") or _is_script(cp, "Han"):
                 return True
         return False
 
     elif 0x660 <= cp_value <= 0x669:
         for cp in label:
-            if 0x6f0 <= ord(cp) <= 0x06f9:
+            if 0x6F0 <= ord(cp) <= 0x06F9:
                 return False
         return True
 
-    elif 0x6f0 <= cp_value <= 0x6f9:
+    elif 0x6F0 <= cp_value <= 0x6F9:
         for cp in label:
             if 0x660 <= ord(cp) <= 0x0669:
                 return False
@@ -227,37 +244,49 @@ def valid_contexto(label: str, pos: int, exception: bool = False) -> bool:
 
 def check_label(label: Union[str, bytes, bytearray]) -> None:
     if isinstance(label, (bytes, bytearray)):
-        label = label.decode('utf-8')
+        label = label.decode("utf-8")
     if len(label) == 0:
-        raise IDNAError('Empty Label')
+        raise IDNAError("Empty Label")
 
     check_nfc(label)
     check_hyphen_ok(label)
     check_initial_combiner(label)
 
-    for (pos, cp) in enumerate(label):
+    for pos, cp in enumerate(label):
         cp_value = ord(cp)
-        if intranges_contain(cp_value, idnadata.codepoint_classes['PVALID']):
+        if intranges_contain(cp_value, idnadata.codepoint_classes["PVALID"]):
             continue
-        elif intranges_contain(cp_value, idnadata.codepoint_classes['CONTEXTJ']):
-            if not valid_contextj(label, pos):
-                raise InvalidCodepointContext('Joiner {} not allowed at position {} in {}'.format(
-                    _unot(cp_value), pos+1, repr(label)))
-        elif intranges_contain(cp_value, idnadata.codepoint_classes['CONTEXTO']):
+        elif intranges_contain(cp_value, idnadata.codepoint_classes["CONTEXTJ"]):
+            try:
+                if not valid_contextj(label, pos):
+                    raise InvalidCodepointContext(
+                        "Joiner {} not allowed at position {} in {}".format(_unot(cp_value), pos + 1, repr(label))
+                    )
+            except ValueError:
+                raise IDNAError(
+                    "Unknown codepoint adjacent to joiner {} at position {} in {}".format(
+                        _unot(cp_value), pos + 1, repr(label)
+                    )
+                )
+        elif intranges_contain(cp_value, idnadata.codepoint_classes["CONTEXTO"]):
             if not valid_contexto(label, pos):
-                raise InvalidCodepointContext('Codepoint {} not allowed at position {} in {}'.format(_unot(cp_value), pos+1, repr(label)))
+                raise InvalidCodepointContext(
+                    "Codepoint {} not allowed at position {} in {}".format(_unot(cp_value), pos + 1, repr(label))
+                )
         else:
-            raise InvalidCodepoint('Codepoint {} at position {} of {} not allowed'.format(_unot(cp_value), pos+1, repr(label)))
+            raise InvalidCodepoint(
+                "Codepoint {} at position {} of {} not allowed".format(_unot(cp_value), pos + 1, repr(label))
+            )
 
     check_bidi(label)
 
 
 def alabel(label: str) -> bytes:
     try:
-        label_bytes = label.encode('ascii')
+        label_bytes = label.encode("ascii")
         ulabel(label_bytes)
         if not valid_label_length(label_bytes):
-            raise IDNAError('Label too long')
+            raise IDNAError("Label too long")
         return label_bytes
     except UnicodeEncodeError:
         pass
@@ -266,7 +295,7 @@ def alabel(label: str) -> bytes:
     label_bytes = _alabel_prefix + _punycode(label)
 
     if not valid_label_length(label_bytes):
-        raise IDNAError('Label too long')
+        raise IDNAError("Label too long")
 
     return label_bytes
 
@@ -274,7 +303,7 @@ def alabel(label: str) -> bytes:
 def ulabel(label: Union[str, bytes, bytearray]) -> str:
     if not isinstance(label, (bytes, bytearray)):
         try:
-            label_bytes = label.encode('ascii')
+            label_bytes = label.encode("ascii")
         except UnicodeEncodeError:
             check_label(label)
             return label
@@ -283,19 +312,19 @@ def ulabel(label: Union[str, bytes, bytearray]) -> str:
 
     label_bytes = label_bytes.lower()
     if label_bytes.startswith(_alabel_prefix):
-        label_bytes = label_bytes[len(_alabel_prefix):]
+        label_bytes = label_bytes[len(_alabel_prefix) :]
         if not label_bytes:
-            raise IDNAError('Malformed A-label, no Punycode eligible content found')
-        if label_bytes.decode('ascii')[-1] == '-':
-            raise IDNAError('A-label must not end with a hyphen')
+            raise IDNAError("Malformed A-label, no Punycode eligible content found")
+        if label_bytes.decode("ascii")[-1] == "-":
+            raise IDNAError("A-label must not end with a hyphen")
     else:
         check_label(label_bytes)
-        return label_bytes.decode('ascii')
+        return label_bytes.decode("ascii")
 
     try:
-        label = label_bytes.decode('punycode')
+        label = label_bytes.decode("punycode")
     except UnicodeError:
-        raise IDNAError('Invalid A-label')
+        raise IDNAError("Invalid A-label")
     check_label(label)
     return label
 
@@ -303,52 +332,60 @@ def ulabel(label: Union[str, bytes, bytearray]) -> str:
 def uts46_remap(domain: str, std3_rules: bool = True, transitional: bool = False) -> str:
     """Re-map the characters in the string according to UTS46 processing."""
     from .uts46data import uts46data
-    output = ''
+
+    output = ""
 
     for pos, char in enumerate(domain):
         code_point = ord(char)
         try:
-            uts46row = uts46data[code_point if code_point < 256 else
-                bisect.bisect_left(uts46data, (code_point, 'Z')) - 1]
+            uts46row = uts46data[code_point if code_point < 256 else bisect.bisect_left(uts46data, (code_point, "Z")) - 1]
             status = uts46row[1]
-            replacement = None  # type: Optional[str]
+            replacement: Optional[str] = None
             if len(uts46row) == 3:
                 replacement = uts46row[2]
-            if (status == 'V' or
-                    (status == 'D' and not transitional) or
-                    (status == '3' and not std3_rules and replacement is None)):
+            if (
+                status == "V"
+                or (status == "D" and not transitional)
+                or (status == "3" and not std3_rules and replacement is None)
+            ):
                 output += char
-            elif replacement is not None and (status == 'M' or
-                    (status == '3' and not std3_rules) or
-                    (status == 'D' and transitional)):
+            elif replacement is not None and (
+                status == "M" or (status == "3" and not std3_rules) or (status == "D" and transitional)
+            ):
                 output += replacement
-            elif status != 'I':
+            elif status != "I":
                 raise IndexError()
         except IndexError:
             raise InvalidCodepoint(
-                'Codepoint {} not allowed at position {} in {}'.format(
-                _unot(code_point), pos + 1, repr(domain)))
+                "Codepoint {} not allowed at position {} in {}".format(_unot(code_point), pos + 1, repr(domain))
+            )
 
-    return unicodedata.normalize('NFC', output)
+    return unicodedata.normalize("NFC", output)
 
 
-def encode(s: Union[str, bytes, bytearray], strict: bool = False, uts46: bool = False, std3_rules: bool = False, transitional: bool = False) -> bytes:
+def encode(
+    s: Union[str, bytes, bytearray],
+    strict: bool = False,
+    uts46: bool = False,
+    std3_rules: bool = False,
+    transitional: bool = False,
+) -> bytes:
     if not isinstance(s, str):
         try:
-            s = str(s, 'ascii')
+            s = str(s, "ascii")
         except UnicodeDecodeError:
-            raise IDNAError('should pass a unicode string to the function rather than a byte string.')
+            raise IDNAError("should pass a unicode string to the function rather than a byte string.")
     if uts46:
         s = uts46_remap(s, std3_rules, transitional)
     trailing_dot = False
     result = []
     if strict:
-        labels = s.split('.')
+        labels = s.split(".")
     else:
         labels = _unicode_dots_re.split(s)
-    if not labels or labels == ['']:
-        raise IDNAError('Empty domain')
-    if labels[-1] == '':
+    if not labels or labels == [""]:
+        raise IDNAError("Empty domain")
+    if labels[-1] == "":
         del labels[-1]
         trailing_dot = True
     for label in labels:
@@ -356,21 +393,26 @@ def encode(s: Union[str, bytes, bytearray], strict: bool = False, uts46: bool =
         if s:
             result.append(s)
         else:
-            raise IDNAError('Empty label')
+            raise IDNAError("Empty label")
     if trailing_dot:
-        result.append(b'')
-    s = b'.'.join(result)
+        result.append(b"")
+    s = b".".join(result)
     if not valid_string_length(s, trailing_dot):
-        raise IDNAError('Domain too long')
+        raise IDNAError("Domain too long")
     return s
 
 
-def decode(s: Union[str, bytes, bytearray], strict: bool = False, uts46: bool = False, std3_rules: bool = False) -> str:
+def decode(
+    s: Union[str, bytes, bytearray],
+    strict: bool = False,
+    uts46: bool = False,
+    std3_rules: bool = False,
+) -> str:
     try:
         if not isinstance(s, str):
-            s = str(s, 'ascii')
+            s = str(s, "ascii")
     except UnicodeDecodeError:
-        raise IDNAError('Invalid ASCII in A-label')
+        raise IDNAError("Invalid ASCII in A-label")
     if uts46:
         s = uts46_remap(s, std3_rules, False)
     trailing_dot = False
@@ -378,9 +420,9 @@ def decode(s: Union[str, bytes, bytearray], strict: bool = False, uts46: bool =
     if not strict:
         labels = _unicode_dots_re.split(s)
     else:
-        labels = s.split('.')
-    if not labels or labels == ['']:
-        raise IDNAError('Empty domain')
+        labels = s.split(".")
+    if not labels or labels == [""]:
+        raise IDNAError("Empty domain")
     if not labels[-1]:
         del labels[-1]
         trailing_dot = True
@@ -389,7 +431,7 @@ def decode(s: Union[str, bytes, bytearray], strict: bool = False, uts46: bool =
         if s:
             result.append(s)
         else:
-            raise IDNAError('Empty label')
+            raise IDNAError("Empty label")
     if trailing_dot:
-        result.append('')
-    return '.'.join(result)
+        result.append("")
+    return ".".join(result)

.venv/lib/python3.12/site-packages/pip/_vendor/idna/intranges.py

@@ -8,6 +8,7 @@ in the original list?" in time O(log(# runs)).
 import bisect
 from typing import List, Tuple
 
+
 def intranges_from_list(list_: List[int]) -> Tuple[int, ...]:
     """Represent a list of integers as a sequence of ranges:
     ((start_0, end_0), (start_1, end_1), ...), such that the original
@@ -20,18 +21,20 @@ def intranges_from_list(list_: List[int]) -> Tuple[int, ...]:
     ranges = []
     last_write = -1
     for i in range(len(sorted_list)):
-        if i+1 < len(sorted_list):
-            if sorted_list[i] == sorted_list[i+1]-1:
+        if i + 1 < len(sorted_list):
+            if sorted_list[i] == sorted_list[i + 1] - 1:
                 continue
-        current_range = sorted_list[last_write+1:i+1]
+        current_range = sorted_list[last_write + 1 : i + 1]
         ranges.append(_encode_range(current_range[0], current_range[-1] + 1))
         last_write = i
 
     return tuple(ranges)
 
+
 def _encode_range(start: int, end: int) -> int:
     return (start << 32) | end
 
+
 def _decode_range(r: int) -> Tuple[int, int]:
     return (r >> 32), (r & ((1 << 32) - 1))
 
@@ -43,7 +46,7 @@ def intranges_contain(int_: int, ranges: Tuple[int, ...]) -> bool:
     # we could be immediately ahead of a tuple (start, end)
     # with start < int_ <= end
     if pos > 0:
-        left, right = _decode_range(ranges[pos-1])
+        left, right = _decode_range(ranges[pos - 1])
         if left <= int_ < right:
             return True
     # or we could be immediately behind a tuple (int_, end)

.venv/lib/python3.12/site-packages/pip/_vendor/idna/package_data.py

@@ -1,2 +1 @@
-__version__ = '3.7'
-
+__version__ = "3.10"

.venv/lib/python3.12/site-packages/pip/_vendor/msgpack/__init__.py

@@ -1,20 +1,20 @@
-from .exceptions import *
-from .ext import ExtType, Timestamp
-
+# ruff: noqa: F401
 import os
 
+from .exceptions import *  # noqa: F403
+from .ext import ExtType, Timestamp
 
-version = (1, 0, 8)
-__version__ = "1.0.8"
+version = (1, 1, 0)
+__version__ = "1.1.0"
 
 
 if os.environ.get("MSGPACK_PUREPYTHON"):
-    from .fallback import Packer, unpackb, Unpacker
+    from .fallback import Packer, Unpacker, unpackb
 else:
     try:
-        from ._cmsgpack import Packer, unpackb, Unpacker
+        from ._cmsgpack import Packer, Unpacker, unpackb
     except ImportError:
-        from .fallback import Packer, unpackb, Unpacker
+        from .fallback import Packer, Unpacker, unpackb
 
 
 def pack(o, stream, **kwargs):

.venv/lib/python3.12/site-packages/pip/_vendor/msgpack/ext.py

@@ -1,6 +1,6 @@
-from collections import namedtuple
 import datetime
 import struct
+from collections import namedtuple
 
 
 class ExtType(namedtuple("ExtType", "code data")):
@@ -157,7 +157,9 @@ class Timestamp:
         :rtype: `datetime.datetime`
         """
         utc = datetime.timezone.utc
-        return datetime.datetime.fromtimestamp(0, utc) + datetime.timedelta(seconds=self.to_unix())
+        return datetime.datetime.fromtimestamp(0, utc) + datetime.timedelta(
+            seconds=self.seconds, microseconds=self.nanoseconds // 1000
+        )
 
     @staticmethod
     def from_datetime(dt):
@@ -165,4 +167,4 @@ class Timestamp:
 
         :rtype: Timestamp
         """
-        return Timestamp.from_unix(dt.timestamp())
+        return Timestamp(seconds=int(dt.timestamp()), nanoseconds=dt.microsecond * 1000)

.venv/lib/python3.12/site-packages/pip/_vendor/msgpack/fallback.py

@@ -1,27 +1,22 @@
 """Fallback pure Python implementation of msgpack"""
-from datetime import datetime as _DateTime
-import sys
-import struct
 
+import struct
+import sys
+from datetime import datetime as _DateTime
 
 if hasattr(sys, "pypy_version_info"):
-    # StringIO is slow on PyPy, StringIO is faster.  However: PyPy's own
-    # StringBuilder is fastest.
     from __pypy__ import newlist_hint
+    from __pypy__.builders import BytesBuilder
 
-    try:
-        from __pypy__.builders import BytesBuilder as StringBuilder
-    except ImportError:
-        from __pypy__.builders import StringBuilder
-    USING_STRINGBUILDER = True
+    _USING_STRINGBUILDER = True
 
-    class StringIO:
+    class BytesIO:
         def __init__(self, s=b""):
             if s:
-                self.builder = StringBuilder(len(s))
+                self.builder = BytesBuilder(len(s))
                 self.builder.append(s)
             else:
-                self.builder = StringBuilder()
+                self.builder = BytesBuilder()
 
         def write(self, s):
             if isinstance(s, memoryview):
@@ -34,17 +29,17 @@ if hasattr(sys, "pypy_version_info"):
             return self.builder.build()
 
 else:
-    USING_STRINGBUILDER = False
-    from io import BytesIO as StringIO
+    from io import BytesIO
 
-    newlist_hint = lambda size: []
+    _USING_STRINGBUILDER = False
+
+    def newlist_hint(size):
+        return []
 
 
-from .exceptions import BufferFull, OutOfData, ExtraData, FormatError, StackError
-
+from .exceptions import BufferFull, ExtraData, FormatError, OutOfData, StackError
 from .ext import ExtType, Timestamp
 
-
 EX_SKIP = 0
 EX_CONSTRUCT = 1
 EX_READ_ARRAY_HEADER = 2
@@ -231,6 +226,7 @@ class Unpacker:
     def __init__(
         self,
         file_like=None,
+        *,
         read_size=0,
         use_list=True,
         raw=False,
@@ -333,6 +329,7 @@ class Unpacker:
 
         # Use extend here: INPLACE_ADD += doesn't reliably typecast memoryview in jython
         self._buffer.extend(view)
+        view.release()
 
     def _consume(self):
         """Gets rid of the used parts of the buffer."""
@@ -649,32 +646,13 @@ class Packer:
         The error handler for encoding unicode. (default: 'strict')
         DO NOT USE THIS!!  This option is kept for very specific usage.
 
-    Example of streaming deserialize from file-like object::
-
-        unpacker = Unpacker(file_like)
-        for o in unpacker:
-            process(o)
-
-    Example of streaming deserialize from socket::
-
-        unpacker = Unpacker()
-        while True:
-            buf = sock.recv(1024**2)
-            if not buf:
-                break
-            unpacker.feed(buf)
-            for o in unpacker:
-                process(o)
-
-    Raises ``ExtraData`` when *packed* contains extra bytes.
-    Raises ``OutOfData`` when *packed* is incomplete.
-    Raises ``FormatError`` when *packed* is not valid msgpack.
-    Raises ``StackError`` when *packed* contains too nested.
-    Other exceptions can be raised during unpacking.
+    :param int buf_size:
+        Internal buffer size. This option is used only for C implementation.
     """
 
     def __init__(
         self,
+        *,
         default=None,
         use_single_float=False,
         autoreset=True,
@@ -682,17 +660,17 @@ class Packer:
         strict_types=False,
         datetime=False,
         unicode_errors=None,
+        buf_size=None,
     ):
         self._strict_types = strict_types
         self._use_float = use_single_float
         self._autoreset = autoreset
         self._use_bin_type = use_bin_type
-        self._buffer = StringIO()
+        self._buffer = BytesIO()
         self._datetime = bool(datetime)
         self._unicode_errors = unicode_errors or "strict"
-        if default is not None:
-            if not callable(default):
-                raise TypeError("default must be callable")
+        if default is not None and not callable(default):
+            raise TypeError("default must be callable")
         self._default = default
 
     def _pack(
@@ -823,18 +801,18 @@ class Packer:
         try:
             self._pack(obj)
         except:
-            self._buffer = StringIO()  # force reset
+            self._buffer = BytesIO()  # force reset
             raise
         if self._autoreset:
             ret = self._buffer.getvalue()
-            self._buffer = StringIO()
+            self._buffer = BytesIO()
             return ret
 
     def pack_map_pairs(self, pairs):
         self._pack_map_pairs(len(pairs), pairs)
         if self._autoreset:
             ret = self._buffer.getvalue()
-            self._buffer = StringIO()
+            self._buffer = BytesIO()
             return ret
 
     def pack_array_header(self, n):
@@ -843,7 +821,7 @@ class Packer:
         self._pack_array_header(n)
         if self._autoreset:
             ret = self._buffer.getvalue()
-            self._buffer = StringIO()
+            self._buffer = BytesIO()
             return ret
 
     def pack_map_header(self, n):
@@ -852,7 +830,7 @@ class Packer:
         self._pack_map_header(n)
         if self._autoreset:
             ret = self._buffer.getvalue()
-            self._buffer = StringIO()
+            self._buffer = BytesIO()
             return ret
 
     def pack_ext_type(self, typecode, data):
@@ -941,11 +919,11 @@ class Packer:
 
         This method is useful only when autoreset=False.
         """
-        self._buffer = StringIO()
+        self._buffer = BytesIO()
 
     def getbuffer(self):
         """Return view of internal buffer."""
-        if USING_STRINGBUILDER:
+        if _USING_STRINGBUILDER:
             return memoryview(self.bytes())
         else:
             return self._buffer.getbuffer()

.venv/lib/python3.12/site-packages/pip/_vendor/packaging/__init__.py

@@ -6,10 +6,10 @@ __title__ = "packaging"
 __summary__ = "Core utilities for Python packages"
 __uri__ = "https://github.com/pypa/packaging"
 
-__version__ = "24.1"
+__version__ = "24.2"
 
 __author__ = "Donald Stufft and individual contributors"
 __email__ = "donald@stufft.io"
 
 __license__ = "BSD-2-Clause or Apache-2.0"
-__copyright__ = "2014 %s" % __author__
+__copyright__ = f"2014 {__author__}"

.venv/lib/python3.12/site-packages/pip/_vendor/packaging/_elffile.py

@@ -48,8 +48,8 @@ class ELFFile:
 
         try:
             ident = self._read("16B")
-        except struct.error:
-            raise ELFInvalid("unable to parse identification")
+        except struct.error as e:
+            raise ELFInvalid("unable to parse identification") from e
         magic = bytes(ident[:4])
         if magic != b"\x7fELF":
             raise ELFInvalid(f"invalid magic: {magic!r}")
@@ -67,11 +67,11 @@ class ELFFile:
                 (2, 1): ("<HHIQQQIHHH", "<IIQQQQQQ", (0, 2, 5)),  # 64-bit LSB.
                 (2, 2): (">HHIQQQIHHH", ">IIQQQQQQ", (0, 2, 5)),  # 64-bit MSB.
             }[(self.capacity, self.encoding)]
-        except KeyError:
+        except KeyError as e:
             raise ELFInvalid(
                 f"unrecognized capacity ({self.capacity}) or "
                 f"encoding ({self.encoding})"
-            )
+            ) from e
 
         try:
             (

.venv/lib/python3.12/site-packages/pip/_vendor/packaging/_manylinux.py

@@ -164,6 +164,7 @@ def _parse_glibc_version(version_str: str) -> tuple[int, int]:
             f"Expected glibc version with 2 components major.minor,"
             f" got: {version_str}",
             RuntimeWarning,
+            stacklevel=2,
         )
         return -1, -1
     return int(m.group("major")), int(m.group("minor"))

.venv/lib/python3.12/site-packages/pip/_vendor/packaging/markers.py

@@ -18,9 +18,9 @@ from .utils import canonicalize_name
 
 __all__ = [
     "InvalidMarker",
+    "Marker",
     "UndefinedComparison",
     "UndefinedEnvironmentName",
-    "Marker",
     "default_environment",
 ]
 
@@ -232,7 +232,7 @@ def _evaluate_markers(markers: MarkerList, environment: dict[str, str]) -> bool:
 
 
 def format_full_version(info: sys._version_info) -> str:
-    version = "{0.major}.{0.minor}.{0.micro}".format(info)
+    version = f"{info.major}.{info.minor}.{info.micro}"
     kind = info.releaselevel
     if kind != "final":
         version += kind[0] + str(info.serial)
@@ -309,12 +309,6 @@ class Marker:
         """
         current_environment = cast("dict[str, str]", default_environment())
         current_environment["extra"] = ""
-        # Work around platform.python_version() returning something that is not PEP 440
-        # compliant for non-tagged Python builds. We preserve default_environment()'s
-        # behavior of returning platform.python_version() verbatim, and leave it to the
-        # caller to provide a syntactically valid version if they want to override it.
-        if current_environment["python_full_version"].endswith("+"):
-            current_environment["python_full_version"] += "local"
         if environment is not None:
             current_environment.update(environment)
             # The API used to allow setting extra to None. We need to handle this
@@ -322,4 +316,16 @@ class Marker:
             if current_environment["extra"] is None:
                 current_environment["extra"] = ""
 
-        return _evaluate_markers(self._markers, current_environment)
+        return _evaluate_markers(
+            self._markers, _repair_python_full_version(current_environment)
+        )
+
+
+def _repair_python_full_version(env: dict[str, str]) -> dict[str, str]:
+    """
+    Work around platform.python_version() returning something that is not PEP 440
+    compliant for non-tagged Python builds.
+    """
+    if env["python_full_version"].endswith("+"):
+        env["python_full_version"] += "local"
+    return env

.venv/lib/python3.12/site-packages/pip/_vendor/packaging/metadata.py

@@ -5,6 +5,8 @@ import email.header
 import email.message
 import email.parser
 import email.policy
+import pathlib
+import sys
 import typing
 from typing import (
     Any,
@@ -15,15 +17,16 @@ from typing import (
     cast,
 )
 
-from . import requirements, specifiers, utils
+from . import licenses, requirements, specifiers, utils
 from . import version as version_module
+from .licenses import NormalizedLicenseExpression
 
 T = typing.TypeVar("T")
 
 
-try:
-    ExceptionGroup
-except NameError:  # pragma: no cover
+if sys.version_info >= (3, 11):  # pragma: no cover
+    ExceptionGroup = ExceptionGroup
+else:  # pragma: no cover
 
     class ExceptionGroup(Exception):
         """A minimal implementation of :external:exc:`ExceptionGroup` from Python 3.11.
@@ -42,9 +45,6 @@ except NameError:  # pragma: no cover
         def __repr__(self) -> str:
             return f"{self.__class__.__name__}({self.message!r}, {self.exceptions!r})"
 
-else:  # pragma: no cover
-    ExceptionGroup = ExceptionGroup
-
 
 class InvalidMetadata(ValueError):
     """A metadata field contains invalid data."""
@@ -128,6 +128,10 @@ class RawMetadata(TypedDict, total=False):
     # No new fields were added in PEP 685, just some edge case were
     # tightened up to provide better interoptability.
 
+    # Metadata 2.4 - PEP 639
+    license_expression: str
+    license_files: list[str]
+
 
 _STRING_FIELDS = {
     "author",
@@ -137,6 +141,7 @@ _STRING_FIELDS = {
     "download_url",
     "home_page",
     "license",
+    "license_expression",
     "maintainer",
     "maintainer_email",
     "metadata_version",
@@ -149,6 +154,7 @@ _STRING_FIELDS = {
 _LIST_FIELDS = {
     "classifiers",
     "dynamic",
+    "license_files",
     "obsoletes",
     "obsoletes_dist",
     "platforms",
@@ -167,7 +173,7 @@ _DICT_FIELDS = {
 
 
 def _parse_keywords(data: str) -> list[str]:
-    """Split a string of comma-separate keyboards into a list of keywords."""
+    """Split a string of comma-separated keywords into a list of keywords."""
     return [k.strip() for k in data.split(",")]
 
 
@@ -216,16 +222,18 @@ def _get_payload(msg: email.message.Message, source: bytes | str) -> str:
     # If our source is a str, then our caller has managed encodings for us,
     # and we don't need to deal with it.
     if isinstance(source, str):
-        payload: str = msg.get_payload()
+        payload = msg.get_payload()
+        assert isinstance(payload, str)
         return payload
     # If our source is a bytes, then we're managing the encoding and we need
     # to deal with it.
     else:
-        bpayload: bytes = msg.get_payload(decode=True)
+        bpayload = msg.get_payload(decode=True)
+        assert isinstance(bpayload, bytes)
         try:
             return bpayload.decode("utf8", "strict")
-        except UnicodeDecodeError:
-            raise ValueError("payload in an invalid encoding")
+        except UnicodeDecodeError as exc:
+            raise ValueError("payload in an invalid encoding") from exc
 
 
 # The various parse_FORMAT functions here are intended to be as lenient as
@@ -251,6 +259,8 @@ _EMAIL_TO_RAW_MAPPING = {
     "home-page": "home_page",
     "keywords": "keywords",
     "license": "license",
+    "license-expression": "license_expression",
+    "license-file": "license_files",
     "maintainer": "maintainer",
     "maintainer-email": "maintainer_email",
     "metadata-version": "metadata_version",
@@ -426,7 +436,7 @@ def parse_email(data: bytes | str) -> tuple[RawMetadata, dict[str, list[str]]]:
         payload = _get_payload(parsed, data)
     except ValueError:
         unparsed.setdefault("description", []).append(
-            parsed.get_payload(decode=isinstance(data, bytes))
+            parsed.get_payload(decode=isinstance(data, bytes))  # type: ignore[call-overload]
         )
     else:
         if payload:
@@ -453,8 +463,8 @@ _NOT_FOUND = object()
 
 
 # Keep the two values in sync.
-_VALID_METADATA_VERSIONS = ["1.0", "1.1", "1.2", "2.1", "2.2", "2.3"]
-_MetadataVersion = Literal["1.0", "1.1", "1.2", "2.1", "2.2", "2.3"]
+_VALID_METADATA_VERSIONS = ["1.0", "1.1", "1.2", "2.1", "2.2", "2.3", "2.4"]
+_MetadataVersion = Literal["1.0", "1.1", "1.2", "2.1", "2.2", "2.3", "2.4"]
 
 _REQUIRED_ATTRS = frozenset(["metadata_version", "name", "version"])
 
@@ -535,7 +545,7 @@ class _Validator(Generic[T]):
         except utils.InvalidName as exc:
             raise self._invalid_metadata(
                 f"{value!r} is invalid for {{field}}", cause=exc
-            )
+            ) from exc
         else:
             return value
 
@@ -547,7 +557,7 @@ class _Validator(Generic[T]):
         except version_module.InvalidVersion as exc:
             raise self._invalid_metadata(
                 f"{value!r} is invalid for {{field}}", cause=exc
-            )
+            ) from exc
 
     def _process_summary(self, value: str) -> str:
         """Check the field contains no newlines."""
@@ -591,10 +601,12 @@ class _Validator(Generic[T]):
         for dynamic_field in map(str.lower, value):
             if dynamic_field in {"name", "version", "metadata-version"}:
                 raise self._invalid_metadata(
-                    f"{value!r} is not allowed as a dynamic field"
+                    f"{dynamic_field!r} is not allowed as a dynamic field"
                 )
             elif dynamic_field not in _EMAIL_TO_RAW_MAPPING:
-                raise self._invalid_metadata(f"{value!r} is not a valid dynamic field")
+                raise self._invalid_metadata(
+                    f"{dynamic_field!r} is not a valid dynamic field"
+                )
         return list(map(str.lower, value))
 
     def _process_provides_extra(
@@ -608,7 +620,7 @@ class _Validator(Generic[T]):
         except utils.InvalidName as exc:
             raise self._invalid_metadata(
                 f"{name!r} is invalid for {{field}}", cause=exc
-            )
+            ) from exc
         else:
             return normalized_names
 
@@ -618,7 +630,7 @@ class _Validator(Generic[T]):
         except specifiers.InvalidSpecifier as exc:
             raise self._invalid_metadata(
                 f"{value!r} is invalid for {{field}}", cause=exc
-            )
+            ) from exc
 
     def _process_requires_dist(
         self,
@@ -629,10 +641,49 @@ class _Validator(Generic[T]):
             for req in value:
                 reqs.append(requirements.Requirement(req))
         except requirements.InvalidRequirement as exc:
-            raise self._invalid_metadata(f"{req!r} is invalid for {{field}}", cause=exc)
+            raise self._invalid_metadata(
+                f"{req!r} is invalid for {{field}}", cause=exc
+            ) from exc
         else:
             return reqs
 
+    def _process_license_expression(
+        self, value: str
+    ) -> NormalizedLicenseExpression | None:
+        try:
+            return licenses.canonicalize_license_expression(value)
+        except ValueError as exc:
+            raise self._invalid_metadata(
+                f"{value!r} is invalid for {{field}}", cause=exc
+            ) from exc
+
+    def _process_license_files(self, value: list[str]) -> list[str]:
+        paths = []
+        for path in value:
+            if ".." in path:
+                raise self._invalid_metadata(
+                    f"{path!r} is invalid for {{field}}, "
+                    "parent directory indicators are not allowed"
+                )
+            if "*" in path:
+                raise self._invalid_metadata(
+                    f"{path!r} is invalid for {{field}}, paths must be resolved"
+                )
+            if (
+                pathlib.PurePosixPath(path).is_absolute()
+                or pathlib.PureWindowsPath(path).is_absolute()
+            ):
+                raise self._invalid_metadata(
+                    f"{path!r} is invalid for {{field}}, paths must be relative"
+                )
+            if pathlib.PureWindowsPath(path).as_posix() != path:
+                raise self._invalid_metadata(
+                    f"{path!r} is invalid for {{field}}, "
+                    "paths must use '/' delimiter"
+                )
+            paths.append(path)
+        return paths
+
 
 class Metadata:
     """Representation of distribution metadata.
@@ -688,8 +739,8 @@ class Metadata:
                             field = _RAW_TO_EMAIL_MAPPING[key]
                             exc = InvalidMetadata(
                                 field,
-                                "{field} introduced in metadata version "
-                                "{field_metadata_version}, not {metadata_version}",
+                                f"{field} introduced in metadata version "
+                                f"{field_metadata_version}, not {metadata_version}",
                             )
                             exceptions.append(exc)
                             continue
@@ -733,6 +784,8 @@ class Metadata:
     metadata_version: _Validator[_MetadataVersion] = _Validator()
     """:external:ref:`core-metadata-metadata-version`
     (required; validated to be a valid metadata version)"""
+    # `name` is not normalized/typed to NormalizedName so as to provide access to
+    # the original/raw name.
     name: _Validator[str] = _Validator()
     """:external:ref:`core-metadata-name`
     (required; validated using :func:`~packaging.utils.canonicalize_name` and its
@@ -770,6 +823,12 @@ class Metadata:
     """:external:ref:`core-metadata-maintainer-email`"""
     license: _Validator[str | None] = _Validator()
     """:external:ref:`core-metadata-license`"""
+    license_expression: _Validator[NormalizedLicenseExpression | None] = _Validator(
+        added="2.4"
+    )
+    """:external:ref:`core-metadata-license-expression`"""
+    license_files: _Validator[list[str] | None] = _Validator(added="2.4")
+    """:external:ref:`core-metadata-license-file`"""
     classifiers: _Validator[list[str] | None] = _Validator(added="1.1")
     """:external:ref:`core-metadata-classifier`"""
     requires_dist: _Validator[list[requirements.Requirement] | None] = _Validator(

.venv/lib/python3.12/site-packages/pip/_vendor/packaging/specifiers.py

@@ -234,7 +234,7 @@ class Specifier(BaseSpecifier):
         """
         match = self._regex.search(spec)
         if not match:
-            raise InvalidSpecifier(f"Invalid specifier: '{spec}'")
+            raise InvalidSpecifier(f"Invalid specifier: {spec!r}")
 
         self._spec: tuple[str, str] = (
             match.group("operator").strip(),
@@ -256,7 +256,7 @@ class Specifier(BaseSpecifier):
         # operators, and if they are if they are including an explicit
         # prerelease.
         operator, version = self._spec
-        if operator in ["==", ">=", "<=", "~=", "==="]:
+        if operator in ["==", ">=", "<=", "~=", "===", ">", "<"]:
             # The == specifier can include a trailing .*, if it does we
             # want to remove before parsing.
             if operator == "==" and version.endswith(".*"):
@@ -694,12 +694,18 @@ class SpecifierSet(BaseSpecifier):
     specifiers (``>=3.0,!=3.1``), or no specifier at all.
     """
 
-    def __init__(self, specifiers: str = "", prereleases: bool | None = None) -> None:
+    def __init__(
+        self,
+        specifiers: str | Iterable[Specifier] = "",
+        prereleases: bool | None = None,
+    ) -> None:
         """Initialize a SpecifierSet instance.
 
         :param specifiers:
             The string representation of a specifier or a comma-separated list of
             specifiers which will be parsed and normalized before use.
+            May also be an iterable of ``Specifier`` instances, which will be used
+            as is.
         :param prereleases:
             This tells the SpecifierSet if it should accept prerelease versions if
             applicable or not. The default of ``None`` will autodetect it from the
@@ -710,12 +716,17 @@ class SpecifierSet(BaseSpecifier):
             raised.
         """
 
-        # Split on `,` to break each individual specifier into it's own item, and
-        # strip each item to remove leading/trailing whitespace.
-        split_specifiers = [s.strip() for s in specifiers.split(",") if s.strip()]
+        if isinstance(specifiers, str):
+            # Split on `,` to break each individual specifier into its own item, and
+            # strip each item to remove leading/trailing whitespace.
+            split_specifiers = [s.strip() for s in specifiers.split(",") if s.strip()]
 
-        # Make each individual specifier a Specifier and save in a frozen set for later.
-        self._specs = frozenset(map(Specifier, split_specifiers))
+            # Make each individual specifier a Specifier and save in a frozen set
+            # for later.
+            self._specs = frozenset(map(Specifier, split_specifiers))
+        else:
+            # Save the supplied specifiers in a frozen set.
+            self._specs = frozenset(specifiers)
 
         # Store our prereleases value so we can use it later to determine if
         # we accept prereleases or not.

.venv/lib/python3.12/site-packages/pip/_vendor/packaging/tags.py

@@ -47,7 +47,7 @@ class Tag:
     is also supported.
     """
 
-    __slots__ = ["_interpreter", "_abi", "_platform", "_hash"]
+    __slots__ = ["_abi", "_hash", "_interpreter", "_platform"]
 
     def __init__(self, interpreter: str, abi: str, platform: str) -> None:
         self._interpreter = interpreter.lower()
@@ -235,9 +235,8 @@ def cpython_tags(
     if use_abi3:
         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))
-                )
+                version = _version_nodot((python_version[0], minor_version))
+                interpreter = f"cp{version}"
                 yield Tag(interpreter, "abi3", platform_)
 
 
@@ -435,24 +434,22 @@ def mac_platforms(
     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.
+        major_version = 10
         for minor_version in range(version[1], -1, -1):
-            compat_version = 10, minor_version
+            compat_version = major_version, 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
-                )
+                yield f"macosx_{major_version}_{minor_version}_{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.
+        minor_version = 0
         for major_version in range(version[0], 10, -1):
-            compat_version = major_version, 0
+            compat_version = major_version, minor_version
             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
-                )
+                yield f"macosx_{major_version}_{minor_version}_{binary_format}"
 
     if version >= (11, 0):
         # Mac OS 11 on x86_64 is compatible with binaries from previous releases.
@@ -462,25 +459,18 @@ def mac_platforms(
         # 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.
+        major_version = 10
         if arch == "x86_64":
             for minor_version in range(16, 3, -1):
-                compat_version = 10, minor_version
+                compat_version = major_version, 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,
-                    )
+                    yield f"macosx_{major_version}_{minor_version}_{binary_format}"
         else:
             for minor_version in range(16, 3, -1):
-                compat_version = 10, minor_version
+                compat_version = major_version, minor_version
                 binary_format = "universal2"
-                yield "macosx_{major}_{minor}_{binary_format}".format(
-                    major=compat_version[0],
-                    minor=compat_version[1],
-                    binary_format=binary_format,
-                )
+                yield f"macosx_{major_version}_{minor_version}_{binary_format}"
 
 
 def ios_platforms(
@@ -500,7 +490,7 @@ def ios_platforms(
         # if iOS is the current platform, ios_ver *must* be defined. However,
         # it won't exist for CPython versions before 3.13, which causes a mypy
         # error.
-        _, release, _, _ = platform.ios_ver()  # type: ignore[attr-defined]
+        _, release, _, _ = platform.ios_ver()  # type: ignore[attr-defined, unused-ignore]
         version = cast("AppleVersion", tuple(map(int, release.split(".")[:2])))
 
     if multiarch is None:

.venv/lib/python3.12/site-packages/pip/_vendor/packaging/utils.py

@@ -4,11 +4,12 @@
 
 from __future__ import annotations
 
+import functools
 import re
 from typing import NewType, Tuple, Union, cast
 
 from .tags import Tag, parse_tag
-from .version import InvalidVersion, Version
+from .version import InvalidVersion, Version, _TrimmedRelease
 
 BuildTag = Union[Tuple[()], Tuple[int, str]]
 NormalizedName = NewType("NormalizedName", str)
@@ -54,52 +55,40 @@ def is_normalized_name(name: str) -> bool:
     return _normalized_regex.match(name) is not None
 
 
+@functools.singledispatch
 def canonicalize_version(
     version: Version | str, *, strip_trailing_zero: bool = True
 ) -> str:
     """
-    This is very similar to Version.__str__, but has one subtle difference
-    with the way it handles the release segment.
+    Return a canonical form of a version as a string.
+
+    >>> canonicalize_version('1.0.1')
+    '1.0.1'
+
+    Per PEP 625, versions may have multiple canonical forms, differing
+    only by trailing zeros.
+
+    >>> canonicalize_version('1.0.0')
+    '1'
+    >>> canonicalize_version('1.0.0', strip_trailing_zero=False)
+    '1.0.0'
+
+    Invalid versions are returned unaltered.
+
+    >>> canonicalize_version('foo bar baz')
+    'foo bar baz'
     """
-    if isinstance(version, str):
-        try:
-            parsed = Version(version)
-        except InvalidVersion:
-            # Legacy versions cannot be normalized
-            return version
-    else:
-        parsed = version
+    return str(_TrimmedRelease(str(version)) if strip_trailing_zero else version)
 
-    parts = []
 
-    # Epoch
-    if parsed.epoch != 0:
-        parts.append(f"{parsed.epoch}!")
-
-    # Release segment
-    release_segment = ".".join(str(x) for x in parsed.release)
-    if strip_trailing_zero:
-        # NB: This strips trailing '.0's to normalize
-        release_segment = re.sub(r"(\.0)+$", "", release_segment)
-    parts.append(release_segment)
-
-    # Pre-release
-    if parsed.pre is not None:
-        parts.append("".join(str(x) for x in parsed.pre))
-
-    # Post-release
-    if parsed.post is not None:
-        parts.append(f".post{parsed.post}")
-
-    # Development release
-    if parsed.dev is not None:
-        parts.append(f".dev{parsed.dev}")
-
-    # Local version segment
-    if parsed.local is not None:
-        parts.append(f"+{parsed.local}")
-
-    return "".join(parts)
+@canonicalize_version.register
+def _(version: str, *, strip_trailing_zero: bool = True) -> str:
+    try:
+        parsed = Version(version)
+    except InvalidVersion:
+        # Legacy versions cannot be normalized
+        return version
+    return canonicalize_version(parsed, strip_trailing_zero=strip_trailing_zero)
 
 
 def parse_wheel_filename(
@@ -107,28 +96,28 @@ def parse_wheel_filename(
 ) -> tuple[NormalizedName, Version, BuildTag, frozenset[Tag]]:
     if not filename.endswith(".whl"):
         raise InvalidWheelFilename(
-            f"Invalid wheel filename (extension must be '.whl'): {filename}"
+            f"Invalid wheel filename (extension must be '.whl'): {filename!r}"
         )
 
     filename = filename[:-4]
     dashes = filename.count("-")
     if dashes not in (4, 5):
         raise InvalidWheelFilename(
-            f"Invalid wheel filename (wrong number of parts): {filename}"
+            f"Invalid wheel filename (wrong number of parts): {filename!r}"
         )
 
     parts = filename.split("-", dashes - 2)
     name_part = parts[0]
     # See PEP 427 for the rules on escaping the project name.
     if "__" in name_part or re.match(r"^[\w\d._]*$", name_part, re.UNICODE) is None:
-        raise InvalidWheelFilename(f"Invalid project name: {filename}")
+        raise InvalidWheelFilename(f"Invalid project name: {filename!r}")
     name = canonicalize_name(name_part)
 
     try:
         version = Version(parts[1])
     except InvalidVersion as e:
         raise InvalidWheelFilename(
-            f"Invalid wheel filename (invalid version): {filename}"
+            f"Invalid wheel filename (invalid version): {filename!r}"
         ) from e
 
     if dashes == 5:
@@ -136,7 +125,7 @@ def parse_wheel_filename(
         build_match = _build_tag_regex.match(build_part)
         if build_match is None:
             raise InvalidWheelFilename(
-                f"Invalid build number: {build_part} in '{filename}'"
+                f"Invalid build number: {build_part} in {filename!r}"
             )
         build = cast(BuildTag, (int(build_match.group(1)), build_match.group(2)))
     else:
@@ -153,14 +142,14 @@ def parse_sdist_filename(filename: str) -> tuple[NormalizedName, Version]:
     else:
         raise InvalidSdistFilename(
             f"Invalid sdist filename (extension must be '.tar.gz' or '.zip'):"
-            f" {filename}"
+            f" {filename!r}"
         )
 
     # We are requiring a PEP 440 version, which cannot contain dashes,
     # so we split on the last dash.
     name_part, sep, version_part = file_stem.rpartition("-")
     if not sep:
-        raise InvalidSdistFilename(f"Invalid sdist filename: {filename}")
+        raise InvalidSdistFilename(f"Invalid sdist filename: {filename!r}")
 
     name = canonicalize_name(name_part)
 
@@ -168,7 +157,7 @@ def parse_sdist_filename(filename: str) -> tuple[NormalizedName, Version]:
         version = Version(version_part)
     except InvalidVersion as e:
         raise InvalidSdistFilename(
-            f"Invalid sdist filename (invalid version): {filename}"
+            f"Invalid sdist filename (invalid version): {filename!r}"
         ) from e
 
     return (name, version)

.venv/lib/python3.12/site-packages/pip/_vendor/packaging/version.py

@@ -15,7 +15,7 @@ from typing import Any, Callable, NamedTuple, SupportsInt, Tuple, Union
 
 from ._structures import Infinity, InfinityType, NegativeInfinity, NegativeInfinityType
 
-__all__ = ["VERSION_PATTERN", "parse", "Version", "InvalidVersion"]
+__all__ = ["VERSION_PATTERN", "InvalidVersion", "Version", "parse"]
 
 LocalType = Tuple[Union[int, str], ...]
 
@@ -199,7 +199,7 @@ class Version(_BaseVersion):
         # Validate the version and parse it into pieces
         match = self._regex.search(version)
         if not match:
-            raise InvalidVersion(f"Invalid version: '{version}'")
+            raise InvalidVersion(f"Invalid version: {version!r}")
 
         # Store the parsed out pieces of the version
         self._version = _Version(
@@ -232,7 +232,7 @@ class Version(_BaseVersion):
         return f"<Version('{self}')>"
 
     def __str__(self) -> str:
-        """A string representation of the version that can be rounded-tripped.
+        """A string representation of the version that can be round-tripped.
 
         >>> str(Version("1.0a5"))
         '1.0a5'
@@ -350,8 +350,8 @@ class Version(_BaseVersion):
         '1.2.3'
         >>> Version("1.2.3+abc").public
         '1.2.3'
-        >>> Version("1.2.3+abc.dev1").public
-        '1.2.3'
+        >>> Version("1!1.2.3dev1+abc").public
+        '1!1.2.3.dev1'
         """
         return str(self).split("+", 1)[0]
 
@@ -363,7 +363,7 @@ class Version(_BaseVersion):
         '1.2.3'
         >>> Version("1.2.3+abc").base_version
         '1.2.3'
-        >>> Version("1!1.2.3+abc.dev1").base_version
+        >>> Version("1!1.2.3dev1+abc").base_version
         '1!1.2.3'
 
         The "base version" is the public version of the project without any pre or post
@@ -451,6 +451,23 @@ class Version(_BaseVersion):
         return self.release[2] if len(self.release) >= 3 else 0
 
 
+class _TrimmedRelease(Version):
+    @property
+    def release(self) -> tuple[int, ...]:
+        """
+        Release segment without any trailing zeros.
+
+        >>> _TrimmedRelease('1.0.0').release
+        (1,)
+        >>> _TrimmedRelease('0.0').release
+        (0,)
+        """
+        rel = super().release
+        nonzeros = (index for index, val in enumerate(rel) if val)
+        last_nonzero = max(nonzeros, default=0)
+        return rel[: last_nonzero + 1]
+
+
 def _parse_letter_version(
     letter: str | None, number: str | bytes | SupportsInt | None
 ) -> tuple[str, int] | None:
@@ -476,7 +493,9 @@ def _parse_letter_version(
             letter = "post"
 
         return letter, int(number)
-    if not letter and number:
+
+    assert not letter
+    if number:
         # We assume if we are given a number, but we are not given a letter
         # then this is using the implicit post release syntax (e.g. 1.0-1)
         letter = "post"

.venv/lib/python3.12/site-packages/pip/_vendor/platformdirs/__init__.py

@@ -19,18 +19,18 @@ if TYPE_CHECKING:
     from pathlib import Path
     from typing import Literal
 
+if sys.platform == "win32":
+    from pip._vendor.platformdirs.windows import Windows as _Result
+elif sys.platform == "darwin":
+    from pip._vendor.platformdirs.macos import MacOS as _Result
+else:
+    from pip._vendor.platformdirs.unix import Unix as _Result
+
 
 def _set_platform_dir_class() -> type[PlatformDirsABC]:
-    if sys.platform == "win32":
-        from pip._vendor.platformdirs.windows import Windows as Result  # noqa: PLC0415
-    elif sys.platform == "darwin":
-        from pip._vendor.platformdirs.macos import MacOS as Result  # noqa: PLC0415
-    else:
-        from pip._vendor.platformdirs.unix import Unix as Result  # noqa: PLC0415
-
     if os.getenv("ANDROID_DATA") == "/data" and os.getenv("ANDROID_ROOT") == "/system":
         if os.getenv("SHELL") or os.getenv("PREFIX"):
-            return Result
+            return _Result
 
         from pip._vendor.platformdirs.android import _android_folder  # noqa: PLC0415
 
@@ -39,10 +39,14 @@ def _set_platform_dir_class() -> type[PlatformDirsABC]:
 
             return Android  # return to avoid redefinition of a result
 
-    return Result
+    return _Result
 
 
-PlatformDirs = _set_platform_dir_class()  #: Currently active platform
+if TYPE_CHECKING:
+    # Work around mypy issue: https://github.com/python/mypy/issues/10962
+    PlatformDirs = _Result
+else:
+    PlatformDirs = _set_platform_dir_class()  #: Currently active platform
 AppDirs = PlatformDirs  #: Backwards compatibility with appdirs
 
 

.venv/lib/python3.12/site-packages/pip/_vendor/platformdirs/android.py

@@ -117,7 +117,7 @@ class Android(PlatformDirsABC):
 
 
 @lru_cache(maxsize=1)
-def _android_folder() -> str | None:  # noqa: C901, PLR0912
+def _android_folder() -> str | None:  # noqa: C901
     """:return: base folder for the Android OS or None if it cannot be found"""
     result: str | None = None
     # type checker isn't happy with our "import android", just don't do this when type checking see

.venv/lib/python3.12/site-packages/pip/_vendor/platformdirs/api.py

@@ -91,6 +91,12 @@ class PlatformDirsABC(ABC):  # noqa: PLR0904
         if self.ensure_exists:
             Path(path).mkdir(parents=True, exist_ok=True)
 
+    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)
+
     @property
     @abstractmethod
     def user_data_dir(self) -> str:

.venv/lib/python3.12/site-packages/pip/_vendor/platformdirs/macos.py

@@ -4,9 +4,13 @@ from __future__ import annotations
 
 import os.path
 import sys
+from typing import TYPE_CHECKING
 
 from .api import PlatformDirsABC
 
+if TYPE_CHECKING:
+    from pathlib import Path
+
 
 class MacOS(PlatformDirsABC):
     """
@@ -42,6 +46,11 @@ class MacOS(PlatformDirsABC):
             return os.pathsep.join(path_list)
         return path_list[0]
 
+    @property
+    def site_data_path(self) -> Path:
+        """:return: data path shared by users. Only return the first item, even if ``multipath`` is set to ``True``"""
+        return self._first_item_as_path_if_multipath(self.site_data_dir)
+
     @property
     def user_config_dir(self) -> str:
         """:return: config directory tied to the user, same as `user_data_dir`"""
@@ -74,6 +83,11 @@ class MacOS(PlatformDirsABC):
             return os.pathsep.join(path_list)
         return path_list[0]
 
+    @property
+    def site_cache_path(self) -> Path:
+        """:return: cache path shared by users. Only return the first item, even if ``multipath`` is set to ``True``"""
+        return self._first_item_as_path_if_multipath(self.site_cache_dir)
+
     @property
     def user_state_dir(self) -> str:
         """:return: state directory tied to the user, same as `user_data_dir`"""

.venv/lib/python3.12/site-packages/pip/_vendor/platformdirs/unix.py

@@ -218,12 +218,6 @@ class Unix(PlatformDirsABC):  # noqa: PLR0904
         """:return: cache path shared by users. Only return the first item, even if ``multipath`` is set to ``True``"""
         return self._first_item_as_path_if_multipath(self.site_cache_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 iter_config_dirs(self) -> Iterator[str]:
         """:yield: all user and site configuration directories."""
         yield self.user_config_dir