arelle-release 2.37.20__tar.gz → 2.37.21__tar.gz

{arelle_release-2.37.20/arelle_release.egg-info → arelle_release-2.37.21}/PKG-INFO

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

{arelle_release-2.37.20 → arelle_release-2.37.21}/arelle/CntlrCmdLine.py

@@ -537,6 +537,14 @@ def parseArgs(args):
         runtimeOptions = RuntimeOptions(pluginOptions=pluginOptions, **baseOptions)
     except RuntimeOptionsException as e:
         parser.error(f"{e}, please try\n python CntlrCmdLine.py --help")
+    if (
+        runtimeOptions.entrypointFile is None and
+        not runtimeOptions.proxy and
+        not runtimeOptions.plugins and
+        not pluginOptions and
+        not runtimeOptions.webserver
+    ):
+        parser.error("No entrypoint specified, please try\n python CntlrCmdLine.py --help")
     return runtimeOptions, arellePluginModules
 
 

{arelle_release-2.37.20 → arelle_release-2.37.21}/arelle/RuntimeOptions.py

@@ -183,12 +183,6 @@ class RuntimeOptions:
                 raise RuntimeOptionsException('Provided plugin options already exist as base options {}'.format(existingBaseOptions))
             for optionName, optionValue in pluginOptions.items():
                 setattr(self, optionName, optionValue)
-        if (self.entrypointFile is None and
-                not self.proxy and
-                not self.plugins and
-                not pluginOptions and
-                not self.webserver):
-            raise RuntimeOptionsException('Incorrect arguments')
         if self.webserver and not hasWebServer():
             raise RuntimeOptionsException("Webserver option requires webserver module")
         if self.webserver and any((

{arelle_release-2.37.20 → arelle_release-2.37.21}/arelle/XbrlConst.py

@@ -101,6 +101,7 @@ elementLabel = "http://xbrl.org/arcrole/2008/element-label"
 genLabel = "http://xbrl.org/2008/label"
 qnGenLabel = qname("{http://xbrl.org/2008/label}label")
 xbrldt = "http://xbrl.org/2005/xbrldt"
+qnXbrldtClosed = qname("{http://xbrl.org/2005/xbrldt}xbrldt:closed")
 qnXbrldtHypercubeItem = qname("{http://xbrl.org/2005/xbrldt}xbrldt:hypercubeItem")
 qnXbrldtDimensionItem = qname("{http://xbrl.org/2005/xbrldt}xbrldt:dimensionItem")
 qnXbrldtContextElement = qname("{http://xbrl.org/2005/xbrldt}xbrldt:contextElement")
@@ -108,6 +109,7 @@ xbrldi = "http://xbrl.org/2006/xbrldi"
 qnXbrldiExplicitMember = qname("{http://xbrl.org/2006/xbrldi}xbrldi:explicitMember")
 qnXbrldiTypedMember = qname("{http://xbrl.org/2006/xbrldi}xbrldi:typedMember")
 xlink = "http://www.w3.org/1999/xlink"
+qnXlinkArcRole = qname("{http://www.w3.org/1999/xlink}xlink:arcrole")
 xl = "http://www.xbrl.org/2003/XLink"
 qnXlExtended = qname("{http://www.xbrl.org/2003/XLink}xl:extended")
 qnXlLocator = qname("{http://www.xbrl.org/2003/XLink}xl:locator")

{arelle_release-2.37.20 → arelle_release-2.37.21}/arelle/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '2.37.20'
-__version_tuple__ = version_tuple = (2, 37, 20)
+__version__ = version = '2.37.21'
+__version_tuple__ = version_tuple = (2, 37, 21)

{arelle_release-2.37.20 → arelle_release-2.37.21}/arelle/api/Session.py

@@ -1,10 +1,7 @@
 """
 See COPYRIGHT.md for copyright information.
 
-The Arelle Python Beta API (located in `arelle.api` module) is an in-progress API module.
-A roadmap for this API is in development.
-
-Users of this API should expect changes in future releases.
+The `arelle.api` module is the supported method for integrating Arelle into other Python applications.
 """
 from __future__ import annotations
 
@@ -12,7 +9,7 @@ import logging
 from types import TracebackType
 from typing import Any, BinaryIO
 
-from arelle import PluginManager, PackageManager
+from arelle import PackageManager, PluginManager
 from arelle.CntlrCmdLine import CntlrCmdLine, createCntlrAndPreloadPlugins
 from arelle.ModelXbrl import ModelXbrl
 from arelle.RuntimeOptions import RuntimeOptions
@@ -81,6 +78,7 @@ class Session:
         responseZipStream: BinaryIO | None = None,
         logHandler: logging.Handler | None = None,
         logFilters: list[logging.Filter] | None = None,
+        sourceZipStreamFileName: str | None = None,
     ) -> bool:
         """
         Perform a run using the given options.
@@ -88,8 +86,11 @@ class Session:
         :param sourceZipStream: Optional stream to read source data from.
         :param responseZipStream: Options stream to write response data to.
         :param logHandler: Optional log handler to use for logging.
+        :param sourceZipStreamFileName: Optional file name to use for the passed zip stream.
         :return: True if the run was successful, False otherwise.
         """
+        if sourceZipStreamFileName is not None and sourceZipStream is None:
+            raise ValueError("sourceZipStreamFileName may only be provided if sourceZipStream is not None.")
         PackageManager.reset()
         PluginManager.reset()
         if self._cntlr is None:
@@ -143,4 +144,5 @@ class Session:
                 options,
                 sourceZipStream=sourceZipStream,
                 responseZipStream=responseZipStream,
+                sourceZipStreamFileName=sourceZipStreamFileName,
             )

