def test_broken_str(): class BrokenStr(Exception): def __str__(self): 1 / 0 console = Console(width=100, file=io.StringIO()) try: raise BrokenStr() except Exception: console.print_exception() result = console.file.getvalue() print(result) assert "<exception str() failed>" in result
class Echo: """Convenience class for pretty console printing.""" def __init__(self): """Initialize Echo().""" self.console = Console() def __call__( # noqa: C901 your mom is too complex self, message, *args, error=False, **kwargs, ): # noqa: C901 """Format message based on type.""" try: to_print = message if isinstance(message, bytes): message = message.decode() if isinstance(message, str): color = "cyan" if error: color = "red" if args: fmt_args = (f"[bold {color}]{a}[/bold {color}]" for a in args) to_print = message.format(*fmt_args) elif kwargs: fmt_args = { k: f"[bold {color}]{v}[/bold {color}]" for k, v in kwargs } to_print = message.format(**fmt_args) elif isinstance(message, (list, tuple, Generator, dict)): try: to_print = Syntax(json.dumps(message, indent=2), "json", theme="native") except json.JSONDecodeError: pass elif isinstance(message, Exception): raise message return self.console.print(to_print) except Exception: self.console.print_exception()
def _fancy_msg(self, f, **event_dict): c = Console(file=f, highlight=False, emoji=False, markup=False) lll = event_dict.pop('level').lower() llu = lll.upper() exc = event_dict.pop('exception', None) event_dict.pop('exception_type', None) event_dict.pop('exception_file', None) name = event_dict.pop('name', 'root') pid = event_dict.pop('pid') ts = event_dict.pop('timestamp')[0:-3] + "Z" try: msg = event_dict.pop('event') except KeyError: msg = "None" for key in self._json_only_keys: # pylint: disable=E1133 try: event_dict.pop(key) except KeyError: pass extra = "" if len(event_dict) > 0: extra = kv_renderer(None, None, event_dict) if lll in ['notset', 'debug', 'info', 'warning', 'error', 'critical']: ls = "logging.level.%s" % lll else: ls = "none" output = Table(show_header=False, expand=True, box=None, padding=(0, 1, 0, 0)) output.add_column(style="log.time") output.add_column(width=10, justify="center") output.add_column(justify="center") output.add_column(ratio=1) row = [] row.append(Text(ts)) row.append(Text("[%s]" % llu, style=ls)) row.append(Text(name, style="bold") + Text("#") + Text("%i" % pid, style="yellow")) row.append(Text(msg)) output.add_row(*row) if extra != "": output.add_row( "", "", "", Text("{ ", style="repr.attrib_name") + Text(extra, style="repr.attrib_name") + Text(" }", style="repr.attrib_name")) c.print(output) if exc is not None: c.print_exception() if Config.auto_dump_locals: _dump_locals(f)
def wrap(*args, **kwargs): try: return func(*args, **kwargs) except BaiduPCSError as err: print( f"(v{__version__}) [bold red]ERROR[/bold red]: BaiduPCSError: {err}" ) if DEBUG: console = Console() console.print_exception() except Exception as err: print(f"(v{__version__}) [bold red]System ERROR[/bold red]: {err}") if DEBUG: console = Console() console.print_exception()
def test_recursive(): def foo(n): return bar(n) def bar(n): return foo(n) console = Console(width=100, file=io.StringIO()) try: foo(1) except Exception: console.print_exception(max_frames=6) result = console.file.getvalue() print(result) assert "frames hidden" in result assert result.count("in foo") < 4
def main(*args): enable_rich_traceback() commands = get_installed_commands() parser = argparse.ArgumentParser() parser.add_argument("--debug", default=False, action="store_true") parser.add_argument("--verbose", default=False, action="store_true") subparsers = parser.add_subparsers(dest="command") subparsers.required = True for cmd_name, cmd_class in commands.items(): parser_kwargs = {} cmd_help = cmd_class.get_help() if cmd_help: parser_kwargs["help"] = cmd_help subparser = subparsers.add_parser(cmd_name, **parser_kwargs) cmd_class._add_arguments(subparser) args = parser.parse_args() logging.basicConfig( format="%(message)s", datefmt="[%X]", handlers=[RichHandler()], level=logging.DEBUG if args.verbose else logging.INFO, ) if args.debug: import debugpy debugpy.listen(5678) debugpy.wait_for_client() console = Console() try: commands[args.command](args).handle() except exceptions.BarbariError as e: console.print(f"[red]{e}[/red]") except exceptions.BarbariUserError as e: console.print(f"[yellow]{e}[/yellow]") except Exception: console.print_exception()
def wrap(*args, **kwargs): try: return func(*args, **kwargs) except BaiduPCSError as err: logger.debug("`app`: BaiduPCSError: %s", traceback.format_exc()) print(f"(v{__version__}) [bold red]ERROR[/bold red]: BaiduPCSError: {err}") if DEBUG: console = Console() console.print_exception() except Exception as err: logger.debug("`app`: System Error: %s", traceback.format_exc()) print(f"(v{__version__}) [bold red]System ERROR[/bold red]: {err}") if DEBUG: console = Console() console.print_exception()
def main(args=None): if args is None: args = sys.argv[1:] parser = argparse.ArgumentParser( epilog=get_command_list(), formatter_class=argparse.RawDescriptionHelpFormatter) parser.add_argument("command", type=str, nargs=1, choices=COMMANDS.keys()) parser.add_argument("--loglevel", type=str, default="INFO") parser.add_argument("--traceback-locals", action="store_true") parser.add_argument("--debugger", action="store_true") args, extra = parser.parse_known_args() # Set up a simple console logger logging.basicConfig(level=args.loglevel) console = Console() if args.debugger: import debugpy console.print( "[blue]Awaiting debugger connection on 0.0.0.0:5678...[/blue]") debugpy.listen(("0.0.0.0", 5678)) debugpy.wait_for_client() logging.basicConfig( level=args.loglevel, format="%(message)s", datefmt="[%X]", handlers=[RichHandler()], ) try: if args.command[0] in COMMANDS: COMMANDS[args.command[0]]["function"](args, *extra) except Exception: console.print_exception(show_locals=args.traceback_locals) console.print( "[bold][red] An unexpected error occurred while processing your " "request; please create a bug issue at " "http://github.com/coddingtonbear/python-myfitnesspal/issues " "including the above traceback and a description of what " "you were trying to accomplish.[/red][/bold]")
def main(): from rich.logging import RichHandler logging.basicConfig(level="INFO", format="%(message)s", datefmt="[%X]", handlers=[RichHandler(rich_tracebacks=True)]) console = Console() obj = NanoContext(console) try: cli(obj=obj, show_default=True) except Exception as e: console.log("[bold red]Exception caught[/bold red]") if not obj.print_traceback: console.log(e) else: console.print_exception()
def test_traceback_console_theme_applies(): """ Ensure that themes supplied via Console init work on Tracebacks. Regression test for https://github.com/Textualize/rich/issues/1786 """ r, g, b = 123, 234, 123 console = Console( force_terminal=True, _environ={"COLORTERM": "truecolor"}, theme=Theme({"traceback.title": f"rgb({r},{g},{b})"}), ) console.begin_capture() try: 1 / 0 except Exception: console.print_exception() result = console.end_capture() assert f"\\x1b[38;2;{r};{g};{b}mTraceback \\x1b[0m" in repr(result)
cfg['order'] = start_order elif c == 'stop': cfg['order'] = start_order[::-1] json.dump(cfg, f, indent=4, sort_keys=True) console.log(f"Generating boot json file") with open(join(json_dir, 'boot.json'), 'w') as f: cfg = generate_boot( tp_sink_spec={ "name": app_tp_sink, "host": "localhost", "port": 3333 }, readout_spec={ "name": app_readout, "host": "localhost", "port": 3334 }, ) json.dump(cfg, f, indent=4, sort_keys=True) console.log(f"MDAapp config generated in {json_dir}") if __name__ == '__main__': try: cli(show_default=True, standalone_mode=True) except Exception as e: console.print_exception()
class jobParser(cmd.Cmd): """sudo code fetch data from the db presents it in the cli asks how many job you want to apply to today check if you have applied to thet job already (whether that's not interreted or applied) asks if you want to apply - yes so opens a webpage to the job application, produces a cover letter, and updates the db to - no updates the database and mark it as not interrested waits for your next command packages cmd/rich/pymongo""" intro = 'Welcome to the command line interactive data Structure program.\nType help or ? to list commands.\n' prompt = '(job engine) ' def __init__(self): super(jobParser, self).__init__() self.console = Console() def do_mongoDBInfo(self, arg): """ method where that will return a number of predetermined statistics about the number of job application in the db. """ # types of collections # numbers of job you have yet to apply df = read_mongo(MONGO_DATABASE, MONGO_COLLECTION, {}, no_id=True) print( f'jobs not yet viewed {len(df[df["applied"].isin([False])])} Jobs viewed {len(df[df["applied"].isin([True])])}' ) print( f'Out of the viewed jobs you rejected (so far): {len(df[df["filtered"].isin(["Rejected"])])} and applied to {len(df[df["filtered"].isin(["Applied"])])} ' ) def do_applyToJobs(self, line): """ description: - method where you will pass an int """ # fun stats numberOfApplication, collection = [arg for arg in line.split()] print(numberOfApplication, collection) applied = 0 rejected = 0 if not numberOfApplication or not numberOfApplication.isnumeric(): print(f'you have entered {numberOfApplication} which is invalid') return query = { "$and": [{ "site": 'stackOverflow' }, { 'applied': False }] } #we we should not filter per collection and instead per applied # fetching the info from the df and populating a dataFrame df = read_mongo(MONGO_DATABASE, MONGO_COLLECTION, query) # since mongo limit requires us to use a different synthax for the querry method it is easier to shrink the df df = df[:int(numberOfApplication)] for rowIndex, row in df.iterrows(): print(f'job number: {rowIndex}') # printing the information for colIndex, col in row.iteritems(): # we want to skip the unfiltered description # we could also drop the column from the df if colIndex == 'description': pass else: print(colIndex, col) answer = input("\nDo you want to apply for this job (y/n)?") if answer.lower() in ['y', 'yes']: # opens a webpage where job offer is hosted webbrowser.open_new_tab(row['url']) # need to integrate the cover letter df.at[rowIndex, 'applied'] = True # sometimes it is possible that the spider did not scrape the right item so we must give flexibility to the user doubleCheck = input( "If the job posting did not fit what you set the spider to do do you want to continue with the job posting (y/n)?" ) if doubleCheck.lower() in ['n', 'no']: df.at[rowIndex, 'filtered'] = 'Rejected' print(f'rejecting the job posting') rejected += 1 else: df.at[rowIndex, 'filtered'] = 'Applied' applied += 1 # git clone # https://stackoverflow.com/questions/1911109/how-do-i-clone-a-specific-git-branch coverLetterFilePath = os.path.join( BASE_DIR, 'Cover-Letter-Generator/') call(["python", coverLetterFilePath + 'main.py']) # /lowriter --headless --convert-to pdf *.docx call(["lowriter --headless --convert-to pdf *.docx"], cwd=coverLetterFilePath + 'coverLetters/', shell=True) call(["rm *.docx"], cwd=coverLetterFilePath + 'coverLetters/', shell=True) # lowriter --headless --convert-to pdf *.docx && rm *.docx else: print(f'rejecting the job posting') rejected += 1 df.at[rowIndex, 'filtered'] = 'Rejected' df.at[rowIndex, 'applied'] = True # db changes print( f'Done with the search. You have applied to {applied} jobs online and ignored {rejected} jobs' ) print('updating mongo database') print(df) update_mongo(MONGO_DATABASE, MONGO_COLLECTION, df) def default(self, line): """ Allows us to use the app as a normal commandline """ try: return exec(line, globals()) except: self.console.print_exception() def do_exit(self, arg): """ exits the command line """ exit()
""" Demonstrates Rich tracebacks for recursion errors. Rich can exclude frames in the middle to avoid huge tracebacks. """ from rich.console import Console def foo(n): return bar(n) def bar(n): return foo(n) console = Console() try: foo(1) except Exception: console.print_exception(max_frames=20)
class interactiveDataStructures(cmd.Cmd): """ documentation: https://docs.python.org/3/library/cmd.html """ intro = 'Welcome to the command line interactive data Structure program.\nType help or ? to list commands.\n' prompt = None def __init__(self, dataStructure): super(interactiveDataStructures, self).__init__() # rich module elements pretty.install() traceback.install() self.console = Console() # Datastructure elements availableDataStrutuces = { 'DynamicArray': DynamicArray(), 'SingleLinkedList': SinglyLinkedList(), 'DoublyLinkedList': DoublyLinkedList(), 'Stack': Stack(), 'Queue': Queue(), 'PriorityQueue': PriorityQueue() } correspondingNodes = { 'DynamicArray': None, 'SingleLinkedList': ListNode(None), 'DoublyLinkedList': ListNode(None), 'Stack': StackNode(None), 'Queue': QueueNode(None), 'PriorityQueue': PQNode(None) } if dataStructure in availableDataStrutuces: self.dataStructure = availableDataStrutuces[dataStructure] self.DSNode = correspondingNodes[dataStructure] self.DSname = dataStructure interactiveDataStructures.prompt = text.Text(f'({dataStructure}) ', style="bold magenta") # doesn't quite work else: raise ValueError(f'Please choose one of the following available data structure: {availableDataStrutuces.keys()}') def do_DSInfo(self,info=False): """ print all non special method of the data structure that was selected """ print(f'Info regarding the Class:{type(self.dataStructure).__name__}.__init__\n{self.dataStructure.__init__.__doc__}\n') print(f'Info regarding the Node used for the Class: {type(self.DSNode).__name__}.__init__\n{self.DSNode.__init__.__doc__}\n') print(f'The following methods for {type(self.dataStructure).__name__} are available:\n{vdir(self.dataStructure)}\n') if info: print(f'Detailled overview of each methods of {type(self.dataStructure).__name__}:\n{vdir(self.dataStructure,info=True)}') # print(f'If you want more info about what a specific {type(self.DSNode).__name__} method use') def do_manual(self,arg): """ If you want to learn more about data structures """ #taken from Django # BASE_DIR = Path(__file__).resolve().parent.parent # woah pathlib is amazing BASE_DIR = Path('../dataStructure.md') with open(BASE_DIR) as readme: markdown = Markdown(readme.read()) self.console.print(markdown) def default(self, line): #! this is what I was looking for the exec() cmd """Called on an input line when the command prefix is not recognized. In that case we execute the line as Python code. """ try: # https://stackoverflow.com/questions/7969949/whats-the-difference-between-globals-locals-and-vars # glo return exec(line, globals()) # exec(print(str(line))) except:# Exception as e: self.console.print_exception() # print(f'{e.__class__}:{e}') def do_exit(self,arg): """ exits the command line """ exit()
def extract(lines: List[str], nlp, use_dict=False, category=None): # extracting... 👇 try: if category == "noun": terms: Iterator[str] = extract_by_lines(lines, nlp, extract_noun_by_line) result = count_terms(terms, use_dict) yield from result if category == "verb": terms: Iterator[str] = extract_by_lines(lines, nlp, extract_verb_by_line) result = count_terms(terms, use_dict) yield from result elif category == "np": terms: Iterator[str] = extract_by_lines(lines, nlp, extract_np_by_line) result = count_terms(terms, use_dict) yield from result elif category == "vp": terms: Iterator[str] = extract_by_lines(lines, nlp, extract_vb_by_line) result = count_terms(terms, use_dict) yield from result elif category == "pp": terms: Iterator[str] = extract_by_lines(lines, nlp, extract_pp_by_line) result = count_terms(terms, use_dict) yield from result elif category == "abbr": if nlp.pipe_names[-1] == "AbbreviationDetector": pass else: from .vendor.abbr import AbbreviationDetector abbreviation_pipe = AbbreviationDetector(nlp) nlp.add_pipe(abbreviation_pipe) terms: Iterator[str] = extract_by_lines(lines, nlp, extract_abbr_by_line) return count_terms(terms, use_dict) elif category == "compound-complex": result = extract_sentences_by_lines(lines, nlp, extract_cc_by_line) yield from sorted(result, key=lambda entry: entry[1], reverse=True) elif category == "inversion": result = extract_sentences_by_lines(lines, nlp, extract_inversion_by_line) yield from result elif category == "imperative": result = extract_sentences_by_lines(lines, nlp, extract_imperative_by_line) yield from result elif category == "passive": result = extract_sentences_by_lines(lines, nlp, extract_passive_by_line) yield from result elif category == "condition": result = extract_sentences_by_lines(lines, nlp, extract_condition_by_line) yield from result elif category == "infinitive": result = extract_sentences_by_lines(lines, nlp, extract_infinitive_by_line) yield from result except: from rich.console import Console console = Console() console.print_exception()
"-f", "--filter", type=str, help="Execute the check only for directories containing this string.", default="") args = parser.parse_args() result = False try: checker = ComponentGenerationChecker() result = checker.check_components_generation( args.test_folder, args.dry_run, args.dirty, args.generate_only, args.no_execution, args.filter, args.avoid, args.clean) except (KeyboardInterrupt, SystemExit): console.log("\nExiting in the middle of the execution.", style="red") console.log("Some files will be left on the directories.", style="yellow") console.log("Use -c option to clean all the generated files.", style="yellow") sys.exit(-1) except Exception as e: console.log("Unexpected exception: %s" % e, style="red") console.print_exception(show_locals=True) sys.exit(-1) finally: if result: sys.exit(0) else: sys.exit(-1)
f"git remote add origin https://github.com/{login}/{PROJECTNAME}.git") commands.append("git push -u origin master") # Global actions try: # Move files to destination for fileobj in os.scandir(path.join(LOCAL, "toClone")): shutil.copy2( path.join(fileobj.path), path.join(NEWFOLDER, fileobj.name.replace("template", "")), ) # Change to destination folder os.chdir(NEWFOLDER) if args.python: open(path.join(NEWFOLDER, "main.py"), "a").close() # Create project for c in commands: os.system(c) print(f"{PROJECTNAME} created") except: c.print_exception() finally: c.print("Done!") os.system("code .") # Open edtor c.print(f"cd {NEWFOLDER}")
class Shell: """Shell is wrapper for Plumbum Commands Machine To use: >>> sh = Shell() >>> sh.check_command("python") True >>> sh.cmd["python"]["-c"]("print(123)") '123\n' """ @property def name(self) -> str: """ Name """ return self.__class__.__name__.lower() def __init__(self, executor: Machine = LocalMachine()): self.logger = logger.getChild(self.__class__.__name__) self.exec = executor self.console = Console() def is_sudo(self) -> bool: """ Check is this shell session is sudo """ self.logger.warning("is_sudo() not support by Shell!") return False def is_installed(self) -> bool: return True def which(self, command_name: str) -> Machine: return self.exec.which(command_name) def check_command(self, command_name): try: self.which(command_name) return True except CommandNotFound: return False @property def cmd(self) -> Machine: return self.exec def get_sudo(self) -> bool: """ Elevate the privileges of the current shell session To use: >>> sh = Shell() >>> sh.is sudo() False >>> sh.get_sudo() True Returns: bool: is sudo """ sudo = self.exec["sudo"] try: sudo["ls"]() return True except ProcessExecutionError as e: if ("no password" in e.stderr) or ("-S" in e.stderr): __pass = getpass("Sudo password: "******"--stdin"]["ls"].popen(stdin=PIPE) out = p.communicate(f"{__pass}\n".encode(), timeout=2) return True else: self.console.print_exception() return self.is_sudo() @property def sudo_cmd(self) -> BoundCommand: sudo = self.exec["sudo"] return sudo[self.cmd]