def main(
sequences: Path,
fasta_output: Path = typer.Option(Path('input_sequences.correctedID.fasta'),
help='FASTA Sequences with correct ID for Pangolin Analysis.'),
):
from rich.traceback import install
install(show_locals=True, width=200, word_wrap=True)
logging.basicConfig(
format="%(message)s",
datefmt="[%Y-%m-%d %X]",
level=logging.INFO,
handlers=[RichHandler(rich_tracebacks=True, tracebacks_show_locals=True, locals_max_string=200)],
)
with open(fasta_output, 'w') as fout:
if '.gz' in Path(sequences).suffixes:
logging.info(f'Input Sequences {sequences} in gz format provided')
with gzip.open(sequences, 'rt') as fin:
for name, seq in SimpleFastaParser(fin):
header = re.sub(r'[\|\s].*$', "", name)
fout.write(f'>{header}\n{seq}\n')
else:
logging.info(f'Input Sequences {sequences} in unzip format provided')
with open(sequences, 'rt') as fin:
for name, seq in SimpleFastaParser(fin):
header = re.sub(r'[\|\s].*$', "", name)
fout.write(f'>{header}\n{seq}\n')
def main(self):
pretty.install()
install()
shell = AutoShell()
self.init(shell)
out_list = []
if self.all_flag:
for PM in self.PMs:
pm = PM()
out_list.extend(pm.get_all_packages())
else:
for package_name in self.known_packages.keys():
try:
package = UniversalePackage(
package_name,
shell=shell,
pms_classes=self.PMs, # не работает как надо!
known_packages=self.known_packages,
)
except PackageManagerNotInatalled:
continue
if package.is_installed():
ver = package.info.get("version", None)
if not ver:
out_list.append(f"{package_name}")
else:
out_list.append(f"{package_name}@{ver}")
for line in out_list:
print(line)
if self.output != None:
data = {"packages": out_list}
with open(self.output, 'w+') as f:
yaml.dump(data, f, default_flow_style=False)
def main(
newick_tree_input: Path,
lineage_report: Path,
aa_mutation_matrix: Path = typer.Option(None),
leaflist: Path = typer.Option(Path('leaflist')),
metadata_output: Path = typer.Option(Path('metadata.merged.tsv')),
):
from rich.traceback import install
install(show_locals=True, width=120, word_wrap=True)
logging.basicConfig(
format="%(message)s",
datefmt="[%Y-%m-%d %X]",
level=logging.INFO,
handlers=[RichHandler(rich_tracebacks=True, tracebacks_show_locals=True)],
)
df_lineage_report = pd.read_csv(lineage_report, index_col=0)
if aa_mutation_matrix:
df_aa_change = pd.read_table(aa_mutation_matrix, index_col=0)
df_out = pd.concat([df_lineage_report, df_aa_change], axis=1)
else:
df_out = df_lineage_report
df_out.to_csv(metadata_output, sep='\t', index=True)
tree = Phylo.read(newick_tree_input, 'newick')
with open(leaflist, 'w') as fout:
for node in tree.get_terminals():
fout.write(f'{node.name}\n')
def main(argv: List[str] = None) -> int:
"""Entry point for the CLI of the Pynguin automatic unit test generation framework.
This method behaves like a standard UNIX command-line application, i.e.,
the return value `0` signals a successful execution. Any other return value
signals some errors. This is, e.g., the case if the framework was not able
to generate one successfully running test case for the class under test.
Args:
argv: List of command-line arguments
Returns:
An integer representing the success of the program run. 0 means
success, all non-zero exit codes indicate errors.
"""
install()
if argv is None:
argv = sys.argv
if len(argv) <= 1:
argv.append("--help")
argv = _expand_arguments_if_necessary(argv[1:])
argument_parser = _create_argument_parser()
parsed = argument_parser.parse_args(argv)
_setup_output_path(parsed.config.output_path)
_setup_logging(parsed.verbosity, parsed.log_file)
set_configuration(parsed.config)
with console.status("Running Pynguin..."):
return run_pynguin().value
def __init__(self):
cfg_file = Path(
os.path.expanduser(
os.environ.get('TIMEFRED_CONFIG_PATH', "~/.timefred.toml")))
if cfg_file.exists():
cfg = toml.load(cfg_file.open())
else:
self._create_default_config_file(cfg_file)
cfg = {}
super().__init__(**cfg)
if self.dev.debugger:
os.environ['PYTHONBREAKPOINT'] = self.dev.debugger
if self.dev.traceback:
try:
if self.dev.traceback == "rich.traceback":
from rich.traceback import install
install(show_locals=True)
else:
log.warning(f"Don't support {self.dev.traceback}")
except Exception as e:
log.error(
f'{e.__class__.__qualname__} caught in {self}.__init__: {e}'
)
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 main(
newick_tree_input: Path,
metadata_input: Path,
lineage_report: Path = typer.Option(
..., help="Pangolin lineage report CSV"),
ref_name: str = typer.Option("MN908947.3",
help="Reference/outgroup name"),
leaflist: Path = typer.Option(
Path('leaflist'),
help='List of leaves/taxa to filter for in shiptv tree'),
metadata_output: Path = typer.Option(
'metadata.leaflist.tsv', help='Metadata for leaflist taxa'),
max_taxa: int = typer.Option(100, help="Max taxa in leaflist"),
):
"""Prune phylo tree to taxa neighboring user taxa"""
from rich.traceback import install
install(show_locals=True, width=120, word_wrap=True)
logging.basicConfig(
format="%(message)s",
datefmt="[%Y-%m-%d %X]",
level=logging.INFO,
handlers=[
RichHandler(rich_tracebacks=True, tracebacks_show_locals=True)
],
)
df = pd.read_table(metadata_input, index_col=0)
logging.info(
f'Read metadata table "{metadata_input}" with {df.shape[0]} rows.')
tree: Tree = Phylo.read(newick_tree_input, "newick")
n_taxa = tree.count_terminals()
logging.info(f'Read tree "{newick_tree_input}" with {n_taxa}.')
if n_taxa <= max_taxa:
logging.info(
f'No pruning of tree required. Number of taxa ({n_taxa}) '
f'less than/equal to max taxa desired in tree ({max_taxa}). '
f'Writing leaflist "{leaflist}" with all {n_taxa} taxa.')
write_leaflist((n.name for n in tree.get_terminals()), leaflist)
logging.info(f'Symlinking "{metadata_output}" to "{metadata_input}".')
metadata_output.symlink_to(metadata_input.resolve())
sys.exit(0)
df_lineage_report = pd.read_csv(lineage_report, index_col=0)
logging.info(
f'Read Pangolin lineage report with {df_lineage_report.index.size} rows.'
)
user_taxa = set(df_lineage_report.index)
logging.info(f'User taxa in tree determined to be {user_taxa}')
logging.info(
f'Getting neighboring nodes for user taxa up to {max_taxa} taxa in total.'
)
clade_neighbors = get_neighbors(tree, user_taxa, max_taxa - 1)
logging.info(
f'Found {len(clade_neighbors - user_taxa)} neighboring taxa to {len(user_taxa)} '
f'user taxa. Writing leaf list.')
clade_neighbors.add(ref_name)
write_leaflist(clade_neighbors, leaflist)
df.loc[list(clade_neighbors & set(df.index)), :].to_csv(metadata_output,
sep="\t")
def _rich_logger(log_type: int = logging.INFO) -> logging.Logger:
r_traceback.install()
logging.basicConfig(level=log_type,
format='%(message)s',
datefmt="[%c]",
handlers=[r_logging.RichHandler()])
return logging.getLogger("rich")
def torch_traceback():
from rich.traceback import install
install(show_locals=True)
def repr(self):
return f"Tensor<{', '.join(map(str, self.shape))}>"
torch.Tensor.__repr__ = repr
def __init__(self, config: ExperimentConfig):
self.tb_global_step = 0
self.custom_stats_format = None
self.config = config
self.device = config.device
try:
from rich.traceback import install
install()
except ImportError:
print('Note: Rich text traceback avaliable by pip install rich')
def __init__(self, cache_folder='cache', database_folder='database'):
self.console = Console()
install()
self.cache = Cache(cache_folder)
self.api = Api(self.cache)
self.database = Database()
self.database_folder = database_folder
self.champion_names = None
self.selected_champion = ''
self.is_running = True
def __init__(self):
self.core = Core()
self.session = PromptSession(reserve_space_for_menu=6, complete_in_thread=True)
self.headless = False
self.console = None
self.table = None
self.slugs = None
self.tipsDatabase = None
self.completer = None
self.os = platform.system()
install()
def __init__(self):
self.core = Core()
self.session = PromptSession(reserve_space_for_menu=6)
self.headless = False
self.console = None
self.table = None
self.cfSlugs = None
self.wowiSlugs = None
self.completer = None
self.os = platform.system()
install()
def main(self, package_name: str):
pretty.install()
install()
shell = AutoShell()
self.init(shell)
package = UniversalePackage(
package_name,
shell=shell,
pms_classes=self.PMs,
auto_update_conf=not self.no_auto_update_conf)
package.install()
def main(filename, premodel=None):
global current_line, model
if premodel == None:
model = usemodel.load()
else:
model = premodel
# print the intro
rich.print("[yellow]Hello From The Alter Community[/yellow]")
install(extra_lines=8, show_locals=True)
if str(filename).endswith(".altr") is False:
raise Exception("File must end with .altr")
# load file and scan for errors, print out a custom message if were errs
lines = []
with open(filename, "r") as file:
raw = file.read().split("\n")
for i in raw:
lines.append(i)
out = []
if filename.startswith("fizzbuzz"):
filename = "Fdf"
else:
filename = None
for i in lines:
current_line += 1
line_out = top_level(i, fname=filename)
if line_out is not None and "ignore" not in str(line_out):
out.append(line_out)
print("\n")
time.sleep(1.5)
console = Console()
table = Table(show_header=True, header_style="bold blue", show_lines=True)
table.add_column("Name")
table.add_column("Type", justify="right")
table.add_column("Value")
for i in variables.keys():
table.add_row(i, str(type(variables[i])), str(variables[i]))
console.print(table)
table = Table(show_header=True, header_style="bold blue", show_lines=True)
table.add_column("Order")
for i in order:
table.add_row(str(i))
console.print(table)
table = Table(show_header=True, header_style="bold blue", show_lines=True)
table.add_column("Line #")
table.add_column("Line Content")
for x, i in enumerate(lines):
table.add_row(str(x + 1), i)
console.print(table)
rich.print("[bold green]No Errors![/bold green]")
rich.print("[bold blue]Program exited with code 0[/bold blue]")
return out
def main(metadata_input: Path,
pangolin_report: Path,
metadata_output: Path = typer.Option(Path('metadata.merged.tsv')),
aa_mutation_matrix: Optional[Path] = typer.Option(
None, help='Amino acid mutation matrix TSV'),
select_metadata_fields: Optional[str] = typer.Option(
None,
help='Comma-delimited list of metadata fields to output. '
'If unset, all metadata fields will be output.')):
"""Merge a metadata table, Pangolin results table and AA mutation matrix into one table."""
from rich.traceback import install
install(show_locals=True, width=120, word_wrap=True)
logging.basicConfig(
format="%(message)s",
datefmt="[%Y-%m-%d %X]",
level=logging.INFO,
handlers=[
RichHandler(rich_tracebacks=True, tracebacks_show_locals=True)
],
)
df_metadata = pd.read_table(metadata_input, index_col=0)
logging.info(
f'Read metadata table "{metadata_input}" with '
f'{df_metadata.shape[0]} rows and {df_metadata.shape[1]} columns')
if select_metadata_fields:
logging.info(f'Selecting specified metadata fields/columns from '
f'"{metadata_input}": {select_metadata_fields}')
df_metadata = select_fields(df_metadata, select_metadata_fields)
dfs = [df_metadata]
df_pangolin = read_pangolin_report(pangolin_report)
dfs.append(df_pangolin)
if aa_mutation_matrix:
dfs.append(pd.read_table(aa_mutation_matrix, index_col=0))
logging.info(f'Merging {len(dfs)} dataframes on index')
df_merged = pd.concat(dfs, axis=1)
if 'Pango_lineage' in df_merged.columns:
df_merged['Pango_lineage'] = df_merged['Pango_lineage'].combine_first(
df_pangolin['lineage'])
if 'Pangolin_version' in df_merged.columns:
df_merged['Pangolin_version'] = df_merged[
'Pangolin_version'].combine_first(
df_pangolin['pangoLEARN_version'])
logging.info(
f'Writing merged dataframe with shape {df_merged.shape} to "{metadata_output}".'
)
df_merged.to_csv(metadata_output, sep='\t', index=True)
logging.info(
f'Wrote merged dataframe with shape {df_merged.shape} to "{metadata_output}".'
)
def main():
# set rich as default backtrace logger
install()
console = Console()
# set up parser for command line arguments
parser = argparse.ArgumentParser()
parser.add_argument(
"mode",
metavar="mode",
type=str,
help=
"The type of operation to be performed on the database: create, delete, or access"
)
parser.add_argument(
"source",
metavar="source",
type=str,
help="The path to the database file to be accessed or created")
parser.add_argument(
"--query",
type=str,
help=
"If accessing the database, this must be provided as the query to be run"
)
parser.add_argument(
"--infinite",
action="store_true",
help=
"Set this flag to open a session to the database to run multiple queries"
)
parser.add_argument(
"--embedded",
action="store_true",
help="Set this flag to only output JSON for use in other applications")
args = vars(parser.parse_args())
# main logic occurs -- split based on mode
mode = args["mode"].lower()
source = args["source"]
if mode == "create":
create(source)
elif mode == "delete":
delete(source, console)
elif mode == "access":
access(source, args["query"], args["infinite"], args["embedded"],
console)
def main():
traceback.install(width=200, word_wrap=True)
console.print(rf"""[bold blue]
██████ ██████ ██████ ██ ██ ██ ███████ ████████ ███████ ███ ███ ██████ ██ ███████
██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ████ ████ ██ ██ ██ ██
██ ██ ██ ██ ██ █████ ██ █████ ██ █████ ██ ████ ██ ██████ ██ █████
██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██
██████ ██████ ██████ ██ ██ ██ ███████ ██ ███████ ██ ██ ██ ███████ ███████
""")
console.print('[bold blue]Run [green]cookietemple --help [blue]for an overview of all commands\n')
# Is the latest cookietemple version installed? Upgrade if not!
if not UpgradeCommand.check_cookietemple_latest():
console.print('[bold blue]Run [green]cookietemple upgrade [blue]to get the latest version.')
cookietemple_cli()
def __init__(self):
from rich.traceback import install
install()
import colorama
colorama.init()
self.name: str = 'command'
self.entry_point: str = 'command'
self.args: List[Argument] = []
self.mutually_exclusive_args: List[MutuallyExclusiveArgumentGroup] = []
self.argument_groups: List[ArgumentGroup] = []
self.subcommands: List[Type[Subcommand]] = []
self._update_meta()
self.parser: argparse.ArgumentParser = self._create_parser()
argcomplete.autocomplete(self.parser)
self.parsed_args: Any = self.parser.parse_args()
self.process_args()
def update_verbosity(debug):
"""Set the logging verbosity according to the settings object.
Also enable rich tracebacks in debug mode.
"""
if debug:
logger.setLevel(SPAM)
try:
from rich.traceback import install
install(show_locals=True)
logger.debug('Using rich.traceback')
except Exception as error:
# since this is optional, just skip all exceptions
if not isinstance(error, ImportError):
logger.debug('Cannot use rich.traceback: %s', error)
else:
logger.setLevel(logging.INFO)
def start(self, argv):
if argv[1:]:
for argv in argv[1:]:
try:
getattr(self, argv)()
except AttributeError:
print('help msg')
else:
from base.shell import MainShell
from rich.traceback import install
install()
Shell = MainShell()
while True:
try:
Shell.cmdloop()
except KeyboardInterrupt:
print('')
def main(self, package_name: str):
pretty.install()
install()
shell = AutoShell()
self.init(shell)
data = {}
for pm in self.PMs:
try:
out = pm(shell=shell).search(package_name)
if out != {}:
data[pm.name] = out
except NotImplementedError as e:
logger.warning(
f"{pm.name} not have search method!") # , exc_info=True)
if self.list_mode:
print_search_results(data)
else:
print_info(data)
def update_verbosity(debug):
"""Set the logging verbosity according to the settings object.
Also enable rich tracebacks in debug mode.
"""
# pylint really doesn't like what I'm doing with rich.traceback here
# pylint: disable=broad-except,import-error,import-outside-toplevel
if debug:
logger.setLevel(SPAM)
try:
from rich.traceback import install
install(show_locals=True)
logger.debug('Using rich.traceback')
except Exception as error:
# since this is optional, just skip all exceptions
if not isinstance(error, ImportError):
logger.debug('Cannot use rich.traceback: %s', error)
else:
logger.setLevel(logging.INFO)
def main(nextclade_csv: Path, metadata_output: Path):
from rich.traceback import install
install(show_locals=True, width=120, word_wrap=True)
logging.basicConfig(
format="%(message)s",
datefmt="[%Y-%m-%d %X]",
level=logging.INFO,
handlers=[
RichHandler(rich_tracebacks=True, tracebacks_show_locals=True)
],
)
df_nextclade = pd.read_table(nextclade_csv, sep=';')
# remove surrounding brackets, split on ',' to get Series of list of str AA mutations
aasubs: pd.Series = df_nextclade['aaSubstitutions'].str.replace(
r'^(\(|\))$', '', regex=True).str.split(',')
sample_aas = sample_to_aa_mutations(aasubs, df_nextclade['seqName'])
samples = list(sample_aas.keys())
unique_aas = get_sorted_aa_mutations(sample_aas)
arr_aas = fill_aa_mutation_matrix(sample_aas, samples, unique_aas)
dfaa = pd.DataFrame(arr_aas, index=samples, columns=unique_aas)
dfaa.to_csv(metadata_output, sep='\t')
def main():
traceback.install(width=200, word_wrap=True)
print(r"""[bold blue]
██████ ██ ██ ██████ ███████
██ ██ ██ ██ ██ ██ ██
██ ██ ██ ██ ██████ █████
██ ▄▄ ██ ██ ██ ██ ██ ██
██████ ██████ ██████ ███████
▀▀
""")
print(
'[bold blue]Run [green]qube --help [blue]for an overview of all commands\n'
)
# Is the latest qube version installed? Upgrade if not!
if not UpgradeCommand.check_qube_latest():
print(
'[bold blue]Run [green]qube upgrade [blue]to get the latest version.'
)
qube_cli()
def test_handler():
console = Console(file=io.StringIO(), width=100, color_system=None)
expected_old_handler = sys.excepthook
def level1():
level2()
def level2():
return 1 / 0
try:
old_handler = install(console=console)
try:
level1()
except Exception:
exc_type, exc_value, traceback = sys.exc_info()
sys.excepthook(exc_type, exc_value, traceback)
rendered_exception = console.file.getvalue()
print(repr(rendered_exception))
assert "Traceback" in rendered_exception
assert "ZeroDivisionError" in rendered_exception
frame_blank_line_possible_preambles = (
# Start of the stack rendering:
"╭─────────────────────────────── Traceback (most recent call last) ────────────────────────────────╮",
# Each subsequent frame (starting with the file name) should then be preceded with a blank line:
"│" + (" " * 98) + "│",
)
for frame_start in re.finditer(
"^│ .+rich/tests/test_traceback\.py:",
rendered_exception,
flags=re.MULTILINE,
):
frame_start_index = frame_start.start()
for preamble in frame_blank_line_possible_preambles:
preamble_start, preamble_end = (
frame_start_index - len(preamble) - 1,
frame_start_index - 1,
)
if rendered_exception[
preamble_start:preamble_end] == preamble:
break
else:
pytest.fail(
f"Frame {frame_start[0]} doesn't have the expected preamble"
)
finally:
sys.excepthook = old_handler
assert old_handler == expected_old_handler
def main() -> None:
traceback.install(width=200, word_wrap=True)
print(r"""[bold blue]
██████ ▄████▄ ▄▄▄█████▓ ▒█████ ▒█████ ██▓ ▄▄▄▄ ▒█████ ▒██ ██▒
▒██ ▒ ▒██▀ ▀█ ▓ ██▒ ▓▒▒██▒ ██▒▒██▒ ██▒▓██▒ ▓█████▄ ▒██▒ ██▒▒▒ █ █ ▒░
░ ▓██▄ ▒▓█ ▄ ▒ ▓██░ ▒░▒██░ ██▒▒██░ ██▒▒██░ ▒██▒ ▄██▒██░ ██▒░░ █ ░
▒ ██▒▒▓▓▄ ▄██▒░ ▓██▓ ░ ▒██ ██░▒██ ██░▒██░ ▒██░█▀ ▒██ ██░ ░ █ █ ▒
▒██████▒▒▒ ▓███▀ ░ ▒██▒ ░ ░ ████▓▒░░ ████▓▒░░██████▒░▓█ ▀█▓░ ████▓▒░▒██▒ ▒██▒
▒ ▒▓▒ ▒ ░░ ░▒ ▒ ░ ▒ ░░ ░ ▒░▒░▒░ ░ ▒░▒░▒░ ░ ▒░▓ ░░▒▓███▀▒░ ▒░▒░▒░ ▒▒ ░ ░▓ ░
░ ░▒ ░ ░ ░ ▒ ░ ░ ▒ ▒░ ░ ▒ ▒░ ░ ░ ▒ ░▒░▒ ░ ░ ▒ ▒░ ░░ ░▒ ░
░ ░ ░ ░ ░ ░ ░ ░ ▒ ░ ░ ░ ▒ ░ ░ ░ ░ ░ ░ ░ ▒ ░ ░
░ ░ ░ ░ ░ ░ ░ ░ ░ ░ ░ ░ ░ ░
░ ░
""")
print(
"[bold blue]Run [green]sc-toolbox --help [blue]for an overview of all commands\n"
)
# Is the latest sc-toolbox version installed? Upgrade if not!
if not UpgradeCommand.check_sc_toolbox_latest():
print(
"[bold blue]Run [green]sc-toolbox upgrade [blue]to get the latest version."
)
sc_toolbox_cli() # type: ignore
def _rich_logger(log_type: int = logging.INFO) -> logging.Logger:
"""Logs information with the rich library with fancy tracebacks.
Args:
log_type (:obj:`t.Union[str, int]`, optional): The level of logging to be used.
Defaults to None.
store_file (bool, optional): If the logs want to be stored.
Returns:
:obj:`logging.Logger`: The object that the bot will use to log information to.
Raises:
IndexError: If `log_type` isn't within log_types.
"""
r_traceback.install()
logging.basicConfig(level=log_type,
format='%(message)s',
datefmt="[%c]",
handlers=[r_logging.RichHandler()])
# different message types: info, debug, warning, critical
return logging.getLogger("rich")
def main(self, package_name):
pretty.install()
install()
shell = AutoShell()
self.init(shell)
logger.debug(
f"Args:\n\tpackage_name = {package_name},\n\tpm_names = {self.pm_names}\n\tall = {self.all_flag}\n\toffline = {self.offline}"
)
package = UniversalePackage(package_name,
shell=shell,
pms_classes=self.PMs,
known_packages=self.known_packages)
package.update_package_info(all_pm=self.all_flag)
info = package.info
if info == {}:
logger.error("Package Does Not Found")
return
print_info(info)
if package_name not in self.known_packages:
update_user_known_package(package_name, package.config)
def test_handler():
console = Console(file=io.StringIO(), width=100, color_system=None)
expected_old_handler = sys.excepthook
try:
old_handler = install(console=console)
try:
1 / 0
except Exception:
exc_type, exc_value, traceback = sys.exc_info()
sys.excepthook(exc_type, exc_value, traceback)
rendered_exception = console.file.getvalue()
print(repr(rendered_exception))
assert "Traceback" in rendered_exception
assert "ZeroDivisionError" in rendered_exception
finally:
sys.excepthook = old_handler
assert old_handler == expected_old_handler
