def run(self): self.loop.add_signal_handler(signal.SIGTERM, self.stop) ensure_future(self.bootstrap(), loop=self.loop) try: self.loop.run_forever() finally: self.loop.close()
async def get_user_choice(cls, ctx: Context, search_query: str, entries: List[Tuple[str]]) -> int: em = Embed(colour=cls._embed_colour,) em.set_author(name=f'{cls._track_type} search results - {search_query} - Requested by {ctx.author}') for index, entry in enumerate(entries, 1): em.add_field( name=f'{index} - {entry[0]}', value=entry[1], inline=False) search_message = await ctx.send(embed=em) ensure_future(add_numeric_reactions(search_message, len(entries))) def check(react: Reaction, user: User): return any(( react.message.id == search_message.id, user == ctx.author, react.emoji in (numeric_emoji(n) for n in range(1, 1+len(entries))) )) try: reaction, _ = await ctx.bot.wait_for('reaction_add', check=check, timeout=60) except TimeoutError: raise BadArgument("You did not choose a search result in time.") await search_message.delete() return int(reaction.emoji[0]) - 1
async def bootstrap(self): user_service = self.get_resource('core.users.user_service') for name, bot in [(name, bot) for name, bot in self._resources.items() if isinstance(bot, Bot)]: bot.register_update_processor(partial(user_update_processor, service_id=name, user_service=user_service)) ensure_future(bot.start_get_updates())
def run_until_complete(self, future, **kw): """Run until the Future is done. If the argument is a coroutine, it is wrapped in a Task. WARNING: It would be disastrous to call run_until_complete() with the same coroutine twice -- it would wrap it in two different Tasks and that can't be good. Return the Future's result, or raise its exception. """ def stop(f): self.stop() future = tasks.ensure_future(future, loop=self) future.add_done_callback(stop) try: self.run_forever(**kw) finally: future.remove_done_callback(stop) if not future.done(): raise RuntimeError('Event loop stopped before Future completed.') return future.result()
def _send(self, key, data): print("Start storing key:'{}' in P2P-network".format(key)) fut = ensure_future(self.server.set(key, data)) d = Deferred.fromFuture(fut) # from twisted.internet import reactor # d.addTimeout(30, reactor, self.send_failed) return d
def run_until_complete(self, future, **kw): """Run the event loop until a Future is done. Return the Future's result, or raise its exception. """ def stop(f): self.stop() future = tasks.ensure_future(future, loop=self) future.add_done_callback(stop) try: self.run_forever(**kw) finally: future.remove_done_callback(stop) if not future.done(): raise RuntimeError("Event loop stopped before Future completed.") return future.result()
def cli(): import argparse from asyncio.tasks import ensure_future loop = asyncio.get_event_loop() parser = argparse.ArgumentParser( description="Perform Bluetooth Low Energy device scan") parser.add_argument("-i", dest="dev", default="hci0", help="HCI device") parser.add_argument("-t", dest="timeout", type=int, default=5, help="Duration to scan for") args = parser.parse_args() out = loop.run_until_complete( ensure_future(discover(device=args.dev, timeout=float(args.timeout)))) for o in out: print(str(o))
def from_continuation(callback: Callback[_T3]) -> Awaitable[_T3]: future: Future[_T3] = Future() return ensure_future(future)
def poll_devices(self): """Walk through ALDB and populate device information for each device.""" self.log.info('Polling all devices in ALDB') do_poll_func = self._poll_devices() ensure_future(do_poll_func)
def wrapper(*args, **kwargs): return Deferred.fromFuture(ensure_future(func(*args, **kwargs)))
print("Problem with starting Characteristic") exit() def WriteRequestedAsync(sender, args): logger.debug("A write is requested!") def ServiceProvider_AdvertisementStatusChanged(sender, args): logger.debug("Advertisement status changed!") opCharacteristic.WriteRequested += WriteRequestedAsync serviceProvider.AdvertisementStatusChanged += ServiceProvider_AdvertisementStatusChanged advertising_parameters = GattServiceProviderAdvertisingParameters( IsConnectable=System.Convert.ToBoolean(1), IsDiscoverable=System.Convert.ToBoolean(1)) serviceProvider.StartAdvertising(advertising_parameters) logger.debug("started adv") await asyncio.sleep(60, loop=loop) serviceProvider.StopAdvertising() await asyncio.sleep(5) if __name__ == "__main__": service_uuid = System.Guid.Parse("caecface-e1d9-11e6-bf01-fe55135034f0") char_uuid = System.Guid.Parse("caec2ebc-e1d9-11e6-bf01-fe55135034f1") enable_logging() loop = asyncio.get_event_loop() loop.run_until_complete( ensure_future(ServiceProviderInitAsync(service_uuid, char_uuid, loop)))
def get(self, key): fut = ensure_future(self.server.get(key)) d = Deferred.fromFuture(fut) return d
def connect_p2p(self, bootstrap_address): future = ensure_future( self.server.bootstrap([(bootstrap_address, 8468)])) d = Deferred.fromFuture(future) return d