arelle-release 2.37.5__tar.gz → 2.37.7__tar.gz

{arelle_release-2.37.5/arelle_release.egg-info → arelle_release-2.37.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: arelle-release
-Version: 2.37.5
+Version: 2.37.7
 Summary: An open source XBRL platform.
 Author-email: "arelle.org" <support@arelle.org>
 License: Apache-2.0

{arelle_release-2.37.5 → arelle_release-2.37.7}/arelle/CntlrCmdLine.py

@@ -603,7 +603,7 @@ def filesourceEntrypointFiles(filesource, entrypointFiles=None, inlineOnly=False
                         pluginXbrlMethod(filesource, reportEntries)
                         ixdsDiscovered = True
                     if not ixdsDiscovered and len(reportEntries) > 1:
-                        raise RuntimeError(_("Loading error. Inline document set encountered. Enable 'InlineDocumentSet' plug-in to load this filing: {0}").format(filesource.url))
+                        raise RuntimeError(_("Loading error. Inline document set encountered. Enable 'InlineXbrlDocumentSet' plug-in to load this filing: {0}").format(filesource.url))
                     entrypointFiles.extend(reportEntries)
                 elif not inlineOnly:
                     entrypointFiles.append({"file": report.fullPathPrimary})

{arelle_release-2.37.5 → arelle_release-2.37.7}/arelle/ModelDocument.py

@@ -1704,6 +1704,35 @@ def inlineIxdsDiscover(modelXbrl, modelIxdsDocument, setTargetModelXbrl=False, *
                             for _target in sourceFactTargets:
                                 targetRoleUris[_target].add(footnoteRole)
 
+    for htmlElement in modelXbrl.ixdsHtmlElements:
+        # Discover iXBRL 1.0 footnote roles and arcroles.
+        iXBRL1_0Footnotes = list(htmlElement.iterdescendants(tag=XbrlConst.qnIXbrlFootnote.clarkNotation))
+        if not iXBRL1_0Footnotes:
+            continue
+        footnoteRefElems = (
+            XbrlConst.qnIXbrlFraction.clarkNotation,
+            XbrlConst.qnIXbrlNonFraction.clarkNotation,
+            XbrlConst.qnIXbrlNonNumeric.clarkNotation,
+            XbrlConst.qnIXbrlTuple.clarkNotation,
+        )
+        targetsByFootnoteId = defaultdict(set)
+        for elem in htmlElement.iterdescendants(footnoteRefElems):
+            if isinstance(elem, ModelObject):
+                refs = elem.get("footnoteRefs")
+                if refs:
+                    _target = elem.get("target")
+                    for footnoteRef in refs.split():
+                        targetsByFootnoteId[footnoteRef].add(_target)
+        for modelInlineFootnote in iXBRL1_0Footnotes:
+            arcrole = modelInlineFootnote.get("arcrole", XbrlConst.factFootnote)
+            footnoteLinkRole = modelInlineFootnote.get("footnoteLinkRole", XbrlConst.defaultLinkRole)
+            footnoteRole = modelInlineFootnote.get("footnoteRole")
+            for _target in targetsByFootnoteId[modelInlineFootnote.footnoteID]:
+                targetRoleUris[_target].add(footnoteLinkRole)
+                targetArcroleUris[_target].add(arcrole)
+                if footnoteRole:
+                    targetRoleUris[_target].add(footnoteRole)
+
     contextRefs = factTargetContextRefs[ixdsTarget]
     unitRefs = factTargetUnitRefs[ixdsTarget]
     allContextRefs = set.union(*factTargetContextRefs.values())

{arelle_release-2.37.5 → arelle_release-2.37.7}/arelle/Validate.py

@@ -734,7 +734,7 @@ class Validate:
             if not isinstance(expected, list):
                 expected = [expected]
             for testErr in _errors:
-                if isinstance(testErr,str) and testErr.startswith("ESEF."): # compared as list of strings to QName localname
+                if isinstance(testErr, str) and testErr.startswith(("ESEF.", "NL.NL-KVK")): # compared as list of strings to QName localname
                     testErr = testErr.rpartition(".")[2]
                 for _exp in _expectedList:
                     _expMatched = False

{arelle_release-2.37.5 → arelle_release-2.37.7}/arelle/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '2.37.5'
-__version_tuple__ = version_tuple = (2, 37, 5)
+__version__ = version = '2.37.7'
+__version_tuple__ = version_tuple = (2, 37, 7)

{arelle_release-2.37.5 → arelle_release-2.37.7}/arelle/oim/Load.py

@@ -74,6 +74,7 @@ reservedLinkTypeAndGroupAliases = {
 XLINKTYPE = "{http://www.w3.org/1999/xlink}type"
 XLINKLABEL = "{http://www.w3.org/1999/xlink}label"
 XLINKARCROLE = "{http://www.w3.org/1999/xlink}arcrole"
+XLINKROLE = "{http://www.w3.org/1999/xlink}role"
 XLINKFROM = "{http://www.w3.org/1999/xlink}from"
 XLINKTO = "{http://www.w3.org/1999/xlink}to"
 XLINKHREF = "{http://www.w3.org/1999/xlink}href"
@@ -2717,6 +2718,7 @@ def _loadFromOIM(cntlr, error, warning, modelXbrl, oimFile, mappedUri):
                             footnoteLinkNotes[linkrole].add(noteId)
                             xbrlNote = xbrlNoteTbl[noteId]
                             attrs = {XLINKTYPE: "resource",
+                                     XLINKROLE: XbrlConst.footnote,
                                      XLINKLABEL: footnoteToLabel,
                                      "id": idDeduped(modelXbrl, noteId),
                                      # "oimNoteId": noteId
@@ -2816,6 +2818,8 @@ def _loadFromOIM(cntlr, error, warning, modelXbrl, oimFile, mappedUri):
                     modelObject=modelXbrl, action=currentAction, error=ex,
                     traceback=traceback.format_tb(sys.exc_info()[2]))
 
+    # Reset modified status of model so user is not prompted for changes triggered by this loading operation.
+    _return.isModified = False
     return _return
 
 def _isParamRef(value):

{arelle_release-2.37.5 → arelle_release-2.37.7}/arelle/plugin/inlineXbrlDocumentSet.py

@@ -441,7 +441,7 @@ def createTargetInstance(
         arcrole, linkrole, linkqname, arcqname = linkKey
         if (linkrole and linkqname and arcqname and  # fully specified roles
             arcrole != "XBRL-footnotes" and
-            any(lP.modelDocument.type == Type.INLINEXBRL for lP in linkPrototypes)):
+            any(lP.modelDocument.type in (Type.INLINEXBRL, Type.INLINEXBRLDOCUMENTSET) for lP in linkPrototypes)):
             for linkPrototype in linkPrototypes:
                 if linkPrototype not in footnoteLinks[linkrole]:
                     footnoteLinks[linkrole].append(linkPrototype)

{arelle_release-2.37.5 → arelle_release-2.37.7}/arelle/plugin/saveLoadableOIM.py

@@ -59,6 +59,7 @@ from __future__ import annotations
 import csv
 import io
 import json
+import operator
 import os
 import threading
 import zipfile
@@ -124,6 +125,17 @@ qnOimPeriodAspect = qname("period", noPrefixIsNoNamespace=True)
 qnOimEntityAspect = qname("entity", noPrefixIsNoNamespace=True)
 qnOimUnitAspect = qname("unit", noPrefixIsNoNamespace=True)
 
+reservedUriAliases = {
+    nsOim: "xbrl",
+    XbrlConst.defaultLinkRole: "_",
+    XbrlConst.factExplanatoryFact: "explanatoryFact",
+    XbrlConst.factFootnote: "footnote",
+    XbrlConst.iso4217: "iso4217",
+    XbrlConst.utr: "utr",
+    XbrlConst.xbrli: "xbrli",
+    XbrlConst.xsd: "xs",
+}
+
 ONE = Decimal(1)
 TEN = Decimal(10)
 NILVALUE = "nil"
@@ -142,6 +154,43 @@ csvOpenNewline = ""
 OimFact = dict[str, Any]
 OimReport = dict[str, Any]
 
+class NamespacePrefixes:
+    def __init__(self, prefixesByNamespace: dict[str, str] | None = None) -> None:
+        self._prefixesByNamespace: dict[str, str] = prefixesByNamespace or {}
+        self._usedPrefixes: set[str] = set(self._prefixesByNamespace.values())
+
+    @property
+    def namespaces(self) -> dict[str, str]:
+        return {
+            prefix: namespace
+            for namespace, prefix in sorted(
+                self._prefixesByNamespace.items(),
+                key=operator.itemgetter(1)
+            )
+        }
+
+    def __contains__(self, namespace: str) -> bool:
+        return namespace in self._prefixesByNamespace
+
+    def getPrefix(self, namespace: str) -> str | None:
+        return self._prefixesByNamespace.get(namespace)
+
+    def addNamespace(self, namespace: str, preferredPrefix: str) -> str:
+        prefix = self._prefixesByNamespace.get(namespace)
+        if prefix is not None:
+            return prefix
+
+        prefix = reservedUriAliases.get(namespace)
+        if prefix is None:
+            prefix = preferredPrefix
+            i = 2
+            while prefix in self._usedPrefixes:
+                prefix = f"{preferredPrefix}{i}"
+                i += 1
+        self._prefixesByNamespace[namespace] = prefix
+        self._usedPrefixes.add(prefix)
+        return prefix
+
 
 def saveLoadableOIM(
     modelXbrl: ModelXbrl,
@@ -160,20 +209,19 @@ def saveLoadableOIM(
     isXL = oimFile.endswith(".xlsx")
     isCSVorXL = isCSV or isXL
     if not isJSON and not isCSVorXL:
-        return
+        oimFile = oimFile + ".json"
+        isJSON = True
 
-    namespacePrefixes = {nsOim: "xbrl"}
-    prefixNamespaces: dict[str, str] = {}
+    namespacePrefixes = NamespacePrefixes({nsOim: "xbrl"})
     if extensionPrefixes:
         for extensionPrefix, extensionNamespace in extensionPrefixes.items():
-            namespacePrefixes[extensionNamespace] = extensionPrefix
-            prefixNamespaces[extensionPrefix] = extensionNamespace
+            namespacePrefixes.addNamespace(extensionNamespace, extensionPrefix)
     linkTypeAliases = {}
     groupAliases = {}
 
     def compileQname(qname: QName) -> None:
         if qname.namespaceURI is not None and qname.namespaceURI not in namespacePrefixes:
-            namespacePrefixes[qname.namespaceURI] = qname.prefix or ""
+            namespacePrefixes.addNamespace(qname.namespaceURI, qname.prefix or "")
 
     aspectsDefined = {qnOimConceptAspect, qnOimEntityAspect, qnOimPeriodAspect}
 
@@ -183,12 +231,8 @@ def saveLoadableOIM(
             return " ".join([oimValue(o) for o in obj])
         if isinstance(obj, QName) and obj.namespaceURI is not None:
             if obj.namespaceURI not in namespacePrefixes:
-                if obj.prefix:
-                    namespacePrefixes[obj.namespaceURI] = obj.prefix
-                else:
-                    _prefix = "_{}".format(sum(1 for p in namespacePrefixes if p.startswith("_")))
-                    namespacePrefixes[obj.namespaceURI] = _prefix
-            return f"{namespacePrefixes[obj.namespaceURI]}:{obj.localName}"
+                namespacePrefixes.addNamespace(obj.namespaceURI, obj.prefix or "_")
+            return f"{namespacePrefixes.getPrefix(obj.namespaceURI)}:{obj.localName}"
         if isinstance(obj, (float, Decimal)):
             try:
                 if isinf(obj):
@@ -198,7 +242,11 @@ def saveLoadableOIM(
                 elif isinstance(obj, Decimal):
                     # XML canonical representation of decimal requires a decimal point.
                     # https://www.w3.org/TR/xmlschema-2/#decimal-canonical-representation
-                    return f"{obj:.1f}" if obj % 1 == 0 else f"{obj}"
+                    if obj % 1 == 0:
+                        return f"{obj:.1f}"
+                    intPart, fracPart = f"{obj:f}".split(".")
+                    canonicalFracPart = fracPart.rstrip("0") or "0"
+                    return f"{intPart}.{canonicalFracPart}"
                 else:
                     return f"{obj}"
             except Exception:
@@ -283,8 +331,8 @@ def saveLoadableOIM(
                         _schemePrefix = "scheme"
                 else:
                     _schemePrefix = f"scheme{len(entitySchemePrefixes) + 1}"
-                entitySchemePrefixes[scheme] = _schemePrefix
-                namespacePrefixes[scheme] = _schemePrefix
+                namespacePrefixes.addNamespace(scheme, _schemePrefix)
+                entitySchemePrefixes[scheme] = namespacePrefixes.getPrefix(scheme)
         for dim in cntx.qnameDims.values():
             compileQname(dim.dimensionQname)
             aspectsDefined.add(dim.dimensionQname)
@@ -297,23 +345,17 @@ def saveLoadableOIM(
                 for measure in measures:
                     compileQname(measure)
 
-    if XbrlConst.xbrli in namespacePrefixes and namespacePrefixes[XbrlConst.xbrli] != "xbrli":
-        namespacePrefixes[XbrlConst.xbrli] = "xbrli"  # normalize xbrli prefix
-
     if hasLang:
         aspectsDefined.add(qnOimLangAspect)
     if hasUnits:
         aspectsDefined.add(qnOimUnitAspect)
 
     for footnoteRel in footnotesRelationshipSet.modelRelationships:
-        typePrefix = "ftTyp_" + os.path.basename(footnoteRel.arcrole)
-        if footnoteRel.linkrole == XbrlConst.defaultLinkRole:
-            groupPrefix = "ftGrp_default"
-        else:
-            groupPrefix = "ftGrp_" + os.path.basename(footnoteRel.linkrole)
         if footnoteRel.arcrole not in linkTypeAliases:
+            typePrefix = reservedUriAliases.get(footnoteRel.arcrole, f"ftTyp_{os.path.basename(footnoteRel.arcrole)}")
             linkTypeAliases[footnoteRel.arcrole] = typePrefix
-        if groupPrefix not in groupAliases:
+        if footnoteRel.linkrole not in groupAliases:
+            groupPrefix = reservedUriAliases.get(footnoteRel.linkrole, f"ftGrp_{os.path.basename(footnoteRel.linkrole)}")
             groupAliases[footnoteRel.linkrole] = groupPrefix
 
     dtsReferences = set()
@@ -354,12 +396,14 @@ def saveLoadableOIM(
                     _link[groupPrefix] = []
                 elif isCSVorXL:
                     _link[groupPrefix] = {}
+            tgtId = toObj.id if toObj.id else f"f{toObj.objectIndex}"
             if isJSON:
                 tgtIdList = _link[groupPrefix]
+                tgtIdList.append(tgtId)
             elif isCSVorXL:
-                tgtIdList = _link[groupPrefix].setdefault(srcId, [])
-            tgtId = toObj.id if toObj.id else f"f{toObj.objectIndex}"
-            tgtIdList.append(tgtId)
+                # Footnote links in xBRL-CSV include the CSV table identifier.
+                tgtIdList = _link[groupPrefix].setdefault(f"facts.r_{srcId}.value", [])
+                tgtIdList.append(f"footnotes.r_{tgtId}.footnote")
             footnote = {
                 "group": footnoteRel.linkrole,
                 "footnoteType": footnoteRel.arcrole,
@@ -441,19 +485,17 @@ def saveLoadableOIM(
             factFootnotes(fact, oimFact=oimFact)
         return oimFact
 
-    namespaces = {p: ns for ns, p in sorted(namespacePrefixes.items(), key=lambda item: item[1])}
-
     # common metadata
     oimReport = {}  # top level of oim json output
     oimReport["documentInfo"] = oimDocInfo = {}
     oimDocInfo["documentType"] = nsOim + ("/xbrl-json" if isJSON else "/xbrl-csv")
     if isJSON:
         oimDocInfo["features"] = oimFeatures = {}
-    oimDocInfo["namespaces"] = namespaces
+    oimDocInfo["namespaces"] = namespacePrefixes.namespaces
     if linkTypeAliases:
-        oimDocInfo["linkTypes"] = {a: u for u, a in sorted(linkTypeAliases.items(), key=lambda item: item[1])}
-    if linkTypeAliases:
-        oimDocInfo["linkGroups"] = {a: u for u, a in sorted(groupAliases.items(), key=lambda item: item[1])}
+        oimDocInfo["linkTypes"] = {a: u for u, a in sorted(linkTypeAliases.items(), key=operator.itemgetter(1))}
+    if groupAliases:
+        oimDocInfo["linkGroups"] = {a: u for u, a in sorted(groupAliases.items(), key=operator.itemgetter(1))}
     oimDocInfo["taxonomy"] = dtsReferences
     if isJSON:
         oimFeatures["xbrl:canonicalValues"] = True
@@ -511,6 +553,8 @@ def saveLoadableOIM(
             if outputZip:
                 fh.seek(0)
                 outputZip.writestr(os.path.basename(oimFile), fh.read())
+        if not outputZip:
+            modelXbrl.modelManager.cntlr.showStatus(_("Saved JSON OIM file {}").format(oimFile))
 
     elif isCSVorXL:
         # save CSV
@@ -678,21 +722,31 @@ def saveLoadableOIM(
 
         # save footnotes
         if footnotesRelationshipSet.modelRelationships:
-            footnotes = sorted(
-                (footnote for fact in modelXbrl.facts for footnote in factFootnotes(fact, csvLinks=csvLinks)),
-                key=lambda footnote: footnote["id"],
-            )
+            footnotesDeduplicatedById = {
+                footnote["id"]: footnote
+                for fact in modelXbrl.facts
+                for footnote in factFootnotes(fact, csvLinks=csvLinks)
+            }
+            footnotes = sorted(footnotesDeduplicatedById.values(), key=operator.itemgetter("id"))
             if footnotes:  # text footnotes
-                oimTables["footnotes"] = csvFtTable = {}
-                csvFtTable["url"] = "tbd"
-                csvFtTable["tableDimensions"] = {}
-                csvFtTable["factColumns"] = csvFtFactColumns = {}
-                csvFtFactColumns["footnote"] = csvFtValCol = {}
-                csvFtValCol["id"] = "$id"
-                csvFtValCol["noteId"] = "$id"
-                csvFtValCol["concept"] = "xbrl:note"
-                csvFtValCol["language"] = "$language"
-                _open("-footnotes.csv", "footnotes", csvFtTable)
+                footnotesTable = {"template": "footnotes"}
+                oimTables["footnotes"] = footnotesTable
+                csvTableTemplates[footnotesTable["template"]] = {
+                    "rowIdColumn" : "id",
+                    "dimensions": {
+                        "language": "$language"
+                    },
+                    "columns": {
+                        "id": {},
+                        "footnote": {
+                            "dimensions": {
+                                "concept": "xbrl:note",
+                            },
+                        },
+                        "language": {},
+                    }
+                }
+                _open("-footnotes.csv", "footnotes", footnotesTable)
                 cols = ("id", "footnote", "language")
                 _writerow(cols, header=True)
                 for footnote in footnotes:
@@ -702,16 +756,17 @@ def saveLoadableOIM(
         # save metadata
         if isCSV:
             assert isinstance(_baseURL, str)
-            with open(_baseURL + "-metadata.json", "w", encoding="utf-8") as fh:
+            csvMetadataFile = _baseURL + "-metadata.json"
+            with open(csvMetadataFile, "w", encoding="utf-8") as fh:
                 fh.write(json.dumps(oimReport, ensure_ascii=False, indent=2, sort_keys=False))
+            modelXbrl.modelManager.cntlr.showStatus(_("Saved CSV OIM metadata file {}").format(csvMetadataFile))
         elif isXL:
             _open(None, "metadata")
             _writerow(["metadata"], header=True)
             _writerow([json.dumps(oimReport, ensure_ascii=False, indent=1, sort_keys=False)])
             _close()
-
-        if isXL:
             workbook.save(oimFile)
+            modelXbrl.modelManager.cntlr.showStatus(_("Saved Excel file {}").format(oimFile))
 
 
 def saveLoadableOIMMenuCommand(cntlr: CntlrWinMain) -> None:
@@ -722,18 +777,23 @@ def saveLoadableOIMMenuCommand(cntlr: CntlrWinMain) -> None:
         or cntlr.modelManager.modelXbrl is None
         or cntlr.modelManager.modelXbrl.modelDocument is None
         or cntlr.modelManager.modelXbrl.modelDocument.type
-        not in (ModelDocument.Type.INSTANCE, ModelDocument.Type.INLINEXBRL)
+        not in (ModelDocument.Type.INSTANCE, ModelDocument.Type.INLINEXBRL, ModelDocument.Type.INLINEXBRLDOCUMENTSET)
     ):
+        cntlr.addToLog(
+            messageCode="arelleOIMsaver",
+            message=_("No supported XBRL instance documents loaded that can be saved to OIM format."),
+        )
         return
         # get file name into which to save log file while in foreground thread
     oimFile = cntlr.uiFileDialog(
         "save",
         title=_("arelle - Save Loadable OIM file"),
-        initialdir=cntlr.config.setdefault("loadableExcelFileDir", "."),
+        initialdir=cntlr.config.setdefault("loadableOIMFileDir", "."),
         filetypes=[(_("JSON file .json"), "*.json"), (_("CSV file .csv"), "*.csv"), (_("XLSX file .xlsx"), "*.xlsx")],
         defaultextension=".json",
     )  # type: ignore[no-untyped-call]
     if not isinstance(oimFile, str):
+        # User cancelled file dialog.
         return
 
     cntlr.config["loadableOIMFileDir"] = os.path.dirname(oimFile)

{arelle_release-2.37.5 → arelle_release-2.37.7}/arelle/plugin/validate/ESEF/ESEF_Current/ValidateXbrlFinally.py

@@ -606,7 +606,7 @@ def validateXbrlFinally(val: ValidateXbrl, *args: Any, **kwargs: Any) -> None:
             for context in contextsWithWrongInstantDate:
                 modelXbrl.error("ESEF.2.1.2.inappropriateInstantDate",
                                 _("Instant date %(actualValue)s in context %(contextID)s shall be replaced by %(expectedValue)s to ensure a better comparability between the facts."),
-                                modelObject=contextsWithWrongInstantDate, actualValue=context.instantDate, expectedValue=context.instantDate - timedelta(days=1), contextID=context.id)
+                                modelObject=context, actualValue=context.instantDate, expectedValue=context.instantDate - timedelta(days=1), contextID=context.id)
 
         # identify unique contexts and units
         mapContext = {}

{arelle_release-2.37.5 → arelle_release-2.37.7}/arelle/plugin/validate/NL/DisclosureSystems.py

@@ -2,4 +2,4 @@ DISCLOSURE_SYSTEM_NT16 = 'NT16'
 DISCLOSURE_SYSTEM_NT17 = 'NT17'
 DISCLOSURE_SYSTEM_NT18 = 'NT18'
 DISCLOSURE_SYSTEM_NT19 = 'NT19'
-DISCLOSURE_SYSTEM_INLINE_NT19 = 'INLINE-NT19'
+DISCLOSURE_SYSTEM_NL_INLINE_2024 = 'NL-INLINE-2024'

{arelle_release-2.37.5 → arelle_release-2.37.7}/arelle/plugin/validate/NL/PluginValidationDataExtension.py

@@ -9,16 +9,22 @@ import regex as re
 from collections import defaultdict
 from dataclasses import dataclass
 
-from arelle.ModelInstanceObject import ModelUnit, ModelContext, ModelFact
+from arelle.FunctionIxt import ixtNamespaces
+from arelle.ModelInstanceObject import ModelUnit, ModelContext, ModelFact, ModelInlineFootnote
 from arelle.ModelValue import QName
 from arelle.ModelXbrl import ModelXbrl
 from arelle.utils.PluginData import PluginData
 from arelle.XmlValidate import lexicalPatterns
 
-
 XBRLI_IDENTIFIER_PATTERN = re.compile(r"^(?!00)\d{8}$")
 XBRLI_IDENTIFIER_SCHEMA = 'http://www.kvk.nl/kvk-id'
 
+DISALLOWED_IXT_NAMESPACES = frozenset((
+    ixtNamespaces["ixt v1"],
+    ixtNamespaces["ixt v2"],
+    ixtNamespaces["ixt v3"],
+))
+
 @dataclass
 class PluginValidationDataExtension(PluginData):
     chamberOfCommerceRegistrationNumberQn: QName
@@ -42,6 +48,9 @@ class PluginValidationDataExtension(PluginData):
     _contextsWithSegments: list[ModelContext | None] | None = None
     _entityIdentifiers: set[tuple[str, str]] | None = None
     _factsByDocument: dict[str, list[ModelFact]] | None = None
+    _factLangs: set[str] | None = None
+    _noMatchLangFootnotes: set[ModelInlineFootnote] | None = None
+    _orphanedFootnotes: set[ModelInlineFootnote] | None = None
     _unitsByDocument: dict[str, list[ModelUnit]] | None = None
 
     def contextsByDocument(self, modelXbrl: ModelXbrl) -> dict[str, list[ModelContext]]:
@@ -80,6 +89,23 @@ class PluginValidationDataExtension(PluginData):
         self._contextsWithPeriodTimeZone = contextsWithPeriodTimeZone
         self._contextsWithSegments = contextsWithSegments
 
+    def checkFootnote(self, modelXbrl: ModelXbrl) -> None:
+        factLangs = self.factLangs(modelXbrl)
+        footnotesRelationshipSet = modelXbrl.relationshipSet("XBRL-footnotes")
+        orphanedFootnotes = set()
+        noMatchLangFootnotes = 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 not elt.xmlLang in factLangs:
+                            noMatchLangFootnotes.add(elt)
+        self._noMatchLangFootnotes = noMatchLangFootnotes
+        self._orphanedFootnotes = orphanedFootnotes
+
     def entityIdentifiersInDocument(self, modelXbrl: ModelXbrl) -> set[tuple[str, str]]:
         if self._entityIdentifiers is not None:
             return self._entityIdentifiers
@@ -95,6 +121,16 @@ class PluginValidationDataExtension(PluginData):
         self._factsByDocument = dict(factsByDocument)
         return self._factsByDocument
 
+    def factLangs(self, modelXbrl: ModelXbrl) -> set[str]:
+        if self._factLangs is not None:
+                return self._factLangs
+        factLangs = set()
+        for fact in modelXbrl.facts:
+            if fact is not None:
+                factLangs.add(fact.xmlLang)
+        self._factLangs = factLangs
+        return self._factLangs
+
     def getContextsWithImproperContent(self, modelXbrl: ModelXbrl) -> list[ModelContext | None]:
         if self._contextsWithImproperContent is None:
             self.checkContexts(self.contextsByDocument(modelXbrl))
@@ -119,6 +155,18 @@ class PluginValidationDataExtension(PluginData):
         assert(self._contextsWithSegments is not None)
         return self._contextsWithSegments
 
+    def getNoMatchLangFootnotes(self, modelXbrl: ModelXbrl) -> set[ModelInlineFootnote]:
+        if self._noMatchLangFootnotes is None:
+            self.checkFootnote(modelXbrl)
+        assert(self._noMatchLangFootnotes is not None)
+        return self._noMatchLangFootnotes
+
+    def getOrphanedFootnotes(self, modelXbrl: ModelXbrl) -> set[ModelInlineFootnote]:
+        if self._orphanedFootnotes is None:
+            self.checkFootnote(modelXbrl)
+        assert(self._orphanedFootnotes is not None)
+        return self._orphanedFootnotes
+
     def unitsByDocument(self, modelXbrl: ModelXbrl) -> dict[str, list[ModelUnit]]:
         if self._unitsByDocument is not None:
             return self._unitsByDocument

{arelle_release-2.37.5 → arelle_release-2.37.7}/arelle/plugin/validate/NL/ValidationPluginExtension.py

@@ -10,7 +10,7 @@ from arelle.ModelXbrl import ModelXbrl
 from arelle.ValidateXbrl import ValidateXbrl
 from arelle.typing import TypeGetText
 from arelle.utils.validate.ValidationPlugin import ValidationPlugin
-from .DisclosureSystems import DISCLOSURE_SYSTEM_NT16, DISCLOSURE_SYSTEM_NT17, DISCLOSURE_SYSTEM_NT18, DISCLOSURE_SYSTEM_NT19, DISCLOSURE_SYSTEM_INLINE_NT19
+from .DisclosureSystems import DISCLOSURE_SYSTEM_NT16, DISCLOSURE_SYSTEM_NT17, DISCLOSURE_SYSTEM_NT18, DISCLOSURE_SYSTEM_NT19, DISCLOSURE_SYSTEM_NL_INLINE_2024
 from .PluginValidationDataExtension import PluginValidationDataExtension
 
 _: TypeGetText
@@ -132,7 +132,7 @@ class ValidationPluginExtension(ValidationPlugin):
                 'kvk-rpt-jaarverantwoording-2023-nlgaap-verzekeringsmaatschappijen.xsd',
                 'kvk-rpt-jaarverantwoording-2023-nlgaap-zorginstellingen.xsd',
             ]}
-        elif disclosureSystem == DISCLOSURE_SYSTEM_NT19 or disclosureSystem == DISCLOSURE_SYSTEM_INLINE_NT19:
+        elif disclosureSystem == DISCLOSURE_SYSTEM_NT19 or disclosureSystem == DISCLOSURE_SYSTEM_NL_INLINE_2024:
             jenvNamespace = 'http://www.nltaxonomie.nl/nt19/jenv/20241211/dictionary/jenv-bw2-data'
             kvkINamespace = 'http://www.nltaxonomie.nl/nt19/kvk/20241211/dictionary/kvk-data'
             nlTypesNamespace = 'http://www.nltaxonomie.nl/nt19/sbr/20240301/dictionary/nl-types'
@@ -192,7 +192,7 @@ class ValidationPluginExtension(ValidationPlugin):
     def modelXbrlLoadComplete(self, modelXbrl: ModelXbrl, *args: Any, **kwargs: Any) -> ModelDocument | LoadingException | None:
         if self.disclosureSystemFromPluginSelected(modelXbrl):
             disclosureSystem = modelXbrl.modelManager.disclosureSystem.name
-            if disclosureSystem in (DISCLOSURE_SYSTEM_NT16, DISCLOSURE_SYSTEM_NT17, DISCLOSURE_SYSTEM_NT18, DISCLOSURE_SYSTEM_NT19, DISCLOSURE_SYSTEM_INLINE_NT19):
+            if disclosureSystem in (DISCLOSURE_SYSTEM_NT16, DISCLOSURE_SYSTEM_NT17, DISCLOSURE_SYSTEM_NT18, DISCLOSURE_SYSTEM_NT19, DISCLOSURE_SYSTEM_NL_INLINE_2024):
                 # Dutch taxonomies prior to 2025 incorrectly used hypercube linkrole for roots instead of dimension linkrole.
                 paramQName = qname('tlbDimRelsUseHcRoleForDomainRoots', noPrefixIsNoNamespace=True)
                 modelXbrl.modelManager.formulaOptions.parameterValues[paramQName] = (None, "true")

{arelle_release-2.37.5 → arelle_release-2.37.7}/arelle/plugin/validate/NL/__init__.py

@@ -14,6 +14,8 @@ from pathlib import Path
 from typing import Any
 
 from arelle.ModelDocument import LoadingException, ModelDocument
+from arelle.ModelXbrl import ModelXbrl
+from arelle.ValidateXbrl import ValidateXbrl
 from arelle.Version import authorLabel, copyrightLabel
 from .ValidationPluginExtension import ValidationPluginExtension
 from .rules import br_kvk, fg_nl, fr_kvk, fr_nl, nl_kvk
@@ -46,6 +48,16 @@ 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",
@@ -53,8 +65,10 @@ __pluginInfo__ = {
     "license": "Apache-2",
     "author": authorLabel,
     "copyright": copyrightLabel,
+    "import": ("inlineXbrlDocumentSet",),  # import dependent modules
     "DisclosureSystem.Types": disclosureSystemTypes,
     "DisclosureSystem.ConfigURL": disclosureSystemConfigURL,
     "ModelXbrl.LoadComplete": modelXbrlLoadComplete,
     "Validate.XBRL.Finally": validateXbrlFinally,
+    "ModelTestcaseVariation.ReportPackageIxdsOptions": modelTestcaseVariationReportPackageIxdsOptions,
 }

{arelle_release-2.37.5 → arelle_release-2.37.7}/arelle/plugin/validate/NL/resources/config.xml

@@ -4,8 +4,8 @@
         xsi:noNamespaceSchemaLocation="../../../../config/disclosuresystems.xsd">
     <!-- see arelle/config/disclosuresystems.xml for full comments -->
     <DisclosureSystem
-            names="INLINE-NT19|inline-nt19|kvk-ixbrl-2024-preview"
-            description="Checks for NT2024"
+            names="NL-INLINE-2024|nl-inline-2024|kvk-inline-2024-preview"
+            description="Checks for NL INLINE 2024"
             validationType="NL"
     />
     <DisclosureSystem