More removal of obsolete code.

setup.py

@@ -427,6 +427,8 @@ def run_setup(ext_modules):
                 # leak checks. previously we had a hand-rolled version.
                 'objgraph',
 
+                # We still have some places we like to test with pkg_resources
+                'setuptools',
             ],
         },
         # It's always safe to pass the CFFI keyword, even if

src/gevent/_compat.py

@@ -12,12 +12,6 @@
 import os
 
 
-PY2 = sys.version_info[0] == 2
-PY3 = sys.version_info[0] >= 3
-PY35 = sys.version_info[:2] >= (3, 5)
-PY36 = sys.version_info[:2] >= (3, 6)
-PY37 = sys.version_info[:2] >= (3, 7)
-PY38 = sys.version_info[:2] >= (3, 8)
 PY39 = sys.version_info[:2] >= (3, 9)
 PY311 = sys.version_info[:2] >= (3, 11)
 PYPY = hasattr(sys, 'pypy_version_info')
@@ -30,48 +24,33 @@
 
 ## Types
 
-if PY3:
-    string_types = (str,)
-    integer_types = (int,)
-    text_type = str
-    native_path_types = (str, bytes)
-    thread_mod_name = '_thread'
-
-else:
-    import __builtin__ # pylint:disable=import-error
-    string_types = (__builtin__.basestring,)
-    text_type = __builtin__.unicode
-    integer_types = (int, __builtin__.long)
-    native_path_types = string_types
-    thread_mod_name = 'thread'
+
+string_types = (str,)
+integer_types = (int,)
+text_type = str
+native_path_types = (str, bytes)
+thread_mod_name = '_thread'
 
 hostname_types = tuple(set(string_types + (bytearray, bytes)))
 
 def NativeStrIO():
     import io
     return io.BytesIO() if str is bytes else io.StringIO()
 
-try:
-    from abc import ABC
-except ImportError:
-    import abc
-    ABC = abc.ABCMeta('ABC', (object,), {'__slots__': ()})
-    del abc
+
+from abc import ABC # pylint:disable=unused-import
 
 
 ## Exceptions
-if PY3:
-    def reraise(t, value, tb=None): # pylint:disable=unused-argument
-        if value.__traceback__ is not tb and tb is not None:
-            raise value.with_traceback(tb)
-        raise value
-    def exc_clear():
-        pass
-
-else:
-    from gevent._util_py2 import reraise # pylint:disable=import-error,no-name-in-module
-    reraise = reraise # export
-    exc_clear = sys.exc_clear
+
+def reraise(t, value, tb=None): # pylint:disable=unused-argument
+    if value.__traceback__ is not tb and tb is not None:
+        raise value.with_traceback(tb)
+    raise value
+def exc_clear():
+    pass
+
+
 
 ## import locks
 try:
@@ -86,127 +65,28 @@ def exc_clear():
 imp_release_lock = imp.release_lock
 
 ## Functions
-if PY3:
-    iteritems = dict.items
-    itervalues = dict.values
-    xrange = range
-    izip = zip
-
-else:
-    iteritems = dict.iteritems # python 3: pylint:disable=no-member
-    itervalues = dict.itervalues # python 3: pylint:disable=no-member
-    xrange = __builtin__.xrange
-    from itertools import izip # python 3: pylint:disable=no-member,no-name-in-module
-    izip = izip
+iteritems = dict.items
+itervalues = dict.values
+xrange = range
+izip = zip
 
-## The __fspath__ protocol
 
