Warning: chmod(): Operation not permitted in /var/www/hopeinstoughton_www/wp-content/plugins/simple-universal-google-analytics/main.php on line 8 [0] in function chmod in /var/www/hopeinstoughton_www/wp-content/plugins/simple-universal-google-analytics/main.php on line 8 [1] in function include_once in /var/www/hopeinstoughton_www/wp-settings.php on line 560 [2] in function require_once in /var/www/hopeinstoughton_www/wp-config.php on line 85 [3] in function require_once in /var/www/hopeinstoughton_www/wp-load.php on line 50 [4] in function require_once in /var/www/hopeinstoughton_www/wp-blog-header.php on line 13 [5] in function require in /var/www/hopeinstoughton_www/index.php on line 17
| Server IP : 94.177.8.99 / Your IP : 216.73.217.165 Web Server : Apache/2.4.58 (Ubuntu) System : Linux aries 6.8.0-134-generic #134-Ubuntu SMP PREEMPT_DYNAMIC Fri Jun 26 18:43:11 UTC 2026 x86_64 User : www-data ( 33) PHP Version : 8.1.34 Disable Function : NONE MySQL : OFF | cURL : ON | WGET : ON | Perl : ON | Python : OFF | Sudo : ON | Pkexec : OFF Directory : /nuitka/eggshell.build/ |
Upload File : |
�� �tornado.platform.asyncio�.�� �BaseAsyncIOLoop���.�K .�h.�� �
import_object�.��9 �5only AsyncIOLoop is allowed when asyncio is available�.��
�IOLoop�.��
� configure�.�� �current�.��R XK Deprecated alias for `IOLoop.current()`.
.. versionchanged:: 5.0
Previously, this method returned a global singleton
`IOLoop`, in contrast with the per-thread `IOLoop` returned
by `current()`. In nearly all cases the two were the same
(when they differed, it was generally used from non-Tornado
threads to communicate back to the main thread's `IOLoop`).
This distinction is not present in `asyncio`, so in order
to facilitate integration with that package `instance()`
was changed to be an alias to `current()`. Applications
using the cross-thread communications aspect of
`instance()` should instead set their own global variable
to point to the `IOLoop` they want to use.
.. deprecated:: 5.0
�.�� � make_current�.��g X` Deprecated alias for `make_current()`.
.. versionchanged:: 5.0
Previously, this method would set this `IOLoop` as the
global singleton used by `IOLoop.instance()`. Now that
`instance()` is an alias for `current()`, `install()`
is an alias for `make_current()`.
.. deprecated:: 5.0
�.�� �
clear_current�.��r Xk Deprecated alias for `clear_current()`.
.. versionchanged:: 5.0
Previously, this method would clear the `IOLoop` used as
the global singleton by `IOLoop.instance()`. Now that
`instance()` is an alias for `current()`,
`clear_instance()` is an alias for `clear_current()`.
.. deprecated:: 5.0
�.�� �asyncio�.�� �get_event_loop�.��4 �builtins�� RuntimeError���h�AssertionError�����.�� �_ioloop_for_asyncio�.�� �AsyncIOMainLoop���.�h.�� ���.�� h ��.��J XC Returns the current thread's `IOLoop`.
If an `IOLoop` is currently running or has been marked as
current by `make_current`, returns that instance. If there is
no current `IOLoop` and ``instance`` is true, creates one.
.. versionchanged:: 4.1
Added ``instance`` argument to control the fallback to
`IOLoop.instance()`.
.. versionchanged:: 5.0
On Python 3, control of the current `IOLoop` is delegated
to `asyncio`, with this and other methods as pass-through accessors.
The ``instance`` argument now controls whether an `IOLoop`
is created automatically when there is none, instead of
whether we fall back to `IOLoop.instance()` (which is now
an alias for this method). ``instance=False`` is deprecated,
since even if we do not create an `IOLoop`, this method
may initialize the asyncio loop.
.. deprecated:: 6.2
It is deprecated to call ``IOLoop.current()`` when no `asyncio`
event loop is running.
�.��� X� Makes this the `IOLoop` for the current thread.
An `IOLoop` automatically becomes current for its thread
when it is started, but it is sometimes useful to call
`make_current` explicitly before starting the `IOLoop`,
so that code run at startup time can find the right
instance.
.. versionchanged:: 4.1
An `IOLoop` created while there is no current `IOLoop`
will automatically become current.
.. versionchanged:: 5.0
This method also sets the current `asyncio` event loop.
.. deprecated:: 6.2
The concept of an event loop that is "current" without
currently running is deprecated in asyncio since Python
3.10. All related functionality in Tornado is also
deprecated. Instead, start the event loop with `asyncio.run`
before interacting with it.
�.�� �warnings�.�� �warn�.�� �clear_current is deprecated�.�� �DeprecationWarning�.�� }��
stacklevel�Ks.�� �_clear_current�.�� ��Clears the `IOLoop` for the current thread.
Intended primarily for use by test frameworks in between tests.
.. versionchanged:: 5.0
This method also clears the current `asyncio` event loop.
.. deprecated:: 6.2
�.�� ���.�� �instance���.�� �_clear_current_hook�.�� � AsyncIOLoop���.�h(.��! � current IOLoop already exists�.��� X� Closes the `IOLoop`, freeing any resources used.
If ``all_fds`` is true, all file descriptors registered on the
IOLoop will be closed (not just the ones created by the
`IOLoop` itself).
Many applications will only use a single `IOLoop` that runs for the
entire lifetime of the process. In that case closing the `IOLoop`
is not necessary since everything will be cleaned up when the
process exits. `IOLoop.close` is provided mainly for scenarios
such as unit tests, which create and destroy a large number of
``IOLoops``.
An `IOLoop` must be completely stopped before it can be closed. This
means that `IOLoop.stop()` must be called *and* `IOLoop.start()` must
be allowed to return before attempting to call `IOLoop.close()`.
Therefore the call to `close` will usually appear just after
the call to `start` rather than near the call to `stop`.
.. versionchanged:: 3.1
If the `IOLoop` implementation supports non-integer objects
for "file descriptors", those objects will have their
``close`` method when ``all_fds`` is true.
�.��2 X+ Registers the given handler to receive the given events for ``fd``.
The ``fd`` argument may either be an integer file descriptor or
a file-like object with a ``fileno()`` and ``close()`` method.
The ``events`` argument is a bitwise or of the constants
``IOLoop.READ``, ``IOLoop.WRITE``, and ``IOLoop.ERROR``.
When an event occurs, ``handler(fd, events)`` will be run.
.. versionchanged:: 4.0
Added the ability to pass file-like objects in addition to
raw file descriptors.
�.��� ��Changes the events we listen for ``fd``.
.. versionchanged:: 4.0
Added the ability to pass file-like objects in addition to
raw file descriptors.
�.��� ��Stop listening for events on ``fd``.
.. versionchanged:: 4.0
Added the ability to pass file-like objects in addition to
raw file descriptors.
�.��� ��Starts the I/O loop.
The loop will run until one of the callbacks calls `stop()`, which
will make the loop stop after the current event iteration completes.
�.��� X� Stop the I/O loop.
If the event loop is not currently running, the next call to `start()`
will return immediately.
Note that even after `stop` has been called, the `IOLoop` is not
completely stopped until `IOLoop.start` has also returned.
Some work that was scheduled before the call to `stop` may still
be run before the `IOLoop` shuts down.
�.�� ]�Na.�� }��return�Ns.�� �run�.�� � IOLoop.run_sync.<locals>.run�.�� � add_callback�.�� �timeout_callback�.��- �)IOLoop.run_sync.<locals>.timeout_callback�.�� � add_timeout�.�� �time�.�� �start�.�� �timeout�.�� �remove_timeout�.�� �timeout_handle�.��
� cancelled�.�� �done�.�� � TimeoutError�.��( �$Operation timed out after %s seconds�.��
�result�.��� X� Starts the `IOLoop`, runs the given function, and stops the loop.
The function must return either an awaitable object or
``None``. If the function returns an awaitable object, the
`IOLoop` will run until the awaitable is resolved (and
`run_sync()` will return the awaitable's result). If it raises
an exception, the `IOLoop` will stop and the exception will be
re-raised to the caller.
The keyword-only argument ``timeout`` may be used to set
a maximum duration for the function. If the timeout expires,
a `asyncio.TimeoutError` is raised.
This method is useful to allow asynchronous calls in a
``main()`` function::
async def main():
# do stuff...
if __name__ == '__main__':
IOLoop.current().run_sync(main)
.. versionchanged:: 4.3
Returning a non-``None``, non-awaitable value is now an error.
.. versionchanged:: 5.0
If a timeout occurs, the ``func`` coroutine will be cancelled.
.. versionchanged:: 6.2
``tornado.util.TimeoutError`` is now an alias to ``asyncio.TimeoutError``.
�.�� �func�.�� � tornado.gen�.�� �convert_yielded���.�hG.��
�Future�.�� � future_cell�.�� �future_set_exc_info�.�� �sys�.�� �exc_info�.��
� is_future�.�� �
set_result�.�� �self�.�� �
add_future�.�� �<lambda>�.��2 �.IOLoop.run_sync.<locals>.run.<locals>.<lambda>�.�� �stop�.��
�cancel�.��� X� Returns the current time according to the `IOLoop`'s clock.
The return value is a floating-point number relative to an
unspecified time in the past.
Historically, the IOLoop could be customized to use e.g.
`time.monotonic` instead of `time.time`, but this is not
currently supported and so this method is equivalent to
`time.time`.
�.�� �numbers�.�� �Real�.�� �call_at�.�� �datetime�.��
� timedelta�.�� �
total_seconds�.�� �Unsupported deadline %r�.��� X� Runs the ``callback`` at the time ``deadline`` from the I/O loop.
Returns an opaque handle that may be passed to
`remove_timeout` to cancel.
``deadline`` may be a number denoting a time (on the same
scale as `IOLoop.time`, normally `time.time`), or a
`datetime.timedelta` object for a deadline relative to the
current time. Since Tornado 4.0, `call_later` is a more
convenient alternative for the relative case since it does not
require a timedelta object.
Note that it is not safe to call `add_timeout` from other threads.
Instead, you must use `add_callback` to transfer control to the
`IOLoop`'s thread, and then call `add_timeout` from there.
Subclasses of IOLoop must implement either `add_timeout` or
`call_at`; the default implementations of each will call
the other. `call_at` is usually easier to implement, but
subclasses that wish to maintain compatibility with Tornado
versions prior to 4.0 must use `add_timeout` instead.
.. versionchanged:: 4.0
Now passes through ``*args`` and ``**kwargs`` to the callback.
�.��� X� Runs the ``callback`` after ``delay`` seconds have passed.
Returns an opaque handle that may be passed to `remove_timeout`
to cancel. Note that unlike the `asyncio` method of the same
name, the returned object does not have a ``cancel()`` method.
See `add_timeout` for comments on thread-safety and subclassing.
.. versionadded:: 4.0
�.��� X� Runs the ``callback`` at the absolute time designated by ``when``.
``when`` must be a number using the same reference point as
`IOLoop.time`.
Returns an opaque handle that may be passed to `remove_timeout`
to cancel. Note that unlike the `asyncio` method of the same
name, the returned object does not have a ``cancel()`` method.
See `add_timeout` for comments on thread-safety and subclassing.
.. versionadded:: 4.0
�.��� ��Cancels a pending timeout.
The argument is a handle as returned by `add_timeout`. It is
safe to call `remove_timeout` even if the callback has already
been run.
�.��: X3 Calls the given callback on the next I/O loop iteration.
It is safe to call this method from any thread at any time,
except from a signal handler. Note that this is the **only**
method in `IOLoop` that makes this thread-safety guarantee; all
other interaction with the `IOLoop` must be done from that
`IOLoop`'s thread. `add_callback()` may be used to transfer
control from other threads to the `IOLoop`'s thread.
To add a callback from a signal handler, see
`add_callback_from_signal`.
�.��� ��Calls the given callback on the next I/O loop iteration.
Safe for use from a Python signal handler; should not be used
otherwise.
�.��� ��Calls the given callback on the next IOLoop iteration.
As of Tornado 6.0, this method is equivalent to `add_callback`.
.. versionadded:: 4.0
�.�� �add_done_callback�.��' �#IOLoop.add_future.<locals>.<lambda>�.�� �future_add_done_callback�.��H XA Schedules a callback on the ``IOLoop`` when the given
`.Future` is finished.
The callback is invoked with one argument, the
`.Future`.
This method only accepts `.Future` objects and not other
awaitables (unlike most of Tornado where the two are
interchangeable).
�.�� �
_run_callback�.�� �partial�.�� �callback�.��
�future�.��
� _executor�.�� �tornado.process�.�� � cpu_count���.�ho.�� �
concurrent�.�� �futures�.�� �ThreadPoolExecutor�.�K.�� � max_workers���.��
�submit�.��, �(IOLoop.run_in_executor.<locals>.<lambda>�.��� ��Runs a function in a ``concurrent.futures.Executor``. If
``executor`` is ``None``, the IO loop's default executor will be used.
Use `functools.partial` to pass keyword arguments to ``func``.
.. versionadded:: 5.0
�.�� � chain_future�.�� �t_future�.��j �fSets the default executor to use with :meth:`run_in_executor`.
.. versionadded:: 5.0
�.�� �tornado�.�� �gen���.�h}.�� �
BadYieldError�.�� �ret�.�� �_discard_future_result�.�� �CancelledError�.�� �app_log�.�� �error�.�� �Exception in callback %r�.�� }�hM�s.��� ��Runs a callback with error handling.
.. versionchanged:: 6.0
CancelledErrors are no longer logged.
�.��? �;Avoid unhandled-exception warnings from spawned coroutines.�.��
�fileno�.�� �os�.�� �close�.�� �deadline�.�� �_timeout_counter�.��
� tdeadline�.�� K��.�� � milliseconds���.�� �
callback_time�.��8 �4Periodic callback must have a positive callback_time�.��
�jitter�.�� �_running�.�� �_timeout�.�� �io_loop�.�� �
_next_timeout�.�� �_schedule_next�.�� �Starts the timer.�.�� �Stops the timer.�.��j �fReturns ``True`` if this `.PeriodicCallback` has been started.
.. versionadded:: 4.1
�.�� � isawaitable�.�� �val�.�� �_run�.�� �PeriodicCallback._run�.�� � _update_next�.��
G@�@ .�K.��
�random�.��
G?� .�� �math�.�� �floor�.��� X� An I/O event loop for non-blocking sockets.
In Tornado 6.0, `.IOLoop` is a wrapper around the `asyncio` event loop, with a
slightly different interface. The `.IOLoop` interface is now provided primarily
for backwards compatibility; new code should generally use the `asyncio` event
loop interface directly. The `IOLoop.current` class method provides the
`IOLoop` instance corresponding to the running `asyncio` event loop.
�.�� �__doc__�.��< �8/usr/local/lib/python3.8/dist-packages/tornado/ioloop.py�.�� �__file__�.�� �__spec__�.��
�origin�.�� � has_location�.�� �
__cached__�.�� �concurrent.futures�.��
� functools�.�� �inspect�.�� h���.�� �tornado.concurrent�.�� (hIhNhyhKhgt�.�� � tornado.log�.�� h���.�� � tornado.util�.�� � Configurable�hAh��.�h�.��
�typing�.�� �Union�.�� �Any�.�� �Type�.�� �Optional�.�� �Callable�.�� �TypeVar�.�� �Tuple�.��
� Awaitable�.�� �Protocol�.��
� metaclass�.�� � __prepare__�.�� � _Selectable�.�� � __getitem__�.��2 �.%s.__prepare__() must return a mapping, not %s�.�� �__name__�.�� � <metaclass>�.�� �tornado.ioloop�.�� �
__module__�.�� � __qualname__�.�h3.�� �int�.�� �_Selectable.fileno�.�� �_Selectable.close�.�� �__orig_bases__�.�� �_T���.�� �_T�.�� �_S���.�� �bound���.�� �_S�.��� X� An I/O event loop.
As of Tornado 6.0, `IOLoop` is a wrapper around the `asyncio` event loop.
Example usage for a simple TCP server:
.. testcode::
import asyncio
import errno
import functools
import socket
import tornado.ioloop
from tornado.iostream import IOStream
async def handle_connection(connection, address):
stream = IOStream(connection)
message = await stream.read_until_close()
print("message from client:", message.decode().strip())
def connection_ready(sock, fd, events):
while True:
try:
connection, address = sock.accept()
except BlockingIOError:
return
connection.setblocking(0)
io_loop = tornado.ioloop.IOLoop.current()
io_loop.spawn_callback(handle_connection, connection, address)
async def main():
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM, 0)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
sock.setblocking(0)
sock.bind(("", 8888))
sock.listen(128)
io_loop = tornado.ioloop.IOLoop.current()
callback = functools.partial(connection_ready, sock)
io_loop.add_handler(sock.fileno(), callback, io_loop.READ)
await asyncio.Event().wait()
if __name__ == "__main__":
asyncio.run(main())
.. testoutput::
:hide:
Most applications should not attempt to construct an `IOLoop` directly,
and instead initialize the `asyncio` event loop and use `IOLoop.current()`.
In some cases, such as in test frameworks when initializing an `IOLoop`
to be run in a secondary thread, it may be appropriate to construct
an `IOLoop` with ``IOLoop(make_current=False)``. Constructing an `IOLoop`
without the ``make_current=False`` argument is deprecated since Tornado 6.2.
In general, an `IOLoop` cannot survive a fork or be shared across processes
in any way. When multiple processes are being used, each process should
create its own `IOLoop`, which also implies that any objects which depend on
the `IOLoop` (such as `.AsyncHTTPClient`) must also be created in the child
processes. As a guideline, anything that starts processes (including the
`tornado.process` and `multiprocessing` modules) should do so as early as
possible, ideally the first thing the application does after loading its
configuration, and *before* any calls to `.IOLoop.start` or `asyncio.run`.
.. versionchanged:: 4.2
Added the ``make_current`` keyword argument to the `IOLoop`
constructor.
.. versionchanged:: 5.0
Uses the `asyncio` event loop by default. The ``IOLoop.configure`` method
cannot be used on Python 3 except to redundantly specify the `asyncio`
event loop.
.. deprecated:: 6.2
It is deprecated to create an event loop that is "current" but not
running. This means it is deprecated to pass
``make_current=True`` to the ``IOLoop`` constructor, or to create
an ``IOLoop`` while no asyncio event loop is running unless
``make_current=False`` is used.
�.�� �NONE�.�� �READ�.�K.�� �WRITE�.�K.�� �ERROR�.�� �dict�.�� � classmethod�.�� �impl�.��( �$Union[None, str, Type[Configurable]]�.��
�kwargs�.�� �IOLoop.configure�.�� � staticmethod�.�� }�h3�IOLoop�s.�h%.�� �IOLoop.instance�.�� �install�.�� �IOLoop.install�.�� �clear_instance�.�� �IOLoop.clear_instance�.�� �overload�.�� �IOLoop.current�.�� �bool�.�� �IOLoop.make_current�.�� �IOLoop.clear_current�.�� �IOLoop._clear_current�.��� ��Instance method called when an IOLoop ceases to be current.
May be overridden by subclasses as a counterpart to make_current.
�.�� �IOLoop._clear_current_hook�.�� �configurable_base�.�� �IOLoop.configurable_base�.�� �configurable_default�.�� �IOLoop.configurable_default�.�� N��.�� �
initialize�.�� �IOLoop.initialize�.�� �all_fds�.�� � IOLoop.close�.�� �fd�.�� �handler�.��
�events�.�� � add_handler�.�� �IOLoop.add_handler�.��W � nuitka.constants.Serialization��BuiltinSpecialValue���)��}��value��Ellipsis�sbN��.�� �update_handler�.�� �IOLoop.update_handler�.�� �remove_handler�.�� �IOLoop.remove_handler�.�� � IOLoop.start�.�� � IOLoop.stop�.�� �float�.�� �run_sync�.�� �IOLoop.run_sync�.�� � IOLoop.time�.�� �args�.��
�object�.�� �IOLoop.add_timeout�.�� �delay�.�� �
call_later�.�� �IOLoop.call_later�.�� �when�.�� �IOLoop.call_at�.�� �IOLoop.remove_timeout�.�� �IOLoop.add_callback�.�� �add_callback_from_signal�.��# � IOLoop.add_callback_from_signal�.�� �spawn_callback�.�� �IOLoop.spawn_callback�.��4 �0Union[Future[_T], concurrent.futures.Future[_T]]�.�� ]��
Future[_T]�aN��.�� �IOLoop.add_future�.�� �executor�.�� �Executor�.�� �run_in_executor�.�� �IOLoop.run_in_executor�.�� �set_default_executor�.�� �IOLoop.set_default_executor�.�� �IOLoop._run_callback�.��! � IOLoop._discard_future_result�.�� �split_fd�.�� �IOLoop.split_fd�.�� �close_fd�.�� �IOLoop.close_fd�.�� h�object�����.�� �_Timeout�.��6 �2An IOLoop timeout, a UNIX timestamp and a callback�.��' ]�(�deadline��callback�� tdeadline�e.��
� __slots__�.�� ]�N��.�� �__init__�.�� �_Timeout.__init__�.�� �other�.��
�__lt__�.�� �_Timeout.__lt__�.��
�__le__�.�� �_Timeout.__le__�.�� �PeriodicCallback�.��� X� Schedules the given callback to be called periodically.
The callback is called every ``callback_time`` milliseconds when
``callback_time`` is a float. Note that the timeout is given in
milliseconds, while most other time-related functions in Tornado use
seconds. ``callback_time`` may alternatively be given as a
`datetime.timedelta` object.
If ``jitter`` is specified, each callback time will be randomly selected
within a window of ``jitter * callback_time`` milliseconds.
Jitter can be used to reduce alignment of events with similar periods.
A jitter of 0.1 means allowing a 10% variation in callback time.
The window is centered on ``callback_time`` so the total number of calls
within a given interval should not be significantly affected by adding
jitter.
If the callback runs for longer than ``callback_time`` milliseconds,
subsequent invocations will be skipped to get back on schedule.
`start` must be called after the `PeriodicCallback` is created.
.. versionchanged:: 5.0
The ``io_loop`` argument (deprecated since version 4.1) has been removed.
.. versionchanged:: 5.1
The ``jitter`` argument is added.
.. versionchanged:: 6.2
If the ``callback`` argument is a coroutine, and a callback runs for
longer than ``callback_time``, subsequent invocations will be skipped.
Previously this was only true for regular functions, not coroutines,
which were "fire-and-forget" for `PeriodicCallback`.
The ``callback_time`` argument now accepts `datetime.timedelta` objects,
in addition to the previous numeric milliseconds.
�.�� K ��.�� �PeriodicCallback.__init__�.�� �PeriodicCallback.start�.�� �PeriodicCallback.stop�.�� �
is_running�.�� �PeriodicCallback.is_running�.��# � PeriodicCallback._schedule_next�.�� � current_time�.��! � PeriodicCallback._update_next�.�� (�f�hPhkhlt�.�� hkhlhP��.��
jP hz��.�� hz��.�� hlhP��.�� hP��.�� �<module tornado.ioloop>�.�� � __class__���.�� (hPhkh�h�t�.�� (hPh�hkh�t�.��
hPj@ ��.�� �old���.�� hPhl��.�� hPh���.�� (hPhkh�h}t�.�� hPjN �callback_time_sec���.�� (hPhkj h�t�.�� hPhlhk��.�� (hPh�h�h�t�.�� (hPh�hkj h�t�.�� (hPj hkj h�t�.�� (hPj hkj h�t�.�� hPh���.�� hPh���.�� �cls���.��
jl h(��.�� (jl h�h�hjX t�.�� (h%�loop�hht�.�� hPh h��.�� hPh<��.�� (hChG�fut�hEhJhPt�.�� hEhJhP��.��! (hPj& hEj ho�c_future�hzt�.�� (hPhEh<hJh4h7h>t�.��
hPj& ��.�� hJhP��.�� hPh�h���.�� � �.