Inheritance diagram for Debugger:

Collaboration diagram for Debugger:

Public Member Functions
def	__init__ (self, logger_name, logger_level=None)

def	output_file (self)

def	active (self)

def	debug_level (self)

def	debug_level (self, debug_level)

def	traceback (self, kwargs)

def	reset (self)

def	setup_basic (self, kwargs)

def	newline (self, debug_level=1, count=1)

def	new_line (self, debug_level=1, count=1)

def	__call__ (self, debug_level=1, msg=EMPTY_KWARG, args, kwargs)

def	clean (self, debug_level=1, msg=EMPTY_KWARG, args, kwargs)

def	basic (self, debug_level=1, msg=EMPTY_KWARG, args, kwargs)

def	clear (self, delete=False)

def	invert (self)

def	handle_stderr (self, stderr=False, stdout=False)

def	setup (self, file=EMPTY_KWARG, mode=EMPTY_KWARG, delete=EMPTY_KWARG, date=EMPTY_KWARG, levels=EMPTY_KWARG, function=EMPTY_KWARG, name=EMPTY_KWARG, time=EMPTY_KWARG, msecs=EMPTY_KWARG, tick=EMPTY_KWARG, separator=EMPTY_KWARG, formatter=EMPTY_KWARG, rotation=EMPTY_KWARG, kwargs)

def	warn (self, msg, args, kwargs)

def	exception (self, msg, args, kwargs)

def	addHandler (self, handler)

def	removeHandler (self, handler)

def	deleteAllLoggers (cls)

def	delete (self)

def	removeHandlers (self)

def	hasStreamHandlers (self)

def	fix_children (self, callable_action)

def	get_debug_file_path (cls, file_path)

def	remove_windows_driver_letter (cls, file_path)

def	getRootLogger (cls)

def	__str__ (self)

def	findCaller (self)

def	findCaller (self, stack_info=False)

def	makeRecord (self, name, level, fn, lno, msg, args, exc_info, func=None, extra=None)

def	makeRecord (self, name, level, fn, lno, msg, args, exc_info, func=None, extra=None, sinfo=None)

Static Public Member Functions
def	getFormat (arguments, setting, default, next_parameter="")

Public Attributes
	trimname

	full_formatter

	clean_formatter

	basic_formatter

	debug_level

	clean

	basic

Detailed Description

    https://docs.python.org/2.6/library/logging.html

    How to define global function in Python?
    https://stackoverflow.com/questions/27930038/how-to-define-global-function-in-python

    How to print list inside python print?
    https://stackoverflow.com/questions/45427500/how-to-print-list-inside-python-print

Definition at line 130 of file logger.py.

Constructor & Destructor Documentation

◆ init()

def __init__	(	self,
		logger_name,
		logger_level = `None`
	)

    See the factory global function logger.getLogger().

Definition at line 144 of file logger.py.

References Debugger._debugger_level, Debugger._file, Debugger._force_debug, Debugger._frame_level, Debugger._last_tick, Debugger._reset(), Debugger._stream, and Debugger.trimname.

     def __init__(self, logger_name, logger_level=None):
         """
             See the factory global function logger.getLogger().
         """
         # What is a clean, pythonic way to have multiple constructors in Python?
         # https://stackoverflow.com/questions/682504/what-is-a-clean-pythonic-way-to-have-multiple-constructors-in-python
         super( Debugger, self ).__init__( logger_name, logger_level or "DEBUG" )
 
         self._file = None
         self._stream = None
 
         # Initialize the first last tick as the current tick
         self._last_tick = timeit.default_timer()
 
         # Forces this debug_level into all children
         self._force_debug = None
         self.trimname = 0
 
         # Enable debug messages: (bitwise)
         # 0 - Disabled debugging
         # 1 - Errors messages
         self._frame_level = 4
         self._debugger_level = 127
         self._reset()
 

Here is the call graph for this function:

Member Function Documentation

◆ call()

def __call__	(	self,
		debug_level = `1`,
		msg = `EMPTY_KWARG`,
		args,
		kwargs
	)

    Log to the current active handlers its message based on the bitwise `self._debugger_level`
    value. Note, differently from the standard logging level, each logger object has its own
    bitwise logging level, instead of all sharing the main `level`.

Definition at line 346 of file logger.py.

References Debugger._debugger_level, Debugger._log(), Debugger._log_clean(), Debugger.active(), and Debugger.clean_formatter.

     def __call__(self, debug_level=1, msg=EMPTY_KWARG, *args, **kwargs):
         """
             Log to the current active handlers its message based on the bitwise `self._debugger_level`
             value. Note, differently from the standard logging level, each logger object has its own
             bitwise logging level, instead of all sharing the main `level`.
         """
 
         if type( debug_level ) is int:
 
             if msg is EMPTY_KWARG:
 
                 if self._debugger_level & 1 != 0:
                     kwargs['debug_level'] = 1
                     self._log( DEBUG, debug_level, args, **kwargs )
 
             elif self._debugger_level & debug_level != 0:
                 kwargs['debug_level'] = debug_level
                 self._log( DEBUG, msg, args, **kwargs )
 
         else:
 
             if self._debugger_level & 1 != 0:
                 kwargs['debug_level'] = 1
 
                 if msg is EMPTY_KWARG:
                     self._log( DEBUG, debug_level, args, **kwargs )
 
                 else:
                     self._log( DEBUG, debug_level, (msg,) + args, **kwargs )
 

