FM / python3.5

/opt/alt/python35/lib64/python3.5

Name	Size	Mode	Actions
asyncio/	-	0755	rm
collections/	-	0755	rm
concurrent/	-	0755	rm
config-3.5m/	-	0755	rm
ctypes/	-	0755	rm
curses/	-	0755	rm
dbm/	-	0755	rm
distutils/	-	0755	rm
email/	-	0755	rm
encodings/	-	0755	rm
ensurepip/	-	0755	rm
html/	-	0755	rm
http/	-	0755	rm
idlelib/	-	0755	rm
importlib/	-	0755	rm
json/	-	0755	rm
lib-dynload/	-	0755	rm
lib2to3/	-	0755	rm
logging/	-	0755	rm
multiprocessing/	-	0755	rm
plat-linux/	-	0755	rm
pydoc_data/	-	0755	rm
site-packages/	-	0755	rm
sqlite3/	-	0755	rm
test/	-	0755	rm
unittest/	-	0755	rm
urllib/	-	0755	rm
venv/	-	0755	rm
wsgiref/	-	0755	rm
xml/	-	0755	rm
xmlrpc/	-	0755	rm
__pycache__/	-	0755	rm
abc.py	8628	0644	edit dl rm
aifc.py	31967	0644	edit dl rm
antigravity.py	476	0644	edit dl rm
argparse.py	90138	0644	edit dl rm
ast.py	12001	0644	edit dl rm
asynchat.py	11971	0644	edit dl rm
asyncore.py	20104	0644	edit dl rm
base64.py	20522	0755	edit dl rm
bdb.py	23354	0644	edit dl rm
binhex.py	13954	0644	edit dl rm
bisect.py	2595	0644	edit dl rm
bz2.py	12424	0644	edit dl rm
calendar.py	22998	0644	edit dl rm
cgi.py	36046	0755	edit dl rm
cgitb.py	12023	0644	edit dl rm
chunk.py	5425	0644	edit dl rm
cmd.py	14860	0644	edit dl rm
code.py	10118	0644	edit dl rm
codecs.py	36231	0644	edit dl rm
codeop.py	5994	0644	edit dl rm
colorsys.py	4064	0644	edit dl rm
compileall.py	11711	0644	edit dl rm
configparser.py	53452	0644	edit dl rm
contextlib.py	12451	0644	edit dl rm
copy.py	8946	0644	edit dl rm
copyreg.py	6833	0644	edit dl rm
cProfile.py	5324	0755	edit dl rm
crypt.py	1879	0644	edit dl rm
csv.py	16128	0644	edit dl rm
datetime.py	75899	0644	edit dl rm
decimal.py	320	0644	edit dl rm
difflib.py	84204	0644	edit dl rm
dis.py	17350	0644	edit dl rm
doctest.py	104036	0644	edit dl rm
dummy_threading.py	2815	0644	edit dl rm
enum.py	22226	0644	edit dl rm
filecmp.py	9830	0644	edit dl rm
fileinput.py	14259	0644	edit dl rm
fnmatch.py	3163	0644	edit dl rm
formatter.py	15143	0644	edit dl rm
fractions.py	24612	0644	edit dl rm
ftplib.py	34951	0644	edit dl rm
functools.py	28944	0644	edit dl rm
genericpath.py	4364	0644	edit dl rm
getopt.py	7489	0644	edit dl rm
getpass.py	5994	0644	edit dl rm
gettext.py	21530	0644	edit dl rm
glob.py	5072	0644	edit dl rm
gzip.py	20260	0644	edit dl rm
hashlib.py	7979	0644	edit dl rm
heapq.py	22929	0644	edit dl rm
hmac.py	5063	0644	edit dl rm
imaplib.py	52183	0644	edit dl rm
imghdr.py	3758	0644	edit dl rm
imp.py	10676	0644	edit dl rm
inspect.py	114199	0644	edit dl rm
io.py	3396	0644	edit dl rm
ipaddress.py	75733	0644	edit dl rm
keyword.py	2222	0755	edit dl rm
linecache.py	5312	0644	edit dl rm
locale.py	74713	0644	edit dl rm
lzma.py	12925	0644	edit dl rm
macpath.py	5907	0644	edit dl rm
macurl2path.py	2732	0644	edit dl rm
mailbox.py	78418	0644	edit dl rm
mailcap.py	8104	0644	edit dl rm
mimetypes.py	20847	0644	edit dl rm
modulefinder.py	23085	0644	edit dl rm
netrc.py	5748	0644	edit dl rm
nntplib.py	43078	0644	edit dl rm
ntpath.py	22793	0644	edit dl rm
nturl2path.py	2444	0644	edit dl rm
numbers.py	10243	0644	edit dl rm
opcode.py	5885	0644	edit dl rm
operator.py	10863	0644	edit dl rm
optparse.py	60344	0644	edit dl rm
os.py	37033	0644	edit dl rm
pathlib.py	47001	0644	edit dl rm
pdb.py	61149	0755	edit dl rm
pickle.py	56176	0644	edit dl rm
pickletools.py	91761	0644	edit dl rm
pipes.py	8916	0644	edit dl rm
pkgutil.py	21355	0644	edit dl rm
platform.py	46147	0755	edit dl rm
plistlib.py	31810	0644	edit dl rm
poplib.py	14717	0644	edit dl rm
posixpath.py	14911	0644	edit dl rm
pprint.py	20860	0644	edit dl rm
profile.py	22032	0755	edit dl rm
pstats.py	26564	0644	edit dl rm
pty.py	4763	0644	edit dl rm
pyclbr.py	13564	0644	edit dl rm
pydoc.py	103652	0755	edit dl rm
py_compile.py	7181	0644	edit dl rm
queue.py	8780	0644	edit dl rm
quopri.py	7265	0755	edit dl rm
random.py	26463	0644	edit dl rm
re.py	15501	0644	edit dl rm
reprlib.py	5336	0644	edit dl rm
rlcompleter.py	6307	0644	edit dl rm
runpy.py	11959	0644	edit dl rm
sched.py	6216	0644	edit dl rm
selectors.py	19438	0644	edit dl rm
shelve.py	8528	0644	edit dl rm
shlex.py	11448	0644	edit dl rm
shutil.py	40048	0644	edit dl rm
signal.py	2123	0644	edit dl rm
site.py	21509	0644	edit dl rm
smtpd.py	35373	0755	edit dl rm
smtplib.py	43635	0755	edit dl rm
sndhdr.py	6418	0644	edit dl rm
socket.py	27135	0644	edit dl rm
socketserver.py	24666	0644	edit dl rm
sre_compile.py	18410	0644	edit dl rm
sre_constants.py	6821	0644	edit dl rm
sre_parse.py	35117	0644	edit dl rm
ssl.py	42352	0644	edit dl rm
stat.py	5038	0644	edit dl rm
statistics.py	19533	0644	edit dl rm
string.py	11854	0644	edit dl rm
stringprep.py	12917	0644	edit dl rm
struct.py	257	0644	edit dl rm
subprocess.py	58912	0644	edit dl rm
sunau.py	18095	0644	edit dl rm
symbol.py	2106	0755	edit dl rm
symtable.py	7191	0644	edit dl rm
sysconfig.py	24462	0644	edit dl rm
tabnanny.py	11414	0755	edit dl rm
tarfile.py	93070	0755	edit dl rm
telnetlib.py	23016	0644	edit dl rm
tempfile.py	26636	0644	edit dl rm
textwrap.py	19558	0644	edit dl rm
this.py	1003	0644	edit dl rm
threading.py	49027	0644	edit dl rm
timeit.py	12403	0755	edit dl rm
token.py	3075	0644	edit dl rm
tokenize.py	27790	0644	edit dl rm
trace.py	31553	0755	edit dl rm
traceback.py	22175	0644	edit dl rm
tracemalloc.py	15641	0644	edit dl rm
tty.py	879	0644	edit dl rm
types.py	8799	0644	edit dl rm
typing.py	80135	0644	edit dl rm
uu.py	6766	0755	edit dl rm
uuid.py	23261	0644	edit dl rm
warnings.py	15850	0644	edit dl rm
wave.py	17682	0644	edit dl rm
weakref.py	20466	0644	edit dl rm
webbrowser.py	21828	0755	edit dl rm
xdrlib.py	5913	0644	edit dl rm
zipapp.py	7157	0644	edit dl rm
zipfile.py	73672	0644	edit dl rm
_bootlocale.py	1301	0644	edit dl rm
_collections_abc.py	24794	0644	edit dl rm
_compat_pickle.py	8556	0644	edit dl rm
_compression.py	5340	0644	edit dl rm
_dummy_thread.py	5118	0644	edit dl rm
_markupbase.py	14598	0644	edit dl rm
_osx_support.py	19115	0644	edit dl rm
_pydecimal.py	228628	0644	edit dl rm
_pyio.py	87968	0644	edit dl rm
_sitebuiltins.py	3115	0644	edit dl rm
_strptime.py	22185	0644	edit dl rm
_sysconfigdata.py	24273	0644	edit dl rm
_threading_local.py	7410	0644	edit dl rm
_weakrefset.py	5705	0644	edit dl rm
__future__.py	4841	0644	edit dl rm
__phello__.foo.py	64	0644	edit dl rm

