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
            self.__handling = handling
            self.hadMatch = False
            self.hadNonMatch = False
            self.allowUnexpectedMessages = 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(messageText)
            self.hadMatch |= match
            self.hadNonMatch |= not match
            return match
 
        def __isMatch(self, messageText: str) -> bool:
            if self.__regEx:
                strippedMessageText = STRIP_HTML_TAGS_REGEXP.sub("", messageText)
                return self.__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 == MessageHandling.IGNORE:
                postFix = " (ignored)"
            elif self.__handling == MessageHandling.EXPECT:
                postFix = " (expected)"
            return postFix
 
        def __eq__(self, other) -> bool:
            return (
                isinstance(other, self.__class__)
                and self.__regEx == other.__regEx
                and self._messageType_messageType == other._messageType
                and self.__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], allowUnexpectedMessages: bool):
            super().__init__(handling, regEx)
            self.allowUnexpectedMessagesallowUnexpectedMessages = allowUnexpectedMessages