3

	��fs�@s�dZd
dl
Z
d
dlmZ
d
dlZd
dlZd
dlZd
dlZd
dlZd
dl	Z	d
dl
Z
d
dlZd
dlZd
dl
mZ
d
dlmZmZ
d
dlmZ
d
dlmZmZ
d
dl
mZ
d
d	lmZ
d
d
lmZ
d
dlmZ
d
dlmZm Z 
d
d
l!m"Z"
d
dl#Z#d
dl#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*
d
dl+m,Z,
e#j-�
rNd
dl#m.Z.
e$e*e'e/e*e/e*e,fZ0eZ1d0e2e$e
j
e3fd�dd�Z4e5d�
dd�Z6Gdd�de7�Z8Gdd�dej9�Z:Gdd�de:�Z;Gdd�de;�Z<e#j=dd �
e5e&e&d!e)ed"ffg
e&d1fd#�d$d%��
Z>e#j=e&d!e)ed"ffe&d2d&�d'd%��
Z>d3e&d!e)ed"ffe5e)e&d4e&e&d!e)ed"ffg
e&d5ffd(�d)d%�Z>de>_?Gd*d+�d+ej@�ZAe%dd,�d-d.�ZBeCd/k�r�eB�
dS)6a�
Support classes for automated testing.

* `AsyncTestCase` and `AsyncHTTPTestCase`:  Subclasses of unittest.TestCase
  with additional support for testing asynchronous (`.IOLoop`-based) code.

* `ExpectLog`: Make test logs less spammy.

* `main()`: A simple test runner (wrapper around unittest.main()) with support
  for the tornado.autoreload module to rerun the tests when code changes.
�N)
�	Generator)
�gen)�AsyncHTTPClient�HTTPResponse)
�
HTTPServer)�IOLoop�TimeoutError)
�netutil)
�AsyncIOMainLoop)
�
Subprocess)
�app_log)�raise_exc_info�basestring_type)
�Application)�Tuple�Any�Callable�Type�Dict�Union�Optional)
�
TracebackType)
�	CoroutineF)�
reuse_port�returnc
Cs,tj
d
dtj|d�d
}
|
j�d}|
|fS)z�Binds a server socket to an available port on localhost.

    Returns a tuple (socket, port).

    .. versionchanged:: 4.4
       Always binds to ``127.0.0.1`` without resolving the name
       ``localhost``.
    r
z	127.0.0.1)Zfamilyr�
)r	Zbind_sockets�socketZAF_INETZgetsockname)r�sock�port�r�/usr/lib64/python3.6/testing.py�bind_unused_port4s
	



r!)
rc
Cs6tj
jd
�
}|dk	r2yt|�
Stk
r0


YnXdS)z}Get the global timeout setting for async tests.

    Returns a float, the timeout in seconds.

    .. versionadded:: 3.1
    ZASYNC_TEST_TIMEOUTN�)�os�environ�get�float�
ValueError)
�envrrr �get_async_test_timeoutDs





r)c@sBeZ
dZd
Zedd�dd�Zeedd�dd�Zeed	�d
d�Z	dS)�_TestMethodWrappera~
Wraps a test method to raise an error if it returns a value.

    This is mainly used to detect undecorated generators (if a test
    method yields it must use a decorator to consume the generator),
    but will also detect other kinds of return values (these are not
    necessarily errors, but we alert anyway since there is no good
    reason to return a value from a test).
    N)�orig_methodrcCs
|
|_dS)
N)
r+)�selfr+rrr �__init__^s
z_TestMethodWrapper.__init__)�args�kwargsrc
OsB|j|
|�
}t
|t�s tj|�
r*td
�
�
n|dk	r>td|�
�
dS)NzVGenerator and coroutine test methods should be decorated with tornado.testing.gen_testz)Return value from test method ignored: %r)r+�
isinstancer�inspect�iscoroutine�	TypeErrorr')r,r.r/�resultrrr �__call__as




z_TestMethodWrapper.__call__)�namercCst|j
|
�S)
z�Proxy all unknown attributes to the original method.

        This is important for some of the decorators in the `unittest`
        module, such as `unittest.skipIf`.
        )�getattrr+)r,r6rrr �__getattr__ksz_TestMethodWrapper.__getattr__)
�__name__�
__module__�__qualname__�__doc__rr-rr5�strr8rrrr r*Ts
r*cs�eZ
dZd
Zdedd��f
dd�
Zdd�
�f
dd	�Zdd�
�f
d
d�Zed�
dd
�Z	e
eeee
d�dd�Zdd�
dd�Zdejejd��f
dd�
Zdeedd�dd�Zd ede
fedd�dd�Z�ZS)!�
AsyncTestCasea�`~unittest.TestCase` subclass for testing `.IOLoop`-based
    asynchronous code.

    The unittest framework is synchronous, so the test must be
    complete by the time the test method returns. This means that
    asynchronous code cannot be used in quite the same way as usual
    and must be adapted to fit. To write your tests with coroutines,
    decorate your test methods with `tornado.testing.gen_test` instead
    of `tornado.gen.coroutine`.

    This class also provides the (deprecated) `stop()` and `wait()`
    methods for a more manual style of testing. The test method itself
    must call ``self.wait()``, and asynchronous callbacks should call
    ``self.stop()`` to signal completion.

    By default, a new `.IOLoop` is constructed for each test and is available
    as ``self.io_loop``.  If the code being tested requires a
    global `.IOLoop`, subclasses should override `get_new_ioloop` to return it.

    The `.IOLoop`'s ``start`` and ``stop`` methods should not be
    called directly.  Instead, use `self.stop <stop>` and `self.wait
    <wait>`.  Arguments passed to ``self.stop`` are returned from
    ``self.wait``.  It is possible to have multiple ``wait``/``stop``
    cycles in the same test.

    Example::

        # This test uses coroutine style.
        class MyTestCase(AsyncTestCase):
            @tornado.testing.gen_test
            def test_http_fetch(self):
                client = AsyncHTTPClient()
                response = yield client.fetch("http://www.tornadoweb.org")
                # Test contents of response
                self.assertIn("FriendFeed", response.body)

        # This test uses argument passing between self.stop and self.wait.
        class MyTestCase2(AsyncTestCase):
            def test_http_fetch(self):
                client = AsyncHTTPClient()
                client.fetch("http://www.tornadoweb.org/", self.stop)
                response = self.wait()
                # Test contents of response
                self.assertIn("FriendFeed", response.body)
    �runTestN)�
methodNamercsNtt
|�j|
�

d
|_d
|_d|_d|_d|_t||
t	t
||
��
�
d|_dS)NF)�superr>r-�_AsyncTestCase__stopped�_AsyncTestCase__running�_AsyncTestCase__failure�_AsyncTestCase__stop_args�_AsyncTestCase__timeout�setattrr*r7�_test_generator)r,r@)
�	__class__rr r-�s





zAsyncTestCase.__init__)
rc

s&tt
|�j�
|j�|_|jj�
dS)
N)rAr>�setUp�get_new_ioloop�io_loopZmake_current)
r,)
rIrr rJ�s



zAsyncTestCase.setUpc
s�|jj
}
ttd
�rtj|
�
�ntjj|
�
�dd��D�
�x�D]}|j�
q>W�r�|jj�f
dd��
\}}|stt�
x0|D](}y|j	�
Wqztj
k
r�


YqzXqzWtj�
|jj
�
t|jt�s�|jjdd�

tt|�j�
|j�
dS)N�	all_tasksc
Ssg|]}
|
j�s|
�qSr)
�done)�.0�
trrr �
<listcomp>�sz*AsyncTestCase.tearDown.<locals>.<listcomp>cs
tj
��
S)
N)�asyncio�waitr)
�tasksrr �<lambda>�sz(AsyncTestCase.tearDown.<locals>.<lambda>T)
Zall_fds)rL�asyncio_loop�hasattrrRrMZTaskZcancel�run_sync�AssertionErrorr4ZCancelledErrorrZuninitializeZ
clear_currentr0�_NON_OWNED_IOLOOPS�closerAr>�tearDown�_AsyncTestCase__rethrow)r,rVrPrN�pending�
f)
rI)
rTr r\�s*


















zAsyncTestCase.tearDownc


Cst�S)
a�
Returns the `.IOLoop` to use for this test.

        By default, a new `.IOLoop` is created for each test.
        Subclasses may override this method to return
        `.IOLoop.current()` if it is not appropriate to use a new
        `.IOLoop` in each tests (for example, if there are global
        singletons using the default `.IOLoop`) or if a per-test event
        loop is being provided by another system (such as
        ``pytest-asyncio``).
        )
