def run_until_complete(coro: Awaitable, loop: AbstractEventLoop=None): """Run a task through to completion. The ``.run_until_complete()`` method on asyncio event loop objects does not finish tasks when it receives a SIGINT/CTRL-C. The method simply raises a ``KeyboardInterrupt`` exception and this usually results in warnings about unfinished tasks plus some "event loop closed" ``RuntimeError`` exceptions in pending tasks. This is a really annoying default behavior and this function aims at replacing that behavior with something that ensures the task actually runs through to completion. When the ``KeyboardInterrupt`` exception is caught, the task is canceled and resumed to give it a chance to clean up properly. .. versionadded:: 0.4 .. versionchanged:: 0.5 Can now be called with a ``asyncio.Task`` argument. """ loop = loop or asyncio.get_event_loop() if isinstance(coro, asyncio.Task): task = coro else: task = loop.create_task(coro) try: loop.run_until_complete(task) except KeyboardInterrupt: task.cancel() try: loop.run_until_complete(task) except asyncio.CancelledError: return None return task.result()
def init_requirements(self, loop: asyncio.AbstractEventLoop): getattr(super(), "init_requirements")(loop) loop.run_until_complete( self.connect_to_stream() ) # Save to app object to be accessible in request handlers self._server_instance.app.stream = self._stream
def run(*tasks: Awaitable, loop: asyncio.AbstractEventLoop=asyncio.get_event_loop()): """Helper to run tasks in the event loop :param tasks: Tasks to run in the event loop. :param loop: The event loop. """ futures = [asyncio.ensure_future(task, loop=loop) for task in tasks] return loop.run_until_complete(asyncio.gather(*futures))
def _cancel_all_tasks(loop: asyncio.AbstractEventLoop) -> None: to_cancel = all_tasks(loop) if not to_cancel: return for task in to_cancel: task.cancel() loop.run_until_complete( asyncio.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, })
def test_throttle_runs_coroutine(redis, event_loop: asyncio.AbstractEventLoop): throttle = AsyncThrottle('test', 1, redis) done = False async def do_something(a, b): nonlocal done await asyncio.sleep(0.1) done = True return a * b coroutine = do_something(3, 7) assert not done assert event_loop.run_until_complete(throttle.run(coroutine)) == 21 assert done assert not redis.exists('redis_gt:test')
def test_get_invalid_sig( self, caplog: pytest.LogCaptureFixture, temp_event_loop: asyncio.AbstractEventLoop, ): caplog.set_level(logging.DEBUG) mock_reader = self.MockAsyncReader( b"PROXI TCP4 1.2.3.4 5.6.7.8 9 10\r\n") reslt = temp_event_loop.run_until_complete(get_proxy(mock_reader)) assert isinstance(reslt, ProxyData) assert not reslt.valid expect_msg = "PROXY unrecognized signature" assert reslt.error == expect_msg expect = ("mail.debug", 30, "PROXY error: " + expect_msg) assert expect in caplog.record_tuples
def create_tasks( loop: asyncio.AbstractEventLoop, *arg: Any, **kwargs: Any, ) -> Tasks: """ .. deprecated:: 1.0 This is a synchronous interface to `spawn_tasks`. It is only kept for backward compatibility, as it was exposed via the public interface of the framework. """ warnings.warn( "kopf.create_tasks() is deprecated: " "use kopf.spawn_tasks() or kopf.operator().", DeprecationWarning) return loop.run_until_complete(spawn_tasks(*arg, **kwargs))
def save_download(args: Namespace, form: FormsiteForm, loop: asyncio.AbstractEventLoop): """Download all files uploaded to the form using the File Upload control""" if not args.download: path = Path(f"./download_{form.form_id}_{TIMESTAMP}").resolve() else: path = Path(args.download).resolve() # ---- os.makedirs(path.parent.as_posix(), exist_ok=True) str_path = path.as_posix() download = form.async_downloader( str_path, max_concurrent=args.concurrent_downloads, timeout=args.timeout, max_attempts=args.retries, url_filter_re=args.extract_regex, filename_substitution_re_pat=args.download_regex, overwrite_existing=args.dont_overwrite_downloads, strip_prefix=args.strip_prefix, callback=download_pbar_callback, ) # ---- loop.run_until_complete(download.run())
def api_server_fixture(loop: asyncio.AbstractEventLoop, aiohttp_client): sp_mock = SPMQTTMock() influx_mock = InfluxMQTTMock() mqtt_influx_mock = MQTTMockClient(InfluxMQTTMock()) mqtt_sp_mock = MQTTMockClient(SPMQTTMock()) api_server = APIServer() client = loop.run_until_complete(aiohttp_client(api_server.app)) influx_mock_task = loop.create_task( mqtt_influx_mock.run_loop(config.MQTT_BROKER_IP)) sp_mock_task = loop.create_task( mqtt_sp_mock.run_loop(config.MQTT_BROKER_IP)) loop.run_until_complete(api_server.start()) yield client, influx_mock, sp_mock mqtt_influx_mock.stop_loop() mqtt_sp_mock.stop_loop() loop.run_until_complete(influx_mock_task) loop.run_until_complete(sp_mock_task) loop.run_until_complete(api_server.stop())
def _serve(loop: asyncio.AbstractEventLoop, shutdown_signal: asyncio.Event, host: str, port: int) -> None: app = web.Application() app.add_routes(routes) runner = web.AppRunner(app) asyncio.set_event_loop(loop) asyncio.set_event_loop(loop) loop.run_until_complete(runner.setup()) site = web.TCPSite(runner, host, port) loop.run_until_complete(site.start()) loop.run_until_complete(shutdown_signal.wait())
def stop_schedule(addr: Tuple[str, int], name: str = '', list_schedules: bool = False, loop: asyncio.AbstractEventLoop = None): """Send a command to the server to stop running a schedule. Args: addr (tuple): Server IP address name (str)['']: Name of the schedule. list_schedules (bool)[False]: If True request and print the schedules that the server is running. loop (asyncio.AbstractEventLoop)[None]: Event loop to run the async command with. """ if loop is None: loop = get_loop() return loop.run_until_complete( stop_schedule_async(addr, name, list_schedules=list_schedules))
def update_server(addr: Tuple[str, int], module_name: str = '', list_schedules: bool = False, loop: asyncio.AbstractEventLoop = None): """Send a command to the server to Update Commands. Args: addr (tuple): Server IP address module_name (str)['']: Module name to import/reload. If blank import/reload all modules. list_schedules (bool)[False]: If True request and print the schedules that the server is running. loop (asyncio.AbstractEventLoop)[None]: Event loop to run the async command with. """ if loop is None: loop = get_loop() return loop.run_until_complete( update_server_async(addr, module_name, list_schedules))
def run(loop: asyncio.AbstractEventLoop, arguments: dict): try: loop.run_until_complete(main(arguments)) loop.run_until_complete(asyncio.sleep(0.250)) loop.run_until_complete(loop.shutdown_asyncgens()) except Exception: log.exception("there has been an unrecoverable error") finally: loop.close()
def client( loop: asyncio.AbstractEventLoop, aiohttp_unused_port: Callable[[], int], aiohttp_client: Callable[..., Awaitable[TestClient]], valid_config: Dict[str, Any], monkeypatch, ) -> Iterator[TestClient]: # increase the speed to fail monkeypatch.setattr(auto_deploy_task, "RETRY_COUNT", 2) monkeypatch.setattr(auto_deploy_task, "RETRY_WAIT_SECS", 1) app = create(valid_config) server_kwargs = {"port": aiohttp_unused_port(), "host": "localhost"} client = loop.run_until_complete( aiohttp_client(app, server_kwargs=server_kwargs)) yield client
def block(coroutine: Coroutine, loop: asyncio.AbstractEventLoop, *, timeout): if loop.is_running(): coroutine.close() raise CannotBlockHere( "It appears you have tried to use a blocking API method " "from within an event loop. Unfortunately this is unsupported. " "Instead, use the async version of the method. This commonly " "occurs when calling bus methods from within a bus event listener. " "In this case the only option is to define you listeners as async." ) try: val = loop.run_until_complete( asyncio.wait_for(coroutine, timeout=timeout, loop=loop)) except Exception as e: # The intention here is to get sensible stack traces from exceptions within blocking calls raise e return val
def send(data: Any, config_name: str, *, loop: AbstractEventLoop): async def _send(): try: async with factory.get_sender(config_name) as queue: await queue.send(data=data) except (NotFound, CannotImport) as ex: print_err(str(ex)) return -1 except QueueNotFound: print_err(f"Queue not found.") return -2 return 0 return loop.run_until_complete(_send())
def test_user_create_by_superuser(client: TestClient, event_loop: EventLoop): email = random_email() password = random_lower_string() is_superuser = True is_active = False user_in = UserCreateBySuperuser( email=email, password=password, is_superuser=is_superuser, is_active=is_active, ) user = event_loop.run_until_complete( crud.user.create_by_superuser(user_in)) assert user.email == email assert hasattr(user, "password_hash") assert user.is_superuser == is_superuser assert user.is_active == is_active
def client( event_loop: asyncio.AbstractEventLoop, postgres_session: sa.orm.session.Session, rabbit_service: RabbitSettings, redis_settings: RedisSettings, simcore_services_ready: None, aiohttp_client: Callable, app_config: Dict[str, Any], ## waits until swarm with *_services are up mocker: MockerFixture, monkeypatch_setenv_from_app_config: Callable, ) -> TestClient: cfg = deepcopy(app_config) assert cfg["rest"]["version"] == API_VTAG cfg["storage"]["enabled"] = False cfg["main"]["testing"] = True # fake config monkeypatch_setenv_from_app_config(cfg) app = create_safe_application(app_config) assert setup_settings(app) setup_db(app) setup_session(app) setup_security(app) setup_rest(app) setup_diagnostics(app) setup_login(app) setup_users(app) setup_socketio(app) setup_projects(app) setup_computation(app) setup_director_v2(app) setup_resource_manager(app) # no garbage collector return event_loop.run_until_complete( aiohttp_client( app, server_kwargs={ "port": app_config["main"]["port"], "host": app_config["main"]["host"], }, ))
def run_sendria_servers(loop: asyncio.AbstractEventLoop) -> NoReturn: # initialize db loop.run_until_complete(db.setup(config.CONFIG.db)) # initialize and start webhooks callbacks_enabled = callback.setup( debug_mode=config.CONFIG.debug, callback_webhook_url=config.CONFIG.callback_webhook_url, callback_webhook_method=config.CONFIG.callback_webhook_method, callback_webhook_auth=config.CONFIG.callback_webhook_auth, ) if callbacks_enabled: loop.create_task(callback.send_messages()) # initialize and start message saver loop.create_task(db.message_saver()) # start smtp server smtp.run(config.CONFIG.smtp_ip, config.CONFIG.smtp_port, config.CONFIG.smtp_auth, config.CONFIG.smtp_ident, config.CONFIG.debug) logger.info('smtp server started', host=config.CONFIG.smtp_ip, port=config.CONFIG.smtp_port, auth='enabled' if config.CONFIG.smtp_auth else 'disabled', password_file=str(config.CONFIG.smtp_auth.path) if config.CONFIG.smtp_auth else None, url=f'smtp://{config.CONFIG.smtp_ip}:{config.CONFIG.smtp_port}', ) # initialize and start web server app = http.setup() runner = aiohttp.web.AppRunner(app) loop.run_until_complete(runner.setup()) site = aiohttp.web.TCPSite(runner, host=config.CONFIG.http_ip, port=config.CONFIG.http_port) server = site.start() loop.run_until_complete(server) logger.info('http server started', host=config.CONFIG.http_ip, port=config.CONFIG.http_port, url=f'http://{config.CONFIG.http_ip}:{config.CONFIG.http_port}', auth='enabled' if config.CONFIG.http_auth else 'disabled', password_file=str(config.CONFIG.http_auth.path) if config.CONFIG.http_auth else None, ) # prepare for clean terminate async def _initialize_aiohttp_services__stop() -> NoReturn: for ws in set(app['websockets']): await ws.close(code=aiohttp.WSCloseCode.GOING_AWAY, message='Server shutdown') await app.shutdown() SHUTDOWN.append(_initialize_aiohttp_services__stop()) signals = (signal.SIGHUP, signal.SIGTERM, signal.SIGINT) for s in signals: loop.add_signal_handler(s, lambda s=s: asyncio.create_task(terminate_server(s, loop)))
def run(self, event_loop: AbstractEventLoop = None): # Configure the logging system if isinstance(self.logging_config, dict): logging.config.dictConfig(self.logging_config) elif self.logging_config: logging.basicConfig(level=logging.INFO) # Assign a new default executor with the given max worker thread limit event_loop = event_loop or asyncio.get_event_loop() event_loop.set_default_executor(ThreadPoolExecutor(self.max_threads)) # Create the application context context = self.create_context() try: # Start all the components and run the loop until they've finished self.logger.info("Starting components") coroutines = (component.start(context) for component in self.components) coroutines = [coro for coro in coroutines if coro is not None] event_loop.run_until_complete(asyncio.gather(*coroutines)) self.logger.info("All components started") # Run the application's custom startup code coro = self.start(context) if coro is not None: event_loop.run_until_complete(coro) # Run all the application context's start callbacks event_loop.run_until_complete(context.run_callbacks(ContextEventType.started)) self.logger.info("Application started") except Exception as exc: self.logger.exception("Error during application startup") context.exception = exc else: # Finally, run the event loop until the process is terminated or Ctrl+C is pressed try: event_loop.run_forever() except (KeyboardInterrupt, SystemExit): pass event_loop.run_until_complete(context.run_callbacks(ContextEventType.finished)) event_loop.close() self.logger.info("Application stopped")
def client( mock_garbage_collector_task, loop: asyncio.AbstractEventLoop, aiohttp_client: Callable, app_cfg: Dict[str, Any], postgres_db: sa.engine.Engine, mock_orphaned_services, redis_client: Redis, monkeypatch_setenv_from_app_config: Callable, ) -> TestClient: cfg = deepcopy(app_cfg) assert cfg["rest"]["version"] == API_VERSION assert cfg["rest"]["enabled"] cfg["projects"]["enabled"] = True cfg["director"]["enabled"] = True cfg[config.CONFIG_SECTION_NAME][ "garbage_collection_interval_seconds"] = GARBAGE_COLLECTOR_INTERVAL # increase speed of garbage collection # fake config monkeypatch_setenv_from_app_config(cfg) app = create_safe_application(cfg) # activates only security+restAPI sub-modules setup_db(app) setup_session(app) setup_security(app) setup_rest(app) setup_login(app) setup_users(app) setup_socketio(app) setup_projects(app) setup_director(app) setup_director_v2(app) assert setup_resource_manager(app) return loop.run_until_complete( aiohttp_client( app, server_kwargs={ "port": cfg["main"]["port"], "host": cfg["main"]["host"] }, ))
def client( loop: asyncio.AbstractEventLoop, aiohttp_client: Callable, app_config: Dict[str, Any], ## waits until swarm with *_services are up rabbit_service: RabbitConfig, ## waits until rabbit is responsive and set env vars postgres_db: sa.engine.Engine, mocker: MockerFixture, monkeypatch_setenv_from_app_config: Callable, ): app_config["storage"]["enabled"] = False monkeypatch_setenv_from_app_config(app_config) app = create_safe_application(app_config) setup_db(app) setup_session(app) setup_security(app) setup_rest(app) setup_diagnostics(app) setup_login(app) setup_projects(app) setup_computation(app) setup_director_v2(app) setup_socketio(app) # GC not relevant for these test-suite, mocker.patch( "simcore_service_webserver.resource_manager.module_setup.setup_garbage_collector", side_effect=lambda app: print( f"PATCH @{__name__}:" "Garbage collector disabled." "Mock bypasses setup_garbage_collector to skip initializing the GC" ), ) setup_resource_manager(app) return loop.run_until_complete( aiohttp_client( app, server_kwargs={ "port": app_config["main"]["port"], "host": app_config["main"]["host"], }, ))
def receiver(config_name: str, *, loop: AbstractEventLoop): async def _receiver(): try: async with factory.get_receiver(config_name) as queue: queue.new_message.bind(on_new_message) await queue.listen() except (NotFound, CannotImport) as ex: print_err(str(ex)) return -1 except QueueNotFound: print_err(f"Queue not found.") return -2 return 0 return loop.run_until_complete(_receiver())
def run_command(addr: Tuple[str, int], callback_name: str = '', *args, loop: asyncio.AbstractEventLoop = None, **kwargs): """Send a command to the server to run a registered callback function with the given arguments. Args: addr (tuple): Server IP address callback_name (str)['']: Name of the registered callback function. *args: Positional arguments for the callback function. **kwargs: Keyword Arguments for the callback function. loop (asyncio.AbstractEventLoop)[None]: Event loop to run the async command with. """ if loop is None: loop = get_loop() return loop.run_until_complete( run_command_async(addr, callback_name, *args, **kwargs))
def hyper_threading_guard(loop: asyncio.AbstractEventLoop, ht_flag): async def _gather_online_core(online_file: Path, core_id: int): if online_file.is_file(): async with aiofiles.open(online_file) as afp: line = await afp.readline() if line.strip() == '1': return core_id jobs: List[Coroutine] = [] cur_core_id = 1 while True: path = Path(f'/sys/devices/system/cpu/cpu{cur_core_id}') if not path.is_dir(): break else: jobs.append(_gather_online_core(path / 'online', cur_core_id)) cur_core_id += 1 online_core: Set[int] = set(filter(None.__ne__, loop.run_until_complete(asyncio.gather(*jobs)))) if not ht_flag: print('disabling Hyper-Threading...') logical_cores: Set[int] = set() for cur_core_id in online_core | {0}: with open(f'/sys/devices/system/cpu/cpu{cur_core_id}/topology/thread_siblings_list') as fp: for core in fp.readline().strip().split(',')[1:]: logical_cores.add(int(core)) files_to_write = ('/sys/devices/system/cpu/cpu{}/online'.format(core_id) for core_id in logical_cores) subprocess.run(('sudo', 'tee', *files_to_write), input="0", encoding='UTF-8', stdout=subprocess.DEVNULL) print('Hyper-Threading is disabled.') yield files_to_write = ('/sys/devices/system/cpu/cpu{}/online'.format(core_id) for core_id in online_core) subprocess.run(('sudo', 'tee', *files_to_write), input="1", encoding='UTF-8', stdout=subprocess.DEVNULL)
def __init__(self, host: str, port: int, database: str, user: str, password: str, p_loop: AbstractEventLoop) -> None: self._host = host self._port = port self._database = database self._user = user self._password = password self._counter = 0 self._step = 50000 self._step_counter = 0 self._pool = p_loop.run_until_complete( asyncpg.create_pool(user=user, password=password, database=database, host=host, port=port, loop=p_loop, min_size=15, max_size=15))
def test_create_server_saved_to_db( client: TestClient, event_loop: asyncio.AbstractEventLoop): # nosec response = client.post("/api/rabbit/server", json={ "host": "test.com", "name": "server_name", "password": "******" }) assert response.status_code == 200 data = response.json() assert "id" in data server_id = data["id"] async def get_server_by_db(): server = await RabbitServer.get(id=server_id) return server server_obj = event_loop.run_until_complete(get_server_by_db()) assert server_obj.id == server_id
def mock_test_client( loop: AbstractEventLoop, sanic_test_app: Sanic) -> Generator[None, None, AbstractEventLoop]: """Fixture for starting server in the event loop. Args: loop: Fixture of mocked ``AbstractEventLoop`` object. sanic_test_app: Fixture of mocked ``Sanic`` object. Returns: An event loop with a running server. """ return loop.run_until_complete( sanic_test_app.create_server( host=get_local_ip_address(), port=consts.TEST_SERVER_PORT, return_asyncio_server=True, ))
def __init__( self, client: httpx.AsyncClient = None, proxy: Optional[Union[str, Dict[str, str]]] = None, ua: Optional[str] = None, cookies: Optional[Dict[str, str]] = None, local_client: httpx.AsyncClient = local_client, loop: asyncio.AbstractEventLoop = worker_loop, ): self.client = client or loop.run_until_complete( build_client_with_clearance(ua, cookies, proxies=proxy, test=False)) if client: self.proxy = next(iter(client._mounts.values()))._pool._proxy_url elif type(proxy) is str: self.proxy = proxy elif type(proxy) is dict: self.proxy = next(iter(proxy.values())) self.local_client = local_client self.loop = loop self.fingerprint = md5(('TiLakPanColNoRhChNeIt' + self.proxy).encode()).hexdigest()
def __init__( self, loop: asyncio.AbstractEventLoop, pickle_file_path: str, **kwargs ): self._pickle_file_path = pickle_file_path logging.info("Creating a connection pool for DB") self.db_pool = loop.run_until_complete(asyncpg.create_pool(**kwargs)) logging.info("Pooled") # Boolean indicating if a launch notification has been sent for the current # schedule. self._launch_embed_for_current_schedule_sent: bool = False # A dict of the most previously sent schedule embed (for comparison). self._previous_schedule_embed_dict: Dict = {} try: with open(self._pickle_file_path, "rb") as f_in: tmp = pickle.load(f_in) self.__dict__.update(tmp) logging.info(f"Updated self.__dict__ from {self._pickle_file_path}") except FileNotFoundError: logging.info(f"Could not find file at location: {self._pickle_file_path}")
def client( event_loop: asyncio.AbstractEventLoop, aiohttp_client: Callable, app_config: Dict[str, Any], ## waits until swarm with *_services are up rabbit_service: RabbitSettings, ## waits until rabbit is responsive and set env vars postgres_db: sa.engine.Engine, mocker: MockerFixture, monkeypatch_setenv_from_app_config: Callable, ): app_config["storage"]["enabled"] = False monkeypatch_setenv_from_app_config(app_config) app = create_safe_application(app_config) assert setup_settings(app) assert app[APP_SETTINGS_KEY].WEBSERVER_COMPUTATION setup_db(app) setup_session(app) setup_security(app) setup_rest(app) setup_diagnostics(app) setup_login(app) setup_projects(app) setup_computation(app) setup_director_v2(app) setup_socketio(app) setup_resource_manager(app) # GC not relevant for these test-suite, return event_loop.run_until_complete( aiohttp_client( app, server_kwargs={ "port": app_config["main"]["port"], "host": app_config["main"]["host"], }, ) )
def scan_for_device(self, loop: asyncio.AbstractEventLoop) -> bool: """ Scan for device and set BLE address :param asyncio.AbstractEventLoop loop: Main Asyncio loop to use :return: True, if device found. False, else. :rtype: bool """ # Warn, if address is already present if self.ble_address: self.logger.warning("Scanning for device, but address already present: %s", self.ble_address) # Start scanning process self.logger.info("Scanning for BLE Device by Name: %s", self.name) # Attempt to find device self.loop_status = LoopStatus.ACTIVE escape_counter: int = 0 # Give up after 5 tries result: bool = True while not self.ble_address and self.loop_status == LoopStatus.ACTIVE: # Use Asyncio loop to find bike ble_address = loop.run_until_complete(self.scan()) if ble_address: self.ble_address = ble_address self.logger.debug("Setting device (%s) to BLE address (%s)", self.name, self.ble_address) self.loop_status = LoopStatus.INACTIVE else: if escape_counter < 4: escape_counter += 1 else: self.logger.warning("Unable to find device (%s).") result = False self.logger.warning("Unable to find device (%s). Retrying...", self.name) self.loop_status = LoopStatus.INACTIVE return result
def _destroy_loop(loop: asyncio.AbstractEventLoop) -> None: async def murder(future: asyncio.Future[typing.Any]) -> None: # These include _GatheringFuture which must be awaited if the children # throw an asyncio.CancelledError, otherwise it will spam logs with warnings # about exceptions not being retrieved before GC. try: _LOGGER.log(ux.TRACE, "killing %s", future) future.cancel() await future except asyncio.CancelledError: pass except Exception as ex: loop.call_exception_handler({ "message": "Future raised unexpected exception after requesting cancellation", "exception": ex, "future": future, }) remaining_tasks = [ t for t in asyncio.all_tasks(loop) if not t.cancelled() and not t.done() ] if remaining_tasks: _LOGGER.debug("terminating %s remaining tasks forcefully", len(remaining_tasks)) loop.run_until_complete( asyncio.gather(*(murder(task) for task in remaining_tasks))) else: _LOGGER.debug("No remaining tasks exist, good job!") if sys.version_info >= (3, 9): _LOGGER.debug("shutting down default executor") with contextlib.suppress(NotImplementedError): # This seems to raise a NotImplementedError when running with uvloop. loop.run_until_complete(loop.shutdown_default_executor()) _LOGGER.debug("shutting down asyncgens") loop.run_until_complete(loop.shutdown_asyncgens()) _LOGGER.debug("closing event loop") loop.close()
def bruh(self, encoder, loop: asyncio.AbstractEventLoop): asyncio.set_event_loop(loop) loop.run_until_complete(encoder.encode()) loop.close()
def model_server(loop: asyncio.AbstractEventLoop, sanic_client: Callable, trained_moodbot_path: Text) -> TestClient: app = model_server_app(trained_moodbot_path, model_hash="somehash") return loop.run_until_complete(sanic_client(app))
def redis_pool(event_loop: asyncio.AbstractEventLoop, redis_port: int): redis_pool = event_loop.run_until_complete( aioredis.create_pool(('localhost', redis_port))) yield redis_pool redis_pool.close() event_loop.run_until_complete(redis_pool.wait_closed())