arelle_release-2.37.21/arelle/plugin/validate/NL/LinkbaseType.py

@@ -0,0 +1,77 @@
+'''
+See COPYRIGHT.md for copyright information.
+'''
+from __future__ import annotations
+
+from enum import Enum
+
+from arelle import XbrlConst
+from arelle.ModelValue import QName
+
+
+class LinkbaseType(Enum):
+    CALCULATION = "calculation"
+    DEFINITION = "definition"
+    LABEL = "label"
+    PRESENTATION = "presentation"
+    REFERENCE = "reference"
+
+    @staticmethod
+    def fromRefUri(refUri: str | None) -> LinkbaseType | None:
+        """
+        Returns the LinkbaseType corresponding to the given ref URI.
+        If the URI does not match any known linkbase reference type, returns None.
+        """
+        if refUri is None:
+            return None
+        return LINKBASE_TYPE_BY_REF_URI.get(refUri, None)
+
+    def getArcQn(self) -> QName:
+        """
+        Returns the qname of the arc associated with this LinkbaseType.
+        """
+        return LINKBASE_ARC_QN[self]
+
+    def getLinkQn(self) -> QName:
+        """
+        Returns the qname of the link associated with this LinkbaseType.
+        """
+        return LINKBASE_LINK_QN[self]
+
+    def getLowerName(self) -> str:
+        """
+        Returns the lower-case name of this LinkbaseType.
+        """
+        return self.value.lower()
+
+    def getRefUri(self) -> str:
+        """
+        Returns the ref URI associated with this LinkbaseType.
+        """
+        return LINKBASE_REF_URIS[self]
+
+
+LINKBASE_ARC_QN = {
+    LinkbaseType.CALCULATION: XbrlConst.qnLinkCalculationArc,
+    LinkbaseType.DEFINITION: XbrlConst.qnLinkDefinitionArc,
+    LinkbaseType.LABEL: XbrlConst.qnLinkLabelArc,
+    LinkbaseType.PRESENTATION: XbrlConst.qnLinkPresentationArc,
+    LinkbaseType.REFERENCE: XbrlConst.qnLinkReferenceArc,
+}
+
+LINKBASE_LINK_QN = {
+    LinkbaseType.CALCULATION: XbrlConst.qnLinkCalculationLink,
+    LinkbaseType.DEFINITION: XbrlConst.qnLinkDefinitionLink,
+    LinkbaseType.LABEL: XbrlConst.qnLinkLabelLink,
+    LinkbaseType.PRESENTATION: XbrlConst.qnLinkPresentationLink,
+    LinkbaseType.REFERENCE: XbrlConst.qnLinkReferenceLink,
+}
+
+LINKBASE_REF_URIS = {
+    LinkbaseType.CALCULATION: "http://www.xbrl.org/2003/role/calculationLinkbaseRef",
+    LinkbaseType.DEFINITION: "http://www.xbrl.org/2003/role/definitionLinkbaseRef",
+    LinkbaseType.LABEL: "http://www.xbrl.org/2003/role/labelLinkbaseRef",
+    LinkbaseType.PRESENTATION: "http://www.xbrl.org/2003/role/presentationLinkbaseRef",
+    LinkbaseType.REFERENCE: "http://www.xbrl.org/2003/role/referenceLinkbaseRef",
+}
+LINKBASE_TYPE_BY_REF_URI = {v: k for k, v in LINKBASE_REF_URIS.items()}

