def run_task(self): from prompt_toolkit.eventloop import use_asyncio_event_loop from tui_app import make_tui_app use_asyncio_event_loop() logger.info('run_task ENTER') wrapped_application = make_tui_app(config=self.config, out_queue=self.tui_queue, state=self.task_state) application = wrapped_application.application self.logger_buffer = application.layout.get_buffer_by_name( 'logger_buffer') if self.logger_sink: asyncio.ensure_future(self.pull_logger_sink()) if self.control_sink: asyncio.ensure_future(self.pull_control_sink()) asyncio.ensure_future(self.pull_tui_sink()) asyncio.get_event_loop().run_until_complete( application.run_async().to_asyncio_future()) logger.info('run_task EXIT')
def __init__(self, input_handler: Callable, bindings: KeyBindings, completer: Completer): use_asyncio_event_loop() self.input_field = create_input_field(completer=completer) self.output_field = create_output_field() self.log_field = create_log_field() self.layout = generate_layout(self.input_field, self.output_field, self.log_field) self.bindings = bindings self.input_handler = input_handler self.input_field.accept_handler = self.accept self.app = Application(layout=self.layout, full_screen=True, key_bindings=self.bindings, style=load_style(), mouse_support=True, clipboard=PyperclipClipboard()) self.log_lines: Deque[str] = deque() self.log(HEADER) # settings self.prompt_text = ">>> " self.pending_input = None self.input_event = None self.hide_input = False
async def _run_prompt_forever(self): while True: try: if _is_prompt_toolkit3(): result = await self.session.prompt_async( self.prompt, completer=self.completer) else: # This is done because old versions of prompt toolkit don't support Python 3.5. # When we deprecate 3.5, this can be removed. from prompt_toolkit.eventloop import use_asyncio_event_loop use_asyncio_event_loop() result = await self.session.prompt( self.prompt, async_=True, completer=self.completer) except EOFError: return if not result: continue args = shlex.split(result) if args[0] in self.command_list: try: self._currently_running_task = asyncio.ensure_future( self._run_single_command(args[0], args[1:])) await self._currently_running_task except asyncio.CancelledError: print() continue except ExitPromptException: return else: print("Command %s not found!" % args[0])
def __init__(self, args): use_asyncio_event_loop() self.args = args self.current_context = self self.contexts = [ TeamServers(args['<URL>']), Listeners(), Sessions(), Modules(), Stagers() ] self.teamservers = self.contexts[0] self.completer = STCompleter(self) self.prompt_session = PromptSession( HTML(("[<ansiyellow>" f"{len(self.teamservers.connections)}" "</ansiyellow>] ST ≫ ")), bottom_toolbar=functools.partial(bottom_toolbar, ts=self.teamservers), completer=self.completer, complete_in_thread=True, complete_while_typing=True, auto_suggest=AutoSuggestFromHistory(), #rprompt=get_rprompt(False), #style=example_style, search_ignore_case=True)
def main(): doc = """ Mesh CLI Usage: meshcli [options] [<command>] meshcli -h | --help | --version Options: -l --login <login> User login to platform service (email) -p --password <password> User password to platform service (!unsecured!) -n --project <project> Project name to be loaded from platform --partner <partner> Partner identifier [default: silvair] --env <environment> Environment: dev,preprod or prod [default: preprod] -d --debug -h --help Show this help message and exit --version Show version and exit """ use_asyncio_event_loop() arguments = docopt(doc, version="stat_checker 0.5") logging.basicConfig( format= "%(asctime)s %(name)-40s %(levelname)-8s %(filename)15s:%(lineno)3s %(message)s", level=logging.INFO, datefmt="%Y-%m-%d %H:%M:%S", ) loop = asyncio.get_event_loop() mesh_cli = MeshCommandLine(loop, arguments) with suppress(EOFError, KeyboardInterrupt), patch_stdout(): loop.run_until_complete(mesh_cli.run(arguments.get("<command>")))
def main(etmdir=""): global item, settings, ampm, style, etmstyle, application ampm = settings['ampm'] terminal_style = settings['style'] if terminal_style == "dark": style = dark_style etmstyle = dark_etmstyle else: style = light_style etmstyle = light_etmstyle agenda_view() application = Application( layout=Layout( root_container, focused_element=text_area, ), key_bindings=bindings, enable_page_navigation_bindings=True, mouse_support=True, style=style, full_screen=True) # Tell prompt_toolkit to use asyncio. use_asyncio_event_loop() # Run application async. loop = get_event_loop() loop.call_later(0, event_handler, loop) loop.run_until_complete( application.run_async().to_asyncio_future())
async def cmdloop(self): use_asyncio_event_loop() self.db = await aiosqlite.connect(self.db_path) try: while True: #with patch_stdout(): text = await self.prompt_session.prompt(async_=True) command = shlex.split(text) if len(command): # Apperently you can't call await on a coroutine retrieved via getattr() ?? # So this sucks now but thankfully we don't have a lot of commands try: if command[0] == 'exit': await self.exit() break elif command[0] == 'show': await self.show(command[1:]) elif command[0] == 'open': await self.open(command[1:]) elif command[0] == 'hosts': await self.hosts(command[1:]) elif command[0] == 'servers': await self.servers(command[1:]) elif command[0] == 'scan': await self.scan() except Exception as e: import traceback traceback.print_exc() print(f"Error calling command '{command[0]}': {e}") finally: await self.db.close()
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(): # 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(): cfg = config.parse() rchat = api.Session(cfg) app, appstate = build_layout(rchat) use_asyncio_event_loop() loop = asyncio.get_event_loop() loop.call_soon(list_channels, loop, rchat, appstate) loop.run_until_complete(app.run_async().to_asyncio_future())
def run(args): configure_logger(logging.getLogger(), args.log_level) loop = asyncio.get_event_loop() use_asyncio_event_loop(loop) try: return asyncio.get_event_loop().run_until_complete(_run(args)) except KeyboardInterrupt: logger.warn("CTRL-C pressed, exiting")
async def activate_prompt_toolkit_async_mode(): """Configure prompt toolkit to use the asyncio event loop. Needs to be async, so we use the right event loop in py 3.5""" from prompt_toolkit.eventloop import use_asyncio_event_loop global ACTIVATED_ASYNC_MODE # Tell prompt_toolkit to use asyncio for the event loop. use_asyncio_event_loop() ACTIVATED_ASYNC_MODE = True
def run_scrimmage_ui(): use_asyncio_event_loop() app = Application( layout=layout, key_bindings=kb, full_screen=True, style=style, mouse_support=True, enable_page_navigation_bindings=True,) loop = asyncio.get_event_loop() loop.run_until_complete( app.run_async().to_asyncio_future())
def launch(self): colorama.init() use_asyncio_event_loop() patch_stdout() while self.run_again: self.run_again = False self._loop = True self.loop.create_task(self.start()) try: self.loop.run_until_complete( self.app.run_async().to_asyncio_future()) except KeyboardInterrupt: if self.current_ip != self.own_ip: self.loop.run_until_complete(self.command("dc"))
def run(args): configure_logger(logging.getLogger(), args.log_level) loop = asyncio.get_event_loop() use_asyncio_event_loop(loop) try: return asyncio.get_event_loop().run_until_complete(_run(args)) except KeyboardInterrupt: logger.warn("CTRL-C pressed, exiting") except Terminated: logger.warn("Browser window terminated, exiting") except AuthResponseError as exc: logger.error( f'Required attributes not found in response ("{exc}", does this endpoint do SSO?), exiting' ) except HTTPError as exc: logger.error(f"Request error: {exc}")
def __init__(self, *, base, loop): use_asyncio_event_loop(loop) self.app = App( base=base, loop=loop, message_handler=self.handle_incoming_message, friend_handler=self.handle_friend_request, ) self.files = [] self.active_friend = None self.prompt_session = PromptSession() self.online_friends = [] self.offline_friends = [] self.count = 0 self.addable_entities = {} self.friend_request_count = 0 loop.create_task(self.run_update())
def main(): """Sets up playback and app then runs both in async loop """ ################################################### # Setting Up Playback object ################################################### files = parseconfig("histfile_list") playback_list = [] for fi, hint in files.items(): playback_list.append(Playback(fi, hint)) playback = merge_history(playback_list) playback.playback_mode = "MANUAL" ################################################### # Setting Up HspApp object ################################################### hspApp = HspApp(playback, SAVE_LOCATION) ################################################### # Setting Up async loop ################################################### loop = asyncio.get_event_loop() use_asyncio_event_loop() try: # Run command_loop and hspApp.run_async next to each other # future: handle when one completes before the other loop.run_until_complete( asyncio.gather( hspApp.command_loop(), hspApp.run_async().to_asyncio_future(), hspApp.playback.run_async(), hspApp.redraw_timer(), )) finally: loop.close()
def main(): # Tell prompt_toolkit to use asyncio for the event loop. use_asyncio_event_loop() logging.basicConfig(level=logging.INFO, format='%(levelname)s: %(message)s') # logging.getLogger('asyncio').setLevel(logging.DEBUG) if sys.platform == 'win32': loop = asyncio.ProactorEventLoop() asyncio.set_event_loop(loop) else: loop = asyncio.get_event_loop() # loop.set_debug(True) parser = argparse.ArgumentParser( description='Run FS-UAE with enabled console debugger.') parser.add_argument('params', nargs='*', type=str, help='Parameters passed to FS-UAE emulator.') args = parser.parse_args() uae = UaeLaunch(loop, args.params) loop.run_until_complete(uae) loop.close()
def main(): parser = argparse.ArgumentParser() # Network group group = parser.add_mutually_exclusive_group() group.add_argument("-m", "--mainnet", action="store_true", default=False, help="Use MainNet instead of the default TestNet") group.add_argument( "-p", "--privnet", nargs="?", metavar="host", const=True, default=False, help= "Use a private net instead of the default TestNet, optionally using a custom host (default: 127.0.0.1)" ) group.add_argument( "--coznet", action="store_true", default=False, help="Use the CoZ network instead of the default TestNet") group.add_argument( "-u", "--unittest", nargs="?", metavar="host", const=True, default=False, help= "Use a private net instead of the default TestNet, optionally using a custom host (default: 127.0.0.1)" ) group.add_argument("-c", "--config", action="store", help="Use a specific config file") # Theme parser.add_argument( "-t", "--set-default-theme", dest="theme", choices=["dark", "light"], help= "Set the default theme to be loaded from the config file. Default: 'dark'" ) # Verbose parser.add_argument("-v", "--verbose", action="store_true", default=False, help="Show smart-contract events by default") # Where to store stuff parser.add_argument("--datadir", action="store", help="Absolute path to use for database directories") # peers parser.add_argument("--minpeers", action="store", type=int, choices=range(1, 10 + 1), metavar="[1-10]", help="Min peers to use for P2P Joining") parser.add_argument("--maxpeers", action="store", type=int, default=5, choices=range(1, 10 + 1), metavar="[1-10]", help="Max peers to use for P2P Joining") # Show the neo-python version parser.add_argument( "--version", action="version", version="neo-python v{version}".format(version=__version__)) args = parser.parse_args() # Setting the datadir must come before setting the network, else the wrong path is checked at net setup. if args.datadir: settings.set_data_dir(args.datadir) # Setup depending on command line arguments. By default, the testnet settings are already loaded. if args.config: settings.setup(args.config) elif args.mainnet: settings.setup_mainnet() elif args.privnet: try: settings.setup_privnet(args.privnet) except PrivnetConnectionError as e: logger.error(str(e)) return elif args.coznet: settings.setup_coznet() elif args.unittest: settings.setup_unittest_net() # Logfile settings & setup logfile_fn = os.path.join(settings.DATA_DIR_PATH, 'prompt.log') logfile_max_bytes = 5e7 # 50 MB logfile_backup_count = 3 # 3 logfiles history settings.set_logfile(logfile_fn, logfile_max_bytes, logfile_backup_count) if args.theme: preferences.set_theme(args.theme) if args.verbose: settings.set_log_smart_contract_events(True) def set_min_peers(num_peers) -> bool: try: settings.set_min_peers(num_peers) print("Minpeers set to ", num_peers) return True except ValueError: print("Please supply a positive integer for minpeers") return False def set_max_peers(num_peers) -> bool: try: settings.set_max_peers(num_peers) print("Maxpeers set to ", num_peers) return True except ValueError: print("Please supply a positive integer for maxpeers") return False minpeers = args.minpeers maxpeers = args.maxpeers if minpeers and maxpeers: if minpeers > maxpeers: print("minpeers setting cannot be bigger than maxpeers setting") return if not set_min_peers(minpeers) or not set_max_peers(maxpeers): return elif minpeers: if not set_min_peers(minpeers): return if minpeers > settings.CONNECTED_PEER_MAX: if not set_max_peers(minpeers): return elif maxpeers: if not set_max_peers(maxpeers): return if maxpeers < settings.CONNECTED_PEER_MIN: if not set_min_peers(maxpeers): return loop = asyncio.get_event_loop() # put prompt_toolkit on top of asyncio to avoid blocking use_asyncio_event_loop() # Instantiate the blockchain and subscribe to notifications blockchain = Blockchain( DBFactory.getBlockchainDB(settings.chain_leveldb_path)) Blockchain.RegisterBlockchain(blockchain) # Try to set up a notification db if NotificationDB.instance(): NotificationDB.instance().start() # Start the prompt interface fn_prompt_history = os.path.join(settings.DATA_DIR_PATH, '.prompt.py.history') cli = PromptInterface(fn_prompt_history) cli_task = loop.create_task(cli.run()) p2p = NetworkService() loop.create_task(p2p.start()) async def shutdown(): all_tasks = asyncio.all_tasks() for task in all_tasks: task.cancel() with suppress(asyncio.CancelledError): await task # prompt_toolkit hack for not cleaning up see: https://github.com/prompt-toolkit/python-prompt-toolkit/issues/787 old_attrs = termios.tcgetattr(sys.stdin) try: loop.run_forever() except SystemExit: pass finally: with suppress(asyncio.InvalidStateError): app = prompt_toolkit_get_app() if app.is_running: app.exit() with suppress((SystemExit, Exception)): cli_task.exception() loop.run_until_complete(p2p.shutdown()) loop.run_until_complete(shutdown()) loop.run_until_complete(loop.shutdown_asyncgens()) loop.stop() loop.close() # Run things # After the reactor is stopped, gracefully shutdown the database. NotificationDB.close() Blockchain.Default().Dispose() # clean up prompt_toolkit mess, see above termios.tcsetattr(sys.stdin, termios.TCSANOW, old_attrs)
def runclient(): pubkey, privkey = get_keys() parser = configparser.ConfigParser() nloop = asyncio.new_event_loop() if os.path.exists("./server.conf") and yes_no_dialog( "Server", "Connect to last server?"): parser.read("server.conf") server = parser["server"]["server"] port = str(int(parser["server"]["port"])) else: server = input_dialog("Server", "Enter Server IP/Hostname:") port = input_dialog("Server", "Enter Port:") try: int(port) except: message_dialog("Server", "Invalid Port") sys.exit(1) parser["server"] = {} parser["server"]["server"] = server parser["server"]["port"] = port # save the server conf to file with open("server.conf", "w") as cfile: parser.write(cfile) # connect to server nick = input_dialog("Nickname", "Enter a nickname:") if nick is None: nick = "" banned = "/." if any([x in banned for x in nick]): message_dialog("Nickname", "Invalid nickname") messages = TextArea("", read_only=True) mes = [] q = queue.Queue() def handle_message(buf): q.put(buf.text) inputbox = TextArea(height=1, multiline=False, accept_handler=handle_message) msgbody = Frame(messages) body = HSplit( [msgbody, Window(height=1, char="#", style="class:line"), inputbox]) root = HSplit([ Window( height=1, content=FormattedTextControl(get_titlebar_text), align=WindowAlign.CENTER, ), Window(height=1, char=" ", style="class:line"), body, ]) kb = KeyBindings() @kb.add("c-c", eager=True) @kb.add("c-q", eager=True) def exitevent(event): q.put("!DISCONNECT") eventquit.set() event.app.exit() nloop.stop() myloop.stop() iscomplete.wait(1) sys.exit(0) app = Application( layout=Layout(root, focused_element=inputbox), key_bindings=kb, mouse_support=True, full_screen=True, ) async def update(serverpipe, qu): while True: while serverpipe.poll(): data = serverpipe.recv() mes.append(data) out = "\n".join(mes) msgbody.body = TextArea(out) get_app().invalidate() try: while True: dt = qu.get_nowait() serverpipe.send(dt) except queue.Empty: pass await asyncio.sleep(0.5) t = threading.Thread(target=startloop, args=(nloop, ), daemon=True) t.start() serversoc, cl = Pipe() iscomplete = threading.Event() eventquit = threading.Event() myloop = asyncio.new_event_loop() asyncio.set_event_loop(myloop) use_asyncio_event_loop(myloop) asyncio.run_coroutine_threadsafe( process_code("ws://{}:{}/{}".format(server, port, nick), cl, eventquit, iscomplete), nloop) asyncio.get_event_loop().create_task(update(serversoc, q)) asyncio.get_event_loop().run_until_complete(app.run_async()) myloop.run_forever()
def terminal_use_async(): """ Tell prompt_toolkit to use asyncio """ use_asyncio_event_loop()
import numpy as np import prompt_toolkit from prompt_toolkit.completion import WordCompleter from prompt_toolkit.eventloop import use_asyncio_event_loop from thotus.task import Task, GuiFeedback, run_in_thread from thotus.shell_commands import commands, toggle_advanced_mode from thotus.commands import get_scanner from thotus.cloudify import LineMaker from thotus.calibration.chessboard import chess_detect, chess_draw from thotus.ui import gui from thotus import settings DEBUG = os.getenv('DEBUG', False) use_asyncio_event_loop() def s2h(t): if t > 80: return "%d min %ds" % divmod(t, 60) else: return "%.1fs" % t class MainGUi: running = True visible = True line_mode = False async def viewer(self):