arelle-release 2.37.11__tar.gz → 2.37.13__tar.gz

{arelle_release-2.37.11 → arelle_release-2.37.13}/.github/workflows/build-linux.yml

@@ -87,7 +87,7 @@ jobs:
       - name: Docker setup buildx
         uses: docker/setup-buildx-action@v3.10.0
       - name: Docker build
-        uses: docker/build-push-action@v6.16.0
+        uses: docker/build-push-action@v6.17.0
         with:
           build-args: |
             "OPENSSL_VERSION=${{ inputs.openssl_version }}"

{arelle_release-2.37.11 → arelle_release-2.37.13}/.github/workflows/conformance-suite.yml

@@ -41,7 +41,7 @@ jobs:
           persist-credentials: false
       - name: Configure AWS Credentials
         if: ${{ inputs.environment == 'integration-tests' }}
-        uses: aws-actions/configure-aws-credentials@v4.2.0
+        uses: aws-actions/configure-aws-credentials@v4.2.1
         with:
           aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY }}
           aws-secret-access-key: ${{ secrets.AWS_SECRET_KEY }}

{arelle_release-2.37.11 → arelle_release-2.37.13}/.github/workflows/conformance-suites.yml

@@ -47,7 +47,7 @@ jobs:
           repository: ${{ github.event.pull_request.head.repo.full_name }}
       - name: Configure AWS Credentials
         if: ${{ matrix.test.environment == 'integration-tests' }}
-        uses: aws-actions/configure-aws-credentials@v4.2.0
+        uses: aws-actions/configure-aws-credentials@v4.2.1
         with:
           aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY }}
           aws-secret-access-key: ${{ secrets.AWS_SECRET_KEY }}

{arelle_release-2.37.11 → arelle_release-2.37.13}/.github/workflows/publish-frozen-build.yml

@@ -44,7 +44,7 @@ jobs:
           files: ${{ inputs.build_name }}
 
       - name: Configure AWS credentials
-        uses: aws-actions/configure-aws-credentials@v4.2.0
+        uses: aws-actions/configure-aws-credentials@v4.2.1
         with:
           aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
           aws-secret-access-key: ${{ secrets.AWS_ACCESS_KEY_SECRET }}

{arelle_release-2.37.11/arelle_release.egg-info → arelle_release-2.37.13}/PKG-INFO

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

{arelle_release-2.37.11 → arelle_release-2.37.13}/arelle/CntlrCmdLine.py

@@ -56,6 +56,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.utils.EntryPointDetection import filesourceEntrypointFiles
 from arelle.UrlUtil import isHttpUrl
 from arelle.ValidateXbrlDTS import ValidateBaseTaxonomiesMode
 from arelle.WebCache import proxyTuple
@@ -585,72 +586,6 @@ def configAndRunCntlr(options, arellePluginModules):
         return cntlr
 
 