Here is the call graph for this function:

◆ active()

def active ( self )

    Works accordingly with super::hasHandlers(), except that this returns the activate
    logger object if it has some activate handler, or None if there are not loggers with
    active handlers.

    The root logger is not returned, unless it is already setup with handlers.

Definition at line 178 of file logger.py.

Referenced by Debugger.__call__(), Debugger.basic(), Debugger.clean(), Debugger.clear(), Debugger.debug_level(), Debugger.exception(), and Debugger.setup().

     def active(self):
         """
             Works accordingly with super::hasHandlers(), except that this returns the activate
             logger object if it has some activate handler, or None if there are not loggers with
             active handlers.
 
             The root logger is not returned, unless it is already setup with handlers.
         """
         current = self
 
         while current:
 
             if current.handlers:
                 return current
 
             if not current.propagate:
                 break
 
             else:
                 current = current.parent
 
         return None
 

Here is the caller graph for this function:

◆ addHandler()

def addHandler	(	self,
		handler
	)

    Override the super() method to correctly set up `sys.stderr/stdout` handlers.

    When adding a new handler and either `sys.stderr` or `sys.stdout` is enabled. It is
    required to check whether there is also a stream handler enabled, and if so, then, we
    need to add a log record filter to avoid infinity log records trying to be displayed.
    See also logging::Logger::addHandler().

Definition at line 1071 of file logger.py.

References Debugger._file, Debugger._file_context_filter, Debugger._has_file_context_filter, Debugger._stderr(), Debugger._stdout(), Debugger._stream, and Debugger.handle_stderr().

Referenced by Debugger.setup().

     def addHandler(self, handler):
         """
             Override the super() method to correctly set up `sys.stderr/stdout` handlers.
 
             When adding a new handler and either `sys.stderr` or `sys.stdout` is enabled. It is
             required to check whether there is also a stream handler enabled, and if so, then, we
             need to add a log record filter to avoid infinity log records trying to be displayed.
             See also logging::Logger::addHandler().
         """
 
         if self._stderr or self._stdout:
 
             if self._file and self._stream:
                 handler.addFilter( self._file_context_filter )
 
                 self._has_file_context_filter = True
                 _acquireLock()
 
                 try:
                     for other_handler in self.handlers:
                         other_handler.addFilter( self._file_context_filter )
 
                 finally:
                     _releaseLock()
 
                 self.handle_stderr( self._stderr, self._stdout )
 
             # else: # TODO: Support other this logic also for other handlers and the builtin _stream and _file
 
         super( Debugger, self ).addHandler( handler )
 

Here is the call graph for this function:

Here is the caller graph for this function:

◆ basic()

def basic	(	self,
		debug_level = `1`,
		msg = `EMPTY_KWARG`,
		args,
		kwargs
	)

    Prints the bitwise logging message with the standard basic formatter, which uses by
    default the format: [%(name)s] %(asctime)s:%(msecs)010.6f %(tickDifference).2e %(message)s

    The basic logger format can be configured setting the standard formatter with
    setup() and calling invert() to set the `full_formatter` as
    the basic formatter.

Definition at line 510 of file logger.py.

References Debugger._debugger_level, Debugger._log(), Debugger.active(), and Debugger.basic_formatter.

     def basic(self, debug_level=1, msg=EMPTY_KWARG, *args, **kwargs):
         """
             Prints the bitwise logging message with the standard basic formatter, which uses by
             default the format: [%(name)s] %(asctime)s:%(msecs)010.6f %(tickDifference).2e %(message)s
 
             The basic logger format can be configured setting the standard formatter with
             setup() and calling invert() to set the `full_formatter` as
             the basic formatter.
         """
 
         if type( debug_level ) is int:
 
             if msg is EMPTY_KWARG:
 
                 if self._debugger_level & 1 != 0:
                     other = self.active or self
 
                     old_formatters = {}
                     _acquireLock()
                     try:
                         for handler in other.handlers:
                             old_formatters[handler] = handler.formatter
                             handler.formatter = self.basic_formatter
 
                     finally:
                         _releaseLock()
 
                     kwargs['debug_level'] = 1
                     self._log( DEBUG, debug_level, args, **kwargs )
 
                     for handler, formatter in old_formatters.items():
                         handler.formatter = formatter
 
             elif self._debugger_level & debug_level != 0:
                 other = self.active or self
 
                 old_formatters = {}
                 _acquireLock()
                 try:
                     for handler in other.handlers:
                         old_formatters[handler] = handler.formatter
                         handler.formatter = self.basic_formatter
 
                 finally:
                     _releaseLock()
 
                 kwargs['debug_level'] = debug_level
                 self._log( DEBUG, msg, args, **kwargs )
 
                 for handler, formatter in old_formatters.items():
                     handler.formatter = formatter
 
         else:
 
             if self._debugger_level & 1 != 0:
 
                 if msg is EMPTY_KWARG:
                     other = self.active or self
 
                     old_formatters = {}
                     _acquireLock()
                     try:
                         for handler in other.handlers:
                             old_formatters[handler] = handler.formatter
                             handler.formatter = self.basic_formatter
 
                     finally:
                         _releaseLock()
 
                     kwargs['debug_level'] = 1
                     self._log( DEBUG, debug_level, args, **kwargs )
 
                     for handler, formatter in old_formatters.items():
                         handler.formatter = formatter
 
                 else:
                     other = self.active or self
 
                     old_formatters = {}
                     _acquireLock()
                     try:
                         for handler in other.handlers:
                             old_formatters[handler] = handler.formatter
                             handler.formatter = self.basic_formatter
 
                     finally:
                         _releaseLock()
 
                     kwargs['debug_level'] = 1
                     self._log( DEBUG, debug_level, (msg,) + args, **kwargs )
 
                     for handler, formatter in old_formatters.items():
                         handler.formatter = formatter
 

