MessageFilters.py

Go to the documentation of this file.

#
# Copyright 2020, 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 typing import Optional, Sequence
from enum import Enum
import re
 
# We need to prevent reloading this module, as otherwise comparisons for MessageType and MessageHandling actually fail if auto-reloading of
# python modules is enabled.
if "___HasLoadedMessageFilters" not in globals():
  
  ___HasLoadedMessageFilters = True
  
  STRIP_HTML_TAGS_REGEXP = re.compile('<[^>]*>')
 
  class MessageType( Enum ):
    INFO    = 0
    WARNING = 1
    ERROR   = 2
    
  class MessageHandling( Enum ):
    NONE   = 0
    EXPECT = 1
    IGNORE = 2
  
  
  class MessageFilter( object ):
    """
    Base class to implement filters for specific log messages, allowing e.g. to expect or ignore errors.
    """
  
    _typeIdentifiers:Sequence[str] = ()
    _messageType:MessageType
    
    def __init__( self, handling:MessageHandling, regEx:Optional[str] ):
      if isinstance( regEx, str ):
        regEx = re.compile( regEx )    
      self.__regEx__regEx = regEx
      self.__handling__handling = handling
      self.hadMatchhadMatch = False
      self.hadNonMatchhadNonMatch = False
      
    def match( self, messageText:str ) -> bool:
      """
      Returns True if the given messageText matches the regex, and also updates the fields
      hadMatch and hadNonMatch
      """
      match = self.__isMatch__isMatch( messageText )
      self.hadMatchhadMatch |= match
      self.hadNonMatchhadNonMatch |= not match
      return match
    
    def __isMatch( self, messageText:str ) -> bool:
      if self.__regEx__regEx:
        strippedMessageText = STRIP_HTML_TAGS_REGEXP.sub('', messageText)        
        return ( self.__regEx__regEx.match( strippedMessageText ) != None )
      return True
    
    def getTypePostfix( self ) -> str:
      """
      Returns the suitable postfix shown in the test report for the message type based on 
      self.__handling
      """
      #print( self.__handling, MessageHandling.EXPECT, self.__handling.__class__, MessageHandling.EXPECT.__class__, id( self.__handling ), id( MessageHandling.EXPECT) )
      postFix = ""
      if self.__handling__handling == MessageHandling.IGNORE:
        postFix = " (ignored)"
      elif self.__handling__handling == MessageHandling.EXPECT:
        postFix = " (expected)"
      return postFix    
    
    def __eq__( self, other ) -> bool:    
      return isinstance( other, self.__class__ ) and \
             self.__regEx__regEx == other.__regEx and \
             self._messageType_messageType == other._messageType and \
             self.__handling__handling == other.__handling
            
    @classmethod
    def GetMessageType( cls ) -> MessageType:
      return cls._messageType_messageType
      
      
    @classmethod
    def IsTypeMatch( cls, typeString:str ) -> bool:
      """
      Returns True if any of the classes' type identifiers (e.g. 'cerr') occurs in the given typeString.
      Note that the check is case insensitive.
      """
      for t in cls._typeIdentifiers:
        if t in typeString.lower():
          return True
      return False  
  
  
  class ErrorMessageFilter( MessageFilter ):
    """
    Filter for error messages
    """
    _typeIdentifiers = ( "error", "cerr" )  
    _messageType = MessageType.ERROR  
    def __init__( self, handling:MessageHandling, regEx:Optional[str] ): 
      super().__init__( handling, regEx )
  
  class WarningMessageFilter( MessageFilter ):
    """
    Filter for warning messages
    """
    _typeIdentifiers = ( "warning", )
    _messageType = MessageType.WARNING
    def __init__( self, handling:MessageHandling, regEx:Optional[str] ): 
      super().__init__( handling, regEx )
  
  class InfoMessageFilter( MessageFilter ):
    """
    Filter for info messages
    """  
    _typeIdentifiers = ( "info", "cout", "other")
    _messageType = MessageType.INFO  
    def __init__( self, handling:MessageHandling, regEx:Optional[str] ): 
      super().__init__( handling, regEx )