First commit

author: Shubham Saini <shubham6405@gmail.com> 2018-12-11 10:01:23 +0000
committer: Shubham Saini <shubham6405@gmail.com> 2018-12-11 10:01:23 +0000
commit: 68df54d6629ec019142eb149dd037774f2d11e7c (patch)
tree: 345bc22d46b4e01a4ba8303b94278952a4ed2b9e /venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_vendor/urllib3/util/selectors.py
1 files changed, 581 insertions, 0 deletions
diff --git a/venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_vendor/urllib3/util/selectors.py b/venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_vendor/urllib3/util/selectors.py
new file mode 100644
index 0000000..9f16c66
--- /dev/null
+++ b/venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_vendor/urllib3/util/selectors.py
@@ -0,0 +1,581 @@
+# Backport of selectors.py from Python 3.5+ to support Python < 3.4
+# Also has the behavior specified in PEP 475 which is to retry syscalls
+# in the case of an EINTR error. This module is required because selectors34
+# does not follow this behavior and instead returns that no dile descriptor
+# events have occurred rather than retry the syscall. The decision to drop
+# support for select.devpoll is made to maintain 100% test coverage.
+import errno
+import math
+import select
+import socket
+import sys
+import time
+from collections import namedtuple, Mapping
+try:
+    monotonic = time.monotonic
+except (AttributeError, ImportError):  # Python 3.3<
+    monotonic = time.time
+EVENT_READ = (1 << 0)
+EVENT_WRITE = (1 << 1)
+HAS_SELECT = True  # Variable that shows whether the platform has a selector.
+_SYSCALL_SENTINEL = object()  # Sentinel in case a system call returns None.
+_DEFAULT_SELECTOR = None
+class SelectorError(Exception):
+    def __init__(self, errcode):
+        super(SelectorError, self).__init__()
+        self.errno = errcode
+    def __repr__(self):
+        return "<SelectorError errno={0}>".format(self.errno)
+    def __str__(self):
+        return self.__repr__()
+def _fileobj_to_fd(fileobj):
+    """ Return a file descriptor from a file object. If
+    given an integer will simply return that integer back. """
+    if isinstance(fileobj, int):
+        fd = fileobj
+    else:
+        try:
+            fd = int(fileobj.fileno())
+        except (AttributeError, TypeError, ValueError):
+            raise ValueError("Invalid file object: {0!r}".format(fileobj))
+    if fd < 0:
+        raise ValueError("Invalid file descriptor: {0}".format(fd))
+    return fd
+# Determine which function to use to wrap system calls because Python 3.5+
+# already handles the case when system calls are interrupted.
+if sys.version_info >= (3, 5):
+    def _syscall_wrapper(func, _, *args, **kwargs):
+        """ This is the short-circuit version of the below logic
+        because in Python 3.5+ all system calls automatically restart
+        and recalculate their timeouts. """
+        try:
+            return func(*args, **kwargs)
+        except (OSError, IOError, select.error) as e:
+            errcode = None
+            if hasattr(e, "errno"):
+                errcode = e.errno
+            raise SelectorError(errcode)
+else:
+    def _syscall_wrapper(func, recalc_timeout, *args, **kwargs):
+        """ Wrapper function for syscalls that could fail due to EINTR.
+        All functions should be retried if there is time left in the timeout
+        in accordance with PEP 475. """
+        timeout = kwargs.get("timeout", None)
+        if timeout is None:
+            expires = None
+            recalc_timeout = False
+        else:
+            timeout = float(timeout)
+            if timeout < 0.0:  # Timeout less than 0 treated as no timeout.
+                expires = None
+            else:
+                expires = monotonic() + timeout
+        args = list(args)
+        if recalc_timeout and "timeout" not in kwargs:
+            raise ValueError(
+                "Timeout must be in args or kwargs to be recalculated")
+        result = _SYSCALL_SENTINEL
+        while result is _SYSCALL_SENTINEL:
+            try:
+                result = func(*args, **kwargs)
+            # OSError is thrown by select.select
+            # IOError is thrown by select.epoll.poll
+            # select.error is thrown by select.poll.poll
+            # Aren't we thankful for Python 3.x rework for exceptions?
+            except (OSError, IOError, select.error) as e:
+                # select.error wasn't a subclass of OSError in the past.
+                errcode = None
+                if hasattr(e, "errno"):
+                    errcode = e.errno
+                elif hasattr(e, "args"):
+                    errcode = e.args[0]
+                # Also test for the Windows equivalent of EINTR.
+                is_interrupt = (errcode == errno.EINTR or (hasattr(errno, "WSAEINTR") and
+                                                           errcode == errno.WSAEINTR))
+                if is_interrupt:
+                    if expires is not None:
+                        current_time = monotonic()
+                        if current_time > expires:
+                            raise OSError(errno=errno.ETIMEDOUT)
+                        if recalc_timeout:
+                            if "timeout" in kwargs:
+                                kwargs["timeout"] = expires - current_time
+                    continue
+                if errcode:
+                    raise SelectorError(errcode)
+                else:
+                    raise
+        return result
+SelectorKey = namedtuple('SelectorKey', ['fileobj', 'fd', 'events', 'data'])
+class _SelectorMapping(Mapping):
+    """ Mapping of file objects to selector keys """
+    def __init__(self, selector):
+        self._selector = selector
+    def __len__(self):
+        return len(self._selector._fd_to_key)
+    def __getitem__(self, fileobj):
+        try:
+            fd = self._selector._fileobj_lookup(fileobj)
+            return self._selector._fd_to_key[fd]
+        except KeyError:
+            raise KeyError("{0!r} is not registered.".format(fileobj))
+    def __iter__(self):
+        return iter(self._selector._fd_to_key)
+class BaseSelector(object):
+    """ Abstract Selector class
+    A selector supports registering file objects to be monitored
+    for specific I/O events.
+    A file object is a file descriptor or any object with a
+    `fileno()` method. An arbitrary object can be attached to the
+    file object which can be used for example to store context info,
+    a callback, etc.
+    A selector can use various implementations (select(), poll(), epoll(),
+    and kqueue()) depending on the platform. The 'DefaultSelector' class uses
+    the most efficient implementation for the current platform.
+    """
+    def __init__(self):
+        # Maps file descriptors to keys.
+        self._fd_to_key = {}
+        # Read-only mapping returned by get_map()
+        self._map = _SelectorMapping(self)
+    def _fileobj_lookup(self, fileobj):
+        """ Return a file descriptor from a file object.
+        This wraps _fileobj_to_fd() to do an exhaustive
+        search in case the object is invalid but we still
+        have it in our map. Used by unregister() so we can
+        unregister an object that was previously registered
+        even if it is closed. It is also used by _SelectorMapping
+        """
+        try:
+            return _fileobj_to_fd(fileobj)
+        except ValueError:
+            # Search through all our mapped keys.
+            for key in self._fd_to_key.values():
+                if key.fileobj is fileobj:
+                    return key.fd
+            # Raise ValueError after all.
+            raise
+    def register(self, fileobj, events, data=None):
+        """ Register a file object for a set of events to monitor. """
+        if (not events) or (events & ~(EVENT_READ | EVENT_WRITE)):
+            raise ValueError("Invalid events: {0!r}".format(events))
+        key = SelectorKey(fileobj, self._fileobj_lookup(fileobj), events, data)
+        if key.fd in self._fd_to_key:
+            raise KeyError("{0!r} (FD {1}) is already registered"
+                           .format(fileobj, key.fd))
+        self._fd_to_key[key.fd] = key
+        return key
+    def unregister(self, fileobj):
+        """ Unregister a file object from being monitored. """
+        try:
+            key = self._fd_to_key.pop(self._fileobj_lookup(fileobj))
+        except KeyError:
+            raise KeyError("{0!r} is not registered".format(fileobj))
+        # Getting the fileno of a closed socket on Windows errors with EBADF.
+        except socket.error as e:  # Platform-specific: Windows.
+            if e.errno != errno.EBADF:
+                raise
+            else:
+                for key in self._fd_to_key.values():
+                    if key.fileobj is fileobj:
+                        self._fd_to_key.pop(key.fd)
+                        break
+                else:
+                    raise KeyError("{0!r} is not registered".format(fileobj))
+        return key
+    def modify(self, fileobj, events, data=None):
+        """ Change a registered file object monitored events and data. """
+        # NOTE: Some subclasses optimize this operation even further.
+        try:
+            key = self._fd_to_key[self._fileobj_lookup(fileobj)]
+        except KeyError:
+            raise KeyError("{0!r} is not registered".format(fileobj))
+        if events != key.events:
+            self.unregister(fileobj)
+            key = self.register(fileobj, events, data)
+        elif data != key.data:
+            # Use a shortcut to update the data.
+            key = key._replace(data=data)
+            self._fd_to_key[key.fd] = key
+        return key
+    def select(self, timeout=None):
+        """ Perform the actual selection until some monitored file objects
+        are ready or the timeout expires. """
+        raise NotImplementedError()
+    def close(self):
+        """ Close the selector. This must be called to ensure that all
+        underlying resources are freed. """
+        self._fd_to_key.clear()
+        self._map = None
+    def get_key(self, fileobj):
+        """ Return the key associated with a registered file object. """
+        mapping = self.get_map()
+        if mapping is None:
+            raise RuntimeError("Selector is closed")
+        try:
+            return mapping[fileobj]
+        except KeyError:
+            raise KeyError("{0!r} is not registered".format(fileobj))
+    def get_map(self):
+        """ Return a mapping of file objects to selector keys """
+        return self._map
+    def _key_from_fd(self, fd):
+        """ Return the key associated to a given file descriptor
+         Return None if it is not found. """
+        try:
+            return self._fd_to_key[fd]
+        except KeyError:
+            return None
+    def __enter__(self):
+        return self
+    def __exit__(self, *args):
+        self.close()
+# Almost all platforms have select.select()
+if hasattr(select, "select"):
+    class SelectSelector(BaseSelector):
+        """ Select-based selector. """
+        def __init__(self):
+            super(SelectSelector, self).__init__()
+            self._readers = set()
+            self._writers = set()
+        def register(self, fileobj, events, data=None):
+            key = super(SelectSelector, self).register(fileobj, events, data)
+            if events & EVENT_READ:
+                self._readers.add(key.fd)
+            if events & EVENT_WRITE:
+                self._writers.add(key.fd)
+            return key
+        def unregister(self, fileobj):
+            key = super(SelectSelector, self).unregister(fileobj)
+            self._readers.discard(key.fd)
+            self._writers.discard(key.fd)
+            return key
+        def _select(self, r, w, timeout=None):
+            """ Wrapper for select.select because timeout is a positional arg """
+            return select.select(r, w, [], timeout)
+        def select(self, timeout=None):
+            # Selecting on empty lists on Windows errors out.
+            if not len(self._readers) and not len(self._writers):
+                return []
+            timeout = None if timeout is None else max(timeout, 0.0)
+            ready = []
+            r, w, _ = _syscall_wrapper(self._select, True, self._readers,
+                                       self._writers, timeout)
+            r = set(r)
+            w = set(w)
+            for fd in r | w:
+                events = 0
+                if fd in r:
+                    events |= EVENT_READ
+                if fd in w:
+                    events |= EVENT_WRITE
+                key = self._key_from_fd(fd)
+                if key:
+                    ready.append((key, events & key.events))
+            return ready
+if hasattr(select, "poll"):
+    class PollSelector(BaseSelector):
+        """ Poll-based selector """
+        def __init__(self):
+            super(PollSelector, self).__init__()
+            self._poll = select.poll()
+        def register(self, fileobj, events, data=None):
+            key = super(PollSelector, self).register(fileobj, events, data)
+            event_mask = 0
+            if events & EVENT_READ:
+                event_mask |= select.POLLIN
+            if events & EVENT_WRITE:
+                event_mask |= select.POLLOUT
+            self._poll.register(key.fd, event_mask)
+            return key
+        def unregister(self, fileobj):
+            key = super(PollSelector, self).unregister(fileobj)
+            self._poll.unregister(key.fd)
+            return key
+        def _wrap_poll(self, timeout=None):
+            """ Wrapper function for select.poll.poll() so that
+            _syscall_wrapper can work with only seconds. """
+            if timeout is not None:
+                if timeout <= 0:
+                    timeout = 0
+                else:
+                    # select.poll.poll() has a resolution of 1 millisecond,
+                    # round away from zero to wait *at least* timeout seconds.
+                    timeout = math.ceil(timeout * 1e3)
+            result = self._poll.poll(timeout)
+            return result
+        def select(self, timeout=None):
+            ready = []
+            fd_events = _syscall_wrapper(self._wrap_poll, True, timeout=timeout)
+            for fd, event_mask in fd_events:
+                events = 0
+                if event_mask & ~select.POLLIN:
+                    events |= EVENT_WRITE
+                if event_mask & ~select.POLLOUT:
+                    events |= EVENT_READ
+                key = self._key_from_fd(fd)
+                if key:
+                    ready.append((key, events & key.events))
+            return ready
+if hasattr(select, "epoll"):
+    class EpollSelector(BaseSelector):
+        """ Epoll-based selector """
+        def __init__(self):
+            super(EpollSelector, self).__init__()
+            self._epoll = select.epoll()
+        def fileno(self):
+            return self._epoll.fileno()
+        def register(self, fileobj, events, data=None):
+            key = super(EpollSelector, self).register(fileobj, events, data)
+            events_mask = 0
+            if events & EVENT_READ:
+                events_mask |= select.EPOLLIN
+            if events & EVENT_WRITE:
+                events_mask |= select.EPOLLOUT
+            _syscall_wrapper(self._epoll.register, False, key.fd, events_mask)
+            return key
+        def unregister(self, fileobj):
+            key = super(EpollSelector, self).unregister(fileobj)
+            try:
+                _syscall_wrapper(self._epoll.unregister, False, key.fd)
+            except SelectorError:
+                # This can occur when the fd was closed since registry.
+                pass
+            return key
+        def select(self, timeout=None):
+            if timeout is not None:
+                if timeout <= 0:
+                    timeout = 0.0
+                else:
+                    # select.epoll.poll() has a resolution of 1 millisecond
+                    # but luckily takes seconds so we don't need a wrapper
+                    # like PollSelector. Just for better rounding.
+                    timeout = math.ceil(timeout * 1e3) * 1e-3
+                timeout = float(timeout)
+            else:
+                timeout = -1.0  # epoll.poll() must have a float.
+            # We always want at least 1 to ensure that select can be called
+            # with no file descriptors registered. Otherwise will fail.
+            max_events = max(len(self._fd_to_key), 1)
+            ready = []
+            fd_events = _syscall_wrapper(self._epoll.poll, True,
+                                         timeout=timeout,
+                                         maxevents=max_events)
+            for fd, event_mask in fd_events:
+                events = 0
+                if event_mask & ~select.EPOLLIN:
+                    events |= EVENT_WRITE
+                if event_mask & ~select.EPOLLOUT:
+                    events |= EVENT_READ
+                key = self._key_from_fd(fd)
+                if key:
+                    ready.append((key, events & key.events))
+            return ready
+        def close(self):
+            self._epoll.close()
+            super(EpollSelector, self).close()
+if hasattr(select, "kqueue"):
+    class KqueueSelector(BaseSelector):
+        """ Kqueue / Kevent-based selector """
+        def __init__(self):
+            super(KqueueSelector, self).__init__()
+            self._kqueue = select.kqueue()
+        def fileno(self):
+            return self._kqueue.fileno()
+        def register(self, fileobj, events, data=None):
+            key = super(KqueueSelector, self).register(fileobj, events, data)
+            if events & EVENT_READ:
+                kevent = select.kevent(key.fd,
+                                       select.KQ_FILTER_READ,
+                                       select.KQ_EV_ADD)
+                _syscall_wrapper(self._kqueue.control, False, [kevent], 0, 0)
+            if events & EVENT_WRITE:
+                kevent = select.kevent(key.fd,
+                                       select.KQ_FILTER_WRITE,
+                                       select.KQ_EV_ADD)
+                _syscall_wrapper(self._kqueue.control, False, [kevent], 0, 0)
+            return key
+        def unregister(self, fileobj):
+            key = super(KqueueSelector, self).unregister(fileobj)
+            if key.events & EVENT_READ:
+                kevent = select.kevent(key.fd,
+                                       select.KQ_FILTER_READ,
+                                       select.KQ_EV_DELETE)
+                try:
+                    _syscall_wrapper(self._kqueue.control, False, [kevent], 0, 0)
+                except SelectorError:
+                    pass
+            if key.events & EVENT_WRITE:
+                kevent = select.kevent(key.fd,
+                                       select.KQ_FILTER_WRITE,
+                                       select.KQ_EV_DELETE)
+                try:
+                    _syscall_wrapper(self._kqueue.control, False, [kevent], 0, 0)
+                except SelectorError:
+                    pass
+            return key
+        def select(self, timeout=None):
+            if timeout is not None:
+                timeout = max(timeout, 0)
+            max_events = len(self._fd_to_key) * 2
+            ready_fds = {}
+            kevent_list = _syscall_wrapper(self._kqueue.control, True,
+                                           None, max_events, timeout)
+            for kevent in kevent_list:
+                fd = kevent.ident
+                event_mask = kevent.filter
+                events = 0
+                if event_mask == select.KQ_FILTER_READ:
+                    events |= EVENT_READ
+                if event_mask == select.KQ_FILTER_WRITE:
+                    events |= EVENT_WRITE
+                key = self._key_from_fd(fd)
+                if key:
+                    if key.fd not in ready_fds:
+                        ready_fds[key.fd] = (key, events & key.events)
+                    else:
+                        old_events = ready_fds[key.fd][1]
+                        ready_fds[key.fd] = (key, (events | old_events) & key.events)
+            return list(ready_fds.values())
+        def close(self):
+            self._kqueue.close()
+            super(KqueueSelector, self).close()
+if not hasattr(select, 'select'):  # Platform-specific: AppEngine
+    HAS_SELECT = False
+def _can_allocate(struct):
+    """ Checks that select structs can be allocated by the underlying
+    operating system, not just advertised by the select module. We don't
+    check select() because we'll be hopeful that most platforms that
+    don't have it available will not advertise it. (ie: GAE) """
+    try:
+        # select.poll() objects won't fail until used.
+        if struct == 'poll':
+            p = select.poll()
+            p.poll(0)
+        # All others will fail on allocation.
+        else:
+            getattr(select, struct)().close()
+        return True
+    except (OSError, AttributeError) as e:
+        return False
+# Choose the best implementation, roughly:
+# kqueue == epoll > poll > select. Devpoll not supported. (See above)
+# select() also can't accept a FD > FD_SETSIZE (usually around 1024)
+def DefaultSelector():
+    """ This function serves as a first call for DefaultSelector to
+    detect if the select module is being monkey-patched incorrectly
+    by eventlet, greenlet, and preserve proper behavior. """
+    global _DEFAULT_SELECTOR
+    if _DEFAULT_SELECTOR is None:
+        if _can_allocate('kqueue'):
+            _DEFAULT_SELECTOR = KqueueSelector
+        elif _can_allocate('epoll'):
+            _DEFAULT_SELECTOR = EpollSelector
+        elif _can_allocate('poll'):
+            _DEFAULT_SELECTOR = PollSelector
+        elif hasattr(select, 'select'):
+            _DEFAULT_SELECTOR = SelectSelector
+        else:  # Platform-specific: AppEngine
+            raise ValueError('Platform does not have a selector')
+    return _DEFAULT_SELECTOR()
author	Shubham Saini <shubham6405@gmail.com>	2018-12-11 10:01:23 +0000
committer	Shubham Saini <shubham6405@gmail.com>	2018-12-11 10:01:23 +0000
commit	68df54d6629ec019142eb149dd037774f2d11e7c (patch)
tree	345bc22d46b4e01a4ba8303b94278952a4ed2b9e /venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_vendor/urllib3/util/selectors.py