Edit: /opt/alt/python35/lib64/python3.5/selectors.py (19438B)

"""Selectors module.

This module allows high-level and efficient I/O multiplexing, built upon the
`select` module primitives.
"""

from abc import ABCMeta, abstractmethod
from collections import namedtuple, Mapping
import math
import select
import sys

# generic events, that must be mapped to implementation-specific ones
EVENT_READ = (1 << 0)
EVENT_WRITE = (1 << 1)

def _fileobj_to_fd(fileobj):
    """Return a file descriptor from a file object.

Parameters:
    fileobj -- file object or file descriptor

Returns:
    corresponding file descriptor

Raises:
    ValueError if the object is invalid
    """
    if isinstance(fileobj, int):
        fd = fileobj
    else:
        try:
            fd = int(fileobj.fileno())
        except (AttributeError, TypeError, ValueError):
            raise ValueError("Invalid file object: "
                             "{!r}".format(fileobj)) from None
    if fd < 0:
        raise ValueError("Invalid file descriptor: {}".format(fd))
    return fd

SelectorKey = namedtuple('SelectorKey', ['fileobj', 'fd', 'events', 'data'])

SelectorKey.__doc__ = """SelectorKey(fileobj, fd, events, data)

Object used to associate a file object to its backing
    file descriptor, selected event mask, and attached data.
"""
if sys.version_info >= (3, 5):
    SelectorKey.fileobj.__doc__ = 'File object registered.'
    SelectorKey.fd.__doc__ = 'Underlying file descriptor.'
    SelectorKey.events.__doc__ = 'Events that must be waited for on this file object.'
    SelectorKey.data.__doc__ = ('''Optional opaque data associated to this file object.
    For example, this could be used to store a per-client session ID.''')

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("{!r} is not registered".format(fileobj)) from None

