Select/poll improvements.

Author: jonathanslenders

prompt_toolkit/eventloop/inputhook.py

@@ -24,8 +24,8 @@
 """
 from __future__ import unicode_literals
 import os
-import select
 import threading
+from .select import select_fds
 
 __all__ = (
     'InputHookContext',
@@ -80,7 +80,7 @@ def thread():
             # the above thread.
             # This appears to be only required when gevent.monkey.patch_all()
             # has been executed. Otherwise it doesn't do much.
-            select.select([self._r], [], [])
+            select_fds([self._r], timeout=None)
 
             os.read(self._r, 1024)
         except OSError:

prompt_toolkit/eventloop/posix.py

@@ -1,10 +1,8 @@
 from __future__ import unicode_literals
 import datetime
-import errno
 import fcntl
 import os
 import random
-import select
 import signal
 import threading
 
@@ -16,6 +14,7 @@
 from .inputhook import InputHookContext
 from .posix_utils import PosixStdinReader
 from .utils import TimeIt
+from .select import select_fds
 
 __all__ = (
     'PosixEventLoop',
@@ -181,8 +180,8 @@ def _ready_for_reading(self, timeout=None):
         Return the file descriptors that are ready for reading.
         """
         read_fds = list(self._read_fds.keys())
-        r, _, _ =_select(read_fds, [], [], timeout)
-        return r
+        fds = select_fds(read_fds, timeout)
+        return fds
 
     def received_winch(self):
         """
@@ -266,24 +265,6 @@ def remove_reader(self, fd):
             del self._read_fds[fd]
 
 
-def _select(*args, **kwargs):
-    """
-    Wrapper around select.select.
-
-    When the SIGWINCH signal is handled, other system calls, like select
-    are aborted in Python. This wrapper will retry the system call.
-    """
-    while True:
-        try:
-            return select.select(*args, **kwargs)
-        except select.error as e:
-            # Retry select call when EINTR
-            if e.args and e.args[0] == errno.EINTR:
-                continue
-            else:
-                raise
-
-
 class call_on_sigwinch(object):
     """
     Context manager which Installs a SIGWINCH callback.

prompt_toolkit/eventloop/select.py

@@ -0,0 +1,95 @@
+import sys
+import select
+import errno
+
+__all__ = (
+    'select_fds',
+)
+
+def _fd_to_int(fd):
+    if isinstance(fd, int):
+        return fd
+    else:
+        return fd.fileno()
+
+def select_fds(read_fds, timeout):
+    """
+    Wait for a list of file descriptors (`read_fds`) to become ready for
+    reading. This chooses the most appropriate select-tool for use in
+    prompt-toolkit.
+
+    Note: This is an internal API that shouldn't be used for external projects.
+    """
+    # Map to ensure that we return the objects that were passed in originally.
+    # Whether they are a fd integer or an object that has a fileno().
+    # (The 'poll' implementation for instance, returns always integers.)
+    fd_map = {_fd_to_int(fd): fd for fd in read_fds}
+
+    if sys.version_info >= (3, 5):
+        # Use of the 'select' module, that was introduced in Python3.4.
+        # We don't use it before 3.5 however, because this is the point where
+        # this module retries interrupted system calls.
+        result = _python3_selectors(read_fds, timeout)
+    else:
+        try:
+            # First, try the 'select' module. This is the most universal, and
+            # powerful enough in our case.
+            result = _select(read_fds, timeout)
+        except ValueError:
+            # When we have more than 1024 open file descriptors, we'll always
+            # get a "ValueError: filedescriptor out of range in select()" for
+            # 'select'. In this case, retry, using 'poll' instead.
+            result = _poll(read_fds, timeout)
+
+    return [fd_map[_fd_to_int(fd)] for fd in result]
+
+
+def _python3_selectors(read_fds, timeout):
+    """
+    Use of the Python3 'selectors' module.
+
+    NOTE: Only use on Python 3.5 or newer!
+    """
+    import selectors  # Inline import: Python3 only!
+    sel = selectors.DefaultSelector()
+
+    for fd in read_fds:
+        sel.register(fd, selectors.EVENT_READ, None)
+
+    events = sel.select(timeout=timeout)
+    try:
+        return [key.fileobj for key, mask in events]
+    finally:
+        sel.close()
+
+
+def _poll(read_fds, timeout):
+    """
+    Use 'poll', to wait for any of the given `read_fds` to become ready.
+    """
+    from select import poll
+
+    p = poll()
+    for fd in read_fds:
+        p.register(fd, select.POLLIN)
+
+    tuples = p.poll(timeout)  # Returns (fd, event) tuples.
+    return [t[0] for t in tuples]
+
+
+def _select(read_fds, timeout):
+    """
+    Wrapper around select.select.
+
+    When the SIGWINCH signal is handled, other system calls, like select
+    are aborted in Python. This wrapper will retry the system call.
+    """
+    while True:
+        try:
+            return select.select(read_fds, [], [], timeout)[0]
+        except select.error as e:
+            # Retry select call when EINTR
+            if e.args and e.args[0] == errno.EINTR:
+                continue
+            else:
+                raise