arelle-release 2.17.1__py3-none-any.whl → 2.37.71__py3-none-any.whl

arelle/Cntlr.py

@@ -9,18 +9,33 @@
    :synopsis: Common controller class to initialize for platform and setup common logger functions
 """
 from __future__ import annotations
-from typing import Any, TYPE_CHECKING, TextIO, Mapping
 
+import gettext
+import io
+import json
+import logging
+import os
+import subprocess
+import sys
+import tempfile
+from typing import TYPE_CHECKING, Any, cast
+
+import regex
+
+from arelle import Locale, ModelManager, PackageManager, PluginManager, XbrlConst
 from arelle.BetaFeatures import BETA_FEATURES_AND_DESCRIPTIONS
+from arelle.ErrorManager import ErrorManager
+from arelle.FileSource import FileSource
+from arelle.logging.formatters.LogFormatter import LogFormatter, logRefsFileLines  # noqa: F401 - for reimport
+from arelle.logging.handlers.LogHandlerWithXml import LogHandlerWithXml  # noqa: F401 - for reimport
+from arelle.logging.handlers.LogToBufferHandler import LogToBufferHandler
+from arelle.logging.handlers.LogToPrintHandler import LogToPrintHandler
+from arelle.logging.handlers.LogToXmlHandler import LogToXmlHandler
+from arelle.logging.handlers.StructuredMessageLogHandler import StructuredMessageLogHandler
+from arelle.SystemInfo import PlatformOS, getSystemWordSize, hasFileSystem, hasWebServer, isCGI, isGAE
 from arelle.typing import TypeGetText
-import tempfile, os, io, sys, logging, gettext, json, subprocess, math
-import regex as re
-from arelle import ModelManager
+from arelle.utils.PluginData import PluginData
 from arelle.WebCache import WebCache
-from arelle.Locale import getLanguageCodes, setDisableRTL
-from arelle import PluginManager, PackageManager, XbrlConst
-from arelle.SystemInfo import PlatformOS, getSystemWordSize, hasFileSystem, isCGI, isGAE, hasWebServer
-from collections import defaultdict
 
 _: TypeGetText
 
@@ -45,7 +60,7 @@ def resourcesDir() -> str:
     # for python 3.2 remove __pycache__
     if _moduleDir.endswith("__pycache__"):
         _moduleDir = os.path.dirname(_moduleDir)
-    if (re.match(r".*[\\/](library|python{0.major}{0.minor}).zip[\\/]arelle$".format(sys.version_info),
+    if (regex.match(r".*[\\/](library|python{0.major}{0.minor}).zip[\\/]arelle$".format(sys.version_info),
                    _moduleDir)): # cx_Freexe uses library up to 3.4 and python35 after 3.5
         _resourcesDir = os.path.dirname(os.path.dirname(_moduleDir))
     else:
@@ -110,6 +125,7 @@ class Cntlr:
     """
     __version__ = "1.6.0"
     betaFeatures: dict[str, bool]
+    errorManager: ErrorManager | None
     hasWin32gui: bool
     hasGui: bool
     hasFileSystem: bool
@@ -117,7 +133,6 @@ class Cntlr:
     isCGI: bool
     systemWordSize: int
     uiLang: str
-    uiLangDir: str
     configDir: str
     imagesDir: str
     localeDir: str
@@ -146,12 +161,14 @@ class Cntlr:
         disable_persistent_config: bool = False,
         betaFeatures: dict[str, bool] | None = None
     ) -> None:
+        self.logger = None
         if betaFeatures is None:
             betaFeatures = {}
         self.betaFeatures = {
             b: betaFeatures.get(b, False)
             for b in BETA_FEATURES_AND_DESCRIPTIONS.keys()
         }
+        self.errorManager = None
         self.hasWin32gui = False
         self.hasGui = hasGui
         self.hasFileSystem = hasFileSystem() # no file system on Google App Engine servers
@@ -161,7 +178,7 @@ class Cntlr:
         self.isMac = platformOS == PlatformOS.MACOS
         self.isMSW = platformOS == PlatformOS.WINDOWS
         self.systemWordSize = getSystemWordSize()  # e.g., 32 or 64
