arelle-release 2.36.30__py3-none-any.whl → 2.36.32__py3-none-any.whl

arelle/CntlrCmdLine.py

@@ -6,33 +6,59 @@ This module is Arelle's controller in command line non-interactive mode
 See COPYRIGHT.md for copyright information.
 '''
 from __future__ import annotations
-from arelle import PackageManager, ValidateDuplicateFacts
-import gettext, time, datetime, os, shlex, sys, traceback, fnmatch, threading, json, logging, platform
-from optparse import OptionGroup, OptionParser, SUPPRESS_HELP, Option
+
+import datetime
+import fnmatch
+import gettext
+import glob
+import json
+import logging
+import os
+import platform
+import shlex
+import sys
+import threading
+import time
+import traceback
+from optparse import SUPPRESS_HELP, Option, OptionGroup, OptionParser
+from pprint import pprint
+
 import regex as re
-from arelle import (Cntlr, FileSource, ModelDocument, XmlUtil, XbrlConst, Version,
-                    ViewFileDTS, ViewFileFactList, ViewFileFactTable, ViewFileConcepts,
-                    ViewFileFormulae, ViewFileRelationshipSet, ViewFileTests, ViewFileRssFeed,
-                    ViewFileRoleTypes)
-from arelle.oim.xml.Save import saveOimReportToXmlInstance
-from arelle.rendering import RenderingEvaluator
-from arelle.RuntimeOptions import RuntimeOptions, RuntimeOptionsException
+from lxml import etree
+
+from arelle import (
+    Cntlr,
+    FileSource,
+    ModelDocument,
+    PackageManager,
+    PluginManager,
+    ValidateDuplicateFacts,
+    Version,
+    ViewFileConcepts,
+    ViewFileDTS,
+    ViewFileFactList,
+    ViewFileFactTable,
+    ViewFileFormulae,
+    ViewFileRelationshipSet,
+    ViewFileRoleTypes,
+    ViewFileRssFeed,
+    ViewFileTests,
+    XbrlConst,
+    XmlUtil,
+)
 from arelle.BetaFeatures import BETA_FEATURES_AND_DESCRIPTIONS
-from arelle.ModelValue import qname
 from arelle.Locale import format_string, setApplicationLocale, setDisableRTL
 from arelle.ModelFormulaObject import FormulaOptions
-from arelle import PluginManager
-from arelle.PluginManager import pluginClassMethods
+from arelle.ModelValue import qname
+from arelle.oim.xml.Save import saveOimReportToXmlInstance
+from arelle.rendering import RenderingEvaluator
+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.Version import copyrightLabel
+from arelle.ValidateXbrlDTS import ValidateBaseTaxonomiesMode
 from arelle.WebCache import proxyTuple
-from arelle.SystemInfo import getSystemInfo, getSystemWordSize, hasWebServer, isCGI, isGAE, PlatformOS
-from pprint import pprint
-import logging
-from lxml import etree
-import glob
 
 win32file = win32api = win32process = pywintypes = None
 STILL_ACTIVE = 259 # MS Windows process status constants
@@ -51,10 +77,7 @@ def main():
        :type message: [str]
        """
     envArgs = os.getenv("ARELLE_ARGS")
-    if envArgs:
-        args = shlex.split(envArgs)
-    else:
-        args = sys.argv[1:]
+    args = shlex.split(envArgs) if envArgs else sys.argv[1:]
     setApplicationLocale()
     gettext.install("arelle")
     parseAndRun(args)
@@ -96,7 +119,7 @@ def parseArgs(args):
     cntlr = CntlrCmdLine(uiLang=uiLang, disable_persistent_config=disable_persistent_config)  # This Cntlr is needed for translations and to enable the web cache.  The cntlr is not used outside the parse function
     usage = "usage: %prog [options]"
     parser = OptionParser(usage,
-                          version="Arelle(r) {0} ({1}bit)".format(Version.__version__, getSystemWordSize()),
+                          version=f"Arelle(r) {Version.__version__} ({getSystemWordSize()}bit)",
                           conflict_handler="resolve") # allow reloading plug-in options without errors
     parser.add_option("-f", "--file", dest="entrypointFile",
                       help=_("FILENAME is an entry point, which may be "
@@ -137,6 +160,15 @@ def parseArgs(args):
                       choices=[a.value for a in ValidateDuplicateFacts.DUPLICATE_TYPE_ARG_MAP],
                       dest="validateDuplicateFacts",
                       help=_("Select which types of duplicates should trigger warnings."))
+    parser.add_option("--baseTaxonomyValidation", "--basetaxonomyvalidation",
+                      choices=("disclosureSystem", "none", "all"),
+                      dest="baseTaxonomyValidationMode",
+                      default="disclosureSystem",
+                      help=_("""Specify if base taxonomies should be validated.
+                             Skipping validation of base taxonomy files which are known to be valid can significantly reduce validation time.
+                             disclosureSystem - (default) skip validation of base taxonomy files which are known to be valid by the disclosure system
+                             none - skip validation of all base taxonomies
+                             all - validate all base taxonomies"""))
     parser.add_option("--saveOIMToXMLReport", "--saveoimtoxmlreport", "--saveOIMinstance", "--saveoiminstance",
                       action="store",
                       dest="saveOIMToXMLReport",
@@ -397,7 +429,7 @@ def parseArgs(args):
                         PluginManager.reset()
             break
     # add plug-in options
-    for optionsExtender in pluginClassMethods("CntlrCmdLine.Options"):
+    for optionsExtender in PluginManager.pluginClassMethods("CntlrCmdLine.Options"):
         optionsExtender(parser)
     pluginLastOptionIndex = len(parser.option_list)
     pluginLastOptionsGroupIndex = len(parser.option_groups)
@@ -459,7 +491,7 @@ def parseArgs(args):
             version=Version.__version__,
             wordSize=getSystemWordSize(),
             platform=platform.machine(),
-            copyrightLabel=copyrightLabel,
+            copyrightLabel=Version.copyrightLabel,
             pythonVersion=f'{sys.version_info[0]}.{sys.version_info[1]}.{sys.version_info[2]}',
             lxmlVersion=f'{etree.LXML_VERSION[0]}.{etree.LXML_VERSION[1]}.{etree.LXML_VERSION[2]}',
             bottleCopyright="\n   Bottle (c) 2011-2013 Marcel Hellkamp" if hasWebServer() else ""
@@ -568,7 +600,7 @@ def filesourceEntrypointFiles(filesource, entrypointFiles=None, inlineOnly=False
                 if report.isInline:
                     reportEntries = [{"file": f} for f in report.fullPathFiles]
                     ixdsDiscovered = False
-                    for pluginXbrlMethod in pluginClassMethods("InlineDocumentSet.Discovery"):
+                    for pluginXbrlMethod in PluginManager.pluginClassMethods("InlineDocumentSet.Discovery"):
                         pluginXbrlMethod(filesource, reportEntries)
                         ixdsDiscovered = True
                     if not ixdsDiscovered and len(reportEntries) > 1:
@@ -590,13 +622,17 @@ def filesourceEntrypointFiles(filesource, entrypointFiles=None, inlineOnly=False
                     entrypointFiles.append({"file":url})
                 if entrypointFiles:
                     if identifiedType == ModelDocument.Type.INLINEXBRL:
-                        for pluginXbrlMethod in pluginClassMethods("InlineDocumentSet.Discovery"):
+                        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):
@@ -611,7 +647,7 @@ def filesourceEntrypointFiles(filesource, entrypointFiles=None, inlineOnly=False
                 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 pluginClassMethods("InlineDocumentSet.Discovery"):
+            for pluginXbrlMethod in PluginManager.pluginClassMethods("InlineDocumentSet.Discovery"):
                 pluginXbrlMethod(filesource, entrypointFiles)
 
     return entrypointFiles
@@ -652,7 +688,7 @@ class CntlrCmdLine(Cntlr.Cntlr):
     """
 
     def __init__(self, logFileName=None, uiLang=None, disable_persistent_config=False):
-        super(CntlrCmdLine, self).__init__(hasGui=False, uiLang=uiLang, disable_persistent_config=disable_persistent_config)
+        super().__init__(hasGui=False, uiLang=uiLang, disable_persistent_config=disable_persistent_config)
         self.preloadedPlugins =  {}
 
     def run(self, options: RuntimeOptions, sourceZipStream=None, responseZipStream=None, sourceZipStreamFileName=None) -> bool:
@@ -664,24 +700,24 @@ class CntlrCmdLine(Cntlr.Cntlr):
         :param options: OptionParser options from parse_args of main argv arguments (when called from command line) or corresponding arguments from web service (REST) request.
         :type options: optparse.Values
         """
-        for b in BETA_FEATURES_AND_DESCRIPTIONS.keys():
+        for b in BETA_FEATURES_AND_DESCRIPTIONS:
             self.betaFeatures[b] = getattr(options, b)
         if options.statusPipe or options.monitorParentProcess:
             try:
                 global win32file, win32api, win32process, pywintypes
                 import win32file, win32api, win32process, pywintypes
             except ImportError: # win32 not installed
-                self.addToLog("--statusPipe {} cannot be installed, packages for win32 missing".format(options.statusPipe))
+                self.addToLog(f"--statusPipe {options.statusPipe} cannot be installed, packages for win32 missing")
                 options.statusPipe = options.monitorParentProcess = None
         if options.statusPipe:
             try:
-                self.statusPipe = win32file.CreateFile("\\\\.\\pipe\\{}".format(options.statusPipe),
+                self.statusPipe = win32file.CreateFile(f"\\\\.\\pipe\\{options.statusPipe}",
                                                        win32file.GENERIC_READ | win32file.GENERIC_WRITE, 0, None, win32file.OPEN_EXISTING, win32file.FILE_FLAG_NO_BUFFERING, None)
                 self.showStatus = self.showStatusOnPipe
                 self.lastStatusTime = 0.0
                 self.parentProcessHandle = None
             except pywintypes.error: # named pipe doesn't exist
-                self.addToLog("--statusPipe {} has not been created by calling program".format(options.statusPipe))
+                self.addToLog(f"--statusPipe {options.statusPipe} has not been created by calling program")
         if options.monitorParentProcess:
             try:
                 self.parentProcessHandle = win32api.OpenProcess(PROCESS_QUERY_INFORMATION, False, int(options.monitorParentProcess))
@@ -693,14 +729,14 @@ class CntlrCmdLine(Cntlr.Cntlr):
                     _t.start()
                 monitorParentProcess()
             except ImportError: # win32 not installed
-                self.addToLog("--monitorParentProcess {} cannot be installed, packages for win32api and win32process missing".format(options.monitorParentProcess))
+                self.addToLog(f"--monitorParentProcess {options.monitorParentProcess} cannot be installed, packages for win32api and win32process missing")
             except (ValueError, pywintypes.error): # parent process doesn't exist
-                self.addToLog("--monitorParentProcess Process {} Id is invalid".format(options.monitorParentProcess))
+                self.addToLog(f"--monitorParentProcess Process {options.monitorParentProcess} Id is invalid")
                 sys.exit()
         if options.showOptions: # debug options
             for optName, optValue in sorted(options.__dict__.items(), key=lambda optItem: optItem[0]):
-                self.addToLog("Option {0}={1}".format(optName, optValue), messageCode="info")
-            self.addToLog("sys.argv {0}".format(sys.argv), messageCode="info")
+                self.addToLog(f"Option {optName}={optValue}", messageCode="info")
+            self.addToLog(f"sys.argv {sys.argv}", messageCode="info")
 
         setDisableRTL(options.disableRtl) # not saved to config
 
@@ -730,7 +766,7 @@ class CntlrCmdLine(Cntlr.Cntlr):
                     ":****" if password else "",
                     "@" if (user or password) else "",
                     urlAddr,
-                    ":{0}".format(urlPort) if urlPort else ""), messageCode="info")
+                    f":{urlPort}" if urlPort else ""), messageCode="info")
             else:
                 self.addToLog(_("Proxy is disabled."), messageCode="info")
         if options.noCertificateCheck:
@@ -801,7 +837,7 @@ class CntlrCmdLine(Cntlr.Cntlr):
                 if loadPluginOptions:
                     _optionsParser = ParserForDynamicPlugins(options)
                     # add plug-in options
-                    for optionsExtender in pluginClassMethods("CntlrCmdLine.Options"):
+                    for optionsExtender in PluginManager.pluginClassMethods("CntlrCmdLine.Options"):
                         optionsExtender(_optionsParser)
 
             if showPluginModules:
@@ -844,6 +880,8 @@ class CntlrCmdLine(Cntlr.Cntlr):
         else:
             self.modelManager.disclosureSystem.select(None) # just load ordinary mappings
             self.modelManager.validateDisclosureSystem = False
+        if options.baseTaxonomyValidationMode is not None:
+            self.modelManager.baseTaxonomyValidationMode = ValidateBaseTaxonomiesMode.fromName(options.baseTaxonomyValidationMode)
         self.modelManager.validateXmlOim = bool(options.validateXmlOim)
         if options.validateDuplicateFacts:
             duplicateTypeArg = ValidateDuplicateFacts.DuplicateTypeArg(options.validateDuplicateFacts)
@@ -981,7 +1019,7 @@ class CntlrCmdLine(Cntlr.Cntlr):
 
         # run utility command line options that don't depend on entrypoint Files
         hasUtilityPlugin = False
-        for pluginXbrlMethod in pluginClassMethods("CntlrCmdLine.Utility.Run"):
+        for pluginXbrlMethod in PluginManager.pluginClassMethods("CntlrCmdLine.Utility.Run"):
             hasUtilityPlugin = True
             try:
                 pluginXbrlMethod(self, options, sourceZipStream=sourceZipStream, responseZipStream=responseZipStream)
@@ -1006,7 +1044,7 @@ class CntlrCmdLine(Cntlr.Cntlr):
             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: {0}\n{1}".format(e, _f)),
+                    self.addToLog(_("File name parameter appears to be malformed JSON: {}\n{}").format(e, _f),
                                   messageCode="FileNameFormatError",
                                   level=logging.ERROR)
                     success = False
@@ -1029,9 +1067,9 @@ class CntlrCmdLine(Cntlr.Cntlr):
                 self.addToLog(str(err), messageCode="error", level=logging.ERROR)
                 return False
 
-        for pluginXbrlMethod in pluginClassMethods("CntlrCmdLine.Filing.Start"):
+        for pluginXbrlMethod in PluginManager.pluginClassMethods("CntlrCmdLine.Filing.Start"):
             pluginXbrlMethod(self, options, filesource, _entrypointFiles, sourceZipStream=sourceZipStream, responseZipStream=responseZipStream)
-        if len(_entrypointFiles) == 0:
+        if len(_entrypointFiles) == 0 and not options.packages:
             if options.entrypointFile:
                 msg = _("No XBRL entry points could be loaded from provided file: {}").format(options.entrypointFile)
             else:
@@ -1090,10 +1128,10 @@ class CntlrCmdLine(Cntlr.Cntlr):
                     if modelXbrl.errors:
                         success = False    # loading errors, don't attempt to utilize loaded DTS
                 if modelXbrl.modelDocument.type in ModelDocument.Type.TESTCASETYPES:
-                    for pluginXbrlMethod in pluginClassMethods("Testcases.Start"):
+                    for pluginXbrlMethod in PluginManager.pluginClassMethods("Testcases.Start"):
                         pluginXbrlMethod(self, options, modelXbrl)
                 else: # not a test case, probably instance or DTS
-                    for pluginXbrlMethod in pluginClassMethods("CntlrCmdLine.Xbrl.Loaded"):
+                    for pluginXbrlMethod in PluginManager.pluginClassMethods("CntlrCmdLine.Xbrl.Loaded"):
                         pluginXbrlMethod(self, options, modelXbrl, _entrypoint, responseZipStream=responseZipStream)
                     if options.saveOIMToXMLReport:
                         if modelXbrl.loadedFromOIM and modelXbrl.modelDocument is not None:
@@ -1142,7 +1180,7 @@ class CntlrCmdLine(Cntlr.Cntlr):
                     for modelXbrl in [self.modelManager.modelXbrl] + getattr(self.modelManager.modelXbrl, "supplementalModelXbrls", []):
                         hasFormulae = modelXbrl.hasFormulae
                         isAlreadyValidated = False
-                        for pluginXbrlMethod in pluginClassMethods("ModelDocument.IsValidated"):
+                        for pluginXbrlMethod in PluginManager.pluginClassMethods("ModelDocument.IsValidated"):
                             if pluginXbrlMethod(modelXbrl): # e.g., streaming extensions already has validated
                                 isAlreadyValidated = True
                         if options.validate and not isAlreadyValidated:
@@ -1208,10 +1246,10 @@ class CntlrCmdLine(Cntlr.Cntlr):
                         if options.arcroleTypesFile:
                             ViewFileRoleTypes.viewRoleTypes(modelXbrl, options.arcroleTypesFile, "Arcrole Types", isArcrole=True, lang=options.labelLang)
 
-                        for pluginXbrlMethod in pluginClassMethods("CntlrCmdLine.Xbrl.Run"):
+                        for pluginXbrlMethod in PluginManager.pluginClassMethods("CntlrCmdLine.Xbrl.Run"):
                             pluginXbrlMethod(self, options, modelXbrl, _entrypoint, sourceZipStream=sourceZipStream, responseZipStream=responseZipStream)
 
-                except (IOError, EnvironmentError) as err:
+                except OSError as err:
                     self.addToLog(_("[IOError] Failed to save output:\n {0}").format(err),
                                   messageCode="IOError",
                                   file=options.entrypointFile,
@@ -1258,15 +1296,15 @@ class CntlrCmdLine(Cntlr.Cntlr):
                         self.modelManager.close(modelDiffReport)
                     elif modelXbrl:
                         self.modelManager.close(modelXbrl)
-        if not options.keepOpen:
+        if filesource is not None and not options.keepOpen:
             # Archive filesource potentially used by multiple reports may still be open.
             filesource.close()
 
         if success:
             if options.validate:
-                for pluginXbrlMethod in pluginClassMethods("CntlrCmdLine.Filing.Validate"):
+                for pluginXbrlMethod in PluginManager.pluginClassMethods("CntlrCmdLine.Filing.Validate"):
                     pluginXbrlMethod(self, options, filesource, _entrypointFiles, sourceZipStream=sourceZipStream, responseZipStream=responseZipStream)
-            for pluginXbrlMethod in pluginClassMethods("CntlrCmdLine.Filing.End"):
+            for pluginXbrlMethod in PluginManager.pluginClassMethods("CntlrCmdLine.Filing.End"):
                 pluginXbrlMethod(self, options, filesource, _entrypointFiles, sourceZipStream=sourceZipStream, responseZipStream=responseZipStream)
         self.username = self.password = None #dereference password
         self._clearPluginData()

arelle/CntlrWinMain.py

@@ -34,6 +34,7 @@ from arelle import XbrlConst
 from arelle.PluginManager import pluginClassMethods
 from arelle.UrlUtil import isHttpUrl
 from arelle.ValidateXbrlCalcs import ValidateCalcsMode as CalcsMode
+from arelle.ValidateXbrlDTS import ValidateBaseTaxonomiesMode
 from arelle.Version import copyrightLabel
 from arelle.oim.xml.Save import saveOimReportToXmlInstance
 import logging
@@ -164,6 +165,16 @@ class CntlrWinMain (Cntlr.Cntlr):
         for calcChoiceMenuLabel, calcChoiceEnumValue in CalcsMode.menu().items():
             calcMenu.add_radiobutton(label=calcChoiceMenuLabel, underline=0, var=self.calcChoiceEnumVar, value=calcChoiceEnumValue)
         toolsMenu.add_cascade(label=_("Calc linkbase"), menu=calcMenu, underline=0)
+
+        baseValidateModeMenu = Menu(self.menubar, tearoff=0)
+        baseValidationModeName = self.config.setdefault("baseTaxonomyValidationMode", ValidateBaseTaxonomiesMode.DISCLOSURE_SYSTEM.value)
+        self.modelManager.baseTaxonomyValidationMode = ValidateBaseTaxonomiesMode.fromName(baseValidationModeName)
+        self.baseTaxonomyValidationModeEnumVar = StringVar(self.parent, value=baseValidationModeName)
+        self.baseTaxonomyValidationModeEnumVar.trace("w", self.setBaseTaxonomyValidationModeEnumVar)
+        for modeLabel, modeValue in ValidateBaseTaxonomiesMode.menu().items():
+            baseValidateModeMenu.add_radiobutton(label=modeLabel, underline=0, var=self.baseTaxonomyValidationModeEnumVar, value=modeValue)
+        validateMenu.add_cascade(label=_("Base taxonomy validation"), menu=baseValidateModeMenu, underline=0)
+
         self.modelManager.validateUtr = self.config.setdefault("validateUtr",True)
         self.validateUtr = BooleanVar(value=self.modelManager.validateUtr)
         self.validateUtr.trace("w", self.setValidateUtr)
@@ -670,7 +681,16 @@ class CntlrWinMain (Cntlr.Cntlr):
                     elif isinstance(view, ViewWinDTS.ViewDTS):
                         ViewFileDTS.viewDTS(modelXbrl, filename)
                     else:
-                        ViewFileRelationshipSet.viewRelationshipSet(modelXbrl, filename, view.tabTitle, view.arcrole, labelrole=view.labelrole, lang=view.lang)
+                        if isinstance(view.arcrole, tuple) and len(view.arcrole) > 0 and view.arcrole[0] == "Calculation":
+                            # "arcrole" is overloaded with special strings that are sometimes used magically to query
+                            # the model and other times just to provide a header value. In the case of Calculation, it's
+                            # only the header used in the GUI view and including it here when going to save will throw
+                            # an exception.
+                            arcrole = XbrlConst.summationItems
+                        else:
+                            arcrole = view.arcrole
+
+                        ViewFileRelationshipSet.viewRelationshipSet(modelXbrl, filename, view.tabTitle, arcrole, labelrole=view.labelrole, lang=view.lang)
                 except (IOError, EnvironmentError) as err:
                     tkinter.messagebox.showwarning(_("arelle - Error"),
                                         _("Failed to save {0}:\n{1}").format(
@@ -977,7 +997,7 @@ class CntlrWinMain (Cntlr.Cntlr):
                 hasView = ViewWinRelationshipSet.viewRelationshipSet(modelXbrl, self.tabWinTopRt, XbrlConst.parentChild, lang=self.labelLang)
                 if hasView and topView is None: topView = modelXbrl.views[-1]
                 currentAction = "calculation linkbase view"
-                hasView = ViewWinRelationshipSet.viewRelationshipSet(modelXbrl, self.tabWinTopRt, ("Calculation",(XbrlConst.summationItem, XbrlConst.summationItem11)), lang=self.labelLang)
+                hasView = ViewWinRelationshipSet.viewRelationshipSet(modelXbrl, self.tabWinTopRt, ("Calculation", XbrlConst.summationItems), lang=self.labelLang)
                 if hasView and topView is None: topView = modelXbrl.views[-1]
                 currentAction = "dimensions relationships view"
                 hasView = ViewWinRelationshipSet.viewRelationshipSet(modelXbrl, self.tabWinTopRt, "XBRL-dimensions", lang=self.labelLang)
@@ -1401,6 +1421,13 @@ class CntlrWinMain (Cntlr.Cntlr):
         self.saveConfig()
         self.setValidateTooltipText()
 
+    def setBaseTaxonomyValidationModeEnumVar(self, *args):
+        modeName = self.baseTaxonomyValidationModeEnumVar.get()
+        self.modelManager.baseTaxonomyValidationMode = ValidateBaseTaxonomiesMode.fromName(modeName)
+        self.config["baseTaxonomyValidationMode"] = modeName
+        self.saveConfig()
+        self.setValidateTooltipText()
+
     def setValidateUtr(self, *args):
         self.modelManager.validateUtr = self.validateUtr.get()
         self.config["validateUtr"] = self.modelManager.validateUtr

arelle/ModelManager.py

@@ -9,6 +9,7 @@ import gc, sys, traceback, logging
 from arelle import ModelXbrl, Validate, DisclosureSystem, PackageManager, ValidateXbrlCalcs, ValidateDuplicateFacts
 from arelle.ModelFormulaObject import FormulaOptions
 from arelle.PluginManager import pluginClassMethods
+from arelle.ValidateXbrlDTS import ValidateBaseTaxonomiesMode
 from arelle.typing import LocaleDict
 
 if TYPE_CHECKING:
@@ -67,6 +68,7 @@ class ModelManager:
         self.loadedModelXbrls = []
         self.customTransforms: dict[QName, Callable[[str], str]] | None = None
         self.isLocaleSet = False
+        self.baseTaxonomyValidationMode = ValidateBaseTaxonomiesMode.DISCLOSURE_SYSTEM
         self.validateAllFilesAsReportPackages = False
         self.validateDuplicateFacts = ValidateDuplicateFacts.DuplicateType.NONE
         self.validateXmlOim = False

arelle/ModelValue.py

@@ -277,10 +277,11 @@ def tzinfo(tz: str | None) -> datetime.timezone | None:
     else:
         return datetime.timezone(datetime.timedelta(hours=int(tz[0:3]), minutes=int(tz[0]+tz[4:6])))
 
-def tzinfoStr(dt: datetime.datetime) -> str:
-    tz = str(dt.tzinfo or "")
-    if tz.startswith("UTC"):
-        return tz[3:] or "Z"
+def tzinfoStr(dt: datetime.datetime | datetime.date) -> str:
+    if isinstance(dt, datetime.datetime):
+        tz = str(dt.tzinfo or "")
+        if tz.startswith("UTC"):
+            return tz[3:] or "Z"
     return ""
 
 def dateTime(

arelle/RuntimeOptions.py

@@ -33,6 +33,7 @@ class RuntimeOptions:
     about: Optional[str] = None
     anchFile: Optional[str] = None
     arcroleTypesFile: Optional[str] = None
+    baseTaxonomyValidationMode: Optional[str] = None
     betaObjectModel: Optional[bool] = False
     cacheDirectory: Optional[str] = None
     calFile: Optional[str] = None

arelle/ValidateXbrlDTS.py

@@ -2,6 +2,7 @@
 See COPYRIGHT.md for copyright information.
 '''
 from __future__ import annotations
