arelle-release 2.37.18__py3-none-any.whl → 2.37.19__py3-none-any.whl

arelle/plugin/saveOIMTaxonomy.py

@@ -0,0 +1,311 @@
+# -*- coding: utf-8 -*-
+'''
+saveOIMTaxonomy.py is a plug-in that saves an extension taxonomy in the json OIM taxonomy format
+
+See COPYRIGHT.md for copyright information.
+'''
+import os, io, json
+from arelle.Version import authorLabel, copyrightLabel
+from arelle import XbrlConst
+from collections import OrderedDict
+
+jsonDocumentType = "https://xbrl.org/PWD/2023-05-17/cti"
+jsonTxmyVersion = "1.0"
+primaryLang = "en"
+
+excludeImportNamespaces = {XbrlConst.xbrli, XbrlConst.xbrldt}
+
+def saveOIMTaxonomy(dts, jsonFile):
+    from arelle import ModelDocument, XmlUtil
+
+    # identify extension schema
+    namespacePrefixes = dict((ns, prefix) for prefix, ns in dts.prefixedNamespaces.items())
+    namespacesInUse = set()
+    extensionSchemaDoc = None
+    if dts.modelDocument.type == ModelDocument.Type.SCHEMA:
+        extensionSchemaDoc = dts.modelDocument
+    elif dts.modelDocument.type in (ModelDocument.Type.INSTANCE, ModelDocument.Type.INLINEXBRL, ModelDocument.Type.INLINEXBRLDOCUMENTSET):
+        for doc, docReference in dts.modelDocument.referencesDocument.items():
+            if "href" in docReference.referenceTypes:
+                extensionSchemaDoc = doc
+                extensionPrefix = namespacePrefixes[extensionSchemaDoc.targetNamespace]
+                namespacesInUse.add(extensionSchemaDoc.targetNamespace)
+                break
+    if extensionSchemaDoc is None:
+        dts.info("error:saveLoadableOIMTaxonomy",
+         _("Unable to identify extension taxonomy."),
+         modelObject=dts)
+        return
+
+    oimTxmy = OrderedDict()
+    oimTxmy["documentInfo"] = docInfo = OrderedDict()
+    docInfo["documentType"] = jsonDocumentType
+    docInfo["namespaces"] = namespaces = []
+    oimTxmy["taxonomy"] = txmy = OrderedDict()
+
+    # provide consistent order to taxonomy properties and objects
+    txmy["name"] = os.path.splitext(extensionSchemaDoc.basename)[0]
+    txmy["namespace"] = extensionSchemaDoc.targetNamespace
+    txmy["version"] = jsonTxmyVersion
+    txmy["entryPoint"] = os.path.basename(jsonFile)
+    txmy["importedTaxonomies"] = imports = []
+    txmy["concepts"] = concepts = []
+    txmy["cubes"] = cubes = []
+    txmy["domains"] = domains = []
+    txmy["networks"] = networks = []
+    txmy["relationships"] = relationships = []
+    txmy["labels"] = labels = []
+    sharedLabelRefs = {}
+    txmy["references"] = references = []
+
+    # taxonomy object
+    extensionLinkbaseDocs = {doc
+                             for doc, docReference in extensionSchemaDoc.referencesDocument.items()
+                             if "href" in docReference.referenceTypes and docReference.referringModelObject.elementQname == XbrlConst.qnLinkLinkbaseRef}
+    extensionLinkbaseDocs.add(extensionSchemaDoc)
+
+    labelsRelationshipSet = dts.relationshipSet(XbrlConst.conceptLabel)
+    for concept in sorted(set(dts.qnameConcepts.values()), key=lambda c:c.name): # may be twice if unqualified, with and without namespace
+        if concept.modelDocument == extensionSchemaDoc:
+            c = OrderedDict()
+            concepts.append(c)
+            c["name"] = str(concept.qname)
+            if concept.typeQname: # may be absent
+                c["dataType"] = str(concept.typeQname)
+            if concept.substitutionGroupQname:
+                c["substitutionGroup"] = str(concept.substitutionGroupQname)
+            if concept.periodType:
+                c["periodType"] = concept.periodType
+            if concept.balance:
+                c["balance"] = concept.balance
+            c["abstract"] = str(concept.abstract).lower()
+            c["nillable"] = str(concept.nillable).lower()
+        conceptLabels = dict(((lbl.role, lbl.xmlLang), lbl)
+                             for rel in labelsRelationshipSet.fromModelObject(concept)
+                             for lbl in (rel.toModelObject,)
+                             if lbl is not None)
+        for _key, label in sorted(conceptLabels.items(), key=lambda i:i[0]):
+            labelDupKey = (label.xmlLang, label.role, label.textValue)
+            if labelDupKey in sharedLabelRefs:
+                sharedLabelRefs[labelDupKey]["relatedId"].append(str(concept.qname))
+            else:
+                l = OrderedDict((
+                    ("relatedId", [str(concept.qname)]),
+                    ("language", label.xmlLang),
+                    ("labelType", os.path.basename(label.role)),
+                    ("value", label.textValue)))
+                labels.append(l)
+                sharedLabelRefs[labelDupKey] = l
+        # TBD add references here
+
+    # extended link roles defined in this document
+    networkOrder = 0
+    for roleURI, roleTypes in sorted(dts.roleTypes.items(),
+            # sort on definition if any else URI
+            key=lambda item: (item[1][0].definition if len(item[1]) and item[1][0].definition else item[0])):
+        for roleType in roleTypes:
+            if roleType.modelDocument == extensionSchemaDoc:
+                name = f"{extensionPrefix}:_{os.path.basename(roleURI)}_"
+                definition = roleType.definition
+                # define network concept (not in XBRL 2.1
+                c = OrderedDict((("name", name),
+                                 ("dataType","dtr:networkItemType"),
+                                 ("periodType", "duration"),
+                                 ("substitutionGroup", "xbrli:item"),
+                                 ("abstract", True),
+                                 ("nillable", True)))
+                concepts.append(c)
+                networks.append( OrderedDict((
+                    ("networkURI", roleType.roleURI),
+                    ("name", name))))
+                networkOrder += 1
+                relationships.append( OrderedDict((
+                    ("source", "xbrli:networkConcept"),
+                    ("target", name),
+                    ("order", networkOrder),
+                    ("networkURI", "https://www.xbrl.org/Network"),
+                    ("relationshipType", "root-child"))))
+                if definition:
+                    labels.append( OrderedDict((
+                        ("relatedId", [name]),
+                        ("language", primaryLang),
+                        ("labelType", XbrlConst.standardLabel),
+                        ("value", definition))))
+
+    # cubes by linkrole
+    for arcrole, linkrole, arcQN, linkQN in dts.baseSets.keys():
+        if arcrole == XbrlConst.all and linkrole is not None and arcQN is None and linkQN is None:
+            for rel in dts.relationshipSet(XbrlConst.all, linkrole).modelRelationships:
+                if rel.modelDocument not in extensionLinkbaseDocs:
+                    continue
+                hc = rel.toModelObject
+                priItem = rel.fromModelObject
+                if hc is not None and priItem is not None:
+                    dims = []
+                    dim = OrderedDict((("dimensionConcept", "xbrl:PrimaryDimension"),
+                                       ("domainID", priItem.name),
+                                       ("dimensionType", "xbrl:concept")))
+                    dims.append(dim)
+                    # priItem domains
+                    rels = []
+                    domains.append( OrderedDict((
+                        ("domainId", priItem.name),
+                        ("domainConcept", str(priItem.qname)),
+                        ("networkURI", rel.linkrole),
+                        ("relationships", rels))) )
+                    for domRel in dts.relationshipSet(XbrlConst.domainMember, rel.consecutiveLinkrole).fromModelObject(priItem):
+                        domObj = domRel.toModelObject
+                        if domObj is not None:
+                            rels.append( OrderedDict((
+                                ("source", str(priItem.qname)),
+                                ("target", str(domObj.qname)),
+                                ("order", domRel.order))) )
+                    # dimension domains
+                    for dimRel in dts.relationshipSet(XbrlConst.hypercubeDimension, rel.consecutiveLinkrole).fromModelObject(hc):
+                        dimObj = dimRel.toModelObject
+                        if dimObj is not None:
+                            dim = OrderedDict((("dimensionConcept", str(dimObj.qname)),
+                                               ("domainId", dimObj.name),
+                                               ("dimensionType", "explicit")))
+                            dims.append(dim)
+                            domRels = []
+                            domains.append( OrderedDict((
+                                ("domainId", dimObj.name),
+                                ("domainConcept", str(dimObj.qname)),
+                                ("networkURI", rel.linkrole),
+                                ("relationships", domRels))) )
+                            for domRel in dts.relationshipSet(XbrlConst.dimensionDomain, rel.consecutiveLinkrole).fromModelObject(dimObj):
+                                domObj = domRel.toModelObject
+                                if domObj is not None:
+                                    domRels.append( OrderedDict((
+                                        ("source", str(dimObj.qname)),
+                                        ("target", str(domObj.qname)),
+                                        ("order", domRel.order))) )
+                cubes.append( OrderedDict((
+                    ("name", str(hc.qname)),
+                    ("networkURI", rel.linkrole),
+                    ("cubeType", "aggregate"),
+                    ("dimensions", dims))) )
+
+    # domains
+
+    # tree walk recursive function
+    def treeWalk(depth, concept, arcrole, relSet, visited):
+        if concept is not None:
+            if concept not in visited:
+                visited.add(concept)
+                for rel in relSet.fromModelObject(concept):
+                    toConcept = rel.toModelObject
+                    if toConcept is not None:
+                        namespacesInUse.add(concept.qname.namespaceURI)
+                        namespacesInUse.add(toConcept.qname.namespaceURI)
+                        if rel.modelDocument in extensionLinkbaseDocs:
+                            relationships.append( OrderedDict((
+                                ("source", str(concept.qname)),
+                                ("target", str(toConcept.qname)),
+                                ("order", rel.order),
+                                ("networkURI", rel.linkrole),
+                                ("relationshipType", os.path.basename(rel.arcrole))) +
+                                ((("weight", rel.weight),) if rel.weight is not None else ())
+                                ) )
+                        row = treeWalk(depth + 1, toConcept, arcrole, relSet, visited)
+                visited.remove(concept)
+
+    # use presentation relationships for conceptsWs
+    for arcrole in (XbrlConst.parentChild,) + XbrlConst.summationItems:
+        # sort URIs by definition
+        linkroleUris = []
+        relationshipSet = dts.relationshipSet(arcrole)
+        if relationshipSet:
+            for linkroleUri in relationshipSet.linkRoleUris:
+                modelRoleTypes = dts.roleTypes.get(linkroleUri)
+                if modelRoleTypes:
+                    roledefinition = (modelRoleTypes[0].genLabel(strip=True) or modelRoleTypes[0].definition or linkroleUri)
+                else:
+                    roledefinition = linkroleUri
+                linkroleUris.append((roledefinition, linkroleUri))
+            linkroleUris.sort()
+
+            # for each URI in definition order
+            for roledefinition, linkroleUri in linkroleUris:
+                # elr relationships for tree walk
+                linkRelationshipSet = dts.relationshipSet(arcrole, linkroleUri)
+                for rootConcept in linkRelationshipSet.rootConcepts:
+                    # is root child required?
+                    treeWalk(0, rootConcept, arcrole, linkRelationshipSet, set())
+
+    for ns in sorted(namespacesInUse, key=lambda ns: namespacePrefixes[ns]):
+        namespaces.append(OrderedDict((("prefix", namespacePrefixes[ns]),
+                                       ("uri", ns))))
+
+    try:
+        with open(jsonFile, "w") as fh:
+            fh.write(json.dumps(oimTxmy, indent=3))
+
+        dts.info("info:saveOIMTaxonomy",
+            _("Saved OIM Taxonomy file: %(excelFile)s"),
+            excelFile=os.path.basename(jsonFile),
+            modelXbrl=dts)
+    except Exception as ex:
+        dts.error("exception:saveOIMTaxonomy",
+            _("File saving exception: %(error)s"), error=ex,
+            modelXbrl=dts)
+
+def saveOIMTaxonomyMenuEntender(cntlr, menu, *args, **kwargs):
+    # Extend menu with an item for the savedts plugin
+    menu.add_command(label="Save OIM Taxonomy",
+                     underline=0,
+                     command=lambda: saveOIMTaxonomyMenuCommand(cntlr) )
+
+def saveOIMTaxonomyMenuCommand(cntlr):
+    # save DTS menu item has been invoked
+    if cntlr.modelManager is None or cntlr.modelManager.modelXbrl is None:
+        cntlr.addToLog("No taxonomy loaded.")
+        return
+        # get file name into which to save log file while in foreground thread
+    jsonFile = cntlr.uiFileDialog("save",
+            title=_("arelle - Save OIM Taxonomy file"),
+            initialdir=cntlr.config.setdefault("OIMTaxonomyFileDir","."),
+            filetypes=[(_("OIM Taxonomy .json"), "*.json")],
+            defaultextension=".json")
+    if not jsonFile:
+        return False
+    import os
+    cntlr.config["OIMTaxonomyFileDir"] = os.path.dirname(jsonFile)
+    cntlr.saveConfig()
+
+    import threading
+    thread = threading.Thread(target=lambda
+                                  _dts=cntlr.modelManager.modelXbrl,
+                                  _jsonFile=jsonFile:
+                                        saveOIMTaxonomy(_dts, _jsonFile))
+    thread.daemon = True
+    thread.start()
+
+def saveOIMTaxonomyCommandLineOptionExtender(parser, *args, **kwargs):
+    # extend command line options with a save DTS option
+    parser.add_option("--save-OIM-taxonomy",
+                      dest="saveOIMTaxonomy",
+                      help=_("Save OIM Taxonomy file"))
+
+def saveOIMTaxonomyCommandLineXbrlRun(cntlr, options, modelXbrl, *args, **kwargs):
+    # extend XBRL-loaded run processing for this option
+    jsonFile = getattr(options, "saveOIMTaxonomy", None)
+    if jsonFile:
+        if cntlr.modelManager is None or cntlr.modelManager.modelXbrl is None:
+            cntlr.addToLog("No taxonomy loaded.")
+            return
+        saveOIMTaxonomy(cntlr.modelManager.modelXbrl, jsonFile)
+
+__pluginInfo__ = {
+    'name': 'Save OIM Taxonomy',
+    'version': '0.9',
+    'description': "This plug-in saves an OIM Taxonomy.",
+    'license': 'Apache-2',
+    'author': authorLabel,
+    'copyright': copyrightLabel,
+    # classes of mount points (required)
+    'CntlrWinMain.Menu.Tools': saveOIMTaxonomyMenuEntender,
+    'CntlrCmdLine.Options': saveOIMTaxonomyCommandLineOptionExtender,
+    'CntlrCmdLine.Xbrl.Run': saveOIMTaxonomyCommandLineXbrlRun,
+}

arelle/plugin/validate/NL/PluginValidationDataExtension.py

@@ -13,6 +13,8 @@ import regex as re
 from lxml.etree import _Comment, _ElementTree, _Entity, _ProcessingInstruction
 
 from arelle.FunctionIxt import ixtNamespaces
+from arelle import ModelDocument as ModelDocumentFile
+from arelle.ModelDocument import ModelDocument
 from arelle.ModelInstanceObject import ModelContext, ModelFact, ModelInlineFootnote, ModelUnit, ModelInlineFact
 from arelle.ModelObject import ModelObject
 from arelle.ModelValue import QName
@@ -20,13 +22,14 @@ 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.ValidateXbrl import ValidateXbrl
 from arelle.XbrlConst import ixbrl11, xhtmlBaseIdentifier, xmlBaseIdentifier
 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'
-
+MAX_REPORT_PACKAGE_SIZE_MBS = 100
 
 DISALLOWED_IXT_NAMESPACES = frozenset((
     ixtNamespaces["ixt v1"],
@@ -54,6 +57,11 @@ ALLOWABLE_LANGUAGES = frozenset((
     'fr'
 ))
 
+EFFECTIVE_TAXONOMY_URLS = frozenset((
+    'https://www.nltaxonomie.nl/kvk/2024-12-31/kvk-annual-report-nlgaap-ext.xsd',
+    'https://www.nltaxonomie.nl/kvk/2024-12-31/kvk-annual-report-ifrs-ext.xsd',
+))
+
 @dataclass(frozen=True)
 class ContextData:
     contextsWithImproperContent: list[ModelContext | None]
@@ -136,6 +144,21 @@ class PluginValidationDataExtension(PluginData):
             contextsWithSegments=contextsWithSegments,
         )
 
+    def checkFilingDTS(
+            self,
+            val: ValidateXbrl,
+            modelDocument: ModelDocument,
+            visited: list[ModelDocument]
+    ) -> None:
+        visited.append(modelDocument)
+        for referencedDocument, modelDocumentReference in modelDocument.referencesDocument.items():
+            if referencedDocument not in visited and referencedDocument.inDTS:
+                self.checkFilingDTS(val, referencedDocument, visited)
+        if modelDocument.type == ModelDocumentFile.Type.SCHEMA:
+            for doc, docRef in modelDocument.referencesDocument.items():
+                if "import" in docRef.referenceTypes:
+                    val.extensionImportedUrls.add(doc.uri)
+
     @lru_cache(1)
     def checkHiddenElements(self, modelXbrl: ModelXbrl) -> HiddenElementsData:
         cssHiddenFacts = set()
@@ -338,6 +361,17 @@ class PluginValidationDataExtension(PluginData):
                         firstRootmostXmlLangDepth = depth
         return reportXmlLang
 
+    @lru_cache(1)
+    def getTargetElements(self, modelXbrl: ModelXbrl) -> list[Any]:
+        targetElements = []
+        for ixdsHtmlRootElt in modelXbrl.ixdsHtmlElements:
+            ixNStag = getattr(ixdsHtmlRootElt.modelDocument, "ixNStag", ixbrl11)
+            ixTags = set(ixNStag + ln for ln in ("nonNumeric", "nonFraction", "references", "relationship"))
+            for elt, depth in etreeIterWithDepth(ixdsHtmlRootElt):
+                if elt.tag in ixTags and elt.get("target"):
+                    targetElements.append(elt)
+        return targetElements
+
     @lru_cache(1)
     def isFilenameValidCharacters(self, filename: str) -> bool:
         match = self.getFilenameAllowedCharactersPattern().match(filename)

arelle/plugin/validate/NL/__init__.py

@@ -43,6 +43,8 @@ def disclosureSystemConfigURL(*args: Any, **kwargs: Any) -> str:
 def modelXbrlLoadComplete(*args: Any, **kwargs: Any) -> ModelDocument | LoadingException | None:
     return validationPlugin.modelXbrlLoadComplete(*args, **kwargs)
 
+def validateXbrlStart(val: ValidateXbrl, parameters: dict[Any, Any], *args: Any, **kwargs: Any) -> None:
+    val.extensionImportedUrls = set()
 
 def validateXbrlFinally(*args: Any, **kwargs: Any) -> None:
     return validationPlugin.validateXbrlFinally(*args, **kwargs)
@@ -59,5 +61,6 @@ __pluginInfo__ = {
     "DisclosureSystem.Types": disclosureSystemTypes,
     "DisclosureSystem.ConfigURL": disclosureSystemConfigURL,
     "ModelXbrl.LoadComplete": modelXbrlLoadComplete,
+    "Validate.XBRL.Start": validateXbrlStart,
     "Validate.XBRL.Finally": validateXbrlFinally,
 }

arelle/plugin/validate/NL/rules/nl_kvk.py

@@ -4,6 +4,7 @@ See COPYRIGHT.md for copyright information.
 from __future__ import annotations
 
 from datetime import date
+import zipfile
 
 from arelle.ModelInstanceObject import ModelInlineFact
 from arelle.ValidateDuplicateFacts import getDuplicateFactSets
@@ -20,8 +21,10 @@ from arelle.utils.validate.Validation import Validation
 from arelle.ValidateDuplicateFacts import getHashEquivalentFactGroups, getAspectEqualFacts
 from arelle.utils.validate.ValidationUtil import etreeIterWithDepth
 from ..DisclosureSystems import DISCLOSURE_SYSTEM_NL_INLINE_2024
-from ..PluginValidationDataExtension import (PluginValidationDataExtension, XBRLI_IDENTIFIER_PATTERN,
-                                             XBRLI_IDENTIFIER_SCHEMA, DISALLOWED_IXT_NAMESPACES, ALLOWABLE_LANGUAGES)
+from ..PluginValidationDataExtension import (PluginValidationDataExtension, ALLOWABLE_LANGUAGES,
+                                             DISALLOWED_IXT_NAMESPACES, EFFECTIVE_TAXONOMY_URLS,
+                                             MAX_REPORT_PACKAGE_SIZE_MBS, XBRLI_IDENTIFIER_PATTERN,
+                                             XBRLI_IDENTIFIER_SCHEMA)
 
 if TYPE_CHECKING:
     from arelle.ModelXbrl import ModelXbrl
@@ -700,6 +703,30 @@ def rule_nl_kvk_3_5_2_3(
         )
 
 
+@validation(
+    hook=ValidationHook.XBRL_FINALLY,
+    disclosureSystems=[
+        DISCLOSURE_SYSTEM_NL_INLINE_2024
+    ],
+)
+def rule_nl_kvk_3_5_3_1(
+        pluginData: PluginValidationDataExtension,
+        val: ValidateXbrl,
+        *args: Any,
+        **kwargs: Any,
+) -> Iterable[Validation]:
+    """
+    NL-KVK.3.5.3.1: The default target attribute MUST be used for the annual report content.
+    """
+    targetElements = pluginData.getTargetElements(val.modelXbrl)
+    if targetElements:
+        yield Validation.error(
+            codes='NL.NL-KVK.3.5.3.1.defaultTargetAttributeNotUsed',
+            msg=_('Target attribute must not be used for the annual report content.'),
+            modelObject=targetElements
+        )
+
+
 @validation(
     hook=ValidationHook.XBRL_FINALLY,
     disclosureSystems=[
@@ -818,3 +845,58 @@ def rule_nl_kvk_3_6_3_3(
                   'Allowed characters include: A-Z, a-z, 0-9, underscore ( _ ), period ( . ), and hyphen ( - ). '
                   'Update filing naming to review unallowed characters. '
                   'Invalid filenames: %(invalidBasenames)s'))
+
+
+@validation(
+    hook=ValidationHook.XBRL_FINALLY,
+    disclosureSystems=[
+        DISCLOSURE_SYSTEM_NL_INLINE_2024
+    ],
+)
+def rule_nl_kvk_4_1_2_1(
+        pluginData: PluginValidationDataExtension,
+        val: ValidateXbrl,
+        *args: Any,
+        **kwargs: Any,
+) -> Iterable[Validation]:
+    """
+    NL-KVK.4.1.2.1: Validate that the imported taxonomy matches the KVK-specified entry point.
+        - https://www.nltaxonomie.nl/kvk/2024-12-31/kvk-annual-report-nlgaap-ext.xsd,
+        - https://www.nltaxonomie.nl/kvk/2024-12-31/kvk-annual-report-ifrs-ext.xsd.
+    """
+    if val.modelXbrl.modelDocument is not None:
+        pluginData.checkFilingDTS(val, val.modelXbrl.modelDocument, [])
+        if not any(e in val.extensionImportedUrls for e in EFFECTIVE_TAXONOMY_URLS):
+            yield Validation.error(
+                codes='NL.NL-KVK.4.1.2.1.requiredEntryPointNotImported',
+                msg=_('The extension taxonomy must import the entry point of the taxonomy files prepared by KVK.'),
+                modelObject=val.modelXbrl.modelDocument
+            )
+
+
+@validation(
+    hook=ValidationHook.XBRL_FINALLY,
+    disclosureSystems=[
+        DISCLOSURE_SYSTEM_NL_INLINE_2024
+    ],
+)
+def rule_nl_kvk_6_1_1_1(
+        pluginData: PluginValidationDataExtension,
+        val: ValidateXbrl,
+        *args: Any,
+        **kwargs: Any,
+) -> Iterable[Validation]:
+    """
+    NL-KVK.6.1.1.1: The size of the report package MUST NOT exceed 100 MB.
+    """
+    if val.modelXbrl.fileSource.fs and isinstance(val.modelXbrl.fileSource.fs, zipfile.ZipFile):
+        maxMB = float(MAX_REPORT_PACKAGE_SIZE_MBS)
+        # The following code computes report package size by adding the compressed file sizes within the package.
+        # This method of computation is over 99% accurate and gets more accurate the larger the filesize is.
+        _size = sum(zi.compress_size for zi in val.modelXbrl.fileSource.fs.infolist())
+        if _size > maxMB * 1000000:
+            yield Validation.error(
+                codes='NL.NL-KVK.6.1.1.1.reportPackageMaximumSizeExceeded',
+                msg=_('The size of the report package must not exceed %(maxSize)s MBs, size is %(size)s MBs.'),
+                modelObject=val.modelXbrl, maxSize=MAX_REPORT_PACKAGE_SIZE_MBS, size=int(_size/1000000)
+            )

{arelle_release-2.37.18.dist-info → arelle_release-2.37.19.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: arelle-release
-Version: 2.37.18
+Version: 2.37.19
 Summary: An open source XBRL platform.
 Author-email: "arelle.org" <support@arelle.org>
 License: Apache-2.0
@@ -32,6 +32,7 @@ License-File: LICENSE.md
 Requires-Dist: bottle<0.14,>=0.13
 Requires-Dist: certifi
 Requires-Dist: filelock
+Requires-Dist: jsonschema==4.*
 Requires-Dist: isodate==0.*
 Requires-Dist: lxml<6,>=4
 Requires-Dist: numpy<3,>=1