diff options
author | Shubham Saini <shubham6405@gmail.com> | 2019-08-05 08:32:33 +0000 |
---|---|---|
committer | Shubham Saini <shubham6405@gmail.com> | 2019-08-05 08:32:33 +0000 |
commit | 227b2d30a8675b44918f9d9ca89b24144a938215 (patch) | |
tree | 9f8e6a28724514b6fdf463a9ab2067a7ef309b72 /venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_vendor/urllib3/util/selectors.py | |
parent | 842a8cfbbbdb1f92889d892e4859dbd5d40c5be8 (diff) |
removing venv files
Diffstat (limited to 'venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_vendor/urllib3/util/selectors.py')
-rw-r--r-- | venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_vendor/urllib3/util/selectors.py | 581 |
1 files changed, 0 insertions, 581 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 deleted file mode 100644 index 9f16c66..0000000 --- a/venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_vendor/urllib3/util/selectors.py +++ /dev/null | |||
@@ -1,581 +0,0 @@ | |||
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() | ||