arelle-release 2.37.12__py3-none-any.whl → 2.37.14__py3-none-any.whl

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/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/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/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
 
@@ -353,6 +353,13 @@ class ModelTestcaseVariation(ModelObject):
 
         return None
 
+    @property
+    def expectedWarnings(self):
+        warningElements = XmlUtil.descendants(self, None, "warning")
+        if isinstance(warningElements, list) and len(warningElements) > 0:
+            return [w.stringValue for w in warningElements]
+        return None
+
     @property
     def match(self) -> str | None:
         resultElement = XmlUtil.descendant(self, None, "result")

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)
@@ -687,6 +710,7 @@ class Validate:
         testcaseExpectedErrors = self.modelXbrl.modelManager.formulaOptions.testcaseExpectedErrors or {}
         matchAllExpected = testcaseResultOptions == "match-all" or modelTestcaseVariation.match == 'all'
         expectedReportCount = modelTestcaseVariation.expectedReportCount
+        expectedWarnings = modelTestcaseVariation.expectedWarnings if self.modelXbrl.modelManager.formulaOptions.testcaseResultsCaptureWarnings else []
         if expectedReportCount is not None and validateModelCount is not None and expectedReportCount != validateModelCount:
             errors.append("conf:testcaseExpectedReportCountError")
         _blockedMessageCodes = modelTestcaseVariation.blockedMessageCodes # restricts codes examined when provided
@@ -727,10 +751,21 @@ class Validate:
             status = "fail" if numErrors == 0 else "pass"
         elif expected in (None, []) and numErrors == 0:
             status = "pass"
-        elif isinstance(expected,(QName,str,dict,list)): # string or assertion id counts dict
+        elif isinstance(expected, (QName, str, dict, list)) or expectedWarnings:
             status = "fail"
             _passCount = 0
-            _expectedList = expected.copy() if isinstance(expected, list) else [expected]
+            if isinstance(expected, list):
+                _expectedList = expected.copy()
+            elif not expected:
+                _expectedList = []
+            else:
+                _expectedList = [expected]
+            if expectedWarnings:
+                _expectedList.extend(expectedWarnings)
+                if expectedCount is not None:
+                    expectedCount += len(expectedWarnings)
+                else:
+                    expectedCount = len(expectedWarnings)
             if not isinstance(expected, list):
                 expected = [expected]
             for testErr in _errors:

arelle/ValidateDuplicateFacts.py

@@ -380,7 +380,7 @@ def areFactsValueEqual(factA: ModelFact, factB: ModelFact) -> bool:
 
 
 def getAspectEqualFacts(
-    hashEquivalentFacts: list[ModelFact], includeSingles: bool
+    hashEquivalentFacts: list[ModelFact], includeSingles: bool, useLang: bool = True
 ) -> Iterator[list[ModelFact]]:
     """
     Given a list of concept/context/unit hash-equivalent facts,
@@ -389,20 +389,14 @@ def getAspectEqualFacts(
     :param includeSingles: Whether to include lists of single facts (with no duplicates).
     :return: Lists of aspect-equal facts.
     """
