12.2.6. Setting up logging — MDAnalysis.lib.log

Configure logging for MDAnalysis. Import this module if logging is desired in application code.

Logging to a file and the console is set up by default as described under logging to multiple destinations.

The top level logger of the library is named MDAnalysis by convention; a simple logger that writes to the console and logfile can be created with the create() function. This only has to be done once. For convenience, the default MDAnalysis logger can be created with MDAnalysis.start_logging():

import MDAnalysis
MDAnalysis.start_logging()

Once this has been done, MDAnalysis will write messages to the logfile (named MDAnalysis.log by default but this can be changed with the optional argument to start_logging()).

Any code can log to the MDAnalysis logger by using

import logging
logger = logging.getLogger('MDAnalysis.MODULENAME')

# use the logger, for example at info level:
logger.info("Starting task ...")

The important point is that the name of the logger begins with “MDAnalysis.”.

Note

The logging module in the standard library contains in depth documentation about using logging.

12.2.6.1. Convenience functions

Two convenience functions at the top level make it easy to start and stop the default MDAnalysis logger.

MDAnalysis.start_logging(logfile='MDAnalysis.log', version='0.20.2-dev0')[source]

Start logging of messages to file and console.

The default logfile is named MDAnalysis.log and messages are logged with the tag MDAnalysis.

MDAnalysis.stop_logging()[source]

Stop logging to logfile and console.

12.2.6.2. Other functions and classes for logging purposes

class MDAnalysis.lib.log.NullHandler(level=0)[source]

Silent Handler.

Useful as a default:

h = NullHandler()
logging.getLogger("MDAnalysis").addHandler(h)
del h

see the advice on logging and libraries in http://docs.python.org/library/logging.html?#configuring-logging-for-a-library

Initializes the instance - basically setting the formatter to None and the filter list to empty.

emit(record)[source]

Do whatever it takes to actually log the specified logging record.

This version is intended to be implemented by subclasses and so raises a NotImplementedError.

class MDAnalysis.lib.log.ProgressMeter(numsteps, format=None, interval=10, offset=1, verbose=True, dynamic=True, format_handling='auto')[source]

Simple progress meter

The ProgressMeter class can be used to show running progress such as frames processed or percentage done to give the user feedback on the duration and progress of a task. It is structures as a class that is customized on instantation (e.g., using a custom format string and the expected total number of frames to be processed). Within a processing loop, call echo() with the current frame number to print the output to stderr.

Parameters:
  • numsteps (int) – total number of steps
  • interval (int) – only calculate and print progress every interval steps [10]
  • format (str) –

    a format string with Python variable interpolation. Allowed values:

    • step: current step
    • numsteps: total number of steps as supplied in numsteps
    • percentage: percentage of total

    The last call to ProgressMeter.print() will automatically issue a newline \n.

    If format is None then the default is used:

    Step {step:5d}/{numsteps} [{percentage:5.1f}%]
    
  • offset (int) – number to add to step; e.g. if step is 0-based (as in MDAnalysis) then one should set offset = 1; for 1-based steps, choose 0. [1]
  • verbose (bool) – If False, disable all output, True print all messages as specified, [True]
  • dynamic (bool) – If True, each line will be printed on top of the previous one. This is done by prepedind the format with \r. [True]
  • format_handling (str) –

    how to handle the format string. Allowed values are:

    • new: the format string uses {}-based formating
    • legacy: the format string uses %-basedd formating
    • auto: default, try to guess how the format string should be handled

Examples

The typical use case is to show progress as frames of a trajectory are processed:

u = Universe(PSF, DCD)
pm = ProgressMeter(u.trajectory.n_frames, interval=100)
for ts in u.trajectory:
    pm.echo(ts.frame)
    ...

For a trajectory with 10000 frames this will produce output such as

Step   100/10000 [  1.0%]
Step   200/10000 [  2.0%]
...

The default format string is:

Step {step:5d}/{numsteps} [{percentage:5.1f}%]

By default, each line of the progress meter is displayed on top of the previous one. To prevent this behaviour, set the dynamic keyword to False.

It is possible to embed (almost) arbitrary additional data in the format string, for example a current RMSD value:

format_line = "RMSD {rmsd:5.2f} at {step:5d}/{numsteps} [{percentage:5.1f}%]"
pm = ProgressMeter(u.trajectory.n_frames,
                   interval=100, format=format_line)
for ts in u.trajectory:
   pm.echo(ts.frame, rmsd=current_rmsd)
   ...

This will print something like:

RMSD   1.02 at  100/10000 [  1.0%]
RMSD   1.89 at  200/10000 [  2.0%]
...

Changed in version 0.8: Keyword argument quiet was added.

Changed in version 0.16: Keyword argument dynamic replaces \r in the format.

Deprecated since version 0.16: Keyword argument quiet is deprecated in favor of verbose.

echo(step, **kwargs)[source]

Print the state to stderr, but only every interval steps.

  1. calls update()
  2. writes step and percentage to stderr with echo(), using the format string (in ProgressMeter.format)

The last step is always shown, even if not on an interval, and a carriage return is replaced with a new line for a cleaner display.

kwargs are additional attributes that can be references in the format string.

Note

If verbose = False has been set in the constructor or if ProgressMeter.verbose has been set to False, then no messages will be printed.

update(step, **kwargs)[source]

Update the state of the ProgressMeter.

kwargs are additional attributes that can be references in the format string.

MDAnalysis.lib.log.clear_handlers(logger)[source]

clean out handlers in the library top level logger

(only important for reload/debug cycles…)

MDAnalysis.lib.log.create(logger_name='MDAnalysis', logfile='MDAnalysis.log')[source]

Create a top level logger.

  • The file logger logs everything (including DEBUG).
  • The console logger only logs INFO and above.

Logging to a file and the console as described under logging to multiple destinations.

The top level logger of MDAnalysis is named MDAnalysis. Note that we are configuring this logger with console output. If a root logger also does this then we will get two output lines to the console.

MDAnalysis.lib.log.echo(s='', replace=False, newline=True)[source]

Simple string output that immediately prints to the console.

The string s is modified according to the keyword arguments and then printed to sys.stderr, which is immediately flushed.

Parameters:
  • s (str) – The string to output.
  • replace (bool) – If True, the string will be printed on top of the current line. In practice, \r is added at the beginning of the string.
  • newline (bool) – If True, a newline is added at the end of the string.
MDAnalysis.lib.log.start_logging(logfile='MDAnalysis.log', version='0.20.2-dev0')[source]

Start logging of messages to file and console.

The default logfile is named MDAnalysis.log and messages are logged with the tag MDAnalysis.

MDAnalysis.lib.log.stop_logging()[source]

Stop logging to logfile and console.