Classes and Functions

Inform

The Inform class controls the active informants.

class inform.Inform(mute=False, quiet=False, verbose=False, narrate=False, logfile=False, prog_name=True, argv=None, version=None, termination_callback=None, colorscheme='dark', flush=False, stdout=None, stderr=None, length_thresh=80, culprit_sep=', ', stream_policy='termination', notify_if_no_tty=False, notifier='notify-send', **kwargs)

Manages all informants, which in turn handle user messaging. Generally informants copy messages to the logfile while most also send to the standard output as well, however all is controllable.

Parameters:
  • mute (bool) –

    All output is suppressed (it is still logged).

    With the provided informants all output is suppressed when set (it is still logged). This is generally used when the program being run is being run by another program that is generating its own messages and does not want the user confused by additional messages. In this case, the calling program is responsible for observing and reacting to the exit status of the called program.

  • quiet (bool) –

    Normal output is suppressed (it is still logged).

    With the provided informants normal output is suppressed when set (it is still logged). This is used when the user has indicated that they are uninterested in any conversational messages and just want to see the essentials (generally error messages).

  • verbose (bool) –

    Comments are output to user, normally they are just logged.

    With the provided informants comments are output to user when set; normally they are just logged. Comments are generally used to document unusual occurrences that might warrant the user’s attention.

  • narrate (bool) –

    Narration is output to user, normally it is just logged.

    With the provided informants narration is output to user when set, normally it is just logged. Narration is generally used to inform the user as to what is going on. This can help place errors and warnings in context so that they are easier to understand.

  • logfile (path, string, stream, bool) – May be a pathlib path or a string, in which case it is taken to be the path of the logfile. May be True, in which case ./.<prog_name>.log is used. May be an open stream. Or it may be False, in which case no log file is created.
  • prog_name (string) – The program name. Is appended to the message headers and used to create the default logfile name. May be a string, in which case it is used as the name of the program. May be True, in which case basename(argv[0]) is used. May be False to indicate that program name should not be added to message headers.
  • argv (list of strings) – System command line arguments (logged). By default, sys.argv is used. If False is passed in, argv is not logged and argv[0] is not available to be the program name.
  • version (string) – program version (logged if provided).
  • termination_callback (func) – A function that is called at program termination.
  • colorscheme (None, ‘light’, or ‘dark’) – Color scheme to use. None indicates that messages should not be colorized. Colors are not used if desired output stream is not a TTY.
  • flush (bool) – Flush the stream after each write. Is useful if your program is crashing, causing loss of the latest writes. Can cause programs to run considerably slower if they produce a lot of output. Not available with python2.
  • stdout (stream) – Messages are sent here by default. Generally used for testing. If not given, sys.stdout is used.
  • stderr (stream) – Exceptional messages are sent here by default. Exceptional message include termination messages and possibly error messages (depends on stream_policy). Generally used for testing. If not given, sys.stderr is used.
  • length_thresh (integer) – Split header from body if line length would be greater than this threshold.
  • culprit_sep (string) – Join string used for culprit collections. Default is ‘, ‘.
  • stream_policy (string or func) –

    The default stream policy, which determines which stream each informant uses by default (which stream is used if the stream is not specifically specified when the informant is created).

    The following named policies are available:
    ’termination’:
    stderr is used for the final termination message. stdout is used otherwise. This is generally used for programs are not filters (the output is largely status rather than data that might be fed into another program through a pipeline).
    ’header’:
    stderr is used for all messages with headers/severities. stdout is used otherwise. This is generally used for programs are filters (the output is largely data that might be fed into another program through a pipeline). In this case stderr is used for error messages so they do not pollute the data stream.

    May also be a function that returns the stream and takes three arguments: the active informant, Inform’s stdout, and Inform’s stderr.

    If no stream is specified, either explicitly on the informant when it is defined, or through the stream policy, then Inform’s stdout is used.

  • notify_if_no_tty (bool) – If it appears that an error message is expecting to displayed on the console but the standard output is not a TTY send it to the notifier if this flag is True.
  • notifier (str) – Command used to run the notifier. The command will be called with two arguments, the header and the body of the message.
  • **kwargs – Any additional keyword arguments are made attributes that are ignored by Inform, but may be accessed by the informants.
add_culprit(culprit)

Add to the currently saved culprit.

Similar to Inform.set_culprit() except that this method appends the given culprit to the cached culprit rather than simply replacing it.