Here is the call graph for this function:

◆ clean()

def clean	(	self,
		debug_level = `1`,
		msg = `EMPTY_KWARG`,
		args,
		kwargs
	)

    Prints a message without the time prefix as `[plugin_name.py] 11:13:51:0582059`

    How to insert newline in python logging?
    https://stackoverflow.com/questions/20111758/how-to-insert-newline-in-python-logging

Definition at line 397 of file logger.py.

References Debugger._debugger_level, Debugger._log(), Debugger._log_clean(), Debugger.active(), Debugger.basic_formatter, and Debugger.clean_formatter.

     def clean(self, debug_level=1, msg=EMPTY_KWARG, *args, **kwargs):
         """
             Prints a message without the time prefix as `[plugin_name.py] 11:13:51:0582059`
 
             How to insert newline in python logging?
             https://stackoverflow.com/questions/20111758/how-to-insert-newline-in-python-logging
         """
 
         if type( debug_level ) is int:
 
             if msg is EMPTY_KWARG:
 
                 if self._debugger_level & 1 != 0:
                     other = self.active or self
 
                     old_formatters = {}
                     _acquireLock()
                     try:
                         for handler in other.handlers:
                             old_formatters[handler] = handler.formatter
                             handler.formatter = self.clean_formatter
 
                     finally:
                         _releaseLock()
 
                     kwargs['debug_level'] = 1
                     self._log_clean( debug_level, args, kwargs )
 
                     for handler, formatter in old_formatters.items():
                         handler.formatter = formatter
 
             elif self._debugger_level & debug_level != 0:
                 other = self.active or self
 
                 old_formatters = {}
                 _acquireLock()
                 try:
                     for handler in other.handlers:
                         old_formatters[handler] = handler.formatter
                         handler.formatter = self.clean_formatter
 
                 finally:
                     _releaseLock()
 
                 kwargs['debug_level'] = debug_level
                 self._log_clean( msg, args, kwargs )
 
                 for handler, formatter in old_formatters.items():
                     handler.formatter = formatter
 
         else:
 
             if self._debugger_level & 1 != 0:
 
                 if msg is EMPTY_KWARG:
                     other = self.active or self
 
                     old_formatters = {}
                     _acquireLock()
                     try:
                         for handler in other.handlers:
                             old_formatters[handler] = handler.formatter
                             handler.formatter = self.clean_formatter
 
                     finally:
                         _releaseLock()
 
                     kwargs['debug_level'] = 1
                     self._log_clean( debug_level, args, kwargs )
 
                     for handler, formatter in old_formatters.items():
                         handler.formatter = formatter
 
                 else:
                     other = self.active or self
 
                     old_formatters = {}
                     _acquireLock()
                     try:
                         for handler in other.handlers:
                             old_formatters[handler] = handler.formatter
                             handler.formatter = self.clean_formatter
 
                     finally:
                         _releaseLock()
 
                     kwargs['debug_level'] = 1
                     self._log_clean( debug_level, (msg,) + args, kwargs )
 
                     for handler, formatter in old_formatters.items():
                         handler.formatter = formatter
 

Here is the call graph for this function:

◆ clear()

def clear	(	self,
		delete = `False`
	)

    Clear the log file contents.

    @param `delete` if True, the log file will also be removed/deleted and the current file
handler will be removed.

Definition at line 607 of file logger.py.

References Debugger._stderr(), Debugger._stdout(), Debugger.active(), Debugger.handle_stderr(), and CleanLogRecord.name.

Referenced by SleepEvent.sleep().

     def clear(self, delete=False):
         """
             Clear the log file contents.
 
             @param `delete` if True, the log file will also be removed/deleted and the current file
                 handler will be removed.
         """
         active = self.active
 
         if active and active.output_file:
             output_file = active.output_file
             sys.stderr.write( "Cleaning %s (delete=%s) the file: %s\n" % ( self.name, delete, output_file ) )
 
             active._create_file( output_file, active._arguments['rotation'], active._arguments['mode'], True, delete )
             self.handle_stderr( stderr=self._stderr and not delete, stdout=self._stdout and not delete )
 

Here is the call graph for this function:

Here is the caller graph for this function:

◆ debug_level() [1/2]

def debug_level ( self )

    Return this logger active debug level.

Definition at line 202 of file logger.py.

References Debugger._debugger_level.

     def debug_level(self):
         """
             Return this logger active debug level.
         """
         return self._debugger_level
 

◆ debug_level() [2/2]

def debug_level	(	self,
		debug_level
	)

    Set this current logger object active debug level.

Definition at line 209 of file logger.py.

