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

arelle/utils/validate/DetectScriptsInXhtml.py

@@ -0,0 +1,99 @@
+from typing import Any, Collection
+
+from arelle.XbrlConst import xhtml
+from lxml.etree import _Element
+
+HTML_EVENT_HANDLER_ATTRIBUTES = frozenset((
+    "onabort",
+    "onafterprint",
+    "onbeforeprint",
+    "onbeforeunload",
+    "onblur",
+    "oncanplay",
+    "oncanplaythrough",
+    "onchange",
+    "onclick",
+    "oncontextmenu",
+    "oncopy",
+    "oncuechange",
+    "oncut",
+    "ondblclick",
+    "ondrag",
+    "ondragend",
+    "ondragenter",
+    "ondragleave",
+    "ondragover",
+    "ondragstart",
+    "ondrop",
+    "ondurationchange",
+    "onemptied",
+    "onended",
+    "onerror",
+    "onfocus",
+    "onhashchange",
+    "oninput",
+    "oninvalid",
+    "onkeydown",
+    "onkeypress",
+    "onkeyup",
+    "onload",
+    "onloadeddata",
+    "onloadedmetadata",
+    "onloadstart",
+    "onmessage",
+    "onmousedown",
+    "onmousemove",
+    "onmouseout",
+    "onmouseover",
+    "onmouseup",
+    "onmousewheel",
+    "onoffline",
+    "ononline",
+    "onpagehide",
+    "onpageshow",
+    "onpaste",
+    "onpause",
+    "onplay",
+    "onplaying",
+    "onpopstate",
+    "onprogress",
+    "onratechange",
+    "onreset",
+    "onresize",
+    "onscroll",
+    "onsearch",
+    "onseeked",
+    "onseeking",
+    "onselect",
+    "onstalled",
+    "onstorage",
+    "onsubmit",
+    "onsuspend",
+    "ontimeupdate",
+    "ontoggle",
+    "onunload",
+    "onvolumechange",
+    "onwaiting",
+    "onwheel",
+))
+
+
+def hasEventHandlerAttributes(elt: Any) -> bool:
+    return _hasEventAttributes(elt, HTML_EVENT_HANDLER_ATTRIBUTES)
+
+
+def _hasEventAttributes(elt: Any, attributes: Collection[str]) -> bool:
+    if isinstance(elt, _Element):
+        return any(a in attributes for a in elt.keys())
+    return False
+
+
+def containsScriptMarkers(elt: Any) -> Any:
+    _xhtmlNs = "{{{}}}".format(xhtml)
+    _xhtmlNsLen = len(_xhtmlNs)
+    eltTag = elt.tag.removeprefix(_xhtmlNs)
+    if ((eltTag in ("object", "script")) or
+            (eltTag == "a" and "javascript:" in elt.get("href","")) or
+            (eltTag == "img" and "javascript:" in elt.get("src","")) or
+            (hasEventHandlerAttributes(elt))):
+        return True

arelle/utils/validate/ESEFImage.py

