def resolve_file_conversion(remote_file: GoogleDriveFile) -> str: """ A function to take in a remote file and return to the caller a string that represents the file extension to use for this file. This exists to let users who may not know what conversion are available see all options that are available to them given a document type so they can download the file as the one best suited to their needs. Parameters: remote_file (GoogleDriveFile): The remote file who we are attempting to get the conversion for Returns: conversion_opts[user_input] (str): The file extension we are converting this file to """ while 1: # Print the helpful prompt on what the user is choosing and cache the supported conversions list for this # file print_formatted_text(ANSI(f"\x1b[36mWhat file type would you like to convert \"{remote_file['title']}\" to?")) conversion_opts = [ext for ext, link in SUPPORTED_FILE_TYPES.items() if link in remote_file['exportLinks']] # Print out all of the possible conversion's for this document and their associated number for choice, conversion in enumerate(conversion_opts): print_formatted_text(f"[{choice + 1}]: {conversion}") try: # Prompt the user for their choice of the file types printed out above user_input = int(prompt(ANSI(f'\x1b[36mChoose [1-{len(conversion_opts)}]: '))) - 1 # If the user input a valid index then return the conversion extension they desire if 0 <= user_input < len(conversion_opts): return conversion_opts[user_input] # If the user input a non integer cast-able value then inform them to use the numbers except ValueError: print_formatted_text(ANSI('\x1b[31mPlease input the integer that corresponds to your desired file type'))
def run(self, args): curr_module = core.get_current_module() headers = ['\x1b[96m%s\x1b[0m' % s for s in ['Name', 'Current value', 'Type', 'Required', 'Default value', 'Description']] items = [[n, core.module_input[ n] if n in core.module_input else '\x1b[91m-\x1b[0m\x1b[97m', p.type.__name__, p.required, p.default if p.default else '\x1b[91m-\x1b[0m\x1b[97m', p.description] for n, p in curr_module.input.items()] core.logger.info('Module input parameters:') print() print_formatted_text( ANSI(tabulate( [['\x1b[97m%s\x1b[0m' % str(s) for s in row] for row in items], headers=headers, tablefmt='psql'))) print() if curr_module.output: headers = ['\x1b[96m%s\x1b[0m' % s for s in ['Name', 'Description']] items = list(curr_module.output.items()) core.logger.info('Module output parameters:') print_formatted_text( ANSI(tabulate( [['\x1b[97m%s\x1b[0m' % str(s) for s in row] for row in items], headers=headers, tablefmt='psql'))) print()
def on_enter_alter_definitions(self): click.echo('\n') _alter_resources = confirm( ANSI( click.style(self._TEXT_ASKALTERRESOURCES, fg=self.CLICK_PROMPT_FG_COLOR))) if _alter_resources: # open editor self._edit_file_with_editor(self.settings.resources_path) self._read_resources_file() self._parse_resources() self.settings.solver.set_resources(self.settings.resources) _alter_deployments = confirm( ANSI( click.style(self._TEXT_ASKALTERWORKLOADS, fg=self.CLICK_PROMPT_FG_COLOR))) if _alter_deployments: # open editor self.settings.dsl_content = self._edit_content_with_editor( self.settings.dsl_content) self.settings.dsl_importer.reset_app_modules() self._parse_dsl() self.settings.solver.set_deployment_entities( self.settings.deployment_entities) self.start_matching()
def filterTable(buff): global searching global selected global filteredList global table global passwords global page selected = 0 searching = False filteredList = [] for pwd in passwords: found = False for attr in pwd: if (pwd[attr] and not found): found = toPlain(input_field.text) in toPlain(pwd[attr]) else: pass if (found): filteredList.append(pwd) text = ANSI("") if len(filteredList) == 0: text = ANSI(bcolors.FAIL + "No matches..." + bcolors.ENDC) else: if page != -1: page = 0 text = getFormattedTable(selected, filteredList) table.content.text = text
def resolve_mnemonic_conflict(matching_filenames: List[GoogleDriveFile]) -> GoogleDriveFile: """ A function to ask the user to resolve any mnemonic conflicts that can arise because of how Google Drive works. Since Google Drive has display names that are not unique and since we want to use traditional file pathing as much as possible it is possible that a filename may correspond to many different files. In that case we need to ask the user which one they meant to reference with their query Parameters: matching_filenames (List[GoogleDriveFile]): A list of all google drive files matched the query by the user Returns: file_ids[response] (GoogleDriveFile): The GoogleDriveFile whose ID was entered by the user when prompted """ # Cache a dictionary linking all file ids to their corresponding file objects file_ids = {file['id']: file for file in matching_filenames} while 1: # Let the user know what is going wrong before anything else print_formatted_text(ANSI("\x1b[31mThere are multiple files with the same filename given!\n")) # Until the user provides the info we want keep printing the matching files for file in matching_filenames: pretty_date = file['modifiedDate'][:file['modifiedDate'].index('.')].replace('T', ' ') print_formatted_text(ANSI(f"\x1b[36mDisplay Name: \x1b[37m{file['title']} \x1b[36mLast Modified: " f"\x1b[37m{pretty_date} \x1b[36mFile ID: \x1b[37m{file['id']}")) # Newline for terminal readability and prompt the user to resolve the conflict print_formatted_text("") response = prompt(ANSI('\x1b[31mPlease copy/paste the ID of the file to which you were referring: ')) # If the user's response is a valid key then return the associated file if response in file_ids.keys(): return file_ids[response]
async def run(self): self.clear_output() if self.json["cell_type"] == "code": code = self.input_buffer.text.strip() if code: if self not in self.notebook.executing_cells.values(): self.notebook.dirty = True executing_text = rich_print("\nIn [*]:", style="green") self.input_prefix.content = FormattedTextControl( text=ANSI(executing_text)) self.notebook.execution_count += 1 execution_count = self.notebook.execution_count msg_id = uuid.uuid4().hex self.notebook.msg_id_2_execution_count[ msg_id] = execution_count self.notebook.executing_cells[execution_count] = self await self.notebook.kd.execute(self.input_buffer.text, msg_id=msg_id) del self.notebook.executing_cells[execution_count] text = rich_print( f"\nIn [{execution_count}]:", style="green", ) self.input_prefix.content = FormattedTextControl( text=ANSI(text)) self.json["execution_count"] = execution_count if self.notebook.app: self.notebook.app.invalidate() else: self.clear_output() else: self.clear_output()
def do_sync_repo(progress: ProgressBar, repo_path: Path, repo_data: Repository): """ Perform synchronization of one repository :param progress: ProgressBar instance :param repo_path: Path to repository :param repo_data: Repository data :return: True if successful """ pb = progress() pb.label = ANSI(ui.format_item(str(repo_data.path), ("track", repo_data.track))) if not repo_path.exists(): repo = git.Repo.init(repo_path) repo.create_remote("origin", repo_data.url) try: repo = vcs_git.RepoTool(repo_path, repo_data.url) except vcs_git.InvalidRepository: pb.label = ANSI(ui.format_item_error(f"Unable to open {repo_data.path!s}", "Invalid repository")) return False # Fetch fetch_result = repo.fetch(repo_data.track) # Warn if ahead if fetch_result.ahead: pb.label = ANSI( ui.format_item_error(f"Skipped {repo_data.path!s}", err=f"Ahead by {len(fetch_result.ahead)} commit(s)") ) return False status = repo.get_status() # Warn if dirty if status.is_dirty: pb.label = ANSI(ui.format_item_error(f"Skipped {repo_data.path!s}", err="Workspace is dirty")) return False current_commit = status.head new_commit = fetch_result.fetch_head extras = [] if current_commit is None: extras.append(f"Checked out {repo_data.track}") elif current_commit == new_commit: extras.append(f"Already up to date") else: extras.append(("update", f"{str(current_commit)[0:7]} -> {str(new_commit)[0:7]}")) extras.append(("commits", len(fetch_result.behind))) repo.checkout("origin/" + repo_data.track, repo_data.track) pb.label = ANSI(ui.format_item_ok(str(repo_data.path), *extras)) return True
def print_detect_ansi(val, *more_vals, **kwargs): """ If any val has escape codes, wrap all the vals in ANSI and print with print_formatted_text. Otherwise, print with plain old python print. This is much faster than printing everything with print_formatted_text. """ has_escape = '\x1b' in val or any(['\x1b' in more_vals]) if has_escape: print_formatted_text(ANSI(val), *[ANSI(v) for v in more_vals], **kwargs) else: print(val, *more_vals, **kwargs)
def nb_prompt(self) -> Union[str, ANSI]: prompt = f'<{{}}{self.current.get_type()}{{}}> {self.current.get_name()}$ ' if self.options['color']: if isinstance(self.current, archive_paths.ArchivePath): prompt = ANSI(prompt.format('\x1b[31;1m', '\x1b[0m')) elif isinstance(self.current, paths.VirtualDirPath): prompt = ANSI(prompt.format('\x1b[36;1m', '\x1b[0m')) else: prompt = ANSI(prompt.format('\x1b[34;1m', '\x1b[0m')) else: prompt = prompt.format('', '') return prompt
def main(ctx, verbose, script): '''Runs SCRIPT as a Dish shell script, or runs an interactive shell if it is not specified. GitHub repository: https://github.com/dullbananas/dish ''' interactive = script.isatty() interpreter = Interpreter( ctx=ctx, verbose=verbose, ) if interactive: from prompt_toolkit import PromptSession, ANSI from prompt_toolkit.history import FileHistory from prompt_toolkit.lexers import PygmentsLexer from prompt_toolkit.auto_suggest import ThreadedAutoSuggest from .autosuggest import DishSuggest, CombinedSuggest, FileSuggest from .syntax_highlighting import DishHighlight from pygments.lexers.shell import BashLexer history_path = os.path.expanduser('~/.dish-history') open(history_path, 'a').close() psession = PromptSession( auto_suggest=ThreadedAutoSuggest(CombinedSuggest(objects=[ DishSuggest(ctx=ctx), FileSuggest(ctx=ctx), ])), history=FileHistory(history_path), lexer=DishHighlight(interpreter=interpreter), mouse_support=True, ) gprompt = ctx.obj.generate_prompt while True: prompt1 = ANSI(gprompt('PS1')) prompt2 = ANSI(gprompt('PS2')) line = psession.prompt(prompt1) needs_more = interpreter.feed(line) while needs_more: line = psession.prompt(prompt2) needs_more = interpreter.feed(line) else: while True: line = script.readline() if line == '': break else: interpreter.feed(line[:-1])
async def run(self): if self.notebook.executing_cells[0] is not self: self.clear_output() if self.json["cell_type"] == "code": code = self.input_buffer.text.strip() if code: executing_text = rich_print("\nIn [*]:", self.notebook.console, style="green", end="") if self.notebook.executing_cells[0] is self: already_executing = True else: already_executing = False self.input_prefix.content = FormattedTextControl( text=ANSI(executing_text)) if self.notebook.idle is None: self.notebook.idle = asyncio.Event() else: while True: await self.notebook.idle.wait() if self.notebook.executing_cells[0] is self: break self.notebook.idle.clear() if already_executing: self.input_prefix.content = FormattedTextControl( text=ANSI(executing_text)) self.clear_output() await self.notebook.kd.execute(self.input_buffer.text) text = rich_print( f"\nIn [{self.notebook.execution_count}]:", self.notebook.console, style="green", end="", ) self.input_prefix.content = FormattedTextControl( text=ANSI(text)) self.json["execution_count"] = self.notebook.execution_count self.notebook.execution_count += 1 if self.notebook.app: self.notebook.app.invalidate() self.notebook.executing_cells.remove(self) self.notebook.idle.set() else: self.clear_output() else: self.clear_output() self.notebook.executing_cells.remove(self)
def _render_toolbar(self): """Render the formatted text for the bottom toolbar""" if self.manager.target is None: markup_result = "Active Session: [red]None[/red]" else: markup_result = f"Active Session: {self.manager.target.platform}" # Convert rich-style markup to prompt_toolkit formatted text text = rich.text.Text.from_markup(markup_result) segments = list(text.render(console)) rendered = [] # Here we take each segment's stile, invert the color and render the # segment text. This is because the bottom toolbar has it's colors # inverted. for i in range(len(segments)): style = segments[i].style.copy() temp = style.color style._color = segments[i].style.bgcolor style._bgcolor = temp rendered.append(style.render(segments[i].text)) # Join the rendered segments to ANSI escape sequences. # This format can be parsed by prompt_toolkit formatted text. ansi_result = "".join(rendered) # Produce prompt_toolkit formatted text from the ANSI escaped string return ANSI(ansi_result)
def c_install(self, args): if args: if args.startswith('-i '): args = args[3:] optignore = True else: optignore = False addons = [addon.strip() for addon in args.split(',')] with tqdm(total=len(addons), bar_format='{n_fmt}/{total_fmt} |{bar}|') as pbar: for addon in addons: installed, name, version = self.core.add_addon( addon, optignore) if installed: self.tableData.append( [f'{AC.GREEN}Installed{AC.RESET}', name, version]) else: self.tableData.append([ f'{AC.LIGHTBLACK_EX}Already installed{AC.RESET}', name, version ]) pbar.update(1) self.sanitize_table() printft(ANSI(self.table.table)) else: printft( HTML( '<ansigreen>Usage:</ansigreen>\n\tThis command accepts a comma-separated list of links as an a' 'rgument.\n\tOption <ansiwhite>-i</ansiwhite> will disable the client version check.\n<ansigre' 'en>Supported URLs:</ansigreen>\n\thttps://www.curseforge.com/wow/addons/[addon_name] <ansiwhi' 'te>|</ansiwhite> cf:[addon_name]\n\thttps://www.wowinterface.com/downloads/[addon_name] <ansi' 'white>|</ansiwhite> wowi:[addon_id]\n\thttps://www.tukui.org/addons.php?id=[addon_id] <ansiwh' 'ite>|</ansiwhite> tu:[addon_id]\n\thttps://www.tukui.org/classic-addons.php?id=[addon_id] <an' 'siwhite>|</ansiwhite> tuc:[addon_id]\n\tElvUI <ansiwhite>|</ansiwhite> ElvU' 'I:Dev\n\tTukui'))
def main(self): # Very important that we specify input and output, otherwise the # terminal will mostly work, but not control characters (e.g. backspace, # new line, etc),or ANSI escape sequences will be sent. #session = PromptSession(input=self.input, output=self.output) #print = print_formatted_text cmd = ConsoleCmd(input=self.input, output=self.output, node=self, process_lock=self.process_lock, process_started=self.process_started) cmd.cmdloop() while True: try: prompt = str(self.get_node("/root/Player").prompt) text = session.prompt(ANSI(prompt)) except KeyboardInterrupt: continue except EOFError: continue else: print('You entered:', text) print('looking for file to execute...') bin_path = str( ProjectSettings.globalize_path( "res://system/bin/")) + "rm" + ".py" print('happy?') print(bin_path)
def show_help(self): self.help_mode = True self.help_text = rich_print(md) self.help_window = Window(content=FormattedTextControl( text=ANSI(self.help_text))) self.app.layout = Layout(self.help_window) self.help_line = 0
def __init__(self, debug: bool = True, prompt: str = "> ") -> None: self.debug_ = debug self.prompt = ANSI("> " if prompt is None else prompt) self.stdout = StdoutProxy(sleep_between_writes=0.5) self.out = create_output(self.stdout) self.ses = PromptSession(output=self.out)
def get_output_text_and_height(outputs: List[Dict[str, Any]], console: Console): text_list = [] height = 0 for output in outputs: if output["output_type"] == "stream": text = "".join(output["text"]) height += text.count("\n") or 1 if output["name"] == "stderr": # TODO: take terminal width into account lines = [ line + " " * (200 - len(line)) for line in text.split() ] text = "\n".join(lines) text = rich_print(text, console, style="white on red") elif output["output_type"] == "error": text = "\n".join(output["traceback"]) height += text.count("\n") + 1 elif output["output_type"] == "execute_result": text = "\n".join(output["data"].get("text/plain", "")) height += text.count("\n") or 1 else: continue text_list.append(text) text_ansi = ANSI("".join(text_list)) return text_ansi, height
def main(ctx, verbose, script): '''Runs SCRIPT as a Dish shell script, or runs an interactive shell if it is not specified. GitHub repository: https://github.com/dullbananas/dish ''' interactive = script.isatty() interpreter = Interpreter( ctx=ctx, verbose=verbose, ) if interactive: from prompt_toolkit import PromptSession, ANSI from prompt_toolkit.history import FileHistory from prompt_toolkit.lexers import PygmentsLexer from pygments.lexers.shell import BashLexer history_path = os.path.expanduser('~/.dish-history') open(history_path, 'a').close() psession = PromptSession( history=FileHistory(history_path), lexer=PygmentsLexer(BashLexer), mouse_support=True, ) while True: prompt = ANSI(ctx.obj.generate_prompt('PS1')) line = psession.prompt(prompt) interpreter.feed(line) else: while True: interpreter.feed(script.readline())
def prompt(session): ''' mec prompt ''' cmd_list = readline_init(session) # cook our completions completion_dict = dict.fromkeys(cmd_list) completion_dict["target"] = dict.fromkeys(os.listdir("./data")) completion_dict["set"] = dict.fromkeys(["auto-update", "proxy-pool"]) completion_dict["set"]["auto-update"] = dict.fromkeys(["True", "False"]) mec_completer = NestedCompleter.from_nested_dict(completion_dict) mec_ps = ANSI(colors.CYAN + colors.BOLD + "\nmec > " + colors.END) cmd_autosuggest = ThreadedAutoSuggest(MecAutoSuggest(completions=cmd_list)) try: mecprompt = PromptSession(message=mec_ps, mouse_support=True, history=FileHistory(HISTFILE), completer=mec_completer, complete_while_typing=True, reserve_space_for_menu=2, auto_suggest=cmd_autosuggest).prompt() except termios.error as err: colors.colored_print(f"[-] Fatal error: {err}", color_code=colors.RED) os.system("mec stop") return mecprompt
def on_enter_config_solver(self): click.echo('\n') click.echo('Configure solver settings:\n') _config = self.settings.solver.get_config() for setting in _config.get_settings(): click.echo('Configure {}:\n'.format(setting.name)) _options = setting.get_options() for key, option in enumerate(_options): click.echo('[{}] {} - {}'.format( key, click.style(option.value, fg='blue'), option.description)) _list_of_options = list(range(len(_options))) _list_of_options = ListValidator.list_items_to_str( _list_of_options) option_completer = WordCompleter(_list_of_options) _option_choice = prompt(ANSI( click.style('\nWhich config option do you choose: ', fg=self.CLICK_PROMPT_FG_COLOR)), completer=option_completer, validator=ListValidator(_list_of_options)) setting.set_value(_options[int(_option_choice)]) self.start_matching()
def on_enter_config_dsl(self): click.echo('\n') _importer = { 'helm': Helm, } for plugin in plugins.plugin_manager.getPluginsOfCategory("Importer"): _name = plugin.name.lower() _importer[_name] = plugin.plugin_object _options = list(_importer.keys()) if self.settings.dsl_type is None: prompt_completer = WordCompleter(_options) _dsl_type = prompt(ANSI( click.style(self._TEXT_ASKDSLTYPE, fg=self.CLICK_PROMPT_FG_COLOR)), completer=prompt_completer, validator=ListValidator(_options)) self.settings.dsl_type = _dsl_type try: self.settings.dsl_importer = _importer[self.settings.dsl_type]() except RequirementsError as e: click.echo(click.style('\n[Error] {} '.format(e.message), fg='red'), err=True) exit(1) click.echo('\n') _config = self.settings.dsl_importer.get_config() self._ask_setting_options(_config) self.ask_dsl()
def c_install(self, args): if args: addons = [addon.strip() for addon in args.split(',')] with tqdm(total=len(addons), bar_format='{n_fmt}/{total_fmt} |{bar}|') as pbar: for addon in addons: installed, name, version = self.core.add_addon(addon) if installed: self.tableData.append( [f'{AC.GREEN}Installed{AC.RESET}', name, version]) else: self.tableData.append([ f'{AC.LIGHTBLACK_EX}Already installed{AC.RESET}', name, version ]) pbar.update(1) printft(ANSI(self.table.table)) else: printft( HTML( '<ansigreen>Usage:</ansigreen>\n\tThis command accepts a comma-separated list of links as an a' 'rgument.\n<ansigreen>Supported URLs:</ansigreen>\n\thttps://www.curseforge.com/wow/addons/[ad' 'don_name] <ansiwhite>|</ansiwhite> cf:[addon_name]\n\thttps://www.wowinterface.com/downloads/' '[addon_name] <ansiwhite>|</ansiwhite> wowi:[addon_id]\n\thttps://www.tukui.org/addons.php?id=' '[addon_id]\n\thttps://www.tukui.org/classic-addons.php?id=[addon_id]\n\tElvUI <ansiwhite>|</a' 'nsiwhite> ElvUI:Dev\n\tTukui'))
def c_uninstall(self, args): if args: addons = [ addon.strip() for addon in list(reader([args], skipinitialspace=True))[0] ] with tqdm(total=len(addons), bar_format='{n_fmt}/{total_fmt} |{bar}|') as pbar: for addon in addons: name, version = self.core.del_addon(addon) if name: self.tableData.append([ f'{AC.LIGHTRED_EX}Uninstalled{AC.RESET}', name, version ]) else: self.tableData.append([ f'{AC.LIGHTBLACK_EX}Not installed{AC.RESET}', addon, '' ]) pbar.update(1) self.sanitize_table() printft(ANSI(self.table.table)) else: printft( HTML( '<ansigreen>Usage:</ansigreen>\n\tThis command accepts a comma-separated list of links as an a' 'rgument.\n<ansigreen>Supported URLs:</ansigreen>\n\thttps://www.curseforge.com/wow/addons/[ad' 'don_name] <ansiwhite>|</ansiwhite> cf:[addon_name]\n\thttps://www.wowinterface.com/downloads/' '[addon_name] <ansiwhite>|</ansiwhite> wowi:[addon_id]\n\thttps://www.tukui.org/addons.php?id=' '[addon_id] <ansiwhite>|</ansiwhite> tu:[addon_id]\n\thttps://www.tukui.org/classic-addons.php' '?id=[addon_id] <ansiwhite>|</ansiwhite> tuc:[addon_id]\n\tElvUI <ansiwhite>|</ansiwhite> ElvU' 'I:Dev\n\tTukui'))
def parse_user_input(user_input: str): """ A function to parse user input into a friendly form using the docopt library. We firstly need to split the user input on spaces unless in quotation marks (files can have spaces in names) so we need to use shlex to do this and subsequently separate teh command given from the arguments. Then we can attempt to return the given command along with the arguments parsed out by docopt. We use a simply little trick where we get the get the function pointer for the given command and can use __doc__ to get the docstring for docopt parsing with the arguments being everything in the user input that is not the command. Parameters: user_input (str): The string representing the raw user input to the shell application """ try: # Split the full command into its parts but ignore space in quotes full_command = shlex.split(user_input) command, arguments = full_command[0], full_command[1:] # Attempt to parse the arguments using docopt and a function pointer to their docstring return command, docopt(FUNCTION_COMMANDS[command].__doc__, argv=arguments) except (SystemExit, KeyError) as e: # If the error was caused by the user issuing a non-valid command then let them know if type(e) is KeyError: print_formatted_text( ANSI( f'\x1b[31mCommand "{command}" is not recognized as a valid command!' )) # Otherwise check to make sure they user gave invalid arguments and not asking for help elif '-h' not in arguments and '--help' not in arguments: print_formatted_text( ANSI( f'\x1b[31mInvalid arguments for command "{command}" -> {arguments}' )) # Return an empty dictionary to let execute_shell know we failed return command, dict() except ValueError: # If the error was caused by not closing the parenthesis then let the user know print_formatted_text( ANSI(f'\x1b[31mMissing closing quotation, so cannot parse input')) return '', dict()
def handle_exception(self, e): if len(self.tableData) > 1: printft(ANSI(self.table.table)) if getattr(sys, 'frozen', False): printft(HTML(f'\n<ansibrightred>{str(e)}</ansibrightred>')) else: sys.tracebacklimit = 1000 traceback.print_exc()
def c_update(self, args, addline=False, update=True, force=False): if len(self.core.cfCache) > 0 or len(self.core.wowiCache) > 0: self.core.cfCache = {} self.core.wowiCache = {} if args: addons = [ addon.strip() for addon in list(reader([args], skipinitialspace=True))[0] ] else: addons = sorted(self.core.config['Addons'], key=lambda k: k['Name'].lower()) self.core.bulk_check(addons) with tqdm(total=len(addons), bar_format='{n_fmt}/{total_fmt} |{bar}|') as pbar: exceptions = [] for addon in addons: try: name, versionnew, versionold, modified = self.core.\ update_addon(addon if isinstance(addon, str) else addon['URL'], update, force) if versionold: if versionold == versionnew: if modified: self.tableData.append([ f'{AC.LIGHTRED_EX}Modified{AC.RESET}', name, versionold ]) else: self.tableData.append([ f'{AC.GREEN}Up-to-date{AC.RESET}', name, versionold ]) else: if modified: self.tableData.append([ f'{AC.LIGHTRED_EX}Update suppressed{AC.RESET}', name, versionold ]) else: self.tableData.append([ f'{AC.YELLOW}{"Updated " if update else "Update available"}' f'{AC.RESET}', name, f'{AC.YELLOW}{versionnew}{AC.RESET}' ]) else: self.tableData.append([ f'{AC.LIGHTBLACK_EX}Not installed{AC.RESET}', addon, '' ]) except Exception as e: exceptions.append(e) pbar.update(1) self.sanitize_table() printft(ANSI('\n' + self.table.table if addline else self.table.table)) if len(exceptions) > 0: self.handle_exception(exceptions, False)
def __init__(self, unit, lab, format, label, val): if 'int' in format: col = '\x1b[94m' elif 'float' in format: col = '\x1b[33m' elif 'tuple' in format: col = '\x1b[98m' elif 'str' in format: col = '\x1b[35m' elif 'bool' in format: col = '\x1b[92m' elif 'path' in format: col = '\x1b[91m' elif 'dict' in format: col = '\x1b[93m' if label == 'Type': tmpval = val continued = True if isinstance(tmpval, list): if val: if isinstance(tmpval, list): while continued: if isinstance(tmpval, list): tmpval = tmpval[0] else: val = 'array of ' + type(tmpval).__name__ continued = False else: val = 'list of ' + type(tmpval).__name__ else: val = type(tmpval).__name__ elif label == 'Length': if isinstance(val, list): if val: tmptxt = '(' tmpval = val continued = True if isinstance(tmpval, list): while continued: if isinstance(tmpval, list): tmptxt += str(len(tmpval)) tmpval = tmpval[0] tmptxt += ', ' else: continued = False tmptxt = tmptxt[0:-2]+')' else: tmptxt = '1' val = tmptxt else: val = '1' print_formatted_text(ANSI(col+unit+'('+lab+')' + ' : ' + label+' = ' + str(val)))
def __init__(self, notebook, cell_json: Optional[Dict[str, Any]] = None): self.notebook = notebook self.json = cell_json or empty_cell_json() self.input_prefix = Window(width=10) self.output_prefix = Window(width=10, height=0) input_text = "".join(self.json["source"]) if self.json["cell_type"] == "code": execution_count = self.json["execution_count"] or " " text = rich_print( f"\nIn [{execution_count}]:", self.notebook.console, style="green", end="", ) self.input_prefix.content = FormattedTextControl(text=ANSI(text)) outputs = self.json["outputs"] for output in outputs: if "execution_count" in output: text = rich_print( f"Out[{output['execution_count']}]:", self.notebook.console, style="red", end="", ) self.output_prefix.content = FormattedTextControl( text=ANSI(text)) break else: outputs = [] output_text, output_height = get_output_text_and_height( outputs, self.notebook.console) self.input_window = Window() self.input_buffer = Buffer(on_text_changed=self.input_text_changed) self.input_buffer.text = input_text self.set_input_readonly() if self.json["cell_type"] == "markdown": self.input = HSplit( [ONE_ROW, VSplit([ONE_COL, self.input_window]), ONE_ROW]) else: self.input = Frame(self.input_window) self.output = Window(content=FormattedTextControl(text=output_text)) self.output.height = output_height
def set_input_readonly(self): if self.json["cell_type"] == "markdown": text = self.input_buffer.text or "Type *Markdown*" md = Markdown(text) text = rich_print(md, self.notebook.console) elif self.json["cell_type"] == "code": code = Syntax(self.input_buffer.text, self.notebook.language) text = rich_print(code, self.notebook.console) self.input_window.content = FormattedTextControl(text=ANSI(text)) self.input_window.height = text.count("\n") or 1
def on_enter_check_results(self): _placement_ok = confirm( ANSI( click.style(self._TEXT_ASKPLACEMENTOK, fg=self.CLICK_PROMPT_FG_COLOR))) if _placement_ok: self.export() else: self.ask_alter()