References Debugger._arguments, Debugger._debugger_level, and Debugger.active().

     def debug_level(self, debug_level):
         """
             Set this current logger object active debug level.
         """
 
         if isinstance( debug_level, int ):
             self._debugger_level = debug_level
 
         else:
             raise ValueError( "Error: The debug_level `%s` must be an integer!" % debug_level )
 

Here is the call graph for this function:

◆ deleteAllLoggers()

def deleteAllLoggers ( cls )

    Delete all loggers created by `getLogger()` calls.

Definition at line 1132 of file logger.py.

References Debugger.exception(), CleanLogRecord.name, and Debugger.removeHandlers().

     def deleteAllLoggers(cls):
         """
             Delete all loggers created by `getLogger()` calls.
         """
         _acquireLock()
 
         try:
             cls.manager.loggerDict.clear()
 
         except Exception:
             cls.exception("Could not delete all registered loggers!")
 
         finally:
             _releaseLock()
 

Here is the call graph for this function:

◆ exception()

def exception	(	self,
		msg,
		args,
		kwargs
	)

    Fix second indirection created by the super().error() method, by directly calling _log()

Definition at line 923 of file logger.py.

References Debugger._arguments, Debugger._create_formatter(), Debugger._current_tick, Debugger._last_tick, Debugger._log(), Debugger.active(), Debugger.getFormat(), and CleanLogRecord.name.

Referenced by Debugger.deleteAllLoggers(), Debugger.handle_stderr(), and Debugger.setup().

     def exception(self, msg, *args, **kwargs):
         """
             Fix second indirection created by the super().error() method, by directly calling _log()
         """
         if self.isEnabledFor(ERROR):
             self._log(ERROR, msg, args, exc_info=True, **kwargs)
 

Here is the call graph for this function:

Here is the caller graph for this function:

◆ fix_children()

def fix_children	(	self,
		callable_action
	)

    When automatically creating loggers, some children logger can be setup before the
    parent logger, if the children logger is instantiated on module level and its module
    is imported before the parent logger to be setup.

    Then this will cause the the both parent and child logger to be setup and have handlers
    outputting data to theirs output stream. Hence, here we fix that by disabling the
    children logger when they are setup before the parent logger.

    This method is only called automatically by this module level function `getLogger()`
    when is set to automatically setup the logger. If you are not using the automatic setup
    you do not need to use this function because you should know what you are doing and how
    you should setup your own loggers.

Definition at line 1184 of file logger.py.

References CleanLogRecord.name.

     def fix_children(self, callable_action):
         """
             When automatically creating loggers, some children logger can be setup before the
             parent logger, if the children logger is instantiated on module level and its module
             is imported before the parent logger to be setup.
 
             Then this will cause the the both parent and child logger to be setup and have handlers
             outputting data to theirs output stream. Hence, here we fix that by disabling the
             children logger when they are setup before the parent logger.
 
             This method is only called automatically by this module level function `getLogger()`
             when is set to automatically setup the logger. If you are not using the automatic setup
             you do not need to use this function because you should know what you are doing and how
             you should setup your own loggers.
         """
         loggers = Debugger.manager.loggerDict
         parent_name = self.name
         parent_name_length = len( parent_name )
 
         for logger_name in loggers:
             logger = loggers[logger_name]
 
             if not isinstance( logger, PlaceHolder ):
 
                 # i.e., if logger.parent.name.startswith( parent_name )
                 if logger.parent.name[:parent_name_length] == parent_name:
                     callable_action( logger )
 

◆ get_debug_file_path()

def get_debug_file_path	(	cls,
		file_path
	)

    Reliably detect Windows in Python
    https://stackoverflow.com/questions/1387222/reliably-detect-windows-in-python

    Convert "D:/User/Downloads/debug.txt"
    To "/cygwin/D/User/Downloads/debug.txt"
    To "/mnt/D/User/Downloads/debug.txt"

Definition at line 1213 of file logger.py.

References Debugger.remove_windows_driver_letter().

Referenced by Debugger.setup().

     def get_debug_file_path(cls, file_path):
         """
             Reliably detect Windows in Python
             https://stackoverflow.com/questions/1387222/reliably-detect-windows-in-python
 
             Convert "D:/User/Downloads/debug.txt"
             To "/cygwin/D/User/Downloads/debug.txt"
             To "/mnt/D/User/Downloads/debug.txt"
         """
         is_absolute   = os.path.isabs( file_path )
         platform_info = platform.platform( True ).lower()
 
         if is_absolute \
                 and not file_path.startswith( "/cygdrive/" ) \
                 and "cygwin" in platform_info:
 
             new_output = "/cygdrive/" + cls.remove_windows_driver_letter( file_path )
 
         elif is_absolute \
                 and not file_path.startswith( "/mnt/" ) \
                 and "linux" in platform_info \
                 and "microsoft" in platform_info:
 
             new_output = cls.remove_windows_driver_letter( file_path )
             new_output = "/mnt/" + new_output[0].lower() + new_output[1:]
 
         else:
             new_output = os.path.abspath( file_path )
 
         # print( "Debugger, is_absolute:   %s" % is_absolute )
         # print( "Debugger, new_output:    %s" % new_output )
         # print( "Debugger, isabs:         %s" % str( os.path.isabs( new_output ) ) )
         # print( "Debugger, platform_info: %s" % platform_info )
         return new_output
 

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getRootLogger()

def getRootLogger ( cls )

    Return the main root logger `root_debugger` used by this extension of the standard
    logging module.

