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