-        self.uiLangDir = "ltr"
+        self._uiLocale: str | None = None
         self.disablePersistentConfig = disable_persistent_config
 
         # sys.setrecursionlimit(10000) # 1000 default exceeded in some inline documents
@@ -171,6 +188,7 @@ class Cntlr:
         self.imagesDir = os.path.join(_resourcesDir, "images")
         self.localeDir = os.path.join(_resourcesDir, "locale")
         self.pluginDir = os.path.join(_resourcesDir, "plugin")
+        self.__pluginData: dict[str, PluginData] = {}
         if cxFrozen:
             # some cx_freeze versions set this variable, which is incompatible with matplotlib after v3.1
             os.environ.pop("MATPLOTLIBDATA", None)
@@ -247,8 +265,7 @@ class Cntlr:
         # assert that app dir must exist
         self.config = None
         if self.hasFileSystem and not self.disablePersistentConfig:
-            if not os.path.exists(self.userAppDir):
-                os.makedirs(self.userAppDir)
+            os.makedirs(self.userAppDir, exist_ok=True)
             # load config if it exists
             self.configJsonFile = self.userAppDir + os.sep + "config.json"
             if os.path.exists(self.configJsonFile):
@@ -265,7 +282,7 @@ class Cntlr:
 
         # start language translation for domain
         self.setUiLanguage(uiLang or self.config.get("userInterfaceLangOverride",None), fallbackToDefault=True)
-        setDisableRTL(self.config.get('disableRtl', False))
+        Locale.setDisableRTL(self.config.get('disableRtl', False))
 
         self.webCache = WebCache(self, self.config.get("proxySettings"))
 
@@ -279,6 +296,44 @@ class Cntlr:
         PackageManager.init(self, loadPackagesConfig=hasGui)
 
         self.startLogging(logFileName, logFileMode, logFileEncoding, logFormat)
+        self.errorManager = ErrorManager(self.modelManager, logging._checkLevel("INCONSISTENCY")) # type: ignore[attr-defined]
+
+    def error(self, codes: Any, msg: str, level: str = "ERROR", fileSource: FileSource | None = None, **args: Any) -> None:
+        if self.logger is None or self.errorManager is None:
+            self.addToLog(
+                message=msg,
+                messageCode=str(codes),
+                messageArgs=args,
+                level=level
+            )
+            return
+        self.errorManager.log(
+            self.logger,
+            level,
+            codes,
+            msg,
+            fileSource=fileSource,
+            logRefObjectProperties=getattr(self.logger, "logRefObjectProperties", False),
+            **args
+        )
+
+    @property
+    def errors(self) -> list[str | None]:
+        if self.errorManager is None:
+            return []
+        return self.errorManager.errors
+
+    @property
+    def uiLangDir(self) -> str:
+        return 'rtl' if getattr(self, 'uiLang', '')[0:2].lower() in {"ar", "he"} else 'ltr'
+
+    @property
+    def uiLocale(self) -> str | None:
+        return self._uiLocale
+
+    @uiLocale.setter
+    def uiLocale(self, uiLocale: str | None) -> None:
+        self._uiLocale = Locale.findCompatibleLocale(uiLocale)
 
     def postLoggingInit(self, localeSetupMessage: str | None = None) -> None:
         if not self.modelManager.isLocaleSet:
@@ -291,29 +346,18 @@ class Cntlr:
             pluginMethod(self)
 
     def setUiLanguage(self, locale: str | None, fallbackToDefault: bool = False) -> None:
+        langCodes = Locale.getLanguageCodes(locale)
         try:
-            self.uiLocale = locale
-            langCodes = getLanguageCodes(locale)
-            gettext.translation("arelle",
-                                self.localeDir,
-                                langCodes).install()
+            gettext.translation("arelle", self.localeDir, langCodes).install()
             self.uiLang = langCodes[0]
-            if not locale and self.uiLang:
-                self.uiLocale = self.uiLang
-            self.uiLangDir = 'rtl' if self.uiLang[0:2].lower() in {"ar","he"} else 'ltr'
-        except Exception as ex:
-            if fallbackToDefault and not locale and langCodes:
+        except OSError:
+            if fallbackToDefault and not locale:
                 locale = langCodes[0]