Definition at line 1255 of file logger.py.

References Debugger._frame_level.

     def getRootLogger(cls):
         """
             Return the main root logger `root_debugger` used by this extension of the standard
             logging module.
         """
         return cls.root
 

◆ handle_stderr()

def handle_stderr	(	self,
		stderr = `False`,
		stdout = `False`
	)

    Register a exception hook if the logger is capable of logging them to alternate streams.

    @param `stderr` if True, it will enable the logging hook on the sys.stderr.
    @param `stdout` if True, it will enable the logging hook on the sys.stdout.

Definition at line 629 of file logger.py.

References Debugger._debug_level, Debugger._debugme, Debugger._file, Debugger._stream, Debugger.debug_level, Debugger.exception(), Debugger.handle_stderr(), Debugger.hasStreamHandlers(), CleanLogRecord.name, Debugger.removeHandler(), and Debugger.setup().

Referenced by Debugger.addHandler(), Debugger.clear(), Debugger.handle_stderr(), and Debugger.removeHandler().

     def handle_stderr(self, stderr=False, stdout=False):
         """
             Register a exception hook if the logger is capable of logging them to alternate streams.
 
             @param `stderr` if True, it will enable the logging hook on the sys.stderr.
             @param `stdout` if True, it will enable the logging hook on the sys.stdout.
         """
         _acquireLock()
 
         try:
             if self._debugme:
                 sys.stderr.write( "stderr: %s, stdout: %s" % ( stderr, stdout ) )
                 sys.stderr.write( "sys.stderr: %s, sys.stdout: %s" % ( sys.stderr, sys.stdout ) )
                 sys.stderr.write( "name: %s, hasStreamHandlers: %s" % ( self.name, self.hasStreamHandlers() ) )
 
             if stderr:
                 stderr_replacement.lock( self )
             else:
                 stderr_replacement.unlock()
 
             if stdout:
                 stdout_replacement.lock( self )
             else:
                 stdout_replacement.unlock()
 
         except Exception:
             self.exception( "Could not register the sys.stderr stream handler" )
 
         finally:
             _releaseLock()
 

Here is the call graph for this function:

Here is the caller graph for this function:

◆ hasStreamHandlers()

def hasStreamHandlers ( self )

    Return True if the current logger has some stream handler defined.

Definition at line 1171 of file logger.py.

Referenced by Debugger.handle_stderr().

     def hasStreamHandlers(self):
         """
             Return True if the current logger has some stream handler defined.
         """
 
         for handler in self.handlers:
             # print( "Name: %s, handler: %s" % ( self.name, type( handler ) ) )
 
             if "StreamHandler" in str( type( handler ) ):
                 return True
 
         return False
 

Here is the caller graph for this function:

◆ invert()

def invert ( self )

    Inverts the default formatter between the preconfigured `basic` and `full_formatter`.

Definition at line 623 of file logger.py.

References Debugger.basic_formatter, and Debugger.full_formatter.

     def invert(self):
         """
             Inverts the default formatter between the preconfigured `basic` and `full_formatter`.
         """
         self.basic_formatter, self.full_formatter = self.full_formatter, self.basic_formatter
 

◆ makeRecord() [1/2]

def makeRecord	(	self,
		name,
		level,
		fn,
		lno,
		msg,
		args,
		exc_info,
		func = `None`,
		extra = `None`
	)

A factory method which can be overridden in subclasses to create
specialized LogRecords.

Definition at line 1360 of file logger.py.

References Debugger.trimname.

Referenced by Debugger.makeRecord().

         def makeRecord(self, name, level, fn, lno, msg, args, exc_info, func=None, extra=None):
             """
             A factory method which can be overridden in subclasses to create
             specialized LogRecords.
             """
             rv = SmartLogRecord(name[self.trimname:], level, fn, lno, msg, args, exc_info, func)
             if extra is not None:
                 for key in extra:
                     if (key in ["message", "asctime"]) or (key in rv.__dict__):
                         raise KeyError("Attempt to overwrite %r in LogRecord" % key)
                     rv.__dict__[key] = extra[key]
             return rv
 

Here is the caller graph for this function:

◆ makeRecord() [2/2]

def makeRecord	(	self,
		name,
		level,
		fn,
		lno,
		msg,
		args,
		exc_info,
		func = `None`,
		extra = `None`,
		sinfo = `None`
	)

A factory method which can be overridden in subclasses to create
specialized LogRecords.

Definition at line 1375 of file logger.py.

References Debugger.makeRecord(), and Debugger.trimname.

         def makeRecord(self, name, level, fn, lno, msg, args, exc_info, func=None, extra=None, sinfo=None):
             """
             A factory method which can be overridden in subclasses to create
             specialized LogRecords.
             """
             rv = SmartLogRecord(name[self.trimname:], level, fn, lno, msg, args, exc_info, func, sinfo)
             if extra is not None:
                 for key in extra:
                     if (key in ["message", "asctime"]) or (key in rv.__dict__):
                         raise KeyError("Attempt to overwrite %r in LogRecord" % key)
                     rv.__dict__[key] = extra[key]
             return rv
 
 

Here is the call graph for this function:

◆ new_line()

def new_line	(	self,
		debug_level = `1`,
		count = `1`
	)

    Prints a clean new line, without any formatter header.
    @param `count` how many new lines to output

Definition at line 338 of file logger.py.

