def test_ctor_loop(self): loop = unittest.mock.Mock() lock = locks.Lock(loop=loop) self.assertIs(lock._loop, loop) lock = locks.Lock(loop=self.loop) self.assertIs(lock._loop, self.loop)
def test_ctor_noloop(self): try: events.set_event_loop(self.loop) lock = locks.Lock() self.assertIs(lock._loop, self.loop) finally: events.set_event_loop(None)
def test_release_no_waiters(self): lock = locks.Lock(loop=self.loop) self.loop.run_until_complete(lock.acquire()) self.assertTrue(lock.locked()) lock.release() self.assertFalse(lock.locked())
def test_acquire_cancel(self): lock = locks.Lock(loop=self.loop) self.assertTrue(self.loop.run_until_complete(lock.acquire())) task = tasks.Task(lock.acquire(), loop=self.loop) self.loop.call_soon(task.cancel) self.assertRaises(futures.CancelledError, self.loop.run_until_complete, task) self.assertFalse(lock._waiters)
def test_context_manager_no_yield(self): lock = locks.Lock(loop=self.loop) try: with lock: self.fail('RuntimeError is not raised in with expression') except RuntimeError as err: self.assertEqual( str(err), '"yield from" should be used as context manager expression')
def test_context_manager(self): lock = locks.Lock(loop=self.loop) @tasks.coroutine def acquire_lock(): return (yield from lock) with self.loop.run_until_complete(acquire_lock()): self.assertTrue(lock.locked()) self.assertFalse(lock.locked())
def test_acquire(self): lock = locks.Lock(loop=self.loop) result = [] self.assertTrue(self.loop.run_until_complete(lock.acquire())) @tasks.coroutine def c1(result): if (yield from lock.acquire()): result.append(1) return True @tasks.coroutine def c2(result): if (yield from lock.acquire()): result.append(2) return True @tasks.coroutine def c3(result): if (yield from lock.acquire()): result.append(3) return True t1 = tasks.Task(c1(result), loop=self.loop) t2 = tasks.Task(c2(result), loop=self.loop) test_utils.run_briefly(self.loop) self.assertEqual([], result) lock.release() test_utils.run_briefly(self.loop) self.assertEqual([1], result) test_utils.run_briefly(self.loop) self.assertEqual([1], result) t3 = tasks.Task(c3(result), loop=self.loop) lock.release() test_utils.run_briefly(self.loop) self.assertEqual([1, 2], result) lock.release() test_utils.run_briefly(self.loop) self.assertEqual([1, 2, 3], result) self.assertTrue(t1.done()) self.assertTrue(t1.result()) self.assertTrue(t2.done()) self.assertTrue(t2.result()) self.assertTrue(t3.done()) self.assertTrue(t3.result())
def test_repr(self): lock = locks.Lock(loop=self.loop) self.assertTrue(repr(lock).endswith('[unlocked]>')) self.assertTrue(RGX_REPR.match(repr(lock))) @tasks.coroutine def acquire_lock(): yield from lock self.loop.run_until_complete(acquire_lock()) self.assertTrue(repr(lock).endswith('[locked]>')) self.assertTrue(RGX_REPR.match(repr(lock)))
def test_lock(self): lock = locks.Lock(loop=self.loop) @tasks.coroutine def acquire_lock(): return (yield from lock) res = self.loop.run_until_complete(acquire_lock()) self.assertTrue(res) self.assertTrue(lock.locked()) lock.release() self.assertFalse(lock.locked())
def test_cancel_race(self): # Several tasks: # - A acquires the lock # - B is blocked in aqcuire() # - C is blocked in aqcuire() # # Now, concurrently: # - B is cancelled # - A releases the lock # # If B's waiter is marked cancelled but not yet removed from # _waiters, A's release() call will crash when trying to set # B's waiter; instead, it should move on to C's waiter. # Setup: A has the lock, b and c are waiting. lock = locks.Lock(loop=self.loop) @tasks.coroutine def lockit(name, blocker): yield from lock.acquire() try: if blocker is not None: yield from blocker finally: lock.release() fa = futures.Future(loop=self.loop) ta = tasks.Task(lockit('A', fa), loop=self.loop) test_utils.run_briefly(self.loop) self.assertTrue(lock.locked()) tb = tasks.Task(lockit('B', None), loop=self.loop) test_utils.run_briefly(self.loop) self.assertEqual(len(lock._waiters), 1) tc = tasks.Task(lockit('C', None), loop=self.loop) test_utils.run_briefly(self.loop) self.assertEqual(len(lock._waiters), 2) # Create the race and check. # Without the fix this failed at the last assert. fa.set_result(None) tb.cancel() self.assertTrue(lock._waiters[0].cancelled()) test_utils.run_briefly(self.loop) self.assertFalse(lock.locked()) self.assertTrue(ta.done()) self.assertTrue(tb.cancelled()) self.assertTrue(tc.done())
def __init__(self, loop=None): self._store = {} self._lock = locks.Lock(loop=loop)
def __init__(self, pair: str): self._bids = dict() self._asks = dict() self._async_lock = locks.Lock() self._pair = pair
from asyncio import locks from discord import Client, Message, TextChannel from interact import append_messages, generate_message from config import TOKEN, talk_id, view_id client = Client() client.message_list = [] lock = locks.Lock() @client.event async def on_message(person_message: Message): # we do not want the bot to reply to itself if person_message.author == client.user: return channel: TextChannel = person_message.channel if channel.id != talk_id: return # view: TextChannel = client.get_channel(view_id) await lock.acquire() my_message = person_message.clean_content # if my_message != '': # await view.send(my_message) append_messages(client.message_list, [my_message]) async with channel.typing(): my_response = generate_message(client.message_list)
def __init__(self): self._store = {} self._lock = locks.Lock()
def test_release_not_acquired(self): lock = locks.Lock(loop=self.loop) self.assertRaises(RuntimeError, lock.release)