-def filesourceEntrypointFiles(filesource, entrypointFiles=None, inlineOnly=False):
-    if entrypointFiles is None:
-        entrypointFiles = []
-    if filesource.isArchive:
-        if filesource.isTaxonomyPackage:  # if archive is also a taxonomy package, activate mappings
-            filesource.loadTaxonomyPackageMappings()
-        # HF note: a web api request to load a specific file from archive is ignored, is this right?
-        del entrypointFiles[:] # clear out archive from entrypointFiles
-        if reportPackage := filesource.reportPackage:
-            assert isinstance(filesource.basefile, str)
-            for report in reportPackage.reports or []:
-                if report.isInline:
-                    reportEntries = [{"file": f} for f in report.fullPathFiles]
-                    ixdsDiscovered = False
-                    for pluginXbrlMethod in PluginManager.pluginClassMethods("InlineDocumentSet.Discovery"):
-                        pluginXbrlMethod(filesource, reportEntries)
-                        ixdsDiscovered = True
-                    if not ixdsDiscovered and len(reportEntries) > 1:
-                        raise RuntimeError(_("Loading error. Inline document set encountered. Enable 'InlineXbrlDocumentSet' plug-in to load this filing: {0}").format(filesource.url))
-                    entrypointFiles.extend(reportEntries)
-                elif not inlineOnly:
-                    entrypointFiles.append({"file": report.fullPathPrimary})
-        else:
-            # attempt to find inline XBRL files before instance files, .xhtml before probing others (ESMA)
-            urlsByType = {}
-            for _archiveFile in (filesource.dir or ()): # .dir might be none if IOerror
-                filesource.select(_archiveFile)
-                identifiedType = ModelDocument.Type.identify(filesource, filesource.url)
-                if identifiedType in (ModelDocument.Type.INSTANCE, ModelDocument.Type.INLINEXBRL, ModelDocument.Type.HTML):
-                    urlsByType.setdefault(identifiedType, []).append(filesource.url)
-            # use inline instances, if any, else non-inline instances
-            for identifiedType in ((ModelDocument.Type.INLINEXBRL,) if inlineOnly else (ModelDocument.Type.INLINEXBRL, ModelDocument.Type.INSTANCE)):
-                for url in urlsByType.get(identifiedType, []):
-                    entrypointFiles.append({"file":url})
-                if entrypointFiles:
-                    if identifiedType == ModelDocument.Type.INLINEXBRL:
-                        for pluginXbrlMethod in PluginManager.pluginClassMethods("InlineDocumentSet.Discovery"):
-                            pluginXbrlMethod(filesource, entrypointFiles) # group into IXDS if plugin feature is available
-                    break # found inline (or non-inline) entrypoint files, don't look for any other type
-            # for ESEF non-consolidated xhtml documents accept an xhtml entry point
-            if not entrypointFiles and not inlineOnly:
-                for url in urlsByType.get(ModelDocument.Type.HTML, []):
-                    entrypointFiles.append({"file":url})
-            if not entrypointFiles and filesource.taxonomyPackage is not None:
-                for packageEntry in filesource.taxonomyPackage.get('entryPoints', {}).values():
-                    for _resolvedUrl, remappedUrl, _closest in packageEntry:
-                        entrypointFiles.append({"file": remappedUrl})
-
-
-    elif os.path.isdir(filesource.url):
-        del entrypointFiles[:] # clear list
-        hasInline = False
-        for _file in os.listdir(filesource.url):
-            _path = os.path.join(filesource.url, _file)
-            if os.path.isfile(_path):
-                identifiedType = ModelDocument.Type.identify(filesource, _path)
-                if identifiedType == ModelDocument.Type.INLINEXBRL:
-                    hasInline = True
-                if identifiedType in (ModelDocument.Type.INSTANCE, ModelDocument.Type.INLINEXBRL):
-                    entrypointFiles.append({"file":_path})
-        if hasInline: # group into IXDS if plugin feature is available
-            for pluginXbrlMethod in PluginManager.pluginClassMethods("InlineDocumentSet.Discovery"):
-                pluginXbrlMethod(filesource, entrypointFiles)
-
-    return entrypointFiles
-
 class ParserForDynamicPlugins:
     def __init__(self, options):
         self._long_opt = {}

{arelle_release-2.37.11 → arelle_release-2.37.13}/arelle/ModelDtsObject.py

@@ -1846,7 +1846,7 @@ class ModelRelationship(ModelObject):
 
     @property
     def orderDecimal(self):
-        """(decimal) -- Value of xlink:order attribute, NaN if not convertable to float, or None if not specified"""
+        """(decimal) -- Value of xlink:order attribute, NaN if not convertible to float, or None if not specified"""
         try:
             return decimal.Decimal(self.order)
         except decimal.InvalidOperation:

{arelle_release-2.37.11 → arelle_release-2.37.13}/arelle/ModelInstanceObject.py

