py2docfx 0.1.16rc2051518__py3-none-any.whl → 0.1.17__py3-none-any.whl

py2docfx/venv/basevenv/Lib/site-packages/urllib3/connection.py

@@ -74,7 +74,7 @@ port_by_scheme = {"http": 80, "https": 443}
 
 # When it comes time to update this value as a part of regular maintenance
 # (ie test_recent_date is failing) update it to ~6 months before the current date.
-RECENT_DATE = datetime.date(2023, 6, 1)
+RECENT_DATE = datetime.date(2025, 1, 1)
 
 _CONTAINS_CONTROL_CHAR_RE = re.compile(r"[^-!#$%&'*+.^_`|~0-9a-zA-Z]")
 
@@ -232,45 +232,94 @@ class HTTPConnection(_HTTPConnection):
         super().set_tunnel(host, port=port, headers=headers)
         self._tunnel_scheme = scheme
 
-    if sys.version_info < (3, 11, 4):
-
-        def _tunnel(self) -> None:
-            _MAXLINE = http.client._MAXLINE  # type: ignore[attr-defined]
-            connect = b"CONNECT %s:%d HTTP/1.0\r\n" % (  # type: ignore[str-format]
-                self._tunnel_host.encode("ascii"),  # type: ignore[union-attr]
-                self._tunnel_port,
-            )
-            headers = [connect]
-            for header, value in self._tunnel_headers.items():  # type: ignore[attr-defined]
-                headers.append(f"{header}: {value}\r\n".encode("latin-1"))
-            headers.append(b"\r\n")
-            # Making a single send() call instead of one per line encourages
-            # the host OS to use a more optimal packet size instead of
-            # potentially emitting a series of small packets.
-            self.send(b"".join(headers))
-            del headers
-
-            response = self.response_class(self.sock, method=self._method)  # type: ignore[attr-defined]
-            try:
-                (version, code, message) = response._read_status()  # type: ignore[attr-defined]
-
-                if code != http.HTTPStatus.OK:
-                    self.close()
-                    raise OSError(f"Tunnel connection failed: {code} {message.strip()}")
-                while True:
-                    line = response.fp.readline(_MAXLINE + 1)
-                    if len(line) > _MAXLINE:
-                        raise http.client.LineTooLong("header line")
-                    if not line:
-                        # for sites which EOF without sending a trailer
-                        break
-                    if line in (b"\r\n", b"\n", b""):
-                        break
+    if sys.version_info < (3, 11, 9) or ((3, 12) <= sys.version_info < (3, 12, 3)):
+        # Taken from python/cpython#100986 which was backported in 3.11.9 and 3.12.3.
+        # When using connection_from_host, host will come without brackets.
+        def _wrap_ipv6(self, ip: bytes) -> bytes:
+            if b":" in ip and ip[0] != b"["[0]:
+                return b"[" + ip + b"]"
+            return ip
+
+        if sys.version_info < (3, 11, 9):
+            # `_tunnel` copied from 3.11.13 backporting
+            # https://github.com/python/cpython/commit/0d4026432591d43185568dd31cef6a034c4b9261
+            # and https://github.com/python/cpython/commit/6fbc61070fda2ffb8889e77e3b24bca4249ab4d1
+            def _tunnel(self) -> None:
+                _MAXLINE = http.client._MAXLINE  # type: ignore[attr-defined]
+                connect = b"CONNECT %s:%d HTTP/1.0\r\n" % (  # type: ignore[str-format]
+                    self._wrap_ipv6(self._tunnel_host.encode("ascii")),  # type: ignore[union-attr]
+                    self._tunnel_port,
+                )
+                headers = [connect]
+                for header, value in self._tunnel_headers.items():  # type: ignore[attr-defined]
+                    headers.append(f"{header}: {value}\r\n".encode("latin-1"))
+                headers.append(b"\r\n")
+                # Making a single send() call instead of one per line encourages
+                # the host OS to use a more optimal packet size instead of
+                # potentially emitting a series of small packets.
+                self.send(b"".join(headers))
+                del headers
+
+                response = self.response_class(self.sock, method=self._method)  # type: ignore[attr-defined]
+                try:
+                    (version, code, message) = response._read_status()  # type: ignore[attr-defined]
+
+                    if code != http.HTTPStatus.OK:
+                        self.close()
+                        raise OSError(
+                            f"Tunnel connection failed: {code} {message.strip()}"
+                        )
+                    while True:
+                        line = response.fp.readline(_MAXLINE + 1)
+                        if len(line) > _MAXLINE:
+                            raise http.client.LineTooLong("header line")
+                        if not line:
+                            # for sites which EOF without sending a trailer
+                            break
+                        if line in (b"\r\n", b"\n", b""):
+                            break
+
+                        if self.debuglevel > 0:
+                            print("header:", line.decode())
+                finally:
+                    response.close()
+
+        elif (3, 12) <= sys.version_info < (3, 12, 3):
+            # `_tunnel` copied from 3.12.11 backporting
+            # https://github.com/python/cpython/commit/23aef575c7629abcd4aaf028ebd226fb41a4b3c8
+            def _tunnel(self) -> None:  # noqa: F811
+                connect = b"CONNECT %s:%d HTTP/1.1\r\n" % (  # type: ignore[str-format]
+                    self._wrap_ipv6(self._tunnel_host.encode("idna")),  # type: ignore[union-attr]
+                    self._tunnel_port,
+                )
+                headers = [connect]
+                for header, value in self._tunnel_headers.items():  # type: ignore[attr-defined]
+                    headers.append(f"{header}: {value}\r\n".encode("latin-1"))
+                headers.append(b"\r\n")
+                # Making a single send() call instead of one per line encourages
+                # the host OS to use a more optimal packet size instead of
+                # potentially emitting a series of small packets.
+                self.send(b"".join(headers))
+                del headers
+
+                response = self.response_class(self.sock, method=self._method)  # type: ignore[attr-defined]
+                try:
+                    (version, code, message) = response._read_status()  # type: ignore[attr-defined]
+
+                    self._raw_proxy_headers = http.client._read_headers(response.fp)  # type: ignore[attr-defined]
 
                     if self.debuglevel > 0:
-                        print("header:", line.decode())
-            finally:
-                response.close()
+                        for header in self._raw_proxy_headers:
+                            print("header:", header.decode())
+
+                    if code != http.HTTPStatus.OK:
+                        self.close()
+                        raise OSError(
+                            f"Tunnel connection failed: {code} {message.strip()}"
+                        )
+
+                finally:
+                    response.close()
 
     def connect(self) -> None:
         self.sock = self._new_conn()

py2docfx/venv/basevenv/Lib/site-packages/urllib3/contrib/emscripten/fetch.py

@@ -573,6 +573,11 @@ def send_jspi_request(
         "method": request.method,
         "signal": js_abort_controller.signal,
     }
+    # Node.js returns the whole response (unlike opaqueredirect in browsers),
+    # so urllib3 can set `redirect: manual` to control redirects itself.
+    # https://stackoverflow.com/a/78524615
+    if _is_node_js():
+        fetch_data["redirect"] = "manual"
     # Call JavaScript fetch (async api, returns a promise)
     fetcher_promise_js = js.fetch(request.url, _obj_from_dict(fetch_data))
     # Now suspend WebAssembly until we resolve that promise
@@ -693,6 +698,21 @@ def has_jspi() -> bool:
         return False
 
 
+def _is_node_js() -> bool:
+    """
+    Check if we are in Node.js.
+
+    :return: True if we are in Node.js.
+    :rtype: bool
+    """
+    return (
+        hasattr(js, "process")
+        and hasattr(js.process, "release")
+        # According to the Node.js documentation, the release name is always "node".
+        and js.process.release.name == "node"
+    )
+
+
 def streaming_ready() -> bool | None:
     if _fetcher:
         return _fetcher.streaming_ready

py2docfx/venv/basevenv/Lib/site-packages/urllib3/contrib/emscripten/response.py

@@ -160,26 +160,18 @@ class EmscriptenHttpResponseWrapper(BaseHTTPResponse):
                 # don't cache partial content
                 cache_content = False
                 data = self._response.body.read(amt)
-                if self.length_remaining is not None:
-                    self.length_remaining = max(self.length_remaining - len(data), 0)
-                if (self.length_is_certain and self.length_remaining == 0) or len(
-                    data
-                ) < amt:
-                    # definitely finished reading, close response stream
-                    self._response.body.close()
-                return typing.cast(bytes, data)
             else:  # read all we can (and cache it)
                 data = self._response.body.read()
                 if cache_content:
                     self._body = data
-                if self.length_remaining is not None:
-                    self.length_remaining = max(self.length_remaining - len(data), 0)
-                if len(data) == 0 or (
-                    self.length_is_certain and self.length_remaining == 0
-                ):
-                    # definitely finished reading, close response stream
-                    self._response.body.close()
-                return typing.cast(bytes, data)
+            if self.length_remaining is not None:
+                self.length_remaining = max(self.length_remaining - len(data), 0)
+            if len(data) == 0 or (
+                self.length_is_certain and self.length_remaining == 0
+            ):
+                # definitely finished reading, close response stream
+                self._response.body.close()
+            return typing.cast(bytes, data)
 
     def read_chunked(
         self,

py2docfx/venv/basevenv/Lib/site-packages/urllib3/contrib/pyopenssl.py

@@ -424,6 +424,7 @@ class PyOpenSSLContext:
         self.check_hostname = False
         self._minimum_version: int = ssl.TLSVersion.MINIMUM_SUPPORTED
         self._maximum_version: int = ssl.TLSVersion.MAXIMUM_SUPPORTED
+        self._verify_flags: int = ssl.VERIFY_X509_TRUSTED_FIRST
 
     @property
     def options(self) -> int:
@@ -434,6 +435,15 @@ class PyOpenSSLContext:
         self._options = value
         self._set_ctx_options()
 
+    @property
+    def verify_flags(self) -> int:
+        return self._verify_flags
+
+    @verify_flags.setter
+    def verify_flags(self, value: int) -> None:
+        self._verify_flags = value
+        self._ctx.get_cert_store().set_flags(self._verify_flags)
+
     @property
     def verify_mode(self) -> int:
         return _openssl_to_stdlib_verify[self._ctx.get_verify_mode()]

py2docfx/venv/basevenv/Lib/site-packages/urllib3/exceptions.py

@@ -31,11 +31,12 @@ class PoolError(HTTPError):
 
     def __init__(self, pool: ConnectionPool, message: str) -> None:
         self.pool = pool
+        self._message = message
         super().__init__(f"{pool}: {message}")
 
     def __reduce__(self) -> _TYPE_REDUCE_RESULT:
         # For pickling purposes.
-        return self.__class__, (None, None)
+        return self.__class__, (None, self._message)
 
 
 class RequestError(PoolError):
@@ -47,7 +48,7 @@ class RequestError(PoolError):
 
     def __reduce__(self) -> _TYPE_REDUCE_RESULT:
         # For pickling purposes.
-        return self.__class__, (None, self.url, None)
+        return self.__class__, (None, self.url, self._message)
 
 
 class SSLError(HTTPError):
@@ -100,6 +101,10 @@ class MaxRetryError(RequestError):
 
         super().__init__(pool, url, message)
 
+    def __reduce__(self) -> _TYPE_REDUCE_RESULT:
+        # For pickling purposes.
+        return self.__class__, (None, self.url, self.reason)
+
 
 class HostChangedError(RequestError):
     """Raised when an existing pool gets a request for a foreign host."""
@@ -139,11 +144,12 @@ class NewConnectionError(ConnectTimeoutError, HTTPError):
 
     def __init__(self, conn: HTTPConnection, message: str) -> None:
         self.conn = conn
+        self._message = message
         super().__init__(f"{conn}: {message}")
 
     def __reduce__(self) -> _TYPE_REDUCE_RESULT:
         # For pickling purposes.
-        return self.__class__, (None, None)
+        return self.__class__, (None, self._message)
 
     @property
     def pool(self) -> HTTPConnection:
@@ -162,11 +168,13 @@ class NameResolutionError(NewConnectionError):
 
     def __init__(self, host: str, conn: HTTPConnection, reason: socket.gaierror):
         message = f"Failed to resolve '{host}' ({reason})"
+        self._host = host
+        self._reason = reason
         super().__init__(conn, message)
 
     def __reduce__(self) -> _TYPE_REDUCE_RESULT:
         # For pickling purposes.
-        return self.__class__, (None, None, None)
+        return self.__class__, (self._host, None, self._reason)
 
 
 class EmptyPoolError(PoolError):

py2docfx/venv/basevenv/Lib/site-packages/urllib3/http2/connection.py

@@ -140,7 +140,7 @@ class HTTP2Connection(HTTPSConnection):
         with self._h2_conn as conn:
             self._h2_stream = conn.get_next_available_stream_id()
 
-    def putheader(self, header: str | bytes, *values: str | bytes) -> None:
+    def putheader(self, header: str | bytes, *values: str | bytes) -> None:  # type: ignore[override]
         # TODO SKIPPABLE_HEADERS from urllib3 are ignored.
         header = header.encode() if isinstance(header, str) else header
         header = header.lower()  # A lot of upstream code uses capitalized headers.

py2docfx/venv/basevenv/Lib/site-packages/urllib3/poolmanager.py

@@ -203,6 +203,22 @@ class PoolManager(RequestMethods):
         **connection_pool_kw: typing.Any,
     ) -> None:
         super().__init__(headers)