def __iter__(self):
        return iter(self._selector._fd_to_key)

class BaseSelector(metaclass=ABCMeta):
    """Selector abstract base 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 information, a callback, etc.

A selector can use various implementations (select(), poll(), epoll()...)
    depending on the platform. The default `Selector` class uses the most
    efficient implementation on the current platform.
    """

@abstractmethod
    def register(self, fileobj, events, data=None):
        """Register a file object.

Parameters:
        fileobj -- file object or file descriptor
        events  -- events to monitor (bitwise mask of EVENT_READ|EVENT_WRITE)
        data    -- attached data

Returns:
        SelectorKey instance

Raises:
        ValueError if events is invalid
        KeyError if fileobj is already registered
        OSError if fileobj is closed or otherwise is unacceptable to
                the underlying system call (if a system call is made)

Note:
        OSError may or may not be raised
        """
        raise NotImplementedError

@abstractmethod
    def unregister(self, fileobj):
        """Unregister a file object.

Parameters:
        fileobj -- file object or file descriptor

Returns:
        SelectorKey instance

Raises:
        KeyError if fileobj is not registered

Note:
        If fileobj is registered but has since been closed this does
        *not* raise OSError (even if the wrapped syscall does)
        """
        raise NotImplementedError

def modify(self, fileobj, events, data=None):
        """Change a registered file object monitored events or attached data.

Parameters:
        fileobj -- file object or file descriptor
        events  -- events to monitor (bitwise mask of EVENT_READ|EVENT_WRITE)
        data    -- attached data

Returns:
        SelectorKey instance

Raises:
        Anything that unregister() or register() raises
        """
        self.unregister(fileobj)
        return self.register(fileobj, events, data)