Parameters:culprit (string, number or tuple of strings and numbers) – A culprit or collection of culprits that are cached with the intent that they be available to be included in a message upon demand. They generally are used to indicate what a message refers to.

This function is designed to work as a context manager, meaning that it meant to be used with Python’s with statement. It temporarily replaces any existing culprit, but that culprit in reinstated upon exiting the with statement. Once a culprit is saved, inform.Inform.get_culprit() is used to access it.

See Inform.set_culprit() for an example of a closely related method.

disconnect()

Disconnect informer, returning to previous informer.

done(exit=True)

Terminate the program with normal exit status.

Parameters:exit (bool) – If False, all preparations for termination are done, but sys.exit() is not called. Instead, the exit status is returned.
Returns:The desired exit status is returned if exit is False (the function does not return if exit is True).
errors_accrued(reset=False)

Returns number of errors that have accrued.

Parameters:reset (bool) – Reset the error count to 0 if True.
flush_logfile()

Flush the logfile.

get_culprit(culprit=None)

Get the current culprit.

Return the currently cached culprit as a tuple. If a culprit is specified as an argument, it is appended to the cached culprit without modifying it.

Parameters:culprit (string, number or tuple of strings and numbers) – A culprit or collection of culprits that is appended to the return value without modifying the cached culprit.
Returns:The culprit argument is appended to the cached culprit and the combination is returned. The return value is always in the form of a tuple even if there is only one component.

See Inform.set_culprit() for an example use of this method.

get_prog_name()

Returns the program name.

set_culprit(culprit)

Set the culprit while temporarily displacing current culprit.

Squirrels away a culprit for later use. Any existing culprit is moved out of the way.

Parameters:culprit (string, number or tuple of strings and numbers) – A culprit or collection of culprits that are cached with the intent that they be available to be included in a message upon demand. They generally are used to indicate what a message refers to.

This function is designed to work as a context manager, meaning that it meant to be used with Python’s with statement. It temporarily replaces any existing saved culprit, but that culprit in reinstated upon exiting the with statement. Once a culprit is saved, inform.Inform.get_culprit() is used to access it. For example:

>>> from inform import get_culprit, set_culprit, warn

>>> def count_lines(lines):
...    empty = 0
...    for lineno, line in enumerate(lines):
...        if not line:
...            warn('empty line.', culprit=get_culprit(lineno))

>>> filename = 'setup.py'
>>> with open(filename) as f, set_culprit(filename):
...    lines = f.read().splitlines()
...    num_lines = count_lines(lines)
warning: setup.py, 5: empty line.
warning: setup.py, 8: empty line.
warning: setup.py, 13: empty line.
set_logfile(logfile, encoding='utf-8')

Allows you to change the logfile (only available as a method).

Parameters:
  • logfile – May be a pathlib path. May be a string, in which case it is taken to be the path of the logfile. May be True, in which case ./.<prog_name>.log is used. May be an open stream. Or it may be False, in which case no log file is created.
  • encoding (string) – The encoding to use when writing the file.
set_stream_policy(stream_policy)

Allows you to change the stream policy (see inform.Inform).

suppress_output(mute=True)

Allows you to change the mute flag (only available as a method).

Parameters:mute (bool) – If mute is True all output is suppressed (it is still logged).
terminate(status=None, exit=True)

Terminate the program with specified exit status.

Parameters:
  • status (int, bool, string, or None) – The desired exit status or exit message. Exit status is 1 if True is passed in. When None, return 1 if errors occurred and 0 otherwise
  • exit (bool) – If False, all preparations for termination are done, but sys.exit() is not called. Instead, the exit status is returned.
Returns:

The desired exit status is returned if exit is False (the function does not return if exit is True).

Recommended status codes:
0: success
1: unexpected error
2: invalid invocation
3: panic

Status may also be a string, in which case it is printed to stderr and the exit status is 1.

terminate_if_errors(status=1, exit=True)

Terminate the program if error count is nonzero.

Parameters:
  • status (int, bool or string) – The desired exit status or exit message.
  • exit (bool) – If False, all preparations for termination are done, but sys.exit() is not called. Instead, the exit status is returned.
Returns:

None is returned if there is no errors, otherwise the desired exit status is returned if exit is False (the function does not return if there is an error and exit is True).

Direct Access Functions

Several of the above methods are also available as stand-alone functions that act on the currently active informer. This make it easy to use their functionality even if you do not have local access to the informer.

inform.done(exit=True)