@@ -0,0 +1,283 @@
+"""
+See COPYRIGHT.md for copyright information.
+"""
+from __future__ import annotations
+
+import binascii
+import os
+from collections.abc import Iterable
+from dataclasses import dataclass
+from typing import Any, cast
+from urllib.parse import unquote
+
+import tinycss2  # type: ignore[import-untyped]
+from lxml.etree import XML, XMLSyntaxError, _Element
+
+from arelle import ModelDocument
+from arelle.ModelObjectFactory import parser
+from arelle.ModelXbrl import ModelXbrl
+from arelle.typing import TypeGetText
+from arelle.UrlUtil import decodeBase64DataImage, isExternalUrl
+from arelle.utils.validate.Validation import Validation
+from arelle.ValidateFilingText import parseImageDataURL, validateGraphicHeaderType
+from arelle.ValidateXbrl import ValidateXbrl
+
+_: TypeGetText  # Handle gettext
+
+
+@dataclass(frozen=True)
+class ImageValidationParameters:
+    checkMinExternalResourceSize: bool
+    consolidated: bool
+    contentOtherThanXHTMLGuidance: str
+    missingMimeTypeIsIncorrect: bool
+    recommendBase64EncodingEmbeddedImages: bool
+    supportedImgTypes: dict[bool, tuple[str, ...]]
+
+    @classmethod
+    def from_non_esef(
+        cls,
+        checkMinExternalResourceSize: bool,
+        missingMimeTypeIsIncorrect: bool,
+        recommendBase64EncodingEmbeddedImages: bool,
+        supportedImgTypes: dict[bool, tuple[str, ...]],
+    ) -> ImageValidationParameters:
+        return cls(
+            checkMinExternalResourceSize=checkMinExternalResourceSize,
+            consolidated=True,
+            # This must be an ESEF code, even if it's later discarded.
+            contentOtherThanXHTMLGuidance="ESEF.2.5.1",
+            missingMimeTypeIsIncorrect=missingMimeTypeIsIncorrect,
+            recommendBase64EncodingEmbeddedImages=recommendBase64EncodingEmbeddedImages,
+            supportedImgTypes=supportedImgTypes,
+        )
+
+
+def validateImageAndLog(
+    baseUrl: str | None,
+    image: str,
+    modelXbrl: ModelXbrl,
+    val: ValidateXbrl,
+    elts: _Element | list[_Element],
+    evaluatedMsg: str,
+    params: ImageValidationParameters,
+    prelude: list[Any] | None = None,
+) -> None:
+    cssSelectors = None
+    for validation in validateImage(
+        baseUrl=baseUrl,
+        image=image,
+        modelXbrl=modelXbrl,
+        val=val,
+        elts=elts,
+        evaluatedMsg=evaluatedMsg,
+        params=params,
+    ):
+        if cssSelectorsArg := validation.args.get("cssSelectors"):
+            raise ValueError(_("The 'cssSelectors' argument is reserved to record the CSS selector. It should not be present in the validation arguments: {}").format(cssSelectorsArg))
+        if prelude and cssSelectors is None:
+            cssSelectors = tinycss2.serialize(prelude).strip()
+        args = validation.args.copy()
+        if cssSelectors:
+            args["cssSelectors"] = cssSelectors
+        modelXbrl.log(level=validation.level.name, codes=validation.codes, msg=validation.msg, **args)
+
+# check image contents against mime/file ext and for Steganography
+def validateImage(
+    baseUrl: str | None,
+    image: str,
+    modelXbrl: ModelXbrl,
+    val: ValidateXbrl,
+    elts: _Element | list[_Element],
+    evaluatedMsg: str,
+    params: ImageValidationParameters,
+) -> Iterable[Validation]:
+    """
+    image: either an url or base64 in data:image style
+    """
+    contentOtherThanXHTMLGuidance = params.contentOtherThanXHTMLGuidance
+    # a list of img elements are maintained because an SVG can reference another SVG
+    # or other type of image and we need to log the entire reference chain.
+    if not isinstance(elts, list):
+        elts = [elts]
+    if params.checkMinExternalResourceSize:
+        minExternalRessourceSize = val.authParam["minExternalResourceSizekB"]
+        if minExternalRessourceSize != -1:
+            # transform kb to b
+            minExternalRessourceSize = minExternalRessourceSize * 1024
+    if isExternalUrl(image):
+        yield Validation.error(("ESEF.4.1.6.xHTMLDocumentContainsExternalReferences" if not params.consolidated
+                               else "ESEF.3.5.1.inlineXbrlDocumentContainsExternalReferences",
+                               "NL.NL-KVK.3.6.2.1.inlineXbrlDocumentContainsExternalReferences"),
+                               _("Inline XBRL instance documents MUST NOT contain any reference pointing to resources outside the reporting package: %(element)s"),
+                               modelObject=elts, element=elts[0].tag, evaluatedMsg=evaluatedMsg,
+                               messageCodes=("ESEF.3.5.1.inlineXbrlDocumentContainsExternalReferences",
+                                             "ESEF.4.1.6.xHTMLDocumentContainsExternalReferences",
+                                             "NL.NL-KVK.3.6.2.1.inlineXbrlDocumentContainsExternalReferences"))
+    elif image.startswith("data:image"):
+        dataURLParts = parseImageDataURL(image)
+        if not dataURLParts or not dataURLParts.isBase64:
+            if params.recommendBase64EncodingEmbeddedImages:
+                yield Validation.warning(f"{contentOtherThanXHTMLGuidance}.embeddedImageNotUsingBase64Encoding",
+                                         _("Images included in the XHTML document SHOULD be base64 encoded: %(src)s."),
+                                         modelObject=elts, src=image[:128], evaluatedMsg=evaluatedMsg)
+            if dataURLParts and dataURLParts.mimeSubtype and dataURLParts.data:
+                yield from checkImageContents(None, modelXbrl, elts, dataURLParts.mimeSubtype, False, unquote(dataURLParts.data), params, True, val)
+        else:
+            hasMimeType = bool(dataURLParts.mimeSubtype)
+            if not hasMimeType:
+                yield Validation.error((f"{contentOtherThanXHTMLGuidance}.MIMETypeNotSpecified", "NL.NL-KVK.3.5.1.2.MIMETypeNotSpecified"),
+                                       _("Images included in the XHTML document MUST be saved with MIME type specifying PNG, GIF, SVG or JPG/JPEG formats: %(src)s."),
+                                       modelObject=elts, src=image[:128], evaluatedMsg=evaluatedMsg)
+            elif dataURLParts.mimeSubtype not in ("gif", "jpeg", "png", "svg+xml"):
+                yield Validation.error((f"{contentOtherThanXHTMLGuidance}.imageFormatNotSupported", "NL.NL-KVK.3.5.1.5.imageFormatNotSupported"),
+                                       _("Images included in the XHTML document MUST be saved in PNG, GIF, SVG or JPG/JPEG formats: %(src)s."),
+                                       modelObject=elts, src=image[:128], evaluatedMsg=evaluatedMsg)
+            # check for malicious image contents
+            try:  # allow embedded newlines
+                imgContents = decodeBase64DataImage(dataURLParts.data)
+                yield from checkImageContents(None, modelXbrl, elts, str(dataURLParts.mimeSubtype), False, imgContents, params, hasMimeType, val)
+                imgContents = b""  # deref, may be very large
+
+            except binascii.Error as err:
+                if params.recommendBase64EncodingEmbeddedImages:
+                    yield Validation.error(f"{contentOtherThanXHTMLGuidance}.embeddedImageNotUsingBase64Encoding",
+                                           _("Base64 encoding error %(err)s in image source: %(src)s."),
+                                           modelObject=elts, err=str(err), src=image[:128], evaluatedMsg=evaluatedMsg)
+    else:
+        # presume it to be an image file, check image contents
+        try:
+            base = baseUrl
+            normalizedUri = modelXbrl.modelManager.cntlr.webCache.normalizeUrl(image, base)
+            if not modelXbrl.fileSource.isInArchive(normalizedUri):
+                normalizedUri = modelXbrl.modelManager.cntlr.webCache.getfilename(normalizedUri)
+            imglen = 0
+            with modelXbrl.fileSource.file(normalizedUri, binary=True)[0] as fh:
+                imgContents = cast(bytes, fh.read())
+                imglen += len(imgContents or '')
+                yield from checkImageContents(normalizedUri, modelXbrl, elts, os.path.splitext(image)[1], True, imgContents, params, False, val)
+                imgContents = b""  # deref, may be very large
+            if params.checkMinExternalResourceSize and imglen < minExternalRessourceSize:
+                yield Validation.warning(
+                    ("%s.imageIncludedAndNotEmbeddedAsBase64EncodedString" % contentOtherThanXHTMLGuidance, "NL.NL-KVK.3.5.1.imageIncludedAndNotEmbeddedAsBase64EncodedString"),
+                    _("Images SHOULD be included in the XHTML document as a base64 encoded string unless their size exceeds the minimum size for the authority (%(maxImageSize)s): %(file)s."),
+                    modelObject=elts, maxImageSize=minExternalRessourceSize, file=os.path.basename(normalizedUri), evaluatedMsg=evaluatedMsg)
+        except IOError as err:
+            fileReferencingImage = os.path.basename(baseUrl) if baseUrl else ''
+            yield Validation.error((f"{contentOtherThanXHTMLGuidance}.imageFileCannotBeLoaded", "NL.NL-KVK.3.5.1.imageFileCannotBeLoaded"),
+                                   _("Error opening the file '%(src)s' referenced by '%(fileReferencingImage)s': %(error)s"),
+                                   modelObject=elts, src=image, fileReferencingImage=fileReferencingImage, error=err, evaluatedMsg=evaluatedMsg)
+
+
+def checkImageContents(
+    baseURI: str | None,
+    modelXbrl: ModelXbrl,
+    imgElts: list[_Element],
+    imgType: str,
+    isFile: bool,
+    data: bytes | str,
+    params: ImageValidationParameters,
+    hasMimeType: bool,
+    val: ValidateXbrl,
+) -> Iterable[Validation]:
+    guidance = params.contentOtherThanXHTMLGuidance
+    if "svg" in imgType:
+        try:
+            yield from checkSVGContent(baseURI, modelXbrl, imgElts, data, params, val)
+        except XMLSyntaxError as err:
+            try:
+                yield from checkSVGContent(baseURI, modelXbrl, imgElts, unquote(data), params, val)  # Try with utf-8 decoded data as in conformance suite G4-1-3_2/TC2
+            except XMLSyntaxError:
+                yield Validation.error((f"{guidance}.imageFileCannotBeLoaded", "NL.NL-KVK.3.5.1.imageFileCannotBeLoaded"),
+                                       _("Image SVG has XML error %(error)s"),
+                                       modelObject=imgElts, error=err)
+        except UnicodeDecodeError as err:
+            yield Validation.error((f"{guidance}.imageFileCannotBeLoaded", "NL.NL-KVK.3.5.1.imageFileCannotBeLoaded"),
+                                   _("Image SVG has XML error %(error)s"),
+                                   modelObject=imgElts, error=err)
+    else:
+        headerType = validateGraphicHeaderType(data)  # type: ignore[arg-type]
+        if (("gif" not in imgType and headerType == "gif") or
+            ("jpeg" not in imgType and "jpg" not in imgType and headerType == "jpg") or
+            ("png" not in imgType and headerType == "png")):
+            imageDoesNotMatchItsFileExtension = (f"{guidance}.imageDoesNotMatchItsFileExtension", "NL.NL-KVK.3.5.1.4.imageDoesNotMatchItsFileExtension")
+            incorrectMIMETypeSpecified = (f"{guidance}.incorrectMIMETypeSpecified", "NL.NL-KVK.3.5.1.3.incorrectMIMETypeSpecified")
+            if isFile:
+                codes = imageDoesNotMatchItsFileExtension
+                message = _("File type %(headerType)s inferred from file signature does not match the file extension %(imgType)s")
+            else:
+                codes = incorrectMIMETypeSpecified
+                message = _("File type %(headerType)s inferred from file signature does not match the data URL media subtype (MIME subtype) %(imgType)s")
+            if isFile or params.missingMimeTypeIsIncorrect or hasMimeType:
+                yield Validation.error(codes, message,
+                    modelObject=imgElts, imgType=imgType, headerType=headerType,
+                    messageCodes=(
+                        imageDoesNotMatchItsFileExtension, incorrectMIMETypeSpecified,
+                        "NL.NL-KVK.3.5.1.3.incorrectMIMETypeSpecified", "NL.NL-KVK.3.5.1.4.imageDoesNotMatchItsFileExtension",
+                    ))
+        elif not any(it in imgType for it in params.supportedImgTypes[isFile]):
+            yield Validation.error((f"{guidance}.imageFormatNotSupported", "NL.NL-KVK.3.5.1.5.imageFormatNotSupported"),
+                                   _("Images included in the XHTML document MUST be saved in PNG, GIF, SVG or JPEG formats: %(imgType)s is not supported"),
+                                   modelObject=imgElts, imgType=imgType)
+
+
+def checkSVGContent(
+    baseURI: str | None,
+    modelXbrl: ModelXbrl,
+    imgElts: list[_Element],
+    data: bytes | str,
+    params: ImageValidationParameters,
+    val: ValidateXbrl,
+) -> Iterable[Validation]:
+    if baseURI:
+        svgDoc = cast(ModelDocument.ModelDocument, ModelDocument.load(modelXbrl, baseURI, referringElement=imgElts[0]))
+        elt = svgDoc.xmlRootElement
+    else:
+        _parser, _, _ = parser(modelXbrl, baseURI)
+        elt = XML(data, parser=_parser)
+    yield from checkSVGContentElt(elt, baseURI, modelXbrl, imgElts, params, val)
+
+
+def getHref(elt:_Element) -> str:
+    simple_href = elt.get("href", "").strip()
+    if len(simple_href) > 0:
+        return simple_href
+    else:
+        # 'xlink:href' is deprecated but still used by some SVG generators
+        return elt.get("{http://www.w3.org/1999/xlink}href", "").strip()
+
+
+def checkSVGContentElt(
+    elt: _Element,
+    baseUrl: str | None,
+    modelXbrl: ModelXbrl,
+    imgElts: list[_Element],
+    params: ImageValidationParameters,
+    val: ValidateXbrl,
+) -> Iterable[Validation]:
+    guidance = params.contentOtherThanXHTMLGuidance
+    rootElement = True
+    for childElt in elt.iter():
+        if rootElement:
+            if childElt.tag != "{http://www.w3.org/2000/svg}svg":
+                yield Validation.error((f"{guidance}.imageFileCannotBeLoaded", "NL.NL-KVK.3.5.1.imageFileCannotBeLoaded"),
+                                       _("Image SVG has root element which is not svg"),
+                                       modelObject=imgElts)
+            rootElement = False
+        # Comments, processing instructions, and maybe other special constructs don't have string tags.
+        if not isinstance(childElt.tag, str):
+            continue
+        eltTag = childElt.tag.rpartition("}")[2] # strip namespace
+        if eltTag == "image":
+            imgElts = [*imgElts, childElt]
+            yield from validateImage(baseUrl, getHref(childElt), modelXbrl, val, imgElts, "", params)
+        if eltTag in ("object", "script", "audio", "foreignObject", "iframe", "image", "use", "video"):
+            href = childElt.get("href","")
+            if eltTag in ("object", "script") or "javascript:" in href:
+                yield Validation.error((f"{guidance}.executableCodePresent", "NL.NL-KVK.3.5.1.1.executableCodePresent"),
+                                       _("Inline XBRL images MUST NOT contain executable code: %(element)s"),
+                                       modelObject=imgElts, element=eltTag)
+            elif isExternalUrl(href):
+                yield Validation.error((f"{guidance}.referencesPointingOutsideOfTheReportingPackagePresent", "NL.NL-KVK.3.6.2.1.inlineXbrlDocumentContainsExternalReferences"),
+                                       _("Inline XBRL instance document [image] MUST NOT contain any reference pointing to resources outside the reporting package: %(element)s"),
+                                       modelObject=imgElts, element=eltTag)

