arelle-release 2.37.53__tar.gz → 2.37.55__tar.gz

{arelle_release-2.37.53 → arelle_release-2.37.55}/PKG-INFO

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

{arelle_release-2.37.53 → arelle_release-2.37.55}/arelle/CntlrCmdLine.py

@@ -57,8 +57,7 @@ from arelle.RuntimeOptions import RuntimeOptions, RuntimeOptionsException
 from arelle.SocketUtils import INTERNET_CONNECTIVITY, OFFLINE
 from arelle.SystemInfo import PlatformOS, getSystemInfo, getSystemWordSize, hasWebServer, isCGI, isGAE
 from arelle.typing import TypeGetText
-from arelle.UrlUtil import isHttpUrl
-from arelle.utils.EntryPointDetection import filesourceEntrypointFiles
+from arelle.utils.EntryPointDetection import parseEntrypointFileInput
 from arelle.ValidateXbrlDTS import ValidateBaseTaxonomiesMode
 from arelle.WebCache import proxyTuple
 
@@ -978,41 +977,12 @@ class CntlrCmdLine(Cntlr.Cntlr):
             if not (options.entrypointFile or sourceZipStream):
                 return True # success
 
+        entrypointParseResult = parseEntrypointFileInput(self, options.entrypointFile, sourceZipStream)
+        if not entrypointParseResult.success:
+            return False
+        filesource = entrypointParseResult.filesource
+        _entrypointFiles = entrypointParseResult.entrypointFiles
         success = True
-        # entrypointFile may be absent (if input is a POSTED zip or file name ending in .zip)
-        #    or may be a | separated set of file names
-        _entryPoints = []
-        _checkIfXmlIsEis = self.modelManager.disclosureSystem and self.modelManager.disclosureSystem.validationType == "EFM"
-        if options.entrypointFile:
-            _f = options.entrypointFile
-            try: # may be a json list
-                _entryPoints = json.loads(_f)
-                _checkIfXmlIsEis = False # json entry objects never specify an xml EIS archive
-            except ValueError as e:
-                # is it malformed json?
-                if _f.startswith("[{") or _f.endswith("]}") or '"file:"' in _f:
-                    self.addToLog(_("File name parameter appears to be malformed JSON: {}\n{}").format(e, _f),
-                                  messageCode="FileNameFormatError",
-                                  level=logging.ERROR)
-                    success = False
-                else: # try as file names separated by '|'
-                    for f in (_f or '').split('|'):
-                        if not sourceZipStream and not isHttpUrl(f) and not os.path.isabs(f):
-                            f = os.path.normpath(os.path.join(os.getcwd(), f)) # make absolute normed path
-                        _entryPoints.append({"file":f})
-        filesource = None # file source for all instances if not None
-        if sourceZipStream:
-            filesource = FileSource.openFileSource(None, self, sourceZipStream)
-        elif len(_entryPoints) == 1 and "file" in _entryPoints[0]: # check if an archive and need to discover entry points (and not IXDS)
-            entryPath = PackageManager.mappedUrl(_entryPoints[0]["file"])
-            filesource = FileSource.openFileSource(entryPath, self, checkIfXmlIsEis=_checkIfXmlIsEis)
-        _entrypointFiles = _entryPoints
-        if filesource and not filesource.selection and not (sourceZipStream and len(_entrypointFiles) > 0):
-            try:
-                filesourceEntrypointFiles(filesource, _entrypointFiles)
-            except Exception as err:
-                self.addToLog(str(err), messageCode="error", level=logging.ERROR)
-                return False
 
         for pluginXbrlMethod in PluginManager.pluginClassMethods("CntlrCmdLine.Filing.Start"):
             pluginXbrlMethod(self, options, filesource, _entrypointFiles, sourceZipStream=sourceZipStream, responseZipStream=responseZipStream)
@@ -1248,6 +1218,11 @@ class CntlrCmdLine(Cntlr.Cntlr):
                         self.modelManager.close(modelDiffReport)
                     elif modelXbrl:
                         self.modelManager.close(modelXbrl)
+
+        if options.validate:
+            for pluginXbrlMethod in PluginManager.pluginClassMethods("Validate.Complete"):
+                pluginXbrlMethod(self, filesource)
+
         if filesource is not None and not options.keepOpen:
             # Archive filesource potentially used by multiple reports may still be open.
             filesource.close()

