arelle-release 2.37.46__tar.gz → 2.37.47__tar.gz

{arelle_release-2.37.46/arelle_release.egg-info → arelle_release-2.37.47}/PKG-INFO

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

{arelle_release-2.37.46 → arelle_release-2.37.47}/arelle/CntlrCmdLine.py

@@ -1012,6 +1012,11 @@ class CntlrCmdLine(Cntlr.Cntlr):
 
         for pluginXbrlMethod in PluginManager.pluginClassMethods("CntlrCmdLine.Filing.Start"):
             pluginXbrlMethod(self, options, filesource, _entrypointFiles, sourceZipStream=sourceZipStream, responseZipStream=responseZipStream)
+
+        if options.validate:
+            for pluginXbrlMethod in PluginManager.pluginClassMethods("Validate.FileSource"):
+                pluginXbrlMethod(self, filesource, _entrypointFiles)
+
         if len(_entrypointFiles) == 0 and not options.packages:
             if options.entrypointFile:
                 msg = _("No XBRL entry points could be loaded from provided file: {}").format(options.entrypointFile)

{arelle_release-2.37.46 → arelle_release-2.37.47}/arelle/ErrorManager.py

@@ -204,13 +204,22 @@ class ErrorManager:
                             _arg:ModelObject = arg.modelObject if isinstance(arg, ObjectPropertyViewWrapper) else arg
                             if len(modelObjectArgs) > 1 and getattr(arg,"tag",None) == "instance":
                                 continue # skip IXDS top level element
-                            fragmentIdentifier = cast(str, XmlUtil.elementFragmentIdentifier(_arg))
-                            if not hasattr(_arg, 'modelDocument') and _arg.namespaceURI == XbrlConst.svg:
+                            fragmentIdentifier = "#" + cast(str, XmlUtil.elementFragmentIdentifier(_arg))
+                            if not hasattr(_arg, 'modelDocument') and _arg.namespaceURI == XbrlConst.svg and len(refs) > 0:
                                 # This is an embedded SVG document without its own file.
-                                ref["href"] = "#" + fragmentIdentifier
+                                # Set the href to the containing document element that defined the encoded SVG.
+                                # and define a nestedHrefs attribute with the fragment identifier.
+                                priorRef = refs[-1]
+                                ref["href"] = priorRef["href"]
+                                priorNestedHrefs = priorRef.get("customAttributes", {}).get("nestedHrefs", [])
+                                ref["customAttributes"] = {
+                                    "nestedHrefs": [*priorNestedHrefs, fragmentIdentifier]
+                                }
+                                if priorArgSourceline := priorRef.get("sourceLine"):
+                                    ref["sourceLine"] = priorArgSourceline
                             else:
-                                ref["href"] = file + "#" + fragmentIdentifier
-                            ref["sourceLine"] = _arg.sourceline
+                                ref["href"] = file + fragmentIdentifier
+                                ref["sourceLine"] = _arg.sourceline
                             ref["objectId"] = _arg.objectId()
                             if logRefObjectProperties:
                                 try:

{arelle_release-2.37.46 → arelle_release-2.37.47}/arelle/Validate.py

@@ -398,6 +398,8 @@ class Validate:
                             filesource.select(None) # must select loadable reports (not the taxonomy package itself)
                         elif not filesource.isReportPackage:
                             entrypoints = filesourceEntrypointFiles(filesource)
+                            for pluginXbrlMethod in pluginClassMethods("Validate.FileSource"):
+                                pluginXbrlMethod(self.modelXbrl.modelManager.cntlr, filesource, entrypoints)
                             if entrypoints:
                                 # resolve an IXDS in entrypoints
                                 for pluginXbrlMethod in pluginClassMethods("ModelTestcaseVariation.ArchiveIxds"):
@@ -421,6 +423,8 @@ class Validate:
                     if not reportPackageErrors:
                         assert isinstance(filesource.basefile, str)
                         if entrypoints := filesourceEntrypointFiles(filesource):
+                            for pluginXbrlMethod in pluginClassMethods("Validate.FileSource"):
+                                pluginXbrlMethod(self.modelXbrl.modelManager.cntlr, filesource, entrypoints)
                             for pluginXbrlMethod in pluginClassMethods("ModelTestcaseVariation.ArchiveIxds"):
                                 pluginXbrlMethod(self, filesource, entrypoints)
                             for entrypoint in entrypoints:

