ii3dZddlZddlZddlZddlmZddlmZdejfdZ dZ dd Z d Z Gd d ej ZGddeZdS)aNSetting up logging --- :mod:`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 :func:`create` function. This only has to be done *once*. For convenience, the default MDAnalysis logger can be created with :func:`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 :func:`~MDAnalysis.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.". .. _logging to multiple destinations: http://docs.python.org/library/logging.html?#logging-to-multiple-destinations Note ---- The :mod:`logging` module in the standard library contains in depth documentation about using logging. Convenience functions --------------------- Two convenience functions at the top level make it easy to start and stop the default *MDAnalysis* logger. .. autofunction:: MDAnalysis.start_logging .. autofunction:: MDAnalysis.stop_logging Other functions and classes for logging purposes ------------------------------------------------ .. versionchanged:: 2.0.0 Deprecated :class:`MDAnalysis.lib.log.ProgressMeter` has now been removed. .. autogenerated, see Online Docs N)tqdm)versionMDAnalysis.logcztd|tjdd||dS)zStart logging of messages to file and console. The default logfile is named `MDAnalysis.log` and messages are logged with the tag *MDAnalysis*. MDAnalysis)logfilez#MDAnalysis %s STARTED logging to %rN)createlogging getLoggerinfo)r rs \/srv/www/vhosts/g4struct/public_html/venv/lib/python3.11/site-packages/MDAnalysis/lib/log.py start_loggingr`sK  <)))) l##((-wcvtjd}|dt|dS)z$Stop logging to logfile and console.rzMDAnalysis STOPPED loggingN)r r r clear_handlers)loggers r stop_loggingrls9  | , ,F KK,---6rrctj|}|tjtj|}tjd}||||tj}|tj tjd}|||||S)aKCreate 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. .. _logging to multiple destinations: http://docs.python.org/library/logging.html?#logging-to-multiple-destinations z3%(asctime)s %(name)-12s %(levelname)-8s %(message)sz(%(name)-12s: %(levelname)-8s %(message)s) r r setLevelDEBUG FileHandler Formatter setFormatter addHandler StreamHandlerINFO) logger_namer rlogfile_handlerlogfile_formatterconsole_handler formatters rr r ss$ { + +F OOGM""")'22O)=  !2333 o&&&+--OW\***!"LMMI  +++ o&&& MrcD|jD]}||dS)ziclean out handlers in the library top level logger (only important for reload/debug cycles...) N)handlers removeHandler)rhs rrrs6 _  Q  rceZdZdZdZdS) NullHandlera 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 cdS)N)selfrecords remitzNullHandler.emits rN)__name__ __module__ __qualname____doc__r-r*rrr(r(s-       rr(c"eZdZdZfdZxZS) ProgressBaruDisplay a visual progress bar and time estimate. The :class:`ProgressBar` decorates an iterable object, returning an iterator which acts exactly like the original iterable, but prints a dynamically updating progressbar every time a value is requested. See the example below for how to use it when iterating over the frames of a trajectory. Parameters ---------- iterable : iterable, optional Iterable to decorate with a progressbar. Leave blank to manually manage the updates. verbose : bool, optional If ``True`` (the default) then show the progress bar, *unless* the `disable` keyword is set to ``True`` (`disable` takes precedence over `verbose`). If `verbose` is set to ``None`` then the progress bar is displayed (like ``True``), *unless* this is a non-TTY output device (see `disable`). desc : str, optional Prefix for the progressbar. total : int or float, optional The number of expected iterations. If unspecified, ``len(iterable)`` is used if possible. If ``float("inf")`` or as a last resort, only basic progress statistics are displayed (no ETA, no progressbar). leave : bool, optional If [default: ``True``], keeps all traces of the progressbar upon termination of iteration. If ``None``, will leave only if `position` is 0. file : :class:`io.TextIOWrapper` or :class:`io.StringIO`, optional Specifies where to output the progress messages (default: :data:`sys.stderr`). Uses :meth:`file.write` and :meth:`file.flush` methods. For encoding, see `write_bytes`. ncols : int, optional The width of the entire output message. If specified, dynamically resizes the progressbar to stay within this bound. If unspecified, attempts to use environment width. The fallback is a meter width of 10 and no limit for the counter and statistics. If 0, will not print any meter (only stats). mininterval : float, optional Minimum progress display update interval [default: 0.1] seconds. maxinterval : float, optional Maximum progress display update interval [default: 10] seconds. Automatically adjusts `miniters` to correspond to `mininterval` after long display update lag. Only works if `dynamic_miniters` or monitor thread is enabled. miniters : int or float, optional Minimum progress display update interval, in iterations. If 0 and `dynamic_miniters`, will automatically adjust to equal `mininterval` (more CPU efficient, good for tight loops). If > 0, will skip display of specified number of iterations. Tweak this and `mininterval` to get very efficient loops. If your progress is erratic with both fast and slow iterations (network, skipping items, etc) you should set miniters=1. ascii : bool or str, optional If unspecified or ``False``, use unicode (smooth blocks) to fill the meter. The fallback is to use ASCII characters " 123456789#". disable : bool, optional Whether to disable the entire progressbar wrapper [default: ``False``]. If set to None, disable on non-TTY. unit : str, optional String that will be used to define the unit of each iteration [default: it]. unit_scale : bool or int or float, optional If 1 or True, the number of iterations will be reduced/scaled automatically and a metric prefix following the International System of Units standard will be added (kilo, mega, etc.) [default: ``False``]. If any other non-zero number, will scale `total` and `n`. dynamic_ncols : bool, optional If set, constantly alters `ncols` and `nrows` to the environment (allowing for window resizes) [default: ``False``]. smoothing : float, optional Exponential moving average smoothing factor for speed estimates (ignored in GUI mode). Ranges from 0 (average speed) to 1 (current/instantaneous speed) [default: 0.3]. bar_format : str, optional Specify a custom bar string formatting. May impact performance. [default: ``'{l_bar}{bar}{r_bar}'``], where ``l_bar='{desc}: {percentage:3.0f}%|'`` and ``r_bar='| {n_fmt}/{total_fmt} [{elapsed}<{remaining}, {rate_fmt}{postfix}]'`` Possible vars: l_bar, bar, r_bar, n, n_fmt, total, total_fmt, percentage, elapsed, elapsed_s, ncols, nrows, desc, unit, rate, rate_fmt, rate_noinv, rate_noinv_fmt, rate_inv, rate_inv_fmt, postfix, unit_divisor, remaining, remaining_s. Note that a trailing ": " is automatically removed after {desc} if the latter is empty. initial : int or float, optional The initial counter value. Useful when restarting a progress bar [default: 0]. If using :class:`float`, consider specifying ``{n:.3f}`` or similar in `bar_format`, or specifying `unit_scale`. position : int, optional Specify the line offset to print this bar (starting from 0) Automatic if unspecified. Useful to manage multiple bars at once (e.g., from threads). postfix : dict or \*, optional Specify additional stats to display at the end of the bar. Calls ``set_postfix(**postfix)`` if possible (:class:`dict`). unit_divisor : float, optional [default: 1000], ignored unless `unit_scale` is ``True``. write_bytes : bool, optional If (default: ``None``) and `file` is unspecified, bytes will be written in Python 2. If `True` will also write bytes. In all other cases will default to unicode. lock_args : tuple, optional Passed to `refresh` for intermediate output (initialisation, iterating, and updating). nrows : int, optional The screen height. If specified, hides nested bars outside this bound. If unspecified, attempts to use environment height. The fallback is 20. Returns ------- out : decorated iterator. Example ------- To get a progress bar when analyzing a trajectory:: from MDAnalysis.lib.log import ProgressBar ... for ts in ProgressBar(u.trajectory): # perform analysis will produce something similar to :: 30%|███████████ | 3/10 [00:13<00:30, 4.42s/it] in a terminal or Jupyter notebook. See Also -------- The :class:`ProgressBar` is derived from :class:`tqdm.auto.tqdm`; see the `tqdm documentation`_ for further details on how to use it. .. _`tqdm documentation`: https://tqdm.github.io/ c|dd}||n| }|d||d<tt|j|i|dS)verboseTNdisable)popsuperr3__init__)r+argskwargsr6r7 __class__s rr:zProgressBar.__init__Osi**Y--%_''g+"JJy'::y)k4  )4:6:::::r)r.r/r0r1r: __classcell__)r=s@rr3r3sEUUn ; ; ; ; ; ; ; ; ;rr3)rr)r1sysr re tqdm.autorr5r __version__rrr rHandlerr(r3r*rrrDs 2==|  +G4G    &&&&R        '/   "c;c;c;c;c;$c;c;c;c;c;r