-try:
-    from os import PathLike # pylint:disable=unused-import
-except ImportError:
-    class PathLike(ABC):
-        @classmethod
-        def __subclasshook__(cls, subclass):
-            return hasattr(subclass, '__fspath__')
-
-# fspath from 3.6 os.py, but modified to raise the same exceptions as the
-# real native implementation.
-# Define for testing
-def _fspath(path):
-    """
-    Return the path representation of a path-like object.
-
-    If str or bytes is passed in, it is returned unchanged. Otherwise the
-    os.PathLike interface is used to get the path representation. If the
-    path representation is not str or bytes, TypeError is raised. If the
-    provided path is not str, bytes, or os.PathLike, TypeError is raised.
-    """
-    if isinstance(path, native_path_types):
-        return path
-
-    # Work from the object's type to match method resolution of other magic
-    # methods.
-    path_type = type(path)
-    try:
-        path_type_fspath = path_type.__fspath__
-    except AttributeError:
-        raise TypeError("expected str, bytes or os.PathLike object, "
-                        "not " + path_type.__name__)
-
-    path_repr = path_type_fspath(path)
-    if isinstance(path_repr, native_path_types):
-        return path_repr
-
-    raise TypeError("expected {}.__fspath__() to return str or bytes, "
-                    "not {}".format(path_type.__name__,
-                                    type(path_repr).__name__))
-try:
-    from os import fspath # pylint: disable=unused-import,no-name-in-module
-except ImportError:
-    # if not available, use the Python version as transparently as
-    # possible
-    fspath = _fspath
-    fspath.__name__ = 'fspath'
-
-try:
-    from os import fsencode # pylint: disable=unused-import,no-name-in-module
-except ImportError:
-    encoding = sys.getfilesystemencoding() or ('utf-8' if not WIN else 'mbcs')
-    errors = 'strict' if WIN and encoding == 'mbcs' else 'surrogateescape'
-
-    # Added in 3.2, so this is for Python 2.7. Note that it doesn't have
-    # sys.getfilesystemencodeerrors(), which was added in 3.6
-    def fsencode(filename):
-        """Encode filename (an os.PathLike, bytes, or str) to the filesystem
-        encoding with 'surrogateescape' error handler, return bytes unchanged.
-        On Windows, use 'strict' error handler if the file system encoding is
-        'mbcs' (which is the default encoding).
-        """
-        filename = fspath(filename)  # Does type-checking of `filename`.
-        if isinstance(filename, bytes):
-            return filename
-
-        try:
-            return filename.encode(encoding, errors)
-        except LookupError:
-            # Can't encode it, and the error handler doesn't
-            # exist. Probably on Python 2 with an astral character.
-            # Not sure how to handle this.
-            raise UnicodeEncodeError("Can't encode path to filesystem encoding")
-
-try:
-    from os import fsdecode # pylint:disable=unused-import
-except ImportError:
-    def fsdecode(filename):
-        """Decode filename (an os.PathLike, bytes, or str) from the filesystem
-        encoding with 'surrogateescape' error handler, return str unchanged. On
-        Windows, use 'strict' error handler if the file system encoding is
-        'mbcs' (which is the default encoding).
-        """
-        filename = fspath(filename)  # Does type-checking of `filename`.
-        if PY3 and isinstance(filename, bytes):
-            return filename.decode(encoding, errors)
-        return filename
+## The __fspath__ protocol
+from os import PathLike # pylint:disable=unused-import
+from os import fspath
+_fspath = fspath
+from os import fsencode # pylint:disable=unused-import
+from os import fsdecode # pylint:disable=unused-import
 
 ## Clocks
-try:
-    # Python 3.3+ (PEP 418)
-    from time import perf_counter
-    from time import get_clock_info
-    from time import monotonic
-    perf_counter = perf_counter
-    monotonic = monotonic
-    get_clock_info = get_clock_info
-except ImportError:
-    import time
-
-    if sys.platform == "win32":
-        perf_counter = time.clock # pylint:disable=no-member
-    else:
-        perf_counter = time.time
-    monotonic = perf_counter
-    def get_clock_info(_):
-        return 'Unknown'
+# Python 3.3+ (PEP 418)
+from time import perf_counter
+from time import get_clock_info
+from time import monotonic
+perf_counter = perf_counter
+monotonic = monotonic
+get_clock_info = get_clock_info
+
 
 ## Monitoring
 def get_this_psutil_process():

src/gevent/_fileobjectcommon.py

@@ -14,7 +14,6 @@
 import os
 
 from gevent.hub import _get_hub_noargs as get_hub
-from gevent._compat import PY2
 from gevent._compat import integer_types
 from gevent._compat import reraise
 from gevent._compat import fspath
@@ -393,18 +392,12 @@ def __wrapped(self, raw):
 
         if not self.binary:
             # Either native or text at this point.
-            if PY2 and self.native:
-                # Neither text mode nor binary mode specified.
-                if self.universal:
-                    # universal was requested, e.g., 'rU'
-                    result = UniversalNewlineBytesWrapper(result, line_buffering)
-            else:
-                # Python 2 and text mode, or Python 3 and either text or native (both are the same)
-                if not isinstance(raw, io.TextIOBase):
-                    # Avoid double-wrapping a TextIOBase in another TextIOWrapper.
-                    # That tends not to work. See https://github.com/gevent/gevent/issues/1542
-                    result = io.TextIOWrapper(result, self.encoding, self.errors, self.newline,
-                                              line_buffering)
+            # Python 2 and text mode, or Python 3 and either text or native (both are the same)
+            if not isinstance(raw, io.TextIOBase):
+                # Avoid double-wrapping a TextIOBase in another TextIOWrapper.
+                # That tends not to work. See https://github.com/gevent/gevent/issues/1542
+                result = io.TextIOWrapper(result, self.encoding, self.errors, self.newline,
+                                          line_buffering)
 
         if result is not raw or self._raw_object_is_new(raw):
             # Set the mode, if possible, but only if we created a new

src/gevent/_patcher.py

@@ -12,7 +12,7 @@
 import importlib
 import sys
 
-from gevent._compat import PY3
+
 from gevent._compat import iteritems
 from gevent._compat import imp_acquire_lock
 from gevent._compat import imp_release_lock
