def test_init_constructor_default_loop(self):
try:
events.set_event_loop(self.loop)
f = futures.Future()
self.assertIs(f._loop, self.loop)
finally:
events.set_event_loop(None)
def test_ctor_noloop(self):
try:
events.set_event_loop(self.loop)
q = queues.Queue()
self.assertIs(q._loop, self.loop)
finally:
events.set_event_loop(None)
def test_ctor_noloop(self):
try:
events.set_event_loop(self.loop)
cond = locks.Condition()
self.assertIs(cond._loop, self.loop)
finally:
events.set_event_loop(None)
def test_ctor_noloop(self):
try:
events.set_event_loop(self.loop)
sem = locks.Semaphore()
self.assertIs(sem._loop, self.loop)
finally:
events.set_event_loop(None)
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_ctor_noloop(self):
try:
events.set_event_loop(self.loop)
cond = locks.Condition()
self.assertIs(cond._loop, self.loop)
finally:
events.set_event_loop(None)
def test_wait_with_global_loop(self):
def gen():
when = yield
self.assertAlmostEqual(0.01, when)
when = yield 0
self.assertAlmostEqual(0.015, when)
yield 0.015
loop = test_utils.TestLoop(gen)
self.addCleanup(loop.close)
a = tasks.Task(tasks.sleep(0.01, loop=loop), loop=loop)
b = tasks.Task(tasks.sleep(0.015, loop=loop), loop=loop)
@tasks.coroutine
def foo():
done, pending = yield from tasks.wait([b, a])
self.assertEqual(done, set([a, b]))
self.assertEqual(pending, set())
return 42
events.set_event_loop(loop)
try:
res = loop.run_until_complete(
tasks.Task(foo(), loop=loop))
finally:
events.set_event_loop(None)
self.assertEqual(res, 42)
def run(self, debug=False):
if events._get_running_loop() is not None:
raise RuntimeError("There is already a running event loop")
async def runner():
try:
await self.start()
finally:
await self.close()
loop = self.loop
try:
events.set_event_loop(loop)
loop.set_debug(debug)
loop.run_until_complete(runner())
except KeyboardInterrupt:
self.logger.info("Received signal to terminate tasks and event loop.")
finally:
try:
self.logger.debug("Cleaning up tasks.")
_cancel_all_tasks(loop)
loop.run_until_complete(loop.shutdown_asyncgens())
# loop.run_until_complete(loop.shutdown_default_executor())
finally:
events.set_event_loop(None)
self.logger.info("Closing event loop.")
def test_ctor_noloop(self):
try:
events.set_event_loop(self.loop)
q = queues.Queue()
self.assertIs(q._loop, self.loop)
finally:
events.set_event_loop(None)
def test_wait_for_with_global_loop(self):
def gen():
when = yield
self.assertAlmostEqual(0.2, when)
when = yield 0
self.assertAlmostEqual(0.01, when)
yield 0.01
loop = test_utils.TestLoop(gen)
self.addCleanup(loop.close)
@tasks.coroutine
def foo():
yield from tasks.sleep(0.2, loop=loop)
return 'done'
events.set_event_loop(loop)
try:
fut = tasks.Task(foo(), loop=loop)
with self.assertRaises(futures.TimeoutError):
loop.run_until_complete(tasks.wait_for(fut, 0.01))
finally:
events.set_event_loop(None)
self.assertAlmostEqual(0.01, loop.time())
self.assertFalse(fut.done())
# move forward to close generator
loop.advance_time(10)
loop.run_until_complete(fut)
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_init_constructor_default_loop(self):
try:
events.set_event_loop(self.loop)
f = futures.Future()
self.assertIs(f._loop, self.loop)
finally:
events.set_event_loop(None)
def test_ctor_noloop(self):
try:
events.set_event_loop(self.loop)
ev = locks.Event()
self.assertIs(ev._loop, self.loop)
finally:
events.set_event_loop(None)
def test_ctor_noloop(self):
try:
events.set_event_loop(self.loop)
ev = locks.Event()
self.assertIs(ev._loop, self.loop)
finally:
events.set_event_loop(None)
def test_wait_for_with_global_loop(self):
def gen():
when = yield
self.assertAlmostEqual(0.2, when)
when = yield 0
self.assertAlmostEqual(0.01, when)
yield 0.01
loop = test_utils.TestLoop(gen)
self.addCleanup(loop.close)
@tasks.coroutine
def foo():
yield from tasks.sleep(0.2, loop=loop)
return 'done'
events.set_event_loop(loop)
try:
fut = tasks.Task(foo(), loop=loop)
with self.assertRaises(futures.TimeoutError):
loop.run_until_complete(tasks.wait_for(fut, 0.01))
finally:
events.set_event_loop(None)
self.assertAlmostEqual(0.01, loop.time())
self.assertFalse(fut.done())
# move forward to close generator
loop.advance_time(10)
loop.run_until_complete(fut)
def tearDown(self):
"""Tear down test."""
if self._exception:
try:
self.machine.shutdown()
except:
pass
if self._exception and 'exception' in self._exception:
raise self._exception['exception']
elif self._exception:
raise Exception(self._exception)
duration = time.time() - self.test_start_time
if duration > self.expected_duration:
print("Test {}.{} took {} > {}s".format(self.__class__,
self._testMethodName,
round(duration, 2),
self.expected_duration))
self.machine.log.debug("Test ended")
if sys.exc_info != (None, None, None):
# disable teardown logging after error
logging.basicConfig(level=99)
else:
# fire all delays
self.advance_time_and_run(300)
self.machine._do_stop()
self.machine = None
self.restore_sys_path()
events.set_event_loop(None)
def test_wait_with_global_loop(self):
def gen():
when = yield
self.assertAlmostEqual(0.01, when)
when = yield 0
self.assertAlmostEqual(0.015, when)
yield 0.015
loop = test_utils.TestLoop(gen)
self.addCleanup(loop.close)
a = tasks.Task(tasks.sleep(0.01, loop=loop), loop=loop)
b = tasks.Task(tasks.sleep(0.015, loop=loop), loop=loop)
@tasks.coroutine
def foo():
done, pending = yield from tasks.wait([b, a])
self.assertEqual(done, set([a, b]))
self.assertEqual(pending, set())
return 42
events.set_event_loop(loop)
try:
res = loop.run_until_complete(tasks.Task(foo(), loop=loop))
finally:
events.set_event_loop(None)
self.assertEqual(res, 42)
def set_event_loop(self, loop, *, cleanup=True):
if loop is None:
raise AssertionError('loop is None')
# ensure that the event loop is passed explicitly in asyncio
events.set_event_loop(None)
if cleanup:
self.addCleanup(self.close_loop, loop)
def test_ctor_noloop(self):
try:
events.set_event_loop(self.loop)
sem = locks.Semaphore()
self.assertIs(sem._loop, self.loop)
finally:
events.set_event_loop(None)
def sitemap_gen(link, link_key):
if '--iocp' in sys.argv:
sys.argv.remove('--iocp')
logging.info('using iocp')
el = windows_events.ProactorEventLoop()
events.set_event_loop(el)
root_url = link
crawler(root_url, out_file=f'sitemap_{link_key}.xml')
def tearDown(self):
events.set_event_loop(None)
# Detect CPython bug #23353: ensure that yield/yield-from is not used
# in an except block of a generator
self.assertEqual(sys.exc_info(), (None, None, None))
self.doCleanups()
threading_helper.threading_cleanup(*self._thread_cleanup)
support.reap_children()
def asyncio_run(future): # NOQA:WPS440
"""Execute future in loop.
:param future: some future
:return: result
"""
loop = events.new_event_loop()
future_result = loop.run_until_complete(future)
events.set_event_loop(None)
loop.close()
return future_result # NOQA:WPS331
def _check_empty_sequence(self, seq_or_iter):
events.set_event_loop(self.one_loop)
self.addCleanup(events.set_event_loop, None)
fut = tasks.gather(*seq_or_iter)
self.assertIsInstance(fut, futures.Future)
self.assertIs(fut._loop, self.one_loop)
self._run_loop(self.one_loop)
self.assertTrue(fut.done())
self.assertEqual(fut.result(), [])
fut = tasks.gather(*seq_or_iter, loop=self.other_loop)
self.assertIs(fut._loop, self.other_loop)
def _check_empty_sequence(self, seq_or_iter):
events.set_event_loop(self.one_loop)
self.addCleanup(events.set_event_loop, None)
fut = tasks.gather(*seq_or_iter)
self.assertIsInstance(fut, futures.Future)
self.assertIs(fut._loop, self.one_loop)
self._run_loop(self.one_loop)
self.assertTrue(fut.done())
self.assertEqual(fut.result(), [])
fut = tasks.gather(*seq_or_iter, loop=self.other_loop)
self.assertIs(fut._loop, self.other_loop)
def run(main):
loop = events.new_event_loop()
try:
events.set_event_loop(loop)
return loop.run_until_complete(main)
finally:
try:
loop.run_until_complete(loop.shutdown_asyncgens())
finally:
events.set_event_loop(None)
loop.close()
def tearDown(self):
self.unpatch_get_running_loop()
events.set_event_loop(None)
# Detect CPython bug #23353: ensure that yield/yield-from is not used
# in an except block of a generator
self.assertEqual(sys.exc_info(), (None, None, None))
self.doCleanups()
support.threading_cleanup(*self._thread_cleanup)
support.reap_children()
def setUp(self):
super(AsyncIOTestCase, self).setUp()
# Ensure that the event loop is passed explicitly in Motor.
events.set_event_loop(None)
self.loop = asyncio.new_event_loop()
if self.ssl and not env.mongod_started_with_ssl:
raise SkipTest("mongod doesn't support SSL, or is down")
self.cx = self.asyncio_client(ssl=self.ssl)
self.db = self.cx.motor_test
self.collection = self.db.test_collection
def setUp(self):
super(AsyncIOTestCase, self).setUp()
# Ensure that the event loop is passed explicitly in Motor.
events.set_event_loop(None)
self.loop = asyncio.new_event_loop()
if self.ssl and not env.mongod_started_with_ssl:
raise SkipTest("mongod doesn't support SSL, or is down")
self.cx = self.asyncio_client(ssl=self.ssl)
self.db = self.cx.motor_test
self.collection = self.db.test_collection
def test_open_connection_no_loop_ssl(self):
with test_utils.run_test_server(use_ssl=True) as httpd:
try:
events.set_event_loop(self.loop)
f = streams.open_connection(*httpd.address,
ssl=test_utils.dummy_ssl_context())
reader, writer = self.loop.run_until_complete(f)
finally:
events.set_event_loop(None)
writer.write(b'GET / HTTP/1.0\r\n\r\n')
f = reader.read()
data = self.loop.run_until_complete(f)
self.assertTrue(data.endswith(b'\r\n\r\nTest message'))
writer.close()
def test_open_connection_no_loop_ssl(self):
with test_utils.run_test_server(use_ssl=True) as httpd:
try:
events.set_event_loop(self.loop)
f = streams.open_connection(*httpd.address,
ssl=test_utils.dummy_ssl_context())
reader, writer = self.loop.run_until_complete(f)
finally:
events.set_event_loop(None)
writer.write(b'GET / HTTP/1.0\r\n\r\n')
f = reader.read()
data = self.loop.run_until_complete(f)
self.assertTrue(data.endswith(b'\r\n\r\nTest message'))
writer.close()
def run(main, *, debug=False):
loop = events._get_running_loop()
if not loop:
loop = events.new_event_loop()
events.set_event_loop(loop)
_patch_loop(loop)
loop.set_debug(debug)
task = asyncio.ensure_future(main)
try:
return loop.run_until_complete(task)
finally:
if not task.done():
task.cancel()
with suppress(asyncio.CancelledError):
loop.run_until_complete(task)
def main():
parser = argparse.ArgumentParser(description='MadCars Bot Competition')
parser.add_argument('-n',
'--num-games',
type=int,
help='Total number of games',
required=True)
parser.add_argument('-d',
'--model-dir',
type=str,
help='NN model root directory',
required=True)
parser.add_argument('-l',
'--log-interval',
type=int,
help='Rating print interval',
default=50)
parser.add_argument('-c',
'--cache-path',
type=str,
default='competition_cache.json',
help='Ragings JSON cache')
args = parser.parse_args()
model_dir: str = args.model_dir
num_games: int = args.num_games
cache_path: str = args.cache_path
log_interval: int = args.log_interval
ts.setup(draw_probability=0.0001)
loop = events.new_event_loop()
events.set_event_loop(loop)
clients = get_simple_bots() + get_nn_bots(model_dir)
clients = load_ratings(cache_path, clients)
games_played = 0
while games_played < num_games:
games_played += log_interval
ratings = run_competition(clients, log_interval)
ratings = sorted(ratings, key=lambda t: -ts.expose(t[1]))
save_ratings(cache_path, clients)
print(f'-- RATINGS {games_played} --')
for name, rating in ratings:
print(
f'{ts.expose(rating):4.1f} ({rating.mu:4.1f} +- {rating.sigma * 3:4.1f}): {name:<32}'
)
def native_run(main, *, debug=False):
# Snatched from Python 3.7
from asyncio import coroutines
from asyncio import events
from asyncio import tasks
def _cancel_all_tasks(loop):
to_cancel = all_tasks(loop)
if not to_cancel:
return
for task in to_cancel:
task.cancel()
loop.run_until_complete(
tasks.gather(*to_cancel, loop=loop, return_exceptions=True))
for task in to_cancel:
if task.cancelled():
continue
if task.exception() is not None:
loop.call_exception_handler({
'message':
'unhandled exception during asyncio.run() shutdown',
'exception': task.exception(),
'task': task,
})
if events._get_running_loop() is not None:
raise RuntimeError(
"asyncio.run() cannot be called from a running event loop")
if not coroutines.iscoroutine(main):
raise ValueError("a coroutine was expected, got {!r}".format(main))
loop = events.new_event_loop()
try:
events.set_event_loop(loop)
loop.set_debug(debug)
return loop.run_until_complete(main)
finally:
try:
_cancel_all_tasks(loop)
loop.run_until_complete(loop.shutdown_asyncgens())
finally:
events.set_event_loop(None)
loop.close()
def native_run(main: Awaitable[_T], *, debug: bool = False) -> _T:
"""Run a coroutine.
This function runs the passed coroutine, taking care of
managing the asyncio event loop and finalizing asynchronous
generators.
This function cannot be called when another asyncio event loop is
running in the same thread.
If debug is True, the event loop will be run in debug mode.
This function always creates a new event loop and closes it at the end.
It should be used as a main entry point for asyncio programs, and should
ideally only be called once.
Example:
async def main():
await asyncio.sleep(1)
print('hello')
asyncio.run(main())
"""
from asyncio import events, coroutines
if events._get_running_loop() is not None:
raise RuntimeError(
"asyncio.run() cannot be called from a running event loop")
if not coroutines.iscoroutine(main):
raise ValueError("a coroutine was expected, got {!r}".format(main))
loop = events.new_event_loop()
try:
events.set_event_loop(loop)
loop.set_debug(debug)
return loop.run_until_complete(main)
finally:
try:
_cancel_all_tasks(loop)
loop.run_until_complete(loop.shutdown_asyncgens())
finally:
events.set_event_loop(None) # type: ignore
loop.close()
def async_run(main):
"""
A simplified version of Python 3.7+ run
"""
if events._get_running_loop() is not None: # pylint: disable=protected-access
raise RuntimeError(
"asyncio.run() cannot be called from a running event loop"
)
if not coroutines.iscoroutine(main):
raise ValueError("a coroutine was expected, got {!r}".format(main))
loop = events.new_event_loop()
try:
events.set_event_loop(loop)
return loop.run_until_complete(main)
finally:
events.set_event_loop(None)
loop.close()
def setUp(self):
super().setUp()
self.loop = self.create_event_loop()
events.set_event_loop(None)
print(len(self.done), 'completed tasks,', len(self.tasks),
'still pending, todo', len(self.todo))
def main():
loop = asyncio.get_event_loop()
c = Crawler(sys.argv[1], loop)
asyncio.Task(c.run())
try:
loop.add_signal_handler(signal.SIGINT, loop.stop)
except RuntimeError:
pass
loop.run_forever()
print('todo:', len(c.todo))
print('busy:', len(c.busy))
print('done:', len(c.done), '; ok:', sum(c.done.values()))
print('tasks:', len(c.tasks))
if __name__ == '__main__':
if '--iocp' in sys.argv:
from asyncio import events, windows_events
sys.argv.remove('--iocp')
logging.info('using iocp')
el = windows_events.ProactorEventLoop()
events.set_event_loop(el)
main()
def setUp(self):
self.loop = base_events.BaseEventLoop()
self.loop._selector = unittest.mock.Mock()
events.set_event_loop(None)
help='Max tick count',
default=1500)
parser.add_argument('-c',
'--console',
type=str,
nargs='?',
help='on/off run as console without drawing game objects.',
default='off')
parser.add_argument('--replay', help='Replay visio.gz')
args = parser.parse_args()
CONSTS.MAX_TICK_COUNT = args.max_tick_count
loop = events.new_event_loop()
events.set_event_loop(loop)
tcpClient = None
async def handle_connection(reader, writer):
global tcpClient
tcpClient = TcpClient(reader, writer, args.check_execution_limit == 'on')
async def client_wait_timeout():
end_time = datetime.datetime.now() + datetime.timedelta(
0, CONSTS.LR_CLIENT_WAIT_TIMEOUT)
while not tcpClient and datetime.datetime.now() < end_time:
await asyncio.sleep(0.1)
#!/usr/bin/env python3
import aiohttp
import sys
import asyncio
def curl(url):
response = yield from aiohttp.request('GET', url)
print(repr(response))
chunk = yield from response.content.read()
print('Downloaded: %s' % len(chunk))
response.close()
if __name__ == '__main__':
if '--iocp' in sys.argv:
from asyncio import events, windows_events
sys.argv.remove('--iocp')
el = windows_events.ProactorEventLoop()
events.set_event_loop(el)
loop = asyncio.get_event_loop()
loop.run_until_complete(curl(sys.argv[1]))
def setUp(self):
self.loop = unix_events.SelectorEventLoop()
events.set_event_loop(None)
def setUp(self):
self.loop = events.new_event_loop()
events.set_event_loop(None)
def setUp(self):
self.loop = events.new_event_loop()
events.set_event_loop(None)
def set_event_loop(self, loop, *, cleanup=True):
assert loop is not None
# ensure that the event loop is passed explicitly in asyncio
events.set_event_loop(None)
if cleanup:
self.addCleanup(self.close_loop, loop)
import argparse
import asyncio
import aiohttp
def function1873(arg493):
var1865 = aiohttp.ClientSession()
var881 = yield from var1865.request('GET', arg493)
print(repr(var881))
var3637 = yield from var881.content.read()
print(('Downloaded: %s' % len(var3637)))
var881.close()
yield from var1865.close()
if (__name__ == '__main__'):
var627 = argparse.ArgumentParser(description='GET url example')
var627.add_argument('url', nargs=1, metavar='URL', help='URL to download')
var627.add_argument('--iocp', default=False, action='store_true', help='Use ProactorEventLoop on Windows')
var3320 = var627.parse_args()
if var3320.iocp:
from asyncio import events, windows_events
var3481 = windows_events.ProactorEventLoop()
events.set_event_loop(var3481)
var519 = asyncio.get_event_loop()
var519.run_until_complete(function1873(var3320.url[0]))
def setUp(self):
self.loop = base_events.BaseEventLoop()
self.loop._selector = unittest.mock.Mock()
events.set_event_loop(None)
def setUp(self):
self.loop = test_utils.TestLoop()
events.set_event_loop(None)
def setUp(self):
super().setUp()
events.set_event_loop(self.one_loop)
def set_event_loop(self, loop, *, cleanup=True):
assert loop is not None
# ensure that the event loop is passed explicitly in asyncio
events.set_event_loop(None)
if cleanup:
self.addCleanup(self.close_loop, loop)
def tearDown(self):
events.set_event_loop(None)
super().tearDown()
def setUp(self):
self.loop = test_utils.TestLoop()
events.set_event_loop(None)