Downgraade urllib3==1.26.16

lib/urllib3/util/wait.py

@@ -1,10 +1,18 @@
-from __future__ import annotations
-
+import errno
 import select
-import socket
+import sys
 from functools import partial
 
-__all__ = ["wait_for_read", "wait_for_write"]
+try:
+    from time import monotonic
+except ImportError:
+    from time import time as monotonic
+
+__all__ = ["NoWayToWaitForSocketError", "wait_for_read", "wait_for_write"]
+
+
+class NoWayToWaitForSocketError(Exception):
+    pass
 
 
 # How should we wait on sockets?
@@ -29,13 +37,37 @@ __all__ = ["wait_for_read", "wait_for_write"]
 # So: on Windows we use select(), and everywhere else we use poll(). We also
 # fall back to select() in case poll() is somehow broken or missing.
 
+if sys.version_info >= (3, 5):
+    # Modern Python, that retries syscalls by default
+    def _retry_on_intr(fn, timeout):
+        return fn(timeout)
 
-def select_wait_for_socket(
-    sock: socket.socket,
-    read: bool = False,
-    write: bool = False,
-    timeout: float | None = None,
-) -> bool:
+else:
+    # Old and broken Pythons.
+    def _retry_on_intr(fn, timeout):
+        if timeout is None:
+            deadline = float("inf")
+        else:
+            deadline = monotonic() + timeout
+
+        while True:
+            try:
+                return fn(timeout)
+            # OSError for 3 <= pyver < 3.5, select.error for pyver <= 2.7
+            except (OSError, select.error) as e:
+                # 'e.args[0]' incantation works for both OSError and select.error
+                if e.args[0] != errno.EINTR:
+                    raise
+                else:
+                    timeout = deadline - monotonic()
+                    if timeout < 0:
+                        timeout = 0
+                    if timeout == float("inf"):
+                        timeout = None
+                    continue
+
+
+def select_wait_for_socket(sock, read=False, write=False, timeout=None):
     if not read and not write:
         raise RuntimeError("must specify at least one of read=True, write=True")
     rcheck = []
@@ -50,16 +82,11 @@ def select_wait_for_socket(
     # sockets for both conditions. (The stdlib selectors module does the same
     # thing.)
     fn = partial(select.select, rcheck, wcheck, wcheck)
-    rready, wready, xready = fn(timeout)
+    rready, wready, xready = _retry_on_intr(fn, timeout)
     return bool(rready or wready or xready)
 
 
-def poll_wait_for_socket(
-    sock: socket.socket,
-    read: bool = False,
-    write: bool = False,
-    timeout: float | None = None,
-) -> bool:
+def poll_wait_for_socket(sock, read=False, write=False, timeout=None):
     if not read and not write:
         raise RuntimeError("must specify at least one of read=True, write=True")
     mask = 0
@@ -71,33 +98,32 @@ def poll_wait_for_socket(
     poll_obj.register(sock, mask)
 
     # For some reason, poll() takes timeout in milliseconds
-    def do_poll(t: float | None) -> list[tuple[int, int]]:
+    def do_poll(t):
         if t is not None:
             t *= 1000
         return poll_obj.poll(t)
 
-    return bool(do_poll(timeout))
+    return bool(_retry_on_intr(do_poll, timeout))
 
 
-def _have_working_poll() -> bool:
+def null_wait_for_socket(*args, **kwargs):
+    raise NoWayToWaitForSocketError("no select-equivalent available")
+
+
+def _have_working_poll():
     # Apparently some systems have a select.poll that fails as soon as you try
     # to use it, either due to strange configuration or broken monkeypatching
     # from libraries like eventlet/greenlet.
     try:
         poll_obj = select.poll()
-        poll_obj.poll(0)
+        _retry_on_intr(poll_obj.poll, 0)
     except (AttributeError, OSError):
         return False
     else:
         return True
 
 
-def wait_for_socket(
-    sock: socket.socket,
-    read: bool = False,
-    write: bool = False,
-    timeout: float | None = None,
-) -> bool:
+def wait_for_socket(*args, **kwargs):
     # We delay choosing which implementation to use until the first time we're
     # called. We could do it at import time, but then we might make the wrong
     # decision if someone goes wild with monkeypatching select.poll after
@@ -107,17 +133,19 @@ def wait_for_socket(
         wait_for_socket = poll_wait_for_socket
     elif hasattr(select, "select"):
         wait_for_socket = select_wait_for_socket
-    return wait_for_socket(sock, read, write, timeout)
+    else:  # Platform-specific: Appengine.
+        wait_for_socket = null_wait_for_socket
+    return wait_for_socket(*args, **kwargs)
 
 
-def wait_for_read(sock: socket.socket, timeout: float | None = None) -> bool:
+def wait_for_read(sock, timeout=None):
     """Waits for reading to be available on a given socket.
     Returns True if the socket is readable, or False if the timeout expired.
     """
     return wait_for_socket(sock, read=True, timeout=timeout)
 
 
-def wait_for_write(sock: socket.socket, timeout: float | None = None) -> bool:
+def wait_for_write(sock, timeout=None):
     """Waits for writing to be available on a given socket.
     Returns True if the socket is readable, or False if the timeout expired.
     """