Logging.py

Go to the documentation of this file.

#
# Copyright 2009, MeVis Medical Solutions AG
#
# The user may use this file in accordance with the license agreement provided with
# the Software or, alternatively, in accordance with the terms contained in a
# written agreement between the user and MeVis Medical Solutions AG.
#
# For further information use the contact form at https://www.mevislab.de/contact
#
 
from builtins import str
 
# Already ported to Python 3
 
 
# -- system imports ----------------------------------------------------------------------------{{{-
import os
import sys
import traceback
# ----------------------------------------------------------------------------------------------}}}-
 
# -- local imports -----------------------------------------------------------------------------{{{-
import mevis
 
from TestSupport.TestHelper import TestHelper, CancelTestException, emitSpecialMessage, emitSpecialCommand
import TestSupport.TestHelper
 
# ----------------------------------------------------------------------------------------------}}}-
 
# Global flag to stop on first error that occurs, indicated by gStopped.
gStopOnFirstError = False
# Global flag that stores if the test should be stopped right now.
gStopped = False
 
def setStopped(stopped):
  global gStopped
  gStopped = stopped
 
# -- def LoggingDecorator ----------------------------------------------------------------------{{{-
# @cond
 
def LoggingDecorator (func):
  def wrapper (*args, **kwds):
    loggingMethod, message, type, depth, escapeHtml = func(*args, **kwds)
    isInfoMessage = loggingMethod == mevis.MLAB.logHTML
    if TestSupport.TestHelper.gLogInfoMessages or not isInfoMessage:
      message = str(message)
      if TestHelper.getInstance().hasCallerStackFrame():
        callerStackFrame = TestHelper.getInstance().getCallerStackFrame()
      else:
        callerStackFrame = sys._getframe(1 + depth)
      if isInfoMessage:
        stackLine = traceback.extract_stack(callerStackFrame, 1)[0]
        formattedStack = ''
      else:
        stackTrace = traceback.extract_stack(callerStackFrame)
        # Skip test runner traceback levels
        for i, frame in enumerate(stackTrace):
          if frame[2] == '__callTestFunction':
            stackTrace = stackTrace[i+1:]
            break
        stackLine = stackTrace[-1]
        formattedStack = ''.join(traceback.format_list(stackTrace))
      emitSpecialMessage(loggingMethod, stackLine[0], stackLine[1], type, message, escapeHtml, formattedStack)
 
    if gStopOnFirstError and gStopped:
      raise CancelTestException
  return wrapper
# @endcond
# ----------------------------------------------------------------------------------------------}}}-
 
# -- def info ----------------------------------------------------------------------------------{{{-
 
@LoggingDecorator
def info (message, stack=False, type='', depth=0):
  if stack:
    mevis.MLAB.logError("The stack option is deprecated!")
  return mevis.MLAB.logHTML, message, type, depth, True
# ----------------------------------------------------------------------------------------------}}}-
 
# -- def infoHTML ----------------------------------------------------------------------------------{{{-
 
@LoggingDecorator
def infoHTML (message, type='', depth=0):
  return mevis.MLAB.logHTML, message, type, depth, False
# ----------------------------------------------------------------------------------------------}}}-
 
# -- def warning -------------------------------------------------------------------------------{{{-
 
@LoggingDecorator
def warning (message, stack=False, type='', depth=0):
  if stack:
    mevis.MLAB.logError("The stack option is deprecated!")
  return mevis.MLAB.logWarningHTML, message, type, depth, True
# ----------------------------------------------------------------------------------------------}}}-
 
# -- def warningHTML -------------------------------------------------------------------------------{{{-
 
@LoggingDecorator
def warningHTML (message, type='', depth=0):
  return mevis.MLAB.logWarningHTML, message, type, depth, False
# ----------------------------------------------------------------------------------------------}}}-
 
 
# -- def error ---------------------------------------------------------------------------------{{{-
 
@LoggingDecorator
def error (message, stack=False, type='', depth=0):
  if stack:
    mevis.MLAB.logError("The stack option is deprecated!")
  return mevis.MLAB.logErrorHTML, message, type, depth, True
# ----------------------------------------------------------------------------------------------}}}-
 
# -- def errorHTML ---------------------------------------------------------------------------------{{{-
 
@LoggingDecorator
def errorHTML (message, type='', depth=0):
  return mevis.MLAB.logErrorHTML, message, type, depth, False
# ----------------------------------------------------------------------------------------------}}}-
 
 
# -- def showImage -----------------------------------------------------------------------------{{{-
 
def showImage (description, *files):
  fileList = []
  for filename in files:
    if not os.path.isfile(filename):
      error("Image (%s) does not exist" % (filename), depth=1)
    else:
      hash = Base_getHash(filename)
      fileList.append("%s|%s" % (hash, filename))
  if len(fileList) == 0:
    error("No images given!", depth=1)
  else:
    stackLine = traceback.extract_stack(sys._getframe(1), 1)[0]
    emitSpecialCommand(stackLine[0], stackLine[1], "ImageShow", fileList, description)
# ----------------------------------------------------------------------------------------------}}}-
 
# -- def showFile ------------------------------------------------------------------------------{{{-
 
def showFile (description, *files):
  fileList = []
  for filename in files:
    if not os.path.isfile(filename):
      error("File (%s) does not exist" % (filename), depth=1)
    else:
      hash = Base_getHash(filename)
      fileList.append("%s|%s" % (hash, filename))
  if len(fileList) == 0:
    error("No files given!", depth=1)
  else:
    stackLine = traceback.extract_stack(sys._getframe(1), 1)[0]
    emitSpecialCommand(stackLine[0], stackLine[1], "FileShow", fileList, description)
# ----------------------------------------------------------------------------------------------}}}-
 
# -- def showDiff ------------------------------------------------------------------------------{{{-
 
def showDiff (description, fromLines, toLines, showOnlyContextOfDiff=False, numberOfContextLines=10):
  if type(fromLines) != list:
    with open(fromLines) as fh:
      fromLines = fh.readlines()
  if type(toLines) != list:
    with open(toLines) as fh:
      toLines = fh.readlines()
  diff = Base_createHtmlDiff(fromLines, toLines, showOnlyContextOfDiff, numberOfContextLines)
  baseDiffFileName = os.path.join(Base_getResultDirectory(), "diff%s.html")
  diffFileName = baseDiffFileName % ""
  i = 0
  while os.path.exists(diffFileName):
    i += 1
    diffFileName = baseDiffFileName % i
  if not os.path.exists(Base_getResultDirectory()):
    os.makedirs(Base_getResultDirectory())
  with open(diffFileName, "w") as f:
    f.write(diff)
  showFile(description, diffFileName)
# ----------------------------------------------------------------------------------------------}}}-
 
# -- def getStack ------------------------------------------------------------------------------{{{-
 
def getStack (depth=0):
  content = ""
  for line in traceback.extract_stack(sys._getframe(2+depth)):
    content += "[[%s][%d][%s][%s]]" % (line[0], line[1], line[2], line[3])
  return "##S[%s]" % (content)
# ----------------------------------------------------------------------------------------------}}}-
 
from .Base import getResultDirectory as Base_getResultDirectory, createHtmlDiff as Base_createHtmlDiff, getHash as Base_getHash