@@ -795,6 +795,15 @@ class ModelInlineFact(ModelInlineValueObject, ModelFact):
             for inline root element, the xbrli:xbrl element is substituted for by the inline root element"""
         return getattr(self, "_ixFactParent") # set by ModelDocument locateFactInTuple for the inline target's root element
 
+    @property
+    def isEscaped(self):
+        """(bool) -- if true, the fact is escaped"""
+        try:
+            return self._isEscaped
+        except AttributeError:
+            self._isEscaped = self.get("escape") in ("true", "1")
+            return self._isEscaped
+
     def ixIter(self, childOnly=False):
         """(ModelObject) -- child elements (tuple facts) of the inline target instance document"""
         for fact in self.modelTupleFacts:

{arelle_release-2.37.11 → arelle_release-2.37.13}/arelle/ModelTestcaseObject.py

@@ -158,7 +158,7 @@ class ModelTestcaseVariation(ModelObject):
         except AttributeError:
             self._dataUris = defaultdict(list) # may contain instances, schemas, linkbases
             for dataElement in XmlUtil.descendants(self, None, ("data", "input")):
-                for elt in XmlUtil.descendants(dataElement, None, ("xsd", "schema", "linkbase", "instance")):
+                for elt in XmlUtil.descendants(dataElement, None, ("xsd", "schema", "linkbase", "instance", "taxonomyPackage")):
                     self._dataUris["schema" if elt.localName == "xsd" else elt.localName].append(elt.textValue.strip())
             return self._dataUris
 

{arelle_release-2.37.11 → arelle_release-2.37.13}/arelle/PackageManager.py

@@ -130,7 +130,7 @@ def _parsePackageMetadata(
     try:
         metadataFileContent = filesource.file(metadataFile)[0] # URL in zip, plain file in file system or web
         tree = _parseFile(cntlr, parser, metadataFile, metadataFileContent, TP_XSD)
-    except (etree.XMLSyntaxError, etree.DocumentInvalid) as err:
+    except (etree.XMLSyntaxError, etree.DocumentInvalid, etree.XMLSchemaError) as err:
         cntlr.addToLog(_("Taxonomy package file syntax error %(error)s"),
                        messageArgs={"error": str(err)},
                        messageCode="tpe:invalidMetaDataFile",

{arelle_release-2.37.11 → arelle_release-2.37.13}/arelle/Validate.py

@@ -1,6 +1,7 @@
 '''
 See COPYRIGHT.md for copyright information.
 '''
+import bisect
 import fnmatch
 import os, sys, traceback, logging
 import time
@@ -25,6 +26,7 @@ from arelle.PluginManager import pluginClassMethods
 from arelle.packages.report.DetectReportPackage import isReportPackageExtension
 from arelle.packages.report.ReportPackageValidator import ReportPackageValidator
 from arelle.rendering import RenderingEvaluator
+from arelle.utils.EntryPointDetection import filesourceEntrypointFiles
 from arelle.XmlUtil import collapseWhitespace, xmlstring
 
 def validate(modelXbrl):
@@ -166,7 +168,6 @@ class Validate:
                     filesource = FileSource.openFileSource(rssItemUrl, self.modelXbrl.modelManager.cntlr)
                     if filesource and not filesource.selection and filesource.isArchive:
                         try:
-                            from arelle.CntlrCmdLine import filesourceEntrypointFiles
                             entrypoints = filesourceEntrypointFiles(filesource)
                             if entrypoints:
                                 # resolve an IXDS in entrypoints
@@ -394,13 +395,12 @@ class Validate:
                             filesource.loadTaxonomyPackageMappings(errors=preLoadingErrors, expectTaxonomyPackage=expectTaxonomyPackage)
                             filesource.select(None) # must select loadable reports (not the taxonomy package itself)
                         elif not filesource.isReportPackage:
-                            from arelle.CntlrCmdLine import filesourceEntrypointFiles
                             entrypoints = filesourceEntrypointFiles(filesource)
                             if entrypoints:
                                 # resolve an IXDS in entrypoints
                                 for pluginXbrlMethod in pluginClassMethods("ModelTestcaseVariation.ArchiveIxds"):
                                     pluginXbrlMethod(self, filesource,entrypoints)
-                                filesource.select(entrypoints[0].get("file", None) )
+                                filesource.select(entrypoints[0].get("file", None))
                     except Exception as err:
                         self.modelXbrl.error("exception:" + type(err).__name__,
                             _("Testcase variation validation exception: %(error)s, entry URL: %(instance)s"),
@@ -408,17 +408,20 @@ class Validate:
                         return [] # don't try to load this entry URL
                 if filesource and filesource.isReportPackage and not _rptPkgIxdsOptions:
                     if not reportPackageErrors:
-                        for report in filesource.reportPackage.reports or []:
-                            assert isinstance(filesource.basefile, str)
-                            modelXbrl = ModelXbrl.load(self.modelXbrl.modelManager,
-                                                        report.primary,
-                                                        _("validating"),
-                                                        useFileSource=filesource,
-                                                        base=filesource.basefile + "/",
-                                                        errorCaptureLevel=errorCaptureLevel,
-                                                        ixdsTarget=modelTestcaseVariation.ixdsTarget,
-                                                        errors=preLoadingErrors)
-                            loadedModels.append(modelXbrl)
+                        assert isinstance(filesource.basefile, str)
+                        if entrypoints := filesourceEntrypointFiles(filesource):
+                            for pluginXbrlMethod in pluginClassMethods("ModelTestcaseVariation.ArchiveIxds"):
+                                pluginXbrlMethod(self, filesource, entrypoints)
+                            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)
                 else:
                     if _rptPkgIxdsOptions and filesource.isTaxonomyPackage:
                         # Legacy ESEF conformance suite logic.
@@ -492,9 +495,17 @@ class Validate:
         # validate schema, linkbase, or instance
         formulaOutputInstance = None
         modelXbrl = inputDTSes[None][0]
-        expectedDataFiles = set(modelXbrl.modelManager.cntlr.webCache.normalizeUrl(uri, baseForElement)
-                                for d in modelTestcaseVariation.dataUris.values() for uri in d
-                                if not UrlUtil.isAbsolute(uri))
+        expectedDataFiles = set()
+        expectedTaxonomyPackages = []
+        for localName, d in modelTestcaseVariation.dataUris.items():
+            for uri in d:
+                if not UrlUtil.isAbsolute(uri):
+                    normalizedUri = self.modelXbrl.modelManager.cntlr.webCache.normalizeUrl(uri, baseForElement)
+                    if localName == "taxonomyPackage":
+                        expectedTaxonomyPackages.append(normalizedUri)
+                    else:
+                        expectedDataFiles.add(normalizedUri)
+        expectedTaxonomyPackages.sort()
         foundDataFiles = set()
         variationBase = os.path.dirname(baseForElement)
         for dtsName, inputDTS in inputDTSes.items():  # input instances are also parameters
@@ -509,16 +520,28 @@ class Validate:
                             if docUrl.replace("-formula.xml", ".xf") in expectedDataFiles:
                                 docUrl = docUrl.replace("-formula.xml", ".xf")
                         foundDataFiles.add(docUrl)
-        if expectedDataFiles - foundDataFiles:
+
+        foundDataFilesInTaxonomyPackages = set()
+        foundTaxonomyPackages = set()
+        for f in foundDataFiles:
+            if i := bisect.bisect(expectedTaxonomyPackages, f):
+                package = expectedTaxonomyPackages[i-1]
+                if f.startswith(package + "/"):
+                    foundDataFilesInTaxonomyPackages.add(f)
+                    foundTaxonomyPackages.add(package)
+
+        expectedNotFound = expectedDataFiles.union(expectedTaxonomyPackages) - foundDataFiles - foundTaxonomyPackages
+        if expectedNotFound:
             modelXbrl.info("arelle:testcaseDataNotUsed",
                 _("Variation %(id)s %(name)s data files not used: %(missingDataFiles)s"),
                 modelObject=modelTestcaseVariation, name=modelTestcaseVariation.name, id=modelTestcaseVariation.id,
-                missingDataFiles=", ".join(sorted(os.path.basename(f) for f in expectedDataFiles - foundDataFiles)))
-        if foundDataFiles - expectedDataFiles:
+                missingDataFiles=", ".join(sorted(os.path.basename(f) for f in expectedNotFound)))
+        foundNotExpected = foundDataFiles - expectedDataFiles - foundDataFilesInTaxonomyPackages
+        if foundNotExpected:
             modelXbrl.info("arelle:testcaseDataUnexpected",
                 _("Variation %(id)s %(name)s files not in variation data: %(unexpectedDataFiles)s"),
                 modelObject=modelTestcaseVariation, name=modelTestcaseVariation.name, id=modelTestcaseVariation.id,
-                unexpectedDataFiles=", ".join(sorted(os.path.basename(f) for f in foundDataFiles - expectedDataFiles)))
+                unexpectedDataFiles=", ".join(sorted(os.path.basename(f) for f in foundNotExpected)))
         if modelXbrl.hasTableRendering or modelTestcaseVariation.resultIsTable:
             try:
                 RenderingEvaluator.init(modelXbrl)

{arelle_release-2.37.11 → arelle_release-2.37.13}/arelle/ValidateFilingText.py

@@ -3,7 +3,7 @@ See COPYRIGHT.md for copyright information.
 '''
 from __future__ import annotations
 #import xml.sax, xml.sax.handler
-from lxml.etree import XML, DTD, SubElement, _ElementTree, _Comment, _ProcessingInstruction, XMLSyntaxError, XMLParser
+from lxml.etree import XML, DTD, SubElement, _ElementTree, _Comment, _ProcessingInstruction, _Entity, XMLSyntaxError, XMLParser
 from dataclasses import dataclass
 from PIL import Image as pilImage
 import os, io, base64
@@ -604,7 +604,7 @@ def validateTextBlockFacts(modelXbrl):
                         eltTag = elt.tag
                         if isinstance(elt, ModelObject) and elt.namespaceURI == xhtml:
                             eltTag = elt.localName
-                        elif isinstance(elt, (_ElementTree, _Comment, _ProcessingInstruction)):
+                        elif isinstance(elt, (_ElementTree, _Comment, _ProcessingInstruction, _Entity)):
                             continue # comment or other non-parsed element
                         else:
                             eltTag = elt.tag
@@ -730,7 +730,7 @@ def validateHtmlContent(modelXbrl, referenceElt, htmlEltTree, validatedObjectLab
     for elt in htmlEltTree.iter():
         if isinstance(elt, ModelObject) and elt.namespaceURI == xhtml:
             eltTag = elt.localName
-        elif isinstance(elt, (_ElementTree, _Comment, _ProcessingInstruction)):
+        elif isinstance(elt, (_ElementTree, _Comment, _ProcessingInstruction, _Entity)):
             continue # comment or other non-parsed element
         else:
             eltTag = elt.tag

{arelle_release-2.37.11 → arelle_release-2.37.13}/arelle/XmlValidate.py

@@ -777,7 +777,7 @@ def lxmlSchemaValidate(modelDocument: ModelDocument, extraSchema : str | None =
                                    file=modelDocument.basename,
                                    level=logging.ERROR)
                     modelDocument.modelXbrl.errors.append(msgCode)
-        except etree.XMLSyntaxError as err:
+        except (etree.XMLSyntaxError, etree.XMLSchemaError) as err:
             msgCode = "lxml.schemaError"
             cntlr.addToLog(_("XML file syntax error %(error)s"),
                            messageArgs={"error": str(err)},

{arelle_release-2.37.11 → arelle_release-2.37.13}/arelle/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '2.37.11'
-__version_tuple__ = version_tuple = (2, 37, 11)
+__version__ = version = '2.37.13'
+__version_tuple__ = version_tuple = (2, 37, 13)

{arelle_release-2.37.11 → arelle_release-2.37.13}/arelle/formula/XPathParser.py

@@ -3,6 +3,7 @@ See COPYRIGHT.md for copyright information.
 '''
 from __future__ import annotations
 
+import logging
 import sys
 import time
 import traceback
@@ -906,9 +907,14 @@ def initializeParser(modelManager: ModelManager) -> bool:
         modelManager.showStatus(_("initializing formula xpath2 grammar"))
         startedAt = time.time()
         xpathExpr.parse_string("0", parseAll=True)
-        modelManager.addToLog(format_string(modelManager.locale,
-                                    _("Formula xpath2 grammar initialized in %.2f secs"),
-                                    time.time() - startedAt))
+        modelManager.addToLog(
+            format_string(
+                modelManager.locale,
+                _("Formula xpath2 grammar initialized in %.2f secs"),
+                time.time() - startedAt
+            ),
+            level=logging.DEBUG
+        )
         modelManager.showStatus(None)
         isInitialized = True
         return True  # was initialized on this call

{arelle_release-2.37.11 → arelle_release-2.37.13}/arelle/packages/report/ReportPackage.py

@@ -7,10 +7,10 @@ from __future__ import annotations
 import json
 import os
 import zipfile
-from collections import defaultdict
+from collections import Counter, defaultdict
 from dataclasses import dataclass
 from pathlib import Path, PurePosixPath
-from typing import TYPE_CHECKING, Any, Counter, cast
+from typing import TYPE_CHECKING, Any, cast
 
 from arelle.packages import PackageUtils
 from arelle.packages.report import ReportPackageConst as Const
@@ -162,6 +162,10 @@ class ReportEntry:
     def isTopLevel(self) -> bool:
         return len(PurePosixPath(self.primary).parts) == 3
 
+    @property
+    def dir(self) -> str:
+        return PurePosixPath(self.primary).parent.name
+
 
 class ReportPackage:
     def __init__(
@@ -204,7 +208,7 @@ class ReportPackage:
         reports = getAllReportEntries(filesource, stld)
         if reportPackageJsonFile is None and reports is None:
             return None
-        reportEntriesBySubDir = Counter(dir for report in reports or [] if not report.isTopLevel)
+        reportEntriesBySubDir = Counter(report.dir for report in reports or [] if not report.isTopLevel)
         if reports is not None and any(report.isTopLevel for report in reports):
             reports = [report for report in reports if report.isTopLevel]
         if any(subdirCount > 1 for subdirCount in reportEntriesBySubDir.values()):

{arelle_release-2.37.11 → arelle_release-2.37.13}/arelle/packages/report/ReportPackageValidator.py

@@ -4,9 +4,10 @@ See COPYRIGHT.md for copyright information.
 
 from __future__ import annotations
 
+from collections import Counter
 from collections.abc import Generator
 from pathlib import Path, PurePosixPath
-from typing import TYPE_CHECKING, Counter
+from typing import TYPE_CHECKING
 
 from arelle.packages import PackageValidation
 from arelle.packages.PackageType import PackageType
@@ -146,8 +147,8 @@ class ReportPackageValidator:
                     _("Report package must contain at least one report"),
                 )
             if len(reportEntries) > 1 and not any(report.isTopLevel for report in reportEntries):
-                byBaseDir = Counter(report.baseDir for report in reportEntries)
-                if byBaseDir:
+                reportEntriesBySubDir = Counter(report.dir for report in reportEntries or [] if not report.isTopLevel)
+                if any(subdirCount > 1 for subdirCount in reportEntriesBySubDir.values()):
                     return Validation.error(
                         "rpe:multipleReportsInSubdirectory",
                         _("Report package must contain only one report"),

{arelle_release-2.37.11 → arelle_release-2.37.13}/arelle/plugin/inlineXbrlDocumentSet.py

@@ -131,7 +131,6 @@ import regex as re
 from lxml.etree import XML, XMLSyntaxError
 
 from arelle import FileSource, ModelXbrl, ValidateDuplicateFacts, ValidateXbrlDimensions, XbrlConst
-from arelle.CntlrCmdLine import filesourceEntrypointFiles
 from arelle.FileSource import archiveFilenameParts, archiveFilenameSuffixes
 from arelle.ModelDocument import ModelDocument, ModelDocumentReference, Type, create, inlineIxdsDiscover, load
 from arelle.ModelInstanceObject import ModelInlineFootnote
@@ -142,6 +141,7 @@ from arelle.PrototypeDtsObject import ArcPrototype, LocPrototype
 from arelle.PythonUtil import attrdict, isLegacyAbs
 from arelle.RuntimeOptions import RuntimeOptions
 from arelle.UrlUtil import isHttpUrl
+from arelle.utils.EntryPointDetection import filesourceEntrypointFiles
 from arelle.ValidateDuplicateFacts import DeduplicationType
 from arelle.ValidateFilingText import CDATApattern
 from arelle.Version import authorLabel, copyrightLabel

{arelle_release-2.37.11 → arelle_release-2.37.13}/arelle/plugin/validate/CIPC/__init__.py

@@ -12,7 +12,7 @@ Taxonomy packages:
 """
 import os
 import regex as re