r)
r,rrr rK�szAsyncTestCase.get_new_ioloop)�typ�value�tbrcCs8|jdkr|
||f|_nt
jd
|
||fd�
|j�
dS)Nz%multiple unhandled exceptions in test)
�exc_infoT)rDr�error�stop)r,r`rarbrrr �_handle_exception�s



zAsyncTestCase._handle_exceptionc
Cs"|jdk	r|j}
d|_t
|
�

dS)
N)rDr
)r,Zfailurerrr Z	__rethrow

s




zAsyncTestCase.__rethrow)r4rcstt
|�j|
�
}|j�
|S)
N)rAr>�runr])r,r4�ret)
rIrr rg
s

zAsyncTestCase.run)�_argr/rcKs<|
d
ks|st�
|p|
|_
|jr2|jj�
d|_d|_d
S)aI
Stops the `.IOLoop`, causing one pending (or future) call to `wait()`
        to return.

        Keyword arguments or a single positional argument passed to `stop()` are
        saved and will be returned by `wait()`.

        .. deprecated:: 5.1

           `stop` and `wait` are deprecated; use ``@gen_test`` instead.
        NFT)rYrErCrLrerB)r,rir/rrr re
s






zAsyncTestCase.stop.)�	condition�timeoutrcs��
d
krt��
�j
s��
rFd
d�
��
fdd�}�jj�jj��
|��_x.d�_�jj�
�jd
k	sp|
d
ksp|
�rHPqHW�jd
k	r��jj	�j�

d
�_�j
s�t
�
d�_
�j�
�j}d
�_|S)a�Runs the `.IOLoop` until stop is called or timeout has passed.

        In the event of a timeout, an exception will be thrown. The
        default timeout is 5 seconds; it may be overridden with a
        ``timeout`` keyword argument or globally with the
        ``ASYNC_TEST_TIMEOUT`` environment variable.

        If ``condition`` is not ``None``, the `.IOLoop` will be restarted
        after `stop()` until ``condition()`` returns ``True``.

        .. versionchanged:: 3.1
           Added the ``ASYNC_TEST_TIMEOUT`` environment variable.

        .. deprecated:: 5.1

           `stop` and `wait` are deprecated; use ``@gen_test`` instead.
        N)
rcs>y�jd
�
�
�
Wnt
k
r0


tj��_YnX�j�
dS)Nz*Async operation timed out after %s seconds)ZfailureException�	Exception�sysrcrDrer)r,rkrr �timeout_func<
s




z(AsyncTestCase.wait.<locals>.timeout_funcTF)
r)rBrLZadd_timeoutZtimerFrC�startrDZremove_timeoutrYr]rE)r,rjrkrnr4r)r,rkr rS"
s*

	
















zAsyncTestCase.wait)
r?)
N)
N)NN)r9r:r;r<r=r-rJr\rrKrrlr�boolrfr]�unittestZ
TestResult�TestCasergrrerr&rS�
__classcell__rr)
rIr r>ts-/


	
r>cs�eZ
dZd
Zdd�
�f
dd�Zed�
dd�Zed�
dd	�Ze	d�
d
d�Z
deee
ed
�dd�Zeee
fd�
dd�Zed�
dd�Zed�
dd�Zeed�dd�Zdd�
�f
dd�Z�ZS)�AsyncHTTPTestCasearA test case that starts up an HTTP server.

    Subclasses must override `get_app()`, which returns the
    `tornado.web.Application` (or other `.HTTPServer` callback) to be tested.
    Tests will typically use the provided ``self.http_client`` to fetch
    URLs from this server.

    Example, assuming the "Hello, world" example from the user guide is in
    ``hello.py``::

        import hello

        class TestHelloApp(AsyncHTTPTestCase):
            def get_app(self):
                return hello.make_app()

            def test_homepage(self):
                response = self.fetch('/')
                self.assertEqual(response.code, 200)
                self.assertEqual(response.body, 'Hello, world')

    That call to ``self.fetch()`` is equivalent to ::

        self.http_client.fetch(self.get_url('/'), self.stop)
        response = self.wait()

    which illustrates how AsyncTestCase can turn an asynchronous operation,
    like ``http_client.fetch()``, into a synchronous operation. If you need
    to do other asynchronous operations in tests, you'll probably need to use
    ``stop()`` and ``wait()`` yourself.
    N)
rc
sNtt
|�j�
t�\}
}||_|j�|_|j�|_|j	�|_
|j
j|
g
�

dS)
N)rArtrJr!�_AsyncHTTPTestCase__port�get_http_client�http_client�get_app�_app�get_http_server�http_serverZadd_sockets)r,rr)
rIrr rJy
s









zAsyncHTTPTestCase.setUpc


Cst�S)
N)
r)
r,rrr rv�
s
z!AsyncHTTPTestCase.get_http_clientc

Cst|j
f
|j��
S)
N)rry�get_httpserver_options)
r,rrr rz�
s
z!AsyncHTTPTestCase.get_http_serverc


Cs
t��
d
S)zzShould be overridden by subclasses to return a
        `tornado.web.Application` or other `.HTTPServer` callback.
        N)
�NotImplementedError)
r,rrr rx�
szAsyncHTTPTestCase.get_appF)�path�raise_errorr/rcs>|
j�j
d�
r|
�n
�j|
�
��jj��
��fdd�t�d�S)aEConvenience method to synchronously fetch a URL.

        The given path will be appended to the local server's host and
        port.  Any additional keyword arguments will be passed directly to
        `.AsyncHTTPClient.fetch` (and so could be used to pass
        ``method="POST"``, ``body="..."``, etc).

        If the path begins with http:// or https://, it will be treated as a
        full URL and will be fetched as-is.

        If ``raise_error`` is ``True``, a `tornado.httpclient.HTTPError` will
        be raised if the response code is not 200. This is the same behavior
        as the ``raise_error`` argument to `.AsyncHTTPClient.fetch`, but
        the default is ``False`` here (it's ``True`` in `.AsyncHTTPClient`)
        because tests often need to deal with non-200 response codes.

        .. versionchanged:: 5.0
           Added support for absolute URLs.

        .. versionchanged:: 5.1

           Added the ``raise_error`` argument.

        .. deprecated:: 5.1

           This method currently turns any exception into an
           `.HTTPResponse` with status code 599. In Tornado 6.0,
           errors other than `tornado.httpclient.HTTPError` will be
           passed through, and ``raise_error=False`` will only
           suppress errors that would be raised due to non-200
           response codes.

        �http://�https://cs�jj
�f
d
�
i
���
S)Nr)rw�fetchr)r/rr,�urlrr rU�
sz)AsyncHTTPTestCase.fetch.<locals>.<lambda>)
rk)r�r�)�lower�
startswith�get_urlrLrXr))r,r~rr/r)r/rr,r�r r��
s$




zAsyncHTTPTestCase.fetchc


CsiS)
zgMay be overridden by subclasses to return additional
        keyword arguments for the server.
        r)
r,rrr r|�
sz(AsyncHTTPTestCase.get_httpserver_optionsc


Cs|jS)
zZReturns the port used by the server.

        A new port is chosen for each test.
        )
ru)
r,rrr �
get_http_port�
szAsyncHTTPTestCase.get_http_portc


Csd
S)NZhttpr)
r,rrr �get_protocol�
s
zAsyncHTTPTestCase.get_protocol)r~rcCsd
|j�|j
�|
fS)z>Returns an absolute url for the given path on the test server.z%s://127.0.0.1:%s%s)r�r�)r,r~rrr r��
szAsyncHTTPTestCase.get_urlc

sD|jj
�
|jj|jjt�d
�
|jj�
|`|`t	t
|�j�
dS)N)
rk)r{rerLrXZclose_all_connectionsr)rwr[ryrArtr\)
r,)
rIrr r\�
s







zAsyncHTTPTestCase.tearDown)
F)r9r:r;r<rJrrvrrzrrxr=rprrr�rr|�intr�r�r�r\rsrr)
rIr rtX
s

+rtc@sreZ
dZd
Zed�
dd�Zeeefd�
dd�Z	eeefd�
dd�Z
eeeefd�
d	d
��
Zed�
dd�Z
d
S)�AsyncHTTPSTestCasezjA test case that starts an HTTPS server.

    Interface is generally the same as `AsyncHTTPTestCase`.
    )
rc

Cstd
t
dd�
d�S)NTF)
Z
validate_cert)Zforce_instanceZdefaults)r�dict)
r,rrr rv�
s
z"AsyncHTTPSTestCase.get_http_clientc

Cst|j
�d
�
S)N)
Zssl_options)r��get_ssl_options)
r,rrr r|�
s
z)AsyncHTTPSTestCase.get_httpserver_optionsc


Cstj
�S)
zMay be overridden by subclasses to select SSL options.

        By default includes a self-signed testing certificate.
        )r��default_ssl_options)
r,rrr r��
sz"AsyncHTTPSTestCase.get_ssl_optionsc
Cs0tj
jt�
}ttj
j|d
d�tj
j|d
d�d�S)NZtestztest.crtztest.key)ZcertfileZkeyfile)r#r~�dirname�__file__r��join)
Z
module_dirrrr r��
s


z&AsyncHTTPSTestCase.default_ssl_optionsc


Csd
S)NZhttpsr)
r,rrr r��
s
zAsyncHTTPSTestCase.get_protocolN)r9r:r;r<rrvrr=rr|r��staticmethodr�r�rrrr r��
s

r�)
rk.r)rkrc


CsdS)
Nr)
rkrrr �gen_test�
sr�)�funcrc


CsdS)
Nr)
r�rrr r�s)r�rkrcsN�d
krt��t
dttdfft
dd��f
dd�}|d
k	rF||�
S|Sd
S)a1Testing equivalent of ``@gen.coroutine``, to be applied to test methods.

    ``@gen.coroutine`` cannot be used on tests because the `.IOLoop` is not
    already running.  ``@gen_test`` should be applied to test methods
    on subclasses of `AsyncTestCase`.

    Example::

        class MyTest(AsyncHTTPTestCase):
            @gen_test
            def test_something(self):
                response = yield self.http_client.fetch(self.get_url('/'))

    By default, ``@gen_test`` times out after 5 seconds. The timeout may be
    overridden globally with the ``ASYNC_TEST_TIMEOUT`` environment variable,
    or for each test with the ``timeout`` keyword argument::

        class MyTest(AsyncHTTPTestCase):
            @gen_test(timeout=10)
            def test_something_slow(self):
                response = yield self.http_client.fetch(self.get_url('/'))

    Note that ``@gen_test`` is incompatible with `AsyncTestCase.stop`,
    `AsyncTestCase.wait`, and `AsyncHTTPTestCase.fetch`. Use ``yield
    self.http_client.fetch(self.get_url())`` as shown above instead.

    .. versionadded:: 3.1
       The ``timeout`` argument and ``ASYNC_TEST_TIMEOUT`` environment
       variable.

    .. versionchanged:: 4.0
       The wrapper now passes along ``*args, **kwargs`` so it can be used
       on functions with arguments.

    N.r)r_rc
sLtj
�
�
�
f
d
d��
}
tj�
�
r&|
�n
tj|
�
�tj
��
��fdd��
}|S)Nc
s6�|f
|
�|�
}t|t
�s$tj|�
r,||_nd|_|S)
N)r0rr1r2rH)r,r.r/r4)
r_rr �
pre_coroutine>s



z-gen_test.<locals>.wrap.<locals>.pre_coroutinec
sty |jj
tj�|f|
�|�
�
d
�Stk
rn
}
z2|jdk	r\t|jdd�r\|jjt|�
|�
�WYdd}~XnXdS)N)
rk�
cr_runningT)	rLrX�	functools�partialrrHr7�throw�type)r,r.r/�
e)�cororkrr �post_coroutineNs


z.gen_test.<locals>.wrap.<locals>.post_coroutine)r��wrapsr1Ziscoroutinefunctionr�	coroutine)r_r�r�)
rk)r�r_r �wrap5s	


zgen_test.<locals>.wrap).N)r)rrr)r�rkr�r)
rkr r�	s)
(3c@sleZ
dZd
Zdeejefee	dd�dd�Z
eje	d�dd	�Zdd
�
dd�Z
d
eeeedd�dd�ZdS)�	ExpectLoga�
Context manager to capture and suppress expected log output.

    Useful to make tests of error conditions less noisy, while still
    leaving unexpected log entries visible.  *Not thread safe.*

    The attribute ``logged_stack`` is set to ``True`` if any exception
    stack trace was logged.

    Usage::

        with ExpectLog('tornado.application', "Uncaught exception"):
            error_response = self.fetch("/some_page")

    .. versionchanged:: 4.3
       Added the ``logged_stack`` attribute.
    TN)�logger�regex�requiredrcCs<t|
t
�rtj|
�
}
|
|_tj|�
|_||_d
|_	d
|_
dS)a�
Constructs an ExpectLog context manager.

        :param logger: Logger object (or name of logger) to watch.  Pass
            an empty string to watch the root logger.
        :param regex: Regular expression to match.  Any log entries on
            the specified logger that match this regex will be suppressed.
        :param required: If true, an exception will be raised if the end of
            the ``with`` statement is reached without matching any log entries.
        FN)r0r�loggingZ	getLoggerr��re�compiler�r��matched�logged_stack)r,r�r�r�rrr r-�s







zExpectLog.__init__)�recordrcCs.|
jrd
|_
|
j�}|jj|�
r*d
|_dSd
S)NTF)rcr�Z
getMessager��matchr�)r,r��messagerrr �filter�s






zExpectLog.filter)
rc

Cs|jj
|�

|S)
N)r�Z	addFilter)
r,rrr �	__enter__�s

zExpectLog.__enter__zOptional[Type[BaseException]])r`rarbrcCs,|jj
|�

|
r(|jr(|jr(td
�
�
dS)Nz did not get expected log message)r�ZremoveFilterr�r�rl)r,r`rarbrrr �__exit__�s

zExpectLog.__exit__)
T)r9r:r;r<rr�ZLoggerrr=rpr-Z	LogRecordr�r�r�
BaseExceptionrr�rrrr r�xs
	


r�)r/rcKsT
d
dlm
}
m}m}
|
dtddd�
|
dtd�
|
d	td�
|
d
td�
|
dtd�
|
dtd�
tjd
g
|tj�
}|js�tjtj	tj
�
|jd
k	r�d|d<|jd
k	r�d
|d<|j
d
k	r�d|d
<|jd
k	r�d|d<|jd
k	r�d|d<tdko�t|�
dk�
rtdtjd�
tjd�

t|�
dk�
r:tjfd
|d�|��

ntjfd|d�|��

d
S)aA simple test runner.

    This test runner is essentially equivalent to `unittest.main` from
    the standard library, but adds support for Tornado-style option
    parsing and log formatting. It is *not* necessary to use this
    `main` function to run tests using `AsyncTestCase`; these tests
    are self-contained and can run with any test runner.

    The easiest way to run a test is via the command line::

        python -m tornado.testing tornado.test.web_test

    See the standard library ``unittest`` module for ways in which
    tests can be specified.

    Projects with many tests may wish to define a test script like
    ``tornado/test/runtests.py``.  This script should define a method
    ``all()`` which returns a test suite and then call
    `tornado.testing.main()`.  Note that even when a test script is
    used, the ``all()`` test suite may be overridden by naming a
    single test on the command line::

        # Runs all tests
        python -m tornado.test.runtests
        # Runs one test
        python -m tornado.test.runtests tornado.test.web_test

    Additional keyword arguments passed through to ``unittest.main()``.
    For example, use ``tornado.testing.main(verbosity=2)``
    to show many test details as they are run.
    See http://docs.python.org/library/unittest.html#unittest.main
    for full argument list.

    .. versionchanged:: 5.0

       This function produces no output of its own; only that produced
       by the `unittest` module (previously it would add a PASS or FAIL
       log message).
    r
)�define�options�parse_command_line�exception_on_interruptTz�If true (default), ctrl-c raises a KeyboardInterrupt exception.  This prints a stack trace but cannot interrupt certain operations.  If false, the process is more reliably killed, but does not print a stack trace.)r��default�help�verbose)
r��quiet�failfast�catch�bufferN��	verbosityZ
catchbreak�__main__rzNo tests specified)
�file)�module�argv�all)ZdefaultTestr�)Ztornado.optionsr�r�r�rprmr�r��signal�SIGINT�SIG_DFLr�r�r�r�r�r9�len�print�stderr�exitrq�main)r/r�r�r�r�rrr r��s<(

























r�r�)
F).N).N)NN).N).N)Dr<rR�collections.abcrr�r1r�r#r�r�rrmrqZtornadorZtornado.httpclientrrZtornado.httpserverrZtornado.iolooprrr	Ztornado.platform.asyncior
Ztornado.processrZtornado.logrZtornado.utilr
rZtornado.webrZtypingrrrrrrr�typesrZ
TYPE_CHECKINGrr�Z
_ExcInfoTuplerZrpr�r!r&r)�objectr*rrr>rtr�Zoverloadr�Z__test__�Filterr�r�r9rrrr �<module>
sf



















$

 e"
.
&


0hA\