[Feature] Color support for Exceptions

[UjjwalAyyangar]

Right now, the click module gives us the option of using colors only through click.echo and click.secho commands. I was thinking that if we can tweak the classes inside the exceptions.py file and use secho inside them in place of echo, then we can give the users an option of colorizing error/exception messages.

[nickwu241]

For example:

import click

try:
    raise Exception("some message")
except Exception as e:
    click.echo(e)  # works
    click.secho(str(e), fg='red) # works
    click.secho(e, fg='red')  # raises a TypeError, would be nice to be able do this

This is because

import click
click.style(Exception("some message"), fg='red')

expects the first parameter to be a string, currently this raises TypeError: sequence item 1: expected string, exceptions.Exception found.

[davidism]

This seems to be about being able to have ClickException.show() apply style information to the message, not with being able to pass exceptions to secho().

One way to handle this would be to call style() on the message first, and have a ClickException.style_args attribute that could be set to a dict of style arguments.

[reillysiemens]

@davidism: I'd love to take a stab at resolving this as I've wanted colored exceptions for a while, but in my first attempt I noticed that there's a circular import between click.termui where style() comes from and the click.exceptions module.

The circular import can be trivially resolved by importing style() within the ClickException.show() method, but something about that just feels wrong to me... 😅

diff --git a/src/click/exceptions.py b/src/click/exceptions.py
index 9623cd8..0042bf4 100644
--- a/src/click/exceptions.py
+++ b/src/click/exceptions.py
@@ -14,6 +14,7 @@ class ClickException(Exception):
 
     #: The exit code for this exception.
     exit_code = 1
+    style_args = {}
 
     def __init__(self, message):
         super().__init__(message)
@@ -28,7 +29,8 @@ class ClickException(Exception):
     def show(self, file=None):
         if file is None:
             file = get_text_stderr()
-        echo(f"Error: {self.format_message()}", file=file)
+        from .termui import style
+        echo(style(f"Error: {self.format_message()}", **self.style_args), file=file)
 
 
 class UsageError(ClickException):

As an alternative I considered that just providing override instructions for the ClickException.show() method in the docs seems simple enough. The one caveat I see there is that the

if file is None:
    file = get_text_stderr()

in all of the show() implementations would require/encourage implementers to use click._compat.get_text_stderr(), which I think is private...

Do you have any thoughts on the issue of circular imports or users overriding show() with the support of a private function? 🤔

[brandonchinn178]

It would also be nice to be able to globally style all errors. What about an API like this:

1. ClickException takes an optional style: Callable[[str], str] parameter
2. ClickException also has a style_default class variable that initializes as lambda x: x
3. When style is not set, it defaults to style_default; this is then applied to the message in ClickException
4. Add exc_style parameter to Context that proxies ClickException.style_default (get and set)

raise ClickException("bad", style=lambda s: style(s, fg="red"))

SETTINGS = dict(exc_style=lambda s: style(s, fg="red"))
@click.group(context_settings=SETTINGS)
def cli():
    pass

Bonus points: Implement a Style class with a format(s: str) -> str method, where click.style(s, **kwargs) is equivalent to Style(**kwargs).format(s). Then the Callable parameters here could just be Style objects:

SETTINGS = dict(exc_style=Style(fg="red"))