@abstractmethod
    def select(self, timeout=None):
        """Perform the actual selection, until some monitored file objects are
        ready or a timeout expires.

Parameters:
        timeout -- if timeout > 0, this specifies the maximum wait time, in
                   seconds
                   if timeout <= 0, the select() call won't block, and will
                   report the currently ready file objects
                   if timeout is None, select() will block until a monitored
                   file object becomes ready

Returns:
        list of (key, events) for ready file objects
        `events` is a bitwise mask of EVENT_READ|EVENT_WRITE
        """
        raise NotImplementedError

def close(self):
        """Close the selector.

This must be called to make sure that any underlying resource is freed.
        """
        pass

def get_key(self, fileobj):
        """Return the key associated to a registered file object.

Returns:
        SelectorKey for this file object
        """
        mapping = self.get_map()
        if mapping is None:
            raise RuntimeError('Selector is closed')
        try:
            return mapping[fileobj]
        except KeyError:
            raise KeyError("{!r} is not registered".format(fileobj)) from None

@abstractmethod
    def get_map(self):
        """Return a mapping of file objects to selector keys."""
        raise NotImplementedError

def __enter__(self):
        return self

def __exit__(self, *args):
        self.close()

class _BaseSelectorImpl(BaseSelector):
    """Base selector implementation."""

def __init__(self):
        # this 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.  This
        is 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:
            # Do an exhaustive search.
            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):
        if (not events) or (events & ~(EVENT_READ | EVENT_WRITE)):
            raise ValueError("Invalid events: {!r}".format(events))

key = SelectorKey(fileobj, self._fileobj_lookup(fileobj), events, data)

if key.fd in self._fd_to_key:
            raise KeyError("{!r} (FD {}) is already registered"
                           .format(fileobj, key.fd))

self._fd_to_key[key.fd] = key
        return key

def unregister(self, fileobj):
        try:
            key = self._fd_to_key.pop(self._fileobj_lookup(fileobj))
        except KeyError:
            raise KeyError("{!r} is not registered".format(fileobj)) from None
        return key

def modify(self, fileobj, events, data=None):
        # TODO: Subclasses can probably optimize this even further.
        try:
            key = self._fd_to_key[self._fileobj_lookup(fileobj)]
        except KeyError:
            raise KeyError("{!r} is not registered".format(fileobj)) from None
        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 close(self):
        self._fd_to_key.clear()
        self._map = None

def get_map(self):
        return self._map

def _key_from_fd(self, fd):
        """Return the key associated to a given file descriptor.

Parameters:
        fd -- file descriptor

Returns:
        corresponding key, or None if not found
        """
        try:
            return self._fd_to_key[fd]
        except KeyError:
            return None