+        if "retries" in connection_pool_kw:
+            retries = connection_pool_kw["retries"]
+            if not isinstance(retries, Retry):
+                # When Retry is initialized, raise_on_redirect is based
+                # on a redirect boolean value.
+                # But requests made via a pool manager always set
+                # redirect to False, and raise_on_redirect always ends
+                # up being False consequently.
+                # Here we fix the issue by setting raise_on_redirect to
+                # a value needed by the pool manager without considering
+                # the redirect boolean.
+                raise_on_redirect = retries is not False
+                retries = Retry.from_int(retries, redirect=False)
+                retries.raise_on_redirect = raise_on_redirect
+                connection_pool_kw = connection_pool_kw.copy()
+                connection_pool_kw["retries"] = retries
         self.connection_pool_kw = connection_pool_kw
 
         self.pools: RecentlyUsedContainer[PoolKey, HTTPConnectionPool]
@@ -456,7 +472,7 @@ class PoolManager(RequestMethods):
             kw["body"] = None
             kw["headers"] = HTTPHeaderDict(kw["headers"])._prepare_for_method_change()
 
-        retries = kw.get("retries")
+        retries = kw.get("retries", response.retries)
         if not isinstance(retries, Retry):
             retries = Retry.from_int(retries, redirect=redirect)
 

py2docfx/venv/basevenv/Lib/site-packages/urllib3/py.typed

@@ -0,0 +1,2 @@
+# Instruct type checkers to look for inline type annotations in this package.
+# See PEP 561.

py2docfx/venv/basevenv/Lib/site-packages/urllib3/response.py

@@ -26,23 +26,6 @@ try:
 except ImportError:
     brotli = None
 
-try:
-    import zstandard as zstd
-except (AttributeError, ImportError, ValueError):  # Defensive:
-    HAS_ZSTD = False
-else:
-    # The package 'zstandard' added the 'eof' property starting
-    # in v0.18.0 which we require to ensure a complete and
-    # valid zstd stream was fed into the ZstdDecoder.
-    # See: https://github.com/urllib3/urllib3/pull/2624
-    _zstd_version = tuple(
-        map(int, re.search(r"^([0-9]+)\.([0-9]+)", zstd.__version__).groups())  # type: ignore[union-attr]
-    )
-    if _zstd_version < (0, 18):  # Defensive:
-        HAS_ZSTD = False
-    else:
-        HAS_ZSTD = True
-
 from . import util
 from ._base_connection import _TYPE_BODY
 from ._collections import HTTPHeaderDict