-from lxml.etree import _ElementTree, _Comment, _ProcessingInstruction
+from lxml.etree import _ElementTree, _Comment, _ProcessingInstruction, _Entity
 from arelle import ModelDocument, XbrlConst
 from arelle.ModelDtsObject import ModelResource
 from arelle.ModelInstanceObject import ModelFact, ModelInlineFact, ModelInlineFootnote
@@ -125,7 +125,7 @@ def validateXbrlFinally(val, *args, **kwargs):
                 eltTag = elt.tag
                 if isinstance(elt, ModelObject) and elt.namespaceURI == xhtml:
                     eltTag = elt.localName
-                elif isinstance(elt, (_ElementTree, _Comment, _ProcessingInstruction)):
+                elif isinstance(elt, (_ElementTree, _Comment, _ProcessingInstruction, _Entity)):
                     continue # comment or other non-parsed element
                 else:
                     eltTag = elt.tag

{arelle_release-2.37.11 → arelle_release-2.37.13}/arelle/plugin/validate/ESEF/ESEF_2021/ValidateXbrlFinally.py

@@ -11,7 +11,7 @@ from math import isnan
 from typing import Any, cast
 
 import regex as re
-from lxml.etree import EntityBase, _Comment, _ElementTree, _ProcessingInstruction
+from lxml.etree import _Comment, _Element, _ElementTree, _Entity, _ProcessingInstruction
 
 from arelle import LeiUtil, ModelDocument, XbrlConst
 from arelle.ModelDtsObject import ModelConcept