{arelle_release-2.37.20 → arelle_release-2.37.21}/arelle/plugin/validate/NL/PluginValidationDataExtension.py

@@ -7,14 +7,15 @@ from collections import defaultdict
 from dataclasses import dataclass
 from functools import lru_cache
 from pathlib import Path
-from typing import Any, TYPE_CHECKING, cast
+from typing import Any, TYPE_CHECKING, cast, Iterable
 
 import regex as re
-from lxml.etree import _Comment, _ElementTree, _Entity, _ProcessingInstruction
+from lxml.etree import _Comment, _ElementTree, _Entity, _ProcessingInstruction, _Element
 
+from arelle import XbrlConst
 from arelle.FunctionIxt import ixtNamespaces
-from arelle import ModelDocument as ModelDocumentFile
-from arelle.ModelDocument import ModelDocument
+from arelle.ModelDocument import ModelDocument, Type as ModelDocumentType
+from arelle.ModelDtsObject import ModelConcept
 from arelle.ModelInstanceObject import ModelContext, ModelFact, ModelInlineFootnote, ModelUnit, ModelInlineFact
 from arelle.ModelObject import ModelObject
 from arelle.ModelValue import QName
@@ -22,10 +23,10 @@ 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
+from .LinkbaseType import LinkbaseType
 
 XBRLI_IDENTIFIER_PATTERN = re.compile(r"^(?!00)\d{8}$")
 XBRLI_IDENTIFIER_SCHEMA = 'http://www.kvk.nl/kvk-id'
@@ -57,11 +58,43 @@ ALLOWABLE_LANGUAGES = frozenset((
     'fr'
 ))
 
-EFFECTIVE_TAXONOMY_URLS = frozenset((
+EFFECTIVE_KVK_GAAP_IFRS_ENTRYPOINT_FILES = 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',
 ))
 
+TAXONOMY_URLS_BY_YEAR = {
+    '2024': {
+        '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',
+        'https://www.nltaxonomie.nl/kvk/2024-12-31/kvk-annual-report-other-gaap.xsd',
+    }
+}
+
+STANDARD_TAXONOMY_URLS = frozenset((
+    'http://www.nltaxonomie.nl/ifrs/20',
+    'https://www.nltaxonomie.nl/ifrs/20',
+    'http://www.nltaxonomie.nl/',
+    'https://www.nltaxonomie.nl/',
+    'http://www.xbrl.org/taxonomy/int/lei/',
+    'https://www.xbrl.org/taxonomy/int/lei/',
+    'http://www.xbrl.org/20',
+    'https://www.xbrl.org/20',
+    'http://www.xbrl.org/lrr/',
+    'https://www.xbrl.org/lrr/',
+    'http://xbrl.org/20',
+    'https://xbrl.org/20',
+    'http://xbrl.ifrs.org/',
+    'https://xbrl.ifrs.org/',
+    'http://www.xbrl.org/dtr/',
+    'https://www.xbrl.org/dtr/',
+    'http://xbrl.org/2020/extensible-enumerations-2.0',
+    'https://xbrl.org/2020/extensible-enumerations-2.0',
+    'http://www.w3.org/1999/xlink',
+    'https://www.w3.org/1999/xlink'
+))
+
+
 @dataclass(frozen=True)
 class ContextData:
     contextsWithImproperContent: list[ModelContext | None]
@@ -69,6 +102,48 @@ class ContextData:
     contextsWithPeriodTimeZone: list[ModelContext | None]
     contextsWithSegments: list[ModelContext | None]
 
+
+@dataclass(frozen=True)
+class ExtensionData:
+    extensionConcepts: list[ModelConcept]
+    extensionDocuments: dict[ModelDocument, ExtensionDocumentData]
+    extensionImportedUrls: frozenset[str]
+
+
+@dataclass(frozen=True)
+class ExtensionDocumentData:
+    basename: str
+    hrefXlinkRole: str | None
+    linkbases: list[LinkbaseData]
+
+    def iterArcsByType(
+            self,
+            linkbaseType: LinkbaseType,
+            includeArcroles: set[str] | None = None,
+            excludeArcroles: set[str] | None = None,
+    ) -> Iterable[_Element]:
+        """
+        Returns a list of LinkbaseData objects for the specified LinkbaseType.
+        """
+        for linkbase in self.iterLinkbasesByType(linkbaseType):
+            for arc in linkbase.arcs:
+                if includeArcroles is not None:
+                    if arc.get(XbrlConst.qnXlinkArcRole.clarkNotation) not in includeArcroles:
+                        continue
+                if excludeArcroles is not None:
+                    if arc.get(XbrlConst.qnXlinkArcRole.clarkNotation) in excludeArcroles:
+                        continue
+                yield arc
+
+    def iterLinkbasesByType(self, linkbaseType: LinkbaseType) -> Iterable[LinkbaseData]:
+        """
+        Returns a list of LinkbaseData objects for the specified LinkbaseType.
+        """
+        for linkbase in self.linkbases:
+            if linkbase.linkbaseType == linkbaseType:
+                yield linkbase
+
+
 @dataclass(frozen=True)
 class HiddenElementsData:
     cssHiddenFacts: set[ModelInlineFact]
@@ -76,6 +151,7 @@ class HiddenElementsData:
     hiddenFactsOutsideHiddenSection: set[ModelInlineFact]
     requiredToDisplayFacts: set[ModelInlineFact]
 
+
 @dataclass(frozen=True)
 class InlineHTMLData:
     baseElements: set[Any]
@@ -85,6 +161,19 @@ class InlineHTMLData:
     factLangFootnotes: dict[ModelInlineFootnote, set[str]]
     fractionElements: set[Any]
 
+
+@dataclass(frozen=True)
+class LinkbaseData:
+    arcs: list[_Element]
+    basename: str
+    element: _Element
+    linkbaseType: LinkbaseType | None
+
+    @property
+    def hasArcs(self) -> bool:
+        return len(self.arcs) > 0
+
+
 @dataclass
 class PluginValidationDataExtension(PluginData):
     chamberOfCommerceRegistrationNumberQn: QName
@@ -93,6 +182,7 @@ class PluginValidationDataExtension(PluginData):
     documentResubmissionUnsurmountableInaccuraciesQn: QName
     entrypointRoot: str
     entrypoints: set[str]
+    financialReportingPeriodQn: QName
     financialReportingPeriodCurrentStartDateQn: QName
     financialReportingPeriodCurrentEndDateQn: QName
     financialReportingPeriodPreviousStartDateQn: QName
@@ -144,21 +234,6 @@ 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()
@@ -169,7 +244,7 @@ class PluginValidationDataExtension(PluginData):
         presentedHiddenEltIds = defaultdict(list)
         requiredToDisplayFacts = set()
         for ixdsHtmlRootElt in modelXbrl.ixdsHtmlElements:
-            ixNStag = getattr(ixdsHtmlRootElt.modelDocument, "ixNStag", ixbrl11)
+            ixNStag = str(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):
@@ -218,7 +293,7 @@ class PluginValidationDataExtension(PluginData):
         tupleElements = set()
         orphanedFootnotes = set()
         for ixdsHtmlRootElt in modelXbrl.ixdsHtmlElements:
-            ixNStag = getattr(ixdsHtmlRootElt.modelDocument, "ixNStag", ixbrl11)
+            ixNStag = str(getattr(ixdsHtmlRootElt.modelDocument, "ixNStag", ixbrl11))
             ixTupleTag = ixNStag + "tuple"
             ixFractionTag = ixNStag + "fraction"
             for elts in modelXbrl.ixdsEltById.values():   # type: ignore[attr-defined]
@@ -291,6 +366,24 @@ class PluginValidationDataExtension(PluginData):
     def getContextsWithSegments(self, modelXbrl: ModelXbrl) -> list[ModelContext | None]:
         return self.checkContexts(modelXbrl).contextsWithSegments
 
+    @lru_cache(1)
+    def getDocumentsInDts(self, modelXbrl: ModelXbrl) -> dict[ModelDocument, str | None]:
+        modelDocuments: dict[ModelDocument, str | None] = {}
+        if modelXbrl.modelDocument is None:
+            return modelDocuments
+
+        def _getDocumentsInDts(modelDocument: ModelDocument) -> None:
+            for referencedDocument, modelDocumentReference in modelDocument.referencesDocument.items():
+                if referencedDocument in modelDocuments:
+                    continue
+                if referencedDocument.inDTS:
+                    modelDocuments[referencedDocument] = modelDocumentReference.referringXlinkRole
+                    _getDocumentsInDts(referencedDocument)
+
+        modelDocuments[modelXbrl.modelDocument] = None
+        _getDocumentsInDts(modelXbrl.modelDocument)
+        return modelDocuments
+
     def getEligibleForTransformHiddenFacts(self, modelXbrl: ModelXbrl) -> set[ModelInlineFact]:
         return self.checkHiddenElements(modelXbrl).eligibleForTransformHiddenFacts
 
@@ -321,8 +414,19 @@ class PluginValidationDataExtension(PluginData):
         )
 
     @lru_cache(1)
-    def getFilenameParts(self, filename: str) -> dict[str, Any] | None:
-        match = self.getFilenameFormatPattern().match(filename)
+    def getExtensionFilenameFormatPattern(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"(?<suffix>[_pre|_cal|_lab|_def]*)"
+            r"(?<lang>-*[^-]*)"
+            r"\.(?<extension>xsd|xml)$",
+            flags=re.ASCII
+        )
+
+    @lru_cache(1)
+    def getFilenameParts(self, filename: str, filenamePattern: re.Pattern[str]) -> dict[str, Any] | None:
+        match = filenamePattern.match(filename)
         if match:
             return match.groupdict()
         return None
@@ -331,6 +435,56 @@ class PluginValidationDataExtension(PluginData):
     def getIxdsDocBasenames(self, modelXbrl: ModelXbrl) -> set[str]:
         return set(Path(url).name for url in getattr(modelXbrl, "ixdsDocUrls", []))
 
+    def getExtensionConcepts(self, modelXbrl: ModelXbrl) -> list[ModelConcept]:
+        """
+        Returns a list of extension concepts in the DTS.
+        """
+        extensionConcepts = []
+        for concepts in modelXbrl.nameConcepts.values():
+            for concept in concepts:
+                if self.isExtensionUri(concept.qname.namespaceURI, modelXbrl):
+                    extensionConcepts.append(concept)
+        return extensionConcepts
+
+    @lru_cache(1)
+    def getExtensionData(self, modelXbrl: ModelXbrl) -> ExtensionData:
+        extensionDocuments = {}
+        extensionImportedUrls = set()
+        documentsInDts = self.getDocumentsInDts(modelXbrl)
+        for modelDocument, hrefXlinkRole in documentsInDts.items():
+            if not self.isExtensionUri(modelDocument.uri, modelDocument.modelXbrl):
+                # Skip non-extension documents
+                continue
+            if modelDocument.type in (ModelDocumentType.LINKBASE, ModelDocumentType.SCHEMA):
+                extensionDocuments[modelDocument] = ExtensionDocumentData(
+                    basename=modelDocument.basename,
+                    hrefXlinkRole=hrefXlinkRole,
+                    linkbases=self.getLinkbaseData(modelDocument),
+                )
+            if modelDocument.type == ModelDocumentType.SCHEMA:
+                for doc, docRef in modelDocument.referencesDocument.items():
+                    if "import" in docRef.referenceTypes:
+                        extensionImportedUrls.add(doc.uri)
+        return ExtensionData(
+            extensionConcepts=self.getExtensionConcepts(modelXbrl),
+            extensionDocuments=extensionDocuments,
+            extensionImportedUrls=frozenset(sorted(extensionImportedUrls)),
+        )
+
+    def getLinkbaseData(self, modelDocument: ModelDocument) -> list[LinkbaseData]:
+        linkbases = []
+        for linkbaseType in LinkbaseType:
+            for linkElt in modelDocument.xmlRootElement.iterdescendants(tag=linkbaseType.getLinkQn().clarkNotation):
+                arcQn = linkbaseType.getArcQn()
+                arcs = list(linkElt.iterdescendants(tag=arcQn.clarkNotation))
+                linkbases.append(LinkbaseData(
+                    arcs=arcs,
+                    basename=modelDocument.basename,
+                    element=linkElt,
+                    linkbaseType=linkbaseType,
+                ))
+        return linkbases
+
     def getNoMatchLangFootnotes(self, modelXbrl: ModelXbrl) -> set[ModelInlineFootnote]:
         return self.checkInlineHTMLElements(modelXbrl).noMatchLangFootnotes
 
@@ -346,6 +500,14 @@ class PluginValidationDataExtension(PluginData):
     def getTupleElements(self, modelXbrl: ModelXbrl) -> set[tuple[Any]]:
         return self.checkInlineHTMLElements(modelXbrl).tupleElements
 
+    @lru_cache(1)
+    def getReportingPeriod(self, modelXbrl: ModelXbrl) -> str | None:
+        reportingPeriodFacts = modelXbrl.factsByQname.get(self.financialReportingPeriodQn, set())
+        for fact in reportingPeriodFacts:
+            if fact.xValid >= VALID:
+                return cast(str, fact.xValue)
+        return None
+
     @lru_cache(1)
     def getReportXmlLang(self, modelXbrl: ModelXbrl) -> str | None:
         reportXmlLang = None
@@ -365,13 +527,20 @@ class PluginValidationDataExtension(PluginData):
     def getTargetElements(self, modelXbrl: ModelXbrl) -> list[Any]:
         targetElements = []
         for ixdsHtmlRootElt in modelXbrl.ixdsHtmlElements:
-            ixNStag = getattr(ixdsHtmlRootElt.modelDocument, "ixNStag", ixbrl11)
+            ixNStag = str(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
 
+    def isExtensionUri(self, uri: str, modelXbrl: ModelXbrl) -> bool:
+        if uri.startswith(modelXbrl.uriDir):
+            return True
+        if not any(uri.startswith(taxonomyUri) for taxonomyUri in STANDARD_TAXONOMY_URLS):
+            return True
+        return False
+
     @lru_cache(1)
     def isFilenameValidCharacters(self, filename: str) -> bool:
         match = self.getFilenameAllowedCharactersPattern().match(filename)

{arelle_release-2.37.20 → arelle_release-2.37.21}/arelle/plugin/validate/NL/ValidationPluginExtension.py

@@ -186,6 +186,7 @@ class ValidationPluginExtension(ValidationPlugin):
             documentResubmissionUnsurmountableInaccuraciesQn=qname(f'{{{kvkINamespace}}}DocumentResubmissionDueToUnsurmountableInaccuracies'),
             entrypointRoot=entrypointRoot,
             entrypoints=entrypoints,
+            financialReportingPeriodQn=qname(f'{{{jenvNamespace}}}FinancialReportingPeriod'),
             financialReportingPeriodCurrentStartDateQn=qname(f'{{{jenvNamespace}}}FinancialReportingPeriodCurrentStartDate'),
             financialReportingPeriodCurrentEndDateQn=qname(f'{{{jenvNamespace}}}FinancialReportingPeriodCurrentEndDate'),
             financialReportingPeriodPreviousStartDateQn=qname(f'{{{jenvNamespace}}}FinancialReportingPeriodPreviousStartDate'),

{arelle_release-2.37.20 → arelle_release-2.37.21}/arelle/plugin/validate/NL/__init__.py

@@ -46,9 +46,6 @@ def modelXbrlLoadComplete(*args: Any, **kwargs: Any) -> ModelDocument | LoadingE
 def validateFinally(*args: Any, **kwargs: Any) -> None:
     return validationPlugin.validateFinally(*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)
 
@@ -64,7 +61,6 @@ __pluginInfo__ = {
     "DisclosureSystem.Types": disclosureSystemTypes,
     "DisclosureSystem.ConfigURL": disclosureSystemConfigURL,
     "ModelXbrl.LoadComplete": modelXbrlLoadComplete,
-    "Validate.XBRL.Start": validateXbrlStart,
     "Validate.XBRL.Finally": validateXbrlFinally,
     "ValidateFormula.Finished": validateFinally,
 }