@@ -163,11 +146,15 @@ if brotli is not None:
             return b""
 
 
-if HAS_ZSTD:
+try:
+    # Python 3.14+
+    from compression import zstd  # type: ignore[import-not-found] # noqa: F401
+
+    HAS_ZSTD = True
 
     class ZstdDecoder(ContentDecoder):
         def __init__(self) -> None:
-            self._obj = zstd.ZstdDecompressor().decompressobj()
+            self._obj = zstd.ZstdDecompressor()
 
         def decompress(self, data: bytes) -> bytes:
             if not data:
@@ -175,15 +162,53 @@ if HAS_ZSTD:
             data_parts = [self._obj.decompress(data)]
             while self._obj.eof and self._obj.unused_data:
                 unused_data = self._obj.unused_data
-                self._obj = zstd.ZstdDecompressor().decompressobj()
+                self._obj = zstd.ZstdDecompressor()
                 data_parts.append(self._obj.decompress(unused_data))
             return b"".join(data_parts)
 
         def flush(self) -> bytes:
-            ret = self._obj.flush()  # note: this is a no-op
             if not self._obj.eof:
                 raise DecodeError("Zstandard data is incomplete")
-            return ret
+            return b""
+
+except ImportError:
+    try:
+        # Python 3.13 and earlier require the 'zstandard' module.
+        import zstandard as zstd
+
+        # The package 'zstandard' added the 'eof' property starting
+        # in v0.18.0 which we require to ensure a complete and
+        # valid zstd stream was fed into the ZstdDecoder.
+        # See: https://github.com/urllib3/urllib3/pull/2624
+        _zstd_version = tuple(
+            map(int, re.search(r"^([0-9]+)\.([0-9]+)", zstd.__version__).groups())  # type: ignore[union-attr]
+        )
+        if _zstd_version < (0, 18):  # Defensive:
+            raise ImportError("zstandard module doesn't have eof")
+    except (AttributeError, ImportError, ValueError):  # Defensive:
+        HAS_ZSTD = False
+    else:
+        HAS_ZSTD = True
+
+        class ZstdDecoder(ContentDecoder):  # type: ignore[no-redef]
+            def __init__(self) -> None:
+                self._obj = zstd.ZstdDecompressor().decompressobj()
+
+            def decompress(self, data: bytes) -> bytes:
+                if not data:
+                    return b""
+                data_parts = [self._obj.decompress(data)]
+                while self._obj.eof and self._obj.unused_data:
+                    unused_data = self._obj.unused_data
+                    self._obj = zstd.ZstdDecompressor().decompressobj()
+                    data_parts.append(self._obj.decompress(unused_data))
+                return b"".join(data_parts)
+
+            def flush(self) -> bytes:
+                ret = self._obj.flush()  # note: this is a no-op
+                if not self._obj.eof:
+                    raise DecodeError("Zstandard data is incomplete")
+                return ret  # type: ignore[no-any-return]
 
 
 class MultiDecoder(ContentDecoder):
@@ -518,7 +543,7 @@ class BaseHTTPResponse(io.IOBase):
     def getheaders(self) -> HTTPHeaderDict:
         warnings.warn(
             "HTTPResponse.getheaders() is deprecated and will be removed "
-            "in urllib3 v2.1.0. Instead access HTTPResponse.headers directly.",
+            "in urllib3 v2.6.0. Instead access HTTPResponse.headers directly.",
             category=DeprecationWarning,
             stacklevel=2,
         )
@@ -527,7 +552,7 @@ class BaseHTTPResponse(io.IOBase):
     def getheader(self, name: str, default: str | None = None) -> str | None:
         warnings.warn(
             "HTTPResponse.getheader() is deprecated and will be removed "
-            "in urllib3 v2.1.0. Instead use HTTPResponse.headers.get(name, default).",
+            "in urllib3 v2.6.0. Instead use HTTPResponse.headers.get(name, default).",
             category=DeprecationWarning,
             stacklevel=2,
         )
@@ -1075,6 +1100,10 @@ class HTTPResponse(BaseHTTPResponse):
     def shutdown(self) -> None:
         if not self._sock_shutdown:
             raise ValueError("Cannot shutdown socket as self._sock_shutdown is not set")
+        if self._connection is None:
+            raise RuntimeError(
+                "Cannot shutdown as connection has already been released to the pool"
+            )
         self._sock_shutdown(socket.SHUT_RD)
 
     def close(self) -> None:

py2docfx/venv/basevenv/Lib/site-packages/urllib3/util/request.py

@@ -28,12 +28,20 @@ except ImportError:
     pass
 else:
     ACCEPT_ENCODING += ",br"
+
 try:
-    import zstandard as _unused_module_zstd  # noqa: F401
-except ImportError:
-    pass
-else:
+    from compression import (  # type: ignore[import-not-found] # noqa: F401
+        zstd as _unused_module_zstd,
+    )
+
     ACCEPT_ENCODING += ",zstd"
+except ImportError:
+    try:
+        import zstandard as _unused_module_zstd  # noqa: F401
+
+        ACCEPT_ENCODING += ",zstd"
+    except ImportError:
+        pass
 
 
 class _TYPE_FAILEDTELL(Enum):

py2docfx/venv/basevenv/Lib/site-packages/urllib3/util/ssl_.py

@@ -101,6 +101,7 @@ try:  # Do we have ssl at all?
         OPENSSL_VERSION_NUMBER,
         PROTOCOL_TLS,
         PROTOCOL_TLS_CLIENT,
+        VERIFY_X509_STRICT,
         OP_NO_SSLv2,
         OP_NO_SSLv3,
         SSLContext,
@@ -109,6 +110,9 @@ try:  # Do we have ssl at all?
 
     PROTOCOL_SSLv23 = PROTOCOL_TLS
 
+    # Needed for Python 3.9 which does not define this
+    VERIFY_X509_PARTIAL_CHAIN = getattr(ssl, "VERIFY_X509_PARTIAL_CHAIN", 0x80000)
+
     # Setting SSLContext.hostname_checks_common_name = False didn't work before CPython
     # 3.9.3, and 3.10 (but OK on PyPy) or OpenSSL 1.1.1l+
     if HAS_NEVER_CHECK_COMMON_NAME and not _is_has_never_check_common_name_reliable(
@@ -117,7 +121,7 @@ try:  # Do we have ssl at all?
         sys.implementation.name,
         sys.version_info,
         sys.pypy_version_info if sys.implementation.name == "pypy" else None,  # type: ignore[attr-defined]
-    ):
+    ):  # Defensive: for Python < 3.9.3
         HAS_NEVER_CHECK_COMMON_NAME = False
 
     # Need to be careful here in case old TLS versions get
@@ -138,6 +142,8 @@ except ImportError:
     OP_NO_SSLv3 = 0x2000000  # type: ignore[assignment]
     PROTOCOL_SSLv23 = PROTOCOL_TLS = 2  # type: ignore[assignment]
     PROTOCOL_TLS_CLIENT = 16  # type: ignore[assignment]
+    VERIFY_X509_PARTIAL_CHAIN = 0x80000
+    VERIFY_X509_STRICT = 0x20  # type: ignore[assignment]
 
 
 _TYPE_PEER_CERT_RET = typing.Union["_TYPE_PEER_CERT_RET_DICT", bytes, None]
@@ -223,6 +229,7 @@ def create_urllib3_context(
     ciphers: str | None = None,
     ssl_minimum_version: int | None = None,
     ssl_maximum_version: int | None = None,
+    verify_flags: int | None = None,
 ) -> ssl.SSLContext:
     """Creates and configures an :class:`ssl.SSLContext` instance for use with urllib3.
 
@@ -247,6 +254,9 @@ def create_urllib3_context(
     :param ciphers:
         Which cipher suites to allow the server to select. Defaults to either system configured
         ciphers if OpenSSL 1.1.1+, otherwise uses a secure default set of ciphers.
+    :param verify_flags:
+        The flags for certificate verification operations. These default to
+        ``ssl.VERIFY_X509_PARTIAL_CHAIN`` and ``ssl.VERIFY_X509_STRICT`` for Python 3.13+.
     :returns:
         Constructed SSLContext object with specified options
     :rtype: SSLContext
@@ -279,7 +289,7 @@ def create_urllib3_context(
             # keep the maximum version to be it's default value: 'TLSVersion.MAXIMUM_SUPPORTED'
             warnings.warn(
                 "'ssl_version' option is deprecated and will be "
-                "removed in urllib3 v2.1.0. Instead use 'ssl_minimum_version'",
+                "removed in urllib3 v2.6.0. Instead use 'ssl_minimum_version'",
                 category=DeprecationWarning,
                 stacklevel=2,
             )
@@ -320,6 +330,16 @@ def create_urllib3_context(
 
     context.options |= options
 
+    if verify_flags is None:
+        verify_flags = 0
+        # In Python 3.13+ ssl.create_default_context() sets VERIFY_X509_PARTIAL_CHAIN
+        # and VERIFY_X509_STRICT so we do the same
+        if sys.version_info >= (3, 13):
+            verify_flags |= VERIFY_X509_PARTIAL_CHAIN
+            verify_flags |= VERIFY_X509_STRICT
+
+    context.verify_flags |= verify_flags
+
     # Enable post-handshake authentication for TLS 1.3, see GH #1634. PHA is
     # necessary for conditional client cert authentication with TLS 1.3.
     # The attribute is None for OpenSSL <= 1.1.0 or does not exist when using

py2docfx/venv/basevenv/Lib/site-packages/urllib3/util/ssl_match_hostname.py

@@ -146,7 +146,7 @@ def match_hostname(
                 if key == "commonName":
                     if _dnsname_match(value, hostname):
                         return
-                    dnsnames.append(value)
+                    dnsnames.append(value)  # Defensive: for Python < 3.9.3
 
     if len(dnsnames) > 1:
         raise CertificateError(

py2docfx/venv/basevenv/Lib/site-packages/wheel/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.45.1"
+__version__ = "0.46.1"

py2docfx/venv/basevenv/Lib/site-packages/wheel/__main__.py

@@ -1,23 +1,25 @@
 """
-Wheel command line tool (enable python -m wheel syntax)
+Wheel command line tool (enables the ``python -m wheel`` syntax)
 """
 
 from __future__ import annotations
 
 import sys
+from typing import NoReturn
 
 
-def main():  # needed for console script
+def main() -> NoReturn:  # needed for console script
     if __package__ == "":
         # To be able to run 'python wheel-0.9.whl/wheel':
         import os.path
 
         path = os.path.dirname(os.path.dirname(__file__))
         sys.path[0:0] = [path]
-    import wheel.cli
 
-    sys.exit(wheel.cli.main())
+    from ._commands import main as cli_main
+
+    sys.exit(cli_main())
 
 
 if __name__ == "__main__":
-    sys.exit(main())
+    main()

py2docfx/venv/{venv1/Lib/site-packages/wheel/cli → basevenv/Lib/site-packages/wheel/_commands}/__init__.py

@@ -9,9 +9,7 @@ import os
 import sys
 from argparse import ArgumentTypeError
 
-
-class WheelError(Exception):
-    pass
+from ..wheelfile import WheelError
 
 
 def unpack_f(args: argparse.Namespace) -> None:
@@ -75,7 +73,7 @@ output filename(s) will be displayed on stdout for further processing.
 """
 
 
-def parser():
+def parser() -> argparse.ArgumentParser:
     p = argparse.ArgumentParser()
     s = p.add_subparsers(help="commands")
 
@@ -140,7 +138,7 @@ def parser():
     return p
 
 
-def main():
+def main() -> int:
     p = parser()
     args = p.parse_args()
     if not hasattr(args, "func"):