Repository: erdewit/eventkit Branch: master Commit: caec9382bf4e Files: 83 Total size: 2.5 MB Directory structure: gitextract_7ujg68vi/ ├── .gitattributes ├── .github/ │ └── workflows/ │ └── test.yml ├── .gitignore ├── .readthedocs.yml ├── LICENSE ├── README.rst ├── docs/ │ ├── Makefile │ ├── api.rst │ ├── conf.py │ ├── html/ │ │ ├── _modules/ │ │ │ ├── asyncio/ │ │ │ │ └── unix_events.html │ │ │ ├── eventkit/ │ │ │ │ ├── event.html │ │ │ │ ├── ops/ │ │ │ │ │ ├── aggregate.html │ │ │ │ │ ├── array.html │ │ │ │ │ ├── combine.html │ │ │ │ │ ├── create.html │ │ │ │ │ ├── misc.html │ │ │ │ │ ├── op.html │ │ │ │ │ ├── select.html │ │ │ │ │ ├── timing.html │ │ │ │ │ └── transform.html │ │ │ │ └── util.html │ │ │ ├── index.html │ │ │ └── logging.html │ │ ├── _sources/ │ │ │ ├── api.rst.txt │ │ │ └── index.rst.txt │ │ ├── _static/ │ │ │ ├── _sphinx_javascript_frameworks_compat.js │ │ │ ├── basic.css │ │ │ ├── css/ │ │ │ │ ├── badge_only.css │ │ │ │ └── theme.css │ │ │ ├── doctools.js │ │ │ ├── documentation_options.js │ │ │ ├── fonts/ │ │ │ │ └── FontAwesome.otf │ │ │ ├── jquery-3.2.1.js │ │ │ ├── jquery-3.5.1.js │ │ │ ├── jquery-3.6.0.js │ │ │ ├── jquery.js │ │ │ ├── js/ │ │ │ │ ├── badge_only.js │ │ │ │ └── theme.js │ │ │ ├── language_data.js │ │ │ ├── pygments.css │ │ │ ├── searchtools.js │ │ │ ├── sphinx_highlight.js │ │ │ ├── underscore-1.12.0.js │ │ │ ├── underscore-1.13.1.js │ │ │ ├── underscore-1.3.1.js │ │ │ ├── underscore.js │ │ │ └── websupport.js │ │ ├── api.html │ │ ├── genindex.html │ │ ├── index.html │ │ ├── objects.inv │ │ ├── py-modindex.html │ │ ├── search.html │ │ └── searchindex.js │ ├── index.rst │ ├── make.bat │ └── requirements.txt ├── eventkit/ │ ├── __init__.py │ ├── event.py │ ├── ops/ │ │ ├── __init__.py │ │ ├── aggregate.py │ │ ├── array.py │ │ ├── combine.py │ │ ├── create.py │ │ ├── misc.py │ │ ├── op.py │ │ ├── select.py │ │ ├── timing.py │ │ └── transform.py │ ├── util.py │ └── version.py ├── notebooks/ │ └── eventkit_introduction.ipynb ├── requirements.txt ├── setup.cfg ├── setup.py └── tests/ ├── __init__.py ├── aggregate_test.py ├── combine_test.py ├── create_test.py ├── event_test.py ├── select_test.py ├── timing_test.py └── transform_test.py ================================================ FILE CONTENTS ================================================ ================================================ FILE: .gitattributes ================================================ notebooks/* linguist-documentation ================================================ FILE: .github/workflows/test.yml ================================================ name: eventkit on: [ push, pull_request ] jobs: build: runs-on: ubuntu-latest strategy: matrix: python-version: [ 3.8, 3.9, "3.10", "3.11", "3.12" ] steps: - uses: actions/checkout@v3 - name: Set up Python ${{ matrix.python-version }} uses: actions/setup-python@v4 with: python-version: ${{ matrix.python-version }} - name: Install dependencies run: | python -m pip install --upgrade pip pip install flake8 mypy pytest . if [ -f requirements.txt ]; then pip install -r requirements.txt; fi - name: Flake8 static code analysis run: flake8 eventkit - name: MyPy static code analysis run: | mypy -p eventkit - name: Test with pytest run: | pytest tests ================================================ FILE: .gitignore ================================================ dist.sh **/__pycache__ dist build .vscode .idea .settings .spyproject .project .pydevproject .mypy_cache docs/html/.buildinfo docs/html/.doctrees docs/doctrees eventkit.egg-info ================================================ FILE: .readthedocs.yml ================================================ # .readthedocs.yml version: 2 build: os: ubuntu-22.04 tools: python: "3.12" python: install: - method: pip path: . - requirements: requirements.txt - requirements: docs/requirements.txt # Build all formats formats: all ================================================ FILE: LICENSE ================================================ BSD 2-Clause License Copyright (c) 2023, Ewald de Wit All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ================================================ FILE: README.rst ================================================ |Build| |PyVersion| |Status| |PyPiVersion| |License| |Docs| Introduction ------------ The primary use cases of eventkit are * to send events between loosely coupled components; * to compose all kinds of event-driven data pipelines. The interface is kept as Pythonic as possible, with familiar names from Python and its libraries where possible. For scheduling asyncio is used and there is seamless integration with it. See the examples and the `introduction notebook `_ to get a true feel for the possibilities. Installation ------------ :: pip3 install eventkit Python_ version 3.6 or higher is required. Examples -------- **Create an event and connect two listeners** .. code-block:: python import eventkit as ev def f(a, b): print(a * b) def g(a, b): print(a / b) event = ev.Event() event += f event += g event.emit(10, 5) **Create a simple pipeline** .. code-block:: python import eventkit as ev event = ( ev.Sequence('abcde') .map(str.upper) .enumerate() ) print(event.run()) # in Jupyter: await event.list() Output:: [(0, 'A'), (1, 'B'), (2, 'C'), (3, 'D'), (4, 'E')] **Create a pipeline to get a running average and standard deviation** .. code-block:: python import random import eventkit as ev source = ev.Range(1000).map(lambda i: random.gauss(0, 1)) event = source.array(500)[ev.ArrayMean, ev.ArrayStd].zip() print(event.last().run()) # in Jupyter: await event.last() Output:: [(0.00790957852672618, 1.0345673260655333)] **Combine async iterators together** .. code-block:: python import asyncio import eventkit as ev async def ait(r): for i in r: await asyncio.sleep(0.1) yield i async def main(): async for t in ev.Zip(ait('XYZ'), ait('123')): print(t) asyncio.get_event_loop().run_until_complete(main()) # in Jupyter: await main() Output:: ('X', '1') ('Y', '2') ('Z', '3') **Real-time video analysis pipeline** .. code-block:: python self.video = VideoStream(conf.CAM_ID) scene = self.video | FaceTracker | SceneAnalyzer lastScene = scene.aiter(skip_to_last=True) async for frame, persons in lastScene: ... `Full source code `_ Distributed computing --------------------- The `distex `_ library provides a ``poolmap`` extension method to put multiple cores or machines to use: .. code-block:: python from distex import Pool import eventkit as ev import bz2 pool = Pool() # await pool # un-comment in Jupyter data = [b'A' * 1000000] * 1000 pipe = ev.Sequence(data).poolmap(pool, bz2.compress).map(len).mean().last() print(pipe.run()) # in Jupyter: print(await pipe) pool.shutdown() Inspired by: ------------ * `Qt Signals & Slots `_ * `itertools `_ * `aiostream `_ * `Bacon `_ * `aioreactive `_ * `Reactive extensions `_ * `underscore.js `_ * `.NET Events `_ Documentation ------------- The complete `API documentation `_. .. _Python: http://www.python.org .. _`Interactive Brokers Python API`: http://interactivebrokers.github.io .. |Build| image:: https://github.com/erdewit/eventkit/actions/workflows/test.yml/badge.svg?branch=master :alt: Build :target: https://github.com/erdewit/eventkit/actions .. |PyPiVersion| image:: https://img.shields.io/pypi/v/eventkit.svg :alt: PyPi :target: https://pypi.python.org/pypi/eventkit .. |PyVersion| image:: https://img.shields.io/badge/python-3.6+-blue.svg :alt: .. |Status| image:: https://img.shields.io/badge/status-stable-green.svg :alt: .. |License| image:: https://img.shields.io/badge/license-BSD-blue.svg :alt: .. |Docs| image:: https://readthedocs.org/projects/eventkit/badge/?version=latest :alt: Documentation :target: https://eventkit.readthedocs.io ================================================ FILE: docs/Makefile ================================================ # Minimal makefile for Sphinx documentation # # You can set these variables from the command line. SPHINXOPTS = SPHINXBUILD = python3 -msphinx SPHINXPROJ = distex SOURCEDIR = . BUILDDIR = . # Put it first so that "make" without argument is like "make help". help: @$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) .PHONY: help Makefile # Catch-all target: route all unknown targets to Sphinx using the new # "make mode" option. $(O) is meant as a shortcut for $(SPHINXOPTS). %: Makefile @$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) ================================================ FILE: docs/api.rst ================================================ .. _api: eventkit ======== Release |release|. .. toctree:: :maxdepth: 3 :caption: Modules: Event ----- .. autoclass:: eventkit.event.Event :members: .. automethod:: __await__ .. automethod:: __aiter__ Op -- .. automodule:: eventkit.ops.op Create ------ .. automodule:: eventkit.ops.create Select ------ .. automodule:: eventkit.ops.select Transform --------- .. automodule:: eventkit.ops.transform Aggregate --------- .. automodule:: eventkit.ops.aggregate Combine ------- .. automodule:: eventkit.ops.combine Timing ------ .. automodule:: eventkit.ops.timing Array ----- .. automodule:: eventkit.ops.array Misc ---- .. automodule:: eventkit.ops.misc Util ---- .. automodule:: eventkit.util ================================================ FILE: docs/conf.py ================================================ extensions = [ 'sphinx.ext.autodoc', 'sphinx.ext.viewcode', 'sphinx.ext.napoleon', 'sphinx_autodoc_typehints', ] templates_path = ['_templates'] source_suffix = '.rst' master_doc = 'index' project = 'eventkit' copyright = '2021, Ewald de Wit' author = 'Ewald de Wit' __version__ = None exec(open('../eventkit/version.py').read()) version = '.'.join(__version__.split('.')[:2]) release = __version__ language = None exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store'] pygments_style = 'sphinx' todo_include_todos = False html_theme = 'sphinx_rtd_theme' html_theme_options = { 'canonical_url': 'https://eventkit.readthedocs.io', 'logo_only': False, 'display_version': True, 'prev_next_buttons_location': 'bottom', 'style_external_links': False, # Toc options 'collapse_navigation': True, 'sticky_navigation': True, 'navigation_depth': 4, 'includehidden': True, 'titles_only': False } github_url = 'https://github.com/erdewit/eventkit' autoclass_content = 'both' autodoc_member_order = "bysource" autodoc_default_flags = [ 'members', 'undoc-members', ] ================================================ FILE: docs/html/_modules/asyncio/unix_events.html ================================================ asyncio.unix_events — eventkit 0.8.5 documentation

Source code for asyncio.unix_events

"""Selector event loop for Unix with signal handling."""

import errno
import io
import os
import selectors
import signal
import socket
import stat
import subprocess
import sys
import threading
import warnings


from . import base_events
from . import base_subprocess
from . import constants
from . import coroutines
from . import events
from . import futures
from . import selector_events
from . import tasks
from . import transports
from .log import logger


__all__ = (
    'SelectorEventLoop',
    'AbstractChildWatcher', 'SafeChildWatcher',
    'FastChildWatcher', 'DefaultEventLoopPolicy',
)


if sys.platform == 'win32':  # pragma: no cover
    raise ImportError('Signals are not really supported on Windows')


def _sighandler_noop(signum, frame):
    """Dummy signal handler."""
    pass


class _UnixSelectorEventLoop(selector_events.BaseSelectorEventLoop):
    """Unix event loop.

    Adds signal handling and UNIX Domain Socket support to SelectorEventLoop.
    """

    def __init__(self, selector=None):
        super().__init__(selector)
        self._signal_handlers = {}

    def close(self):
        super().close()
        if not sys.is_finalizing():
            for sig in list(self._signal_handlers):
                self.remove_signal_handler(sig)
        else:
            if self._signal_handlers:
                warnings.warn(f"Closing the loop {self!r} "
                              f"on interpreter shutdown "
                              f"stage, skipping signal handlers removal",
                              ResourceWarning,
                              source=self)
                self._signal_handlers.clear()

    def _process_self_data(self, data):
        for signum in data:
            if not signum:
                # ignore null bytes written by _write_to_self()
                continue
            self._handle_signal(signum)

    def add_signal_handler(self, sig, callback, *args):
        """Add a handler for a signal.  UNIX only.

        Raise ValueError if the signal number is invalid or uncatchable.
        Raise RuntimeError if there is a problem setting up the handler.
        """
        if (coroutines.iscoroutine(callback) or
                coroutines.iscoroutinefunction(callback)):
            raise TypeError("coroutines cannot be used "
                            "with add_signal_handler()")
        self._check_signal(sig)
        self._check_closed()
        try:
            # set_wakeup_fd() raises ValueError if this is not the
            # main thread.  By calling it early we ensure that an
            # event loop running in another thread cannot add a signal
            # handler.
            signal.set_wakeup_fd(self._csock.fileno())
        except (ValueError, OSError) as exc:
            raise RuntimeError(str(exc))

        handle = events.Handle(callback, args, self, None)
        self._signal_handlers[sig] = handle

        try:
            # Register a dummy signal handler to ask Python to write the signal
            # number in the wakup file descriptor. _process_self_data() will
            # read signal numbers from this file descriptor to handle signals.
            signal.signal(sig, _sighandler_noop)

            # Set SA_RESTART to limit EINTR occurrences.
            signal.siginterrupt(sig, False)
        except OSError as exc:
            del self._signal_handlers[sig]
            if not self._signal_handlers:
                try:
                    signal.set_wakeup_fd(-1)
                except (ValueError, OSError) as nexc:
                    logger.info('set_wakeup_fd(-1) failed: %s', nexc)

            if exc.errno == errno.EINVAL:
                raise RuntimeError(f'sig {sig} cannot be caught')
            else:
                raise

    def _handle_signal(self, sig):
        """Internal helper that is the actual signal handler."""
        handle = self._signal_handlers.get(sig)
        if handle is None:
            return  # Assume it's some race condition.
        if handle._cancelled:
            self.remove_signal_handler(sig)  # Remove it properly.
        else:
            self._add_callback_signalsafe(handle)

    def remove_signal_handler(self, sig):
        """Remove a handler for a signal.  UNIX only.

        Return True if a signal handler was removed, False if not.
        """
        self._check_signal(sig)
        try:
            del self._signal_handlers[sig]
        except KeyError:
            return False

        if sig == signal.SIGINT:
            handler = signal.default_int_handler
        else:
            handler = signal.SIG_DFL

        try:
            signal.signal(sig, handler)
        except OSError as exc:
            if exc.errno == errno.EINVAL:
                raise RuntimeError(f'sig {sig} cannot be caught')
            else:
                raise

        if not self._signal_handlers:
            try:
                signal.set_wakeup_fd(-1)
            except (ValueError, OSError) as exc:
                logger.info('set_wakeup_fd(-1) failed: %s', exc)

        return True

    def _check_signal(self, sig):
        """Internal helper to validate a signal.

        Raise ValueError if the signal number is invalid or uncatchable.
        Raise RuntimeError if there is a problem setting up the handler.
        """
        if not isinstance(sig, int):
            raise TypeError(f'sig must be an int, not {sig!r}')

        if not (1 <= sig < signal.NSIG):
            raise ValueError(f'sig {sig} out of range(1, {signal.NSIG})')

    def _make_read_pipe_transport(self, pipe, protocol, waiter=None,
                                  extra=None):
        return _UnixReadPipeTransport(self, pipe, protocol, waiter, extra)

    def _make_write_pipe_transport(self, pipe, protocol, waiter=None,
                                   extra=None):
        return _UnixWritePipeTransport(self, pipe, protocol, waiter, extra)

    async def _make_subprocess_transport(self, protocol, args, shell,
                                         stdin, stdout, stderr, bufsize,
                                         extra=None, **kwargs):
        with events.get_child_watcher() as watcher:
            waiter = self.create_future()
            transp = _UnixSubprocessTransport(self, protocol, args, shell,
                                              stdin, stdout, stderr, bufsize,
                                              waiter=waiter, extra=extra,
                                              **kwargs)

            watcher.add_child_handler(transp.get_pid(),
                                      self._child_watcher_callback, transp)
            try:
                await waiter
            except Exception:
                transp.close()
                await transp._wait()
                raise

        return transp

    def _child_watcher_callback(self, pid, returncode, transp):
        self.call_soon_threadsafe(transp._process_exited, returncode)

    async def create_unix_connection(
            self, protocol_factory, path=None, *,
            ssl=None, sock=None,
            server_hostname=None,
            ssl_handshake_timeout=None):
        assert server_hostname is None or isinstance(server_hostname, str)
        if ssl:
            if server_hostname is None:
                raise ValueError(
                    'you have to pass server_hostname when using ssl')
        else:
            if server_hostname is not None:
                raise ValueError('server_hostname is only meaningful with ssl')
            if ssl_handshake_timeout is not None:
                raise ValueError(
                    'ssl_handshake_timeout is only meaningful with ssl')

        if path is not None:
            if sock is not None:
                raise ValueError(
                    'path and sock can not be specified at the same time')

            path = os.fspath(path)
            sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM, 0)
            try:
                sock.setblocking(False)
                await self.sock_connect(sock, path)
            except:
                sock.close()
                raise

        else:
            if sock is None:
                raise ValueError('no path and sock were specified')
            if (sock.family != socket.AF_UNIX or
                    sock.type != socket.SOCK_STREAM):
                raise ValueError(
                    f'A UNIX Domain Stream Socket was expected, got {sock!r}')
            sock.setblocking(False)

        transport, protocol = await self._create_connection_transport(
            sock, protocol_factory, ssl, server_hostname,
            ssl_handshake_timeout=ssl_handshake_timeout)
        return transport, protocol

    async def create_unix_server(
            self, protocol_factory, path=None, *,
            sock=None, backlog=100, ssl=None,
            ssl_handshake_timeout=None,
            start_serving=True):
        if isinstance(ssl, bool):
            raise TypeError('ssl argument must be an SSLContext or None')

        if ssl_handshake_timeout is not None and not ssl:
            raise ValueError(
                'ssl_handshake_timeout is only meaningful with ssl')

        if path is not None:
            if sock is not None:
                raise ValueError(
                    'path and sock can not be specified at the same time')

            path = os.fspath(path)
            sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)

            # Check for abstract socket. `str` and `bytes` paths are supported.
            if path[0] not in (0, '\x00'):
                try:
                    if stat.S_ISSOCK(os.stat(path).st_mode):
                        os.remove(path)
                except FileNotFoundError:
                    pass
                except OSError as err:
                    # Directory may have permissions only to create socket.
                    logger.error('Unable to check or remove stale UNIX socket '
                                 '%r: %r', path, err)

            try:
                sock.bind(path)
            except OSError as exc:
                sock.close()
                if exc.errno == errno.EADDRINUSE:
                    # Let's improve the error message by adding
                    # with what exact address it occurs.
                    msg = f'Address {path!r} is already in use'
                    raise OSError(errno.EADDRINUSE, msg) from None
                else:
                    raise
            except:
                sock.close()
                raise
        else:
            if sock is None:
                raise ValueError(
                    'path was not specified, and no sock specified')

            if (sock.family != socket.AF_UNIX or
                    sock.type != socket.SOCK_STREAM):
                raise ValueError(
                    f'A UNIX Domain Stream Socket was expected, got {sock!r}')

        sock.setblocking(False)
        server = base_events.Server(self, [sock], protocol_factory,
                                    ssl, backlog, ssl_handshake_timeout)
        if start_serving:
            server._start_serving()
            # Skip one loop iteration so that all 'loop.add_reader'
            # go through.
            await tasks.sleep(0, loop=self)

        return server

    async def _sock_sendfile_native(self, sock, file, offset, count):
        try:
            os.sendfile
        except AttributeError as exc:
            raise events.SendfileNotAvailableError(
                "os.sendfile() is not available")
        try:
            fileno = file.fileno()
        except (AttributeError, io.UnsupportedOperation) as err:
            raise events.SendfileNotAvailableError("not a regular file")
        try:
            fsize = os.fstat(fileno).st_size
        except OSError as err:
            raise events.SendfileNotAvailableError("not a regular file")
        blocksize = count if count else fsize
        if not blocksize:
            return 0  # empty file

        fut = self.create_future()
        self._sock_sendfile_native_impl(fut, None, sock, fileno,
                                        offset, count, blocksize, 0)
        return await fut

    def _sock_sendfile_native_impl(self, fut, registered_fd, sock, fileno,
                                   offset, count, blocksize, total_sent):
        fd = sock.fileno()
        if registered_fd is not None:
            # Remove the callback early.  It should be rare that the
            # selector says the fd is ready but the call still returns
            # EAGAIN, and I am willing to take a hit in that case in
            # order to simplify the common case.
            self.remove_writer(registered_fd)
        if fut.cancelled():
            self._sock_sendfile_update_filepos(fileno, offset, total_sent)
            return
        if count:
            blocksize = count - total_sent
            if blocksize <= 0:
                self._sock_sendfile_update_filepos(fileno, offset, total_sent)
                fut.set_result(total_sent)
                return

        try:
            sent = os.sendfile(fd, fileno, offset, blocksize)
        except (BlockingIOError, InterruptedError):
            if registered_fd is None:
                self._sock_add_cancellation_callback(fut, sock)
            self.add_writer(fd, self._sock_sendfile_native_impl, fut,
                            fd, sock, fileno,
                            offset, count, blocksize, total_sent)
        except OSError as exc:
            if (registered_fd is not None and
                    exc.errno == errno.ENOTCONN and
                    type(exc) is not ConnectionError):
                # If we have an ENOTCONN and this isn't a first call to
                # sendfile(), i.e. the connection was closed in the middle
                # of the operation, normalize the error to ConnectionError
                # to make it consistent across all Posix systems.
                new_exc = ConnectionError(
                    "socket is not connected", errno.ENOTCONN)
                new_exc.__cause__ = exc
                exc = new_exc
            if total_sent == 0:
                # We can get here for different reasons, the main
                # one being 'file' is not a regular mmap(2)-like
                # file, in which case we'll fall back on using
                # plain send().
                err = events.SendfileNotAvailableError(
                    "os.sendfile call failed")
                self._sock_sendfile_update_filepos(fileno, offset, total_sent)
                fut.set_exception(err)
            else:
                self._sock_sendfile_update_filepos(fileno, offset, total_sent)
                fut.set_exception(exc)
        except Exception as exc:
            self._sock_sendfile_update_filepos(fileno, offset, total_sent)
            fut.set_exception(exc)
        else:
            if sent == 0:
                # EOF
                self._sock_sendfile_update_filepos(fileno, offset, total_sent)
                fut.set_result(total_sent)
            else:
                offset += sent
                total_sent += sent
                if registered_fd is None:
                    self._sock_add_cancellation_callback(fut, sock)
                self.add_writer(fd, self._sock_sendfile_native_impl, fut,
                                fd, sock, fileno,
                                offset, count, blocksize, total_sent)

    def _sock_sendfile_update_filepos(self, fileno, offset, total_sent):
        if total_sent > 0:
            os.lseek(fileno, offset, os.SEEK_SET)

    def _sock_add_cancellation_callback(self, fut, sock):
        def cb(fut):
            if fut.cancelled():
                fd = sock.fileno()
                if fd != -1:
                    self.remove_writer(fd)
        fut.add_done_callback(cb)


class _UnixReadPipeTransport(transports.ReadTransport):

    max_size = 256 * 1024  # max bytes we read in one event loop iteration

    def __init__(self, loop, pipe, protocol, waiter=None, extra=None):
        super().__init__(extra)
        self._extra['pipe'] = pipe
        self._loop = loop
        self._pipe = pipe
        self._fileno = pipe.fileno()
        self._protocol = protocol
        self._closing = False

        mode = os.fstat(self._fileno).st_mode
        if not (stat.S_ISFIFO(mode) or
                stat.S_ISSOCK(mode) or
                stat.S_ISCHR(mode)):
            self._pipe = None
            self._fileno = None
            self._protocol = None
            raise ValueError("Pipe transport is for pipes/sockets only.")

        os.set_blocking(self._fileno, False)

        self._loop.call_soon(self._protocol.connection_made, self)
        # only start reading when connection_made() has been called
        self._loop.call_soon(self._loop._add_reader,
                             self._fileno, self._read_ready)
        if waiter is not None:
            # only wake up the waiter when connection_made() has been called
            self._loop.call_soon(futures._set_result_unless_cancelled,
                                 waiter, None)

    def __repr__(self):
        info = [self.__class__.__name__]
        if self._pipe is None:
            info.append('closed')
        elif self._closing:
            info.append('closing')
        info.append(f'fd={self._fileno}')
        selector = getattr(self._loop, '_selector', None)
        if self._pipe is not None and selector is not None:
            polling = selector_events._test_selector_event(
                selector, self._fileno, selectors.EVENT_READ)
            if polling:
                info.append('polling')
            else:
                info.append('idle')
        elif self._pipe is not None:
            info.append('open')
        else:
            info.append('closed')
        return '<{}>'.format(' '.join(info))

    def _read_ready(self):
        try:
            data = os.read(self._fileno, self.max_size)
        except (BlockingIOError, InterruptedError):
            pass
        except OSError as exc:
            self._fatal_error(exc, 'Fatal read error on pipe transport')
        else:
            if data:
                self._protocol.data_received(data)
            else:
                if self._loop.get_debug():
                    logger.info("%r was closed by peer", self)
                self._closing = True
                self._loop._remove_reader(self._fileno)
                self._loop.call_soon(self._protocol.eof_received)
                self._loop.call_soon(self._call_connection_lost, None)

    def pause_reading(self):
        self._loop._remove_reader(self._fileno)

    def resume_reading(self):
        self._loop._add_reader(self._fileno, self._read_ready)

    def set_protocol(self, protocol):
        self._protocol = protocol

    def get_protocol(self):
        return self._protocol

    def is_closing(self):
        return self._closing

    def close(self):
        if not self._closing:
            self._close(None)

    def __del__(self):
        if self._pipe is not None:
            warnings.warn(f"unclosed transport {self!r}", ResourceWarning,
                          source=self)
            self._pipe.close()

    def _fatal_error(self, exc, message='Fatal error on pipe transport'):
        # should be called by exception handler only
        if (isinstance(exc, OSError) and exc.errno == errno.EIO):
            if self._loop.get_debug():
                logger.debug("%r: %s", self, message, exc_info=True)
        else:
            self._loop.call_exception_handler({
                'message': message,
                'exception': exc,
                'transport': self,
                'protocol': self._protocol,
            })
        self._close(exc)

    def _close(self, exc):
        self._closing = True
        self._loop._remove_reader(self._fileno)
        self._loop.call_soon(self._call_connection_lost, exc)

    def _call_connection_lost(self, exc):
        try:
            self._protocol.connection_lost(exc)
        finally:
            self._pipe.close()
            self._pipe = None
            self._protocol = None
            self._loop = None


class _UnixWritePipeTransport(transports._FlowControlMixin,
                              transports.WriteTransport):

    def __init__(self, loop, pipe, protocol, waiter=None, extra=None):
        super().__init__(extra, loop)
        self._extra['pipe'] = pipe
        self._pipe = pipe
        self._fileno = pipe.fileno()
        self._protocol = protocol
        self._buffer = bytearray()
        self._conn_lost = 0
        self._closing = False  # Set when close() or write_eof() called.

        mode = os.fstat(self._fileno).st_mode
        is_char = stat.S_ISCHR(mode)
        is_fifo = stat.S_ISFIFO(mode)
        is_socket = stat.S_ISSOCK(mode)
        if not (is_char or is_fifo or is_socket):
            self._pipe = None
            self._fileno = None
            self._protocol = None
            raise ValueError("Pipe transport is only for "
                             "pipes, sockets and character devices")

        os.set_blocking(self._fileno, False)
        self._loop.call_soon(self._protocol.connection_made, self)

        # On AIX, the reader trick (to be notified when the read end of the
        # socket is closed) only works for sockets. On other platforms it
        # works for pipes and sockets. (Exception: OS X 10.4?  Issue #19294.)
        if is_socket or (is_fifo and not sys.platform.startswith("aix")):
            # only start reading when connection_made() has been called
            self._loop.call_soon(self._loop._add_reader,
                                 self._fileno, self._read_ready)

        if waiter is not None:
            # only wake up the waiter when connection_made() has been called
            self._loop.call_soon(futures._set_result_unless_cancelled,
                                 waiter, None)

    def __repr__(self):
        info = [self.__class__.__name__]
        if self._pipe is None:
            info.append('closed')
        elif self._closing:
            info.append('closing')
        info.append(f'fd={self._fileno}')
        selector = getattr(self._loop, '_selector', None)
        if self._pipe is not None and selector is not None:
            polling = selector_events._test_selector_event(
                selector, self._fileno, selectors.EVENT_WRITE)
            if polling:
                info.append('polling')
            else:
                info.append('idle')

            bufsize = self.get_write_buffer_size()
            info.append(f'bufsize={bufsize}')
        elif self._pipe is not None:
            info.append('open')
        else:
            info.append('closed')
        return '<{}>'.format(' '.join(info))

    def get_write_buffer_size(self):
        return len(self._buffer)

    def _read_ready(self):
        # Pipe was closed by peer.
        if self._loop.get_debug():
            logger.info("%r was closed by peer", self)
        if self._buffer:
            self._close(BrokenPipeError())
        else:
            self._close()

    def write(self, data):
        assert isinstance(data, (bytes, bytearray, memoryview)), repr(data)
        if isinstance(data, bytearray):
            data = memoryview(data)
        if not data:
            return

        if self._conn_lost or self._closing:
            if self._conn_lost >= constants.LOG_THRESHOLD_FOR_CONNLOST_WRITES:
                logger.warning('pipe closed by peer or '
                               'os.write(pipe, data) raised exception.')
            self._conn_lost += 1
            return

        if not self._buffer:
            # Attempt to send it right away first.
            try:
                n = os.write(self._fileno, data)
            except (BlockingIOError, InterruptedError):
                n = 0
            except Exception as exc:
                self._conn_lost += 1
                self._fatal_error(exc, 'Fatal write error on pipe transport')
                return
            if n == len(data):
                return
            elif n > 0:
                data = memoryview(data)[n:]
            self._loop._add_writer(self._fileno, self._write_ready)

        self._buffer += data
        self._maybe_pause_protocol()

    def _write_ready(self):
        assert self._buffer, 'Data should not be empty'

        try:
            n = os.write(self._fileno, self._buffer)
        except (BlockingIOError, InterruptedError):
            pass
        except Exception as exc:
            self._buffer.clear()
            self._conn_lost += 1
            # Remove writer here, _fatal_error() doesn't it
            # because _buffer is empty.
            self._loop._remove_writer(self._fileno)
            self._fatal_error(exc, 'Fatal write error on pipe transport')
        else:
            if n == len(self._buffer):
                self._buffer.clear()
                self._loop._remove_writer(self._fileno)
                self._maybe_resume_protocol()  # May append to buffer.
                if self._closing:
                    self._loop._remove_reader(self._fileno)
                    self._call_connection_lost(None)
                return
            elif n > 0:
                del self._buffer[:n]

    def can_write_eof(self):
        return True

    def write_eof(self):
        if self._closing:
            return
        assert self._pipe
        self._closing = True
        if not self._buffer:
            self._loop._remove_reader(self._fileno)
            self._loop.call_soon(self._call_connection_lost, None)

    def set_protocol(self, protocol):
        self._protocol = protocol

    def get_protocol(self):
        return self._protocol

    def is_closing(self):
        return self._closing

    def close(self):
        if self._pipe is not None and not self._closing:
            # write_eof is all what we needed to close the write pipe
            self.write_eof()

    def __del__(self):
        if self._pipe is not None:
            warnings.warn(f"unclosed transport {self!r}", ResourceWarning,
                          source=self)
            self._pipe.close()

    def abort(self):
        self._close(None)

    def _fatal_error(self, exc, message='Fatal error on pipe transport'):
        # should be called by exception handler only
        if isinstance(exc, OSError):
            if self._loop.get_debug():
                logger.debug("%r: %s", self, message, exc_info=True)
        else:
            self._loop.call_exception_handler({
                'message': message,
                'exception': exc,
                'transport': self,
                'protocol': self._protocol,
            })
        self._close(exc)

    def _close(self, exc=None):
        self._closing = True
        if self._buffer:
            self._loop._remove_writer(self._fileno)
        self._buffer.clear()
        self._loop._remove_reader(self._fileno)
        self._loop.call_soon(self._call_connection_lost, exc)

    def _call_connection_lost(self, exc):
        try:
            self._protocol.connection_lost(exc)
        finally:
            self._pipe.close()
            self._pipe = None
            self._protocol = None
            self._loop = None


class _UnixSubprocessTransport(base_subprocess.BaseSubprocessTransport):

    def _start(self, args, shell, stdin, stdout, stderr, bufsize, **kwargs):
        stdin_w = None
        if stdin == subprocess.PIPE:
            # Use a socket pair for stdin, since not all platforms
            # support selecting read events on the write end of a
            # socket (which we use in order to detect closing of the
            # other end).  Notably this is needed on AIX, and works
            # just fine on other platforms.
            stdin, stdin_w = socket.socketpair()
        try:
            self._proc = subprocess.Popen(
                args, shell=shell, stdin=stdin, stdout=stdout, stderr=stderr,
                universal_newlines=False, bufsize=bufsize, **kwargs)
            if stdin_w is not None:
                stdin.close()
                self._proc.stdin = open(stdin_w.detach(), 'wb', buffering=bufsize)
                stdin_w = None
        finally:
            if stdin_w is not None:
                stdin.close()
                stdin_w.close()


class AbstractChildWatcher:
    """Abstract base class for monitoring child processes.

    Objects derived from this class monitor a collection of subprocesses and
    report their termination or interruption by a signal.

    New callbacks are registered with .add_child_handler(). Starting a new
    process must be done within a 'with' block to allow the watcher to suspend
    its activity until the new process if fully registered (this is needed to
    prevent a race condition in some implementations).

    Example:
        with watcher:
            proc = subprocess.Popen("sleep 1")
            watcher.add_child_handler(proc.pid, callback)

    Notes:
        Implementations of this class must be thread-safe.

        Since child watcher objects may catch the SIGCHLD signal and call
        waitpid(-1), there should be only one active object per process.
    """

    def add_child_handler(self, pid, callback, *args):
        """Register a new child handler.

        Arrange for callback(pid, returncode, *args) to be called when
        process 'pid' terminates. Specifying another callback for the same
        process replaces the previous handler.

        Note: callback() must be thread-safe.
        """
        raise NotImplementedError()

    def remove_child_handler(self, pid):
        """Removes the handler for process 'pid'.

        The function returns True if the handler was successfully removed,
        False if there was nothing to remove."""

        raise NotImplementedError()

    def attach_loop(self, loop):
        """Attach the watcher to an event loop.

        If the watcher was previously attached to an event loop, then it is
        first detached before attaching to the new loop.

        Note: loop may be None.
        """
        raise NotImplementedError()

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

        This must be called to make sure that any underlying resource is freed.
        """
        raise NotImplementedError()

    def __enter__(self):
        """Enter the watcher's context and allow starting new processes

        This function must return self"""
        raise NotImplementedError()

    def __exit__(self, a, b, c):
        """Exit the watcher's context"""
        raise NotImplementedError()


class BaseChildWatcher(AbstractChildWatcher):

    def __init__(self):
        self._loop = None
        self._callbacks = {}

    def close(self):
        self.attach_loop(None)

    def _do_waitpid(self, expected_pid):
        raise NotImplementedError()

    def _do_waitpid_all(self):
        raise NotImplementedError()

    def attach_loop(self, loop):
        assert loop is None or isinstance(loop, events.AbstractEventLoop)

        if self._loop is not None and loop is None and self._callbacks:
            warnings.warn(
                'A loop is being detached '
                'from a child watcher with pending handlers',
                RuntimeWarning)

        if self._loop is not None:
            self._loop.remove_signal_handler(signal.SIGCHLD)

        self._loop = loop
        if loop is not None:
            loop.add_signal_handler(signal.SIGCHLD, self._sig_chld)

            # Prevent a race condition in case a child terminated
            # during the switch.
            self._do_waitpid_all()

    def _sig_chld(self):
        try:
            self._do_waitpid_all()
        except Exception as exc:
            # self._loop should always be available here
            # as '_sig_chld' is added as a signal handler
            # in 'attach_loop'
            self._loop.call_exception_handler({
                'message': 'Unknown exception in SIGCHLD handler',
                'exception': exc,
            })

    def _compute_returncode(self, status):
        if os.WIFSIGNALED(status):
            # The child process died because of a signal.
            return -os.WTERMSIG(status)
        elif os.WIFEXITED(status):
            # The child process exited (e.g sys.exit()).
            return os.WEXITSTATUS(status)
        else:
            # The child exited, but we don't understand its status.
            # This shouldn't happen, but if it does, let's just
            # return that status; perhaps that helps debug it.
            return status


class SafeChildWatcher(BaseChildWatcher):
    """'Safe' child watcher implementation.

    This implementation avoids disrupting other code spawning processes by
    polling explicitly each process in the SIGCHLD handler instead of calling
    os.waitpid(-1).

    This is a safe solution but it has a significant overhead when handling a
    big number of children (O(n) each time SIGCHLD is raised)
    """

    def close(self):
        self._callbacks.clear()
        super().close()

    def __enter__(self):
        return self

    def __exit__(self, a, b, c):
        pass

    def add_child_handler(self, pid, callback, *args):
        if self._loop is None:
            raise RuntimeError(
                "Cannot add child handler, "
                "the child watcher does not have a loop attached")

        self._callbacks[pid] = (callback, args)

        # Prevent a race condition in case the child is already terminated.
        self._do_waitpid(pid)

    def remove_child_handler(self, pid):
        try:
            del self._callbacks[pid]
            return True
        except KeyError:
            return False

    def _do_waitpid_all(self):

        for pid in list(self._callbacks):
            self._do_waitpid(pid)

    def _do_waitpid(self, expected_pid):
        assert expected_pid > 0

        try:
            pid, status = os.waitpid(expected_pid, os.WNOHANG)
        except ChildProcessError:
            # The child process is already reaped
            # (may happen if waitpid() is called elsewhere).
            pid = expected_pid
            returncode = 255
            logger.warning(
                "Unknown child process pid %d, will report returncode 255",
                pid)
        else:
            if pid == 0:
                # The child process is still alive.
                return

            returncode = self._compute_returncode(status)
            if self._loop.get_debug():
                logger.debug('process %s exited with returncode %s',
                             expected_pid, returncode)

        try:
            callback, args = self._callbacks.pop(pid)
        except KeyError:  # pragma: no cover
            # May happen if .remove_child_handler() is called
            # after os.waitpid() returns.
            if self._loop.get_debug():
                logger.warning("Child watcher got an unexpected pid: %r",
                               pid, exc_info=True)
        else:
            callback(pid, returncode, *args)


class FastChildWatcher(BaseChildWatcher):
    """'Fast' child watcher implementation.

    This implementation reaps every terminated processes by calling
    os.waitpid(-1) directly, possibly breaking other code spawning processes
    and waiting for their termination.

    There is no noticeable overhead when handling a big number of children
    (O(1) each time a child terminates).
    """
    def __init__(self):
        super().__init__()
        self._lock = threading.Lock()
        self._zombies = {}
        self._forks = 0

    def close(self):
        self._callbacks.clear()
        self._zombies.clear()
        super().close()

    def __enter__(self):
        with self._lock:
            self._forks += 1

            return self

    def __exit__(self, a, b, c):
        with self._lock:
            self._forks -= 1

            if self._forks or not self._zombies:
                return

            collateral_victims = str(self._zombies)
            self._zombies.clear()

        logger.warning(
            "Caught subprocesses termination from unknown pids: %s",
            collateral_victims)

    def add_child_handler(self, pid, callback, *args):
        assert self._forks, "Must use the context manager"

        if self._loop is None:
            raise RuntimeError(
                "Cannot add child handler, "
                "the child watcher does not have a loop attached")

        with self._lock:
            try:
                returncode = self._zombies.pop(pid)
            except KeyError:
                # The child is running.
                self._callbacks[pid] = callback, args
                return

        # The child is dead already. We can fire the callback.
        callback(pid, returncode, *args)

    def remove_child_handler(self, pid):
        try:
            del self._callbacks[pid]
            return True
        except KeyError:
            return False

    def _do_waitpid_all(self):
        # Because of signal coalescing, we must keep calling waitpid() as
        # long as we're able to reap a child.
        while True:
            try:
                pid, status = os.waitpid(-1, os.WNOHANG)
            except ChildProcessError:
                # No more child processes exist.
                return
            else:
                if pid == 0:
                    # A child process is still alive.
                    return

                returncode = self._compute_returncode(status)

            with self._lock:
                try:
                    callback, args = self._callbacks.pop(pid)
                except KeyError:
                    # unknown child
                    if self._forks:
                        # It may not be registered yet.
                        self._zombies[pid] = returncode
                        if self._loop.get_debug():
                            logger.debug('unknown process %s exited '
                                         'with returncode %s',
                                         pid, returncode)
                        continue
                    callback = None
                else:
                    if self._loop.get_debug():
                        logger.debug('process %s exited with returncode %s',
                                     pid, returncode)

            if callback is None:
                logger.warning(
                    "Caught subprocess termination from unknown pid: "
                    "%d -> %d", pid, returncode)
            else:
                callback(pid, returncode, *args)


class _UnixDefaultEventLoopPolicy(events.BaseDefaultEventLoopPolicy):
    """UNIX event loop policy with a watcher for child processes."""
    _loop_factory = _UnixSelectorEventLoop

    def __init__(self):
        super().__init__()
        self._watcher = None

    def _init_watcher(self):
        with events._lock:
            if self._watcher is None:  # pragma: no branch
                self._watcher = SafeChildWatcher()
                if isinstance(threading.current_thread(),
                              threading._MainThread):
                    self._watcher.attach_loop(self._local._loop)

    def set_event_loop(self, loop):
        """Set the event loop.

        As a side effect, if a child watcher was set before, then calling
        .set_event_loop() from the main thread will call .attach_loop(loop) on
        the child watcher.
        """

        super().set_event_loop(loop)

        if (self._watcher is not None and
                isinstance(threading.current_thread(), threading._MainThread)):
            self._watcher.attach_loop(loop)

    def get_child_watcher(self):
        """Get the watcher for child processes.

        If not yet set, a SafeChildWatcher object is automatically created.
        """
        if self._watcher is None:
            self._init_watcher()

        return self._watcher

    def set_child_watcher(self, watcher):
        """Set the watcher for child processes."""

        assert watcher is None or isinstance(watcher, AbstractChildWatcher)

        if self._watcher is not None:
            self._watcher.close()

        self._watcher = watcher


SelectorEventLoop = _UnixSelectorEventLoop
DefaultEventLoopPolicy = _UnixDefaultEventLoopPolicy
================================================ FILE: docs/html/_modules/eventkit/event.html ================================================ eventkit.event — eventkit 1.0.1 documentation

Source code for eventkit.event

import asyncio
import logging
import types
import weakref
from typing import (
    Any as AnyType, AsyncIterable, Awaitable, Iterable, List, Optional,
    Tuple, Union)

from .util import NO_VALUE, get_event_loop, main_event_loop



[docs]class Event:
    """
    Enable event passing between loosely coupled components.
    The event emits values to connected listeners and has
    a selection of operators to create general data flow pipelines.

    Args:
        name: Name to use for this event.
    """

    __slots__ = (
        'error_event', 'done_event', '_name', '_value',
        '_slots', '_done', '_source', '__weakref__')

    NO_VALUE = NO_VALUE
    logger = logging.getLogger(__name__)

    error_event: Optional["Event"]
    done_event: Optional["Event"]
    _name: str
    _value: AnyType
    _slots: List[List]
    _done: bool
    _source: Optional["Event"]

    def __init__(self, name: str = '', _with_error_done_events: bool = True):
        self.error_event = None
        """
        Sub event that emits errors from this event as
        ``emit(source, exception)``.
        """
        self.done_event = None
        """
        Sub event that emits when this event is done as
        ``emit(source)``.
        """
        if _with_error_done_events:
            self.error_event = Event('error', False)
            self.done_event = Event('done', False)
        self._slots = []  # list of [obj, weakref, func] sublists
        self._name = name or self.__class__.__qualname__
        self._value = NO_VALUE
        self._done = False
        self._source = None


[docs]    def name(self) -> str:
        """
        This event's name.
        """
        return self._name



[docs]    def done(self) -> bool:
        """
        ``True`` if event has ended with no more emits coming,
        ``False`` otherwise.
        """
        return self._done



[docs]    def set_done(self):
        """
        Set this event to be ended. The event should not emit anything
        after that.
        """
        if not self._done:
            self._done = True
            self.done_event.emit(self)



[docs]    def value(self):
        """
        This event's last emitted value.
        """
        v = self._value
        return NO_VALUE if v is NO_VALUE else \
            v[0] if len(v) == 1 else v if v else NO_VALUE



[docs]    def connect(self, listener, error=None, done=None,
                keep_ref: bool = False) -> "Event":
        """
        Connect a listener to this event. If the listener is added multiple
        times then it is invoked just as many times on emit.

        The ``+=`` operator can be used as a synonym for this method::

            import eventkit as ev

            def f(a, b):
                print(a * b)

            def g(a, b):
                print(a / b)

            event = ev.Event()
            event += f
            event += g
            event.emit(10, 5)

        Args:
            listener: The callback to invoke on emit of this event.
                It gets the ``*args`` from an emit as arguments.
                If the listener is a coroutine function, or a function that
                returns an awaitable, the awaitable is run in the
                asyncio event loop.
            error: The callback to invoke on error of this event.
                It gets (this event, exception) as two arguments.
            done: The callback to invoke on ending of this event.
                It gets this event as single argument.
            keep_ref:
                * ``True``: A strong reference to the callable is kept
                * ``False``: If the callable allows weak refs and it is
                  garbage collected, then it is automatically disconnected
                  from this event.
        """
        obj, func = self._split(listener)
        if not keep_ref and hasattr(obj, '__weakref__'):
            ref = weakref.ref(obj, self._onFinalize)
            obj = None
        else:
            ref = None
        slot = [obj, ref, func]
        self._slots.append(slot)
        if self.done_event and done is not None:
            self.done_event.connect(done)
        if self.error_event and error is not None:
            self.error_event.connect(error)
        return self



[docs]    def disconnect(self, listener, error=None, done=None):
        """
        Disconnect a listener from this event.

        The ``-=`` operator can be used as a synonym for this method.

        Args:
            listener: The callback to disconnect. The callback is removed at
                most once. It is valid if the callback is already
                not connected.
            error: The error callback to disconnect.
            done: The done callback to disconnect.
        """
        obj, func = self._split(listener)
        for slot in self._slots:
            if (slot[0] is obj or slot[1] and slot[1]() is obj) \
                    and slot[2] is func:
                slot[0] = slot[1] = slot[2] = None
                break
        self._slots = [s for s in self._slots if s != [None, None, None]]
        if error is not None:
            self.error_event.disconnect(error)
        if done is not None:
            self.done_event.disconnect(done)
        return self



[docs]    def disconnect_obj(self, obj):
        """
        Disconnect all listeners on the given object.
        (also the error and done listeners).

        Args:
            obj: The target object that is to be completely removed from
              this event.
        """
        for slot in self._slots:
            if slot[0] is obj or slot[1] and slot[1]() is obj:
                slot[0] = slot[1] = slot[2] = None
        self._slots = [s for s in self._slots if s != [None, None, None]]
        if self.error_event is not None:
            self.error_event.disconnect_obj(obj)
        if self.done_event is not None:
            self.done_event.disconnect_obj(obj)



[docs]    def emit(self, *args):
        """
        Emit a new value to all connected listeners.

        Args:
            args: Argument values to emit to listeners.
        """
        self._value = args
        for obj, ref, func in self._slots:
            try:
                if ref:
                    obj = ref()

                result = None
                if obj is None:
                    if func:
                        result = func(*args)
                else:
                    if func:
                        result = func(obj, *args)
                    else:
                        result = obj(*args)

                if result and hasattr(result, '__await__'):
                    loop = get_event_loop()
                    asyncio.ensure_future(result, loop=loop)

            except Exception as error:
                if len(self.error_event):
                    self.error_event.emit(self, error)
                else:
                    Event.logger.exception(
                        f'Value {args} caused exception for event {self}')



[docs]    def emit_threadsafe(self, *args):
        """
        Threadsafe version of :meth:`emit` that doesn't invoke the
        listeners directly but via the event loop of the main thread.
        """
        main_event_loop.call_soon_threadsafe(self.emit, *args)



[docs]    def clear(self):
        """
        Disconnect all listeners.
        """
        for slot in self._slots:
            slot[0] = slot[1] = slot[2] = None
        self._slots = []



[docs]    def run(self) -> List:
        """
        Start the asyncio event loop, run this event to completion and
        return all values as a list::

            import eventkit as ev

            ev.Timer(0.25, count=10).run()
            ->
            [0.25, 0.5, 0.75, 1.0, 1.25, 1.5, 1.75, 2.0, 2.25, 2.5]

        .. note::

            When running inside a Jupyter notebook this will give an error
            that the asyncio event loop is already running. This can be
            remedied by applying
            `nest_asyncio <https://github.com/erdewit/nest_asyncio>`_
            or by using the top-level ``await`` statement of Jupyter::

                await event.list()
        """
        loop = get_event_loop()
        return loop.run_until_complete(self.list())



[docs]    def pipe(self, *targets: "Event"):
        """
        Form several events into a pipe::

            import eventkit as ev

            e1 = ev.Sequence('abcde')
            e2 = ev.Enumerate().map(lambda i, c: (i, i + ord(c)))
            e3 = ev.Star().pluck(1).map(chr)

            e1.pipe(e2, e3)     # or: ev.Event.Pipe(e1, e2, e3)
            ->
            ['a', 'c', 'e', 'g', 'i']

        Args:
            targets: One or more Events that have no source yet,
                or ``Event`` constructors that needs no arguments.
        """
        source = self
        for t in targets:
            t = Event.create(t)
            t.set_source(source)
            source = t
        return source



[docs]    def fork(self, *targets: "Event") -> "Fork":
        """
        Fork this event into one or more target events.
        Square brackets can be used as a synonym::

            import eventkit as ev

            ev.Range(2, 5)[ev.Min, ev.Max, ev.Sum].zip()
            ->
            [(2, 2, 2), (2, 3, 5), (2, 4, 9)]

        The events in the fork can be combined by one of the join
        methods of ``Fork``.

        Args:
            targets: One or more events that have no source yet,
                or ``Event`` constructors that need no arguments.
        """
        fork = Fork()
        for t in targets:
            t = Event.create(t)
            t.set_source(self)
            fork.append(t)
        return fork


    def set_source(self, source):
        self._source = source

    def _onFinalize(self, ref):
        for slot in self._slots:
            if slot[1] is ref:
                slot[0] = slot[1] = slot[2] = None
        self._slots = [s for s in self._slots if s != [None, None, None]]

    @staticmethod
    def _split(c):
        """
        Split given callable in (object, function) tuple.
        """
        if isinstance(c, types.FunctionType):
            return (None, c)
        elif isinstance(c, types.MethodType):
            return (c.__self__, c.__func__)
        elif isinstance(c, types.BuiltinMethodType):
            if type(c.__self__) is type:
                # built-in method
                return (c.__self__, c)
            else:
                # built-in function
                return (None, c)
        elif hasattr(c, '__call__'):
            return (c, None)
        else:
            raise ValueError(f'Invalid callable: {c}')


[docs]    async def aiter(self, skip_to_last: bool = False, tuples: bool = False):
        """
        Create an asynchronous iterator that yields the emitted values
        from this event::

            async def coro():
                async for args in event.aiter():
                    ...

        :meth:`__aiter__` is a synonym for :meth:`aiter` with
        default arguments,

        Args:
            skip_to_last:
                * ``True``: Backlogged source values are skipped over to
                  yield only the latest value. Can be used as a
                  slipper clutch between a source that produces too fast
                  and the handling that can't keep up.
                * ``False``: All events are yielded.
            tuples:
                * ``True``: Always yield arguments as a tuple.
                * ``False``: Unpack single argument tuples.
        """
        def on_event(*args):
            if skip_to_last:
                while q.qsize():
                    q.get_nowait()
            q.put_nowait(('', args))

        def on_error(source, error):
            q.put_nowait(('ERROR', error))

        def on_done(source):
            q.put_nowait(('DONE', None))

        if self.done():
            return
        q: asyncio.Queue[Tuple[str, AnyType]] = asyncio.Queue()
        self.connect(on_event, on_error, on_done)
        try:
            while True:
                what, args = await q.get()
                if not what:
                    yield args if tuples else args[0] if len(args) == 1 \
                        else args if args else NO_VALUE
                elif what == 'ERROR':
                    raise args
                else:
                    break
        finally:
            self.disconnect(on_event, on_error, on_done)


    __iadd__ = connect
    __isub__ = disconnect
    __call__ = emit
    __or__ = pipe

    def __repr__(self):
        return f'Event<{self.name()}, {self._slots}>'

    def __len__(self):
        return len(self._slots)

    def __bool__(self):
        return True

    def __getitem__(self, fork_targets) -> "Fork":
        if not hasattr(fork_targets, '__iter__'):
            fork_targets = (fork_targets,)
        return self.fork(*fork_targets)


[docs]    def __await__(self):
        """
        Asynchronously await the next emit of an event::

            async def coro():
                args = await event
                ...

        If the event does an empty ``emit()``, then the value
        of ``args`` is set to ``util.NO_VALUE``.

        :meth:`wait` and :meth:`__await__` are each other's inverse.
        """
        def on_event(*args):
            if not fut.done():
                fut.set_result(
                    args[0] if len(args) == 1 else args if args else NO_VALUE)

        def on_error(source, error):
            if not fut.done():
                fut.set_exception(error)

        def on_future_done(f):
            self.disconnect(on_event, on_error)

        if self.done():
            raise ValueError('Event already done')
        fut = asyncio.Future()
        self.connect(on_event, on_error)
        fut.add_done_callback(on_future_done)
        return fut.__await__()


    __aiter__ = aiter
    """
    Synonym for :meth:`aiter` with default arguments::

        async def coro():
            async for args in event:
                ...

    :meth:`aiterate` and :meth:`__aiter__` are each other's inverse.
    """

    def __contains__(self, c):
        """
        See if callable is already connected.
        """
        obj, func = self._split(c)
        return any(
            (s[0] is obj or s[1] and s[1]() is obj) and s[2] is func
            for s in self._slots)

    def __reduce__(self):
        """
        Don't pickle slots.
        """
        with_error_done_event = (
            self.error_event is not None or self.done_event is not None)
        return self.__class__, (self._name, with_error_done_event)


[docs]    @staticmethod
    def init(obj, event_names: Iterable):
        """
        Convenience function for initializing multiple events as members
        of the given object.

        Args:
            event_names: Names to use for the created events.
        """
        for name in event_names:
            setattr(obj, name, Event(name))


    # dot access to constructors


[docs]    @staticmethod
    def create(obj):
        """
        Create an event from a async iterator, awaitable, or event
        constructor without arguments.

        Args:
            obj: The source object. If it's already an event then it
              is passed as-is.
        """
        if isinstance(obj, Event):
            return obj
        if hasattr(obj, '__call__'):
            obj = obj()

        if isinstance(obj, Event):
            return obj
        elif hasattr(obj, '__aiter__'):
            return Event.aiterate(obj)
        elif hasattr(obj, '__await__'):
            return Event.wait(obj)
        else:
            raise ValueError(f'Invalid type: {obj}')



[docs]    @staticmethod
    def wait(future: Awaitable) -> "Wait":
        """
        Create a new event that emits the value of the
        awaitable when it becomes available and then set this event done.

        :meth:`wait` and :meth:`__await__` are each other's inverse.

        Args:
            future: Future to wait on.
        """
        return Wait(future)



[docs]    @staticmethod
    def aiterate(ait: AsyncIterable) -> "Aiterate":
        """
        Create a new event that emits the yielded values from the
        asynchronous iterator.

        The asynchronous iterator serves as a source for both the time
        and value of emits.

        :meth:`aiterate` and :meth:`__aiter__` are each other's inverse.

        Args:
            ait: The asynchronous source iterator. It must ``await``
                at least once; If necessary use::

                    await asyncio.sleep(0)
        """
        return Aiterate(ait)



[docs]    @staticmethod
    def sequence(
            values: Iterable, interval: float = 0,
            times: Union[Iterable[float], None] = None) -> "Sequence":
        """
        Create a new event that emits the given values.
        Supply at most one ``interval`` or ``times``.

        Args:
            values: The source values.
            interval: Time interval in seconds between values.
            times: Relative times for individual values, in seconds since
                start of event. The sequence should match ``values``.
        """
        return Sequence(values, interval, times)



[docs]    @staticmethod
    def repeat(
            value=NO_VALUE, count=1, interval: float = 0,
            times: Union[Iterable[float], None] = None) -> "Repeat":
        """
        Create a new event that repeats ``value`` a number of ``count`` times.

        Args:
            value: The value to emit.
            count: Number of times to emit.
            interval: Time interval in seconds between values.
            times: Relative times for individual values, in seconds since
                start of event. The sequence should match ``values``.
        """
        return Repeat(interval, value, count, times)



[docs]    @staticmethod
    def range(
            *args, interval: float = 0,
            times: Union[Iterable[float], None] = None) -> "Range":
        """
        Create a new event that emits the values from a range.

        Args:
            args: Same as for built-in ``range``.
            interval: Time interval in seconds between values.
            times: Relative times for individual values, in seconds since
                start of event. The sequence should match the range.
        """
        return Range(*args, interval=interval, times=times)



[docs]    @staticmethod
    def timerange(start=0, end=None, step=1) -> "Timerange":
        """
        Create a new event that emits the datetime value, at that datetime,
        from a range of datetimes.

        Args:
            start: Start time, can be specified as:

                * ``datetime.datetime``.
                * ``datetime.time``: Today is used as date.
                * ``int`` or ``float``: Number of seconds relative to now.
                  Values will be quantized to the given step.
            end: End time, can be specified as:

                * ``datetime.datetime``.
                * ``datetime.time``: Today is used as date.
                * ``None``: No end limit.
            step: Number of seconds, or ``datetime.timedelta``,
                to space between values.
        """
        return Timerange(start, end, step)



[docs]    @staticmethod
    def timer(interval: float, count: Union[int, None] = None) -> "Timer":
        """
        Create a new timer event that emits at regularly paced intervals
        the number of seconds since starting it.

        Args:
            interval: Time interval in seconds between emits.
            count: Number of times to emit, or ``None`` for no limit.
        """
        return Timer(interval, count)



[docs]    @staticmethod
    def marble(
            s: str, interval: float = 0,
            times: Union[Iterable[float], None] = None) -> "Marble":
        """
        Create a new event that emits the values from a Rx-type marble string.

        Args:
            s: The string with characters that are emitted.
            interval: Time interval in seconds between values.
            times: Relative times for individual values, in seconds since
                start of event. The sequence should match the marble string.

        """
        return Marble(s, interval, times)


    # dot access to operators


[docs]    def filter(self, predicate=bool) -> "Filter":
        """
        For every source value, apply predicate and re-emit when True.

        Args:
            predicate: The function to test every source value with.
                The default is to test the general truthiness with ``bool()``.
        """
        return Filter(predicate, self)



[docs]    def skip(self, count: int = 1) -> "Skip":
        """
        Drop the first ``count`` values from source and follow the source
        after that.

        Args:
            count: Number of source values to drop.
        """
        return Skip(count, self)



[docs]    def take(self, count: int = 1) -> "Take":
        """
        Re-emit first ``count`` values from the source and then end.

        Args:
            count: Number of source values to re-emit.
        """
        return Take(count, self)



[docs]    def takewhile(self, predicate=bool) -> "TakeWhile":
        """
        Re-emit values from the source until the predicate becomes False
        and then end.

        Args:
            predicate: The function to test every source value with.
                The default is to test the general truthiness with ``bool()``.
        """
        return TakeWhile(predicate, self)



[docs]    def dropwhile(self, predicate=lambda x: not x) -> "DropWhile":
        """
        Drop source values until the predicate becomes False and after that
        re-emit everything from the source.

        Args:
            predicate: The function to test every source value with.
                The default is to test the inverted general truthiness.
        """
        return DropWhile(predicate, self)



[docs]    def takeuntil(self, notifier: "Event") -> "TakeUntil":
        """
        Re-emit values from the source until the ``notifier`` emits
        and then end. If the notifier ends without any emit then
        keep passing source values.

        Args:
            notifier: Event that signals to end this event.
        """
        return TakeUntil(notifier, self)



[docs]    def constant(self, constant) -> "Constant":
        """
        On emit of the source emit a constant value::

            emit(value) -> emit(constant)

        Args:
            constant: The constant value to emit.
        """
        return Constant(constant, self)



[docs]    def iterate(self, it) -> "Iterate":
        """
        On emit of the source, emit the next value from an iterator::

            emit(a, b, ...) -> emit(next(it))

        The time of events follows the source and the values follow
        the iterator.

        Args:
            it: The source iterator to use for generating values. When the
                iterator is exhausted the event is set to be done.
        """
        return Iterate(it, self)



[docs]    def count(self, start=0, step=1) -> "Count":
        """
        Count and emit the number of source emits::

            emit(a, b, ...) -> emit(count)

        Args:
            start: Start count.
            step: Add count by this amount for every new source value.
        """
        return Count(start, step, self)



[docs]    def enumerate(self, start=0, step=1) -> "Enumerate":
        """
        Add a count to every source value::

            emit(a, b, ...) -> emit(count, a, b, ...)

        Args:
            start: Start count.
            step: Increase by this amount for every new source value.
        """
        return Enumerate(start, step, self)



[docs]    def timestamp(self) -> "Timestamp":
        """
        Add a timestamp (from time.time()) to every source value::

            emit(a, b, ...) -> emit(timestamp, a, b, ...)

        The timestamp is the float number in seconds since the
        midnight Jan 1, 1970 epoch.
        """
        return Timestamp(self)



[docs]    def partial(self, *left_args) -> "Partial":
        """
        Pad source values with extra arguments on the left::

            emit(a, b, ...) -> emit(*left_args, a, b, ...)

        Args:
            left_args: Arguments to inject.
        """
        return Partial(*left_args, source=self)



[docs]    def partial_right(self, *right_args) -> "PartialRight":
        """
        Pad source values with extra arguments on the right::

            emit(a, b, ...) -> emit(a, b, ..., *right_args)

        Args:
            right_args: Arguments to inject.
        """
        return PartialRight(*right_args, source=self)



[docs]    def star(self) -> "Star":
        """
        Unpack a source tuple into positional arguments, similar to the
        star operator::

            emit((a, b, ...)) -> emit(a, b, ...)

        :meth:`star` and :meth:`pack` are each other's inverse.
        """
        return Star(self)



[docs]    def pack(self) -> "Pack":
        """
        Pack positional arguments into a tuple::

            emit(a, b, ...) -> emit((a, b, ...))

        :meth:`star` and :meth:`pack` are each other's inverse.
        """
        return Pack(self)



[docs]    def pluck(self, *selections: Union[int, str]) -> "Pluck":
        """
        Extract arguments or nested properties from the source values.

        Select which argument positions to keep::

            emit(a, b, c, d).pluck(1, 2) -> emit(b, c)

        Re-order arguments::

            emit(a, b, c).pluck(2, 1, 0) -> emit(c, b, a)

        To do an empty emit leave ``selections`` empty::

            emit(a, b).pluck() -> emit()

        Select nested properties from positional arguments::

            emit(person, account).pluck(
                '1.number', '0.address.street') ->

            emit(account.number, person.address.street)

        If no value can be extracted then ``NO_VALUE`` is emitted in its place.

        Args:
            selections: The values to extract.
        """
        return Pluck(*selections, source=self)



[docs]    def map(
            self, func, timeout=None, ordered=True,
            task_limit=None) -> "Map":
        """
        Apply a sync or async function to source values using
        positional arguments::

            emit(a, b, ...) -> emit(func(a, b, ...))

        or if ``func`` returns an awaitable then it will be awaited::

            emit(a, b, ...) -> emit(await func(a, b, ...))

        In case of timeout or other failure, ``NO_VALUE`` is emitted.

        Args:
            func: The function or coroutine constructor to apply.
            timeout: Timeout in seconds since coroutine is started
            ordered:
                * ``True``: The order of emitted results preserves the
                  order of the source values.
                * ``False``: Results are in order of completion.
            task_limit: Max number of concurrent tasks, or None for no limit.

        ``timeout``, ``ordered`` and ``task_limit`` apply to
        async functions only.
        """
        return Map(func, timeout, ordered, task_limit, self)



[docs]    def emap(self, constr, joiner: "AddableJoinOp") -> "Emap":
        """
        Higher-order event map that creates a new ``Event`` instance
        for every source value::

            emit(a, b, ...) -> new Event constr(a, b, ...)

        Args:
            constr: Constructor function for creating a new event.
                Apart from returning  an ``Event``, the constructor may also
                return an awaitable or an asynchronous iterator, in which
                case an ``Event`` will be created.
            joiner: Join operator to combine the emits of nested events.
        """
        return Emap(constr, joiner, self)



[docs]    def mergemap(self, constr) -> "Mergemap":
        """
        :meth:`emap` that uses :meth:`merge` to combine the nested events::

            marbles = [
                'A   B    C    D',
                '_1   2  3    4',
                '__K   L     M   N']

            ev.Range(3).mergemap(lambda v: ev.Marble(marbles[v]))
            ->
            ['A', '1', 'K', 'B', '2', 'L', '3', 'C', 'M', '4', 'D', 'N']
        """
        return Mergemap(constr, self)



[docs]    def concatmap(self, constr) -> "Concatmap":
        """
        :meth:`emap` that uses :meth:`concat` to combine the nested events::

            marbles = [
                'A    B    C    D',
                '_       1    2    3    4',
                '__                  K    L      M   N']

            ev.Range(3).concatmap(lambda v: ev.Marble(marbles[v]))
            ->
            ['A', 'B', '1', '2', '3', 'K', 'L', 'M', 'N']
        """
        return Concatmap(constr, self)



[docs]    def chainmap(self, constr) -> "Chainmap":
        """
        :meth:`emap` that uses :meth:`chain` to combine the nested events::

            marbles = [
                'A    B    C    D           ',
                '_       1    2    3    4',
                '__                  K    L      M   N']

            ev.Range(3).chainmap(lambda v: ev.Marble(marbles[v]))
            ->
            ['A', 'B', 'C', 'D', '1', '2', '3', '4', 'K', 'L', 'M', 'N']
        """
        return Chainmap(constr, self)



[docs]    def switchmap(self, constr) -> "Switchmap":
        """
        :meth:`emap` that uses :meth:`switch` to combine the nested events::

            marbles = [
                'A    B    C    D           ',
                '_                 K    L      M   N',
                '__      1    2      3    4'
            ]
            ev.Range(3).switchmap(lambda v: Event.marble(marbles[v]))
            ->
            ['A', 'B', '1', '2', 'K', 'L', 'M', 'N'])
        """
        return Switchmap(constr, self)



[docs]    def reduce(self, func, initializer=NO_VALUE) -> "Reduce":
        """
        Apply a two-argument reduction function to the previous reduction
        result and the current value and emit the new reduction result.

        Args:
            func: Reduction function::

                emit(args) -> emit(func(prev_args, args))

            initializer: First argument of first reduction::

                    first_result = func(initializer, first_value)

                If no initializer is given, then the first result is
                emitted on the second source emit.
        """
        return Reduce(func, initializer, self)



[docs]    def min(self) -> "Min":
        """
        Minimum value.
        """
        return Min(self)



[docs]    def max(self) -> "Max":
        """
        Maximum value.
        """
        return Max(self)



[docs]    def sum(self, start=0) -> "Sum":
        """
        Total sum.

        Args:
            start: Value added to total sum.
        """
        return Sum(start, self)



[docs]    def product(self, start=1) -> "Product":
        """
        Total product.

        Args:
            start: Initial start value.
        """
        return Product(start, self)



[docs]    def mean(self) -> "Mean":
        """
        Total average.
        """
        return Mean(self)



[docs]    def any(self) -> "Any":
        """
        Test if predicate holds for at least one source value.
        """
        return Any(self)



[docs]    def all(self) -> "All":
        """
        Test if predicate holds for all source values.
        """
        return All(self)



[docs]    def ema(self, n: Union[int, None] = None,
            weight: Union[float, None] = None) -> "Ema":
        """
        Exponential moving average.

        Args:
            n: Number of periods.
            weight: Weight of new value.

        Give either ``n`` or ``weight``.
        The relation is ``weight = 2 / (n + 1)``.
        """
        return Ema(n, weight, self)



[docs]    def previous(self, count: int = 1) -> "Previous":
        """
        For every source value, emit the ``count``-th previous value::

            source:  -ab---c--d-e-
            output:  --a---b--c-d-

        Starts emitting on the ``count + 1``-th source emit.

        Args:
            count: Number of periods to go back.
        """
        return Previous(count, self)



[docs]    def pairwise(self) -> "Pairwise":
        """
        Emit ``(previous_source_value, current_source_value)`` tuples.
        Starts emitting on the second source emit::

            source:  -a----b------c--------d-----
            output:  ------(a,b)--(b,c)----(c,d)-
        """
        return Pairwise(self)



[docs]    def changes(self) -> "Changes":
        """
        Emit only source values that have changed from the previous value.
        """
        return Changes(self)



[docs]    def unique(self, key=None) -> "Unique":
        """
        Emit only unique values, dropping values that have already
        been emitted.

        Args:
            key: `The callable `'key(value)`` is used to group values.
                The default of ``None`` groups values by equality.
                The resulting group must be hashable.
        """
        return Unique(key, self)



[docs]    def last(self) -> "Last":
        """
        Wait until source has ended and re-emit its last value.
        """
        return Last(self)



[docs]    def list(self) -> "ListOp":
        """
        Collect all source values and emit as list when the source ends.
        """
        return ListOp(self)



[docs]    def deque(self, count=0) -> "Deque":
        """
        Emit a ``deque`` with the last ``count`` values from the source
        (or less in the lead-in phase).

        Args:
            count: Number of last periods to use, or 0 to use all.
        """
        return Deque(count, self)



[docs]    def array(self, count=0) -> "Array":
        """
        Emit a numpy array with the last ``count`` values from the source
        (or less in the lead-in phase).

        Args:
            count: Number of last periods to use, or 0 to use all.
        """
        return Array(count, self)



[docs]    def chunk(self, size: int) -> "Chunk":
        """
        Chunk values up in lists of equal size. The last chunk can be shorter.

        Args:
            size: Chunk size.
        """
        return Chunk(size, self)



[docs]    def chunkwith(
            self, timer: "Event", emit_empty: bool = True) -> "ChunkWith":
        """
        Emit a chunked list of values when the timer emits.

        Args:
            timer: Event to use for timing the chunks.
            emit_empty: Emit empty list if no values present since last emit.
        """
        return ChunkWith(timer, emit_empty, self)



[docs]    def chain(self, *sources: "Event") -> "Chain":
        """
        Re-emit from a source until it ends, then move to the next source,
        Repeat until all sources have ended, ending the chain.
        Emits from pending sources are queued up::

            source 1:  -a----b---c|
            source 2:        --2-----3--4|
            source 3:  ------------x---------y--|
            output:    -a----b---c2--3--4x---y--|


        Args:
            sources: Source events.
        """
        return Chain(self, *sources)



[docs]    def merge(self, *sources) -> "Merge":
        """
        Re-emit everything from the source events::

            source 1:  -a----b-------------c------d-|
            source 2:     ------1-----2------3--4-|
            source 3:      --------x----y--|
            output:    -a----b--1--x--2-y--c-3--4-d-|

        Args:
            sources: Source events.
        """
        return Merge(self, *sources)



[docs]    def concat(self, *sources) -> "Concat":
        """
        Re-emit everything from one source until it ends and then move
        to the next source::

            source 1:  -a----b-----|
            source 2:    --1-----2-----3----4--|
            source 3:                 -----------x--y--|
            output:    -a----b---------3----4----x--y--|

        Args:
            sources: Source events.
        """
        return Concat(self, *sources)



[docs]    def switch(self, *sources) -> "Switch":
        """
        Re-emit everything from one source and move to another source as soon
        as that other source starts to emit::

            source 1:  -a----b---c-----d---|
            source 2:        -----------x---y-|
            source 3:  ---------1----2----3-----|
            output:    -a----b--1----2--x---y---|

        Args:
            sources: Source events.
        """
        return Switch(self, *sources)



[docs]    def zip(self, *sources) -> "Zip":
        """
        Zip sources together: The i-th emit has the i-th value from
        each source as positional arguments. Only emits when each source has
        emtted its i-th value and ends when any source ends::

            source 1:    -a----b------------------c------d---e--f---|
            source 2:    --------1-------2-------3---------4-----|
            output emit: --------(a,1)---(b,2)----(c,3)----(d,4)-|


        Args:
            sources: Source events.
        """
        return Zip(self, *sources)



[docs]    def ziplatest(self, *sources, partial: bool = True) -> "Ziplatest":
        """
        Emit zipped values with the latest value from each of the
        source events. Emits every time when a source emits::

            source 1:   -a-------------------b-------c---|
            source 2:   ---------------1--------------------2------|
            output emit: (a,NoValue)---(a,1)-(b,1)---(c,1)--(c,2)--|

        Args:
            sources: Source events.
            partial:
                * True: Use ``NoValue`` for sources that have not emitted yet.
                * False: Wait until all sources have emitted.
        """
        return Ziplatest(self, *sources, partial=partial)



[docs]    def delay(self, delay) -> "Delay":
        """
        Time-shift all source events by a delay::

            source:  -abc-d-e---f---|
            output:  ---abc-d-e---f---|

        This applies to the source errors and the source done event as well.

        Args:
            delay: Time delay of all events (in seconds).
        """
        return Delay(delay, self)



[docs]    def timeout(self, timeout) -> "Timeout":
        """
        When the source doesn't emit for longer than the timeout period,
        do an empty emit and set this event as done.

        Args:
            timeout: Timeout value.
        """
        return Timeout(timeout, self)



[docs]    def throttle(
            self, maximum, interval, cost_func=None) -> "Throttle":
        """
        Limit number of emits per time without dropping values.
        Values that come in too fast are queued and re-emitted as soon
        as allowed by the limits.

        A nested ``status_event`` emits ``True`` when throttling starts
        and ``False`` when throttling ends.

        The limit can be dynamically changed with ``set_limit``.

        Args:
            maximum: Maximum payload per interval.
            interval: Time interval (in seconds).
            cost_func: The sum of ``cost_func(value)`` for every
                source value inside the ``interval`` that is to remain
                under the ``maximum``. The default is to count every
                source value as 1.
        """
        return Throttle(maximum, interval, cost_func, self)



[docs]    def debounce(self, delay, on_first: bool = False) -> "Debounce":
        """
        Filter out values from the source that happen in rapid succession.

        Args:
            delay: Maximal time difference (in seconds) between
                successive values before debouncing kicks in.
            on_first:
                * True: First value is send immediately and following values
                  in the rapid succession are dropped::

                    source: -abcd----efg-
                    output: -a-------e---

                * False: Last value of a rapid succession is send after
                  the delay and the values before that are dropped::

                    source:  -abcd----efg--
                    output:   ----d------g-
        """
        return Debounce(delay, on_first, self)



[docs]    def copy(self) -> "Copy":
        """
        Create a shallow copy of the source values.
        """
        return Copy(self)



[docs]    def deepcopy(self) -> "Deepcopy":
        """
        Create a deep copy of the source values.
        """
        return Deepcopy(self)



[docs]    def sample(self, timer: "Event") -> "Sample":
        """
        At the times that the timer emits, sample the value from this
        event and emit the sample.

        Args:
            timer: Event used to time the samples.
        """
        return Sample(timer, self)



[docs]    def errors(self) -> "Errors":
        """
        Emit errors from the source.
        """
        return Errors(self)



[docs]    def end_on_error(self) -> "EndOnError":
        """
        End on any error from the source.
        """
        return EndOnError(self)



from .ops.aggregate import (
    All, Any, Count, Deque, Ema, List as ListOp, Max, Mean, Min, Pairwise,
    Product, Reduce, Sum)
from .ops.array import (
    Array, ArrayAll, ArrayAny, ArrayMax, ArrayMean, ArrayMin, ArrayProd,
    ArrayStd, ArraySum)
from .ops.combine import (
    AddableJoinOp, Chain, Concat, Fork, Merge, Switch, Zip, Ziplatest)
from .ops.create import (
    Aiterate, Marble, Range, Repeat, Sequence, Timer, Timerange, Wait)
from .ops.misc import EndOnError, Errors
from .ops.op import Op
from .ops.select import (
    Changes, DropWhile, Filter, Last, Skip, Take, TakeUntil, TakeWhile, Unique)
from .ops.timing import (
    Debounce, Delay, Sample, Throttle, Timeout)
from .ops.transform import (
    Chainmap, Chunk, ChunkWith, Concatmap, Constant, Copy, Deepcopy, Emap,
    Enumerate, Iterate, Map, Mergemap, Pack, Partial, PartialRight, Pluck,
    Previous, Star, Switchmap, Timestamp)
================================================ FILE: docs/html/_modules/eventkit/ops/aggregate.html ================================================ eventkit.ops.aggregate — eventkit 0.8.5 documentation

Source code for eventkit.ops.aggregate

import operator
import itertools
from collections import deque

from ..util import NO_VALUE
from .op import Op
from .transform import Iterate



[docs]class Count(Iterate):
    __slots__ = ()

    def __init__(self, start=0, step=1, source=None):
        it = itertools.count(start, step)
        Iterate.__init__(self, it, source)




[docs]class Reduce(Op):
    __slots__ = ('_func', '_initializer', '_prev')

    def __init__(self, func, initializer=NO_VALUE, source=None):
        Op.__init__(self, source)
        self._func = func
        self._initializer = initializer
        self._prev = NO_VALUE


[docs]    def on_source(self, arg):
        if self._prev is NO_VALUE:
            if self._initializer is NO_VALUE:
                self._prev = arg
            else:
                self._prev = self._func(self._initializer, arg)
                self.emit(self._prev)
        else:
            self._prev = self._func(self._prev, arg)
            self.emit(self._prev)




[docs]class Min(Reduce):
    __slots__ = ()

    def __init__(self, source=None):
        Reduce.__init__(self, min, float('inf'), source)




[docs]class Max(Reduce):
    __slots__ = ()

    def __init__(self, source=None):
        Reduce.__init__(self, max, -float('inf'), source)




[docs]class Sum(Reduce):
    __slots__ = ()

    def __init__(self, start=0, source=None):
        Reduce.__init__(self, operator.add, start, source)




[docs]class Product(Reduce):
    __slots__ = ()

    def __init__(self, start=1, source=None):
        Reduce.__init__(self, operator.mul, start, source)




[docs]class Mean(Op):
    __slots__ = ('_count', '_sum')

    def __init__(self, source=None):
        Op.__init__(self, source)
        self._count = 0
        self._sum = 0


[docs]    def on_source(self, arg):
        self._count += 1
        self._sum += arg
        self.emit(self._sum / self._count)




[docs]class Any(Reduce):
    __slots__ = ()

    def __init__(self, source=None):
        Reduce.__init__(self, lambda prev, v: prev or bool(v), False, source)




[docs]class All(Reduce):
    __slots__ = ()

    def __init__(self, source=None):
        Reduce.__init__(self, lambda prev, v: prev and bool(v), True, source)




[docs]class Ema(Op):
    __slots__ = ('_f1', '_f2', '_prev')

    def __init__(self, n=None, weight=None, source=None):
        Op.__init__(self, source)
        self._f1 = weight or 2.0 / (n + 1)
        self._f2 = 1 - self._f1
        self._prev = NO_VALUE


[docs]    def on_source(self, *args):
        if self._prev is NO_VALUE:
            value = args
        else:
            value = [
                self._f2 * p + self._f1 * a for p, a in zip(self._prev, args)]
        self._prev = value
        self.emit(*value)




[docs]class Pairwise(Op):
    __slots__ = ('_prev', '_has_prev')

    def __init__(self, source=None):
        Op.__init__(self, source)
        self._has_prev = False


[docs]    def on_source(self, *args):
        value = args[0] if len(args) == 1 else args if args else NO_VALUE
        if self._has_prev:
            self.emit(self._prev, value)
        else:
            self._has_prev = True
        self._prev = value




[docs]class List(Op):
    __slots__ = ('_values')

    def __init__(self, source=None):
        Op.__init__(self, source)
        self._values = []


[docs]    def on_source(self, *args):
        self._values.append(
            args[0] if len(args) == 1 else args if args else NO_VALUE)



[docs]    def on_source_done(self, source):
        self.emit(self._values)
        self._disconnect_from(self._source)
        self._source = None
        self.set_done()




[docs]class Deque(Op):
    __slots__ = ('_count', '_q')

    def __init__(self, count, source=None):
        Op.__init__(self, source)
        self._count = count
        self._q = deque()


[docs]    def on_source(self, *args):
        self._q.append(
            args[0] if len(args) == 1 else args if args else NO_VALUE)
        if self._count and len(self._q) > self._count:
            self._q.popleft()
        self.emit(self._q)
================================================ FILE: docs/html/_modules/eventkit/ops/array.html ================================================ eventkit.ops.array — eventkit 0.8.5 documentation

Source code for eventkit.ops.array

from collections import deque

from .op import Op
from ..util import NO_VALUE

import numpy as np



[docs]class Array(Op):
    __slots__ = ('_count', '_q')

    def __init__(self, count, source=None):
        Op.__init__(self, source)
        self._count = count
        self._q = deque()


[docs]    def on_source(self, *args):
        self._q.append(
            args[0] if len(args) == 1 else args if args else NO_VALUE)
        if self._count and len(self._q) > self._count:
            self._q.popleft()
        self.emit(np.asarray(self._q))



[docs]    def min(self) -> "ArrayMin":
        """
        Minimum value.
        """
        return ArrayMin(self)



[docs]    def max(self) -> "ArrayMax":
        """
        Maximum value.
        """
        return ArrayMax(self)



[docs]    def sum(self) -> "ArraySum":
        """
        Summation.
        """
        return ArraySum(self)



[docs]    def prod(self) -> "ArrayProd":
        """
        Product.
        """
        return ArrayProd(self)



[docs]    def mean(self) -> "ArrayMean":
        """
        Mean value.
        """
        return ArrayMean(self)



[docs]    def std(self) -> "ArrayStd":
        """
        Sample standard deviation.
        """
        return ArrayStd(self)



[docs]    def any(self) -> "ArrayAny":
        """
        Test if any array value is true.
        """
        return ArrayAny(self)



[docs]    def all(self) -> "ArrayAll":
        """
        Test if all array values are true.
        """
        return ArrayAll(self)




[docs]class ArrayMin(Op):
    __slots__ = ()


[docs]    def on_source(self, arg):
        self.emit(arg.min())




[docs]class ArrayMax(Op):
    __slots__ = ()


[docs]    def on_source(self, arg):
        self.emit(arg.max())




[docs]class ArraySum(Op):
    __slots__ = ()


[docs]    def on_source(self, arg):
        self.emit(arg.sum())




[docs]class ArrayProd(Op):
    __slots__ = ()


[docs]    def on_source(self, arg):
        self.emit(arg.prod())




[docs]class ArrayMean(Op):
    __slots__ = ()


[docs]    def on_source(self, arg):
        self.emit(arg.mean())




[docs]class ArrayStd(Op):
    __slots__ = ()


[docs]    def on_source(self, arg):
        self.emit(arg.std(ddof=1) if len(arg) > 1 else np.nan)




[docs]class ArrayAny(Op):
    __slots__ = ()


[docs]    def on_source(self, arg):
        self.emit(arg.any())




[docs]class ArrayAll(Op):
    __slots__ = ()


[docs]    def on_source(self, arg):
        self.emit(arg.all())
================================================ FILE: docs/html/_modules/eventkit/ops/combine.html ================================================ eventkit.ops.combine — eventkit 0.8.5 documentation

Source code for eventkit.ops.combine

import functools
from collections import deque, defaultdict

from .op import Op
from ..event import Event
from ..util import NO_VALUE



[docs]class Fork(list):
    __slots__ = ()

    def __init__(self):
        list.__init__(self)


[docs]    def join(self, joiner: "JoinOp") -> Event:
        joiner._set_sources(*self)
        self.clear()
        return joiner



[docs]    def concat(self) -> "Concat":
        return self.join(Concat())



[docs]    def merge(self) -> "Merge":
        return self.join(Merge())



[docs]    def switch(self) -> "Switch":
        return self.join(Switch())



[docs]    def zip(self) -> "Zip":
        return self.join(Zip())



[docs]    def ziplatest(self) -> "Ziplatest":
        return self.join(Ziplatest())



[docs]    def chain(self) -> "Chain":
        return self.join(Chain())




[docs]class JoinOp(Op):
    """
    Base class for join operators that combine the emits
    from multiple source events.
    """
    __slots__ = ('_sources',)

    def _set_sources(self, sources):
        raise NotImplementedError




[docs]class AddableJoinOp(JoinOp):
    """
    Base class for join operators where new sources, produced by a
    parent higher-order event, can be added dynamically.
    """
    __slots__ = ('_parent',)

    def __init__(self, *sources: Event):
        JoinOp.__init__(self)
        self._sources = deque()
        self._parent = None
        self._set_sources(*sources)

    def _set_sources(self, *sources):
        for source in sources:
            source = Event.create(source)
            self.add_source(source)


[docs]    def add_source(self, source):
        # note: the same source can be added multiple times
        raise NotImplementedError



[docs]    def set_parent(self, parent: Event):
        self._parent = parent
        parent.done_event += self._on_parent_done



[docs]    def on_source_done(self, source):
        self._disconnect_from(source)
        self._sources.remove(source)
        if not self._sources and self._parent is None:
            self.set_done()


    def _on_parent_done(self, parent):
        parent -= self._on_parent_done
        self._parent = None
        if not self._sources:
            self.set_done()




[docs]class Merge(AddableJoinOp):
    __slots__ = ()


[docs]    def add_source(self, source):
        self._sources.append(source)
        self._connect_from(source)




[docs]class Switch(AddableJoinOp):
    __slots__ = ('_source2cb', '_active_source')

    def __init__(self, *sources):
        AddableJoinOp.__init__(self)
        self._source2cb = {}  # map from source to callback
        self._active_source = None
        self._set_sources(*sources)


[docs]    def add_source(self, source):
        self._sources.append(source)
        cb = self._source2cb.get(source)
        if not cb:
            cb = functools.partial(self.on_source_s, source)
            self._source2cb[source] = cb
            source.connect(cb, done=self.on_source_done)


    def _remove_source(self, source):
        if source in self._sources:
            self._sources.remove(source)
            cb = self._source2cb.pop(source, None)
            if cb:
                source -= cb


[docs]    def on_source_s(self, source, *args):
        if source is not self._active_source:
            self._remove_source(self._active_source)
            self._active_source = source
        self.emit(*args)



[docs]    def on_source_done(self, source):
        self._remove_source(source)
        if not self._sources and self._parent is None:
            self._active_source = None
            self.set_done()




[docs]class Concat(AddableJoinOp):
    __slots__ = ('_source2cb',)

    def __init__(self, *sources):
        AddableJoinOp.__init__(self)
        self._source2cb = {}  # map from source to callback
        self._set_sources(*sources)


[docs]    def add_source(self, source):
        if source in self._sources:
            return
        self._sources.append(source)
        cb = self._source2cb.get(source)
        if not cb:
            cb = functools.partial(self._on_source_s, source)
            self._source2cb[source] = cb
            source.connect(cb, done=self.on_source_done)


    def _on_source_s(self, source, *args):
        while self._sources and self._sources[0] is not source:
            s = self._sources.popleft()
            cb = self._source2cb.pop(s, None)
            if cb:
                s.disconnect(cb, done=self.on_source_done)
        self.emit(*args)


[docs]    def on_source_done(self, source):
        cb = self._source2cb.pop(source)
        source.disconnect(cb, done=self.on_source_done)
        while source in self._sources:
            self._sources.remove(source)
        if not self._sources and self._parent is None:
            self.set_done()




[docs]class Chain(AddableJoinOp):
    __slots__ = ('_qq', '_source2cbs')

    def __init__(self, *sources):
        AddableJoinOp.__init__(self)
        self._qq = deque()
        self._source2cbs = defaultdict(list)  # map from source to callbacks
        self._set_sources(*sources)


[docs]    def add_source(self, source):
        if not self._sources:
            self._connect_from(source)
        else:
            def cb(*args):
                q.append(args)
            q = deque()
            self._qq.append(q)
            source += cb
            self._source2cbs[source].append(cb)
        self._sources.append(source)



[docs]    def on_source_done(self, source):
        if source is not self._sources[0]:
            return
        self._disconnect_from(source)
        self._sources.popleft()
        while self._sources:
            source = self._sources[0]
            q = self._qq.popleft()
            for args in q:
                self.emit(*args)
            for cb in self._source2cbs.pop(source, []):
                source -= cb
            if source.done():
                self._sources.popleft()
                continue
            self._connect_from(source)
            return
        if not self._sources and self._parent is None:
            self.set_done()




[docs]class Zip(JoinOp):
    __slots__ = ('_results', '_source2cbs', '_num_ready')

    def __init__(self, *sources):
        JoinOp.__init__(self)
        self._num_ready = 0  # number of sources with a pending result
        self._source2cbs = defaultdict(list)  # map from source to callbacks
        if sources:
            self._set_sources(*sources)

    def _set_sources(self, *sources):
        self._sources = deque(Event.create(s) for s in sources)
        if any(s.done() for s in self._sources):
            self.set_done()
            return
        self._results = [deque() for _ in self._sources]
        for i, source in enumerate(self._sources):
            cb = functools.partial(self._on_source_i, i)
            source.connect(cb, self.on_source_error, self.on_source_done)
            self._source2cbs[source].append(cb)

    def _on_source_i(self, i, *args):
        q = self._results[i]
        if not q:
            self._num_ready += 1
            ready = self._num_ready == len(self._results)
        else:
            ready = False
        q.append(args[0] if len(args) == 1 else args if args else NO_VALUE)
        if ready:
            tup = tuple(q.popleft() for q in self._results)
            self._num_ready = sum(bool(q) for q in self._results)
            self.emit(*tup)


[docs]    def on_source_done(self, source):
        self._sources.remove(source)
        if not self._sources:
            for source, cbs in self._source2cbs.items():
                for cb in cbs:
                    source.disconnect(
                        cb, self.on_source_error, self.on_source_done)
            self._source2cbs = None
            self.set_done()




[docs]class Ziplatest(JoinOp):
    __slots__ = ('_values', '_is_primed', '_source2cbs')

    def __init__(self, *sources, partial=True):
        JoinOp.__init__(self)
        self._is_primed = partial
        self._source2cbs = defaultdict(list)  # map from source to callbacks
        if sources:
            self._set_sources(*sources)

    def _set_sources(self, *sources):
        sources = [Event.create(s) for s in sources]
        self._sources = deque(s for s in sources if not s.done())
        if not self._sources:
            self.set_done()
            return
        self._values = [s.value() for s in sources]
        for i, source in enumerate(self._sources):
            cb = functools.partial(self._on_source_i, i)
            source.connect(cb, self.on_source_error, self.on_source_done)
            self._source2cbs[source].append(cb)

    def _on_source_i(self, i, *args):
        self._values[i] = \
            args[0] if len(args) == 1 else args if args else NO_VALUE
        if not self._is_primed:
            self._is_primed = not any(r is NO_VALUE for r in self._values)
        if self._is_primed:
            self.emit(*self._values)


[docs]    def on_source_done(self, source):
        self._sources.remove(source)
        if not self._sources:
            for source, cbs in self._source2cbs.items():
                for cb in cbs:
                    source.disconnect(
                        cb, self.on_source_error, self.on_source_done)
            self._source2cbs = None
            self.set_done()
================================================ FILE: docs/html/_modules/eventkit/ops/create.html ================================================ eventkit.ops.create — eventkit 0.8.5 documentation

Source code for eventkit.ops.create

import asyncio
import itertools
import time

from ..event import Event
from ..util import NO_VALUE, timerange
from .op import Op



[docs]class Wait(Event):
    __slots__ = ('_task',)

    def __init__(self, future, name='wait'):
        Event.__init__(self, name)
        if future.done():
            self.set_done()
            return
        self._task = asyncio.ensure_future(future)
        future.add_done_callback(self._on_task_done)

    def _on_task_done(self, task):
        try:
            result = task.result()
        except Exception as error:
            result = NO_VALUE
            self.error_event.emit(self, error)
        self.emit(result)
        self._task = None
        self.set_done()

    def __del__(self):
        if self._task:
            self._task.cancel()




[docs]class Aiterate(Event):
    __slots__ = ('_task',)

    def __init__(self, ait):
        Event.__init__(self, ait.__qualname__)
        self._task = asyncio.ensure_future(self._looper(ait))

    async def _looper(self, ait):
        try:
            async for args in ait:
                self.emit(args)
        except Exception as error:
            self.error_event.emit(self, error)
        self._task = None
        self.set_done()

    def __del__(self):
        if self._task:
            self._task.cancel()




[docs]class Sequence(Aiterate):
    __slots__ = ()

    def __init__(self, values, interval=0, times=None):
        async def sequence():
            t0 = time.time()
            if times is not None:
                for t, value in zip(times, values):
                    delay = max(0, time.time() + t - t0)
                    await asyncio.sleep(delay)
                    yield value
            else:
                for i, value in enumerate(values):
                    delay = max(0, i * interval + t0 - time.time())
                    await asyncio.sleep(delay)
                    yield value
        Aiterate.__init__(self, sequence())




[docs]class Repeat(Sequence):
    __slots__ = ()

    def __init__(self, value, count, interval=0, times=None):
        Sequence.__init__(self, itertools.repeat(count), interval, times)




[docs]class Range(Sequence):
    __slots__ = ()

    def __init__(self, *args, interval=0, times=None):
        Sequence.__init__(self, range(*args), interval, times)




[docs]class Timerange(Aiterate):
    __slots__ = ()

    def __init__(self, start=0, end=None, step=1):
        Aiterate.__init__(self, timerange(start, end, step))




[docs]class Timer(Aiterate):
    __slots__ = ()

    def __init__(self, interval, count=None):
        async def timer():
            t0 = time.time()
            i = 0
            while count is None or i < count:
                i += 1
                delay = i * interval + t0 - time.time()
                await asyncio.sleep(delay)
                yield i * interval
        Aiterate.__init__(self, timer())




[docs]class Marble(Op):
    __slots__ = ()

    def __init__(self, s, interval=0, times=None):
        s = s.replace('_', '')
        source = Event.sequence(s, interval, times) \
            .filter(lambda c: c not in '- ') \
            .takewhile(lambda c: c != '|')
        Op.__init__(self, source)
================================================ FILE: docs/html/_modules/eventkit/ops/misc.html ================================================ eventkit.ops.misc — eventkit 0.8.5 documentation

Source code for eventkit.ops.misc

from ..event import Event
from .op import Op



[docs]class Errors(Event):
    __slots__ = ('_source',)

    def __init__(self, source=None):
        Event.__init__(self)
        self._source = source
        if source.done():
            self.set_done()
        else:
            source.error_event += self.emit




[docs]class EndOnError(Op):
    __slots__ = ()

    def __init__(self, source=None):
        Op.__init__(self, source)


[docs]    def on_source_error(self, error):
        self.disconnect_from(self._source)
        self.error_event.emit(error)
        self.set_done()
================================================ FILE: docs/html/_modules/eventkit/ops/op.html ================================================ eventkit.ops.op — eventkit 0.8.5 documentation

Source code for eventkit.ops.op

from ..event import Event



[docs]class Op(Event):
    """
    Base functionality for operators.

    The Observer pattern is implemented by the following three methods::

        on_source(self, *args)
        on_source_error(self, source, error)
        on_source_done(self, source)

    The default handlers will pass along source emits, errors and done events.
    This makes ``Op`` also suitable as an identity operator.
    """
    __slots__ = ()

    def __init__(self, source: Event = None):
        Event.__init__(self)
        if source is not None:
            self.set_source(source)

    on_source = Event.emit


[docs]    def on_source_error(self, source, error):
        if len(self.error_event):
            self.error_event.emit(source, error)
        else:
            Event.logger.exception(error)



[docs]    def on_source_done(self, source):
        if self._source is not None:
            self._disconnect_from(self._source)
            self._source = None
        self.set_done()



[docs]    def set_source(self, source):
        source = Event.create(source)
        if self._source is None:
            self._source = source
            self._connect_from(source)
        else:
            self._source.set_source(source)


    def _connect_from(self, source: Event):
        if source.done():
            self.set_done()
        else:
            source.connect(
                self.on_source,
                self.on_source_error,
                self.on_source_done)

    def _disconnect_from(self, source: Event):
        source.disconnect(
            self.on_source,
            self.on_source_error,
            self.on_source_done)
================================================ FILE: docs/html/_modules/eventkit/ops/select.html ================================================ eventkit.ops.select — eventkit 0.8.5 documentation

Source code for eventkit.ops.select

from ..util import NO_VALUE
from .op import Op



[docs]class Filter(Op):
    __slots__ = ('_predicate',)

    def __init__(self, predicate=bool, source=None):
        Op.__init__(self, source)
        self._predicate = predicate


[docs]    def on_source(self, *args):
        if self._predicate(*args):
            self.emit(*args)







[docs]class Take(Op):
    __slots__ = ('_count', '_n')

    def __init__(self, count=1, source=None):
        Op.__init__(self, source)
        self._count = count
        self._n = 0


[docs]    def on_source(self, *args):
        self._n += 1
        if self._n <= self._count:
            self.emit(*args)
        if self._n == self._count:
            self._disconnect_from(self._source)
            self.set_done()




[docs]class TakeWhile(Op):
    __slots__ = ('_predicate',)

    def __init__(self, predicate=bool, source=None):
        Op.__init__(self, source)
        self._predicate = predicate


[docs]    def on_source(self, *args):
        if self._predicate(*args):
            self.emit(*args)
        else:
            self.set_done()
            self._disconnect_from(self._source)




[docs]class DropWhile(Op):
    __slots__ = ('_predicate', '_drop')

    def __init__(self, predicate=lambda x: not(x), source=None):
        Op.__init__(self, source)
        self._predicate = predicate
        self._drop = True


[docs]    def on_source(self, *args):
        if self._drop:
            self._drop = self._predicate(*args)
        if not self._drop:
            self.emit(*args)




[docs]class TakeUntil(Op):
    __slots__ = ('_notifier',)

    def __init__(self, notifier, source=None):
        Op.__init__(self, source)
        self._notifier = notifier
        notifier.connect(
            self._on_notifier,
            self.on_source_error,
            self.on_source_done)

    def _on_notifier(self, *args):
        self.on_source_done()


[docs]    def on_source_done(self, source):
        Op.on_source_done(self, self)
        self._notifier.disconnect(
            self._on_notifier,
            self.on_source_error,
            self.on_source_done)
        self._notifier = None




[docs]class Changes(Op):
    __slots__ = ('_prev',)

    def __init__(self, source=None):
        Op.__init__(self, source)
        self._prev = NO_VALUE


[docs]    def on_source(self, *args):
        if args != self._prev:
            self.emit(*args)
        self._prev = args




[docs]class Unique(Op):
    __slots__ = ('_key', '_seen')

    def __init__(self, key, source=None):
        Op.__init__(self, source)
        self._key = key
        self._seen = set()


[docs]    def on_source(self, *args):
        if self._key is None:
            new = args not in self._seen
        else:
            new = self._key(*args) not in self._seen
        self._seen.add(args)
        if new:
            self.emit(*args)




[docs]class Last(Op):
    __slots__ = ('_last',)

    def __init__(self, source=None):
        Op.__init__(self, source)
        self._last = NO_VALUE


[docs]    def on_source(self, *args):
        self._last = args



[docs]    def on_source_done(self, source):
        self.emit(*self._last)
        self.set_done()
================================================ FILE: docs/html/_modules/eventkit/ops/timing.html ================================================ eventkit.ops.timing — eventkit 0.8.5 documentation

Source code for eventkit.ops.timing

from collections import deque

from ..event import Event
from ..util import NO_VALUE, loop
from .op import Op



[docs]class Delay(Op):
    __slots__ = ('_delay',)

    def __init__(self, delay, source=None):
        Op.__init__(self, source)
        self._delay = delay


[docs]    def on_source(self, *args):
        loop.call_later(self._delay, self.emit, *args)



[docs]    def on_source_error(self, error):
        loop.call_later(self._delay, self.error_event.emit, error)



[docs]    def on_source_done(self, source):
        loop.call_later(self._delay, self.set_done)




[docs]class Timeout(Op):
    __slots__ = ('_timeout', '_handle', '_last_time')

    def __init__(self, timeout, source=None):
        Op.__init__(self, source)
        if source.done():
            return
        self._timeout = timeout
        self._last_time = loop.time()
        self._handle = None
        self._schedule()


[docs]    def on_source(self, *args):
        self._last_time = loop.time()



[docs]    def on_source_done(self, source):
        self._disconnect_from(self._source)
        self._handle.cancel()
        del self._handle
        self.set_done()


    def _schedule(self):
        self._handle = loop.call_at(
            self._last_time + self._timeout, self._on_timer)

    def _on_timer(self):
        if loop.time() - self._last_time > self._timeout:
            self.emit()
            self.set_done()
        else:
            self._schedule()




[docs]class Debounce(Op):
    __slots__ = ('_interval', '_on_first', '_handle', '_last_time')

    def __init__(self, interval, on_first=False, source=None):
        Op.__init__(self, source)
        self._interval = interval
        self._on_first = on_first
        self._last_time = -float('inf')
        self._handle = None


[docs]    def on_source(self, *args):
        time = loop.time()
        delta = time - self._last_time
        self._last_time = time
        if self._on_first:
            if delta >= self._interval:
                self.emit(*args)
        else:
            if self._handle:
                self._handle.cancel()
            self._handle = loop.call_at(
                time + self._interval, self._delayed_emit, *args)


    def _delayed_emit(self, *args):
        self._handle = None
        self.emit(*args)
        if self._source is None:
            self.set_done()


[docs]    def on_source_done(self, source):
        self._disconnect_from(source)
        self._source = None
        if not self._handle:
            self.set_done()




[docs]class Throttle(Op):
    __slots__ = (
        'status_event', '_maximum', '_interval', '_cost_func',
        '_q', '_time_q', '_cost_q', '_is_throttling')

    def __init__(self, maximum, interval, cost_func=None, source=None):
        Op.__init__(self, source)
        self.status_event = Event('throttle_status')
        """
        Sub event that emits ``True`` when throttling starts and ``False``
        when throttling ends.
        """
        self._maximum = maximum
        self._interval = interval
        self._cost_func = cost_func
        self._q = deque()        # deque of (args, cost) tuples
        self._time_q = deque()   # deque of previous emit times
        self._cost_q = deque()   # deque of costs of previous emits
        self._is_throttling = False


[docs]    def set_limit(self, maximum, interval):
        """
        Dynamically update the ``maximum`` per ``interval`` limit.
        """
        self._maximum = maximum
        self._interval = interval



[docs]    def on_source(self, *args):
        cost = self._cost_func
        if cost is not None:
            cost = cost(*args)
        self._q.append((args, cost))
        self._try_emit()



[docs]    def on_source_done(self, source):
        self._disconnect_from(source)
        self._source = None
        if not self._q:
            self.set_done()
            self.status_event.set_done()


    def _try_emit(self):
        t = loop.time()
        q = self._q
        times = self._time_q
        costs = self._cost_q

        # forget old emit times
        while times and t - times[0] > self._interval:
            times.popleft()
            costs.popleft()

        # emit values while not exceeding the limit
        while q:
            args, cost = q[0]
            if self._cost_func:
                cost = self._cost_func(*args)
                total_cost = cost + sum(costs)
            else:
                cost = None
                total_cost = 1 + len(costs)
            if self._maximum and total_cost >= self._maximum:
                break
            args, cost = q.popleft()
            times.append(t)
            costs.append(cost)
            self.emit(*args)

        # update status and schedule new emits
        if q:
            if not self._is_throttling:
                self.status_event.emit(True)
            loop.call_at(times[0] + self._interval, self._try_emit)
        elif self._is_throttling:
            self.status_event.emit(False)
        self._is_throttling = bool(q)

        if not q and self._source is None:
            self.set_done()
            self.status_event.set_done()




[docs]class Sample(Op):
    __slots__ = ('_timer',)

    def __init__(self, timer, source=None):
        Op.__init__(self, source)
        self._timer = timer
        timer.connect(
            self._on_timer,
            self.on_source_error,
            self.on_source_done)


[docs]    def on_source(self, *args):
        self._value = args


    def _on_timer(self, *args):
        if self._value is not NO_VALUE:
            self.emit(*self._value)


[docs]    def on_source_done(self, source):
        Op.on_source_done(self, self)
        self._timer.disconnect(
            self._on_timer,
            self.on_source_error,
            self.on_source_done)
        self._timer = None
================================================ FILE: docs/html/_modules/eventkit/ops/transform.html ================================================ eventkit.ops.transform — eventkit 0.8.5 documentation

Source code for eventkit.ops.transform

import asyncio
import time
import copy
from collections import deque

from ..util import NO_VALUE, loop

from .op import Op
from .combine import Merge, Chain, Concat, Switch



[docs]class Constant(Op):
    __slots__ = ('_constant',)

    def __init__(self, constant, source=None):
        Op.__init__(self, source)
        self._constant = constant


[docs]    def on_source(self, *args):
        self.emit(self._constant)




[docs]class Iterate(Op):
    __slots__ = ('_it',)

    def __init__(self, it, source=None):
        Op.__init__(self, source)
        self._it = iter(it)


[docs]    def on_source(self, *args):
        try:
            value = next(self._it)
            self.emit(value)
        except StopIteration:
            self._disconnect_from(self._source)
            self.set_done()




[docs]class Enumerate(Op):
    __slots__ = ('_step', '_i')

    def __init__(self, start=0, step=1, source=None):
        Op.__init__(self, source)
        self._i = start
        self._step = step


[docs]    def on_source(self, *args):
        self.emit(
            self._i,
            args[0] if len(args) == 1 else args if args else NO_VALUE)
        self._i += self._step




[docs]class Timestamp(Op):
    __slots__ = ()


[docs]    def on_source(self, *args):
        self.emit(
            time.time(),
            args[0] if len(args) == 1 else args if args else NO_VALUE)




[docs]class Partial(Op):
    __slots__ = ('_left_args',)

    def __init__(self, *left_args, source=None):
        Op.__init__(self, source)
        self._left_args = left_args


[docs]    def on_source(self, *args):
        self.emit(*(self._left_args + args))




[docs]class PartialRight(Op):
    __slots__ = ('_right_args',)

    def __init__(self, *right_args, source=None):
        Op.__init__(self, source)
        self._right_args = right_args


[docs]    def on_source(self, *args):
        self.emit(*(args + self._right_args))




[docs]class Star(Op):
    __slots__ = ()


[docs]    def on_source(self, arg):
        self.emit(*arg)




[docs]class Pack(Op):
    __slots__ = ()


[docs]    def on_source(self, *args):
        self.emit(args)




[docs]class Pluck(Op):
    __slots__ = ('_selections',)

    def __init__(self, *selections, source=None):
        Op.__init__(self, source)
        self._selections = []  # list of [arg-index, *sub-attributes]
        for sel in selections:
            if type(sel) is int:
                s = [sel]
            else:
                s = sel.split('.')
                if s[0].isdigit():
                    s[0] = int(s[0])
                elif s[0] == '':
                    s[0] = 0
                else:
                    s.insert(0, 0)
            self._selections.append(s)


[docs]    def on_source(self, *args):
        values = []
        for s in self._selections:
            try:
                value = args[s[0]]
                for attr in s[1:]:
                    value = getattr(value, attr)
            except Exception:
                value = NO_VALUE
            values.append(value)
        self.emit(*values)







[docs]class Copy(Op):
    __slots__ = ()


[docs]    def on_source(self, *args):
        self.emit(*(copy.copy(a) for a in args))




[docs]class Deepcopy(Op):
    __slots__ = ()


[docs]    def on_source(self, *args):
        self.emit(*copy.deepcopy(args))




[docs]class Chunk(Op):
    __slots__ = ('_size', '_list')

    def __init__(self, size, source=None):
        Op.__init__(self, source)
        self._size = size
        self._list = []


[docs]    def on_source(self, *args):
        self._list.append(
            args[0] if len(args) == 1 else args if args else NO_VALUE)
        if len(self._list) == self._size:
            self.emit(self._list)
            self._list = []



[docs]    def on_source_done(self, source):
        if self._list:
            self.emit(self._list)
        self._disconnect_from(self._source)
        self._source = None
        self.set_done()




[docs]class ChunkWith(Op):
    __slots__ = ('_timer', '_list', '_emit_empty')

    def __init__(self, timer, emit_empty, source=None):
        Op.__init__(self, source)
        self._timer = timer
        self._emit_empty = emit_empty
        self._list = []
        timer.connect(
            self._on_timer,
            self.on_source_error,
            self.on_source_done)


[docs]    def on_source(self, *args):
        self._list.append(
            args[0] if len(args) == 1 else args if args else NO_VALUE)


    def _on_timer(self, *args):
        if self._list or self._emit_empty:
            self.emit(self._list)
            self._list = []


[docs]    def on_source_done(self, source):
        if self._list:
            self.emit(self._list)
            self._list = None
        if self._source is not None:
            self._disconnect_from(self._source)
            self._source = None
        if self._timer is not None:
            self._timer.disconnect(
                self._on_timer,
                self.on_source_error,
                self.on_source_done)
            self._timer = None
        self.set_done()




[docs]class Map(Op):
    __slots__ = (
        '_func', '_timeout', '_ordered', '_task_limit', '_coro_q', '_tasks')

    def __init__(
            self, func, timeout=0, ordered=True, task_limit=None, source=None):
        Op.__init__(self, source)
        if source.done():
            return
        self._func = func
        self._timeout = timeout
        self._ordered = ordered
        self._task_limit = task_limit
        self._coro_q = deque()
        self._tasks = deque()


[docs]    def on_source(self, *args):
        obj = self._func(*args)
        if hasattr(obj, '__await__'):
            # function returns an awaitable
            if not self._task_limit or len(self._tasks) < self._task_limit:
                # schedule right away
                self._create_task(obj)
            else:
                # queue for later
                self._coro_q.append(obj)
        else:
            # regular function returns the result directly
            self.emit(obj)



[docs]    def on_source_done(self, source):
        if not self._tasks:
            # only end when no tasks are pending
            Op.on_source_done(self, self)
        self._source = None


    def _create_task(self, coro):
        # schedule a task to be run
        if self._timeout:
            coro = asyncio.wait_for(coro, self._timeout)
        task = loop.create_task(coro)
        task.add_done_callback(self._on_task_done)
        self._tasks.append(task)

    def _on_task_done(self, task):
        # handle task result
        tasks = self._tasks
        if self._ordered:
            while tasks and tasks[0].done():
                # remove task after emitting result
                task = tasks[0]
                self._emit_task(task)
                task = tasks.popleft()
        else:
            # remove task after emitting result
            self._emit_task(task)
            tasks.remove(task)

        # schedule pending awaitables from the queue
        while self._coro_q and (
                not self._task_limit or len(tasks) < self._task_limit):
            self._create_task(self._coro_q.popleft())

        # end when source has ended with no pending tasks
        if not tasks and self._source is None:
            Op.on_source_done(self, self)

    def _emit_task(self, task):
        try:
            result = task.result()
        except Exception as error:
            result = NO_VALUE
            self.error_event.emit(error)
        self.emit(result)




[docs]class Emap(Op):
    __slots__ = ('_constr', '_joiner',)

    def __init__(self, constr, joiner, source=None):
        Op.__init__(self, source)
        self._constr = constr
        self._joiner = joiner
        joiner.set_parent(source)
        joiner.connect(
            self.emit,
            self.error_event.emit,
            self._on_joiner_done)


[docs]    def on_source(self, *args):
        obj = self._constr(*args)
        event = self.create(obj)
        self._joiner.add_source(event)



[docs]    def on_source_done(self, source):
        pass


    def _on_joiner_done(self, joiner):
        joiner.disconnect(
            self.emit,
            self.error_event.emit,
            self._on_joiner_done)
        self._joiner = None
        self.set_done()




[docs]class Mergemap(Emap):
    __slots__ = ()

    def __init__(self, constr, source=None):
        Emap.__init__(self, constr, Merge(), source)




[docs]class Chainmap(Emap):
    __slots__ = ()

    def __init__(self, constr, source=None):
        Emap.__init__(self, constr, Chain(), source)




[docs]class Concatmap(Emap):
    __slots__ = ()

    def __init__(self, constr, source=None):
        Emap.__init__(self, constr, Concat(), source)




[docs]class Switchmap(Emap):
    __slots__ = ()

    def __init__(self, constr, source=None):
        Emap.__init__(self, constr, Switch(), source)
================================================ FILE: docs/html/_modules/eventkit/util.html ================================================ eventkit.util — eventkit 0.8.5 documentation

Source code for eventkit.util

import asyncio
import datetime
from typing import AsyncIterator


class _NoValue:
    def __bool__(self):
        return False

    def __repr__(self):
        return '<NoValue>'

    __str__ = __repr__


NO_VALUE = _NoValue()


loop = asyncio.get_event_loop()
"""
Main-thread event loop.
"""



[docs]async def timerange(start=0, end=None, step: float = 1) \
        -> AsyncIterator[datetime.datetime]:
    """
    Iterator that waits periodically until certain time points are
    reached while yielding those time points.

    Args:
        start: Start time, can be specified as:

            * ``datetime.datetime``.
            * ``datetime.time``: Today is used as date.
            * ``int`` or ``float``: Number of seconds relative to now.
              Values will be quantized to the given step.
        end: End time, can be specified as:

            * ``datetime.datetime``.
            * ``datetime.time``: Today is used as date.
            * ``None``: No end limit.
        step: Number of seconds, or ``datetime.timedelta``,
            to space between values.
    """
    now = datetime.datetime.now()
    delta = datetime.timedelta(seconds=step)
    t = start
    if t == 0 or isinstance(t, (int, float)):
        t = now + datetime.timedelta(seconds=t)
        # quantize to step
        t = datetime.datetime.fromtimestamp(
            step * int(t.timestamp() / step))
    elif isinstance(t, datetime.time):
        t = datetime.datetime.combine(now.today(), t)

    if t < now:
        # t += delta
        t -= ((t - now) // delta) * delta

    if isinstance(end, datetime.time):
        end = datetime.datetime.combine(now.today(), end)
    elif isinstance(end, (int, float)):
        end = now + datetime.timedelta(seconds=end)

    while end is None or t <= end:
        now = datetime.datetime.now(t.tzinfo)
        secs = (t - now).total_seconds()
        await asyncio.sleep(secs)
        yield t
        t += delta
================================================ FILE: docs/html/_modules/index.html ================================================ Overview: module code — eventkit 1.0.1 documentation
  • Overview: module code

All modules for which code is available

================================================ FILE: docs/html/_modules/logging.html ================================================ logging — eventkit 0.8.5 documentation

Source code for logging

# Copyright 2001-2017 by Vinay Sajip. All Rights Reserved.
#
# Permission to use, copy, modify, and distribute this software and its
# documentation for any purpose and without fee is hereby granted,
# provided that the above copyright notice appear in all copies and that
# both that copyright notice and this permission notice appear in
# supporting documentation, and that the name of Vinay Sajip
# not be used in advertising or publicity pertaining to distribution
# of the software without specific, written prior permission.
# VINAY SAJIP DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
# ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL
# VINAY SAJIP BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
# ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER
# IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
# OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

"""
Logging package for Python. Based on PEP 282 and comments thereto in
comp.lang.python.

Copyright (C) 2001-2017 Vinay Sajip. All Rights Reserved.

To use, simply 'import logging' and log away!
"""

import sys, os, time, io, traceback, warnings, weakref, collections.abc

from string import Template

__all__ = ['BASIC_FORMAT', 'BufferingFormatter', 'CRITICAL', 'DEBUG', 'ERROR',
           'FATAL', 'FileHandler', 'Filter', 'Formatter', 'Handler', 'INFO',
           'LogRecord', 'Logger', 'LoggerAdapter', 'NOTSET', 'NullHandler',
           'StreamHandler', 'WARN', 'WARNING', 'addLevelName', 'basicConfig',
           'captureWarnings', 'critical', 'debug', 'disable', 'error',
           'exception', 'fatal', 'getLevelName', 'getLogger', 'getLoggerClass',
           'info', 'log', 'makeLogRecord', 'setLoggerClass', 'shutdown',
           'warn', 'warning', 'getLogRecordFactory', 'setLogRecordFactory',
           'lastResort', 'raiseExceptions']

import threading

__author__  = "Vinay Sajip <vinay_sajip@red-dove.com>"
__status__  = "production"
# The following module attributes are no longer updated.
__version__ = "0.5.1.2"
__date__    = "07 February 2010"

#---------------------------------------------------------------------------
#   Miscellaneous module data
#---------------------------------------------------------------------------

#
#_startTime is used as the base when calculating the relative time of events
#
_startTime = time.time()

#
#raiseExceptions is used to see if exceptions during handling should be
#propagated
#
raiseExceptions = True

#
# If you don't want threading information in the log, set this to zero
#
logThreads = True

#
# If you don't want multiprocessing information in the log, set this to zero
#
logMultiprocessing = True

#
# If you don't want process information in the log, set this to zero
#
logProcesses = True

#---------------------------------------------------------------------------
#   Level related stuff
#---------------------------------------------------------------------------
#
# Default levels and level names, these can be replaced with any positive set
# of values having corresponding names. There is a pseudo-level, NOTSET, which
# is only really there as a lower limit for user-defined levels. Handlers and
# loggers are initialized with NOTSET so that they will log all messages, even
# at user-defined levels.
#

CRITICAL = 50
FATAL = CRITICAL
ERROR = 40
WARNING = 30
WARN = WARNING
INFO = 20
DEBUG = 10
NOTSET = 0

_levelToName = {
    CRITICAL: 'CRITICAL',
    ERROR: 'ERROR',
    WARNING: 'WARNING',
    INFO: 'INFO',
    DEBUG: 'DEBUG',
    NOTSET: 'NOTSET',
}
_nameToLevel = {
    'CRITICAL': CRITICAL,
    'FATAL': FATAL,
    'ERROR': ERROR,
    'WARN': WARNING,
    'WARNING': WARNING,
    'INFO': INFO,
    'DEBUG': DEBUG,
    'NOTSET': NOTSET,
}

def getLevelName(level):
    """
    Return the textual representation of logging level 'level'.

    If the level is one of the predefined levels (CRITICAL, ERROR, WARNING,
    INFO, DEBUG) then you get the corresponding string. If you have
    associated levels with names using addLevelName then the name you have
    associated with 'level' is returned.

    If a numeric value corresponding to one of the defined levels is passed
    in, the corresponding string representation is returned.

    Otherwise, the string "Level %s" % level is returned.
    """
    # See Issues #22386, #27937 and #29220 for why it's this way
    result = _levelToName.get(level)
    if result is not None:
        return result
    result = _nameToLevel.get(level)
    if result is not None:
        return result
    return "Level %s" % level

def addLevelName(level, levelName):
    """
    Associate 'levelName' with 'level'.

    This is used when converting levels to text during message formatting.
    """
    _acquireLock()
    try:    #unlikely to cause an exception, but you never know...
        _levelToName[level] = levelName
        _nameToLevel[levelName] = level
    finally:
        _releaseLock()

if hasattr(sys, '_getframe'):
    currentframe = lambda: sys._getframe(3)
else: #pragma: no cover
    def currentframe():
        """Return the frame object for the caller's stack frame."""
        try:
            raise Exception
        except Exception:
            return sys.exc_info()[2].tb_frame.f_back

#
# _srcfile is used when walking the stack to check when we've got the first
# caller stack frame, by skipping frames whose filename is that of this
# module's source. It therefore should contain the filename of this module's
# source file.
#
# Ordinarily we would use __file__ for this, but frozen modules don't always
# have __file__ set, for some reason (see Issue #21736). Thus, we get the
# filename from a handy code object from a function defined in this module.
# (There's no particular reason for picking addLevelName.)
#

_srcfile = os.path.normcase(addLevelName.__code__.co_filename)

# _srcfile is only used in conjunction with sys._getframe().
# To provide compatibility with older versions of Python, set _srcfile
# to None if _getframe() is not available; this value will prevent
# findCaller() from being called. You can also do this if you want to avoid
# the overhead of fetching caller information, even when _getframe() is
# available.
#if not hasattr(sys, '_getframe'):
#    _srcfile = None


def _checkLevel(level):
    if isinstance(level, int):
        rv = level
    elif str(level) == level:
        if level not in _nameToLevel:
            raise ValueError("Unknown level: %r" % level)
        rv = _nameToLevel[level]
    else:
        raise TypeError("Level not an integer or a valid string: %r" % level)
    return rv

#---------------------------------------------------------------------------
#   Thread-related stuff
#---------------------------------------------------------------------------

#
#_lock is used to serialize access to shared data structures in this module.
#This needs to be an RLock because fileConfig() creates and configures
#Handlers, and so might arbitrary user threads. Since Handler code updates the
#shared dictionary _handlers, it needs to acquire the lock. But if configuring,
#the lock would already have been acquired - so we need an RLock.
#The same argument applies to Loggers and Manager.loggerDict.
#
_lock = threading.RLock()

def _acquireLock():
    """
    Acquire the module-level lock for serializing access to shared data.

    This should be released with _releaseLock().
    """
    if _lock:
        _lock.acquire()

def _releaseLock():
    """
    Release the module-level lock acquired by calling _acquireLock().
    """
    if _lock:
        _lock.release()


# Prevent a held logging lock from blocking a child from logging.

if not hasattr(os, 'register_at_fork'):  # Windows and friends.
    def _register_at_fork_reinit_lock(instance):
        pass  # no-op when os.register_at_fork does not exist.
else:
    # A collection of instances with a createLock method (logging.Handler)
    # to be called in the child after forking.  The weakref avoids us keeping
    # discarded Handler instances alive.  A set is used to avoid accumulating
    # duplicate registrations as createLock() is responsible for registering
    # a new Handler instance with this set in the first place.
    _at_fork_reinit_lock_weakset = weakref.WeakSet()

    def _register_at_fork_reinit_lock(instance):
        _acquireLock()
        try:
            _at_fork_reinit_lock_weakset.add(instance)
        finally:
            _releaseLock()

    def _after_at_fork_child_reinit_locks():
        # _acquireLock() was called in the parent before forking.
        for handler in _at_fork_reinit_lock_weakset:
            try:
                handler.createLock()
            except Exception as err:
                # Similar to what PyErr_WriteUnraisable does.
                print("Ignoring exception from logging atfork", instance,
                      "._reinit_lock() method:", err, file=sys.stderr)
        _releaseLock()  # Acquired by os.register_at_fork(before=.


    os.register_at_fork(before=_acquireLock,
                        after_in_child=_after_at_fork_child_reinit_locks,
                        after_in_parent=_releaseLock)


#---------------------------------------------------------------------------
#   The logging record
#---------------------------------------------------------------------------

class LogRecord(object):
    """
    A LogRecord instance represents an event being logged.

    LogRecord instances are created every time something is logged. They
    contain all the information pertinent to the event being logged. The
    main information passed in is in msg and args, which are combined
    using str(msg) % args to create the message field of the record. The
    record also includes information such as when the record was created,
    the source line where the logging call was made, and any exception
    information to be logged.
    """
    def __init__(self, name, level, pathname, lineno,
                 msg, args, exc_info, func=None, sinfo=None, **kwargs):
        """
        Initialize a logging record with interesting information.
        """
        ct = time.time()
        self.name = name
        self.msg = msg
        #
        # The following statement allows passing of a dictionary as a sole
        # argument, so that you can do something like
        #  logging.debug("a %(a)d b %(b)s", {'a':1, 'b':2})
        # Suggested by Stefan Behnel.
        # Note that without the test for args[0], we get a problem because
        # during formatting, we test to see if the arg is present using
        # 'if self.args:'. If the event being logged is e.g. 'Value is %d'
        # and if the passed arg fails 'if self.args:' then no formatting
        # is done. For example, logger.warning('Value is %d', 0) would log
        # 'Value is %d' instead of 'Value is 0'.
        # For the use case of passing a dictionary, this should not be a
        # problem.
        # Issue #21172: a request was made to relax the isinstance check
        # to hasattr(args[0], '__getitem__'). However, the docs on string
        # formatting still seem to suggest a mapping object is required.
        # Thus, while not removing the isinstance check, it does now look
        # for collections.abc.Mapping rather than, as before, dict.
        if (args and len(args) == 1 and isinstance(args[0], collections.abc.Mapping)
            and args[0]):
            args = args[0]
        self.args = args
        self.levelname = getLevelName(level)
        self.levelno = level
        self.pathname = pathname
        try:
            self.filename = os.path.basename(pathname)
            self.module = os.path.splitext(self.filename)[0]
        except (TypeError, ValueError, AttributeError):
            self.filename = pathname
            self.module = "Unknown module"
        self.exc_info = exc_info
        self.exc_text = None      # used to cache the traceback text
        self.stack_info = sinfo
        self.lineno = lineno
        self.funcName = func
        self.created = ct
        self.msecs = (ct - int(ct)) * 1000
        self.relativeCreated = (self.created - _startTime) * 1000
        if logThreads:
            self.thread = threading.get_ident()
            self.threadName = threading.current_thread().name
        else: # pragma: no cover
            self.thread = None
            self.threadName = None
        if not logMultiprocessing: # pragma: no cover
            self.processName = None
        else:
            self.processName = 'MainProcess'
            mp = sys.modules.get('multiprocessing')
            if mp is not None:
                # Errors may occur if multiprocessing has not finished loading
                # yet - e.g. if a custom import hook causes third-party code
                # to run when multiprocessing calls import. See issue 8200
                # for an example
                try:
                    self.processName = mp.current_process().name
                except Exception: #pragma: no cover
                    pass
        if logProcesses and hasattr(os, 'getpid'):
            self.process = os.getpid()
        else:
            self.process = None

    def __str__(self):
        return '<LogRecord: %s, %s, %s, %s, "%s">'%(self.name, self.levelno,
            self.pathname, self.lineno, self.msg)

    __repr__ = __str__

    def getMessage(self):
        """
        Return the message for this LogRecord.

        Return the message for this LogRecord after merging any user-supplied
        arguments with the message.
        """
        msg = str(self.msg)
        if self.args:
            msg = msg % self.args
        return msg

#
#   Determine which class to use when instantiating log records.
#
_logRecordFactory = LogRecord

def setLogRecordFactory(factory):
    """
    Set the factory to be used when instantiating a log record.

    :param factory: A callable which will be called to instantiate
    a log record.
    """
    global _logRecordFactory
    _logRecordFactory = factory

def getLogRecordFactory():
    """
    Return the factory to be used when instantiating a log record.
    """

    return _logRecordFactory

def makeLogRecord(dict):
    """
    Make a LogRecord whose attributes are defined by the specified dictionary,
    This function is useful for converting a logging event received over
    a socket connection (which is sent as a dictionary) into a LogRecord
    instance.
    """
    rv = _logRecordFactory(None, None, "", 0, "", (), None, None)
    rv.__dict__.update(dict)
    return rv

#---------------------------------------------------------------------------
#   Formatter classes and functions
#---------------------------------------------------------------------------

class PercentStyle(object):

    default_format = '%(message)s'
    asctime_format = '%(asctime)s'
    asctime_search = '%(asctime)'

    def __init__(self, fmt):
        self._fmt = fmt or self.default_format

    def usesTime(self):
        return self._fmt.find(self.asctime_search) >= 0

    def format(self, record):
        return self._fmt % record.__dict__

class StrFormatStyle(PercentStyle):
    default_format = '{message}'
    asctime_format = '{asctime}'
    asctime_search = '{asctime'

    def format(self, record):
        return self._fmt.format(**record.__dict__)


class StringTemplateStyle(PercentStyle):
    default_format = '${message}'
    asctime_format = '${asctime}'
    asctime_search = '${asctime}'

    def __init__(self, fmt):
        self._fmt = fmt or self.default_format
        self._tpl = Template(self._fmt)

    def usesTime(self):
        fmt = self._fmt
        return fmt.find('$asctime') >= 0 or fmt.find(self.asctime_format) >= 0

    def format(self, record):
        return self._tpl.substitute(**record.__dict__)

BASIC_FORMAT = "%(levelname)s:%(name)s:%(message)s"

_STYLES = {
    '%': (PercentStyle, BASIC_FORMAT),
    '{': (StrFormatStyle, '{levelname}:{name}:{message}'),
    '$': (StringTemplateStyle, '${levelname}:${name}:${message}'),
}

class Formatter(object):
    """
    Formatter instances are used to convert a LogRecord to text.

    Formatters need to know how a LogRecord is constructed. They are
    responsible for converting a LogRecord to (usually) a string which can
    be interpreted by either a human or an external system. The base Formatter
    allows a formatting string to be specified. If none is supplied, the
    the style-dependent default value, "%(message)s", "{message}", or
    "${message}", is used.

    The Formatter can be initialized with a format string which makes use of
    knowledge of the LogRecord attributes - e.g. the default value mentioned
    above makes use of the fact that the user's message and arguments are pre-
    formatted into a LogRecord's message attribute. Currently, the useful
    attributes in a LogRecord are described by:

    %(name)s            Name of the logger (logging channel)
    %(levelno)s         Numeric logging level for the message (DEBUG, INFO,
                        WARNING, ERROR, CRITICAL)
    %(levelname)s       Text logging level for the message ("DEBUG", "INFO",
                        "WARNING", "ERROR", "CRITICAL")
    %(pathname)s        Full pathname of the source file where the logging
                        call was issued (if available)
    %(filename)s        Filename portion of pathname
    %(module)s          Module (name portion of filename)
    %(lineno)d          Source line number where the logging call was issued
                        (if available)
    %(funcName)s        Function name
    %(created)f         Time when the LogRecord was created (time.time()
                        return value)
    %(asctime)s         Textual time when the LogRecord was created
    %(msecs)d           Millisecond portion of the creation time
    %(relativeCreated)d Time in milliseconds when the LogRecord was created,
                        relative to the time the logging module was loaded
                        (typically at application startup time)
    %(thread)d          Thread ID (if available)
    %(threadName)s      Thread name (if available)
    %(process)d         Process ID (if available)
    %(message)s         The result of record.getMessage(), computed just as
                        the record is emitted
    """

    converter = time.localtime

    def __init__(self, fmt=None, datefmt=None, style='%'):
        """
        Initialize the formatter with specified format strings.

        Initialize the formatter either with the specified format string, or a
        default as described above. Allow for specialized date formatting with
        the optional datefmt argument. If datefmt is omitted, you get an
        ISO8601-like (or RFC 3339-like) format.

        Use a style parameter of '%', '{' or '$' to specify that you want to
        use one of %-formatting, :meth:`str.format` (``{}``) formatting or
        :class:`string.Template` formatting in your format string.

        .. versionchanged:: 3.2
           Added the ``style`` parameter.
        """
        if style not in _STYLES:
            raise ValueError('Style must be one of: %s' % ','.join(
                             _STYLES.keys()))
        self._style = _STYLES[style][0](fmt)
        self._fmt = self._style._fmt
        self.datefmt = datefmt

    default_time_format = '%Y-%m-%d %H:%M:%S'
    default_msec_format = '%s,%03d'

    def formatTime(self, record, datefmt=None):
        """
        Return the creation time of the specified LogRecord as formatted text.

        This method should be called from format() by a formatter which
        wants to make use of a formatted time. This method can be overridden
        in formatters to provide for any specific requirement, but the
        basic behaviour is as follows: if datefmt (a string) is specified,
        it is used with time.strftime() to format the creation time of the
        record. Otherwise, an ISO8601-like (or RFC 3339-like) format is used.
        The resulting string is returned. This function uses a user-configurable
        function to convert the creation time to a tuple. By default,
        time.localtime() is used; to change this for a particular formatter
        instance, set the 'converter' attribute to a function with the same
        signature as time.localtime() or time.gmtime(). To change it for all
        formatters, for example if you want all logging times to be shown in GMT,
        set the 'converter' attribute in the Formatter class.
        """
        ct = self.converter(record.created)
        if datefmt:
            s = time.strftime(datefmt, ct)
        else:
            t = time.strftime(self.default_time_format, ct)
            s = self.default_msec_format % (t, record.msecs)
        return s

    def formatException(self, ei):
        """
        Format and return the specified exception information as a string.

        This default implementation just uses
        traceback.print_exception()
        """
        sio = io.StringIO()
        tb = ei[2]
        # See issues #9427, #1553375. Commented out for now.
        #if getattr(self, 'fullstack', False):
        #    traceback.print_stack(tb.tb_frame.f_back, file=sio)
        traceback.print_exception(ei[0], ei[1], tb, None, sio)
        s = sio.getvalue()
        sio.close()
        if s[-1:] == "\n":
            s = s[:-1]
        return s

    def usesTime(self):
        """
        Check if the format uses the creation time of the record.
        """
        return self._style.usesTime()

    def formatMessage(self, record):
        return self._style.format(record)

    def formatStack(self, stack_info):
        """
        This method is provided as an extension point for specialized
        formatting of stack information.

        The input data is a string as returned from a call to
        :func:`traceback.print_stack`, but with the last trailing newline
        removed.

        The base implementation just returns the value passed in.
        """
        return stack_info

    def format(self, record):
        """
        Format the specified record as text.

        The record's attribute dictionary is used as the operand to a
        string formatting operation which yields the returned string.
        Before formatting the dictionary, a couple of preparatory steps
        are carried out. The message attribute of the record is computed
        using LogRecord.getMessage(). If the formatting string uses the
        time (as determined by a call to usesTime(), formatTime() is
        called to format the event time. If there is exception information,
        it is formatted using formatException() and appended to the message.
        """
        record.message = record.getMessage()
        if self.usesTime():
            record.asctime = self.formatTime(record, self.datefmt)
        s = self.formatMessage(record)
        if record.exc_info:
            # Cache the traceback text to avoid converting it multiple times
            # (it's constant anyway)
            if not record.exc_text:
                record.exc_text = self.formatException(record.exc_info)
        if record.exc_text:
            if s[-1:] != "\n":
                s = s + "\n"
            s = s + record.exc_text
        if record.stack_info:
            if s[-1:] != "\n":
                s = s + "\n"
            s = s + self.formatStack(record.stack_info)
        return s

#
#   The default formatter to use when no other is specified
#
_defaultFormatter = Formatter()

class BufferingFormatter(object):
    """
    A formatter suitable for formatting a number of records.
    """
    def __init__(self, linefmt=None):
        """
        Optionally specify a formatter which will be used to format each
        individual record.
        """
        if linefmt:
            self.linefmt = linefmt
        else:
            self.linefmt = _defaultFormatter

    def formatHeader(self, records):
        """
        Return the header string for the specified records.
        """
        return ""

    def formatFooter(self, records):
        """
        Return the footer string for the specified records.
        """
        return ""

    def format(self, records):
        """
        Format the specified records and return the result as a string.
        """
        rv = ""
        if len(records) > 0:
            rv = rv + self.formatHeader(records)
            for record in records:
                rv = rv + self.linefmt.format(record)
            rv = rv + self.formatFooter(records)
        return rv

#---------------------------------------------------------------------------
#   Filter classes and functions
#---------------------------------------------------------------------------

class Filter(object):
    """
    Filter instances are used to perform arbitrary filtering of LogRecords.

    Loggers and Handlers can optionally use Filter instances to filter
    records as desired. The base filter class only allows events which are
    below a certain point in the logger hierarchy. For example, a filter
    initialized with "A.B" will allow events logged by loggers "A.B",
    "A.B.C", "A.B.C.D", "A.B.D" etc. but not "A.BB", "B.A.B" etc. If
    initialized with the empty string, all events are passed.
    """
    def __init__(self, name=''):
        """
        Initialize a filter.

        Initialize with the name of the logger which, together with its
        children, will have its events allowed through the filter. If no
        name is specified, allow every event.
        """
        self.name = name
        self.nlen = len(name)

    def filter(self, record):
        """
        Determine if the specified record is to be logged.

        Is the specified record to be logged? Returns 0 for no, nonzero for
        yes. If deemed appropriate, the record may be modified in-place.
        """
        if self.nlen == 0:
            return True
        elif self.name == record.name:
            return True
        elif record.name.find(self.name, 0, self.nlen) != 0:
            return False
        return (record.name[self.nlen] == ".")

class Filterer(object):
    """
    A base class for loggers and handlers which allows them to share
    common code.
    """
    def __init__(self):
        """
        Initialize the list of filters to be an empty list.
        """
        self.filters = []

    def addFilter(self, filter):
        """
        Add the specified filter to this handler.
        """
        if not (filter in self.filters):
            self.filters.append(filter)

    def removeFilter(self, filter):
        """
        Remove the specified filter from this handler.
        """
        if filter in self.filters:
            self.filters.remove(filter)

    def filter(self, record):
        """
        Determine if a record is loggable by consulting all the filters.

        The default is to allow the record to be logged; any filter can veto
        this and the record is then dropped. Returns a zero value if a record
        is to be dropped, else non-zero.

        .. versionchanged:: 3.2

           Allow filters to be just callables.
        """
        rv = True
        for f in self.filters:
            if hasattr(f, 'filter'):
                result = f.filter(record)
            else:
                result = f(record) # assume callable - will raise if not
            if not result:
                rv = False
                break
        return rv

#---------------------------------------------------------------------------
#   Handler classes and functions
#---------------------------------------------------------------------------

_handlers = weakref.WeakValueDictionary()  #map of handler names to handlers
_handlerList = [] # added to allow handlers to be removed in reverse of order initialized

def _removeHandlerRef(wr):
    """
    Remove a handler reference from the internal cleanup list.
    """
    # This function can be called during module teardown, when globals are
    # set to None. It can also be called from another thread. So we need to
    # pre-emptively grab the necessary globals and check if they're None,
    # to prevent race conditions and failures during interpreter shutdown.
    acquire, release, handlers = _acquireLock, _releaseLock, _handlerList
    if acquire and release and handlers:
        acquire()
        try:
            if wr in handlers:
                handlers.remove(wr)
        finally:
            release()

def _addHandlerRef(handler):
    """
    Add a handler to the internal cleanup list using a weak reference.
    """
    _acquireLock()
    try:
        _handlerList.append(weakref.ref(handler, _removeHandlerRef))
    finally:
        _releaseLock()

class Handler(Filterer):
    """
    Handler instances dispatch logging events to specific destinations.

    The base handler class. Acts as a placeholder which defines the Handler
    interface. Handlers can optionally use Formatter instances to format
    records as desired. By default, no formatter is specified; in this case,
    the 'raw' message as determined by record.message is logged.
    """
    def __init__(self, level=NOTSET):
        """
        Initializes the instance - basically setting the formatter to None
        and the filter list to empty.
        """
        Filterer.__init__(self)
        self._name = None
        self.level = _checkLevel(level)
        self.formatter = None
        # Add the handler to the global _handlerList (for cleanup on shutdown)
        _addHandlerRef(self)
        self.createLock()

    def get_name(self):
        return self._name

    def set_name(self, name):
        _acquireLock()
        try:
            if self._name in _handlers:
                del _handlers[self._name]
            self._name = name
            if name:
                _handlers[name] = self
        finally:
            _releaseLock()

    name = property(get_name, set_name)

    def createLock(self):
        """
        Acquire a thread lock for serializing access to the underlying I/O.
        """
        self.lock = threading.RLock()
        _register_at_fork_reinit_lock(self)

    def acquire(self):
        """
        Acquire the I/O thread lock.
        """
        if self.lock:
            self.lock.acquire()

    def release(self):
        """
        Release the I/O thread lock.
        """
        if self.lock:
            self.lock.release()

    def setLevel(self, level):
        """
        Set the logging level of this handler.  level must be an int or a str.
        """
        self.level = _checkLevel(level)

    def format(self, record):
        """
        Format the specified record.

        If a formatter is set, use it. Otherwise, use the default formatter
        for the module.
        """
        if self.formatter:
            fmt = self.formatter
        else:
            fmt = _defaultFormatter
        return fmt.format(record)

    def emit(self, record):
        """
        Do whatever it takes to actually log the specified logging record.

        This version is intended to be implemented by subclasses and so
        raises a NotImplementedError.
        """
        raise NotImplementedError('emit must be implemented '
                                  'by Handler subclasses')

    def handle(self, record):
        """
        Conditionally emit the specified logging record.

        Emission depends on filters which may have been added to the handler.
        Wrap the actual emission of the record with acquisition/release of
        the I/O thread lock. Returns whether the filter passed the record for
        emission.
        """
        rv = self.filter(record)
        if rv:
            self.acquire()
            try:
                self.emit(record)
            finally:
                self.release()
        return rv

    def setFormatter(self, fmt):
        """
        Set the formatter for this handler.
        """
        self.formatter = fmt

    def flush(self):
        """
        Ensure all logging output has been flushed.

        This version does nothing and is intended to be implemented by
        subclasses.
        """
        pass

    def close(self):
        """
        Tidy up any resources used by the handler.

        This version removes the handler from an internal map of handlers,
        _handlers, which is used for handler lookup by name. Subclasses
        should ensure that this gets called from overridden close()
        methods.
        """
        #get the module data lock, as we're updating a shared structure.
        _acquireLock()
        try:    #unlikely to raise an exception, but you never know...
            if self._name and self._name in _handlers:
                del _handlers[self._name]
        finally:
            _releaseLock()

    def handleError(self, record):
        """
        Handle errors which occur during an emit() call.

        This method should be called from handlers when an exception is
        encountered during an emit() call. If raiseExceptions is false,
        exceptions get silently ignored. This is what is mostly wanted
        for a logging system - most users will not care about errors in
        the logging system, they are more interested in application errors.
        You could, however, replace this with a custom handler if you wish.
        The record which was being processed is passed in to this method.
        """
        if raiseExceptions and sys.stderr:  # see issue 13807
            t, v, tb = sys.exc_info()
            try:
                sys.stderr.write('--- Logging error ---\n')
                traceback.print_exception(t, v, tb, None, sys.stderr)
                sys.stderr.write('Call stack:\n')
                # Walk the stack frame up until we're out of logging,
                # so as to print the calling context.
                frame = tb.tb_frame
                while (frame and os.path.dirname(frame.f_code.co_filename) ==
                       __path__[0]):
                    frame = frame.f_back
                if frame:
                    traceback.print_stack(frame, file=sys.stderr)
                else:
                    # couldn't find the right stack frame, for some reason
                    sys.stderr.write('Logged from file %s, line %s\n' % (
                                     record.filename, record.lineno))
                # Issue 18671: output logging message and arguments
                try:
                    sys.stderr.write('Message: %r\n'
                                     'Arguments: %s\n' % (record.msg,
                                                          record.args))
                except RecursionError:  # See issue 36272
                    raise
                except Exception:
                    sys.stderr.write('Unable to print the message and arguments'
                                     ' - possible formatting error.\nUse the'
                                     ' traceback above to help find the error.\n'
                                    )
            except OSError: #pragma: no cover
                pass    # see issue 5971
            finally:
                del t, v, tb

    def __repr__(self):
        level = getLevelName(self.level)
        return '<%s (%s)>' % (self.__class__.__name__, level)

class StreamHandler(Handler):
    """
    A handler class which writes logging records, appropriately formatted,
    to a stream. Note that this class does not close the stream, as
    sys.stdout or sys.stderr may be used.
    """

    terminator = '\n'

    def __init__(self, stream=None):
        """
        Initialize the handler.

        If stream is not specified, sys.stderr is used.
        """
        Handler.__init__(self)
        if stream is None:
            stream = sys.stderr
        self.stream = stream

    def flush(self):
        """
        Flushes the stream.
        """
        self.acquire()
        try:
            if self.stream and hasattr(self.stream, "flush"):
                self.stream.flush()
        finally:
            self.release()

    def emit(self, record):
        """
        Emit a record.

        If a formatter is specified, it is used to format the record.
        The record is then written to the stream with a trailing newline.  If
        exception information is present, it is formatted using
        traceback.print_exception and appended to the stream.  If the stream
        has an 'encoding' attribute, it is used to determine how to do the
        output to the stream.
        """
        try:
            msg = self.format(record)
            stream = self.stream
            # issue 35046: merged two stream.writes into one.
            stream.write(msg + self.terminator)
            self.flush()
        except RecursionError:  # See issue 36272
            raise
        except Exception:
            self.handleError(record)

    def setStream(self, stream):
        """
        Sets the StreamHandler's stream to the specified value,
        if it is different.

        Returns the old stream, if the stream was changed, or None
        if it wasn't.
        """
        if stream is self.stream:
            result = None
        else:
            result = self.stream
            self.acquire()
            try:
                self.flush()
                self.stream = stream
            finally:
                self.release()
        return result

    def __repr__(self):
        level = getLevelName(self.level)
        name = getattr(self.stream, 'name', '')
        #  bpo-36015: name can be an int
        name = str(name)
        if name:
            name += ' '
        return '<%s %s(%s)>' % (self.__class__.__name__, name, level)


class FileHandler(StreamHandler):
    """
    A handler class which writes formatted logging records to disk files.
    """
    def __init__(self, filename, mode='a', encoding=None, delay=False):
        """
        Open the specified file and use it as the stream for logging.
        """
        # Issue #27493: add support for Path objects to be passed in
        filename = os.fspath(filename)
        #keep the absolute path, otherwise derived classes which use this
        #may come a cropper when the current directory changes
        self.baseFilename = os.path.abspath(filename)
        self.mode = mode
        self.encoding = encoding
        self.delay = delay
        if delay:
            #We don't open the stream, but we still need to call the
            #Handler constructor to set level, formatter, lock etc.
            Handler.__init__(self)
            self.stream = None
        else:
            StreamHandler.__init__(self, self._open())

    def close(self):
        """
        Closes the stream.
        """
        self.acquire()
        try:
            try:
                if self.stream:
                    try:
                        self.flush()
                    finally:
                        stream = self.stream
                        self.stream = None
                        if hasattr(stream, "close"):
                            stream.close()
            finally:
                # Issue #19523: call unconditionally to
                # prevent a handler leak when delay is set
                StreamHandler.close(self)
        finally:
            self.release()

    def _open(self):
        """
        Open the current base file with the (original) mode and encoding.
        Return the resulting stream.
        """
        return open(self.baseFilename, self.mode, encoding=self.encoding)

    def emit(self, record):
        """
        Emit a record.

        If the stream was not opened because 'delay' was specified in the
        constructor, open it before calling the superclass's emit.
        """
        if self.stream is None:
            self.stream = self._open()
        StreamHandler.emit(self, record)

    def __repr__(self):
        level = getLevelName(self.level)
        return '<%s %s (%s)>' % (self.__class__.__name__, self.baseFilename, level)


class _StderrHandler(StreamHandler):
    """
    This class is like a StreamHandler using sys.stderr, but always uses
    whatever sys.stderr is currently set to rather than the value of
    sys.stderr at handler construction time.
    """
    def __init__(self, level=NOTSET):
        """
        Initialize the handler.
        """
        Handler.__init__(self, level)

    @property
    def stream(self):
        return sys.stderr


_defaultLastResort = _StderrHandler(WARNING)
lastResort = _defaultLastResort

#---------------------------------------------------------------------------
#   Manager classes and functions
#---------------------------------------------------------------------------

class PlaceHolder(object):
    """
    PlaceHolder instances are used in the Manager logger hierarchy to take
    the place of nodes for which no loggers have been defined. This class is
    intended for internal use only and not as part of the public API.
    """
    def __init__(self, alogger):
        """
        Initialize with the specified logger being a child of this placeholder.
        """
        self.loggerMap = { alogger : None }

    def append(self, alogger):
        """
        Add the specified logger as a child of this placeholder.
        """
        if alogger not in self.loggerMap:
            self.loggerMap[alogger] = None

#
#   Determine which class to use when instantiating loggers.
#

def setLoggerClass(klass):
    """
    Set the class to be used when instantiating a logger. The class should
    define __init__() such that only a name argument is required, and the
    __init__() should call Logger.__init__()
    """
    if klass != Logger:
        if not issubclass(klass, Logger):
            raise TypeError("logger not derived from logging.Logger: "
                            + klass.__name__)
    global _loggerClass
    _loggerClass = klass

def getLoggerClass():
    """
    Return the class to be used when instantiating a logger.
    """
    return _loggerClass

class Manager(object):
    """
    There is [under normal circumstances] just one Manager instance, which
    holds the hierarchy of loggers.
    """
    def __init__(self, rootnode):
        """
        Initialize the manager with the root node of the logger hierarchy.
        """
        self.root = rootnode
        self.disable = 0
        self.emittedNoHandlerWarning = False
        self.loggerDict = {}
        self.loggerClass = None
        self.logRecordFactory = None

    def getLogger(self, name):
        """
        Get a logger with the specified name (channel name), creating it
        if it doesn't yet exist. This name is a dot-separated hierarchical
        name, such as "a", "a.b", "a.b.c" or similar.

        If a PlaceHolder existed for the specified name [i.e. the logger
        didn't exist but a child of it did], replace it with the created
        logger and fix up the parent/child references which pointed to the
        placeholder to now point to the logger.
        """
        rv = None
        if not isinstance(name, str):
            raise TypeError('A logger name must be a string')
        _acquireLock()
        try:
            if name in self.loggerDict:
                rv = self.loggerDict[name]
                if isinstance(rv, PlaceHolder):
                    ph = rv
                    rv = (self.loggerClass or _loggerClass)(name)
                    rv.manager = self
                    self.loggerDict[name] = rv
                    self._fixupChildren(ph, rv)
                    self._fixupParents(rv)
            else:
                rv = (self.loggerClass or _loggerClass)(name)
                rv.manager = self
                self.loggerDict[name] = rv
                self._fixupParents(rv)
        finally:
            _releaseLock()
        return rv

    def setLoggerClass(self, klass):
        """
        Set the class to be used when instantiating a logger with this Manager.
        """
        if klass != Logger:
            if not issubclass(klass, Logger):
                raise TypeError("logger not derived from logging.Logger: "
                                + klass.__name__)
        self.loggerClass = klass

    def setLogRecordFactory(self, factory):
        """
        Set the factory to be used when instantiating a log record with this
        Manager.
        """
        self.logRecordFactory = factory

    def _fixupParents(self, alogger):
        """
        Ensure that there are either loggers or placeholders all the way
        from the specified logger to the root of the logger hierarchy.
        """
        name = alogger.name
        i = name.rfind(".")
        rv = None
        while (i > 0) and not rv:
            substr = name[:i]
            if substr not in self.loggerDict:
                self.loggerDict[substr] = PlaceHolder(alogger)
            else:
                obj = self.loggerDict[substr]
                if isinstance(obj, Logger):
                    rv = obj
                else:
                    assert isinstance(obj, PlaceHolder)
                    obj.append(alogger)
            i = name.rfind(".", 0, i - 1)
        if not rv:
            rv = self.root
        alogger.parent = rv

    def _fixupChildren(self, ph, alogger):
        """
        Ensure that children of the placeholder ph are connected to the
        specified logger.
        """
        name = alogger.name
        namelen = len(name)
        for c in ph.loggerMap.keys():
            #The if means ... if not c.parent.name.startswith(nm)
            if c.parent.name[:namelen] != name:
                alogger.parent = c.parent
                c.parent = alogger

    def _clear_cache(self):
        """
        Clear the cache for all loggers in loggerDict
        Called when level changes are made
        """

        _acquireLock()
        for logger in self.loggerDict.values():
            if isinstance(logger, Logger):
                logger._cache.clear()
        self.root._cache.clear()
        _releaseLock()

#---------------------------------------------------------------------------
#   Logger classes and functions
#---------------------------------------------------------------------------

class Logger(Filterer):
    """
    Instances of the Logger class represent a single logging channel. A
    "logging channel" indicates an area of an application. Exactly how an
    "area" is defined is up to the application developer. Since an
    application can have any number of areas, logging channels are identified
    by a unique string. Application areas can be nested (e.g. an area
    of "input processing" might include sub-areas "read CSV files", "read
    XLS files" and "read Gnumeric files"). To cater for this natural nesting,
    channel names are organized into a namespace hierarchy where levels are
    separated by periods, much like the Java or Python package namespace. So
    in the instance given above, channel names might be "input" for the upper
    level, and "input.csv", "input.xls" and "input.gnu" for the sub-levels.
    There is no arbitrary limit to the depth of nesting.
    """
    def __init__(self, name, level=NOTSET):
        """
        Initialize the logger with a name and an optional level.
        """
        Filterer.__init__(self)
        self.name = name
        self.level = _checkLevel(level)
        self.parent = None
        self.propagate = True
        self.handlers = []
        self.disabled = False
        self._cache = {}

    def setLevel(self, level):
        """
        Set the logging level of this logger.  level must be an int or a str.
        """
        self.level = _checkLevel(level)
        self.manager._clear_cache()

    def debug(self, msg, *args, **kwargs):
        """
        Log 'msg % args' with severity 'DEBUG'.

        To pass exception information, use the keyword argument exc_info with
        a true value, e.g.

        logger.debug("Houston, we have a %s", "thorny problem", exc_info=1)
        """
        if self.isEnabledFor(DEBUG):
            self._log(DEBUG, msg, args, **kwargs)

    def info(self, msg, *args, **kwargs):
        """
        Log 'msg % args' with severity 'INFO'.

        To pass exception information, use the keyword argument exc_info with
        a true value, e.g.

        logger.info("Houston, we have a %s", "interesting problem", exc_info=1)
        """
        if self.isEnabledFor(INFO):
            self._log(INFO, msg, args, **kwargs)

    def warning(self, msg, *args, **kwargs):
        """
        Log 'msg % args' with severity 'WARNING'.

        To pass exception information, use the keyword argument exc_info with
        a true value, e.g.

        logger.warning("Houston, we have a %s", "bit of a problem", exc_info=1)
        """
        if self.isEnabledFor(WARNING):
            self._log(WARNING, msg, args, **kwargs)

    def warn(self, msg, *args, **kwargs):
        warnings.warn("The 'warn' method is deprecated, "
            "use 'warning' instead", DeprecationWarning, 2)
        self.warning(msg, *args, **kwargs)

    def error(self, msg, *args, **kwargs):
        """
        Log 'msg % args' with severity 'ERROR'.

        To pass exception information, use the keyword argument exc_info with
        a true value, e.g.

        logger.error("Houston, we have a %s", "major problem", exc_info=1)
        """
        if self.isEnabledFor(ERROR):
            self._log(ERROR, msg, args, **kwargs)

    def exception(self, msg, *args, exc_info=True, **kwargs):
        """
        Convenience method for logging an ERROR with exception information.
        """
        self.error(msg, *args, exc_info=exc_info, **kwargs)

    def critical(self, msg, *args, **kwargs):
        """
        Log 'msg % args' with severity 'CRITICAL'.

        To pass exception information, use the keyword argument exc_info with
        a true value, e.g.

        logger.critical("Houston, we have a %s", "major disaster", exc_info=1)
        """
        if self.isEnabledFor(CRITICAL):
            self._log(CRITICAL, msg, args, **kwargs)

    fatal = critical

    def log(self, level, msg, *args, **kwargs):
        """
        Log 'msg % args' with the integer severity 'level'.

        To pass exception information, use the keyword argument exc_info with
        a true value, e.g.

        logger.log(level, "We have a %s", "mysterious problem", exc_info=1)
        """
        if not isinstance(level, int):
            if raiseExceptions:
                raise TypeError("level must be an integer")
            else:
                return
        if self.isEnabledFor(level):
            self._log(level, msg, args, **kwargs)

    def findCaller(self, stack_info=False):
        """
        Find the stack frame of the caller so that we can note the source
        file name, line number and function name.
        """
        f = currentframe()
        #On some versions of IronPython, currentframe() returns None if
        #IronPython isn't run with -X:Frames.
        if f is not None:
            f = f.f_back
        rv = "(unknown file)", 0, "(unknown function)", None
        while hasattr(f, "f_code"):
            co = f.f_code
            filename = os.path.normcase(co.co_filename)
            if filename == _srcfile:
                f = f.f_back
                continue
            sinfo = None
            if stack_info:
                sio = io.StringIO()
                sio.write('Stack (most recent call last):\n')
                traceback.print_stack(f, file=sio)
                sinfo = sio.getvalue()
                if sinfo[-1] == '\n':
                    sinfo = sinfo[:-1]
                sio.close()
            rv = (co.co_filename, f.f_lineno, co.co_name, sinfo)
            break
        return rv

    def makeRecord(self, name, level, fn, lno, msg, args, exc_info,
                   func=None, extra=None, sinfo=None):
        """
        A factory method which can be overridden in subclasses to create
        specialized LogRecords.
        """
        rv = _logRecordFactory(name, level, fn, lno, msg, args, exc_info, func,
                             sinfo)
        if extra is not None:
            for key in extra:
                if (key in ["message", "asctime"]) or (key in rv.__dict__):
                    raise KeyError("Attempt to overwrite %r in LogRecord" % key)
                rv.__dict__[key] = extra[key]
        return rv

    def _log(self, level, msg, args, exc_info=None, extra=None, stack_info=False):
        """
        Low-level logging routine which creates a LogRecord and then calls
        all the handlers of this logger to handle the record.
        """
        sinfo = None
        if _srcfile:
            #IronPython doesn't track Python frames, so findCaller raises an
            #exception on some versions of IronPython. We trap it here so that
            #IronPython can use logging.
            try:
                fn, lno, func, sinfo = self.findCaller(stack_info)
            except ValueError: # pragma: no cover
                fn, lno, func = "(unknown file)", 0, "(unknown function)"
        else: # pragma: no cover
            fn, lno, func = "(unknown file)", 0, "(unknown function)"
        if exc_info:
            if isinstance(exc_info, BaseException):
                exc_info = (type(exc_info), exc_info, exc_info.__traceback__)
            elif not isinstance(exc_info, tuple):
                exc_info = sys.exc_info()
        record = self.makeRecord(self.name, level, fn, lno, msg, args,
                                 exc_info, func, extra, sinfo)
        self.handle(record)

    def handle(self, record):
        """
        Call the handlers for the specified record.

        This method is used for unpickled records received from a socket, as
        well as those created locally. Logger-level filtering is applied.
        """
        if (not self.disabled) and self.filter(record):
            self.callHandlers(record)

    def addHandler(self, hdlr):
        """
        Add the specified handler to this logger.
        """
        _acquireLock()
        try:
            if not (hdlr in self.handlers):
                self.handlers.append(hdlr)
        finally:
            _releaseLock()

    def removeHandler(self, hdlr):
        """
        Remove the specified handler from this logger.
        """
        _acquireLock()
        try:
            if hdlr in self.handlers:
                self.handlers.remove(hdlr)
        finally:
            _releaseLock()

    def hasHandlers(self):
        """
        See if this logger has any handlers configured.

        Loop through all handlers for this logger and its parents in the
        logger hierarchy. Return True if a handler was found, else False.
        Stop searching up the hierarchy whenever a logger with the "propagate"
        attribute set to zero is found - that will be the last logger which
        is checked for the existence of handlers.
        """
        c = self
        rv = False
        while c:
            if c.handlers:
                rv = True
                break
            if not c.propagate:
                break
            else:
                c = c.parent
        return rv

    def callHandlers(self, record):
        """
        Pass a record to all relevant handlers.

        Loop through all handlers for this logger and its parents in the
        logger hierarchy. If no handler was found, output a one-off error
        message to sys.stderr. Stop searching up the hierarchy whenever a
        logger with the "propagate" attribute set to zero is found - that
        will be the last logger whose handlers are called.
        """
        c = self
        found = 0
        while c:
            for hdlr in c.handlers:
                found = found + 1
                if record.levelno >= hdlr.level:
                    hdlr.handle(record)
            if not c.propagate:
                c = None    #break out
            else:
                c = c.parent
        if (found == 0):
            if lastResort:
                if record.levelno >= lastResort.level:
                    lastResort.handle(record)
            elif raiseExceptions and not self.manager.emittedNoHandlerWarning:
                sys.stderr.write("No handlers could be found for logger"
                                 " \"%s\"\n" % self.name)
                self.manager.emittedNoHandlerWarning = True

    def getEffectiveLevel(self):
        """
        Get the effective level for this logger.

        Loop through this logger and its parents in the logger hierarchy,
        looking for a non-zero logging level. Return the first one found.
        """
        logger = self
        while logger:
            if logger.level:
                return logger.level
            logger = logger.parent
        return NOTSET

    def isEnabledFor(self, level):
        """
        Is this logger enabled for level 'level'?
        """
        try:
            return self._cache[level]
        except KeyError:
            _acquireLock()
            if self.manager.disable >= level:
                is_enabled = self._cache[level] = False
            else:
                is_enabled = self._cache[level] = level >= self.getEffectiveLevel()
            _releaseLock()

            return is_enabled

    def getChild(self, suffix):
        """
        Get a logger which is a descendant to this one.

        This is a convenience method, such that

        logging.getLogger('abc').getChild('def.ghi')

        is the same as

        logging.getLogger('abc.def.ghi')

        It's useful, for example, when the parent logger is named using
        __name__ rather than a literal string.
        """
        if self.root is not self:
            suffix = '.'.join((self.name, suffix))
        return self.manager.getLogger(suffix)

    def __repr__(self):
        level = getLevelName(self.getEffectiveLevel())
        return '<%s %s (%s)>' % (self.__class__.__name__, self.name, level)

    def __reduce__(self):
        # In general, only the root logger will not be accessible via its name.
        # However, the root logger's class has its own __reduce__ method.
        if getLogger(self.name) is not self:
            import pickle
            raise pickle.PicklingError('logger cannot be pickled')
        return getLogger, (self.name,)


class RootLogger(Logger):
    """
    A root logger is not that different to any other logger, except that
    it must have a logging level and there is only one instance of it in
    the hierarchy.
    """
    def __init__(self, level):
        """
        Initialize the logger with the name "root".
        """
        Logger.__init__(self, "root", level)

    def __reduce__(self):
        return getLogger, ()

_loggerClass = Logger

class LoggerAdapter(object):
    """
    An adapter for loggers which makes it easier to specify contextual
    information in logging output.
    """

    def __init__(self, logger, extra):
        """
        Initialize the adapter with a logger and a dict-like object which
        provides contextual information. This constructor signature allows
        easy stacking of LoggerAdapters, if so desired.

        You can effectively pass keyword arguments as shown in the
        following example:

        adapter = LoggerAdapter(someLogger, dict(p1=v1, p2="v2"))
        """
        self.logger = logger
        self.extra = extra

    def process(self, msg, kwargs):
        """
        Process the logging message and keyword arguments passed in to
        a logging call to insert contextual information. You can either
        manipulate the message itself, the keyword args or both. Return
        the message and kwargs modified (or not) to suit your needs.

        Normally, you'll only need to override this one method in a
        LoggerAdapter subclass for your specific needs.
        """
        kwargs["extra"] = self.extra
        return msg, kwargs

    #
    # Boilerplate convenience methods
    #
    def debug(self, msg, *args, **kwargs):
        """
        Delegate a debug call to the underlying logger.
        """
        self.log(DEBUG, msg, *args, **kwargs)

    def info(self, msg, *args, **kwargs):
        """
        Delegate an info call to the underlying logger.
        """
        self.log(INFO, msg, *args, **kwargs)

    def warning(self, msg, *args, **kwargs):
        """
        Delegate a warning call to the underlying logger.
        """
        self.log(WARNING, msg, *args, **kwargs)

    def warn(self, msg, *args, **kwargs):
        warnings.warn("The 'warn' method is deprecated, "
            "use 'warning' instead", DeprecationWarning, 2)
        self.warning(msg, *args, **kwargs)

    def error(self, msg, *args, **kwargs):
        """
        Delegate an error call to the underlying logger.
        """
        self.log(ERROR, msg, *args, **kwargs)

    def exception(self, msg, *args, exc_info=True, **kwargs):
        """
        Delegate an exception call to the underlying logger.
        """
        self.log(ERROR, msg, *args, exc_info=exc_info, **kwargs)

    def critical(self, msg, *args, **kwargs):
        """
        Delegate a critical call to the underlying logger.
        """
        self.log(CRITICAL, msg, *args, **kwargs)

    def log(self, level, msg, *args, **kwargs):
        """
        Delegate a log call to the underlying logger, after adding
        contextual information from this adapter instance.
        """
        if self.isEnabledFor(level):
            msg, kwargs = self.process(msg, kwargs)
            self.logger.log(level, msg, *args, **kwargs)

    def isEnabledFor(self, level):
        """
        Is this logger enabled for level 'level'?
        """
        return self.logger.isEnabledFor(level)

    def setLevel(self, level):
        """
        Set the specified level on the underlying logger.
        """
        self.logger.setLevel(level)

    def getEffectiveLevel(self):
        """
        Get the effective level for the underlying logger.
        """
        return self.logger.getEffectiveLevel()

    def hasHandlers(self):
        """
        See if the underlying logger has any handlers.
        """
        return self.logger.hasHandlers()

    def _log(self, level, msg, args, exc_info=None, extra=None, stack_info=False):
        """
        Low-level log implementation, proxied to allow nested logger adapters.
        """
        return self.logger._log(
            level,
            msg,
            args,
            exc_info=exc_info,
            extra=extra,
            stack_info=stack_info,
        )

    @property
    def manager(self):
        return self.logger.manager

    @manager.setter
    def manager(self, value):
        self.logger.manager = value

    @property
    def name(self):
        return self.logger.name

    def __repr__(self):
        logger = self.logger
        level = getLevelName(logger.getEffectiveLevel())
        return '<%s %s (%s)>' % (self.__class__.__name__, logger.name, level)

root = RootLogger(WARNING)
Logger.root = root
Logger.manager = Manager(Logger.root)

#---------------------------------------------------------------------------
# Configuration classes and functions
#---------------------------------------------------------------------------

def basicConfig(**kwargs):
    """
    Do basic configuration for the logging system.

    This function does nothing if the root logger already has handlers
    configured. It is a convenience method intended for use by simple scripts
    to do one-shot configuration of the logging package.

    The default behaviour is to create a StreamHandler which writes to
    sys.stderr, set a formatter using the BASIC_FORMAT format string, and
    add the handler to the root logger.

    A number of optional keyword arguments may be specified, which can alter
    the default behaviour.

    filename  Specifies that a FileHandler be created, using the specified
              filename, rather than a StreamHandler.
    filemode  Specifies the mode to open the file, if filename is specified
              (if filemode is unspecified, it defaults to 'a').
    format    Use the specified format string for the handler.
    datefmt   Use the specified date/time format.
    style     If a format string is specified, use this to specify the
              type of format string (possible values '%', '{', '$', for
              %-formatting, :meth:`str.format` and :class:`string.Template`
              - defaults to '%').
    level     Set the root logger level to the specified level.
    stream    Use the specified stream to initialize the StreamHandler. Note
              that this argument is incompatible with 'filename' - if both
              are present, 'stream' is ignored.
    handlers  If specified, this should be an iterable of already created
              handlers, which will be added to the root handler. Any handler
              in the list which does not have a formatter assigned will be
              assigned the formatter created in this function.

    Note that you could specify a stream created using open(filename, mode)
    rather than passing the filename and mode in. However, it should be
    remembered that StreamHandler does not close its stream (since it may be
    using sys.stdout or sys.stderr), whereas FileHandler closes its stream
    when the handler is closed.

    .. versionchanged:: 3.2
       Added the ``style`` parameter.

    .. versionchanged:: 3.3
       Added the ``handlers`` parameter. A ``ValueError`` is now thrown for
       incompatible arguments (e.g. ``handlers`` specified together with
       ``filename``/``filemode``, or ``filename``/``filemode`` specified
       together with ``stream``, or ``handlers`` specified together with
       ``stream``.
    """
    # Add thread safety in case someone mistakenly calls
    # basicConfig() from multiple threads
    _acquireLock()
    try:
        if len(root.handlers) == 0:
            handlers = kwargs.pop("handlers", None)
            if handlers is None:
                if "stream" in kwargs and "filename" in kwargs:
                    raise ValueError("'stream' and 'filename' should not be "
                                     "specified together")
            else:
                if "stream" in kwargs or "filename" in kwargs:
                    raise ValueError("'stream' or 'filename' should not be "
                                     "specified together with 'handlers'")
            if handlers is None:
                filename = kwargs.pop("filename", None)
                mode = kwargs.pop("filemode", 'a')
                if filename:
                    h = FileHandler(filename, mode)
                else:
                    stream = kwargs.pop("stream", None)
                    h = StreamHandler(stream)
                handlers = [h]
            dfs = kwargs.pop("datefmt", None)
            style = kwargs.pop("style", '%')
            if style not in _STYLES:
                raise ValueError('Style must be one of: %s' % ','.join(
                                 _STYLES.keys()))
            fs = kwargs.pop("format", _STYLES[style][1])
            fmt = Formatter(fs, dfs, style)
            for h in handlers:
                if h.formatter is None:
                    h.setFormatter(fmt)
                root.addHandler(h)
            level = kwargs.pop("level", None)
            if level is not None:
                root.setLevel(level)
            if kwargs:
                keys = ', '.join(kwargs.keys())
                raise ValueError('Unrecognised argument(s): %s' % keys)
    finally:
        _releaseLock()

#---------------------------------------------------------------------------
# Utility functions at module level.
# Basically delegate everything to the root logger.
#---------------------------------------------------------------------------

def getLogger(name=None):
    """
    Return a logger with the specified name, creating it if necessary.

    If no name is specified, return the root logger.
    """
    if name:
        return Logger.manager.getLogger(name)
    else:
        return root

def critical(msg, *args, **kwargs):
    """
    Log a message with severity 'CRITICAL' on the root logger. If the logger
    has no handlers, call basicConfig() to add a console handler with a
    pre-defined format.
    """
    if len(root.handlers) == 0:
        basicConfig()
    root.critical(msg, *args, **kwargs)

fatal = critical

def error(msg, *args, **kwargs):
    """
    Log a message with severity 'ERROR' on the root logger. If the logger has
    no handlers, call basicConfig() to add a console handler with a pre-defined
    format.
    """
    if len(root.handlers) == 0:
        basicConfig()
    root.error(msg, *args, **kwargs)

def exception(msg, *args, exc_info=True, **kwargs):
    """
    Log a message with severity 'ERROR' on the root logger, with exception
    information. If the logger has no handlers, basicConfig() is called to add
    a console handler with a pre-defined format.
    """
    error(msg, *args, exc_info=exc_info, **kwargs)

def warning(msg, *args, **kwargs):
    """
    Log a message with severity 'WARNING' on the root logger. If the logger has
    no handlers, call basicConfig() to add a console handler with a pre-defined
    format.
    """
    if len(root.handlers) == 0:
        basicConfig()
    root.warning(msg, *args, **kwargs)

def warn(msg, *args, **kwargs):
    warnings.warn("The 'warn' function is deprecated, "
        "use 'warning' instead", DeprecationWarning, 2)
    warning(msg, *args, **kwargs)

def info(msg, *args, **kwargs):
    """
    Log a message with severity 'INFO' on the root logger. If the logger has
    no handlers, call basicConfig() to add a console handler with a pre-defined
    format.
    """
    if len(root.handlers) == 0:
        basicConfig()
    root.info(msg, *args, **kwargs)

def debug(msg, *args, **kwargs):
    """
    Log a message with severity 'DEBUG' on the root logger. If the logger has
    no handlers, call basicConfig() to add a console handler with a pre-defined
    format.
    """
    if len(root.handlers) == 0:
        basicConfig()
    root.debug(msg, *args, **kwargs)

def log(level, msg, *args, **kwargs):
    """
    Log 'msg % args' with the integer severity 'level' on the root logger. If
    the logger has no handlers, call basicConfig() to add a console handler
    with a pre-defined format.
    """
    if len(root.handlers) == 0:
        basicConfig()
    root.log(level, msg, *args, **kwargs)

def disable(level=CRITICAL):
    """
    Disable all logging calls of severity 'level' and below.
    """
    root.manager.disable = level
    root.manager._clear_cache()

def shutdown(handlerList=_handlerList):
    """
    Perform any cleanup actions in the logging system (e.g. flushing
    buffers).

    Should be called at application exit.
    """
    for wr in reversed(handlerList[:]):
        #errors might occur, for example, if files are locked
        #we just ignore them if raiseExceptions is not set
        try:
            h = wr()
            if h:
                try:
                    h.acquire()
                    h.flush()
                    h.close()
                except (OSError, ValueError):
                    # Ignore errors which might be caused
                    # because handlers have been closed but
                    # references to them are still around at
                    # application exit.
                    pass
                finally:
                    h.release()
        except: # ignore everything, as we're shutting down
            if raiseExceptions:
                raise
            #else, swallow

#Let's try and shutdown automatically on application exit...
import atexit
atexit.register(shutdown)

# Null handler

class NullHandler(Handler):
    """
    This handler does nothing. It's intended to be used to avoid the
    "No handlers could be found for logger XXX" one-off warning. This is
    important for library code, which may contain code to log events. If a user
    of the library does not configure logging, the one-off warning might be
    produced; to avoid this, the library developer simply needs to instantiate
    a NullHandler and add it to the top-level logger of the library module or
    package.
    """
    def handle(self, record):
        """Stub."""

    def emit(self, record):
        """Stub."""

    def createLock(self):
        self.lock = None

# Warnings integration

_warnings_showwarning = None

def _showwarning(message, category, filename, lineno, file=None, line=None):
    """
    Implementation of showwarnings which redirects to logging, which will first
    check to see if the file parameter is None. If a file is specified, it will
    delegate to the original warnings implementation of showwarning. Otherwise,
    it will call warnings.formatwarning and will log the resulting string to a
    warnings logger named "py.warnings" with level logging.WARNING.
    """
    if file is not None:
        if _warnings_showwarning is not None:
            _warnings_showwarning(message, category, filename, lineno, file, line)
    else:
        s = warnings.formatwarning(message, category, filename, lineno, line)
        logger = getLogger("py.warnings")
        if not logger.handlers:
            logger.addHandler(NullHandler())
        logger.warning("%s", s)

def captureWarnings(capture):
    """
    If capture is true, redirect all warnings to the logging package.
    If capture is False, ensure that warnings are not redirected to logging
    but to their original destinations.
    """
    global _warnings_showwarning
    if capture:
        if _warnings_showwarning is None:
            _warnings_showwarning = warnings.showwarning
            warnings.showwarning = _showwarning
    else:
        if _warnings_showwarning is not None:
            warnings.showwarning = _warnings_showwarning
            _warnings_showwarning = None
================================================ FILE: docs/html/_sources/api.rst.txt ================================================ .. _api: eventkit ======== Release |release|. .. toctree:: :maxdepth: 3 :caption: Modules: Event ----- .. autoclass:: eventkit.event.Event :members: .. automethod:: __await__ .. automethod:: __aiter__ Op -- .. automodule:: eventkit.ops.op Create ------ .. automodule:: eventkit.ops.create Select ------ .. automodule:: eventkit.ops.select Transform --------- .. automodule:: eventkit.ops.transform Aggregate --------- .. automodule:: eventkit.ops.aggregate Combine ------- .. automodule:: eventkit.ops.combine Timing ------ .. automodule:: eventkit.ops.timing Array ----- .. automodule:: eventkit.ops.array Misc ---- .. automodule:: eventkit.ops.misc Util ---- .. automodule:: eventkit.util ================================================ FILE: docs/html/_sources/index.rst.txt ================================================ .. include:: ../README.rst .. toctree:: :maxdepth: 3 api ================================================ FILE: docs/html/_static/_sphinx_javascript_frameworks_compat.js ================================================ /* * _sphinx_javascript_frameworks_compat.js * ~~~~~~~~~~ * * Compatability shim for jQuery and underscores.js. * * WILL BE REMOVED IN Sphinx 6.0 * xref RemovedInSphinx60Warning * */ /** * select a different prefix for underscore */ $u = _.noConflict(); /** * small helper function to urldecode strings * * See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/decodeURIComponent#Decoding_query_parameters_from_a_URL */ jQuery.urldecode = function(x) { if (!x) { return x } return decodeURIComponent(x.replace(/\+/g, ' ')); }; /** * small helper function to urlencode strings */ jQuery.urlencode = encodeURIComponent; /** * This function returns the parsed url parameters of the * current request. Multiple values per key are supported, * it will always return arrays of strings for the value parts. */ jQuery.getQueryParameters = function(s) { if (typeof s === 'undefined') s = document.location.search; var parts = s.substr(s.indexOf('?') + 1).split('&'); var result = {}; for (var i = 0; i < parts.length; i++) { var tmp = parts[i].split('=', 2); var key = jQuery.urldecode(tmp[0]); var value = jQuery.urldecode(tmp[1]); if (key in result) result[key].push(value); else result[key] = [value]; } return result; }; /** * highlight a given string on a jquery object by wrapping it in * span elements with the given class name. */ jQuery.fn.highlightText = function(text, className) { function highlight(node, addItems) { if (node.nodeType === 3) { var val = node.nodeValue; var pos = val.toLowerCase().indexOf(text); if (pos >= 0 && !jQuery(node.parentNode).hasClass(className) && !jQuery(node.parentNode).hasClass("nohighlight")) { var span; var isInSVG = jQuery(node).closest("body, svg, foreignObject").is("svg"); if (isInSVG) { span = document.createElementNS("http://www.w3.org/2000/svg", "tspan"); } else { span = document.createElement("span"); span.className = className; } span.appendChild(document.createTextNode(val.substr(pos, text.length))); node.parentNode.insertBefore(span, node.parentNode.insertBefore( document.createTextNode(val.substr(pos + text.length)), node.nextSibling)); node.nodeValue = val.substr(0, pos); if (isInSVG) { var rect = document.createElementNS("http://www.w3.org/2000/svg", "rect"); var bbox = node.parentElement.getBBox(); rect.x.baseVal.value = bbox.x; rect.y.baseVal.value = bbox.y; rect.width.baseVal.value = bbox.width; rect.height.baseVal.value = bbox.height; rect.setAttribute('class', className); addItems.push({ "parent": node.parentNode, "target": rect}); } } } else if (!jQuery(node).is("button, select, textarea")) { jQuery.each(node.childNodes, function() { highlight(this, addItems); }); } } var addItems = []; var result = this.each(function() { highlight(this, addItems); }); for (var i = 0; i < addItems.length; ++i) { jQuery(addItems[i].parent).before(addItems[i].target); } return result; }; /* * backward compatibility for jQuery.browser * This will be supported until firefox bug is fixed. */ if (!jQuery.browser) { jQuery.uaMatch = function(ua) { ua = ua.toLowerCase(); var match = /(chrome)[ \/]([\w.]+)/.exec(ua) || /(webkit)[ \/]([\w.]+)/.exec(ua) || /(opera)(?:.*version|)[ \/]([\w.]+)/.exec(ua) || /(msie) ([\w.]+)/.exec(ua) || ua.indexOf("compatible") < 0 && /(mozilla)(?:.*? rv:([\w.]+)|)/.exec(ua) || []; return { browser: match[ 1 ] || "", version: match[ 2 ] || "0" }; }; jQuery.browser = {}; jQuery.browser[jQuery.uaMatch(navigator.userAgent).browser] = true; } ================================================ FILE: docs/html/_static/basic.css ================================================ /* * basic.css * ~~~~~~~~~ * * Sphinx stylesheet -- basic theme. * * :copyright: Copyright 2007-2022 by the Sphinx team, see AUTHORS. * :license: BSD, see LICENSE for details. * */ /* -- main layout ----------------------------------------------------------- */ div.clearer { clear: both; } div.section::after { display: block; content: ''; clear: left; } /* -- relbar ---------------------------------------------------------------- */ div.related { width: 100%; font-size: 90%; } div.related h3 { display: none; } div.related ul { margin: 0; padding: 0 0 0 10px; list-style: none; } div.related li { display: inline; } div.related li.right { float: right; margin-right: 5px; } /* -- sidebar --------------------------------------------------------------- */ div.sphinxsidebarwrapper { padding: 10px 5px 0 10px; } div.sphinxsidebar { float: left; width: 230px; margin-left: -100%; font-size: 90%; word-wrap: break-word; overflow-wrap : break-word; } div.sphinxsidebar ul { list-style: none; } div.sphinxsidebar ul ul, div.sphinxsidebar ul.want-points { margin-left: 20px; list-style: square; } div.sphinxsidebar ul ul { margin-top: 0; margin-bottom: 0; } div.sphinxsidebar form { margin-top: 10px; } div.sphinxsidebar input { border: 1px solid #98dbcc; font-family: sans-serif; font-size: 1em; } div.sphinxsidebar #searchbox form.search { overflow: hidden; } div.sphinxsidebar #searchbox input[type="text"] { float: left; width: 80%; padding: 0.25em; box-sizing: border-box; } div.sphinxsidebar #searchbox input[type="submit"] { float: left; width: 20%; border-left: none; padding: 0.25em; box-sizing: border-box; } img { border: 0; max-width: 100%; } /* -- search page ----------------------------------------------------------- */ ul.search { margin: 10px 0 0 20px; padding: 0; } ul.search li { padding: 5px 0 5px 20px; background-image: url(file.png); background-repeat: no-repeat; background-position: 0 7px; } ul.search li a { font-weight: bold; } ul.search li p.context { color: #888; margin: 2px 0 0 30px; text-align: left; } ul.keywordmatches li.goodmatch a { font-weight: bold; } /* -- index page ------------------------------------------------------------ */ table.contentstable { width: 90%; margin-left: auto; margin-right: auto; } table.contentstable p.biglink { line-height: 150%; } a.biglink { font-size: 1.3em; } span.linkdescr { font-style: italic; padding-top: 5px; font-size: 90%; } /* -- general index --------------------------------------------------------- */ table.indextable { width: 100%; } table.indextable td { text-align: left; vertical-align: top; } table.indextable ul { margin-top: 0; margin-bottom: 0; list-style-type: none; } table.indextable > tbody > tr > td > ul { padding-left: 0em; } table.indextable tr.pcap { height: 10px; } table.indextable tr.cap { margin-top: 10px; background-color: #f2f2f2; } img.toggler { margin-right: 3px; margin-top: 3px; cursor: pointer; } div.modindex-jumpbox { border-top: 1px solid #ddd; border-bottom: 1px solid #ddd; margin: 1em 0 1em 0; padding: 0.4em; } div.genindex-jumpbox { border-top: 1px solid #ddd; border-bottom: 1px solid #ddd; margin: 1em 0 1em 0; padding: 0.4em; } /* -- domain module index --------------------------------------------------- */ table.modindextable td { padding: 2px; border-collapse: collapse; } /* -- general body styles --------------------------------------------------- */ div.body { min-width: 360px; max-width: 800px; } div.body p, div.body dd, div.body li, div.body blockquote { -moz-hyphens: auto; -ms-hyphens: auto; -webkit-hyphens: auto; hyphens: auto; } a.headerlink { visibility: hidden; } h1:hover > a.headerlink, h2:hover > a.headerlink, h3:hover > a.headerlink, h4:hover > a.headerlink, h5:hover > a.headerlink, h6:hover > a.headerlink, dt:hover > a.headerlink, caption:hover > a.headerlink, p.caption:hover > a.headerlink, div.code-block-caption:hover > a.headerlink { visibility: visible; } div.body p.caption { text-align: inherit; } div.body td { text-align: left; } .first { margin-top: 0 !important; } p.rubric { margin-top: 30px; font-weight: bold; } img.align-left, figure.align-left, .figure.align-left, object.align-left { clear: left; float: left; margin-right: 1em; } img.align-right, figure.align-right, .figure.align-right, object.align-right { clear: right; float: right; margin-left: 1em; } img.align-center, figure.align-center, .figure.align-center, object.align-center { display: block; margin-left: auto; margin-right: auto; } img.align-default, figure.align-default, .figure.align-default { display: block; margin-left: auto; margin-right: auto; } .align-left { text-align: left; } .align-center { text-align: center; } .align-default { text-align: center; } .align-right { text-align: right; } /* -- sidebars -------------------------------------------------------------- */ div.sidebar, aside.sidebar { margin: 0 0 0.5em 1em; border: 1px solid #ddb; padding: 7px; background-color: #ffe; width: 40%; float: right; clear: right; overflow-x: auto; } p.sidebar-title { font-weight: bold; } nav.contents, aside.topic, div.admonition, div.topic, blockquote { clear: left; } /* -- topics ---------------------------------------------------------------- */ nav.contents, aside.topic, div.topic { border: 1px solid #ccc; padding: 7px; margin: 10px 0 10px 0; } p.topic-title { font-size: 1.1em; font-weight: bold; margin-top: 10px; } /* -- admonitions ----------------------------------------------------------- */ div.admonition { margin-top: 10px; margin-bottom: 10px; padding: 7px; } div.admonition dt { font-weight: bold; } p.admonition-title { margin: 0px 10px 5px 0px; font-weight: bold; } div.body p.centered { text-align: center; margin-top: 25px; } /* -- content of sidebars/topics/admonitions -------------------------------- */ div.sidebar > :last-child, aside.sidebar > :last-child, nav.contents > :last-child, aside.topic > :last-child, div.topic > :last-child, div.admonition > :last-child { margin-bottom: 0; } div.sidebar::after, aside.sidebar::after, nav.contents::after, aside.topic::after, div.topic::after, div.admonition::after, blockquote::after { display: block; content: ''; clear: both; } /* -- tables ---------------------------------------------------------------- */ table.docutils { margin-top: 10px; margin-bottom: 10px; border: 0; border-collapse: collapse; } table.align-center { margin-left: auto; margin-right: auto; } table.align-default { margin-left: auto; margin-right: auto; } table caption span.caption-number { font-style: italic; } table caption span.caption-text { } table.docutils td, table.docutils th { padding: 1px 8px 1px 5px; border-top: 0; border-left: 0; border-right: 0; border-bottom: 1px solid #aaa; } th { text-align: left; padding-right: 5px; } table.citation { border-left: solid 1px gray; margin-left: 1px; } table.citation td { border-bottom: none; } th > :first-child, td > :first-child { margin-top: 0px; } th > :last-child, td > :last-child { margin-bottom: 0px; } /* -- figures --------------------------------------------------------------- */ div.figure, figure { margin: 0.5em; padding: 0.5em; } div.figure p.caption, figcaption { padding: 0.3em; } div.figure p.caption span.caption-number, figcaption span.caption-number { font-style: italic; } div.figure p.caption span.caption-text, figcaption span.caption-text { } /* -- field list styles ----------------------------------------------------- */ table.field-list td, table.field-list th { border: 0 !important; } .field-list ul { margin: 0; padding-left: 1em; } .field-list p { margin: 0; } .field-name { -moz-hyphens: manual; -ms-hyphens: manual; -webkit-hyphens: manual; hyphens: manual; } /* -- hlist styles ---------------------------------------------------------- */ table.hlist { margin: 1em 0; } table.hlist td { vertical-align: top; } /* -- object description styles --------------------------------------------- */ .sig { font-family: 'Consolas', 'Menlo', 'DejaVu Sans Mono', 'Bitstream Vera Sans Mono', monospace; } .sig-name, code.descname { background-color: transparent; font-weight: bold; } .sig-name { font-size: 1.1em; } code.descname { font-size: 1.2em; } .sig-prename, code.descclassname { background-color: transparent; } .optional { font-size: 1.3em; } .sig-paren { font-size: larger; } .sig-param.n { font-style: italic; } /* C++ specific styling */ .sig-inline.c-texpr, .sig-inline.cpp-texpr { font-family: unset; } .sig.c .k, .sig.c .kt, .sig.cpp .k, .sig.cpp .kt { color: #0033B3; } .sig.c .m, .sig.cpp .m { color: #1750EB; } .sig.c .s, .sig.c .sc, .sig.cpp .s, .sig.cpp .sc { color: #067D17; } /* -- other body styles ----------------------------------------------------- */ ol.arabic { list-style: decimal; } ol.loweralpha { list-style: lower-alpha; } ol.upperalpha { list-style: upper-alpha; } ol.lowerroman { list-style: lower-roman; } ol.upperroman { list-style: upper-roman; } :not(li) > ol > li:first-child > :first-child, :not(li) > ul > li:first-child > :first-child { margin-top: 0px; } :not(li) > ol > li:last-child > :last-child, :not(li) > ul > li:last-child > :last-child { margin-bottom: 0px; } ol.simple ol p, ol.simple ul p, ul.simple ol p, ul.simple ul p { margin-top: 0; } ol.simple > li:not(:first-child) > p, ul.simple > li:not(:first-child) > p { margin-top: 0; } ol.simple p, ul.simple p { margin-bottom: 0; } aside.footnote > span, div.citation > span { float: left; } aside.footnote > span:last-of-type, div.citation > span:last-of-type { padding-right: 0.5em; } aside.footnote > p { margin-left: 2em; } div.citation > p { margin-left: 4em; } aside.footnote > p:last-of-type, div.citation > p:last-of-type { margin-bottom: 0em; } aside.footnote > p:last-of-type:after, div.citation > p:last-of-type:after { content: ""; clear: both; } dl.field-list { display: grid; grid-template-columns: fit-content(30%) auto; } dl.field-list > dt { font-weight: bold; word-break: break-word; padding-left: 0.5em; padding-right: 5px; } dl.field-list > dd { padding-left: 0.5em; margin-top: 0em; margin-left: 0em; margin-bottom: 0em; } dl { margin-bottom: 15px; } dd > :first-child { margin-top: 0px; } dd ul, dd table { margin-bottom: 10px; } dd { margin-top: 3px; margin-bottom: 10px; margin-left: 30px; } dl > dd:last-child, dl > dd:last-child > :last-child { margin-bottom: 0; } dt:target, span.highlighted { background-color: #fbe54e; } rect.highlighted { fill: #fbe54e; } dl.glossary dt { font-weight: bold; font-size: 1.1em; } .versionmodified { font-style: italic; } .system-message { background-color: #fda; padding: 5px; border: 3px solid red; } .footnote:target { background-color: #ffa; } .line-block { display: block; margin-top: 1em; margin-bottom: 1em; } .line-block .line-block { margin-top: 0; margin-bottom: 0; margin-left: 1.5em; } .guilabel, .menuselection { font-family: sans-serif; } .accelerator { text-decoration: underline; } .classifier { font-style: oblique; } .classifier:before { font-style: normal; margin: 0 0.5em; content: ":"; display: inline-block; } abbr, acronym { border-bottom: dotted 1px; cursor: help; } /* -- code displays --------------------------------------------------------- */ pre { overflow: auto; overflow-y: hidden; /* fixes display issues on Chrome browsers */ } pre, div[class*="highlight-"] { clear: both; } span.pre { -moz-hyphens: none; -ms-hyphens: none; -webkit-hyphens: none; hyphens: none; white-space: nowrap; } div[class*="highlight-"] { margin: 1em 0; } td.linenos pre { border: 0; background-color: transparent; color: #aaa; } table.highlighttable { display: block; } table.highlighttable tbody { display: block; } table.highlighttable tr { display: flex; } table.highlighttable td { margin: 0; padding: 0; } table.highlighttable td.linenos { padding-right: 0.5em; } table.highlighttable td.code { flex: 1; overflow: hidden; } .highlight .hll { display: block; } div.highlight pre, table.highlighttable pre { margin: 0; } div.code-block-caption + div { margin-top: 0; } div.code-block-caption { margin-top: 1em; padding: 2px 5px; font-size: small; } div.code-block-caption code { background-color: transparent; } table.highlighttable td.linenos, span.linenos, div.highlight span.gp { /* gp: Generic.Prompt */ user-select: none; -webkit-user-select: text; /* Safari fallback only */ -webkit-user-select: none; /* Chrome/Safari */ -moz-user-select: none; /* Firefox */ -ms-user-select: none; /* IE10+ */ } div.code-block-caption span.caption-number { padding: 0.1em 0.3em; font-style: italic; } div.code-block-caption span.caption-text { } div.literal-block-wrapper { margin: 1em 0; } code.xref, a code { background-color: transparent; font-weight: bold; } h1 code, h2 code, h3 code, h4 code, h5 code, h6 code { background-color: transparent; } .viewcode-link { float: right; } .viewcode-back { float: right; font-family: sans-serif; } div.viewcode-block:target { margin: -1px -10px; padding: 0 10px; } /* -- math display ---------------------------------------------------------- */ img.math { vertical-align: middle; } div.body div.math p { text-align: center; } span.eqno { float: right; } span.eqno a.headerlink { position: absolute; z-index: 1; } div.math:hover a.headerlink { visibility: visible; } /* -- printout stylesheet --------------------------------------------------- */ @media print { div.document, div.documentwrapper, div.bodywrapper { margin: 0 !important; width: 100%; } div.sphinxsidebar, div.related, div.footer, #top-link { display: none; } } ================================================ FILE: docs/html/_static/css/badge_only.css ================================================ .clearfix{*zoom:1}.clearfix:after,.clearfix:before{display:table;content:""}.clearfix:after{clear:both}@font-face{font-family:FontAwesome;font-style:normal;font-weight:400;src:local("FontAwesome"),url('/.sysassets/fonts/fontawesome/fontawesome-webfont.ttf') format("truetype")}.fa:before{font-family:FontAwesome;font-style:normal;font-weight:400;line-height:1}.fa:before,a .fa{text-decoration:inherit}.fa:before,a .fa,li .fa{display:inline-block}li .fa-large:before{width:1.875em}ul.fas{list-style-type:none;margin-left:2em;text-indent:-.8em}ul.fas li .fa{width:.8em}ul.fas li .fa-large:before{vertical-align:baseline}.fa-book:before,.icon-book:before{content:"\f02d"}.fa-caret-down:before,.icon-caret-down:before{content:"\f0d7"}.fa-caret-up:before,.icon-caret-up:before{content:"\f0d8"}.fa-caret-left:before,.icon-caret-left:before{content:"\f0d9"}.fa-caret-right:before,.icon-caret-right:before{content:"\f0da"}.rst-versions{position:fixed;bottom:0;left:0;width:300px;color:#fcfcfc;background:#1f1d1d;font-family:Lato,proxima-nova,Helvetica Neue,Arial,sans-serif;z-index:400}.rst-versions a{color:#2980b9;text-decoration:none}.rst-versions .rst-badge-small{display:none}.rst-versions .rst-current-version{padding:12px;background-color:#272525;display:block;text-align:right;font-size:90%;cursor:pointer;color:#27ae60}.rst-versions .rst-current-version:after{clear:both;content:"";display:block}.rst-versions .rst-current-version .fa{color:#fcfcfc}.rst-versions .rst-current-version .fa-book,.rst-versions .rst-current-version .icon-book{float:left}.rst-versions .rst-current-version.rst-out-of-date{background-color:#e74c3c;color:#fff}.rst-versions .rst-current-version.rst-active-old-version{background-color:#f1c40f;color:#000}.rst-versions.shift-up{height:auto;max-height:100%;overflow-y:scroll}.rst-versions.shift-up .rst-other-versions{display:block}.rst-versions .rst-other-versions{font-size:90%;padding:12px;color:grey;display:none}.rst-versions .rst-other-versions hr{display:block;height:1px;border:0;margin:20px 0;padding:0;border-top:1px solid #413d3d}.rst-versions .rst-other-versions dd{display:inline-block;margin:0}.rst-versions .rst-other-versions dd a{display:inline-block;padding:6px;color:#fcfcfc}.rst-versions.rst-badge{width:auto;bottom:20px;right:20px;left:auto;border:none;max-width:300px;max-height:90%}.rst-versions.rst-badge .fa-book,.rst-versions.rst-badge .icon-book{float:none;line-height:30px}.rst-versions.rst-badge.shift-up .rst-current-version{text-align:right}.rst-versions.rst-badge.shift-up .rst-current-version .fa-book,.rst-versions.rst-badge.shift-up .rst-current-version .icon-book{float:left}.rst-versions.rst-badge>.rst-current-version{width:auto;height:30px;line-height:30px;padding:0 6px;display:block;text-align:center}@media screen and (max-width:768px){.rst-versions{width:85%;display:none}.rst-versions.shift{display:block}} ================================================ FILE: docs/html/_static/css/theme.css ================================================ html{box-sizing:border-box}*,:after,:before{box-sizing:inherit}article,aside,details,figcaption,figure,footer,header,hgroup,nav,section{display:block}audio,canvas,video{display:inline-block;*display:inline;*zoom:1}[hidden],audio:not([controls]){display:none}*{-webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box}html{font-size:100%;-webkit-text-size-adjust:100%;-ms-text-size-adjust:100%}body{margin:0}a:active,a:hover{outline:0}abbr[title]{border-bottom:1px dotted}b,strong{font-weight:700}blockquote{margin:0}dfn{font-style:italic}ins{background:#ff9;text-decoration:none}ins,mark{color:#000}mark{background:#ff0;font-style:italic;font-weight:700}.rst-content code,.rst-content tt,code,kbd,pre,samp{font-family:monospace,serif;_font-family:courier new,monospace;font-size:1em}pre{white-space:pre}q{quotes:none}q:after,q:before{content:"";content:none}small{font-size:85%}sub,sup{font-size:75%;line-height:0;position:relative;vertical-align:baseline}sup{top:-.5em}sub{bottom:-.25em}dl,ol,ul{margin:0;padding:0;list-style:none;list-style-image:none}li{list-style:none}dd{margin:0}img{border:0;-ms-interpolation-mode:bicubic;vertical-align:middle;max-width:100%}svg:not(:root){overflow:hidden}figure,form{margin:0}label{cursor:pointer}button,input,select,textarea{font-size:100%;margin:0;vertical-align:baseline;*vertical-align:middle}button,input{line-height:normal}button,input[type=button],input[type=reset],input[type=submit]{cursor:pointer;-webkit-appearance:button;*overflow:visible}button[disabled],input[disabled]{cursor:default}input[type=search]{-webkit-appearance:textfield;-moz-box-sizing:content-box;-webkit-box-sizing:content-box;box-sizing:content-box}textarea{resize:vertical}table{border-collapse:collapse;border-spacing:0}td{vertical-align:top}.chromeframe{margin:.2em 0;background:#ccc;color:#000;padding:.2em 0}.ir{display:block;border:0;text-indent:-999em;overflow:hidden;background-color:transparent;background-repeat:no-repeat;text-align:left;direction:ltr;*line-height:0}.ir br{display:none}.hidden{display:none!important;visibility:hidden}.visuallyhidden{border:0;clip:rect(0 0 0 0);height:1px;margin:-1px;overflow:hidden;padding:0;position:absolute;width:1px}.visuallyhidden.focusable:active,.visuallyhidden.focusable:focus{clip:auto;height:auto;margin:0;overflow:visible;position:static;width:auto}.invisible{visibility:hidden}.relative{position:relative}big,small{font-size:100%}@media print{body,html,section{background:none!important}*{box-shadow:none!important;text-shadow:none!important;filter:none!important;-ms-filter:none!important}a,a:visited{text-decoration:underline}.ir a:after,a[href^="#"]:after,a[href^="javascript:"]:after{content:""}blockquote,pre{page-break-inside:avoid}thead{display:table-header-group}img,tr{page-break-inside:avoid}img{max-width:100%!important}@page{margin:.5cm}.rst-content .toctree-wrapper>p.caption,h2,h3,p{orphans:3;widows:3}.rst-content .toctree-wrapper>p.caption,h2,h3{page-break-after:avoid}}.btn,.fa:before,.icon:before,.rst-content .admonition,.rst-content .admonition-title:before,.rst-content .admonition-todo,.rst-content .attention,.rst-content .caution,.rst-content .code-block-caption .headerlink:before,.rst-content .danger,.rst-content .eqno .headerlink:before,.rst-content .error,.rst-content .hint,.rst-content .important,.rst-content .note,.rst-content .seealso,.rst-content .tip,.rst-content .warning,.rst-content code.download span:first-child:before,.rst-content dl dt .headerlink:before,.rst-content h1 .headerlink:before,.rst-content h2 .headerlink:before,.rst-content h3 .headerlink:before,.rst-content h4 .headerlink:before,.rst-content h5 .headerlink:before,.rst-content h6 .headerlink:before,.rst-content p.caption .headerlink:before,.rst-content p .headerlink:before,.rst-content table>caption .headerlink:before,.rst-content tt.download span:first-child:before,.wy-alert,.wy-dropdown .caret:before,.wy-inline-validate.wy-inline-validate-danger .wy-input-context:before,.wy-inline-validate.wy-inline-validate-info .wy-input-context:before,.wy-inline-validate.wy-inline-validate-success .wy-input-context:before,.wy-inline-validate.wy-inline-validate-warning .wy-input-context:before,.wy-menu-vertical li.current>a button.toctree-expand:before,.wy-menu-vertical li.on a button.toctree-expand:before,.wy-menu-vertical li button.toctree-expand:before,input[type=color],input[type=date],input[type=datetime-local],input[type=datetime],input[type=email],input[type=month],input[type=number],input[type=password],input[type=search],input[type=tel],input[type=text],input[type=time],input[type=url],input[type=week],select,textarea{-webkit-font-smoothing:antialiased}.clearfix{*zoom:1}.clearfix:after,.clearfix:before{display:table;content:""}.clearfix:after{clear:both}/*! * Font Awesome 4.7.0 by @davegandy - http://fontawesome.io - @fontawesome * License - http://fontawesome.io/license (Font: SIL OFL 1.1, CSS: MIT License) */@font-face{font-family:FontAwesome;src:local("FontAwesome"),url('/.sysassets/fonts/fontawesome/fontawesome-webfont.ttf') format("truetype");font-weight:400;font-style:normal}.fa,.icon,.rst-content .admonition-title,.rst-content .code-block-caption .headerlink,.rst-content .eqno .headerlink,.rst-content code.download span:first-child,.rst-content dl dt .headerlink,.rst-content h1 .headerlink,.rst-content h2 .headerlink,.rst-content h3 .headerlink,.rst-content h4 .headerlink,.rst-content h5 .headerlink,.rst-content h6 .headerlink,.rst-content p.caption .headerlink,.rst-content p .headerlink,.rst-content table>caption .headerlink,.rst-content tt.download span:first-child,.wy-menu-vertical li.current>a button.toctree-expand,.wy-menu-vertical li.on a button.toctree-expand,.wy-menu-vertical li button.toctree-expand{display:inline-block;font:normal normal normal 14px/1 FontAwesome;font-size:inherit;text-rendering:auto;-webkit-font-smoothing:antialiased;-moz-osx-font-smoothing:grayscale}.fa-lg{font-size:1.33333em;line-height:.75em;vertical-align:-15%}.fa-2x{font-size:2em}.fa-3x{font-size:3em}.fa-4x{font-size:4em}.fa-5x{font-size:5em}.fa-fw{width:1.28571em;text-align:center}.fa-ul{padding-left:0;margin-left:2.14286em;list-style-type:none}.fa-ul>li{position:relative}.fa-li{position:absolute;left:-2.14286em;width:2.14286em;top:.14286em;text-align:center}.fa-li.fa-lg{left:-1.85714em}.fa-border{padding:.2em .25em .15em;border:.08em solid #eee;border-radius:.1em}.fa-pull-left{float:left}.fa-pull-right{float:right}.fa-pull-left.icon,.fa.fa-pull-left,.rst-content .code-block-caption .fa-pull-left.headerlink,.rst-content .eqno .fa-pull-left.headerlink,.rst-content .fa-pull-left.admonition-title,.rst-content code.download span.fa-pull-left:first-child,.rst-content dl dt .fa-pull-left.headerlink,.rst-content h1 .fa-pull-left.headerlink,.rst-content h2 .fa-pull-left.headerlink,.rst-content h3 .fa-pull-left.headerlink,.rst-content h4 .fa-pull-left.headerlink,.rst-content h5 .fa-pull-left.headerlink,.rst-content h6 .fa-pull-left.headerlink,.rst-content p .fa-pull-left.headerlink,.rst-content table>caption .fa-pull-left.headerlink,.rst-content tt.download span.fa-pull-left:first-child,.wy-menu-vertical li.current>a button.fa-pull-left.toctree-expand,.wy-menu-vertical li.on a button.fa-pull-left.toctree-expand,.wy-menu-vertical li button.fa-pull-left.toctree-expand{margin-right:.3em}.fa-pull-right.icon,.fa.fa-pull-right,.rst-content .code-block-caption .fa-pull-right.headerlink,.rst-content .eqno .fa-pull-right.headerlink,.rst-content .fa-pull-right.admonition-title,.rst-content code.download span.fa-pull-right:first-child,.rst-content dl dt .fa-pull-right.headerlink,.rst-content h1 .fa-pull-right.headerlink,.rst-content h2 .fa-pull-right.headerlink,.rst-content h3 .fa-pull-right.headerlink,.rst-content h4 .fa-pull-right.headerlink,.rst-content h5 .fa-pull-right.headerlink,.rst-content h6 .fa-pull-right.headerlink,.rst-content p .fa-pull-right.headerlink,.rst-content table>caption .fa-pull-right.headerlink,.rst-content tt.download span.fa-pull-right:first-child,.wy-menu-vertical li.current>a button.fa-pull-right.toctree-expand,.wy-menu-vertical li.on a button.fa-pull-right.toctree-expand,.wy-menu-vertical li button.fa-pull-right.toctree-expand{margin-left:.3em}.pull-right{float:right}.pull-left{float:left}.fa.pull-left,.pull-left.icon,.rst-content .code-block-caption .pull-left.headerlink,.rst-content .eqno .pull-left.headerlink,.rst-content .pull-left.admonition-title,.rst-content code.download span.pull-left:first-child,.rst-content dl dt .pull-left.headerlink,.rst-content h1 .pull-left.headerlink,.rst-content h2 .pull-left.headerlink,.rst-content h3 .pull-left.headerlink,.rst-content h4 .pull-left.headerlink,.rst-content h5 .pull-left.headerlink,.rst-content h6 .pull-left.headerlink,.rst-content p .pull-left.headerlink,.rst-content table>caption .pull-left.headerlink,.rst-content tt.download span.pull-left:first-child,.wy-menu-vertical li.current>a button.pull-left.toctree-expand,.wy-menu-vertical li.on a button.pull-left.toctree-expand,.wy-menu-vertical li button.pull-left.toctree-expand{margin-right:.3em}.fa.pull-right,.pull-right.icon,.rst-content .code-block-caption .pull-right.headerlink,.rst-content .eqno .pull-right.headerlink,.rst-content .pull-right.admonition-title,.rst-content code.download span.pull-right:first-child,.rst-content dl dt .pull-right.headerlink,.rst-content h1 .pull-right.headerlink,.rst-content h2 .pull-right.headerlink,.rst-content h3 .pull-right.headerlink,.rst-content h4 .pull-right.headerlink,.rst-content h5 .pull-right.headerlink,.rst-content h6 .pull-right.headerlink,.rst-content p .pull-right.headerlink,.rst-content table>caption .pull-right.headerlink,.rst-content tt.download span.pull-right:first-child,.wy-menu-vertical li.current>a button.pull-right.toctree-expand,.wy-menu-vertical li.on a button.pull-right.toctree-expand,.wy-menu-vertical li button.pull-right.toctree-expand{margin-left:.3em}.fa-spin{-webkit-animation:fa-spin 2s linear infinite;animation:fa-spin 2s linear infinite}.fa-pulse{-webkit-animation:fa-spin 1s steps(8) infinite;animation:fa-spin 1s steps(8) infinite}@-webkit-keyframes fa-spin{0%{-webkit-transform:rotate(0deg);transform:rotate(0deg)}to{-webkit-transform:rotate(359deg);transform:rotate(359deg)}}@keyframes fa-spin{0%{-webkit-transform:rotate(0deg);transform:rotate(0deg)}to{-webkit-transform:rotate(359deg);transform:rotate(359deg)}}.fa-rotate-90{-ms-filter:"progid:DXImageTransform.Microsoft.BasicImage(rotation=1)";-webkit-transform:rotate(90deg);-ms-transform:rotate(90deg);transform:rotate(90deg)}.fa-rotate-180{-ms-filter:"progid:DXImageTransform.Microsoft.BasicImage(rotation=2)";-webkit-transform:rotate(180deg);-ms-transform:rotate(180deg);transform:rotate(180deg)}.fa-rotate-270{-ms-filter:"progid:DXImageTransform.Microsoft.BasicImage(rotation=3)";-webkit-transform:rotate(270deg);-ms-transform:rotate(270deg);transform:rotate(270deg)}.fa-flip-horizontal{-ms-filter:"progid:DXImageTransform.Microsoft.BasicImage(rotation=0, mirror=1)";-webkit-transform:scaleX(-1);-ms-transform:scaleX(-1);transform:scaleX(-1)}.fa-flip-vertical{-ms-filter:"progid:DXImageTransform.Microsoft.BasicImage(rotation=2, mirror=1)";-webkit-transform:scaleY(-1);-ms-transform:scaleY(-1);transform:scaleY(-1)}:root .fa-flip-horizontal,:root .fa-flip-vertical,:root .fa-rotate-90,:root .fa-rotate-180,:root .fa-rotate-270{filter:none}.fa-stack{position:relative;display:inline-block;width:2em;height:2em;line-height:2em;vertical-align:middle}.fa-stack-1x,.fa-stack-2x{position:absolute;left:0;width:100%;text-align:center}.fa-stack-1x{line-height:inherit}.fa-stack-2x{font-size:2em}.fa-inverse{color:#fff}.fa-glass:before{content:""}.fa-music:before{content:""}.fa-search:before,.icon-search:before{content:""}.fa-envelope-o:before{content:""}.fa-heart:before{content:""}.fa-star:before{content:""}.fa-star-o:before{content:""}.fa-user:before{content:""}.fa-film:before{content:""}.fa-th-large:before{content:""}.fa-th:before{content:""}.fa-th-list:before{content:""}.fa-check:before{content:""}.fa-close:before,.fa-remove:before,.fa-times:before{content:""}.fa-search-plus:before{content:""}.fa-search-minus:before{content:""}.fa-power-off:before{content:""}.fa-signal:before{content:""}.fa-cog:before,.fa-gear:before{content:""}.fa-trash-o:before{content:""}.fa-home:before,.icon-home:before{content:""}.fa-file-o:before{content:""}.fa-clock-o:before{content:""}.fa-road:before{content:""}.fa-download:before,.rst-content code.download span:first-child:before,.rst-content tt.download span:first-child:before{content:""}.fa-arrow-circle-o-down:before{content:""}.fa-arrow-circle-o-up:before{content:""}.fa-inbox:before{content:""}.fa-play-circle-o:before{content:""}.fa-repeat:before,.fa-rotate-right:before{content:""}.fa-refresh:before{content:""}.fa-list-alt:before{content:""}.fa-lock:before{content:""}.fa-flag:before{content:""}.fa-headphones:before{content:""}.fa-volume-off:before{content:""}.fa-volume-down:before{content:""}.fa-volume-up:before{content:""}.fa-qrcode:before{content:""}.fa-barcode:before{content:""}.fa-tag:before{content:""}.fa-tags:before{content:""}.fa-book:before,.icon-book:before{content:""}.fa-bookmark:before{content:""}.fa-print:before{content:""}.fa-camera:before{content:""}.fa-font:before{content:""}.fa-bold:before{content:""}.fa-italic:before{content:""}.fa-text-height:before{content:""}.fa-text-width:before{content:""}.fa-align-left:before{content:""}.fa-align-center:before{content:""}.fa-align-right:before{content:""}.fa-align-justify:before{content:""}.fa-list:before{content:""}.fa-dedent:before,.fa-outdent:before{content:""}.fa-indent:before{content:""}.fa-video-camera:before{content:""}.fa-image:before,.fa-photo:before,.fa-picture-o:before{content:""}.fa-pencil:before{content:""}.fa-map-marker:before{content:""}.fa-adjust:before{content:""}.fa-tint:before{content:""}.fa-edit:before,.fa-pencil-square-o:before{content:""}.fa-share-square-o:before{content:""}.fa-check-square-o:before{content:""}.fa-arrows:before{content:""}.fa-step-backward:before{content:""}.fa-fast-backward:before{content:""}.fa-backward:before{content:""}.fa-play:before{content:""}.fa-pause:before{content:""}.fa-stop:before{content:""}.fa-forward:before{content:""}.fa-fast-forward:before{content:""}.fa-step-forward:before{content:""}.fa-eject:before{content:""}.fa-chevron-left:before{content:""}.fa-chevron-right:before{content:""}.fa-plus-circle:before{content:""}.fa-minus-circle:before{content:""}.fa-times-circle:before,.wy-inline-validate.wy-inline-validate-danger .wy-input-context:before{content:""}.fa-check-circle:before,.wy-inline-validate.wy-inline-validate-success .wy-input-context:before{content:""}.fa-question-circle:before{content:""}.fa-info-circle:before{content:""}.fa-crosshairs:before{content:""}.fa-times-circle-o:before{content:""}.fa-check-circle-o:before{content:""}.fa-ban:before{content:""}.fa-arrow-left:before{content:""}.fa-arrow-right:before{content:""}.fa-arrow-up:before{content:""}.fa-arrow-down:before{content:""}.fa-mail-forward:before,.fa-share:before{content:""}.fa-expand:before{content:""}.fa-compress:before{content:""}.fa-plus:before{content:""}.fa-minus:before{content:""}.fa-asterisk:before{content:""}.fa-exclamation-circle:before,.rst-content .admonition-title:before,.wy-inline-validate.wy-inline-validate-info .wy-input-context:before,.wy-inline-validate.wy-inline-validate-warning .wy-input-context:before{content:""}.fa-gift:before{content:""}.fa-leaf:before{content:""}.fa-fire:before,.icon-fire:before{content:""}.fa-eye:before{content:""}.fa-eye-slash:before{content:""}.fa-exclamation-triangle:before,.fa-warning:before{content:""}.fa-plane:before{content:""}.fa-calendar:before{content:""}.fa-random:before{content:""}.fa-comment:before{content:""}.fa-magnet:before{content:""}.fa-chevron-up:before{content:""}.fa-chevron-down:before{content:""}.fa-retweet:before{content:""}.fa-shopping-cart:before{content:""}.fa-folder:before{content:""}.fa-folder-open:before{content:""}.fa-arrows-v:before{content:""}.fa-arrows-h:before{content:""}.fa-bar-chart-o:before,.fa-bar-chart:before{content:""}.fa-twitter-square:before{content:""}.fa-facebook-square:before{content:""}.fa-camera-retro:before{content:""}.fa-key:before{content:""}.fa-cogs:before,.fa-gears:before{content:""}.fa-comments:before{content:""}.fa-thumbs-o-up:before{content:""}.fa-thumbs-o-down:before{content:""}.fa-star-half:before{content:""}.fa-heart-o:before{content:""}.fa-sign-out:before{content:""}.fa-linkedin-square:before{content:""}.fa-thumb-tack:before{content:""}.fa-external-link:before{content:""}.fa-sign-in:before{content:""}.fa-trophy:before{content:""}.fa-github-square:before{content:""}.fa-upload:before{content:""}.fa-lemon-o:before{content:""}.fa-phone:before{content:""}.fa-square-o:before{content:""}.fa-bookmark-o:before{content:""}.fa-phone-square:before{content:""}.fa-twitter:before{content:""}.fa-facebook-f:before,.fa-facebook:before{content:""}.fa-github:before,.icon-github:before{content:""}.fa-unlock:before{content:""}.fa-credit-card:before{content:""}.fa-feed:before,.fa-rss:before{content:""}.fa-hdd-o:before{content:""}.fa-bullhorn:before{content:""}.fa-bell:before{content:""}.fa-certificate:before{content:""}.fa-hand-o-right:before{content:""}.fa-hand-o-left:before{content:""}.fa-hand-o-up:before{content:""}.fa-hand-o-down:before{content:""}.fa-arrow-circle-left:before,.icon-circle-arrow-left:before{content:""}.fa-arrow-circle-right:before,.icon-circle-arrow-right:before{content:""}.fa-arrow-circle-up:before{content:""}.fa-arrow-circle-down:before{content:""}.fa-globe:before{content:""}.fa-wrench:before{content:""}.fa-tasks:before{content:""}.fa-filter:before{content:""}.fa-briefcase:before{content:""}.fa-arrows-alt:before{content:""}.fa-group:before,.fa-users:before{content:""}.fa-chain:before,.fa-link:before,.icon-link:before{content:""}.fa-cloud:before{content:""}.fa-flask:before{content:""}.fa-cut:before,.fa-scissors:before{content:""}.fa-copy:before,.fa-files-o:before{content:""}.fa-paperclip:before{content:""}.fa-floppy-o:before,.fa-save:before{content:""}.fa-square:before{content:""}.fa-bars:before,.fa-navicon:before,.fa-reorder:before{content:""}.fa-list-ul:before{content:""}.fa-list-ol:before{content:""}.fa-strikethrough:before{content:""}.fa-underline:before{content:""}.fa-table:before{content:""}.fa-magic:before{content:""}.fa-truck:before{content:""}.fa-pinterest:before{content:""}.fa-pinterest-square:before{content:""}.fa-google-plus-square:before{content:""}.fa-google-plus:before{content:""}.fa-money:before{content:""}.fa-caret-down:before,.icon-caret-down:before,.wy-dropdown .caret:before{content:""}.fa-caret-up:before{content:""}.fa-caret-left:before{content:""}.fa-caret-right:before{content:""}.fa-columns:before{content:""}.fa-sort:before,.fa-unsorted:before{content:""}.fa-sort-desc:before,.fa-sort-down:before{content:""}.fa-sort-asc:before,.fa-sort-up:before{content:""}.fa-envelope:before{content:""}.fa-linkedin:before{content:""}.fa-rotate-left:before,.fa-undo:before{content:""}.fa-gavel:before,.fa-legal:before{content:""}.fa-dashboard:before,.fa-tachometer:before{content:""}.fa-comment-o:before{content:""}.fa-comments-o:before{content:""}.fa-bolt:before,.fa-flash:before{content:""}.fa-sitemap:before{content:""}.fa-umbrella:before{content:""}.fa-clipboard:before,.fa-paste:before{content:""}.fa-lightbulb-o:before{content:""}.fa-exchange:before{content:""}.fa-cloud-download:before{content:""}.fa-cloud-upload:before{content:""}.fa-user-md:before{content:""}.fa-stethoscope:before{content:""}.fa-suitcase:before{content:""}.fa-bell-o:before{content:""}.fa-coffee:before{content:""}.fa-cutlery:before{content:""}.fa-file-text-o:before{content:""}.fa-building-o:before{content:""}.fa-hospital-o:before{content:""}.fa-ambulance:before{content:""}.fa-medkit:before{content:""}.fa-fighter-jet:before{content:""}.fa-beer:before{content:""}.fa-h-square:before{content:""}.fa-plus-square:before{content:""}.fa-angle-double-left:before{content:""}.fa-angle-double-right:before{content:""}.fa-angle-double-up:before{content:""}.fa-angle-double-down:before{content:""}.fa-angle-left:before{content:""}.fa-angle-right:before{content:""}.fa-angle-up:before{content:""}.fa-angle-down:before{content:""}.fa-desktop:before{content:""}.fa-laptop:before{content:""}.fa-tablet:before{content:""}.fa-mobile-phone:before,.fa-mobile:before{content:""}.fa-circle-o:before{content:""}.fa-quote-left:before{content:""}.fa-quote-right:before{content:""}.fa-spinner:before{content:""}.fa-circle:before{content:""}.fa-mail-reply:before,.fa-reply:before{content:""}.fa-github-alt:before{content:""}.fa-folder-o:before{content:""}.fa-folder-open-o:before{content:""}.fa-smile-o:before{content:""}.fa-frown-o:before{content:""}.fa-meh-o:before{content:""}.fa-gamepad:before{content:""}.fa-keyboard-o:before{content:""}.fa-flag-o:before{content:""}.fa-flag-checkered:before{content:""}.fa-terminal:before{content:""}.fa-code:before{content:""}.fa-mail-reply-all:before,.fa-reply-all:before{content:""}.fa-star-half-empty:before,.fa-star-half-full:before,.fa-star-half-o:before{content:""}.fa-location-arrow:before{content:""}.fa-crop:before{content:""}.fa-code-fork:before{content:""}.fa-chain-broken:before,.fa-unlink:before{content:""}.fa-question:before{content:""}.fa-info:before{content:""}.fa-exclamation:before{content:""}.fa-superscript:before{content:""}.fa-subscript:before{content:""}.fa-eraser:before{content:""}.fa-puzzle-piece:before{content:""}.fa-microphone:before{content:""}.fa-microphone-slash:before{content:""}.fa-shield:before{content:""}.fa-calendar-o:before{content:""}.fa-fire-extinguisher:before{content:""}.fa-rocket:before{content:""}.fa-maxcdn:before{content:""}.fa-chevron-circle-left:before{content:""}.fa-chevron-circle-right:before{content:""}.fa-chevron-circle-up:before{content:""}.fa-chevron-circle-down:before{content:""}.fa-html5:before{content:""}.fa-css3:before{content:""}.fa-anchor:before{content:""}.fa-unlock-alt:before{content:""}.fa-bullseye:before{content:""}.fa-ellipsis-h:before{content:""}.fa-ellipsis-v:before{content:""}.fa-rss-square:before{content:""}.fa-play-circle:before{content:""}.fa-ticket:before{content:""}.fa-minus-square:before{content:""}.fa-minus-square-o:before,.wy-menu-vertical li.current>a button.toctree-expand:before,.wy-menu-vertical li.on a button.toctree-expand:before{content:""}.fa-level-up:before{content:""}.fa-level-down:before{content:""}.fa-check-square:before{content:""}.fa-pencil-square:before{content:""}.fa-external-link-square:before{content:""}.fa-share-square:before{content:""}.fa-compass:before{content:""}.fa-caret-square-o-down:before,.fa-toggle-down:before{content:""}.fa-caret-square-o-up:before,.fa-toggle-up:before{content:""}.fa-caret-square-o-right:before,.fa-toggle-right:before{content:""}.fa-eur:before,.fa-euro:before{content:""}.fa-gbp:before{content:""}.fa-dollar:before,.fa-usd:before{content:""}.fa-inr:before,.fa-rupee:before{content:""}.fa-cny:before,.fa-jpy:before,.fa-rmb:before,.fa-yen:before{content:""}.fa-rouble:before,.fa-rub:before,.fa-ruble:before{content:""}.fa-krw:before,.fa-won:before{content:""}.fa-bitcoin:before,.fa-btc:before{content:""}.fa-file:before{content:""}.fa-file-text:before{content:""}.fa-sort-alpha-asc:before{content:""}.fa-sort-alpha-desc:before{content:""}.fa-sort-amount-asc:before{content:""}.fa-sort-amount-desc:before{content:""}.fa-sort-numeric-asc:before{content:""}.fa-sort-numeric-desc:before{content:""}.fa-thumbs-up:before{content:""}.fa-thumbs-down:before{content:""}.fa-youtube-square:before{content:""}.fa-youtube:before{content:""}.fa-xing:before{content:""}.fa-xing-square:before{content:""}.fa-youtube-play:before{content:""}.fa-dropbox:before{content:""}.fa-stack-overflow:before{content:""}.fa-instagram:before{content:""}.fa-flickr:before{content:""}.fa-adn:before{content:""}.fa-bitbucket:before,.icon-bitbucket:before{content:""}.fa-bitbucket-square:before{content:""}.fa-tumblr:before{content:""}.fa-tumblr-square:before{content:""}.fa-long-arrow-down:before{content:""}.fa-long-arrow-up:before{content:""}.fa-long-arrow-left:before{content:""}.fa-long-arrow-right:before{content:""}.fa-apple:before{content:""}.fa-windows:before{content:""}.fa-android:before{content:""}.fa-linux:before{content:""}.fa-dribbble:before{content:""}.fa-skype:before{content:""}.fa-foursquare:before{content:""}.fa-trello:before{content:""}.fa-female:before{content:""}.fa-male:before{content:""}.fa-gittip:before,.fa-gratipay:before{content:""}.fa-sun-o:before{content:""}.fa-moon-o:before{content:""}.fa-archive:before{content:""}.fa-bug:before{content:""}.fa-vk:before{content:""}.fa-weibo:before{content:""}.fa-renren:before{content:""}.fa-pagelines:before{content:""}.fa-stack-exchange:before{content:""}.fa-arrow-circle-o-right:before{content:""}.fa-arrow-circle-o-left:before{content:""}.fa-caret-square-o-left:before,.fa-toggle-left:before{content:""}.fa-dot-circle-o:before{content:""}.fa-wheelchair:before{content:""}.fa-vimeo-square:before{content:""}.fa-try:before,.fa-turkish-lira:before{content:""}.fa-plus-square-o:before,.wy-menu-vertical li button.toctree-expand:before{content:""}.fa-space-shuttle:before{content:""}.fa-slack:before{content:""}.fa-envelope-square:before{content:""}.fa-wordpress:before{content:""}.fa-openid:before{content:""}.fa-bank:before,.fa-institution:before,.fa-university:before{content:""}.fa-graduation-cap:before,.fa-mortar-board:before{content:""}.fa-yahoo:before{content:""}.fa-google:before{content:""}.fa-reddit:before{content:""}.fa-reddit-square:before{content:""}.fa-stumbleupon-circle:before{content:""}.fa-stumbleupon:before{content:""}.fa-delicious:before{content:""}.fa-digg:before{content:""}.fa-pied-piper-pp:before{content:""}.fa-pied-piper-alt:before{content:""}.fa-drupal:before{content:""}.fa-joomla:before{content:""}.fa-language:before{content:""}.fa-fax:before{content:""}.fa-building:before{content:""}.fa-child:before{content:""}.fa-paw:before{content:""}.fa-spoon:before{content:""}.fa-cube:before{content:""}.fa-cubes:before{content:""}.fa-behance:before{content:""}.fa-behance-square:before{content:""}.fa-steam:before{content:""}.fa-steam-square:before{content:""}.fa-recycle:before{content:""}.fa-automobile:before,.fa-car:before{content:""}.fa-cab:before,.fa-taxi:before{content:""}.fa-tree:before{content:""}.fa-spotify:before{content:""}.fa-deviantart:before{content:""}.fa-soundcloud:before{content:""}.fa-database:before{content:""}.fa-file-pdf-o:before{content:""}.fa-file-word-o:before{content:""}.fa-file-excel-o:before{content:""}.fa-file-powerpoint-o:before{content:""}.fa-file-image-o:before,.fa-file-photo-o:before,.fa-file-picture-o:before{content:""}.fa-file-archive-o:before,.fa-file-zip-o:before{content:""}.fa-file-audio-o:before,.fa-file-sound-o:before{content:""}.fa-file-movie-o:before,.fa-file-video-o:before{content:""}.fa-file-code-o:before{content:""}.fa-vine:before{content:""}.fa-codepen:before{content:""}.fa-jsfiddle:before{content:""}.fa-life-bouy:before,.fa-life-buoy:before,.fa-life-ring:before,.fa-life-saver:before,.fa-support:before{content:""}.fa-circle-o-notch:before{content:""}.fa-ra:before,.fa-rebel:before,.fa-resistance:before{content:""}.fa-empire:before,.fa-ge:before{content:""}.fa-git-square:before{content:""}.fa-git:before{content:""}.fa-hacker-news:before,.fa-y-combinator-square:before,.fa-yc-square:before{content:""}.fa-tencent-weibo:before{content:""}.fa-qq:before{content:""}.fa-wechat:before,.fa-weixin:before{content:""}.fa-paper-plane:before,.fa-send:before{content:""}.fa-paper-plane-o:before,.fa-send-o:before{content:""}.fa-history:before{content:""}.fa-circle-thin:before{content:""}.fa-header:before{content:""}.fa-paragraph:before{content:""}.fa-sliders:before{content:""}.fa-share-alt:before{content:""}.fa-share-alt-square:before{content:""}.fa-bomb:before{content:""}.fa-futbol-o:before,.fa-soccer-ball-o:before{content:""}.fa-tty:before{content:""}.fa-binoculars:before{content:""}.fa-plug:before{content:""}.fa-slideshare:before{content:""}.fa-twitch:before{content:""}.fa-yelp:before{content:""}.fa-newspaper-o:before{content:""}.fa-wifi:before{content:""}.fa-calculator:before{content:""}.fa-paypal:before{content:""}.fa-google-wallet:before{content:""}.fa-cc-visa:before{content:""}.fa-cc-mastercard:before{content:""}.fa-cc-discover:before{content:""}.fa-cc-amex:before{content:""}.fa-cc-paypal:before{content:""}.fa-cc-stripe:before{content:""}.fa-bell-slash:before{content:""}.fa-bell-slash-o:before{content:""}.fa-trash:before{content:""}.fa-copyright:before{content:""}.fa-at:before{content:""}.fa-eyedropper:before{content:""}.fa-paint-brush:before{content:""}.fa-birthday-cake:before{content:""}.fa-area-chart:before{content:""}.fa-pie-chart:before{content:""}.fa-line-chart:before{content:""}.fa-lastfm:before{content:""}.fa-lastfm-square:before{content:""}.fa-toggle-off:before{content:""}.fa-toggle-on:before{content:""}.fa-bicycle:before{content:""}.fa-bus:before{content:""}.fa-ioxhost:before{content:""}.fa-angellist:before{content:""}.fa-cc:before{content:""}.fa-ils:before,.fa-shekel:before,.fa-sheqel:before{content:""}.fa-meanpath:before{content:""}.fa-buysellads:before{content:""}.fa-connectdevelop:before{content:""}.fa-dashcube:before{content:""}.fa-forumbee:before{content:""}.fa-leanpub:before{content:""}.fa-sellsy:before{content:""}.fa-shirtsinbulk:before{content:""}.fa-simplybuilt:before{content:""}.fa-skyatlas:before{content:""}.fa-cart-plus:before{content:""}.fa-cart-arrow-down:before{content:""}.fa-diamond:before{content:""}.fa-ship:before{content:""}.fa-user-secret:before{content:""}.fa-motorcycle:before{content:""}.fa-street-view:before{content:""}.fa-heartbeat:before{content:""}.fa-venus:before{content:""}.fa-mars:before{content:""}.fa-mercury:before{content:""}.fa-intersex:before,.fa-transgender:before{content:""}.fa-transgender-alt:before{content:""}.fa-venus-double:before{content:""}.fa-mars-double:before{content:""}.fa-venus-mars:before{content:""}.fa-mars-stroke:before{content:""}.fa-mars-stroke-v:before{content:""}.fa-mars-stroke-h:before{content:""}.fa-neuter:before{content:""}.fa-genderless:before{content:""}.fa-facebook-official:before{content:""}.fa-pinterest-p:before{content:""}.fa-whatsapp:before{content:""}.fa-server:before{content:""}.fa-user-plus:before{content:""}.fa-user-times:before{content:""}.fa-bed:before,.fa-hotel:before{content:""}.fa-viacoin:before{content:""}.fa-train:before{content:""}.fa-subway:before{content:""}.fa-medium:before{content:""}.fa-y-combinator:before,.fa-yc:before{content:""}.fa-optin-monster:before{content:""}.fa-opencart:before{content:""}.fa-expeditedssl:before{content:""}.fa-battery-4:before,.fa-battery-full:before,.fa-battery:before{content:""}.fa-battery-3:before,.fa-battery-three-quarters:before{content:""}.fa-battery-2:before,.fa-battery-half:before{content:""}.fa-battery-1:before,.fa-battery-quarter:before{content:""}.fa-battery-0:before,.fa-battery-empty:before{content:""}.fa-mouse-pointer:before{content:""}.fa-i-cursor:before{content:""}.fa-object-group:before{content:""}.fa-object-ungroup:before{content:""}.fa-sticky-note:before{content:""}.fa-sticky-note-o:before{content:""}.fa-cc-jcb:before{content:""}.fa-cc-diners-club:before{content:""}.fa-clone:before{content:""}.fa-balance-scale:before{content:""}.fa-hourglass-o:before{content:""}.fa-hourglass-1:before,.fa-hourglass-start:before{content:""}.fa-hourglass-2:before,.fa-hourglass-half:before{content:""}.fa-hourglass-3:before,.fa-hourglass-end:before{content:""}.fa-hourglass:before{content:""}.fa-hand-grab-o:before,.fa-hand-rock-o:before{content:""}.fa-hand-paper-o:before,.fa-hand-stop-o:before{content:""}.fa-hand-scissors-o:before{content:""}.fa-hand-lizard-o:before{content:""}.fa-hand-spock-o:before{content:""}.fa-hand-pointer-o:before{content:""}.fa-hand-peace-o:before{content:""}.fa-trademark:before{content:""}.fa-registered:before{content:""}.fa-creative-commons:before{content:""}.fa-gg:before{content:""}.fa-gg-circle:before{content:""}.fa-tripadvisor:before{content:""}.fa-odnoklassniki:before{content:""}.fa-odnoklassniki-square:before{content:""}.fa-get-pocket:before{content:""}.fa-wikipedia-w:before{content:""}.fa-safari:before{content:""}.fa-chrome:before{content:""}.fa-firefox:before{content:""}.fa-opera:before{content:""}.fa-internet-explorer:before{content:""}.fa-television:before,.fa-tv:before{content:""}.fa-contao:before{content:""}.fa-500px:before{content:""}.fa-amazon:before{content:""}.fa-calendar-plus-o:before{content:""}.fa-calendar-minus-o:before{content:""}.fa-calendar-times-o:before{content:""}.fa-calendar-check-o:before{content:""}.fa-industry:before{content:""}.fa-map-pin:before{content:""}.fa-map-signs:before{content:""}.fa-map-o:before{content:""}.fa-map:before{content:""}.fa-commenting:before{content:""}.fa-commenting-o:before{content:""}.fa-houzz:before{content:""}.fa-vimeo:before{content:""}.fa-black-tie:before{content:""}.fa-fonticons:before{content:""}.fa-reddit-alien:before{content:""}.fa-edge:before{content:""}.fa-credit-card-alt:before{content:""}.fa-codiepie:before{content:""}.fa-modx:before{content:""}.fa-fort-awesome:before{content:""}.fa-usb:before{content:""}.fa-product-hunt:before{content:""}.fa-mixcloud:before{content:""}.fa-scribd:before{content:""}.fa-pause-circle:before{content:""}.fa-pause-circle-o:before{content:""}.fa-stop-circle:before{content:""}.fa-stop-circle-o:before{content:""}.fa-shopping-bag:before{content:""}.fa-shopping-basket:before{content:""}.fa-hashtag:before{content:""}.fa-bluetooth:before{content:""}.fa-bluetooth-b:before{content:""}.fa-percent:before{content:""}.fa-gitlab:before,.icon-gitlab:before{content:""}.fa-wpbeginner:before{content:""}.fa-wpforms:before{content:""}.fa-envira:before{content:""}.fa-universal-access:before{content:""}.fa-wheelchair-alt:before{content:""}.fa-question-circle-o:before{content:""}.fa-blind:before{content:""}.fa-audio-description:before{content:""}.fa-volume-control-phone:before{content:""}.fa-braille:before{content:""}.fa-assistive-listening-systems:before{content:""}.fa-american-sign-language-interpreting:before,.fa-asl-interpreting:before{content:""}.fa-deaf:before,.fa-deafness:before,.fa-hard-of-hearing:before{content:""}.fa-glide:before{content:""}.fa-glide-g:before{content:""}.fa-sign-language:before,.fa-signing:before{content:""}.fa-low-vision:before{content:""}.fa-viadeo:before{content:""}.fa-viadeo-square:before{content:""}.fa-snapchat:before{content:""}.fa-snapchat-ghost:before{content:""}.fa-snapchat-square:before{content:""}.fa-pied-piper:before{content:""}.fa-first-order:before{content:""}.fa-yoast:before{content:""}.fa-themeisle:before{content:""}.fa-google-plus-circle:before,.fa-google-plus-official:before{content:""}.fa-fa:before,.fa-font-awesome:before{content:""}.fa-handshake-o:before{content:""}.fa-envelope-open:before{content:""}.fa-envelope-open-o:before{content:""}.fa-linode:before{content:""}.fa-address-book:before{content:""}.fa-address-book-o:before{content:""}.fa-address-card:before,.fa-vcard:before{content:""}.fa-address-card-o:before,.fa-vcard-o:before{content:""}.fa-user-circle:before{content:""}.fa-user-circle-o:before{content:""}.fa-user-o:before{content:""}.fa-id-badge:before{content:""}.fa-drivers-license:before,.fa-id-card:before{content:""}.fa-drivers-license-o:before,.fa-id-card-o:before{content:""}.fa-quora:before{content:""}.fa-free-code-camp:before{content:""}.fa-telegram:before{content:""}.fa-thermometer-4:before,.fa-thermometer-full:before,.fa-thermometer:before{content:""}.fa-thermometer-3:before,.fa-thermometer-three-quarters:before{content:""}.fa-thermometer-2:before,.fa-thermometer-half:before{content:""}.fa-thermometer-1:before,.fa-thermometer-quarter:before{content:""}.fa-thermometer-0:before,.fa-thermometer-empty:before{content:""}.fa-shower:before{content:""}.fa-bath:before,.fa-bathtub:before,.fa-s15:before{content:""}.fa-podcast:before{content:""}.fa-window-maximize:before{content:""}.fa-window-minimize:before{content:""}.fa-window-restore:before{content:""}.fa-times-rectangle:before,.fa-window-close:before{content:""}.fa-times-rectangle-o:before,.fa-window-close-o:before{content:""}.fa-bandcamp:before{content:""}.fa-grav:before{content:""}.fa-etsy:before{content:""}.fa-imdb:before{content:""}.fa-ravelry:before{content:""}.fa-eercast:before{content:""}.fa-microchip:before{content:""}.fa-snowflake-o:before{content:""}.fa-superpowers:before{content:""}.fa-wpexplorer:before{content:""}.fa-meetup:before{content:""}.sr-only{position:absolute;width:1px;height:1px;padding:0;margin:-1px;overflow:hidden;clip:rect(0,0,0,0);border:0}.sr-only-focusable:active,.sr-only-focusable:focus{position:static;width:auto;height:auto;margin:0;overflow:visible;clip:auto}.fa,.icon,.rst-content .admonition-title,.rst-content .code-block-caption .headerlink,.rst-content .eqno .headerlink,.rst-content code.download span:first-child,.rst-content dl dt .headerlink,.rst-content h1 .headerlink,.rst-content h2 .headerlink,.rst-content h3 .headerlink,.rst-content h4 .headerlink,.rst-content h5 .headerlink,.rst-content h6 .headerlink,.rst-content p.caption .headerlink,.rst-content p .headerlink,.rst-content table>caption .headerlink,.rst-content tt.download span:first-child,.wy-dropdown .caret,.wy-inline-validate.wy-inline-validate-danger .wy-input-context,.wy-inline-validate.wy-inline-validate-info .wy-input-context,.wy-inline-validate.wy-inline-validate-success .wy-input-context,.wy-inline-validate.wy-inline-validate-warning .wy-input-context,.wy-menu-vertical li.current>a button.toctree-expand,.wy-menu-vertical li.on a button.toctree-expand,.wy-menu-vertical li button.toctree-expand{font-family:inherit}.fa:before,.icon:before,.rst-content .admonition-title:before,.rst-content .code-block-caption .headerlink:before,.rst-content .eqno .headerlink:before,.rst-content code.download span:first-child:before,.rst-content dl dt .headerlink:before,.rst-content h1 .headerlink:before,.rst-content h2 .headerlink:before,.rst-content h3 .headerlink:before,.rst-content h4 .headerlink:before,.rst-content h5 .headerlink:before,.rst-content h6 .headerlink:before,.rst-content p.caption .headerlink:before,.rst-content p .headerlink:before,.rst-content table>caption .headerlink:before,.rst-content tt.download span:first-child:before,.wy-dropdown .caret:before,.wy-inline-validate.wy-inline-validate-danger .wy-input-context:before,.wy-inline-validate.wy-inline-validate-info .wy-input-context:before,.wy-inline-validate.wy-inline-validate-success .wy-input-context:before,.wy-inline-validate.wy-inline-validate-warning .wy-input-context:before,.wy-menu-vertical li.current>a button.toctree-expand:before,.wy-menu-vertical li.on a button.toctree-expand:before,.wy-menu-vertical li button.toctree-expand:before{font-family:FontAwesome;display:inline-block;font-style:normal;font-weight:400;line-height:1;text-decoration:inherit}.rst-content .code-block-caption a .headerlink,.rst-content .eqno a .headerlink,.rst-content a .admonition-title,.rst-content code.download a span:first-child,.rst-content dl dt a .headerlink,.rst-content h1 a .headerlink,.rst-content h2 a .headerlink,.rst-content h3 a .headerlink,.rst-content h4 a .headerlink,.rst-content h5 a .headerlink,.rst-content h6 a .headerlink,.rst-content p.caption a .headerlink,.rst-content p a .headerlink,.rst-content table>caption a .headerlink,.rst-content tt.download a span:first-child,.wy-menu-vertical li.current>a button.toctree-expand,.wy-menu-vertical li.on a button.toctree-expand,.wy-menu-vertical li a button.toctree-expand,a .fa,a .icon,a .rst-content .admonition-title,a .rst-content .code-block-caption .headerlink,a .rst-content .eqno .headerlink,a .rst-content code.download span:first-child,a .rst-content dl dt .headerlink,a .rst-content h1 .headerlink,a .rst-content h2 .headerlink,a .rst-content h3 .headerlink,a .rst-content h4 .headerlink,a .rst-content h5 .headerlink,a .rst-content h6 .headerlink,a .rst-content p.caption .headerlink,a .rst-content p .headerlink,a .rst-content table>caption .headerlink,a .rst-content tt.download span:first-child,a .wy-menu-vertical li button.toctree-expand{display:inline-block;text-decoration:inherit}.btn .fa,.btn .icon,.btn .rst-content .admonition-title,.btn .rst-content .code-block-caption .headerlink,.btn .rst-content .eqno .headerlink,.btn .rst-content code.download span:first-child,.btn .rst-content dl dt .headerlink,.btn .rst-content h1 .headerlink,.btn .rst-content h2 .headerlink,.btn .rst-content h3 .headerlink,.btn .rst-content h4 .headerlink,.btn .rst-content h5 .headerlink,.btn .rst-content h6 .headerlink,.btn .rst-content p .headerlink,.btn .rst-content table>caption .headerlink,.btn .rst-content tt.download span:first-child,.btn .wy-menu-vertical li.current>a button.toctree-expand,.btn .wy-menu-vertical li.on a button.toctree-expand,.btn .wy-menu-vertical li button.toctree-expand,.nav .fa,.nav .icon,.nav .rst-content .admonition-title,.nav .rst-content .code-block-caption .headerlink,.nav .rst-content .eqno .headerlink,.nav .rst-content code.download span:first-child,.nav .rst-content dl dt .headerlink,.nav .rst-content h1 .headerlink,.nav .rst-content h2 .headerlink,.nav .rst-content h3 .headerlink,.nav .rst-content h4 .headerlink,.nav .rst-content h5 .headerlink,.nav .rst-content h6 .headerlink,.nav .rst-content p .headerlink,.nav .rst-content table>caption .headerlink,.nav .rst-content tt.download span:first-child,.nav .wy-menu-vertical li.current>a button.toctree-expand,.nav .wy-menu-vertical li.on a button.toctree-expand,.nav .wy-menu-vertical li button.toctree-expand,.rst-content .btn .admonition-title,.rst-content .code-block-caption .btn .headerlink,.rst-content .code-block-caption .nav .headerlink,.rst-content .eqno .btn .headerlink,.rst-content .eqno .nav .headerlink,.rst-content .nav .admonition-title,.rst-content code.download .btn span:first-child,.rst-content code.download .nav span:first-child,.rst-content dl dt .btn .headerlink,.rst-content dl dt .nav .headerlink,.rst-content h1 .btn .headerlink,.rst-content h1 .nav .headerlink,.rst-content h2 .btn .headerlink,.rst-content h2 .nav .headerlink,.rst-content h3 .btn .headerlink,.rst-content h3 .nav .headerlink,.rst-content h4 .btn .headerlink,.rst-content h4 .nav .headerlink,.rst-content h5 .btn .headerlink,.rst-content h5 .nav .headerlink,.rst-content h6 .btn .headerlink,.rst-content h6 .nav .headerlink,.rst-content p .btn .headerlink,.rst-content p .nav .headerlink,.rst-content table>caption .btn .headerlink,.rst-content table>caption .nav .headerlink,.rst-content tt.download .btn span:first-child,.rst-content tt.download .nav span:first-child,.wy-menu-vertical li .btn button.toctree-expand,.wy-menu-vertical li.current>a .btn button.toctree-expand,.wy-menu-vertical li.current>a .nav button.toctree-expand,.wy-menu-vertical li .nav button.toctree-expand,.wy-menu-vertical li.on a .btn button.toctree-expand,.wy-menu-vertical li.on a .nav button.toctree-expand{display:inline}.btn .fa-large.icon,.btn .fa.fa-large,.btn .rst-content .code-block-caption .fa-large.headerlink,.btn .rst-content .eqno .fa-large.headerlink,.btn .rst-content .fa-large.admonition-title,.btn .rst-content code.download span.fa-large:first-child,.btn .rst-content dl dt .fa-large.headerlink,.btn .rst-content h1 .fa-large.headerlink,.btn .rst-content h2 .fa-large.headerlink,.btn .rst-content h3 .fa-large.headerlink,.btn .rst-content h4 .fa-large.headerlink,.btn .rst-content h5 .fa-large.headerlink,.btn .rst-content h6 .fa-large.headerlink,.btn .rst-content p .fa-large.headerlink,.btn .rst-content table>caption .fa-large.headerlink,.btn .rst-content tt.download span.fa-large:first-child,.btn .wy-menu-vertical li button.fa-large.toctree-expand,.nav .fa-large.icon,.nav .fa.fa-large,.nav .rst-content .code-block-caption .fa-large.headerlink,.nav .rst-content .eqno .fa-large.headerlink,.nav .rst-content .fa-large.admonition-title,.nav .rst-content code.download span.fa-large:first-child,.nav .rst-content dl dt .fa-large.headerlink,.nav .rst-content h1 .fa-large.headerlink,.nav .rst-content h2 .fa-large.headerlink,.nav .rst-content h3 .fa-large.headerlink,.nav .rst-content h4 .fa-large.headerlink,.nav .rst-content h5 .fa-large.headerlink,.nav .rst-content h6 .fa-large.headerlink,.nav .rst-content p .fa-large.headerlink,.nav .rst-content table>caption .fa-large.headerlink,.nav .rst-content tt.download span.fa-large:first-child,.nav .wy-menu-vertical li button.fa-large.toctree-expand,.rst-content .btn .fa-large.admonition-title,.rst-content .code-block-caption .btn .fa-large.headerlink,.rst-content .code-block-caption .nav .fa-large.headerlink,.rst-content .eqno .btn .fa-large.headerlink,.rst-content .eqno .nav .fa-large.headerlink,.rst-content .nav .fa-large.admonition-title,.rst-content code.download .btn span.fa-large:first-child,.rst-content code.download .nav span.fa-large:first-child,.rst-content dl dt .btn .fa-large.headerlink,.rst-content dl dt .nav .fa-large.headerlink,.rst-content h1 .btn .fa-large.headerlink,.rst-content h1 .nav .fa-large.headerlink,.rst-content h2 .btn .fa-large.headerlink,.rst-content h2 .nav .fa-large.headerlink,.rst-content h3 .btn .fa-large.headerlink,.rst-content h3 .nav .fa-large.headerlink,.rst-content h4 .btn .fa-large.headerlink,.rst-content h4 .nav .fa-large.headerlink,.rst-content h5 .btn .fa-large.headerlink,.rst-content h5 .nav .fa-large.headerlink,.rst-content h6 .btn .fa-large.headerlink,.rst-content h6 .nav .fa-large.headerlink,.rst-content p .btn .fa-large.headerlink,.rst-content p .nav .fa-large.headerlink,.rst-content table>caption .btn .fa-large.headerlink,.rst-content table>caption .nav .fa-large.headerlink,.rst-content tt.download .btn span.fa-large:first-child,.rst-content tt.download .nav span.fa-large:first-child,.wy-menu-vertical li .btn button.fa-large.toctree-expand,.wy-menu-vertical li .nav button.fa-large.toctree-expand{line-height:.9em}.btn .fa-spin.icon,.btn .fa.fa-spin,.btn .rst-content .code-block-caption .fa-spin.headerlink,.btn .rst-content .eqno .fa-spin.headerlink,.btn .rst-content .fa-spin.admonition-title,.btn .rst-content code.download span.fa-spin:first-child,.btn .rst-content dl dt .fa-spin.headerlink,.btn .rst-content h1 .fa-spin.headerlink,.btn .rst-content h2 .fa-spin.headerlink,.btn .rst-content h3 .fa-spin.headerlink,.btn .rst-content h4 .fa-spin.headerlink,.btn .rst-content h5 .fa-spin.headerlink,.btn .rst-content h6 .fa-spin.headerlink,.btn .rst-content p .fa-spin.headerlink,.btn .rst-content table>caption .fa-spin.headerlink,.btn .rst-content tt.download span.fa-spin:first-child,.btn .wy-menu-vertical li button.fa-spin.toctree-expand,.nav .fa-spin.icon,.nav .fa.fa-spin,.nav .rst-content .code-block-caption .fa-spin.headerlink,.nav .rst-content .eqno .fa-spin.headerlink,.nav .rst-content .fa-spin.admonition-title,.nav .rst-content code.download span.fa-spin:first-child,.nav .rst-content dl dt .fa-spin.headerlink,.nav .rst-content h1 .fa-spin.headerlink,.nav .rst-content h2 .fa-spin.headerlink,.nav .rst-content h3 .fa-spin.headerlink,.nav .rst-content h4 .fa-spin.headerlink,.nav .rst-content h5 .fa-spin.headerlink,.nav .rst-content h6 .fa-spin.headerlink,.nav .rst-content p .fa-spin.headerlink,.nav .rst-content table>caption .fa-spin.headerlink,.nav .rst-content tt.download span.fa-spin:first-child,.nav .wy-menu-vertical li button.fa-spin.toctree-expand,.rst-content .btn .fa-spin.admonition-title,.rst-content .code-block-caption .btn .fa-spin.headerlink,.rst-content .code-block-caption .nav .fa-spin.headerlink,.rst-content .eqno .btn .fa-spin.headerlink,.rst-content .eqno .nav .fa-spin.headerlink,.rst-content .nav .fa-spin.admonition-title,.rst-content code.download .btn span.fa-spin:first-child,.rst-content code.download .nav span.fa-spin:first-child,.rst-content dl dt .btn .fa-spin.headerlink,.rst-content dl dt .nav .fa-spin.headerlink,.rst-content h1 .btn .fa-spin.headerlink,.rst-content h1 .nav .fa-spin.headerlink,.rst-content h2 .btn .fa-spin.headerlink,.rst-content h2 .nav .fa-spin.headerlink,.rst-content h3 .btn .fa-spin.headerlink,.rst-content h3 .nav .fa-spin.headerlink,.rst-content h4 .btn .fa-spin.headerlink,.rst-content h4 .nav .fa-spin.headerlink,.rst-content h5 .btn .fa-spin.headerlink,.rst-content h5 .nav .fa-spin.headerlink,.rst-content h6 .btn .fa-spin.headerlink,.rst-content h6 .nav .fa-spin.headerlink,.rst-content p .btn .fa-spin.headerlink,.rst-content p .nav .fa-spin.headerlink,.rst-content table>caption .btn .fa-spin.headerlink,.rst-content table>caption .nav .fa-spin.headerlink,.rst-content tt.download .btn span.fa-spin:first-child,.rst-content tt.download .nav span.fa-spin:first-child,.wy-menu-vertical li .btn button.fa-spin.toctree-expand,.wy-menu-vertical li .nav button.fa-spin.toctree-expand{display:inline-block}.btn.fa:before,.btn.icon:before,.rst-content .btn.admonition-title:before,.rst-content .code-block-caption .btn.headerlink:before,.rst-content .eqno .btn.headerlink:before,.rst-content code.download span.btn:first-child:before,.rst-content dl dt .btn.headerlink:before,.rst-content h1 .btn.headerlink:before,.rst-content h2 .btn.headerlink:before,.rst-content h3 .btn.headerlink:before,.rst-content h4 .btn.headerlink:before,.rst-content h5 .btn.headerlink:before,.rst-content h6 .btn.headerlink:before,.rst-content p .btn.headerlink:before,.rst-content table>caption .btn.headerlink:before,.rst-content tt.download span.btn:first-child:before,.wy-menu-vertical li button.btn.toctree-expand:before{opacity:.5;-webkit-transition:opacity .05s ease-in;-moz-transition:opacity .05s ease-in;transition:opacity .05s ease-in}.btn.fa:hover:before,.btn.icon:hover:before,.rst-content .btn.admonition-title:hover:before,.rst-content .code-block-caption .btn.headerlink:hover:before,.rst-content .eqno .btn.headerlink:hover:before,.rst-content code.download span.btn:first-child:hover:before,.rst-content dl dt .btn.headerlink:hover:before,.rst-content h1 .btn.headerlink:hover:before,.rst-content h2 .btn.headerlink:hover:before,.rst-content h3 .btn.headerlink:hover:before,.rst-content h4 .btn.headerlink:hover:before,.rst-content h5 .btn.headerlink:hover:before,.rst-content h6 .btn.headerlink:hover:before,.rst-content p .btn.headerlink:hover:before,.rst-content table>caption .btn.headerlink:hover:before,.rst-content tt.download span.btn:first-child:hover:before,.wy-menu-vertical li button.btn.toctree-expand:hover:before{opacity:1}.btn-mini .fa:before,.btn-mini .icon:before,.btn-mini .rst-content .admonition-title:before,.btn-mini .rst-content .code-block-caption .headerlink:before,.btn-mini .rst-content .eqno .headerlink:before,.btn-mini .rst-content code.download span:first-child:before,.btn-mini .rst-content dl dt .headerlink:before,.btn-mini .rst-content h1 .headerlink:before,.btn-mini .rst-content h2 .headerlink:before,.btn-mini .rst-content h3 .headerlink:before,.btn-mini .rst-content h4 .headerlink:before,.btn-mini .rst-content h5 .headerlink:before,.btn-mini .rst-content h6 .headerlink:before,.btn-mini .rst-content p .headerlink:before,.btn-mini .rst-content table>caption .headerlink:before,.btn-mini .rst-content tt.download span:first-child:before,.btn-mini .wy-menu-vertical li button.toctree-expand:before,.rst-content .btn-mini .admonition-title:before,.rst-content .code-block-caption .btn-mini .headerlink:before,.rst-content .eqno .btn-mini .headerlink:before,.rst-content code.download .btn-mini span:first-child:before,.rst-content dl dt .btn-mini .headerlink:before,.rst-content h1 .btn-mini .headerlink:before,.rst-content h2 .btn-mini .headerlink:before,.rst-content h3 .btn-mini .headerlink:before,.rst-content h4 .btn-mini .headerlink:before,.rst-content h5 .btn-mini .headerlink:before,.rst-content h6 .btn-mini .headerlink:before,.rst-content p .btn-mini .headerlink:before,.rst-content table>caption .btn-mini .headerlink:before,.rst-content tt.download .btn-mini span:first-child:before,.wy-menu-vertical li .btn-mini button.toctree-expand:before{font-size:14px;vertical-align:-15%}.rst-content .admonition,.rst-content .admonition-todo,.rst-content .attention,.rst-content .caution,.rst-content .danger,.rst-content .error,.rst-content .hint,.rst-content .important,.rst-content .note,.rst-content .seealso,.rst-content .tip,.rst-content .warning,.wy-alert{padding:12px;line-height:24px;margin-bottom:24px;background:#e7f2fa}.rst-content .admonition-title,.wy-alert-title{font-weight:700;display:block;color:#fff;background:#6ab0de;padding:6px 12px;margin:-12px -12px 12px}.rst-content .danger,.rst-content .error,.rst-content .wy-alert-danger.admonition,.rst-content .wy-alert-danger.admonition-todo,.rst-content .wy-alert-danger.attention,.rst-content .wy-alert-danger.caution,.rst-content .wy-alert-danger.hint,.rst-content .wy-alert-danger.important,.rst-content .wy-alert-danger.note,.rst-content .wy-alert-danger.seealso,.rst-content .wy-alert-danger.tip,.rst-content .wy-alert-danger.warning,.wy-alert.wy-alert-danger{background:#fdf3f2}.rst-content .danger .admonition-title,.rst-content .danger .wy-alert-title,.rst-content .error .admonition-title,.rst-content .error .wy-alert-title,.rst-content .wy-alert-danger.admonition-todo .admonition-title,.rst-content .wy-alert-danger.admonition-todo .wy-alert-title,.rst-content .wy-alert-danger.admonition .admonition-title,.rst-content .wy-alert-danger.admonition .wy-alert-title,.rst-content .wy-alert-danger.attention .admonition-title,.rst-content .wy-alert-danger.attention .wy-alert-title,.rst-content .wy-alert-danger.caution .admonition-title,.rst-content .wy-alert-danger.caution .wy-alert-title,.rst-content .wy-alert-danger.hint .admonition-title,.rst-content .wy-alert-danger.hint .wy-alert-title,.rst-content .wy-alert-danger.important .admonition-title,.rst-content .wy-alert-danger.important .wy-alert-title,.rst-content .wy-alert-danger.note .admonition-title,.rst-content .wy-alert-danger.note .wy-alert-title,.rst-content .wy-alert-danger.seealso .admonition-title,.rst-content .wy-alert-danger.seealso .wy-alert-title,.rst-content .wy-alert-danger.tip .admonition-title,.rst-content .wy-alert-danger.tip .wy-alert-title,.rst-content .wy-alert-danger.warning .admonition-title,.rst-content .wy-alert-danger.warning .wy-alert-title,.rst-content .wy-alert.wy-alert-danger .admonition-title,.wy-alert.wy-alert-danger .rst-content .admonition-title,.wy-alert.wy-alert-danger .wy-alert-title{background:#f29f97}.rst-content .admonition-todo,.rst-content .attention,.rst-content .caution,.rst-content .warning,.rst-content .wy-alert-warning.admonition,.rst-content .wy-alert-warning.danger,.rst-content .wy-alert-warning.error,.rst-content .wy-alert-warning.hint,.rst-content .wy-alert-warning.important,.rst-content .wy-alert-warning.note,.rst-content .wy-alert-warning.seealso,.rst-content .wy-alert-warning.tip,.wy-alert.wy-alert-warning{background:#ffedcc}.rst-content .admonition-todo .admonition-title,.rst-content .admonition-todo .wy-alert-title,.rst-content .attention .admonition-title,.rst-content .attention .wy-alert-title,.rst-content .caution .admonition-title,.rst-content .caution .wy-alert-title,.rst-content .warning .admonition-title,.rst-content .warning .wy-alert-title,.rst-content .wy-alert-warning.admonition .admonition-title,.rst-content .wy-alert-warning.admonition .wy-alert-title,.rst-content .wy-alert-warning.danger .admonition-title,.rst-content .wy-alert-warning.danger .wy-alert-title,.rst-content .wy-alert-warning.error .admonition-title,.rst-content .wy-alert-warning.error .wy-alert-title,.rst-content .wy-alert-warning.hint .admonition-title,.rst-content .wy-alert-warning.hint .wy-alert-title,.rst-content .wy-alert-warning.important .admonition-title,.rst-content .wy-alert-warning.important .wy-alert-title,.rst-content .wy-alert-warning.note .admonition-title,.rst-content .wy-alert-warning.note .wy-alert-title,.rst-content .wy-alert-warning.seealso .admonition-title,.rst-content .wy-alert-warning.seealso .wy-alert-title,.rst-content .wy-alert-warning.tip .admonition-title,.rst-content .wy-alert-warning.tip .wy-alert-title,.rst-content .wy-alert.wy-alert-warning .admonition-title,.wy-alert.wy-alert-warning .rst-content .admonition-title,.wy-alert.wy-alert-warning .wy-alert-title{background:#f0b37e}.rst-content .note,.rst-content .seealso,.rst-content .wy-alert-info.admonition,.rst-content .wy-alert-info.admonition-todo,.rst-content .wy-alert-info.attention,.rst-content .wy-alert-info.caution,.rst-content .wy-alert-info.danger,.rst-content .wy-alert-info.error,.rst-content .wy-alert-info.hint,.rst-content .wy-alert-info.important,.rst-content .wy-alert-info.tip,.rst-content .wy-alert-info.warning,.wy-alert.wy-alert-info{background:#e7f2fa}.rst-content .note .admonition-title,.rst-content .note .wy-alert-title,.rst-content .seealso .admonition-title,.rst-content .seealso .wy-alert-title,.rst-content .wy-alert-info.admonition-todo .admonition-title,.rst-content .wy-alert-info.admonition-todo .wy-alert-title,.rst-content .wy-alert-info.admonition .admonition-title,.rst-content .wy-alert-info.admonition .wy-alert-title,.rst-content .wy-alert-info.attention .admonition-title,.rst-content .wy-alert-info.attention .wy-alert-title,.rst-content .wy-alert-info.caution .admonition-title,.rst-content .wy-alert-info.caution .wy-alert-title,.rst-content .wy-alert-info.danger .admonition-title,.rst-content .wy-alert-info.danger .wy-alert-title,.rst-content .wy-alert-info.error .admonition-title,.rst-content .wy-alert-info.error .wy-alert-title,.rst-content .wy-alert-info.hint .admonition-title,.rst-content .wy-alert-info.hint .wy-alert-title,.rst-content .wy-alert-info.important .admonition-title,.rst-content .wy-alert-info.important .wy-alert-title,.rst-content .wy-alert-info.tip .admonition-title,.rst-content .wy-alert-info.tip .wy-alert-title,.rst-content .wy-alert-info.warning .admonition-title,.rst-content .wy-alert-info.warning .wy-alert-title,.rst-content .wy-alert.wy-alert-info .admonition-title,.wy-alert.wy-alert-info .rst-content .admonition-title,.wy-alert.wy-alert-info .wy-alert-title{background:#6ab0de}.rst-content .hint,.rst-content .important,.rst-content .tip,.rst-content .wy-alert-success.admonition,.rst-content .wy-alert-success.admonition-todo,.rst-content .wy-alert-success.attention,.rst-content .wy-alert-success.caution,.rst-content .wy-alert-success.danger,.rst-content .wy-alert-success.error,.rst-content .wy-alert-success.note,.rst-content .wy-alert-success.seealso,.rst-content .wy-alert-success.warning,.wy-alert.wy-alert-success{background:#dbfaf4}.rst-content .hint .admonition-title,.rst-content .hint .wy-alert-title,.rst-content .important .admonition-title,.rst-content .important .wy-alert-title,.rst-content .tip .admonition-title,.rst-content .tip .wy-alert-title,.rst-content .wy-alert-success.admonition-todo .admonition-title,.rst-content .wy-alert-success.admonition-todo .wy-alert-title,.rst-content .wy-alert-success.admonition .admonition-title,.rst-content .wy-alert-success.admonition .wy-alert-title,.rst-content .wy-alert-success.attention .admonition-title,.rst-content .wy-alert-success.attention .wy-alert-title,.rst-content .wy-alert-success.caution .admonition-title,.rst-content .wy-alert-success.caution .wy-alert-title,.rst-content .wy-alert-success.danger .admonition-title,.rst-content .wy-alert-success.danger .wy-alert-title,.rst-content .wy-alert-success.error .admonition-title,.rst-content .wy-alert-success.error .wy-alert-title,.rst-content .wy-alert-success.note .admonition-title,.rst-content .wy-alert-success.note .wy-alert-title,.rst-content .wy-alert-success.seealso .admonition-title,.rst-content .wy-alert-success.seealso .wy-alert-title,.rst-content .wy-alert-success.warning .admonition-title,.rst-content .wy-alert-success.warning .wy-alert-title,.rst-content .wy-alert.wy-alert-success .admonition-title,.wy-alert.wy-alert-success .rst-content .admonition-title,.wy-alert.wy-alert-success .wy-alert-title{background:#1abc9c}.rst-content .wy-alert-neutral.admonition,.rst-content .wy-alert-neutral.admonition-todo,.rst-content .wy-alert-neutral.attention,.rst-content .wy-alert-neutral.caution,.rst-content .wy-alert-neutral.danger,.rst-content .wy-alert-neutral.error,.rst-content .wy-alert-neutral.hint,.rst-content .wy-alert-neutral.important,.rst-content .wy-alert-neutral.note,.rst-content .wy-alert-neutral.seealso,.rst-content .wy-alert-neutral.tip,.rst-content .wy-alert-neutral.warning,.wy-alert.wy-alert-neutral{background:#f3f6f6}.rst-content .wy-alert-neutral.admonition-todo .admonition-title,.rst-content .wy-alert-neutral.admonition-todo .wy-alert-title,.rst-content .wy-alert-neutral.admonition .admonition-title,.rst-content .wy-alert-neutral.admonition .wy-alert-title,.rst-content .wy-alert-neutral.attention .admonition-title,.rst-content .wy-alert-neutral.attention .wy-alert-title,.rst-content .wy-alert-neutral.caution .admonition-title,.rst-content .wy-alert-neutral.caution .wy-alert-title,.rst-content .wy-alert-neutral.danger .admonition-title,.rst-content .wy-alert-neutral.danger .wy-alert-title,.rst-content .wy-alert-neutral.error .admonition-title,.rst-content .wy-alert-neutral.error .wy-alert-title,.rst-content .wy-alert-neutral.hint .admonition-title,.rst-content .wy-alert-neutral.hint .wy-alert-title,.rst-content .wy-alert-neutral.important .admonition-title,.rst-content .wy-alert-neutral.important .wy-alert-title,.rst-content .wy-alert-neutral.note .admonition-title,.rst-content .wy-alert-neutral.note .wy-alert-title,.rst-content .wy-alert-neutral.seealso .admonition-title,.rst-content .wy-alert-neutral.seealso .wy-alert-title,.rst-content .wy-alert-neutral.tip .admonition-title,.rst-content .wy-alert-neutral.tip .wy-alert-title,.rst-content .wy-alert-neutral.warning .admonition-title,.rst-content .wy-alert-neutral.warning .wy-alert-title,.rst-content .wy-alert.wy-alert-neutral .admonition-title,.wy-alert.wy-alert-neutral .rst-content .admonition-title,.wy-alert.wy-alert-neutral .wy-alert-title{color:#404040;background:#e1e4e5}.rst-content .wy-alert-neutral.admonition-todo a,.rst-content .wy-alert-neutral.admonition a,.rst-content .wy-alert-neutral.attention a,.rst-content .wy-alert-neutral.caution a,.rst-content .wy-alert-neutral.danger a,.rst-content .wy-alert-neutral.error a,.rst-content .wy-alert-neutral.hint a,.rst-content .wy-alert-neutral.important a,.rst-content .wy-alert-neutral.note a,.rst-content .wy-alert-neutral.seealso a,.rst-content .wy-alert-neutral.tip a,.rst-content .wy-alert-neutral.warning a,.wy-alert.wy-alert-neutral a{color:#2980b9}.rst-content .admonition-todo p:last-child,.rst-content .admonition p:last-child,.rst-content .attention p:last-child,.rst-content .caution p:last-child,.rst-content .danger p:last-child,.rst-content .error p:last-child,.rst-content .hint p:last-child,.rst-content .important p:last-child,.rst-content .note p:last-child,.rst-content .seealso p:last-child,.rst-content .tip p:last-child,.rst-content .warning p:last-child,.wy-alert p:last-child{margin-bottom:0}.wy-tray-container{position:fixed;bottom:0;left:0;z-index:600}.wy-tray-container li{display:block;width:300px;background:transparent;color:#fff;text-align:center;box-shadow:0 5px 5px 0 rgba(0,0,0,.1);padding:0 24px;min-width:20%;opacity:0;height:0;line-height:56px;overflow:hidden;-webkit-transition:all .3s ease-in;-moz-transition:all .3s ease-in;transition:all .3s ease-in}.wy-tray-container li.wy-tray-item-success{background:#27ae60}.wy-tray-container li.wy-tray-item-info{background:#2980b9}.wy-tray-container li.wy-tray-item-warning{background:#e67e22}.wy-tray-container li.wy-tray-item-danger{background:#e74c3c}.wy-tray-container li.on{opacity:1;height:56px}@media screen and (max-width:768px){.wy-tray-container{bottom:auto;top:0;width:100%}.wy-tray-container li{width:100%}}button{font-size:100%;margin:0;vertical-align:baseline;*vertical-align:middle;cursor:pointer;line-height:normal;-webkit-appearance:button;*overflow:visible}button::-moz-focus-inner,input::-moz-focus-inner{border:0;padding:0}button[disabled]{cursor:default}.btn{display:inline-block;border-radius:2px;line-height:normal;white-space:nowrap;text-align:center;cursor:pointer;font-size:100%;padding:6px 12px 8px;color:#fff;border:1px solid rgba(0,0,0,.1);background-color:#27ae60;text-decoration:none;font-weight:400;font-family:Lato,proxima-nova,Helvetica Neue,Arial,sans-serif;box-shadow:inset 0 1px 2px -1px hsla(0,0%,100%,.5),inset 0 -2px 0 0 rgba(0,0,0,.1);outline-none:false;vertical-align:middle;*display:inline;zoom:1;-webkit-user-drag:none;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;-webkit-transition:all .1s linear;-moz-transition:all .1s linear;transition:all .1s linear}.btn-hover{background:#2e8ece;color:#fff}.btn:hover{background:#2cc36b;color:#fff}.btn:focus{background:#2cc36b;outline:0}.btn:active{box-shadow:inset 0 -1px 0 0 rgba(0,0,0,.05),inset 0 2px 0 0 rgba(0,0,0,.1);padding:8px 12px 6px}.btn:visited{color:#fff}.btn-disabled,.btn-disabled:active,.btn-disabled:focus,.btn-disabled:hover,.btn:disabled{background-image:none;filter:progid:DXImageTransform.Microsoft.gradient(enabled = false);filter:alpha(opacity=40);opacity:.4;cursor:not-allowed;box-shadow:none}.btn::-moz-focus-inner{padding:0;border:0}.btn-small{font-size:80%}.btn-info{background-color:#2980b9!important}.btn-info:hover{background-color:#2e8ece!important}.btn-neutral{background-color:#f3f6f6!important;color:#404040!important}.btn-neutral:hover{background-color:#e5ebeb!important;color:#404040}.btn-neutral:visited{color:#404040!important}.btn-success{background-color:#27ae60!important}.btn-success:hover{background-color:#295!important}.btn-danger{background-color:#e74c3c!important}.btn-danger:hover{background-color:#ea6153!important}.btn-warning{background-color:#e67e22!important}.btn-warning:hover{background-color:#e98b39!important}.btn-invert{background-color:#222}.btn-invert:hover{background-color:#2f2f2f!important}.btn-link{background-color:transparent!important;color:#2980b9;box-shadow:none;border-color:transparent!important}.btn-link:active,.btn-link:hover{background-color:transparent!important;color:#409ad5!important;box-shadow:none}.btn-link:visited{color:#9b59b6}.wy-btn-group .btn,.wy-control .btn{vertical-align:middle}.wy-btn-group{margin-bottom:24px;*zoom:1}.wy-btn-group:after,.wy-btn-group:before{display:table;content:""}.wy-btn-group:after{clear:both}.wy-dropdown{position:relative;display:inline-block}.wy-dropdown-active .wy-dropdown-menu{display:block}.wy-dropdown-menu{position:absolute;left:0;display:none;float:left;top:100%;min-width:100%;background:#fcfcfc;z-index:100;border:1px solid #cfd7dd;box-shadow:0 2px 2px 0 rgba(0,0,0,.1);padding:12px}.wy-dropdown-menu>dd>a{display:block;clear:both;color:#404040;white-space:nowrap;font-size:90%;padding:0 12px;cursor:pointer}.wy-dropdown-menu>dd>a:hover{background:#2980b9;color:#fff}.wy-dropdown-menu>dd.divider{border-top:1px solid #cfd7dd;margin:6px 0}.wy-dropdown-menu>dd.search{padding-bottom:12px}.wy-dropdown-menu>dd.search input[type=search]{width:100%}.wy-dropdown-menu>dd.call-to-action{background:#e3e3e3;text-transform:uppercase;font-weight:500;font-size:80%}.wy-dropdown-menu>dd.call-to-action:hover{background:#e3e3e3}.wy-dropdown-menu>dd.call-to-action .btn{color:#fff}.wy-dropdown.wy-dropdown-up .wy-dropdown-menu{bottom:100%;top:auto;left:auto;right:0}.wy-dropdown.wy-dropdown-bubble .wy-dropdown-menu{background:#fcfcfc;margin-top:2px}.wy-dropdown.wy-dropdown-bubble .wy-dropdown-menu a{padding:6px 12px}.wy-dropdown.wy-dropdown-bubble .wy-dropdown-menu a:hover{background:#2980b9;color:#fff}.wy-dropdown.wy-dropdown-left .wy-dropdown-menu{right:0;left:auto;text-align:right}.wy-dropdown-arrow:before{content:" ";border-bottom:5px solid #f5f5f5;border-left:5px solid transparent;border-right:5px solid transparent;position:absolute;display:block;top:-4px;left:50%;margin-left:-3px}.wy-dropdown-arrow.wy-dropdown-arrow-left:before{left:11px}.wy-form-stacked select{display:block}.wy-form-aligned .wy-help-inline,.wy-form-aligned input,.wy-form-aligned label,.wy-form-aligned select,.wy-form-aligned textarea{display:inline-block;*display:inline;*zoom:1;vertical-align:middle}.wy-form-aligned .wy-control-group>label{display:inline-block;vertical-align:middle;width:10em;margin:6px 12px 0 0;float:left}.wy-form-aligned .wy-control{float:left}.wy-form-aligned .wy-control label{display:block}.wy-form-aligned .wy-control select{margin-top:6px}fieldset{margin:0}fieldset,legend{border:0;padding:0}legend{width:100%;white-space:normal;margin-bottom:24px;font-size:150%;*margin-left:-7px}label,legend{display:block}label{margin:0 0 .3125em;color:#333;font-size:90%}input,select,textarea{font-size:100%;margin:0;vertical-align:baseline;*vertical-align:middle}.wy-control-group{margin-bottom:24px;max-width:1200px;margin-left:auto;margin-right:auto;*zoom:1}.wy-control-group:after,.wy-control-group:before{display:table;content:""}.wy-control-group:after{clear:both}.wy-control-group.wy-control-group-required>label:after{content:" *";color:#e74c3c}.wy-control-group .wy-form-full,.wy-control-group .wy-form-halves,.wy-control-group .wy-form-thirds{padding-bottom:12px}.wy-control-group .wy-form-full input[type=color],.wy-control-group .wy-form-full input[type=date],.wy-control-group .wy-form-full input[type=datetime-local],.wy-control-group .wy-form-full input[type=datetime],.wy-control-group .wy-form-full input[type=email],.wy-control-group .wy-form-full input[type=month],.wy-control-group .wy-form-full input[type=number],.wy-control-group .wy-form-full input[type=password],.wy-control-group .wy-form-full input[type=search],.wy-control-group .wy-form-full input[type=tel],.wy-control-group .wy-form-full input[type=text],.wy-control-group .wy-form-full input[type=time],.wy-control-group .wy-form-full input[type=url],.wy-control-group .wy-form-full input[type=week],.wy-control-group .wy-form-full select,.wy-control-group .wy-form-halves input[type=color],.wy-control-group .wy-form-halves input[type=date],.wy-control-group .wy-form-halves input[type=datetime-local],.wy-control-group .wy-form-halves input[type=datetime],.wy-control-group .wy-form-halves input[type=email],.wy-control-group .wy-form-halves input[type=month],.wy-control-group .wy-form-halves input[type=number],.wy-control-group .wy-form-halves input[type=password],.wy-control-group .wy-form-halves input[type=search],.wy-control-group .wy-form-halves input[type=tel],.wy-control-group .wy-form-halves input[type=text],.wy-control-group .wy-form-halves input[type=time],.wy-control-group .wy-form-halves input[type=url],.wy-control-group .wy-form-halves input[type=week],.wy-control-group .wy-form-halves select,.wy-control-group .wy-form-thirds input[type=color],.wy-control-group .wy-form-thirds input[type=date],.wy-control-group .wy-form-thirds input[type=datetime-local],.wy-control-group .wy-form-thirds input[type=datetime],.wy-control-group .wy-form-thirds input[type=email],.wy-control-group .wy-form-thirds input[type=month],.wy-control-group .wy-form-thirds input[type=number],.wy-control-group .wy-form-thirds input[type=password],.wy-control-group .wy-form-thirds input[type=search],.wy-control-group .wy-form-thirds input[type=tel],.wy-control-group .wy-form-thirds input[type=text],.wy-control-group .wy-form-thirds input[type=time],.wy-control-group .wy-form-thirds input[type=url],.wy-control-group .wy-form-thirds input[type=week],.wy-control-group .wy-form-thirds select{width:100%}.wy-control-group .wy-form-full{float:left;display:block;width:100%;margin-right:0}.wy-control-group .wy-form-full:last-child{margin-right:0}.wy-control-group .wy-form-halves{float:left;display:block;margin-right:2.35765%;width:48.82117%}.wy-control-group .wy-form-halves:last-child,.wy-control-group .wy-form-halves:nth-of-type(2n){margin-right:0}.wy-control-group .wy-form-halves:nth-of-type(odd){clear:left}.wy-control-group .wy-form-thirds{float:left;display:block;margin-right:2.35765%;width:31.76157%}.wy-control-group .wy-form-thirds:last-child,.wy-control-group .wy-form-thirds:nth-of-type(3n){margin-right:0}.wy-control-group .wy-form-thirds:nth-of-type(3n+1){clear:left}.wy-control-group.wy-control-group-no-input .wy-control,.wy-control-no-input{margin:6px 0 0;font-size:90%}.wy-control-no-input{display:inline-block}.wy-control-group.fluid-input input[type=color],.wy-control-group.fluid-input input[type=date],.wy-control-group.fluid-input input[type=datetime-local],.wy-control-group.fluid-input input[type=datetime],.wy-control-group.fluid-input input[type=email],.wy-control-group.fluid-input input[type=month],.wy-control-group.fluid-input input[type=number],.wy-control-group.fluid-input input[type=password],.wy-control-group.fluid-input input[type=search],.wy-control-group.fluid-input input[type=tel],.wy-control-group.fluid-input input[type=text],.wy-control-group.fluid-input input[type=time],.wy-control-group.fluid-input input[type=url],.wy-control-group.fluid-input input[type=week]{width:100%}.wy-form-message-inline{padding-left:.3em;color:#666;font-size:90%}.wy-form-message{display:block;color:#999;font-size:70%;margin-top:.3125em;font-style:italic}.wy-form-message p{font-size:inherit;font-style:italic;margin-bottom:6px}.wy-form-message p:last-child{margin-bottom:0}input{line-height:normal}input[type=button],input[type=reset],input[type=submit]{-webkit-appearance:button;cursor:pointer;font-family:Lato,proxima-nova,Helvetica Neue,Arial,sans-serif;*overflow:visible}input[type=color],input[type=date],input[type=datetime-local],input[type=datetime],input[type=email],input[type=month],input[type=number],input[type=password],input[type=search],input[type=tel],input[type=text],input[type=time],input[type=url],input[type=week]{-webkit-appearance:none;padding:6px;display:inline-block;border:1px solid #ccc;font-size:80%;font-family:Lato,proxima-nova,Helvetica Neue,Arial,sans-serif;box-shadow:inset 0 1px 3px #ddd;border-radius:0;-webkit-transition:border .3s linear;-moz-transition:border .3s linear;transition:border .3s linear}input[type=datetime-local]{padding:.34375em .625em}input[disabled]{cursor:default}input[type=checkbox],input[type=radio]{padding:0;margin-right:.3125em;*height:13px;*width:13px}input[type=checkbox],input[type=radio],input[type=search]{-webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box}input[type=search]::-webkit-search-cancel-button,input[type=search]::-webkit-search-decoration{-webkit-appearance:none}input[type=color]:focus,input[type=date]:focus,input[type=datetime-local]:focus,input[type=datetime]:focus,input[type=email]:focus,input[type=month]:focus,input[type=number]:focus,input[type=password]:focus,input[type=search]:focus,input[type=tel]:focus,input[type=text]:focus,input[type=time]:focus,input[type=url]:focus,input[type=week]:focus{outline:0;outline:thin dotted\9;border-color:#333}input.no-focus:focus{border-color:#ccc!important}input[type=checkbox]:focus,input[type=file]:focus,input[type=radio]:focus{outline:thin dotted #333;outline:1px auto #129fea}input[type=color][disabled],input[type=date][disabled],input[type=datetime-local][disabled],input[type=datetime][disabled],input[type=email][disabled],input[type=month][disabled],input[type=number][disabled],input[type=password][disabled],input[type=search][disabled],input[type=tel][disabled],input[type=text][disabled],input[type=time][disabled],input[type=url][disabled],input[type=week][disabled]{cursor:not-allowed;background-color:#fafafa}input:focus:invalid,select:focus:invalid,textarea:focus:invalid{color:#e74c3c;border:1px solid #e74c3c}input:focus:invalid:focus,select:focus:invalid:focus,textarea:focus:invalid:focus{border-color:#e74c3c}input[type=checkbox]:focus:invalid:focus,input[type=file]:focus:invalid:focus,input[type=radio]:focus:invalid:focus{outline-color:#e74c3c}input.wy-input-large{padding:12px;font-size:100%}textarea{overflow:auto;vertical-align:top;width:100%;font-family:Lato,proxima-nova,Helvetica Neue,Arial,sans-serif}select,textarea{padding:.5em .625em;display:inline-block;border:1px solid #ccc;font-size:80%;box-shadow:inset 0 1px 3px #ddd;-webkit-transition:border .3s linear;-moz-transition:border .3s linear;transition:border .3s linear}select{border:1px solid #ccc;background-color:#fff}select[multiple]{height:auto}select:focus,textarea:focus{outline:0}input[readonly],select[disabled],select[readonly],textarea[disabled],textarea[readonly]{cursor:not-allowed;background-color:#fafafa}input[type=checkbox][disabled],input[type=radio][disabled]{cursor:not-allowed}.wy-checkbox,.wy-radio{margin:6px 0;color:#404040;display:block}.wy-checkbox input,.wy-radio input{vertical-align:baseline}.wy-form-message-inline{display:inline-block;*display:inline;*zoom:1;vertical-align:middle}.wy-input-prefix,.wy-input-suffix{white-space:nowrap;padding:6px}.wy-input-prefix .wy-input-context,.wy-input-suffix .wy-input-context{line-height:27px;padding:0 8px;display:inline-block;font-size:80%;background-color:#f3f6f6;border:1px solid #ccc;color:#999}.wy-input-suffix .wy-input-context{border-left:0}.wy-input-prefix .wy-input-context{border-right:0}.wy-switch{position:relative;display:block;height:24px;margin-top:12px;cursor:pointer}.wy-switch:before{left:0;top:0;width:36px;height:12px;background:#ccc}.wy-switch:after,.wy-switch:before{position:absolute;content:"";display:block;border-radius:4px;-webkit-transition:all .2s ease-in-out;-moz-transition:all .2s ease-in-out;transition:all .2s ease-in-out}.wy-switch:after{width:18px;height:18px;background:#999;left:-3px;top:-3px}.wy-switch span{position:absolute;left:48px;display:block;font-size:12px;color:#ccc;line-height:1}.wy-switch.active:before{background:#1e8449}.wy-switch.active:after{left:24px;background:#27ae60}.wy-switch.disabled{cursor:not-allowed;opacity:.8}.wy-control-group.wy-control-group-error .wy-form-message,.wy-control-group.wy-control-group-error>label{color:#e74c3c}.wy-control-group.wy-control-group-error input[type=color],.wy-control-group.wy-control-group-error input[type=date],.wy-control-group.wy-control-group-error input[type=datetime-local],.wy-control-group.wy-control-group-error input[type=datetime],.wy-control-group.wy-control-group-error input[type=email],.wy-control-group.wy-control-group-error input[type=month],.wy-control-group.wy-control-group-error input[type=number],.wy-control-group.wy-control-group-error input[type=password],.wy-control-group.wy-control-group-error input[type=search],.wy-control-group.wy-control-group-error input[type=tel],.wy-control-group.wy-control-group-error input[type=text],.wy-control-group.wy-control-group-error input[type=time],.wy-control-group.wy-control-group-error input[type=url],.wy-control-group.wy-control-group-error input[type=week],.wy-control-group.wy-control-group-error textarea{border:1px solid #e74c3c}.wy-inline-validate{white-space:nowrap}.wy-inline-validate .wy-input-context{padding:.5em .625em;display:inline-block;font-size:80%}.wy-inline-validate.wy-inline-validate-success .wy-input-context{color:#27ae60}.wy-inline-validate.wy-inline-validate-danger .wy-input-context{color:#e74c3c}.wy-inline-validate.wy-inline-validate-warning .wy-input-context{color:#e67e22}.wy-inline-validate.wy-inline-validate-info .wy-input-context{color:#2980b9}.rotate-90{-webkit-transform:rotate(90deg);-moz-transform:rotate(90deg);-ms-transform:rotate(90deg);-o-transform:rotate(90deg);transform:rotate(90deg)}.rotate-180{-webkit-transform:rotate(180deg);-moz-transform:rotate(180deg);-ms-transform:rotate(180deg);-o-transform:rotate(180deg);transform:rotate(180deg)}.rotate-270{-webkit-transform:rotate(270deg);-moz-transform:rotate(270deg);-ms-transform:rotate(270deg);-o-transform:rotate(270deg);transform:rotate(270deg)}.mirror{-webkit-transform:scaleX(-1);-moz-transform:scaleX(-1);-ms-transform:scaleX(-1);-o-transform:scaleX(-1);transform:scaleX(-1)}.mirror.rotate-90{-webkit-transform:scaleX(-1) rotate(90deg);-moz-transform:scaleX(-1) rotate(90deg);-ms-transform:scaleX(-1) rotate(90deg);-o-transform:scaleX(-1) rotate(90deg);transform:scaleX(-1) rotate(90deg)}.mirror.rotate-180{-webkit-transform:scaleX(-1) rotate(180deg);-moz-transform:scaleX(-1) rotate(180deg);-ms-transform:scaleX(-1) rotate(180deg);-o-transform:scaleX(-1) rotate(180deg);transform:scaleX(-1) rotate(180deg)}.mirror.rotate-270{-webkit-transform:scaleX(-1) rotate(270deg);-moz-transform:scaleX(-1) rotate(270deg);-ms-transform:scaleX(-1) rotate(270deg);-o-transform:scaleX(-1) rotate(270deg);transform:scaleX(-1) rotate(270deg)}@media only screen and (max-width:480px){.wy-form button[type=submit]{margin:.7em 0 0}.wy-form input[type=color],.wy-form input[type=date],.wy-form input[type=datetime-local],.wy-form input[type=datetime],.wy-form input[type=email],.wy-form input[type=month],.wy-form input[type=number],.wy-form input[type=password],.wy-form input[type=search],.wy-form input[type=tel],.wy-form input[type=text],.wy-form input[type=time],.wy-form input[type=url],.wy-form input[type=week],.wy-form label{margin-bottom:.3em;display:block}.wy-form input[type=color],.wy-form input[type=date],.wy-form input[type=datetime-local],.wy-form input[type=datetime],.wy-form input[type=email],.wy-form input[type=month],.wy-form input[type=number],.wy-form input[type=password],.wy-form input[type=search],.wy-form input[type=tel],.wy-form input[type=time],.wy-form input[type=url],.wy-form input[type=week]{margin-bottom:0}.wy-form-aligned .wy-control-group label{margin-bottom:.3em;text-align:left;display:block;width:100%}.wy-form-aligned .wy-control{margin:1.5em 0 0}.wy-form-message,.wy-form-message-inline,.wy-form .wy-help-inline{display:block;font-size:80%;padding:6px 0}}@media screen and (max-width:768px){.tablet-hide{display:none}}@media screen and (max-width:480px){.mobile-hide{display:none}}.float-left{float:left}.float-right{float:right}.full-width{width:100%}.rst-content table.docutils,.rst-content table.field-list,.wy-table{border-collapse:collapse;border-spacing:0;empty-cells:show;margin-bottom:24px}.rst-content table.docutils caption,.rst-content table.field-list caption,.wy-table caption{color:#000;font:italic 85%/1 arial,sans-serif;padding:1em 0;text-align:center}.rst-content table.docutils td,.rst-content table.docutils th,.rst-content table.field-list td,.rst-content table.field-list th,.wy-table td,.wy-table th{font-size:90%;margin:0;overflow:visible;padding:8px 16px}.rst-content table.docutils td:first-child,.rst-content table.docutils th:first-child,.rst-content table.field-list td:first-child,.rst-content table.field-list th:first-child,.wy-table td:first-child,.wy-table th:first-child{border-left-width:0}.rst-content table.docutils thead,.rst-content table.field-list thead,.wy-table thead{color:#000;text-align:left;vertical-align:bottom;white-space:nowrap}.rst-content table.docutils thead th,.rst-content table.field-list thead th,.wy-table thead th{font-weight:700;border-bottom:2px solid #e1e4e5}.rst-content table.docutils td,.rst-content table.field-list td,.wy-table td{background-color:transparent;vertical-align:middle}.rst-content table.docutils td p,.rst-content table.field-list td p,.wy-table td p{line-height:18px}.rst-content table.docutils td p:last-child,.rst-content table.field-list td p:last-child,.wy-table td p:last-child{margin-bottom:0}.rst-content table.docutils .wy-table-cell-min,.rst-content table.field-list .wy-table-cell-min,.wy-table .wy-table-cell-min{width:1%;padding-right:0}.rst-content table.docutils .wy-table-cell-min input[type=checkbox],.rst-content table.field-list .wy-table-cell-min input[type=checkbox],.wy-table .wy-table-cell-min input[type=checkbox]{margin:0}.wy-table-secondary{color:grey;font-size:90%}.wy-table-tertiary{color:grey;font-size:80%}.rst-content table.docutils:not(.field-list) tr:nth-child(2n-1) td,.wy-table-backed,.wy-table-odd td,.wy-table-striped tr:nth-child(2n-1) td{background-color:#f3f6f6}.rst-content table.docutils,.wy-table-bordered-all{border:1px solid #e1e4e5}.rst-content table.docutils td,.wy-table-bordered-all td{border-bottom:1px solid #e1e4e5;border-left:1px solid #e1e4e5}.rst-content table.docutils tbody>tr:last-child td,.wy-table-bordered-all tbody>tr:last-child td{border-bottom-width:0}.wy-table-bordered{border:1px solid #e1e4e5}.wy-table-bordered-rows td{border-bottom:1px solid #e1e4e5}.wy-table-bordered-rows tbody>tr:last-child td{border-bottom-width:0}.wy-table-horizontal td,.wy-table-horizontal th{border-width:0 0 1px;border-bottom:1px solid #e1e4e5}.wy-table-horizontal tbody>tr:last-child td{border-bottom-width:0}.wy-table-responsive{margin-bottom:24px;max-width:100%;overflow:auto}.wy-table-responsive table{margin-bottom:0!important}.wy-table-responsive table td,.wy-table-responsive table th{white-space:nowrap}a{color:#2980b9;text-decoration:none;cursor:pointer}a:hover{color:#3091d1}a:visited{color:#9b59b6}html{height:100%}body,html{overflow-x:hidden}body{font-family:Lato,proxima-nova,Helvetica Neue,Arial,sans-serif;font-weight:400;color:#404040;min-height:100%;background:#edf0f2}.wy-text-left{text-align:left}.wy-text-center{text-align:center}.wy-text-right{text-align:right}.wy-text-large{font-size:120%}.wy-text-normal{font-size:100%}.wy-text-small,small{font-size:80%}.wy-text-strike{text-decoration:line-through}.wy-text-warning{color:#e67e22!important}a.wy-text-warning:hover{color:#eb9950!important}.wy-text-info{color:#2980b9!important}a.wy-text-info:hover{color:#409ad5!important}.wy-text-success{color:#27ae60!important}a.wy-text-success:hover{color:#36d278!important}.wy-text-danger{color:#e74c3c!important}a.wy-text-danger:hover{color:#ed7669!important}.wy-text-neutral{color:#404040!important}a.wy-text-neutral:hover{color:#595959!important}.rst-content .toctree-wrapper>p.caption,h1,h2,h3,h4,h5,h6,legend{margin-top:0;font-weight:700;font-family:Roboto Slab,ff-tisa-web-pro,Georgia,Arial,sans-serif}p{line-height:24px;font-size:16px;margin:0 0 24px}h1{font-size:175%}.rst-content .toctree-wrapper>p.caption,h2{font-size:150%}h3{font-size:125%}h4{font-size:115%}h5{font-size:110%}h6{font-size:100%}hr{display:block;height:1px;border:0;border-top:1px solid #e1e4e5;margin:24px 0;padding:0}.rst-content code,.rst-content tt,code{white-space:nowrap;max-width:100%;background:#fff;border:1px solid #e1e4e5;font-size:75%;padding:0 5px;font-family:SFMono-Regular,Menlo,Monaco,Consolas,Liberation Mono,Courier New,Courier,monospace;color:#e74c3c;overflow-x:auto}.rst-content tt.code-large,code.code-large{font-size:90%}.rst-content .section ul,.rst-content .toctree-wrapper ul,.rst-content section ul,.wy-plain-list-disc,article ul{list-style:disc;line-height:24px;margin-bottom:24px}.rst-content .section ul li,.rst-content .toctree-wrapper ul li,.rst-content section ul li,.wy-plain-list-disc li,article ul li{list-style:disc;margin-left:24px}.rst-content .section ul li p:last-child,.rst-content .section ul li ul,.rst-content .toctree-wrapper ul li p:last-child,.rst-content .toctree-wrapper ul li ul,.rst-content section ul li p:last-child,.rst-content section ul li ul,.wy-plain-list-disc li p:last-child,.wy-plain-list-disc li ul,article ul li p:last-child,article ul li ul{margin-bottom:0}.rst-content .section ul li li,.rst-content .toctree-wrapper ul li li,.rst-content section ul li li,.wy-plain-list-disc li li,article ul li li{list-style:circle}.rst-content .section ul li li li,.rst-content .toctree-wrapper ul li li li,.rst-content section ul li li li,.wy-plain-list-disc li li li,article ul li li li{list-style:square}.rst-content .section ul li ol li,.rst-content .toctree-wrapper ul li ol li,.rst-content section ul li ol li,.wy-plain-list-disc li ol li,article ul li ol li{list-style:decimal}.rst-content .section ol,.rst-content .section ol.arabic,.rst-content .toctree-wrapper ol,.rst-content .toctree-wrapper ol.arabic,.rst-content section ol,.rst-content section ol.arabic,.wy-plain-list-decimal,article ol{list-style:decimal;line-height:24px;margin-bottom:24px}.rst-content .section ol.arabic li,.rst-content .section ol li,.rst-content .toctree-wrapper ol.arabic li,.rst-content .toctree-wrapper ol li,.rst-content section ol.arabic li,.rst-content section ol li,.wy-plain-list-decimal li,article ol li{list-style:decimal;margin-left:24px}.rst-content .section ol.arabic li ul,.rst-content .section ol li p:last-child,.rst-content .section ol li ul,.rst-content .toctree-wrapper ol.arabic li ul,.rst-content .toctree-wrapper ol li p:last-child,.rst-content .toctree-wrapper ol li ul,.rst-content section ol.arabic li ul,.rst-content section ol li p:last-child,.rst-content section ol li ul,.wy-plain-list-decimal li p:last-child,.wy-plain-list-decimal li ul,article ol li p:last-child,article ol li ul{margin-bottom:0}.rst-content .section ol.arabic li ul li,.rst-content .section ol li ul li,.rst-content .toctree-wrapper ol.arabic li ul li,.rst-content .toctree-wrapper ol li ul li,.rst-content section ol.arabic li ul li,.rst-content section ol li ul li,.wy-plain-list-decimal li ul li,article ol li ul li{list-style:disc}.wy-breadcrumbs{*zoom:1}.wy-breadcrumbs:after,.wy-breadcrumbs:before{display:table;content:""}.wy-breadcrumbs:after{clear:both}.wy-breadcrumbs>li{display:inline-block;padding-top:5px}.wy-breadcrumbs>li.wy-breadcrumbs-aside{float:right}.rst-content .wy-breadcrumbs>li code,.rst-content .wy-breadcrumbs>li tt,.wy-breadcrumbs>li .rst-content tt,.wy-breadcrumbs>li code{all:inherit;color:inherit}.breadcrumb-item:before{content:"/";color:#bbb;font-size:13px;padding:0 6px 0 3px}.wy-breadcrumbs-extra{margin-bottom:0;color:#b3b3b3;font-size:80%;display:inline-block}@media screen and (max-width:480px){.wy-breadcrumbs-extra,.wy-breadcrumbs li.wy-breadcrumbs-aside{display:none}}@media print{.wy-breadcrumbs li.wy-breadcrumbs-aside{display:none}}html{font-size:16px}.wy-affix{position:fixed;top:1.618em}.wy-menu a:hover{text-decoration:none}.wy-menu-horiz{*zoom:1}.wy-menu-horiz:after,.wy-menu-horiz:before{display:table;content:""}.wy-menu-horiz:after{clear:both}.wy-menu-horiz li,.wy-menu-horiz ul{display:inline-block}.wy-menu-horiz li:hover{background:hsla(0,0%,100%,.1)}.wy-menu-horiz li.divide-left{border-left:1px solid #404040}.wy-menu-horiz li.divide-right{border-right:1px solid #404040}.wy-menu-horiz a{height:32px;display:inline-block;line-height:32px;padding:0 16px}.wy-menu-vertical{width:300px}.wy-menu-vertical header,.wy-menu-vertical p.caption{color:#55a5d9;height:32px;line-height:32px;padding:0 1.618em;margin:12px 0 0;display:block;font-weight:700;text-transform:uppercase;font-size:85%;white-space:nowrap}.wy-menu-vertical ul{margin-bottom:0}.wy-menu-vertical li.divide-top{border-top:1px solid #404040}.wy-menu-vertical li.divide-bottom{border-bottom:1px solid #404040}.wy-menu-vertical li.current{background:#e3e3e3}.wy-menu-vertical li.current a{color:grey;border-right:1px solid #c9c9c9;padding:.4045em 2.427em}.wy-menu-vertical li.current a:hover{background:#d6d6d6}.rst-content .wy-menu-vertical li tt,.wy-menu-vertical li .rst-content tt,.wy-menu-vertical li code{border:none;background:inherit;color:inherit;padding-left:0;padding-right:0}.wy-menu-vertical li button.toctree-expand{display:block;float:left;margin-left:-1.2em;line-height:18px;color:#4d4d4d;border:none;background:none;padding:0}.wy-menu-vertical li.current>a,.wy-menu-vertical li.on a{color:#404040;font-weight:700;position:relative;background:#fcfcfc;border:none;padding:.4045em 1.618em}.wy-menu-vertical li.current>a:hover,.wy-menu-vertical li.on a:hover{background:#fcfcfc}.wy-menu-vertical li.current>a:hover button.toctree-expand,.wy-menu-vertical li.on a:hover button.toctree-expand{color:grey}.wy-menu-vertical li.current>a button.toctree-expand,.wy-menu-vertical li.on a button.toctree-expand{display:block;line-height:18px;color:#333}.wy-menu-vertical li.toctree-l1.current>a{border-bottom:1px solid #c9c9c9;border-top:1px solid #c9c9c9}.wy-menu-vertical .toctree-l1.current .toctree-l2>ul,.wy-menu-vertical .toctree-l2.current .toctree-l3>ul,.wy-menu-vertical .toctree-l3.current .toctree-l4>ul,.wy-menu-vertical .toctree-l4.current .toctree-l5>ul,.wy-menu-vertical .toctree-l5.current .toctree-l6>ul,.wy-menu-vertical .toctree-l6.current .toctree-l7>ul,.wy-menu-vertical .toctree-l7.current .toctree-l8>ul,.wy-menu-vertical .toctree-l8.current .toctree-l9>ul,.wy-menu-vertical .toctree-l9.current .toctree-l10>ul,.wy-menu-vertical .toctree-l10.current .toctree-l11>ul{display:none}.wy-menu-vertical .toctree-l1.current .current.toctree-l2>ul,.wy-menu-vertical .toctree-l2.current .current.toctree-l3>ul,.wy-menu-vertical .toctree-l3.current .current.toctree-l4>ul,.wy-menu-vertical .toctree-l4.current .current.toctree-l5>ul,.wy-menu-vertical .toctree-l5.current .current.toctree-l6>ul,.wy-menu-vertical .toctree-l6.current .current.toctree-l7>ul,.wy-menu-vertical .toctree-l7.current .current.toctree-l8>ul,.wy-menu-vertical .toctree-l8.current .current.toctree-l9>ul,.wy-menu-vertical .toctree-l9.current .current.toctree-l10>ul,.wy-menu-vertical .toctree-l10.current .current.toctree-l11>ul{display:block}.wy-menu-vertical li.toctree-l3,.wy-menu-vertical li.toctree-l4{font-size:.9em}.wy-menu-vertical li.toctree-l2 a,.wy-menu-vertical li.toctree-l3 a,.wy-menu-vertical li.toctree-l4 a,.wy-menu-vertical li.toctree-l5 a,.wy-menu-vertical li.toctree-l6 a,.wy-menu-vertical li.toctree-l7 a,.wy-menu-vertical li.toctree-l8 a,.wy-menu-vertical li.toctree-l9 a,.wy-menu-vertical li.toctree-l10 a{color:#404040}.wy-menu-vertical li.toctree-l2 a:hover button.toctree-expand,.wy-menu-vertical li.toctree-l3 a:hover button.toctree-expand,.wy-menu-vertical li.toctree-l4 a:hover button.toctree-expand,.wy-menu-vertical li.toctree-l5 a:hover button.toctree-expand,.wy-menu-vertical li.toctree-l6 a:hover button.toctree-expand,.wy-menu-vertical li.toctree-l7 a:hover button.toctree-expand,.wy-menu-vertical li.toctree-l8 a:hover button.toctree-expand,.wy-menu-vertical li.toctree-l9 a:hover button.toctree-expand,.wy-menu-vertical li.toctree-l10 a:hover button.toctree-expand{color:grey}.wy-menu-vertical li.toctree-l2.current li.toctree-l3>a,.wy-menu-vertical li.toctree-l3.current li.toctree-l4>a,.wy-menu-vertical li.toctree-l4.current li.toctree-l5>a,.wy-menu-vertical li.toctree-l5.current li.toctree-l6>a,.wy-menu-vertical li.toctree-l6.current li.toctree-l7>a,.wy-menu-vertical li.toctree-l7.current li.toctree-l8>a,.wy-menu-vertical li.toctree-l8.current li.toctree-l9>a,.wy-menu-vertical li.toctree-l9.current li.toctree-l10>a,.wy-menu-vertical li.toctree-l10.current li.toctree-l11>a{display:block}.wy-menu-vertical li.toctree-l2.current>a{padding:.4045em 2.427em}.wy-menu-vertical li.toctree-l2.current li.toctree-l3>a{padding:.4045em 1.618em .4045em 4.045em}.wy-menu-vertical li.toctree-l3.current>a{padding:.4045em 4.045em}.wy-menu-vertical li.toctree-l3.current li.toctree-l4>a{padding:.4045em 1.618em .4045em 5.663em}.wy-menu-vertical li.toctree-l4.current>a{padding:.4045em 5.663em}.wy-menu-vertical li.toctree-l4.current li.toctree-l5>a{padding:.4045em 1.618em .4045em 7.281em}.wy-menu-vertical li.toctree-l5.current>a{padding:.4045em 7.281em}.wy-menu-vertical li.toctree-l5.current li.toctree-l6>a{padding:.4045em 1.618em .4045em 8.899em}.wy-menu-vertical li.toctree-l6.current>a{padding:.4045em 8.899em}.wy-menu-vertical li.toctree-l6.current li.toctree-l7>a{padding:.4045em 1.618em .4045em 10.517em}.wy-menu-vertical li.toctree-l7.current>a{padding:.4045em 10.517em}.wy-menu-vertical li.toctree-l7.current li.toctree-l8>a{padding:.4045em 1.618em .4045em 12.135em}.wy-menu-vertical li.toctree-l8.current>a{padding:.4045em 12.135em}.wy-menu-vertical li.toctree-l8.current li.toctree-l9>a{padding:.4045em 1.618em .4045em 13.753em}.wy-menu-vertical li.toctree-l9.current>a{padding:.4045em 13.753em}.wy-menu-vertical li.toctree-l9.current li.toctree-l10>a{padding:.4045em 1.618em .4045em 15.371em}.wy-menu-vertical li.toctree-l10.current>a{padding:.4045em 15.371em}.wy-menu-vertical li.toctree-l10.current li.toctree-l11>a{padding:.4045em 1.618em .4045em 16.989em}.wy-menu-vertical li.toctree-l2.current>a,.wy-menu-vertical li.toctree-l2.current li.toctree-l3>a{background:#c9c9c9}.wy-menu-vertical li.toctree-l2 button.toctree-expand{color:#a3a3a3}.wy-menu-vertical li.toctree-l3.current>a,.wy-menu-vertical li.toctree-l3.current li.toctree-l4>a{background:#bdbdbd}.wy-menu-vertical li.toctree-l3 button.toctree-expand{color:#969696}.wy-menu-vertical li.current ul{display:block}.wy-menu-vertical li ul{margin-bottom:0;display:none}.wy-menu-vertical li ul li a{margin-bottom:0;color:#d9d9d9;font-weight:400}.wy-menu-vertical a{line-height:18px;padding:.4045em 1.618em;display:block;position:relative;font-size:90%;color:#d9d9d9}.wy-menu-vertical a:hover{background-color:#4e4a4a;cursor:pointer}.wy-menu-vertical a:hover button.toctree-expand{color:#d9d9d9}.wy-menu-vertical a:active{background-color:#2980b9;cursor:pointer;color:#fff}.wy-menu-vertical a:active button.toctree-expand{color:#fff}.wy-side-nav-search{display:block;width:300px;padding:.809em;margin-bottom:.809em;z-index:200;background-color:#2980b9;text-align:center;color:#fcfcfc}.wy-side-nav-search input[type=text]{width:100%;border-radius:50px;padding:6px 12px;border-color:#2472a4}.wy-side-nav-search img{display:block;margin:auto auto .809em;height:45px;width:45px;background-color:#2980b9;padding:5px;border-radius:100%}.wy-side-nav-search .wy-dropdown>a,.wy-side-nav-search>a{color:#fcfcfc;font-size:100%;font-weight:700;display:inline-block;padding:4px 6px;margin-bottom:.809em;max-width:100%}.wy-side-nav-search .wy-dropdown>a:hover,.wy-side-nav-search>a:hover{background:hsla(0,0%,100%,.1)}.wy-side-nav-search .wy-dropdown>a img.logo,.wy-side-nav-search>a img.logo{display:block;margin:0 auto;height:auto;width:auto;border-radius:0;max-width:100%;background:transparent}.wy-side-nav-search .wy-dropdown>a.icon img.logo,.wy-side-nav-search>a.icon img.logo{margin-top:.85em}.wy-side-nav-search>div.version{margin-top:-.4045em;margin-bottom:.809em;font-weight:400;color:hsla(0,0%,100%,.3)}.wy-nav .wy-menu-vertical header{color:#2980b9}.wy-nav .wy-menu-vertical a{color:#b3b3b3}.wy-nav .wy-menu-vertical a:hover{background-color:#2980b9;color:#fff}[data-menu-wrap]{-webkit-transition:all .2s ease-in;-moz-transition:all .2s ease-in;transition:all .2s ease-in;position:absolute;opacity:1;width:100%;opacity:0}[data-menu-wrap].move-center{left:0;right:auto;opacity:1}[data-menu-wrap].move-left{right:auto;left:-100%;opacity:0}[data-menu-wrap].move-right{right:-100%;left:auto;opacity:0}.wy-body-for-nav{background:#fcfcfc}.wy-grid-for-nav{position:absolute;width:100%;height:100%}.wy-nav-side{position:fixed;top:0;bottom:0;left:0;padding-bottom:2em;width:300px;overflow-x:hidden;overflow-y:hidden;min-height:100%;color:#9b9b9b;background:#343131;z-index:200}.wy-side-scroll{width:320px;position:relative;overflow-x:hidden;overflow-y:scroll;height:100%}.wy-nav-top{display:none;background:#2980b9;color:#fff;padding:.4045em .809em;position:relative;line-height:50px;text-align:center;font-size:100%;*zoom:1}.wy-nav-top:after,.wy-nav-top:before{display:table;content:""}.wy-nav-top:after{clear:both}.wy-nav-top a{color:#fff;font-weight:700}.wy-nav-top img{margin-right:12px;height:45px;width:45px;background-color:#2980b9;padding:5px;border-radius:100%}.wy-nav-top i{font-size:30px;float:left;cursor:pointer;padding-top:inherit}.wy-nav-content-wrap{margin-left:300px;background:#fcfcfc;min-height:100%}.wy-nav-content{padding:1.618em 3.236em;height:100%;max-width:800px;margin:auto}.wy-body-mask{position:fixed;width:100%;height:100%;background:rgba(0,0,0,.2);display:none;z-index:499}.wy-body-mask.on{display:block}footer{color:grey}footer p{margin-bottom:12px}.rst-content footer span.commit tt,footer span.commit .rst-content tt,footer span.commit code{padding:0;font-family:SFMono-Regular,Menlo,Monaco,Consolas,Liberation Mono,Courier New,Courier,monospace;font-size:1em;background:none;border:none;color:grey}.rst-footer-buttons{*zoom:1}.rst-footer-buttons:after,.rst-footer-buttons:before{width:100%;display:table;content:""}.rst-footer-buttons:after{clear:both}.rst-breadcrumbs-buttons{margin-top:12px;*zoom:1}.rst-breadcrumbs-buttons:after,.rst-breadcrumbs-buttons:before{display:table;content:""}.rst-breadcrumbs-buttons:after{clear:both}#search-results .search li{margin-bottom:24px;border-bottom:1px solid #e1e4e5;padding-bottom:24px}#search-results .search li:first-child{border-top:1px solid #e1e4e5;padding-top:24px}#search-results .search li a{font-size:120%;margin-bottom:12px;display:inline-block}#search-results .context{color:grey;font-size:90%}.genindextable li>ul{margin-left:24px}@media screen and (max-width:768px){.wy-body-for-nav{background:#fcfcfc}.wy-nav-top{display:block}.wy-nav-side{left:-300px}.wy-nav-side.shift{width:85%;left:0}.wy-menu.wy-menu-vertical,.wy-side-nav-search,.wy-side-scroll{width:auto}.wy-nav-content-wrap{margin-left:0}.wy-nav-content-wrap .wy-nav-content{padding:1.618em}.wy-nav-content-wrap.shift{position:fixed;min-width:100%;left:85%;top:0;height:100%;overflow:hidden}}@media screen and (min-width:1100px){.wy-nav-content-wrap{background:rgba(0,0,0,.05)}.wy-nav-content{margin:0;background:#fcfcfc}}@media print{.rst-versions,.wy-nav-side,footer{display:none}.wy-nav-content-wrap{margin-left:0}}.rst-versions{position:fixed;bottom:0;left:0;width:300px;color:#fcfcfc;background:#1f1d1d;font-family:Lato,proxima-nova,Helvetica Neue,Arial,sans-serif;z-index:400}.rst-versions a{color:#2980b9;text-decoration:none}.rst-versions .rst-badge-small{display:none}.rst-versions .rst-current-version{padding:12px;background-color:#272525;display:block;text-align:right;font-size:90%;cursor:pointer;color:#27ae60;*zoom:1}.rst-versions .rst-current-version:after,.rst-versions .rst-current-version:before{display:table;content:""}.rst-versions .rst-current-version:after{clear:both}.rst-content .code-block-caption .rst-versions .rst-current-version .headerlink,.rst-content .eqno .rst-versions .rst-current-version .headerlink,.rst-content .rst-versions .rst-current-version .admonition-title,.rst-content code.download .rst-versions .rst-current-version span:first-child,.rst-content dl dt .rst-versions .rst-current-version .headerlink,.rst-content h1 .rst-versions .rst-current-version .headerlink,.rst-content h2 .rst-versions .rst-current-version .headerlink,.rst-content h3 .rst-versions .rst-current-version .headerlink,.rst-content h4 .rst-versions .rst-current-version .headerlink,.rst-content h5 .rst-versions .rst-current-version .headerlink,.rst-content h6 .rst-versions .rst-current-version .headerlink,.rst-content p .rst-versions .rst-current-version .headerlink,.rst-content table>caption .rst-versions .rst-current-version .headerlink,.rst-content tt.download .rst-versions .rst-current-version span:first-child,.rst-versions .rst-current-version .fa,.rst-versions .rst-current-version .icon,.rst-versions .rst-current-version .rst-content .admonition-title,.rst-versions .rst-current-version .rst-content .code-block-caption .headerlink,.rst-versions .rst-current-version .rst-content .eqno .headerlink,.rst-versions .rst-current-version .rst-content code.download span:first-child,.rst-versions .rst-current-version .rst-content dl dt .headerlink,.rst-versions .rst-current-version .rst-content h1 .headerlink,.rst-versions .rst-current-version .rst-content h2 .headerlink,.rst-versions .rst-current-version .rst-content h3 .headerlink,.rst-versions .rst-current-version .rst-content h4 .headerlink,.rst-versions .rst-current-version .rst-content h5 .headerlink,.rst-versions .rst-current-version .rst-content h6 .headerlink,.rst-versions .rst-current-version .rst-content p .headerlink,.rst-versions .rst-current-version .rst-content table>caption .headerlink,.rst-versions .rst-current-version .rst-content tt.download span:first-child,.rst-versions .rst-current-version .wy-menu-vertical li button.toctree-expand,.wy-menu-vertical li .rst-versions .rst-current-version button.toctree-expand{color:#fcfcfc}.rst-versions .rst-current-version .fa-book,.rst-versions .rst-current-version .icon-book{float:left}.rst-versions .rst-current-version.rst-out-of-date{background-color:#e74c3c;color:#fff}.rst-versions .rst-current-version.rst-active-old-version{background-color:#f1c40f;color:#000}.rst-versions.shift-up{height:auto;max-height:100%;overflow-y:scroll}.rst-versions.shift-up .rst-other-versions{display:block}.rst-versions .rst-other-versions{font-size:90%;padding:12px;color:grey;display:none}.rst-versions .rst-other-versions hr{display:block;height:1px;border:0;margin:20px 0;padding:0;border-top:1px solid #413d3d}.rst-versions .rst-other-versions dd{display:inline-block;margin:0}.rst-versions .rst-other-versions dd a{display:inline-block;padding:6px;color:#fcfcfc}.rst-versions.rst-badge{width:auto;bottom:20px;right:20px;left:auto;border:none;max-width:300px;max-height:90%}.rst-versions.rst-badge .fa-book,.rst-versions.rst-badge .icon-book{float:none;line-height:30px}.rst-versions.rst-badge.shift-up .rst-current-version{text-align:right}.rst-versions.rst-badge.shift-up .rst-current-version .fa-book,.rst-versions.rst-badge.shift-up .rst-current-version .icon-book{float:left}.rst-versions.rst-badge>.rst-current-version{width:auto;height:30px;line-height:30px;padding:0 6px;display:block;text-align:center}@media screen and (max-width:768px){.rst-versions{width:85%;display:none}.rst-versions.shift{display:block}}.rst-content .toctree-wrapper>p.caption,.rst-content h1,.rst-content h2,.rst-content h3,.rst-content h4,.rst-content h5,.rst-content h6{margin-bottom:24px}.rst-content img{max-width:100%;height:auto}.rst-content div.figure,.rst-content figure{margin-bottom:24px}.rst-content div.figure .caption-text,.rst-content figure .caption-text{font-style:italic}.rst-content div.figure p:last-child.caption,.rst-content figure p:last-child.caption{margin-bottom:0}.rst-content div.figure.align-center,.rst-content figure.align-center{text-align:center}.rst-content .section>a>img,.rst-content .section>img,.rst-content section>a>img,.rst-content section>img{margin-bottom:24px}.rst-content abbr[title]{text-decoration:none}.rst-content.style-external-links a.reference.external:after{font-family:FontAwesome;content:"\f08e";color:#b3b3b3;vertical-align:super;font-size:60%;margin:0 .2em}.rst-content blockquote{margin-left:24px;line-height:24px;margin-bottom:24px}.rst-content pre.literal-block{white-space:pre;margin:0;padding:12px;font-family:SFMono-Regular,Menlo,Monaco,Consolas,Liberation Mono,Courier New,Courier,monospace;display:block;overflow:auto}.rst-content div[class^=highlight],.rst-content pre.literal-block{border:1px solid #e1e4e5;overflow-x:auto;margin:1px 0 24px}.rst-content div[class^=highlight] div[class^=highlight],.rst-content pre.literal-block div[class^=highlight]{padding:0;border:none;margin:0}.rst-content div[class^=highlight] td.code{width:100%}.rst-content .linenodiv pre{border-right:1px solid #e6e9ea;margin:0;padding:12px;font-family:SFMono-Regular,Menlo,Monaco,Consolas,Liberation Mono,Courier New,Courier,monospace;user-select:none;pointer-events:none}.rst-content div[class^=highlight] pre{white-space:pre;margin:0;padding:12px;display:block;overflow:auto}.rst-content div[class^=highlight] pre .hll{display:block;margin:0 -12px;padding:0 12px}.rst-content .linenodiv pre,.rst-content div[class^=highlight] pre,.rst-content pre.literal-block{font-family:SFMono-Regular,Menlo,Monaco,Consolas,Liberation Mono,Courier New,Courier,monospace;font-size:12px;line-height:1.4}.rst-content div.highlight .gp,.rst-content div.highlight span.linenos{user-select:none;pointer-events:none}.rst-content div.highlight span.linenos{display:inline-block;padding-left:0;padding-right:12px;margin-right:12px;border-right:1px solid #e6e9ea}.rst-content .code-block-caption{font-style:italic;font-size:85%;line-height:1;padding:1em 0;text-align:center}@media print{.rst-content .codeblock,.rst-content div[class^=highlight],.rst-content div[class^=highlight] pre{white-space:pre-wrap}}.rst-content .admonition,.rst-content .admonition-todo,.rst-content .attention,.rst-content .caution,.rst-content .danger,.rst-content .error,.rst-content .hint,.rst-content .important,.rst-content .note,.rst-content .seealso,.rst-content .tip,.rst-content .warning{clear:both}.rst-content .admonition-todo .last,.rst-content .admonition-todo>:last-child,.rst-content .admonition .last,.rst-content .admonition>:last-child,.rst-content .attention .last,.rst-content .attention>:last-child,.rst-content .caution .last,.rst-content .caution>:last-child,.rst-content .danger .last,.rst-content .danger>:last-child,.rst-content .error .last,.rst-content .error>:last-child,.rst-content .hint .last,.rst-content .hint>:last-child,.rst-content .important .last,.rst-content .important>:last-child,.rst-content .note .last,.rst-content .note>:last-child,.rst-content .seealso .last,.rst-content .seealso>:last-child,.rst-content .tip .last,.rst-content .tip>:last-child,.rst-content .warning .last,.rst-content .warning>:last-child{margin-bottom:0}.rst-content .admonition-title:before{margin-right:4px}.rst-content .admonition table{border-color:rgba(0,0,0,.1)}.rst-content .admonition table td,.rst-content .admonition table th{background:transparent!important;border-color:rgba(0,0,0,.1)!important}.rst-content .section ol.loweralpha,.rst-content .section ol.loweralpha>li,.rst-content .toctree-wrapper ol.loweralpha,.rst-content .toctree-wrapper ol.loweralpha>li,.rst-content section ol.loweralpha,.rst-content section ol.loweralpha>li{list-style:lower-alpha}.rst-content .section ol.upperalpha,.rst-content .section ol.upperalpha>li,.rst-content .toctree-wrapper ol.upperalpha,.rst-content .toctree-wrapper ol.upperalpha>li,.rst-content section ol.upperalpha,.rst-content section ol.upperalpha>li{list-style:upper-alpha}.rst-content .section ol li>*,.rst-content .section ul li>*,.rst-content .toctree-wrapper ol li>*,.rst-content .toctree-wrapper ul li>*,.rst-content section ol li>*,.rst-content section ul li>*{margin-top:12px;margin-bottom:12px}.rst-content .section ol li>:first-child,.rst-content .section ul li>:first-child,.rst-content .toctree-wrapper ol li>:first-child,.rst-content .toctree-wrapper ul li>:first-child,.rst-content section ol li>:first-child,.rst-content section ul li>:first-child{margin-top:0}.rst-content .section ol li>p,.rst-content .section ol li>p:last-child,.rst-content .section ul li>p,.rst-content .section ul li>p:last-child,.rst-content .toctree-wrapper ol li>p,.rst-content .toctree-wrapper ol li>p:last-child,.rst-content .toctree-wrapper ul li>p,.rst-content .toctree-wrapper ul li>p:last-child,.rst-content section ol li>p,.rst-content section ol li>p:last-child,.rst-content section ul li>p,.rst-content section ul li>p:last-child{margin-bottom:12px}.rst-content .section ol li>p:only-child,.rst-content .section ol li>p:only-child:last-child,.rst-content .section ul li>p:only-child,.rst-content .section ul li>p:only-child:last-child,.rst-content .toctree-wrapper ol li>p:only-child,.rst-content .toctree-wrapper ol li>p:only-child:last-child,.rst-content .toctree-wrapper ul li>p:only-child,.rst-content .toctree-wrapper ul li>p:only-child:last-child,.rst-content section ol li>p:only-child,.rst-content section ol li>p:only-child:last-child,.rst-content section ul li>p:only-child,.rst-content section ul li>p:only-child:last-child{margin-bottom:0}.rst-content .section ol li>ol,.rst-content .section ol li>ul,.rst-content .section ul li>ol,.rst-content .section ul li>ul,.rst-content .toctree-wrapper ol li>ol,.rst-content .toctree-wrapper ol li>ul,.rst-content .toctree-wrapper ul li>ol,.rst-content .toctree-wrapper ul li>ul,.rst-content section ol li>ol,.rst-content section ol li>ul,.rst-content section ul li>ol,.rst-content section ul li>ul{margin-bottom:12px}.rst-content .section ol.simple li>*,.rst-content .section ol.simple li ol,.rst-content .section ol.simple li ul,.rst-content .section ul.simple li>*,.rst-content .section ul.simple li ol,.rst-content .section ul.simple li ul,.rst-content .toctree-wrapper ol.simple li>*,.rst-content .toctree-wrapper ol.simple li ol,.rst-content .toctree-wrapper ol.simple li ul,.rst-content .toctree-wrapper ul.simple li>*,.rst-content .toctree-wrapper ul.simple li ol,.rst-content .toctree-wrapper ul.simple li ul,.rst-content section ol.simple li>*,.rst-content section ol.simple li ol,.rst-content section ol.simple li ul,.rst-content section ul.simple li>*,.rst-content section ul.simple li ol,.rst-content section ul.simple li ul{margin-top:0;margin-bottom:0}.rst-content .line-block{margin-left:0;margin-bottom:24px;line-height:24px}.rst-content .line-block .line-block{margin-left:24px;margin-bottom:0}.rst-content .topic-title{font-weight:700;margin-bottom:12px}.rst-content .toc-backref{color:#404040}.rst-content .align-right{float:right;margin:0 0 24px 24px}.rst-content .align-left{float:left;margin:0 24px 24px 0}.rst-content .align-center{margin:auto}.rst-content .align-center:not(table){display:block}.rst-content .code-block-caption .headerlink,.rst-content .eqno .headerlink,.rst-content .toctree-wrapper>p.caption .headerlink,.rst-content dl dt .headerlink,.rst-content h1 .headerlink,.rst-content h2 .headerlink,.rst-content h3 .headerlink,.rst-content h4 .headerlink,.rst-content h5 .headerlink,.rst-content h6 .headerlink,.rst-content p.caption .headerlink,.rst-content p .headerlink,.rst-content table>caption .headerlink{opacity:0;font-size:14px;font-family:FontAwesome;margin-left:.5em}.rst-content .code-block-caption .headerlink:focus,.rst-content .code-block-caption:hover .headerlink,.rst-content .eqno .headerlink:focus,.rst-content .eqno:hover .headerlink,.rst-content .toctree-wrapper>p.caption .headerlink:focus,.rst-content .toctree-wrapper>p.caption:hover .headerlink,.rst-content dl dt .headerlink:focus,.rst-content dl dt:hover .headerlink,.rst-content h1 .headerlink:focus,.rst-content h1:hover .headerlink,.rst-content h2 .headerlink:focus,.rst-content h2:hover .headerlink,.rst-content h3 .headerlink:focus,.rst-content h3:hover .headerlink,.rst-content h4 .headerlink:focus,.rst-content h4:hover .headerlink,.rst-content h5 .headerlink:focus,.rst-content h5:hover .headerlink,.rst-content h6 .headerlink:focus,.rst-content h6:hover .headerlink,.rst-content p.caption .headerlink:focus,.rst-content p.caption:hover .headerlink,.rst-content p .headerlink:focus,.rst-content p:hover .headerlink,.rst-content table>caption .headerlink:focus,.rst-content table>caption:hover .headerlink{opacity:1}.rst-content p a{overflow-wrap:anywhere}.rst-content .wy-table td p,.rst-content .wy-table td ul,.rst-content .wy-table th p,.rst-content .wy-table th ul,.rst-content table.docutils td p,.rst-content table.docutils td ul,.rst-content table.docutils th p,.rst-content table.docutils th ul,.rst-content table.field-list td p,.rst-content table.field-list td ul,.rst-content table.field-list th p,.rst-content table.field-list th ul{font-size:inherit}.rst-content .btn:focus{outline:2px solid}.rst-content table>caption .headerlink:after{font-size:12px}.rst-content .centered{text-align:center}.rst-content .sidebar{float:right;width:40%;display:block;margin:0 0 24px 24px;padding:24px;background:#f3f6f6;border:1px solid #e1e4e5}.rst-content .sidebar dl,.rst-content .sidebar p,.rst-content .sidebar ul{font-size:90%}.rst-content .sidebar .last,.rst-content .sidebar>:last-child{margin-bottom:0}.rst-content .sidebar .sidebar-title{display:block;font-family:Roboto Slab,ff-tisa-web-pro,Georgia,Arial,sans-serif;font-weight:700;background:#e1e4e5;padding:6px 12px;margin:-24px -24px 24px;font-size:100%}.rst-content .highlighted{background:#f1c40f;box-shadow:0 0 0 2px #f1c40f;display:inline;font-weight:700}.rst-content .citation-reference,.rst-content .footnote-reference{vertical-align:baseline;position:relative;top:-.4em;line-height:0;font-size:90%}.rst-content .hlist{width:100%}.rst-content dl dt span.classifier:before{content:" : "}.rst-content dl dt span.classifier-delimiter{display:none!important}html.writer-html4 .rst-content table.docutils.citation,html.writer-html4 .rst-content table.docutils.footnote{background:none;border:none}html.writer-html4 .rst-content table.docutils.citation td,html.writer-html4 .rst-content table.docutils.citation tr,html.writer-html4 .rst-content table.docutils.footnote td,html.writer-html4 .rst-content table.docutils.footnote tr{border:none;background-color:transparent!important;white-space:normal}html.writer-html4 .rst-content table.docutils.citation td.label,html.writer-html4 .rst-content table.docutils.footnote td.label{padding-left:0;padding-right:0;vertical-align:top}html.writer-html5 .rst-content dl.citation,html.writer-html5 .rst-content dl.field-list,html.writer-html5 .rst-content dl.footnote{display:grid;grid-template-columns:max-content auto}html.writer-html5 .rst-content dl.citation>dt,html.writer-html5 .rst-content dl.field-list>dt,html.writer-html5 .rst-content dl.footnote>dt{padding-left:1rem}html.writer-html5 .rst-content dl.citation>dt:after,html.writer-html5 .rst-content dl.field-list>dt:after,html.writer-html5 .rst-content dl.footnote>dt:after{content:":"}html.writer-html5 .rst-content dl.citation>dd,html.writer-html5 .rst-content dl.citation>dt,html.writer-html5 .rst-content dl.field-list>dd,html.writer-html5 .rst-content dl.field-list>dt,html.writer-html5 .rst-content dl.footnote>dd,html.writer-html5 .rst-content dl.footnote>dt{margin-bottom:0}html.writer-html5 .rst-content dl.citation,html.writer-html5 .rst-content dl.footnote{font-size:.9rem}html.writer-html5 .rst-content dl.citation>dt,html.writer-html5 .rst-content dl.footnote>dt{margin:0 .5rem .5rem 0;line-height:1.2rem;word-break:break-all;font-weight:400}html.writer-html5 .rst-content dl.citation>dt>span.brackets,html.writer-html5 .rst-content dl.footnote>dt>span.brackets{margin-right:.5rem}html.writer-html5 .rst-content dl.citation>dt>span.brackets:before,html.writer-html5 .rst-content dl.footnote>dt>span.brackets:before{content:"["}html.writer-html5 .rst-content dl.citation>dt>span.brackets:after,html.writer-html5 .rst-content dl.footnote>dt>span.brackets:after{content:"]"}html.writer-html5 .rst-content dl.citation>dt>span.fn-backref,html.writer-html5 .rst-content dl.footnote>dt>span.fn-backref{font-style:italic}html.writer-html5 .rst-content dl.citation>dd,html.writer-html5 .rst-content dl.footnote>dd{margin:0 0 .5rem;line-height:1.2rem}html.writer-html5 .rst-content dl.citation>dd p,html.writer-html5 .rst-content dl.footnote>dd p,html.writer-html5 .rst-content dl.option-list kbd{font-size:.9rem}.rst-content dl.citation,.rst-content table.docutils.footnote,html.writer-html4 .rst-content table.docutils.citation,html.writer-html5 .rst-content dl.footnote{color:grey}.rst-content dl.citation code,.rst-content dl.citation tt,.rst-content table.docutils.footnote code,.rst-content table.docutils.footnote tt,html.writer-html4 .rst-content table.docutils.citation code,html.writer-html4 .rst-content table.docutils.citation tt,html.writer-html5 .rst-content dl.footnote code,html.writer-html5 .rst-content dl.footnote tt{color:#555}.rst-content .wy-table-responsive.citation,.rst-content .wy-table-responsive.footnote{margin-bottom:0}.rst-content .wy-table-responsive.citation+:not(.citation),.rst-content .wy-table-responsive.footnote+:not(.footnote){margin-top:24px}.rst-content .wy-table-responsive.citation:last-child,.rst-content .wy-table-responsive.footnote:last-child{margin-bottom:24px}.rst-content table.docutils th{border-color:#e1e4e5}html.writer-html5 .rst-content table.docutils th{border:1px solid #e1e4e5}html.writer-html5 .rst-content table.docutils td>p,html.writer-html5 .rst-content table.docutils th>p{line-height:1rem;margin-bottom:0;font-size:.9rem}.rst-content table.docutils td .last,.rst-content table.docutils td .last>:last-child{margin-bottom:0}.rst-content table.field-list,.rst-content table.field-list td{border:none}.rst-content table.field-list td p{line-height:inherit}.rst-content table.field-list td>strong{display:inline-block}.rst-content table.field-list .field-name{padding-right:10px;text-align:left;white-space:nowrap}.rst-content table.field-list .field-body{text-align:left}.rst-content code,.rst-content tt{color:#000;font-family:SFMono-Regular,Menlo,Monaco,Consolas,Liberation Mono,Courier New,Courier,monospace;padding:2px 5px}.rst-content code big,.rst-content code em,.rst-content tt big,.rst-content tt em{font-size:100%!important;line-height:normal}.rst-content code.literal,.rst-content tt.literal{color:#e74c3c;white-space:normal}.rst-content code.xref,.rst-content tt.xref,a .rst-content code,a .rst-content tt{font-weight:700;color:#404040;overflow-wrap:normal}.rst-content kbd,.rst-content pre,.rst-content samp{font-family:SFMono-Regular,Menlo,Monaco,Consolas,Liberation Mono,Courier New,Courier,monospace}.rst-content a code,.rst-content a tt{color:#2980b9}.rst-content dl{margin-bottom:24px}.rst-content dl dt{font-weight:700;margin-bottom:12px}.rst-content dl ol,.rst-content dl p,.rst-content dl table,.rst-content dl ul{margin-bottom:12px}.rst-content dl dd{margin:0 0 12px 24px;line-height:24px}.rst-content dl dd>ol:last-child,.rst-content dl dd>p:last-child,.rst-content dl dd>table:last-child,.rst-content dl dd>ul:last-child{margin-bottom:0}html.writer-html4 .rst-content dl:not(.docutils),html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple){margin-bottom:24px}html.writer-html4 .rst-content dl:not(.docutils)>dt,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple)>dt{display:table;margin:6px 0;font-size:90%;line-height:normal;background:#e7f2fa;color:#2980b9;border-top:3px solid #6ab0de;padding:6px;position:relative}html.writer-html4 .rst-content dl:not(.docutils)>dt:before,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple)>dt:before{color:#6ab0de}html.writer-html4 .rst-content dl:not(.docutils)>dt .headerlink,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple)>dt .headerlink{color:#404040;font-size:100%!important}html.writer-html4 .rst-content dl:not(.docutils) dl:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple)>dt,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple) dl:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple)>dt{margin-bottom:6px;border:none;border-left:3px solid #ccc;background:#f0f0f0;color:#555}html.writer-html4 .rst-content dl:not(.docutils) dl:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple)>dt .headerlink,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple) dl:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple)>dt .headerlink{color:#404040;font-size:100%!important}html.writer-html4 .rst-content dl:not(.docutils)>dt:first-child,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple)>dt:first-child{margin-top:0}html.writer-html4 .rst-content dl:not(.docutils) code.descclassname,html.writer-html4 .rst-content dl:not(.docutils) code.descname,html.writer-html4 .rst-content dl:not(.docutils) tt.descclassname,html.writer-html4 .rst-content dl:not(.docutils) tt.descname,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple) code.descclassname,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple) code.descname,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple) tt.descclassname,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple) tt.descname{background-color:transparent;border:none;padding:0;font-size:100%!important}html.writer-html4 .rst-content dl:not(.docutils) code.descname,html.writer-html4 .rst-content dl:not(.docutils) tt.descname,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple) code.descname,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple) tt.descname{font-weight:700}html.writer-html4 .rst-content dl:not(.docutils) .optional,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple) .optional{display:inline-block;padding:0 4px;color:#000;font-weight:700}html.writer-html4 .rst-content dl:not(.docutils) .property,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple) .property{display:inline-block;padding-right:8px;max-width:100%}html.writer-html4 .rst-content dl:not(.docutils) .k,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple) .k{font-style:italic}html.writer-html4 .rst-content dl:not(.docutils) .descclassname,html.writer-html4 .rst-content dl:not(.docutils) .descname,html.writer-html4 .rst-content dl:not(.docutils) .sig-name,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple) .descclassname,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple) .descname,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple) .sig-name{font-family:SFMono-Regular,Menlo,Monaco,Consolas,Liberation Mono,Courier New,Courier,monospace;color:#000}.rst-content .viewcode-back,.rst-content .viewcode-link{display:inline-block;color:#27ae60;font-size:80%;padding-left:24px}.rst-content .viewcode-back{display:block;float:right}.rst-content p.rubric{margin-bottom:12px;font-weight:700}.rst-content code.download,.rst-content tt.download{background:inherit;padding:inherit;font-weight:400;font-family:inherit;font-size:inherit;color:inherit;border:inherit;white-space:inherit}.rst-content code.download span:first-child,.rst-content tt.download span:first-child{-webkit-font-smoothing:subpixel-antialiased}.rst-content code.download span:first-child:before,.rst-content tt.download span:first-child:before{margin-right:4px}.rst-content .guilabel{border:1px solid #7fbbe3;background:#e7f2fa;font-size:80%;font-weight:700;border-radius:4px;padding:2.4px 6px;margin:auto 2px}.rst-content :not(dl.option-list)>:not(dt):not(kbd):not(.kbd)>.kbd,.rst-content :not(dl.option-list)>:not(dt):not(kbd):not(.kbd)>kbd{color:inherit;font-size:80%;background-color:#fff;border:1px solid #a6a6a6;border-radius:4px;box-shadow:0 2px grey;padding:2.4px 6px;margin:auto 0}.rst-content .versionmodified{font-style:italic}@media screen and (max-width:480px){.rst-content .sidebar{width:100%}}span[id*=MathJax-Span]{color:#404040}.math{text-align:center}@font-face{font-family:Lato;src:local('Lato-Regular'),url('/.sysassets/fonts/lato/Lato-Regular.ttf') format("truetype");font-weight:400;font-style:normal;font-display:block}@font-face{font-family:Lato;src:local('Lato-Bold'),url('/.sysassets/fonts/lato/Lato-Bold.ttf') format("truetype");font-weight:700;font-style:normal;font-display:block}@font-face{font-family:Lato;src:local('Lato-BoldItalic'),url('/.sysassets/fonts/lato/Lato-BoldItalic.ttf') format("truetype");font-weight:700;font-style:italic;font-display:block}@font-face{font-family:Lato;src:local('Lato-Italic'),url('/.sysassets/fonts/lato/Lato-Italic.ttf') format("truetype");font-weight:400;font-style:italic;font-display:block}@font-face{font-family:Roboto Slab;font-style:normal;font-weight:400;src:local('RobotoSlab-Regular'),url('/.sysassets/fonts/google-roboto-slab-fonts/RobotoSlab-Regular.ttf') format("truetype");font-display:block}@font-face{font-family:Roboto Slab;font-style:normal;font-weight:700;src:local('RobotoSlab-Bold'),url('/.sysassets/fonts/google-roboto-slab-fonts/RobotoSlab-Bold.ttf') format("truetype");font-display:block} ================================================ FILE: docs/html/_static/doctools.js ================================================ /* * doctools.js * ~~~~~~~~~~~ * * Base JavaScript utilities for all Sphinx HTML documentation. * * :copyright: Copyright 2007-2022 by the Sphinx team, see AUTHORS. * :license: BSD, see LICENSE for details. * */ "use strict"; const BLACKLISTED_KEY_CONTROL_ELEMENTS = new Set([ "TEXTAREA", "INPUT", "SELECT", "BUTTON", ]); const _ready = (callback) => { if (document.readyState !== "loading") { callback(); } else { document.addEventListener("DOMContentLoaded", callback); } }; /** * Small JavaScript module for the documentation. */ const Documentation = { init: () => { Documentation.initDomainIndexTable(); Documentation.initOnKeyListeners(); }, /** * i18n support */ TRANSLATIONS: {}, PLURAL_EXPR: (n) => (n === 1 ? 0 : 1), LOCALE: "unknown", // gettext and ngettext don't access this so that the functions // can safely bound to a different name (_ = Documentation.gettext) gettext: (string) => { const translated = Documentation.TRANSLATIONS[string]; switch (typeof translated) { case "undefined": return string; // no translation case "string": return translated; // translation exists default: return translated[0]; // (singular, plural) translation tuple exists } }, ngettext: (singular, plural, n) => { const translated = Documentation.TRANSLATIONS[singular]; if (typeof translated !== "undefined") return translated[Documentation.PLURAL_EXPR(n)]; return n === 1 ? singular : plural; }, addTranslations: (catalog) => { Object.assign(Documentation.TRANSLATIONS, catalog.messages); Documentation.PLURAL_EXPR = new Function( "n", `return (${catalog.plural_expr})` ); Documentation.LOCALE = catalog.locale; }, /** * helper function to focus on search bar */ focusSearchBar: () => { document.querySelectorAll("input[name=q]")[0]?.focus(); }, /** * Initialise the domain index toggle buttons */ initDomainIndexTable: () => { const toggler = (el) => { const idNumber = el.id.substr(7); const toggledRows = document.querySelectorAll(`tr.cg-${idNumber}`); if (el.src.substr(-9) === "minus.png") { el.src = `${el.src.substr(0, el.src.length - 9)}plus.png`; toggledRows.forEach((el) => (el.style.display = "none")); } else { el.src = `${el.src.substr(0, el.src.length - 8)}minus.png`; toggledRows.forEach((el) => (el.style.display = "")); } }; const togglerElements = document.querySelectorAll("img.toggler"); togglerElements.forEach((el) => el.addEventListener("click", (event) => toggler(event.currentTarget)) ); togglerElements.forEach((el) => (el.style.display = "")); if (DOCUMENTATION_OPTIONS.COLLAPSE_INDEX) togglerElements.forEach(toggler); }, initOnKeyListeners: () => { // only install a listener if it is really needed if ( !DOCUMENTATION_OPTIONS.NAVIGATION_WITH_KEYS && !DOCUMENTATION_OPTIONS.ENABLE_SEARCH_SHORTCUTS ) return; document.addEventListener("keydown", (event) => { // bail for input elements if (BLACKLISTED_KEY_CONTROL_ELEMENTS.has(document.activeElement.tagName)) return; // bail with special keys if (event.altKey || event.ctrlKey || event.metaKey) return; if (!event.shiftKey) { switch (event.key) { case "ArrowLeft": if (!DOCUMENTATION_OPTIONS.NAVIGATION_WITH_KEYS) break; const prevLink = document.querySelector('link[rel="prev"]'); if (prevLink && prevLink.href) { window.location.href = prevLink.href; event.preventDefault(); } break; case "ArrowRight": if (!DOCUMENTATION_OPTIONS.NAVIGATION_WITH_KEYS) break; const nextLink = document.querySelector('link[rel="next"]'); if (nextLink && nextLink.href) { window.location.href = nextLink.href; event.preventDefault(); } break; } } // some keyboard layouts may need Shift to get / switch (event.key) { case "/": if (!DOCUMENTATION_OPTIONS.ENABLE_SEARCH_SHORTCUTS) break; Documentation.focusSearchBar(); event.preventDefault(); } }); }, }; // quick alias for translations const _ = Documentation.gettext; _ready(Documentation.init); ================================================ FILE: docs/html/_static/documentation_options.js ================================================ var DOCUMENTATION_OPTIONS = { URL_ROOT: document.getElementById("documentation_options").getAttribute('data-url_root'), VERSION: '1.0.1', LANGUAGE: 'en', COLLAPSE_INDEX: false, BUILDER: 'html', FILE_SUFFIX: '.html', LINK_SUFFIX: '.html', HAS_SOURCE: true, SOURCELINK_SUFFIX: '.txt', NAVIGATION_WITH_KEYS: false, SHOW_SEARCH_SUMMARY: true, ENABLE_SEARCH_SHORTCUTS: true, }; ================================================ FILE: docs/html/_static/jquery-3.2.1.js ================================================ /*! * jQuery JavaScript Library v3.2.1 * https://jquery.com/ * * Includes Sizzle.js * https://sizzlejs.com/ * * Copyright JS Foundation and other contributors * Released under the MIT license * https://jquery.org/license * * Date: 2017-03-20T18:59Z */ ( function( global, factory ) { "use strict"; if ( typeof module === "object" && typeof module.exports === "object" ) { // For CommonJS and CommonJS-like environments where a proper `window` // is present, execute the factory and get jQuery. // For environments that do not have a `window` with a `document` // (such as Node.js), expose a factory as module.exports. // This accentuates the need for the creation of a real `window`. // e.g. var jQuery = require("jquery")(window); // See ticket #14549 for more info. module.exports = global.document ? factory( global, true ) : function( w ) { if ( !w.document ) { throw new Error( "jQuery requires a window with a document" ); } return factory( w ); }; } else { factory( global ); } // Pass this if window is not defined yet } )( typeof window !== "undefined" ? window : this, function( window, noGlobal ) { // Edge <= 12 - 13+, Firefox <=18 - 45+, IE 10 - 11, Safari 5.1 - 9+, iOS 6 - 9.1 // throw exceptions when non-strict code (e.g., ASP.NET 4.5) accesses strict mode // arguments.callee.caller (trac-13335). But as of jQuery 3.0 (2016), strict mode should be common // enough that all such attempts are guarded in a try block. "use strict"; var arr = []; var document = window.document; var getProto = Object.getPrototypeOf; var slice = arr.slice; var concat = arr.concat; var push = arr.push; var indexOf = arr.indexOf; var class2type = {}; var toString = class2type.toString; var hasOwn = class2type.hasOwnProperty; var fnToString = hasOwn.toString; var ObjectFunctionString = fnToString.call( Object ); var support = {}; function DOMEval( code, doc ) { doc = doc || document; var script = doc.createElement( "script" ); script.text = code; doc.head.appendChild( script ).parentNode.removeChild( script ); } /* global Symbol */ // Defining this global in .eslintrc.json would create a danger of using the global // unguarded in another place, it seems safer to define global only for this module var version = "3.2.1", // Define a local copy of jQuery jQuery = function( selector, context ) { // The jQuery object is actually just the init constructor 'enhanced' // Need init if jQuery is called (just allow error to be thrown if not included) return new jQuery.fn.init( selector, context ); }, // Support: Android <=4.0 only // Make sure we trim BOM and NBSP rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, // Matches dashed string for camelizing rmsPrefix = /^-ms-/, rdashAlpha = /-([a-z])/g, // Used by jQuery.camelCase as callback to replace() fcamelCase = function( all, letter ) { return letter.toUpperCase(); }; jQuery.fn = jQuery.prototype = { // The current version of jQuery being used jquery: version, constructor: jQuery, // The default length of a jQuery object is 0 length: 0, toArray: function() { return slice.call( this ); }, // Get the Nth element in the matched element set OR // Get the whole matched element set as a clean array get: function( num ) { // Return all the elements in a clean array if ( num == null ) { return slice.call( this ); } // Return just the one element from the set return num < 0 ? this[ num + this.length ] : this[ num ]; }, // Take an array of elements and push it onto the stack // (returning the new matched element set) pushStack: function( elems ) { // Build a new jQuery matched element set var ret = jQuery.merge( this.constructor(), elems ); // Add the old object onto the stack (as a reference) ret.prevObject = this; // Return the newly-formed element set return ret; }, // Execute a callback for every element in the matched set. each: function( callback ) { return jQuery.each( this, callback ); }, map: function( callback ) { return this.pushStack( jQuery.map( this, function( elem, i ) { return callback.call( elem, i, elem ); } ) ); }, slice: function() { return this.pushStack( slice.apply( this, arguments ) ); }, first: function() { return this.eq( 0 ); }, last: function() { return this.eq( -1 ); }, eq: function( i ) { var len = this.length, j = +i + ( i < 0 ? len : 0 ); return this.pushStack( j >= 0 && j < len ? [ this[ j ] ] : [] ); }, end: function() { return this.prevObject || this.constructor(); }, // For internal use only. // Behaves like an Array's method, not like a jQuery method. push: push, sort: arr.sort, splice: arr.splice }; jQuery.extend = jQuery.fn.extend = function() { var options, name, src, copy, copyIsArray, clone, target = arguments[ 0 ] || {}, i = 1, length = arguments.length, deep = false; // Handle a deep copy situation if ( typeof target === "boolean" ) { deep = target; // Skip the boolean and the target target = arguments[ i ] || {}; i++; } // Handle case when target is a string or something (possible in deep copy) if ( typeof target !== "object" && !jQuery.isFunction( target ) ) { target = {}; } // Extend jQuery itself if only one argument is passed if ( i === length ) { target = this; i--; } for ( ; i < length; i++ ) { // Only deal with non-null/undefined values if ( ( options = arguments[ i ] ) != null ) { // Extend the base object for ( name in options ) { src = target[ name ]; copy = options[ name ]; // Prevent never-ending loop if ( target === copy ) { continue; } // Recurse if we're merging plain objects or arrays if ( deep && copy && ( jQuery.isPlainObject( copy ) || ( copyIsArray = Array.isArray( copy ) ) ) ) { if ( copyIsArray ) { copyIsArray = false; clone = src && Array.isArray( src ) ? src : []; } else { clone = src && jQuery.isPlainObject( src ) ? src : {}; } // Never move original objects, clone them target[ name ] = jQuery.extend( deep, clone, copy ); // Don't bring in undefined values } else if ( copy !== undefined ) { target[ name ] = copy; } } } } // Return the modified object return target; }; jQuery.extend( { // Unique for each copy of jQuery on the page expando: "jQuery" + ( version + Math.random() ).replace( /\D/g, "" ), // Assume jQuery is ready without the ready module isReady: true, error: function( msg ) { throw new Error( msg ); }, noop: function() {}, isFunction: function( obj ) { return jQuery.type( obj ) === "function"; }, isWindow: function( obj ) { return obj != null && obj === obj.window; }, isNumeric: function( obj ) { // As of jQuery 3.0, isNumeric is limited to // strings and numbers (primitives or objects) // that can be coerced to finite numbers (gh-2662) var type = jQuery.type( obj ); return ( type === "number" || type === "string" ) && // parseFloat NaNs numeric-cast false positives ("") // ...but misinterprets leading-number strings, particularly hex literals ("0x...") // subtraction forces infinities to NaN !isNaN( obj - parseFloat( obj ) ); }, isPlainObject: function( obj ) { var proto, Ctor; // Detect obvious negatives // Use toString instead of jQuery.type to catch host objects if ( !obj || toString.call( obj ) !== "[object Object]" ) { return false; } proto = getProto( obj ); // Objects with no prototype (e.g., `Object.create( null )`) are plain if ( !proto ) { return true; } // Objects with prototype are plain iff they were constructed by a global Object function Ctor = hasOwn.call( proto, "constructor" ) && proto.constructor; return typeof Ctor === "function" && fnToString.call( Ctor ) === ObjectFunctionString; }, isEmptyObject: function( obj ) { /* eslint-disable no-unused-vars */ // See https://github.com/eslint/eslint/issues/6125 var name; for ( name in obj ) { return false; } return true; }, type: function( obj ) { if ( obj == null ) { return obj + ""; } // Support: Android <=2.3 only (functionish RegExp) return typeof obj === "object" || typeof obj === "function" ? class2type[ toString.call( obj ) ] || "object" : typeof obj; }, // Evaluates a script in a global context globalEval: function( code ) { DOMEval( code ); }, // Convert dashed to camelCase; used by the css and data modules // Support: IE <=9 - 11, Edge 12 - 13 // Microsoft forgot to hump their vendor prefix (#9572) camelCase: function( string ) { return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase ); }, each: function( obj, callback ) { var length, i = 0; if ( isArrayLike( obj ) ) { length = obj.length; for ( ; i < length; i++ ) { if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) { break; } } } else { for ( i in obj ) { if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) { break; } } } return obj; }, // Support: Android <=4.0 only trim: function( text ) { return text == null ? "" : ( text + "" ).replace( rtrim, "" ); }, // results is for internal usage only makeArray: function( arr, results ) { var ret = results || []; if ( arr != null ) { if ( isArrayLike( Object( arr ) ) ) { jQuery.merge( ret, typeof arr === "string" ? [ arr ] : arr ); } else { push.call( ret, arr ); } } return ret; }, inArray: function( elem, arr, i ) { return arr == null ? -1 : indexOf.call( arr, elem, i ); }, // Support: Android <=4.0 only, PhantomJS 1 only // push.apply(_, arraylike) throws on ancient WebKit merge: function( first, second ) { var len = +second.length, j = 0, i = first.length; for ( ; j < len; j++ ) { first[ i++ ] = second[ j ]; } first.length = i; return first; }, grep: function( elems, callback, invert ) { var callbackInverse, matches = [], i = 0, length = elems.length, callbackExpect = !invert; // Go through the array, only saving the items // that pass the validator function for ( ; i < length; i++ ) { callbackInverse = !callback( elems[ i ], i ); if ( callbackInverse !== callbackExpect ) { matches.push( elems[ i ] ); } } return matches; }, // arg is for internal usage only map: function( elems, callback, arg ) { var length, value, i = 0, ret = []; // Go through the array, translating each of the items to their new values if ( isArrayLike( elems ) ) { length = elems.length; for ( ; i < length; i++ ) { value = callback( elems[ i ], i, arg ); if ( value != null ) { ret.push( value ); } } // Go through every key on the object, } else { for ( i in elems ) { value = callback( elems[ i ], i, arg ); if ( value != null ) { ret.push( value ); } } } // Flatten any nested arrays return concat.apply( [], ret ); }, // A global GUID counter for objects guid: 1, // Bind a function to a context, optionally partially applying any // arguments. proxy: function( fn, context ) { var tmp, args, proxy; if ( typeof context === "string" ) { tmp = fn[ context ]; context = fn; fn = tmp; } // Quick check to determine if target is callable, in the spec // this throws a TypeError, but we will just return undefined. if ( !jQuery.isFunction( fn ) ) { return undefined; } // Simulated bind args = slice.call( arguments, 2 ); proxy = function() { return fn.apply( context || this, args.concat( slice.call( arguments ) ) ); }; // Set the guid of unique handler to the same of original handler, so it can be removed proxy.guid = fn.guid = fn.guid || jQuery.guid++; return proxy; }, now: Date.now, // jQuery.support is not used in Core but other projects attach their // properties to it so it needs to exist. support: support } ); if ( typeof Symbol === "function" ) { jQuery.fn[ Symbol.iterator ] = arr[ Symbol.iterator ]; } // Populate the class2type map jQuery.each( "Boolean Number String Function Array Date RegExp Object Error Symbol".split( " " ), function( i, name ) { class2type[ "[object " + name + "]" ] = name.toLowerCase(); } ); function isArrayLike( obj ) { // Support: real iOS 8.2 only (not reproducible in simulator) // `in` check used to prevent JIT error (gh-2145) // hasOwn isn't used here due to false negatives // regarding Nodelist length in IE var length = !!obj && "length" in obj && obj.length, type = jQuery.type( obj ); if ( type === "function" || jQuery.isWindow( obj ) ) { return false; } return type === "array" || length === 0 || typeof length === "number" && length > 0 && ( length - 1 ) in obj; } var Sizzle = /*! * Sizzle CSS Selector Engine v2.3.3 * https://sizzlejs.com/ * * Copyright jQuery Foundation and other contributors * Released under the MIT license * http://jquery.org/license * * Date: 2016-08-08 */ (function( window ) { var i, support, Expr, getText, isXML, tokenize, compile, select, outermostContext, sortInput, hasDuplicate, // Local document vars setDocument, document, docElem, documentIsHTML, rbuggyQSA, rbuggyMatches, matches, contains, // Instance-specific data expando = "sizzle" + 1 * new Date(), preferredDoc = window.document, dirruns = 0, done = 0, classCache = createCache(), tokenCache = createCache(), compilerCache = createCache(), sortOrder = function( a, b ) { if ( a === b ) { hasDuplicate = true; } return 0; }, // Instance methods hasOwn = ({}).hasOwnProperty, arr = [], pop = arr.pop, push_native = arr.push, push = arr.push, slice = arr.slice, // Use a stripped-down indexOf as it's faster than native // https://jsperf.com/thor-indexof-vs-for/5 indexOf = function( list, elem ) { var i = 0, len = list.length; for ( ; i < len; i++ ) { if ( list[i] === elem ) { return i; } } return -1; }, booleans = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped", // Regular expressions // http://www.w3.org/TR/css3-selectors/#whitespace whitespace = "[\\x20\\t\\r\\n\\f]", // http://www.w3.org/TR/CSS21/syndata.html#value-def-identifier identifier = "(?:\\\\.|[\\w-]|[^\0-\\xa0])+", // Attribute selectors: http://www.w3.org/TR/selectors/#attribute-selectors attributes = "\\[" + whitespace + "*(" + identifier + ")(?:" + whitespace + // Operator (capture 2) "*([*^$|!~]?=)" + whitespace + // "Attribute values must be CSS identifiers [capture 5] or strings [capture 3 or capture 4]" "*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|(" + identifier + "))|)" + whitespace + "*\\]", pseudos = ":(" + identifier + ")(?:\\((" + // To reduce the number of selectors needing tokenize in the preFilter, prefer arguments: // 1. quoted (capture 3; capture 4 or capture 5) "('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|" + // 2. simple (capture 6) "((?:\\\\.|[^\\\\()[\\]]|" + attributes + ")*)|" + // 3. anything else (capture 2) ".*" + ")\\)|)", // Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter rwhitespace = new RegExp( whitespace + "+", "g" ), rtrim = new RegExp( "^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" + whitespace + "+$", "g" ), rcomma = new RegExp( "^" + whitespace + "*," + whitespace + "*" ), rcombinators = new RegExp( "^" + whitespace + "*([>+~]|" + whitespace + ")" + whitespace + "*" ), rattributeQuotes = new RegExp( "=" + whitespace + "*([^\\]'\"]*?)" + whitespace + "*\\]", "g" ), rpseudo = new RegExp( pseudos ), ridentifier = new RegExp( "^" + identifier + "$" ), matchExpr = { "ID": new RegExp( "^#(" + identifier + ")" ), "CLASS": new RegExp( "^\\.(" + identifier + ")" ), "TAG": new RegExp( "^(" + identifier + "|[*])" ), "ATTR": new RegExp( "^" + attributes ), "PSEUDO": new RegExp( "^" + pseudos ), "CHILD": new RegExp( "^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" + whitespace + "*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" + whitespace + "*(\\d+)|))" + whitespace + "*\\)|)", "i" ), "bool": new RegExp( "^(?:" + booleans + ")$", "i" ), // For use in libraries implementing .is() // We use this for POS matching in `select` "needsContext": new RegExp( "^" + whitespace + "*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" + whitespace + "*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", "i" ) }, rinputs = /^(?:input|select|textarea|button)$/i, rheader = /^h\d$/i, rnative = /^[^{]+\{\s*\[native \w/, // Easily-parseable/retrievable ID or TAG or CLASS selectors rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/, rsibling = /[+~]/, // CSS escapes // http://www.w3.org/TR/CSS21/syndata.html#escaped-characters runescape = new RegExp( "\\\\([\\da-f]{1,6}" + whitespace + "?|(" + whitespace + ")|.)", "ig" ), funescape = function( _, escaped, escapedWhitespace ) { var high = "0x" + escaped - 0x10000; // NaN means non-codepoint // Support: Firefox<24 // Workaround erroneous numeric interpretation of +"0x" return high !== high || escapedWhitespace ? escaped : high < 0 ? // BMP codepoint String.fromCharCode( high + 0x10000 ) : // Supplemental Plane codepoint (surrogate pair) String.fromCharCode( high >> 10 | 0xD800, high & 0x3FF | 0xDC00 ); }, // CSS string/identifier serialization // https://drafts.csswg.org/cssom/#common-serializing-idioms rcssescape = /([\0-\x1f\x7f]|^-?\d)|^-$|[^\0-\x1f\x7f-\uFFFF\w-]/g, fcssescape = function( ch, asCodePoint ) { if ( asCodePoint ) { // U+0000 NULL becomes U+FFFD REPLACEMENT CHARACTER if ( ch === "\0" ) { return "\uFFFD"; } // Control characters and (dependent upon position) numbers get escaped as code points return ch.slice( 0, -1 ) + "\\" + ch.charCodeAt( ch.length - 1 ).toString( 16 ) + " "; } // Other potentially-special ASCII characters get backslash-escaped return "\\" + ch; }, // Used for iframes // See setDocument() // Removing the function wrapper causes a "Permission Denied" // error in IE unloadHandler = function() { setDocument(); }, disabledAncestor = addCombinator( function( elem ) { return elem.disabled === true && ("form" in elem || "label" in elem); }, { dir: "parentNode", next: "legend" } ); // Optimize for push.apply( _, NodeList ) try { push.apply( (arr = slice.call( preferredDoc.childNodes )), preferredDoc.childNodes ); // Support: Android<4.0 // Detect silently failing push.apply arr[ preferredDoc.childNodes.length ].nodeType; } catch ( e ) { push = { apply: arr.length ? // Leverage slice if possible function( target, els ) { push_native.apply( target, slice.call(els) ); } : // Support: IE<9 // Otherwise append directly function( target, els ) { var j = target.length, i = 0; // Can't trust NodeList.length while ( (target[j++] = els[i++]) ) {} target.length = j - 1; } }; } function Sizzle( selector, context, results, seed ) { var m, i, elem, nid, match, groups, newSelector, newContext = context && context.ownerDocument, // nodeType defaults to 9, since context defaults to document nodeType = context ? context.nodeType : 9; results = results || []; // Return early from calls with invalid selector or context if ( typeof selector !== "string" || !selector || nodeType !== 1 && nodeType !== 9 && nodeType !== 11 ) { return results; } // Try to shortcut find operations (as opposed to filters) in HTML documents if ( !seed ) { if ( ( context ? context.ownerDocument || context : preferredDoc ) !== document ) { setDocument( context ); } context = context || document; if ( documentIsHTML ) { // If the selector is sufficiently simple, try using a "get*By*" DOM method // (excepting DocumentFragment context, where the methods don't exist) if ( nodeType !== 11 && (match = rquickExpr.exec( selector )) ) { // ID selector if ( (m = match[1]) ) { // Document context if ( nodeType === 9 ) { if ( (elem = context.getElementById( m )) ) { // Support: IE, Opera, Webkit // TODO: identify versions // getElementById can match elements by name instead of ID if ( elem.id === m ) { results.push( elem ); return results; } } else { return results; } // Element context } else { // Support: IE, Opera, Webkit // TODO: identify versions // getElementById can match elements by name instead of ID if ( newContext && (elem = newContext.getElementById( m )) && contains( context, elem ) && elem.id === m ) { results.push( elem ); return results; } } // Type selector } else if ( match[2] ) { push.apply( results, context.getElementsByTagName( selector ) ); return results; // Class selector } else if ( (m = match[3]) && support.getElementsByClassName && context.getElementsByClassName ) { push.apply( results, context.getElementsByClassName( m ) ); return results; } } // Take advantage of querySelectorAll if ( support.qsa && !compilerCache[ selector + " " ] && (!rbuggyQSA || !rbuggyQSA.test( selector )) ) { if ( nodeType !== 1 ) { newContext = context; newSelector = selector; // qSA looks outside Element context, which is not what we want // Thanks to Andrew Dupont for this workaround technique // Support: IE <=8 // Exclude object elements } else if ( context.nodeName.toLowerCase() !== "object" ) { // Capture the context ID, setting it first if necessary if ( (nid = context.getAttribute( "id" )) ) { nid = nid.replace( rcssescape, fcssescape ); } else { context.setAttribute( "id", (nid = expando) ); } // Prefix every selector in the list groups = tokenize( selector ); i = groups.length; while ( i-- ) { groups[i] = "#" + nid + " " + toSelector( groups[i] ); } newSelector = groups.join( "," ); // Expand context for sibling selectors newContext = rsibling.test( selector ) && testContext( context.parentNode ) || context; } if ( newSelector ) { try { push.apply( results, newContext.querySelectorAll( newSelector ) ); return results; } catch ( qsaError ) { } finally { if ( nid === expando ) { context.removeAttribute( "id" ); } } } } } } // All others return select( selector.replace( rtrim, "$1" ), context, results, seed ); } /** * Create key-value caches of limited size * @returns {function(string, object)} Returns the Object data after storing it on itself with * property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength) * deleting the oldest entry */ function createCache() { var keys = []; function cache( key, value ) { // Use (key + " ") to avoid collision with native prototype properties (see Issue #157) if ( keys.push( key + " " ) > Expr.cacheLength ) { // Only keep the most recent entries delete cache[ keys.shift() ]; } return (cache[ key + " " ] = value); } return cache; } /** * Mark a function for special use by Sizzle * @param {Function} fn The function to mark */ function markFunction( fn ) { fn[ expando ] = true; return fn; } /** * Support testing using an element * @param {Function} fn Passed the created element and returns a boolean result */ function assert( fn ) { var el = document.createElement("fieldset"); try { return !!fn( el ); } catch (e) { return false; } finally { // Remove from its parent by default if ( el.parentNode ) { el.parentNode.removeChild( el ); } // release memory in IE el = null; } } /** * Adds the same handler for all of the specified attrs * @param {String} attrs Pipe-separated list of attributes * @param {Function} handler The method that will be applied */ function addHandle( attrs, handler ) { var arr = attrs.split("|"), i = arr.length; while ( i-- ) { Expr.attrHandle[ arr[i] ] = handler; } } /** * Checks document order of two siblings * @param {Element} a * @param {Element} b * @returns {Number} Returns less than 0 if a precedes b, greater than 0 if a follows b */ function siblingCheck( a, b ) { var cur = b && a, diff = cur && a.nodeType === 1 && b.nodeType === 1 && a.sourceIndex - b.sourceIndex; // Use IE sourceIndex if available on both nodes if ( diff ) { return diff; } // Check if b follows a if ( cur ) { while ( (cur = cur.nextSibling) ) { if ( cur === b ) { return -1; } } } return a ? 1 : -1; } /** * Returns a function to use in pseudos for input types * @param {String} type */ function createInputPseudo( type ) { return function( elem ) { var name = elem.nodeName.toLowerCase(); return name === "input" && elem.type === type; }; } /** * Returns a function to use in pseudos for buttons * @param {String} type */ function createButtonPseudo( type ) { return function( elem ) { var name = elem.nodeName.toLowerCase(); return (name === "input" || name === "button") && elem.type === type; }; } /** * Returns a function to use in pseudos for :enabled/:disabled * @param {Boolean} disabled true for :disabled; false for :enabled */ function createDisabledPseudo( disabled ) { // Known :disabled false positives: fieldset[disabled] > legend:nth-of-type(n+2) :can-disable return function( elem ) { // Only certain elements can match :enabled or :disabled // https://html.spec.whatwg.org/multipage/scripting.html#selector-enabled // https://html.spec.whatwg.org/multipage/scripting.html#selector-disabled if ( "form" in elem ) { // Check for inherited disabledness on relevant non-disabled elements: // * listed form-associated elements in a disabled fieldset // https://html.spec.whatwg.org/multipage/forms.html#category-listed // https://html.spec.whatwg.org/multipage/forms.html#concept-fe-disabled // * option elements in a disabled optgroup // https://html.spec.whatwg.org/multipage/forms.html#concept-option-disabled // All such elements have a "form" property. if ( elem.parentNode && elem.disabled === false ) { // Option elements defer to a parent optgroup if present if ( "label" in elem ) { if ( "label" in elem.parentNode ) { return elem.parentNode.disabled === disabled; } else { return elem.disabled === disabled; } } // Support: IE 6 - 11 // Use the isDisabled shortcut property to check for disabled fieldset ancestors return elem.isDisabled === disabled || // Where there is no isDisabled, check manually /* jshint -W018 */ elem.isDisabled !== !disabled && disabledAncestor( elem ) === disabled; } return elem.disabled === disabled; // Try to winnow out elements that can't be disabled before trusting the disabled property. // Some victims get caught in our net (label, legend, menu, track), but it shouldn't // even exist on them, let alone have a boolean value. } else if ( "label" in elem ) { return elem.disabled === disabled; } // Remaining elements are neither :enabled nor :disabled return false; }; } /** * Returns a function to use in pseudos for positionals * @param {Function} fn */ function createPositionalPseudo( fn ) { return markFunction(function( argument ) { argument = +argument; return markFunction(function( seed, matches ) { var j, matchIndexes = fn( [], seed.length, argument ), i = matchIndexes.length; // Match elements found at the specified indexes while ( i-- ) { if ( seed[ (j = matchIndexes[i]) ] ) { seed[j] = !(matches[j] = seed[j]); } } }); }); } /** * Checks a node for validity as a Sizzle context * @param {Element|Object=} context * @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value */ function testContext( context ) { return context && typeof context.getElementsByTagName !== "undefined" && context; } // Expose support vars for convenience support = Sizzle.support = {}; /** * Detects XML nodes * @param {Element|Object} elem An element or a document * @returns {Boolean} True iff elem is a non-HTML XML node */ isXML = Sizzle.isXML = function( elem ) { // documentElement is verified for cases where it doesn't yet exist // (such as loading iframes in IE - #4833) var documentElement = elem && (elem.ownerDocument || elem).documentElement; return documentElement ? documentElement.nodeName !== "HTML" : false; }; /** * Sets document-related variables once based on the current document * @param {Element|Object} [doc] An element or document object to use to set the document * @returns {Object} Returns the current document */ setDocument = Sizzle.setDocument = function( node ) { var hasCompare, subWindow, doc = node ? node.ownerDocument || node : preferredDoc; // Return early if doc is invalid or already selected if ( doc === document || doc.nodeType !== 9 || !doc.documentElement ) { return document; } // Update global variables document = doc; docElem = document.documentElement; documentIsHTML = !isXML( document ); // Support: IE 9-11, Edge // Accessing iframe documents after unload throws "permission denied" errors (jQuery #13936) if ( preferredDoc !== document && (subWindow = document.defaultView) && subWindow.top !== subWindow ) { // Support: IE 11, Edge if ( subWindow.addEventListener ) { subWindow.addEventListener( "unload", unloadHandler, false ); // Support: IE 9 - 10 only } else if ( subWindow.attachEvent ) { subWindow.attachEvent( "onunload", unloadHandler ); } } /* Attributes ---------------------------------------------------------------------- */ // Support: IE<8 // Verify that getAttribute really returns attributes and not properties // (excepting IE8 booleans) support.attributes = assert(function( el ) { el.className = "i"; return !el.getAttribute("className"); }); /* getElement(s)By* ---------------------------------------------------------------------- */ // Check if getElementsByTagName("*") returns only elements support.getElementsByTagName = assert(function( el ) { el.appendChild( document.createComment("") ); return !el.getElementsByTagName("*").length; }); // Support: IE<9 support.getElementsByClassName = rnative.test( document.getElementsByClassName ); // Support: IE<10 // Check if getElementById returns elements by name // The broken getElementById methods don't pick up programmatically-set names, // so use a roundabout getElementsByName test support.getById = assert(function( el ) { docElem.appendChild( el ).id = expando; return !document.getElementsByName || !document.getElementsByName( expando ).length; }); // ID filter and find if ( support.getById ) { Expr.filter["ID"] = function( id ) { var attrId = id.replace( runescape, funescape ); return function( elem ) { return elem.getAttribute("id") === attrId; }; }; Expr.find["ID"] = function( id, context ) { if ( typeof context.getElementById !== "undefined" && documentIsHTML ) { var elem = context.getElementById( id ); return elem ? [ elem ] : []; } }; } else { Expr.filter["ID"] = function( id ) { var attrId = id.replace( runescape, funescape ); return function( elem ) { var node = typeof elem.getAttributeNode !== "undefined" && elem.getAttributeNode("id"); return node && node.value === attrId; }; }; // Support: IE 6 - 7 only // getElementById is not reliable as a find shortcut Expr.find["ID"] = function( id, context ) { if ( typeof context.getElementById !== "undefined" && documentIsHTML ) { var node, i, elems, elem = context.getElementById( id ); if ( elem ) { // Verify the id attribute node = elem.getAttributeNode("id"); if ( node && node.value === id ) { return [ elem ]; } // Fall back on getElementsByName elems = context.getElementsByName( id ); i = 0; while ( (elem = elems[i++]) ) { node = elem.getAttributeNode("id"); if ( node && node.value === id ) { return [ elem ]; } } } return []; } }; } // Tag Expr.find["TAG"] = support.getElementsByTagName ? function( tag, context ) { if ( typeof context.getElementsByTagName !== "undefined" ) { return context.getElementsByTagName( tag ); // DocumentFragment nodes don't have gEBTN } else if ( support.qsa ) { return context.querySelectorAll( tag ); } } : function( tag, context ) { var elem, tmp = [], i = 0, // By happy coincidence, a (broken) gEBTN appears on DocumentFragment nodes too results = context.getElementsByTagName( tag ); // Filter out possible comments if ( tag === "*" ) { while ( (elem = results[i++]) ) { if ( elem.nodeType === 1 ) { tmp.push( elem ); } } return tmp; } return results; }; // Class Expr.find["CLASS"] = support.getElementsByClassName && function( className, context ) { if ( typeof context.getElementsByClassName !== "undefined" && documentIsHTML ) { return context.getElementsByClassName( className ); } }; /* QSA/matchesSelector ---------------------------------------------------------------------- */ // QSA and matchesSelector support // matchesSelector(:active) reports false when true (IE9/Opera 11.5) rbuggyMatches = []; // qSa(:focus) reports false when true (Chrome 21) // We allow this because of a bug in IE8/9 that throws an error // whenever `document.activeElement` is accessed on an iframe // So, we allow :focus to pass through QSA all the time to avoid the IE error // See https://bugs.jquery.com/ticket/13378 rbuggyQSA = []; if ( (support.qsa = rnative.test( document.querySelectorAll )) ) { // Build QSA regex // Regex strategy adopted from Diego Perini assert(function( el ) { // Select is set to empty string on purpose // This is to test IE's treatment of not explicitly // setting a boolean content attribute, // since its presence should be enough // https://bugs.jquery.com/ticket/12359 docElem.appendChild( el ).innerHTML = "" + ""; // Support: IE8, Opera 11-12.16 // Nothing should be selected when empty strings follow ^= or $= or *= // The test attribute must be unknown in Opera but "safe" for WinRT // https://msdn.microsoft.com/en-us/library/ie/hh465388.aspx#attribute_section if ( el.querySelectorAll("[msallowcapture^='']").length ) { rbuggyQSA.push( "[*^$]=" + whitespace + "*(?:''|\"\")" ); } // Support: IE8 // Boolean attributes and "value" are not treated correctly if ( !el.querySelectorAll("[selected]").length ) { rbuggyQSA.push( "\\[" + whitespace + "*(?:value|" + booleans + ")" ); } // Support: Chrome<29, Android<4.4, Safari<7.0+, iOS<7.0+, PhantomJS<1.9.8+ if ( !el.querySelectorAll( "[id~=" + expando + "-]" ).length ) { rbuggyQSA.push("~="); } // Webkit/Opera - :checked should return selected option elements // http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked // IE8 throws error here and will not see later tests if ( !el.querySelectorAll(":checked").length ) { rbuggyQSA.push(":checked"); } // Support: Safari 8+, iOS 8+ // https://bugs.webkit.org/show_bug.cgi?id=136851 // In-page `selector#id sibling-combinator selector` fails if ( !el.querySelectorAll( "a#" + expando + "+*" ).length ) { rbuggyQSA.push(".#.+[+~]"); } }); assert(function( el ) { el.innerHTML = "" + ""; // Support: Windows 8 Native Apps // The type and name attributes are restricted during .innerHTML assignment var input = document.createElement("input"); input.setAttribute( "type", "hidden" ); el.appendChild( input ).setAttribute( "name", "D" ); // Support: IE8 // Enforce case-sensitivity of name attribute if ( el.querySelectorAll("[name=d]").length ) { rbuggyQSA.push( "name" + whitespace + "*[*^$|!~]?=" ); } // FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled) // IE8 throws error here and will not see later tests if ( el.querySelectorAll(":enabled").length !== 2 ) { rbuggyQSA.push( ":enabled", ":disabled" ); } // Support: IE9-11+ // IE's :disabled selector does not pick up the children of disabled fieldsets docElem.appendChild( el ).disabled = true; if ( el.querySelectorAll(":disabled").length !== 2 ) { rbuggyQSA.push( ":enabled", ":disabled" ); } // Opera 10-11 does not throw on post-comma invalid pseudos el.querySelectorAll("*,:x"); rbuggyQSA.push(",.*:"); }); } if ( (support.matchesSelector = rnative.test( (matches = docElem.matches || docElem.webkitMatchesSelector || docElem.mozMatchesSelector || docElem.oMatchesSelector || docElem.msMatchesSelector) )) ) { assert(function( el ) { // Check to see if it's possible to do matchesSelector // on a disconnected node (IE 9) support.disconnectedMatch = matches.call( el, "*" ); // This should fail with an exception // Gecko does not error, returns false instead matches.call( el, "[s!='']:x" ); rbuggyMatches.push( "!=", pseudos ); }); } rbuggyQSA = rbuggyQSA.length && new RegExp( rbuggyQSA.join("|") ); rbuggyMatches = rbuggyMatches.length && new RegExp( rbuggyMatches.join("|") ); /* Contains ---------------------------------------------------------------------- */ hasCompare = rnative.test( docElem.compareDocumentPosition ); // Element contains another // Purposefully self-exclusive // As in, an element does not contain itself contains = hasCompare || rnative.test( docElem.contains ) ? function( a, b ) { var adown = a.nodeType === 9 ? a.documentElement : a, bup = b && b.parentNode; return a === bup || !!( bup && bup.nodeType === 1 && ( adown.contains ? adown.contains( bup ) : a.compareDocumentPosition && a.compareDocumentPosition( bup ) & 16 )); } : function( a, b ) { if ( b ) { while ( (b = b.parentNode) ) { if ( b === a ) { return true; } } } return false; }; /* Sorting ---------------------------------------------------------------------- */ // Document order sorting sortOrder = hasCompare ? function( a, b ) { // Flag for duplicate removal if ( a === b ) { hasDuplicate = true; return 0; } // Sort on method existence if only one input has compareDocumentPosition var compare = !a.compareDocumentPosition - !b.compareDocumentPosition; if ( compare ) { return compare; } // Calculate position if both inputs belong to the same document compare = ( a.ownerDocument || a ) === ( b.ownerDocument || b ) ? a.compareDocumentPosition( b ) : // Otherwise we know they are disconnected 1; // Disconnected nodes if ( compare & 1 || (!support.sortDetached && b.compareDocumentPosition( a ) === compare) ) { // Choose the first element that is related to our preferred document if ( a === document || a.ownerDocument === preferredDoc && contains(preferredDoc, a) ) { return -1; } if ( b === document || b.ownerDocument === preferredDoc && contains(preferredDoc, b) ) { return 1; } // Maintain original order return sortInput ? ( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) : 0; } return compare & 4 ? -1 : 1; } : function( a, b ) { // Exit early if the nodes are identical if ( a === b ) { hasDuplicate = true; return 0; } var cur, i = 0, aup = a.parentNode, bup = b.parentNode, ap = [ a ], bp = [ b ]; // Parentless nodes are either documents or disconnected if ( !aup || !bup ) { return a === document ? -1 : b === document ? 1 : aup ? -1 : bup ? 1 : sortInput ? ( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) : 0; // If the nodes are siblings, we can do a quick check } else if ( aup === bup ) { return siblingCheck( a, b ); } // Otherwise we need full lists of their ancestors for comparison cur = a; while ( (cur = cur.parentNode) ) { ap.unshift( cur ); } cur = b; while ( (cur = cur.parentNode) ) { bp.unshift( cur ); } // Walk down the tree looking for a discrepancy while ( ap[i] === bp[i] ) { i++; } return i ? // Do a sibling check if the nodes have a common ancestor siblingCheck( ap[i], bp[i] ) : // Otherwise nodes in our document sort first ap[i] === preferredDoc ? -1 : bp[i] === preferredDoc ? 1 : 0; }; return document; }; Sizzle.matches = function( expr, elements ) { return Sizzle( expr, null, null, elements ); }; Sizzle.matchesSelector = function( elem, expr ) { // Set document vars if needed if ( ( elem.ownerDocument || elem ) !== document ) { setDocument( elem ); } // Make sure that attribute selectors are quoted expr = expr.replace( rattributeQuotes, "='$1']" ); if ( support.matchesSelector && documentIsHTML && !compilerCache[ expr + " " ] && ( !rbuggyMatches || !rbuggyMatches.test( expr ) ) && ( !rbuggyQSA || !rbuggyQSA.test( expr ) ) ) { try { var ret = matches.call( elem, expr ); // IE 9's matchesSelector returns false on disconnected nodes if ( ret || support.disconnectedMatch || // As well, disconnected nodes are said to be in a document // fragment in IE 9 elem.document && elem.document.nodeType !== 11 ) { return ret; } } catch (e) {} } return Sizzle( expr, document, null, [ elem ] ).length > 0; }; Sizzle.contains = function( context, elem ) { // Set document vars if needed if ( ( context.ownerDocument || context ) !== document ) { setDocument( context ); } return contains( context, elem ); }; Sizzle.attr = function( elem, name ) { // Set document vars if needed if ( ( elem.ownerDocument || elem ) !== document ) { setDocument( elem ); } var fn = Expr.attrHandle[ name.toLowerCase() ], // Don't get fooled by Object.prototype properties (jQuery #13807) val = fn && hasOwn.call( Expr.attrHandle, name.toLowerCase() ) ? fn( elem, name, !documentIsHTML ) : undefined; return val !== undefined ? val : support.attributes || !documentIsHTML ? elem.getAttribute( name ) : (val = elem.getAttributeNode(name)) && val.specified ? val.value : null; }; Sizzle.escape = function( sel ) { return (sel + "").replace( rcssescape, fcssescape ); }; Sizzle.error = function( msg ) { throw new Error( "Syntax error, unrecognized expression: " + msg ); }; /** * Document sorting and removing duplicates * @param {ArrayLike} results */ Sizzle.uniqueSort = function( results ) { var elem, duplicates = [], j = 0, i = 0; // Unless we *know* we can detect duplicates, assume their presence hasDuplicate = !support.detectDuplicates; sortInput = !support.sortStable && results.slice( 0 ); results.sort( sortOrder ); if ( hasDuplicate ) { while ( (elem = results[i++]) ) { if ( elem === results[ i ] ) { j = duplicates.push( i ); } } while ( j-- ) { results.splice( duplicates[ j ], 1 ); } } // Clear input after sorting to release objects // See https://github.com/jquery/sizzle/pull/225 sortInput = null; return results; }; /** * Utility function for retrieving the text value of an array of DOM nodes * @param {Array|Element} elem */ getText = Sizzle.getText = function( elem ) { var node, ret = "", i = 0, nodeType = elem.nodeType; if ( !nodeType ) { // If no nodeType, this is expected to be an array while ( (node = elem[i++]) ) { // Do not traverse comment nodes ret += getText( node ); } } else if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) { // Use textContent for elements // innerText usage removed for consistency of new lines (jQuery #11153) if ( typeof elem.textContent === "string" ) { return elem.textContent; } else { // Traverse its children for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) { ret += getText( elem ); } } } else if ( nodeType === 3 || nodeType === 4 ) { return elem.nodeValue; } // Do not include comment or processing instruction nodes return ret; }; Expr = Sizzle.selectors = { // Can be adjusted by the user cacheLength: 50, createPseudo: markFunction, match: matchExpr, attrHandle: {}, find: {}, relative: { ">": { dir: "parentNode", first: true }, " ": { dir: "parentNode" }, "+": { dir: "previousSibling", first: true }, "~": { dir: "previousSibling" } }, preFilter: { "ATTR": function( match ) { match[1] = match[1].replace( runescape, funescape ); // Move the given value to match[3] whether quoted or unquoted match[3] = ( match[3] || match[4] || match[5] || "" ).replace( runescape, funescape ); if ( match[2] === "~=" ) { match[3] = " " + match[3] + " "; } return match.slice( 0, 4 ); }, "CHILD": function( match ) { /* matches from matchExpr["CHILD"] 1 type (only|nth|...) 2 what (child|of-type) 3 argument (even|odd|\d*|\d*n([+-]\d+)?|...) 4 xn-component of xn+y argument ([+-]?\d*n|) 5 sign of xn-component 6 x of xn-component 7 sign of y-component 8 y of y-component */ match[1] = match[1].toLowerCase(); if ( match[1].slice( 0, 3 ) === "nth" ) { // nth-* requires argument if ( !match[3] ) { Sizzle.error( match[0] ); } // numeric x and y parameters for Expr.filter.CHILD // remember that false/true cast respectively to 0/1 match[4] = +( match[4] ? match[5] + (match[6] || 1) : 2 * ( match[3] === "even" || match[3] === "odd" ) ); match[5] = +( ( match[7] + match[8] ) || match[3] === "odd" ); // other types prohibit arguments } else if ( match[3] ) { Sizzle.error( match[0] ); } return match; }, "PSEUDO": function( match ) { var excess, unquoted = !match[6] && match[2]; if ( matchExpr["CHILD"].test( match[0] ) ) { return null; } // Accept quoted arguments as-is if ( match[3] ) { match[2] = match[4] || match[5] || ""; // Strip excess characters from unquoted arguments } else if ( unquoted && rpseudo.test( unquoted ) && // Get excess from tokenize (recursively) (excess = tokenize( unquoted, true )) && // advance to the next closing parenthesis (excess = unquoted.indexOf( ")", unquoted.length - excess ) - unquoted.length) ) { // excess is a negative index match[0] = match[0].slice( 0, excess ); match[2] = unquoted.slice( 0, excess ); } // Return only captures needed by the pseudo filter method (type and argument) return match.slice( 0, 3 ); } }, filter: { "TAG": function( nodeNameSelector ) { var nodeName = nodeNameSelector.replace( runescape, funescape ).toLowerCase(); return nodeNameSelector === "*" ? function() { return true; } : function( elem ) { return elem.nodeName && elem.nodeName.toLowerCase() === nodeName; }; }, "CLASS": function( className ) { var pattern = classCache[ className + " " ]; return pattern || (pattern = new RegExp( "(^|" + whitespace + ")" + className + "(" + whitespace + "|$)" )) && classCache( className, function( elem ) { return pattern.test( typeof elem.className === "string" && elem.className || typeof elem.getAttribute !== "undefined" && elem.getAttribute("class") || "" ); }); }, "ATTR": function( name, operator, check ) { return function( elem ) { var result = Sizzle.attr( elem, name ); if ( result == null ) { return operator === "!="; } if ( !operator ) { return true; } result += ""; return operator === "=" ? result === check : operator === "!=" ? result !== check : operator === "^=" ? check && result.indexOf( check ) === 0 : operator === "*=" ? check && result.indexOf( check ) > -1 : operator === "$=" ? check && result.slice( -check.length ) === check : operator === "~=" ? ( " " + result.replace( rwhitespace, " " ) + " " ).indexOf( check ) > -1 : operator === "|=" ? result === check || result.slice( 0, check.length + 1 ) === check + "-" : false; }; }, "CHILD": function( type, what, argument, first, last ) { var simple = type.slice( 0, 3 ) !== "nth", forward = type.slice( -4 ) !== "last", ofType = what === "of-type"; return first === 1 && last === 0 ? // Shortcut for :nth-*(n) function( elem ) { return !!elem.parentNode; } : function( elem, context, xml ) { var cache, uniqueCache, outerCache, node, nodeIndex, start, dir = simple !== forward ? "nextSibling" : "previousSibling", parent = elem.parentNode, name = ofType && elem.nodeName.toLowerCase(), useCache = !xml && !ofType, diff = false; if ( parent ) { // :(first|last|only)-(child|of-type) if ( simple ) { while ( dir ) { node = elem; while ( (node = node[ dir ]) ) { if ( ofType ? node.nodeName.toLowerCase() === name : node.nodeType === 1 ) { return false; } } // Reverse direction for :only-* (if we haven't yet done so) start = dir = type === "only" && !start && "nextSibling"; } return true; } start = [ forward ? parent.firstChild : parent.lastChild ]; // non-xml :nth-child(...) stores cache data on `parent` if ( forward && useCache ) { // Seek `elem` from a previously-cached index // ...in a gzip-friendly way node = parent; outerCache = node[ expando ] || (node[ expando ] = {}); // Support: IE <9 only // Defend against cloned attroperties (jQuery gh-1709) uniqueCache = outerCache[ node.uniqueID ] || (outerCache[ node.uniqueID ] = {}); cache = uniqueCache[ type ] || []; nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ]; diff = nodeIndex && cache[ 2 ]; node = nodeIndex && parent.childNodes[ nodeIndex ]; while ( (node = ++nodeIndex && node && node[ dir ] || // Fallback to seeking `elem` from the start (diff = nodeIndex = 0) || start.pop()) ) { // When found, cache indexes on `parent` and break if ( node.nodeType === 1 && ++diff && node === elem ) { uniqueCache[ type ] = [ dirruns, nodeIndex, diff ]; break; } } } else { // Use previously-cached element index if available if ( useCache ) { // ...in a gzip-friendly way node = elem; outerCache = node[ expando ] || (node[ expando ] = {}); // Support: IE <9 only // Defend against cloned attroperties (jQuery gh-1709) uniqueCache = outerCache[ node.uniqueID ] || (outerCache[ node.uniqueID ] = {}); cache = uniqueCache[ type ] || []; nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ]; diff = nodeIndex; } // xml :nth-child(...) // or :nth-last-child(...) or :nth(-last)?-of-type(...) if ( diff === false ) { // Use the same loop as above to seek `elem` from the start while ( (node = ++nodeIndex && node && node[ dir ] || (diff = nodeIndex = 0) || start.pop()) ) { if ( ( ofType ? node.nodeName.toLowerCase() === name : node.nodeType === 1 ) && ++diff ) { // Cache the index of each encountered element if ( useCache ) { outerCache = node[ expando ] || (node[ expando ] = {}); // Support: IE <9 only // Defend against cloned attroperties (jQuery gh-1709) uniqueCache = outerCache[ node.uniqueID ] || (outerCache[ node.uniqueID ] = {}); uniqueCache[ type ] = [ dirruns, diff ]; } if ( node === elem ) { break; } } } } } // Incorporate the offset, then check against cycle size diff -= last; return diff === first || ( diff % first === 0 && diff / first >= 0 ); } }; }, "PSEUDO": function( pseudo, argument ) { // pseudo-class names are case-insensitive // http://www.w3.org/TR/selectors/#pseudo-classes // Prioritize by case sensitivity in case custom pseudos are added with uppercase letters // Remember that setFilters inherits from pseudos var args, fn = Expr.pseudos[ pseudo ] || Expr.setFilters[ pseudo.toLowerCase() ] || Sizzle.error( "unsupported pseudo: " + pseudo ); // The user may use createPseudo to indicate that // arguments are needed to create the filter function // just as Sizzle does if ( fn[ expando ] ) { return fn( argument ); } // But maintain support for old signatures if ( fn.length > 1 ) { args = [ pseudo, pseudo, "", argument ]; return Expr.setFilters.hasOwnProperty( pseudo.toLowerCase() ) ? markFunction(function( seed, matches ) { var idx, matched = fn( seed, argument ), i = matched.length; while ( i-- ) { idx = indexOf( seed, matched[i] ); seed[ idx ] = !( matches[ idx ] = matched[i] ); } }) : function( elem ) { return fn( elem, 0, args ); }; } return fn; } }, pseudos: { // Potentially complex pseudos "not": markFunction(function( selector ) { // Trim the selector passed to compile // to avoid treating leading and trailing // spaces as combinators var input = [], results = [], matcher = compile( selector.replace( rtrim, "$1" ) ); return matcher[ expando ] ? markFunction(function( seed, matches, context, xml ) { var elem, unmatched = matcher( seed, null, xml, [] ), i = seed.length; // Match elements unmatched by `matcher` while ( i-- ) { if ( (elem = unmatched[i]) ) { seed[i] = !(matches[i] = elem); } } }) : function( elem, context, xml ) { input[0] = elem; matcher( input, null, xml, results ); // Don't keep the element (issue #299) input[0] = null; return !results.pop(); }; }), "has": markFunction(function( selector ) { return function( elem ) { return Sizzle( selector, elem ).length > 0; }; }), "contains": markFunction(function( text ) { text = text.replace( runescape, funescape ); return function( elem ) { return ( elem.textContent || elem.innerText || getText( elem ) ).indexOf( text ) > -1; }; }), // "Whether an element is represented by a :lang() selector // is based solely on the element's language value // being equal to the identifier C, // or beginning with the identifier C immediately followed by "-". // The matching of C against the element's language value is performed case-insensitively. // The identifier C does not have to be a valid language name." // http://www.w3.org/TR/selectors/#lang-pseudo "lang": markFunction( function( lang ) { // lang value must be a valid identifier if ( !ridentifier.test(lang || "") ) { Sizzle.error( "unsupported lang: " + lang ); } lang = lang.replace( runescape, funescape ).toLowerCase(); return function( elem ) { var elemLang; do { if ( (elemLang = documentIsHTML ? elem.lang : elem.getAttribute("xml:lang") || elem.getAttribute("lang")) ) { elemLang = elemLang.toLowerCase(); return elemLang === lang || elemLang.indexOf( lang + "-" ) === 0; } } while ( (elem = elem.parentNode) && elem.nodeType === 1 ); return false; }; }), // Miscellaneous "target": function( elem ) { var hash = window.location && window.location.hash; return hash && hash.slice( 1 ) === elem.id; }, "root": function( elem ) { return elem === docElem; }, "focus": function( elem ) { return elem === document.activeElement && (!document.hasFocus || document.hasFocus()) && !!(elem.type || elem.href || ~elem.tabIndex); }, // Boolean properties "enabled": createDisabledPseudo( false ), "disabled": createDisabledPseudo( true ), "checked": function( elem ) { // In CSS3, :checked should return both checked and selected elements // http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked var nodeName = elem.nodeName.toLowerCase(); return (nodeName === "input" && !!elem.checked) || (nodeName === "option" && !!elem.selected); }, "selected": function( elem ) { // Accessing this property makes selected-by-default // options in Safari work properly if ( elem.parentNode ) { elem.parentNode.selectedIndex; } return elem.selected === true; }, // Contents "empty": function( elem ) { // http://www.w3.org/TR/selectors/#empty-pseudo // :empty is negated by element (1) or content nodes (text: 3; cdata: 4; entity ref: 5), // but not by others (comment: 8; processing instruction: 7; etc.) // nodeType < 6 works because attributes (2) do not appear as children for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) { if ( elem.nodeType < 6 ) { return false; } } return true; }, "parent": function( elem ) { return !Expr.pseudos["empty"]( elem ); }, // Element/input types "header": function( elem ) { return rheader.test( elem.nodeName ); }, "input": function( elem ) { return rinputs.test( elem.nodeName ); }, "button": function( elem ) { var name = elem.nodeName.toLowerCase(); return name === "input" && elem.type === "button" || name === "button"; }, "text": function( elem ) { var attr; return elem.nodeName.toLowerCase() === "input" && elem.type === "text" && // Support: IE<8 // New HTML5 attribute values (e.g., "search") appear with elem.type === "text" ( (attr = elem.getAttribute("type")) == null || attr.toLowerCase() === "text" ); }, // Position-in-collection "first": createPositionalPseudo(function() { return [ 0 ]; }), "last": createPositionalPseudo(function( matchIndexes, length ) { return [ length - 1 ]; }), "eq": createPositionalPseudo(function( matchIndexes, length, argument ) { return [ argument < 0 ? argument + length : argument ]; }), "even": createPositionalPseudo(function( matchIndexes, length ) { var i = 0; for ( ; i < length; i += 2 ) { matchIndexes.push( i ); } return matchIndexes; }), "odd": createPositionalPseudo(function( matchIndexes, length ) { var i = 1; for ( ; i < length; i += 2 ) { matchIndexes.push( i ); } return matchIndexes; }), "lt": createPositionalPseudo(function( matchIndexes, length, argument ) { var i = argument < 0 ? argument + length : argument; for ( ; --i >= 0; ) { matchIndexes.push( i ); } return matchIndexes; }), "gt": createPositionalPseudo(function( matchIndexes, length, argument ) { var i = argument < 0 ? argument + length : argument; for ( ; ++i < length; ) { matchIndexes.push( i ); } return matchIndexes; }) } }; Expr.pseudos["nth"] = Expr.pseudos["eq"]; // Add button/input type pseudos for ( i in { radio: true, checkbox: true, file: true, password: true, image: true } ) { Expr.pseudos[ i ] = createInputPseudo( i ); } for ( i in { submit: true, reset: true } ) { Expr.pseudos[ i ] = createButtonPseudo( i ); } // Easy API for creating new setFilters function setFilters() {} setFilters.prototype = Expr.filters = Expr.pseudos; Expr.setFilters = new setFilters(); tokenize = Sizzle.tokenize = function( selector, parseOnly ) { var matched, match, tokens, type, soFar, groups, preFilters, cached = tokenCache[ selector + " " ]; if ( cached ) { return parseOnly ? 0 : cached.slice( 0 ); } soFar = selector; groups = []; preFilters = Expr.preFilter; while ( soFar ) { // Comma and first run if ( !matched || (match = rcomma.exec( soFar )) ) { if ( match ) { // Don't consume trailing commas as valid soFar = soFar.slice( match[0].length ) || soFar; } groups.push( (tokens = []) ); } matched = false; // Combinators if ( (match = rcombinators.exec( soFar )) ) { matched = match.shift(); tokens.push({ value: matched, // Cast descendant combinators to space type: match[0].replace( rtrim, " " ) }); soFar = soFar.slice( matched.length ); } // Filters for ( type in Expr.filter ) { if ( (match = matchExpr[ type ].exec( soFar )) && (!preFilters[ type ] || (match = preFilters[ type ]( match ))) ) { matched = match.shift(); tokens.push({ value: matched, type: type, matches: match }); soFar = soFar.slice( matched.length ); } } if ( !matched ) { break; } } // Return the length of the invalid excess // if we're just parsing // Otherwise, throw an error or return tokens return parseOnly ? soFar.length : soFar ? Sizzle.error( selector ) : // Cache the tokens tokenCache( selector, groups ).slice( 0 ); }; function toSelector( tokens ) { var i = 0, len = tokens.length, selector = ""; for ( ; i < len; i++ ) { selector += tokens[i].value; } return selector; } function addCombinator( matcher, combinator, base ) { var dir = combinator.dir, skip = combinator.next, key = skip || dir, checkNonElements = base && key === "parentNode", doneName = done++; return combinator.first ? // Check against closest ancestor/preceding element function( elem, context, xml ) { while ( (elem = elem[ dir ]) ) { if ( elem.nodeType === 1 || checkNonElements ) { return matcher( elem, context, xml ); } } return false; } : // Check against all ancestor/preceding elements function( elem, context, xml ) { var oldCache, uniqueCache, outerCache, newCache = [ dirruns, doneName ]; // We can't set arbitrary data on XML nodes, so they don't benefit from combinator caching if ( xml ) { while ( (elem = elem[ dir ]) ) { if ( elem.nodeType === 1 || checkNonElements ) { if ( matcher( elem, context, xml ) ) { return true; } } } } else { while ( (elem = elem[ dir ]) ) { if ( elem.nodeType === 1 || checkNonElements ) { outerCache = elem[ expando ] || (elem[ expando ] = {}); // Support: IE <9 only // Defend against cloned attroperties (jQuery gh-1709) uniqueCache = outerCache[ elem.uniqueID ] || (outerCache[ elem.uniqueID ] = {}); if ( skip && skip === elem.nodeName.toLowerCase() ) { elem = elem[ dir ] || elem; } else if ( (oldCache = uniqueCache[ key ]) && oldCache[ 0 ] === dirruns && oldCache[ 1 ] === doneName ) { // Assign to newCache so results back-propagate to previous elements return (newCache[ 2 ] = oldCache[ 2 ]); } else { // Reuse newcache so results back-propagate to previous elements uniqueCache[ key ] = newCache; // A match means we're done; a fail means we have to keep checking if ( (newCache[ 2 ] = matcher( elem, context, xml )) ) { return true; } } } } } return false; }; } function elementMatcher( matchers ) { return matchers.length > 1 ? function( elem, context, xml ) { var i = matchers.length; while ( i-- ) { if ( !matchers[i]( elem, context, xml ) ) { return false; } } return true; } : matchers[0]; } function multipleContexts( selector, contexts, results ) { var i = 0, len = contexts.length; for ( ; i < len; i++ ) { Sizzle( selector, contexts[i], results ); } return results; } function condense( unmatched, map, filter, context, xml ) { var elem, newUnmatched = [], i = 0, len = unmatched.length, mapped = map != null; for ( ; i < len; i++ ) { if ( (elem = unmatched[i]) ) { if ( !filter || filter( elem, context, xml ) ) { newUnmatched.push( elem ); if ( mapped ) { map.push( i ); } } } } return newUnmatched; } function setMatcher( preFilter, selector, matcher, postFilter, postFinder, postSelector ) { if ( postFilter && !postFilter[ expando ] ) { postFilter = setMatcher( postFilter ); } if ( postFinder && !postFinder[ expando ] ) { postFinder = setMatcher( postFinder, postSelector ); } return markFunction(function( seed, results, context, xml ) { var temp, i, elem, preMap = [], postMap = [], preexisting = results.length, // Get initial elements from seed or context elems = seed || multipleContexts( selector || "*", context.nodeType ? [ context ] : context, [] ), // Prefilter to get matcher input, preserving a map for seed-results synchronization matcherIn = preFilter && ( seed || !selector ) ? condense( elems, preMap, preFilter, context, xml ) : elems, matcherOut = matcher ? // If we have a postFinder, or filtered seed, or non-seed postFilter or preexisting results, postFinder || ( seed ? preFilter : preexisting || postFilter ) ? // ...intermediate processing is necessary [] : // ...otherwise use results directly results : matcherIn; // Find primary matches if ( matcher ) { matcher( matcherIn, matcherOut, context, xml ); } // Apply postFilter if ( postFilter ) { temp = condense( matcherOut, postMap ); postFilter( temp, [], context, xml ); // Un-match failing elements by moving them back to matcherIn i = temp.length; while ( i-- ) { if ( (elem = temp[i]) ) { matcherOut[ postMap[i] ] = !(matcherIn[ postMap[i] ] = elem); } } } if ( seed ) { if ( postFinder || preFilter ) { if ( postFinder ) { // Get the final matcherOut by condensing this intermediate into postFinder contexts temp = []; i = matcherOut.length; while ( i-- ) { if ( (elem = matcherOut[i]) ) { // Restore matcherIn since elem is not yet a final match temp.push( (matcherIn[i] = elem) ); } } postFinder( null, (matcherOut = []), temp, xml ); } // Move matched elements from seed to results to keep them synchronized i = matcherOut.length; while ( i-- ) { if ( (elem = matcherOut[i]) && (temp = postFinder ? indexOf( seed, elem ) : preMap[i]) > -1 ) { seed[temp] = !(results[temp] = elem); } } } // Add elements to results, through postFinder if defined } else { matcherOut = condense( matcherOut === results ? matcherOut.splice( preexisting, matcherOut.length ) : matcherOut ); if ( postFinder ) { postFinder( null, results, matcherOut, xml ); } else { push.apply( results, matcherOut ); } } }); } function matcherFromTokens( tokens ) { var checkContext, matcher, j, len = tokens.length, leadingRelative = Expr.relative[ tokens[0].type ], implicitRelative = leadingRelative || Expr.relative[" "], i = leadingRelative ? 1 : 0, // The foundational matcher ensures that elements are reachable from top-level context(s) matchContext = addCombinator( function( elem ) { return elem === checkContext; }, implicitRelative, true ), matchAnyContext = addCombinator( function( elem ) { return indexOf( checkContext, elem ) > -1; }, implicitRelative, true ), matchers = [ function( elem, context, xml ) { var ret = ( !leadingRelative && ( xml || context !== outermostContext ) ) || ( (checkContext = context).nodeType ? matchContext( elem, context, xml ) : matchAnyContext( elem, context, xml ) ); // Avoid hanging onto element (issue #299) checkContext = null; return ret; } ]; for ( ; i < len; i++ ) { if ( (matcher = Expr.relative[ tokens[i].type ]) ) { matchers = [ addCombinator(elementMatcher( matchers ), matcher) ]; } else { matcher = Expr.filter[ tokens[i].type ].apply( null, tokens[i].matches ); // Return special upon seeing a positional matcher if ( matcher[ expando ] ) { // Find the next relative operator (if any) for proper handling j = ++i; for ( ; j < len; j++ ) { if ( Expr.relative[ tokens[j].type ] ) { break; } } return setMatcher( i > 1 && elementMatcher( matchers ), i > 1 && toSelector( // If the preceding token was a descendant combinator, insert an implicit any-element `*` tokens.slice( 0, i - 1 ).concat({ value: tokens[ i - 2 ].type === " " ? "*" : "" }) ).replace( rtrim, "$1" ), matcher, i < j && matcherFromTokens( tokens.slice( i, j ) ), j < len && matcherFromTokens( (tokens = tokens.slice( j )) ), j < len && toSelector( tokens ) ); } matchers.push( matcher ); } } return elementMatcher( matchers ); } function matcherFromGroupMatchers( elementMatchers, setMatchers ) { var bySet = setMatchers.length > 0, byElement = elementMatchers.length > 0, superMatcher = function( seed, context, xml, results, outermost ) { var elem, j, matcher, matchedCount = 0, i = "0", unmatched = seed && [], setMatched = [], contextBackup = outermostContext, // We must always have either seed elements or outermost context elems = seed || byElement && Expr.find["TAG"]( "*", outermost ), // Use integer dirruns iff this is the outermost matcher dirrunsUnique = (dirruns += contextBackup == null ? 1 : Math.random() || 0.1), len = elems.length; if ( outermost ) { outermostContext = context === document || context || outermost; } // Add elements passing elementMatchers directly to results // Support: IE<9, Safari // Tolerate NodeList properties (IE: "length"; Safari: ) matching elements by id for ( ; i !== len && (elem = elems[i]) != null; i++ ) { if ( byElement && elem ) { j = 0; if ( !context && elem.ownerDocument !== document ) { setDocument( elem ); xml = !documentIsHTML; } while ( (matcher = elementMatchers[j++]) ) { if ( matcher( elem, context || document, xml) ) { results.push( elem ); break; } } if ( outermost ) { dirruns = dirrunsUnique; } } // Track unmatched elements for set filters if ( bySet ) { // They will have gone through all possible matchers if ( (elem = !matcher && elem) ) { matchedCount--; } // Lengthen the array for every element, matched or not if ( seed ) { unmatched.push( elem ); } } } // `i` is now the count of elements visited above, and adding it to `matchedCount` // makes the latter nonnegative. matchedCount += i; // Apply set filters to unmatched elements // NOTE: This can be skipped if there are no unmatched elements (i.e., `matchedCount` // equals `i`), unless we didn't visit _any_ elements in the above loop because we have // no element matchers and no seed. // Incrementing an initially-string "0" `i` allows `i` to remain a string only in that // case, which will result in a "00" `matchedCount` that differs from `i` but is also // numerically zero. if ( bySet && i !== matchedCount ) { j = 0; while ( (matcher = setMatchers[j++]) ) { matcher( unmatched, setMatched, context, xml ); } if ( seed ) { // Reintegrate element matches to eliminate the need for sorting if ( matchedCount > 0 ) { while ( i-- ) { if ( !(unmatched[i] || setMatched[i]) ) { setMatched[i] = pop.call( results ); } } } // Discard index placeholder values to get only actual matches setMatched = condense( setMatched ); } // Add matches to results push.apply( results, setMatched ); // Seedless set matches succeeding multiple successful matchers stipulate sorting if ( outermost && !seed && setMatched.length > 0 && ( matchedCount + setMatchers.length ) > 1 ) { Sizzle.uniqueSort( results ); } } // Override manipulation of globals by nested matchers if ( outermost ) { dirruns = dirrunsUnique; outermostContext = contextBackup; } return unmatched; }; return bySet ? markFunction( superMatcher ) : superMatcher; } compile = Sizzle.compile = function( selector, match /* Internal Use Only */ ) { var i, setMatchers = [], elementMatchers = [], cached = compilerCache[ selector + " " ]; if ( !cached ) { // Generate a function of recursive functions that can be used to check each element if ( !match ) { match = tokenize( selector ); } i = match.length; while ( i-- ) { cached = matcherFromTokens( match[i] ); if ( cached[ expando ] ) { setMatchers.push( cached ); } else { elementMatchers.push( cached ); } } // Cache the compiled function cached = compilerCache( selector, matcherFromGroupMatchers( elementMatchers, setMatchers ) ); // Save selector and tokenization cached.selector = selector; } return cached; }; /** * A low-level selection function that works with Sizzle's compiled * selector functions * @param {String|Function} selector A selector or a pre-compiled * selector function built with Sizzle.compile * @param {Element} context * @param {Array} [results] * @param {Array} [seed] A set of elements to match against */ select = Sizzle.select = function( selector, context, results, seed ) { var i, tokens, token, type, find, compiled = typeof selector === "function" && selector, match = !seed && tokenize( (selector = compiled.selector || selector) ); results = results || []; // Try to minimize operations if there is only one selector in the list and no seed // (the latter of which guarantees us context) if ( match.length === 1 ) { // Reduce context if the leading compound selector is an ID tokens = match[0] = match[0].slice( 0 ); if ( tokens.length > 2 && (token = tokens[0]).type === "ID" && context.nodeType === 9 && documentIsHTML && Expr.relative[ tokens[1].type ] ) { context = ( Expr.find["ID"]( token.matches[0].replace(runescape, funescape), context ) || [] )[0]; if ( !context ) { return results; // Precompiled matchers will still verify ancestry, so step up a level } else if ( compiled ) { context = context.parentNode; } selector = selector.slice( tokens.shift().value.length ); } // Fetch a seed set for right-to-left matching i = matchExpr["needsContext"].test( selector ) ? 0 : tokens.length; while ( i-- ) { token = tokens[i]; // Abort if we hit a combinator if ( Expr.relative[ (type = token.type) ] ) { break; } if ( (find = Expr.find[ type ]) ) { // Search, expanding context for leading sibling combinators if ( (seed = find( token.matches[0].replace( runescape, funescape ), rsibling.test( tokens[0].type ) && testContext( context.parentNode ) || context )) ) { // If seed is empty or no tokens remain, we can return early tokens.splice( i, 1 ); selector = seed.length && toSelector( tokens ); if ( !selector ) { push.apply( results, seed ); return results; } break; } } } } // Compile and execute a filtering function if one is not provided // Provide `match` to avoid retokenization if we modified the selector above ( compiled || compile( selector, match ) )( seed, context, !documentIsHTML, results, !context || rsibling.test( selector ) && testContext( context.parentNode ) || context ); return results; }; // One-time assignments // Sort stability support.sortStable = expando.split("").sort( sortOrder ).join("") === expando; // Support: Chrome 14-35+ // Always assume duplicates if they aren't passed to the comparison function support.detectDuplicates = !!hasDuplicate; // Initialize against the default document setDocument(); // Support: Webkit<537.32 - Safari 6.0.3/Chrome 25 (fixed in Chrome 27) // Detached nodes confoundingly follow *each other* support.sortDetached = assert(function( el ) { // Should return 1, but returns 4 (following) return el.compareDocumentPosition( document.createElement("fieldset") ) & 1; }); // Support: IE<8 // Prevent attribute/property "interpolation" // https://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx if ( !assert(function( el ) { el.innerHTML = ""; return el.firstChild.getAttribute("href") === "#" ; }) ) { addHandle( "type|href|height|width", function( elem, name, isXML ) { if ( !isXML ) { return elem.getAttribute( name, name.toLowerCase() === "type" ? 1 : 2 ); } }); } // Support: IE<9 // Use defaultValue in place of getAttribute("value") if ( !support.attributes || !assert(function( el ) { el.innerHTML = ""; el.firstChild.setAttribute( "value", "" ); return el.firstChild.getAttribute( "value" ) === ""; }) ) { addHandle( "value", function( elem, name, isXML ) { if ( !isXML && elem.nodeName.toLowerCase() === "input" ) { return elem.defaultValue; } }); } // Support: IE<9 // Use getAttributeNode to fetch booleans when getAttribute lies if ( !assert(function( el ) { return el.getAttribute("disabled") == null; }) ) { addHandle( booleans, function( elem, name, isXML ) { var val; if ( !isXML ) { return elem[ name ] === true ? name.toLowerCase() : (val = elem.getAttributeNode( name )) && val.specified ? val.value : null; } }); } return Sizzle; })( window ); jQuery.find = Sizzle; jQuery.expr = Sizzle.selectors; // Deprecated jQuery.expr[ ":" ] = jQuery.expr.pseudos; jQuery.uniqueSort = jQuery.unique = Sizzle.uniqueSort; jQuery.text = Sizzle.getText; jQuery.isXMLDoc = Sizzle.isXML; jQuery.contains = Sizzle.contains; jQuery.escapeSelector = Sizzle.escape; var dir = function( elem, dir, until ) { var matched = [], truncate = until !== undefined; while ( ( elem = elem[ dir ] ) && elem.nodeType !== 9 ) { if ( elem.nodeType === 1 ) { if ( truncate && jQuery( elem ).is( until ) ) { break; } matched.push( elem ); } } return matched; }; var siblings = function( n, elem ) { var matched = []; for ( ; n; n = n.nextSibling ) { if ( n.nodeType === 1 && n !== elem ) { matched.push( n ); } } return matched; }; var rneedsContext = jQuery.expr.match.needsContext; function nodeName( elem, name ) { return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase(); }; var rsingleTag = ( /^<([a-z][^\/\0>:\x20\t\r\n\f]*)[\x20\t\r\n\f]*\/?>(?:<\/\1>|)$/i ); var risSimple = /^.[^:#\[\.,]*$/; // Implement the identical functionality for filter and not function winnow( elements, qualifier, not ) { if ( jQuery.isFunction( qualifier ) ) { return jQuery.grep( elements, function( elem, i ) { return !!qualifier.call( elem, i, elem ) !== not; } ); } // Single element if ( qualifier.nodeType ) { return jQuery.grep( elements, function( elem ) { return ( elem === qualifier ) !== not; } ); } // Arraylike of elements (jQuery, arguments, Array) if ( typeof qualifier !== "string" ) { return jQuery.grep( elements, function( elem ) { return ( indexOf.call( qualifier, elem ) > -1 ) !== not; } ); } // Simple selector that can be filtered directly, removing non-Elements if ( risSimple.test( qualifier ) ) { return jQuery.filter( qualifier, elements, not ); } // Complex selector, compare the two sets, removing non-Elements qualifier = jQuery.filter( qualifier, elements ); return jQuery.grep( elements, function( elem ) { return ( indexOf.call( qualifier, elem ) > -1 ) !== not && elem.nodeType === 1; } ); } jQuery.filter = function( expr, elems, not ) { var elem = elems[ 0 ]; if ( not ) { expr = ":not(" + expr + ")"; } if ( elems.length === 1 && elem.nodeType === 1 ) { return jQuery.find.matchesSelector( elem, expr ) ? [ elem ] : []; } return jQuery.find.matches( expr, jQuery.grep( elems, function( elem ) { return elem.nodeType === 1; } ) ); }; jQuery.fn.extend( { find: function( selector ) { var i, ret, len = this.length, self = this; if ( typeof selector !== "string" ) { return this.pushStack( jQuery( selector ).filter( function() { for ( i = 0; i < len; i++ ) { if ( jQuery.contains( self[ i ], this ) ) { return true; } } } ) ); } ret = this.pushStack( [] ); for ( i = 0; i < len; i++ ) { jQuery.find( selector, self[ i ], ret ); } return len > 1 ? jQuery.uniqueSort( ret ) : ret; }, filter: function( selector ) { return this.pushStack( winnow( this, selector || [], false ) ); }, not: function( selector ) { return this.pushStack( winnow( this, selector || [], true ) ); }, is: function( selector ) { return !!winnow( this, // If this is a positional/relative selector, check membership in the returned set // so $("p:first").is("p:last") won't return true for a doc with two "p". typeof selector === "string" && rneedsContext.test( selector ) ? jQuery( selector ) : selector || [], false ).length; } } ); // Initialize a jQuery object // A central reference to the root jQuery(document) var rootjQuery, // A simple way to check for HTML strings // Prioritize #id over to avoid XSS via location.hash (#9521) // Strict HTML recognition (#11290: must start with <) // Shortcut simple #id case for speed rquickExpr = /^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]+))$/, init = jQuery.fn.init = function( selector, context, root ) { var match, elem; // HANDLE: $(""), $(null), $(undefined), $(false) if ( !selector ) { return this; } // Method init() accepts an alternate rootjQuery // so migrate can support jQuery.sub (gh-2101) root = root || rootjQuery; // Handle HTML strings if ( typeof selector === "string" ) { if ( selector[ 0 ] === "<" && selector[ selector.length - 1 ] === ">" && selector.length >= 3 ) { // Assume that strings that start and end with <> are HTML and skip the regex check match = [ null, selector, null ]; } else { match = rquickExpr.exec( selector ); } // Match html or make sure no context is specified for #id if ( match && ( match[ 1 ] || !context ) ) { // HANDLE: $(html) -> $(array) if ( match[ 1 ] ) { context = context instanceof jQuery ? context[ 0 ] : context; // Option to run scripts is true for back-compat // Intentionally let the error be thrown if parseHTML is not present jQuery.merge( this, jQuery.parseHTML( match[ 1 ], context && context.nodeType ? context.ownerDocument || context : document, true ) ); // HANDLE: $(html, props) if ( rsingleTag.test( match[ 1 ] ) && jQuery.isPlainObject( context ) ) { for ( match in context ) { // Properties of context are called as methods if possible if ( jQuery.isFunction( this[ match ] ) ) { this[ match ]( context[ match ] ); // ...and otherwise set as attributes } else { this.attr( match, context[ match ] ); } } } return this; // HANDLE: $(#id) } else { elem = document.getElementById( match[ 2 ] ); if ( elem ) { // Inject the element directly into the jQuery object this[ 0 ] = elem; this.length = 1; } return this; } // HANDLE: $(expr, $(...)) } else if ( !context || context.jquery ) { return ( context || root ).find( selector ); // HANDLE: $(expr, context) // (which is just equivalent to: $(context).find(expr) } else { return this.constructor( context ).find( selector ); } // HANDLE: $(DOMElement) } else if ( selector.nodeType ) { this[ 0 ] = selector; this.length = 1; return this; // HANDLE: $(function) // Shortcut for document ready } else if ( jQuery.isFunction( selector ) ) { return root.ready !== undefined ? root.ready( selector ) : // Execute immediately if ready is not present selector( jQuery ); } return jQuery.makeArray( selector, this ); }; // Give the init function the jQuery prototype for later instantiation init.prototype = jQuery.fn; // Initialize central reference rootjQuery = jQuery( document ); var rparentsprev = /^(?:parents|prev(?:Until|All))/, // Methods guaranteed to produce a unique set when starting from a unique set guaranteedUnique = { children: true, contents: true, next: true, prev: true }; jQuery.fn.extend( { has: function( target ) { var targets = jQuery( target, this ), l = targets.length; return this.filter( function() { var i = 0; for ( ; i < l; i++ ) { if ( jQuery.contains( this, targets[ i ] ) ) { return true; } } } ); }, closest: function( selectors, context ) { var cur, i = 0, l = this.length, matched = [], targets = typeof selectors !== "string" && jQuery( selectors ); // Positional selectors never match, since there's no _selection_ context if ( !rneedsContext.test( selectors ) ) { for ( ; i < l; i++ ) { for ( cur = this[ i ]; cur && cur !== context; cur = cur.parentNode ) { // Always skip document fragments if ( cur.nodeType < 11 && ( targets ? targets.index( cur ) > -1 : // Don't pass non-elements to Sizzle cur.nodeType === 1 && jQuery.find.matchesSelector( cur, selectors ) ) ) { matched.push( cur ); break; } } } } return this.pushStack( matched.length > 1 ? jQuery.uniqueSort( matched ) : matched ); }, // Determine the position of an element within the set index: function( elem ) { // No argument, return index in parent if ( !elem ) { return ( this[ 0 ] && this[ 0 ].parentNode ) ? this.first().prevAll().length : -1; } // Index in selector if ( typeof elem === "string" ) { return indexOf.call( jQuery( elem ), this[ 0 ] ); } // Locate the position of the desired element return indexOf.call( this, // If it receives a jQuery object, the first element is used elem.jquery ? elem[ 0 ] : elem ); }, add: function( selector, context ) { return this.pushStack( jQuery.uniqueSort( jQuery.merge( this.get(), jQuery( selector, context ) ) ) ); }, addBack: function( selector ) { return this.add( selector == null ? this.prevObject : this.prevObject.filter( selector ) ); } } ); function sibling( cur, dir ) { while ( ( cur = cur[ dir ] ) && cur.nodeType !== 1 ) {} return cur; } jQuery.each( { parent: function( elem ) { var parent = elem.parentNode; return parent && parent.nodeType !== 11 ? parent : null; }, parents: function( elem ) { return dir( elem, "parentNode" ); }, parentsUntil: function( elem, i, until ) { return dir( elem, "parentNode", until ); }, next: function( elem ) { return sibling( elem, "nextSibling" ); }, prev: function( elem ) { return sibling( elem, "previousSibling" ); }, nextAll: function( elem ) { return dir( elem, "nextSibling" ); }, prevAll: function( elem ) { return dir( elem, "previousSibling" ); }, nextUntil: function( elem, i, until ) { return dir( elem, "nextSibling", until ); }, prevUntil: function( elem, i, until ) { return dir( elem, "previousSibling", until ); }, siblings: function( elem ) { return siblings( ( elem.parentNode || {} ).firstChild, elem ); }, children: function( elem ) { return siblings( elem.firstChild ); }, contents: function( elem ) { if ( nodeName( elem, "iframe" ) ) { return elem.contentDocument; } // Support: IE 9 - 11 only, iOS 7 only, Android Browser <=4.3 only // Treat the template element as a regular one in browsers that // don't support it. if ( nodeName( elem, "template" ) ) { elem = elem.content || elem; } return jQuery.merge( [], elem.childNodes ); } }, function( name, fn ) { jQuery.fn[ name ] = function( until, selector ) { var matched = jQuery.map( this, fn, until ); if ( name.slice( -5 ) !== "Until" ) { selector = until; } if ( selector && typeof selector === "string" ) { matched = jQuery.filter( selector, matched ); } if ( this.length > 1 ) { // Remove duplicates if ( !guaranteedUnique[ name ] ) { jQuery.uniqueSort( matched ); } // Reverse order for parents* and prev-derivatives if ( rparentsprev.test( name ) ) { matched.reverse(); } } return this.pushStack( matched ); }; } ); var rnothtmlwhite = ( /[^\x20\t\r\n\f]+/g ); // Convert String-formatted options into Object-formatted ones function createOptions( options ) { var object = {}; jQuery.each( options.match( rnothtmlwhite ) || [], function( _, flag ) { object[ flag ] = true; } ); return object; } /* * Create a callback list using the following parameters: * * options: an optional list of space-separated options that will change how * the callback list behaves or a more traditional option object * * By default a callback list will act like an event callback list and can be * "fired" multiple times. * * Possible options: * * once: will ensure the callback list can only be fired once (like a Deferred) * * memory: will keep track of previous values and will call any callback added * after the list has been fired right away with the latest "memorized" * values (like a Deferred) * * unique: will ensure a callback can only be added once (no duplicate in the list) * * stopOnFalse: interrupt callings when a callback returns false * */ jQuery.Callbacks = function( options ) { // Convert options from String-formatted to Object-formatted if needed // (we check in cache first) options = typeof options === "string" ? createOptions( options ) : jQuery.extend( {}, options ); var // Flag to know if list is currently firing firing, // Last fire value for non-forgettable lists memory, // Flag to know if list was already fired fired, // Flag to prevent firing locked, // Actual callback list list = [], // Queue of execution data for repeatable lists queue = [], // Index of currently firing callback (modified by add/remove as needed) firingIndex = -1, // Fire callbacks fire = function() { // Enforce single-firing locked = locked || options.once; // Execute callbacks for all pending executions, // respecting firingIndex overrides and runtime changes fired = firing = true; for ( ; queue.length; firingIndex = -1 ) { memory = queue.shift(); while ( ++firingIndex < list.length ) { // Run callback and check for early termination if ( list[ firingIndex ].apply( memory[ 0 ], memory[ 1 ] ) === false && options.stopOnFalse ) { // Jump to end and forget the data so .add doesn't re-fire firingIndex = list.length; memory = false; } } } // Forget the data if we're done with it if ( !options.memory ) { memory = false; } firing = false; // Clean up if we're done firing for good if ( locked ) { // Keep an empty list if we have data for future add calls if ( memory ) { list = []; // Otherwise, this object is spent } else { list = ""; } } }, // Actual Callbacks object self = { // Add a callback or a collection of callbacks to the list add: function() { if ( list ) { // If we have memory from a past run, we should fire after adding if ( memory && !firing ) { firingIndex = list.length - 1; queue.push( memory ); } ( function add( args ) { jQuery.each( args, function( _, arg ) { if ( jQuery.isFunction( arg ) ) { if ( !options.unique || !self.has( arg ) ) { list.push( arg ); } } else if ( arg && arg.length && jQuery.type( arg ) !== "string" ) { // Inspect recursively add( arg ); } } ); } )( arguments ); if ( memory && !firing ) { fire(); } } return this; }, // Remove a callback from the list remove: function() { jQuery.each( arguments, function( _, arg ) { var index; while ( ( index = jQuery.inArray( arg, list, index ) ) > -1 ) { list.splice( index, 1 ); // Handle firing indexes if ( index <= firingIndex ) { firingIndex--; } } } ); return this; }, // Check if a given callback is in the list. // If no argument is given, return whether or not list has callbacks attached. has: function( fn ) { return fn ? jQuery.inArray( fn, list ) > -1 : list.length > 0; }, // Remove all callbacks from the list empty: function() { if ( list ) { list = []; } return this; }, // Disable .fire and .add // Abort any current/pending executions // Clear all callbacks and values disable: function() { locked = queue = []; list = memory = ""; return this; }, disabled: function() { return !list; }, // Disable .fire // Also disable .add unless we have memory (since it would have no effect) // Abort any pending executions lock: function() { locked = queue = []; if ( !memory && !firing ) { list = memory = ""; } return this; }, locked: function() { return !!locked; }, // Call all callbacks with the given context and arguments fireWith: function( context, args ) { if ( !locked ) { args = args || []; args = [ context, args.slice ? args.slice() : args ]; queue.push( args ); if ( !firing ) { fire(); } } return this; }, // Call all the callbacks with the given arguments fire: function() { self.fireWith( this, arguments ); return this; }, // To know if the callbacks have already been called at least once fired: function() { return !!fired; } }; return self; }; function Identity( v ) { return v; } function Thrower( ex ) { throw ex; } function adoptValue( value, resolve, reject, noValue ) { var method; try { // Check for promise aspect first to privilege synchronous behavior if ( value && jQuery.isFunction( ( method = value.promise ) ) ) { method.call( value ).done( resolve ).fail( reject ); // Other thenables } else if ( value && jQuery.isFunction( ( method = value.then ) ) ) { method.call( value, resolve, reject ); // Other non-thenables } else { // Control `resolve` arguments by letting Array#slice cast boolean `noValue` to integer: // * false: [ value ].slice( 0 ) => resolve( value ) // * true: [ value ].slice( 1 ) => resolve() resolve.apply( undefined, [ value ].slice( noValue ) ); } // For Promises/A+, convert exceptions into rejections // Since jQuery.when doesn't unwrap thenables, we can skip the extra checks appearing in // Deferred#then to conditionally suppress rejection. } catch ( value ) { // Support: Android 4.0 only // Strict mode functions invoked without .call/.apply get global-object context reject.apply( undefined, [ value ] ); } } jQuery.extend( { Deferred: function( func ) { var tuples = [ // action, add listener, callbacks, // ... .then handlers, argument index, [final state] [ "notify", "progress", jQuery.Callbacks( "memory" ), jQuery.Callbacks( "memory" ), 2 ], [ "resolve", "done", jQuery.Callbacks( "once memory" ), jQuery.Callbacks( "once memory" ), 0, "resolved" ], [ "reject", "fail", jQuery.Callbacks( "once memory" ), jQuery.Callbacks( "once memory" ), 1, "rejected" ] ], state = "pending", promise = { state: function() { return state; }, always: function() { deferred.done( arguments ).fail( arguments ); return this; }, "catch": function( fn ) { return promise.then( null, fn ); }, // Keep pipe for back-compat pipe: function( /* fnDone, fnFail, fnProgress */ ) { var fns = arguments; return jQuery.Deferred( function( newDefer ) { jQuery.each( tuples, function( i, tuple ) { // Map tuples (progress, done, fail) to arguments (done, fail, progress) var fn = jQuery.isFunction( fns[ tuple[ 4 ] ] ) && fns[ tuple[ 4 ] ]; // deferred.progress(function() { bind to newDefer or newDefer.notify }) // deferred.done(function() { bind to newDefer or newDefer.resolve }) // deferred.fail(function() { bind to newDefer or newDefer.reject }) deferred[ tuple[ 1 ] ]( function() { var returned = fn && fn.apply( this, arguments ); if ( returned && jQuery.isFunction( returned.promise ) ) { returned.promise() .progress( newDefer.notify ) .done( newDefer.resolve ) .fail( newDefer.reject ); } else { newDefer[ tuple[ 0 ] + "With" ]( this, fn ? [ returned ] : arguments ); } } ); } ); fns = null; } ).promise(); }, then: function( onFulfilled, onRejected, onProgress ) { var maxDepth = 0; function resolve( depth, deferred, handler, special ) { return function() { var that = this, args = arguments, mightThrow = function() { var returned, then; // Support: Promises/A+ section 2.3.3.3.3 // https://promisesaplus.com/#point-59 // Ignore double-resolution attempts if ( depth < maxDepth ) { return; } returned = handler.apply( that, args ); // Support: Promises/A+ section 2.3.1 // https://promisesaplus.com/#point-48 if ( returned === deferred.promise() ) { throw new TypeError( "Thenable self-resolution" ); } // Support: Promises/A+ sections 2.3.3.1, 3.5 // https://promisesaplus.com/#point-54 // https://promisesaplus.com/#point-75 // Retrieve `then` only once then = returned && // Support: Promises/A+ section 2.3.4 // https://promisesaplus.com/#point-64 // Only check objects and functions for thenability ( typeof returned === "object" || typeof returned === "function" ) && returned.then; // Handle a returned thenable if ( jQuery.isFunction( then ) ) { // Special processors (notify) just wait for resolution if ( special ) { then.call( returned, resolve( maxDepth, deferred, Identity, special ), resolve( maxDepth, deferred, Thrower, special ) ); // Normal processors (resolve) also hook into progress } else { // ...and disregard older resolution values maxDepth++; then.call( returned, resolve( maxDepth, deferred, Identity, special ), resolve( maxDepth, deferred, Thrower, special ), resolve( maxDepth, deferred, Identity, deferred.notifyWith ) ); } // Handle all other returned values } else { // Only substitute handlers pass on context // and multiple values (non-spec behavior) if ( handler !== Identity ) { that = undefined; args = [ returned ]; } // Process the value(s) // Default process is resolve ( special || deferred.resolveWith )( that, args ); } }, // Only normal processors (resolve) catch and reject exceptions process = special ? mightThrow : function() { try { mightThrow(); } catch ( e ) { if ( jQuery.Deferred.exceptionHook ) { jQuery.Deferred.exceptionHook( e, process.stackTrace ); } // Support: Promises/A+ section 2.3.3.3.4.1 // https://promisesaplus.com/#point-61 // Ignore post-resolution exceptions if ( depth + 1 >= maxDepth ) { // Only substitute handlers pass on context // and multiple values (non-spec behavior) if ( handler !== Thrower ) { that = undefined; args = [ e ]; } deferred.rejectWith( that, args ); } } }; // Support: Promises/A+ section 2.3.3.3.1 // https://promisesaplus.com/#point-57 // Re-resolve promises immediately to dodge false rejection from // subsequent errors if ( depth ) { process(); } else { // Call an optional hook to record the stack, in case of exception // since it's otherwise lost when execution goes async if ( jQuery.Deferred.getStackHook ) { process.stackTrace = jQuery.Deferred.getStackHook(); } window.setTimeout( process ); } }; } return jQuery.Deferred( function( newDefer ) { // progress_handlers.add( ... ) tuples[ 0 ][ 3 ].add( resolve( 0, newDefer, jQuery.isFunction( onProgress ) ? onProgress : Identity, newDefer.notifyWith ) ); // fulfilled_handlers.add( ... ) tuples[ 1 ][ 3 ].add( resolve( 0, newDefer, jQuery.isFunction( onFulfilled ) ? onFulfilled : Identity ) ); // rejected_handlers.add( ... ) tuples[ 2 ][ 3 ].add( resolve( 0, newDefer, jQuery.isFunction( onRejected ) ? onRejected : Thrower ) ); } ).promise(); }, // Get a promise for this deferred // If obj is provided, the promise aspect is added to the object promise: function( obj ) { return obj != null ? jQuery.extend( obj, promise ) : promise; } }, deferred = {}; // Add list-specific methods jQuery.each( tuples, function( i, tuple ) { var list = tuple[ 2 ], stateString = tuple[ 5 ]; // promise.progress = list.add // promise.done = list.add // promise.fail = list.add promise[ tuple[ 1 ] ] = list.add; // Handle state if ( stateString ) { list.add( function() { // state = "resolved" (i.e., fulfilled) // state = "rejected" state = stateString; }, // rejected_callbacks.disable // fulfilled_callbacks.disable tuples[ 3 - i ][ 2 ].disable, // progress_callbacks.lock tuples[ 0 ][ 2 ].lock ); } // progress_handlers.fire // fulfilled_handlers.fire // rejected_handlers.fire list.add( tuple[ 3 ].fire ); // deferred.notify = function() { deferred.notifyWith(...) } // deferred.resolve = function() { deferred.resolveWith(...) } // deferred.reject = function() { deferred.rejectWith(...) } deferred[ tuple[ 0 ] ] = function() { deferred[ tuple[ 0 ] + "With" ]( this === deferred ? undefined : this, arguments ); return this; }; // deferred.notifyWith = list.fireWith // deferred.resolveWith = list.fireWith // deferred.rejectWith = list.fireWith deferred[ tuple[ 0 ] + "With" ] = list.fireWith; } ); // Make the deferred a promise promise.promise( deferred ); // Call given func if any if ( func ) { func.call( deferred, deferred ); } // All done! return deferred; }, // Deferred helper when: function( singleValue ) { var // count of uncompleted subordinates remaining = arguments.length, // count of unprocessed arguments i = remaining, // subordinate fulfillment data resolveContexts = Array( i ), resolveValues = slice.call( arguments ), // the master Deferred master = jQuery.Deferred(), // subordinate callback factory updateFunc = function( i ) { return function( value ) { resolveContexts[ i ] = this; resolveValues[ i ] = arguments.length > 1 ? slice.call( arguments ) : value; if ( !( --remaining ) ) { master.resolveWith( resolveContexts, resolveValues ); } }; }; // Single- and empty arguments are adopted like Promise.resolve if ( remaining <= 1 ) { adoptValue( singleValue, master.done( updateFunc( i ) ).resolve, master.reject, !remaining ); // Use .then() to unwrap secondary thenables (cf. gh-3000) if ( master.state() === "pending" || jQuery.isFunction( resolveValues[ i ] && resolveValues[ i ].then ) ) { return master.then(); } } // Multiple arguments are aggregated like Promise.all array elements while ( i-- ) { adoptValue( resolveValues[ i ], updateFunc( i ), master.reject ); } return master.promise(); } } ); // These usually indicate a programmer mistake during development, // warn about them ASAP rather than swallowing them by default. var rerrorNames = /^(Eval|Internal|Range|Reference|Syntax|Type|URI)Error$/; jQuery.Deferred.exceptionHook = function( error, stack ) { // Support: IE 8 - 9 only // Console exists when dev tools are open, which can happen at any time if ( window.console && window.console.warn && error && rerrorNames.test( error.name ) ) { window.console.warn( "jQuery.Deferred exception: " + error.message, error.stack, stack ); } }; jQuery.readyException = function( error ) { window.setTimeout( function() { throw error; } ); }; // The deferred used on DOM ready var readyList = jQuery.Deferred(); jQuery.fn.ready = function( fn ) { readyList .then( fn ) // Wrap jQuery.readyException in a function so that the lookup // happens at the time of error handling instead of callback // registration. .catch( function( error ) { jQuery.readyException( error ); } ); return this; }; jQuery.extend( { // Is the DOM ready to be used? Set to true once it occurs. isReady: false, // A counter to track how many items to wait for before // the ready event fires. See #6781 readyWait: 1, // Handle when the DOM is ready ready: function( wait ) { // Abort if there are pending holds or we're already ready if ( wait === true ? --jQuery.readyWait : jQuery.isReady ) { return; } // Remember that the DOM is ready jQuery.isReady = true; // If a normal DOM Ready event fired, decrement, and wait if need be if ( wait !== true && --jQuery.readyWait > 0 ) { return; } // If there are functions bound, to execute readyList.resolveWith( document, [ jQuery ] ); } } ); jQuery.ready.then = readyList.then; // The ready event handler and self cleanup method function completed() { document.removeEventListener( "DOMContentLoaded", completed ); window.removeEventListener( "load", completed ); jQuery.ready(); } // Catch cases where $(document).ready() is called // after the browser event has already occurred. // Support: IE <=9 - 10 only // Older IE sometimes signals "interactive" too soon if ( document.readyState === "complete" || ( document.readyState !== "loading" && !document.documentElement.doScroll ) ) { // Handle it asynchronously to allow scripts the opportunity to delay ready window.setTimeout( jQuery.ready ); } else { // Use the handy event callback document.addEventListener( "DOMContentLoaded", completed ); // A fallback to window.onload, that will always work window.addEventListener( "load", completed ); } // Multifunctional method to get and set values of a collection // The value/s can optionally be executed if it's a function var access = function( elems, fn, key, value, chainable, emptyGet, raw ) { var i = 0, len = elems.length, bulk = key == null; // Sets many values if ( jQuery.type( key ) === "object" ) { chainable = true; for ( i in key ) { access( elems, fn, i, key[ i ], true, emptyGet, raw ); } // Sets one value } else if ( value !== undefined ) { chainable = true; if ( !jQuery.isFunction( value ) ) { raw = true; } if ( bulk ) { // Bulk operations run against the entire set if ( raw ) { fn.call( elems, value ); fn = null; // ...except when executing function values } else { bulk = fn; fn = function( elem, key, value ) { return bulk.call( jQuery( elem ), value ); }; } } if ( fn ) { for ( ; i < len; i++ ) { fn( elems[ i ], key, raw ? value : value.call( elems[ i ], i, fn( elems[ i ], key ) ) ); } } } if ( chainable ) { return elems; } // Gets if ( bulk ) { return fn.call( elems ); } return len ? fn( elems[ 0 ], key ) : emptyGet; }; var acceptData = function( owner ) { // Accepts only: // - Node // - Node.ELEMENT_NODE // - Node.DOCUMENT_NODE // - Object // - Any return owner.nodeType === 1 || owner.nodeType === 9 || !( +owner.nodeType ); }; function Data() { this.expando = jQuery.expando + Data.uid++; } Data.uid = 1; Data.prototype = { cache: function( owner ) { // Check if the owner object already has a cache var value = owner[ this.expando ]; // If not, create one if ( !value ) { value = {}; // We can accept data for non-element nodes in modern browsers, // but we should not, see #8335. // Always return an empty object. if ( acceptData( owner ) ) { // If it is a node unlikely to be stringify-ed or looped over // use plain assignment if ( owner.nodeType ) { owner[ this.expando ] = value; // Otherwise secure it in a non-enumerable property // configurable must be true to allow the property to be // deleted when data is removed } else { Object.defineProperty( owner, this.expando, { value: value, configurable: true } ); } } } return value; }, set: function( owner, data, value ) { var prop, cache = this.cache( owner ); // Handle: [ owner, key, value ] args // Always use camelCase key (gh-2257) if ( typeof data === "string" ) { cache[ jQuery.camelCase( data ) ] = value; // Handle: [ owner, { properties } ] args } else { // Copy the properties one-by-one to the cache object for ( prop in data ) { cache[ jQuery.camelCase( prop ) ] = data[ prop ]; } } return cache; }, get: function( owner, key ) { return key === undefined ? this.cache( owner ) : // Always use camelCase key (gh-2257) owner[ this.expando ] && owner[ this.expando ][ jQuery.camelCase( key ) ]; }, access: function( owner, key, value ) { // In cases where either: // // 1. No key was specified // 2. A string key was specified, but no value provided // // Take the "read" path and allow the get method to determine // which value to return, respectively either: // // 1. The entire cache object // 2. The data stored at the key // if ( key === undefined || ( ( key && typeof key === "string" ) && value === undefined ) ) { return this.get( owner, key ); } // When the key is not a string, or both a key and value // are specified, set or extend (existing objects) with either: // // 1. An object of properties // 2. A key and value // this.set( owner, key, value ); // Since the "set" path can have two possible entry points // return the expected data based on which path was taken[*] return value !== undefined ? value : key; }, remove: function( owner, key ) { var i, cache = owner[ this.expando ]; if ( cache === undefined ) { return; } if ( key !== undefined ) { // Support array or space separated string of keys if ( Array.isArray( key ) ) { // If key is an array of keys... // We always set camelCase keys, so remove that. key = key.map( jQuery.camelCase ); } else { key = jQuery.camelCase( key ); // If a key with the spaces exists, use it. // Otherwise, create an array by matching non-whitespace key = key in cache ? [ key ] : ( key.match( rnothtmlwhite ) || [] ); } i = key.length; while ( i-- ) { delete cache[ key[ i ] ]; } } // Remove the expando if there's no more data if ( key === undefined || jQuery.isEmptyObject( cache ) ) { // Support: Chrome <=35 - 45 // Webkit & Blink performance suffers when deleting properties // from DOM nodes, so set to undefined instead // https://bugs.chromium.org/p/chromium/issues/detail?id=378607 (bug restricted) if ( owner.nodeType ) { owner[ this.expando ] = undefined; } else { delete owner[ this.expando ]; } } }, hasData: function( owner ) { var cache = owner[ this.expando ]; return cache !== undefined && !jQuery.isEmptyObject( cache ); } }; var dataPriv = new Data(); var dataUser = new Data(); // Implementation Summary // // 1. Enforce API surface and semantic compatibility with 1.9.x branch // 2. Improve the module's maintainability by reducing the storage // paths to a single mechanism. // 3. Use the same single mechanism to support "private" and "user" data. // 4. _Never_ expose "private" data to user code (TODO: Drop _data, _removeData) // 5. Avoid exposing implementation details on user objects (eg. expando properties) // 6. Provide a clear path for implementation upgrade to WeakMap in 2014 var rbrace = /^(?:\{[\w\W]*\}|\[[\w\W]*\])$/, rmultiDash = /[A-Z]/g; function getData( data ) { if ( data === "true" ) { return true; } if ( data === "false" ) { return false; } if ( data === "null" ) { return null; } // Only convert to a number if it doesn't change the string if ( data === +data + "" ) { return +data; } if ( rbrace.test( data ) ) { return JSON.parse( data ); } return data; } function dataAttr( elem, key, data ) { var name; // If nothing was found internally, try to fetch any // data from the HTML5 data-* attribute if ( data === undefined && elem.nodeType === 1 ) { name = "data-" + key.replace( rmultiDash, "-$&" ).toLowerCase(); data = elem.getAttribute( name ); if ( typeof data === "string" ) { try { data = getData( data ); } catch ( e ) {} // Make sure we set the data so it isn't changed later dataUser.set( elem, key, data ); } else { data = undefined; } } return data; } jQuery.extend( { hasData: function( elem ) { return dataUser.hasData( elem ) || dataPriv.hasData( elem ); }, data: function( elem, name, data ) { return dataUser.access( elem, name, data ); }, removeData: function( elem, name ) { dataUser.remove( elem, name ); }, // TODO: Now that all calls to _data and _removeData have been replaced // with direct calls to dataPriv methods, these can be deprecated. _data: function( elem, name, data ) { return dataPriv.access( elem, name, data ); }, _removeData: function( elem, name ) { dataPriv.remove( elem, name ); } } ); jQuery.fn.extend( { data: function( key, value ) { var i, name, data, elem = this[ 0 ], attrs = elem && elem.attributes; // Gets all values if ( key === undefined ) { if ( this.length ) { data = dataUser.get( elem ); if ( elem.nodeType === 1 && !dataPriv.get( elem, "hasDataAttrs" ) ) { i = attrs.length; while ( i-- ) { // Support: IE 11 only // The attrs elements can be null (#14894) if ( attrs[ i ] ) { name = attrs[ i ].name; if ( name.indexOf( "data-" ) === 0 ) { name = jQuery.camelCase( name.slice( 5 ) ); dataAttr( elem, name, data[ name ] ); } } } dataPriv.set( elem, "hasDataAttrs", true ); } } return data; } // Sets multiple values if ( typeof key === "object" ) { return this.each( function() { dataUser.set( this, key ); } ); } return access( this, function( value ) { var data; // The calling jQuery object (element matches) is not empty // (and therefore has an element appears at this[ 0 ]) and the // `value` parameter was not undefined. An empty jQuery object // will result in `undefined` for elem = this[ 0 ] which will // throw an exception if an attempt to read a data cache is made. if ( elem && value === undefined ) { // Attempt to get data from the cache // The key will always be camelCased in Data data = dataUser.get( elem, key ); if ( data !== undefined ) { return data; } // Attempt to "discover" the data in // HTML5 custom data-* attrs data = dataAttr( elem, key ); if ( data !== undefined ) { return data; } // We tried really hard, but the data doesn't exist. return; } // Set the data... this.each( function() { // We always store the camelCased key dataUser.set( this, key, value ); } ); }, null, value, arguments.length > 1, null, true ); }, removeData: function( key ) { return this.each( function() { dataUser.remove( this, key ); } ); } } ); jQuery.extend( { queue: function( elem, type, data ) { var queue; if ( elem ) { type = ( type || "fx" ) + "queue"; queue = dataPriv.get( elem, type ); // Speed up dequeue by getting out quickly if this is just a lookup if ( data ) { if ( !queue || Array.isArray( data ) ) { queue = dataPriv.access( elem, type, jQuery.makeArray( data ) ); } else { queue.push( data ); } } return queue || []; } }, dequeue: function( elem, type ) { type = type || "fx"; var queue = jQuery.queue( elem, type ), startLength = queue.length, fn = queue.shift(), hooks = jQuery._queueHooks( elem, type ), next = function() { jQuery.dequeue( elem, type ); }; // If the fx queue is dequeued, always remove the progress sentinel if ( fn === "inprogress" ) { fn = queue.shift(); startLength--; } if ( fn ) { // Add a progress sentinel to prevent the fx queue from being // automatically dequeued if ( type === "fx" ) { queue.unshift( "inprogress" ); } // Clear up the last queue stop function delete hooks.stop; fn.call( elem, next, hooks ); } if ( !startLength && hooks ) { hooks.empty.fire(); } }, // Not public - generate a queueHooks object, or return the current one _queueHooks: function( elem, type ) { var key = type + "queueHooks"; return dataPriv.get( elem, key ) || dataPriv.access( elem, key, { empty: jQuery.Callbacks( "once memory" ).add( function() { dataPriv.remove( elem, [ type + "queue", key ] ); } ) } ); } } ); jQuery.fn.extend( { queue: function( type, data ) { var setter = 2; if ( typeof type !== "string" ) { data = type; type = "fx"; setter--; } if ( arguments.length < setter ) { return jQuery.queue( this[ 0 ], type ); } return data === undefined ? this : this.each( function() { var queue = jQuery.queue( this, type, data ); // Ensure a hooks for this queue jQuery._queueHooks( this, type ); if ( type === "fx" && queue[ 0 ] !== "inprogress" ) { jQuery.dequeue( this, type ); } } ); }, dequeue: function( type ) { return this.each( function() { jQuery.dequeue( this, type ); } ); }, clearQueue: function( type ) { return this.queue( type || "fx", [] ); }, // Get a promise resolved when queues of a certain type // are emptied (fx is the type by default) promise: function( type, obj ) { var tmp, count = 1, defer = jQuery.Deferred(), elements = this, i = this.length, resolve = function() { if ( !( --count ) ) { defer.resolveWith( elements, [ elements ] ); } }; if ( typeof type !== "string" ) { obj = type; type = undefined; } type = type || "fx"; while ( i-- ) { tmp = dataPriv.get( elements[ i ], type + "queueHooks" ); if ( tmp && tmp.empty ) { count++; tmp.empty.add( resolve ); } } resolve(); return defer.promise( obj ); } } ); var pnum = ( /[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/ ).source; var rcssNum = new RegExp( "^(?:([+-])=|)(" + pnum + ")([a-z%]*)$", "i" ); var cssExpand = [ "Top", "Right", "Bottom", "Left" ]; var isHiddenWithinTree = function( elem, el ) { // isHiddenWithinTree might be called from jQuery#filter function; // in that case, element will be second argument elem = el || elem; // Inline style trumps all return elem.style.display === "none" || elem.style.display === "" && // Otherwise, check computed style // Support: Firefox <=43 - 45 // Disconnected elements can have computed display: none, so first confirm that elem is // in the document. jQuery.contains( elem.ownerDocument, elem ) && jQuery.css( elem, "display" ) === "none"; }; var swap = function( elem, options, callback, args ) { var ret, name, old = {}; // Remember the old values, and insert the new ones for ( name in options ) { old[ name ] = elem.style[ name ]; elem.style[ name ] = options[ name ]; } ret = callback.apply( elem, args || [] ); // Revert the old values for ( name in options ) { elem.style[ name ] = old[ name ]; } return ret; }; function adjustCSS( elem, prop, valueParts, tween ) { var adjusted, scale = 1, maxIterations = 20, currentValue = tween ? function() { return tween.cur(); } : function() { return jQuery.css( elem, prop, "" ); }, initial = currentValue(), unit = valueParts && valueParts[ 3 ] || ( jQuery.cssNumber[ prop ] ? "" : "px" ), // Starting value computation is required for potential unit mismatches initialInUnit = ( jQuery.cssNumber[ prop ] || unit !== "px" && +initial ) && rcssNum.exec( jQuery.css( elem, prop ) ); if ( initialInUnit && initialInUnit[ 3 ] !== unit ) { // Trust units reported by jQuery.css unit = unit || initialInUnit[ 3 ]; // Make sure we update the tween properties later on valueParts = valueParts || []; // Iteratively approximate from a nonzero starting point initialInUnit = +initial || 1; do { // If previous iteration zeroed out, double until we get *something*. // Use string for doubling so we don't accidentally see scale as unchanged below scale = scale || ".5"; // Adjust and apply initialInUnit = initialInUnit / scale; jQuery.style( elem, prop, initialInUnit + unit ); // Update scale, tolerating zero or NaN from tween.cur() // Break the loop if scale is unchanged or perfect, or if we've just had enough. } while ( scale !== ( scale = currentValue() / initial ) && scale !== 1 && --maxIterations ); } if ( valueParts ) { initialInUnit = +initialInUnit || +initial || 0; // Apply relative offset (+=/-=) if specified adjusted = valueParts[ 1 ] ? initialInUnit + ( valueParts[ 1 ] + 1 ) * valueParts[ 2 ] : +valueParts[ 2 ]; if ( tween ) { tween.unit = unit; tween.start = initialInUnit; tween.end = adjusted; } } return adjusted; } var defaultDisplayMap = {}; function getDefaultDisplay( elem ) { var temp, doc = elem.ownerDocument, nodeName = elem.nodeName, display = defaultDisplayMap[ nodeName ]; if ( display ) { return display; } temp = doc.body.appendChild( doc.createElement( nodeName ) ); display = jQuery.css( temp, "display" ); temp.parentNode.removeChild( temp ); if ( display === "none" ) { display = "block"; } defaultDisplayMap[ nodeName ] = display; return display; } function showHide( elements, show ) { var display, elem, values = [], index = 0, length = elements.length; // Determine new display value for elements that need to change for ( ; index < length; index++ ) { elem = elements[ index ]; if ( !elem.style ) { continue; } display = elem.style.display; if ( show ) { // Since we force visibility upon cascade-hidden elements, an immediate (and slow) // check is required in this first loop unless we have a nonempty display value (either // inline or about-to-be-restored) if ( display === "none" ) { values[ index ] = dataPriv.get( elem, "display" ) || null; if ( !values[ index ] ) { elem.style.display = ""; } } if ( elem.style.display === "" && isHiddenWithinTree( elem ) ) { values[ index ] = getDefaultDisplay( elem ); } } else { if ( display !== "none" ) { values[ index ] = "none"; // Remember what we're overwriting dataPriv.set( elem, "display", display ); } } } // Set the display of the elements in a second loop to avoid constant reflow for ( index = 0; index < length; index++ ) { if ( values[ index ] != null ) { elements[ index ].style.display = values[ index ]; } } return elements; } jQuery.fn.extend( { show: function() { return showHide( this, true ); }, hide: function() { return showHide( this ); }, toggle: function( state ) { if ( typeof state === "boolean" ) { return state ? this.show() : this.hide(); } return this.each( function() { if ( isHiddenWithinTree( this ) ) { jQuery( this ).show(); } else { jQuery( this ).hide(); } } ); } } ); var rcheckableType = ( /^(?:checkbox|radio)$/i ); var rtagName = ( /<([a-z][^\/\0>\x20\t\r\n\f]+)/i ); var rscriptType = ( /^$|\/(?:java|ecma)script/i ); // We have to close these tags to support XHTML (#13200) var wrapMap = { // Support: IE <=9 only option: [ 1, "" ], // XHTML parsers do not magically insert elements in the // same way that tag soup parsers do. So we cannot shorten // this by omitting or other required elements. thead: [ 1, "", "
" ], col: [ 2, "", "
" ], tr: [ 2, "", "
" ], td: [ 3, "", "
" ], _default: [ 0, "", "" ] }; // Support: IE <=9 only wrapMap.optgroup = wrapMap.option; wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead; wrapMap.th = wrapMap.td; function getAll( context, tag ) { // Support: IE <=9 - 11 only // Use typeof to avoid zero-argument method invocation on host objects (#15151) var ret; if ( typeof context.getElementsByTagName !== "undefined" ) { ret = context.getElementsByTagName( tag || "*" ); } else if ( typeof context.querySelectorAll !== "undefined" ) { ret = context.querySelectorAll( tag || "*" ); } else { ret = []; } if ( tag === undefined || tag && nodeName( context, tag ) ) { return jQuery.merge( [ context ], ret ); } return ret; } // Mark scripts as having already been evaluated function setGlobalEval( elems, refElements ) { var i = 0, l = elems.length; for ( ; i < l; i++ ) { dataPriv.set( elems[ i ], "globalEval", !refElements || dataPriv.get( refElements[ i ], "globalEval" ) ); } } var rhtml = /<|&#?\w+;/; function buildFragment( elems, context, scripts, selection, ignored ) { var elem, tmp, tag, wrap, contains, j, fragment = context.createDocumentFragment(), nodes = [], i = 0, l = elems.length; for ( ; i < l; i++ ) { elem = elems[ i ]; if ( elem || elem === 0 ) { // Add nodes directly if ( jQuery.type( elem ) === "object" ) { // Support: Android <=4.0 only, PhantomJS 1 only // push.apply(_, arraylike) throws on ancient WebKit jQuery.merge( nodes, elem.nodeType ? [ elem ] : elem ); // Convert non-html into a text node } else if ( !rhtml.test( elem ) ) { nodes.push( context.createTextNode( elem ) ); // Convert html into DOM nodes } else { tmp = tmp || fragment.appendChild( context.createElement( "div" ) ); // Deserialize a standard representation tag = ( rtagName.exec( elem ) || [ "", "" ] )[ 1 ].toLowerCase(); wrap = wrapMap[ tag ] || wrapMap._default; tmp.innerHTML = wrap[ 1 ] + jQuery.htmlPrefilter( elem ) + wrap[ 2 ]; // Descend through wrappers to the right content j = wrap[ 0 ]; while ( j-- ) { tmp = tmp.lastChild; } // Support: Android <=4.0 only, PhantomJS 1 only // push.apply(_, arraylike) throws on ancient WebKit jQuery.merge( nodes, tmp.childNodes ); // Remember the top-level container tmp = fragment.firstChild; // Ensure the created nodes are orphaned (#12392) tmp.textContent = ""; } } } // Remove wrapper from fragment fragment.textContent = ""; i = 0; while ( ( elem = nodes[ i++ ] ) ) { // Skip elements already in the context collection (trac-4087) if ( selection && jQuery.inArray( elem, selection ) > -1 ) { if ( ignored ) { ignored.push( elem ); } continue; } contains = jQuery.contains( elem.ownerDocument, elem ); // Append to fragment tmp = getAll( fragment.appendChild( elem ), "script" ); // Preserve script evaluation history if ( contains ) { setGlobalEval( tmp ); } // Capture executables if ( scripts ) { j = 0; while ( ( elem = tmp[ j++ ] ) ) { if ( rscriptType.test( elem.type || "" ) ) { scripts.push( elem ); } } } } return fragment; } ( function() { var fragment = document.createDocumentFragment(), div = fragment.appendChild( document.createElement( "div" ) ), input = document.createElement( "input" ); // Support: Android 4.0 - 4.3 only // Check state lost if the name is set (#11217) // Support: Windows Web Apps (WWA) // `name` and `type` must use .setAttribute for WWA (#14901) input.setAttribute( "type", "radio" ); input.setAttribute( "checked", "checked" ); input.setAttribute( "name", "t" ); div.appendChild( input ); // Support: Android <=4.1 only // Older WebKit doesn't clone checked state correctly in fragments support.checkClone = div.cloneNode( true ).cloneNode( true ).lastChild.checked; // Support: IE <=11 only // Make sure textarea (and checkbox) defaultValue is properly cloned div.innerHTML = ""; support.noCloneChecked = !!div.cloneNode( true ).lastChild.defaultValue; } )(); var documentElement = document.documentElement; var rkeyEvent = /^key/, rmouseEvent = /^(?:mouse|pointer|contextmenu|drag|drop)|click/, rtypenamespace = /^([^.]*)(?:\.(.+)|)/; function returnTrue() { return true; } function returnFalse() { return false; } // Support: IE <=9 only // See #13393 for more info function safeActiveElement() { try { return document.activeElement; } catch ( err ) { } } function on( elem, types, selector, data, fn, one ) { var origFn, type; // Types can be a map of types/handlers if ( typeof types === "object" ) { // ( types-Object, selector, data ) if ( typeof selector !== "string" ) { // ( types-Object, data ) data = data || selector; selector = undefined; } for ( type in types ) { on( elem, type, selector, data, types[ type ], one ); } return elem; } if ( data == null && fn == null ) { // ( types, fn ) fn = selector; data = selector = undefined; } else if ( fn == null ) { if ( typeof selector === "string" ) { // ( types, selector, fn ) fn = data; data = undefined; } else { // ( types, data, fn ) fn = data; data = selector; selector = undefined; } } if ( fn === false ) { fn = returnFalse; } else if ( !fn ) { return elem; } if ( one === 1 ) { origFn = fn; fn = function( event ) { // Can use an empty set, since event contains the info jQuery().off( event ); return origFn.apply( this, arguments ); }; // Use same guid so caller can remove using origFn fn.guid = origFn.guid || ( origFn.guid = jQuery.guid++ ); } return elem.each( function() { jQuery.event.add( this, types, fn, data, selector ); } ); } /* * Helper functions for managing events -- not part of the public interface. * Props to Dean Edwards' addEvent library for many of the ideas. */ jQuery.event = { global: {}, add: function( elem, types, handler, data, selector ) { var handleObjIn, eventHandle, tmp, events, t, handleObj, special, handlers, type, namespaces, origType, elemData = dataPriv.get( elem ); // Don't attach events to noData or text/comment nodes (but allow plain objects) if ( !elemData ) { return; } // Caller can pass in an object of custom data in lieu of the handler if ( handler.handler ) { handleObjIn = handler; handler = handleObjIn.handler; selector = handleObjIn.selector; } // Ensure that invalid selectors throw exceptions at attach time // Evaluate against documentElement in case elem is a non-element node (e.g., document) if ( selector ) { jQuery.find.matchesSelector( documentElement, selector ); } // Make sure that the handler has a unique ID, used to find/remove it later if ( !handler.guid ) { handler.guid = jQuery.guid++; } // Init the element's event structure and main handler, if this is the first if ( !( events = elemData.events ) ) { events = elemData.events = {}; } if ( !( eventHandle = elemData.handle ) ) { eventHandle = elemData.handle = function( e ) { // Discard the second event of a jQuery.event.trigger() and // when an event is called after a page has unloaded return typeof jQuery !== "undefined" && jQuery.event.triggered !== e.type ? jQuery.event.dispatch.apply( elem, arguments ) : undefined; }; } // Handle multiple events separated by a space types = ( types || "" ).match( rnothtmlwhite ) || [ "" ]; t = types.length; while ( t-- ) { tmp = rtypenamespace.exec( types[ t ] ) || []; type = origType = tmp[ 1 ]; namespaces = ( tmp[ 2 ] || "" ).split( "." ).sort(); // There *must* be a type, no attaching namespace-only handlers if ( !type ) { continue; } // If event changes its type, use the special event handlers for the changed type special = jQuery.event.special[ type ] || {}; // If selector defined, determine special event api type, otherwise given type type = ( selector ? special.delegateType : special.bindType ) || type; // Update special based on newly reset type special = jQuery.event.special[ type ] || {}; // handleObj is passed to all event handlers handleObj = jQuery.extend( { type: type, origType: origType, data: data, handler: handler, guid: handler.guid, selector: selector, needsContext: selector && jQuery.expr.match.needsContext.test( selector ), namespace: namespaces.join( "." ) }, handleObjIn ); // Init the event handler queue if we're the first if ( !( handlers = events[ type ] ) ) { handlers = events[ type ] = []; handlers.delegateCount = 0; // Only use addEventListener if the special events handler returns false if ( !special.setup || special.setup.call( elem, data, namespaces, eventHandle ) === false ) { if ( elem.addEventListener ) { elem.addEventListener( type, eventHandle ); } } } if ( special.add ) { special.add.call( elem, handleObj ); if ( !handleObj.handler.guid ) { handleObj.handler.guid = handler.guid; } } // Add to the element's handler list, delegates in front if ( selector ) { handlers.splice( handlers.delegateCount++, 0, handleObj ); } else { handlers.push( handleObj ); } // Keep track of which events have ever been used, for event optimization jQuery.event.global[ type ] = true; } }, // Detach an event or set of events from an element remove: function( elem, types, handler, selector, mappedTypes ) { var j, origCount, tmp, events, t, handleObj, special, handlers, type, namespaces, origType, elemData = dataPriv.hasData( elem ) && dataPriv.get( elem ); if ( !elemData || !( events = elemData.events ) ) { return; } // Once for each type.namespace in types; type may be omitted types = ( types || "" ).match( rnothtmlwhite ) || [ "" ]; t = types.length; while ( t-- ) { tmp = rtypenamespace.exec( types[ t ] ) || []; type = origType = tmp[ 1 ]; namespaces = ( tmp[ 2 ] || "" ).split( "." ).sort(); // Unbind all events (on this namespace, if provided) for the element if ( !type ) { for ( type in events ) { jQuery.event.remove( elem, type + types[ t ], handler, selector, true ); } continue; } special = jQuery.event.special[ type ] || {}; type = ( selector ? special.delegateType : special.bindType ) || type; handlers = events[ type ] || []; tmp = tmp[ 2 ] && new RegExp( "(^|\\.)" + namespaces.join( "\\.(?:.*\\.|)" ) + "(\\.|$)" ); // Remove matching events origCount = j = handlers.length; while ( j-- ) { handleObj = handlers[ j ]; if ( ( mappedTypes || origType === handleObj.origType ) && ( !handler || handler.guid === handleObj.guid ) && ( !tmp || tmp.test( handleObj.namespace ) ) && ( !selector || selector === handleObj.selector || selector === "**" && handleObj.selector ) ) { handlers.splice( j, 1 ); if ( handleObj.selector ) { handlers.delegateCount--; } if ( special.remove ) { special.remove.call( elem, handleObj ); } } } // Remove generic event handler if we removed something and no more handlers exist // (avoids potential for endless recursion during removal of special event handlers) if ( origCount && !handlers.length ) { if ( !special.teardown || special.teardown.call( elem, namespaces, elemData.handle ) === false ) { jQuery.removeEvent( elem, type, elemData.handle ); } delete events[ type ]; } } // Remove data and the expando if it's no longer used if ( jQuery.isEmptyObject( events ) ) { dataPriv.remove( elem, "handle events" ); } }, dispatch: function( nativeEvent ) { // Make a writable jQuery.Event from the native event object var event = jQuery.event.fix( nativeEvent ); var i, j, ret, matched, handleObj, handlerQueue, args = new Array( arguments.length ), handlers = ( dataPriv.get( this, "events" ) || {} )[ event.type ] || [], special = jQuery.event.special[ event.type ] || {}; // Use the fix-ed jQuery.Event rather than the (read-only) native event args[ 0 ] = event; for ( i = 1; i < arguments.length; i++ ) { args[ i ] = arguments[ i ]; } event.delegateTarget = this; // Call the preDispatch hook for the mapped type, and let it bail if desired if ( special.preDispatch && special.preDispatch.call( this, event ) === false ) { return; } // Determine handlers handlerQueue = jQuery.event.handlers.call( this, event, handlers ); // Run delegates first; they may want to stop propagation beneath us i = 0; while ( ( matched = handlerQueue[ i++ ] ) && !event.isPropagationStopped() ) { event.currentTarget = matched.elem; j = 0; while ( ( handleObj = matched.handlers[ j++ ] ) && !event.isImmediatePropagationStopped() ) { // Triggered event must either 1) have no namespace, or 2) have namespace(s) // a subset or equal to those in the bound event (both can have no namespace). if ( !event.rnamespace || event.rnamespace.test( handleObj.namespace ) ) { event.handleObj = handleObj; event.data = handleObj.data; ret = ( ( jQuery.event.special[ handleObj.origType ] || {} ).handle || handleObj.handler ).apply( matched.elem, args ); if ( ret !== undefined ) { if ( ( event.result = ret ) === false ) { event.preventDefault(); event.stopPropagation(); } } } } } // Call the postDispatch hook for the mapped type if ( special.postDispatch ) { special.postDispatch.call( this, event ); } return event.result; }, handlers: function( event, handlers ) { var i, handleObj, sel, matchedHandlers, matchedSelectors, handlerQueue = [], delegateCount = handlers.delegateCount, cur = event.target; // Find delegate handlers if ( delegateCount && // Support: IE <=9 // Black-hole SVG instance trees (trac-13180) cur.nodeType && // Support: Firefox <=42 // Suppress spec-violating clicks indicating a non-primary pointer button (trac-3861) // https://www.w3.org/TR/DOM-Level-3-Events/#event-type-click // Support: IE 11 only // ...but not arrow key "clicks" of radio inputs, which can have `button` -1 (gh-2343) !( event.type === "click" && event.button >= 1 ) ) { for ( ; cur !== this; cur = cur.parentNode || this ) { // Don't check non-elements (#13208) // Don't process clicks on disabled elements (#6911, #8165, #11382, #11764) if ( cur.nodeType === 1 && !( event.type === "click" && cur.disabled === true ) ) { matchedHandlers = []; matchedSelectors = {}; for ( i = 0; i < delegateCount; i++ ) { handleObj = handlers[ i ]; // Don't conflict with Object.prototype properties (#13203) sel = handleObj.selector + " "; if ( matchedSelectors[ sel ] === undefined ) { matchedSelectors[ sel ] = handleObj.needsContext ? jQuery( sel, this ).index( cur ) > -1 : jQuery.find( sel, this, null, [ cur ] ).length; } if ( matchedSelectors[ sel ] ) { matchedHandlers.push( handleObj ); } } if ( matchedHandlers.length ) { handlerQueue.push( { elem: cur, handlers: matchedHandlers } ); } } } } // Add the remaining (directly-bound) handlers cur = this; if ( delegateCount < handlers.length ) { handlerQueue.push( { elem: cur, handlers: handlers.slice( delegateCount ) } ); } return handlerQueue; }, addProp: function( name, hook ) { Object.defineProperty( jQuery.Event.prototype, name, { enumerable: true, configurable: true, get: jQuery.isFunction( hook ) ? function() { if ( this.originalEvent ) { return hook( this.originalEvent ); } } : function() { if ( this.originalEvent ) { return this.originalEvent[ name ]; } }, set: function( value ) { Object.defineProperty( this, name, { enumerable: true, configurable: true, writable: true, value: value } ); } } ); }, fix: function( originalEvent ) { return originalEvent[ jQuery.expando ] ? originalEvent : new jQuery.Event( originalEvent ); }, special: { load: { // Prevent triggered image.load events from bubbling to window.load noBubble: true }, focus: { // Fire native event if possible so blur/focus sequence is correct trigger: function() { if ( this !== safeActiveElement() && this.focus ) { this.focus(); return false; } }, delegateType: "focusin" }, blur: { trigger: function() { if ( this === safeActiveElement() && this.blur ) { this.blur(); return false; } }, delegateType: "focusout" }, click: { // For checkbox, fire native event so checked state will be right trigger: function() { if ( this.type === "checkbox" && this.click && nodeName( this, "input" ) ) { this.click(); return false; } }, // For cross-browser consistency, don't fire native .click() on links _default: function( event ) { return nodeName( event.target, "a" ); } }, beforeunload: { postDispatch: function( event ) { // Support: Firefox 20+ // Firefox doesn't alert if the returnValue field is not set. if ( event.result !== undefined && event.originalEvent ) { event.originalEvent.returnValue = event.result; } } } } }; jQuery.removeEvent = function( elem, type, handle ) { // This "if" is needed for plain objects if ( elem.removeEventListener ) { elem.removeEventListener( type, handle ); } }; jQuery.Event = function( src, props ) { // Allow instantiation without the 'new' keyword if ( !( this instanceof jQuery.Event ) ) { return new jQuery.Event( src, props ); } // Event object if ( src && src.type ) { this.originalEvent = src; this.type = src.type; // Events bubbling up the document may have been marked as prevented // by a handler lower down the tree; reflect the correct value. this.isDefaultPrevented = src.defaultPrevented || src.defaultPrevented === undefined && // Support: Android <=2.3 only src.returnValue === false ? returnTrue : returnFalse; // Create target properties // Support: Safari <=6 - 7 only // Target should not be a text node (#504, #13143) this.target = ( src.target && src.target.nodeType === 3 ) ? src.target.parentNode : src.target; this.currentTarget = src.currentTarget; this.relatedTarget = src.relatedTarget; // Event type } else { this.type = src; } // Put explicitly provided properties onto the event object if ( props ) { jQuery.extend( this, props ); } // Create a timestamp if incoming event doesn't have one this.timeStamp = src && src.timeStamp || jQuery.now(); // Mark it as fixed this[ jQuery.expando ] = true; }; // jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding // https://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html jQuery.Event.prototype = { constructor: jQuery.Event, isDefaultPrevented: returnFalse, isPropagationStopped: returnFalse, isImmediatePropagationStopped: returnFalse, isSimulated: false, preventDefault: function() { var e = this.originalEvent; this.isDefaultPrevented = returnTrue; if ( e && !this.isSimulated ) { e.preventDefault(); } }, stopPropagation: function() { var e = this.originalEvent; this.isPropagationStopped = returnTrue; if ( e && !this.isSimulated ) { e.stopPropagation(); } }, stopImmediatePropagation: function() { var e = this.originalEvent; this.isImmediatePropagationStopped = returnTrue; if ( e && !this.isSimulated ) { e.stopImmediatePropagation(); } this.stopPropagation(); } }; // Includes all common event props including KeyEvent and MouseEvent specific props jQuery.each( { altKey: true, bubbles: true, cancelable: true, changedTouches: true, ctrlKey: true, detail: true, eventPhase: true, metaKey: true, pageX: true, pageY: true, shiftKey: true, view: true, "char": true, charCode: true, key: true, keyCode: true, button: true, buttons: true, clientX: true, clientY: true, offsetX: true, offsetY: true, pointerId: true, pointerType: true, screenX: true, screenY: true, targetTouches: true, toElement: true, touches: true, which: function( event ) { var button = event.button; // Add which for key events if ( event.which == null && rkeyEvent.test( event.type ) ) { return event.charCode != null ? event.charCode : event.keyCode; } // Add which for click: 1 === left; 2 === middle; 3 === right if ( !event.which && button !== undefined && rmouseEvent.test( event.type ) ) { if ( button & 1 ) { return 1; } if ( button & 2 ) { return 3; } if ( button & 4 ) { return 2; } return 0; } return event.which; } }, jQuery.event.addProp ); // Create mouseenter/leave events using mouseover/out and event-time checks // so that event delegation works in jQuery. // Do the same for pointerenter/pointerleave and pointerover/pointerout // // Support: Safari 7 only // Safari sends mouseenter too often; see: // https://bugs.chromium.org/p/chromium/issues/detail?id=470258 // for the description of the bug (it existed in older Chrome versions as well). jQuery.each( { mouseenter: "mouseover", mouseleave: "mouseout", pointerenter: "pointerover", pointerleave: "pointerout" }, function( orig, fix ) { jQuery.event.special[ orig ] = { delegateType: fix, bindType: fix, handle: function( event ) { var ret, target = this, related = event.relatedTarget, handleObj = event.handleObj; // For mouseenter/leave call the handler if related is outside the target. // NB: No relatedTarget if the mouse left/entered the browser window if ( !related || ( related !== target && !jQuery.contains( target, related ) ) ) { event.type = handleObj.origType; ret = handleObj.handler.apply( this, arguments ); event.type = fix; } return ret; } }; } ); jQuery.fn.extend( { on: function( types, selector, data, fn ) { return on( this, types, selector, data, fn ); }, one: function( types, selector, data, fn ) { return on( this, types, selector, data, fn, 1 ); }, off: function( types, selector, fn ) { var handleObj, type; if ( types && types.preventDefault && types.handleObj ) { // ( event ) dispatched jQuery.Event handleObj = types.handleObj; jQuery( types.delegateTarget ).off( handleObj.namespace ? handleObj.origType + "." + handleObj.namespace : handleObj.origType, handleObj.selector, handleObj.handler ); return this; } if ( typeof types === "object" ) { // ( types-object [, selector] ) for ( type in types ) { this.off( type, selector, types[ type ] ); } return this; } if ( selector === false || typeof selector === "function" ) { // ( types [, fn] ) fn = selector; selector = undefined; } if ( fn === false ) { fn = returnFalse; } return this.each( function() { jQuery.event.remove( this, types, fn, selector ); } ); } } ); var /* eslint-disable max-len */ // See https://github.com/eslint/eslint/issues/3229 rxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([a-z][^\/\0>\x20\t\r\n\f]*)[^>]*)\/>/gi, /* eslint-enable */ // Support: IE <=10 - 11, Edge 12 - 13 // In IE/Edge using regex groups here causes severe slowdowns. // See https://connect.microsoft.com/IE/feedback/details/1736512/ rnoInnerhtml = /\s*$/g; // Prefer a tbody over its parent table for containing new rows function manipulationTarget( elem, content ) { if ( nodeName( elem, "table" ) && nodeName( content.nodeType !== 11 ? content : content.firstChild, "tr" ) ) { return jQuery( ">tbody", elem )[ 0 ] || elem; } return elem; } // Replace/restore the type attribute of script elements for safe DOM manipulation function disableScript( elem ) { elem.type = ( elem.getAttribute( "type" ) !== null ) + "/" + elem.type; return elem; } function restoreScript( elem ) { var match = rscriptTypeMasked.exec( elem.type ); if ( match ) { elem.type = match[ 1 ]; } else { elem.removeAttribute( "type" ); } return elem; } function cloneCopyEvent( src, dest ) { var i, l, type, pdataOld, pdataCur, udataOld, udataCur, events; if ( dest.nodeType !== 1 ) { return; } // 1. Copy private data: events, handlers, etc. if ( dataPriv.hasData( src ) ) { pdataOld = dataPriv.access( src ); pdataCur = dataPriv.set( dest, pdataOld ); events = pdataOld.events; if ( events ) { delete pdataCur.handle; pdataCur.events = {}; for ( type in events ) { for ( i = 0, l = events[ type ].length; i < l; i++ ) { jQuery.event.add( dest, type, events[ type ][ i ] ); } } } } // 2. Copy user data if ( dataUser.hasData( src ) ) { udataOld = dataUser.access( src ); udataCur = jQuery.extend( {}, udataOld ); dataUser.set( dest, udataCur ); } } // Fix IE bugs, see support tests function fixInput( src, dest ) { var nodeName = dest.nodeName.toLowerCase(); // Fails to persist the checked state of a cloned checkbox or radio button. if ( nodeName === "input" && rcheckableType.test( src.type ) ) { dest.checked = src.checked; // Fails to return the selected option to the default selected state when cloning options } else if ( nodeName === "input" || nodeName === "textarea" ) { dest.defaultValue = src.defaultValue; } } function domManip( collection, args, callback, ignored ) { // Flatten any nested arrays args = concat.apply( [], args ); var fragment, first, scripts, hasScripts, node, doc, i = 0, l = collection.length, iNoClone = l - 1, value = args[ 0 ], isFunction = jQuery.isFunction( value ); // We can't cloneNode fragments that contain checked, in WebKit if ( isFunction || ( l > 1 && typeof value === "string" && !support.checkClone && rchecked.test( value ) ) ) { return collection.each( function( index ) { var self = collection.eq( index ); if ( isFunction ) { args[ 0 ] = value.call( this, index, self.html() ); } domManip( self, args, callback, ignored ); } ); } if ( l ) { fragment = buildFragment( args, collection[ 0 ].ownerDocument, false, collection, ignored ); first = fragment.firstChild; if ( fragment.childNodes.length === 1 ) { fragment = first; } // Require either new content or an interest in ignored elements to invoke the callback if ( first || ignored ) { scripts = jQuery.map( getAll( fragment, "script" ), disableScript ); hasScripts = scripts.length; // Use the original fragment for the last item // instead of the first because it can end up // being emptied incorrectly in certain situations (#8070). for ( ; i < l; i++ ) { node = fragment; if ( i !== iNoClone ) { node = jQuery.clone( node, true, true ); // Keep references to cloned scripts for later restoration if ( hasScripts ) { // Support: Android <=4.0 only, PhantomJS 1 only // push.apply(_, arraylike) throws on ancient WebKit jQuery.merge( scripts, getAll( node, "script" ) ); } } callback.call( collection[ i ], node, i ); } if ( hasScripts ) { doc = scripts[ scripts.length - 1 ].ownerDocument; // Reenable scripts jQuery.map( scripts, restoreScript ); // Evaluate executable scripts on first document insertion for ( i = 0; i < hasScripts; i++ ) { node = scripts[ i ]; if ( rscriptType.test( node.type || "" ) && !dataPriv.access( node, "globalEval" ) && jQuery.contains( doc, node ) ) { if ( node.src ) { // Optional AJAX dependency, but won't run scripts if not present if ( jQuery._evalUrl ) { jQuery._evalUrl( node.src ); } } else { DOMEval( node.textContent.replace( rcleanScript, "" ), doc ); } } } } } } return collection; } function remove( elem, selector, keepData ) { var node, nodes = selector ? jQuery.filter( selector, elem ) : elem, i = 0; for ( ; ( node = nodes[ i ] ) != null; i++ ) { if ( !keepData && node.nodeType === 1 ) { jQuery.cleanData( getAll( node ) ); } if ( node.parentNode ) { if ( keepData && jQuery.contains( node.ownerDocument, node ) ) { setGlobalEval( getAll( node, "script" ) ); } node.parentNode.removeChild( node ); } } return elem; } jQuery.extend( { htmlPrefilter: function( html ) { return html.replace( rxhtmlTag, "<$1>" ); }, clone: function( elem, dataAndEvents, deepDataAndEvents ) { var i, l, srcElements, destElements, clone = elem.cloneNode( true ), inPage = jQuery.contains( elem.ownerDocument, elem ); // Fix IE cloning issues if ( !support.noCloneChecked && ( elem.nodeType === 1 || elem.nodeType === 11 ) && !jQuery.isXMLDoc( elem ) ) { // We eschew Sizzle here for performance reasons: https://jsperf.com/getall-vs-sizzle/2 destElements = getAll( clone ); srcElements = getAll( elem ); for ( i = 0, l = srcElements.length; i < l; i++ ) { fixInput( srcElements[ i ], destElements[ i ] ); } } // Copy the events from the original to the clone if ( dataAndEvents ) { if ( deepDataAndEvents ) { srcElements = srcElements || getAll( elem ); destElements = destElements || getAll( clone ); for ( i = 0, l = srcElements.length; i < l; i++ ) { cloneCopyEvent( srcElements[ i ], destElements[ i ] ); } } else { cloneCopyEvent( elem, clone ); } } // Preserve script evaluation history destElements = getAll( clone, "script" ); if ( destElements.length > 0 ) { setGlobalEval( destElements, !inPage && getAll( elem, "script" ) ); } // Return the cloned set return clone; }, cleanData: function( elems ) { var data, elem, type, special = jQuery.event.special, i = 0; for ( ; ( elem = elems[ i ] ) !== undefined; i++ ) { if ( acceptData( elem ) ) { if ( ( data = elem[ dataPriv.expando ] ) ) { if ( data.events ) { for ( type in data.events ) { if ( special[ type ] ) { jQuery.event.remove( elem, type ); // This is a shortcut to avoid jQuery.event.remove's overhead } else { jQuery.removeEvent( elem, type, data.handle ); } } } // Support: Chrome <=35 - 45+ // Assign undefined instead of using delete, see Data#remove elem[ dataPriv.expando ] = undefined; } if ( elem[ dataUser.expando ] ) { // Support: Chrome <=35 - 45+ // Assign undefined instead of using delete, see Data#remove elem[ dataUser.expando ] = undefined; } } } } } ); jQuery.fn.extend( { detach: function( selector ) { return remove( this, selector, true ); }, remove: function( selector ) { return remove( this, selector ); }, text: function( value ) { return access( this, function( value ) { return value === undefined ? jQuery.text( this ) : this.empty().each( function() { if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) { this.textContent = value; } } ); }, null, value, arguments.length ); }, append: function() { return domManip( this, arguments, function( elem ) { if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) { var target = manipulationTarget( this, elem ); target.appendChild( elem ); } } ); }, prepend: function() { return domManip( this, arguments, function( elem ) { if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) { var target = manipulationTarget( this, elem ); target.insertBefore( elem, target.firstChild ); } } ); }, before: function() { return domManip( this, arguments, function( elem ) { if ( this.parentNode ) { this.parentNode.insertBefore( elem, this ); } } ); }, after: function() { return domManip( this, arguments, function( elem ) { if ( this.parentNode ) { this.parentNode.insertBefore( elem, this.nextSibling ); } } ); }, empty: function() { var elem, i = 0; for ( ; ( elem = this[ i ] ) != null; i++ ) { if ( elem.nodeType === 1 ) { // Prevent memory leaks jQuery.cleanData( getAll( elem, false ) ); // Remove any remaining nodes elem.textContent = ""; } } return this; }, clone: function( dataAndEvents, deepDataAndEvents ) { dataAndEvents = dataAndEvents == null ? false : dataAndEvents; deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents; return this.map( function() { return jQuery.clone( this, dataAndEvents, deepDataAndEvents ); } ); }, html: function( value ) { return access( this, function( value ) { var elem = this[ 0 ] || {}, i = 0, l = this.length; if ( value === undefined && elem.nodeType === 1 ) { return elem.innerHTML; } // See if we can take a shortcut and just use innerHTML if ( typeof value === "string" && !rnoInnerhtml.test( value ) && !wrapMap[ ( rtagName.exec( value ) || [ "", "" ] )[ 1 ].toLowerCase() ] ) { value = jQuery.htmlPrefilter( value ); try { for ( ; i < l; i++ ) { elem = this[ i ] || {}; // Remove element nodes and prevent memory leaks if ( elem.nodeType === 1 ) { jQuery.cleanData( getAll( elem, false ) ); elem.innerHTML = value; } } elem = 0; // If using innerHTML throws an exception, use the fallback method } catch ( e ) {} } if ( elem ) { this.empty().append( value ); } }, null, value, arguments.length ); }, replaceWith: function() { var ignored = []; // Make the changes, replacing each non-ignored context element with the new content return domManip( this, arguments, function( elem ) { var parent = this.parentNode; if ( jQuery.inArray( this, ignored ) < 0 ) { jQuery.cleanData( getAll( this ) ); if ( parent ) { parent.replaceChild( elem, this ); } } // Force callback invocation }, ignored ); } } ); jQuery.each( { appendTo: "append", prependTo: "prepend", insertBefore: "before", insertAfter: "after", replaceAll: "replaceWith" }, function( name, original ) { jQuery.fn[ name ] = function( selector ) { var elems, ret = [], insert = jQuery( selector ), last = insert.length - 1, i = 0; for ( ; i <= last; i++ ) { elems = i === last ? this : this.clone( true ); jQuery( insert[ i ] )[ original ]( elems ); // Support: Android <=4.0 only, PhantomJS 1 only // .get() because push.apply(_, arraylike) throws on ancient WebKit push.apply( ret, elems.get() ); } return this.pushStack( ret ); }; } ); var rmargin = ( /^margin/ ); var rnumnonpx = new RegExp( "^(" + pnum + ")(?!px)[a-z%]+$", "i" ); var getStyles = function( elem ) { // Support: IE <=11 only, Firefox <=30 (#15098, #14150) // IE throws on elements created in popups // FF meanwhile throws on frame elements through "defaultView.getComputedStyle" var view = elem.ownerDocument.defaultView; if ( !view || !view.opener ) { view = window; } return view.getComputedStyle( elem ); }; ( function() { // Executing both pixelPosition & boxSizingReliable tests require only one layout // so they're executed at the same time to save the second computation. function computeStyleTests() { // This is a singleton, we need to execute it only once if ( !div ) { return; } div.style.cssText = "box-sizing:border-box;" + "position:relative;display:block;" + "margin:auto;border:1px;padding:1px;" + "top:1%;width:50%"; div.innerHTML = ""; documentElement.appendChild( container ); var divStyle = window.getComputedStyle( div ); pixelPositionVal = divStyle.top !== "1%"; // Support: Android 4.0 - 4.3 only, Firefox <=3 - 44 reliableMarginLeftVal = divStyle.marginLeft === "2px"; boxSizingReliableVal = divStyle.width === "4px"; // Support: Android 4.0 - 4.3 only // Some styles come back with percentage values, even though they shouldn't div.style.marginRight = "50%"; pixelMarginRightVal = divStyle.marginRight === "4px"; documentElement.removeChild( container ); // Nullify the div so it wouldn't be stored in the memory and // it will also be a sign that checks already performed div = null; } var pixelPositionVal, boxSizingReliableVal, pixelMarginRightVal, reliableMarginLeftVal, container = document.createElement( "div" ), div = document.createElement( "div" ); // Finish early in limited (non-browser) environments if ( !div.style ) { return; } // Support: IE <=9 - 11 only // Style of cloned element affects source element cloned (#8908) div.style.backgroundClip = "content-box"; div.cloneNode( true ).style.backgroundClip = ""; support.clearCloneStyle = div.style.backgroundClip === "content-box"; container.style.cssText = "border:0;width:8px;height:0;top:0;left:-9999px;" + "padding:0;margin-top:1px;position:absolute"; container.appendChild( div ); jQuery.extend( support, { pixelPosition: function() { computeStyleTests(); return pixelPositionVal; }, boxSizingReliable: function() { computeStyleTests(); return boxSizingReliableVal; }, pixelMarginRight: function() { computeStyleTests(); return pixelMarginRightVal; }, reliableMarginLeft: function() { computeStyleTests(); return reliableMarginLeftVal; } } ); } )(); function curCSS( elem, name, computed ) { var width, minWidth, maxWidth, ret, // Support: Firefox 51+ // Retrieving style before computed somehow // fixes an issue with getting wrong values // on detached elements style = elem.style; computed = computed || getStyles( elem ); // getPropertyValue is needed for: // .css('filter') (IE 9 only, #12537) // .css('--customProperty) (#3144) if ( computed ) { ret = computed.getPropertyValue( name ) || computed[ name ]; if ( ret === "" && !jQuery.contains( elem.ownerDocument, elem ) ) { ret = jQuery.style( elem, name ); } // A tribute to the "awesome hack by Dean Edwards" // Android Browser returns percentage for some values, // but width seems to be reliably pixels. // This is against the CSSOM draft spec: // https://drafts.csswg.org/cssom/#resolved-values if ( !support.pixelMarginRight() && rnumnonpx.test( ret ) && rmargin.test( name ) ) { // Remember the original values width = style.width; minWidth = style.minWidth; maxWidth = style.maxWidth; // Put in the new values to get a computed value out style.minWidth = style.maxWidth = style.width = ret; ret = computed.width; // Revert the changed values style.width = width; style.minWidth = minWidth; style.maxWidth = maxWidth; } } return ret !== undefined ? // Support: IE <=9 - 11 only // IE returns zIndex value as an integer. ret + "" : ret; } function addGetHookIf( conditionFn, hookFn ) { // Define the hook, we'll check on the first run if it's really needed. return { get: function() { if ( conditionFn() ) { // Hook not needed (or it's not possible to use it due // to missing dependency), remove it. delete this.get; return; } // Hook needed; redefine it so that the support test is not executed again. return ( this.get = hookFn ).apply( this, arguments ); } }; } var // Swappable if display is none or starts with table // except "table", "table-cell", or "table-caption" // See here for display values: https://developer.mozilla.org/en-US/docs/CSS/display rdisplayswap = /^(none|table(?!-c[ea]).+)/, rcustomProp = /^--/, cssShow = { position: "absolute", visibility: "hidden", display: "block" }, cssNormalTransform = { letterSpacing: "0", fontWeight: "400" }, cssPrefixes = [ "Webkit", "Moz", "ms" ], emptyStyle = document.createElement( "div" ).style; // Return a css property mapped to a potentially vendor prefixed property function vendorPropName( name ) { // Shortcut for names that are not vendor prefixed if ( name in emptyStyle ) { return name; } // Check for vendor prefixed names var capName = name[ 0 ].toUpperCase() + name.slice( 1 ), i = cssPrefixes.length; while ( i-- ) { name = cssPrefixes[ i ] + capName; if ( name in emptyStyle ) { return name; } } } // Return a property mapped along what jQuery.cssProps suggests or to // a vendor prefixed property. function finalPropName( name ) { var ret = jQuery.cssProps[ name ]; if ( !ret ) { ret = jQuery.cssProps[ name ] = vendorPropName( name ) || name; } return ret; } function setPositiveNumber( elem, value, subtract ) { // Any relative (+/-) values have already been // normalized at this point var matches = rcssNum.exec( value ); return matches ? // Guard against undefined "subtract", e.g., when used as in cssHooks Math.max( 0, matches[ 2 ] - ( subtract || 0 ) ) + ( matches[ 3 ] || "px" ) : value; } function augmentWidthOrHeight( elem, name, extra, isBorderBox, styles ) { var i, val = 0; // If we already have the right measurement, avoid augmentation if ( extra === ( isBorderBox ? "border" : "content" ) ) { i = 4; // Otherwise initialize for horizontal or vertical properties } else { i = name === "width" ? 1 : 0; } for ( ; i < 4; i += 2 ) { // Both box models exclude margin, so add it if we want it if ( extra === "margin" ) { val += jQuery.css( elem, extra + cssExpand[ i ], true, styles ); } if ( isBorderBox ) { // border-box includes padding, so remove it if we want content if ( extra === "content" ) { val -= jQuery.css( elem, "padding" + cssExpand[ i ], true, styles ); } // At this point, extra isn't border nor margin, so remove border if ( extra !== "margin" ) { val -= jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles ); } } else { // At this point, extra isn't content, so add padding val += jQuery.css( elem, "padding" + cssExpand[ i ], true, styles ); // At this point, extra isn't content nor padding, so add border if ( extra !== "padding" ) { val += jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles ); } } } return val; } function getWidthOrHeight( elem, name, extra ) { // Start with computed style var valueIsBorderBox, styles = getStyles( elem ), val = curCSS( elem, name, styles ), isBorderBox = jQuery.css( elem, "boxSizing", false, styles ) === "border-box"; // Computed unit is not pixels. Stop here and return. if ( rnumnonpx.test( val ) ) { return val; } // Check for style in case a browser which returns unreliable values // for getComputedStyle silently falls back to the reliable elem.style valueIsBorderBox = isBorderBox && ( support.boxSizingReliable() || val === elem.style[ name ] ); // Fall back to offsetWidth/Height when value is "auto" // This happens for inline elements with no explicit setting (gh-3571) if ( val === "auto" ) { val = elem[ "offset" + name[ 0 ].toUpperCase() + name.slice( 1 ) ]; } // Normalize "", auto, and prepare for extra val = parseFloat( val ) || 0; // Use the active box-sizing model to add/subtract irrelevant styles return ( val + augmentWidthOrHeight( elem, name, extra || ( isBorderBox ? "border" : "content" ), valueIsBorderBox, styles ) ) + "px"; } jQuery.extend( { // Add in style property hooks for overriding the default // behavior of getting and setting a style property cssHooks: { opacity: { get: function( elem, computed ) { if ( computed ) { // We should always get a number back from opacity var ret = curCSS( elem, "opacity" ); return ret === "" ? "1" : ret; } } } }, // Don't automatically add "px" to these possibly-unitless properties cssNumber: { "animationIterationCount": true, "columnCount": true, "fillOpacity": true, "flexGrow": true, "flexShrink": true, "fontWeight": true, "lineHeight": true, "opacity": true, "order": true, "orphans": true, "widows": true, "zIndex": true, "zoom": true }, // Add in properties whose names you wish to fix before // setting or getting the value cssProps: { "float": "cssFloat" }, // Get and set the style property on a DOM Node style: function( elem, name, value, extra ) { // Don't set styles on text and comment nodes if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style ) { return; } // Make sure that we're working with the right name var ret, type, hooks, origName = jQuery.camelCase( name ), isCustomProp = rcustomProp.test( name ), style = elem.style; // Make sure that we're working with the right name. We don't // want to query the value if it is a CSS custom property // since they are user-defined. if ( !isCustomProp ) { name = finalPropName( origName ); } // Gets hook for the prefixed version, then unprefixed version hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ]; // Check if we're setting a value if ( value !== undefined ) { type = typeof value; // Convert "+=" or "-=" to relative numbers (#7345) if ( type === "string" && ( ret = rcssNum.exec( value ) ) && ret[ 1 ] ) { value = adjustCSS( elem, name, ret ); // Fixes bug #9237 type = "number"; } // Make sure that null and NaN values aren't set (#7116) if ( value == null || value !== value ) { return; } // If a number was passed in, add the unit (except for certain CSS properties) if ( type === "number" ) { value += ret && ret[ 3 ] || ( jQuery.cssNumber[ origName ] ? "" : "px" ); } // background-* props affect original clone's values if ( !support.clearCloneStyle && value === "" && name.indexOf( "background" ) === 0 ) { style[ name ] = "inherit"; } // If a hook was provided, use that value, otherwise just set the specified value if ( !hooks || !( "set" in hooks ) || ( value = hooks.set( elem, value, extra ) ) !== undefined ) { if ( isCustomProp ) { style.setProperty( name, value ); } else { style[ name ] = value; } } } else { // If a hook was provided get the non-computed value from there if ( hooks && "get" in hooks && ( ret = hooks.get( elem, false, extra ) ) !== undefined ) { return ret; } // Otherwise just get the value from the style object return style[ name ]; } }, css: function( elem, name, extra, styles ) { var val, num, hooks, origName = jQuery.camelCase( name ), isCustomProp = rcustomProp.test( name ); // Make sure that we're working with the right name. We don't // want to modify the value if it is a CSS custom property // since they are user-defined. if ( !isCustomProp ) { name = finalPropName( origName ); } // Try prefixed name followed by the unprefixed name hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ]; // If a hook was provided get the computed value from there if ( hooks && "get" in hooks ) { val = hooks.get( elem, true, extra ); } // Otherwise, if a way to get the computed value exists, use that if ( val === undefined ) { val = curCSS( elem, name, styles ); } // Convert "normal" to computed value if ( val === "normal" && name in cssNormalTransform ) { val = cssNormalTransform[ name ]; } // Make numeric if forced or a qualifier was provided and val looks numeric if ( extra === "" || extra ) { num = parseFloat( val ); return extra === true || isFinite( num ) ? num || 0 : val; } return val; } } ); jQuery.each( [ "height", "width" ], function( i, name ) { jQuery.cssHooks[ name ] = { get: function( elem, computed, extra ) { if ( computed ) { // Certain elements can have dimension info if we invisibly show them // but it must have a current display style that would benefit return rdisplayswap.test( jQuery.css( elem, "display" ) ) && // Support: Safari 8+ // Table columns in Safari have non-zero offsetWidth & zero // getBoundingClientRect().width unless display is changed. // Support: IE <=11 only // Running getBoundingClientRect on a disconnected node // in IE throws an error. ( !elem.getClientRects().length || !elem.getBoundingClientRect().width ) ? swap( elem, cssShow, function() { return getWidthOrHeight( elem, name, extra ); } ) : getWidthOrHeight( elem, name, extra ); } }, set: function( elem, value, extra ) { var matches, styles = extra && getStyles( elem ), subtract = extra && augmentWidthOrHeight( elem, name, extra, jQuery.css( elem, "boxSizing", false, styles ) === "border-box", styles ); // Convert to pixels if value adjustment is needed if ( subtract && ( matches = rcssNum.exec( value ) ) && ( matches[ 3 ] || "px" ) !== "px" ) { elem.style[ name ] = value; value = jQuery.css( elem, name ); } return setPositiveNumber( elem, value, subtract ); } }; } ); jQuery.cssHooks.marginLeft = addGetHookIf( support.reliableMarginLeft, function( elem, computed ) { if ( computed ) { return ( parseFloat( curCSS( elem, "marginLeft" ) ) || elem.getBoundingClientRect().left - swap( elem, { marginLeft: 0 }, function() { return elem.getBoundingClientRect().left; } ) ) + "px"; } } ); // These hooks are used by animate to expand properties jQuery.each( { margin: "", padding: "", border: "Width" }, function( prefix, suffix ) { jQuery.cssHooks[ prefix + suffix ] = { expand: function( value ) { var i = 0, expanded = {}, // Assumes a single number if not a string parts = typeof value === "string" ? value.split( " " ) : [ value ]; for ( ; i < 4; i++ ) { expanded[ prefix + cssExpand[ i ] + suffix ] = parts[ i ] || parts[ i - 2 ] || parts[ 0 ]; } return expanded; } }; if ( !rmargin.test( prefix ) ) { jQuery.cssHooks[ prefix + suffix ].set = setPositiveNumber; } } ); jQuery.fn.extend( { css: function( name, value ) { return access( this, function( elem, name, value ) { var styles, len, map = {}, i = 0; if ( Array.isArray( name ) ) { styles = getStyles( elem ); len = name.length; for ( ; i < len; i++ ) { map[ name[ i ] ] = jQuery.css( elem, name[ i ], false, styles ); } return map; } return value !== undefined ? jQuery.style( elem, name, value ) : jQuery.css( elem, name ); }, name, value, arguments.length > 1 ); } } ); function Tween( elem, options, prop, end, easing ) { return new Tween.prototype.init( elem, options, prop, end, easing ); } jQuery.Tween = Tween; Tween.prototype = { constructor: Tween, init: function( elem, options, prop, end, easing, unit ) { this.elem = elem; this.prop = prop; this.easing = easing || jQuery.easing._default; this.options = options; this.start = this.now = this.cur(); this.end = end; this.unit = unit || ( jQuery.cssNumber[ prop ] ? "" : "px" ); }, cur: function() { var hooks = Tween.propHooks[ this.prop ]; return hooks && hooks.get ? hooks.get( this ) : Tween.propHooks._default.get( this ); }, run: function( percent ) { var eased, hooks = Tween.propHooks[ this.prop ]; if ( this.options.duration ) { this.pos = eased = jQuery.easing[ this.easing ]( percent, this.options.duration * percent, 0, 1, this.options.duration ); } else { this.pos = eased = percent; } this.now = ( this.end - this.start ) * eased + this.start; if ( this.options.step ) { this.options.step.call( this.elem, this.now, this ); } if ( hooks && hooks.set ) { hooks.set( this ); } else { Tween.propHooks._default.set( this ); } return this; } }; Tween.prototype.init.prototype = Tween.prototype; Tween.propHooks = { _default: { get: function( tween ) { var result; // Use a property on the element directly when it is not a DOM element, // or when there is no matching style property that exists. if ( tween.elem.nodeType !== 1 || tween.elem[ tween.prop ] != null && tween.elem.style[ tween.prop ] == null ) { return tween.elem[ tween.prop ]; } // Passing an empty string as a 3rd parameter to .css will automatically // attempt a parseFloat and fallback to a string if the parse fails. // Simple values such as "10px" are parsed to Float; // complex values such as "rotate(1rad)" are returned as-is. result = jQuery.css( tween.elem, tween.prop, "" ); // Empty strings, null, undefined and "auto" are converted to 0. return !result || result === "auto" ? 0 : result; }, set: function( tween ) { // Use step hook for back compat. // Use cssHook if its there. // Use .style if available and use plain properties where available. if ( jQuery.fx.step[ tween.prop ] ) { jQuery.fx.step[ tween.prop ]( tween ); } else if ( tween.elem.nodeType === 1 && ( tween.elem.style[ jQuery.cssProps[ tween.prop ] ] != null || jQuery.cssHooks[ tween.prop ] ) ) { jQuery.style( tween.elem, tween.prop, tween.now + tween.unit ); } else { tween.elem[ tween.prop ] = tween.now; } } } }; // Support: IE <=9 only // Panic based approach to setting things on disconnected nodes Tween.propHooks.scrollTop = Tween.propHooks.scrollLeft = { set: function( tween ) { if ( tween.elem.nodeType && tween.elem.parentNode ) { tween.elem[ tween.prop ] = tween.now; } } }; jQuery.easing = { linear: function( p ) { return p; }, swing: function( p ) { return 0.5 - Math.cos( p * Math.PI ) / 2; }, _default: "swing" }; jQuery.fx = Tween.prototype.init; // Back compat <1.8 extension point jQuery.fx.step = {}; var fxNow, inProgress, rfxtypes = /^(?:toggle|show|hide)$/, rrun = /queueHooks$/; function schedule() { if ( inProgress ) { if ( document.hidden === false && window.requestAnimationFrame ) { window.requestAnimationFrame( schedule ); } else { window.setTimeout( schedule, jQuery.fx.interval ); } jQuery.fx.tick(); } } // Animations created synchronously will run synchronously function createFxNow() { window.setTimeout( function() { fxNow = undefined; } ); return ( fxNow = jQuery.now() ); } // Generate parameters to create a standard animation function genFx( type, includeWidth ) { var which, i = 0, attrs = { height: type }; // If we include width, step value is 1 to do all cssExpand values, // otherwise step value is 2 to skip over Left and Right includeWidth = includeWidth ? 1 : 0; for ( ; i < 4; i += 2 - includeWidth ) { which = cssExpand[ i ]; attrs[ "margin" + which ] = attrs[ "padding" + which ] = type; } if ( includeWidth ) { attrs.opacity = attrs.width = type; } return attrs; } function createTween( value, prop, animation ) { var tween, collection = ( Animation.tweeners[ prop ] || [] ).concat( Animation.tweeners[ "*" ] ), index = 0, length = collection.length; for ( ; index < length; index++ ) { if ( ( tween = collection[ index ].call( animation, prop, value ) ) ) { // We're done with this property return tween; } } } function defaultPrefilter( elem, props, opts ) { var prop, value, toggle, hooks, oldfire, propTween, restoreDisplay, display, isBox = "width" in props || "height" in props, anim = this, orig = {}, style = elem.style, hidden = elem.nodeType && isHiddenWithinTree( elem ), dataShow = dataPriv.get( elem, "fxshow" ); // Queue-skipping animations hijack the fx hooks if ( !opts.queue ) { hooks = jQuery._queueHooks( elem, "fx" ); if ( hooks.unqueued == null ) { hooks.unqueued = 0; oldfire = hooks.empty.fire; hooks.empty.fire = function() { if ( !hooks.unqueued ) { oldfire(); } }; } hooks.unqueued++; anim.always( function() { // Ensure the complete handler is called before this completes anim.always( function() { hooks.unqueued--; if ( !jQuery.queue( elem, "fx" ).length ) { hooks.empty.fire(); } } ); } ); } // Detect show/hide animations for ( prop in props ) { value = props[ prop ]; if ( rfxtypes.test( value ) ) { delete props[ prop ]; toggle = toggle || value === "toggle"; if ( value === ( hidden ? "hide" : "show" ) ) { // Pretend to be hidden if this is a "show" and // there is still data from a stopped show/hide if ( value === "show" && dataShow && dataShow[ prop ] !== undefined ) { hidden = true; // Ignore all other no-op show/hide data } else { continue; } } orig[ prop ] = dataShow && dataShow[ prop ] || jQuery.style( elem, prop ); } } // Bail out if this is a no-op like .hide().hide() propTween = !jQuery.isEmptyObject( props ); if ( !propTween && jQuery.isEmptyObject( orig ) ) { return; } // Restrict "overflow" and "display" styles during box animations if ( isBox && elem.nodeType === 1 ) { // Support: IE <=9 - 11, Edge 12 - 13 // Record all 3 overflow attributes because IE does not infer the shorthand // from identically-valued overflowX and overflowY opts.overflow = [ style.overflow, style.overflowX, style.overflowY ]; // Identify a display type, preferring old show/hide data over the CSS cascade restoreDisplay = dataShow && dataShow.display; if ( restoreDisplay == null ) { restoreDisplay = dataPriv.get( elem, "display" ); } display = jQuery.css( elem, "display" ); if ( display === "none" ) { if ( restoreDisplay ) { display = restoreDisplay; } else { // Get nonempty value(s) by temporarily forcing visibility showHide( [ elem ], true ); restoreDisplay = elem.style.display || restoreDisplay; display = jQuery.css( elem, "display" ); showHide( [ elem ] ); } } // Animate inline elements as inline-block if ( display === "inline" || display === "inline-block" && restoreDisplay != null ) { if ( jQuery.css( elem, "float" ) === "none" ) { // Restore the original display value at the end of pure show/hide animations if ( !propTween ) { anim.done( function() { style.display = restoreDisplay; } ); if ( restoreDisplay == null ) { display = style.display; restoreDisplay = display === "none" ? "" : display; } } style.display = "inline-block"; } } } if ( opts.overflow ) { style.overflow = "hidden"; anim.always( function() { style.overflow = opts.overflow[ 0 ]; style.overflowX = opts.overflow[ 1 ]; style.overflowY = opts.overflow[ 2 ]; } ); } // Implement show/hide animations propTween = false; for ( prop in orig ) { // General show/hide setup for this element animation if ( !propTween ) { if ( dataShow ) { if ( "hidden" in dataShow ) { hidden = dataShow.hidden; } } else { dataShow = dataPriv.access( elem, "fxshow", { display: restoreDisplay } ); } // Store hidden/visible for toggle so `.stop().toggle()` "reverses" if ( toggle ) { dataShow.hidden = !hidden; } // Show elements before animating them if ( hidden ) { showHide( [ elem ], true ); } /* eslint-disable no-loop-func */ anim.done( function() { /* eslint-enable no-loop-func */ // The final step of a "hide" animation is actually hiding the element if ( !hidden ) { showHide( [ elem ] ); } dataPriv.remove( elem, "fxshow" ); for ( prop in orig ) { jQuery.style( elem, prop, orig[ prop ] ); } } ); } // Per-property setup propTween = createTween( hidden ? dataShow[ prop ] : 0, prop, anim ); if ( !( prop in dataShow ) ) { dataShow[ prop ] = propTween.start; if ( hidden ) { propTween.end = propTween.start; propTween.start = 0; } } } } function propFilter( props, specialEasing ) { var index, name, easing, value, hooks; // camelCase, specialEasing and expand cssHook pass for ( index in props ) { name = jQuery.camelCase( index ); easing = specialEasing[ name ]; value = props[ index ]; if ( Array.isArray( value ) ) { easing = value[ 1 ]; value = props[ index ] = value[ 0 ]; } if ( index !== name ) { props[ name ] = value; delete props[ index ]; } hooks = jQuery.cssHooks[ name ]; if ( hooks && "expand" in hooks ) { value = hooks.expand( value ); delete props[ name ]; // Not quite $.extend, this won't overwrite existing keys. // Reusing 'index' because we have the correct "name" for ( index in value ) { if ( !( index in props ) ) { props[ index ] = value[ index ]; specialEasing[ index ] = easing; } } } else { specialEasing[ name ] = easing; } } } function Animation( elem, properties, options ) { var result, stopped, index = 0, length = Animation.prefilters.length, deferred = jQuery.Deferred().always( function() { // Don't match elem in the :animated selector delete tick.elem; } ), tick = function() { if ( stopped ) { return false; } var currentTime = fxNow || createFxNow(), remaining = Math.max( 0, animation.startTime + animation.duration - currentTime ), // Support: Android 2.3 only // Archaic crash bug won't allow us to use `1 - ( 0.5 || 0 )` (#12497) temp = remaining / animation.duration || 0, percent = 1 - temp, index = 0, length = animation.tweens.length; for ( ; index < length; index++ ) { animation.tweens[ index ].run( percent ); } deferred.notifyWith( elem, [ animation, percent, remaining ] ); // If there's more to do, yield if ( percent < 1 && length ) { return remaining; } // If this was an empty animation, synthesize a final progress notification if ( !length ) { deferred.notifyWith( elem, [ animation, 1, 0 ] ); } // Resolve the animation and report its conclusion deferred.resolveWith( elem, [ animation ] ); return false; }, animation = deferred.promise( { elem: elem, props: jQuery.extend( {}, properties ), opts: jQuery.extend( true, { specialEasing: {}, easing: jQuery.easing._default }, options ), originalProperties: properties, originalOptions: options, startTime: fxNow || createFxNow(), duration: options.duration, tweens: [], createTween: function( prop, end ) { var tween = jQuery.Tween( elem, animation.opts, prop, end, animation.opts.specialEasing[ prop ] || animation.opts.easing ); animation.tweens.push( tween ); return tween; }, stop: function( gotoEnd ) { var index = 0, // If we are going to the end, we want to run all the tweens // otherwise we skip this part length = gotoEnd ? animation.tweens.length : 0; if ( stopped ) { return this; } stopped = true; for ( ; index < length; index++ ) { animation.tweens[ index ].run( 1 ); } // Resolve when we played the last frame; otherwise, reject if ( gotoEnd ) { deferred.notifyWith( elem, [ animation, 1, 0 ] ); deferred.resolveWith( elem, [ animation, gotoEnd ] ); } else { deferred.rejectWith( elem, [ animation, gotoEnd ] ); } return this; } } ), props = animation.props; propFilter( props, animation.opts.specialEasing ); for ( ; index < length; index++ ) { result = Animation.prefilters[ index ].call( animation, elem, props, animation.opts ); if ( result ) { if ( jQuery.isFunction( result.stop ) ) { jQuery._queueHooks( animation.elem, animation.opts.queue ).stop = jQuery.proxy( result.stop, result ); } return result; } } jQuery.map( props, createTween, animation ); if ( jQuery.isFunction( animation.opts.start ) ) { animation.opts.start.call( elem, animation ); } // Attach callbacks from options animation .progress( animation.opts.progress ) .done( animation.opts.done, animation.opts.complete ) .fail( animation.opts.fail ) .always( animation.opts.always ); jQuery.fx.timer( jQuery.extend( tick, { elem: elem, anim: animation, queue: animation.opts.queue } ) ); return animation; } jQuery.Animation = jQuery.extend( Animation, { tweeners: { "*": [ function( prop, value ) { var tween = this.createTween( prop, value ); adjustCSS( tween.elem, prop, rcssNum.exec( value ), tween ); return tween; } ] }, tweener: function( props, callback ) { if ( jQuery.isFunction( props ) ) { callback = props; props = [ "*" ]; } else { props = props.match( rnothtmlwhite ); } var prop, index = 0, length = props.length; for ( ; index < length; index++ ) { prop = props[ index ]; Animation.tweeners[ prop ] = Animation.tweeners[ prop ] || []; Animation.tweeners[ prop ].unshift( callback ); } }, prefilters: [ defaultPrefilter ], prefilter: function( callback, prepend ) { if ( prepend ) { Animation.prefilters.unshift( callback ); } else { Animation.prefilters.push( callback ); } } } ); jQuery.speed = function( speed, easing, fn ) { var opt = speed && typeof speed === "object" ? jQuery.extend( {}, speed ) : { complete: fn || !fn && easing || jQuery.isFunction( speed ) && speed, duration: speed, easing: fn && easing || easing && !jQuery.isFunction( easing ) && easing }; // Go to the end state if fx are off if ( jQuery.fx.off ) { opt.duration = 0; } else { if ( typeof opt.duration !== "number" ) { if ( opt.duration in jQuery.fx.speeds ) { opt.duration = jQuery.fx.speeds[ opt.duration ]; } else { opt.duration = jQuery.fx.speeds._default; } } } // Normalize opt.queue - true/undefined/null -> "fx" if ( opt.queue == null || opt.queue === true ) { opt.queue = "fx"; } // Queueing opt.old = opt.complete; opt.complete = function() { if ( jQuery.isFunction( opt.old ) ) { opt.old.call( this ); } if ( opt.queue ) { jQuery.dequeue( this, opt.queue ); } }; return opt; }; jQuery.fn.extend( { fadeTo: function( speed, to, easing, callback ) { // Show any hidden elements after setting opacity to 0 return this.filter( isHiddenWithinTree ).css( "opacity", 0 ).show() // Animate to the value specified .end().animate( { opacity: to }, speed, easing, callback ); }, animate: function( prop, speed, easing, callback ) { var empty = jQuery.isEmptyObject( prop ), optall = jQuery.speed( speed, easing, callback ), doAnimation = function() { // Operate on a copy of prop so per-property easing won't be lost var anim = Animation( this, jQuery.extend( {}, prop ), optall ); // Empty animations, or finishing resolves immediately if ( empty || dataPriv.get( this, "finish" ) ) { anim.stop( true ); } }; doAnimation.finish = doAnimation; return empty || optall.queue === false ? this.each( doAnimation ) : this.queue( optall.queue, doAnimation ); }, stop: function( type, clearQueue, gotoEnd ) { var stopQueue = function( hooks ) { var stop = hooks.stop; delete hooks.stop; stop( gotoEnd ); }; if ( typeof type !== "string" ) { gotoEnd = clearQueue; clearQueue = type; type = undefined; } if ( clearQueue && type !== false ) { this.queue( type || "fx", [] ); } return this.each( function() { var dequeue = true, index = type != null && type + "queueHooks", timers = jQuery.timers, data = dataPriv.get( this ); if ( index ) { if ( data[ index ] && data[ index ].stop ) { stopQueue( data[ index ] ); } } else { for ( index in data ) { if ( data[ index ] && data[ index ].stop && rrun.test( index ) ) { stopQueue( data[ index ] ); } } } for ( index = timers.length; index--; ) { if ( timers[ index ].elem === this && ( type == null || timers[ index ].queue === type ) ) { timers[ index ].anim.stop( gotoEnd ); dequeue = false; timers.splice( index, 1 ); } } // Start the next in the queue if the last step wasn't forced. // Timers currently will call their complete callbacks, which // will dequeue but only if they were gotoEnd. if ( dequeue || !gotoEnd ) { jQuery.dequeue( this, type ); } } ); }, finish: function( type ) { if ( type !== false ) { type = type || "fx"; } return this.each( function() { var index, data = dataPriv.get( this ), queue = data[ type + "queue" ], hooks = data[ type + "queueHooks" ], timers = jQuery.timers, length = queue ? queue.length : 0; // Enable finishing flag on private data data.finish = true; // Empty the queue first jQuery.queue( this, type, [] ); if ( hooks && hooks.stop ) { hooks.stop.call( this, true ); } // Look for any active animations, and finish them for ( index = timers.length; index--; ) { if ( timers[ index ].elem === this && timers[ index ].queue === type ) { timers[ index ].anim.stop( true ); timers.splice( index, 1 ); } } // Look for any animations in the old queue and finish them for ( index = 0; index < length; index++ ) { if ( queue[ index ] && queue[ index ].finish ) { queue[ index ].finish.call( this ); } } // Turn off finishing flag delete data.finish; } ); } } ); jQuery.each( [ "toggle", "show", "hide" ], function( i, name ) { var cssFn = jQuery.fn[ name ]; jQuery.fn[ name ] = function( speed, easing, callback ) { return speed == null || typeof speed === "boolean" ? cssFn.apply( this, arguments ) : this.animate( genFx( name, true ), speed, easing, callback ); }; } ); // Generate shortcuts for custom animations jQuery.each( { slideDown: genFx( "show" ), slideUp: genFx( "hide" ), slideToggle: genFx( "toggle" ), fadeIn: { opacity: "show" }, fadeOut: { opacity: "hide" }, fadeToggle: { opacity: "toggle" } }, function( name, props ) { jQuery.fn[ name ] = function( speed, easing, callback ) { return this.animate( props, speed, easing, callback ); }; } ); jQuery.timers = []; jQuery.fx.tick = function() { var timer, i = 0, timers = jQuery.timers; fxNow = jQuery.now(); for ( ; i < timers.length; i++ ) { timer = timers[ i ]; // Run the timer and safely remove it when done (allowing for external removal) if ( !timer() && timers[ i ] === timer ) { timers.splice( i--, 1 ); } } if ( !timers.length ) { jQuery.fx.stop(); } fxNow = undefined; }; jQuery.fx.timer = function( timer ) { jQuery.timers.push( timer ); jQuery.fx.start(); }; jQuery.fx.interval = 13; jQuery.fx.start = function() { if ( inProgress ) { return; } inProgress = true; schedule(); }; jQuery.fx.stop = function() { inProgress = null; }; jQuery.fx.speeds = { slow: 600, fast: 200, // Default speed _default: 400 }; // Based off of the plugin by Clint Helfers, with permission. // https://web.archive.org/web/20100324014747/http://blindsignals.com/index.php/2009/07/jquery-delay/ jQuery.fn.delay = function( time, type ) { time = jQuery.fx ? jQuery.fx.speeds[ time ] || time : time; type = type || "fx"; return this.queue( type, function( next, hooks ) { var timeout = window.setTimeout( next, time ); hooks.stop = function() { window.clearTimeout( timeout ); }; } ); }; ( function() { var input = document.createElement( "input" ), select = document.createElement( "select" ), opt = select.appendChild( document.createElement( "option" ) ); input.type = "checkbox"; // Support: Android <=4.3 only // Default value for a checkbox should be "on" support.checkOn = input.value !== ""; // Support: IE <=11 only // Must access selectedIndex to make default options select support.optSelected = opt.selected; // Support: IE <=11 only // An input loses its value after becoming a radio input = document.createElement( "input" ); input.value = "t"; input.type = "radio"; support.radioValue = input.value === "t"; } )(); var boolHook, attrHandle = jQuery.expr.attrHandle; jQuery.fn.extend( { attr: function( name, value ) { return access( this, jQuery.attr, name, value, arguments.length > 1 ); }, removeAttr: function( name ) { return this.each( function() { jQuery.removeAttr( this, name ); } ); } } ); jQuery.extend( { attr: function( elem, name, value ) { var ret, hooks, nType = elem.nodeType; // Don't get/set attributes on text, comment and attribute nodes if ( nType === 3 || nType === 8 || nType === 2 ) { return; } // Fallback to prop when attributes are not supported if ( typeof elem.getAttribute === "undefined" ) { return jQuery.prop( elem, name, value ); } // Attribute hooks are determined by the lowercase version // Grab necessary hook if one is defined if ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) { hooks = jQuery.attrHooks[ name.toLowerCase() ] || ( jQuery.expr.match.bool.test( name ) ? boolHook : undefined ); } if ( value !== undefined ) { if ( value === null ) { jQuery.removeAttr( elem, name ); return; } if ( hooks && "set" in hooks && ( ret = hooks.set( elem, value, name ) ) !== undefined ) { return ret; } elem.setAttribute( name, value + "" ); return value; } if ( hooks && "get" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) { return ret; } ret = jQuery.find.attr( elem, name ); // Non-existent attributes return null, we normalize to undefined return ret == null ? undefined : ret; }, attrHooks: { type: { set: function( elem, value ) { if ( !support.radioValue && value === "radio" && nodeName( elem, "input" ) ) { var val = elem.value; elem.setAttribute( "type", value ); if ( val ) { elem.value = val; } return value; } } } }, removeAttr: function( elem, value ) { var name, i = 0, // Attribute names can contain non-HTML whitespace characters // https://html.spec.whatwg.org/multipage/syntax.html#attributes-2 attrNames = value && value.match( rnothtmlwhite ); if ( attrNames && elem.nodeType === 1 ) { while ( ( name = attrNames[ i++ ] ) ) { elem.removeAttribute( name ); } } } } ); // Hooks for boolean attributes boolHook = { set: function( elem, value, name ) { if ( value === false ) { // Remove boolean attributes when set to false jQuery.removeAttr( elem, name ); } else { elem.setAttribute( name, name ); } return name; } }; jQuery.each( jQuery.expr.match.bool.source.match( /\w+/g ), function( i, name ) { var getter = attrHandle[ name ] || jQuery.find.attr; attrHandle[ name ] = function( elem, name, isXML ) { var ret, handle, lowercaseName = name.toLowerCase(); if ( !isXML ) { // Avoid an infinite loop by temporarily removing this function from the getter handle = attrHandle[ lowercaseName ]; attrHandle[ lowercaseName ] = ret; ret = getter( elem, name, isXML ) != null ? lowercaseName : null; attrHandle[ lowercaseName ] = handle; } return ret; }; } ); var rfocusable = /^(?:input|select|textarea|button)$/i, rclickable = /^(?:a|area)$/i; jQuery.fn.extend( { prop: function( name, value ) { return access( this, jQuery.prop, name, value, arguments.length > 1 ); }, removeProp: function( name ) { return this.each( function() { delete this[ jQuery.propFix[ name ] || name ]; } ); } } ); jQuery.extend( { prop: function( elem, name, value ) { var ret, hooks, nType = elem.nodeType; // Don't get/set properties on text, comment and attribute nodes if ( nType === 3 || nType === 8 || nType === 2 ) { return; } if ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) { // Fix name and attach hooks name = jQuery.propFix[ name ] || name; hooks = jQuery.propHooks[ name ]; } if ( value !== undefined ) { if ( hooks && "set" in hooks && ( ret = hooks.set( elem, value, name ) ) !== undefined ) { return ret; } return ( elem[ name ] = value ); } if ( hooks && "get" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) { return ret; } return elem[ name ]; }, propHooks: { tabIndex: { get: function( elem ) { // Support: IE <=9 - 11 only // elem.tabIndex doesn't always return the // correct value when it hasn't been explicitly set // https://web.archive.org/web/20141116233347/http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/ // Use proper attribute retrieval(#12072) var tabindex = jQuery.find.attr( elem, "tabindex" ); if ( tabindex ) { return parseInt( tabindex, 10 ); } if ( rfocusable.test( elem.nodeName ) || rclickable.test( elem.nodeName ) && elem.href ) { return 0; } return -1; } } }, propFix: { "for": "htmlFor", "class": "className" } } ); // Support: IE <=11 only // Accessing the selectedIndex property // forces the browser to respect setting selected // on the option // The getter ensures a default option is selected // when in an optgroup // eslint rule "no-unused-expressions" is disabled for this code // since it considers such accessions noop if ( !support.optSelected ) { jQuery.propHooks.selected = { get: function( elem ) { /* eslint no-unused-expressions: "off" */ var parent = elem.parentNode; if ( parent && parent.parentNode ) { parent.parentNode.selectedIndex; } return null; }, set: function( elem ) { /* eslint no-unused-expressions: "off" */ var parent = elem.parentNode; if ( parent ) { parent.selectedIndex; if ( parent.parentNode ) { parent.parentNode.selectedIndex; } } } }; } jQuery.each( [ "tabIndex", "readOnly", "maxLength", "cellSpacing", "cellPadding", "rowSpan", "colSpan", "useMap", "frameBorder", "contentEditable" ], function() { jQuery.propFix[ this.toLowerCase() ] = this; } ); // Strip and collapse whitespace according to HTML spec // https://html.spec.whatwg.org/multipage/infrastructure.html#strip-and-collapse-whitespace function stripAndCollapse( value ) { var tokens = value.match( rnothtmlwhite ) || []; return tokens.join( " " ); } function getClass( elem ) { return elem.getAttribute && elem.getAttribute( "class" ) || ""; } jQuery.fn.extend( { addClass: function( value ) { var classes, elem, cur, curValue, clazz, j, finalValue, i = 0; if ( jQuery.isFunction( value ) ) { return this.each( function( j ) { jQuery( this ).addClass( value.call( this, j, getClass( this ) ) ); } ); } if ( typeof value === "string" && value ) { classes = value.match( rnothtmlwhite ) || []; while ( ( elem = this[ i++ ] ) ) { curValue = getClass( elem ); cur = elem.nodeType === 1 && ( " " + stripAndCollapse( curValue ) + " " ); if ( cur ) { j = 0; while ( ( clazz = classes[ j++ ] ) ) { if ( cur.indexOf( " " + clazz + " " ) < 0 ) { cur += clazz + " "; } } // Only assign if different to avoid unneeded rendering. finalValue = stripAndCollapse( cur ); if ( curValue !== finalValue ) { elem.setAttribute( "class", finalValue ); } } } } return this; }, removeClass: function( value ) { var classes, elem, cur, curValue, clazz, j, finalValue, i = 0; if ( jQuery.isFunction( value ) ) { return this.each( function( j ) { jQuery( this ).removeClass( value.call( this, j, getClass( this ) ) ); } ); } if ( !arguments.length ) { return this.attr( "class", "" ); } if ( typeof value === "string" && value ) { classes = value.match( rnothtmlwhite ) || []; while ( ( elem = this[ i++ ] ) ) { curValue = getClass( elem ); // This expression is here for better compressibility (see addClass) cur = elem.nodeType === 1 && ( " " + stripAndCollapse( curValue ) + " " ); if ( cur ) { j = 0; while ( ( clazz = classes[ j++ ] ) ) { // Remove *all* instances while ( cur.indexOf( " " + clazz + " " ) > -1 ) { cur = cur.replace( " " + clazz + " ", " " ); } } // Only assign if different to avoid unneeded rendering. finalValue = stripAndCollapse( cur ); if ( curValue !== finalValue ) { elem.setAttribute( "class", finalValue ); } } } } return this; }, toggleClass: function( value, stateVal ) { var type = typeof value; if ( typeof stateVal === "boolean" && type === "string" ) { return stateVal ? this.addClass( value ) : this.removeClass( value ); } if ( jQuery.isFunction( value ) ) { return this.each( function( i ) { jQuery( this ).toggleClass( value.call( this, i, getClass( this ), stateVal ), stateVal ); } ); } return this.each( function() { var className, i, self, classNames; if ( type === "string" ) { // Toggle individual class names i = 0; self = jQuery( this ); classNames = value.match( rnothtmlwhite ) || []; while ( ( className = classNames[ i++ ] ) ) { // Check each className given, space separated list if ( self.hasClass( className ) ) { self.removeClass( className ); } else { self.addClass( className ); } } // Toggle whole class name } else if ( value === undefined || type === "boolean" ) { className = getClass( this ); if ( className ) { // Store className if set dataPriv.set( this, "__className__", className ); } // If the element has a class name or if we're passed `false`, // then remove the whole classname (if there was one, the above saved it). // Otherwise bring back whatever was previously saved (if anything), // falling back to the empty string if nothing was stored. if ( this.setAttribute ) { this.setAttribute( "class", className || value === false ? "" : dataPriv.get( this, "__className__" ) || "" ); } } } ); }, hasClass: function( selector ) { var className, elem, i = 0; className = " " + selector + " "; while ( ( elem = this[ i++ ] ) ) { if ( elem.nodeType === 1 && ( " " + stripAndCollapse( getClass( elem ) ) + " " ).indexOf( className ) > -1 ) { return true; } } return false; } } ); var rreturn = /\r/g; jQuery.fn.extend( { val: function( value ) { var hooks, ret, isFunction, elem = this[ 0 ]; if ( !arguments.length ) { if ( elem ) { hooks = jQuery.valHooks[ elem.type ] || jQuery.valHooks[ elem.nodeName.toLowerCase() ]; if ( hooks && "get" in hooks && ( ret = hooks.get( elem, "value" ) ) !== undefined ) { return ret; } ret = elem.value; // Handle most common string cases if ( typeof ret === "string" ) { return ret.replace( rreturn, "" ); } // Handle cases where value is null/undef or number return ret == null ? "" : ret; } return; } isFunction = jQuery.isFunction( value ); return this.each( function( i ) { var val; if ( this.nodeType !== 1 ) { return; } if ( isFunction ) { val = value.call( this, i, jQuery( this ).val() ); } else { val = value; } // Treat null/undefined as ""; convert numbers to string if ( val == null ) { val = ""; } else if ( typeof val === "number" ) { val += ""; } else if ( Array.isArray( val ) ) { val = jQuery.map( val, function( value ) { return value == null ? "" : value + ""; } ); } hooks = jQuery.valHooks[ this.type ] || jQuery.valHooks[ this.nodeName.toLowerCase() ]; // If set returns undefined, fall back to normal setting if ( !hooks || !( "set" in hooks ) || hooks.set( this, val, "value" ) === undefined ) { this.value = val; } } ); } } ); jQuery.extend( { valHooks: { option: { get: function( elem ) { var val = jQuery.find.attr( elem, "value" ); return val != null ? val : // Support: IE <=10 - 11 only // option.text throws exceptions (#14686, #14858) // Strip and collapse whitespace // https://html.spec.whatwg.org/#strip-and-collapse-whitespace stripAndCollapse( jQuery.text( elem ) ); } }, select: { get: function( elem ) { var value, option, i, options = elem.options, index = elem.selectedIndex, one = elem.type === "select-one", values = one ? null : [], max = one ? index + 1 : options.length; if ( index < 0 ) { i = max; } else { i = one ? index : 0; } // Loop through all the selected options for ( ; i < max; i++ ) { option = options[ i ]; // Support: IE <=9 only // IE8-9 doesn't update selected after form reset (#2551) if ( ( option.selected || i === index ) && // Don't return options that are disabled or in a disabled optgroup !option.disabled && ( !option.parentNode.disabled || !nodeName( option.parentNode, "optgroup" ) ) ) { // Get the specific value for the option value = jQuery( option ).val(); // We don't need an array for one selects if ( one ) { return value; } // Multi-Selects return an array values.push( value ); } } return values; }, set: function( elem, value ) { var optionSet, option, options = elem.options, values = jQuery.makeArray( value ), i = options.length; while ( i-- ) { option = options[ i ]; /* eslint-disable no-cond-assign */ if ( option.selected = jQuery.inArray( jQuery.valHooks.option.get( option ), values ) > -1 ) { optionSet = true; } /* eslint-enable no-cond-assign */ } // Force browsers to behave consistently when non-matching value is set if ( !optionSet ) { elem.selectedIndex = -1; } return values; } } } } ); // Radios and checkboxes getter/setter jQuery.each( [ "radio", "checkbox" ], function() { jQuery.valHooks[ this ] = { set: function( elem, value ) { if ( Array.isArray( value ) ) { return ( elem.checked = jQuery.inArray( jQuery( elem ).val(), value ) > -1 ); } } }; if ( !support.checkOn ) { jQuery.valHooks[ this ].get = function( elem ) { return elem.getAttribute( "value" ) === null ? "on" : elem.value; }; } } ); // Return jQuery for attributes-only inclusion var rfocusMorph = /^(?:focusinfocus|focusoutblur)$/; jQuery.extend( jQuery.event, { trigger: function( event, data, elem, onlyHandlers ) { var i, cur, tmp, bubbleType, ontype, handle, special, eventPath = [ elem || document ], type = hasOwn.call( event, "type" ) ? event.type : event, namespaces = hasOwn.call( event, "namespace" ) ? event.namespace.split( "." ) : []; cur = tmp = elem = elem || document; // Don't do events on text and comment nodes if ( elem.nodeType === 3 || elem.nodeType === 8 ) { return; } // focus/blur morphs to focusin/out; ensure we're not firing them right now if ( rfocusMorph.test( type + jQuery.event.triggered ) ) { return; } if ( type.indexOf( "." ) > -1 ) { // Namespaced trigger; create a regexp to match event type in handle() namespaces = type.split( "." ); type = namespaces.shift(); namespaces.sort(); } ontype = type.indexOf( ":" ) < 0 && "on" + type; // Caller can pass in a jQuery.Event object, Object, or just an event type string event = event[ jQuery.expando ] ? event : new jQuery.Event( type, typeof event === "object" && event ); // Trigger bitmask: & 1 for native handlers; & 2 for jQuery (always true) event.isTrigger = onlyHandlers ? 2 : 3; event.namespace = namespaces.join( "." ); event.rnamespace = event.namespace ? new RegExp( "(^|\\.)" + namespaces.join( "\\.(?:.*\\.|)" ) + "(\\.|$)" ) : null; // Clean up the event in case it is being reused event.result = undefined; if ( !event.target ) { event.target = elem; } // Clone any incoming data and prepend the event, creating the handler arg list data = data == null ? [ event ] : jQuery.makeArray( data, [ event ] ); // Allow special events to draw outside the lines special = jQuery.event.special[ type ] || {}; if ( !onlyHandlers && special.trigger && special.trigger.apply( elem, data ) === false ) { return; } // Determine event propagation path in advance, per W3C events spec (#9951) // Bubble up to document, then to window; watch for a global ownerDocument var (#9724) if ( !onlyHandlers && !special.noBubble && !jQuery.isWindow( elem ) ) { bubbleType = special.delegateType || type; if ( !rfocusMorph.test( bubbleType + type ) ) { cur = cur.parentNode; } for ( ; cur; cur = cur.parentNode ) { eventPath.push( cur ); tmp = cur; } // Only add window if we got to document (e.g., not plain obj or detached DOM) if ( tmp === ( elem.ownerDocument || document ) ) { eventPath.push( tmp.defaultView || tmp.parentWindow || window ); } } // Fire handlers on the event path i = 0; while ( ( cur = eventPath[ i++ ] ) && !event.isPropagationStopped() ) { event.type = i > 1 ? bubbleType : special.bindType || type; // jQuery handler handle = ( dataPriv.get( cur, "events" ) || {} )[ event.type ] && dataPriv.get( cur, "handle" ); if ( handle ) { handle.apply( cur, data ); } // Native handler handle = ontype && cur[ ontype ]; if ( handle && handle.apply && acceptData( cur ) ) { event.result = handle.apply( cur, data ); if ( event.result === false ) { event.preventDefault(); } } } event.type = type; // If nobody prevented the default action, do it now if ( !onlyHandlers && !event.isDefaultPrevented() ) { if ( ( !special._default || special._default.apply( eventPath.pop(), data ) === false ) && acceptData( elem ) ) { // Call a native DOM method on the target with the same name as the event. // Don't do default actions on window, that's where global variables be (#6170) if ( ontype && jQuery.isFunction( elem[ type ] ) && !jQuery.isWindow( elem ) ) { // Don't re-trigger an onFOO event when we call its FOO() method tmp = elem[ ontype ]; if ( tmp ) { elem[ ontype ] = null; } // Prevent re-triggering of the same event, since we already bubbled it above jQuery.event.triggered = type; elem[ type ](); jQuery.event.triggered = undefined; if ( tmp ) { elem[ ontype ] = tmp; } } } } return event.result; }, // Piggyback on a donor event to simulate a different one // Used only for `focus(in | out)` events simulate: function( type, elem, event ) { var e = jQuery.extend( new jQuery.Event(), event, { type: type, isSimulated: true } ); jQuery.event.trigger( e, null, elem ); } } ); jQuery.fn.extend( { trigger: function( type, data ) { return this.each( function() { jQuery.event.trigger( type, data, this ); } ); }, triggerHandler: function( type, data ) { var elem = this[ 0 ]; if ( elem ) { return jQuery.event.trigger( type, data, elem, true ); } } } ); jQuery.each( ( "blur focus focusin focusout resize scroll click dblclick " + "mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " + "change select submit keydown keypress keyup contextmenu" ).split( " " ), function( i, name ) { // Handle event binding jQuery.fn[ name ] = function( data, fn ) { return arguments.length > 0 ? this.on( name, null, data, fn ) : this.trigger( name ); }; } ); jQuery.fn.extend( { hover: function( fnOver, fnOut ) { return this.mouseenter( fnOver ).mouseleave( fnOut || fnOver ); } } ); support.focusin = "onfocusin" in window; // Support: Firefox <=44 // Firefox doesn't have focus(in | out) events // Related ticket - https://bugzilla.mozilla.org/show_bug.cgi?id=687787 // // Support: Chrome <=48 - 49, Safari <=9.0 - 9.1 // focus(in | out) events fire after focus & blur events, // which is spec violation - http://www.w3.org/TR/DOM-Level-3-Events/#events-focusevent-event-order // Related ticket - https://bugs.chromium.org/p/chromium/issues/detail?id=449857 if ( !support.focusin ) { jQuery.each( { focus: "focusin", blur: "focusout" }, function( orig, fix ) { // Attach a single capturing handler on the document while someone wants focusin/focusout var handler = function( event ) { jQuery.event.simulate( fix, event.target, jQuery.event.fix( event ) ); }; jQuery.event.special[ fix ] = { setup: function() { var doc = this.ownerDocument || this, attaches = dataPriv.access( doc, fix ); if ( !attaches ) { doc.addEventListener( orig, handler, true ); } dataPriv.access( doc, fix, ( attaches || 0 ) + 1 ); }, teardown: function() { var doc = this.ownerDocument || this, attaches = dataPriv.access( doc, fix ) - 1; if ( !attaches ) { doc.removeEventListener( orig, handler, true ); dataPriv.remove( doc, fix ); } else { dataPriv.access( doc, fix, attaches ); } } }; } ); } var location = window.location; var nonce = jQuery.now(); var rquery = ( /\?/ ); // Cross-browser xml parsing jQuery.parseXML = function( data ) { var xml; if ( !data || typeof data !== "string" ) { return null; } // Support: IE 9 - 11 only // IE throws on parseFromString with invalid input. try { xml = ( new window.DOMParser() ).parseFromString( data, "text/xml" ); } catch ( e ) { xml = undefined; } if ( !xml || xml.getElementsByTagName( "parsererror" ).length ) { jQuery.error( "Invalid XML: " + data ); } return xml; }; var rbracket = /\[\]$/, rCRLF = /\r?\n/g, rsubmitterTypes = /^(?:submit|button|image|reset|file)$/i, rsubmittable = /^(?:input|select|textarea|keygen)/i; function buildParams( prefix, obj, traditional, add ) { var name; if ( Array.isArray( obj ) ) { // Serialize array item. jQuery.each( obj, function( i, v ) { if ( traditional || rbracket.test( prefix ) ) { // Treat each array item as a scalar. add( prefix, v ); } else { // Item is non-scalar (array or object), encode its numeric index. buildParams( prefix + "[" + ( typeof v === "object" && v != null ? i : "" ) + "]", v, traditional, add ); } } ); } else if ( !traditional && jQuery.type( obj ) === "object" ) { // Serialize object item. for ( name in obj ) { buildParams( prefix + "[" + name + "]", obj[ name ], traditional, add ); } } else { // Serialize scalar item. add( prefix, obj ); } } // Serialize an array of form elements or a set of // key/values into a query string jQuery.param = function( a, traditional ) { var prefix, s = [], add = function( key, valueOrFunction ) { // If value is a function, invoke it and use its return value var value = jQuery.isFunction( valueOrFunction ) ? valueOrFunction() : valueOrFunction; s[ s.length ] = encodeURIComponent( key ) + "=" + encodeURIComponent( value == null ? "" : value ); }; // If an array was passed in, assume that it is an array of form elements. if ( Array.isArray( a ) || ( a.jquery && !jQuery.isPlainObject( a ) ) ) { // Serialize the form elements jQuery.each( a, function() { add( this.name, this.value ); } ); } else { // If traditional, encode the "old" way (the way 1.3.2 or older // did it), otherwise encode params recursively. for ( prefix in a ) { buildParams( prefix, a[ prefix ], traditional, add ); } } // Return the resulting serialization return s.join( "&" ); }; jQuery.fn.extend( { serialize: function() { return jQuery.param( this.serializeArray() ); }, serializeArray: function() { return this.map( function() { // Can add propHook for "elements" to filter or add form elements var elements = jQuery.prop( this, "elements" ); return elements ? jQuery.makeArray( elements ) : this; } ) .filter( function() { var type = this.type; // Use .is( ":disabled" ) so that fieldset[disabled] works return this.name && !jQuery( this ).is( ":disabled" ) && rsubmittable.test( this.nodeName ) && !rsubmitterTypes.test( type ) && ( this.checked || !rcheckableType.test( type ) ); } ) .map( function( i, elem ) { var val = jQuery( this ).val(); if ( val == null ) { return null; } if ( Array.isArray( val ) ) { return jQuery.map( val, function( val ) { return { name: elem.name, value: val.replace( rCRLF, "\r\n" ) }; } ); } return { name: elem.name, value: val.replace( rCRLF, "\r\n" ) }; } ).get(); } } ); var r20 = /%20/g, rhash = /#.*$/, rantiCache = /([?&])_=[^&]*/, rheaders = /^(.*?):[ \t]*([^\r\n]*)$/mg, // #7653, #8125, #8152: local protocol detection rlocalProtocol = /^(?:about|app|app-storage|.+-extension|file|res|widget):$/, rnoContent = /^(?:GET|HEAD)$/, rprotocol = /^\/\//, /* Prefilters * 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example) * 2) These are called: * - BEFORE asking for a transport * - AFTER param serialization (s.data is a string if s.processData is true) * 3) key is the dataType * 4) the catchall symbol "*" can be used * 5) execution will start with transport dataType and THEN continue down to "*" if needed */ prefilters = {}, /* Transports bindings * 1) key is the dataType * 2) the catchall symbol "*" can be used * 3) selection will start with transport dataType and THEN go to "*" if needed */ transports = {}, // Avoid comment-prolog char sequence (#10098); must appease lint and evade compression allTypes = "*/".concat( "*" ), // Anchor tag for parsing the document origin originAnchor = document.createElement( "a" ); originAnchor.href = location.href; // Base "constructor" for jQuery.ajaxPrefilter and jQuery.ajaxTransport function addToPrefiltersOrTransports( structure ) { // dataTypeExpression is optional and defaults to "*" return function( dataTypeExpression, func ) { if ( typeof dataTypeExpression !== "string" ) { func = dataTypeExpression; dataTypeExpression = "*"; } var dataType, i = 0, dataTypes = dataTypeExpression.toLowerCase().match( rnothtmlwhite ) || []; if ( jQuery.isFunction( func ) ) { // For each dataType in the dataTypeExpression while ( ( dataType = dataTypes[ i++ ] ) ) { // Prepend if requested if ( dataType[ 0 ] === "+" ) { dataType = dataType.slice( 1 ) || "*"; ( structure[ dataType ] = structure[ dataType ] || [] ).unshift( func ); // Otherwise append } else { ( structure[ dataType ] = structure[ dataType ] || [] ).push( func ); } } } }; } // Base inspection function for prefilters and transports function inspectPrefiltersOrTransports( structure, options, originalOptions, jqXHR ) { var inspected = {}, seekingTransport = ( structure === transports ); function inspect( dataType ) { var selected; inspected[ dataType ] = true; jQuery.each( structure[ dataType ] || [], function( _, prefilterOrFactory ) { var dataTypeOrTransport = prefilterOrFactory( options, originalOptions, jqXHR ); if ( typeof dataTypeOrTransport === "string" && !seekingTransport && !inspected[ dataTypeOrTransport ] ) { options.dataTypes.unshift( dataTypeOrTransport ); inspect( dataTypeOrTransport ); return false; } else if ( seekingTransport ) { return !( selected = dataTypeOrTransport ); } } ); return selected; } return inspect( options.dataTypes[ 0 ] ) || !inspected[ "*" ] && inspect( "*" ); } // A special extend for ajax options // that takes "flat" options (not to be deep extended) // Fixes #9887 function ajaxExtend( target, src ) { var key, deep, flatOptions = jQuery.ajaxSettings.flatOptions || {}; for ( key in src ) { if ( src[ key ] !== undefined ) { ( flatOptions[ key ] ? target : ( deep || ( deep = {} ) ) )[ key ] = src[ key ]; } } if ( deep ) { jQuery.extend( true, target, deep ); } return target; } /* Handles responses to an ajax request: * - finds the right dataType (mediates between content-type and expected dataType) * - returns the corresponding response */ function ajaxHandleResponses( s, jqXHR, responses ) { var ct, type, finalDataType, firstDataType, contents = s.contents, dataTypes = s.dataTypes; // Remove auto dataType and get content-type in the process while ( dataTypes[ 0 ] === "*" ) { dataTypes.shift(); if ( ct === undefined ) { ct = s.mimeType || jqXHR.getResponseHeader( "Content-Type" ); } } // Check if we're dealing with a known content-type if ( ct ) { for ( type in contents ) { if ( contents[ type ] && contents[ type ].test( ct ) ) { dataTypes.unshift( type ); break; } } } // Check to see if we have a response for the expected dataType if ( dataTypes[ 0 ] in responses ) { finalDataType = dataTypes[ 0 ]; } else { // Try convertible dataTypes for ( type in responses ) { if ( !dataTypes[ 0 ] || s.converters[ type + " " + dataTypes[ 0 ] ] ) { finalDataType = type; break; } if ( !firstDataType ) { firstDataType = type; } } // Or just use first one finalDataType = finalDataType || firstDataType; } // If we found a dataType // We add the dataType to the list if needed // and return the corresponding response if ( finalDataType ) { if ( finalDataType !== dataTypes[ 0 ] ) { dataTypes.unshift( finalDataType ); } return responses[ finalDataType ]; } } /* Chain conversions given the request and the original response * Also sets the responseXXX fields on the jqXHR instance */ function ajaxConvert( s, response, jqXHR, isSuccess ) { var conv2, current, conv, tmp, prev, converters = {}, // Work with a copy of dataTypes in case we need to modify it for conversion dataTypes = s.dataTypes.slice(); // Create converters map with lowercased keys if ( dataTypes[ 1 ] ) { for ( conv in s.converters ) { converters[ conv.toLowerCase() ] = s.converters[ conv ]; } } current = dataTypes.shift(); // Convert to each sequential dataType while ( current ) { if ( s.responseFields[ current ] ) { jqXHR[ s.responseFields[ current ] ] = response; } // Apply the dataFilter if provided if ( !prev && isSuccess && s.dataFilter ) { response = s.dataFilter( response, s.dataType ); } prev = current; current = dataTypes.shift(); if ( current ) { // There's only work to do if current dataType is non-auto if ( current === "*" ) { current = prev; // Convert response if prev dataType is non-auto and differs from current } else if ( prev !== "*" && prev !== current ) { // Seek a direct converter conv = converters[ prev + " " + current ] || converters[ "* " + current ]; // If none found, seek a pair if ( !conv ) { for ( conv2 in converters ) { // If conv2 outputs current tmp = conv2.split( " " ); if ( tmp[ 1 ] === current ) { // If prev can be converted to accepted input conv = converters[ prev + " " + tmp[ 0 ] ] || converters[ "* " + tmp[ 0 ] ]; if ( conv ) { // Condense equivalence converters if ( conv === true ) { conv = converters[ conv2 ]; // Otherwise, insert the intermediate dataType } else if ( converters[ conv2 ] !== true ) { current = tmp[ 0 ]; dataTypes.unshift( tmp[ 1 ] ); } break; } } } } // Apply converter (if not an equivalence) if ( conv !== true ) { // Unless errors are allowed to bubble, catch and return them if ( conv && s.throws ) { response = conv( response ); } else { try { response = conv( response ); } catch ( e ) { return { state: "parsererror", error: conv ? e : "No conversion from " + prev + " to " + current }; } } } } } } return { state: "success", data: response }; } jQuery.extend( { // Counter for holding the number of active queries active: 0, // Last-Modified header cache for next request lastModified: {}, etag: {}, ajaxSettings: { url: location.href, type: "GET", isLocal: rlocalProtocol.test( location.protocol ), global: true, processData: true, async: true, contentType: "application/x-www-form-urlencoded; charset=UTF-8", /* timeout: 0, data: null, dataType: null, username: null, password: null, cache: null, throws: false, traditional: false, headers: {}, */ accepts: { "*": allTypes, text: "text/plain", html: "text/html", xml: "application/xml, text/xml", json: "application/json, text/javascript" }, contents: { xml: /\bxml\b/, html: /\bhtml/, json: /\bjson\b/ }, responseFields: { xml: "responseXML", text: "responseText", json: "responseJSON" }, // Data converters // Keys separate source (or catchall "*") and destination types with a single space converters: { // Convert anything to text "* text": String, // Text to html (true = no transformation) "text html": true, // Evaluate text as a json expression "text json": JSON.parse, // Parse text as xml "text xml": jQuery.parseXML }, // For options that shouldn't be deep extended: // you can add your own custom options here if // and when you create one that shouldn't be // deep extended (see ajaxExtend) flatOptions: { url: true, context: true } }, // Creates a full fledged settings object into target // with both ajaxSettings and settings fields. // If target is omitted, writes into ajaxSettings. ajaxSetup: function( target, settings ) { return settings ? // Building a settings object ajaxExtend( ajaxExtend( target, jQuery.ajaxSettings ), settings ) : // Extending ajaxSettings ajaxExtend( jQuery.ajaxSettings, target ); }, ajaxPrefilter: addToPrefiltersOrTransports( prefilters ), ajaxTransport: addToPrefiltersOrTransports( transports ), // Main method ajax: function( url, options ) { // If url is an object, simulate pre-1.5 signature if ( typeof url === "object" ) { options = url; url = undefined; } // Force options to be an object options = options || {}; var transport, // URL without anti-cache param cacheURL, // Response headers responseHeadersString, responseHeaders, // timeout handle timeoutTimer, // Url cleanup var urlAnchor, // Request state (becomes false upon send and true upon completion) completed, // To know if global events are to be dispatched fireGlobals, // Loop variable i, // uncached part of the url uncached, // Create the final options object s = jQuery.ajaxSetup( {}, options ), // Callbacks context callbackContext = s.context || s, // Context for global events is callbackContext if it is a DOM node or jQuery collection globalEventContext = s.context && ( callbackContext.nodeType || callbackContext.jquery ) ? jQuery( callbackContext ) : jQuery.event, // Deferreds deferred = jQuery.Deferred(), completeDeferred = jQuery.Callbacks( "once memory" ), // Status-dependent callbacks statusCode = s.statusCode || {}, // Headers (they are sent all at once) requestHeaders = {}, requestHeadersNames = {}, // Default abort message strAbort = "canceled", // Fake xhr jqXHR = { readyState: 0, // Builds headers hashtable if needed getResponseHeader: function( key ) { var match; if ( completed ) { if ( !responseHeaders ) { responseHeaders = {}; while ( ( match = rheaders.exec( responseHeadersString ) ) ) { responseHeaders[ match[ 1 ].toLowerCase() ] = match[ 2 ]; } } match = responseHeaders[ key.toLowerCase() ]; } return match == null ? null : match; }, // Raw string getAllResponseHeaders: function() { return completed ? responseHeadersString : null; }, // Caches the header setRequestHeader: function( name, value ) { if ( completed == null ) { name = requestHeadersNames[ name.toLowerCase() ] = requestHeadersNames[ name.toLowerCase() ] || name; requestHeaders[ name ] = value; } return this; }, // Overrides response content-type header overrideMimeType: function( type ) { if ( completed == null ) { s.mimeType = type; } return this; }, // Status-dependent callbacks statusCode: function( map ) { var code; if ( map ) { if ( completed ) { // Execute the appropriate callbacks jqXHR.always( map[ jqXHR.status ] ); } else { // Lazy-add the new callbacks in a way that preserves old ones for ( code in map ) { statusCode[ code ] = [ statusCode[ code ], map[ code ] ]; } } } return this; }, // Cancel the request abort: function( statusText ) { var finalText = statusText || strAbort; if ( transport ) { transport.abort( finalText ); } done( 0, finalText ); return this; } }; // Attach deferreds deferred.promise( jqXHR ); // Add protocol if not provided (prefilters might expect it) // Handle falsy url in the settings object (#10093: consistency with old signature) // We also use the url parameter if available s.url = ( ( url || s.url || location.href ) + "" ) .replace( rprotocol, location.protocol + "//" ); // Alias method option to type as per ticket #12004 s.type = options.method || options.type || s.method || s.type; // Extract dataTypes list s.dataTypes = ( s.dataType || "*" ).toLowerCase().match( rnothtmlwhite ) || [ "" ]; // A cross-domain request is in order when the origin doesn't match the current origin. if ( s.crossDomain == null ) { urlAnchor = document.createElement( "a" ); // Support: IE <=8 - 11, Edge 12 - 13 // IE throws exception on accessing the href property if url is malformed, // e.g. http://example.com:80x/ try { urlAnchor.href = s.url; // Support: IE <=8 - 11 only // Anchor's host property isn't correctly set when s.url is relative urlAnchor.href = urlAnchor.href; s.crossDomain = originAnchor.protocol + "//" + originAnchor.host !== urlAnchor.protocol + "//" + urlAnchor.host; } catch ( e ) { // If there is an error parsing the URL, assume it is crossDomain, // it can be rejected by the transport if it is invalid s.crossDomain = true; } } // Convert data if not already a string if ( s.data && s.processData && typeof s.data !== "string" ) { s.data = jQuery.param( s.data, s.traditional ); } // Apply prefilters inspectPrefiltersOrTransports( prefilters, s, options, jqXHR ); // If request was aborted inside a prefilter, stop there if ( completed ) { return jqXHR; } // We can fire global events as of now if asked to // Don't fire events if jQuery.event is undefined in an AMD-usage scenario (#15118) fireGlobals = jQuery.event && s.global; // Watch for a new set of requests if ( fireGlobals && jQuery.active++ === 0 ) { jQuery.event.trigger( "ajaxStart" ); } // Uppercase the type s.type = s.type.toUpperCase(); // Determine if request has content s.hasContent = !rnoContent.test( s.type ); // Save the URL in case we're toying with the If-Modified-Since // and/or If-None-Match header later on // Remove hash to simplify url manipulation cacheURL = s.url.replace( rhash, "" ); // More options handling for requests with no content if ( !s.hasContent ) { // Remember the hash so we can put it back uncached = s.url.slice( cacheURL.length ); // If data is available, append data to url if ( s.data ) { cacheURL += ( rquery.test( cacheURL ) ? "&" : "?" ) + s.data; // #9682: remove data so that it's not used in an eventual retry delete s.data; } // Add or update anti-cache param if needed if ( s.cache === false ) { cacheURL = cacheURL.replace( rantiCache, "$1" ); uncached = ( rquery.test( cacheURL ) ? "&" : "?" ) + "_=" + ( nonce++ ) + uncached; } // Put hash and anti-cache on the URL that will be requested (gh-1732) s.url = cacheURL + uncached; // Change '%20' to '+' if this is encoded form body content (gh-2658) } else if ( s.data && s.processData && ( s.contentType || "" ).indexOf( "application/x-www-form-urlencoded" ) === 0 ) { s.data = s.data.replace( r20, "+" ); } // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode. if ( s.ifModified ) { if ( jQuery.lastModified[ cacheURL ] ) { jqXHR.setRequestHeader( "If-Modified-Since", jQuery.lastModified[ cacheURL ] ); } if ( jQuery.etag[ cacheURL ] ) { jqXHR.setRequestHeader( "If-None-Match", jQuery.etag[ cacheURL ] ); } } // Set the correct header, if data is being sent if ( s.data && s.hasContent && s.contentType !== false || options.contentType ) { jqXHR.setRequestHeader( "Content-Type", s.contentType ); } // Set the Accepts header for the server, depending on the dataType jqXHR.setRequestHeader( "Accept", s.dataTypes[ 0 ] && s.accepts[ s.dataTypes[ 0 ] ] ? s.accepts[ s.dataTypes[ 0 ] ] + ( s.dataTypes[ 0 ] !== "*" ? ", " + allTypes + "; q=0.01" : "" ) : s.accepts[ "*" ] ); // Check for headers option for ( i in s.headers ) { jqXHR.setRequestHeader( i, s.headers[ i ] ); } // Allow custom headers/mimetypes and early abort if ( s.beforeSend && ( s.beforeSend.call( callbackContext, jqXHR, s ) === false || completed ) ) { // Abort if not done already and return return jqXHR.abort(); } // Aborting is no longer a cancellation strAbort = "abort"; // Install callbacks on deferreds completeDeferred.add( s.complete ); jqXHR.done( s.success ); jqXHR.fail( s.error ); // Get transport transport = inspectPrefiltersOrTransports( transports, s, options, jqXHR ); // If no transport, we auto-abort if ( !transport ) { done( -1, "No Transport" ); } else { jqXHR.readyState = 1; // Send global event if ( fireGlobals ) { globalEventContext.trigger( "ajaxSend", [ jqXHR, s ] ); } // If request was aborted inside ajaxSend, stop there if ( completed ) { return jqXHR; } // Timeout if ( s.async && s.timeout > 0 ) { timeoutTimer = window.setTimeout( function() { jqXHR.abort( "timeout" ); }, s.timeout ); } try { completed = false; transport.send( requestHeaders, done ); } catch ( e ) { // Rethrow post-completion exceptions if ( completed ) { throw e; } // Propagate others as results done( -1, e ); } } // Callback for when everything is done function done( status, nativeStatusText, responses, headers ) { var isSuccess, success, error, response, modified, statusText = nativeStatusText; // Ignore repeat invocations if ( completed ) { return; } completed = true; // Clear timeout if it exists if ( timeoutTimer ) { window.clearTimeout( timeoutTimer ); } // Dereference transport for early garbage collection // (no matter how long the jqXHR object will be used) transport = undefined; // Cache response headers responseHeadersString = headers || ""; // Set readyState jqXHR.readyState = status > 0 ? 4 : 0; // Determine if successful isSuccess = status >= 200 && status < 300 || status === 304; // Get response data if ( responses ) { response = ajaxHandleResponses( s, jqXHR, responses ); } // Convert no matter what (that way responseXXX fields are always set) response = ajaxConvert( s, response, jqXHR, isSuccess ); // If successful, handle type chaining if ( isSuccess ) { // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode. if ( s.ifModified ) { modified = jqXHR.getResponseHeader( "Last-Modified" ); if ( modified ) { jQuery.lastModified[ cacheURL ] = modified; } modified = jqXHR.getResponseHeader( "etag" ); if ( modified ) { jQuery.etag[ cacheURL ] = modified; } } // if no content if ( status === 204 || s.type === "HEAD" ) { statusText = "nocontent"; // if not modified } else if ( status === 304 ) { statusText = "notmodified"; // If we have data, let's convert it } else { statusText = response.state; success = response.data; error = response.error; isSuccess = !error; } } else { // Extract error from statusText and normalize for non-aborts error = statusText; if ( status || !statusText ) { statusText = "error"; if ( status < 0 ) { status = 0; } } } // Set data for the fake xhr object jqXHR.status = status; jqXHR.statusText = ( nativeStatusText || statusText ) + ""; // Success/Error if ( isSuccess ) { deferred.resolveWith( callbackContext, [ success, statusText, jqXHR ] ); } else { deferred.rejectWith( callbackContext, [ jqXHR, statusText, error ] ); } // Status-dependent callbacks jqXHR.statusCode( statusCode ); statusCode = undefined; if ( fireGlobals ) { globalEventContext.trigger( isSuccess ? "ajaxSuccess" : "ajaxError", [ jqXHR, s, isSuccess ? success : error ] ); } // Complete completeDeferred.fireWith( callbackContext, [ jqXHR, statusText ] ); if ( fireGlobals ) { globalEventContext.trigger( "ajaxComplete", [ jqXHR, s ] ); // Handle the global AJAX counter if ( !( --jQuery.active ) ) { jQuery.event.trigger( "ajaxStop" ); } } } return jqXHR; }, getJSON: function( url, data, callback ) { return jQuery.get( url, data, callback, "json" ); }, getScript: function( url, callback ) { return jQuery.get( url, undefined, callback, "script" ); } } ); jQuery.each( [ "get", "post" ], function( i, method ) { jQuery[ method ] = function( url, data, callback, type ) { // Shift arguments if data argument was omitted if ( jQuery.isFunction( data ) ) { type = type || callback; callback = data; data = undefined; } // The url can be an options object (which then must have .url) return jQuery.ajax( jQuery.extend( { url: url, type: method, dataType: type, data: data, success: callback }, jQuery.isPlainObject( url ) && url ) ); }; } ); jQuery._evalUrl = function( url ) { return jQuery.ajax( { url: url, // Make this explicit, since user can override this through ajaxSetup (#11264) type: "GET", dataType: "script", cache: true, async: false, global: false, "throws": true } ); }; jQuery.fn.extend( { wrapAll: function( html ) { var wrap; if ( this[ 0 ] ) { if ( jQuery.isFunction( html ) ) { html = html.call( this[ 0 ] ); } // The elements to wrap the target around wrap = jQuery( html, this[ 0 ].ownerDocument ).eq( 0 ).clone( true ); if ( this[ 0 ].parentNode ) { wrap.insertBefore( this[ 0 ] ); } wrap.map( function() { var elem = this; while ( elem.firstElementChild ) { elem = elem.firstElementChild; } return elem; } ).append( this ); } return this; }, wrapInner: function( html ) { if ( jQuery.isFunction( html ) ) { return this.each( function( i ) { jQuery( this ).wrapInner( html.call( this, i ) ); } ); } return this.each( function() { var self = jQuery( this ), contents = self.contents(); if ( contents.length ) { contents.wrapAll( html ); } else { self.append( html ); } } ); }, wrap: function( html ) { var isFunction = jQuery.isFunction( html ); return this.each( function( i ) { jQuery( this ).wrapAll( isFunction ? html.call( this, i ) : html ); } ); }, unwrap: function( selector ) { this.parent( selector ).not( "body" ).each( function() { jQuery( this ).replaceWith( this.childNodes ); } ); return this; } } ); jQuery.expr.pseudos.hidden = function( elem ) { return !jQuery.expr.pseudos.visible( elem ); }; jQuery.expr.pseudos.visible = function( elem ) { return !!( elem.offsetWidth || elem.offsetHeight || elem.getClientRects().length ); }; jQuery.ajaxSettings.xhr = function() { try { return new window.XMLHttpRequest(); } catch ( e ) {} }; var xhrSuccessStatus = { // File protocol always yields status code 0, assume 200 0: 200, // Support: IE <=9 only // #1450: sometimes IE returns 1223 when it should be 204 1223: 204 }, xhrSupported = jQuery.ajaxSettings.xhr(); support.cors = !!xhrSupported && ( "withCredentials" in xhrSupported ); support.ajax = xhrSupported = !!xhrSupported; jQuery.ajaxTransport( function( options ) { var callback, errorCallback; // Cross domain only allowed if supported through XMLHttpRequest if ( support.cors || xhrSupported && !options.crossDomain ) { return { send: function( headers, complete ) { var i, xhr = options.xhr(); xhr.open( options.type, options.url, options.async, options.username, options.password ); // Apply custom fields if provided if ( options.xhrFields ) { for ( i in options.xhrFields ) { xhr[ i ] = options.xhrFields[ i ]; } } // Override mime type if needed if ( options.mimeType && xhr.overrideMimeType ) { xhr.overrideMimeType( options.mimeType ); } // X-Requested-With header // For cross-domain requests, seeing as conditions for a preflight are // akin to a jigsaw puzzle, we simply never set it to be sure. // (it can always be set on a per-request basis or even using ajaxSetup) // For same-domain requests, won't change header if already provided. if ( !options.crossDomain && !headers[ "X-Requested-With" ] ) { headers[ "X-Requested-With" ] = "XMLHttpRequest"; } // Set headers for ( i in headers ) { xhr.setRequestHeader( i, headers[ i ] ); } // Callback callback = function( type ) { return function() { if ( callback ) { callback = errorCallback = xhr.onload = xhr.onerror = xhr.onabort = xhr.onreadystatechange = null; if ( type === "abort" ) { xhr.abort(); } else if ( type === "error" ) { // Support: IE <=9 only // On a manual native abort, IE9 throws // errors on any property access that is not readyState if ( typeof xhr.status !== "number" ) { complete( 0, "error" ); } else { complete( // File: protocol always yields status 0; see #8605, #14207 xhr.status, xhr.statusText ); } } else { complete( xhrSuccessStatus[ xhr.status ] || xhr.status, xhr.statusText, // Support: IE <=9 only // IE9 has no XHR2 but throws on binary (trac-11426) // For XHR2 non-text, let the caller handle it (gh-2498) ( xhr.responseType || "text" ) !== "text" || typeof xhr.responseText !== "string" ? { binary: xhr.response } : { text: xhr.responseText }, xhr.getAllResponseHeaders() ); } } }; }; // Listen to events xhr.onload = callback(); errorCallback = xhr.onerror = callback( "error" ); // Support: IE 9 only // Use onreadystatechange to replace onabort // to handle uncaught aborts if ( xhr.onabort !== undefined ) { xhr.onabort = errorCallback; } else { xhr.onreadystatechange = function() { // Check readyState before timeout as it changes if ( xhr.readyState === 4 ) { // Allow onerror to be called first, // but that will not handle a native abort // Also, save errorCallback to a variable // as xhr.onerror cannot be accessed window.setTimeout( function() { if ( callback ) { errorCallback(); } } ); } }; } // Create the abort callback callback = callback( "abort" ); try { // Do send the request (this may raise an exception) xhr.send( options.hasContent && options.data || null ); } catch ( e ) { // #14683: Only rethrow if this hasn't been notified as an error yet if ( callback ) { throw e; } } }, abort: function() { if ( callback ) { callback(); } } }; } } ); // Prevent auto-execution of scripts when no explicit dataType was provided (See gh-2432) jQuery.ajaxPrefilter( function( s ) { if ( s.crossDomain ) { s.contents.script = false; } } ); // Install script dataType jQuery.ajaxSetup( { accepts: { script: "text/javascript, application/javascript, " + "application/ecmascript, application/x-ecmascript" }, contents: { script: /\b(?:java|ecma)script\b/ }, converters: { "text script": function( text ) { jQuery.globalEval( text ); return text; } } } ); // Handle cache's special case and crossDomain jQuery.ajaxPrefilter( "script", function( s ) { if ( s.cache === undefined ) { s.cache = false; } if ( s.crossDomain ) { s.type = "GET"; } } ); // Bind script tag hack transport jQuery.ajaxTransport( "script", function( s ) { // This transport only deals with cross domain requests if ( s.crossDomain ) { var script, callback; return { send: function( _, complete ) { script = jQuery( "

eventkit

Release 1.0.1.

Event

class eventkit.event.Event(name='', _with_error_done_events=True)[source]

Enable event passing between loosely coupled components. The event emits values to connected listeners and has a selection of operators to create general data flow pipelines.

Parameters:

name (str) – Name to use for this event.

__await__()[source]

Asynchronously await the next emit of an event:

async def coro():
    args = await event
    ...

If the event does an empty emit(), then the value of args is set to util.NO_VALUE.

wait() and __await__() are each other’s inverse.

async __aiter__(skip_to_last=False, tuples=False)

Synonym for aiter() with default arguments:

async def coro():
    async for args in event:
        ...

aiterate() and __aiter__() are each other’s inverse.

error_event: Optional[Event]

Sub event that emits errors from this event as emit(source, exception).

done_event: Optional[Event]

Sub event that emits when this event is done as emit(source).

name()[source]

This event’s name.

Return type:

str

done()[source]

True if event has ended with no more emits coming, False otherwise.

Return type:

bool

set_done()[source]

Set this event to be ended. The event should not emit anything after that.

value()[source]

This event’s last emitted value.

connect(listener, error=None, done=None, keep_ref=False)[source]

Connect a listener to this event. If the listener is added multiple times then it is invoked just as many times on emit.

The += operator can be used as a synonym for this method:

import eventkit as ev

def f(a, b):
    print(a * b)

def g(a, b):
    print(a / b)

event = ev.Event()
event += f
event += g
event.emit(10, 5)
Parameters:

  • listener – The callback to invoke on emit of this event. It gets the *args from an emit as arguments. If the listener is a coroutine function, or a function that returns an awaitable, the awaitable is run in the asyncio event loop.

  • error – The callback to invoke on error of this event. It gets (this event, exception) as two arguments.

  • done – The callback to invoke on ending of this event. It gets this event as single argument.

  • keep_ref (bool) –

    • True: A strong reference to the callable is kept

    • False: If the callable allows weak refs and it is garbage collected, then it is automatically disconnected from this event.

Return type:

Event

disconnect(listener, error=None, done=None)[source]

Disconnect a listener from this event.

The -= operator can be used as a synonym for this method.

Parameters:

  • listener – The callback to disconnect. The callback is removed at most once. It is valid if the callback is already not connected.

  • error – The error callback to disconnect.

  • done – The done callback to disconnect.

disconnect_obj(obj)[source]

Disconnect all listeners on the given object. (also the error and done listeners).

Parameters:

obj – The target object that is to be completely removed from this event.

emit(*args)[source]

Emit a new value to all connected listeners.

Parameters:

args – Argument values to emit to listeners.

emit_threadsafe(*args)[source]

Threadsafe version of emit() that doesn’t invoke the listeners directly but via the event loop of the main thread.

clear()[source]

Disconnect all listeners.

run()[source]

Start the asyncio event loop, run this event to completion and return all values as a list:

import eventkit as ev

ev.Timer(0.25, count=10).run()
->
[0.25, 0.5, 0.75, 1.0, 1.25, 1.5, 1.75, 2.0, 2.25, 2.5]

Note

When running inside a Jupyter notebook this will give an error that the asyncio event loop is already running. This can be remedied by applying nest_asyncio or by using the top-level await statement of Jupyter:

await event.list()
Return type:

List

pipe(*targets)[source]

Form several events into a pipe:

import eventkit as ev

e1 = ev.Sequence('abcde')
e2 = ev.Enumerate().map(lambda i, c: (i, i + ord(c)))
e3 = ev.Star().pluck(1).map(chr)

e1.pipe(e2, e3)     # or: ev.Event.Pipe(e1, e2, e3)
->
['a', 'c', 'e', 'g', 'i']
Parameters:

targets (Event) – One or more Events that have no source yet, or Event constructors that needs no arguments.

fork(*targets)[source]

Fork this event into one or more target events. Square brackets can be used as a synonym:

import eventkit as ev

ev.Range(2, 5)[ev.Min, ev.Max, ev.Sum].zip()
->
[(2, 2, 2), (2, 3, 5), (2, 4, 9)]

The events in the fork can be combined by one of the join methods of Fork.

Parameters:

targets (Event) – One or more events that have no source yet, or Event constructors that need no arguments.

Return type:

Fork

async aiter(skip_to_last=False, tuples=False)[source]

Create an asynchronous iterator that yields the emitted values from this event:

async def coro():
    async for args in event.aiter():
        ...

__aiter__() is a synonym for aiter() with default arguments,

Parameters:

  • skip_to_last (bool) –

    • True: Backlogged source values are skipped over to yield only the latest value. Can be used as a slipper clutch between a source that produces too fast and the handling that can’t keep up.

    • False: All events are yielded.

  • tuples (bool) –

    • True: Always yield arguments as a tuple.

    • False: Unpack single argument tuples.

static init(obj, event_names)[source]

Convenience function for initializing multiple events as members of the given object.

Parameters:

event_names (Iterable) – Names to use for the created events.

static create(obj)[source]

Create an event from a async iterator, awaitable, or event constructor without arguments.

Parameters:

obj – The source object. If it’s already an event then it is passed as-is.

static wait(future)[source]

Create a new event that emits the value of the awaitable when it becomes available and then set this event done.

wait() and __await__() are each other’s inverse.

Parameters:

future (Awaitable) – Future to wait on.

Return type:

Wait

static aiterate(ait)[source]

Create a new event that emits the yielded values from the asynchronous iterator.

The asynchronous iterator serves as a source for both the time and value of emits.

aiterate() and __aiter__() are each other’s inverse.

Parameters:

ait (AsyncIterable) –

The asynchronous source iterator. It must await at least once; If necessary use:

await asyncio.sleep(0)

Return type:

Aiterate

static sequence(values, interval=0, times=None)[source]

Create a new event that emits the given values. Supply at most one interval or times.

Parameters:

  • values (Iterable) – The source values.

  • interval (float) – Time interval in seconds between values.

  • times (Optional[Iterable[float]]) – Relative times for individual values, in seconds since start of event. The sequence should match values.

Return type:

Sequence

static repeat(value=<NoValue>, count=1, interval=0, times=None)[source]

Create a new event that repeats value a number of count times.

Parameters:

  • value – The value to emit.

  • count – Number of times to emit.

  • interval (float) – Time interval in seconds between values.

  • times (Optional[Iterable[float]]) – Relative times for individual values, in seconds since start of event. The sequence should match values.

Return type:

Repeat

static range(*args, interval=0, times=None)[source]

Create a new event that emits the values from a range.

Parameters:

  • args – Same as for built-in range.

  • interval (float) – Time interval in seconds between values.

  • times (Optional[Iterable[float]]) – Relative times for individual values, in seconds since start of event. The sequence should match the range.

Return type:

Range

static timerange(start=0, end=None, step=1)[source]

Create a new event that emits the datetime value, at that datetime, from a range of datetimes.

Parameters:

  • start –

    Start time, can be specified as:

    • datetime.datetime.

    • datetime.time: Today is used as date.

    • int or float: Number of seconds relative to now. Values will be quantized to the given step.

  • end –

    End time, can be specified as:

    • datetime.datetime.

    • datetime.time: Today is used as date.

    • None: No end limit.

  • step – Number of seconds, or datetime.timedelta, to space between values.

Return type:

Timerange

static timer(interval, count=None)[source]

Create a new timer event that emits at regularly paced intervals the number of seconds since starting it.

Parameters:

  • interval (float) – Time interval in seconds between emits.

  • count (Optional[int]) – Number of times to emit, or None for no limit.

Return type:

Timer

static marble(s, interval=0, times=None)[source]

Create a new event that emits the values from a Rx-type marble string.

Parameters:

  • s (str) – The string with characters that are emitted.

  • interval (float) – Time interval in seconds between values.

  • times (Optional[Iterable[float]]) – Relative times for individual values, in seconds since start of event. The sequence should match the marble string.

Return type:

Marble

filter(predicate=<class 'bool'>)[source]

For every source value, apply predicate and re-emit when True.

Parameters:

predicate – The function to test every source value with. The default is to test the general truthiness with bool().

Return type:

Filter

skip(count=1)[source]

Drop the first count values from source and follow the source after that.

Parameters:

count (int) – Number of source values to drop.

Return type:

Skip

take(count=1)[source]

Re-emit first count values from the source and then end.

Parameters:

count (int) – Number of source values to re-emit.

Return type:

Take

takewhile(predicate=<class 'bool'>)[source]

Re-emit values from the source until the predicate becomes False and then end.

Parameters:

predicate – The function to test every source value with. The default is to test the general truthiness with bool().

Return type:

TakeWhile

dropwhile(predicate=<function Event.<lambda>>)[source]

Drop source values until the predicate becomes False and after that re-emit everything from the source.

Parameters:

predicate – The function to test every source value with. The default is to test the inverted general truthiness.

Return type:

DropWhile

takeuntil(notifier)[source]

Re-emit values from the source until the notifier emits and then end. If the notifier ends without any emit then keep passing source values.

Parameters:

notifier (Event) – Event that signals to end this event.

Return type:

TakeUntil

constant(constant)[source]

On emit of the source emit a constant value:

emit(value) -> emit(constant)
Parameters:

constant – The constant value to emit.

Return type:

Constant

iterate(it)[source]

On emit of the source, emit the next value from an iterator:

emit(a, b, ...) -> emit(next(it))

The time of events follows the source and the values follow the iterator.

Parameters:

it – The source iterator to use for generating values. When the iterator is exhausted the event is set to be done.

Return type:

Iterate

count(start=0, step=1)[source]

Count and emit the number of source emits:

emit(a, b, ...) -> emit(count)
Parameters:

  • start – Start count.

  • step – Add count by this amount for every new source value.

Return type:

Count

enumerate(start=0, step=1)[source]

Add a count to every source value:

emit(a, b, ...) -> emit(count, a, b, ...)
Parameters:

  • start – Start count.

  • step – Increase by this amount for every new source value.

Return type:

Enumerate

timestamp()[source]

Add a timestamp (from time.time()) to every source value:

emit(a, b, ...) -> emit(timestamp, a, b, ...)

The timestamp is the float number in seconds since the midnight Jan 1, 1970 epoch.

Return type:

Timestamp

partial(*left_args)[source]

Pad source values with extra arguments on the left:

emit(a, b, ...) -> emit(*left_args, a, b, ...)
Parameters:

left_args – Arguments to inject.

Return type:

Partial

partial_right(*right_args)[source]

Pad source values with extra arguments on the right:

emit(a, b, ...) -> emit(a, b, ..., *right_args)
Parameters:

right_args – Arguments to inject.

Return type:

PartialRight

star()[source]

Unpack a source tuple into positional arguments, similar to the star operator:

emit((a, b, ...)) -> emit(a, b, ...)

star() and pack() are each other’s inverse.

Return type:

Star

pack()[source]

Pack positional arguments into a tuple:

emit(a, b, ...) -> emit((a, b, ...))

star() and pack() are each other’s inverse.

Return type:

Pack

pluck(*selections)[source]

Extract arguments or nested properties from the source values.

Select which argument positions to keep:

emit(a, b, c, d).pluck(1, 2) -> emit(b, c)

Re-order arguments:

emit(a, b, c).pluck(2, 1, 0) -> emit(c, b, a)

To do an empty emit leave selections empty:

emit(a, b).pluck() -> emit()

Select nested properties from positional arguments:

emit(person, account).pluck(
    '1.number', '0.address.street') ->

emit(account.number, person.address.street)

If no value can be extracted then NO_VALUE is emitted in its place.

Parameters:

selections (Union[int, str]) – The values to extract.

Return type:

Pluck

map(func, timeout=None, ordered=True, task_limit=None)[source]

Apply a sync or async function to source values using positional arguments:

emit(a, b, ...) -> emit(func(a, b, ...))

or if func returns an awaitable then it will be awaited:

emit(a, b, ...) -> emit(await func(a, b, ...))

In case of timeout or other failure, NO_VALUE is emitted.

Parameters:

  • func – The function or coroutine constructor to apply.

  • timeout – Timeout in seconds since coroutine is started

  • ordered –

    • True: The order of emitted results preserves the order of the source values.

    • False: Results are in order of completion.

  • task_limit – Max number of concurrent tasks, or None for no limit.

timeout, ordered and task_limit apply to async functions only.

Return type:

Map

emap(constr, joiner)[source]

Higher-order event map that creates a new Event instance for every source value:

emit(a, b, ...) -> new Event constr(a, b, ...)
Parameters:

  • constr – Constructor function for creating a new event. Apart from returning an Event, the constructor may also return an awaitable or an asynchronous iterator, in which case an Event will be created.

  • joiner (AddableJoinOp) – Join operator to combine the emits of nested events.

Return type:

Emap

mergemap(constr)[source]

emap() that uses merge() to combine the nested events:

marbles = [
    'A   B    C    D',
    '_1   2  3    4',
    '__K   L     M   N']

ev.Range(3).mergemap(lambda v: ev.Marble(marbles[v]))
->
['A', '1', 'K', 'B', '2', 'L', '3', 'C', 'M', '4', 'D', 'N']
Return type:

Mergemap

concatmap(constr)[source]

emap() that uses concat() to combine the nested events:

marbles = [
    'A    B    C    D',
    '_       1    2    3    4',
    '__                  K    L      M   N']

ev.Range(3).concatmap(lambda v: ev.Marble(marbles[v]))
->
['A', 'B', '1', '2', '3', 'K', 'L', 'M', 'N']
Return type:

Concatmap

chainmap(constr)[source]

emap() that uses chain() to combine the nested events:

marbles = [
    'A    B    C    D           ',
    '_       1    2    3    4',
    '__                  K    L      M   N']

ev.Range(3).chainmap(lambda v: ev.Marble(marbles[v]))
->
['A', 'B', 'C', 'D', '1', '2', '3', '4', 'K', 'L', 'M', 'N']
Return type:

Chainmap

switchmap(constr)[source]

emap() that uses switch() to combine the nested events:

marbles = [
    'A    B    C    D           ',
    '_                 K    L      M   N',
    '__      1    2      3    4'
]
ev.Range(3).switchmap(lambda v: Event.marble(marbles[v]))
->
['A', 'B', '1', '2', 'K', 'L', 'M', 'N'])
Return type:

Switchmap

reduce(func, initializer=<NoValue>)[source]

Apply a two-argument reduction function to the previous reduction result and the current value and emit the new reduction result.

Parameters:

  • func –

    Reduction function:

    emit(args) -> emit(func(prev_args, args))

  • initializer –

    First argument of first reduction:

    first_result = func(initializer, first_value)

    If no initializer is given, then the first result is emitted on the second source emit.

Return type:

Reduce

min()[source]

Minimum value.

Return type:

Min

max()[source]

Maximum value.

Return type:

Max

sum(start=0)[source]

Total sum.

Parameters:

start – Value added to total sum.

Return type:

Sum

product(start=1)[source]

Total product.

Parameters:

start – Initial start value.

Return type:

Product

mean()[source]

Total average.

Return type:

Mean

any()[source]

Test if predicate holds for at least one source value.

Return type:

Any

all()[source]

Test if predicate holds for all source values.

Return type:

All

ema(n=None, weight=None)[source]

Exponential moving average.

Parameters:

  • n (Optional[int]) – Number of periods.

  • weight (Optional[float]) – Weight of new value.

Give either n or weight. The relation is weight = 2 / (n + 1).

Return type:

Ema

previous(count=1)[source]

For every source value, emit the count-th previous value:

source:  -ab---c--d-e-
output:  --a---b--c-d-

Starts emitting on the count + 1-th source emit.

Parameters:

count (int) – Number of periods to go back.

Return type:

Previous

pairwise()[source]

Emit (previous_source_value, current_source_value) tuples. Starts emitting on the second source emit:

source:  -a----b------c--------d-----
output:  ------(a,b)--(b,c)----(c,d)-
Return type:

Pairwise

changes()[source]

Emit only source values that have changed from the previous value.

Return type:

Changes

unique(key=None)[source]

Emit only unique values, dropping values that have already been emitted.

Parameters:

key – The callable `’key(value)` is used to group values. The default of None groups values by equality. The resulting group must be hashable.

Return type:

Unique

last()[source]

Wait until source has ended and re-emit its last value.

Return type:

Last

list()[source]

Collect all source values and emit as list when the source ends.

Return type:

List

deque(count=0)[source]

Emit a deque with the last count values from the source (or less in the lead-in phase).

Parameters:

count – Number of last periods to use, or 0 to use all.

Return type:

Deque

array(count=0)[source]

Emit a numpy array with the last count values from the source (or less in the lead-in phase).

Parameters:

count – Number of last periods to use, or 0 to use all.

Return type:

Array

chunk(size)[source]

Chunk values up in lists of equal size. The last chunk can be shorter.

Parameters:

size (int) – Chunk size.

Return type:

Chunk

chunkwith(timer, emit_empty=True)[source]

Emit a chunked list of values when the timer emits.

Parameters:

  • timer (Event) – Event to use for timing the chunks.

  • emit_empty (bool) – Emit empty list if no values present since last emit.

Return type:

ChunkWith

chain(*sources)[source]

Re-emit from a source until it ends, then move to the next source, Repeat until all sources have ended, ending the chain. Emits from pending sources are queued up:

source 1:  -a----b---c|
source 2:        --2-----3--4|
source 3:  ------------x---------y--|
output:    -a----b---c2--3--4x---y--|
Parameters:

sources (Event) – Source events.

Return type:

Chain

merge(*sources)[source]

Re-emit everything from the source events:

source 1:  -a----b-------------c------d-|
source 2:     ------1-----2------3--4-|
source 3:      --------x----y--|
output:    -a----b--1--x--2-y--c-3--4-d-|
Parameters:

sources – Source events.

Return type:

Merge

concat(*sources)[source]

Re-emit everything from one source until it ends and then move to the next source:

source 1:  -a----b-----|
source 2:    --1-----2-----3----4--|
source 3:                 -----------x--y--|
output:    -a----b---------3----4----x--y--|
Parameters:

sources – Source events.

Return type:

Concat

switch(*sources)[source]

Re-emit everything from one source and move to another source as soon as that other source starts to emit:

source 1:  -a----b---c-----d---|
source 2:        -----------x---y-|
source 3:  ---------1----2----3-----|
output:    -a----b--1----2--x---y---|
Parameters:

sources – Source events.

Return type:

Switch

zip(*sources)[source]

Zip sources together: The i-th emit has the i-th value from each source as positional arguments. Only emits when each source has emtted its i-th value and ends when any source ends:

source 1:    -a----b------------------c------d---e--f---|
source 2:    --------1-------2-------3---------4-----|
output emit: --------(a,1)---(b,2)----(c,3)----(d,4)-|
Parameters:

sources – Source events.

Return type:

Zip

ziplatest(*sources, partial=True)[source]

Emit zipped values with the latest value from each of the source events. Emits every time when a source emits:

source 1:   -a-------------------b-------c---|
source 2:   ---------------1--------------------2------|
output emit: (a,NoValue)---(a,1)-(b,1)---(c,1)--(c,2)--|
Parameters:

  • sources – Source events.

  • partial (bool) –

    • True: Use NoValue for sources that have not emitted yet.

    • False: Wait until all sources have emitted.

Return type:

Ziplatest

delay(delay)[source]

Time-shift all source events by a delay:

source:  -abc-d-e---f---|
output:  ---abc-d-e---f---|

This applies to the source errors and the source done event as well.

Parameters:

delay – Time delay of all events (in seconds).

Return type:

Delay

timeout(timeout)[source]

When the source doesn’t emit for longer than the timeout period, do an empty emit and set this event as done.

Parameters:

timeout – Timeout value.

Return type:

Timeout

throttle(maximum, interval, cost_func=None)[source]

Limit number of emits per time without dropping values. Values that come in too fast are queued and re-emitted as soon as allowed by the limits.

A nested status_event emits True when throttling starts and False when throttling ends.

The limit can be dynamically changed with set_limit.

Parameters:

  • maximum – Maximum payload per interval.

  • interval – Time interval (in seconds).

  • cost_func – The sum of cost_func(value) for every source value inside the interval that is to remain under the maximum. The default is to count every source value as 1.

Return type:

Throttle

debounce(delay, on_first=False)[source]

Filter out values from the source that happen in rapid succession.

Parameters:

  • delay – Maximal time difference (in seconds) between successive values before debouncing kicks in.

  • on_first (bool) –

    • True: First value is send immediately and following values in the rapid succession are dropped:

      source: -abcd----efg-
output: -a-------e---

    • False: Last value of a rapid succession is send after the delay and the values before that are dropped:

      source:  -abcd----efg--
output:   ----d------g-

Return type:

Debounce

copy()[source]

Create a shallow copy of the source values.

Return type:

Copy

deepcopy()[source]

Create a deep copy of the source values.

Return type:

Deepcopy

sample(timer)[source]

At the times that the timer emits, sample the value from this event and emit the sample.

Parameters:

timer (Event) – Event used to time the samples.

Return type:

Sample

errors()[source]

Emit errors from the source.

Return type:

Errors

end_on_error()[source]

End on any error from the source.

Return type:

EndOnError

Op

Create

Select

Transform

Aggregate

Combine

Timing

Array

Misc

Util

================================================ FILE: docs/html/genindex.html ================================================ Index — eventkit 1.0.1 documentation
  • Index

Index

_ | A | C | D | E | F | I | L | M | N | P | R | S | T | U | V | W | Z

_

A

C

D

E

F

I

L

M

N

P

R

S

T

U

V

W

Z

================================================ FILE: docs/html/index.html ================================================ Introduction — eventkit 1.0.1 documentation

Build PyPi Documentation

Introduction

The primary use cases of eventkit are

  • to send events between loosely coupled components;

  • to compose all kinds of event-driven data pipelines.

The interface is kept as Pythonic as possible, with familiar names from Python and its libraries where possible. For scheduling asyncio is used and there is seamless integration with it.

See the examples and the introduction notebook to get a true feel for the possibilities.

Installation

pip3 install eventkit

Python version 3.6 or higher is required.

Examples

Create an event and connect two listeners

import eventkit as ev

def f(a, b):
    print(a * b)

def g(a, b):
    print(a / b)

event = ev.Event()
event += f
event += g
event.emit(10, 5)

Create a simple pipeline

import eventkit as ev

event = (
    ev.Sequence('abcde')
    .map(str.upper)
    .enumerate()
)

print(event.run())  # in Jupyter: await event.list()

Output:

[(0, 'A'), (1, 'B'), (2, 'C'), (3, 'D'), (4, 'E')]

Create a pipeline to get a running average and standard deviation

import random
import eventkit as ev

source = ev.Range(1000).map(lambda i: random.gauss(0, 1))

event = source.array(500)[ev.ArrayMean, ev.ArrayStd].zip()

print(event.last().run())  # in Jupyter: await event.last()

Output:

[(0.00790957852672618, 1.0345673260655333)]

Combine async iterators together

import asyncio
import eventkit as ev

async def ait(r):
    for i in r:
        await asyncio.sleep(0.1)
        yield i

async def main():
    async for t in ev.Zip(ait('XYZ'), ait('123')):
        print(t)

asyncio.get_event_loop().run_until_complete(main())  # in Jupyter: await main()

Output:

('X', '1')
('Y', '2')
('Z', '3')

Real-time video analysis pipeline

self.video = VideoStream(conf.CAM_ID)
scene = self.video | FaceTracker | SceneAnalyzer
lastScene = scene.aiter(skip_to_last=True)
async for frame, persons in lastScene:
    ...

Full source code

Distributed computing

The distex library provides a poolmap extension method to put multiple cores or machines to use:

from distex import Pool
import eventkit as ev
import bz2

pool = Pool()
# await pool  # un-comment in Jupyter
data = [b'A' * 1000000] * 1000

pipe = ev.Sequence(data).poolmap(pool, bz2.compress).map(len).mean().last()

print(pipe.run())  # in Jupyter: print(await pipe)
pool.shutdown()

Inspired by:

Documentation

The complete API documentation.

================================================ FILE: docs/html/py-modindex.html ================================================ Python Module Index — eventkit 1.0.1 documentation
  • Python Module Index
================================================ FILE: docs/html/search.html ================================================ Search — eventkit 1.0.1 documentation
  • Search
================================================ FILE: docs/html/searchindex.js ================================================ Search.setIndex({"docnames": ["api", "index"], "filenames": ["api.rst", "index.rst"], "titles": ["eventkit", "Introduction"], "terms": {"releas": 0, "0": [0, 1], "8": [], "9": 0, "class": 0, "name": [0, 1], "_with_error_done_ev": 0, "true": [0, 1], "sourc": [0, 1], "enabl": 0, "pass": 0, "between": [0, 1], "loos": [0, 1], "coupl": [0, 1], "compon": [0, 1], "The": [0, 1], "emit": [0, 1], "valu": 0, "connect": [0, 1], "listen": [0, 1], "ha": 0, "oper": 0, "gener": 0, "data": [0, 1], "flow": 0, "pipelin": [0, 1], "paramet": 0, "str": [0, 1], "us": [0, 1], "thi": 0, "__await__": 0, "asynchron": 0, "await": [0, 1], "next": 0, "an": [0, 1], "async": [0, 1], "def": [0, 1], "coro": 0, "arg": 0, "If": 0, "doe": 0, "empti": 0, "i": [0, 1], "set": 0, "no_valu": 0, "wait": 0, "ar": [0, 1], "each": 0, "other": 0, "": 0, "invers": 0, "__aiter__": 0, "skip_to_last": [0, 1], "fals": 0, "tupl": 0, "synonym": 0, "aiter": [0, 1], "default": 0, "argument": 0, "error_ev": 0, "sub": 0, "error": 0, "from": [0, 1], "except": 0, "done_ev": 0, "when": 0, "done": 0, "return": 0, "type": 0, "end": 0, "more": 0, "come": 0, "otherwis": 0, "bool": 0, "set_don": 0, "should": 0, "anyth": 0, "after": 0, "last": [0, 1], "none": 0, "keep_ref": 0, "ad": 0, "multipl": [0, 1], "invok": 0, "just": 0, "mani": 0, "can": 0, "method": [0, 1], "import": [0, 1], "ev": [0, 1], "f": [0, 1], "b": [0, 1], "print": [0, 1], "g": [0, 1], "10": [0, 1], "5": [0, 1], "callback": 0, "It": 0, "get": [0, 1], "coroutin": 0, "function": 0, "run": [0, 1], "asyncio": [0, 1], "loop": 0, "two": [0, 1], "singl": 0, "A": [0, 1], "strong": 0, "refer": 0, "callabl": 0, "kept": [0, 1], "allow": 0, "weak": 0, "ref": 0, "garbag": 0, "collect": 0, "automat": 0, "disconnect": 0, "remov": 0, "most": 0, "onc": 0, "valid": 0, "alreadi": 0, "disconnect_obj": 0, "obj": 0, "all": [0, 1], "given": 0, "object": 0, "also": 0, "target": 0, "complet": [0, 1], "new": 0, "emit_threadsaf": 0, "threadsaf": 0, "version": [0, 1], "doesn": 0, "t": [0, 1], "directli": 0, "via": 0, "main": [0, 1], "thread": 0, "clear": 0, "start": 0, "list": [0, 1], "timer": 0, "25": 0, "count": 0, "75": 0, "1": [0, 1], "2": [0, 1], "insid": 0, "jupyt": [0, 1], "notebook": [0, 1], "give": 0, "remedi": 0, "appli": 0, "nest_asyncio": 0, "top": 0, "level": 0, "statement": 0, "pipe": [0, 1], "form": 0, "sever": 0, "e1": 0, "sequenc": [0, 1], "abcd": [0, 1], "e2": 0, "enumer": [0, 1], "map": [0, 1], "lambda": [0, 1], "c": [0, 1], "ord": 0, "e3": 0, "star": 0, "pluck": 0, "chr": 0, "e": [0, 1], "One": 0, "have": 0, "yet": 0, "constructor": 0, "need": 0, "fork": 0, "one": 0, "squar": 0, "bracket": 0, "rang": [0, 1], "min": 0, "max": 0, "sum": 0, "zip": [0, 1], "3": [0, 1], "4": [0, 1], "join": 0, "iter": [0, 1], "yield": [0, 1], "backlog": 0, "skip": 0, "over": 0, "onli": 0, "latest": 0, "slipper": 0, "clutch": 0, "produc": 0, "too": 0, "fast": 0, "handl": 0, "keep": 0, "up": 0, "alwai": 0, "unpack": 0, "static": 0, "init": 0, "event_nam": 0, "conveni": 0, "initi": 0, "member": 0, "without": 0, "futur": 0, "becom": 0, "avail": 0, "ait": [0, 1], "serv": 0, "both": 0, "asynciter": 0, "must": 0, "least": 0, "necessari": 0, "sleep": [0, 1], "interv": 0, "suppli": 0, "float": 0, "second": 0, "rel": 0, "individu": 0, "sinc": 0, "match": 0, "repeat": 0, "novalu": 0, "number": 0, "same": 0, "built": 0, "timerang": 0, "step": 0, "datetim": 0, "specifi": 0, "todai": 0, "date": 0, "int": 0, "now": 0, "quantiz": 0, "No": 0, "limit": 0, "timedelta": 0, "space": 0, "regularli": 0, "pace": 0, "marbl": 0, "rx": 0, "string": 0, "charact": 0, "filter": 0, "predic": 0, "For": [0, 1], "everi": 0, "re": 0, "test": 0, "truthi": 0, "drop": 0, "first": 0, "follow": 0, "take": 0, "takewhil": 0, "until": 0, "dropwhil": 0, "everyth": 0, "invert": 0, "takeuntil": 0, "notifi": 0, "ani": 0, "signal": [0, 1], "constant": 0, "On": 0, "exhaust": 0, "add": 0, "amount": 0, "increas": 0, "timestamp": 0, "midnight": 0, "jan": 0, "1970": 0, "epoch": 0, "partial": 0, "left_arg": 0, "pad": 0, "extra": 0, "left": 0, "inject": 0, "partial_right": 0, "right_arg": 0, "right": 0, "partialright": 0, "posit": 0, "similar": 0, "pack": 0, "extract": 0, "nest": 0, "properti": 0, "which": 0, "d": [0, 1], "order": 0, "To": 0, "do": 0, "leav": 0, "person": [0, 1], "account": 0, "address": 0, "street": 0, "its": [0, 1], "place": 0, "union": 0, "func": 0, "timeout": 0, "task_limit": 0, "sync": 0, "In": 0, "case": [0, 1], "failur": 0, "result": 0, "preserv": 0, "concurr": 0, "task": 0, "emap": 0, "constr": 0, "joiner": 0, "higher": [0, 1], "instanc": 0, "apart": 0, "mai": 0, "addablejoinop": 0, "mergemap": 0, "merg": 0, "_1": 0, "__k": 0, "l": 0, "m": 0, "n": 0, "v": 0, "k": 0, "concatmap": 0, "concat": 0, "_": 0, "__": 0, "chainmap": 0, "chain": 0, "switchmap": 0, "switch": 0, "reduc": 0, "reduct": 0, "previou": 0, "current": 0, "prev_arg": 0, "first_result": 0, "first_valu": 0, "minimum": 0, "maximum": 0, "total": 0, "product": 0, "mean": [0, 1], "averag": [0, 1], "hold": 0, "ema": 0, "weight": 0, "exponenti": 0, "move": 0, "period": 0, "either": 0, "relat": 0, "th": 0, "ab": 0, "output": [0, 1], "go": 0, "back": 0, "pairwis": 0, "previous_source_valu": 0, "current_source_valu": 0, "chang": 0, "uniqu": 0, "kei": 0, "been": 0, "group": 0, "equal": 0, "hashabl": 0, "dequ": 0, "less": 0, "lead": 0, "phase": 0, "numpi": 0, "chunk": 0, "size": 0, "shorter": 0, "chunkwith": 0, "emit_empti": 0, "present": 0, "pend": 0, "queu": 0, "x": [0, 1], "y": [0, 1], "c2": 0, "4x": 0, "anoth": 0, "soon": 0, "togeth": [0, 1], "emt": 0, "ziplatest": 0, "delai": 0, "shift": 0, "abc": 0, "well": 0, "longer": 0, "than": 0, "throttl": 0, "cost_func": 0, "per": 0, "status_ev": 0, "dynam": 0, "set_limit": 0, "payload": 0, "remain": 0, "under": 0, "debounc": 0, "on_first": 0, "out": 0, "happen": 0, "rapid": 0, "success": 0, "maxim": 0, "differ": 0, "befor": 0, "kick": 0, "send": [0, 1], "immedi": 0, "efg": 0, "copi": 0, "shallow": 0, "deepcopi": 0, "deep": 0, "sampl": 0, "At": 0, "end_on_error": 0, "endonerror": 0, "primari": 1, "eventkit": 1, "event": 1, "compos": 1, "kind": 1, "driven": 1, "interfac": 1, "python": 1, "possibl": 1, "familiar": 1, "librari": 1, "where": 1, "schedul": 1, "seamless": 1, "integr": 1, "see": 1, "feel": 1, "pip3": 1, "6": 1, "requir": 1, "creat": 1, "simpl": 1, "upper": 1, "standard": 1, "deviat": 1, "random": 1, "1000": 1, "gauss": 1, "arrai": 1, "500": 1, "arraymean": 1, "arraystd": 1, "00790957852672618": 1, "0345673260655333": 1, "combin": 1, "r": 1, "xyz": 1, "123": 1, "get_event_loop": 1, "run_until_complet": 1, "z": 1, "real": 1, "time": 1, "video": 1, "analysi": 1, "self": 1, "videostream": 1, "conf": 1, "cam_id": 1, "scene": 1, "facetrack": 1, "sceneanalyz": 1, "lastscen": 1, "frame": 1, "full": 1, "code": 1, "distex": 1, "provid": 1, "poolmap": 1, "extens": 1, "put": 1, "core": 1, "machin": 1, "pool": 1, "bz2": 1, "un": 1, "comment": 1, "1000000": 1, "compress": 1, "len": 1, "shutdown": 1, "qt": 1, "slot": 1, "itertool": 1, "aiostream": 1, "bacon": 1, "aioreact": 1, "reactiv": 1, "underscor": 1, "j": 1, "net": 1, "api": 1, "op": 1, "select": 1, "transform": 1, "aggreg": 1, "misc": 1, "util": 1, "option": 0}, "objects": {"eventkit.event": [[0, 0, 1, "", "Event"]], "eventkit.event.Event": [[0, 1, 1, "", "__aiter__"], [0, 1, 1, "", "__await__"], [0, 1, 1, "", "aiter"], [0, 1, 1, "", "aiterate"], [0, 1, 1, "", "all"], [0, 1, 1, "", "any"], [0, 1, 1, "", "array"], [0, 1, 1, "", "chain"], [0, 1, 1, "", "chainmap"], [0, 1, 1, "", "changes"], [0, 1, 1, "", "chunk"], [0, 1, 1, "", "chunkwith"], [0, 1, 1, "", "clear"], [0, 1, 1, "", "concat"], [0, 1, 1, "", "concatmap"], [0, 1, 1, "", "connect"], [0, 1, 1, "", "constant"], [0, 1, 1, "", "copy"], [0, 1, 1, "", "count"], [0, 1, 1, "", "create"], [0, 1, 1, "", "debounce"], [0, 1, 1, "", "deepcopy"], [0, 1, 1, "", "delay"], [0, 1, 1, "", "deque"], [0, 1, 1, "", "disconnect"], [0, 1, 1, "", "disconnect_obj"], [0, 1, 1, "", "done"], [0, 2, 1, "", "done_event"], [0, 1, 1, "", "dropwhile"], [0, 1, 1, "", "ema"], [0, 1, 1, "", "emap"], [0, 1, 1, "", "emit"], [0, 1, 1, "", "emit_threadsafe"], [0, 1, 1, "", "end_on_error"], [0, 1, 1, "", "enumerate"], [0, 2, 1, "", "error_event"], [0, 1, 1, "", "errors"], [0, 1, 1, "", "filter"], [0, 1, 1, "", "fork"], [0, 1, 1, "", "init"], [0, 1, 1, "", "iterate"], [0, 1, 1, "", "last"], [0, 1, 1, "", "list"], [0, 1, 1, "", "map"], [0, 1, 1, "", "marble"], [0, 1, 1, "", "max"], [0, 1, 1, "", "mean"], [0, 1, 1, "", "merge"], [0, 1, 1, "", "mergemap"], [0, 1, 1, "", "min"], [0, 1, 1, "", "name"], [0, 1, 1, "", "pack"], [0, 1, 1, "", "pairwise"], [0, 1, 1, "", "partial"], [0, 1, 1, "", "partial_right"], [0, 1, 1, "", "pipe"], [0, 1, 1, "", "pluck"], [0, 1, 1, "", "previous"], [0, 1, 1, "", "product"], [0, 1, 1, "", "range"], [0, 1, 1, "", "reduce"], [0, 1, 1, "", "repeat"], [0, 1, 1, "", "run"], [0, 1, 1, "", "sample"], [0, 1, 1, "", "sequence"], [0, 1, 1, "", "set_done"], [0, 1, 1, "", "skip"], [0, 1, 1, "", "star"], [0, 1, 1, "", "sum"], [0, 1, 1, "", "switch"], [0, 1, 1, "", "switchmap"], [0, 1, 1, "", "take"], [0, 1, 1, "", "takeuntil"], [0, 1, 1, "", "takewhile"], [0, 1, 1, "", "throttle"], [0, 1, 1, "", "timeout"], [0, 1, 1, "", "timer"], [0, 1, 1, "", "timerange"], [0, 1, 1, "", "timestamp"], [0, 1, 1, "", "unique"], [0, 1, 1, "", "value"], [0, 1, 1, "", "wait"], [0, 1, 1, "", "zip"], [0, 1, 1, "", "ziplatest"]], "eventkit.ops": [[0, 3, 0, "-", "aggregate"], [0, 3, 0, "-", "array"], [0, 3, 0, "-", "combine"], [0, 3, 0, "-", "create"], [0, 3, 0, "-", "misc"], [0, 3, 0, "-", "op"], [0, 3, 0, "-", "select"], [0, 3, 0, "-", "timing"], [0, 3, 0, "-", "transform"]], "eventkit": [[0, 3, 0, "-", "util"]]}, "objtypes": {"0": "py:class", "1": "py:method", "2": "py:attribute", "3": "py:module"}, "objnames": {"0": ["py", "class", "Python class"], "1": ["py", "method", "Python method"], "2": ["py", "attribute", "Python attribute"], "3": ["py", "module", "Python module"]}, "titleterms": {"eventkit": 0, "event": 0, "op": 0, "creat": 0, "select": 0, "transform": 0, "aggreg": 0, "combin": 0, "time": 0, "arrai": 0, "misc": 0, "util": 0, "introduct": 1, "instal": 1, "exampl": 1, "distribut": 1, "comput": 1, "inspir": 1, "document": 1}, "envversion": {"sphinx.domains.c": 2, "sphinx.domains.changeset": 1, "sphinx.domains.citation": 1, "sphinx.domains.cpp": 8, "sphinx.domains.index": 1, "sphinx.domains.javascript": 2, "sphinx.domains.math": 2, "sphinx.domains.python": 3, "sphinx.domains.rst": 2, "sphinx.domains.std": 2, "sphinx.ext.viewcode": 1, "sphinx": 57}, "alltitles": {"eventkit": [[0, "eventkit"]], "Event": [[0, "event"]], "Op": [[0, "module-eventkit.ops.op"]], "Create": [[0, "module-eventkit.ops.create"]], "Select": [[0, "module-eventkit.ops.select"]], "Transform": [[0, "module-eventkit.ops.transform"]], "Aggregate": [[0, "module-eventkit.ops.aggregate"]], "Combine": [[0, "module-eventkit.ops.combine"]], "Timing": [[0, "module-eventkit.ops.timing"]], "Array": [[0, "module-eventkit.ops.array"]], "Misc": [[0, "module-eventkit.ops.misc"]], "Util": [[0, "module-eventkit.util"]], "Introduction": [[1, "introduction"]], "Installation": [[1, "installation"]], "Examples": [[1, "examples"]], "Distributed computing": [[1, "distributed-computing"]], "Inspired by:": [[1, "inspired-by"]], "Documentation": [[1, "documentation"]]}, "indexentries": {"event (class in eventkit.event)": [[0, "eventkit.event.Event"]], "__aiter__() (eventkit.event.event method)": [[0, "eventkit.event.Event.__aiter__"]], "__await__() (eventkit.event.event method)": [[0, "eventkit.event.Event.__await__"]], "aiter() (eventkit.event.event method)": [[0, "eventkit.event.Event.aiter"]], "aiterate() (eventkit.event.event static method)": [[0, "eventkit.event.Event.aiterate"]], "all() (eventkit.event.event method)": [[0, "eventkit.event.Event.all"]], "any() (eventkit.event.event method)": [[0, "eventkit.event.Event.any"]], "array() (eventkit.event.event method)": [[0, "eventkit.event.Event.array"]], "chain() (eventkit.event.event method)": [[0, "eventkit.event.Event.chain"]], "chainmap() (eventkit.event.event method)": [[0, "eventkit.event.Event.chainmap"]], "changes() (eventkit.event.event method)": [[0, "eventkit.event.Event.changes"]], "chunk() (eventkit.event.event method)": [[0, "eventkit.event.Event.chunk"]], "chunkwith() (eventkit.event.event method)": [[0, "eventkit.event.Event.chunkwith"]], "clear() (eventkit.event.event method)": [[0, "eventkit.event.Event.clear"]], "concat() (eventkit.event.event method)": [[0, "eventkit.event.Event.concat"]], "concatmap() (eventkit.event.event method)": [[0, "eventkit.event.Event.concatmap"]], "connect() (eventkit.event.event method)": [[0, "eventkit.event.Event.connect"]], "constant() (eventkit.event.event method)": [[0, "eventkit.event.Event.constant"]], "copy() (eventkit.event.event method)": [[0, "eventkit.event.Event.copy"]], "count() (eventkit.event.event method)": [[0, "eventkit.event.Event.count"]], "create() (eventkit.event.event static method)": [[0, "eventkit.event.Event.create"]], "debounce() (eventkit.event.event method)": [[0, "eventkit.event.Event.debounce"]], "deepcopy() (eventkit.event.event method)": [[0, "eventkit.event.Event.deepcopy"]], "delay() (eventkit.event.event method)": [[0, "eventkit.event.Event.delay"]], "deque() (eventkit.event.event method)": [[0, "eventkit.event.Event.deque"]], "disconnect() (eventkit.event.event method)": [[0, "eventkit.event.Event.disconnect"]], "disconnect_obj() (eventkit.event.event method)": [[0, "eventkit.event.Event.disconnect_obj"]], "done() (eventkit.event.event method)": [[0, "eventkit.event.Event.done"]], "done_event (eventkit.event.event attribute)": [[0, "eventkit.event.Event.done_event"]], "dropwhile() (eventkit.event.event method)": [[0, "eventkit.event.Event.dropwhile"]], "ema() (eventkit.event.event method)": [[0, "eventkit.event.Event.ema"]], "emap() (eventkit.event.event method)": [[0, "eventkit.event.Event.emap"]], "emit() (eventkit.event.event method)": [[0, "eventkit.event.Event.emit"]], "emit_threadsafe() (eventkit.event.event method)": [[0, "eventkit.event.Event.emit_threadsafe"]], "end_on_error() (eventkit.event.event method)": [[0, "eventkit.event.Event.end_on_error"]], "enumerate() (eventkit.event.event method)": [[0, "eventkit.event.Event.enumerate"]], "error_event (eventkit.event.event attribute)": [[0, "eventkit.event.Event.error_event"]], "errors() (eventkit.event.event method)": [[0, "eventkit.event.Event.errors"]], "eventkit.ops.aggregate": [[0, "module-eventkit.ops.aggregate"]], "eventkit.ops.array": [[0, "module-eventkit.ops.array"]], "eventkit.ops.combine": [[0, "module-eventkit.ops.combine"]], "eventkit.ops.create": [[0, "module-eventkit.ops.create"]], "eventkit.ops.misc": [[0, "module-eventkit.ops.misc"]], "eventkit.ops.op": [[0, "module-eventkit.ops.op"]], "eventkit.ops.select": [[0, "module-eventkit.ops.select"]], "eventkit.ops.timing": [[0, "module-eventkit.ops.timing"]], "eventkit.ops.transform": [[0, "module-eventkit.ops.transform"]], "eventkit.util": [[0, "module-eventkit.util"]], "filter() (eventkit.event.event method)": [[0, "eventkit.event.Event.filter"]], "fork() (eventkit.event.event method)": [[0, "eventkit.event.Event.fork"]], "init() (eventkit.event.event static method)": [[0, "eventkit.event.Event.init"]], "iterate() (eventkit.event.event method)": [[0, "eventkit.event.Event.iterate"]], "last() (eventkit.event.event method)": [[0, "eventkit.event.Event.last"]], "list() (eventkit.event.event method)": [[0, "eventkit.event.Event.list"]], "map() (eventkit.event.event method)": [[0, "eventkit.event.Event.map"]], "marble() (eventkit.event.event static method)": [[0, "eventkit.event.Event.marble"]], "max() (eventkit.event.event method)": [[0, "eventkit.event.Event.max"]], "mean() (eventkit.event.event method)": [[0, "eventkit.event.Event.mean"]], "merge() (eventkit.event.event method)": [[0, "eventkit.event.Event.merge"]], "mergemap() (eventkit.event.event method)": [[0, "eventkit.event.Event.mergemap"]], "min() (eventkit.event.event method)": [[0, "eventkit.event.Event.min"]], "module": [[0, "module-eventkit.ops.aggregate"], [0, "module-eventkit.ops.array"], [0, "module-eventkit.ops.combine"], [0, "module-eventkit.ops.create"], [0, "module-eventkit.ops.misc"], [0, "module-eventkit.ops.op"], [0, "module-eventkit.ops.select"], [0, "module-eventkit.ops.timing"], [0, "module-eventkit.ops.transform"], [0, "module-eventkit.util"]], "name() (eventkit.event.event method)": [[0, "eventkit.event.Event.name"]], "pack() (eventkit.event.event method)": [[0, "eventkit.event.Event.pack"]], "pairwise() (eventkit.event.event method)": [[0, "eventkit.event.Event.pairwise"]], "partial() (eventkit.event.event method)": [[0, "eventkit.event.Event.partial"]], "partial_right() (eventkit.event.event method)": [[0, "eventkit.event.Event.partial_right"]], "pipe() (eventkit.event.event method)": [[0, "eventkit.event.Event.pipe"]], "pluck() (eventkit.event.event method)": [[0, "eventkit.event.Event.pluck"]], "previous() (eventkit.event.event method)": [[0, "eventkit.event.Event.previous"]], "product() (eventkit.event.event method)": [[0, "eventkit.event.Event.product"]], "range() (eventkit.event.event static method)": [[0, "eventkit.event.Event.range"]], "reduce() (eventkit.event.event method)": [[0, "eventkit.event.Event.reduce"]], "repeat() (eventkit.event.event static method)": [[0, "eventkit.event.Event.repeat"]], "run() (eventkit.event.event method)": [[0, "eventkit.event.Event.run"]], "sample() (eventkit.event.event method)": [[0, "eventkit.event.Event.sample"]], "sequence() (eventkit.event.event static method)": [[0, "eventkit.event.Event.sequence"]], "set_done() (eventkit.event.event method)": [[0, "eventkit.event.Event.set_done"]], "skip() (eventkit.event.event method)": [[0, "eventkit.event.Event.skip"]], "star() (eventkit.event.event method)": [[0, "eventkit.event.Event.star"]], "sum() (eventkit.event.event method)": [[0, "eventkit.event.Event.sum"]], "switch() (eventkit.event.event method)": [[0, "eventkit.event.Event.switch"]], "switchmap() (eventkit.event.event method)": [[0, "eventkit.event.Event.switchmap"]], "take() (eventkit.event.event method)": [[0, "eventkit.event.Event.take"]], "takeuntil() (eventkit.event.event method)": [[0, "eventkit.event.Event.takeuntil"]], "takewhile() (eventkit.event.event method)": [[0, "eventkit.event.Event.takewhile"]], "throttle() (eventkit.event.event method)": [[0, "eventkit.event.Event.throttle"]], "timeout() (eventkit.event.event method)": [[0, "eventkit.event.Event.timeout"]], "timer() (eventkit.event.event static method)": [[0, "eventkit.event.Event.timer"]], "timerange() (eventkit.event.event static method)": [[0, "eventkit.event.Event.timerange"]], "timestamp() (eventkit.event.event method)": [[0, "eventkit.event.Event.timestamp"]], "unique() (eventkit.event.event method)": [[0, "eventkit.event.Event.unique"]], "value() (eventkit.event.event method)": [[0, "eventkit.event.Event.value"]], "wait() (eventkit.event.event static method)": [[0, "eventkit.event.Event.wait"]], "zip() (eventkit.event.event method)": [[0, "eventkit.event.Event.zip"]], "ziplatest() (eventkit.event.event method)": [[0, "eventkit.event.Event.ziplatest"]]}}) ================================================ FILE: docs/index.rst ================================================ .. include:: ../README.rst .. toctree:: :maxdepth: 3 api ================================================ FILE: docs/make.bat ================================================ @ECHO OFF pushd %~dp0 REM Command file for Sphinx documentation if "%SPHINXBUILD%" == "" ( set SPHINXBUILD=python3 -msphinx ) set SOURCEDIR=. set BUILDDIR=_build set SPHINXPROJ=distex if "%1" == "" goto help %SPHINXBUILD% >NUL 2>NUL if errorlevel 9009 ( echo. echo.The Sphinx module was not found. Make sure you have Sphinx installed, echo.then set the SPHINXBUILD environment variable to point to the full echo.path of the 'sphinx-build' executable. Alternatively you may add the echo.Sphinx directory to PATH. echo. echo.If you don't have Sphinx installed, grab it from echo.http://sphinx-doc.org/ exit /b 1 ) %SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% goto end :help %SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% :end popd ================================================ FILE: docs/requirements.txt ================================================ sphinxcontrib-napoleon sphinx-autodoc-typehints sphinx-rtd-theme ================================================ FILE: eventkit/__init__.py ================================================ """Event-driven data pipelines.""" from .event import Event from .ops.aggregate import ( All, Any, Count, Deque, Ema, List, Max, Mean, Min, Pairwise, Product, Reduce, Sum) from .ops.array import ( Array, ArrayAll, ArrayAny, ArrayMax, ArrayMean, ArrayMin, ArrayStd, ArraySum) from .ops.combine import ( AddableJoinOp, Chain, Concat, Fork, Merge, Switch, Zip, Ziplatest) from .ops.create import ( Aiterate, Marble, Range, Repeat, Sequence, Timer, Timerange, Wait) from .ops.misc import EndOnError, Errors from .ops.op import Op from .ops.select import ( Changes, DropWhile, Filter, Last, Skip, Take, TakeUntil, TakeWhile, Unique) from .ops.timing import (Debounce, Delay, Sample, Throttle, Timeout) from .ops.transform import ( Chainmap, Chunk, ChunkWith, Concatmap, Constant, Copy, Deepcopy, Emap, Enumerate, Iterate, Map, Mergemap, Pack, Partial, PartialRight, Pluck, Previous, Star, Switchmap, Timestamp) from .version import __version__, __version_info__ ================================================ FILE: eventkit/event.py ================================================ import asyncio import logging import types import weakref from typing import ( Any as AnyType, AsyncIterable, Awaitable, Iterable, List, Optional, Tuple, Union) from .util import NO_VALUE, get_event_loop, main_event_loop class Event: """ Enable event passing between loosely coupled components. The event emits values to connected listeners and has a selection of operators to create general data flow pipelines. Args: name: Name to use for this event. """ __slots__ = ( 'error_event', 'done_event', '_name', '_value', '_slots', '_done', '_source', '__weakref__') NO_VALUE = NO_VALUE logger = logging.getLogger(__name__) error_event: Optional["Event"] done_event: Optional["Event"] _name: str _value: AnyType _slots: List[List] _done: bool _source: Optional["Event"] def __init__(self, name: str = '', _with_error_done_events: bool = True): self.error_event = None """ Sub event that emits errors from this event as ``emit(source, exception)``. """ self.done_event = None """ Sub event that emits when this event is done as ``emit(source)``. """ if _with_error_done_events: self.error_event = Event('error', False) self.done_event = Event('done', False) self._slots = [] # list of [obj, weakref, func] sublists self._name = name or self.__class__.__qualname__ self._value = NO_VALUE self._done = False self._source = None def name(self) -> str: """ This event's name. """ return self._name def done(self) -> bool: """ ``True`` if event has ended with no more emits coming, ``False`` otherwise. """ return self._done def set_done(self): """ Set this event to be ended. The event should not emit anything after that. """ if not self._done: self._done = True self.done_event.emit(self) def value(self): """ This event's last emitted value. """ v = self._value return NO_VALUE if v is NO_VALUE else \ v[0] if len(v) == 1 else v if v else NO_VALUE def connect(self, listener, error=None, done=None, keep_ref: bool = False) -> "Event": """ Connect a listener to this event. If the listener is added multiple times then it is invoked just as many times on emit. The ``+=`` operator can be used as a synonym for this method:: import eventkit as ev def f(a, b): print(a * b) def g(a, b): print(a / b) event = ev.Event() event += f event += g event.emit(10, 5) Args: listener: The callback to invoke on emit of this event. It gets the ``*args`` from an emit as arguments. If the listener is a coroutine function, or a function that returns an awaitable, the awaitable is run in the asyncio event loop. error: The callback to invoke on error of this event. It gets (this event, exception) as two arguments. done: The callback to invoke on ending of this event. It gets this event as single argument. keep_ref: * ``True``: A strong reference to the callable is kept * ``False``: If the callable allows weak refs and it is garbage collected, then it is automatically disconnected from this event. """ if isinstance(listener, Op): # let the operator connect itself to this event listener.set_source(self) return self obj, func = self._split(listener) if not keep_ref and hasattr(obj, '__weakref__'): ref = weakref.ref(obj, self._onFinalize) obj = None else: ref = None slot = [obj, ref, func] self._slots.append(slot) if self.done_event and done is not None: self.done_event.connect(done) if self.error_event and error is not None: self.error_event.connect(error) return self def disconnect(self, listener, error=None, done=None): """ Disconnect a listener from this event. The ``-=`` operator can be used as a synonym for this method. Args: listener: The callback to disconnect. The callback is removed at most once. It is valid if the callback is already not connected. error: The error callback to disconnect. done: The done callback to disconnect. """ obj, func = self._split(listener) for slot in self._slots: if (slot[0] is obj or slot[1] and slot[1]() is obj) \ and slot[2] is func: slot[0] = slot[1] = slot[2] = None break self._slots = [s for s in self._slots if s != [None, None, None]] if error is not None: self.error_event.disconnect(error) if done is not None: self.done_event.disconnect(done) return self def disconnect_obj(self, obj): """ Disconnect all listeners on the given object. (also the error and done listeners). Args: obj: The target object that is to be completely removed from this event. """ for slot in self._slots: if slot[0] is obj or slot[1] and slot[1]() is obj: slot[0] = slot[1] = slot[2] = None self._slots = [s for s in self._slots if s != [None, None, None]] if self.error_event is not None: self.error_event.disconnect_obj(obj) if self.done_event is not None: self.done_event.disconnect_obj(obj) def emit(self, *args): """ Emit a new value to all connected listeners. Args: args: Argument values to emit to listeners. """ self._value = args for obj, ref, func in self._slots.copy(): try: if ref: obj = ref() result = None if obj is None: if func: result = func(*args) else: if func: result = func(obj, *args) else: result = obj(*args) if result and hasattr(result, '__await__'): loop = get_event_loop() asyncio.ensure_future(result, loop=loop) except Exception as error: if len(self.error_event): self.error_event.emit(self, error) else: Event.logger.exception( f'Value {args} caused exception for event {self}') def emit_threadsafe(self, *args): """ Threadsafe version of :meth:`emit` that doesn't invoke the listeners directly but via the event loop of the main thread. """ main_event_loop.call_soon_threadsafe(self.emit, *args) def clear(self): """ Disconnect all listeners. """ for slot in self._slots: slot[0] = slot[1] = slot[2] = None self._slots = [] def run(self) -> List: """ Start the asyncio event loop, run this event to completion and return all values as a list:: import eventkit as ev ev.Timer(0.25, count=10).run() -> [0.25, 0.5, 0.75, 1.0, 1.25, 1.5, 1.75, 2.0, 2.25, 2.5] .. note:: When running inside a Jupyter notebook this will give an error that the asyncio event loop is already running. This can be remedied by applying `nest_asyncio `_ or by using the top-level ``await`` statement of Jupyter:: await event.list() """ loop = get_event_loop() return loop.run_until_complete(self.list()) def pipe(self, *targets: "Event"): """ Form several events into a pipe:: import eventkit as ev e1 = ev.Sequence('abcde') e2 = ev.Enumerate().map(lambda i, c: (i, i + ord(c))) e3 = ev.Star().pluck(1).map(chr) e1.pipe(e2, e3) # or: ev.Event.Pipe(e1, e2, e3) -> ['a', 'c', 'e', 'g', 'i'] Args: targets: One or more Events that have no source yet, or ``Event`` constructors that needs no arguments. """ source = self for t in targets: t = Event.create(t) t.set_source(source) source = t return source def fork(self, *targets: "Event") -> "Fork": """ Fork this event into one or more target events. Square brackets can be used as a synonym:: import eventkit as ev ev.Range(2, 5)[ev.Min, ev.Max, ev.Sum].zip() -> [(2, 2, 2), (2, 3, 5), (2, 4, 9)] The events in the fork can be combined by one of the join methods of ``Fork``. Args: targets: One or more events that have no source yet, or ``Event`` constructors that need no arguments. """ fork = Fork() for t in targets: t = Event.create(t) t.set_source(self) fork.append(t) return fork def set_source(self, source): self._source = source def _onFinalize(self, ref): for slot in self._slots: if slot[1] is ref: slot[0] = slot[1] = slot[2] = None self._slots = [s for s in self._slots if s != [None, None, None]] @staticmethod def _split(c): """ Split given callable in (object, function) tuple. """ if isinstance(c, types.FunctionType): return (None, c) elif isinstance(c, types.MethodType): return (c.__self__, c.__func__) elif isinstance(c, types.BuiltinMethodType): if type(c.__self__) is type: # built-in method return (c.__self__, c) else: # built-in function return (None, c) elif hasattr(c, '__call__'): return (c, None) else: raise ValueError(f'Invalid callable: {c}') async def aiter(self, skip_to_last: bool = False, tuples: bool = False): """ Create an asynchronous iterator that yields the emitted values from this event:: async def coro(): async for args in event.aiter(): ... :meth:`__aiter__` is a synonym for :meth:`aiter` with default arguments, Args: skip_to_last: * ``True``: Backlogged source values are skipped over to yield only the latest value. Can be used as a slipper clutch between a source that produces too fast and the handling that can't keep up. * ``False``: All events are yielded. tuples: * ``True``: Always yield arguments as a tuple. * ``False``: Unpack single argument tuples. """ def on_event(*args): if skip_to_last: while q.qsize(): q.get_nowait() q.put_nowait(('', args)) def on_error(source, error): q.put_nowait(('ERROR', error)) def on_done(source): q.put_nowait(('DONE', None)) if self.done(): return q: asyncio.Queue[Tuple[str, AnyType]] = asyncio.Queue() self.connect(on_event, on_error, on_done) try: while True: what, args = await q.get() if not what: yield args if tuples else args[0] if len(args) == 1 \ else args if args else NO_VALUE elif what == 'ERROR': raise args else: break finally: self.disconnect(on_event, on_error, on_done) __iadd__ = connect __isub__ = disconnect __call__ = emit __or__ = pipe def __repr__(self): return f'Event<{self.name()}, {self._slots}>' def __len__(self): return len(self._slots) def __bool__(self): return True def __getitem__(self, fork_targets) -> "Fork": if not hasattr(fork_targets, '__iter__'): fork_targets = (fork_targets,) return self.fork(*fork_targets) def __await__(self): """ Asynchronously await the next emit of an event:: async def coro(): args = await event ... If the event does an empty ``emit()``, then the value of ``args`` is set to ``util.NO_VALUE``. :meth:`wait` and :meth:`__await__` are each other's inverse. """ def on_event(*args): if not fut.done(): fut.set_result( args[0] if len(args) == 1 else args if args else NO_VALUE) def on_error(source, error): if not fut.done(): fut.set_exception(error) def on_future_done(f): self.disconnect(on_event, on_error) if self.done(): raise ValueError('Event already done') fut = asyncio.Future() self.connect(on_event, on_error) fut.add_done_callback(on_future_done) return fut.__await__() __aiter__ = aiter """ Synonym for :meth:`aiter` with default arguments:: async def coro(): async for args in event: ... :meth:`aiterate` and :meth:`__aiter__` are each other's inverse. """ def __contains__(self, c): """ See if callable is already connected. """ obj, func = self._split(c) return any( (s[0] is obj or s[1] and s[1]() is obj) and s[2] is func for s in self._slots) def __reduce__(self): """ Don't pickle slots. """ with_error_done_event = ( self.error_event is not None or self.done_event is not None) return self.__class__, (self._name, with_error_done_event) @staticmethod def init(obj, event_names: Iterable): """ Convenience function for initializing multiple events as members of the given object. Args: event_names: Names to use for the created events. """ for name in event_names: setattr(obj, name, Event(name)) # dot access to constructors @staticmethod def create(obj): """ Create an event from a async iterator, awaitable, or event constructor without arguments. Args: obj: The source object. If it's already an event then it is passed as-is. """ if isinstance(obj, Event): return obj if hasattr(obj, '__call__'): obj = obj() if isinstance(obj, Event): return obj elif hasattr(obj, '__aiter__'): return Event.aiterate(obj) elif hasattr(obj, '__await__'): return Event.wait(obj) else: raise ValueError(f'Invalid type: {obj}') @staticmethod def wait(future: Awaitable) -> "Wait": """ Create a new event that emits the value of the awaitable when it becomes available and then set this event done. :meth:`wait` and :meth:`__await__` are each other's inverse. Args: future: Future to wait on. """ return Wait(future) @staticmethod def aiterate(ait: AsyncIterable) -> "Aiterate": """ Create a new event that emits the yielded values from the asynchronous iterator. The asynchronous iterator serves as a source for both the time and value of emits. :meth:`aiterate` and :meth:`__aiter__` are each other's inverse. Args: ait: The asynchronous source iterator. It must ``await`` at least once; If necessary use:: await asyncio.sleep(0) """ return Aiterate(ait) @staticmethod def sequence( values: Iterable, interval: float = 0, times: Union[Iterable[float], None] = None) -> "Sequence": """ Create a new event that emits the given values. Supply at most one ``interval`` or ``times``. Args: values: The source values. interval: Time interval in seconds between values. times: Relative times for individual values, in seconds since start of event. The sequence should match ``values``. """ return Sequence(values, interval, times) @staticmethod def repeat( value=NO_VALUE, count=1, interval: float = 0, times: Union[Iterable[float], None] = None) -> "Repeat": """ Create a new event that repeats ``value`` a number of ``count`` times. Args: value: The value to emit. count: Number of times to emit. interval: Time interval in seconds between values. times: Relative times for individual values, in seconds since start of event. The sequence should match ``values``. """ return Repeat(interval, value, count, times) @staticmethod def range( *args, interval: float = 0, times: Union[Iterable[float], None] = None) -> "Range": """ Create a new event that emits the values from a range. Args: args: Same as for built-in ``range``. interval: Time interval in seconds between values. times: Relative times for individual values, in seconds since start of event. The sequence should match the range. """ return Range(*args, interval=interval, times=times) @staticmethod def timerange(start=0, end=None, step=1) -> "Timerange": """ Create a new event that emits the datetime value, at that datetime, from a range of datetimes. Args: start: Start time, can be specified as: * ``datetime.datetime``. * ``datetime.time``: Today is used as date. * ``int`` or ``float``: Number of seconds relative to now. Values will be quantized to the given step. end: End time, can be specified as: * ``datetime.datetime``. * ``datetime.time``: Today is used as date. * ``None``: No end limit. step: Number of seconds, or ``datetime.timedelta``, to space between values. """ return Timerange(start, end, step) @staticmethod def timer(interval: float, count: Union[int, None] = None) -> "Timer": """ Create a new timer event that emits at regularly paced intervals the number of seconds since starting it. Args: interval: Time interval in seconds between emits. count: Number of times to emit, or ``None`` for no limit. """ return Timer(interval, count) @staticmethod def marble( s: str, interval: float = 0, times: Union[Iterable[float], None] = None) -> "Marble": """ Create a new event that emits the values from a Rx-type marble string. Args: s: The string with characters that are emitted. interval: Time interval in seconds between values. times: Relative times for individual values, in seconds since start of event. The sequence should match the marble string. """ return Marble(s, interval, times) # dot access to operators def filter(self, predicate=bool) -> "Filter": """ For every source value, apply predicate and re-emit when True. Args: predicate: The function to test every source value with. The default is to test the general truthiness with ``bool()``. """ return Filter(predicate, self) def skip(self, count: int = 1) -> "Skip": """ Drop the first ``count`` values from source and follow the source after that. Args: count: Number of source values to drop. """ return Skip(count, self) def take(self, count: int = 1) -> "Take": """ Re-emit first ``count`` values from the source and then end. Args: count: Number of source values to re-emit. """ return Take(count, self) def takewhile(self, predicate=bool) -> "TakeWhile": """ Re-emit values from the source until the predicate becomes False and then end. Args: predicate: The function to test every source value with. The default is to test the general truthiness with ``bool()``. """ return TakeWhile(predicate, self) def dropwhile(self, predicate=lambda x: not x) -> "DropWhile": """ Drop source values until the predicate becomes False and after that re-emit everything from the source. Args: predicate: The function to test every source value with. The default is to test the inverted general truthiness. """ return DropWhile(predicate, self) def takeuntil(self, notifier: "Event") -> "TakeUntil": """ Re-emit values from the source until the ``notifier`` emits and then end. If the notifier ends without any emit then keep passing source values. Args: notifier: Event that signals to end this event. """ return TakeUntil(notifier, self) def constant(self, constant) -> "Constant": """ On emit of the source emit a constant value:: emit(value) -> emit(constant) Args: constant: The constant value to emit. """ return Constant(constant, self) def iterate(self, it) -> "Iterate": """ On emit of the source, emit the next value from an iterator:: emit(a, b, ...) -> emit(next(it)) The time of events follows the source and the values follow the iterator. Args: it: The source iterator to use for generating values. When the iterator is exhausted the event is set to be done. """ return Iterate(it, self) def count(self, start=0, step=1) -> "Count": """ Count and emit the number of source emits:: emit(a, b, ...) -> emit(count) Args: start: Start count. step: Add count by this amount for every new source value. """ return Count(start, step, self) def enumerate(self, start=0, step=1) -> "Enumerate": """ Add a count to every source value:: emit(a, b, ...) -> emit(count, a, b, ...) Args: start: Start count. step: Increase by this amount for every new source value. """ return Enumerate(start, step, self) def timestamp(self) -> "Timestamp": """ Add a timestamp (from time.time()) to every source value:: emit(a, b, ...) -> emit(timestamp, a, b, ...) The timestamp is the float number in seconds since the midnight Jan 1, 1970 epoch. """ return Timestamp(self) def partial(self, *left_args) -> "Partial": """ Pad source values with extra arguments on the left:: emit(a, b, ...) -> emit(*left_args, a, b, ...) Args: left_args: Arguments to inject. """ return Partial(*left_args, source=self) def partial_right(self, *right_args) -> "PartialRight": """ Pad source values with extra arguments on the right:: emit(a, b, ...) -> emit(a, b, ..., *right_args) Args: right_args: Arguments to inject. """ return PartialRight(*right_args, source=self) def star(self) -> "Star": """ Unpack a source tuple into positional arguments, similar to the star operator:: emit((a, b, ...)) -> emit(a, b, ...) :meth:`star` and :meth:`pack` are each other's inverse. """ return Star(self) def pack(self) -> "Pack": """ Pack positional arguments into a tuple:: emit(a, b, ...) -> emit((a, b, ...)) :meth:`star` and :meth:`pack` are each other's inverse. """ return Pack(self) def pluck(self, *selections: Union[int, str]) -> "Pluck": """ Extract arguments or nested properties from the source values. Select which argument positions to keep:: emit(a, b, c, d).pluck(1, 2) -> emit(b, c) Re-order arguments:: emit(a, b, c).pluck(2, 1, 0) -> emit(c, b, a) To do an empty emit leave ``selections`` empty:: emit(a, b).pluck() -> emit() Select nested properties from positional arguments:: emit(person, account).pluck( '1.number', '0.address.street') -> emit(account.number, person.address.street) If no value can be extracted then ``NO_VALUE`` is emitted in its place. Args: selections: The values to extract. """ return Pluck(*selections, source=self) def map( self, func, timeout=None, ordered=True, task_limit=None) -> "Map": """ Apply a sync or async function to source values using positional arguments:: emit(a, b, ...) -> emit(func(a, b, ...)) or if ``func`` returns an awaitable then it will be awaited:: emit(a, b, ...) -> emit(await func(a, b, ...)) In case of timeout or other failure, ``NO_VALUE`` is emitted. Args: func: The function or coroutine constructor to apply. timeout: Timeout in seconds since coroutine is started ordered: * ``True``: The order of emitted results preserves the order of the source values. * ``False``: Results are in order of completion. task_limit: Max number of concurrent tasks, or None for no limit. ``timeout``, ``ordered`` and ``task_limit`` apply to async functions only. """ return Map(func, timeout, ordered, task_limit, self) def emap(self, constr, joiner: "AddableJoinOp") -> "Emap": """ Higher-order event map that creates a new ``Event`` instance for every source value:: emit(a, b, ...) -> new Event constr(a, b, ...) Args: constr: Constructor function for creating a new event. Apart from returning an ``Event``, the constructor may also return an awaitable or an asynchronous iterator, in which case an ``Event`` will be created. joiner: Join operator to combine the emits of nested events. """ return Emap(constr, joiner, self) def mergemap(self, constr) -> "Mergemap": """ :meth:`emap` that uses :meth:`merge` to combine the nested events:: marbles = [ 'A B C D', '_1 2 3 4', '__K L M N'] ev.Range(3).mergemap(lambda v: ev.Marble(marbles[v])) -> ['A', '1', 'K', 'B', '2', 'L', '3', 'C', 'M', '4', 'D', 'N'] """ return Mergemap(constr, self) def concatmap(self, constr) -> "Concatmap": """ :meth:`emap` that uses :meth:`concat` to combine the nested events:: marbles = [ 'A B C D', '_ 1 2 3 4', '__ K L M N'] ev.Range(3).concatmap(lambda v: ev.Marble(marbles[v])) -> ['A', 'B', '1', '2', '3', 'K', 'L', 'M', 'N'] """ return Concatmap(constr, self) def chainmap(self, constr) -> "Chainmap": """ :meth:`emap` that uses :meth:`chain` to combine the nested events:: marbles = [ 'A B C D ', '_ 1 2 3 4', '__ K L M N'] ev.Range(3).chainmap(lambda v: ev.Marble(marbles[v])) -> ['A', 'B', 'C', 'D', '1', '2', '3', '4', 'K', 'L', 'M', 'N'] """ return Chainmap(constr, self) def switchmap(self, constr) -> "Switchmap": """ :meth:`emap` that uses :meth:`switch` to combine the nested events:: marbles = [ 'A B C D ', '_ K L M N', '__ 1 2 3 4' ] ev.Range(3).switchmap(lambda v: Event.marble(marbles[v])) -> ['A', 'B', '1', '2', 'K', 'L', 'M', 'N']) """ return Switchmap(constr, self) def reduce(self, func, initializer=NO_VALUE) -> "Reduce": """ Apply a two-argument reduction function to the previous reduction result and the current value and emit the new reduction result. Args: func: Reduction function:: emit(args) -> emit(func(prev_args, args)) initializer: First argument of first reduction:: first_result = func(initializer, first_value) If no initializer is given, then the first result is emitted on the second source emit. """ return Reduce(func, initializer, self) def min(self) -> "Min": """ Minimum value. """ return Min(self) def max(self) -> "Max": """ Maximum value. """ return Max(self) def sum(self, start=0) -> "Sum": """ Total sum. Args: start: Value added to total sum. """ return Sum(start, self) def product(self, start=1) -> "Product": """ Total product. Args: start: Initial start value. """ return Product(start, self) def mean(self) -> "Mean": """ Total average. """ return Mean(self) def any(self) -> "Any": """ Test if predicate holds for at least one source value. """ return Any(self) def all(self) -> "All": """ Test if predicate holds for all source values. """ return All(self) def ema(self, n: Union[int, None] = None, weight: Union[float, None] = None) -> "Ema": """ Exponential moving average. Args: n: Number of periods. weight: Weight of new value. Give either ``n`` or ``weight``. The relation is ``weight = 2 / (n + 1)``. """ return Ema(n, weight, self) def previous(self, count: int = 1) -> "Previous": """ For every source value, emit the ``count``-th previous value:: source: -ab---c--d-e- output: --a---b--c-d- Starts emitting on the ``count + 1``-th source emit. Args: count: Number of periods to go back. """ return Previous(count, self) def pairwise(self) -> "Pairwise": """ Emit ``(previous_source_value, current_source_value)`` tuples. Starts emitting on the second source emit:: source: -a----b------c--------d----- output: ------(a,b)--(b,c)----(c,d)- """ return Pairwise(self) def changes(self) -> "Changes": """ Emit only source values that have changed from the previous value. """ return Changes(self) def unique(self, key=None) -> "Unique": """ Emit only unique values, dropping values that have already been emitted. Args: key: `The callable `'key(value)`` is used to group values. The default of ``None`` groups values by equality. The resulting group must be hashable. """ return Unique(key, self) def last(self) -> "Last": """ Wait until source has ended and re-emit its last value. """ return Last(self) def list(self) -> "ListOp": """ Collect all source values and emit as list when the source ends. """ return ListOp(self) def deque(self, count=0) -> "Deque": """ Emit a ``deque`` with the last ``count`` values from the source (or less in the lead-in phase). Args: count: Number of last periods to use, or 0 to use all. """ return Deque(count, self) def array(self, count=0) -> "Array": """ Emit a numpy array with the last ``count`` values from the source (or less in the lead-in phase). Args: count: Number of last periods to use, or 0 to use all. """ return Array(count, self) def chunk(self, size: int) -> "Chunk": """ Chunk values up in lists of equal size. The last chunk can be shorter. Args: size: Chunk size. """ return Chunk(size, self) def chunkwith( self, timer: "Event", emit_empty: bool = True) -> "ChunkWith": """ Emit a chunked list of values when the timer emits. Args: timer: Event to use for timing the chunks. emit_empty: Emit empty list if no values present since last emit. """ return ChunkWith(timer, emit_empty, self) def chain(self, *sources: "Event") -> "Chain": """ Re-emit from a source until it ends, then move to the next source, Repeat until all sources have ended, ending the chain. Emits from pending sources are queued up:: source 1: -a----b---c| source 2: --2-----3--4| source 3: ------------x---------y--| output: -a----b---c2--3--4x---y--| Args: sources: Source events. """ return Chain(self, *sources) def merge(self, *sources) -> "Merge": """ Re-emit everything from the source events:: source 1: -a----b-------------c------d-| source 2: ------1-----2------3--4-| source 3: --------x----y--| output: -a----b--1--x--2-y--c-3--4-d-| Args: sources: Source events. """ return Merge(self, *sources) def concat(self, *sources) -> "Concat": """ Re-emit everything from one source until it ends and then move to the next source:: source 1: -a----b-----| source 2: --1-----2-----3----4--| source 3: -----------x--y--| output: -a----b---------3----4----x--y--| Args: sources: Source events. """ return Concat(self, *sources) def switch(self, *sources) -> "Switch": """ Re-emit everything from one source and move to another source as soon as that other source starts to emit:: source 1: -a----b---c-----d---| source 2: -----------x---y-| source 3: ---------1----2----3-----| output: -a----b--1----2--x---y---| Args: sources: Source events. """ return Switch(self, *sources) def zip(self, *sources) -> "Zip": """ Zip sources together: The i-th emit has the i-th value from each source as positional arguments. Only emits when each source has emtted its i-th value and ends when any source ends:: source 1: -a----b------------------c------d---e--f---| source 2: --------1-------2-------3---------4-----| output emit: --------(a,1)---(b,2)----(c,3)----(d,4)-| Args: sources: Source events. """ return Zip(self, *sources) def ziplatest(self, *sources, partial: bool = True) -> "Ziplatest": """ Emit zipped values with the latest value from each of the source events. Emits every time when a source emits:: source 1: -a-------------------b-------c---| source 2: ---------------1--------------------2------| output emit: (a,NoValue)---(a,1)-(b,1)---(c,1)--(c,2)--| Args: sources: Source events. partial: * True: Use ``NoValue`` for sources that have not emitted yet. * False: Wait until all sources have emitted. """ return Ziplatest(self, *sources, partial=partial) def delay(self, delay) -> "Delay": """ Time-shift all source events by a delay:: source: -abc-d-e---f---| output: ---abc-d-e---f---| This applies to the source errors and the source done event as well. Args: delay: Time delay of all events (in seconds). """ return Delay(delay, self) def timeout(self, timeout) -> "Timeout": """ When the source doesn't emit for longer than the timeout period, do an empty emit and set this event as done. Args: timeout: Timeout value. """ return Timeout(timeout, self) def throttle( self, maximum, interval, cost_func=None) -> "Throttle": """ Limit number of emits per time without dropping values. Values that come in too fast are queued and re-emitted as soon as allowed by the limits. A nested ``status_event`` emits ``True`` when throttling starts and ``False`` when throttling ends. The limit can be dynamically changed with ``set_limit``. Args: maximum: Maximum payload per interval. interval: Time interval (in seconds). cost_func: The sum of ``cost_func(value)`` for every source value inside the ``interval`` that is to remain under the ``maximum``. The default is to count every source value as 1. """ return Throttle(maximum, interval, cost_func, self) def debounce(self, delay, on_first: bool = False) -> "Debounce": """ Filter out values from the source that happen in rapid succession. Args: delay: Maximal time difference (in seconds) between successive values before debouncing kicks in. on_first: * True: First value is send immediately and following values in the rapid succession are dropped:: source: -abcd----efg- output: -a-------e--- * False: Last value of a rapid succession is send after the delay and the values before that are dropped:: source: -abcd----efg-- output: ----d------g- """ return Debounce(delay, on_first, self) def copy(self) -> "Copy": """ Create a shallow copy of the source values. """ return Copy(self) def deepcopy(self) -> "Deepcopy": """ Create a deep copy of the source values. """ return Deepcopy(self) def sample(self, timer: "Event") -> "Sample": """ At the times that the timer emits, sample the value from this event and emit the sample. Args: timer: Event used to time the samples. """ return Sample(timer, self) def errors(self) -> "Errors": """ Emit errors from the source. """ return Errors(self) def end_on_error(self) -> "EndOnError": """ End on any error from the source. """ return EndOnError(self) from .ops.aggregate import ( All, Any, Count, Deque, Ema, List as ListOp, Max, Mean, Min, Pairwise, Product, Reduce, Sum) from .ops.array import ( Array, ArrayAll, ArrayAny, ArrayMax, ArrayMean, ArrayMin, ArrayProd, ArrayStd, ArraySum) from .ops.combine import ( AddableJoinOp, Chain, Concat, Fork, Merge, Switch, Zip, Ziplatest) from .ops.create import ( Aiterate, Marble, Range, Repeat, Sequence, Timer, Timerange, Wait) from .ops.misc import EndOnError, Errors from .ops.op import Op from .ops.select import ( Changes, DropWhile, Filter, Last, Skip, Take, TakeUntil, TakeWhile, Unique) from .ops.timing import ( Debounce, Delay, Sample, Throttle, Timeout) from .ops.transform import ( Chainmap, Chunk, ChunkWith, Concatmap, Constant, Copy, Deepcopy, Emap, Enumerate, Iterate, Map, Mergemap, Pack, Partial, PartialRight, Pluck, Previous, Star, Switchmap, Timestamp) ================================================ FILE: eventkit/ops/__init__.py ================================================ """Event operators.""" ================================================ FILE: eventkit/ops/aggregate.py ================================================ import itertools import operator from collections import deque from .op import Op from .transform import Iterate from ..util import NO_VALUE class Count(Iterate): __slots__ = () def __init__(self, start=0, step=1, source=None): it = itertools.count(start, step) Iterate.__init__(self, it, source) class Reduce(Op): __slots__ = ('_func', '_initializer', '_prev') def __init__(self, func, initializer=NO_VALUE, source=None): Op.__init__(self, source) self._func = func self._initializer = initializer self._prev = NO_VALUE def on_source(self, arg): if self._prev is NO_VALUE: if self._initializer is NO_VALUE: self._prev = arg else: self._prev = self._func(self._initializer, arg) self.emit(self._prev) else: self._prev = self._func(self._prev, arg) self.emit(self._prev) class Min(Reduce): __slots__ = () def __init__(self, source=None): Reduce.__init__(self, min, float('inf'), source) class Max(Reduce): __slots__ = () def __init__(self, source=None): Reduce.__init__(self, max, -float('inf'), source) class Sum(Reduce): __slots__ = () def __init__(self, start=0, source=None): Reduce.__init__(self, operator.add, start, source) class Product(Reduce): __slots__ = () def __init__(self, start=1, source=None): Reduce.__init__(self, operator.mul, start, source) class Mean(Op): __slots__ = ('_count', '_sum') def __init__(self, source=None): Op.__init__(self, source) self._count = 0 self._sum = 0 def on_source(self, arg): self._count += 1 self._sum += arg self.emit(self._sum / self._count) class Any(Reduce): __slots__ = () def __init__(self, source=None): Reduce.__init__(self, lambda prev, v: prev or bool(v), False, source) class All(Reduce): __slots__ = () def __init__(self, source=None): Reduce.__init__(self, lambda prev, v: prev and bool(v), True, source) class Ema(Op): __slots__ = ('_f1', '_f2', '_prev') def __init__(self, n=None, weight=None, source=None): Op.__init__(self, source) self._f1 = weight or 2.0 / (n + 1) self._f2 = 1 - self._f1 self._prev = NO_VALUE def on_source(self, *args): if self._prev is NO_VALUE: value = args else: value = [ self._f2 * p + self._f1 * a for p, a in zip(self._prev, args)] self._prev = value self.emit(*value) class Pairwise(Op): __slots__ = ('_prev', '_has_prev') def __init__(self, source=None): Op.__init__(self, source) self._has_prev = False def on_source(self, *args): value = args[0] if len(args) == 1 else args if args else NO_VALUE if self._has_prev: self.emit(self._prev, value) else: self._has_prev = True self._prev = value class List(Op): __slots__ = ('_values') def __init__(self, source=None): Op.__init__(self, source) self._values = [] def on_source(self, *args): self._values.append( args[0] if len(args) == 1 else args if args else NO_VALUE) def on_source_done(self, source): self.emit(self._values) Op.on_source_done(self, source) class Deque(Op): __slots__ = ('_count', '_q') def __init__(self, count, source=None): Op.__init__(self, source) self._count = count self._q = deque() def on_source(self, *args): self._q.append( args[0] if len(args) == 1 else args if args else NO_VALUE) if self._count and len(self._q) > self._count: self._q.popleft() self.emit(self._q) ================================================ FILE: eventkit/ops/array.py ================================================ from collections import deque import numpy as np from .op import Op from ..util import NO_VALUE class Array(Op): __slots__ = ('_count', '_q') def __init__(self, count, source=None): Op.__init__(self, source) self._count = count self._q = deque() def on_source(self, *args): self._q.append( args[0] if len(args) == 1 else args if args else NO_VALUE) if self._count and len(self._q) > self._count: self._q.popleft() self.emit(np.asarray(self._q)) def min(self) -> "ArrayMin": # type: ignore """ Minimum value. """ return ArrayMin(self) def max(self) -> "ArrayMax": # type: ignore """ Maximum value. """ return ArrayMax(self) def sum(self) -> "ArraySum": # type: ignore """ Summation. """ return ArraySum(self) def prod(self) -> "ArrayProd": """ Product. """ return ArrayProd(self) def mean(self) -> "ArrayMean": # type: ignore """ Mean value. """ return ArrayMean(self) def std(self) -> "ArrayStd": # type: ignore """ Sample standard deviation. """ return ArrayStd(self) def any(self) -> "ArrayAny": # type: ignore """ Test if any array value is true. """ return ArrayAny(self) def all(self) -> "ArrayAll": # type: ignore """ Test if all array values are true. """ return ArrayAll(self) class ArrayMin(Op): __slots__ = () def on_source(self, arg): self.emit(arg.min()) class ArrayMax(Op): __slots__ = () def on_source(self, arg): self.emit(arg.max()) class ArraySum(Op): __slots__ = () def on_source(self, arg): self.emit(arg.sum()) class ArrayProd(Op): __slots__ = () def on_source(self, arg): self.emit(arg.prod()) class ArrayMean(Op): __slots__ = () def on_source(self, arg): self.emit(arg.mean()) class ArrayStd(Op): __slots__ = () def on_source(self, arg): self.emit(arg.std(ddof=1) if len(arg) > 1 else np.nan) class ArrayAny(Op): __slots__ = () def on_source(self, arg): self.emit(arg.any()) class ArrayAll(Op): __slots__ = () def on_source(self, arg): self.emit(arg.all()) ================================================ FILE: eventkit/ops/combine.py ================================================ import functools from collections import defaultdict, deque from typing import Deque, Optional from .op import Op from ..event import Event from ..util import NO_VALUE class Fork(list): __slots__ = () def __init__(self): list.__init__(self) def join(self, joiner: "JoinOp"): joiner._set_sources(*self) self.clear() return joiner def concat(self) -> "Concat": return self.join(Concat()) def merge(self) -> "Merge": return self.join(Merge()) def switch(self) -> "Switch": return self.join(Switch()) def zip(self) -> "Zip": return self.join(Zip()) def ziplatest(self) -> "Ziplatest": return self.join(Ziplatest()) def chain(self) -> "Chain": return self.join(Chain()) class JoinOp(Op): """ Base class for join operators that combine the emits from multiple source events. """ __slots__ = ('_sources',) _sources: Deque[Event] def _set_sources(self, sources): raise NotImplementedError class AddableJoinOp(JoinOp): """ Base class for join operators where new sources, produced by a parent higher-order event, can be added dynamically. """ __slots__ = ('_parent',) _parent: Optional[Event] def __init__(self, *sources: Event): JoinOp.__init__(self) self._sources = deque() self._parent = None self._set_sources(*sources) def _set_sources(self, *sources): for source in sources: source = Event.create(source) self.add_source(source) def add_source(self, source): # note: the same source can be added multiple times raise NotImplementedError def set_parent(self, parent: Event): self._parent = parent if parent.done_event: parent.done_event += self._on_parent_done def on_source_done(self, source): self._disconnect_from(source) self._sources.remove(source) if not self._sources and self._parent is None: self.set_done() def _on_parent_done(self, parent): parent -= self._on_parent_done self._parent = None if not self._sources: self.set_done() class Merge(AddableJoinOp): __slots__ = () def add_source(self, source): self._sources.append(source) self._connect_from(source) class Switch(AddableJoinOp): __slots__ = ('_source2cb', '_active_source') def __init__(self, *sources): AddableJoinOp.__init__(self) self._source2cb = {} # map from source to callback self._active_source = None self._set_sources(*sources) def add_source(self, source): self._sources.append(source) cb = self._source2cb.get(source) if not cb: cb = functools.partial(self.on_source_s, source) self._source2cb[source] = cb source.connect(cb, done=self.on_source_done) def _remove_source(self, source): if source in self._sources: self._sources.remove(source) cb = self._source2cb.pop(source, None) if cb: source -= cb def on_source_s(self, source, *args): if source is not self._active_source: self._remove_source(self._active_source) self._active_source = source self.emit(*args) def on_source_done(self, source): self._remove_source(source) if not self._sources and self._parent is None: self._active_source = None self.set_done() class Concat(AddableJoinOp): __slots__ = ('_source2cb',) def __init__(self, *sources): AddableJoinOp.__init__(self) self._source2cb = {} # map from source to callback self._set_sources(*sources) def add_source(self, source): if source in self._sources: return self._sources.append(source) cb = self._source2cb.get(source) if not cb: cb = functools.partial(self._on_source_s, source) self._source2cb[source] = cb source.connect(cb, done=self.on_source_done) def _on_source_s(self, source, *args): while self._sources and self._sources[0] is not source: s = self._sources.popleft() cb = self._source2cb.pop(s, None) if cb: s.disconnect(cb, done=self.on_source_done) self.emit(*args) def on_source_done(self, source): cb = self._source2cb.pop(source) source.disconnect(cb, done=self.on_source_done) while source in self._sources: self._sources.remove(source) if not self._sources and self._parent is None: self.set_done() class Chain(AddableJoinOp): __slots__ = ('_qq', '_source2cbs') def __init__(self, *sources): AddableJoinOp.__init__(self) self._qq = deque() self._source2cbs = defaultdict(list) # map from source to callbacks self._set_sources(*sources) def add_source(self, source): if not self._sources: self._connect_from(source) else: def cb(*args): q.append(args) q = deque() self._qq.append(q) source += cb self._source2cbs[source].append(cb) self._sources.append(source) def on_source_done(self, source): if source is not self._sources[0]: return self._disconnect_from(source) self._sources.popleft() while self._sources: source = self._sources[0] q = self._qq.popleft() for args in q: self.emit(*args) for cb in self._source2cbs.pop(source, []): source -= cb if source.done(): self._sources.popleft() continue self._connect_from(source) return if not self._sources and self._parent is None: self.set_done() class Zip(JoinOp): __slots__ = ('_results', '_source2cbs', '_num_ready') def __init__(self, *sources): JoinOp.__init__(self) self._num_ready = 0 # number of sources with a pending result self._source2cbs = defaultdict(list) # map from source to callbacks if sources: self._set_sources(*sources) def _set_sources(self, *sources): self._sources = deque(Event.create(s) for s in sources) if any(s.done() for s in self._sources): self.set_done() return self._results = [deque() for _ in self._sources] for i, source in enumerate(self._sources): cb = functools.partial(self._on_source_i, i) source.connect(cb, self.on_source_error, self.on_source_done) self._source2cbs[source].append(cb) def _on_source_i(self, i, *args): q = self._results[i] if not q: self._num_ready += 1 ready = self._num_ready == len(self._results) else: ready = False q.append(args[0] if len(args) == 1 else args if args else NO_VALUE) if ready: tup = tuple(q.popleft() for q in self._results) self._num_ready = sum(bool(q) for q in self._results) self.emit(*tup) def on_source_done(self, source): self._sources.remove(source) if not self._sources: for source, cbs in self._source2cbs.items(): for cb in cbs: source.disconnect( cb, self.on_source_error, self.on_source_done) self._source2cbs = None self.set_done() class Ziplatest(JoinOp): __slots__ = ('_values', '_is_primed', '_source2cbs') def __init__(self, *sources, partial=True): JoinOp.__init__(self) self._is_primed = partial self._source2cbs = defaultdict(list) # map from source to callbacks if sources: self._set_sources(*sources) def _set_sources(self, *sources): sources = [Event.create(s) for s in sources] self._sources = deque(s for s in sources if not s.done()) if not self._sources: self.set_done() return self._values = [s.value() for s in sources] for i, source in enumerate(self._sources): cb = functools.partial(self._on_source_i, i) source.connect(cb, self.on_source_error, self.on_source_done) self._source2cbs[source].append(cb) def _on_source_i(self, i, *args): self._values[i] = \ args[0] if len(args) == 1 else args if args else NO_VALUE if not self._is_primed: self._is_primed = not any(r is NO_VALUE for r in self._values) if self._is_primed: self.emit(*self._values) def on_source_done(self, source): self._sources.remove(source) if not self._sources: for source, cbs in self._source2cbs.items(): for cb in cbs: source.disconnect( cb, self.on_source_error, self.on_source_done) self._source2cbs = None self.set_done() ================================================ FILE: eventkit/ops/create.py ================================================ import asyncio import itertools import time from .op import Op from ..event import Event from ..util import NO_VALUE, get_event_loop, timerange class Wait(Event): __slots__ = ('_task',) def __init__(self, future, name='wait'): Event.__init__(self, name) if future.done(): self._task = None self.set_done() else: loop = get_event_loop() self._task = asyncio.ensure_future(future, loop=loop) future.add_done_callback(self._on_task_done) def _on_task_done(self, task): try: result = task.result() except Exception as error: result = NO_VALUE self.error_event.emit(self, error) self.emit(result) self._task = None self.set_done() def __del__(self): if self._task: self._task.cancel() class Aiterate(Event): __slots__ = ('_task',) def __init__(self, ait): Event.__init__(self, ait.__qualname__) loop = get_event_loop() self._task = asyncio.ensure_future(self._looper(ait), loop=loop) async def _looper(self, ait): try: async for args in ait: self.emit(args) except Exception as error: self.error_event.emit(self, error) self._task = None self.set_done() def __del__(self): if self._task: self._task.cancel() class Sequence(Aiterate): __slots__ = () def __init__(self, values, interval=0, times=None): async def sequence(): t0 = time.time() if times is not None: for t, value in zip(times, values): delay = max(0, time.time() + t - t0) await asyncio.sleep(delay) yield value else: for i, value in enumerate(values): delay = max(0, i * interval + t0 - time.time()) await asyncio.sleep(delay) yield value Aiterate.__init__(self, sequence()) class Repeat(Sequence): __slots__ = () def __init__(self, value, count, interval=0, times=None): Sequence.__init__(self, itertools.repeat(count), interval, times) class Range(Sequence): __slots__ = () def __init__(self, *args, interval=0, times=None): Sequence.__init__(self, range(*args), interval, times) class Timerange(Aiterate): __slots__ = () def __init__(self, start=0, end=None, step=1): Aiterate.__init__(self, timerange(start, end, step)) class Timer(Aiterate): __slots__ = () def __init__(self, interval, count=None): async def timer(): t0 = time.time() i = 0 while count is None or i < count: i += 1 delay = i * interval + t0 - time.time() await asyncio.sleep(delay) yield i * interval Aiterate.__init__(self, timer()) class Marble(Op): __slots__ = () def __init__(self, s, interval=0, times=None): s = s.replace('_', '') source = Event.sequence(s, interval, times) \ .filter(lambda c: c not in '- ') \ .takewhile(lambda c: c != '|') Op.__init__(self, source) ================================================ FILE: eventkit/ops/misc.py ================================================ from .op import Op from ..event import Event class Errors(Event): __slots__ = ('_source',) def __init__(self, source=None): Event.__init__(self) self._source = source if source is not None and source.done(): self.set_done() else: source.error_event += self.emit class EndOnError(Op): __slots__ = () def __init__(self, source=None): Op.__init__(self, source) def on_source_error(self, error): self.disconnect_from(self._source) self.error_event.emit(error) self.set_done() ================================================ FILE: eventkit/ops/op.py ================================================ from typing import Union from ..event import Event class Op(Event): """ Base functionality for operators. The Observer pattern is implemented by the following three methods:: on_source(self, *args) on_source_error(self, source, error) on_source_done(self, source) The default handlers will pass along source emits, errors and done events. This makes ``Op`` also suitable as an identity operator. """ __slots__ = () def __init__(self, source: Union[Event, None] = None): Event.__init__(self) if source is not None: self.set_source(source) on_source = Event.emit def on_source_error(self, source, error): if len(self.error_event): self.error_event.emit(source, error) else: Event.logger.exception(error) def on_source_done(self, _source): if self._source is not None: self._disconnect_from(self._source) self._source = None self.set_done() def set_source(self, source): source = Event.create(source) if self._source is None: self._source = source self._connect_from(source) else: self._source.set_source(source) def _connect_from(self, source: Event): if source.done(): self.set_done() else: source.connect( self.on_source, self.on_source_error, self.on_source_done, keep_ref=True) def _disconnect_from(self, source: Event): source.disconnect( self.on_source, self.on_source_error, self.on_source_done) ================================================ FILE: eventkit/ops/select.py ================================================ from .op import Op from ..util import NO_VALUE class Filter(Op): __slots__ = ('_predicate',) def __init__(self, predicate=bool, source=None): Op.__init__(self, source) self._predicate = predicate def on_source(self, *args): if self._predicate(*args): self.emit(*args) class Skip(Op): __slots__ = ('_count', '_n') def __init__(self, count=1, source=None): Op.__init__(self, source) self._count = count self._n = 0 def on_source(self, *args): self._n += 1 if self._n == self._count: self._source -= self.on_source self._source += self.emit class Take(Op): __slots__ = ('_count', '_n') def __init__(self, count=1, source=None): Op.__init__(self, source) self._count = count self._n = 0 def on_source(self, *args): self._n += 1 if self._n <= self._count: self.emit(*args) if self._n == self._count: self._disconnect_from(self._source) self.set_done() class TakeWhile(Op): __slots__ = ('_predicate',) def __init__(self, predicate=bool, source=None): Op.__init__(self, source) self._predicate = predicate def on_source(self, *args): if self._predicate(*args): self.emit(*args) else: self.set_done() self._disconnect_from(self._source) class DropWhile(Op): __slots__ = ('_predicate', '_drop') def __init__(self, predicate=lambda x: not x, source=None): Op.__init__(self, source) self._predicate = predicate self._drop = True def on_source(self, *args): if self._drop: self._drop = self._predicate(*args) if not self._drop: self.emit(*args) class TakeUntil(Op): __slots__ = ('_notifier',) def __init__(self, notifier, source=None): Op.__init__(self, source) self._notifier = notifier notifier.connect( self._on_notifier, self.on_source_error, self.on_source_done) def _on_notifier(self, *args): self.on_source_done(self._source) def on_source_done(self, source): Op.on_source_done(self, self._source) self._notifier.disconnect( self._on_notifier, self.on_source_error, self.on_source_done) self._notifier = None class Changes(Op): __slots__ = ('_prev',) def __init__(self, source=None): Op.__init__(self, source) self._prev = NO_VALUE def on_source(self, *args): if args != self._prev: self.emit(*args) self._prev = args class Unique(Op): __slots__ = ('_key', '_seen') def __init__(self, key, source=None): Op.__init__(self, source) self._key = key self._seen = set() def on_source(self, *args): if self._key is None: new = args not in self._seen else: new = self._key(*args) not in self._seen self._seen.add(args) if new: self.emit(*args) class Last(Op): __slots__ = ('_last',) def __init__(self, source=None): Op.__init__(self, source) self._last = NO_VALUE def on_source(self, *args): self._last = args def on_source_done(self, source): self.emit(*self._last) Op.on_source_done(self, source) ================================================ FILE: eventkit/ops/timing.py ================================================ from collections import deque from .op import Op from ..event import Event from ..util import NO_VALUE, get_event_loop class Delay(Op): __slots__ = ('_delay',) def __init__(self, delay, source=None): Op.__init__(self, source) self._delay = delay def on_source(self, *args): loop = get_event_loop() loop.call_later(self._delay, self.emit, *args) def on_source_error(self, error): loop = get_event_loop() loop.call_later(self._delay, self.error_event.emit, error) def on_source_done(self, source): if self._source is not None: self._disconnect_from(self._source) self._source = None loop = get_event_loop() loop.call_later(self._delay, self.set_done) class Timeout(Op): __slots__ = ('_timeout', '_handle', '_last_time') def __init__(self, timeout, source=None): Op.__init__(self, source) if source is not None and source.done(): return self._timeout = timeout loop = get_event_loop() self._last_time = loop.time() self._handle = None self._schedule() def on_source(self, *args): loop = get_event_loop() self._last_time = loop.time() def on_source_done(self, source): self._handle.cancel() del self._handle Op.on_source_done(self, source) def _schedule(self): loop = get_event_loop() self._handle = loop.call_at( self._last_time + self._timeout, self._on_timer) def _on_timer(self): loop = get_event_loop() if loop.time() - self._last_time > self._timeout: self.emit() self.set_done() else: self._schedule() class Debounce(Op): __slots__ = ('_interval', '_on_first', '_handle', '_last_time') def __init__(self, interval, on_first=False, source=None): Op.__init__(self, source) self._interval = interval self._on_first = on_first self._last_time = -float('inf') self._handle = None def on_source(self, *args): loop = get_event_loop() time = loop.time() delta = time - self._last_time self._last_time = time if self._on_first: if delta >= self._interval: self.emit(*args) else: if self._handle: self._handle.cancel() self._handle = loop.call_at( time + self._interval, self._delayed_emit, *args) def _delayed_emit(self, *args): self._handle = None self.emit(*args) if self._source is None: self.set_done() def on_source_done(self, source): self._disconnect_from(source) self._source = None if not self._handle: self.set_done() class Throttle(Op): __slots__ = ( 'status_event', '_maximum', '_interval', '_cost_func', '_q', '_time_q', '_cost_q', '_is_throttling') def __init__(self, maximum, interval, cost_func=None, source=None): Op.__init__(self, source) self.status_event = Event('throttle_status') """ Sub event that emits ``True`` when throttling starts and ``False`` when throttling ends. """ self._maximum = maximum self._interval = interval self._cost_func = cost_func self._q = deque() # deque of (args, cost) tuples self._time_q = deque() # deque of previous emit times self._cost_q = deque() # deque of costs of previous emits self._is_throttling = False def set_limit(self, maximum, interval): """ Dynamically update the ``maximum`` per ``interval`` limit. """ self._maximum = maximum self._interval = interval def on_source(self, *args): cost = self._cost_func if cost is not None: cost = cost(*args) self._q.append((args, cost)) self._try_emit() def on_source_done(self, source): self._disconnect_from(source) self._source = None if not self._q: self.set_done() self.status_event.set_done() def _try_emit(self): loop = get_event_loop() t = loop.time() q = self._q times = self._time_q costs = self._cost_q # forget old emit times while times and t - times[0] > self._interval: times.popleft() costs.popleft() # emit values while not exceeding the limit while q: args, cost = q[0] if self._cost_func: cost = self._cost_func(*args) total_cost = cost + sum(costs) else: cost = None total_cost = 1 + len(costs) if self._maximum and total_cost >= self._maximum: break args, cost = q.popleft() times.append(t) costs.append(cost) self.emit(*args) # update status and schedule new emits if q: if not self._is_throttling: self.status_event.emit(True) loop.call_at(times[0] + self._interval, self._try_emit) elif self._is_throttling: self.status_event.emit(False) self._is_throttling = bool(q) if not q and self._source is None: self.set_done() self.status_event.set_done() class Sample(Op): __slots__ = ('_timer',) def __init__(self, timer, source=None): Op.__init__(self, source) self._timer = timer timer.connect( self._on_timer, self.on_source_error, self.on_source_done) def on_source(self, *args): self._value = args def _on_timer(self, *args): if self._value is not NO_VALUE: self.emit(*self._value) def on_source_done(self, source): Op.on_source_done(self, self._source) self._timer.disconnect( self._on_timer, self.on_source_error, self.on_source_done) self._timer = None ================================================ FILE: eventkit/ops/transform.py ================================================ import asyncio import copy import time from collections import deque from .combine import Chain, Concat, Merge, Switch from .op import Op from ..util import NO_VALUE, get_event_loop class Constant(Op): __slots__ = ('_constant',) def __init__(self, constant, source=None): Op.__init__(self, source) self._constant = constant def on_source(self, *args): self.emit(self._constant) class Iterate(Op): __slots__ = ('_it',) def __init__(self, it, source=None): Op.__init__(self, source) self._it = iter(it) def on_source(self, *args): try: value = next(self._it) self.emit(value) except StopIteration: self._disconnect_from(self._source) self.set_done() class Enumerate(Op): __slots__ = ('_step', '_i') def __init__(self, start=0, step=1, source=None): Op.__init__(self, source) self._i = start self._step = step def on_source(self, *args): self.emit( self._i, args[0] if len(args) == 1 else args if args else NO_VALUE) self._i += self._step class Timestamp(Op): __slots__ = () def on_source(self, *args): self.emit( time.time(), args[0] if len(args) == 1 else args if args else NO_VALUE) class Partial(Op): __slots__ = ('_left_args',) def __init__(self, *left_args, source=None): Op.__init__(self, source) self._left_args = left_args def on_source(self, *args): self.emit(*(self._left_args + args)) class PartialRight(Op): __slots__ = ('_right_args',) def __init__(self, *right_args, source=None): Op.__init__(self, source) self._right_args = right_args def on_source(self, *args): self.emit(*(args + self._right_args)) class Star(Op): __slots__ = () def on_source(self, arg): self.emit(*arg) class Pack(Op): __slots__ = () def on_source(self, *args): self.emit(args) class Pluck(Op): __slots__ = ('_selections',) def __init__(self, *selections, source=None): Op.__init__(self, source) self._selections = [] # list of [arg-index, *sub-attributes] for sel in selections: if type(sel) is int: s = [sel] else: s = sel.split('.') if s[0].isdigit(): s[0] = int(s[0]) elif s[0] == '': s[0] = 0 else: s.insert(0, 0) self._selections.append(s) def on_source(self, *args): values = [] for s in self._selections: try: value = args[s[0]] for attr in s[1:]: value = getattr(value, attr) except Exception: value = NO_VALUE values.append(value) self.emit(*values) class Previous(Op): __slots__ = ('_count', '_q') def __init__(self, count=1, source=None): Op.__init__(self, source) self._count = count self._q = deque() def on_source(self, *args): self._q.append(args) if len(self._q) > self._count: self.emit(*self._q.popleft()) class Copy(Op): __slots__ = () def on_source(self, *args): self.emit(*(copy.copy(a) for a in args)) class Deepcopy(Op): __slots__ = () def on_source(self, *args): self.emit(*copy.deepcopy(args)) class Chunk(Op): __slots__ = ('_size', '_list') def __init__(self, size, source=None): Op.__init__(self, source) self._size = size self._list = [] def on_source(self, *args): self._list.append( args[0] if len(args) == 1 else args if args else NO_VALUE) if len(self._list) == self._size: self.emit(self._list) self._list = [] def on_source_done(self, source): if self._list: self.emit(self._list) Op.on_source_done(self, self._source) class ChunkWith(Op): __slots__ = ('_timer', '_list', '_emit_empty') def __init__(self, timer, emit_empty, source=None): Op.__init__(self, source) self._timer = timer self._emit_empty = emit_empty self._list = [] timer.connect( self._on_timer, self.on_source_error, self.on_source_done) def on_source(self, *args): self._list.append( args[0] if len(args) == 1 else args if args else NO_VALUE) def _on_timer(self, *args): if self._list or self._emit_empty: self.emit(self._list) self._list = [] def on_source_done(self, source): if self._list: self.emit(self._list) self._list = None if self._timer is not None: self._timer.disconnect( self._on_timer, self.on_source_error, self.on_source_done) self._timer = None Op.on_source_done(self, self._source) class Map(Op): __slots__ = ( '_func', '_timeout', '_ordered', '_task_limit', '_coro_q', '_tasks') def __init__( self, func, timeout=0, ordered=True, task_limit=None, source=None): Op.__init__(self, source) if source is not None and source.done(): return self._func = func self._timeout = timeout self._ordered = ordered self._task_limit = task_limit self._coro_q = deque() self._tasks = deque() def on_source(self, *args): obj = self._func(*args) if hasattr(obj, '__await__'): # function returns an awaitable if not self._task_limit or len(self._tasks) < self._task_limit: # schedule right away self._create_task(obj) else: # queue for later self._coro_q.append(obj) else: # regular function returns the result directly self.emit(obj) def on_source_done(self, source): if not self._tasks: # only end when no tasks are pending Op.on_source_done(self, self._source) self._source = None def _create_task(self, coro): # schedule a task to be run if self._timeout: coro = asyncio.wait_for(coro, self._timeout) loop = get_event_loop() task = asyncio.ensure_future(coro, loop=loop) task.add_done_callback(self._on_task_done) self._tasks.append(task) def _on_task_done(self, task): # handle task result tasks = self._tasks if self._ordered: while tasks and tasks[0].done(): # remove task after emitting result task = tasks[0] self._emit_task(task) task = tasks.popleft() else: # remove task after emitting result self._emit_task(task) tasks.remove(task) # schedule pending awaitables from the queue while self._coro_q and ( not self._task_limit or len(tasks) < self._task_limit): self._create_task(self._coro_q.popleft()) # end when source has ended with no pending tasks if not tasks and self._source is None: Op.on_source_done(self, self._source) def _emit_task(self, task): try: result = task.result() except Exception as error: result = NO_VALUE self.error_event.emit(error) self.emit(result) class Emap(Op): __slots__ = ('_constr', '_joiner',) def __init__(self, constr, joiner, source=None): Op.__init__(self, source) self._constr = constr self._joiner = joiner joiner.set_parent(source) joiner.connect( self.emit, self.error_event.emit, self._on_joiner_done) def on_source(self, *args): obj = self._constr(*args) event = self.create(obj) self._joiner.add_source(event) def on_source_done(self, source): pass def _on_joiner_done(self, joiner): joiner.disconnect( self.emit, self.error_event.emit, self._on_joiner_done) self._joiner = None self.set_done() class Mergemap(Emap): __slots__ = () def __init__(self, constr, source=None): Emap.__init__(self, constr, Merge(), source) class Chainmap(Emap): __slots__ = () def __init__(self, constr, source=None): Emap.__init__(self, constr, Chain(), source) class Concatmap(Emap): __slots__ = () def __init__(self, constr, source=None): Emap.__init__(self, constr, Concat(), source) class Switchmap(Emap): __slots__ = () def __init__(self, constr, source=None): Emap.__init__(self, constr, Switch(), source) ================================================ FILE: eventkit/util.py ================================================ import asyncio import datetime as dt from typing import AsyncIterator class _NoValue: def __bool__(self): return False def __repr__(self): return '' __str__ = __repr__ NO_VALUE = _NoValue() def get_event_loop(): """Get asyncio event loop, running or not.""" return asyncio.get_event_loop_policy().get_event_loop() main_event_loop = get_event_loop() async def timerange(start=0, end=None, step: float = 1) \ -> AsyncIterator[dt.datetime]: """ Iterator that waits periodically until certain time points are reached while yielding those time points. Args: start: Start time, can be specified as: * ``datetime.datetime``. * ``datetime.time``: Today is used as date. * ``int`` or ``float``: Number of seconds relative to now. Values will be quantized to the given step. end: End time, can be specified as: * ``datetime.datetime``. * ``datetime.time``: Today is used as date. * ``None``: No end limit. step: Number of seconds, or ``datetime.timedelta``, to space between values. """ tz = getattr(start, 'tzinfo', None) now = dt.datetime.now(tz) if isinstance(step, dt.timedelta): delta = step step = delta.total_seconds() else: delta = dt.timedelta(seconds=step) t = start if t == 0 or isinstance(t, (int, float)): t = now + dt.timedelta(seconds=t) # quantize to step t = dt.datetime.fromtimestamp( step * int(t.timestamp() / step)) elif isinstance(t, dt.time): t = dt.datetime.combine(now.today(), t) if t < now: # t += delta t -= ((t - now) // delta) * delta if isinstance(end, dt.time): end = dt.datetime.combine(now.today(), end) elif isinstance(end, (int, float)): end = now + dt.timedelta(seconds=end) while end is None or t <= end: now = dt.datetime.now(tz) secs = (t - now).total_seconds() await asyncio.sleep(secs) yield t t += delta ================================================ FILE: eventkit/version.py ================================================ __version_info__ = (1, 0, 3) __version__ = '.'.join(str(v) for v in __version_info__) ================================================ FILE: notebooks/eventkit_introduction.ipynb ================================================ { "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# eventkit introduction\n", "\n", "## Connecting to events and emitting" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "import eventkit as ev" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "An event contains a list of callables (the listeners, or handlers) that are\n", "called when the event is emitted. Let'\n", "s make two listeners first:" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "def f(i):\n", " print('f got', i)\n", "\n", "def g(i):\n", " print('g got', i)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now create an event and add the listeners. This is done with the ``connect`` method, or its shorthand ``+=``:" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "event = ev.Event()\n", "event += f\n", "event += g" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "When the event emits a value, the value is emitted to all the listeners:" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "f got 42\n", "g got 42\n" ] } ], "source": [ "event.emit(42)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "For testing purposes it is often convenient to add the built-in ``print`` function as listener:" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "f got 43\n", "g got 43\n", "43\n" ] } ], "source": [ "event += print\n", "\n", "event.emit(43)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Removing a listener is done with ``disconnect``, or ``-=``:" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "f got 44\n" ] } ], "source": [ "event -= g\n", "event -= print\n", "\n", "event.emit(44)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "All listeners are removed with ``clear``:" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "event.clear()\n", "event.emit(45)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Nobody's listening...\n", "\n", "Multiple arguments can be emitted:" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "f got 7 A\n" ] } ], "source": [ "def f(a, b):\n", " print('f got', a, b)\n", " \n", "event += f\n", "event.emit(7, 'A')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Instead of a function let's add a method as listener:" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "on_event got Whats up?\n" ] } ], "source": [ "class A:\n", " \n", " def on_event(self, s, t):\n", " print('on_event got', s, t)\n", "\n", " \n", "a = A()\n", "event = ev.Event()\n", "event += a.on_event\n", "event.emit('Whats', 'up?')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "A listener is automatically disconnected when it's garbage collected:" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [], "source": [ "del a\n", "event.emit('Still', 'there?')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Nope, he's gone.\n", "\n", "## Time\n", "\n", "A crucial aspect of events is their time dimension: Events happen at a certain time. Let's create a timer event to illustrate:" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0.25\n", "0.5\n", "0.75\n", "1.0\n", "1.25\n", "1.5\n", "1.75\n", "2.0\n", "2.25\n", "2.5\n" ] } ], "source": [ "timer = ev.Timer(0.25, count=10)\n", "timer += print\n", "\n", "await timer.last(); # to keep output in this cell" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "There are multiple other create methods, such as ``Sequence``, ``Repeat``, ``Range`` or ``Timerange``. They are accessible from the ``eventkit`` namespace or as static methods from the ``Event`` class but in lower case.\n", "For example ``ev.Sequence`` is the same as ``Event.sequence``.\n", "\n", "Let's try a timerange, it produces absolute datetimes:" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "2019-03-17 09:23:41.500000\n", "2019-03-17 09:23:41.750000\n", "2019-03-17 09:23:42\n", "2019-03-17 09:23:42.250000\n", "2019-03-17 09:23:42.500000\n", "2019-03-17 09:23:42.750000\n", "2019-03-17 09:23:43\n", "2019-03-17 09:23:43.250000\n" ] } ], "source": [ "event = ev.Timerange(0, 2, 0.25)\n", "event += print\n", "\n", "await event.last(); # to keep output in this cell" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "To capture all values produced by an event, the ``list()`` method can be used. It finishes when the event is done and this has to be awaited:" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]" ] }, "execution_count": 13, "metadata": {}, "output_type": "execute_result" } ], "source": [ "await ev.Range(10).list()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In a plain Python console the same is accomplished with ``event.run()``. The ``run`` method doesn't work in Jupyter, IPython or Eric because they have an already running asyncio event loop.\n", "\n", "## Event operators\n", "\n", "\n", "There are a lot of operations that can be done on events, mostly dealing with selection, transformation, aggregation, combination and timing.\n", "\n", "### Selection\n", "\n", "The selection operators decide whether an emitted value is passed along or not, but don't change the emitted value. Take for example ``filter``:" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[0, 2, 4, 6, 8]" ] }, "execution_count": 14, "metadata": {}, "output_type": "execute_result" } ], "source": [ "event = ev.Range(10).filter(lambda x: x % 2 == 0)\n", "\n", "await event.list()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "or ``take``:" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "['A', 'B', 'C']" ] }, "execution_count": 15, "metadata": {}, "output_type": "execute_result" } ], "source": [ "event = ev.Sequence('ABCDE').take(3)\n", "\n", "await event.list()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Others are ``skip``, ``takeWhile``, ``dropWhile``, ``takeUntil``, ``changes``, ``unique`` and ``last``." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Transformation\n", "\n", "The transformation operators change a source value. For example ``map``, that maps a function onto each source value::" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "['a', 'b', 'c', 'd', 'e']" ] }, "execution_count": 16, "metadata": {}, "output_type": "execute_result" } ], "source": [ "event = ev.Sequence('ABCDE').map(str.lower)\n", "\n", "await event.list()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "or with ``enumerate``:" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "['A0', 'B1', 'C2', 'D3', 'E4']" ] }, "execution_count": 17, "metadata": {}, "output_type": "execute_result" } ], "source": [ "event = ev.Sequence('ABCDE').enumerate().map(lambda i, c: f'{c}{i}')\n", "\n", "await event.list()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "``pluck`` can select nested properties (and also positional arguments):" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "['.ipynb', '.py', '']" ] }, "execution_count": 18, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from pathlib import Path\n", "files = Path('.').glob('*')\n", "\n", "event = ev.Sequence(files).pluck('.suffix').unique()\n", "\n", "await event.list()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "There are a multitude of other transformations, including asynchronous mapping and higher-order mapping." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Aggregation\n", "\n", "The aggregation operators aggregate the latest source value into a running result.\n", "Examples are ``Min``, ``Max``, ``Sum``, ``Count`` and ``Mean``. \n", "\n", "Let's try a sum:" ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[0, 1, 3, 6, 10, 15, 21, 28, 36, 45]" ] }, "execution_count": 19, "metadata": {}, "output_type": "execute_result" } ], "source": [ "event = ev.Range(10).sum()\n", "\n", "await event.list()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Another useful one is ``array``, which emits a numpy array of specified size with the last source values:" ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[array([0]),\n", " array([0, 1]),\n", " array([0, 1, 2]),\n", " array([1, 2, 3]),\n", " array([2, 3, 4]),\n", " array([3, 4, 5]),\n", " array([4, 5, 6]),\n", " array([5, 6, 7]),\n", " array([6, 7, 8]),\n", " array([7, 8, 9])]" ] }, "execution_count": 20, "metadata": {}, "output_type": "execute_result" } ], "source": [ "event = ev.Range(10).array(3)\n", "\n", "await event.list()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The ``array`` operator has some of the numpy array methods: ``min``, ``max``, ``sum``, ``mean``, ``std``, ``any`` and ``all``. These are specific to arrays and are different from the general operators of the same name.\n", "\n", "To sum only over the last 3 periods:" ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[0, 1, 3, 6, 9, 12, 15, 18, 21, 24]" ] }, "execution_count": 21, "metadata": {}, "output_type": "execute_result" } ], "source": [ "event = ev.Range(10).array(3).sum()\n", "\n", "await event.list()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Combination\n", "\n", "Combining multiple events can be done with ``merge``, ``chain``, ``concat``, ``switch``, ``zip`` or ``ziplatest``.\n", "\n", "The first one, ``merge``, passes the emitted values from all source events as soon as they happen:" ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "['A', '1', 'X', 'B', 'C', '2', 'Y', '3', 'Z']" ] }, "execution_count": 22, "metadata": {}, "output_type": "execute_result" } ], "source": [ "e1 = ev.Sequence('ABC', 0.01)\n", "e2 = ev.Sequence('123', 0.02)\n", "e3 = ev.Sequence('XYZ', 0.03)\n", "\n", "event = e1.merge(e2, e3)\n", "\n", "await event.list()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "``chain`` follows the order of the given sources, queing up emits from next sources:" ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "['A', 'B', 'C', '1', '2', '3', 'X', 'Y', 'Z']" ] }, "execution_count": 23, "metadata": {}, "output_type": "execute_result" } ], "source": [ "e1 = ev.Sequence('ABC', 0.01)\n", "e2 = ev.Sequence('123', 0.02)\n", "e3 = ev.Sequence('XYZ', 0.03)\n", "\n", "event = e1.chain(e2, e3)\n", "\n", "await event.list()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "``concat`` and ``switch`` only follow one source and drop emits from others. ``concat`` moves to the next in line source that emits and ``switch`` moves to the soonest source to emit." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "``zip`` creates matching tuples by queing up emits from all sources and waiting until a full tuple can be emitted, unpacked into postional arguments:" ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[('A', '1', 'X'), ('B', '2', 'Y'), ('C', '3', 'Z')]" ] }, "execution_count": 24, "metadata": {}, "output_type": "execute_result" } ], "source": [ "e1 = ev.Sequence('ABC', 0.01)\n", "e2 = ev.Sequence('123', 0.02)\n", "e3 = ev.Sequence('XYZ', 0.03)\n", "\n", "event = e1.zip(e2, e3)\n", "\n", "await event.list()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "``ziplatest`` doesn't wait, it emits a tuple with the latest value of all sources whenever a source emits." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Timing\n", "\n", "The timing operators deal with emit times. Currently there are ``delay``, ``timeout``, ``sample``, ``throttle`` and ``debounce``." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "To delay a source by half a second:" ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[(0.00016689300537109375, 0.5008916854858398),\n", " (0.10051321983337402, 0.6011142730712891),\n", " (0.2008514404296875, 0.7013490200042725),\n", " (0.3011617660522461, 0.8015925884246826),\n", " (0.4005553722381592, 0.9008283615112305)]" ] }, "execution_count": 25, "metadata": {}, "output_type": "execute_result" } ], "source": [ "import time\n", "t0 = time.time()\n", "\n", "e1 = ev.Range(5, interval=0.1).timestamp().map(lambda t, i: t - t0)\n", "e2 = e1.delay(0.5).timestamp().map(lambda t, i: t - t0)\n", "\n", "await e1.zip(e2).list()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Tip:\n", "\n", "Remember how ``print`` can be used as a listener? This can be done inside a long chain as well:" ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "(0, 97)\n", "(1, 99)\n", "(2, 101)\n", "(3, 103)\n", "(4, 105)\n" ] }, { "data": { "text/plain": [ "['a', 'c', 'e', 'g', 'i']" ] }, "execution_count": 26, "metadata": {}, "output_type": "execute_result" } ], "source": [ "event = (\n", " ev.Sequence('abcde')\n", " .enumerate()\n", " .map(lambda i, c: (i, i + ord(c)))\n", " .connect(print)\n", " .star().pluck(1).map(chr)\n", ")\n", " \n", "await event.list()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Piping & forking" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "A source event can pipe into the next operator in four equivalent ways::\n", " \n", " ev.Range(10).take(5) # familiar 'dot piping'\n", " ev.Range(10) | ev.Take(5) # using | pipe symbol\n", " ev.Range(10).pipe(ev.Take(5)) # using pipe method\n", " ev.Take(5, ev.Range(10)) # contructor piping\n", "\n", "With a fork, the emitted values of an event are fed into multiple operators.\n", "Forking is done with ``fork`` or its shorthand form, square brackets. The forked events\n", "are joined by one the combination methods, such as merge or zip.\n", "\n", "The following illustrates this by coursely sampling the min and max of a sine wave:" ] }, { "cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[(0.0, 0.0),\n", " (0.0, 0.8414709848078965),\n", " (0.0, 0.9092974268256817),\n", " (0.0, 0.9092974268256817),\n", " (-0.7568024953079282, 0.9092974268256817),\n", " (-0.9589242746631385, 0.9092974268256817)]" ] }, "execution_count": 27, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from math import sin\n", "\n", "event = ev.Range(6).map(sin)[ev.Min, ev.Max].zip()\n", "\n", "await event.list()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Or to create several different delays:" ] }, { "cell_type": "code", "execution_count": 28, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[0, 0, 1, 0, 1, 2, 1, 2, 3, 4, 2, 3, 0, 4, 3, 1, 4, 2, 3, 4]" ] }, "execution_count": 28, "metadata": {}, "output_type": "execute_result" } ], "source": [ "event = ev.Range(5, interval=0.1)[\n", " ev.Op, ev.Delay(0.1), ev.Delay(0.2), ev.Delay(0.5)].merge()\n", "\n", "await event.list()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Or to get a moving average and standard deviation from a simulated stock price:" ] }, { "cell_type": "code", "execution_count": 29, "metadata": {}, "outputs": [], "source": [ "import random\n", "\n", "sim_stock = ev.Range(500).map(lambda i: random.lognormvariate(0.001, 0.01)).product(100)\n", "\n", "bollinger = (\n", " sim_stock\n", " .array(50)[ev.ArrayMean, ev.ArrayStd].zip()\n", " .map(lambda av, std: (av, av - 2 * std, av + 2 * std))\n", " .list()\n", ")\n", "close = sim_stock.list()\n", "await bollinger.last();\n", "\n", "# plotting and top-level await don't mix well in one cell, so break into two cells" ] }, { "cell_type": "code", "execution_count": 30, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "%matplotlib inline\n", "import matplotlib.pyplot as plt\n", "plt.figure(figsize=(12, 6))\n", "\n", "plt.plot(close.value());\n", "plt.plot(bollinger.value());" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Flow control\n", "\n", "In async pipelines it can be necessary to regulate the speed of the source values so as not to overwhelm the rest of the pipeline.\n", "A way to do this is with a feedback loop, where an emitted result triggers a new source value to be emitted:" ] }, { "cell_type": "code", "execution_count": 31, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "['a', 'b', 'c', 'd', 'e']" ] }, "execution_count": 31, "metadata": {}, "output_type": "execute_result" } ], "source": [ "import asyncio\n", "\n", "async def coro(c):\n", " await asyncio.sleep(0.2)\n", " return c.lower()\n", "\n", "pacer = ev.Event()\n", "pipe = pacer.iterate('ABCDE').map(coro).connect(pacer.emit)\n", "pacer.emit() # kickstart pipeline\n", "\n", "await pipe.list()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The number of kicks detemines the number of tasks in-flight." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Async interoperability\n", "\n", "Two other event constructors that have not been mentioned yet are ``Wait``, which waits on a Future, and ``Aiterate`` which creates an Event from an async iterator. The latter one is particularly intereresting: Just like an event, an asynchronous iterator produces values at certain times. The values have to be pulled out of the iterator, which makes it a 'pull' type of method. Events on the other hand are fully 'push' based.\n", "\n", "Besides producing a time series of values, async iterators can also throw exceptions and indicate when they have ended. To achieve parity with this, an Event has two additional sub events, called ``error_event`` and ``done_event`` (who have no error or done events themselves to avoid infinite recursion). When an event encounters an error or is done, this is emitted by the corresponding sub event.\n", "\n", "With this machinery in place, it is straightforward to go from Event to async iterator:" ] }, { "cell_type": "code", "execution_count": 32, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "2019-03-17 09:23:47\n", "2019-03-17 09:23:47.250000\n", "2019-03-17 09:23:47.500000\n", "2019-03-17 09:23:47.750000\n", "2019-03-17 09:23:48\n", "2019-03-17 09:23:48.250000\n", "2019-03-17 09:23:48.500000\n", "2019-03-17 09:23:48.750000\n" ] } ], "source": [ "event = ev.Timerange(0, 2, 0.25)\n", "\n", "async for t in event:\n", " print(t)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "and back:" ] }, { "cell_type": "code", "execution_count": 33, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "['K', 'L', 'M', 'N', 'O', 'P']" ] }, "execution_count": 33, "metadata": {}, "output_type": "execute_result" } ], "source": [ "async def ait(r):\n", " for i in r:\n", " await asyncio.sleep(0.1)\n", " yield i\n", " \n", "event = ev.Aiterate(ait('KLMNOP'))\n", "\n", "await event.list()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "or from Event to Future:" ] }, { "cell_type": "code", "execution_count": 34, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "['OK']" ] }, "execution_count": 34, "metadata": {}, "output_type": "execute_result" } ], "source": [ "def getFut(result):\n", " fut = asyncio.Future()\n", " loop = asyncio.get_event_loop()\n", " loop.call_later(1, fut.set_result, result)\n", " return fut\n", "\n", "fut = getFut('OK')\n", "event = ev.Wait(fut)\n", "\n", "await event.list()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "or back:" ] }, { "cell_type": "code", "execution_count": 35, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "3" ] }, "execution_count": 35, "metadata": {}, "output_type": "execute_result" } ], "source": [ "event = ev.Range(3, 10)\n", "\n", "await event" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Notice how awaiting an event produces the first emitted value." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The event operators can also be applied to straight async iterators:" ] }, { "cell_type": "code", "execution_count": 36, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "(0, 'X')\n", "(1, 'K')\n", "(2, 'A')\n", "(3, 'Y')\n", "(4, 'L')\n", "(5, 'B')\n", "(6, 'Z')\n", "(7, 'M')\n", "(8, 'C')\n" ] } ], "source": [ "async for t in ev.Merge(ait('XYZ'), ait('KLM'), ait('ABC')).enumerate():\n", " print(t)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "or futures:" ] }, { "cell_type": "code", "execution_count": 37, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)" ] }, "execution_count": 37, "metadata": {}, "output_type": "execute_result" } ], "source": [ "futs = [getFut(i) for i in range(10)]\n", "\n", "await ev.Zip(*futs)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In the last two examples, where have the events gone? They have been abstracted away, but are still working in the background." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Final words\n", "\n", "While the emphasis of this library is on realtime events, an event can be any sort of data.\n", "The applicability of the library's operators is very general and allows for composing all kinds of data pipelines that can execute both synchronous or asynchronous.\n", "\n", "**Bonus riddle:**" ] }, { "cell_type": "code", "execution_count": 38, "metadata": {}, "outputs": [], "source": [ "async def wave(a, b):\n", " c = 100\n", " return a + b / c, b - a / c\n", "\n", "start = ev.Event()\n", "pipe = start.map(wave).star().take(1000).connect(start.emit).list()\n", "start.emit(0, 1)\n", "\n", "await pipe;" ] }, { "cell_type": "code", "execution_count": 39, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "plt.plot(pipe.value());" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now where do these nice sine and cosine waves come from?" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.7.3" } }, "nbformat": 4, "nbformat_minor": 2 } ================================================ FILE: requirements.txt ================================================ numpy ================================================ FILE: setup.cfg ================================================ [flake8] ignore = D100,D101,D102,D105,D107,D200,D205,D400,D401,D402,E402,F401,I100,I102,I202,W503 ================================================ FILE: setup.py ================================================ import os import codecs from setuptools import setup, find_packages here = os.path.abspath(os.path.dirname(__file__)) with codecs.open(os.path.join(here, 'README.rst'), encoding='utf-8') as f: long_description = f.read() __version__ = '' exec(open(os.path.join(here, 'eventkit', 'version.py')).read()) setup( name='eventkit', version=__version__, description='Event-driven data pipelines', long_description=long_description, url='https://github.com/erdewit/eventkit', author='Ewald R. de Wit', author_email='ewald.de.wit@gmail.com', license='BSD', classifiers=[ 'Development Status :: 4 - Beta', 'Intended Audience :: Science/Research', 'Intended Audience :: Developers', 'License :: OSI Approved :: BSD License', 'Programming Language :: Python :: 3.6', 'Programming Language :: Python :: 3.7', 'Programming Language :: Python :: 3.8', 'Programming Language :: Python :: 3.9', 'Programming Language :: Python :: 3.10', 'Programming Language :: Python :: 3.11', 'Programming Language :: Python :: 3.12', 'Programming Language :: Python :: 3 :: Only', ], keywords=('python asyncio event driven data pipelines'), packages=find_packages(), test_suite="tests", install_requires=['numpy'], ) ================================================ FILE: tests/__init__.py ================================================ ================================================ FILE: tests/aggregate_test.py ================================================ import unittest from eventkit import Event array = list(range(10)) class AggregateTest(unittest.TestCase): def test_min(self): event = Event.sequence(array).min() self.assertEqual(event.run(), [0] * 10) def test_max(self): event = Event.sequence(array).max() self.assertEqual(event.run(), array) def test_sum(self): event = Event.sequence(array).sum() self.assertEqual(event.run(), [ 0, 1, 3, 6, 10, 15, 21, 28, 36, 45]) def test_product(self): event = Event.sequence(array[1:]).product() self.assertEqual(event.run(), [ 1, 2, 6, 24, 120, 720, 5040, 40320, 362880]) def test_any(self): event = Event.sequence(array).any() self.assertEqual(event.run(), [ False, True, True, True, True, True, True, True, True, True]) def test_all(self): x = [True] * 10 + [False] * 10 event = Event.sequence(x).all() self.assertEqual(event.run(), x) def test_pairwaise(self): event = Event.sequence(array).pairwise() self.assertEqual(event.run(), list(zip(array, array[1:]))) def test_chunk(self): event = Event.sequence(array).chunk(3) self.assertEqual(event.run(), [[0, 1, 2], [3, 4, 5], [6, 7, 8], [9]]) def test_chunkwith(self): timer = Event.timer(0.029, 10) event = Event.sequence(array, 0.01).chunkwith(timer) self.assertEqual(event.run(), [[0, 1, 2], [3, 4, 5], [6, 7, 8], [9]]) def test_array(self): event = Event.sequence(array).array(5).last() self.assertEqual(list(event.run()[0]), array[-5:]) ================================================ FILE: tests/combine_test.py ================================================ import unittest from eventkit import Event array1 = list(range(10)) array2 = list(range(100, 110)) array3 = list(range(200, 210)) class CombineTest(unittest.TestCase): def test_merge(self): e1 = Event.sequence(array1, interval=0.01) e2 = Event.sequence(array2, interval=0.01).delay(0.001) event = e1.merge(e2) self.assertEqual(event.run(), [ i for j in zip(array1, array2) for i in j]) def test_switch(self): e1 = Event.sequence(array1, interval=0.01) e2 = Event.sequence(array2, interval=0.01).delay(0.001) e3 = Event.sequence(array3, interval=0.01).delay(0.002) event = e1.switch(e2, e3, e2) self.assertEqual(event.run(), [0, 100] + array3) def test_concat(self): e1 = Event.sequence(array1, interval=0.02) e2 = Event.sequence(array2, interval=0.02).delay(0.07) event = e1.concat(e2) self.assertEqual(event.run(), [ 0, 1, 2, 3, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109]) def test_chain(self): e1 = Event.sequence(array1, interval=0.01) e2 = Event.sequence(array2, interval=0.01).delay(0.001) event = e1.chain(e2, e1) self.assertEqual(event.run(), array1 + array2 + array1) def test_zip(self): e1 = Event.sequence(array1) e2 = Event.sequence(array2).delay(0.001) event = e1.zip(e2) self.assertEqual(event.run(), list(zip(array1, array2))) def test_zip_self(self): e1 = Event.sequence(array1) event = e1.zip(e1) self.assertEqual(event.run(), list(zip(array1, array1))) def test_ziplatest(self): e1 = Event.sequence([0, 1], interval=0.01) e2 = Event.sequence([2, 3], interval=0.01).delay(0.001) event = e1.ziplatest(e2) self.assertEqual( event.run(), [(0, Event.NO_VALUE), (0, 2), (1, 2), (1, 3)]) ================================================ FILE: tests/create_test.py ================================================ import asyncio import unittest from eventkit import Event array1 = list(range(10)) array2 = list(range(100, 110)) loop = asyncio.get_event_loop_policy().get_event_loop() class CreateTest(unittest.TestCase): def test_wait(self): fut = asyncio.Future(loop=loop) loop.call_later(0.001, fut.set_result, 42) event = Event.wait(fut) self.assertEqual(event.run(), [42]) def test_aiterate(self): async def ait(): await asyncio.sleep(0) for i in array1: yield i event = Event.aiterate(ait()) self.assertEqual(event.run(), array1) def test_marble(self): s = ' a b c d e f' event = Event.marble(s, interval=0.001) self.assertEqual(event.run(), [c for c in 'abcdef']) ================================================ FILE: tests/event_test.py ================================================ import asyncio import unittest from eventkit import Event import eventkit as ev loop = asyncio.get_event_loop_policy().get_event_loop() run = loop.run_until_complete class Object: def __init__(self): self.value = 0 def method(self, x, y): self.value += x - y def __call__(self, x, y): self.value += x - y async def ait(it): for x in it: await asyncio.sleep(0) yield x class EventTest(unittest.TestCase): def test_functor(self): obj1 = Object() obj2 = Object() event = Event('test') event += obj1 event.emit(9, 4) self.assertEqual(obj1.value, 5) event += obj2 event.emit(5, 6) self.assertEqual(obj1.value, 4) self.assertEqual(obj2.value, -1) del obj2 self.assertEqual(len(event), 1) event -= obj1 self.assertNotIn(obj1, event) self.assertEqual(len(event), 0) def test_method(self): obj1 = Object() obj2 = Object() event = Event('test') event += obj1.method event.emit(9, 4) self.assertEqual(obj1.value, 5) event += obj2.method event.emit(5, 6) self.assertEqual(obj1.value, 4) self.assertEqual(obj2.value, -1) del obj2 self.assertEqual(len(event), 1) event -= obj1.method self.assertNotIn(obj1.method, event) self.assertEqual(len(event), 0) event += obj1.method event += obj1.method self.assertEqual(len(event), 2) event.disconnect_obj(obj1) self.assertEqual(len(event), 0) def test_function(self): def f1(x, y): nonlocal value1 value1 += x - y def f2(x, y): nonlocal value2 value2 += x - y value1 = 0 value2 = 0 event = Event('test') event += f1 event.emit(9, 4) self.assertEqual(value1, 5) event += f2 event.emit(5, 6) self.assertEqual(value1, 4) self.assertEqual(value2, -1) event -= f1 self.assertNotIn(f1, event) event -= f2 self.assertNotIn(f2, event) self.assertEqual(len(event), 0) def test_cmethod(self): import math event = Event('test') event += math.pow event.emit(2, 8) def test_keep_ref(self): import weakref obj = Object() event = Event('test') event.connect(obj.method, keep_ref=True) wr = weakref.ref(obj) del obj event.emit(9, 4) self.assertEqual(wr().value, 5) obj = wr() event.emit(5, 6) self.assertEqual(obj.value, 4) self.assertIn(obj.method, event) event -= obj.method self.assertNotIn(obj.method, event) def test_coro_func(self): async def coro(d): result.append(d) await asyncio.sleep(0) result = [] event = Event('test') event += coro event.emit(4) event.emit(2) run(asyncio.sleep(0)) self.assertEqual(result, [4, 2]) result.clear() event -= coro event.emit(8) run(asyncio.sleep(0)) self.assertEqual(result, []) def test_aiter(self): async def coro(): return [v async for v in event] a = list(range(0, 10)) event = Event.sequence(a) result = run(coro()) self.assertEqual(result, a) def test_fork(self): event = Event.range(4, 10)[ev.Min, ev.Max, ev.Op().sum()].zip() self.assertEqual(event.run(), [ (4, 4, 4), (4, 5, 9), (4, 6, 15), (4, 7, 22), (4, 8, 30), (4, 9, 39)]) def test_operator_connect(self): result = [] ev1 = Event() ev2 = ev.Map(lambda x: x + 10) ev2 += result.append ev1 += ev2 for i in range(10): ev1.emit(i) self.assertEqual(result, list(range(10, 20))) if __name__ == "__main__": unittest.main() ================================================ FILE: tests/select_test.py ================================================ import unittest from eventkit import Event array = list(range(10)) class SelectTest(unittest.TestCase): def test_select(self): event = Event.sequence(array).filter(lambda x: x % 2) self.assertEqual(event.run(), [x for x in array if x % 2]) def test_skip(self): event = Event.sequence(array).skip(5) self.assertEqual(event.run(), array[5:]) def test_take(self): event = Event.sequence(array).take(5) self.assertEqual(event.run(), array[:5]) def test_takewhile(self): event = Event.sequence(array).takewhile(lambda x: x < 5) self.assertEqual(event.run(), array[:5]) def test_dropwhile(self): event = Event.sequence(array).dropwhile(lambda x: x < 5) self.assertEqual(event.run(), array[5:]) def test_changes(self): array = [1, 1, 2, 1, 2, 2, 2, 3, 1, 4, 4] event = Event.sequence(array).changes() self.assertEqual(event.run(), [1, 2, 1, 2, 3, 1, 4]) def test_unique(self): array = [1, 1, 2, 1, 2, 2, 2, 3, 1, 4, 4] event = Event.sequence(array).unique() self.assertEqual(event.run(), [1, 2, 3, 4]) def test_last(self): event = Event.sequence(array).last() self.assertEqual(event.run(), [9]) ================================================ FILE: tests/timing_test.py ================================================ import unittest import time from eventkit import Event array1 = list(range(10)) array2 = list(range(100, 110)) array3 = list(range(200, 210)) class TimingTest(unittest.TestCase): def test_delay(self): delay = 0.01 src = Event.sequence(array1, interval=0.01) e1 = src.timestamp().pluck(0) e2 = src.delay(delay).timestamp().pluck(0) r = e1.zip(e2).map(lambda a, b: b - a).mean().run() self.assertLess(abs(r[-1]), delay + 0.002) def test_sample(self): timer = Event.timer(0.021, 4) event = Event.range(10, interval=0.01).sample(timer) self.assertEqual(event.run(), [2, 4, 6, 8]) def test_timeout(self): timer = Event.timer(10, count=1) event = timer.timeout(0.01) self.assertEqual(event.run(), [Event.NO_VALUE]) def test_debounce(self): event = Event.range(10, interval=0.05) \ .mergemap(lambda t: Event.sequence(array2, 0.001)) \ .debounce(0.01) self.assertEqual(event.run(), [109] * 10) def test_debounce_on_first(self): event = Event.range(10, interval=0.05) \ .mergemap(lambda t: Event.sequence(array2, 0.001)) \ .debounce(0.02, on_first=True) self.assertEqual(event.run(), [100] * 10) def test_throttle(self): t0 = time.time() a = list(range(500)) event = Event.sequence(a) \ .throttle(1000, 0.1, cost_func=lambda i: 10) result = event.run() self.assertEqual(result, a) dt = time.time() - t0 self.assertLess(abs(dt - 0.5), 0.05) ================================================ FILE: tests/transform_test.py ================================================ import unittest import asyncio from collections import namedtuple import numpy as np from eventkit import Event loop = asyncio.get_event_loop_policy().get_event_loop() loop.set_debug(True) array = list(range(20)) class TransformTest(unittest.TestCase): def test_constant(self): event = Event.sequence(array).constant(42) self.assertEqual(event.run(), [42] * len(array)) def test_previous(self): event = Event.sequence(array).previous(2) self.assertEqual(event.run(), array[:-2]) def test_iterate(self): event = Event.sequence(array).iterate([5, 4, 3, 2, 1]) self.assertEqual(event.run(), [5, 4, 3, 2, 1]) def test_count(self): s = 'abcdefghij' event = Event.sequence(s).count() self.assertEqual(event.run(), array[:len(s)]) def test_enumerate(self): s = 'abcdefghij' event = Event.sequence(s).enumerate() self.assertEqual(event.run(), list(enumerate(s))) def test_timestamp(self): interval = 0.002 event = Event.sequence(array, interval=interval).timestamp() times = event.pluck(0).run() std = np.std(np.diff(times) - interval) self.assertLess(std, interval) def test_partial(self): event = Event.sequence(array).partial(42) self.assertEqual(event.run(), [(42, i) for i in array]) def test_partial_right(self): event = Event.sequence(array).partial_right(42) self.assertEqual(event.run(), [(i, 42) for i in array]) def test_star(self): def f(i, j): r.append((i, j)) r = [] event = Event.sequence(array).map(lambda i: (i, i)).star().connect(f) self.assertEqual(event.run(), r) def test_pack(self): event = Event.sequence(array).pack() self.assertEqual(event.run(), [(i,) for i in array]) def test_pluck(self): Person = namedtuple('Person', 'name address') Address = namedtuple('Address', 'city street number zipcode') data = [ Person('Max', Address('Delft', 'Levelstreet', '3', '2333AS')), Person('Elena', Address('Leiden', 'Punt', '122', '2412DE')), Person('Fem', Address('Rotterdam', 'Burgundy', '12', '3001RT'))] def event(): return Event.sequence(data) self.assertEqual( event().pluck('0.name', '.address.street').run(), [(d.name, d.address.street) for d in data]) def test_sync_map(self): event = Event.sequence(array).map(lambda x: x * x) self.assertEqual(event.run(), [i * i for i in array]) def test_sync_star_map(self): event = Event.sequence(array) event = event.map(lambda i: (i, i)).star().map(lambda x, y: x / 2 - y) self.assertEqual( event.run(), [x / 2 - y for x, y in zip(array, array)]) def test_async_map(self): async def coro(x): await asyncio.sleep(0.1) return x * x event = Event.sequence(array).map(coro) self.assertEqual(event.run(), [i * i for i in array]) def test_async_map_unordered(self): class A(): def __init__(self): self.t = 0.1 async def coro(self, x): self.t -= 0.01 await asyncio.sleep(self.t) return x * x a = A() event = Event.range(10).map(a.coro, ordered=False) result = set(event.run()) expected = set(i * i for i in reversed(range(10))) self.assertEqual(result, expected) def test_mergemap(self): marbles = [ 'A B C D', '_1 2 3 4', '__K L M N' ] event = Event.range(3) \ .mergemap(lambda v: Event.marble(marbles[v])) self.assertEqual(event.run(), [ 'A', '1', 'K', 'B', '2', 'L', '3', 'C', 'M', '4', 'D', 'N']) def test_mergemap2(self): a = ['ABC', 'UVW', 'XYZ'] event = Event.range(3, interval=0.01) \ .mergemap(lambda v: Event.sequence(a[v], 0.05 * v)) self.assertEqual(event.run(), [ 'A', 'B', 'C', 'U', 'X', 'V', 'W', 'Y', 'Z']) def test_concatmap(self): marbles = [ 'A B C D', '_ 1 2 3 4', '__ K L M N' ] event = Event.range(3) \ .concatmap(lambda v: Event.marble(marbles[v])) self.assertEqual(event.run(), [ 'A', 'B', '1', '2', '3', 'K', 'L', 'M', 'N']) def test_chainmap(self): marbles = [ 'A B C D ', '_ 1 2 3 4', '__ K L M N' ] event = Event.range(3) \ .chainmap(lambda v: Event.marble(marbles[v])) self.assertEqual(event.run(), [ 'A', 'B', 'C', 'D', '1', '2', '3', '4', 'K', 'L', 'M', 'N']) def test_switchmap(self): marbles = [ 'A B C D ', '_ K L M N', '__ 1 2 3 4' ] event = Event.range(3) \ .switchmap(lambda v: Event.marble(marbles[v])) self.assertEqual(event.run(), [ 'A', 'B', '1', '2', 'K', 'L', 'M', 'N'])