diff --git a/venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_vendor/urllib3/util/selectors.py b/venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_vendor/urllib3/util/selectors.py new file mode 100644 index 0000000..9f16c66 --- /dev/null +++ b/venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_vendor/urllib3/util/selectors.py
@@ -0,0 +1,581 @@
	1	# Backport of selectors.py from Python 3.5+ to support Python < 3.4
	2	# Also has the behavior specified in PEP 475 which is to retry syscalls
	3	# in the case of an EINTR error. This module is required because selectors34
	4	# does not follow this behavior and instead returns that no dile descriptor
	5	# events have occurred rather than retry the syscall. The decision to drop
	6	# support for select.devpoll is made to maintain 100% test coverage.
	7
	8	import errno
	9	import math
	10	import select
	11	import socket
	12	import sys
	13	import time
	14	from collections import namedtuple, Mapping
	15
	16	try:
	17	monotonic = time.monotonic
	18	except (AttributeError, ImportError): # Python 3.3<
	19	monotonic = time.time
	20
	21	EVENT_READ = (1 << 0)
	22	EVENT_WRITE = (1 << 1)
	23
	24	HAS_SELECT = True # Variable that shows whether the platform has a selector.
	25	_SYSCALL_SENTINEL = object() # Sentinel in case a system call returns None.
	26	_DEFAULT_SELECTOR = None
	27
	28
	29	class SelectorError(Exception):
	30	def __init__(self, errcode):
	31	super(SelectorError, self).__init__()
	32	self.errno = errcode
	33
	34	def __repr__(self):
	35	return "<SelectorError errno={0}>".format(self.errno)
	36
	37	def __str__(self):
	38	return self.__repr__()
	39
	40
	41	def _fileobj_to_fd(fileobj):
	42	""" Return a file descriptor from a file object. If
	43	given an integer will simply return that integer back. """
	44	if isinstance(fileobj, int):
	45	fd = fileobj
	46	else:
	47	try:
	48	fd = int(fileobj.fileno())
	49	except (AttributeError, TypeError, ValueError):
	50	raise ValueError("Invalid file object: {0!r}".format(fileobj))
	51	if fd < 0:
	52	raise ValueError("Invalid file descriptor: {0}".format(fd))
	53	return fd
	54
	55
	56	# Determine which function to use to wrap system calls because Python 3.5+
	57	# already handles the case when system calls are interrupted.
	58	if sys.version_info >= (3, 5):
	59	def _syscall_wrapper(func, _, args, *kwargs):
	60	""" This is the short-circuit version of the below logic
	61	because in Python 3.5+ all system calls automatically restart
	62	and recalculate their timeouts. """
	63	try:
	64	return func(args, *kwargs)
	65	except (OSError, IOError, select.error) as e:
	66	errcode = None
	67	if hasattr(e, "errno"):
	68	errcode = e.errno
	69	raise SelectorError(errcode)
	70	else:
	71	def _syscall_wrapper(func, recalc_timeout, args, *kwargs):
	72	""" Wrapper function for syscalls that could fail due to EINTR.
	73	All functions should be retried if there is time left in the timeout
	74	in accordance with PEP 475. """
	75	timeout = kwargs.get("timeout", None)
	76	if timeout is None:
	77	expires = None
	78	recalc_timeout = False
	79	else:
	80	timeout = float(timeout)
	81	if timeout < 0.0: # Timeout less than 0 treated as no timeout.
	82	expires = None
	83	else:
	84	expires = monotonic() + timeout
	85
	86	args = list(args)
	87	if recalc_timeout and "timeout" not in kwargs:
	88	raise ValueError(
	89	"Timeout must be in args or kwargs to be recalculated")
	90
	91	result = _SYSCALL_SENTINEL
	92	while result is _SYSCALL_SENTINEL:
	93	try:
	94	result = func(args, *kwargs)
	95	# OSError is thrown by select.select
	96	# IOError is thrown by select.epoll.poll
	97	# select.error is thrown by select.poll.poll
	98	# Aren't we thankful for Python 3.x rework for exceptions?
	99	except (OSError, IOError, select.error) as e:
	100	# select.error wasn't a subclass of OSError in the past.
	101	errcode = None
	102	if hasattr(e, "errno"):
	103	errcode = e.errno
	104	elif hasattr(e, "args"):
	105	errcode = e.args[0]
	106
	107	# Also test for the Windows equivalent of EINTR.
	108	is_interrupt = (errcode == errno.EINTR or (hasattr(errno, "WSAEINTR") and
	109	errcode == errno.WSAEINTR))
	110
	111	if is_interrupt:
	112	if expires is not None:
	113	current_time = monotonic()
	114	if current_time > expires:
	115	raise OSError(errno=errno.ETIMEDOUT)
	116	if recalc_timeout:
	117	if "timeout" in kwargs:
	118	kwargs["timeout"] = expires - current_time
	119	continue
	120	if errcode:
	121	raise SelectorError(errcode)
	122	else:
	123	raise
	124	return result
	125
	126
	127	SelectorKey = namedtuple('SelectorKey', ['fileobj', 'fd', 'events', 'data'])
	128
	129
	130	class _SelectorMapping(Mapping):
	131	""" Mapping of file objects to selector keys """
	132
	133	def __init__(self, selector):
	134	self._selector = selector
	135
	136	def __len__(self):
	137	return len(self._selector._fd_to_key)
	138
	139	def __getitem__(self, fileobj):
	140	try:
	141	fd = self._selector._fileobj_lookup(fileobj)
	142	return self._selector._fd_to_key[fd]
	143	except KeyError:
	144	raise KeyError("{0!r} is not registered.".format(fileobj))
	145
	146	def __iter__(self):
	147	return iter(self._selector._fd_to_key)
	148
	149
	150	class BaseSelector(object):
	151	""" Abstract Selector class
	152
	153	A selector supports registering file objects to be monitored
	154	for specific I/O events.
	155
	156	A file object is a file descriptor or any object with a
	157	`fileno()` method. An arbitrary object can be attached to the
	158	file object which can be used for example to store context info,
	159	a callback, etc.
	160
	161	A selector can use various implementations (select(), poll(), epoll(),
	162	and kqueue()) depending on the platform. The 'DefaultSelector' class uses
	163	the most efficient implementation for the current platform.
	164	"""
	165	def __init__(self):
	166	# Maps file descriptors to keys.
	167	self._fd_to_key = {}
	168
	169	# Read-only mapping returned by get_map()
	170	self._map = _SelectorMapping(self)
	171
	172	def _fileobj_lookup(self, fileobj):
	173	""" Return a file descriptor from a file object.
	174	This wraps _fileobj_to_fd() to do an exhaustive
	175	search in case the object is invalid but we still
	176	have it in our map. Used by unregister() so we can
	177	unregister an object that was previously registered
	178	even if it is closed. It is also used by _SelectorMapping
	179	"""
	180	try:
	181	return _fileobj_to_fd(fileobj)
	182	except ValueError:
	183
	184	# Search through all our mapped keys.
	185	for key in self._fd_to_key.values():
	186	if key.fileobj is fileobj:
	187	return key.fd
	188
	189	# Raise ValueError after all.
	190	raise
	191
	192	def register(self, fileobj, events, data=None):
	193	""" Register a file object for a set of events to monitor. """
	194	if (not events) or (events & ~(EVENT_READ \| EVENT_WRITE)):
	195	raise ValueError("Invalid events: {0!r}".format(events))
	196
	197	key = SelectorKey(fileobj, self._fileobj_lookup(fileobj), events, data)
	198
	199	if key.fd in self._fd_to_key:
	200	raise KeyError("{0!r} (FD {1}) is already registered"
	201	.format(fileobj, key.fd))
	202
	203	self._fd_to_key[key.fd] = key
	204	return key
	205
	206	def unregister(self, fileobj):
	207	""" Unregister a file object from being monitored. """
	208	try:
	209	key = self._fd_to_key.pop(self._fileobj_lookup(fileobj))
	210	except KeyError:
	211	raise KeyError("{0!r} is not registered".format(fileobj))
	212
	213	# Getting the fileno of a closed socket on Windows errors with EBADF.
	214	except socket.error as e: # Platform-specific: Windows.
	215	if e.errno != errno.EBADF:
	216	raise
	217	else:
	218	for key in self._fd_to_key.values():
	219	if key.fileobj is fileobj:
	220	self._fd_to_key.pop(key.fd)
	221	break
	222	else:
	223	raise KeyError("{0!r} is not registered".format(fileobj))
	224	return key
	225
	226	def modify(self, fileobj, events, data=None):
	227	""" Change a registered file object monitored events and data. """
	228	# NOTE: Some subclasses optimize this operation even further.
	229	try:
	230	key = self._fd_to_key[self._fileobj_lookup(fileobj)]
	231	except KeyError:
	232	raise KeyError("{0!r} is not registered".format(fileobj))
	233
	234	if events != key.events:
	235	self.unregister(fileobj)
	236	key = self.register(fileobj, events, data)
	237
	238	elif data != key.data:
	239	# Use a shortcut to update the data.
	240	key = key._replace(data=data)
	241	self._fd_to_key[key.fd] = key
	242
	243	return key
	244
	245	def select(self, timeout=None):
	246	""" Perform the actual selection until some monitored file objects
	247	are ready or the timeout expires. """
	248	raise NotImplementedError()
	249
	250	def close(self):
	251	""" Close the selector. This must be called to ensure that all
	252	underlying resources are freed. """
	253	self._fd_to_key.clear()
	254	self._map = None
	255
	256	def get_key(self, fileobj):
	257	""" Return the key associated with a registered file object. """
	258	mapping = self.get_map()
	259	if mapping is None:
	260	raise RuntimeError("Selector is closed")
	261	try:
	262	return mapping[fileobj]
	263	except KeyError:
	264	raise KeyError("{0!r} is not registered".format(fileobj))
	265
	266	def get_map(self):
	267	""" Return a mapping of file objects to selector keys """
	268	return self._map
	269
	270	def _key_from_fd(self, fd):
	271	""" Return the key associated to a given file descriptor
	272	Return None if it is not found. """
	273	try:
	274	return self._fd_to_key[fd]
	275	except KeyError:
	276	return None
	277
	278	def __enter__(self):
	279	return self
	280
	281	def __exit__(self, *args):
	282	self.close()
	283
	284
	285	# Almost all platforms have select.select()
	286	if hasattr(select, "select"):
	287	class SelectSelector(BaseSelector):
	288	""" Select-based selector. """
	289	def __init__(self):
	290	super(SelectSelector, self).__init__()
	291	self._readers = set()
	292	self._writers = set()
	293
	294	def register(self, fileobj, events, data=None):
	295	key = super(SelectSelector, self).register(fileobj, events, data)
	296	if events & EVENT_READ:
	297	self._readers.add(key.fd)
	298	if events & EVENT_WRITE:
	299	self._writers.add(key.fd)
	300	return key
	301
	302	def unregister(self, fileobj):
	303	key = super(SelectSelector, self).unregister(fileobj)
	304	self._readers.discard(key.fd)
	305	self._writers.discard(key.fd)
	306	return key
	307
	308	def _select(self, r, w, timeout=None):
	309	""" Wrapper for select.select because timeout is a positional arg """
	310	return select.select(r, w, [], timeout)
	311
	312	def select(self, timeout=None):
	313	# Selecting on empty lists on Windows errors out.
	314	if not len(self._readers) and not len(self._writers):
	315	return []
	316
	317	timeout = None if timeout is None else max(timeout, 0.0)
	318	ready = []
	319	r, w, _ = _syscall_wrapper(self._select, True, self._readers,
	320	self._writers, timeout)
	321	r = set(r)
	322	w = set(w)
	323	for fd in r \| w:
	324	events = 0
	325	if fd in r:
	326	events \|= EVENT_READ
	327	if fd in w:
	328	events \|= EVENT_WRITE
	329
	330	key = self._key_from_fd(fd)
	331	if key:
	332	ready.append((key, events & key.events))
	333	return ready
	334
	335
	336	if hasattr(select, "poll"):
	337	class PollSelector(BaseSelector):
	338	""" Poll-based selector """
	339	def __init__(self):
	340	super(PollSelector, self).__init__()
	341	self._poll = select.poll()
	342
	343	def register(self, fileobj, events, data=None):
	344	key = super(PollSelector, self).register(fileobj, events, data)
	345	event_mask = 0
	346	if events & EVENT_READ:
	347	event_mask \|= select.POLLIN
	348	if events & EVENT_WRITE:
	349	event_mask \|= select.POLLOUT
	350	self._poll.register(key.fd, event_mask)
	351	return key
	352
	353	def unregister(self, fileobj):
	354	key = super(PollSelector, self).unregister(fileobj)
	355	self._poll.unregister(key.fd)
	356	return key
	357
	358	def _wrap_poll(self, timeout=None):
	359	""" Wrapper function for select.poll.poll() so that
	360	_syscall_wrapper can work with only seconds. """
	361	if timeout is not None:
	362	if timeout <= 0:
	363	timeout = 0
	364	else:
	365	# select.poll.poll() has a resolution of 1 millisecond,
	366	# round away from zero to wait at least timeout seconds.
	367	timeout = math.ceil(timeout * 1e3)
	368
	369	result = self._poll.poll(timeout)
	370	return result
	371
	372	def select(self, timeout=None):
	373	ready = []
	374	fd_events = _syscall_wrapper(self._wrap_poll, True, timeout=timeout)
	375	for fd, event_mask in fd_events:
	376	events = 0
	377	if event_mask & ~select.POLLIN:
	378	events \|= EVENT_WRITE
	379	if event_mask & ~select.POLLOUT:
	380	events \|= EVENT_READ
	381
	382	key = self._key_from_fd(fd)
	383	if key:
	384	ready.append((key, events & key.events))
	385
	386	return ready
	387
	388
	389	if hasattr(select, "epoll"):
	390	class EpollSelector(BaseSelector):
	391	""" Epoll-based selector """
	392	def __init__(self):
	393	super(EpollSelector, self).__init__()
	394	self._epoll = select.epoll()
	395
	396	def fileno(self):
	397	return self._epoll.fileno()
	398
	399	def register(self, fileobj, events, data=None):
	400	key = super(EpollSelector, self).register(fileobj, events, data)
	401	events_mask = 0
	402	if events & EVENT_READ:
	403	events_mask \|= select.EPOLLIN
	404	if events & EVENT_WRITE:
	405	events_mask \|= select.EPOLLOUT
	406	_syscall_wrapper(self._epoll.register, False, key.fd, events_mask)
	407	return key
	408
	409	def unregister(self, fileobj):
	410	key = super(EpollSelector, self).unregister(fileobj)
	411	try:
	412	_syscall_wrapper(self._epoll.unregister, False, key.fd)
	413	except SelectorError:
	414	# This can occur when the fd was closed since registry.
	415	pass
	416	return key
	417
	418	def select(self, timeout=None):
	419	if timeout is not None:
	420	if timeout <= 0:
	421	timeout = 0.0
	422	else:
	423	# select.epoll.poll() has a resolution of 1 millisecond
	424	# but luckily takes seconds so we don't need a wrapper
	425	# like PollSelector. Just for better rounding.
	426	timeout = math.ceil(timeout * 1e3) * 1e-3
	427	timeout = float(timeout)
	428	else:
	429	timeout = -1.0 # epoll.poll() must have a float.
	430
	431	# We always want at least 1 to ensure that select can be called
	432	# with no file descriptors registered. Otherwise will fail.
	433	max_events = max(len(self._fd_to_key), 1)
	434
	435	ready = []
	436	fd_events = _syscall_wrapper(self._epoll.poll, True,
	437	timeout=timeout,
	438	maxevents=max_events)
	439	for fd, event_mask in fd_events:
	440	events = 0
	441	if event_mask & ~select.EPOLLIN:
	442	events \|= EVENT_WRITE
	443	if event_mask & ~select.EPOLLOUT:
	444	events \|= EVENT_READ
	445
	446	key = self._key_from_fd(fd)
	447	if key:
	448	ready.append((key, events & key.events))
	449	return ready
	450
	451	def close(self):
	452	self._epoll.close()
	453	super(EpollSelector, self).close()
	454
	455
	456	if hasattr(select, "kqueue"):
	457	class KqueueSelector(BaseSelector):
	458	""" Kqueue / Kevent-based selector """
	459	def __init__(self):
	460	super(KqueueSelector, self).__init__()
	461	self._kqueue = select.kqueue()
	462
	463	def fileno(self):
	464	return self._kqueue.fileno()
	465
	466	def register(self, fileobj, events, data=None):
	467	key = super(KqueueSelector, self).register(fileobj, events, data)
	468	if events & EVENT_READ:
	469	kevent = select.kevent(key.fd,
	470	select.KQ_FILTER_READ,
	471	select.KQ_EV_ADD)
	472
	473	_syscall_wrapper(self._kqueue.control, False, [kevent], 0, 0)
	474
	475	if events & EVENT_WRITE:
	476	kevent = select.kevent(key.fd,
	477	select.KQ_FILTER_WRITE,
	478	select.KQ_EV_ADD)
	479
	480	_syscall_wrapper(self._kqueue.control, False, [kevent], 0, 0)
	481
	482	return key
	483
	484	def unregister(self, fileobj):
	485	key = super(KqueueSelector, self).unregister(fileobj)
	486	if key.events & EVENT_READ:
	487	kevent = select.kevent(key.fd,
	488	select.KQ_FILTER_READ,
	489	select.KQ_EV_DELETE)
	490	try:
	491	_syscall_wrapper(self._kqueue.control, False, [kevent], 0, 0)
	492	except SelectorError:
	493	pass
	494	if key.events & EVENT_WRITE:
	495	kevent = select.kevent(key.fd,
	496	select.KQ_FILTER_WRITE,
	497	select.KQ_EV_DELETE)
	498	try:
	499	_syscall_wrapper(self._kqueue.control, False, [kevent], 0, 0)
	500	except SelectorError:
	501	pass
	502
	503	return key
	504
	505	def select(self, timeout=None):
	506	if timeout is not None:
	507	timeout = max(timeout, 0)
	508
	509	max_events = len(self._fd_to_key) * 2
	510	ready_fds = {}
	511
	512	kevent_list = _syscall_wrapper(self._kqueue.control, True,
	513	None, max_events, timeout)
	514
	515	for kevent in kevent_list:
	516	fd = kevent.ident
	517	event_mask = kevent.filter
	518	events = 0
	519	if event_mask == select.KQ_FILTER_READ:
	520	events \|= EVENT_READ
	521	if event_mask == select.KQ_FILTER_WRITE:
	522	events \|= EVENT_WRITE
	523
	524	key = self._key_from_fd(fd)
	525	if key:
	526	if key.fd not in ready_fds:
	527	ready_fds[key.fd] = (key, events & key.events)
	528	else:
	529	old_events = ready_fds[key.fd][1]
	530	ready_fds[key.fd] = (key, (events \| old_events) & key.events)
	531
	532	return list(ready_fds.values())
	533
	534	def close(self):
	535	self._kqueue.close()
	536	super(KqueueSelector, self).close()
	537
	538
	539	if not hasattr(select, 'select'): # Platform-specific: AppEngine
	540	HAS_SELECT = False
	541
	542
	543	def _can_allocate(struct):
	544	""" Checks that select structs can be allocated by the underlying
	545	operating system, not just advertised by the select module. We don't
	546	check select() because we'll be hopeful that most platforms that
	547	don't have it available will not advertise it. (ie: GAE) """
	548	try:
	549	# select.poll() objects won't fail until used.
	550	if struct == 'poll':
	551	p = select.poll()
	552	p.poll(0)
	553
	554	# All others will fail on allocation.
	555	else:
	556	getattr(select, struct)().close()
	557	return True
	558	except (OSError, AttributeError) as e:
	559	return False
	560
	561
	562	# Choose the best implementation, roughly:
	563	# kqueue == epoll > poll > select. Devpoll not supported. (See above)
	564	# select() also can't accept a FD > FD_SETSIZE (usually around 1024)
	565	def DefaultSelector():
	566	""" This function serves as a first call for DefaultSelector to
	567	detect if the select module is being monkey-patched incorrectly
	568	by eventlet, greenlet, and preserve proper behavior. """
	569	global _DEFAULT_SELECTOR
	570	if _DEFAULT_SELECTOR is None:
	571	if _can_allocate('kqueue'):
	572	_DEFAULT_SELECTOR = KqueueSelector
	573	elif _can_allocate('epoll'):
	574	_DEFAULT_SELECTOR = EpollSelector
	575	elif _can_allocate('poll'):
	576	_DEFAULT_SELECTOR = PollSelector
	577	elif hasattr(select, 'select'):
	578	_DEFAULT_SELECTOR = SelectSelector
	579	else: # Platform-specific: AppEngine
	580	raise ValueError('Platform does not have a selector')
	581	return _DEFAULT_SELECTOR()