parent
43d33dc247
commit
f389c38a9c
@ -1,3 +1,3 @@
|
|||||||
from .core import where
|
from .core import where
|
||||||
|
|
||||||
__version__ = "2019.03.09"
|
__version__ = "2019.09.11"
|
||||||
|
@ -1,2 +1,2 @@
|
|||||||
__version__ = '2.7'
|
__version__ = '2.8'
|
||||||
|
|
||||||
|
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@ -1,5 +1,6 @@
|
|||||||
# coding=utf-8
|
# coding=utf-8
|
||||||
|
|
||||||
from main import get_filebot_attrs
|
from __future__ import absolute_import
|
||||||
|
from .main import get_filebot_attrs
|
||||||
|
|
||||||
__all__ = ["get_filebot_attrs"]
|
__all__ = ["get_filebot_attrs"]
|
||||||
|
@ -1,2 +1,4 @@
|
|||||||
|
|
||||||
from pyprobe import VideoFileParser
|
from pyprobe.pyprobe import VideoFileParser
|
||||||
|
from pyprobe.helpers import timeToTuple, sizeStr
|
||||||
|
|
@ -1,259 +0,0 @@
|
|||||||
# Backport of OrderedDict() class that runs on Python 2.4, 2.5, 2.6, 2.7 and pypy.
|
|
||||||
# Passes Python2.7's test suite and incorporates all the latest updates.
|
|
||||||
# Copyright 2009 Raymond Hettinger, released under the MIT License.
|
|
||||||
# http://code.activestate.com/recipes/576693/
|
|
||||||
try:
|
|
||||||
from thread import get_ident as _get_ident
|
|
||||||
except ImportError:
|
|
||||||
from dummy_thread import get_ident as _get_ident
|
|
||||||
|
|
||||||
try:
|
|
||||||
from _abcoll import KeysView, ValuesView, ItemsView
|
|
||||||
except ImportError:
|
|
||||||
pass
|
|
||||||
|
|
||||||
|
|
||||||
class OrderedDict(dict):
|
|
||||||
'Dictionary that remembers insertion order'
|
|
||||||
# An inherited dict maps keys to values.
|
|
||||||
# The inherited dict provides __getitem__, __len__, __contains__, and get.
|
|
||||||
# The remaining methods are order-aware.
|
|
||||||
# Big-O running times for all methods are the same as for regular dictionaries.
|
|
||||||
|
|
||||||
# The internal self.__map dictionary maps keys to links in a doubly linked list.
|
|
||||||
# The circular doubly linked list starts and ends with a sentinel element.
|
|
||||||
# The sentinel element never gets deleted (this simplifies the algorithm).
|
|
||||||
# Each link is stored as a list of length three: [PREV, NEXT, KEY].
|
|
||||||
|
|
||||||
def __init__(self, *args, **kwds):
|
|
||||||
'''Initialize an ordered dictionary. Signature is the same as for
|
|
||||||
regular dictionaries, but keyword arguments are not recommended
|
|
||||||
because their insertion order is arbitrary.
|
|
||||||
|
|
||||||
'''
|
|
||||||
if len(args) > 1:
|
|
||||||
raise TypeError('expected at most 1 arguments, got %d' % len(args))
|
|
||||||
try:
|
|
||||||
self.__root
|
|
||||||
except AttributeError:
|
|
||||||
self.__root = root = [] # sentinel node
|
|
||||||
root[:] = [root, root, None]
|
|
||||||
self.__map = {}
|
|
||||||
self.__update(*args, **kwds)
|
|
||||||
|
|
||||||
def __setitem__(self, key, value, dict_setitem=dict.__setitem__):
|
|
||||||
'od.__setitem__(i, y) <==> od[i]=y'
|
|
||||||
# Setting a new item creates a new link which goes at the end of the linked
|
|
||||||
# list, and the inherited dictionary is updated with the new key/value pair.
|
|
||||||
if key not in self:
|
|
||||||
root = self.__root
|
|
||||||
last = root[0]
|
|
||||||
last[1] = root[0] = self.__map[key] = [last, root, key]
|
|
||||||
dict_setitem(self, key, value)
|
|
||||||
|
|
||||||
def __delitem__(self, key, dict_delitem=dict.__delitem__):
|
|
||||||
'od.__delitem__(y) <==> del od[y]'
|
|
||||||
# Deleting an existing item uses self.__map to find the link which is
|
|
||||||
# then removed by updating the links in the predecessor and successor nodes.
|
|
||||||
dict_delitem(self, key)
|
|
||||||
link_prev, link_next, key = self.__map.pop(key)
|
|
||||||
link_prev[1] = link_next
|
|
||||||
link_next[0] = link_prev
|
|
||||||
|
|
||||||
def __iter__(self):
|
|
||||||
'od.__iter__() <==> iter(od)'
|
|
||||||
root = self.__root
|
|
||||||
curr = root[1]
|
|
||||||
while curr is not root:
|
|
||||||
yield curr[2]
|
|
||||||
curr = curr[1]
|
|
||||||
|
|
||||||
def __reversed__(self):
|
|
||||||
'od.__reversed__() <==> reversed(od)'
|
|
||||||
root = self.__root
|
|
||||||
curr = root[0]
|
|
||||||
while curr is not root:
|
|
||||||
yield curr[2]
|
|
||||||
curr = curr[0]
|
|
||||||
|
|
||||||
def clear(self):
|
|
||||||
'od.clear() -> None. Remove all items from od.'
|
|
||||||
try:
|
|
||||||
for node in self.__map.itervalues():
|
|
||||||
del node[:]
|
|
||||||
root = self.__root
|
|
||||||
root[:] = [root, root, None]
|
|
||||||
self.__map.clear()
|
|
||||||
except AttributeError:
|
|
||||||
pass
|
|
||||||
dict.clear(self)
|
|
||||||
|
|
||||||
def popitem(self, last=True):
|
|
||||||
'''od.popitem() -> (k, v), return and remove a (key, value) pair.
|
|
||||||
Pairs are returned in LIFO order if last is true or FIFO order if false.
|
|
||||||
|
|
||||||
'''
|
|
||||||
if not self:
|
|
||||||
raise KeyError('dictionary is empty')
|
|
||||||
root = self.__root
|
|
||||||
if last:
|
|
||||||
link = root[0]
|
|
||||||
link_prev = link[0]
|
|
||||||
link_prev[1] = root
|
|
||||||
root[0] = link_prev
|
|
||||||
else:
|
|
||||||
link = root[1]
|
|
||||||
link_next = link[1]
|
|
||||||
root[1] = link_next
|
|
||||||
link_next[0] = root
|
|
||||||
key = link[2]
|
|
||||||
del self.__map[key]
|
|
||||||
value = dict.pop(self, key)
|
|
||||||
return key, value
|
|
||||||
|
|
||||||
# -- the following methods do not depend on the internal structure --
|
|
||||||
|
|
||||||
def keys(self):
|
|
||||||
'od.keys() -> list of keys in od'
|
|
||||||
return list(self)
|
|
||||||
|
|
||||||
def values(self):
|
|
||||||
'od.values() -> list of values in od'
|
|
||||||
return [self[key] for key in self]
|
|
||||||
|
|
||||||
def items(self):
|
|
||||||
'od.items() -> list of (key, value) pairs in od'
|
|
||||||
return [(key, self[key]) for key in self]
|
|
||||||
|
|
||||||
def iterkeys(self):
|
|
||||||
'od.iterkeys() -> an iterator over the keys in od'
|
|
||||||
return iter(self)
|
|
||||||
|
|
||||||
def itervalues(self):
|
|
||||||
'od.itervalues -> an iterator over the values in od'
|
|
||||||
for k in self:
|
|
||||||
yield self[k]
|
|
||||||
|
|
||||||
def iteritems(self):
|
|
||||||
'od.iteritems -> an iterator over the (key, value) items in od'
|
|
||||||
for k in self:
|
|
||||||
yield (k, self[k])
|
|
||||||
|
|
||||||
def update(*args, **kwds):
|
|
||||||
'''od.update(E, **F) -> None. Update od from dict/iterable E and F.
|
|
||||||
|
|
||||||
If E is a dict instance, does: for k in E: od[k] = E[k]
|
|
||||||
If E has a .keys() method, does: for k in E.keys(): od[k] = E[k]
|
|
||||||
Or if E is an iterable of items, does: for k, v in E: od[k] = v
|
|
||||||
In either case, this is followed by: for k, v in F.items(): od[k] = v
|
|
||||||
|
|
||||||
'''
|
|
||||||
if len(args) > 2:
|
|
||||||
raise TypeError('update() takes at most 2 positional '
|
|
||||||
'arguments (%d given)' % (len(args),))
|
|
||||||
elif not args:
|
|
||||||
raise TypeError('update() takes at least 1 argument (0 given)')
|
|
||||||
self = args[0]
|
|
||||||
# Make progressively weaker assumptions about "other"
|
|
||||||
other = ()
|
|
||||||
if len(args) == 2:
|
|
||||||
other = args[1]
|
|
||||||
if isinstance(other, dict):
|
|
||||||
for key in other:
|
|
||||||
self[key] = other[key]
|
|
||||||
elif hasattr(other, 'keys'):
|
|
||||||
for key in other.keys():
|
|
||||||
self[key] = other[key]
|
|
||||||
else:
|
|
||||||
for key, value in other:
|
|
||||||
self[key] = value
|
|
||||||
for key, value in kwds.items():
|
|
||||||
self[key] = value
|
|
||||||
|
|
||||||
__update = update # let subclasses override update without breaking __init__
|
|
||||||
|
|
||||||
__marker = object()
|
|
||||||
|
|
||||||
def pop(self, key, default=__marker):
|
|
||||||
'''od.pop(k[,d]) -> v, remove specified key and return the corresponding value.
|
|
||||||
If key is not found, d is returned if given, otherwise KeyError is raised.
|
|
||||||
|
|
||||||
'''
|
|
||||||
if key in self:
|
|
||||||
result = self[key]
|
|
||||||
del self[key]
|
|
||||||
return result
|
|
||||||
if default is self.__marker:
|
|
||||||
raise KeyError(key)
|
|
||||||
return default
|
|
||||||
|
|
||||||
def setdefault(self, key, default=None):
|
|
||||||
'od.setdefault(k[,d]) -> od.get(k,d), also set od[k]=d if k not in od'
|
|
||||||
if key in self:
|
|
||||||
return self[key]
|
|
||||||
self[key] = default
|
|
||||||
return default
|
|
||||||
|
|
||||||
def __repr__(self, _repr_running={}):
|
|
||||||
'od.__repr__() <==> repr(od)'
|
|
||||||
call_key = id(self), _get_ident()
|
|
||||||
if call_key in _repr_running:
|
|
||||||
return '...'
|
|
||||||
_repr_running[call_key] = 1
|
|
||||||
try:
|
|
||||||
if not self:
|
|
||||||
return '%s()' % (self.__class__.__name__,)
|
|
||||||
return '%s(%r)' % (self.__class__.__name__, self.items())
|
|
||||||
finally:
|
|
||||||
del _repr_running[call_key]
|
|
||||||
|
|
||||||
def __reduce__(self):
|
|
||||||
'Return state information for pickling'
|
|
||||||
items = [[k, self[k]] for k in self]
|
|
||||||
inst_dict = vars(self).copy()
|
|
||||||
for k in vars(OrderedDict()):
|
|
||||||
inst_dict.pop(k, None)
|
|
||||||
if inst_dict:
|
|
||||||
return (self.__class__, (items,), inst_dict)
|
|
||||||
return self.__class__, (items,)
|
|
||||||
|
|
||||||
def copy(self):
|
|
||||||
'od.copy() -> a shallow copy of od'
|
|
||||||
return self.__class__(self)
|
|
||||||
|
|
||||||
@classmethod
|
|
||||||
def fromkeys(cls, iterable, value=None):
|
|
||||||
'''OD.fromkeys(S[, v]) -> New ordered dictionary with keys from S
|
|
||||||
and values equal to v (which defaults to None).
|
|
||||||
|
|
||||||
'''
|
|
||||||
d = cls()
|
|
||||||
for key in iterable:
|
|
||||||
d[key] = value
|
|
||||||
return d
|
|
||||||
|
|
||||||
def __eq__(self, other):
|
|
||||||
'''od.__eq__(y) <==> od==y. Comparison to another OD is order-sensitive
|
|
||||||
while comparison to a regular mapping is order-insensitive.
|
|
||||||
|
|
||||||
'''
|
|
||||||
if isinstance(other, OrderedDict):
|
|
||||||
return len(self)==len(other) and self.items() == other.items()
|
|
||||||
return dict.__eq__(self, other)
|
|
||||||
|
|
||||||
def __ne__(self, other):
|
|
||||||
return not self == other
|
|
||||||
|
|
||||||
# -- the following methods are only used in Python 2.7 --
|
|
||||||
|
|
||||||
def viewkeys(self):
|
|
||||||
"od.viewkeys() -> a set-like object providing a view on od's keys"
|
|
||||||
return KeysView(self)
|
|
||||||
|
|
||||||
def viewvalues(self):
|
|
||||||
"od.viewvalues() -> an object providing a view on od's values"
|
|
||||||
return ValuesView(self)
|
|
||||||
|
|
||||||
def viewitems(self):
|
|
||||||
"od.viewitems() -> a set-like object providing a view on od's items"
|
|
||||||
return ItemsView(self)
|
|
@ -1,581 +0,0 @@
|
|||||||
# 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()
|
|
Loading…
Reference in new issue