{arelle_release-2.37.46 → arelle_release-2.37.47}/arelle/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '2.37.46'
-__version_tuple__ = version_tuple = (2, 37, 46)
+__version__ = version = '2.37.47'
+__version_tuple__ = version_tuple = (2, 37, 47)

{arelle_release-2.37.46 → arelle_release-2.37.47}/arelle/examples/plugin/validate/XYZ/ValidationPluginExtension.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 
 from typing import Any
 
+from arelle.Cntlr import Cntlr
 from arelle.ModelDocument import LoadingException, ModelDocument
 from arelle.ModelXbrl import ModelXbrl
 from arelle.ValidateXbrl import ValidateXbrl
@@ -16,7 +17,7 @@ _: TypeGetText
 
 
 class ValidationPluginExtension(ValidationPlugin):
-    def newPluginData(self, validateXbrl: ValidateXbrl) -> PluginValidationDataExtension:
+    def newPluginData(self, cntlr: Cntlr, validateXbrl: ValidateXbrl | None) -> PluginValidationDataExtension:
         return PluginValidationDataExtension(self.name)
 
     def modelDocumentPullLoader(

{arelle_release-2.37.46 → arelle_release-2.37.47}/arelle/plugin/validate/DBA/ValidationPluginExtension.py

@@ -3,6 +3,7 @@ See COPYRIGHT.md for copyright information.
 """
 from __future__ import annotations
 
+from arelle.Cntlr import Cntlr
 from arelle.ModelValue import qname
 from arelle.ValidateXbrl import ValidateXbrl
 from arelle.typing import TypeGetText
@@ -26,7 +27,7 @@ REQUIRED_DISCLOSURE_OF_EQUITY_FACTS = 2
 
 
 class ValidationPluginExtension(ValidationPlugin):
-    def newPluginData(self, validateXbrl: ValidateXbrl) -> PluginValidationDataExtension:
+    def newPluginData(self, cntlr: Cntlr, validateXbrl: ValidateXbrl | None) -> PluginValidationDataExtension:
         return PluginValidationDataExtension(
             self.name,
             accountingPolicyConceptQns=frozenset([

arelle_release-2.37.47/arelle/plugin/validate/EDINET/ControllerPluginData.py

@@ -0,0 +1,164 @@
+"""
+See COPYRIGHT.md for copyright information.
+"""
+from __future__ import annotations
+
+import zipfile
+from collections import defaultdict
+from dataclasses import dataclass
+from functools import lru_cache
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from arelle.Cntlr import Cntlr
+from arelle.FileSource import FileSource
+from arelle.ModelXbrl import ModelXbrl
+from arelle.typing import TypeGetText
+from arelle.utils.PluginData import PluginData
+from .InstanceType import InstanceType
+from .UploadContents import UploadContents
+
+if TYPE_CHECKING:
+    from .ManifestInstance import ManifestInstance
+
+_: TypeGetText
+
+
+@dataclass
+class ControllerPluginData(PluginData):
+    _manifestInstancesById: dict[str, ManifestInstance]
+
+    def __init__(self, name: str):
+        super().__init__(name)
+        self._manifestInstancesById = {}
+
+    def __hash__(self) -> int:
+        return id(self)
+
+    def addManifestInstance(self, manifestInstance: ManifestInstance) -> None:
+        """
+        Add a manifest instance with unique ID to the plugin data.
+        """
+        self._manifestInstancesById[manifestInstance.id] = manifestInstance
+
+    def getManifestInstances(self) -> list[ManifestInstance]:
+        """
+        Retrieve all loaded manifest instances.
+        """
+        return list(self._manifestInstancesById.values())
+
+    @lru_cache(1)
+    def getUploadContents(self, fileSource: FileSource) -> UploadContents:
+        uploadFilepaths = self.getUploadFilepaths(fileSource)
+        amendmentPaths = defaultdict(list)
+        unknownPaths = []
+        directories = []
+        forms = defaultdict(list)
+        for path in uploadFilepaths:
+            parents = list(reversed([p.name for p in path.parents if len(p.name) > 0]))
+            if len(parents) == 0:
+                continue
+            if parents[0] == 'XBRL':
+                if len(parents) > 1:
+                    formName = parents[1]
+                    instanceType = InstanceType.parse(formName)
+                    if instanceType is not None:
+                        forms[instanceType].append(path)
+                        continue
+            formName = parents[0]
+            instanceType = InstanceType.parse(formName)
+            if instanceType is not None:
+                amendmentPaths[instanceType].append(path)
+                continue
+            if len(path.suffix) == 0:
+                directories.append(path)
+                continue
+            unknownPaths.append(path)
+        return UploadContents(
+            amendmentPaths={k: frozenset(v) for k, v in amendmentPaths.items() if len(v) > 0},
+            directories=frozenset(directories),
+            instances={k: frozenset(v) for k, v in forms.items() if len(v) > 0},
+            unknownPaths=frozenset(unknownPaths)
+        )
+
+    @lru_cache(1)
+    def getUploadFilepaths(self, fileSource: FileSource) -> list[Path]:
+        if not self.isUpload(fileSource):
+            return []
+        paths = set()
+        assert isinstance(fileSource.fs, zipfile.ZipFile)
+        for name in fileSource.fs.namelist():
+            path = Path(name)
+            paths.add(path)
+            paths.update(path.parents)
+        return sorted(paths)
+
+    @lru_cache(1)
+    def getUploadFileSizes(self, fileSource: FileSource) -> dict[Path, int]:
+        """
+        Get the sizes of files in the upload directory.
+        :param fileSource: The FileSource instance to get file sizes for.
+        :return: A dictionary mapping file paths to their sizes.
+        """
+        if not self.isUpload(fileSource):
+            return {}
+        assert isinstance(fileSource.fs, zipfile.ZipFile)
+        return {
+            Path(i.filename): i.file_size
+            for i in fileSource.fs.infolist()
+            if not i.is_dir()
+        }
+
+    @lru_cache(1)
+    def isUpload(self, fileSource: FileSource) -> bool:
+        fileSource.open()  # Make sure file source is open
+        if (fileSource.fs is None or
+                not isinstance(fileSource.fs, zipfile.ZipFile)):
+            if fileSource.cntlr is not None:
+                fileSource.cntlr.error(
+                    level="WARNING",
+                    codes="EDINET.uploadNotValidated",
+                    msg=_("The target file is not a zip file, so upload validation could not be performed.")
+                )
+            return False
+        return True
+
+    def matchManifestInstance(self, ixdsDocUrls: list[str]) -> ManifestInstance | None:
+        """
+        Match a manifest instance based on the provided ixdsDocUrls.
+        A one-to-one mapping must exist between the model's IXDS document URLs and the manifest instance's IXBRL files.
+        :param ixdsDocUrls: A model's list of IXDS document URLs.
+        :return: A matching ManifestInstance if found, otherwise None.
+        """
+        modelUrls = set(ixdsDocUrls)
+        matchedInstance = None
+        for instance in self._manifestInstancesById.values():
+            if len(instance.ixbrlFiles) != len(ixdsDocUrls):
+                continue
+            manifestUrls = {str(path) for path in instance.ixbrlFiles}
+            unmatchedModelUrls = set(modelUrls)
+            unmatchedManifestUrls = set(manifestUrls)
+            for modelUrl in modelUrls:
+                if modelUrl not in unmatchedModelUrls:
+                    continue
+                for manifestUrl in manifestUrls:
+                    if modelUrl.endswith(manifestUrl):
+                        unmatchedModelUrls.remove(modelUrl)
+                        unmatchedManifestUrls.remove(manifestUrl)
+                        break
+            if len(unmatchedModelUrls) > 0:
+                continue
+            if len(unmatchedManifestUrls) > 0:
+                continue
+            matchedInstance = instance
+            break
+        return matchedInstance
+
+    @staticmethod
+    def get(cntlr: Cntlr, name: str) -> ControllerPluginData:
+        controllerPluginData = cntlr.getPluginData(name)
+        if controllerPluginData is None:
+            controllerPluginData = ControllerPluginData(name)
+            cntlr.setPluginData(controllerPluginData)
+        assert isinstance(controllerPluginData, ControllerPluginData), "Expected ControllerPluginData instance."
+        return controllerPluginData

{arelle_release-2.37.46 → arelle_release-2.37.47}/arelle/plugin/validate/EDINET/PluginValidationDataExtension.py

@@ -4,7 +4,6 @@ See COPYRIGHT.md for copyright information.
 from __future__ import annotations
 
 import zipfile
-from collections import defaultdict
 from dataclasses import dataclass
 from functools import lru_cache
 from pathlib import Path
@@ -18,26 +17,16 @@ from arelle.ModelValue import QName, qname
 from arelle.ModelXbrl import ModelXbrl
 from arelle.PrototypeDtsObject import LinkPrototype
 from arelle.ValidateDuplicateFacts import getDeduplicatedFacts, DeduplicationType
-from arelle.ValidateXbrl import ValidateXbrl
 from arelle.XmlValidate import VALID
 from arelle.typing import TypeGetText
 from arelle.utils.PluginData import PluginData
 from .Constants import CORPORATE_FORMS
 from .ControllerPluginData import ControllerPluginData
-from .InstanceType import InstanceType
 from .ManifestInstance import ManifestInstance
 
 _: TypeGetText
 
 
-@dataclass(frozen=True)
-class UploadContents:
-    amendmentPaths: dict[InstanceType, frozenset[Path]]
-    directories: frozenset[Path]
-    instances: dict[InstanceType, frozenset[Path]]
-    unknownPaths: frozenset[Path]
-
-
 @dataclass
 class PluginValidationDataExtension(PluginData):
     assetsIfrsQn: QName
@@ -83,32 +72,6 @@ class PluginValidationDataExtension(PluginData):
             return True
         return False
 
-    @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 getDeduplicatedFacts(self, modelXbrl: ModelXbrl) -> list[ModelFact]:
         return getDeduplicatedFacts(modelXbrl, DeduplicationType.CONSISTENT_PAIRS)
@@ -149,86 +112,9 @@ class PluginValidationDataExtension(PluginData):
         controllerPluginData = ControllerPluginData.get(modelXbrl.modelManager.cntlr, self.name)
         return controllerPluginData.matchManifestInstance(modelXbrl.ixdsDocUrls)
 
-    @lru_cache(1)
-    def getManifestInstances(self, modelXbrl: ModelXbrl) -> list[ManifestInstance]:
-        controllerPluginData = ControllerPluginData.get(modelXbrl.modelManager.cntlr, self.name)
-        return controllerPluginData.getManifestInstances()
-
-    def getUploadFileSizes(self, modelXbrl: ModelXbrl) -> dict[Path, int]:
-        """
-        Get the sizes of files in the upload directory.
-        :param modelXbrl: The ModelXbrl instance to get file sizes for.
-        :return: A dictionary mapping file paths to their sizes.
-        """
-        if not self.isUpload(modelXbrl):
-            return {}
-        assert isinstance(modelXbrl.fileSource.fs, zipfile.ZipFile)
-        return {
-            Path(i.filename): i.file_size
-            for i in modelXbrl.fileSource.fs.infolist()
-            if not i.is_dir()
-        }
-
-    @lru_cache(1)
-    def getUploadContents(self, modelXbrl: ModelXbrl) -> UploadContents:
-        uploadFilepaths = self.getUploadFilepaths(modelXbrl)
-        amendmentPaths = defaultdict(list)
-        unknownPaths = []
-        directories = []
-        forms = defaultdict(list)
-        for path in uploadFilepaths:
-            parents = list(reversed([p.name for p in path.parents if len(p.name) > 0]))
-            if len(parents) == 0:
-                continue
-            if parents[0] == 'XBRL':
-                if len(parents) > 1:
-                    formName = parents[1]
-                    instanceType = InstanceType.parse(formName)
-                    if instanceType is not None:
-                        forms[instanceType].append(path)
-                        continue
-            formName = parents[0]
-            instanceType = InstanceType.parse(formName)
-            if instanceType is not None:
-                amendmentPaths[instanceType].append(path)
-                continue
-            if len(path.suffix) == 0:
-                directories.append(path)
-                continue
-            unknownPaths.append(path)
-        return UploadContents(
-            amendmentPaths={k: frozenset(v) for k, v in amendmentPaths.items() if len(v) > 0},
-            directories=frozenset(directories),
-            instances={k: frozenset(v) for k, v in forms.items() if len(v) > 0},
-            unknownPaths=frozenset(unknownPaths)
-        )
-
-    @lru_cache(1)
-    def getUploadFilepaths(self, modelXbrl: ModelXbrl) -> list[Path]:
-        if not self.isUpload(modelXbrl):
-            return []
-        paths = set()
-        assert isinstance(modelXbrl.fileSource.fs, zipfile.ZipFile)
-        for name in modelXbrl.fileSource.fs.namelist():
-            path = Path(name)
-            paths.add(path)
-            paths.update(path.parents)
-        return sorted(paths)
-
     def hasValidNonNilFact(self, modelXbrl: ModelXbrl, qname: QName) -> bool:
         requiredFacts = modelXbrl.factsByQname.get(qname, set())
         return any(fact.xValid >= VALID and not fact.isNil for fact in requiredFacts)
 
-    @lru_cache(1)
-    def isUpload(self, modelXbrl: ModelXbrl) -> bool:
-        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 False
-        return True
-
     def isStandardTaxonomyUrl(self, uri: str, modelXbrl: ModelXbrl) -> bool:
         return modelXbrl.modelManager.disclosureSystem.hrefValidForDisclosureSystem(uri)

arelle_release-2.37.47/arelle/plugin/validate/EDINET/UploadContents.py

@@ -0,0 +1,17 @@
+"""
+See COPYRIGHT.md for copyright information.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+
+from .InstanceType import InstanceType
+
+
+@dataclass(frozen=True)
+class UploadContents:
+    amendmentPaths: dict[InstanceType, frozenset[Path]]
+    directories: frozenset[Path]
+    instances: dict[InstanceType, frozenset[Path]]
+    unknownPaths: frozenset[Path]

{arelle_release-2.37.46 → arelle_release-2.37.47}/arelle/plugin/validate/EDINET/ValidationPluginExtension.py

@@ -5,9 +5,11 @@ from __future__ import annotations
 
 from typing import Any
 
+from arelle.Cntlr import Cntlr
 from arelle.FileSource import FileSource
 from arelle.ValidateXbrl import ValidateXbrl
 from arelle.typing import TypeGetText
+from arelle.utils.PluginData import PluginData
 from arelle.utils.validate.ValidationPlugin import ValidationPlugin
 from .ControllerPluginData import ControllerPluginData
 from .DisclosureSystems import DISCLOSURE_SYSTEM_EDINET
@@ -35,8 +37,12 @@ class ValidationPluginExtension(ValidationPlugin):
             entrypointFiles.append({'ixds': entrypoints, 'id': instance.id})
         return entrypointFiles
 
-    def newPluginData(self, validateXbrl: ValidateXbrl) -> PluginValidationDataExtension:
-        disclosureSystem = validateXbrl.disclosureSystem.name
+    def newPluginData(self, cntlr: Cntlr, validateXbrl: ValidateXbrl | None) -> PluginData:
+        if validateXbrl is None:
+            return ControllerPluginData.get(cntlr, self.name)
+        disclosureSystem = DISCLOSURE_SYSTEM_EDINET
+        if validateXbrl is not None:
+            disclosureSystem = str(validateXbrl.disclosureSystem.name)
         if disclosureSystem == DISCLOSURE_SYSTEM_EDINET:
             pass
         else:

{arelle_release-2.37.46 → arelle_release-2.37.47}/arelle/plugin/validate/EDINET/__init__.py

@@ -59,6 +59,10 @@ def loggingSeverityReleveler(modelXbrl: ModelXbrl, level: str, messageCode: str,
     return level, messageCode
 
 
+def validateFileSource(*args: Any, **kwargs: Any) -> None:
+    return validationPlugin.validateFileSource(*args, **kwargs)
+
+
 def validateFinally(*args: Any, **kwargs: Any) -> None:
     return validationPlugin.validateFinally(*args, **kwargs)
 
@@ -79,6 +83,7 @@ __pluginInfo__ = {
     "DisclosureSystem.ConfigURL": disclosureSystemConfigURL,
     "FileSource.EntrypointFiles": fileSourceEntrypointFiles,
     "Logging.Severity.Releveler": loggingSeverityReleveler,
+    "Validate.FileSource": validateFileSource,
     "Validate.XBRL.Finally": validateXbrlFinally,
     "ValidateFormula.Finished": validateFinally,
 }