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

{arelle_release-2.37.6/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.6
+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.6 → 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.6 → 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.6'
-__version_tuple__ = version_tuple = (2, 37, 6)
+__version__ = version = '2.37.7'
+__version_tuple__ = version_tuple = (2, 37, 7)

{arelle_release-2.37.6 → 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.6 → 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.6 → 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.6 → 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.6 → arelle_release-2.37.7}/arelle/plugin/validate/NL/rules/nl_kvk.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 
 from datetime import date, timedelta
 
+from arelle.ModelInstanceObject import ModelInlineFact
 from arelle.XmlValidateConst import VALID
 from dateutil import relativedelta
 from collections.abc import Iterable
@@ -21,7 +22,7 @@ from arelle.utils.PluginHooks import ValidationHook
 from arelle.utils.validate.Decorator import validation
 from arelle.utils.validate.Validation import Validation
 from ..DisclosureSystems import DISCLOSURE_SYSTEM_NL_INLINE_2024
-from ..PluginValidationDataExtension import PluginValidationDataExtension, XBRLI_IDENTIFIER_PATTERN, XBRLI_IDENTIFIER_SCHEMA
+from ..PluginValidationDataExtension import PluginValidationDataExtension, XBRLI_IDENTIFIER_PATTERN, XBRLI_IDENTIFIER_SCHEMA, DISALLOWED_IXT_NAMESPACES
 
 if TYPE_CHECKING:
     from arelle.ModelXbrl import ModelXbrl
@@ -269,3 +270,78 @@ def rule_nl_kvk_3_2_1_1 (
             msg=_('Precision should not be used on numeric facts.'),
             modelObject = factsWithPrecision
         )
+
+
+@validation(
+    hook=ValidationHook.XBRL_FINALLY,
+    disclosureSystems=[
+        DISCLOSURE_SYSTEM_NL_INLINE_2024
+    ],
+)
+def rule_nl_kvk_3_2_3_1 (
+        pluginData: PluginValidationDataExtension,
+        val: ValidateXbrl,
+        *args: Any,
+        **kwargs: Any,
+) -> Iterable[Validation]:
+    """
+    NL-KVK.3.2.3.1: Transformation Registry 4 or newer are allowed. Everything else is prohibited.
+    """
+    transformRegistryErrors = []
+    for fact in val.modelXbrl.facts:
+        if isinstance(fact, ModelInlineFact):
+            if fact.format is not None and fact.format.namespaceURI in DISALLOWED_IXT_NAMESPACES:
+                transformRegistryErrors.append(fact)
+    if len(transformRegistryErrors) >0:
+        yield Validation.error(
+            codes='NL.NL-KVK.3.2.3.1.incorrectTransformationRuleApplied',
+            msg=_('Transformation Registry 4 or newer are allowed. Everything else is prohibited.'),
+            modelObject = transformRegistryErrors
+        )
+
+
+@validation(
+    hook=ValidationHook.XBRL_FINALLY,
+    disclosureSystems=[
+        DISCLOSURE_SYSTEM_NL_INLINE_2024
+    ],
+)
+def rule_nl_kvk_3_3_1_1 (
+        pluginData: PluginValidationDataExtension,
+        val: ValidateXbrl,
+        *args: Any,
+        **kwargs: Any,
+) -> Iterable[Validation]:
+    """
+    NL-KVK.3.3.1.1: Ensure that every nonempty <link:footnote> element is associated with at least one fact in the XBRL document.
+    """
+    orphanedFootnotes = pluginData.getOrphanedFootnotes(val.modelXbrl)
+    if len(orphanedFootnotes) >0:
+        yield Validation.error(
+            codes='NL.NL-KVK.3.3.1.1.unusedFootnote',
+            msg=_('Ensure that every nonempty <link:footnote> element is associated with at least one fact in the XBRL document.'),
+            modelObject = orphanedFootnotes
+        )
+
+@validation(
+    hook=ValidationHook.XBRL_FINALLY,
+    disclosureSystems=[
+        DISCLOSURE_SYSTEM_NL_INLINE_2024
+    ],
+)
+def rule_nl_kvk_3_3_1_2 (
+        pluginData: PluginValidationDataExtension,
+        val: ValidateXbrl,
+        *args: Any,
+        **kwargs: Any,
+) -> Iterable[Validation]:
+    """
+    NL-KVK.3.3.1.2: The xml:lang attribute of each footnote matches the language of at least one textual fact.
+    """
+    noMatchLangFootnotes = pluginData.getNoMatchLangFootnotes(val.modelXbrl)
+    if len(noMatchLangFootnotes) >0:
+        yield Validation.error(
+            codes='NL.NL-KVK.3.3.1.2.footnoteInLanguagesOtherThanLanguageOfContentOfAnyTextualFact',
+            msg=_('The xml:lang attribute of each footnote matches the language of at least one textual fact.'),
+            modelObject = noMatchLangFootnotes
+        )

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: arelle-release
-Version: 2.37.6
+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.6 → arelle_release-2.37.7}/tests/integration_tests/validation/conformance_suite_configurations/nl_inline_2024.py

