def test_decoder_failure(self): """ This test checks that the decoder works properly whenever random data in given to it. :return: """ async def run(q): try: s = asyncio.Semaphore(0) def error_callback(): q.put(None) s.release() decoder = Decoder(error_callback) data = os.urandom(1000) await decoder.digest(struct.pack(">I", len(data))) await decoder.digest(data) s.acquire() q.put(None) except: q.put(sys.exc_info()) q = Queue() loop = get_event_loop() asyncio.run_coroutine_threadsafe(run(q), loop) # If you get an Empty exception over here, it means the co-routine timed out. exc_info = q.get(timeout=1) if exc_info is not None: raise exc_info[1].with_traceback(exc_info[2])
def test_ping(self): async def run(q): try: connections = {} listener = Listener("127.0.0.1", 8888, connections) await listener.wait_until_started() client_connection = await Connection.from_host("127.0.0.1", 8888) # This one is optional. Any commands transmitting will wait for the connection to be ready anyways. await client_connection.wait_for_ready() await client_connection.ping() await client_connection.ping() q.put(None) except: q.put(sys.exc_info()) q = Queue() loop = get_event_loop() asyncio.run_coroutine_threadsafe(run(q), loop) # If you get an Empty exception over here, it means the co-routine timed out. exc_info = q.get(timeout=1) if exc_info is not None: raise exc_info[1].with_traceback(exc_info[2])
def test_decoder(self): """ This test, tests whether the decoder is working properly by given it a raw package and checking whether the result matches. """ async def run(q): try: decoder = Decoder() inp_data = [0, [1, 2, 3]] data = umsgpack.packb(inp_data) await decoder.digest(struct.pack(">I", len(data))) await decoder.digest(data) out_data = await decoder.get() assert inp_data == out_data q.put(None) except: q.put(sys.exc_info()) q = Queue() loop = get_event_loop() asyncio.run_coroutine_threadsafe(run(q), loop) # If you get an Empty exception over here, it means the co-routine timed out. exc_info = q.get(timeout=1) if exc_info is not None: raise exc_info[1].with_traceback(exc_info[2])
def __init__(self, network: 'Network', server: str, proxy: Optional[dict]): self.ready = asyncio.Future() self.got_disconnected = asyncio.Future() self.server = server self.host, self.port, self.protocol = deserialize_server(self.server) self.port = int(self.port) Logger.__init__(self) assert network.config.path self.cert_path = os.path.join(network.config.path, 'certs', self.host) self.blockchain = None self._requested_chunks = set() self.network = network self._set_proxy(proxy) self.session = None # type: NotificationSession self._ipaddr_bucket = None self.tip_header = None self.tip = 0 # Dump network messages (only for this interface). Set at runtime from the console. self.debug = False asyncio.run_coroutine_threadsafe( self.network.main_taskgroup.spawn(self.run()), self.network.asyncio_loop) self.group = SilentTaskGroup()
def close(cls, connection_str=None): """Close DB connections""" if connection_str: conn = cls.connections.pop(connection_str) if not conn: raise RuntimeError('Specified conn does not exist') if connection_str == conn.uri: cls.connections.pop(conn.alias) else: cls.connections.pop(conn.uri) if conn is cls.current: cls.current = None conns = [conn] else: keys= set(cls.connections.keys()) conns = set() for k in keys: conn = cls.connections.pop(k) conns.add(conn) cls.current = None async def go(conns): for conn in conns: await conn.close() asyncio.run_coroutine_threadsafe(go(conns), LOOP).result() LOOP.stop() LOOP.close() executor.shutdown()
def _sigterm(self, *_): """ Handle SIGTERM and shut down gracefully. """ self.log.debug("SIGTERM caught.") asyncio.run_coroutine_threadsafe(self.shutdown(), self.event_loop)
def tell(self, mtype, m): """ Decorate a message with a dummy reply attribute, send it to the master, then return immediately. """ m.reply = DummyReply() asyncio.run_coroutine_threadsafe(self._q.put((mtype, m)), self.loop)
def run(self): while not self._stop_ev.wait(self.interval): if self._last_ack + self.heartbeat_timeout < time.perf_counter(): log.warning("Shard ID %s has stopped responding to the gateway. Closing and restarting.", self.shard_id) coro = self.ws.close(4000) f = asyncio.run_coroutine_threadsafe(coro, loop=self.ws.loop) try: f.result() except Exception: pass finally: self.stop() return data = self.get_payload() log.debug(self.msg, data['d']) coro = self.ws.send_as_json(data) f = asyncio.run_coroutine_threadsafe(coro, loop=self.ws.loop) try: # block until sending is complete total = 0 while True: try: f.result(5) break except concurrent.futures.TimeoutError: total += 5 log.warning(self.block_msg, total) except Exception: self.stop() else: self._last_send = time.perf_counter()
def my_send(self, msg): @asyncio.coroutine def send(): self.writer.write(self.serdes.serialize(msg)) yield from self.writer.drain() asyncio.run_coroutine_threadsafe(send(), self.loop) print('client Sent')
async def _start(self): assert not self.main_taskgroup self.main_taskgroup = SilentTaskGroup() assert not self.interface and not self.interfaces assert not self.connecting and not self.server_queue self.print_error('starting network') self.disconnected_servers = set([]) self.protocol = deserialize_server(self.default_server)[2] self.server_queue = queue.Queue() self._set_proxy(deserialize_proxy(self.config.get('proxy'))) self._set_oneserver(self.config.get('oneserver', False)) self._start_interface(self.default_server) async def main(): try: await self._init_headers_file() async with self.main_taskgroup as group: await group.spawn(self._maintain_sessions()) [await group.spawn(job) for job in self._jobs] except Exception as e: traceback.print_exc(file=sys.stderr) raise e asyncio.run_coroutine_threadsafe(main(), self.asyncio_loop) self.trigger_callback('network_updated')
def command(self, key, value): """Create and enqueue a task from a command coming from UI layer""" task = None if key == "connection.open.credentials": try: # Direct execution because queue is empty at this moment self._open() task = self._task_set_credentials(*value) except: pass if key == "connection.close": task = self._task_close() if key == "connection.close.deletion": task = self._task_deletion() if key == "application.editblock": task = self._task_add_data_or_update_data(*value) if key == "application.deleteblock": task = self._task_delete_data(value) if key == "application.searchblock": task = self._task_search_data(value) if key == "application.exportblock": task = self._task_export_data() if key == "application.searchblock.blockvalues": task = self._task_get_block_values(value) if task is not None: asyncio.run_coroutine_threadsafe(self.queue.put(task), self.loop)
def send(self, n1, n2, t, m, c, s, uid): c = self.idToChan(c) if not c: return m = oirc.stripIrcColors(m) msg = '' if t == 'message': msg = '<{}> {}'.format(n1, m) elif t == 'action': msg = '* {} {}'.format(n1, m) elif t == 'join': msg = '* {} has joined'.format(n1) elif t == 'part': msg = '* {} has left'.format(n1) elif t == 'quit': msg = '* {} has quit ({})'.format(n1, m) elif t == 'mode': msg = '* {} set mode {}'.format(n1, m) elif t == 'kick': msg = '* {} has kicked {} ({})'.format(n1, n2, m) elif t == 'topic': msg = '* {} has changed the topic to {}'.format(n1, m) elif t == 'nick': msg = '* {} has changed nicks to {}'.format(n1, n2) if not msg: return prefix = self.getNetworkPrefix(s) asyncio.run_coroutine_threadsafe(self.client.send_message(c, prefix['prefix'] + msg), self.loop)
async def process(self, client, event): """Process a new event""" eventtype = event['event'] event['client'] = client if eventtype == 'response': # We receive a response to a specific property, attr or text request if 'request_id' in event: self.requests[event['request_id']] = event return if eventtype in self.handlers: # Check for local handler if 'key' in event: key = event['key'] if key in self.handlers[eventtype]: for handler in list(self.handlers[eventtype][key]): if callable(handler): asyncio.run_coroutine_threadsafe(handler(event), self.loop) # Check for global handler for handler in list(self.handlers[eventtype]['_']): if callable(handler): asyncio.run_coroutine_threadsafe(handler(event), self.loop)
def __init__(self, network: 'Network'): asyncio.set_event_loop(network.asyncio_loop) self.network = network self.interface = None # type: Interface self._restart_lock = asyncio.Lock() self._reset() asyncio.run_coroutine_threadsafe(self._restart(), network.asyncio_loop) network.register_callback(self._restart, ['default_server_changed'])
def _sigint(self, *_): """ Handle CTRL+C or SIGINT and shut down gracefully. """ print("") # Or it'll print on the same line as the ^C self.log.debug("SIGINT caught.") asyncio.run_coroutine_threadsafe(self.shutdown(), self.event_loop)
def put_message(self, message): """ :param message: protobuf generated validator_pb2.Message """ with self._condition: self._condition.wait_for(lambda: self._event_loop is not None) asyncio.run_coroutine_threadsafe(self._put_message(message), self._event_loop)
def send_message(self, msg, identity=None): """ :param msg: protobuf validator_pb2.Message """ with self._condition: self._condition.wait_for(lambda: self._event_loop is not None) asyncio.run_coroutine_threadsafe(self._send_message(identity, msg), self._event_loop)
def transmit_threadsafe(self, command_id, *args): """ A thread safe version of send. :param command_id: Command id :param *args: Command arguments """ asyncio.run_coroutine_threadsafe(self.transmit(command_id, *args), self.loop)
def setup(self): """ Set up this Ultros instance. This will parse configs, load plugins, and get networks connected. The managers however have already been instantiated. """ self.network_manager.load_networks() asyncio.run_coroutine_threadsafe(self.network_manager.connect_all(), self.event_loop)
def trigger_callback(self, event, *args): with self.callback_lock: callbacks = self.callbacks[event][:] for callback in callbacks: # FIXME: if callback throws, we will lose the traceback if asyncio.iscoroutinefunction(callback): asyncio.run_coroutine_threadsafe(callback(event, *args), self.asyncio_loop) else: self.asyncio_loop.call_soon_threadsafe(callback, event, *args)
def _push_chunk(self, chunk): if self._loop_thread.ident != get_ident(): asyncio.run_coroutine_threadsafe( self._write_queue.put(chunk), loop=self._loop ) else: # avoid races/hangs by just scheduling this, not using threadsafe self._loop.create_task(self._write_queue.put(chunk))
def stop(self): self.acceptMessages = False try: asyncio.run_coroutine_threadsafe(self.client.logout(), self.loop) except: pass try: asyncio.run_coroutine_threadsafe(self.client.close(), self.loop) except: pass
def flush_threadsafe(self, data): """ Thread safe version of flush. :param data: Data to flush. """ # ctlog.debug("OutputPort.flush_threadsafe({})".format(data)) if self.channel is not None: loop = get_event_loop() asyncio.run_coroutine_threadsafe(self.channel.flush(data), loop)
def shutdown(self): """ Shut down the proxy. This method is thread-safe. """ if not self.should_exit.is_set(): self.should_exit.set() asyncio.run_coroutine_threadsafe( self._shutdown(), loop = self.channel.loop, )
def __init__(self, api, source_playlist:SpotifyPlaylist): self.api = api self.tracks = [] self.playlist_id = source_playlist.id if len(source_playlist.tracks) > source_playlist.total_tracks: asyncio.run_coroutine_threadsafe(source_playlist.load_tracks()) self.spotify_tracks = source_playlist.tracks self.playlist_hash = hash(source_playlist)
def _sigbreak(self, *_): """ Handle SIGBREAK (CTRL+BREAK or closing the CMD window) on Windows and shut down gracefully. Note that we only get five seconds when this happens before the process is killed, so we should try to keep this process fast. """ self.log.debug("SIGBREAK caught.") asyncio.run_coroutine_threadsafe(self.shutdown(), self.event_loop)
def _cb(): try: callback(*args, **kwargs) finally: _main_async_loop.stop() async def _null(): pass asyncio.run_coroutine_threadsafe(_null(), _main_async_loop)
def run_client(name, genesis_path, pipe_conn, seed, batch_size, batch_timeout, req_kind, bg_tasks, refresh): cln = LoadClient(name, pipe_conn, batch_size, batch_timeout, req_kind, bg_tasks, refresh) try: asyncio.run_coroutine_threadsafe(cln.run_test(genesis_path, seed), loop=cln._loop) cln._loop.run_forever() except Exception as e: print("{} running error {}".format(cln._name, e)) # cln._loop.close() stat = cln._stat.dump_stat(dump_all=True) return stat
def kill(self, message="Help! Another thread is killing me :("): """Shut down the bot violently :param sys_exit: True causes sys.exit(0) to be called :type sys_exit: bool :param message: Quit message :type message: str """ self.closeAllModules() asyncio.run_coroutine_threadsafe(self.irc.kill(message=message), self.loop)
def test_simple_input_output_ports(self): ujml_code = '<?xml version="1.0"?><ujml version="{}">'.format(uj_version) + ''' <f_stoff s="s"/> </ujml>''' s = Semaphore(0) globs = {"s": s} ujml = from_string(ujml_code, globals=globs) loop = get_event_loop() asyncio.run_coroutine_threadsafe(ujml[0].transmit(), loop=loop) assert s.acquire(timeout=0.1)
def sendData(self, data): for websocket in self.connected.copy(): #print("Sending data: %s" % data) coro = yield from websocket.send(data) future = asyncio.run_coroutine_threadsafe(coro, loop)
def update_tracked_entity_ids(self, entity_ids): """Update the member entity IDs.""" asyncio.run_coroutine_threadsafe( self.async_update_tracked_entity_ids(entity_ids), self.hass.loop).result()
async def next_song(self, ctx, loop): if len(self.queue[str(ctx.guild.id)]) is 0: await ctx.voice_client.disconnect() await ctx.send( "No songs are left in the queue... Just queue the 🍌 song.") #player = await YTDLSource.from_url(self.queue[str(ctx.guild.id)][0], loop=loop) player = self.queue[str(ctx.guild.id)][0] ctx.voice_client.play( player, after=lambda e: asyncio.run_coroutine_threadsafe( self.next_song(ctx, loop), loop=self.bot.loop).result()) self.queue[str(ctx.guild.id)].remove(self.queue[str(ctx.guild.id)][0]) em = discord.Embed(color=discord.Color(value=0x00ff00), title=f"Playing") em.description = player.title duration = player.get_duration() em.set_author(name=ctx.author.name, icon_url=ctx.author.avatar_url) minutes, seconds = divmod(duration, 60) em.add_field( name='Length', value= f"{str(minutes)}:{str(seconds).replace('0', '00').replace('1', '01').replace('2', '02').replace('3', '03').replace('4', '04').replace('5', '05').replace('6', '06').replace('7', '07').replace('8', '08').replace('9', '09')}" ) em.add_field(name='Volume', value=player.volume) em.add_field(name='Position in Queue', value=len(self.queue[str(ctx.guild.id)])) msg = await ctx.send(embed=em) try: await msg.add_reaction("\U000023f8") # Pause await msg.add_reaction("\U000025b6") # Play await msg.add_reaction("\U000023f9") # Stop await msg.add_reaction("\U0001f501") # Repeat await msg.add_reaction("\U00002753") # Help except discord.Forbidden: return await ctx.send( "I don't have Add Reaction permissions, so I can't show my awesome playing panel!" ) try: while ctx.voice_client.is_playing(): reaction, user = await self.bot.wait_for( 'reaction_add', check=lambda reaction, user: user == ctx.author) if reaction.emoji == "⏸": ctx.voice_client.pause() await msg.remove_reaction("\U000023f8", ctx.author) elif reaction.emoji == "▶": ctx.voice_client.resume() await msg.remove_reaction("\U000025b6", ctx.author) elif reaction.emoji == "⏹": ctx.voice_client.stop() await msg.delete() elif reaction.emoji == "🔁": ctx.voice_client.stop() ctx.voice_client.play( next, after=lambda e: print('Player error: %s' % e) if e else None) await msg.remove_reaction("\U0001f501", ctx.author) elif reaction.emoji == "❓": await msg.remove_reaction("\U00002753", ctx.author) embed = discord.Embed(color=discord.Color(value=0x00ff00), title='Music Player Help') embed.description = "**What do these magical buttons do?** \n\n:pause_button: Pauses the current song.\n:arrow_forward: Resumes any currently paused song.\n:stop_button: Stops the playing song and deletes this message.\n:repeat: Starts the current song from the beginning.\n:question: Shows this message." embed.set_footer( text='This will revert back in 15 seconds.') await msg.edit(embed=embed) await asyncio.sleep(15) await msg.edit(embed=em) except discord.Forbidden: return await ctx.send("I can't remove your reactions! Ouch.")
def _speak(self, speaking): try: asyncio.run_coroutine_threadsafe(self.client.ws.speak(speaking), self.client.loop) except Exception as e: log.info("Speaking call in player failed: %s", e)
def run_async_from_thread(func: Callable[..., Coroutine[Any, Any, T_Retval]], *args) -> T_Retval: f = asyncio.run_coroutine_threadsafe( func(*args), _local.loop) # type: concurrent.futures.Future[T_Retval] return f.result()
#!/usr/bin/env python3 import json import asyncio from statistics import median from numbers import Number from electrum_ltc.network import filter_protocol, Network from electrum_ltc.util import create_and_start_event_loop, log_exceptions loop, stopping_fut, loop_thread = create_and_start_event_loop() network = Network() network.start() @log_exceptions async def f(): try: peers = await network.get_peers() peers = filter_protocol(peers) results = await network.send_multiple_requests( peers, 'blockchain.estimatefee', [2]) print(json.dumps(results, indent=4)) feerate_estimates = filter(lambda x: isinstance(x, Number), results.values()) print(f"median feerate: {median(feerate_estimates)}") finally: stopping_fut.set_result(1) asyncio.run_coroutine_threadsafe(f(), loop)
def _run_coro_threadsafe_with_tracing(self, coro): """Runs `coro` on `self._event_loop` inside the current trace spans.""" with tracing.with_trace_context_from_rpc(): return asyncio.run_coroutine_threadsafe( tracing.wrap_coroutine_in_current_trace_context(coro), self._event_loop)
def update_devices(event_time): asyncio.run_coroutine_threadsafe( hass.data[DOMAIN].async_update(), hass.loop)
def push_update(self, state): """Signal a state change and call the async counterpart.""" asyncio.run_coroutine_threadsafe(self.async_push_update(state), self.hass.loop)
def add_token(self, token: 'Token'): asyncio.run_coroutine_threadsafe(self._add_token_key(token.get_key()), self.asyncio_loop)
def add(self, addr): asyncio.run_coroutine_threadsafe(self._add_address(addr), self.asyncio_loop)
def disconnect(self): asyncio.run_coroutine_threadsafe(self._disconnect(),self.loop)
def post(self, coro): if not self.loop or not self.loop.is_running(): raise ThreadLoopNotRunning(f"could not post {coro}") futur = asyncio.run_coroutine_threadsafe(coro, loop=self.loop) return futur.result()
def _on_command(self, msg): """ProtocolRunner command listener""" # Notify command on main thread asyncio.run_coroutine_threadsafe(self._listener.on_protocol_event(msg), self._loop)
def maybe_analyze_graph(self): loop = asyncio.get_event_loop() fut = asyncio.run_coroutine_threadsafe(self._maybe_analyze_graph(), loop) fut.result()
def on_stream_update(data): for stream in server.streams: if stream.status == 'playing': for group in server.groups: asyncio.run_coroutine_threadsafe( group.set_stream(stream.identifier), loop)
def run(awaitable): if should_use_sync(): loop = get_or_create_background_event_loop() future = asyncio.run_coroutine_threadsafe(awaitable, loop) return future.result() return awaitable
def pull(self, wallet, force): return asyncio.run_coroutine_threadsafe( self.pull_thread(wallet, force), wallet.network.asyncio_loop).result()
def reply(self, channel, msg): asyncio.run_coroutine_threadsafe( self.dclient.send_message(channel, msg), self.dclient.loop)
def _on_message(self, client, userdata, msg): # NOTE! This method is called by the paho-mqtt thread, thus any invocation to the # asyncio platform must be scheduled via `self._loop.call_soon_threadsafe()` method. _LOGGER.debug( f"Received message from topic {msg.topic}: {str(msg.payload)}") # In order to correctly dispatch a message, we should look at: # - message destination topic # - message methods # - source device (from value in header) # Based on the network capture of Meross Devices, we know that there are 4 kinds of messages: # 1. COMMANDS sent from the app to the device (/appliance/<uuid>/subscribe) topic. # Such commands have "from" header populated with "/app/<userid>-<appuuid>/subscribe" as that tells the # device where to send its command ACK. Valid methods are GET/SET # 2. COMMAND-ACKS, which are sent back from the device to the app requesting the command execution on the # "/app/<userid>-<appuuid>/subscribe" topic. Valid methods are GETACK/SETACK/ERROR # 3. PUSH notifications, which are sent to the "/app/46884/subscribe" topic from the device (which populates # the from header with its topic /appliance/<uuid>/subscribe). In this case, only the PUSH # method is allowed. # Case 1 is not of our interest, as we don't want to get notified when the device receives the command. # Instead we care about case 2 to acknowledge commands from devices and case 3, triggered when another app # has successfully changed the state of some device on the network. # Let's parse the message message = json.loads(str(msg.payload, "utf8")) header = message['header'] if not verify_message_signature(header, self._cloud_creds.key): _LOGGER.error( f"Invalid signature received. Message will be discarded. Message: {msg.payload}" ) return _LOGGER.debug("Message signature OK") # Let's retrieve the destination topic, message method and source party: destination_topic = msg.topic message_method = header.get('method') source_topic = header.get('from') # Dispatch the message. # Check case 2: COMMAND_ACKS. In this case, we don't check the source topic address, as we trust it's # originated by a device on this network that we contacted previously. if destination_topic == build_client_response_topic(self._cloud_creds.user_id, self._app_id) and \ message_method in ['SETACK', 'GETACK', 'ERROR']: _LOGGER.debug( "This message is an ACK to a command this client has send.") # If the message is a PUSHACK/GETACK/ERROR, check if there is any pending command waiting for it and, if so, # resolve its future message_id = header.get('messageId') future = self._pending_messages_futures.get(message_id) if future is not None: _LOGGER.debug( "Found a pending command waiting for response message") if message_method == 'ERROR': err = CommandError(error_payload=message.payload) self._loop.call_soon_threadsafe(_handle_future, future, None, err) elif message_method in ('SETACK', 'GETACK'): self._loop.call_soon_threadsafe( _handle_future, future, message, None) # future.set_exception else: _LOGGER.error( f"Unhandled message method {message_method}. Please report it to the developer." f"raw_msg: {msg}") # Check case 3: PUSH notification. # Again, here we don't check the source topic, we trust that's legitimate. elif destination_topic == build_client_user_topic( self._cloud_creds.user_id) and message_method == 'PUSH': namespace = header.get('namespace') payload = message.get('payload') origin_device_uuid = device_uuid_from_push_notification( source_topic) parsed_push_notification = parse_push_notification( namespace=namespace, message_payload=payload, originating_device_uuid=origin_device_uuid) if parsed_push_notification is None: _LOGGER.error( "Push notification parsing failed. That message won't be dispatched." ) else: asyncio.run_coroutine_threadsafe( self._handle_and_dispatch_push_notification( parsed_push_notification), self._loop) else: _LOGGER.warning( f"The current implementation of this library does not handle messages received on topic " f"({destination_topic}) and when the message method is {message_method}. " "If you see this message many times, it means Meross has changed the way its protocol " "works. Contact the developer if that happens!")
def push(self, wallet): return asyncio.run_coroutine_threadsafe( self.push_thread(wallet), wallet.network.asyncio_loop).result()
sys.exit(1) # start network loop = create_and_start_event_loop()[0] network = Network() network.start() class Notifier(SynchronizerBase): def __init__(self, network): SynchronizerBase.__init__(self, network) self.watched_addresses = set() self.watch_queue = asyncio.Queue() async def main(self): # resend existing subscriptions if we were restarted for addr in self.watched_addresses: await self._add_address(addr) # main loop while True: addr = await self.watch_queue.get() self.watched_addresses.add(addr) await self._add_address(addr) async def _on_address_status(self, addr, status): print_msg(f"addr {addr}, status {status}") notifier = Notifier(network) asyncio.run_coroutine_threadsafe(notifier.watch_queue.put(addr), loop)
def broadcast_transaction_from_non_network_thread(self, tx, timeout=10): # note: calling this from the network thread will deadlock it fut = asyncio.run_coroutine_threadsafe( self.broadcast_transaction(tx, timeout=timeout), self.asyncio_loop) return fut.result()
def get_transaction(tx): fut = asyncio.run_coroutine_threadsafe(get_tx_async(tx), network.asyncio_loop) return fut.result()
def stop(self): asyncio.run_coroutine_threadsafe( self.main_taskgroup.cancel_remaining(), self.asyncio_loop)
def send_pm(self, user, msg): asyncio.run_coroutine_threadsafe( self.dclient.start_private_message(user), self.dclient.loop) asyncio.run_coroutine_threadsafe(self.dclient.send_message(user, msg), self.dclient.loop)
def _stop_server_queue(self): # Get a new queue - no old pending connections thanks! self.server_queue = None asyncio.run_coroutine_threadsafe( self.server_queue_group.cancel_remaining(), self.asyncio_loop) self.server_queue_group = None
def doTask(): asyncio.run_coroutine_threadsafe(updateLabel(), loop)
def __init__( self, url, language="en", proxy=None, find_redirect=False, api_url=None, debug=False, newParams=False, executablePath=None, ): self.url = url self.debug = debug self.proxy = proxy self.api_url = api_url self.referrer = "https://www.tiktok.com/" self.language = language self.executablePath = executablePath self.userAgent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/86.0.4240.111 Safari/537.36" self.args = [ "--no-sandbox", "--disable-setuid-sandbox", "--disable-infobars", "--window-position=0,0", "--ignore-certifcate-errors", "--ignore-certifcate-errors-spki-list", "--user-agent=" + self.userAgent, ] if proxy != None: if "@" in proxy: self.args.append( "--proxy-server=" + proxy.split(":")[0] + "://" + proxy.split("://")[1].split(":")[1].split("@")[1] + ":" + proxy.split("://")[1].split(":")[2] ) else: self.args.append("--proxy-server=" + proxy) self.options = { "args": self.args, "headless": True, "ignoreHTTPSErrors": True, "userDataDir": "./tmp", "handleSIGINT": False, "handleSIGTERM": False, "handleSIGHUP": False, } if self.executablePath != None: self.options["executablePath"] = self.executablePath if async_support: loop = asyncio.new_event_loop() t = Thread(target=self.__start_background_loop, args=(loop,), daemon=True) t.start() if find_redirect: fut = asyncio.run_coroutine_threadsafe(self.find_redirect(), loop) elif newParams: fut = asyncio.run_coroutine_threadsafe(self.newParams(), loop) else: fut = asyncio.run_coroutine_threadsafe(self.start(), loop) fut.result() else: try: self.loop = asyncio.new_event_loop() if find_redirect: self.loop.run_until_complete(self.find_redirect()) elif newParams: self.loop.run_until_complete(self.newParams()) else: self.loop.run_until_complete(self.start()) except: self.loop.close()
async def play(self, ctx, *, url): """Search for a YouTube video to play, by name.""" if ctx.author.voice is None: return await ctx.send( "Looks like you aren't connected to a voice channel yet! Where do I join?" ) if ctx.voice_client is None: await ctx.author.voice.channel.connect() em = discord.Embed( color=discord.Color(value=0x00ff00), title="Searching...", description= f"{self.bot.get_emoji(441385713091477504)} Searching `{url}`...") m = await ctx.send(embed=em) if not ctx.voice_client.is_playing(): try: player = await YTDLSource.from_url(url, loop=self.bot.loop) except youtube_dl.DownloadError: return await ctx.send( "Couldn't find any video with that name. Try something else." ) try: ctx.voice_client.play( player, after=lambda e: asyncio.run_coroutine_threadsafe( self.next_song(ctx, self.bot.loop ), loop=self.bot.loop).result()) except discord.Forbidden: return await ctx.send( "I don't have permissions to play in this channel.") await m.delete() em = discord.Embed(color=discord.Color(value=0x00ff00), title=f"Playing") em.description = f"**{player.title}**" em.set_author(name=ctx.author.name, icon_url=ctx.author.avatar_url) duration = player.get_duration() minutes, seconds = divmod(duration, 60) em.add_field( name='Length', value= f"{str(minutes)}:{str(seconds).replace('0', '00').replace('1', '01').replace('2', '02').replace('3', '03').replace('4', '04').replace('5', '05').replace('6', '06').replace('7', '07').replace('8', '08').replace('9', '09')}" ) em.add_field(name='Volume', value=player.volume) em.add_field(name='Position in Queue', value='0') msg = await ctx.send(embed=em) try: await msg.add_reaction("\U000023f8") # Pause await msg.add_reaction("\U000025b6") # Play await msg.add_reaction("\U000023f9") # Stop await msg.add_reaction("\U0001f501") # Repeat await msg.add_reaction("\U00002753") # Help except discord.Forbidden: return await ctx.send( "I don't have Add Reaction permissions, so I can't show my awesome playing panel!" ) try: while ctx.voice_client.is_playing(): reaction, user = await self.bot.wait_for( 'reaction_add', check=lambda reaction, user: user == ctx.author) if reaction.emoji == "⏸": ctx.voice_client.pause() await msg.remove_reaction("\U000023f8", ctx.author) elif reaction.emoji == "▶": ctx.voice_client.resume() await msg.remove_reaction("\U000025b6", ctx.author) elif reaction.emoji == "⏹": ctx.voice_client.stop() await msg.delete() elif reaction.emoji == "🔁": ctx.voice_client.stop() ctx.voice_client.play( player, after=lambda e: print('Player error: %s' % e) if e else None) await msg.remove_reaction("\U0001f501", ctx.author) elif reaction.emoji == "❓": await msg.remove_reaction("\U00002753", ctx.author) embed = discord.Embed( color=discord.Color(value=0x00ff00), title='Music Player Help') embed.description = "**What do these magical buttons do?** \n\n:pause_button: Pauses the current song.\n:arrow_forward: Resumes any currently paused song.\n:stop_button: Stops the playing song and deletes this message.\n:repeat: Starts the current song from the beginning.\n:question: Shows this message." embed.set_footer( text='This will revert back in 15 seconds.') await msg.edit(embed=embed) await asyncio.sleep(15) await msg.edit(embed=em) except discord.Forbidden: return await ctx.send("I can't remove your reactions! Ouch.") # except Exception as e: # return await ctx.send(f"An unknown error occured. Details: \n\n```{e}```") # This made shit way too spammy, can't think of a good way to avoid it, rather just remove it. else: try: to_play = await YTDLSource.from_url(url, loop=self.bot.loop) except youtube_dl.DownloadError: return await ctx.send( "Couldn't find any video with that name. Try something else." ) try: self.queue[str(ctx.guild.id)].append(to_play) except KeyError: self.queue[str(ctx.guild.id)] = [to_play] em = discord.Embed(color=discord.Color(value=0x00ff00), title='Added to queue!') em.description = f"**{to_play.title}**" em.add_field(name='Position in Queue', value=len(self.queue[str(ctx.guild.id)])) duration = to_play.get_duration() minutes, seconds = divmod(duration, 60) em.add_field( name='Length', value= f"{str(minutes)}:{str(seconds).replace('0', '00').replace('1', '01').replace('2', '02').replace('3', '03').replace('4', '04').replace('5', '05').replace('6', '06').replace('7', '07').replace('8', '08').replace('9', '09')}" ) em.set_author(name=f"Played by: {ctx.author.name}", icon_url=ctx.author.avatar_url) await ctx.send(embed=em)