{arelle_release-2.37.53 → arelle_release-2.37.55}/arelle/CntlrWinMain.py

@@ -5,11 +5,14 @@ See COPYRIGHT.md for copyright information.
 '''
 from __future__ import annotations
 
+from typing import Any
+
 from arelle import ValidateDuplicateFacts
 import os, sys, subprocess, pickle, time, locale, fnmatch, platform, webbrowser
 import regex as re
 
 from arelle.logging.formatters.LogFormatter import logRefsFileLines
+from arelle.utils.EntryPointDetection import parseEntrypointFileInput
 
 if sys.platform == 'win32' and getattr(sys, 'frozen', False):
     # need the .dll directory in path to be able to access Tk and Tcl DLLs efore importinng Tk, etc.
@@ -816,15 +819,22 @@ class CntlrWinMain (Cntlr.Cntlr):
         if filename:
             for xbrlLoadedMethod in pluginClassMethods("CntlrWinMain.Xbrl.Open"):
                 filename = xbrlLoadedMethod(self, filename) # runs in GUI thread, allows mapping filename, mult return filename
-            filesource = None
+            entrypointParseResult = parseEntrypointFileInput(self, filename, fallbackSelect=False)
+            if not entrypointParseResult.success or entrypointParseResult.filesource is None:
+                return
+            filesource = entrypointParseResult.filesource
+            entrypointFiles = entrypointParseResult.entrypointFiles
             # check for archive files
-            filesource = openFileSource(filename, self,
-                                        checkIfXmlIsEis=self.modelManager.disclosureSystem and
-                                        self.modelManager.disclosureSystem.validationType == "EFM")
             if filesource.isArchive:
-                if not filesource.selection and not filesource.isReportPackage: # or filesource.isRss:
+                if (
+                    len(entrypointFiles) == 0 and
+                    not filesource.selection and
+                    not filesource.isReportPackage
+                ):
                     from arelle import DialogOpenArchive
                     filename = DialogOpenArchive.askArchiveFile(self, filesource)
+                    if filename is not None:
+                        entrypointFiles.append({"file": filename})
                     if filename and filesource.basefile and not isHttpUrl(filesource.basefile):
                         self.config["fileOpenDir"] = os.path.dirname(filesource.baseurl)
                 filesource.loadTaxonomyPackageMappings() # if a package, load mappings if not loaded yet
@@ -837,7 +847,7 @@ class CntlrWinMain (Cntlr.Cntlr):
                 self.updateFileHistory(filename, importToDTS)
             elif len(filename) == 1:
                 self.updateFileHistory(filename[0], importToDTS)
-            thread = threading.Thread(target=self.backgroundLoadXbrl, args=(filesource,importToDTS,selectTopView), daemon=True).start()
+            thread = threading.Thread(target=self.backgroundLoadXbrl, args=(filesource,entrypointFiles,importToDTS,selectTopView), daemon=True).start()
 
     def webOpen(self, *ignore):
         if not self.okayToContinue():
@@ -848,12 +858,24 @@ class CntlrWinMain (Cntlr.Cntlr):
             self.updateFileHistory(url, False)
             for xbrlLoadedMethod in pluginClassMethods("CntlrWinMain.Xbrl.Open"):
                 url = xbrlLoadedMethod(self, url) # runs in GUI thread, allows mapping url, mult return url
-            filesource = openFileSource(url,self)
-            if filesource.isArchive and not filesource.isReportPackage and not filesource.selection: # or filesource.isRss:
-                from arelle import DialogOpenArchive
-                url = DialogOpenArchive.askArchiveFile(self, filesource)
-                self.updateFileHistory(url, False)
-            thread = threading.Thread(target=self.backgroundLoadXbrl, args=(filesource,False,False), daemon=True).start()
+            entrypointParseResult = parseEntrypointFileInput(self, url, fallbackSelect=False)
+            if not entrypointParseResult.success or entrypointParseResult.filesource is None:
+                return
+            filesource = entrypointParseResult.filesource
+            entrypointFiles = entrypointParseResult.entrypointFiles
+            if filesource.isArchive:
+                if (
+                        len(entrypointFiles) == 0 and
+                        not filesource.selection and
+                        not filesource.isReportPackage
+                ):
+                    from arelle import DialogOpenArchive
+                    url = DialogOpenArchive.askArchiveFile(self, filesource)
+                    if url is not None:
+                        entrypointFiles.append({"file": url})
+                    self.updateFileHistory(url, False)
+                filesource.loadTaxonomyPackageMappings()
+            thread = threading.Thread(target=self.backgroundLoadXbrl, args=(filesource,entrypointFiles,False,False), daemon=True).start()
 
     def importWebOpen(self, *ignore):
         if not self.modelManager.modelXbrl or self.modelManager.modelXbrl.modelDocument.type not in (
@@ -867,36 +889,37 @@ class CntlrWinMain (Cntlr.Cntlr):
             self.fileOpenFile(url, importToDTS=True)
 
 
-    def backgroundLoadXbrl(self, filesource, importToDTS, selectTopView):
+    def backgroundLoadXbrl(self, filesource, entrypointFiles: list[dict[str, Any]], importToDTS, selectTopView):
         startedAt = time.time()
         loadedModels = []
         try:
-            if importToDTS:
-                action = _("imported")
-                profileStat = "import"
-                modelXbrl = self.modelManager.modelXbrl
-                if modelXbrl:
-                    ModelDocument.load(modelXbrl, filesource.url, isSupplemental=importToDTS)
-                    modelXbrl.relationshipSets.clear() # relationships have to be re-cached
-                    loadedModels.append(modelXbrl)
-            else:
-                action = _("loaded")
-                profileStat = "load"
-                if (reportPackage := filesource.reportPackage) and "_IXDS#?#" not in filesource.url:
-                    for report in reportPackage.reports or []:
-                        if len(report.fullPathFiles) > 1:
-                            self.addToLog(_("Loading error. Inline document set encountered. Enable 'Inline XBRL Document Set' plug-in and use the Open Inline Doc Set dialog from the file menu to open this filing: {0}").format(filesource.url))
-                            continue
-                        filesource.select(report.fullPathPrimary)
-                        modelXbrl = self.modelManager.load(filesource, _("views loading"))
-                        if modelXbrl:
-                            loadedModels.append(modelXbrl)
+            action = _("preparing entrypoints")
+            for pluginXbrlMethod in pluginClassMethods("CntlrWinMain.Filing.Start"):
+                pluginXbrlMethod(self, filesource, entrypointFiles)
+            for entrypoint in entrypointFiles:
+                entrypointFile = entrypoint.get("file", None) if isinstance(entrypoint,dict) else entrypoint
+                if filesource and filesource.isArchive:
+                    filesource.select(entrypointFile)
+                else:
+                    entrypointFile = PackageManager.mappedUrl(entrypointFile)
+                    filesource = openFileSource(entrypointFile, self)
+                if importToDTS:
+                    action = _("imported")
+                    profileStat = "import"
+                    modelXbrl = self.modelManager.modelXbrl
+                    if modelXbrl:
+                        ModelDocument.load(modelXbrl, filesource.url, isSupplemental=importToDTS)
+                        modelXbrl.relationshipSets.clear() # relationships have to be re-cached
+                        loadedModels.append(modelXbrl)
                 else:
+                    action = _("loaded")
+                    profileStat = "load"
                     modelXbrl = self.modelManager.load(
                         filesource,
                         _("views loading"),
                         # check modified time if GUI-loading from web
                         checkModifiedTime=isHttpUrl(filesource.url),
+                        entrypoint=entrypoint,
                     )
                     if modelXbrl:
                         loadedModels.append(modelXbrl)

{arelle_release-2.37.53 → arelle_release-2.37.55}/arelle/ModelDocument.py

@@ -446,7 +446,7 @@ def loadSchemalocatedSchema(modelXbrl, element, relativeUrl, namespace, baseUrl)
             doc.inDTS = False
     return doc
 
-def create(modelXbrl, type, uri, schemaRefs=None, isEntry=False, initialXml=None, initialComment=None, base=None, discover=True, documentEncoding="utf-8", xbrliNamespacePrefix=None) -> ModelDocument:
+def create(modelXbrl, type, uri, schemaRefs=None, isEntry=False, initialXml=None, initialComment=None, base=None, discover=True, documentEncoding="utf-8", xbrliNamespacePrefix=None, entrypoint=None) -> ModelDocument:
     """Returns a new modelDocument, created from scratch, with any necessary header elements
 
     (such as the schema, instance, or RSS feed top level elements)
@@ -538,6 +538,7 @@ def create(modelXbrl, type, uri, schemaRefs=None, isEntry=False, initialXml=None
         modelDocument.isQualifiedElementFormDefault = False
         modelDocument.isQualifiedAttributeFormDefault = False
     modelDocument.definesUTR = False
+    modelDocument.entrypoint = entrypoint
     return modelDocument
 
 class Type:
@@ -727,10 +728,12 @@ class ModelDocument:
     # The document encoding. The XML declaration is stripped from the document
     # before lxml parses the document making the lxml DocInfo encoding unreliable.
     documentEncoding: str
+    entrypoint: dict[str, Any] | None
     xmlRootElement: Any
     targetXbrlRootElement: ModelObject
 
     def __init__(self, modelXbrl, type, uri, filepath, xmlDocument):
+        self.entrypoint = None
         self.modelXbrl = modelXbrl
         self.skipDTS = modelXbrl.skipDTS
         self.type = type

{arelle_release-2.37.53 → arelle_release-2.37.55}/arelle/Validate.py

@@ -304,6 +304,7 @@ class Validate:
     def _testcaseLoadReadMeFirstUri(self, testcase, modelTestcaseVariation, index, readMeFirstUri, resultIsVersioningReport, resultIsTaxonomyPackage, inputDTSes, errorCaptureLevel, baseForElement, parameters):
         preLoadingErrors = [] # accumulate pre-loading errors, such as during taxonomy package loading
         loadedModels = []
+        filesource = None
         readMeFirstElements = modelTestcaseVariation.readMeFirstElements
         expectTaxonomyPackage = (index < len(readMeFirstElements) and
                                     readMeFirstElements[index] is not None and
@@ -492,6 +493,8 @@ class Validate:
                         _("Testcase variation validation exception: %(error)s, instance: %(instance)s"),
                         modelXbrl=model, instance=model.modelDocument.basename, error=err, exc_info=(type(err) is not AssertionError))
                 model.hasFormulae = _hasFormulae
+        for pluginXbrlMethod in pluginClassMethods("Validate.Complete"):
+            pluginXbrlMethod(self.modelXbrl.modelManager.cntlr, filesource)
         errors = [error for model in loadedModels for error in model.errors]
         for err in preLoadingErrors:
             if err not in errors:

{arelle_release-2.37.53 → arelle_release-2.37.55}/arelle/ViewWinDTS.py

@@ -30,7 +30,10 @@ class ViewDTS(ViewWinTree.ViewTree):
 
     def viewDtsElement(self, modelDocument, parentNode, n, parents, siblings):
         if modelDocument.type == ModelDocument.Type.INLINEXBRLDOCUMENTSET:
-            text = modelDocument.gettype() # no file name to display
+            if modelDocument.entrypoint is not None and "id" in modelDocument.entrypoint:
+                text = f"{modelDocument.entrypoint['id']} (IXDS)"
+            else:
+                text = "Inline XBRL Document Set" # no file name or ID to display
         else:
             text = "{0} - {1}".format(os.path.basename(modelDocument.uri), modelDocument.gettype())
         node = self.treeView.insert(parentNode, "end",

{arelle_release-2.37.53 → arelle_release-2.37.55}/arelle/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '2.37.53'
-__version_tuple__ = version_tuple = (2, 37, 53)
+__version__ = version = '2.37.55'
+__version_tuple__ = version_tuple = (2, 37, 55)
 
-__commit_id__ = commit_id = 'ge4044e75f'
+__commit_id__ = commit_id = 'g122eb892b'

{arelle_release-2.37.53 → arelle_release-2.37.55}/arelle/packages/report/ReportPackage.py

@@ -19,13 +19,22 @@ if TYPE_CHECKING:
     from arelle.FileSource import FileSource
 
 
+def pathsContainReportsDirectory(paths: set[str], topLevelDir: str) -> bool:
+    reportDirectory = f"{topLevelDir}/{Const.REPORTS_DIRECTORY}"
+    if reportDirectory in paths:
+        return True
+    reportDirectory = f"{reportDirectory}/"
+    return any(path.startswith(reportDirectory) for path in paths)
+
 def getReportPackageTopLevelDirectory(filesource: FileSource) -> str | None:
     packageEntries = set(filesource.dir or [])
-    potentialTopLevelReportDirs = {
-        topLevelDir
-        for topLevelDir in PackageUtils.getPackageTopLevelDirectories(filesource)
-        if any(f"{topLevelDir}/{path}" in packageEntries for path in Const.REPORT_PACKAGE_PATHS)
-    }
+    potentialTopLevelReportDirs = set()
+    for topLevelDir in PackageUtils.getPackageTopLevelDirectories(filesource):
+        if (
+            f"{topLevelDir}/{Const.REPORT_PACKAGE_FILE}" in packageEntries or
+            pathsContainReportsDirectory(packageEntries, topLevelDir)
+        ):
+            potentialTopLevelReportDirs.add(topLevelDir)
     if len(potentialTopLevelReportDirs) == 1:
         return next(iter(potentialTopLevelReportDirs))
     return None
@@ -98,7 +107,7 @@ def getAllReportEntries(filesource: FileSource, stld: str | None) -> list[Report
     if not isinstance(filesource.fs, zipfile.ZipFile):
         return None
     entries = [f.orig_filename for f in filesource.fs.infolist()]
-    if not any(entry.startswith(f"{stld}/{Const.REPORTS_DIRECTORY}") for entry in entries):
+    if not pathsContainReportsDirectory(set(entries), stld):
         return None
     topReportEntries = []
     entriesBySubDir = defaultdict(list)

{arelle_release-2.37.53 → arelle_release-2.37.55}/arelle/packages/report/ReportPackageConst.py

@@ -36,7 +36,6 @@ REPORT_PACKAGE_EXTENSIONS = frozenset(
 
 REPORT_PACKAGE_FILE = f"{META_INF_DIRECTORY}/reportPackage.json"
 REPORTS_DIRECTORY = "reports"
-REPORT_PACKAGE_PATHS = [REPORT_PACKAGE_FILE, f"{REPORTS_DIRECTORY}/"]
 
 XBRL_2_1_REPORT_FILE_EXTENSION = ".xbrl"
 JSON_REPORT_FILE_EXTENSION = ".json"

{arelle_release-2.37.53 → arelle_release-2.37.55}/arelle/plugin/inlineXbrlDocumentSet.py

@@ -248,7 +248,7 @@ def inlineXbrlDocumentSetLoader(modelXbrl, normalizedUri, filepath, isEntry=Fals
         for url in modelXbrl.ixdsDocUrls:
             xml.append("<instance>{}</instance>\n".format(url))
         xml.append("</instances>\n")
-        ixdocset = create(modelXbrl, Type.INLINEXBRLDOCUMENTSET, docsetUrl, isEntry=True, initialXml="".join(xml))
+        ixdocset = create(modelXbrl, Type.INLINEXBRLDOCUMENTSET, docsetUrl, isEntry=True, initialXml="".join(xml), entrypoint=kwargs.get('entrypoint'))
         ixdocset.type = Type.INLINEXBRLDOCUMENTSET
         ixdocset.targetDocumentPreferredFilename = None # possibly no inline docs in this doc set
         for i, elt in enumerate(ixdocset.xmlRootElement.iter(tag="instance")):
@@ -739,7 +739,22 @@ def commandLineOptionExtender(parser, *args, **kwargs):
 def commandLineFilingStart(cntlr, options, filesource, entrypointFiles, *args, **kwargs):
     global skipExpectedInstanceComparison
     skipExpectedInstanceComparison = getattr(options, "skipExpectedInstanceComparison", False)
-    inlineTarget = getattr(options, "inlineTarget", None)
+    filingStart(
+        cntlr,
+        entrypointFiles,
+        getattr(options, "inlineTarget", None),
+    )
+
+def guiFilingStart(cntlr, filesource, entrypointFiles, *args, **kwargs):
+    global skipExpectedInstanceComparison
+    skipExpectedInstanceComparison = False
+    filingStart(
+        cntlr,
+        entrypointFiles,
+        inlineTarget=None
+    )
+
+def filingStart(cntlr, entrypointFiles, inlineTarget):
     if inlineTarget:
         if isinstance(entrypointFiles, dict):
             entrypointFiles = [entrypointFiles]
@@ -1018,6 +1033,7 @@ __pluginInfo__ = {
     'InlineDocumentSet.Discovery': inlineDocsetDiscovery,
     'InlineDocumentSet.Url.Separator': inlineDocsetUrlSeparator,
     'InlineDocumentSet.CreateTargetInstance': createTargetInstance,
+    'CntlrWinMain.Filing.Start': guiFilingStart,
     'CntlrWinMain.Menu.File.Open': fileOpenMenuEntender,
     'CntlrWinMain.Menu.Tools': saveTargetDocumentMenuEntender,
     'CntlrCmdLine.Options': commandLineOptionExtender,

{arelle_release-2.37.53 → arelle_release-2.37.55}/arelle/plugin/validate/EDINET/Constants.py

@@ -39,3 +39,40 @@ qnEdinetManifestTocComposition = qname("{http://disclosure.edinet-fsa.go.jp/2013
 xhtmlDtdExtension = "xhtml1-strict-ix.dtd"
 
 COVER_PAGE_FILENAME_PREFIX = "0000000_header_"
+
+PROHIBITED_HTML_ATTRIBUTES = frozenset({
+    'onblur',
+    'onchange',
+    'onclick',
+    'ondblclick',
+    'onfocus',
+    'onkeydown',
+    'onkeypress',
+    'onkeyup',
+    'onload',
+    'onmousedown',
+    'onmousemove',
+    'onmouseout',
+    'onmouseover',
+    'onmouseup',
+    'onreset',
+    'onselect',
+    'onsubmit',
+    'onunload',
+})
+
+PROHIBITED_HTML_TAGS = frozenset({
+    'applet',
+    'embed',
+    'form',
+    'frame',
+    'frameset',
+    'iframe',
+    'input',
+    'object',
+    'plaintext',
+    'pre',
+    'script',
+    'select',
+    'textarea',
+})

{arelle_release-2.37.53 → arelle_release-2.37.55}/arelle/plugin/validate/EDINET/ControllerPluginData.py

@@ -27,10 +27,12 @@ _: TypeGetText
 @dataclass
 class ControllerPluginData(PluginData):
     _manifestInstancesById: dict[str, ManifestInstance]
+    _usedFilepaths: set[Path]
 
     def __init__(self, name: str):
         super().__init__(name)
         self._manifestInstancesById = {}
+        self._usedFilepaths = set()
 
     def __hash__(self) -> int:
         return id(self)
@@ -120,6 +122,9 @@ class ControllerPluginData(PluginData):
             if not i.is_dir()
         }
 
+    def getUsedFilepaths(self) -> frozenset[Path]:
+        return frozenset(self._usedFilepaths)
+
     @lru_cache(1)
     def isUpload(self, fileSource: FileSource) -> bool:
         fileSource.open()  # Make sure file source is open
@@ -165,6 +170,9 @@ class ControllerPluginData(PluginData):
             break
         return matchedInstance
 
+    def addUsedFilepath(self, path: Path) -> None:
+        self._usedFilepaths.add(path)
+
     @staticmethod
     def get(cntlr: Cntlr, name: str) -> ControllerPluginData:
         controllerPluginData = cntlr.getPluginData(name)

{arelle_release-2.37.53 → arelle_release-2.37.55}/arelle/plugin/validate/EDINET/ManifestInstance.py

@@ -166,4 +166,4 @@ def parseManifests(filesource: FileSource) -> list[ManifestInstance]:
                     err,
                     traceback.format_exc()
                 ))
-    return instances
+    return sorted(instances, key=lambda i: i.id)

{arelle_release-2.37.53 → arelle_release-2.37.55}/arelle/plugin/validate/EDINET/PluginValidationDataExtension.py

@@ -7,15 +7,18 @@ from collections import defaultdict
 from dataclasses import dataclass
 from decimal import Decimal
 from functools import lru_cache
-from lxml.etree import DTD, XML
+from pathlib import Path
+
+from lxml.etree import DTD, XML, _ElementTree, _Comment, _ProcessingInstruction
 from operator import attrgetter
 from typing import Callable, Hashable, Iterable, cast
 
 import os
 import regex
 
+from arelle import UrlUtil
 from arelle.LinkbaseType import LinkbaseType
-from arelle.ModelDocument import Type as ModelDocumentType
+from arelle.ModelDocument import Type as ModelDocumentType, ModelDocument
 from arelle.ModelDtsObject import ModelConcept
 from arelle.ModelInstanceObject import ModelFact, ModelUnit, ModelContext, ModelInlineFact
 from arelle.ModelObject import ModelObject
@@ -23,10 +26,12 @@ 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.XhtmlValidate import htmlEltUriAttrs
 from arelle.XmlValidate import VALID
 from arelle.typing import TypeGetText
 from arelle.utils.PluginData import PluginData
-from .Constants import CORPORATE_FORMS, FormType, xhtmlDtdExtension
+from .Constants import CORPORATE_FORMS, FormType, xhtmlDtdExtension, PROHIBITED_HTML_TAGS, PROHIBITED_HTML_ATTRIBUTES
 from .ControllerPluginData import ControllerPluginData
 from .ManifestInstance import ManifestInstance
 from .Statement import Statement, STATEMENTS, BalanceSheet, StatementInstance, StatementType
@@ -37,6 +42,14 @@ _: TypeGetText
 _DEBIT_QNAME_PATTERN = regex.compile('.*(Liability|Liabilities|Equity)')
 
 
+@dataclass(frozen=True)
+class UriReference:
+    attributeName: str
+    attributeValue: str
+    document: ModelDocument
+    element: ModelObject
+
+
 @dataclass
 class PluginValidationDataExtension(PluginData):
     accountingStandardsDeiQn: QName
@@ -51,9 +64,9 @@ class PluginValidationDataExtension(PluginData):
 
     contextIdPattern: regex.Pattern[str]
 
-    _primaryModelXbrl: ModelXbrl | None = None
+    _uriReferences: list[UriReference]
 
-    def __init__(self, name: str):
+    def __init__(self, name: str, validateXbrl: ValidateXbrl):
         super().__init__(name)
         jpcrpEsrNamespace = "http://disclosure.edinet-fsa.go.jp/taxonomy/jpcrp-esr/2024-11-01/jpcrp-esr_cor"
         self.jpcrpNamespace = 'http://disclosure.edinet-fsa.go.jp/taxonomy/jpcrp/2024-11-01/jpcrp_cor'
@@ -74,6 +87,9 @@ class PluginValidationDataExtension(PluginData):
 
         self.contextIdPattern = regex.compile(r'(Prior[1-9]Year|CurrentYear|Prior[1-9]Interim|Interim)(Duration|Instant)')
 
+        self._uriReferences = []
+        self._initialize(validateXbrl.modelXbrl)
+
     # Identity hash for caching.
     def __hash__(self) -> int:
         return id(self)
@@ -93,6 +109,28 @@ class PluginValidationDataExtension(PluginData):
         contextIsConsolidated = memberValue != self.nonConsolidatedMemberQn
         return bool(statement.isConsolidated == contextIsConsolidated)
 
+    def _initialize(self, modelXbrl: ModelXbrl) -> None:
+        if not isinstance(modelXbrl.fileSource.basefile, str):
+            return
+        controllerPluginData = ControllerPluginData.get(modelXbrl.modelManager.cntlr, self.name)
+        basePath = Path(modelXbrl.fileSource.basefile)
+        for uri, doc in modelXbrl.urlDocs.items():
+            docPath = Path(uri)
+            if not docPath.is_relative_to(basePath):
+                continue
+            controllerPluginData.addUsedFilepath(docPath.relative_to(basePath))
+            for elt, name, value in self.getUriAttributeValues(doc):
+                self._uriReferences.append(UriReference(
+                    attributeName=name,
+                    attributeValue=value,
+                    document=doc,
+                    element=elt,
+                ))
+                fullPath = Path(doc.uri).parent / value
+                if fullPath.is_relative_to(basePath):
+                    fileSourcePath = fullPath.relative_to(basePath)
+                    controllerPluginData.addUsedFilepath(fileSourcePath)
+
     def _isDebitConcept(self, concept: ModelConcept) -> bool:
         """
         :return: Whether the given concept is a debit concept.
@@ -201,6 +239,10 @@ class PluginValidationDataExtension(PluginData):
             if (statementInstance := self.getStatementInstance(modelXbrl, statement)) is not None
         ]
 
+    @property
+    def uriReferences(self) -> list[UriReference]:
+        return self._uriReferences
+
     @lru_cache(1)
     def getDeduplicatedFacts(self, modelXbrl: ModelXbrl) -> list[ModelFact]:
         return getDeduplicatedFacts(modelXbrl, DeduplicationType.CONSISTENT_PAIRS)
@@ -259,6 +301,44 @@ class PluginValidationDataExtension(PluginData):
         controllerPluginData = ControllerPluginData.get(modelXbrl.modelManager.cntlr, self.name)
         return controllerPluginData.matchManifestInstance(modelXbrl.ixdsDocUrls)
 
+    @lru_cache(1)
+    def getProhibitedAttributeElements(self, modelDocument: ModelDocument) -> list[tuple[ModelObject, str]]:
+        results: list[tuple[ModelObject, str]] = []
+        if modelDocument.type not in (ModelDocumentType.INLINEXBRL, ModelDocumentType.HTML):
+            return results
+        for elt in modelDocument.xmlRootElement.iter():
+            if not isinstance(elt, ModelObject):
+                continue
+            for attributeName in elt.attrib.keys():
+                if attributeName in PROHIBITED_HTML_ATTRIBUTES:
+                    results.append((elt, str(attributeName)))
+        return results
+
+    @lru_cache(1)
+    def getProhibitedTagElements(self, modelDocument: ModelDocument) -> list[ModelObject]:
+        elts: list[ModelObject] = []
+        if modelDocument.type not in (ModelDocumentType.INLINEXBRL, ModelDocumentType.HTML):
+            return elts
+        for elt in modelDocument.xmlRootElement.iter():
+            if not isinstance(elt, ModelObject):
+                continue
+            tag = elt.qname.localName
+            if tag in PROHIBITED_HTML_TAGS:
+                elts.append(elt)
+        return elts
+
+    @lru_cache(1)
+    def getUriAttributeValues(self, modelDocument: ModelDocument) -> list[tuple[ModelObject, str, str]]:
+        results: list[tuple[ModelObject, str, str]] = []
+        if modelDocument.type not in (ModelDocumentType.INLINEXBRL, ModelDocumentType.HTML):
+            return results
+        for elt in modelDocument.xmlRootElement.iter():
+            for name in htmlEltUriAttrs.get(elt.localName, ()):
+                value = elt.get(name)
+                if value is not None:
+                    results.append((elt, name, value))
+        return results
+
     def hasValidNonNilFact(self, modelXbrl: ModelXbrl, qname: QName) -> bool:
         return any(True for fact in self.iterValidNonNilFacts(modelXbrl, qname))
 
@@ -270,3 +350,7 @@ class PluginValidationDataExtension(PluginData):
         for fact in facts:
             if fact.xValid >= VALID and not fact.isNil:
                 yield fact
+
+    def addUsedFilepath(self, modelXbrl: ModelXbrl, path: Path) -> None:
+        controllerPluginData = ControllerPluginData.get(modelXbrl.modelManager.cntlr, self.name)
+        controllerPluginData.addUsedFilepath(path)

{arelle_release-2.37.53 → arelle_release-2.37.55}/arelle/plugin/validate/EDINET/ValidationPluginExtension.py

@@ -3,6 +3,7 @@ See COPYRIGHT.md for copyright information.
 """
 from __future__ import annotations
 
+import logging
 from typing import Any
 
 from arelle.Cntlr import Cntlr
@@ -26,6 +27,15 @@ class ValidationPluginExtension(ValidationPlugin):
         if len(instances) == 0:
             return None
         assert filesource.cntlr is not None
+        filesource.cntlr.addToLog(
+            _("EDINET manifest(s) detected (%(manifests)s). Loading %(count)s instances (%(instances)s)."),
+            messageCode="info",
+            messageArgs={
+                "manifests": ', '.join(instance.type for instance in instances),
+                "count": len(instances),
+                "instances": ', '.join(instance.id for instance in instances),
+            }, level=logging.INFO
+        )
         pluginData = ControllerPluginData.get(filesource.cntlr, self.name)
         entrypointFiles = []
         for instance in instances:
@@ -49,4 +59,5 @@ class ValidationPluginExtension(ValidationPlugin):
             raise ValueError(f'Invalid EDINET disclosure system: {disclosureSystem}')
         return PluginValidationDataExtension(
             self.name,
+            validateXbrl
         )