-    aspectEqualFacts: dict[
-        tuple[QName, str | None], dict[tuple[ModelContext, ModelUnit], list[ModelFact]]
-    ] = defaultdict(dict)
-    for (
-        fact
-    ) in (
-        hashEquivalentFacts
-    ):  # check for hash collision by value checks on context and unit
+    aspectEqualFacts: dict[tuple[QName, str | None], dict[tuple[ModelContext, ModelUnit], list[ModelFact]]] = defaultdict(dict)
+    for fact in hashEquivalentFacts:  # check for hash collision by value checks on context and unit
         contextUnitDict = aspectEqualFacts[
             (
                 fact.qname,
                 (
                     cast(str, fact.xmlLang or "").lower()
-                    if fact.concept.type.isWgnStringFactType
+                    if useLang and fact.concept.type.isWgnStringFactType
                     else None
                 ),
             )

arelle/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '2.37.12'
-__version_tuple__ = version_tuple = (2, 37, 12)
+__version__ = version = '2.37.14'
+__version_tuple__ = version_tuple = (2, 37, 14)

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/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/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/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/plugin/validate/DBA/PluginValidationDataExtension.py

@@ -13,6 +13,7 @@ from arelle.ModelInstanceObject import ModelFact, ModelContext
 from arelle.ModelValue import QName
 from arelle.ModelXbrl import ModelXbrl
 from arelle.utils.PluginData import PluginData
+from arelle.XmlValidateConst import VALID
 
 
 @dataclass
@@ -47,7 +48,6 @@ class PluginValidationDataExtension(PluginData):
     consolidatedSoloDimensionQn: QName
     cpr_regex: regex.regex.Pattern[str]
     dateOfApprovalOfAnnualReportQn: QName
-    dateOfApprovalOfReportQn: QName
     dateOfExtraordinaryDividendDistributedAfterEndOfReportingPeriod: QName
     dateOfGeneralMeetingQn: QName
     descriptionOfQualificationsOfAssuranceEngagementPerformedQn: QName
@@ -157,3 +157,11 @@ class PluginValidationDataExtension(PluginData):
             contexts.append(context)
         self._reportingPeriodContexts = sorted(contexts, key=lambda c: c.endDatetime)
         return self._reportingPeriodContexts
+
+    def isAnnualReport(self, modelXbrl: ModelXbrl) -> bool:
+        """
+        :return: Return True if Type of Submitted Report value is in the annual report types
+        """
+        reportTypeFacts = modelXbrl.factsByQname.get(self.informationOnTypeOfSubmittedReportQn, set())
+        filteredReportTypeFacts = [f for f in reportTypeFacts if f.xValid >= VALID and f.xValue in self.annualReportTypes]
+        return len(filteredReportTypeFacts) > 0

arelle/plugin/validate/DBA/ValidationPluginExtension.py

@@ -161,7 +161,10 @@ class ValidationPluginExtension(ValidationPlugin):
             annualReportTypes=frozenset([
                 'Årsrapport',
                 'årsrapport',
-                'Annual report'
+                'Annual report',
+                'Likvidationsregnskab',
+                'likvidationsregnskab',
+                'Liquidation accounts',
             ]),
             assetsQn=qname(f'{{{NAMESPACE_FSA}}}Assets'),
             auditedAssuranceReportsDanish='Andre erklæringer med sikkerhed',
@@ -282,7 +285,6 @@ class ValidationPluginExtension(ValidationPlugin):
             consolidatedSoloDimensionQn=qname(f'{{{NAMESPACE_CMN}}}ConsolidatedSoloDimension'),
             cpr_regex=re.compile(r'^([0-2][0-9]|3[0-1])(0[1-9]|1[0-2])[0-9]{2}-[0-9]{4}'),
             dateOfApprovalOfAnnualReportQn=qname(f'{{{NAMESPACE_SOB}}}DateOfApprovalOfAnnualReport'),
-            dateOfApprovalOfReportQn=qname(f'{{{NAMESPACE_GSD}}}DateOfApprovalOfReport'),
             dateOfExtraordinaryDividendDistributedAfterEndOfReportingPeriod=qname(f'{{{NAMESPACE_FSA}}}DateOfExtraordinaryDividendDistributedAfterEndOfReportingPeriod'),
             dateOfGeneralMeetingQn=qname(f'{{{NAMESPACE_GSD}}}DateOfGeneralMeeting'),
             declarationObligationQns=frozenset([

arelle/plugin/validate/DBA/rules/fr.py

@@ -1266,29 +1266,26 @@ def rule_fr89(
     Regnskabsklasse D // Reporting class D
     Then TypeOfAuditorAssistance should be: Revisionspåtegning // Auditor's report on audited financial statements
     """
-    modelXbrl = val.modelXbrl
-    auditorFacts = modelXbrl.factsByQname.get(pluginData.typeOfAuditorAssistanceQn)
-    if auditorFacts is not None:
+    if pluginData.isAnnualReport(val.modelXbrl):
+        auditorFacts = val.modelXbrl.factsByQname.get(pluginData.typeOfAuditorAssistanceQn, set())
         for auditorFact in auditorFacts:
             if auditorFact.xValid >= VALID and auditorFact.xValue in [
                 pluginData.auditedFinancialStatementsDanish,
                 pluginData.auditedFinancialStatementsEnglish
             ]:
                 return
-    classFacts = []
-    facts = modelXbrl.factsByQname.get(pluginData.classOfReportingEntityQn)
-    if facts is not None:
+        classFacts = []
+        facts = val.modelXbrl.factsByQname.get(pluginData.classOfReportingEntityQn, set())
         for fact in facts:
-            if fact.xValid >= VALID:
-                if fact.xValue in [
-                    pluginData.reportingClassCLargeDanish,
-                    pluginData.reportingClassCLargeEnglish,
-                    pluginData.reportingClassCMediumDanish,
-                    pluginData.reportingClassCMediumEnglish,
-                    pluginData.reportingClassDDanish,
-                    pluginData.reportingClassDEnglish,
-                ]:
-                    classFacts.append(fact)
+            if fact.xValid >= VALID and fact.xValue in [
+                pluginData.reportingClassCLargeDanish,
+                pluginData.reportingClassCLargeEnglish,
+                pluginData.reportingClassCMediumDanish,
+                pluginData.reportingClassCMediumEnglish,
+                pluginData.reportingClassDDanish,
+                pluginData.reportingClassDEnglish
+            ]:
+                classFacts.append(fact)
         if len(classFacts) > 0:
             yield Validation.error(
                 codes='DBA.FR89',
@@ -1313,22 +1310,23 @@ def rule_fr91(
 ) -> Iterable[Validation]:
     """
     DBA.FR91: If the annual report contains information about both the general meeting date
-    (gsd:DateOfGeneralMeeting) and the annual accounts meeting date (gsd:DateOfApprovalOfReport), the values must be the same.
-    """
-    approvalOfReportFact = None
-    generalMeetingFact = None
-    approvalFacts = (val.modelXbrl.factsByQname.get(pluginData.dateOfApprovalOfReportQn, set()))
-    if len(approvalFacts) > 0:
-        approvalOfReportFact = next(iter(approvalFacts), None)
-    meetingFacts = val.modelXbrl.factsByQname.get(pluginData.dateOfGeneralMeetingQn, set())
-    if len(meetingFacts) > 0:
-        generalMeetingFact = next(iter(meetingFacts), None)
-    if generalMeetingFact is not None and generalMeetingFact.xValid >= VALID and approvalOfReportFact is not None and approvalOfReportFact.xValid >= VALID and generalMeetingFact.xValue != approvalOfReportFact.xValue:
-        yield Validation.error(
-            codes='DBA.FR91',
-            msg=_("The annual report contains information about both the general meeting date (gsd:DateOfGeneralMeeting) and the annual accounts meeting date (gsd:DateOfApprovalOfReport), the values must be the same."),
-            modelObject=[generalMeetingFact, approvalOfReportFact]
-        )
+    (gsd:DateOfGeneralMeeting) and the annual accounts meeting date (gsd:DateOfApprovalOfAnnualReport), the values must be the same.
+    """
+    if pluginData.isAnnualReport(val.modelXbrl):
+        approvalOfReportFact = None
+        generalMeetingFact = None
+        approvalFacts = (val.modelXbrl.factsByQname.get(pluginData.dateOfApprovalOfAnnualReportQn, set()))
+        if len(approvalFacts) > 0:
+            approvalOfReportFact = next(iter(approvalFacts), None)
+        meetingFacts = val.modelXbrl.factsByQname.get(pluginData.dateOfGeneralMeetingQn, set())
+        if len(meetingFacts) > 0:
+            generalMeetingFact = next(iter(meetingFacts), None)
+        if generalMeetingFact is not None and generalMeetingFact.xValid >= VALID and approvalOfReportFact is not None and approvalOfReportFact.xValid >= VALID and generalMeetingFact.xValue != approvalOfReportFact.xValue:
+            yield Validation.error(
+                codes='DBA.FR91',
+                msg=_("The annual report contains information about both the general meeting date (gsd:DateOfGeneralMeeting) and the annual accounts meeting date (gsd:DateOfApprovalOfAnnualReport), the values must be the same."),
+                modelObject=[generalMeetingFact, approvalOfReportFact]
+            )
 
 
 @validation(

arelle/plugin/validate/DBA/rules/tm.py

@@ -239,16 +239,16 @@ def rule_tm29(
         **kwargs: Any,
 ) -> Iterable[Validation]:
     """
-    DBA.TM29: Either gsd:DateOfGeneralMeeting or gsd:DateOfApprovalOfReport must be specified
+    DBA.TM29: Either gsd:DateOfGeneralMeeting or gsd:DateOfApprovalOfAnnualReport must be specified
     """
-    modelXbrl = val.modelXbrl
-    meeting_facts = modelXbrl.factsByQname.get(pluginData.dateOfGeneralMeetingQn, set())
-    approval_facts = modelXbrl.factsByQname.get(pluginData.dateOfApprovalOfReportQn, set())
-    if len(meeting_facts) == 0 and len(approval_facts) == 0:
-        yield Validation.error(
-            'DBA.TM29',
-            _('Either DateOfGeneralMeeting or DateOfApprovalOfReport must be tagged in the document.')
-        )
+    if pluginData.isAnnualReport(val.modelXbrl):
+        meeting_facts = val.modelXbrl.factsByQname.get(pluginData.dateOfGeneralMeetingQn, set())
+        approval_facts = val.modelXbrl.factsByQname.get(pluginData.dateOfApprovalOfAnnualReportQn, set())
+        if len(meeting_facts) == 0 and len(approval_facts) == 0:
+            yield Validation.error(
+                'DBA.TM29',
+                _('Either DateOfGeneralMeeting or DateOfApprovalOfReport must be tagged in the document.')
+            )
 
 
 @validation(
@@ -276,9 +276,19 @@ def rule_tm31(
         **kwargs: Any,
 ) -> Iterable[Validation]:
     """
-    DBA.TM31: gsd:DateOfApprovalOfReport must only be tagged once if tagged
-    """
-    return errorOnMultipleFacts(val.modelXbrl, pluginData.dateOfApprovalOfReportQn, 'DBA.TM31')
+    DBA.TM31: gsd:DateOfApprovalOfAnnualReport must only be tagged once if tagged
+    """
+    if pluginData.isAnnualReport(val.modelXbrl):
+        dateFacts = val.modelXbrl.factsByQname.get(pluginData.dateOfApprovalOfAnnualReportQn, set())
+        if len(dateFacts) > 1:
+            yield Validation.error(
+                'DBA.TM31',
+                _('{} must only be tagged once. {} facts were found.').format(
+                    pluginData.dateOfApprovalOfAnnualReportQn.localName,
+                    len(dateFacts)
+                ),
+                modelObject=dateFacts
+            )
 
 
 @validation(

arelle/plugin/validate/ESEF/ESEF_2021/ValidateXbrlFinally.py

@@ -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