@@ -19,15 +19,12 @@ config = ConformanceSuiteConfig(
     ],
     expected_failure_ids=frozenset([
         # Not Implemented
-        'conformance-suite-2024-sbr-domein-handelsregister/tests/G3-2-3_1/index.xml:TC3_invalid',
-        'conformance-suite-2024-sbr-domein-handelsregister/tests/G3-2-3_1/index.xml:TC4_invalid',
         'conformance-suite-2024-sbr-domein-handelsregister/tests/G3-2-4_2/index.xml:TC4_invalid',
         'conformance-suite-2024-sbr-domein-handelsregister/tests/G3-2-7_1/index.xml:TC4_invalid',
         'conformance-suite-2024-sbr-domein-handelsregister/tests/G3-2-7_1/index.xml:TC5_invalid',
         'conformance-suite-2024-sbr-domein-handelsregister/tests/G3-2-7_1/index.xml:TC6_invalid',
         'conformance-suite-2024-sbr-domein-handelsregister/tests/G3-2-7_1/index.xml:TC7_invalid',
-        'conformance-suite-2024-sbr-domein-handelsregister/tests/G3-3-1_1/index.xml:TC2_invalid',
-        'conformance-suite-2024-sbr-domein-handelsregister/tests/G3-3-1_2/index.xml:TC3_invalid',
+        'conformance-suite-2024-sbr-domein-handelsregister/tests/G3-3-1_2/index.xml:TC3_invalid', # Expects an error code with a preceding double quote. G3-3-1_3 expects the same code without the typo.
         'conformance-suite-2024-sbr-domein-handelsregister/tests/G3-3-1_3/index.xml:TC2_invalid',
         'conformance-suite-2024-sbr-domein-handelsregister/tests/G3-4-1_1/index.xml:TC2_invalid',
         'conformance-suite-2024-sbr-domein-handelsregister/tests/G3-4-1_2/index.xml:TC2_invalid',
@@ -61,6 +58,7 @@ config = ConformanceSuiteConfig(
         'conformance-suite-2024-sbr-domein-handelsregister/tests/G4-1-2_2/index.xml:TC2_invalid',
         'conformance-suite-2024-sbr-domein-handelsregister/tests/G4-2-0_1/index.xml:TC2_invalid',
         'conformance-suite-2024-sbr-domein-handelsregister/tests/G4-2-0_2/index.xml:TC2_invalid',
+        'conformance-suite-2024-sbr-domein-handelsregister/tests/G4-2-1_1/index.xml:TC2_invalid', # Expects scenarioNotUsedInExtensionTaxonomy and segmentUsed errors.  scenarioNotUsedInExtensionTaxonomy not yet implemented.
         'conformance-suite-2024-sbr-domein-handelsregister/tests/G4-2-2_2/index.xml:TC2_invalid',
         'conformance-suite-2024-sbr-domein-handelsregister/tests/G4-2-3_1/index.xml:TC2_invalid',
         'conformance-suite-2024-sbr-domein-handelsregister/tests/G4-3-1_1/index.xml:TC2_invalid',
@@ -114,5 +112,5 @@ config = ConformanceSuiteConfig(
     network_or_cache_required=False,
     plugins=frozenset({'validate/NL'}),
     shards=8,
-    test_case_result_options='match-any',
+    test_case_result_options='match-all',
 )