Terminate the program with normal exit status.

Calls inform.Inform.done() for the active informer.

inform.terminate(status=None, exit=True)

Terminate the program with specified exit status.”

Calls inform.Inform.terminate() for the active informer.

inform.terminate_if_errors(status=1, exit=True)

Terminate the program if error count is nonzero.”

Calls inform.Inform.terminate_if_errors() for the active informer.

inform.errors_accrued(reset=False)

Returns number of errors that have accrued.”

Calls inform.Inform.errors_accrued() for the active informer.

inform.get_prog_name()

Returns the program name.

Calls inform.Inform.get_prog_name() for the active informer.

inform.set_culprit(culprit)

Set the culprit while displacing current culprit.

Calls inform.Inform.set_culprit() for the active informer.

inform.add_culprit(culprit)

Append to the end of the current culprit.

Calls inform.Inform.add_culprit() for the active informer.

inform.get_culprit(culprit=None)

Get the current culprit.

Calls inform.Inform.get_culprit() for the active informer.

You can also request the active informer:

inform.get_informer()

Returns the active informer.

InformantFactory

class inform.InformantFactory(severity=None, is_error=False, log=True, output=True, notify=False, terminate=False, is_continuation=False, message_color=None, header_color=None, stream=None)

An object of InformantFactory is referred to as an informant. It is generally treated as a function that is called to produce the desired output.

Parameters:
  • severity (string) – Messages with severities get headers. The header consists of the severity, the program name (if desired), and the culprit (if provided). If the message text does not contain a newline it is appended to the header. Otherwise the message text is indented and placed on the next line.
  • is_error (bool) – Message is counted as an error.
  • log (bool) – Send message to the log file. May be a boolean or a function that accepts the informer as an argument and returns a boolean.
  • output (bool) – Send message to the output stream. May be a boolean or a function that accepts the informer as an argument and returns a boolean.
  • notify (bool) – Send message to the notifier. The notifier will display the message that appears temporarily in a bubble at the top of the screen. May be a boolean or a function that accepts the informer as an argument and returns a boolean.
  • terminate (bool or integer) – Terminate the program. Exit status is the value of terminate unless terminate is True, in which case 1 is returned if an error occurred and 0 otherwise.
  • is_continuation (bool) – This message is a continuation of the previous message. It will use the properties of the previous message (output, log, message color, etc) and if the previous message had a header, that header is not output and instead the message is indented.
  • message_color (string) – Color used to display the message. Choose from: black, red, green, yellow, blue, magenta, cyan or white.
  • header_color (string) – Color used to display the header, if one is produced. Choose from: black, red, green, yellow, blue, magenta, cyan or white.
  • stream (stream) – Output stream to use. Typically sys.stdout or sys.stderr. If not specified, the stream to use will be determine by stream policy of active informer.

Example

The following generates two informants, passes, which prints its messages in green, and fails, which prints its messages in red. Output to the standard output for both is suppressed if quiet is True:

>>> from inform import InformantFactory

>>> passes = InformantFactory(
...     output=lambda inform: not inform.quiet,
...     log=True,
...     message_color='green',
... )
>>> fails = InformantFactory(
...     output=lambda inform: not inform.quiet,
...     log=True,
...     message_color='red',
... )

pass and fail are both informants. Once created, the can be used to give messages to the user:

>>> results = [
...     (0,   0.005, 0.025),
...     (0.5, 0.512, 0.025),
...     (1,   0.875, 0.025),
... ]
>>> for expected, measured, tolerance in results:
...     if abs(expected - measured) > tolerance:
...         report, label = fails, 'FAIL'
...     else:
...         report, label = passes, 'Pass'
...     report(
...         label, measured, expected, measured-expected,
...         template='{}: measured = {:.3f}V, expected = {:.3f}V, diff = {:.3f}V'
...     )
Pass: measured = 0.005V, expected = 0.000V, diff = 0.005V
Pass: measured = 0.512V, expected = 0.500V, diff = 0.012V
FAIL: measured = 0.875V, expected = 1.000V, diff = -0.125V

In the console the passes are rendered in green and the failures in red.

Inform Utilities

inform.indent(text, leader=' ', first=0, stops=1, sep='\n')

Add indentation.

Parameters:
  • leader (string) – the string added to be beginning of a line to indent it.
  • first (integer) – number of indentations for the first line relative to others (may be negative but (first + stops) should not be).
  • stops (integer) – number of indentations (number of leaders to add to the beginning of each line).
  • sep (string) – the string used to separate the lines

