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 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())
