arelle-release 2.37.12__py3-none-any.whl → 2.37.14__py3-none-any.whl

arelle/plugin/validate/ESEF/ESEF_Current/ValidateXbrlFinally.py

@@ -228,12 +228,12 @@ def validateXbrlFinally(val: ValidateXbrl, *args: Any, **kwargs: Any) -> None:
                 _baseName, _baseExt = os.path.splitext(doc.basename)
                 if _baseExt not in (".xhtml",".html"):
                     if val.consolidated:
-                        XHTMLExtensionGuidance = "2.6.1"
+                        errorCode = "ESEF.2.6.1.incorrectFileExtension"
                         reportType = _("Inline XBRL document included within a ESEF report package")
                     else:
-                        XHTMLExtensionGuidance = "4.1.1"
+                        errorCode = "ESEF.4.1.1.incorrectFileExtension"
                         reportType = _("Stand-alone XHTML document")
-                    modelXbrl.error(f"ESEF.{XHTMLExtensionGuidance}.incorrectFileExtension",
+                    modelXbrl.error(errorCode,
                                     _("%(reportType)s MUST have a .html or .xhtml extension: %(fileName)s"),
                                     modelObject=doc, fileName=doc.basename, reportType=reportType)
                 docinfo = doc.xmlRootElement.getroottree().docinfo
@@ -664,8 +664,7 @@ def validateXbrlFinally(val: ValidateXbrl, *args: Any, **kwargs: Any) -> None:
                 if esefDisclosureSystemYear >= 2024:
                     if not f.id:
                         factsMissingId.append(f)
-                    escaped = f.get("escape") in ("true", "1")
-                    if f.concept is not None and escaped != f.concept.isTextBlock:
+                    if isinstance(f, ModelInlineFact) and f.concept is not None and f.isEscaped != f.concept.isTextBlock:
                         modelXbrl.error("ESEF.2.2.7.improperApplicationOfEscapeAttribute",
                                           _("Facts with datatype 'dtr-types:textBlockItemType' MUST use the 'escape' attribute set to 'true'. Facts with any other datatype MUST use the 'escape' attribute set to 'false' - fact %(conceptName)s"),
                                           modelObject=f, conceptName=f.concept.qname)

arelle/plugin/validate/NL/PluginValidationDataExtension.py

@@ -6,18 +6,23 @@ from __future__ import annotations
 from collections import defaultdict
 from dataclasses import dataclass
 from functools import lru_cache
-from typing import Any, cast
+from pathlib import Path
+from typing import Any, TYPE_CHECKING, cast
 
 import regex as re
 from lxml.etree import _Comment, _ElementTree, _Entity, _ProcessingInstruction
 
 from arelle.FunctionIxt import ixtNamespaces
-from arelle.ModelInstanceObject import ModelContext, ModelFact, ModelInlineFootnote, ModelUnit
+from arelle.ModelInstanceObject import ModelContext, ModelFact, ModelInlineFootnote, ModelUnit, ModelInlineFact
+from arelle.ModelObject import ModelObject
 from arelle.ModelValue import QName
 from arelle.ModelXbrl import ModelXbrl
+from arelle.typing import assert_type
 from arelle.utils.PluginData import PluginData
 from arelle.utils.validate.ValidationUtil import etreeIterWithDepth
+from arelle.XbrlConst import ixbrl11
 from arelle.XmlValidate import lexicalPatterns
+from arelle.XmlValidateConst import VALID
 
 XBRLI_IDENTIFIER_PATTERN = re.compile(r"^(?!00)\d{8}$")
 XBRLI_IDENTIFIER_SCHEMA = 'http://www.kvk.nl/kvk-id'
@@ -27,6 +32,25 @@ DISALLOWED_IXT_NAMESPACES = frozenset((
     ixtNamespaces["ixt v2"],
     ixtNamespaces["ixt v3"],
 ))
+UNTRANSFORMABLE_TYPES = frozenset((
+"anyURI",
+"base64Binary",
+"duration",
+"hexBinary",
+"NOTATION",
+"QName",
+"time",
+"token",
+"language",
+))
+STYLE_IX_HIDDEN_PATTERN = re.compile(r"(.*[^\w]|^)ix-hidden\s*:\s*([\w.-]+).*")
+
+ALLOWABLE_LANGUAGES = frozenset((
+    'nl',
+    'en',
+    'de',
+    'fr'
+))
 
 @dataclass(frozen=True)
 class ContextData:
@@ -36,10 +60,18 @@ class ContextData:
     contextsWithSegments: list[ModelContext | None]
 
 @dataclass(frozen=True)
-class FootnoteData:
+class HiddenElementsData:
+    eligibleForTransformHiddenFacts: set[ModelInlineFact]
+    hiddenFactsOutsideHiddenSection: set[ModelInlineFact]
+    requiredToDisplayFacts: set[ModelInlineFact]
+
+@dataclass(frozen=True)
+class InlineHTMLData:
     noMatchLangFootnotes: set[ModelInlineFootnote]
     orphanedFootnotes: set[ModelInlineFootnote]
+    tupleElements: set[tuple[Any]]
     factLangFootnotes: dict[ModelInlineFootnote, set[str]]
+    fractionElements: set[Any]
 
 @dataclass
 class PluginValidationDataExtension(PluginData):
@@ -101,29 +133,83 @@ class PluginValidationDataExtension(PluginData):
         )
 
     @lru_cache(1)