+from enum import Enum, auto
 from typing import TYPE_CHECKING
 from arelle import (ModelDocument, ModelDtsObject, HtmlUtil, UrlUtil, XmlUtil, XbrlUtil, XbrlConst,
                     XmlValidate)
@@ -49,6 +50,37 @@ inlineDisplayNonePattern = re.compile(r"display\s*:\s*none")
 # lookbehind below is to ignore even numbers of \ before illegal escape character
 illegalXsdPatternEscapeChar = re.compile(r"(?:(?:^|[^\\])(?:\\\\)*)(\\[^nrt\\|.^?*+{}()[\]pPsSiIcCdDwW-])")
 
+class ValidateBaseTaxonomiesMode(Enum):
+    DISCLOSURE_SYSTEM = "disclosureSystem"
+    NONE = "none"
+    ALL = "all"
+
+    @staticmethod
+    def fromName(modeName: str) -> ValidateBaseTaxonomiesMode:
+        for mode in ValidateBaseTaxonomiesMode:
+            if mode.value == modeName:
+                return mode
+        raise ValueError(f"Unknown ValidateBaseTaxonomiesMode: {modeName}")
+
+    @staticmethod
+    def tooltip(enum: ValidateBaseTaxonomiesMode):
+        if enum == ValidateBaseTaxonomiesMode.DISCLOSURE_SYSTEM:
+            return _("Skip validation of base taxonomy files which are known to be valid by the disclosure system")
+        if enum == ValidateBaseTaxonomiesMode.NONE:
+            return _("Skip validation of all base taxonomy files")
+        if enum == ValidateBaseTaxonomiesMode.ALL:
+            return _("Validate all base taxonomy files")
+        raise ValueError(f"Unknown ValidateBaseTaxonomiesMode: {enum}")
+
+    @staticmethod
+    def menu():
+        return {
+            _("Use disclosure system settings"): ValidateBaseTaxonomiesMode.DISCLOSURE_SYSTEM.value,
+            _("Don't validate any base files"): ValidateBaseTaxonomiesMode.NONE.value,
+            _("Validate all base files"): ValidateBaseTaxonomiesMode.ALL.value,
+        }
+
+
 def arcFromConceptQname(arcElement):
     modelRelationship = baseSetRelationship(arcElement)
     if modelRelationship is None:
@@ -261,36 +293,42 @@ def checkDTS(val: ValidateXbrl, modelDocument: ModelDocument.ModelDocument, chec
     # XML validation checks (remove if using validating XML)
     val.extendedElementName = None
     isFilingDocument = False
-    # validate contents of entry point document or its sibling/descendant documents or in report package of entry point
-    if ((modelDocument.uri.startswith(val.modelXbrl.uriDir) or # document uri in same subtree as entry doocument
-         (val.modelXbrl.fileSource.isOpen and modelDocument.filepath.startswith(val.modelXbrl.fileSource.baseurl))) and # document in entry submission's package
-        modelDocument.targetNamespace not in val.disclosureSystem.baseTaxonomyNamespaces and
-        modelDocument.xmlDocument):
-        isFilingDocument = True
-        val.valUsedPrefixes = set()
-        val.schemaRoleTypes = {}
-        val.schemaArcroleTypes = {}
-        val.referencedNamespaces = set()
 
-        val.containsRelationship = False
+    if modelDocument.xmlDocument is not None:
+        isExtensionTaxonomyDoc = _isExtensionTaxonomyDocument(val, modelDocument)
+        if isExtensionTaxonomyDoc or _shouldValidateBaseTaxonomyDoc(val, modelDocument):
+            isFilingDocument = True
+            val.valUsedPrefixes = set()
+            val.schemaRoleTypes = {}
+            val.schemaArcroleTypes = {}
+            val.referencedNamespaces = set()
 
-        checkElements(val, modelDocument, modelDocument.xmlDocument)
+            val.containsRelationship = False
 
-        if (modelDocument.type == ModelDocument.Type.INLINEXBRL and
-            val.validateGFM and
-            (val.documentTypeEncoding.lower() != 'utf-8' or val.metaContentTypeEncoding.lower() != 'utf-8')):
-            val.modelXbrl.error("GFM.1.10.4",
-                    _("XML declaration encoding %(encoding)s and meta content type encoding %(metaContentTypeEncoding)s must both be utf-8"),
-                    modelXbrl=modelDocument, encoding=val.documentTypeEncoding,
-                    metaContentTypeEncoding=val.metaContentTypeEncoding)
-        if val.validateSBRNL:
-            for pluginXbrlMethod in pluginClassMethods("Validate.SBRNL.DTS.document"):
-                pluginXbrlMethod(val, modelDocument)
-        del val.valUsedPrefixes
-        del val.schemaRoleTypes
-        del val.schemaArcroleTypes
-    for pluginXbrlMethod in pluginClassMethods("Validate.XBRL.DTS.document"):
-        pluginXbrlMethod(val, modelDocument, isFilingDocument)
+            checkElements(val, modelDocument, modelDocument.xmlDocument)
+
+            if (modelDocument.type == ModelDocument.Type.INLINEXBRL and
+                val.validateGFM and
+                (val.documentTypeEncoding.lower() != 'utf-8' or val.metaContentTypeEncoding.lower() != 'utf-8')):
+                val.modelXbrl.error("GFM.1.10.4",
+                        _("XML declaration encoding %(encoding)s and meta content type encoding %(metaContentTypeEncoding)s must both be utf-8"),
+                        modelXbrl=modelDocument, encoding=val.documentTypeEncoding,
+                        metaContentTypeEncoding=val.metaContentTypeEncoding)
+            if val.validateSBRNL:
+                for pluginXbrlMethod in pluginClassMethods("Validate.SBRNL.DTS.document"):
+                    pluginXbrlMethod(val, modelDocument)
+            del val.valUsedPrefixes
+            del val.schemaRoleTypes
+            del val.schemaArcroleTypes
+
+        if isExtensionTaxonomyDoc:
+            # While not captured in the hook name, the Validate.XBRL.DTS.document hook has been historically used by
+            # plugins (see EDGAR plugin) to validate extension taxonomies. This worked because Arelle didn't fully
+            # validate base taxonomy documents. Although Arelle now validates all documents, it retains this logic for
+            # the plugin hook to prevent running validation rules intended solely for extension taxonomy documents
+            # against base taxonomy documents.
+            for pluginXbrlMethod in pluginClassMethods("Validate.XBRL.DTS.document"):
+                pluginXbrlMethod(val, modelDocument, isFilingDocument)
 
     val.roleRefURIs = None
     val.arcroleRefURIs = None
@@ -1388,3 +1426,21 @@ def checkIxContinuationChain(val, elt, chain=None):
                 if contAt is not None:
                     chain.append(elt)
                 checkIxContinuationChain(val, contAt, chain)
+
+def _isExtensionTaxonomyDocument(val: ValidateXbrl, modelDocument: ModelDocument.ModelDocument) -> bool:
+    if modelDocument.uri.startswith(val.modelXbrl.uriDir):
+        # document uri in same subtree as entry doocument.
+        return True
+
+    # check if document in entry submission's package.
+    return val.modelXbrl.fileSource.isOpen and modelDocument.filepath.startswith(val.modelXbrl.fileSource.baseurl)
+
+def _shouldValidateBaseTaxonomyDoc(val: ValidateXbrl, modelDocument: ModelDocument.ModelDocument) -> bool:
+    baseTaxonomyValidationMode = val.modelXbrl.modelManager.baseTaxonomyValidationMode
+    if baseTaxonomyValidationMode == ValidateBaseTaxonomiesMode.NONE:
+        return False
+    if baseTaxonomyValidationMode == ValidateBaseTaxonomiesMode.ALL:
+        return True
+    if baseTaxonomyValidationMode == ValidateBaseTaxonomiesMode.DISCLOSURE_SYSTEM:
+        return modelDocument.uri not in getattr(val.disclosureSystem, "standardTaxonomiesDict", {})
+    raise ValueError(f"Invalid base taxonomy validation mode: {baseTaxonomyValidationMode}")

arelle/ViewFileRelationshipSet.py

@@ -31,8 +31,10 @@ COL_WIDTHS = {
     "Name": 40, "Namespace": 60, "LocalName": 40, "Documentation": 80
     }
 
-def hasCalcArcrole(arcroles: tuple[str] | str) -> bool:
-    return any(arcrole in XbrlConst.summationItems for arcrole in (arcroles if isinstance(arcroles, (tuple,list)) else (arcroles,)))
+def hasCalcArcrole(arcroles: tuple[str | tuple[str, ...], ...] | str) -> bool:
+    if isinstance(arcroles, (tuple, list)):
+        return any(hasCalcArcrole(arcrole) for arcrole in arcroles)
+    return arcroles in XbrlConst.summationItems
 
 class ViewRelationshipSet(ViewFile.View):
     def __init__(self, modelXbrl, outfile, header, labelrole, lang, cols):

arelle/ViewFileRenderedGrid.py

@@ -16,7 +16,7 @@ from arelle.ModelRenderingObject import (StrctMdlBreakdown, StrctMdlStructuralNo
                                          OPEN_ASPECT_ENTRY_SURROGATE, ROLLUP_SPECIFIES_MEMBER, ROLLUP_FOR_DIMENSION_RELATIONSHIP_NODE,
                                          aspectStrctNodes)
 from arelle.rendering.RenderingLayout import layoutTable
-from arelle.rendering.RenderingResolution import resolveTableStructure, RENDER_UNITS_PER_CHAR
+from arelle.rendering.RenderingResolution import RENDER_UNITS_PER_CHAR
 from arelle.ModelValue import QName
 from arelle.ModelXbrl import DEFAULT
 from arelle.ViewFile import HTML, XML

arelle/ViewFileRenderedLayout.py

@@ -10,7 +10,6 @@ from arelle import ViewFile
 from arelle.FunctionXs import xsString
 from arelle.ModelObject import ModelObject
 from arelle.Aspect import Aspect, aspectModels, aspectRuleAspects, aspectModelAspect, aspectStr
-from arelle.rendering.RenderingResolution import resolveTableStructure
 from arelle.rendering.RenderingLayout import layoutTable
 from arelle import XbrlConst
 from arelle.XmlUtil import elementFragmentIdentifier, addQnameValue