Example:

>>> from inform import display, indent
>>> display(indent('And the answer is ...\n42!', first=-1))
And the answer is ...
    42!
inform.cull(collection, **kwargs)

Cull items of a particular value from a collection.

Parameters:
  • collection – The collection may be list-like (list, tuples, sets, etc.) or dictionary-like (dict, OrderedDict, etc.). A new collection of the same type is returned with the undesirable values removed.
  • remove

    Must be specified as keyword argument. May be a function, a collection, or a scalar. The function would take a single argument, one of the values in the collection, and return True if the value should be culled. The scalar or the collection simply specified the specific value or values to be culled.

    If remove is not specified, the value is culled if its value would be False when cast to a boolean (0, False, None, ‘’, (), [], {}, etc.)

Example:

>>> from inform import cull, display
>>> from collections import OrderedDict
>>> fruits = OrderedDict([
...    ('a','apple'), ('b','banana'), ('c','cranberry'), ('d','date'),
...    ('e',None), ('f',None), ('g','guava'),
... ])
>>> display(*cull(list(fruits.values())), sep=', ')
apple, banana, cranberry, date, guava

>>> for k, v in cull(fruits).items():
...     display('{k} is for {v}'.format(k=k, v=v))
a is for apple
b is for banana
c is for cranberry
d is for date
g is for guava
inform.is_str(arg)

Identifies strings in all their various guises.

Returns True if argument is a string.

Example:

>>> from inform import is_str
>>> is_str('abc')
True

>>> is_str(['a', 'b', 'c'])
False
inform.is_iterable(obj)

Identifies objects that can be iterated over, including strings.

Returns True if argument is a collecton or a string.

Example:

>>> from inform import is_iterable
>>> is_iterable('abc')
True

>>> is_iterable(['a', 'b', 'c'])
True
inform.is_collection(obj)

Identifies objects that can be iterated over, excluding strings.

Returns True if argument is a collecton (tuple, list, set or dictionary).

Example:

>>> from inform import is_collection
>>> is_collection('abc')
False

>>> is_collection(['a', 'b', 'c'])
True
class inform.Color(color, scheme=True, enable=True)

Used to create colorizers, which are used to render text in a particular color.

Parameters:
  • color (string) – The desired color. Choose from: black red green yellow blue magenta cyan white.
  • scheme (string) – Use the specified colorscheme when rendering the text. Choose from None, ‘light’ or ‘dark’, default is ‘dark’.
  • enable (bool) – If set to False, the colorizer does not render the text in color.

Example

>>> from inform import Color
>>> fail = Color('red')

In this example, fail is a colorizer. It behave just like inform.join() in that it combines its arguments into a string that it returns. The difference is that colorizers add color codes that will cause most terminals to display the string in the desired color.

Like inform.join(), colorizers take the following arguments:

unnamed arguments:
The unnamed arguments are converted to strings and joined to form the text to be colored.
sep = ‘ ‘:
The join string, used when joining the unnamed arguments.
template = None:
A template that if present interpolates the arguments to form the final message rather than simply joining the unnamed arguments with sep. The template is a string, and its format method is called with the unnamed and named arguments of the message passed as arguments.
wrap = False:
Specifies whether message should be wrapped. wrap may be True, in which case the default width of 70 is used. Alternately, you may specify the desired width. The wrapping occurs on the final message after the arguments have been joined.
scheme = False:
Use to override the colorscheme when rendering the text. Choose from None, False, ‘light’ or ‘dark’. If you specify False (the default), the colorscheme specified when creating the colorizer is used.
static isTTY(stream=<_io.TextIOWrapper name='<stdout>' mode='w' encoding='UTF-8'>)

Takes a stream as an argument and returns true if it is a TTY.

Parameters:stream (stream) – Stream to test. If not given, stdout is used as the stream.
>>> from inform import Color, display
>>> import sys, re
>>> if Color.isTTY(sys.stdout):
...     emphasize = Color('magenta')
... else:
...     emphasize = str.upper
>>> def highlight(matchobj):
...     return emphasize(matchobj.group(0))
>>> display(re.sub('your', highlight, 'Imagine your city without cars.'))
Imagine YOUR city without cars.
classmethod strip_colors(text)

Takes a string as its input and return that string stripped of any color codes.

User Utilities

inform.fmt(message, *args, **kwargs)

Similar to ‘’.format(), but it can pull arguments from the local scope.

