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 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 __init__(self, logger, webhook=None): self.logger = logger self.loop = events.new_event_loop() self._started_at = datetime.datetime.now() self._properties = None self._port = 8800 self._bots = dict() self._startup_bots = ['kippy'] # uses this if it can't read from yaml self._error_detected = dict() self._webhook_session = None # webhook session self._webhook = webhook self._today = datetime.datetime.now().day self._server = None
def test_async_coroutine(self): @tasks.coroutine def notmuch(): return 'ok' t = tasks.async(notmuch(), loop=self.loop) self.loop.run_until_complete(t) self.assertTrue(t.done()) self.assertEqual(t.result(), 'ok') self.assertIs(t._loop, self.loop) loop = events.new_event_loop() t = tasks.async(notmuch(), loop=loop) self.assertIs(t._loop, loop) loop.close()
def test_async_coroutine(self): @tasks.coroutine def notmuch(): return 'ok' t = tasks. async (notmuch(), loop=self.loop) self.loop.run_until_complete(t) self.assertTrue(t.done()) self.assertEqual(t.result(), 'ok') self.assertIs(t._loop, self.loop) loop = events.new_event_loop() t = tasks. async (notmuch(), loop=loop) self.assertIs(t._loop, loop) loop.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 test_cancel_current_task(self): loop = events.new_event_loop() self.addCleanup(loop.close) @tasks.coroutine def task(): t.cancel() self.assertTrue(t._must_cancel) # White-box test. # The sleep should be cancelled immediately. yield from tasks.sleep(100, loop=loop) return 12 t = tasks.Task(task(), loop=loop) self.assertRaises(futures.CancelledError, loop.run_until_complete, t) self.assertTrue(t.done()) self.assertFalse(t._must_cancel) # White-box test. self.assertFalse(t.cancel())
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 test_cancel_current_task(self): loop = events.new_event_loop() self.addCleanup(loop.close) @tasks.coroutine def task(): t.cancel() self.assertTrue(t._must_cancel) # White-box test. # The sleep should be cancelled immediately. yield from tasks.sleep(100, loop=loop) return 12 t = tasks.Task(task(), loop=loop) self.assertRaises( futures.CancelledError, loop.run_until_complete, t) self.assertTrue(t.done()) self.assertFalse(t._must_cancel) # White-box test. self.assertFalse(t.cancel())
def test_async_future(self): f_orig = futures.Future(loop=self.loop) f_orig.set_result('ko') f = tasks. async (f_orig) self.loop.run_until_complete(f) self.assertTrue(f.done()) self.assertEqual(f.result(), 'ko') self.assertIs(f, f_orig) loop = events.new_event_loop() with self.assertRaises(ValueError): f = tasks. async (f_orig, loop=loop) loop.close() f = tasks. async (f_orig, loop=self.loop) self.assertIs(f, f_orig)
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 test_async_future(self): f_orig = futures.Future(loop=self.loop) f_orig.set_result('ko') f = tasks.async(f_orig) self.loop.run_until_complete(f) self.assertTrue(f.done()) self.assertEqual(f.result(), 'ko') self.assertIs(f, f_orig) loop = events.new_event_loop() with self.assertRaises(ValueError): f = tasks.async(f_orig, loop=loop) loop.close() f = tasks.async(f_orig, loop=self.loop) self.assertIs(f, f_orig)
def test_async_task(self): @tasks.coroutine def notmuch(): return 'ok' t_orig = tasks.Task(notmuch(), loop=self.loop) t = tasks.async(t_orig) self.loop.run_until_complete(t) self.assertTrue(t.done()) self.assertEqual(t.result(), 'ok') self.assertIs(t, t_orig) loop = events.new_event_loop() with self.assertRaises(ValueError): t = tasks.async(t_orig, loop=loop) loop.close() t = tasks.async(t_orig, loop=self.loop) self.assertIs(t, t_orig)
def test_async_task(self): @tasks.coroutine def notmuch(): return 'ok' t_orig = tasks.Task(notmuch(), loop=self.loop) t = tasks. async (t_orig) self.loop.run_until_complete(t) self.assertTrue(t.done()) self.assertEqual(t.result(), 'ok') self.assertIs(t, t_orig) loop = events.new_event_loop() with self.assertRaises(ValueError): t = tasks. async (t_orig, loop=loop) loop.close() t = tasks. async (t_orig, loop=self.loop) self.assertIs(t, t_orig)
def post(self, request): form = ModelForm(request.POST) if form.is_valid(): print("It always goes from here") range_from = form.cleaned_data['range_from'] range_to = form.cleaned_data['range_to'] choosing_selling_sites = form.cleaned_data['choosing_selling_sites'] print(choosing_selling_sites) if 'Flipkart' in choosing_selling_sites: furl_for_multi_page = [] async def data_render(data): with ThreadPoolExecutor(max_workers=10) as executor: with requests.session() as session: loop = asyncio.get_event_loop() tasks = [ loop.run_in_executor(executor, Page_render, *(data_from_fun, page, range_from, range_to, session)) for data_from_fun in data ] for response in await asyncio.gather(*tasks): furl_for_multi_page.append(response) return furl_for_multi_page 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) loop.run_until_complete(data_render(data)) finally: try: # _cancel_all_tasks(loop) loop.run_until_complete(loop.shutdown_asyncgens()) finally: events.set_event_loop(None) loop.close() furl_for_multi_page = furl_for_multi_page[0] print("length of flipkart", len(furl_for_multi_page)) else: furl_for_multi_page = [] print("NOT FOR FLIPKART", furl_for_multi_page) if 'Amazon' in choosing_selling_sites: amazon_url = amazon_page_randor(range_from, range_to, page) print("length of amazon", len(amazon_url)) else: amazon_url = [] print("NOT FOR AMAZON", amazon_url) sleep(5) return render(request, 'url_table.html', {'furl_for_multi_page': furl_for_multi_page, 'aurl_for_multi_page': amazon_url, 'range_from': range_from, 'range_to':range_to})
nargs='?', 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)
def __getattribute__(self, name: str): if name == "_loop": return super().__getattribute__("_loop") if self._loop is None or self._loop.is_closed(): self._loop = new_event_loop() return getattr(self._loop, name)
def setUp(self): self.loop = events.new_event_loop() events.set_event_loop(None)
def _run_thread(self): loop = events.new_event_loop() events.set_event_loop(loop) while not self.done: loop.run_until_complete(self.game.tick())