@@ -25,23 +25,20 @@
     'gevent.local': '_threading_local',
     'gevent.socket': 'socket',
     'gevent.select': 'select',
-    'gevent.selectors': 'selectors' if PY3 else 'selectors2',
+    'gevent.selectors': 'selectors',
     'gevent.ssl': 'ssl',
-    'gevent.thread': '_thread' if PY3 else 'thread',
+    'gevent.thread': '_thread',
     'gevent.subprocess': 'subprocess',
     'gevent.os': 'os',
     'gevent.threading': 'threading',
-    'gevent.builtins': 'builtins' if PY3 else '__builtin__',
+    'gevent.builtins': 'builtins',
     'gevent.signal': 'signal',
     'gevent.time': 'time',
-    'gevent.queue': 'queue' if PY3 else 'Queue',
+    'gevent.queue': 'queue',
     'gevent.contextvars': 'contextvars',
 }
 
-OPTIONAL_STDLIB_MODULES = frozenset() if PY3 else frozenset([
-    'selectors2',
-])
-
+OPTIONAL_STDLIB_MODULES = frozenset()
 _PATCH_PREFIX = '__g_patched_module_'
 
 def _collect_stdlib_gevent_modules():

src/gevent/_socketcommon.py

@@ -270,10 +270,16 @@ def getfqdn(name=''):
     First the hostname returned by gethostbyaddr() is checked, then
     possibly existing aliases. In case no FQDN is available, hostname
     from gethostname() is returned.
+
+    .. versionchanged:: NEXT
+       The IPv6 generic address '::' now returns the result of
+       ``gethostname``, like the IPv4 address '0.0.0.0'.
     """
     # pylint: disable=undefined-variable
     name = name.strip()
-    if not name or name == '0.0.0.0':
+    # IPv6 added in a late Python 3.10/3.11 patch release.
+    # https://github.com/python/cpython/issues/100374
+    if not name or name in ('0.0.0.0', '::'):
         name = gethostname()
     try:
         hostname, aliases, _ = gethostbyaddr(name)

src/gevent/_ssl3.py

@@ -13,13 +13,13 @@
 _ssl = __ssl__._ssl
 
 import errno
-import sys
+
 
 from gevent.socket import socket, timeout_default
 from gevent.socket import error as socket_error
 from gevent.socket import timeout as _socket_timeout
 from gevent._util import copy_globals
-from gevent._compat import PY36
+
 
 from weakref import ref as _wref
 
@@ -49,8 +49,8 @@
 from ssl import SSL_ERROR_WANT_READ
 from ssl import SSL_ERROR_WANT_WRITE
 from ssl import PROTOCOL_SSLv23
-from ssl import SSLObject
-from ssl import match_hostname
+#from ssl import SSLObject
+
 from ssl import CHANNEL_BINDING_TYPES
 from ssl import CERT_REQUIRED
 from ssl import DER_cert_to_PEM_cert
@@ -674,32 +674,14 @@ def do_handshake(self):
                     raise
                 self._wait(self._write_event, timeout_exc=_SSLErrorHandshakeTimeout)
 
-        if sys.version_info[:2] < (3, 7) and self._context.check_hostname:
-            # In Python 3.7, the underlying OpenSSL name matching is used.
-            # The version implemented in Python doesn't understand IDNA encoding.
-            if not self.server_hostname:
-                raise ValueError("check_hostname needs server_hostname "
-                                 "argument")
-            match_hostname(self.getpeercert(), self.server_hostname) # pylint:disable=deprecated-method
-
-    if hasattr(SSLObject, '_create'):
-        # 3.7+, making it difficult to create these objects.
-        # There's a new type, _ssl.SSLSocket, that takes the
-        # place of SSLObject for self._sslobj. This one does it all.
-        def __create_sslobj(self, server_side=False, session=None):
-            return self.context._wrap_socket(
-                self._sock, server_side, self.server_hostname,
-                owner=self._sock, session=session
-            )
-    elif PY36: # 3.6
-        def __create_sslobj(self, server_side=False, session=None):
-            sslobj = self._context._wrap_socket(self._sock, server_side, self.server_hostname)
-            return SSLObject(sslobj, owner=self._sock, session=session)
-    else: # 3.5
-        def __create_sslobj(self, server_side=False, session=None): # pylint:disable=unused-argument
-            sslobj = self._context._wrap_socket(self._sock, server_side, self.server_hostname)
-            return SSLObject(sslobj, owner=self._sock)
-
+    # 3.7+, making it difficult to create these objects.
+    # There's a new type, _ssl.SSLSocket, that takes the
+    # place of SSLObject for self._sslobj. This one does it all.
+    def __create_sslobj(self, server_side=False, session=None):
+        return self.context._wrap_socket(
+            self._sock, server_side, self.server_hostname,
+            owner=self._sock, session=session
+        )
 
     def _real_connect(self, addr, connect_ex):
         if self.server_side: