py2docfx 0.1.11.dev1830301__py3-none-any.whl → 0.1.11.dev1859874__py3-none-any.whl

py2docfx/venv/0/Lib/site-packages/setuptools/tests/test_sdist.py

@@ -1,32 +1,33 @@
 """sdist tests"""
 
+import contextlib
+import io
+import logging
 import os
+import pathlib
 import sys
+import tarfile
 import tempfile
 import unicodedata
-import contextlib
-import io
-import tarfile
-import logging
-import distutils
 from inspect import cleandoc
+from pathlib import Path
 from unittest import mock
 
+import jaraco.path
 import pytest
 
-from distutils.core import run_setup
-from setuptools import Command
+from setuptools import Command, SetuptoolsDeprecationWarning
 from setuptools._importlib import metadata
-from setuptools import SetuptoolsDeprecationWarning
-from setuptools.command.sdist import sdist
 from setuptools.command.egg_info import manifest_maker
+from setuptools.command.sdist import sdist
 from setuptools.dist import Distribution
 from setuptools.extension import Extension
 from setuptools.tests import fail_on_ascii
-from .text import Filenames
 
-import jaraco.path
+from .text import Filenames
 
+import distutils
+from distutils.core import run_setup
 
 SETUP_ATTRS = {
     'name': 'sdist_test',
@@ -426,6 +427,46 @@ class TestSdistTest:
         assert 'setup.py' not in manifest, manifest
         assert 'setup.cfg' not in manifest, manifest
 
+    def test_exclude_dev_only_cache_folders(self, source_dir):
+        included = {
+            # Emulate problem in https://github.com/pypa/setuptools/issues/4601
+            "MANIFEST.in": (
+                "global-include LICEN[CS]E* COPYING* NOTICE* AUTHORS*\n"
+                "global-include *.txt\n"
+            ),
+            # For the sake of being conservative and limiting unforeseen side-effects
+            # we just exclude dev-only cache folders at the root of the repository:
+            "test/.venv/lib/python3.9/site-packages/bar-2.dist-info/AUTHORS.rst": "",
+            "src/.nox/py/lib/python3.12/site-packages/bar-2.dist-info/COPYING.txt": "",
+            "doc/.tox/default/lib/python3.11/site-packages/foo-4.dist-info/LICENSE": "",
+            # Let's test against false positives with similarly named files:
+            ".venv-requirements.txt": "",
+            ".tox-coveragerc.txt": "",
+            ".noxy/coveragerc.txt": "",
+        }
+
+        excluded = {
+            # .tox/.nox/.venv are well-know folders present at the root of Python repos
+            # and therefore should be excluded
+            ".tox/release/lib/python3.11/site-packages/foo-4.dist-info/LICENSE": "",
+            ".nox/py/lib/python3.12/site-packages/bar-2.dist-info/COPYING.txt": "",
+            ".venv/lib/python3.9/site-packages/bar-2.dist-info/AUTHORS.rst": "",
+        }
+
+        for file, content in {**excluded, **included}.items():
+            Path(source_dir, file).parent.mkdir(parents=True, exist_ok=True)
+            Path(source_dir, file).write_text(content, encoding="utf-8")
+
+        cmd = self.setup_with_extension()
+        self.assert_package_data_in_manifest(cmd)
+        manifest = {f.replace(os.sep, '/') for f in cmd.filelist.files}
+        for path in excluded:
+            assert os.path.exists(path)
+            assert path not in manifest, (path, manifest)
+        for path in included:
+            assert os.path.exists(path)
+            assert path in manifest, (path, manifest)
+
     @fail_on_ascii
     def test_manifest_is_written_with_utf8_encoding(self):
         # Test for #303.
@@ -782,6 +823,21 @@ class TestSdistTest:
         manifest = cmd.filelist.files
         assert '.myfile~' in manifest
 
+    @pytest.mark.skipif("os.environ.get('SETUPTOOLS_USE_DISTUTILS') == 'stdlib'")
+    def test_build_base_pathlib(self, source_dir):
+        """
+        Ensure if build_base is a pathlib.Path, the build still succeeds.
+        """
+        dist = Distribution({
+            **SETUP_ATTRS,
+            "script_name": "setup.py",
+            "options": {"build": {"build_base": pathlib.Path('build')}},
+        })
+        cmd = sdist(dist)
+        cmd.ensure_finalized()
+        with quiet():
+            cmd.run()
+
 
 def test_default_revctrl():
     """
@@ -908,3 +964,12 @@ def run_sdist(monkeypatch, project):
     archive = next((project / "dist").glob("*.tar.gz"))
     with tarfile.open(str(archive)) as tar:
         return set(tar.getnames())
+
+
+def test_sanity_check_setuptools_own_sdist(setuptools_sdist):
+    with tarfile.open(setuptools_sdist) as tar:
+        files = tar.getnames()
+
+    # setuptools sdist should not include the .tox folder
+    tox_files = [name for name in files if ".tox" in name]
+    assert len(tox_files) == 0, f"not empty {tox_files}"

py2docfx/venv/0/Lib/site-packages/setuptools/tests/test_setuptools.py

@@ -1,22 +1,22 @@
 """Tests for the 'setuptools' package"""
 
+import os
 import re
 import sys
-import os
-import distutils.core
-import distutils.cmd
-from distutils.errors import DistutilsSetupError
-from distutils.core import Extension
 from zipfile import ZipFile
 
 import pytest
+from packaging.version import Version
 
 import setuptools
-import setuptools.dist
 import setuptools.depends as dep
+import setuptools.dist
 from setuptools.depends import Require
 
-from packaging.version import Version
+import distutils.cmd
+import distutils.core
+from distutils.core import Extension
+from distutils.errors import DistutilsSetupError
 
 
 @pytest.fixture(autouse=True)
@@ -53,7 +53,7 @@ class TestDepends:
         def f1():
             global x, y, z
             x = "test"
-            y = z
+            y = z  # pyright: ignore[reportUnboundVariable] # Explicitly testing for this runtime issue
 
         fc = f1.__code__
 

py2docfx/venv/0/Lib/site-packages/setuptools/tests/test_virtualenv.py

@@ -1,9 +1,8 @@
 import os
-import sys
 import subprocess
-from urllib.request import urlopen
+import sys
 from urllib.error import URLError
-
+from urllib.request import urlopen
 
 import pytest
 
@@ -111,5 +110,4 @@ def test_no_missing_dependencies(bare_venv, request):
     Quick and dirty test to ensure all external dependencies are vendored.
     """
     setuptools_dir = request.config.rootdir
-    for command in ('upload',):  # sorted(distutils.command.__all__):
-        bare_venv.run(['python', 'setup.py', command, '-h'], cwd=setuptools_dir)
+    bare_venv.run(['python', 'setup.py', '--help'], cwd=setuptools_dir)

py2docfx/venv/0/Lib/site-packages/setuptools/tests/test_warnings.py

@@ -4,7 +4,6 @@ import pytest
 
 from setuptools.warnings import SetuptoolsDeprecationWarning, SetuptoolsWarning
 
-
 _EXAMPLES = {
     "default": dict(
         args=("Hello {x}", "\n\t{target} {v:.1f}"),

py2docfx/venv/0/Lib/site-packages/setuptools/tests/test_wheel.py

@@ -2,31 +2,31 @@
 
 from __future__ import annotations
 
-from distutils.sysconfig import get_config_var
-from distutils.util import get_platform
 import contextlib
-import pathlib
-import stat
 import glob
 import inspect
 import os
+import pathlib
 import shutil
+import stat
 import subprocess
 import sys
-from typing import Any
 import zipfile
+from typing import Any
 
 import pytest
 from jaraco import path
-
-from pkg_resources import Distribution, PathMetadata, PY_MAJOR
-from packaging.utils import canonicalize_name
 from packaging.tags import parse_tag
+from packaging.utils import canonicalize_name
+
+from pkg_resources import PY_MAJOR, Distribution, PathMetadata
 from setuptools.wheel import Wheel
 
 from .contexts import tempdir
 from .textwrap import DALS
 
+from distutils.sysconfig import get_config_var
+from distutils.util import get_platform
 
 WHEEL_INFO_TESTS = (
     ('invalid.whl', ValueError),
@@ -175,7 +175,7 @@ class Record:
         self._id = id
         self._fields = kwargs
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return '%s(**%r)' % (self._id, self._fields)
 
 

py2docfx/venv/0/Lib/site-packages/setuptools/tests/test_windows_wrappers.py

@@ -13,15 +13,15 @@ are to wrap.
 """
 
 import pathlib
-import sys
 import platform
-import textwrap
 import subprocess
+import sys
+import textwrap
 
 import pytest
 
-from setuptools.command.easy_install import nt_quote_arg
 import pkg_resources
+from setuptools.command.easy_install import nt_quote_arg
 
 pytestmark = pytest.mark.skipif(sys.platform != 'win32', reason="Windows only")
 

py2docfx/venv/0/Lib/site-packages/setuptools/unicode_utils.py

@@ -1,5 +1,5 @@
-import unicodedata
 import sys
+import unicodedata
 from configparser import ConfigParser
 
 from .compat import py39

py2docfx/venv/0/Lib/site-packages/setuptools/wheel.py

@@ -1,26 +1,25 @@
 """Wheels support."""
 
+import contextlib
 import email
-import itertools
 import functools
+import itertools
 import os
 import posixpath
 import re
 import zipfile
-import contextlib
 
-from packaging.version import Version as parse_version
 from packaging.tags import sys_tags
 from packaging.utils import canonicalize_name
-
-from distutils.util import get_platform
+from packaging.version import Version as parse_version
 
 import setuptools
-from setuptools.command.egg_info import write_requirements, _egg_basename
 from setuptools.archive_util import _unpack_zipfile_obj
+from setuptools.command.egg_info import _egg_basename, write_requirements
 
 from .unicode_utils import _read_utf8_with_fallback
 
+from distutils.util import get_platform
 
 WHEEL_NAME = re.compile(
     r"""^(?P<project_name>.+?)-(?P<version>\d.*?)

py2docfx/venv/0/Lib/site-packages/setuptools/windows_support.py

@@ -8,7 +8,7 @@ def windows_only(func):
 
 
 @windows_only
-def hide_file(path):
+def hide_file(path: str) -> None:
     """
     Set the hidden attribute on a file or directory.
 
@@ -17,8 +17,8 @@ def hide_file(path):
     `path` must be text.
     """
     import ctypes
+    import ctypes.wintypes
 
-    __import__('ctypes.wintypes')
     SetFileAttributes = ctypes.windll.kernel32.SetFileAttributesW
     SetFileAttributes.argtypes = ctypes.wintypes.LPWSTR, ctypes.wintypes.DWORD
     SetFileAttributes.restype = ctypes.wintypes.BOOL

py2docfx/venv/0/Lib/site-packages/urllib3/_request_methods.py

@@ -97,8 +97,7 @@ class RequestMethods:
             an iterable of :class:`str`/:class:`bytes`, or a file-like object.
 
         :param fields:
-            Data to encode and send in the request body.  Values are processed
-            by :func:`urllib.parse.urlencode`.
+            Data to encode and send in the URL or request body, depending on ``method``.
 
         :param headers:
             Dictionary of custom headers to send, such as User-Agent,
@@ -164,7 +163,7 @@ class RequestMethods:
             The URL to perform the request on.
 
         :param fields:
-            Data to encode and send in the request body.
+            Data to encode and send in the URL.
 
         :param headers:
             Dictionary of custom headers to send, such as User-Agent,

py2docfx/venv/0/Lib/site-packages/urllib3/_version.py

@@ -1,4 +1,16 @@
-# This file is protected via CODEOWNERS
-from __future__ import annotations
+# file generated by setuptools_scm
+# don't change, don't track in version control
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple, Union
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
 
-__version__ = "2.2.2"
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+
+__version__ = version = '2.2.3'
+__version_tuple__ = version_tuple = (2, 2, 3)

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

@@ -1,11 +1,13 @@
 from __future__ import annotations
 
 import datetime
+import http.client
 import logging
 import os
 import re
 import socket
 import sys
+import threading
 import typing
 import warnings
 from http.client import HTTPConnection as _HTTPConnection
@@ -19,6 +21,7 @@ if typing.TYPE_CHECKING:
     from .util.ssltransport import SSLTransport
 
 from ._collections import HTTPHeaderDict
+from .http2 import probe as http2_probe
 from .util.response import assert_header_parsing
 from .util.timeout import _DEFAULT_TIMEOUT, _TYPE_TIMEOUT, Timeout
 from .util.util import to_str
@@ -232,6 +235,46 @@ 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 self.debuglevel > 0:
+                        print("header:", line.decode())
+            finally:
+                response.close()
+
     def connect(self) -> None:
         self.sock = self._new_conn()
         if self._tunnel_host:
@@ -239,7 +282,7 @@ class HTTPConnection(_HTTPConnection):
             self._has_connected_to_proxy = True
 
             # TODO: Fix tunnel so it doesn't depend on self.sock state.
-            self._tunnel()  # type: ignore[attr-defined]
+            self._tunnel()
 
         # If there's a proxy to be connected to we are fully connected.
         # This is set twice (once above and here) due to forwarding proxies
@@ -508,6 +551,7 @@ class HTTPSConnection(HTTPConnection):
     ssl_minimum_version: int | None = None
     ssl_maximum_version: int | None = None
     assert_fingerprint: str | None = None
+    _connect_callback: typing.Callable[..., None] | None = None
 
     def __init__(
         self,
@@ -568,6 +612,7 @@ class HTTPSConnection(HTTPConnection):
             else:
                 cert_reqs = resolve_cert_reqs(None)
         self.cert_reqs = cert_reqs
+        self._connect_callback = None
 
     def set_cert(
         self,
@@ -611,63 +656,122 @@ class HTTPSConnection(HTTPConnection):
         self.ca_cert_data = ca_cert_data
 
     def connect(self) -> None:
-        sock: socket.socket | ssl.SSLSocket
-        self.sock = sock = self._new_conn()
-        server_hostname: str = self.host
-        tls_in_tls = False
-
-        # Do we need to establish a tunnel?
-        if self._tunnel_host is not None:
-            # We're tunneling to an HTTPS origin so need to do TLS-in-TLS.
-            if self._tunnel_scheme == "https":
-                # _connect_tls_proxy will verify and assign proxy_is_verified
-                self.sock = sock = self._connect_tls_proxy(self.host, sock)
-                tls_in_tls = True
-            elif self._tunnel_scheme == "http":
-                self.proxy_is_verified = False
+        # Today we don't need to be doing this step before the /actual/ socket
+        # connection, however in the future we'll need to decide whether to
+        # create a new socket or re-use an existing "shared" socket as a part
+        # of the HTTP/2 handshake dance.
+        if self._tunnel_host is not None and self._tunnel_port is not None:
+            probe_http2_host = self._tunnel_host
+            probe_http2_port = self._tunnel_port
+        else:
+            probe_http2_host = self.host
+            probe_http2_port = self.port
+
+        # Check if the target origin supports HTTP/2.
+        # If the value comes back as 'None' it means that the current thread
+        # is probing for HTTP/2 support. Otherwise, we're waiting for another
+        # probe to complete, or we get a value right away.
+        target_supports_http2: bool | None
+        if "h2" in ssl_.ALPN_PROTOCOLS:
+            target_supports_http2 = http2_probe.acquire_and_get(
+                host=probe_http2_host, port=probe_http2_port
+            )
+        else:
+            # If HTTP/2 isn't going to be offered it doesn't matter if
+            # the target supports HTTP/2. Don't want to make a probe.
+            target_supports_http2 = False
+
+        if self._connect_callback is not None:
+            self._connect_callback(
+                "before connect",
+                thread_id=threading.get_ident(),
+                target_supports_http2=target_supports_http2,
+            )
 
-            # If we're tunneling it means we're connected to our proxy.
-            self._has_connected_to_proxy = True
+        try:
+            sock: socket.socket | ssl.SSLSocket
+            self.sock = sock = self._new_conn()
+            server_hostname: str = self.host
+            tls_in_tls = False
+
+            # Do we need to establish a tunnel?
+            if self._tunnel_host is not None:
+                # We're tunneling to an HTTPS origin so need to do TLS-in-TLS.
+                if self._tunnel_scheme == "https":
+                    # _connect_tls_proxy will verify and assign proxy_is_verified
+                    self.sock = sock = self._connect_tls_proxy(self.host, sock)
+                    tls_in_tls = True
+                elif self._tunnel_scheme == "http":
+                    self.proxy_is_verified = False
+
+                # If we're tunneling it means we're connected to our proxy.
+                self._has_connected_to_proxy = True
+
+                self._tunnel()
+                # Override the host with the one we're requesting data from.
+                server_hostname = self._tunnel_host
+
+            if self.server_hostname is not None:
+                server_hostname = self.server_hostname
+
+            is_time_off = datetime.date.today() < RECENT_DATE
+            if is_time_off:
+                warnings.warn(
+                    (
+                        f"System time is way off (before {RECENT_DATE}). This will probably "
+                        "lead to SSL verification errors"
+                    ),
+                    SystemTimeWarning,
+                )
 
-            self._tunnel()  # type: ignore[attr-defined]
-            # Override the host with the one we're requesting data from.
-            server_hostname = self._tunnel_host
-
-        if self.server_hostname is not None:
-            server_hostname = self.server_hostname
-
-        is_time_off = datetime.date.today() < RECENT_DATE
-        if is_time_off:
-            warnings.warn(
-                (
-                    f"System time is way off (before {RECENT_DATE}). This will probably "
-                    "lead to SSL verification errors"
-                ),
-                SystemTimeWarning,
+            # Remove trailing '.' from fqdn hostnames to allow certificate validation
+            server_hostname_rm_dot = server_hostname.rstrip(".")
+
+            sock_and_verified = _ssl_wrap_socket_and_match_hostname(
+                sock=sock,
+                cert_reqs=self.cert_reqs,
+                ssl_version=self.ssl_version,
+                ssl_minimum_version=self.ssl_minimum_version,
+                ssl_maximum_version=self.ssl_maximum_version,
+                ca_certs=self.ca_certs,
+                ca_cert_dir=self.ca_cert_dir,
+                ca_cert_data=self.ca_cert_data,
+                cert_file=self.cert_file,
+                key_file=self.key_file,
+                key_password=self.key_password,
+                server_hostname=server_hostname_rm_dot,
+                ssl_context=self.ssl_context,
+                tls_in_tls=tls_in_tls,
+                assert_hostname=self.assert_hostname,
+                assert_fingerprint=self.assert_fingerprint,
             )
+            self.sock = sock_and_verified.socket
+
+        # If an error occurs during connection/handshake we may need to release
+        # our lock so another connection can probe the origin.
+        except BaseException:
+            if self._connect_callback is not None:
+                self._connect_callback(
+                    "after connect failure",
+                    thread_id=threading.get_ident(),
+                    target_supports_http2=target_supports_http2,
+                )
 
-        # Remove trailing '.' from fqdn hostnames to allow certificate validation
-        server_hostname_rm_dot = server_hostname.rstrip(".")
-
-        sock_and_verified = _ssl_wrap_socket_and_match_hostname(
-            sock=sock,
-            cert_reqs=self.cert_reqs,
-            ssl_version=self.ssl_version,
-            ssl_minimum_version=self.ssl_minimum_version,
-            ssl_maximum_version=self.ssl_maximum_version,
-            ca_certs=self.ca_certs,
-            ca_cert_dir=self.ca_cert_dir,
-            ca_cert_data=self.ca_cert_data,
-            cert_file=self.cert_file,
-            key_file=self.key_file,
-            key_password=self.key_password,
-            server_hostname=server_hostname_rm_dot,
-            ssl_context=self.ssl_context,
-            tls_in_tls=tls_in_tls,
-            assert_hostname=self.assert_hostname,
-            assert_fingerprint=self.assert_fingerprint,
-        )
-        self.sock = sock_and_verified.socket
+            if target_supports_http2 is None:
+                http2_probe.set_and_release(
+                    host=probe_http2_host, port=probe_http2_port, supports_http2=None
+                )
+            raise
+
+        # If this connection doesn't know if the origin supports HTTP/2
+        # we report back to the HTTP/2 probe our result.
+        if target_supports_http2 is None:
+            supports_http2 = sock_and_verified.socket.selected_alpn_protocol() == "h2"
+            http2_probe.set_and_release(
+                host=probe_http2_host,
+                port=probe_http2_port,
+                supports_http2=supports_http2,
+            )
 
         # Forwarding proxies can never have a verified target since
         # the proxy is the one doing the verification. Should instead

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

@@ -400,6 +400,10 @@ class WrappedSocket:
     def version(self) -> str:
         return self.connection.get_protocol_version_name()  # type: ignore[no-any-return]
 
+    def selected_alpn_protocol(self) -> str | None:
+        alpn_proto = self.connection.get_alpn_proto_negotiated()
+        return alpn_proto.decode() if alpn_proto else None
+
 
 WrappedSocket.makefile = socket_cls.makefile  # type: ignore[attr-defined]