class SelectSelector(_BaseSelectorImpl):
    """Select-based selector."""

def __init__(self):
        super().__init__()
        self._readers = set()
        self._writers = set()

def register(self, fileobj, events, data=None):
        key = super().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().unregister(fileobj)
        self._readers.discard(key.fd)
        self._writers.discard(key.fd)
        return key

if sys.platform == 'win32':
        def _select(self, r, w, _, timeout=None):
            r, w, x = select.select(r, w, w, timeout)
            return r, w + x, []
    else:
        _select = select.select

def select(self, timeout=None):
        timeout = None if timeout is None else max(timeout, 0)
        ready = []
        try:
            r, w, _ = self._select(self._readers, self._writers, [], timeout)
        except InterruptedError:
            return ready
        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(_BaseSelectorImpl):
        """Poll-based selector."""

def __init__(self):
            super().__init__()
            self._poll = select.poll()

def register(self, fileobj, events, data=None):
            key = super().register(fileobj, events, data)
            poll_events = 0
            if events & EVENT_READ:
                poll_events |= select.POLLIN
            if events & EVENT_WRITE:
                poll_events |= select.POLLOUT
            self._poll.register(key.fd, poll_events)
            return key

def unregister(self, fileobj):
            key = super().unregister(fileobj)
            self._poll.unregister(key.fd)
            return key

def select(self, timeout=None):
            if timeout is None:
                timeout = None
            elif timeout <= 0:
                timeout = 0
            else:
                # poll() has a resolution of 1 millisecond, round away from
                # zero to wait *at least* timeout seconds.
                timeout = math.ceil(timeout * 1e3)
            ready = []
            try:
                fd_event_list = self._poll.poll(timeout)
            except InterruptedError:
                return ready
            for fd, event in fd_event_list:
                events = 0
                if event & ~select.POLLIN:
                    events |= EVENT_WRITE
                if event & ~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(_BaseSelectorImpl):
        """Epoll-based selector."""

def __init__(self):
            super().__init__()
            self._epoll = select.epoll()

def fileno(self):
            return self._epoll.fileno()

def register(self, fileobj, events, data=None):
            key = super().register(fileobj, events, data)
            epoll_events = 0
            if events & EVENT_READ:
                epoll_events |= select.EPOLLIN
            if events & EVENT_WRITE:
                epoll_events |= select.EPOLLOUT
            try:
                self._epoll.register(key.fd, epoll_events)
            except BaseException:
                super().unregister(fileobj)
                raise
            return key

def unregister(self, fileobj):
            key = super().unregister(fileobj)
            try:
                self._epoll.unregister(key.fd)
            except OSError:
                # This can happen if the FD was closed since it
                # was registered.
                pass
            return key

def select(self, timeout=None):
            if timeout is None:
                timeout = -1
            elif timeout <= 0:
                timeout = 0
            else:
                # epoll_wait() has a resolution of 1 millisecond, round away
                # from zero to wait *at least* timeout seconds.
                timeout = math.ceil(timeout * 1e3) * 1e-3

# epoll_wait() expects `maxevents` to be greater than zero;
            # we want to make sure that `select()` can be called when no
            # FD is registered.
            max_ev = max(len(self._fd_to_key), 1)

ready = []
            try:
                fd_event_list = self._epoll.poll(timeout, max_ev)
            except InterruptedError:
                return ready
            for fd, event in fd_event_list:
                events = 0
                if event & ~select.EPOLLIN:
                    events |= EVENT_WRITE
                if event & ~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().close()

if hasattr(select, 'devpoll'):

class DevpollSelector(_BaseSelectorImpl):
        """Solaris /dev/poll selector."""

def __init__(self):
            super().__init__()
            self._devpoll = select.devpoll()

def fileno(self):
            return self._devpoll.fileno()

