def main(self): evl = urwid.AsyncioEventLoop(loop=asyncio.get_event_loop()) self.loop = urwid.MainLoop( self.app_widget, self.app_widget.palette, event_loop=evl ) self.loop.screen.set_terminal_properties(colors=256) async def q(): try: task = self.dev_rant_service.get_rants() w = weakref.ref(task) await task except Exception as e: task_future = w() if task_future: task_future.cancel() await task_future raise e asyncio.ensure_future( q() ) self.loop.run()
def run(argv) -> None: args = parser.parse_args(argv) palette = [ ("text", "white", "black", ""), ("edit", "black", "yellow", ""), ("btn focus", "white", "dark red", ""), ("btn normal", "white", "dark blue", ""), ("li normal", "light cyan", "black", ""), ("li focus", "white", "dark red", ""), ("pg normal", "white", "black", "standout"), ("pg inverted", "black", "light gray", "standout"), ("pg complete", "white", "dark magenta"), ("pg smooth", "dark magenta", "black"), ("screen header", "white", "brown", "standout"), ("screen header divider", "black", "brown", ""), ("bg", "light gray", "black", ""), ("success message", "light green", "black", ""), ("success banner", "white", "dark green", ""), ("error message", "light red", "black", ""), ("error banner", "yellow", "dark red", ""), ("progress", "light magenta", "black", ""), ("remark", "dark gray", "black", ""), ("highlight", "yellow", "black", ""), ("topbar", "black", "white", ""), # Indicator color scheme ("ind normal", "black", "white", ""), ("ind error", "dark red", "white", ""), ("ind warning", "brown", "white", ""), ("ind good", "dark green", "white", ""), # Light color scheme (for modals and popups) ("bg light", "black", "white", ""), ("li normal light", "dark blue", "white", ""), ("success message light", "dark green", "white", ""), ("error message light", "dark red", "white", ""), ("pg normal light", "white", "black", "standout"), ] asyncioloop = asyncio.get_event_loop() evl = urwid.AsyncioEventLoop(loop=asyncioloop) urwidloop = urwid.MainLoop( None, palette=palette, event_loop=evl, input_filter=debounce_esc, pop_ups=True, ) screen = ScreenManagerImpl(urwidloop) shell = OpenvarioShellImpl(screen, config=args.config, rootfs=args.sim) shell.extensions.load_all(shell) shell.apps.install_new_apps() asyncioloop.call_soon(startui, (shell, args.run)) try: urwidloop.run() except KeyboardInterrupt: pass # Clear the screen on exit print("\033[H\033[J", end="")
def run(self, debug: bool = False) -> None: """ Starts the long running co-routines and the urwid event loop. :param debug: Enables/Disables asyncio event loop debugging """ screen = urwid.raw_display.Screen() screen.set_terminal_properties(256) self.aloop = asyncio.get_event_loop() self.aloop.set_debug(debug) # Gracefully handle SIGTERM and SIGINT signals cancel_signals = [signal.SIGTERM, signal.SIGINT] for sig in cancel_signals: self.aloop.add_signal_handler(sig, self.kill_app) event_loop = urwid.AsyncioEventLoop(loop=self.aloop) main_loop = urwid.MainLoop(urwid.AttrMap(self.window, 'background'), unhandled_input=self.unhandled_input, screen=screen, palette=palette, handle_mouse=True, event_loop=event_loop) create_task(self.manage_connection(), self.aloop) try: main_loop.run() except Exception as err: logging.error('%s\n%s\n', str(err), pretty_traceback()) raise err
def __init__(self, cookies_path, keybindings, palette): """Start the user interface.""" self._keys = keybindings # These are populated by on_connect when it's called. self._conv_widgets = {} # {conversation_id: ConversationWidget} self._tabbed_window = None # TabbedWindowWidget self._conv_list = None # hangups.ConversationList self._user_list = None # hangups.UserList self._notifier = None # hangups.notify.Notifier # TODO Add urwid widget for getting auth. try: cookies = hangups.auth.get_auth_stdin(cookies_path) except hangups.GoogleAuthError as e: sys.exit('Login failed ({})'.format(e)) self._client = hangups.Client(cookies) self._client.on_connect.add_observer(self._on_connect) loop = asyncio.get_event_loop() self._urwid_loop = urwid.MainLoop( LoadingWidget(), palette, handle_mouse=False, event_loop=urwid.AsyncioEventLoop(loop=loop)) self._urwid_loop.start() try: # Returns when the connection is closed. loop.run_until_complete(self._client.connect()) finally: # Ensure urwid cleans up properly and doesn't wreck the terminal. self._urwid_loop.stop()
async def __call__(self): btask = self.loop.create_task(self.bus.notify(False)) context = self.load_suite() reporter = functools.partial(self.exception_handler, context) self.loop.set_exception_handler(reporter) if self.skin == "tui": screen = urwid.raw_display.Screen() screen.set_terminal_properties(256) view = TUIView(self.bus, context, screen) view_controller = urwid.MainLoop( view, palette, screen=screen, event_loop=urwid.AsyncioEventLoop(loop=self.loop), unhandled_input=view.input_handler) else: view = RawView(self.bus, context) view_controller = NoopViewController() if self.xunit: xunit = XUnitView(self.bus, context, self.xunit) # noqa try: view_controller.start() await self.connect_controller(context) await self.run(context) finally: # Wait for any unprocessed events before exiting the loop await btask view_controller.stop() await context.juju_controller.disconnect() self.loop.stop() if self._exc and not isinstance(self._exc, ShutdownException): raise self._exc[0](self._exc[1]).with_traceback(self._exc[2])
def __init__( self, connection: net.Connection, log_path: Optional[Path]) -> None: self._connection = connection self._connection.on_connecting.append(self._on_connecting) self._connection.on_connect.append(self._on_connect) self._connection.on_disconnect.append(self._on_disconnect) self._connection.on_message.append(self._on_message) self._connection.on_refresh.append(self._on_refresh) self._connection.on_exception.append(self._on_exception) self._refreshed = False self._log_path = log_path self._main_widget = MainWidget(self._connection.game_info) urwid.signals.connect_signal( self._main_widget.console.input_box, 'command', self._command) urwid.signals.connect_signal( self._main_widget.console.input_box, 'chat', self._chat) self._loop = urwid.MainLoop( self._main_widget, event_loop=urwid.AsyncioEventLoop()) self._loop.screen.set_terminal_properties(256) self._load_palette() self._load_last_log()
def __init__(self, pubpen, cli_args): super().__init__(pubpen, cli_args) # Note: We don't have any extra command line args # Windows self.title_card = TitleScreen(pubpen) self.login_screen = LoginScreen(pubpen) self.main_window = MainScreen(pubpen) self.root_win = urwid.Frame(urwid.SolidFill(' ')) # Arrange the widgets self.show_title_card() # Connect to UI events urwid.connect_signal(self.title_card, 'close_title_card', self.show_login_screen) urwid.connect_signal(self.login_screen, 'logged_in', self.show_main_window) # Setup the main loop self.urwid_loop = urwid.MainLoop( self.root_win, event_loop=urwid.AsyncioEventLoop(loop=self.pubpen.loop), palette=(('reversed', 'standout', ''), ), )
def __init__(self, loop): base = urwid.SolidFill("") self.loop = urwid.MainLoop( base, event_loop=urwid.AsyncioEventLoop(loop=loop), palette=palettes) self.base = base
def __init__(self): super().__init__(False if (len(sys.argv) > 1 and sys.argv[1] == '1') else True) self.notifInfo = {'buffer': '', 'timer': 0, 'endTimer': 6} self.loop = asyncio.get_event_loop() self.loop.create_task(self.initSessions()) self.main_widget = self.build_main_widget() self.mainKeyList = [{'keybind' : self.fileIO.cfg['keybinds']['upload'], 'widget' : self.build_upload_widget, 'input' : self.handle_keys_null}, {'keybind' : self.fileIO.cfg['keybinds']['download'], 'widget' : self.build_download_widget, 'input' : self.handle_keys_download}, {'keybind' : self.fileIO.cfg['keybinds']['resume'], 'widget' : self.build_resume_widget, 'input' : self.handle_keys_null}] palette = [('boldtext', 'default,bold', 'default', 'bold'), ('reversed', 'standout', '')] self.urwid_loop = urwid.MainLoop( widget=self.main_widget, palette=palette, handle_mouse=False, unhandled_input=self.handle_keys_main, event_loop=urwid.AsyncioEventLoop(loop=self.loop) )
def __init__(self, vehicle, joystick): self._vehicle = vehicle self._joystick = joystick self.mapping = {} self.success = False palette = [('bg', 'black', 'white'), ('title', 'black,bold', 'white')] title = urwid.Text(('title', '\n{}\n'.format(TITLE)), align='center') self._text = urwid.Text('') def skip_or_finish(obj): if self._current >= len(self._vehicle.inputs): self.success = True raise urwid.ExitMainLoop() self._next_input() self._btn = urwid.Button('', on_press=skip_or_finish) def exit(obj): raise urwid.ExitMainLoop() exit_btn = urwid.Button('Exit', on_press=exit) rows = urwid.Pile([title, self._text, self._btn, exit_btn]) top = urwid.AttrMap(urwid.Filler(rows, 'top'), 'bg') evl = urwid.AsyncioEventLoop(loop=asyncio.get_event_loop()) self._loop = urwid.MainLoop(top, palette, event_loop=evl) self._locked_axes = set() self._current = 0 self._current_sub = 0 # for trimmer self._update_text()
def main(args=None): loop = asyncio.get_event_loop() bus = Bus(loop=loop) # logging resolves default bus from the module set_default_bus(bus) matrix = rules.RuleEngine(bus=bus) options = setup(matrix, args) loop.set_debug(options.log_level == logging.DEBUG) loop.create_task(matrix()) if options.skin == "tui": view = TUIView(bus) view_controller = urwid.MainLoop( view.widgets, event_loop=urwid.AsyncioEventLoop(loop=loop), unhandled_input=unhandled) else: view = RawView(bus) view_controller = NoopViewController() try: loop.create_task(bus.notify(False)) view_controller.start() loop.run_forever() finally: view_controller.stop() loop.stop() loop.close()
def run(self): if not sys.stdout.isatty(): print("Error: mitmproxy's console interface requires a tty. " "Please run mitmproxy in an interactive shell environment.", file=sys.stderr) sys.exit(1) self.ui = window.Screen() self.ui.set_terminal_properties(256) self.set_palette(self.options, None) self.options.subscribe( self.set_palette, ["console_palette", "console_palette_transparent"] ) self.loop = urwid.MainLoop( urwid.SolidFill("x"), event_loop=urwid.AsyncioEventLoop(loop=asyncio.get_event_loop()), screen = self.ui, handle_mouse = self.options.console_mouse, ) self.window = window.Window(self) self.loop.widget = self.window self.window.refresh() if self.start_err: def display_err(*_): self.sig_add_log(None, self.start_err) self.start_err = None self.loop.set_alarm_in(0.01, display_err) super().run_loop(self.loop.run)
def test_pop_activity() -> None: # GIVEN # Create a basic palette and an urwid main loop - we are messing with the internal # implementation of palette handling. urwid_mock = UrwidMock() palette = [ ("text", "white", "black", ""), ] asyncioloop = asyncio.get_event_loop() evl = urwid.AsyncioEventLoop(loop=asyncioloop) mainloop = urwid.MainLoop(None, palette=palette, event_loop=evl) screen = ScreenManagerImpl(mainloop) act1 = ActivityStub("Activity One") act2 = ActivityStub("Activity Two") screen.push_activity(act1) screen.push_activity(act2) assert "Activity Two" in urwid_mock.render(mainloop.widget) # WHEN screen.pop_activity() # THEN assert "Activity One" in urwid_mock.render(mainloop.widget) assert act2.activated == 1 assert act2.destroyed == 1 assert act2.shown == 1 assert act2.hidden == 1 assert act1.activated == 1 assert act1.shown == 2 assert act1.hidden == 1
def run(self, loop): urwid_loop = urwid.MainLoop( self.root_widget, event_loop=urwid.AsyncioEventLoop(loop=loop), unhandled_input=self.unhandled, ) return urwid_loop
def runloop(self): self.loop = urwid.MainLoop( self.main_widget, self.palette, # This event loop plays nicer with vlc callbacks event_loop=urwid.AsyncioEventLoop(), unhandled_input=self.handle_input, ) self.loop.run()
def demo1(): txt = urwid.Text(u"Hello World!!!!") fill = urwid.Filler(txt, 'top') urwid_loop = urwid.MainLoop( fill, event_loop=urwid.AsyncioEventLoop(loop=asyncio.get_event_loop()), unhandled_input=unhandled, ) urwid_loop.run()
def loop(self, handle_mouse=False): # self.eloop=urwid.MainLoop(self, self.PALLETE, handle_mouse=handle_mouse) # self._eloop_thread=threading.current_thread() # self.eloop.run() import asyncio evl = urwid.AsyncioEventLoop(loop=asyncio.get_event_loop()) self.eloop = urwid.MainLoop(self, self.PALLETE, event_loop=evl, handle_mouse=True) self._eloop_thread=threading.current_thread() self.eloop.run()
def main(self): self.setup_view() evl = urwid.AsyncioEventLoop(loop=asyncio.get_event_loop()) loop = urwid.MainLoop(self.view, palette=self.palette, unhandled_input=self.keypress, event_loop=evl) loop.set_alarm_in(self.timer, self.refresh) loop.run()
def wiredolphin(filename): asyncio.ensure_future(capture_memeory_packets(filename)) main_loop = urwid.MainLoop( urwid.Frame(pile), palette=palette, screen=screen, unhandled_input=global_input, event_loop=urwid.AsyncioEventLoop(loop=event_loop)) main_loop.run()
def run(self): self.loop=urwid.MainLoop( self.tui, self.PALETTE, event_loop=urwid.AsyncioEventLoop(loop=self.aloop), unhandled_input=self.handle_keys, handle_mouse=False ) self.state.set_text(self.GLOBAL_STATES['CONWAIT']) self.loop.run()
def build_loop(cls, ui, palette, **kwargs): """ Builds eventloop """ cls.extra_opts['screen'].set_terminal_properties(colors=256) cls.extra_opts.update(**kwargs) evl = asyncio.get_event_loop() cls.loop = urwid.MainLoop(ui, palette, event_loop=urwid.AsyncioEventLoop(loop=evl), pop_ups=True, **cls.extra_opts)
def main(self) -> None: self._asyncio_loop = asyncio.get_event_loop() self._loop = urwid.MainLoop( self._view, palette=self._palette_generator.create_palette(), event_loop=urwid.AsyncioEventLoop(loop=self._asyncio_loop), ) self._loop.screen.set_terminal_properties(colors=256) self._asyncio_loop.create_task(self._get_zone_websocket_jobs()) self._loop.run()
def __init__(self, argv): signal.signal(signal.SIGINT, self.sigint) self.file = argv[1] self.readonly = False if self.file.startswith('ip:'): ip = tuple(self.file.split(':')[1:]) print(ip) self.fd = socket.create_connection(self.file.split(':')[1:]) self.io = self.fd.makefile('rw') else: if stat.S_ISCHR(os.stat(self.file).st_mode): self.fd = serial.Serial(self.file, 115200, timeout=1) self.io = io.TextIOWrapper(io.BufferedRandom(self.fd)) else: self.fd = io.FileIO(self.file, 'r') self.io = io.TextIOWrapper(io.BufferedReader(self.fd)) self.readonly = True self.leftbox = urwid.ListBox( urwid.SimpleFocusListWalker([urwid.Text('')])) self.rightbox = urwid.ListBox( urwid.SimpleFocusListWalker([urwid.Text(''), urwid.Text('')])) self.column = urwid.Columns([self.leftbox, self.rightbox]) self.header = urwid.AttrMap(urwid.Text('CAN Bus data stats'), 'header') self.status_icons = urwid.WidgetPlaceholder(urwid.Text('')) self.status_packets = urwid.WidgetPlaceholder(urwid.Text('')) self.footer = urwid.AttrMap( urwid.Columns([self.status_icons, self.status_packets]), 'footer') self.frame = urwid.PopUpTarget( urwid.Frame(self.column, header=self.header, footer=self.footer)) self.statline = [] self.c_packets = 0 self.errors = 0 self.packets = [] self.packets_by_id = dictlist() self.packet_last_time = {} self.packet_avg_times = {} self.ids = Counter() self.classes = Counter() self.event_loop = urwid.AsyncioEventLoop() self.main_loop = urwid.MainLoop(self.frame, event_loop=self.event_loop, unhandled_input=self.handle_key) self.watch_file_handle = None self.toggle_watch() self.event_loop.alarm(0.25, self.update_display) if self.readonly: self.update_statline('RO')
def main(): global loop, client, urwid_loop client = motor.motor_asyncio.AsyncIOMotorClient(host="localhost") loop = asyncio.get_event_loop() urwid_loop = urwid.MainLoop( urwid.SolidFill(), # Placeholder palette=[('reversed', 'standout', '')], event_loop=urwid.AsyncioEventLoop(loop=loop), unhandled_input=lambda k: asyncio.create_task(handle_input(k)), ) loop.create_task(render()) urwid_loop.run()
def build_app(self): widgets, scrolled_texts = self.create_widgets() top = self.build_top(widgets) evl = urwid.AsyncioEventLoop(loop=self.loop) urwid_loop = urwid.MainLoop(top, self.palette, event_loop=evl, unhandled_input=self.key_handler, handle_mouse=False) self.widgets = widgets self.scrolled_texts = scrolled_texts return urwid_loop
def start(self, loop, will_align): widgets = self.build_widgets(will_align) uaioloop = urwid.AsyncioEventLoop(loop=loop) self.urwid_loop = urwid.MainLoop(widgets, event_loop=uaioloop, palette=self.palette, unhandled_input=self.exit_on_q) self.start_update_hooks(loop) self.urwid_loop.start()
def get_app_in_loop(pallete): screen = urwid.raw_display.Screen() screen.set_terminal_properties(256) screen.register_palette(pallete) ui = UI(urwid.SolidFill()) decorated_ui = urwid.AttrMap(ui, "root") loop = ThreadSafeLoop(decorated_ui, screen=screen, event_loop=urwid.AsyncioEventLoop(), handle_mouse=False) ui.loop = loop return loop, ui
def __init__(self, refresh_token_path, keybindings, palette, palette_colors, datetimefmt, notifier_, discreet_notifications): """Start the user interface.""" self._keys = keybindings self._datetimefmt = datetimefmt self._notifier = notifier_ self._discreet_notifications = discreet_notifications set_terminal_title('hangups') # These are populated by on_connect when it's called. self._conv_widgets = {} # {conversation_id: ConversationWidget} self._tabbed_window = None # TabbedWindowWidget self._conv_list = None # hangups.ConversationList self._user_list = None # hangups.UserList # TODO Add urwid widget for getting auth. try: cookies = hangups.auth.get_auth_stdin(refresh_token_path) except hangups.GoogleAuthError as e: sys.exit('Login failed ({})'.format(e)) self._client = hangups.Client(cookies) self._client.on_connect.add_observer(self._on_connect) loop = asyncio.get_event_loop() try: self._urwid_loop = urwid.MainLoop( LoadingWidget(), palette, handle_mouse=False, input_filter=self._input_filter, event_loop=urwid.AsyncioEventLoop(loop=loop)) except urwid.AttrSpecError as e: # Fail gracefully for invalid colour options. sys.exit(e) self._urwid_loop.screen.set_terminal_properties(colors=palette_colors) self._urwid_loop.start() # Enable bracketed paste mode after the terminal has been switched to # the alternate screen (after MainLoop.start() to work around bug # 729533 in VTE. with bracketed_paste_mode(): try: # Returns when the connection is closed. loop.run_until_complete(self._client.connect()) finally: # Ensure urwid cleans up properly and doesn't wreck the # terminal. self._urwid_loop.stop() loop.close()
async def run(): placeholder = urwid.WidgetPlaceholder( urwid.Filler(urwid.Text("Initialize..."))) with urwid.MainLoop( urwid.LineBox(placeholder), event_loop=urwid.AsyncioEventLoop(), handle_mouse=False, ).start(): def widget_cb(widget): placeholder.original_widget = widget await main_menu(widget_cb)
def create(cls, app, user): """Factory method, sets up TUI and an event loop.""" tui = cls(app, user) loop = urwid.MainLoop( tui, palette=PALETTE, event_loop=urwid.AsyncioEventLoop(), unhandled_input=tui.unhandled_input, ) tui.loop = loop return tui