Convert a message with embedded attributes to a string. The values for the attributes can come from the argument list, as with ‘’.format(), or they may come from the local scope (found by introspection).

Examples:

>>> from inform import fmt
>>> s = 'str var'
>>> d = {'msg': 'dict val'}
>>> class Class:
...     a = 'cls attr'

>>> display(fmt("by order: {0}, {1[msg]}, {2.a}.", s, d, Class))
by order: str var, dict val, cls attr.

>>> display(fmt("by name: {S}, {D[msg]}, {C.a}.", S=s, D=d, C=Class))
by name: str var, dict val, cls attr.

>> display(fmt("by magic: {s}, {d[msg]}, {c.a}."))
by magic: str var, dict val, cls attr.

You can change the level at which the introspection occurs using the _lvl keyword argument.

_lvl=0 searches for variables in the scope that calls fmt(), the default
_lvl=-1 searches in the parent of the scope that calls fmt()
_lvl=-2 searches in the grandparent, etc.
_lvl=1 search root scope, etc.
inform.join(*args, **kwargs)

Combines arguments into a string.

Combines the arguments in a manner very similar to an informant and returns the result as a string. Uses the sep, template and wrap keyword arguments to combine the arguments.

If template is specified it controls how the arguments are combined and the result returned. Otherwise the unnamed arguments are joined using the separator and returned.

Parameters:
  • sep (string) – Use specified string as join string rather than single space. The unnamed arguments will be joined with using this string as a separator. Default is ‘ ‘.
  • template (string or collection of strings) – A python format string. If specified, the unnamed and named arguments are combined under the control of the strings format method. This may also be a collection of strings, in which case each is tried in sequence, and the first for which all the interpolated arguments are known is used. By default, an argument is ‘known’ if it would be True if casted to a boolean.
  • remove

    Used if template is a collection.

    May be a function, a collection, or a scalar. The function would take a single argument, one of the values in the collection, and return True if the value should not be considered known. The scalar or the collection simply specified the specific value of values that should not be considered known.

    If remove is not specified, the value should not be considered known if its value would be False when cast to a boolean (0, False, None, ‘’, (), [], {}, etc.)

  • wrap (bool or int) – If true the string is wrapped using a width of 70. If an integer value is passed, is used as the width of the wrap.

Examples:

>>> from inform import join
>>> join('a', 'b', 'c', x='x', y='y', z='z')
'a b c'

>>> join('a', 'b', 'c', x='x', y='y', z='z', template='{2} {z}')
'c z'
inform.render(obj, sort=None, level=0, tab=' ')

Recursively convert object to string with reasonable formatting.

Parameters:
  • obj – The object to render
  • sort (bool) – Dictionary keys and set values are sorted if sort is True. Sometimes this is not possible because the values are not comparable, in which case render reverts to using the natural order.
  • tab (string) – The string used when indenting.

render has built in support for the base Python types (None, bool, int, float, str, set, tuple, list, and dict). If you confine yourself to these types, the output of render can be read by the Python interpreter. Other types are converted to string with repr().

Example:

>>> from inform import display, render
>>> display('result =', render({'a': (0, 1), 'b': [2, 3, 4]}))
result = {'a': (0, 1), 'b': [2, 3, 4]}
inform.os_error(err)

Generates clean messages for operating system errors.

Parameters:err (exception) – The value of an OSError or IOError exception (in Python3 IOError is a subclass of OSError, so you only need to catch OSError).

Example:

>>> from inform import display, os_error
>>> try:
...     with open('config') as f:
...         contents = f.read()
... except (OSError, IOError) as e:
...     display(os_error(e))
config: no such file or directory.
inform.conjoin(iterable, conj=' and ', sep=', ')

Conjunction join.

Parameters:
  • iterable (exception) – The collection of strings to be joined.
  • conj (string) – The separator used between the next to last and last values.
  • sep (string) – The separator to use when joining the strings in iterable.

Return the items of the iterable joined into a string, where conj is used to join the last two items in the list, and sep is used to join the others.

Examples

>>> from inform import conjoin, display
>>> display(conjoin([], ' or '))
>>> display(conjoin(['a'], ' or '))
a
>>> display(conjoin(['a', 'b'], ' or '))
a or b
>>> display(conjoin(['a', 'b', 'c']))
a, b and c
inform.plural(count, singular, plural=None)

Pluralize a word.

