arelle-release 2.37.46__py3-none-any.whl → 2.37.48__py3-none-any.whl

arelle/CntlrCmdLine.py

@@ -620,7 +620,11 @@ class ParserForDynamicPlugins:
 
 
 def _pluginHasCliOptions(moduleInfo):
-    return "CntlrCmdLine.Options" in moduleInfo["classMethods"]
+    if "CntlrCmdLine.Options" in moduleInfo["classMethods"]:
+        return True
+    if imports := moduleInfo.get("imports"):
+        return any(_pluginHasCliOptions(importedModule) for importedModule in imports)
+    return False
 
 
 class CntlrCmdLine(Cntlr.Cntlr):
@@ -1012,6 +1016,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/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/ModelObjectFactory.py

@@ -68,6 +68,22 @@ LINKBASE = 2
 VERSIONINGREPORT = 3
 RSSFEED = 4
 
+LINK_LOCALNAME_TO_MODEL_CLASS = {
+    'loc': ModelLocator,
+    'label': ModelResource,
+    'reference': ModelResource,
+    'roleType': ModelRoleType,
+    'arcroleType': ModelRoleType,
+} | {
+    q.localName: ModelObject
+    for q in [
+        XbrlConst.qnLinkCalculationArc,
+        XbrlConst.qnLinkDefinitionArc,
+        XbrlConst.qnLinkPresentationArc,
+        XbrlConst.qnLinkReferenceArc,
+    ]
+}
+
 
 class KnownNamespacesModelObjectClassLookup(etree.CustomElementClassLookup):
     def __init__(self, modelXbrl: ModelXbrl, fallback: etree.ElementClassLookup | None = None) -> None:
@@ -106,8 +122,8 @@ class KnownNamespacesModelObjectClassLookup(etree.CustomElementClassLookup):
             elif ns == XbrlConst.link:
                 if self.type is None:
                     self.type = LINKBASE
-                if ln == "roleType" or ln == "arcroleType":
-                    return ModelRoleType
+                if modelObjectClass := LINK_LOCALNAME_TO_MODEL_CLASS.get(ln):
+                    return modelObjectClass
             elif ns == "http://edgar/2009/conformance":
                 # don't force loading of test schema
                 if ln == "variation":

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/_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.48'
+__version_tuple__ = version_tuple = (2, 37, 48)

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/plugin/validate/EDINET/ControllerPluginData.py

@@ -3,12 +3,20 @@ 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
@@ -39,6 +47,82 @@ class ControllerPluginData(PluginData):
         """
         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.

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/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/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/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,
 }