def register(self, fileobj, events, data=None):
            key = super().register(fileobj, events, data)
            poll_events = 0
            if events & EVENT_READ:
                poll_events |= select.POLLIN
            if events & EVENT_WRITE:
                poll_events |= select.POLLOUT
            self._devpoll.register(key.fd, poll_events)
            return key

def unregister(self, fileobj):
            key = super().unregister(fileobj)
            self._devpoll.unregister(key.fd)
            return key

def select(self, timeout=None):
            if timeout is None:
                timeout = None
            elif timeout <= 0:
                timeout = 0
            else:
                # devpoll() has a resolution of 1 millisecond, round away from
                # zero to wait *at least* timeout seconds.
                timeout = math.ceil(timeout * 1e3)
            ready = []
            try:
                fd_event_list = self._devpoll.poll(timeout)
            except InterruptedError:
                return ready
            for fd, event in fd_event_list:
                events = 0
                if event & ~select.POLLIN:
                    events |= EVENT_WRITE
                if event & ~select.POLLOUT:
                    events |= EVENT_READ

key = self._key_from_fd(fd)
                if key:
                    ready.append((key, events & key.events))
            return ready

def close(self):
            self._devpoll.close()
            super().close()

if hasattr(select, 'kqueue'):

class KqueueSelector(_BaseSelectorImpl):
        """Kqueue-based selector."""

def __init__(self):
            super().__init__()
            self._kqueue = select.kqueue()

def fileno(self):
            return self._kqueue.fileno()

def register(self, fileobj, events, data=None):
            key = super().register(fileobj, events, data)
            try:
                if events & EVENT_READ:
                    kev = select.kevent(key.fd, select.KQ_FILTER_READ,
                                        select.KQ_EV_ADD)
                    self._kqueue.control([kev], 0, 0)
                if events & EVENT_WRITE:
                    kev = select.kevent(key.fd, select.KQ_FILTER_WRITE,
                                        select.KQ_EV_ADD)
                    self._kqueue.control([kev], 0, 0)
            except BaseException:
                super().unregister(fileobj)
                raise
            return key

def unregister(self, fileobj):
            key = super().unregister(fileobj)
            if key.events & EVENT_READ:
                kev = select.kevent(key.fd, select.KQ_FILTER_READ,
                                    select.KQ_EV_DELETE)
                try:
                    self._kqueue.control([kev], 0, 0)
                except OSError:
                    # This can happen if the FD was closed since it
                    # was registered.
                    pass
            if key.events & EVENT_WRITE:
                kev = select.kevent(key.fd, select.KQ_FILTER_WRITE,
                                    select.KQ_EV_DELETE)
                try:
                    self._kqueue.control([kev], 0, 0)
                except OSError:
                    # See comment above.
                    pass
            return key

def select(self, timeout=None):
            timeout = None if timeout is None else max(timeout, 0)
            max_ev = len(self._fd_to_key)
            ready = []
            try:
                kev_list = self._kqueue.control(None, max_ev, timeout)
            except InterruptedError:
                return ready
            for kev in kev_list:
                fd = kev.ident
                flag = kev.filter
                events = 0
                if flag == select.KQ_FILTER_READ:
                    events |= EVENT_READ
                if flag == select.KQ_FILTER_WRITE:
                    events |= EVENT_WRITE

key = self._key_from_fd(fd)
                if key:
                    ready.append((key, events & key.events))
            return ready

def close(self):
            self._kqueue.close()
            super().close()

# Choose the best implementation, roughly:
#    epoll|kqueue|devpoll > poll > select.
# select() also can't accept a FD > FD_SETSIZE (usually around 1024)
if 'KqueueSelector' in globals():
    DefaultSelector = KqueueSelector
elif 'EpollSelector' in globals():
    DefaultSelector = EpollSelector
elif 'DevpollSelector' in globals():
    DefaultSelector = DevpollSelector
elif 'PollSelector' in globals():
    DefaultSelector = PollSelector
else:
    DefaultSelector = SelectSelector

cmd: