arelle-release 2.37.28__tar.gz → 2.37.29__tar.gz

{arelle_release-2.37.28 → arelle_release-2.37.29}/.gitignore

@@ -47,6 +47,7 @@ obj/
 tests/resources/conformance_suites/*
 !tests/resources/conformance_suites/cipc/
 !tests/resources/conformance_suites/dba/
+!tests/resources/conformance_suites/edinet/
 !tests/resources/conformance_suites/hmrc/
 !tests/resources/conformance_suites/nl_*/
 !tests/resources/conformance_suites/ros/

{arelle_release-2.37.28/arelle_release.egg-info → arelle_release-2.37.29}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: arelle-release
-Version: 2.37.28
+Version: 2.37.29
 Summary: An open source XBRL platform.
 Author-email: "arelle.org" <support@arelle.org>
 License: Apache-2.0
@@ -41,6 +41,7 @@ Requires-Dist: pillow<12,>=10
 Requires-Dist: pyparsing==3.*
 Requires-Dist: python-dateutil==2.*
 Requires-Dist: regex
+Requires-Dist: truststore==0.*; python_version > "3.9"
 Requires-Dist: typing-extensions==4.*
 Provides-Extra: crypto
 Requires-Dist: pycryptodome==3.*; extra == "crypto"

{arelle_release-2.37.28 → arelle_release-2.37.29}/arelle/ModelTestcaseObject.py

@@ -319,9 +319,15 @@ class ModelTestcaseVariation(ModelObject):
         errorElements = XmlUtil.descendants(self, None, "error")
         resultElement = XmlUtil.descendant(self, None, "result")
         if isinstance(errorElements,list) and len(errorElements) > 0:
-            return [ModelValue.qname(e, e.stringValue) if not e.get("nonStandardErrorCodes")
-                    else e.stringValue
-                    for e in errorElements]
+            errorCodes = []
+            for errorElement in errorElements:
+                if errorElement.get("nonStandardErrorCodes"):
+                    errorCode = errorElement.stringValue
+                else:
+                    errorCode = ModelValue.qname(errorElement, errorElement.stringValue)
+                num = int(errorElement.attr("num") or 1)
+                errorCodes.extend([errorCode] * num)
+            return errorCodes
         #else:
         #    errorElement = errorElements[1]
         #    if errorElement is not None and not errorElement.get("nonStandardErrorCodes"):

{arelle_release-2.37.28 → arelle_release-2.37.29}/arelle/Validate.py

@@ -338,17 +338,18 @@ class Validate:
             loadedModels.append(modelXbrl)
             PackageManager.packageInfo(self.modelXbrl.modelManager.cntlr, readMeFirstUri, reload=True, errors=modelXbrl.errors)
         else: # not a multi-schemaRef versioning report
+            readMeFirstUriIsArchive = isReportPackageExtension(readMeFirstUri)
             readMeFirstUriIsEmbeddedZipFile = False
             if self.useFileSource.isArchive and not isLegacyAbs(readMeFirstUri):
-                if isReportPackageExtension(readMeFirstUri):
+                if readMeFirstUriIsArchive:
                     readMeFirstUriIsEmbeddedZipFile = True
                 else:
                     normalizedReadMeFirstUri = self.modelXbrl.modelManager.cntlr.webCache.normalizeUrl(readMeFirstUri, baseForElement)
                     archivePath = FileSource.archiveFilenameParts(normalizedReadMeFirstUri)
                     if archivePath:
                         with self.useFileSource.fs.open(archivePath[1]) as embeddedFile:
-                            readMeFirstUriIsEmbeddedZipFile = zipfile.is_zipfile(embeddedFile)
-            if not readMeFirstUriIsEmbeddedZipFile:
+                            readMeFirstUriIsArchive = readMeFirstUriIsEmbeddedZipFile = zipfile.is_zipfile(embeddedFile)
+            if not readMeFirstUriIsArchive:
                 modelXbrl = ModelXbrl.load(self.modelXbrl.modelManager,
                                             readMeFirstUri,
                                             _("validating"),
@@ -400,7 +401,16 @@ class Validate:
                                 # resolve an IXDS in entrypoints
                                 for pluginXbrlMethod in pluginClassMethods("ModelTestcaseVariation.ArchiveIxds"):
                                     pluginXbrlMethod(self, filesource,entrypoints)
-                                filesource.select(entrypoints[0].get("file", None))
+                                for entrypoint in entrypoints:
+                                    filesource.select(entrypoint.get("file", None))
+                                    modelXbrl = ModelXbrl.load(self.modelXbrl.modelManager,
+                                                               filesource,
+                                                               _("validating"),
+                                                               base=filesource.basefile + "/",
+                                                               errorCaptureLevel=errorCaptureLevel,
+                                                               ixdsTarget=modelTestcaseVariation.ixdsTarget,
+                                                               errors=preLoadingErrors)
+                                    loadedModels.append(modelXbrl)
                     except Exception as err:
                         self.modelXbrl.error("exception:" + type(err).__name__,
                             _("Testcase variation validation exception: %(error)s, entry URL: %(instance)s"),
@@ -427,15 +437,16 @@ class Validate:
                         # Legacy ESEF conformance suite logic.
                         for pluginXbrlMethod in pluginClassMethods("ModelTestcaseVariation.ReportPackageIxds"):
                                 filesource.select(pluginXbrlMethod(filesource, **_rptPkgIxdsOptions))
-                    modelXbrl = ModelXbrl.load(self.modelXbrl.modelManager,
-                                                filesource,
-                                                _("validating"),
-                                                base=baseForElement,
-                                                errorCaptureLevel=errorCaptureLevel,
-                                                ixdsTarget=modelTestcaseVariation.ixdsTarget,
-                                                isLoadable=modelTestcaseVariation.variationDiscoversDTS or filesource.url,
-                                                errors=preLoadingErrors)
-                    loadedModels.append(modelXbrl)
+                    if len(loadedModels) == 0:
+                        modelXbrl = ModelXbrl.load(self.modelXbrl.modelManager,
+                                                    filesource,
+                                                    _("validating"),
+                                                    base=baseForElement,
+                                                    errorCaptureLevel=errorCaptureLevel,
+                                                    ixdsTarget=modelTestcaseVariation.ixdsTarget,
+                                                    isLoadable=modelTestcaseVariation.variationDiscoversDTS or filesource.url,
+                                                    errors=preLoadingErrors)
+                        loadedModels.append(modelXbrl)
 
         for model in loadedModels:
             modelXbrl.isTestcaseVariation = True
@@ -730,7 +741,11 @@ class Validate:
                 indexPath = indexPath[len(baseZipFile) + 1:]
             indexPath = indexPath.replace("\\", "/")
         variationIdPath = f'{indexPath}:{modelTestcaseVariation.id}'
-        if userExpectedErrors := testcaseExpectedErrors.get(variationIdPath):
+        userExpectedErrors = []
+        for userPattern, userErrors in testcaseExpectedErrors.items():
+            if fnmatch.fnmatch(variationIdPath, userPattern):
+                userExpectedErrors.extend(userErrors)
+        if userExpectedErrors:
             if expected is None:
                 expected = []
             if isinstance(expected, str):

{arelle_release-2.37.28 → arelle_release-2.37.29}/arelle/WebCache.py

@@ -27,6 +27,13 @@ try:
     import ssl
 except ImportError:
     ssl = None
+
+try:
+    import truststore
+except ImportError:
+    # truststore requires Python > 3.9
+    truststore = None
+
 from arelle.FileSource import SERVER_WEB_CACHE, archiveFilenameParts
 from arelle.PluginManager import pluginClassMethods
 from arelle.UrlUtil import isHttpUrl
@@ -267,12 +274,10 @@ class WebCache:
             self.http_auth_handler = proxyhandlers.HTTPBasicAuthHandler()
             proxyHandlers = [self.proxy_handler, self.proxy_auth_handler, self.http_auth_handler]
         if ssl:
-            # Attempts to load the default CA certificates from the OS.
-            context = ssl.create_default_context()
+            # Attempt to load the default CA certificates from the OS using truststore if available, else fallback to OpenSSL's default context.
+            context = truststore.SSLContext(ssl.PROTOCOL_TLS_CLIENT) if truststore else ssl.create_default_context()
             # Include certifi certificates (Mozilla’s carefully curated
-            # collection) for systems with outdated certs and for platforms
-            # that we're unable to load certs from (macOS and some Linux
-            # distros.)
+            # collection) for systems with outdated certs.
             context.load_verify_locations(cafile=certifi.where())
             if self.noCertificateCheck:  # this is required in some Akamai environments, such as sec.gov
                 context.check_hostname = False

{arelle_release-2.37.28 → arelle_release-2.37.29}/arelle/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '2.37.28'
-__version_tuple__ = version_tuple = (2, 37, 28)
+__version__ = version = '2.37.29'
+__version_tuple__ = version_tuple = (2, 37, 29)

arelle_release-2.37.29/arelle/plugin/validate/EDINET/DisclosureSystems.py

@@ -0,0 +1 @@
+DISCLOSURE_SYSTEM_EDINET = 'EDINET'

arelle_release-2.37.29/arelle/plugin/validate/EDINET/PluginValidationDataExtension.py

@@ -0,0 +1,67 @@
+"""
+See COPYRIGHT.md for copyright information.
+"""
+from __future__ import annotations
+
+import zipfile
+from dataclasses import dataclass
+from functools import lru_cache
+from pathlib import Path
+
+from arelle.ModelXbrl import ModelXbrl
+from arelle.ValidateXbrl import ValidateXbrl
+from arelle.typing import TypeGetText
+from arelle.utils.PluginData import PluginData
+
+_: TypeGetText
+
+
+@dataclass
+class PluginValidationDataExtension(PluginData):
+    _primaryModelXbrl: ModelXbrl | None = None
+
+    # Identity hash for caching.
+    def __hash__(self) -> int:
+        return id(self)
+
+    @lru_cache(1)
+    def shouldValidateUpload(self, val: ValidateXbrl) -> bool:
+        """
+        Determine if the upload validation should be performed on this model.
+
+        Upload validation should not be performed if the target document is
+        not a zipfile.
+
+        Upload validation should only be performed once for the entire package,
+        not duplicated for each model. To facilitate this with Arelle's validation
+        system which largely prevents referencing other models, we can use `--keepOpen`
+        and check if the given model is the first to be loaded.
+        :param val: The ValidateXbrl instance with a model to check.
+        :return: True if upload validation should be performed, False otherwise.
+        """
+        modelXbrl = val.modelXbrl
+        if modelXbrl == val.testModelXbrl:
+            # Not running within a testcase
+            if modelXbrl != modelXbrl.modelManager.loadedModelXbrls[0]:
+                return False
+        if not modelXbrl.fileSource.fs:
+            return False  # No stream
+        if not isinstance(modelXbrl.fileSource.fs, zipfile.ZipFile):
+            return False  # Not a zipfile
+        return True
+
+    @lru_cache(1)
+    def getUploadFilepaths(self, modelXbrl: ModelXbrl) -> list[Path]:
+        if not modelXbrl.fileSource.fs or \
+                not isinstance(modelXbrl.fileSource.fs, zipfile.ZipFile):
+            modelXbrl.warning(
+                codes="EDINET.uploadNotValidated",
+                msg=_("The target file is not a zip file, so upload validation could not be performed.")
+            )
+            return []
+        paths = set()
+        for name in modelXbrl.fileSource.fs.namelist():
+            path = Path(name)
+            paths.add(path)
+            paths.update(path.parents)
+        return sorted(paths)

arelle_release-2.37.29/arelle/plugin/validate/EDINET/ValidationPluginExtension.py

@@ -0,0 +1,29 @@
+"""
+See COPYRIGHT.md for copyright information.
+"""
+from __future__ import annotations
+
+from typing import Any
+
+from arelle.ValidateXbrl import ValidateXbrl
+from arelle.typing import TypeGetText
+from arelle.utils.validate.ValidationPlugin import ValidationPlugin
+from .DisclosureSystems import DISCLOSURE_SYSTEM_EDINET
+from .PluginValidationDataExtension import PluginValidationDataExtension
+
+_: TypeGetText
+
+
+class ValidationPluginExtension(ValidationPlugin):
+    def newPluginData(self, validateXbrl: ValidateXbrl) -> PluginValidationDataExtension:
+        disclosureSystem = validateXbrl.disclosureSystem.name
+        if disclosureSystem == DISCLOSURE_SYSTEM_EDINET:
+            pass
+        else:
+            raise ValueError(f'Invalid EDINET disclosure system: {disclosureSystem}')
+        return PluginValidationDataExtension(
+            self.name,
+        )
+
+    def modelXbrlLoadComplete(self, *args: Any, **kwargs: Any) -> None:
+        return None

arelle_release-2.37.29/arelle/plugin/validate/EDINET/__init__.py

@@ -0,0 +1,119 @@
+"""
+See COPYRIGHT.md for copyright information.
+- [Operation Guides](https://disclosure2dl.edinet-fsa.go.jp/guide/static/disclosure/WEEK0060.html)
+- [Document Search](https://disclosure2.edinet-fsa.go.jp/week0020.aspx)
+"""
+from __future__ import annotations
+
+import zipfile
+from collections import defaultdict
+from pathlib import Path
+from typing import Any
+
+from lxml import etree
+from lxml.etree import _Element
+
+from arelle.FileSource import FileSource
+from arelle.Version import authorLabel, copyrightLabel
+from .ValidationPluginExtension import ValidationPluginExtension
+from .rules import upload
+
+PLUGIN_NAME = "Validate EDINET"
+DISCLOSURE_SYSTEM_VALIDATION_TYPE = "EDINET"
+
+
+validationPlugin = ValidationPluginExtension(
+    name=PLUGIN_NAME,
+    disclosureSystemConfigUrl=Path(__file__).parent / "resources" / "config.xml",
+    validationTypes=[DISCLOSURE_SYSTEM_VALIDATION_TYPE],
+    validationRuleModules=[
+        upload,
+    ],
+)
+
+
+def disclosureSystemTypes(*args: Any, **kwargs: Any) -> tuple[tuple[str, str], ...]:
+    return validationPlugin.disclosureSystemTypes
+
+
+def disclosureSystemConfigURL(*args: Any, **kwargs: Any) -> str:
+    return validationPlugin.disclosureSystemConfigURL
+
+
+def _parseManifestDoc(xmlRootElement: _Element, base: Path) -> dict[str, list[Path]]:
+    sets = defaultdict(list)
+    for instanceElt in xmlRootElement.iter(tag="{http://disclosure.edinet-fsa.go.jp/2013/manifest}instance"):
+        instanceId = str(instanceElt.attrib["id"])
+        for ixbrlElt in instanceElt.iter(tag="{http://disclosure.edinet-fsa.go.jp/2013/manifest}ixbrl"):
+            uri = ixbrlElt.text.strip() if ixbrlElt.text is not None else None
+            if uri:
+                sets[instanceId].append(base / uri)
+    return sets
+
+
+def fileSourceEntrypointFiles(filesource: FileSource, inlineOnly: bool, *args: Any, **kwargs: Any) -> list[dict[str, Any]] | None:
+    manifests = {}
+    if filesource.isArchive:
+        if filesource.isTaxonomyPackage:
+            return None
+        if filesource.reportPackage is not None:
+            return None
+        for _archiveFile in (filesource.dir or ()):
+            if not Path(_archiveFile).stem.startswith('manifest'):
+                continue
+            assert isinstance(filesource.fs, zipfile.ZipFile), \
+                "The EDINET plugin only supports archives in .zip format."
+            with filesource.fs.open(_archiveFile) as manifestDoc:
+                base = Path(_archiveFile).parent
+                xmlRootElement = etree.fromstring(manifestDoc.read())
+                manifests.update(_parseManifestDoc(xmlRootElement, base))
+    elif (dirpath := Path(str(filesource.url))).is_dir():
+        for file in dirpath.rglob("*"):
+            if not file.is_file():
+                continue
+            if not file.stem.startswith('manifest'):
+                continue
+            with open(file, 'rb') as manifestDoc:
+                base = file.parent
+                xmlRootElement = etree.fromstring(manifestDoc.read())
+                manifests.update(_parseManifestDoc(xmlRootElement, base))
+    if len(manifests) == 0:
+        return None
+
+    entrypointFiles = []
+    for instanceId, uris in manifests.items():
+        entrypoints = []
+        for uri in uris:
+            filesource.select(str(uri))
+            entrypoints.append({"file": filesource.url})
+        entrypointFiles.append({'ixds': entrypoints})
+    return entrypointFiles
+
+
+def modelXbrlLoadComplete(*args: Any, **kwargs: Any) -> None:
+    return validationPlugin.modelXbrlLoadComplete(*args, **kwargs)
+
+
+def validateFinally(*args: Any, **kwargs: Any) -> None:
+    return validationPlugin.validateFinally(*args, **kwargs)
+
+
+def validateXbrlFinally(*args: Any, **kwargs: Any) -> None:
+    return validationPlugin.validateXbrlFinally(*args, **kwargs)
+
+
+__pluginInfo__ = {
+    "name": PLUGIN_NAME,
+    "version": "0.0.1",
+    "description": "Validation plugin for the EDINET taxonomies.",
+    "license": "Apache-2",
+    "author": authorLabel,
+    "copyright": copyrightLabel,
+    "import": ("inlineXbrlDocumentSet",),
+    "DisclosureSystem.Types": disclosureSystemTypes,
+    "DisclosureSystem.ConfigURL": disclosureSystemConfigURL,
+    "FileSource.EntrypointFiles": fileSourceEntrypointFiles,
+    "ModelXbrl.LoadComplete": modelXbrlLoadComplete,
+    "Validate.XBRL.Finally": validateXbrlFinally,
+    "ValidateFormula.Finished": validateFinally,
+}

arelle_release-2.37.29/arelle/plugin/validate/EDINET/resources/config.xml

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<DisclosureSystems
+        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+        xsi:noNamespaceSchemaLocation="../../../../config/disclosuresystems.xsd">
+    <!-- see arelle/config/disclosuresystems.xml for full comments -->
+    <DisclosureSystem
+            names="EDINET|edinet"
+            description="Checks for EDINET."
+            validationType="EDINET"
+            exclusiveTypesPattern="EFM|GFM|FERC|HMRC|SBR.NL|EBA|EIOPA|ESEF"
+    />
+</DisclosureSystems>

arelle_release-2.37.29/arelle/plugin/validate/EDINET/rules/upload.py

@@ -0,0 +1,153 @@
+"""
+See COPYRIGHT.md for copyright information.
+"""
+from __future__ import annotations
+
+import re
+import zipfile
+from collections.abc import Iterable
+from typing import Any, cast, IO
+
+from arelle.ValidateXbrl import ValidateXbrl
+from arelle.typing import TypeGetText
+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_EDINET)
+from ..PluginValidationDataExtension import PluginValidationDataExtension
+
+_: TypeGetText
+
+FILENAME_STEM_PATTERN = re.compile(r'[a-zA-Z0-9_-]*')
+
+
+@validation(
+    hook=ValidationHook.XBRL_FINALLY,
+    disclosureSystems=[DISCLOSURE_SYSTEM_EDINET],
+)
+def rule_EC0121E(
+        pluginData: PluginValidationDataExtension,
+        val: ValidateXbrl,
+        *args: Any,
+        **kwargs: Any,
+) -> Iterable[Validation]:
+    """
+    EDINET.EC0121E: There is a directory or file that contains more than 31 characters
+    or uses characters other than those allowed (alphanumeric characters, '-' and '_').
+
+    Implementation note: getManifestDirectoryPaths results in this validation only
+    considering files that are beneath the same directory as the manifest file that
+    the given DTS originated from. This prevents duplicate errors for packages
+    with multiple document sets, but can still cause duplicates when a single manifest
+    file has multiple document sets, as is often the case with AuditDoc manifests.
+    """
+    if not pluginData.shouldValidateUpload(val):
+        return
+    uploadFilepaths = pluginData.getUploadFilepaths(val.modelXbrl)
+    for path in uploadFilepaths:
+        if len(str(path.name)) > 31 or not FILENAME_STEM_PATTERN.match(path.stem):
+            yield Validation.error(
+                codes='EDINET.EC0121E',
+                msg=_("There is a directory or file in '%(directory)s' that contains more than 31 characters "
+                      "or uses characters other than those allowed (alphanumeric characters, '-' and '_'). "
+                      "Directory or file name: '%(basename)s'. "
+                      "Please change the file name (or folder name) to within 31 characters and to usable "
+                      "characters, and upload again."),
+                directory=str(path.parent),
+                basename=path.name,
+                file=str(path)
+            )
+
+
+@validation(
+    hook=ValidationHook.XBRL_FINALLY,
+    disclosureSystems=[DISCLOSURE_SYSTEM_EDINET],
+)
+def rule_EC0124E(
+        pluginData: PluginValidationDataExtension,
+        val: ValidateXbrl,
+        *args: Any,
+        **kwargs: Any,
+) -> Iterable[Validation]:
+    """
+    EDINET.EC0124E: There are no empty directories.
+
+    See note on EC0121E.
+    """
+    if not pluginData.shouldValidateUpload(val):
+        return
+    uploadFilepaths = pluginData.getUploadFilepaths(val.modelXbrl)
+    emptyDirectories = []
+    for path in uploadFilepaths:
+        if path.suffix:
+            continue
+        if not any(path in p.parents for p in uploadFilepaths):
+            emptyDirectories.append(str(path))
+    for emptyDirectory in emptyDirectories:
+        yield Validation.error(
+            codes='EDINET.EC0124E',
+            msg=_("There is no file directly under '%(emptyDirectory)s'. "
+                  "No empty folders. "
+                  "Please store the file in the appropriate folder or delete the folder and upload again."),
+            emptyDirectory=emptyDirectory,
+        )
+
+
+@validation(
+    hook=ValidationHook.XBRL_FINALLY,
+    disclosureSystems=[DISCLOSURE_SYSTEM_EDINET],
+)
+def rule_EC0132E(
+        pluginData: PluginValidationDataExtension,
+        val: ValidateXbrl,
+        *args: Any,
+        **kwargs: Any,
+) -> Iterable[Validation]:
+    """
+    EDINET.EC0132E: Store the manifest file directly under the relevant folder.
+    """
+    if not pluginData.shouldValidateUpload(val):
+        return
+    uploadFilepaths = pluginData.getUploadFilepaths(val.modelXbrl)
+    docFolders = ("PublicDoc", "PrivateDoc", "AuditDoc")
+    for filepath in uploadFilepaths:
+        if filepath.name not in docFolders:
+            continue
+        expectedManifestName = f'manifest_{filepath.name}.xml'
+        expectedManifestPath = filepath / expectedManifestName
+        if expectedManifestPath in uploadFilepaths:
+            continue
+        yield Validation.error(
+            codes='EDINET.EC0132E',
+            msg=_("'%(expectedManifestName)s' does not exist in '%(expectedManifestFolder)s'. "
+                  "Please store the manifest file (or cover file) directly under the relevant folder and upload it again. "),
+            expectedManifestName=expectedManifestName,
+            expectedManifestFolder=str(filepath),
+        )
+
+
+@validation(
+    hook=ValidationHook.XBRL_FINALLY,
+    disclosureSystems=[DISCLOSURE_SYSTEM_EDINET],
+)
+def rule_EC0183E(
+        pluginData: PluginValidationDataExtension,
+        val: ValidateXbrl,
+        *args: Any,
+        **kwargs: Any,
+) -> Iterable[Validation]:
+    """
+    EDINET.EC0183E: The compressed file size exceeds 55MB.
+    """
+    if not pluginData.shouldValidateUpload(val):
+        return
+    zipFile = cast(zipfile.ZipFile, val.modelXbrl.fileSource.fs)
+    file = cast(IO[Any], zipFile.fp)
+    file.seek(0, 2)  # Move to the end of the file
+    size = file.tell()
+    if size > 55 * 1000 * 1000:  # Interpretting MB as megabytes (1,000,000 bytes)
+        yield Validation.error(
+            codes='EDINET.EC0183E',
+            msg=_("The compressed file size exceeds 55MB. "
+                  "Please compress the file to a size of 55MB or less and upload it again."),
+        )

{arelle_release-2.37.28 → arelle_release-2.37.29}/arelle/plugin/validate/NL/rules/nl_kvk.py

@@ -18,6 +18,7 @@ from arelle.ModelInstanceObject import ModelInlineFact
 from arelle.ModelObject import ModelObject
 from arelle.PrototypeDtsObject import PrototypeObject
 from arelle.ValidateDuplicateFacts import getDuplicateFactSets
+from arelle.XbrlConst import standardLabel
 from arelle.XmlValidateConst import VALID
 
 from arelle import XbrlConst, XmlUtil, ModelDocument
@@ -1896,6 +1897,57 @@ def rule_nl_kvk_RTS_Annex_IV_Par_4_2(
         )
 
 
+@validation(
+    hook=ValidationHook.XBRL_FINALLY,
+    disclosureSystems=ALL_NL_INLINE_DISCLOSURE_SYSTEMS,
+)
+def rule_nl_kvk_RTS_Annex_IV_Par_4_3(
+        pluginData: PluginValidationDataExtension,
+        val: ValidateXbrl,
+        *args: Any,
+        **kwargs: Any,
+) -> Iterable[Validation]:
+    """
+    NL-KVK.RTS_Annex_IV_Par_4_3: Extension elements must be provided with a standard label in the language corresponding to the language of the annual report.
+    """
+    extensionData = pluginData.getExtensionData(val.modelXbrl)
+    extensionConcepts = extensionData.extensionConcepts
+    labelsRelationshipSet = val.modelXbrl.relationshipSet(XbrlConst.conceptLabel)
+    missingLabels =  []
+    missingReportingLabels = []
+    noStandardLabels = []
+    for concept in extensionConcepts:
+        if not concept.label(standardLabel,lang=pluginData.getReportXmlLang(val.modelXbrl),fallbackToQname=False):
+            labelRels = labelsRelationshipSet.fromModelObject(concept)
+            if len(labelRels) == 0:
+                missingLabels.append(concept)
+            for labelRel in labelRels:
+                label = cast(ModelResource, labelRel.toModelObject)
+                if  label.role == XbrlConst.standardLabel:
+                    missingReportingLabels.append(concept)
+                else:
+                    noStandardLabels.append(label)
+    message = 'Extension element is missing a standard label or is missing a label in the language of the report. Review to ensure a standard label is defined with at least the language of the report.'
+    if len(missingLabels) > 0:
+        yield Validation.warning(
+            codes='NL.NL-KVK.RTS_Annex_IV_Par_4_3.extensionConceptNoLabel',
+            msg=_(message),
+            modelObject=missingLabels,
+            )
+    if len(missingReportingLabels) > 0:
+            yield Validation.warning(
+                codes='NL.NL-KVK.RTS_Annex_IV_Par_4_3.missingLabelForRoleInReportLanguage',
+                msg=_(message),
+                modelObject=missingReportingLabels,
+            )
+    if len(noStandardLabels) > 0:
+        yield Validation.warning(
+            codes='NL.NL-KVK.RTS_Annex_IV_Par_4_3.extensionConceptNoStandardLabel',
+            msg=_(message),
+            modelObject=noStandardLabels,
+        )
+
+
 @validation(
     hook=ValidationHook.XBRL_FINALLY,
     disclosureSystems=ALL_NL_INLINE_DISCLOSURE_SYSTEMS,

{arelle_release-2.37.28 → arelle_release-2.37.29}/arelle/utils/EntryPointDetection.py

@@ -9,6 +9,12 @@ from arelle import (
 def filesourceEntrypointFiles(filesource, entrypointFiles=None, inlineOnly=False):
     if entrypointFiles is None:
         entrypointFiles = []
+    for pluginXbrlMethod in PluginManager.pluginClassMethods("FileSource.EntrypointFiles"):
+        resultEntrypointFiles = pluginXbrlMethod(filesource, inlineOnly)
+        if resultEntrypointFiles is not None:
+            del entrypointFiles[:]  # clear list
+            entrypointFiles.extend(resultEntrypointFiles)
+            return entrypointFiles
     if filesource.isArchive:
         if filesource.isTaxonomyPackage:  # if archive is also a taxonomy package, activate mappings
             filesource.loadTaxonomyPackageMappings()

{arelle_release-2.37.28 → arelle_release-2.37.29/arelle_release.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: arelle-release
-Version: 2.37.28
+Version: 2.37.29
 Summary: An open source XBRL platform.
 Author-email: "arelle.org" <support@arelle.org>
 License: Apache-2.0
@@ -41,6 +41,7 @@ Requires-Dist: pillow<12,>=10
 Requires-Dist: pyparsing==3.*
 Requires-Dist: python-dateutil==2.*
 Requires-Dist: regex
+Requires-Dist: truststore==0.*; python_version > "3.9"
 Requires-Dist: typing-extensions==4.*
 Provides-Extra: crypto
 Requires-Dist: pycryptodome==3.*; extra == "crypto"