References Debugger.clean.

     def new_line(self, debug_level=1, count=1):
         """
             Prints a clean new line, without any formatter header.
             @param `count` how many new lines to output
         """
         for index in range(count):
             self.clean( debug_level, "" )
 

◆ newline()

def newline	(	self,
		debug_level = `1`,
		count = `1`
	)

    Prints a clean new line, without any formatter header.
    @param `count` how many new lines to output

Definition at line 330 of file logger.py.

References Debugger.clean.

     def newline(self, debug_level=1, count=1):
         """
             Prints a clean new line, without any formatter header.
             @param `count` how many new lines to output
         """
         for index in range(count):
             self.clean( debug_level, "" )
 

◆ removeHandler()

def removeHandler	(	self,
		handler
	)

    Override the super() method to correctly set up `sys.stderr/stdout` handlers.

    When
    See also logging::Logger::removeHandler().

Definition at line 1102 of file logger.py.

References Debugger._file, Debugger._file_context_filter, Debugger._has_file_context_filter, Debugger._stderr(), Debugger._stdout(), Debugger._stream, and Debugger.handle_stderr().

Referenced by Debugger.handle_stderr(), and Debugger.removeHandlers().

     def removeHandler(self, handler):
         """
             Override the super() method to correctly set up `sys.stderr/stdout` handlers.
 
             When
             See also logging::Logger::removeHandler().
         """
 
         if self._has_file_context_filter:
 
             if not self._stderr and not self._stdout or not self._file or not self._stream:
                 handler.removeFilter( self._file_context_filter )
 
                 self._has_file_context_filter = False
                 _acquireLock()
 
                 try:
                     for other_handler in self.handlers:
                         other_handler.removeFilter( self._file_context_filter )
 
                 finally:
                     _releaseLock()
 
                 self.handle_stderr( self._stderr, self._stdout )
 
             # else: # TODO: Support other this logic also for other handlers and the builtin _stream and _file
 
         super( Debugger, self ).removeHandler( handler )
 

Here is the call graph for this function:

Here is the caller graph for this function:

◆ removeHandlers()

def removeHandlers ( self )

    Delete all handlers registered to the current logger.

Definition at line 1161 of file logger.py.

References Debugger._debugme, Debugger._disable(), CleanLogRecord.name, and Debugger.removeHandler().

Referenced by Debugger.deleteAllLoggers(), and Debugger.reset().

     def removeHandlers(self):
         """
             Delete all handlers registered to the current logger.
         """
         if self._debugme: sys.stderr.write( "Removing all handlers from %s...\n" % self.name )
         self._disable( stream=True, file=True )
 
         for handler in self.handlers:
             self.removeHandler( handler )
 

Here is the call graph for this function:

Here is the caller graph for this function:

◆ reset()

def reset ( self )

    Reset all remembered parameters values set on the subsequent calls to `setup()`.

    Call this if you want to reset to remove all handlers and set all parameters values to
    their default.

Definition at line 280 of file logger.py.

References Debugger._arguments, Debugger._formatter_arguments(), Debugger._reset(), Debugger._setup_formatter(), Debugger.clean_formatter, Debugger.full_formatter, Debugger.removeHandlers(), and Debugger.setup_basic().

     def reset(self):
         """
             Reset all remembered parameters values set on the subsequent calls to `setup()`.
 
             Call this if you want to reset to remove all handlers and set all parameters values to
             their default.
         """
         self.removeHandlers()
         self._reset()
 

Here is the call graph for this function:

◆ setup()

def setup	(	self,
		file = `EMPTY_KWARG`,
		mode = `EMPTY_KWARG`,
		delete = `EMPTY_KWARG`,
		date = `EMPTY_KWARG`,
		levels = `EMPTY_KWARG`,
		function = `EMPTY_KWARG`,
		name = `EMPTY_KWARG`,
		time = `EMPTY_KWARG`,
		msecs = `EMPTY_KWARG`,
		tick = `EMPTY_KWARG`,
		separator = `EMPTY_KWARG`,
		formatter = `EMPTY_KWARG`,
		rotation = `EMPTY_KWARG`,
		kwargs
	)

If `file` parameter is passed, instead of output the debug to the standard output
stream, send it to a file on the file system, which is faster for large outputs.

As this function remembers most of its parameters passed from previous calls, you need to
explicitly pass `file=None` with `delete=True` if you want to disable the file
system output after setting up it to log to a file. See the function Debugger::reset()
for the default parameters values used on this setup utility.

If the parameters `date`, `levels`, `function`, `name`, `time`, `tick` and `msecs` are
nonempty strings, their value will be used to defining their configuration formatting.
For example, if you pass name="%(name)s: " the function name will be displayed as
`name: `, instead of the default `[name] `.

If you change your `sys.stderr` after creating an StreamHandler, you need to pass `handlers=True`
to make it to recreate the StreamHandler because of the old reference to `sys.stderr`.

Single page cheat-sheet about Python string formatting pyformat.info
https://github.com/ulope/pyformat.info

Override a method at instance level
https://stackoverflow.com/questions/394770/override-a-method-at-instance-level

@param `file` a relative or absolute path to the log file. If empty the output
will be sent to the standard output stream.

@param `mode` the file write mode on the file system (default `a`). It can be `a`
to append to the existent file, or `w` to erase the existent file
before start. If the parameter `rotation` is set to non zero, then
this will be an integer value setting how many backups are going to
be keep when doing the file rotation as specified on
logging::handlers::RotatingFileHandler documentation.

@param `delete` if True (default False), it will delete the other handler before
activate the current one, otherwise it will only activate the
selected handler. Useful for enabling multiple handlers
simultaneously.

@param `date` if True, add to the `full_formatter` the date on the format `%Y-%m-%d`.
@param `levels` if True, add to the `full_formatter` the log levels.
@param `function` if True, add to the `full_formatter` the function name.
@param `name` if True, add to the `full_formatter` the logger name.
@param `time` if True, add to the `full_formatter` the time on the format `%H:%M:%S:milliseconds.microseconds`.
@param `msecs` if True, add to the `full_formatter` the current milliseconds on the format ddd,ddddd.
@param `tick` if True, add to the `full_formatter` the time.perf_counter() difference from the last call.
@param `separator` if True, add to the `full_formatter` the a ` - ` to the end of the log record header.
@param `formatter` if not None, replace this `full_formatter` by the logging.Formatter() provided.

@param `rotation` if non zero, creates a RotatingFileHandler with the specified size
in Mega Bytes instead of FileHandler when creating a log file by the
`file` option. See logging::handlers::RotatingFileHandler for more
information. See the parameter `mode` to specify how many files at
most should be created by the rotation algorithm.

@param `handlers` if True (default False), it will force to create the handlers,
even if there are no changes on the current saved default parameters.
Its value is not saved between calls to this setup().

@param `stderr` if True (default True), it will install a listener to the `sys.stderr`
console output. This is useful for logging not handled exceptions.

@param `stdout` if True (default False), it will install a listener to the `sys.stdout`
console output. This is useful for logging all console output to a file.

@param `force` if an integer, set the `debug_level` into all created loggers hierarchy.
Its value is not saved between calls to this setup().

@param `active` if True (default True), it will search for any other active logger in
the current logger hierarchy and do the setup call on him. If no active
logger is found, it will do the setup on the current logger object,
Its value is not saved between calls to this setup().

@param `fast` if True (default False), it will disabled support to log message
calls as `log('message')` and `log(333)`, and it force all log
message calls to respect the format `log(1, message)`. This tradeoff
gains dropping from about 10 seconds to about 7 seconds each
10.000.000 log calls, when the logging debug level is set as
disabled.

@param `stream` (default sys.stderr), an file like object to the StreamHandler use
to print things when outputting results.

@param `trimname` (default 0), Remove these nth characters from the logger name
while creating the log record to print on the screen. Useful to keep
several loggers grouped together but hide their parent.

Definition at line 703 of file logger.py.

References Debugger.__class__, Debugger._arguments, Debugger._configure_force(), Debugger._create_file(), Debugger._disable(), Debugger._fast_basic(), Debugger._fast_clean(), Debugger._file, Debugger._get_time_prefix(), Debugger._old_basic, Debugger._old_clean, Debugger._setup(), Debugger._setup_fast_loggers(), Debugger._stream, Debugger.active(), Debugger.addHandler(), Debugger.basic, Debugger.clean, Debugger.exception(), Debugger.full_formatter, Debugger.get_debug_file_path(), and Debugger.trimname.

Referenced by Debugger.handle_stderr().

             separator=EMPTY_KWARG, formatter=EMPTY_KWARG, rotation=EMPTY_KWARG, **kwargs):
         """
             If `file` parameter is passed, instead of output the debug to the standard output
             stream, send it to a file on the file system, which is faster for large outputs.
 
             As this function remembers most of its parameters passed from previous calls, you need to
             explicitly pass `file=None` with `delete=True` if you want to disable the file
             system output after setting up it to log to a file. See the function Debugger::reset()
             for the default parameters values used on this setup utility.
 
             If the parameters `date`, `levels`, `function`, `name`, `time`, `tick` and `msecs` are
             nonempty strings, their value will be used to defining their configuration formatting.
             For example, if you pass name="%(name)s: " the function name will be displayed as
             `name: `, instead of the default `[name] `.
 
             If you change your `sys.stderr` after creating an StreamHandler, you need to pass `handlers=True`
             to make it to recreate the StreamHandler because of the old reference to `sys.stderr`.
 
             Single page cheat-sheet about Python string formatting pyformat.info
             https://github.com/ulope/pyformat.info
 
             Override a method at instance level
             https://stackoverflow.com/questions/394770/override-a-method-at-instance-level
 
             @param `file`       a relative or absolute path to the log file. If empty the output
                                 will be sent to the standard output stream.
 
             @param `mode`       the file write mode on the file system (default `a`). It can be `a`
                                 to append to the existent file, or `w` to erase the existent file
                                 before start. If the parameter `rotation` is set to non zero, then
                                 this will be an integer value setting how many backups are going to
                                 be keep when doing the file rotation as specified on
                                 logging::handlers::RotatingFileHandler documentation.
 
             @param `delete`     if True (default False), it will delete the other handler before
                                 activate the current one, otherwise it will only activate the
                                 selected handler. Useful for enabling multiple handlers
                                 simultaneously.
 
             @param `date`       if True, add to the `full_formatter` the date on the format `%Y-%m-%d`.
             @param `levels`      if True, add to the `full_formatter` the log levels.
             @param `function`   if True, add to the `full_formatter` the function name.
             @param `name`       if True, add to the `full_formatter` the logger name.
             @param `time`       if True, add to the `full_formatter` the time on the format `%H:%M:%S:milliseconds.microseconds`.
             @param `msecs`      if True, add to the `full_formatter` the current milliseconds on the format ddd,ddddd.
             @param `tick`       if True, add to the `full_formatter` the time.perf_counter() difference from the last call.
             @param `separator`  if True, add to the `full_formatter` the a ` - ` to the end of the log record header.
             @param `formatter`  if not None, replace this `full_formatter` by the logging.Formatter() provided.
 
             @param `rotation`   if non zero, creates a RotatingFileHandler with the specified size
                                 in Mega Bytes instead of FileHandler when creating a log file by the
                                 `file` option. See logging::handlers::RotatingFileHandler for more
                                 information. See the parameter `mode` to specify how many files at
                                 most should be created by the rotation algorithm.
 
             @param `handlers`   if True (default False), it will force to create the handlers,
                                 even if there are no changes on the current saved default parameters.
                                 Its value is not saved between calls to this setup().
 
             @param `stderr`     if True (default True), it will install a listener to the `sys.stderr`
                                 console output. This is useful for logging not handled exceptions.
 
             @param `stdout`     if True (default False), it will install a listener to the `sys.stdout`
                                 console output. This is useful for logging all console output to a file.
 
             @param `force`      if an integer, set the `debug_level` into all created loggers hierarchy.
                                 Its value is not saved between calls to this setup().
 
             @param `active`     if True (default True), it will search for any other active logger in
                                 the current logger hierarchy and do the setup call on him. If no active
                                 logger is found, it will do the setup on the current logger object,
                                 Its value is not saved between calls to this setup().
 
             @param `fast`       if True (default False), it will disabled support to log message
                                 calls as `log('message')` and `log(333)`, and it force all log
                                 message calls to respect the format `log(1, message)`. This tradeoff
                                 gains dropping from about 10 seconds to about 7 seconds each
                                 10.000.000 log calls, when the logging debug level is set as
                                 disabled.
 
             @param `stream`     (default sys.stderr), an file like object to the StreamHandler use
                                 to print things when outputting results.
 
             @param `trimname` (default 0), Remove these nth characters from the logger name
                                 while creating the log record to print on the screen. Useful to keep
                                 several loggers grouped together but hide their parent.
         """
         self._setup( file=file, mode=mode, delete=delete, date=date, levels=levels,
                 function=function, name=name, time=time, msecs=msecs, tick=tick,
                 separator=separator, formatter=formatter, rotation=rotation, **kwargs )
 

Here is the call graph for this function:

Here is the caller graph for this function:

◆ setup_basic()

def setup_basic	(	self,
		kwargs
	)

    Configure the `basic_formatter` used by `basic()` logging function.

    @param `**kwargs` the same formatting arguments passed to `setup()`

Definition at line 297 of file logger.py.

References Debugger._formatter_arguments(), Debugger._setup_formatter(), and Debugger.basic_formatter.

Referenced by Debugger.reset().

     def setup_basic(self, **kwargs):
         """
             Configure the `basic_formatter` used by `basic()` logging function.
 
             @param `**kwargs` the same formatting arguments passed to `setup()`
         """
         basic_arguments = self._formatter_arguments()
         basic_arguments.update( kwargs )
         self.basic_formatter = self._setup_formatter( basic_arguments )
 

Here is the call graph for this function:

Here is the caller graph for this function:

◆ traceback()

def traceback	(	self,
		kwargs
	)

    Prints the stack trace (traceback) until the current function call.

Definition at line 273 of file logger.py.

References Debugger._log().

     def traceback(self, **kwargs):
         """
             Prints the stack trace (traceback) until the current function call.
         """
         kwargs['debug_level'] = 1
         self._log( DEBUG, "traceback.format_stack():\n%s\n\n", "".join( traceback.format_stack() ) )
 

Here is the call graph for this function:

◆ warn()

def warn	(	self,
		msg,
		args,
		kwargs
	)

    Fix second indirection created by the super().warn() method, by directly calling _log()

Definition at line 915 of file logger.py.

References Debugger._log().

     def warn(self, msg, *args, **kwargs):
         """
             Fix second indirection created by the super().warn() method, by directly calling _log()
         """
 
         if self.isEnabledFor( WARNING ):
             self._log( WARNING, msg, args, **kwargs )
 

Here is the call graph for this function:

The documentation for this class was generated from the following file:

logger.py

Public Member Functions

Static Public Member Functions

Public Attributes

Detailed Description

Constructor & Destructor Documentation

◆ __init__()

Member Function Documentation

◆ __call__()

◆ active()

◆ addHandler()

◆ basic()

◆ clean()

◆ clear()

◆ debug_level() [1/2]

◆ debug_level() [2/2]

◆ deleteAllLoggers()

◆ exception()

◆ fix_children()

◆ get_debug_file_path()

◆ getRootLogger()

◆ handle_stderr()

◆ hasStreamHandlers()

◆ invert()

◆ makeRecord() [1/2]

◆ makeRecord() [2/2]

◆ new_line()

◆ newline()

◆ removeHandler()

◆ removeHandlers()

◆ reset()

◆ setup()

◆ setup_basic()

◆ traceback()

◆ warn()

◆ init()

◆ call()