-    def checkFootnotes(self, modelXbrl: ModelXbrl) -> FootnoteData:
+    def checkHiddenElements(self, modelXbrl: ModelXbrl) -> HiddenElementsData:
+        eligibleForTransformHiddenFacts = set()
+        hiddenEltIds = {}
+        hiddenFactsOutsideHiddenSection = set()
+        presentedHiddenEltIds = defaultdict(list)
+        requiredToDisplayFacts = set()
+        for ixdsHtmlRootElt in modelXbrl.ixdsHtmlElements:
+            ixNStag = getattr(ixdsHtmlRootElt.modelDocument, "ixNStag", ixbrl11)
+            for ixHiddenElt in ixdsHtmlRootElt.iterdescendants(tag=ixNStag + "hidden"):
+                for tag in (ixNStag + "nonNumeric", ixNStag+"nonFraction"):
+                    for ixElt in ixHiddenElt.iterdescendants(tag=tag):
+                        if getattr(ixElt, "xValid", 0) >= VALID:
+                            if ixElt.concept.baseXsdType not in UNTRANSFORMABLE_TYPES and not ixElt.isNil:
+                                eligibleForTransformHiddenFacts.add(ixElt)
+                        if ixElt.id:
+                            hiddenEltIds[ixElt.id] = ixElt
+        for ixdsHtmlRootElt in modelXbrl.ixdsHtmlElements:
+            for ixElt in ixdsHtmlRootElt.getroottree().iterfind(".//{http://www.w3.org/1999/xhtml}*[@style]"):
+                styleValue = ixElt.get("style","")
+                hiddenFactRefMatch = STYLE_IX_HIDDEN_PATTERN.match(styleValue)
+                if hiddenFactRefMatch:
+                    hiddenFactRef = hiddenFactRefMatch.group(2)
+                    if hiddenFactRef not in hiddenEltIds:
+                        hiddenFactsOutsideHiddenSection.add(ixElt)
+                    else:
+                        presentedHiddenEltIds[hiddenFactRef].append(ixElt)
+        for hiddenEltId, ixElt in hiddenEltIds.items():
+            if (hiddenEltId not in presentedHiddenEltIds and
+                    getattr(ixElt, "xValid", 0) >= VALID and # may not be validated
+                    (ixElt.concept.baseXsdType in UNTRANSFORMABLE_TYPES or ixElt.isNil)):
+                requiredToDisplayFacts.add(ixElt)
+        return HiddenElementsData(
+            eligibleForTransformHiddenFacts=eligibleForTransformHiddenFacts,
+            hiddenFactsOutsideHiddenSection=hiddenFactsOutsideHiddenSection,
+            requiredToDisplayFacts=requiredToDisplayFacts,
+        )
+
+    @lru_cache(1)
+    def checkInlineHTMLElements(self, modelXbrl: ModelXbrl) -> InlineHTMLData:
         factLangs = self.factLangs(modelXbrl)
         footnotesRelationshipSet = modelXbrl.relationshipSet("XBRL-footnotes")
-        orphanedFootnotes = set()
-        noMatchLangFootnotes = set()
         factLangFootnotes = defaultdict(set)