@@ -188,12 +188,12 @@ def validateXbrlFinally(val: ValidateXbrl, *args: Any, **kwargs: Any) -> None:
                 _baseName, _baseExt = os.path.splitext(doc.basename)
                 if _baseExt not in (".xhtml",".html"):
                     if val.consolidated:
-                        XHTMLExtensionGuidance = "2.6.1"
+                        errorCode = "ESEF.2.6.1.incorrectFileExtension"
                         reportType = _("Inline XBRL document included within a ESEF report package")
                     else:
-                        XHTMLExtensionGuidance = "4.1.1"
+                        errorCode = "ESEF.4.1.1.incorrectFileExtension"
                         reportType = _("Stand-alone XHTML document")
-                    modelXbrl.error(f"ESEF.{XHTMLExtensionGuidance}.incorrectFileExtension",
+                    modelXbrl.error(errorCode,
                                     _("%(reportType)s MUST have a .html or .xhtml extension: %(fileName)s"),
                                     modelObject=doc, fileName=doc.basename, reportType=reportType)
                 docinfo = doc.xmlRootElement.getroottree().docinfo
@@ -275,7 +275,7 @@ def validateXbrlFinally(val: ValidateXbrl, *args: Any, **kwargs: Any) -> None:
                     elt = cast(Any, uncast_elt)
 
                     eltTag = elt.tag
-                    if isinstance(elt, (_ElementTree, _Comment, _ProcessingInstruction, EntityBase)):
+                    if isinstance(elt, (_Comment, _ElementTree, _Entity, _ProcessingInstruction)):
                         continue # comment or other non-parsed element
                     else:
                         eltTag = elt.tag
@@ -726,12 +726,12 @@ def validateXbrlFinally(val: ValidateXbrl, *args: Any, **kwargs: Any) -> None:
                 _("The xlink:role attribute of a link:footnote and link:footnoteLink element as well as xlink:arcrole attribute of a link:footnoteArc MUST be defined in the XBRL Specification 2.1."),
                 modelObject=footnoteRoleErrors)
 