-            if fallbackToDefault or (locale and locale.lower().startswith("en")):
-                if locale and len(locale) == 5 and locale.lower().startswith("en"):
-                    self.uiLang = locale # may be en other than defaultLocale
-                else:
-                    self.uiLang = XbrlConst.defaultLocale # must work with gettext or will raise an exception
-                if not self.uiLocale:
-                    self.uiLocale = self.uiLang
-                self.uiLangDir = "ltr"
-                gettext.install("arelle",
-                                self.localeDir)
+            isEnglishLocale = locale and locale.lower().startswith('en')
+            if fallbackToDefault or isEnglishLocale:
+                self.uiLang = cast(str, locale) if isEnglishLocale else XbrlConst.defaultLocale
+                gettext.install("arelle", self.localeDir)
+        self.uiLocale = locale or getattr(self, "uiLang", None)
 
     def startLogging(
         self,
@@ -322,11 +366,16 @@ class Cntlr:
         logFileEncoding:str | None = None,
         logFormat: str | None = None,
         logLevel: str | None = None,
+        logFilters: list[logging.Filter] | None = None,
         logHandler: logging.Handler | None = None,
         logToBuffer: bool = False,
         logTextMaxLength: int | None = None,
-        logRefObjectProperties: bool = True
+        logRefObjectProperties: bool = True,
+        logXmlMaxAttributeLength: int | None = None,
+        logPropagate: bool | None = None,
     ) -> None:
+        if logFilters is None:
+            logFilters = []
         # add additional logging levels (for python 2.7, all of these are ints)
         logging.addLevelName(logging.INFO - 1, "INFO-RESULT") # result data, has @name, @value, optional href to source and readable message
         logging.addLevelName(logging.INFO + 1, "INFO-SEMANTIC")
@@ -347,8 +396,15 @@ class Cntlr:
             elif logFileName == "logToBuffer":
                 self.logHandler = LogToBufferHandler()
                 setattr(self.logger, "logRefObjectProperties", logRefObjectProperties)
+            elif logFileName == "logToStructuredMessage":
+                self.logHandler = StructuredMessageLogHandler()
+                setattr(self.logger, "logRefObjectProperties", logRefObjectProperties)
             elif logFileName.endswith(".xml") or logFileName.endswith(".json") or logToBuffer:
-                self.logHandler = LogToXmlHandler(filename=logFileName, mode=logFileMode or "a")  # should this be "w" mode??
+                self.logHandler = LogToXmlHandler(
+                    filename=logFileName,
+                    mode=logFileMode or "a",
+                    logXmlMaxAttributeLength=logXmlMaxAttributeLength
+                )  # should this be "w" mode??
                 setattr(self.logger, "logRefObjectProperties", logRefObjectProperties)
                 if not logFormat:
                     logFormat = "%(message)s"
@@ -361,6 +417,10 @@ class Cntlr:
         else:
             self.logger = None
         if self.logger:
+            if logPropagate is not None:
+                self.logger.propagate = logPropagate
+            for logFilter in logFilters:
+                self.logger.addFilter(logFilter)
             try:
                 self.logger.setLevel((logLevel or "debug").upper())
             except ValueError:
@@ -375,11 +435,11 @@ class Cntlr:
 
     def setLogLevelFilter(self, logLevelFilter: str) -> None:
         if self.logger:
-            setattr(self.logger, "messageLevelFilter", re.compile(logLevelFilter) if logLevelFilter else None)
+            setattr(self.logger, "messageLevelFilter", regex.compile(logLevelFilter) if logLevelFilter else None)
 
     def setLogCodeFilter(self, logCodeFilter: str) -> None:
         if self.logger:
-            setattr(self.logger, "messageCodeFilter", re.compile(logCodeFilter) if logCodeFilter else None)
+            setattr(self.logger, "messageCodeFilter", regex.compile(logCodeFilter) if logCodeFilter else None)
 
     def addToLog(
         self,
@@ -614,383 +674,27 @@ class Cntlr:
         if not self.webCache.workOffline:
             # Working online, can proceed regardless of presence in cache
             return True
-        cacheFilepath = self.webCache.urlToCacheFilepath(url)
-        if os.path.exists(cacheFilepath):
-            # The file exists in cache, we can proceed despite working offline
-            return True
+        cacheDirs = (self.webCache.cacheDir, self.webCache.builtInCacheDir)
+        for cacheDir in cacheDirs:
+            cacheFilepath = self.webCache.urlToCacheFilepath(url, cacheDir=cacheDir)
+            normalizedCacheFilepath = self.webCache.normalizeFilepath(cacheFilepath, url)
+            if os.path.exists(normalizedCacheFilepath):
+                # The file exists in cache, we can proceed despite working offline
+                return True
         return False
 
+    def getPluginData(self, pluginName: str) -> PluginData | None:
+        return self.__pluginData.get(pluginName)
 
-def logRefsFileLines(refs: list[dict[str, Any]]) -> str:
-    fileLines: defaultdict[Any, set[str]] = defaultdict(set)
-    for ref in refs:
-        href = ref.get("href")
-        if href:
-            fileLines[href.partition("#")[0]].add(ref.get("sourceLine", 0))
-    return ", ".join(file + " " + ', '.join(str(line)
-                                            for line in sorted(lines, key=lambda l: l)
-                                            if line)
-                    for file, lines in sorted(fileLines.items()))
-
-class LogFormatter(logging.Formatter):
-    def __init__(self, fmt: str | None = None, datefmt: str | None = None) -> None:
-        super(LogFormatter, self).__init__(fmt, datefmt)
-
-    def fileLines(self, record: logging.LogRecord) -> str:
-        # provide a file parameter made up from refs entries
-        return logRefsFileLines(getattr(record, "refs", []))
-
-    def format(self, record: logging.LogRecord) -> str:
-        record.file = self.fileLines(record)
-        try:
-            formattedMessage = super(LogFormatter, self).format(record)
-        except (KeyError, TypeError, ValueError) as ex:
-            formattedMessage = "Message: "
-            if getattr(record, "messageCode", ""):
-                formattedMessage += "[{0}] ".format(getattr(record, "messageCode", ""))
-            if getattr(record, "msg", ""):
-                formattedMessage += record.msg + " "
-            if isinstance(record.args, dict) and 'error' in record.args: # args may be list or empty
-                formattedMessage += record.args['error']
-            formattedMessage += " \nMessage log error: " + str(ex)
-        if hasattr(record, "file"):
-            delattr(record, "file")
-        return formattedMessage
-
-class LogToPrintHandler(logging.Handler):
-    """
-    .. class:: LogToPrintHandler()
-
-    A log handler that emits log entries to standard out as they are logged.
-
-    CAUTION: Output is utf-8 encoded, which is fine for saving to files, but may not display correctly in terminal windows.
-
-    :param logOutput: 'logToStdErr' to cause log print to stderr instead of stdout
-    :type logOutput: str
-    """
-    logFile: str | TextIO | None
-
-    def __init__(self, logOutput: str) -> None:
-        super(LogToPrintHandler, self).__init__()
-        if logOutput == "logToStdErr":
-            self.logFile = sys.stderr
-        else:
-            self.logFile = None
+    def setPluginData(self, pluginData: PluginData) -> None:
+        if pluginData.name in self.__pluginData:
+            raise RuntimeError(f"PluginData already set on Cntlr for {pluginData.name}.")
+        self.__pluginData[pluginData.name] = pluginData
 
-    def emit(self, logRecord: logging.LogRecord) -> None:
-        file = sys.stderr if self.logFile else None
-        logEntry = self.format(logRecord)
-        try:
-            print(logEntry, file=file)
-        except UnicodeEncodeError:
-            # extra parentheses in print to allow for 3-to-2 conversion
-            print((logEntry
-                   .encode(sys.stdout.encoding, 'backslashreplace')
-                   .decode(sys.stdout.encoding, 'strict')),
-                  file=file)
-
-class LogHandlerWithXml(logging.Handler):
-    logTextMaxLength: int
-    def __init__(self) -> None:
-        super(LogHandlerWithXml, self).__init__()
-
-    def recordToXml(self, logRec: logging.LogRecord) -> str:
-        def entityEncode(arg: Any, truncateAt: int = self.logTextMaxLength) -> str:  # be sure it's a string, vs int, etc, and encode &, <, ".
-            s = str(arg)
-            s = s if len(s) <= truncateAt else s[:truncateAt] + '...'
-            return s.replace("&","&amp;").replace("<","&lt;").replace('"','&quot;')
-
-        def ncNameEncode(arg: str) -> str:
-            s = []
-            for c in arg:
-                if c.isalnum() or c in ('.','-','_'):
-                    s.append(c)
-                else: # covers : and any other non-allowed character
-                    s.append('_') # change : into _ for xml correctness
-            return "".join(s)
-
-        def propElts(properties: list[tuple[Any, Any, Any]], indent: str, truncateAt: int = 128) -> str:
-            nestedIndent = indent + ' '
-            return indent.join('<property name="{0}" value="{1}"{2}>'.format(
-                                    entityEncode(p[0]),
-                                    entityEncode(p[1], truncateAt=truncateAt),
-                                    '/' if len(p) == 2
-                                    else '>' + nestedIndent + propElts(p[2],nestedIndent) + indent + '</property')
-                                for p in properties
-                                if 2 <= len(p) <= 3)
-
-        msg = self.format(logRec)
-        if logRec.args and isinstance(logRec.args, Mapping):
-            args = "".join([' {0}="{1}"'.format(ncNameEncode(n), entityEncode(v,
-                                                truncateAt=(65535 if n in ("json",) else 128)))
-                            for n, v in logRec.args.items()])
-        else:
-            args = ""
-        refs = "\n ".join('\n <ref href="{0}"{1}{2}{3}>'.format(
-                        entityEncode(ref["href"]),
-                        ' sourceLine="{0}"'.format(ref["sourceLine"]) if "sourceLine" in ref else '',
-                        ''.join(' {}="{}"'.format(ncNameEncode(k),entityEncode(v))
-                                                  for k,v in ref["customAttributes"].items())
-                             if 'customAttributes' in ref else '',
-                        (">\n  " + propElts(ref["properties"],"\n  ", truncateAt=self.logTextMaxLength) + "\n </ref" )
-                                   if ("properties" in ref) else '/')
-                       for ref in getattr(logRec, "refs", []))
-        return ('<entry code="{0}" level="{1}">'
-                '\n <message{2}>{3}</message>{4}'
-                '</entry>\n'.format(getattr(logRec, "messageCode", ""),
-                                    logRec.levelname.lower(),
-                                    args,
-                                    entityEncode(msg),
-                                    refs))
-    def recordToJson(self, logRec: logging.LogRecord) -> dict[str, Any]:
-        message = { "text": self.format(logRec) }
-        if logRec.args and isinstance(logRec.args, Mapping):
-            for n, v in logRec.args.items():
-                message[n] = str(v)
-        return {"code": getattr(logRec, "messageCode", ""),
-                "level": logRec.levelname.lower(),
-                "refs": getattr(logRec, "refs", []),
-                "message": message}
-
-    def recordToHtml(self, logRec: logging.LogRecord) -> str:
-        record = ["<tr>"]
-        record.append(f"<td>{getattr(logRec, 'messageCode', '')}</td>")
-        record.append(f"<td>{logRec.levelname.lower()}</td>")
-        record.append(f"<td>{self.format(logRec)}</td>")
-        record.append("</tr>")
-        return "\n".join(record)
-
-class LogToXmlHandler(LogHandlerWithXml):
-    """
-    .. class:: LogToXmlHandler(filename)
-
-    A log handler that writes log entries to named XML file (utf-8 encoded) upon closing the application.
-    """
-    logRecordBuffer: list[logging.LogRecord]
-    filename: str | None
-    filemode: str
-    htmlTitle: str = "Arelle Message Log" # may be customized in plugin startup
-
-    def __init__(self, filename: str | None = None, mode: str = 'w') -> None:
-        super(LogToXmlHandler, self).__init__()
-        self.filename = filename # may be none if buffer is retrieved by get methods below and not written anywhere
-        self.logRecordBuffer = []
-        self.filemode = mode
-
-    def flush(self) -> None:
-        # Note to developers: breakpoints in this method don't work, please debug with print statements
-        securityIsActive = securityHasWritten = False
-        for pluginMethod in PluginManager.pluginClassMethods("Security.Crypt.IsActive"):
-            securityIsActive = pluginMethod(self) # must be active for the cntlr object to effect log writing
-        if self.filename == "logToStdOut.xml":
-            print('<?xml version="1.0" encoding="utf-8"?>')
-            print('<log>')
-            for logRec in self.logRecordBuffer:
-                logRecXml = self.recordToXml(logRec)
-                try:
-                    print(logRecXml)
-                except UnicodeEncodeError:
-                    # extra parentheses in print to allow for 3-to-2 conversion
-                    print((logRecXml
-                           .encode(sys.stdout.encoding, 'backslashreplace')
-                           .decode(sys.stdout.encoding, 'strict')))
-            print('</log>')
-        elif self.filename is not None:
-            if self.filename.endswith(".xml"):
-                # print ("filename=" + self.filename)
-                if securityIsActive:
-                    for pluginMethod in PluginManager.pluginClassMethods("Security.Crypt.Write"):
-                        securityHasWritten = pluginMethod(self, self.filename,
-                            '<?xml version="1.0" encoding="utf-8"?>\n<log>\n' +
-                            ''.join(self.recordToXml(logRec) for logRec in self.logRecordBuffer) +
-                            '</log>\n')
-                if not securityHasWritten:
-                    with open(self.filename, self.filemode, encoding='utf-8') as fh:
-                        fh.write('<?xml version="1.0" encoding="utf-8"?>\n<log>\n')
-                        for logRec in self.logRecordBuffer:
-                            fh.write(self.recordToXml(logRec))
-                        fh.write('</log>\n')
-            elif self.filename.endswith(".json"):
-                if securityIsActive:
-                    for pluginMethod in PluginManager.pluginClassMethods("Security.Crypt.Write"):
-                        securityHasWritten = pluginMethod(self, self.filename, self.getJson())
-                if not securityHasWritten:
-                    with open(self.filename, self.filemode, encoding='utf-8') as fh:
-                        fh.write(self.getJson())
-            elif self.filename.endswith(".html"):
-                if securityIsActive:
-                    for pluginMethod in PluginManager.pluginClassMethods("Security.Crypt.Write"):
-                        securityHasWritten = pluginMethod(self, self.filename, self.getHtml())
-                if not securityHasWritten:
-                    with open(self.filename, self.filemode, encoding='utf-8') as fh:
-                        fh.write(self.getHtml())
-            elif self.filename in ("logToPrint", "logToStdErr"):
-                _file = sys.stderr if self.filename == "logToStdErr" else None
-                for logRec in self.logRecordBuffer:
-                    logEntry = self.format(logRec)
-                    try:
-                        print(logEntry, file=_file)
-                    except UnicodeEncodeError:
-                        # extra parentheses in print to allow for 3-to-2 conversion
-                        print((logEntry
-                               .encode(sys.stdout.encoding, 'backslashreplace')
-                               .decode(sys.stdout.encoding, 'strict')),
-                              file=_file)
-            else:
-                if securityIsActive:
-                    for pluginMethod in PluginManager.pluginClassMethods("Security.Crypt.Write"):
-                        securityHasWritten = pluginMethod(self, self.filename,
-                            ''.join(self.format(logRec) + "\n" for logRec in self.logRecordBuffer))
-                if not securityHasWritten:
-                    with open(self.filename, self.filemode, encoding='utf-8') as fh:
-                        for logRec in self.logRecordBuffer:
-                            fh.write(self.format(logRec) + "\n")
-        self.clearLogBuffer()
-
-    def clearLogBuffer(self) -> None:
-        del self.logRecordBuffer[:]
-
-    def getXml(self, clearLogBuffer: bool = True) -> str:
-        """Returns an XML document (as a string) representing the messages in the log buffer, and clears the buffer.
-
-        :reeturns: str -- XML document string of messages in the log buffer.
-        """
-        xml = ['<?xml version="1.0" encoding="utf-8"?>\n',
-               '<log>']
-        for logRec in self.logRecordBuffer:
-            xml.append(self.recordToXml(logRec))
-        xml.append('</log>')
-        if clearLogBuffer:
-            self.clearLogBuffer()
-        return '\n'.join(xml)
-
-    def getJson(self, clearLogBuffer: bool = True) -> str:
-        """Returns an JSON string representing the messages in the log buffer, and clears the buffer.
-
-        :returns: str -- json representation of messages in the log buffer
-        """
-        entries = []
-        for logRec in self.logRecordBuffer:
-            entries.append(self.recordToJson(logRec))
-        if clearLogBuffer:
-            self.clearLogBuffer()
-        return json.dumps( {"log": entries}, ensure_ascii=False, indent=1, default=str )
-
-    def getHtml(self, clearLogBuffer: bool = True) -> str:
-        """Returns an HTML string representing the messages in the log buffer, and clears the buffer.
-
-        :returns: str -- HTML representation of messages in the log buffer
-        """
-        html = ["""<!doctype html>
-        <html>
-        <head>
-            <title>{0}</title>
-            <style>
-                table {{
-                    border: 1px solid black;
-                    border-spacing: 3px;
-                    table-layout: fixed;
-                    width: 100%;
-                }}
-                th, td {{
-                    padding: 5px;
-                    word-wrap: break-word;
-                }}
-                th {{
-                    background-color: #bcf1fd;
-                }}
-                td {{
-                    background-color: #f4f7f7;
-                }}
-                td:last-child, th:last-child {{
-                    width: 80%;
-                }}
-            </style>
-        </head>
-        <body>
-        <table>
-            <thead>
-                <tr>
-                    <th>Code</th>
-                    <th>Level</th>
-                    <th style="">Message</th>
-                </tr>
-            </thead>
-            <tbody>""".format(
-                self.htmlTitle)
-        ]
-        if self.logRecordBuffer:
-            for logRec in self.logRecordBuffer:
-                html.append(self.recordToHtml(logRec))
-            if clearLogBuffer:
-                self.clearLogBuffer()
-            html.append("</tbody>\n</table>\n</body>\n</html>\n")
-        else:
-            html = ["""<!doctype html>
-            <html>
-            <head>
-                <title>{0}</title>
-                <style>
-                    div {{
-                        background-color: #f4f7f7;
-                        position: relative;
-                        top: 33.33%;
-                        margin: -10px auto;
-                        width: 25vw;
-                        height: 25vh;
-                        display: flex;
-                        justify-content: center;
-                        align-items: center;
-                        text-align: center;
-                    }}
-                    body {{
-                        background-color: #bcf1fd;
-                        height: 100vh;
-                    }}
-                </style>
-            </head>
-            <body>
-                <div>
-                    <h1>No log errors to display</h1>
-                </div>
-            </body>
-            </html>
-            """.format(
-                self.htmlTitle)
-            ]
-        return '\n'.join(html)
-
-    def getLines(self, clearLogBuffer: bool = True) -> list[str]:
-        """Returns a list of the message strings in the log buffer, and clears the buffer.
-
-        :returns: [str] -- list of strings representing messages corresponding to log buffer entries
-        """
-        lines = [self.format(logRec) for logRec in self.logRecordBuffer]
-        if clearLogBuffer:
-            self.clearLogBuffer()
-        return lines
-
-    def getText(self, separator: str = '\n', clearLogBuffer: bool = True) -> str:
-        """Returns a string of the lines in the log buffer, separated by newline or provided separator.
-
-        :param separator: Line separator (default is platform os newline character)
-        :type separator: str
-        :returns: str -- joined lines of the log buffer.
-        """
-        return separator.join(self.getLines(clearLogBuffer=clearLogBuffer))
-
-    def emit(self, logRecord: logging.LogRecord) -> None:
-        self.logRecordBuffer.append(logRecord)
-
-class LogToBufferHandler(LogToXmlHandler):
-    """
-    .. class:: LogToBufferHandler()
-
-    A log handler that writes log entries to a memory buffer for later retrieval (to a string) in XML, JSON, or text lines,
-    usually for return to a web service or web page call.
-    """
-    def __init__(self) -> None:
-        super(LogToBufferHandler, self).__init__()
+    def _clearPluginData(self) -> None:
+        self.__pluginData.clear()
 
-    def flush(self) -> None:
-        pass # do nothing -- overrides LogToXmlHandler's flush
+    def testcaseVariationReset(self) -> None:
+        self._clearPluginData()
+        if self.errorManager is not None:
+            self.errorManager.clear()