-        for elts in modelXbrl.ixdsEltById.values():   # type: ignore[attr-defined]
-            for elt in elts:
-                if isinstance(elt, ModelInlineFootnote):
-                    if elt.textValue is not None:
-                        if not any(isinstance(rel.fromModelObject, ModelFact)
-                                   for rel in footnotesRelationshipSet.toModelObject(elt)):
-                            orphanedFootnotes.add(elt)
-                        if elt.xmlLang not in factLangs:
-                            noMatchLangFootnotes.add(elt)
-                        for rel in footnotesRelationshipSet.toModelObject(elt):
-                            if rel.fromModelObject is not None:
-                                factLangFootnotes[rel.fromModelObject].add(elt.xmlLang)
+        fractionElements = set()
+        noMatchLangFootnotes = set()
+        tupleElements = set()
+        orphanedFootnotes = set()
+        for ixdsHtmlRootElt in modelXbrl.ixdsHtmlElements:
+            ixNStag = getattr(ixdsHtmlRootElt.modelDocument, "ixNStag", ixbrl11)
+            ixTupleTag = ixNStag + "tuple"
+            ixFractionTag = ixNStag + "fraction"
+            for elts in modelXbrl.ixdsEltById.values():   # type: ignore[attr-defined]
+                for elt in elts:
+                    if isinstance(elt, ModelInlineFootnote):
+                        if elt.textValue is not None:
+                            if not any(isinstance(rel.fromModelObject, ModelFact)
+                                       for rel in footnotesRelationshipSet.toModelObject(elt)):
+                                orphanedFootnotes.add(elt)
+                            if elt.xmlLang not in factLangs:
+                                noMatchLangFootnotes.add(elt)
+                            if elt.xmlLang is not None:
+                                for rel in footnotesRelationshipSet.toModelObject(elt):
+                                    if rel.fromModelObject is not None:
+                                        fromObj = cast(ModelObject, rel.fromModelObject)
+                                        lang = cast(str, elt.xmlLang)
+                                        factLangFootnotes[fromObj].add(lang)
+                    if elt.tag == ixTupleTag:
+                        tupleElements.add(elt)
+                    if elt.tag == ixFractionTag:
+                        fractionElements.add(elt)
         factLangFootnotes.default_factory = None
-        return FootnoteData(
+        assert_type(factLangFootnotes, defaultdict[ModelObject, set[str]])
+        return InlineHTMLData(
+            factLangFootnotes=cast(dict[ModelInlineFootnote, set[str]], factLangFootnotes),
+            fractionElements=fractionElements,
             noMatchLangFootnotes=noMatchLangFootnotes,
             orphanedFootnotes=orphanedFootnotes,
-            factLangFootnotes=dict(factLangFootnotes),
+            tupleElements=tupleElements,
         )
 
     @lru_cache(1)
@@ -158,33 +244,78 @@ class PluginValidationDataExtension(PluginData):
     def getContextsWithSegments(self, modelXbrl: ModelXbrl) -> list[ModelContext | None]:
         return self.checkContexts(modelXbrl).contextsWithSegments
 
+    def getEligibleForTransformHiddenFacts(self, modelXbrl: ModelXbrl) -> set[ModelInlineFact]:
+        return self.checkHiddenElements(modelXbrl).eligibleForTransformHiddenFacts
+
+    def getFactLangFootnotes(self, modelXbrl: ModelXbrl) -> dict[ModelInlineFootnote, set[str]]:
+        return self.checkInlineHTMLElements(modelXbrl).factLangFootnotes
+
+    def getFractionElements(self, modelXbrl: ModelXbrl) -> set[Any]:
+        return self.checkInlineHTMLElements(modelXbrl).fractionElements
+
+    def getHiddenFactsOutsideHiddenSection(self, modelXbrl: ModelXbrl) -> set[ModelInlineFact]:
+        return self.checkHiddenElements(modelXbrl).hiddenFactsOutsideHiddenSection
+
+    @lru_cache(1)
+    def getFilenameAllowedCharactersPattern(self) -> re.Pattern[str]:
+        return re.compile(
+            r"^[\w\.-]*$",
+            flags=re.ASCII
+        )
+
+    @lru_cache(1)
+    def getFilenameFormatPattern(self) -> re.Pattern[str]:
+        return re.compile(
+            r"^(?<base>[^-]*)"
+            r"-(?<year>\d{4})-(?<month>0[1-9]|1[012])-(?<day>0?[1-9]|[12][0-9]|3[01])"
+            r"-(?<lang>[^-]*)"
+            r"\.(?<extension>html|htm|xhtml)$",
+            flags=re.ASCII
+        )
+
+    @lru_cache(1)
+    def getFilenameParts(self, filename: str) -> dict[str, Any] | None:
+        match = self.getFilenameFormatPattern().match(filename)
+        if match:
+            return match.groupdict()
+        return None
+
+    @lru_cache(1)
+    def getIxdsDocBasenames(self, modelXbrl: ModelXbrl) -> set[str]:
+        return set(Path(url).name for url in modelXbrl.ixdsDocUrls)
+
     def getNoMatchLangFootnotes(self, modelXbrl: ModelXbrl) -> set[ModelInlineFootnote]:
-        return self.checkFootnotes(modelXbrl).noMatchLangFootnotes
+        return self.checkInlineHTMLElements(modelXbrl).noMatchLangFootnotes
 
     def getOrphanedFootnotes(self, modelXbrl: ModelXbrl) -> set[ModelInlineFootnote]:
-        return self.checkFootnotes(modelXbrl).orphanedFootnotes
+        return self.checkInlineHTMLElements(modelXbrl).orphanedFootnotes
 
-    def getFactLangFootnotes(self, modelXbrl: ModelXbrl) -> dict[ModelInlineFootnote, set[str]]:
-        return self.checkFootnotes(modelXbrl).factLangFootnotes
+    def getRequiredToDisplayFacts(self, modelXbrl: ModelXbrl) -> set[ModelInlineFact]:
+        return self.checkHiddenElements(modelXbrl).requiredToDisplayFacts
+
+    def getTupleElements(self, modelXbrl: ModelXbrl) -> set[tuple[Any]]:
+        return self.checkInlineHTMLElements(modelXbrl).tupleElements
 
     @lru_cache(1)
     def getReportXmlLang(self, modelXbrl: ModelXbrl) -> str | None:
-        firstIxdsDoc = True
         reportXmlLang = None
         firstRootmostXmlLangDepth = 9999999
-        for ixdsHtmlRootElt in modelXbrl.ixdsHtmlElements:
-            for uncast_elt, depth in etreeIterWithDepth(ixdsHtmlRootElt):
-                elt = cast(Any, uncast_elt)
+        if modelXbrl.ixdsHtmlElements:
+            ixdsHtmlRootElt = modelXbrl.ixdsHtmlElements[0]
+            for elt, depth in etreeIterWithDepth(ixdsHtmlRootElt):
                 if isinstance(elt, (_Comment, _ElementTree, _Entity, _ProcessingInstruction)):
                     continue
-                if firstIxdsDoc and (not reportXmlLang or depth < firstRootmostXmlLangDepth):
-                    xmlLang = elt.get("{http://www.w3.org/XML/1998/namespace}lang")
-                    if xmlLang:
+                if not reportXmlLang or depth < firstRootmostXmlLangDepth:
+                    if xmlLang := elt.get("{http://www.w3.org/XML/1998/namespace}lang"):
                         reportXmlLang = xmlLang
                         firstRootmostXmlLangDepth = depth
-            firstIxdsDoc = False
         return reportXmlLang
 
+    @lru_cache(1)
+    def isFilenameValidCharacters(self, filename: str) -> bool:
+        match = self.getFilenameAllowedCharactersPattern().match(filename)
+        return match is not None
+
     @lru_cache(1)
     def unitsByDocument(self, modelXbrl: ModelXbrl) -> dict[str, list[ModelUnit]]:
         unitsByDocument = defaultdict(list)

arelle/plugin/validate/NL/__init__.py

@@ -48,16 +48,6 @@ def validateXbrlFinally(*args: Any, **kwargs: Any) -> None:
     return validationPlugin.validateXbrlFinally(*args, **kwargs)
 
 
-def modelTestcaseVariationReportPackageIxdsOptions(
-        val: ValidateXbrl,
-        rptPkgIxdsOptions: dict[str, bool],
-        *args: Any,
-        **kwargs: Any,
-) -> None:
-    rptPkgIxdsOptions["lookOutsideReportsDirectory"] = True
-    rptPkgIxdsOptions["combineIntoSingleIxds"] = True
-
-
 __pluginInfo__ = {
     "name": PLUGIN_NAME,
     "version": "0.0.1",
@@ -70,5 +60,4 @@ __pluginInfo__ = {
     "DisclosureSystem.ConfigURL": disclosureSystemConfigURL,
     "ModelXbrl.LoadComplete": modelXbrlLoadComplete,
     "Validate.XBRL.Finally": validateXbrlFinally,
-    "ModelTestcaseVariation.ReportPackageIxdsOptions": modelTestcaseVariationReportPackageIxdsOptions,
 }