arelle/utils/validate/Validation.py

@@ -12,7 +12,6 @@ class Level(Enum):
     ERROR = "ERROR"
     WARNING = "WARNING"
 
-
 @dataclass(frozen=True)
 class Validation:
     level: Level
@@ -20,6 +19,15 @@ class Validation:
     msg: str
     args: dict[str, Any] = field(default_factory=dict)
 
+    @staticmethod
+    def build(
+            level: Level,
+            codes: str | tuple[str, ...],
+            msg: str,
+            **kwargs: Any,
+    ) -> Validation:
+        return Validation(level=level, codes=codes, msg=msg, args=kwargs)
+
     @staticmethod
     def error(
         codes: str | tuple[str, ...],

arelle/utils/validate/ValidationPlugin.py

@@ -8,17 +8,19 @@ from pathlib import Path
 from types import ModuleType
 from typing import Any
 
+from arelle.Cntlr import Cntlr
 from arelle.DisclosureSystem import DisclosureSystem
+from arelle.FileSource import FileSource
 from arelle.ModelDocument import LoadingException, ModelDocument
 from arelle.ModelXbrl import ModelXbrl
 from arelle.ValidateXbrl import ValidateXbrl
+from arelle.utils.PluginData import PluginData
 from arelle.utils.PluginHooks import ValidationHook
 from arelle.utils.validate.Decorator import (
     ValidationAttributes,
     ValidationFunction,
     getValidationAttributes,
 )
-from arelle.utils.validate.PluginValidationData import PluginValidationData
 
 
 class ValidationPlugin:
@@ -33,7 +35,7 @@ class ValidationPlugin:
         Base validation plugin class. Can be initialized directly, or extended if you require additional plugin hooks.
         This class is intended to be used in conjunction with the [@validation](#arelle.utils.validate.Decorator.validation) decorator.
 
-        If you need to cache or store data between rules, you should implement a dataclass that extends [PluginValidationData](#arelle.utils.validate.PluginValidationData.PluginValidationData)
+        If you need to cache or store data between rules, you should implement a dataclass that extends [PluginData](#arelle.utils.PluginData.PluginData)
         and override the [newPluginData](#newPluginData) method to return your dataclass.
 
         :param disclosureSystemConfigUrl: A path to the plugin disclosure system xml config file.
@@ -55,14 +57,14 @@ class ValidationPlugin:
             ValidationHook, dict[ValidationFunction, set[str]]
         ] = {}
 
-    def newPluginData(self, validateXbrl: ValidateXbrl) -> PluginValidationData:
+    def newPluginData(self, cntlr: Cntlr, validateXbrl: ValidateXbrl | None) -> PluginData:
         """
         Returns a dataclass intended to be overriden by plugins to facilitate caching and passing data between rule functions.
         The default implementation doesn't provide any fields other than the plugin name.
 
-        :return: An instance of PluginValidationData.
+        :return: An instance of PluginData.
         """
-        return PluginValidationData(self.name)
+        return PluginData(self.name)
 
     @property
     def validationTypes(self) -> tuple[str, ...]:
@@ -99,6 +101,46 @@ class ValidationPlugin:
     ) -> ModelDocument | LoadingException | None:
         raise NotImplementedError
 
+    def validateComplete(
+            self,
+            cntlr: Cntlr,
+            fileSource: FileSource,
+            *args: Any,
+            **kwargs: Any,
+    ) -> None:
+        """
+        Executes validation functions in the rules module that was provided to the constructor of this class.
+        Each function decorated with [@validation](#arelle.utils.validate.Decorator.validation) will be run if:
+        1. the decorator was used with the validation complete hook: `@validation(hook=ValidationHook.COMPLETE)`
+
+        :param cntlr: The [Cntlr](#arelle.Cntlr.Cntlr) instance.
+        :param fileSource: The [FileSource](#arelle.FileSource.FileSource) involved in loading the entrypoint files.
+        :param args: Argument capture to ensure new parameters don't break plugin hook.
+        :param kwargs: Argument capture to ensure new named parameters don't break plugin hook.
+        :return: None
+        """
+        self._executeCntlrValidations(ValidationHook.COMPLETE, cntlr, fileSource, *args, **kwargs)
+
+    def validateFileSource(
+        self,
+        cntlr: Cntlr,
+        fileSource: FileSource,
+        *args: Any,
+        **kwargs: Any,
+    ) -> None:
+        """
+        Executes validation functions in the rules module that was provided to the constructor of this class.
+        Each function decorated with [@validation](#arelle.utils.validate.Decorator.validation) will be run if:
+        1. the decorator was used with the FileSource validation hook: `@validation(hook=ValidationHook.FILESOURCE)`
+
+        :param cntlr: The [Cntlr](#arelle.Cntlr.Cntlr) instance.
+        :param fileSource: The [FileSource](#arelle.FileSource.FileSource) to validate.
+        :param args: Argument capture to ensure new parameters don't break plugin hook.
+        :param kwargs: Argument capture to ensure new named parameters don't break plugin hook.
+        :return: None
+        """
+        self._executeCntlrValidations(ValidationHook.FILESOURCE, cntlr, fileSource, *args, **kwargs)
+
     def validateXbrlStart(
         self,
         val: ValidateXbrl,
@@ -118,7 +160,7 @@ class ValidationPlugin:
         :param kwargs: Argument capture to ensure new named parameters don't break plugin hook.
         :return: None
         """
-        self._executeValidations(ValidationHook.XBRL_START, val, parameters, *args, **kwargs)
+        self._executeModelValidations(ValidationHook.XBRL_START, val, parameters, *args, **kwargs)
 
     def validateXbrlFinally(
         self,
@@ -137,7 +179,7 @@ class ValidationPlugin:
         :param kwargs: Argument capture to ensure new named parameters don't break plugin hook.
         :return: None
         """
-        self._executeValidations(ValidationHook.XBRL_FINALLY, val, *args, **kwargs)
+        self._executeModelValidations(ValidationHook.XBRL_FINALLY, val, *args, **kwargs)
 
     def validateXbrlDtsDocument(
         self,
@@ -158,7 +200,7 @@ class ValidationPlugin:
         :param kwargs: Argument capture to ensure new named parameters don't break plugin hook.
         :return: None
         """
-        self._executeValidations(ValidationHook.XBRL_DTS_DOCUMENT, val, modelDocument, isFilingDocument, *args, **kwargs)
+        self._executeModelValidations(ValidationHook.XBRL_DTS_DOCUMENT, val, modelDocument, isFilingDocument, *args, **kwargs)
 
     def validateFinally(
         self,
@@ -177,9 +219,27 @@ class ValidationPlugin:
         :param kwargs: Argument capture to ensure new named parameters don't break plugin hook.
         :return: None
         """
-        self._executeValidations(ValidationHook.FINALLY, val, *args, **kwargs)
+        self._executeModelValidations(ValidationHook.FINALLY, val, *args, **kwargs)
+
+    def _executeCntlrValidations(
+            self,
+            pluginHook: ValidationHook,
+            cntlr: Cntlr,
+            fileSource: FileSource | None = None,
+            *args: Any,
+            **kwargs: Any,
+    ) -> None:
+        pluginData = self.newPluginData(
+            cntlr=cntlr,
+            validateXbrl=None
+        )
+        for rule in self._getValidations(cntlr.modelManager.disclosureSystem, pluginHook):
+            validations = rule(pluginData, cntlr, fileSource, *args, **kwargs)
+            if validations is not None:
+                for val in validations:
+                    cntlr.error(level=val.level.name, codes=val.codes, msg=val.msg, fileSource=fileSource, **val.args)
 
-    def _executeValidations(
+    def _executeModelValidations(
         self,
         pluginHook: ValidationHook,
         validateXbrl: ValidateXbrl,
@@ -189,7 +249,10 @@ class ValidationPlugin:
         if self.disclosureSystemFromPluginSelected(validateXbrl):
             pluginData = validateXbrl.getPluginData(self.name)
             if pluginData is None:
-                pluginData = self.newPluginData(validateXbrl)
+                pluginData = self.newPluginData(
+                    cntlr=validateXbrl.modelXbrl.modelManager.cntlr,
+                    validateXbrl=validateXbrl
+                )
                 validateXbrl.setPluginData(pluginData)
             for rule in self._getValidations(validateXbrl.disclosureSystem, pluginHook):
                 validations = rule(pluginData, validateXbrl, *args, **kwargs)

arelle/utils/validate/ValidationUtil.py

@@ -0,0 +1,55 @@
+"""
+See COPYRIGHT.md for copyright information.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Generator, Iterable
+
+from lxml.etree import _Element
+
+from arelle import XbrlConst
+from arelle.ModelDtsObject import ModelConcept
+from arelle.ModelObject import ModelObject
+from arelle.ModelValue import QName
+from arelle.ModelXbrl import ModelXbrl
+from arelle.typing import TypeGetText
+
+_: TypeGetText
+
+
+def etreeIterWithDepth(
+        node: ModelObject | _Element,
+        depth: int = 0,
+) -> Generator[tuple[ModelObject | _Element, int], None, None]:
+    yield node, depth
+    for child in node.iterchildren():
+        yield from etreeIterWithDepth(child, depth + 1)
+
+
+def hasPresentationalConceptsWithFacts(
+        modelXbrl: ModelXbrl,
+        roleUris: Iterable[str],
+        memberQnameFilter: set[QName] | None = None,
+) -> bool:
+    """
+    Returns True if any concepts used in the presentation network of the role URIs have been tagged with facts.
+    This DOES NOT check if the facts are dimensionally valid against hypercubes defined in the roles.
+    """
+    roleRelSet = modelXbrl.relationshipSet(XbrlConst.parentChild, tuple(roleUris))
+    concepts = set(roleRelSet.fromModelObjects().keys()) | set(roleRelSet.toModelObjects().keys())
+    for concept in concepts:
+        if not isinstance(concept, ModelConcept):
+            continue
+        if concept.qname is None:
+            continue
+        if concept.isAbstract:
+            continue
+        for fact in modelXbrl.factsByQname.get(concept.qname, set()):
+            if memberQnameFilter is None:
+                return True
+            if fact.context is not None:
+                for dimValue in fact.context.qnameDims.values():
+                    if dimValue.memberQname in memberQnameFilter:
+                        return True
+    return False