arelle-release 2.17.1__py3-none-any.whl → 2.37.71__py3-none-any.whl

arelle/CntlrCmdLine.py

@@ -5,35 +5,67 @@ This module is Arelle's controller in command line non-interactive mode
 
 See COPYRIGHT.md for copyright information.
 '''
-from arelle import PythonUtil # define 2.x or 3.x string types
-import gettext, time, datetime, os, shlex, sys, traceback, fnmatch, threading, json, logging, platform
-from optparse import OptionGroup, OptionParser, SUPPRESS_HELP
+from __future__ import annotations
+
+import datetime
+import fnmatch
+import gettext
+import glob
+import logging
+import multiprocessing
+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, RenderingEvaluator, XmlUtil, XbrlConst, Version,
-                    ViewFileDTS, ViewFileFactList, ViewFileFactTable, ViewFileConcepts,
-                    ViewFileFormulae, ViewFileRelationshipSet, ViewFileTests, ViewFileRssFeed,
-                    ViewFileRoleTypes,
-                    ModelManager)
-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.ValidateFileSource import ValidateFileSource
+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.utils.EntryPointDetection import parseEntrypointFileInput
+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
+
 win32file = win32api = win32process = pywintypes = None
 STILL_ACTIVE = 259 # MS Windows process status constants
 PROCESS_QUERY_INFORMATION = 0x400
 DISABLE_PERSISTENT_CONFIG_OPTION = "--disablePersistentConfig"
+TESTCASE_EXPECTED_ERRORS_OPTION="testcaseExpectedErrors"
 UILANG_OPTION = '--uiLang'
 _: TypeGetText
 
@@ -46,16 +78,13 @@ 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)
 
 
-def wsgiApplication(extraArgs=[]): # for example call wsgiApplication(["--plugins=EdgarRenderer"])
+def wsgiApplication(extraArgs=[]): # for example call wsgiApplication(["--plugins=EDGAR/render"])
     return parseAndRun( ["--webserver=::wsgi"] + extraArgs )
 
 
@@ -88,10 +117,10 @@ def parseArgs(args):
             break
     # Check if the config cache needs to be disabled prior to initializing the cntlr
     disable_persistent_config = bool({DISABLE_PERSISTENT_CONFIG_OPTION, DISABLE_PERSISTENT_CONFIG_OPTION.lower()} & set(args))
-    cntlr = createCntlrAndPreloadPlugins(uiLang, disable_persistent_config, {})  # This Cntlr is needed for translations and to enable the web cache.  The cntlr is not used outside the parse function
+    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 "
@@ -128,6 +157,39 @@ def parseArgs(args):
                              "are individually so validated. "
                              "If formulae are present they will be validated and run unless --formula=none is specified. "
                              ))
+    parser.add_option("--validateDuplicateFacts", "--validateduplicatefacts",
+                      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",
+                      help=_("Save a report loaded from OIM into this file XML file name."))
+    parser.add_option("--validateXmlOim", "--validatexmloim", "--oim",
+                      action="store_true",
+                      dest="validateXmlOim",
+                      help=_("Enables OIM validation for XML and iXBRL documents. OIM only formats (json, csv) are always OIM validated."))
+    parser.add_option("--reportPackage", "--reportPackage",
+                      action="store_true",
+                      dest="reportPackage",
+                      help=_("Ignore detected file type and validate all files as Report Packages."))
+    parser.add_option("--deduplicateFacts", "--deduplicatefacts",
+                      choices=[a.value for a in ValidateDuplicateFacts.DeduplicationType],
+                      dest="deduplicateFacts",
+                      help=_("When using '--saveDeduplicatedInstance' to save a deduplicated instance, check for duplicates of this type. "
+                             "Defaults to 'complete'."))
+    parser.add_option("--saveDeduplicatedInstance", "--savededuplicatedinstance",
+                      dest="saveDeduplicatedInstance",
+                      help=_("Save an instance document with duplicates of the provided type ('--deduplicateFacts') deduplicated."))
     parser.add_option("--noValidateTestcaseSchema", "--novalidatetestcaseschema", action="store_false", dest="validateTestcaseSchema", default=True,
                       help=_("Validate testcases against their schemas."))
     betaGroup = OptionGroup(parser, "Beta Features",
@@ -161,7 +223,7 @@ def parseArgs(args):
                              " select disclosure system validation.  "
                              "Enter --disclosureSystem=help for list of names or help-verbose for list of names and descriptions. "))
     parser.add_option("--hmrc", action="store_true", dest="validateHMRC",
-                      help=_("Select U.K. HMRC disclosure system validation."))
+                      help=_("Select HMRC disclosure system validation."))
     parser.add_option("--utr", action="store_true", dest="utrValidate",
                       help=_("Select validation with respect to Unit Type Registry."))
     parser.add_option("--utrUrl", "--utrurl", action="store", dest="utrUrl",
@@ -175,7 +237,7 @@ def parseArgs(args):
     parser.add_option("--labelRole", "--labelrole", action="store", dest="labelRole",
                       help=_("Label role for labels in following file options (instead of standard label)"))
     parser.add_option("--DTS", "--csvDTS", action="store", dest="DTSFile",
-                      help=_("Write DTS tree into FILE (may be .csv or .html)"))
+                      help=_("Write DTS tree into FILE"))
     parser.add_option("--facts", "--csvFacts", action="store", dest="factsFile",
                       help=_("Write fact list into FILE"))
     parser.add_option("--factListCols", action="store", dest="factListCols",
@@ -241,6 +303,8 @@ def parseArgs(args):
                       help=_("Log reference object properties (default)."), default=True)
     parser.add_option("--logNoRefObjectProperties", "--lognorefobjectproperties", action="store_false", dest="logRefObjectProperties",
                       help=_("Do not log reference object properties."))
+    parser.add_option("--logXmlMaxAttributeLength", "--logxmlmaxattributelength", action="store", dest="logXmlMaxAttributeLength", type="int",
+                      help=_("Truncate XML log file attribute values at length. The default is 4096000 for JSON content and 128 for everything else."))
     parser.add_option("--statusPipe", action="store", dest="statusPipe", help=SUPPRESS_HELP)
     parser.add_option("--monitorParentProcess", action="store", dest="monitorParentProcess", help=SUPPRESS_HELP)
     parser.add_option("--outputAttribution", "--outputattribution", action="store", dest="outputAttribution", help=SUPPRESS_HELP)
@@ -255,6 +319,8 @@ def parseArgs(args):
                              "if this option is not specified, -v or --validate will validate and run formulas if present"))
     parser.add_option("--formulaParamExprResult", "--formulaparamexprresult", action="store_true", dest="formulaParamExprResult", help=_("Specify formula tracing."))
     parser.add_option("--formulaParamInputValue", "--formulaparaminputvalue", action="store_true", dest="formulaParamInputValue", help=_("Specify formula tracing."))
+    parser.add_option("--formulaMaximumMessageInterpolationLength", "--formulamaximummessageinterpolationlength", action="store", dest="formulaMaximumMessageInterpolationLength", type="int",
+                      help=_("Truncate interpolated expressions in formula messages to this length."), default=1000)
     parser.add_option("--formulaCallExprSource", "--formulacallexprsource", action="store_true", dest="formulaCallExprSource", help=_("Specify formula tracing."))
     parser.add_option("--formulaCallExprCode", "--formulacallexprcode", action="store_true", dest="formulaCallExprCode", help=_("Specify formula tracing."))
     parser.add_option("--formulaCallExprEval", "--formulacallexpreval", action="store_true", dest="formulaCallExprEval", help=_("Specify formula tracing."))
@@ -275,8 +341,13 @@ def parseArgs(args):
     parser.add_option("--formulaVarExpressionResult", "--formulavarexpressionresult", action="store_true", dest="formulaVarExpressionResult", help=_("Specify formula tracing."))
     parser.add_option("--formulaVarFilterWinnowing", "--formulavarfilterwinnowing", action="store_true", dest="formulaVarFilterWinnowing", help=_("Specify formula tracing."))
     parser.add_option("--formulaVarFiltersResult", "--formulavarfiltersresult", action="store_true", dest="formulaVarFiltersResult", help=_("Specify formula tracing."))
+    parser.add_option("--testcaseExpectedErrors", "--testcaseexpectederrors", action="append", dest=TESTCASE_EXPECTED_ERRORS_OPTION,
+                      help=_("For testcase results, specify comma separated additional expected errors by test case id. --testcaseExpectedErrors=testcase-index.xml:test_id1|IOerror,oime:invalidTaxonomy"))
+    parser.add_option("--testcaseFilter", "--testcasefilter", action="append", dest="testcaseFilters",
+                      help=_("If any filters are provided, any testcase variation path in the form {testcaseFilepath}:{testcaseVariationId} that doesn't pass any filter "
+                             "will be skipped." ))
     parser.add_option("--testcaseResultsCaptureWarnings", "--testcaseresultscapturewarnings", action="store_true", dest="testcaseResultsCaptureWarnings",
-                      help=_("For testcase variations capture warning results, default is inconsistency or warning if there is any warning expected result.  "))
+                      help=_("For testcase variations and RSS feed items, capture warning results, default is inconsistency or warning if there is any warning expected result.  "))
     parser.add_option("--testcaseResultOptions", choices=("match-any", "match-all"), action="store", dest="testcaseResultOptions",
                       help=_("For testcase results, default is match any expected result, options to match any or match all expected result(s).  "))
     parser.add_option("--formulaRunIDs", "--formularunids", action="store", dest="formulaRunIDs", help=_("Specify formula/assertion IDs to run, separated by a '|' character, or a regex expression."))
@@ -302,6 +373,8 @@ def parseArgs(args):
                       help=_("Specify no checking of internet secure connection certificate"))
     parser.add_option("--httpsRedirectCache", "--httpsredirectcache", action="store_true", dest="httpsRedirectCache",
                       help=_("Treat http and https schemes interchangeably when looking up files from the webcache"))
+    parser.add_option("--cacheDirectory", "--cachedirectory", action="store", dest="cacheDirectory",
+                      help=_("Override the default location of the cache directory"))
     parser.add_option("--httpUserAgent", "--httpuseragent", action="store", dest="httpUserAgent",
                       help=_("Specify non-standard http header User-Agent value"))
     parser.add_option(DISABLE_PERSISTENT_CONFIG_OPTION, DISABLE_PERSISTENT_CONFIG_OPTION.lower(), action="store_true", dest="disablePersistentConfig", help=_("Prohibits Arelle from reading and writing a config to the local cache."))
@@ -316,12 +389,10 @@ def parseArgs(args):
                              R" (e.g., 'http://arelle.org/files/hello_web.py', 'C:\Program Files\Arelle\examples\plugin\hello_dolly.py' to load, "
                              "or ../examples/plugin/hello_dolly.py for relative use of examples directory) "
                              "Local python files do not require .py suffix, e.g., hello_dolly without .py is sufficient, "
-                             "Packaged plug-in urls are their directory's url (e.g., --plugins EdgarRenderer or --plugins xbrlDB).  " ))
-    parser.add_option("--packages", "--package", action="store", dest="packages",
-                      help=_("Specify taxonomy packages configuration.  "
-                             "Enter 'show' to show current packages configuration.  "
-                             "Commands show, and module urls are '|' separated: "
-                             "url specifies a package by its url or filename, please use full paths. "
+                             "Packaged plug-in urls are their directory's url (e.g., --plugins EDGAR/render or --plugins xbrlDB).  " ))
+    parser.add_option("--packages", "--package", action="append", dest="packages",
+                      help=_("Load taxonomy packages. Option can be repeated for multiple files. "
+                             "If a directory is specified, all .zip files in the directory will be loaded. "
                              "(Package settings from GUI are no longer shared with cmd line operation. "
                              "Cmd line package settings are not persistent.)  " ))
     parser.add_option("--packageManifestName", action="store", dest="packageManifestName",
@@ -335,7 +406,7 @@ def parseArgs(args):
     if hasWebServer():
         parser.add_option("--webserver", action="store", dest="webserver",
                           help=_("start web server on host:port[:server] for REST and web access, e.g., --webserver locahost:8080, "
-                                 "or specify nondefault a server name, such as cherrypy, --webserver locahost:8080:cherrypy. "
+                                 "or specify nondefault a server name, such as cheroot, --webserver locahost:8080:cheroot. "
                                  "(It is possible to specify options to be defaults for the web server, such as disclosureSystem and validations, but not including file names.) "))
     pluginOptionsIndex = len(parser.option_list)
     pluginOptionsGroupIndex = len(parser.option_groups)
@@ -359,7 +430,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)
@@ -416,15 +487,14 @@ def parseArgs(args):
                           "\n   Python(r) {pythonVersion} (c) 2001-2013 Python Software Foundation"
                           "\n   PyParsing (c) 2003-2013 Paul T. McGuire"
                           "\n   lxml {lxmlVersion} (c) 2004 Infrae, ElementTree (c) 1999-2004 by Fredrik Lundh"
-                          "{bottleCopyright}"
+                          "\n   Bottle (c) 2009-2024 Marcel Hellkamp"
                           "\n   May include installable plug-in modules with author-specific license terms").format(
             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 ""
         ))
         parser.exit()  # Printing the message in parser.exit sends it to stderr NOT stdout
     elif options.diagnostics:
@@ -453,15 +523,31 @@ def parseArgs(args):
         if optionName in pluginOptionDestinations:
             pluginOptions[optionName] = optionValue
         else:
+            if optionName == TESTCASE_EXPECTED_ERRORS_OPTION and optionValue is not None:
+                expectedErrors = {}
+                for expectedError in optionValue:
+                    expectedErrorSplit = expectedError.split('|')
+                    if len(expectedErrorSplit) != 2:
+                        parser.error(_("--testcaseExpectedErrors must be in the format '--testcaseExpectedErrors=testcase-index.xml:v-1|errorCode1,errorCode2,...'"))
+                    expectedErrors[expectedErrorSplit[0]] = expectedErrorSplit[1].split(',')
+                optionValue = expectedErrors
             baseOptions[optionName] = optionValue
     try:
         runtimeOptions = RuntimeOptions(pluginOptions=pluginOptions, **baseOptions)
     except RuntimeOptionsException as e:
         parser.error(f"{e}, please try\n python CntlrCmdLine.py --help")
+    if (
+        runtimeOptions.entrypointFile is None and
+        not runtimeOptions.proxy and
+        not runtimeOptions.plugins and
+        not pluginOptions and
+        not runtimeOptions.webserver
+    ):
+        parser.error("No entrypoint specified, please try\n python CntlrCmdLine.py --help")
     return runtimeOptions, arellePluginModules
 
 
-def createCntlrAndPreloadPlugins(uiLang, disablePersistentConfig, arellePluginModules):
+def createCntlrAndPreloadPlugins(uiLang, disablePersistentConfig, arellePluginModules) -> CntlrCmdLine:
     """
     This function creates a cntlr and preloads all the necessary plugins.
     :param uiLang: The UI Language
@@ -499,62 +585,46 @@ def configAndRunCntlr(options, arellePluginModules):
                            logFormat=(options.logFormat or "[%(messageCode)s] %(message)s - %(file)s"),
                            logLevel=(options.logLevel or "DEBUG"),
                            logToBuffer=getattr(options, "logToBuffer", False),
-                           logTextMaxLength=options.logTextMaxLength,  # e.g., used by EdgarRenderer to require buffered logging
-                           logRefObjectProperties=options.logRefObjectProperties)
+                           logTextMaxLength=options.logTextMaxLength,  # e.g., used by EDGAR/render to require buffered logging
+                           logRefObjectProperties=options.logRefObjectProperties,
+                           logXmlMaxAttributeLength=options.logXmlMaxAttributeLength,
+                           logPropagate=options.logPropagate)
         cntlr.postLoggingInit()  # Cntlr options after logging is started
         cntlr.run(options)
         return cntlr
 
 
-def filesourceEntrypointFiles(filesource, entrypointFiles=[]):
-    if filesource.isArchive:
-        if filesource.isTaxonomyPackage:  # if archive is also a taxonomy package, activate mappings
-            filesource.loadTaxonomyPackageMappings()
-        del entrypointFiles[:] # clear out archive from entrypointFiles
-        # attempt to find inline XBRL files before instance files, .xhtml before probing others (ESMA)
-        for _archiveFile in (filesource.dir or ()): # .dir might be none if IOerror
-            if _archiveFile.endswith(".xhtml") or _archiveFile.endswith(".html"):
-                filesource.select(_archiveFile)
-                if ModelDocument.Type.identify(filesource, filesource.url) in (ModelDocument.Type.INSTANCE, ModelDocument.Type.INLINEXBRL):
-                    entrypointFiles.append({"file":filesource.url})
-        urlsByType = {}
-        if not entrypointFiles:
-            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, ModelDocument.Type.INSTANCE):
-            for url in urlsByType.get(identifiedType, []):
-                entrypointFiles.append({"file":url})
-            if entrypointFiles:
-                if identifiedType == ModelDocument.Type.INLINEXBRL:
-                    for pluginXbrlMethod in 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:
-            for url in urlsByType.get(ModelDocument.Type.HTML, []):
-                entrypointFiles.append({"file":url})
-
-
-    elif os.path.isdir(filesource.url):
-        del entrypointFiles[:] # clear list
-        for _file in os.listdir(filesource.url):
-            _path = os.path.join(filesource.url, _file)
-            if os.path.isfile(_path) and ModelDocument.Type.identify(filesource, _path) in (ModelDocument.Type.INSTANCE, ModelDocument.Type.INLINEXBRL):
-                entrypointFiles.append({"file":_path})
-    return entrypointFiles
-
 class ParserForDynamicPlugins:
     def __init__(self, options):
+        self._long_opt = {}
+        self._short_opt = {}
+        self.conflict_handler = 'error'
+        self.defaults = {}
+        self.option_class = Option
         self.options = options
+
     def add_option(self, *args, **kwargs):
         if 'dest' in kwargs:
             _dest = kwargs['dest']
             if not hasattr(self.options, _dest):
-                setattr(self.options, _dest, kwargs.get('default',None))
+                setattr(self.options, _dest, kwargs.get('default'))
+
+    def add_option_group(self, featureGroup, *args, **kwargs):
+        for opt in featureGroup.option_list:
+            if hasattr(opt, "dest"):
+                self.add_option(dest=opt.dest, default=getattr(opt, 'default', None))
+
+    def __getattr__(self, name: str) -> None:
+        return None
+
+
+def _pluginHasCliOptions(moduleInfo):
+    if "CntlrCmdLine.Options" in moduleInfo["classMethods"]:
+        return True
+    if imports := moduleInfo.get("imports"):
+        return any(_pluginHasCliOptions(importedModule) for importedModule in imports)
+    return False
+
 
 class CntlrCmdLine(Cntlr.Cntlr):
     """
@@ -564,10 +634,10 @@ 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, logFileName=logFileName)
         self.preloadedPlugins =  {}
 
-    def run(self, options, sourceZipStream=None, responseZipStream=None):
+    def run(self, options: RuntimeOptions, sourceZipStream=None, responseZipStream=None) -> bool:
         """Process command line arguments or web service request, such as to load and validate an XBRL document, or start web server.
 
         When a web server has been requested, this method may be called multiple times, once for each web service (REST) request that requires processing.
@@ -576,24 +646,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))
@@ -605,14 +675,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
 
@@ -642,7 +712,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:
@@ -651,10 +721,16 @@ class CntlrCmdLine(Cntlr.Cntlr):
             self.webCache.httpsRedirect = options.httpsRedirectCache
         if options.httpUserAgent:
             self.webCache.httpUserAgent = options.httpUserAgent
+        if options.redirectFallbacks:
+            for matchPattern, replaceFormat in options.redirectFallbacks.items():
+                self.webCache.redirectFallback(matchPattern, replaceFormat)
+        if options.cacheDirectory:
+            self.webCache.cacheDir = options.cacheDirectory
         if options.plugins:
             resetPlugins = False
             savePluginChanges = True
             showPluginModules = False
+            loadPluginOptions = False
             for pluginCmd in options.plugins.split('|'):
                 cmd = pluginCmd.strip()
                 if cmd == "show":
@@ -667,8 +743,8 @@ class CntlrCmdLine(Cntlr.Cntlr):
                         self.addToLog(_("Addition of plug-in {0} successful.").format(moduleInfo.get("name")),
                                       messageCode="info", file=moduleInfo.get("moduleURL"))
                         resetPlugins = True
-                        if "CntlrCmdLine.Options" in moduleInfo["classMethods"]:
-                            addedPluginWithCntlrCmdLineOptions = True
+                        if _pluginHasCliOptions(moduleInfo):
+                            loadPluginOptions = True
                     else:
                         self.addToLog(_("Unable to load plug-in."), messageCode="info", file=cmd[1:])
                 elif cmd.startswith("~"):
@@ -691,6 +767,8 @@ class CntlrCmdLine(Cntlr.Cntlr):
                         moduleInfo = PluginManager.addPluginModule(cmd)
                         if moduleInfo:
                             resetPlugins = True
+                            if _pluginHasCliOptions(moduleInfo):
+                                loadPluginOptions = True
                     if moduleInfo:
                         self.addToLog(_("Activation of plug-in {0} successful, version {1}.").format(moduleInfo.get("name"), moduleInfo.get("version")),
                                       messageCode="info", file=moduleInfo.get("moduleURL"))
@@ -702,11 +780,11 @@ class CntlrCmdLine(Cntlr.Cntlr):
                     PluginManager.reset()
                     if savePluginChanges:
                         PluginManager.save(self)
-                    if options.webserver: # options may need reparsing dynamically
-                        _optionsParser = ParserForDynamicPlugins(options)
-                        # add plug-in options
-                        for optionsExtender in pluginClassMethods("CntlrCmdLine.Options"):
-                            optionsExtender(_optionsParser)
+                if loadPluginOptions:
+                    _optionsParser = ParserForDynamicPlugins(options)
+                    # add plug-in options
+                    for optionsExtender in PluginManager.pluginClassMethods("CntlrCmdLine.Options"):
+                        optionsExtender(_optionsParser)
 
             if showPluginModules:
                 self.addToLog(_("Plug-in modules:"), messageCode="info")
@@ -748,6 +826,17 @@ class CntlrCmdLine(Cntlr.Cntlr):
         else:
             self.modelManager.disclosureSystem.select(None) # just load ordinary mappings
             self.modelManager.validateDisclosureSystem = False
+        if self.modelManager.disclosureSystem.keepOpen:
+            # Force keepOpen if specified by disclosure system.
+            options.keepOpen = True
+        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)
+            duplicateType = duplicateTypeArg.duplicateType()
+            self.modelManager.validateDuplicateFacts = duplicateType
+        self.modelManager.validateAllFilesAsReportPackages = bool(options.reportPackage)
         if options.utrUrl:  # override disclosureSystem utrUrl
             self.modelManager.disclosureSystem.utrUrl = [options.utrUrl]
             # can be set now because the utr is first loaded at validation time
@@ -814,6 +903,7 @@ class CntlrCmdLine(Cntlr.Cntlr):
             fo.parameterValues = dict(((qname(key, noPrefixIsNoNamespace=True),(None,value))
                                        for param in options.parameters.split(parameterSeparator)
                                        for key,sep,value in (param.partition('='),) ) )
+        fo.maximumMessageInterpolationLength = options.formulaMaximumMessageInterpolationLength
         if options.formulaParamExprResult:
             fo.traceParameterExpressionResult = True
         if options.formulaParamInputValue:
@@ -858,7 +948,12 @@ class CntlrCmdLine(Cntlr.Cntlr):
             fo.traceVariableFilterWinnowing = True
         if options.formulaVarFiltersResult:
             fo.traceVariableFiltersResult = True
+        if options.testcaseExpectedErrors:
+            fo.testcaseExpectedErrors = options.testcaseExpectedErrors
+        if options.testcaseFilters:
+            fo.testcaseFilters = options.testcaseFilters
         if options.testcaseResultsCaptureWarnings:
+            self.errorManager.setErrorCaptureLevel(logging._checkLevel("WARNING"))
             fo.testcaseResultsCaptureWarnings = True
         if options.testcaseResultOptions:
             fo.testcaseResultOptions = options.testcaseResultOptions
@@ -874,7 +969,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)
@@ -886,46 +981,36 @@ class CntlrCmdLine(Cntlr.Cntlr):
             if not (options.entrypointFile or sourceZipStream):
                 return True # success
 
+        entrypointParseResult = parseEntrypointFileInput(self, options.entrypointFile, sourceZipStream)
+        if not entrypointParseResult.success:
+            return False
+        filesource = entrypointParseResult.filesource
+        _entrypointFiles = entrypointParseResult.entrypointFiles
         success = True
-        # entrypointFile may be absent (if input is a POSTED zip or file name ending in .zip)
-        #    or may be a | separated set of file names
-        _entryPoints = []
-        _checkIfXmlIsEis = self.modelManager.disclosureSystem and self.modelManager.disclosureSystem.validationType == "EFM"
-        if options.entrypointFile:
-            _f = options.entrypointFile
-            try: # may be a json list
-                _entryPoints = json.loads(_f)
-                _checkIfXmlIsEis = False # json entry objects never specify an xml EIS archive
-            except ValueError as e:
-                # is it malformed json?
-                if _f.startswith("[{") or _f.endswith("]}") or '"file:"' in _f:
-                    self.addToLog(_("File name parameter appears to be malformed JSON: {0}\n{1}".format(e, _f)),
-                                  messageCode="FileNameFormatError",
-                                  level=logging.ERROR)
-                    success = False
-                else: # try as file names separated by '|'
-                    for f in (_f or '').split('|'):
-                        if not sourceZipStream and not isHttpUrl(f) and not os.path.isabs(f):
-                            f = os.path.normpath(os.path.join(os.getcwd(), f)) # make absolute normed path
-                        _entryPoints.append({"file":f})
-        filesource = None # file source for all instances if not None
-        if sourceZipStream:
-            filesource = FileSource.openFileSource(None, self, sourceZipStream)
-        elif len(_entryPoints) == 1 and "file" in _entryPoints[0]: # check if an archive and need to discover entry points (and not IXDS)
-            filesource = FileSource.openFileSource(_entryPoints[0].get("file",None), self, checkIfXmlIsEis=_checkIfXmlIsEis)
-        _entrypointFiles = _entryPoints
-        if filesource and not filesource.selection:
-            if not (sourceZipStream and len(_entrypointFiles) > 0):
-                filesourceEntrypointFiles(filesource, _entrypointFiles)
-
-        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 options.validate and filesource is not None:
+            ValidateFileSource(self, filesource).validate(options.reportPackage)
+
+        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:
+                # web server post request does not have a file name.
+                msg = _("No XBRL entry points could be loaded from provided input")
+            self.addToLog(msg, messageCode="error", level=logging.ERROR)
+            success = False
         for _entrypoint in _entrypointFiles:
             _entrypointFile = _entrypoint.get("file", None) if isinstance(_entrypoint,dict) else _entrypoint
             if filesource and filesource.isArchive:
                 filesource.select(_entrypointFile)
             else:
+                _entrypointFile = PackageManager.mappedUrl(_entrypointFile)
                 filesource = FileSource.openFileSource(_entrypointFile, self, sourceZipStream)
+                if options.validate:
+                    ValidateFileSource(self, filesource).validate(options.reportPackage)
             self.entrypointFile = _entrypointFile
             timeNow = XmlUtil.dateunionValue(datetime.datetime.now())
             firstStartedAt = startedAt = time.time()
@@ -934,6 +1019,9 @@ class CntlrCmdLine(Cntlr.Cntlr):
             try:
                 if filesource:
                     modelXbrl = self.modelManager.load(filesource, _("views loading"), entrypoint=_entrypoint)
+                    if filesource.isArchive:
+                        # Keep archive filesource potentially used by multiple reports open.
+                        modelXbrl.closeFileSource = False
             except ModelDocument.LoadingException:
                 pass
             except Exception as err:
@@ -967,11 +1055,20 @@ 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:
+                            self.showStatus(_("Saving XBRL instance: {0}").format(modelXbrl.modelDocument.basename))
+                            saveOimReportToXmlInstance(modelXbrl.modelDocument, options.saveOIMToXMLReport, responseZipStream)
+                        else:
+                            self.addToLog(_("Report not loaded from OIM, not saving xBRL-XML report."),
+                                        messageCode="NotOim",
+                                        level=logging.INFO)
+
             else:
                 success = False
             if success and options.diffFile and options.versReportFile:
@@ -1002,83 +1099,84 @@ class CntlrCmdLine(Cntlr.Cntlr):
                     success = False
                 except Exception as err:
                     success = False
-                    self.addToLog(_("[Exception] Failed to doad diff file: \n{0} \n{1}").format(
+                    self.addToLog(_("[Exception] Failed to load diff file: \n{0} \n{1}").format(
                                 err,
                                 traceback.format_tb(sys.exc_info()[2])))
             if success:
                 try:
-                    modelXbrl = self.modelManager.modelXbrl
-                    hasFormulae = modelXbrl.hasFormulae
-                    isAlreadyValidated = False
-                    for pluginXbrlMethod in pluginClassMethods("ModelDocument.IsValidated"):
-                        if pluginXbrlMethod(modelXbrl): # e.g., streaming extensions already has validated
-                            isAlreadyValidated = True
-                    if options.validate and not isAlreadyValidated:
-                        startedAt = time.time()
-                        if options.formulaAction: # don't automatically run formulas
-                            modelXbrl.hasFormulae = False
-                        self.modelManager.validate()
-                        if options.formulaAction: # restore setting
-                            modelXbrl.hasFormulae = hasFormulae
-                        self.addToLog(format_string(self.modelManager.locale,
-                                                    _("validated in %.2f secs"),
-                                                    time.time() - startedAt),
-                                                    messageCode="info", file=self.entrypointFile)
-                    if (modelXbrl.modelDocument.type not in ModelDocument.Type.TESTCASETYPES and
-                            options.formulaAction in ("validate", "run") and  # do nothing here if "none"
-                            not isAlreadyValidated):  # formulas can't run if streaming has validated the instance
-                        from arelle import ValidateXbrlDimensions
-                        from arelle.formula import ValidateFormula
-                        startedAt = time.time()
-                        if not options.validate:
-                            ValidateXbrlDimensions.loadDimensionDefaults(modelXbrl)
-                        # setup fresh parameters from formula optoins
-                        modelXbrl.parameters = fo.typedParameters(modelXbrl.prefixedNamespaces)
-                        ValidateFormula.validate(modelXbrl, compileOnly=(options.formulaAction != "run"))
-                        self.addToLog(format_string(self.modelManager.locale,
-                                                    _("formula validation and execution in %.2f secs")
-                                                    if options.formulaAction == "run"
-                                                    else _("formula validation only in %.2f secs"),
-                                                    time.time() - startedAt),
-                                                    messageCode="info", file=self.entrypointFile)
+                    for modelXbrl in [self.modelManager.modelXbrl] + getattr(self.modelManager.modelXbrl, "supplementalModelXbrls", []):
+                        hasFormulae = modelXbrl.hasFormulae
+                        isAlreadyValidated = False
+                        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:
+                            startedAt = time.time()
+                            if options.formulaAction: # don't automatically run formulas
+                                modelXbrl.hasFormulae = False
+                            from arelle import Validate
+                            Validate.validate(modelXbrl)
+                            if options.formulaAction: # restore setting
+                                modelXbrl.hasFormulae = hasFormulae
+                            self.addToLog(format_string(self.modelManager.locale,
+                                                        _("validated in %.2f secs"),
+                                                        time.time() - startedAt),
+                                                        messageCode="info", file=self.entrypointFile)
+                        if (modelXbrl.modelDocument.type not in ModelDocument.Type.TESTCASETYPES and
+                                options.formulaAction in ("validate", "run") and  # do nothing here if "none"
+                                not isAlreadyValidated):  # formulas can't run if streaming has validated the instance
+                            from arelle import ValidateXbrlDimensions
+                            from arelle.formula import ValidateFormula
+                            startedAt = time.time()
+                            if not options.validate:
+                                ValidateXbrlDimensions.loadDimensionDefaults(modelXbrl)
+                            # setup fresh parameters from formula optoins
+                            modelXbrl.parameters = fo.typedParameters(modelXbrl.prefixedNamespaces)
+                            ValidateFormula.validate(modelXbrl, compileOnly=(options.formulaAction != "run"))
+                            self.addToLog(format_string(self.modelManager.locale,
+                                                        _("formula validation and execution in %.2f secs")
+                                                        if options.formulaAction == "run"
+                                                        else _("formula validation only in %.2f secs"),
+                                                        time.time() - startedAt),
+                                                        messageCode="info", file=self.entrypointFile)
 
+                        if options.testReport:
+                            ViewFileTests.viewTests(self.modelManager.modelXbrl, options.testReport, options.testReportCols)
 
-                    if options.testReport:
-                        ViewFileTests.viewTests(self.modelManager.modelXbrl, options.testReport, options.testReportCols)
-
-                    if options.rssReport:
-                        ViewFileRssFeed.viewRssFeed(self.modelManager.modelXbrl, options.rssReport, options.rssReportCols)
-
-                    if options.DTSFile:
-                        ViewFileDTS.viewDTS(modelXbrl, options.DTSFile)
-                    if options.factsFile:
-                        ViewFileFactList.viewFacts(modelXbrl, options.factsFile, labelrole=options.labelRole, lang=options.labelLang, cols=options.factListCols)
-                    if options.factTableFile:
-                        ViewFileFactTable.viewFacts(modelXbrl, options.factTableFile, labelrole=options.labelRole, lang=options.labelLang, cols=options.factTableCols)
-                    if options.conceptsFile:
-                        ViewFileConcepts.viewConcepts(modelXbrl, options.conceptsFile, labelrole=options.labelRole, lang=options.labelLang)
-                    if options.preFile:
-                        ViewFileRelationshipSet.viewRelationshipSet(modelXbrl, options.preFile, "Presentation Linkbase", XbrlConst.parentChild, labelrole=options.labelRole, lang=options.labelLang, cols=options.relationshipCols)
-                    if options.tableFile:
-                        ViewFileRelationshipSet.viewRelationshipSet(modelXbrl, options.tableFile, "Table Linkbase", "Table-rendering", labelrole=options.labelRole, lang=options.labelLang)
-                    if options.calFile:
-                        ViewFileRelationshipSet.viewRelationshipSet(modelXbrl, options.calFile, "Calculation Linkbase", XbrlConst.summationItem, labelrole=options.labelRole, lang=options.labelLang, cols=options.relationshipCols)
-                    if options.dimFile:
-                        ViewFileRelationshipSet.viewRelationshipSet(modelXbrl, options.dimFile, "Dimensions", "XBRL-dimensions", labelrole=options.labelRole, lang=options.labelLang, cols=options.relationshipCols)
-                    if options.anchFile:
-                        ViewFileRelationshipSet.viewRelationshipSet(modelXbrl, options.anchFile, "Anchoring", XbrlConst.widerNarrower, labelrole=options.labelRole, lang=options.labelLang, cols=options.relationshipCols)
-                    if options.formulaeFile:
-                        ViewFileFormulae.viewFormulae(modelXbrl, options.formulaeFile, "Formulae", lang=options.labelLang)
-                    if options.viewArcrole and options.viewFile:
-                        ViewFileRelationshipSet.viewRelationshipSet(modelXbrl, options.viewFile, os.path.basename(options.viewArcrole), options.viewArcrole, labelrole=options.labelRole, lang=options.labelLang, cols=options.relationshipCols)
-                    if options.roleTypesFile:
-                        ViewFileRoleTypes.viewRoleTypes(modelXbrl, options.roleTypesFile, "Role Types", isArcrole=False, lang=options.labelLang)
-                    if options.arcroleTypesFile:
-                        ViewFileRoleTypes.viewRoleTypes(modelXbrl, options.arcroleTypesFile, "Arcrole Types", isArcrole=True, lang=options.labelLang)
-                    for pluginXbrlMethod in pluginClassMethods("CntlrCmdLine.Xbrl.Run"):
-                        pluginXbrlMethod(self, options, modelXbrl, _entrypoint, responseZipStream=responseZipStream)
+                        if options.rssReport:
+                            ViewFileRssFeed.viewRssFeed(self.modelManager.modelXbrl, options.rssReport, options.rssReportCols)
+
+                        if options.DTSFile:
+                            ViewFileDTS.viewDTS(modelXbrl, options.DTSFile)
+                        if options.factsFile:
+                            ViewFileFactList.viewFacts(modelXbrl, options.factsFile, labelrole=options.labelRole, lang=options.labelLang, cols=options.factListCols)
+                        if options.factTableFile:
+                            ViewFileFactTable.viewFacts(modelXbrl, options.factTableFile, labelrole=options.labelRole, lang=options.labelLang, cols=options.factTableCols)
+                        if options.conceptsFile:
+                            ViewFileConcepts.viewConcepts(modelXbrl, options.conceptsFile, labelrole=options.labelRole, lang=options.labelLang)
+                        if options.preFile:
+                            ViewFileRelationshipSet.viewRelationshipSet(modelXbrl, options.preFile, "Presentation Linkbase", XbrlConst.parentChild, labelrole=options.labelRole, lang=options.labelLang, cols=options.relationshipCols)
+                        if options.tableFile:
+                            ViewFileRelationshipSet.viewRelationshipSet(modelXbrl, options.tableFile, "Table Linkbase", "Table-rendering", labelrole=options.labelRole, lang=options.labelLang)
+                        if options.calFile:
+                            ViewFileRelationshipSet.viewRelationshipSet(modelXbrl, options.calFile, "Calculation Linkbase", XbrlConst.summationItems, labelrole=options.labelRole, lang=options.labelLang, cols=options.relationshipCols)
+                        if options.dimFile:
+                            ViewFileRelationshipSet.viewRelationshipSet(modelXbrl, options.dimFile, "Dimensions", "XBRL-dimensions", labelrole=options.labelRole, lang=options.labelLang, cols=options.relationshipCols)
+                        if options.anchFile:
+                            ViewFileRelationshipSet.viewRelationshipSet(modelXbrl, options.anchFile, "Anchoring", XbrlConst.widerNarrower, labelrole=options.labelRole, lang=options.labelLang, cols=options.relationshipCols)
+                        if options.formulaeFile:
+                            ViewFileFormulae.viewFormulae(modelXbrl, options.formulaeFile, "Formulae", lang=options.labelLang)
+                        if options.viewArcrole and options.viewFile:
+                            ViewFileRelationshipSet.viewRelationshipSet(modelXbrl, options.viewFile, os.path.basename(options.viewArcrole), options.viewArcrole, labelrole=options.labelRole, lang=options.labelLang, cols=options.relationshipCols)
+                        if options.roleTypesFile:
+                            ViewFileRoleTypes.viewRoleTypes(modelXbrl, options.roleTypesFile, "Role Types", isArcrole=False, lang=options.labelLang)
+                        if options.arcroleTypesFile:
+                            ViewFileRoleTypes.viewRoleTypes(modelXbrl, options.arcroleTypesFile, "Arcrole Types", isArcrole=True, lang=options.labelLang)
+
+                        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,
@@ -1093,6 +1191,30 @@ class CntlrCmdLine(Cntlr.Cntlr):
                                   level=logging.CRITICAL)
                     success = False
             if modelXbrl:
+                if success:
+                    if options.saveDeduplicatedInstance:
+                        if options.deduplicateFacts:
+                            deduplicateFactsArg = ValidateDuplicateFacts.DeduplicationType(options.deduplicateFacts)
+                        else:
+                            deduplicateFactsArg = ValidateDuplicateFacts.DeduplicationType.COMPLETE
+                        if modelXbrl.modelDocument.type != ModelDocument.Type.INSTANCE:
+                            self.addToLog(_("Provided file must be a traditional XBRL instance document to save a deduplicated instance."),
+                                          messageCode="error", file=modelXbrl.modelDocument.uri)
+                        else:
+                            # Deduplication modifies the underlying lxml tree and leaves the model in an undefined state.
+                            # Anything depending on the ModelXbrl that runs after this may encounter unexpected behavior,
+                            # so we'll run it as a final step in the CLI controller flow.
+                            ValidateDuplicateFacts.saveDeduplicatedInstance(modelXbrl, deduplicateFactsArg, options.saveDeduplicatedInstance)
+                            if options.keepOpen:
+                                success = False
+                                self.addToLog(_("Attempted to keep model connection open after saving deduplicated instance. "
+                                                "Deduplication modifies the model in ways that can cause unexpected behavior on subsequent use."),
+                                              messageCode="error", level=logging.CRITICAL)
+                    elif options.deduplicateFacts:
+                        success = False
+                        self.addToLog(_("'deduplicateFacts' can only be used with 'saveDeduplicatedInstance'"),
+                                      messageCode="error", level=logging.CRITICAL)
+
                 modelXbrl.profileStat(_("total"), time.time() - firstStartedAt)
                 if options.collectProfileStats and modelXbrl:
                     modelXbrl.logProfileStats()
@@ -1101,13 +1223,23 @@ class CntlrCmdLine(Cntlr.Cntlr):
                         self.modelManager.close(modelDiffReport)
                     elif modelXbrl:
                         self.modelManager.close(modelXbrl)
+
+        if options.validate:
+            for pluginXbrlMethod in PluginManager.pluginClassMethods("Validate.Complete"):
+                pluginXbrlMethod(self, filesource)
+
+        if filesource is not None and not options.keepOpen:
+            # Archive filesource potentially used by multiple reports may still be open.
+            filesource.close()
+
         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()
 
         if options.statusPipe and getattr(self, "statusPipe", None) is not None:
             win32file.WriteFile(self.statusPipe, b" ")  # clear status
@@ -1139,7 +1271,18 @@ class CntlrCmdLine(Cntlr.Cntlr):
                 #    fh.write("Status pipe exception {} {}\n".format(type(ex), ex))
                 system.exit()
 
-    def loadPackages(self, packages: str, packageManifestName: str):
+    def loadPackage(self, package: str, packageManifestName: str):
+        from arelle import PackageManager
+        packageInfo = PackageManager.addPackage(self, package, packageManifestName)
+        if packageInfo:
+            self.addToLog(_("Activation of package {0} successful.").format(packageInfo.get("name")),
+                          messageCode="info", file=packageInfo.get("URL"))
+        else:
+            self.addToLog(_("Unable to load package \"%(name)s\". "),
+                          messageCode="arelle:packageLoadingError",
+                          messageArgs={"name": package, "file": package}, level=logging.ERROR)
+
+    def loadPackages(self, packages: list[str], packageManifestName: str):
         """
         Loads specified packages.
 
@@ -1149,7 +1292,9 @@ class CntlrCmdLine(Cntlr.Cntlr):
         from arelle import PackageManager
         savePackagesChanges = True
         showPackages = False
-        for packageCmd in packages.split('|'):
+        # For backwards compatibility, we allow '|' separated filenames/URLs
+        # within a single --packages option.
+        for packageCmd in [cmd for p in packages for cmd in p.split('|')]:
             cmd = packageCmd.strip()
             if cmd == "show":
                 showPackages = True
@@ -1172,16 +1317,13 @@ class CntlrCmdLine(Cntlr.Cntlr):
                     self.addToLog(_("Deletion of package successful."), messageCode="info", file=cmd[1:])
                 else:
                     self.addToLog(_("Unable to delete package."), messageCode="info", file=cmd[1:])
-            else:  # assume it is a module or package
+            elif os.path.isdir(cmd): # load all package files in a directory
                 savePackagesChanges = False
-                packageInfo = PackageManager.addPackage(self, cmd, packageManifestName)
-                if packageInfo:
-                    self.addToLog(_("Activation of package {0} successful.").format(packageInfo.get("name")),
-                                  messageCode="info", file=packageInfo.get("URL"))
-                else:
-                    self.addToLog(_("Unable to load package \"%(name)s\". "),
-                                  messageCode="arelle:packageLoadingError",
-                                  messageArgs={"name": cmd, "file": cmd}, level=logging.ERROR)
+                for package in glob.glob(os.path.join(cmd, "*.zip")):
+                    self.loadPackage(package, packageManifestName)
+            else: # assume it is a module or package
+                savePackagesChanges = False
+                self.loadPackage(cmd, packageManifestName)
         if PackageManager.packagesConfigChanged:
             PackageManager.rebuildRemappings(self)
         if savePackagesChanges:
@@ -1197,11 +1339,6 @@ class CntlrCmdLine(Cntlr.Cntlr):
                     messageCode="info", file=packageInfo.get("URL"))
 
 if __name__ == "__main__":
-    '''
-    if '--COMserver' in sys.argv:
-        from arelle import CntlrComServer
-        CntlrComServer.main()
-    else:
-        main()
-    '''
+    if getattr(sys, 'frozen', False):
+        multiprocessing.freeze_support()
     main()