-        nonStdFootnoteElts = list()
+        nonStdFootnoteElts: list[_Element] = list()
         for modelLink in modelXbrl.baseSets[("XBRL-footnotes",None,None,None)]:
             for uncast_elt in modelLink.iterchildren():
                 elt = cast(Any, uncast_elt)
 
-                if isinstance(elt, (_ElementTree, _Comment, _ProcessingInstruction)):
+                if isinstance(elt, (_Comment, _ElementTree, _Entity, _ProcessingInstruction)):
                     continue # comment or other non-parsed element
                 if elt.qname not in FOOTNOTE_LINK_CHILDREN:
                     nonStdFootnoteElts.append(elt)

{arelle_release-2.37.11 → arelle_release-2.37.13}/arelle/plugin/validate/ESEF/ESEF_Current/ValidateXbrlFinally.py

@@ -12,7 +12,7 @@ from typing import Any, cast
 
 import regex as re
 import tinycss2.ast  # type: ignore[import-untyped]
-from lxml.etree import EntityBase, _Comment, _ElementTree, _ProcessingInstruction
+from lxml.etree import _Comment, _Element, _ElementTree, _Entity, _ProcessingInstruction
 
 from arelle import LeiUtil, ModelDocument, XbrlConst
 from arelle.ModelDtsObject import ModelConcept