If count is 1 or has length 1, the singular argument is returned, otherwise the plural argument is returned. If plural is None, then it is created by adding an ‘s’ to the end of singular argument.

Example:

>>> from inform import display, plural
>>> fruits = 'apple banana cranberry date'.split()
>>> display('I have {} {} of fruit.'.format(len(fruits), plural(fruits, 'piece')))
I have 4 pieces of fruit.
inform.full_stop(sentence)

Add period to end of string if it is needed.

A full stop (a period) is added if there is no terminating punctuation at the end of the string.

Examples:

>>> from inform import full_stop
>>> full_stop('The file is out of date')
'The file is out of date.'

>>> full_stop('The file is out of date.')
'The file is out of date.'

>>> full_stop('Is the file is out of date?')
'Is the file is out of date?'
inform.columns(array, pagewidth=79, alignment='<', leader=' ')

Distribute array over enough columns to fill the screen.

Returns a list of strings, one for each line.

Parameters:
  • array (collection of strings) – The array to be printed.
  • pagewidth (int) – The number of characters available for each line.
  • alignment ('<' or '>') – Whether to left (‘<’) or right (‘>’) align the array items in their columns.
  • leader (str) – The string to prepend to each line.

Example:

>>> from inform import columns, display, full_stop
>>> title = 'Display the NATO phonetic alphabet'
>>> words = '''
...     Alfa Bravo Charlie Delta Echo Foxtrot Golf Hotel India Juliett
...     Kilo Lima Mike November Oscar Papa Quebec Romeo Sierra Tango
...     Uniform Victor Whiskey X-ray Yankee Zulu
... '''.split()
>>> newline = '''
... '''
>>> display(full_stop(title), columns(words), sep=newline)
Display the NATO phonetic alphabet.
    Alfa      Echo      India     Mike      Quebec    Uniform   Yankee
    Bravo     Foxtrot   Juliett   November  Romeo     Victor    Zulu
    Charlie   Golf      Kilo      Oscar     Sierra    Whiskey
    Delta     Hotel     Lima      Papa      Tango     X-ray

Debug Utilities

inform.aaa(*args, **kwargs)

Print argument, then return it.

Pretty-prints its argument. Argument may be named or unnamed. Allows you to display the value that is only contained within an expression.

inform.ddd(*args, **kwargs)

Print arguments function.

Pretty-prints its arguments. Arguments may be named or unnamed.

inform.ppp(*args, **kwargs)

Print function.

Mimics the normal print function, but colors printed output to make it easier to see and labels it with the location of the call.

inform.sss()

Print a stack trace.

inform.vvv(*args)

Print variables function.

Pretty-prints variables from the calling scope. If no arguments are given, all variables are printed. If arguments are given, only the variables whose value match an argument are printed.

Exceptions

exception inform.Error(*args, **kwargs)

A generic exception.

The exception accepts both unnamed and named arguments. All are recorded and available for later use.

get_culprit()

Get exception culprit.

If the culprit keyword argument was specified as a string, it is returned. If it was specified as a collection, the members are converted to strings and joined with culprit_sep. The resulting string is returned.

get_message(template=None)

Get exception message.

Parameters:template (str) –

This argument is treated as a format string and is passed both the unnamed and named arguments. The resulting string is treated as the message and returned.

If not specified, the template keyword argument passed to the exception is used. If there was no template argument, then the positional arguments of the exception are joined using sep and that is returned.

Returned:
The formatted message without the culprits.
render(template=None)

Convert exception to a string for use in an error message.

Parameters:template (str) –

This argument is treated as a format string and is passed both the unnamed and named arguments. The resulting string is treated as the message and returned.

If not specified, the template keyword argument passed to the exception is used. If there was no template argument, then the positional arguments of the exception are joined using sep and that is returned.

report(template=None)

Report exception.

The inform.error() function is called with the exception arguments.

Parameters:template (str) –

This argument is treated as a format string and is passed both the unnamed and named arguments. The resulting string is treated as the message and returned.

If not specified, the template keyword argument passed to the exception is used. If there was no template argument, then the positional arguments of the exception are joined using sep and that is returned.

terminate(template=None)

Report exception and terminate.

The inform.fatal() function is called with the exception arguments.

Parameters:template (str) –

This argument is treated as a format string and is passed both the unnamed and named arguments. The resulting string is treated as the message and returned.

If not specified, the template keyword argument passed to the exception is used. If there was no template argument, then the positional arguments of the exception are joined using sep and that is returned.