@@ -228,12 +228,12 @@ def validateXbrlFinally(val: ValidateXbrl, *args: Any, **kwargs: Any) -> None:
                 _baseName, _baseExt = os.path.splitext(doc.basename)
                 if _baseExt not in (".xhtml",".html"):
                     if val.consolidated:
-                        XHTMLExtensionGuidance = "2.6.1"
+                        errorCode = "ESEF.2.6.1.incorrectFileExtension"
                         reportType = _("Inline XBRL document included within a ESEF report package")
                     else:
-                        XHTMLExtensionGuidance = "4.1.1"
+                        errorCode = "ESEF.4.1.1.incorrectFileExtension"
                         reportType = _("Stand-alone XHTML document")
-                    modelXbrl.error(f"ESEF.{XHTMLExtensionGuidance}.incorrectFileExtension",
+                    modelXbrl.error(errorCode,
                                     _("%(reportType)s MUST have a .html or .xhtml extension: %(fileName)s"),
                                     modelObject=doc, fileName=doc.basename, reportType=reportType)
                 docinfo = doc.xmlRootElement.getroottree().docinfo
@@ -319,7 +319,7 @@ def validateXbrlFinally(val: ValidateXbrl, *args: Any, **kwargs: Any) -> None:
                     elt = cast(Any, uncast_elt)
 
                     eltTag = elt.tag
-                    if isinstance(elt, (_ElementTree, _Comment, _ProcessingInstruction, EntityBase)):
+                    if isinstance(elt, (_ElementTree, _Comment, _ProcessingInstruction, _Entity)):
                         continue # comment or other non-parsed element
                     else:
                         eltTag = elt.tag
@@ -664,8 +664,7 @@ def validateXbrlFinally(val: ValidateXbrl, *args: Any, **kwargs: Any) -> None:
                 if esefDisclosureSystemYear >= 2024:
                     if not f.id:
                         factsMissingId.append(f)
-                    escaped = f.get("escape") in ("true", "1")
-                    if f.concept is not None and escaped != f.concept.isTextBlock:
+                    if isinstance(f, ModelInlineFact) and f.concept is not None and f.isEscaped != f.concept.isTextBlock:
                         modelXbrl.error("ESEF.2.2.7.improperApplicationOfEscapeAttribute",
                                           _("Facts with datatype 'dtr-types:textBlockItemType' MUST use the 'escape' attribute set to 'true'. Facts with any other datatype MUST use the 'escape' attribute set to 'false' - fact %(conceptName)s"),
                                           modelObject=f, conceptName=f.concept.qname)
@@ -808,12 +807,12 @@ def validateXbrlFinally(val: ValidateXbrl, *args: Any, **kwargs: Any) -> None:
                 _("The xlink:role attribute of a link:footnote and link:footnoteLink element as well as xlink:arcrole attribute of a link:footnoteArc MUST be defined in the XBRL Specification 2.1."),
                 modelObject=footnoteRoleErrors)
 
-        nonStdFootnoteElts = list()
+        nonStdFootnoteElts: list[_Element] = list()
         for modelLink in modelXbrl.baseSets[("XBRL-footnotes",None,None,None)]:
             for uncast_elt in modelLink.iterchildren():
                 elt = cast(Any, uncast_elt)
 
-                if isinstance(elt, (_ElementTree, _Comment, _ProcessingInstruction)):
+                if isinstance(elt, (_Comment, _ElementTree, _Entity, _ProcessingInstruction)):
                     continue # comment or other non-parsed element
                 if elt.qname not in FOOTNOTE_LINK_CHILDREN:
                     nonStdFootnoteElts.append(elt)