arelle-release 2.37.46__py3-none-any.whl → 2.38.0__py3-none-any.whl

arelle/BetaFeatures.py

@@ -3,27 +3,6 @@ See COPYRIGHT.md for copyright information.
 """
 from __future__ import annotations
 
-BETA_OBJECT_MODEL_FEATURE = "betaObjectModel"
 # Add camelCaseOptionName
 BETA_FEATURES_AND_DESCRIPTIONS: dict[str, str] = {
-    BETA_OBJECT_MODEL_FEATURE: "Replace lxml based object model with a pure Python class hierarchy.",
 }
-
-
-_NEW_OBJECT_MODEL_STATUS_ACCESSED = False
-_USE_NEW_OBJECT_MODEL = False
-
-
-def enableNewObjectModel() -> None:
-    global _USE_NEW_OBJECT_MODEL
-    if _USE_NEW_OBJECT_MODEL:
-        return
-    if _NEW_OBJECT_MODEL_STATUS_ACCESSED:
-        raise RuntimeError("Can't change object model transition setting after classes have already been defined.")
-    _USE_NEW_OBJECT_MODEL = True
-
-
-def newObjectModelEnabled() -> bool:
-    global _NEW_OBJECT_MODEL_STATUS_ACCESSED
-    _NEW_OBJECT_MODEL_STATUS_ACCESSED = True
-    return _USE_NEW_OBJECT_MODEL

arelle/Cntlr.py

@@ -18,24 +18,25 @@ import os
 import subprocess
 import sys
 import tempfile
-from typing import Any, TYPE_CHECKING, cast
+from typing import TYPE_CHECKING, Any, cast
 
-import regex as re
+import regex
 
 from arelle import Locale, ModelManager, PackageManager, PluginManager, XbrlConst
 from arelle.BetaFeatures import BETA_FEATURES_AND_DESCRIPTIONS
 from arelle.ErrorManager import ErrorManager
 from arelle.FileSource import FileSource
-from arelle.SystemInfo import PlatformOS, getSystemWordSize, hasFileSystem, hasWebServer, isCGI, isGAE
-from arelle.WebCache import WebCache
 from arelle.logging.formatters.LogFormatter import LogFormatter, logRefsFileLines  # noqa: F401 - for reimport
 from arelle.logging.handlers.LogHandlerWithXml import LogHandlerWithXml  # noqa: F401 - for reimport
 from arelle.logging.handlers.LogToBufferHandler import LogToBufferHandler
 from arelle.logging.handlers.LogToPrintHandler import LogToPrintHandler
 from arelle.logging.handlers.LogToXmlHandler import LogToXmlHandler
 from arelle.logging.handlers.StructuredMessageLogHandler import StructuredMessageLogHandler
+from arelle.SystemInfo import PlatformOS, getSystemWordSize, hasFileSystem, hasWebServer, isCGI, isGAE
 from arelle.typing import TypeGetText
 from arelle.utils.PluginData import PluginData
+from arelle.utils.validate.Validation import Validation
+from arelle.WebCache import WebCache
 
 _: TypeGetText
 
@@ -60,7 +61,7 @@ def resourcesDir() -> str:
     # for python 3.2 remove __pycache__
     if _moduleDir.endswith("__pycache__"):
         _moduleDir = os.path.dirname(_moduleDir)
-    if (re.match(r".*[\\/](library|python{0.major}{0.minor}).zip[\\/]arelle$".format(sys.version_info),
+    if (regex.match(r".*[\\/](library|python{0.major}{0.minor}).zip[\\/]arelle$".format(sys.version_info),
                    _moduleDir)): # cx_Freexe uses library up to 3.4 and python35 after 3.5
         _resourcesDir = os.path.dirname(os.path.dirname(_moduleDir))
     else:
@@ -161,11 +162,12 @@ class Cntlr:
         disable_persistent_config: bool = False,
         betaFeatures: dict[str, bool] | None = None
     ) -> None:
+        self.logger = None
         if betaFeatures is None:
             betaFeatures = {}
         self.betaFeatures = {
             b: betaFeatures.get(b, False)
-            for b in BETA_FEATURES_AND_DESCRIPTIONS.keys()
+            for b in BETA_FEATURES_AND_DESCRIPTIONS
         }
         self.errorManager = None
         self.hasWin32gui = False
@@ -297,6 +299,11 @@ class Cntlr:
         self.startLogging(logFileName, logFileMode, logFileEncoding, logFormat)
         self.errorManager = ErrorManager(self.modelManager, logging._checkLevel("INCONSISTENCY")) # type: ignore[attr-defined]
 
+    def validation(self, val: Validation, fileSource: FileSource | None = None) -> None:
+        """Same as `error`, but parameters passed in from Validation object
+        """
+        self.error(codes=val.codes, msg=val.msg, level=val.level.name, fileSource=fileSource, **val.args)
+
     def error(self, codes: Any, msg: str, level: str = "ERROR", fileSource: FileSource | None = None, **args: Any) -> None:
         if self.logger is None or self.errorManager is None:
             self.addToLog(
@@ -434,11 +441,11 @@ class Cntlr:
 
     def setLogLevelFilter(self, logLevelFilter: str) -> None:
         if self.logger:
-            setattr(self.logger, "messageLevelFilter", re.compile(logLevelFilter) if logLevelFilter else None)
+            setattr(self.logger, "messageLevelFilter", regex.compile(logLevelFilter) if logLevelFilter else None)
 
     def setLogCodeFilter(self, logCodeFilter: str) -> None:
         if self.logger:
-            setattr(self.logger, "messageCodeFilter", re.compile(logCodeFilter) if logCodeFilter else None)
+            setattr(self.logger, "messageCodeFilter", regex.compile(logCodeFilter) if logCodeFilter else None)
 
     def addToLog(
         self,

arelle/CntlrCmdLine.py

@@ -51,14 +51,14 @@ from arelle.BetaFeatures import BETA_FEATURES_AND_DESCRIPTIONS
 from arelle.Locale import format_string, setApplicationLocale, setDisableRTL
 from arelle.ModelFormulaObject import FormulaOptions
 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.utils.EntryPointDetection import filesourceEntrypointFiles
+from arelle.utils.EntryPointDetection import parseEntrypointFileInput
 from arelle.ValidateXbrlDTS import ValidateBaseTaxonomiesMode
 from arelle.WebCache import proxyTuple
 
@@ -98,6 +98,38 @@ def parseAndRun(args):
     return cntlr
 
 
+PREPARSE_ARG_CONFIGS = frozenset([
+    (re.compile(r'^--plugins?.*$'), 'plugins'),
+    (re.compile(r'^--options(F|f)ile.*$'), 'optionsFile'),
+])
+
+
+def preparseArgs(args: list[str], parser: OptionParser) -> dict[str, str]:
+    """
+    Some command line arguments influence the actual parsing of other arguments.
+    This function pre-parses those arguments to allow for processing before full
+    argument parseing occurs.
+    :param args: Command line arguments
+    :param parser: OptionParser to report errors
+    :return: Dictionary of pre-parsed options
+    """
+    preparsedArgs = {}
+    for i, arg in enumerate(args):
+        for pattern, preparsedArg in PREPARSE_ARG_CONFIGS:
+            if pattern.fullmatch(arg):
+                __, sep, value = arg.partition('=')
+                if sep:  # --arg=value
+                    preparsedValue = value
+                elif i < len(args) - 1:  # --arg value
+                    preparsedValue = args[i+1]
+                else:  # --arg
+                    preparsedValue = ""
+                if preparsedArg in preparsedArgs:
+                    parser.error(_("Multiple '{}' values found during argument preparsing.").format(preparsedArg))
+                preparsedArgs[preparsedArg] = preparsedValue
+    return preparsedArgs
+
+
 def parseArgs(args):
     """
     Parses the command line arguments and generates runtimeOptions and arellePluginModules
@@ -412,24 +444,27 @@ def parseArgs(args):
     pluginOptionsIndex = len(parser.option_list)
     pluginOptionsGroupIndex = len(parser.option_groups)
 
+    preparsedArgs = preparseArgs(args, parser)
+
+    preloadPlugins = []
+    optionsFile = preparsedArgs.get('optionsFile')
+    optionsFileOptions = {}
+    if optionsFile:
+        optionsFileOptions = _parseOptionsFile(optionsFile, parser)
+        preloadPlugins.extend(optionsFileOptions.get('plugins', '').split('|'))
+
+    preloadPlugins.extend(preparsedArgs.get('plugins', '').split('|'))
+
     # install any dynamic plugins so their command line options can be parsed if present
     arellePluginModules = {}
-    for i, arg in enumerate(args):
-        if arg.startswith('--plugin'): # allow singular or plural (option must simply be non-ambiguous
-            if len(arg) > 9 and arg[9] == '=':
-                preloadPlugins = arg[10:]
-            elif i < len(args) - 1:
-                preloadPlugins = args[i+1]
-            else:
-                preloadPlugins = ""
-            for pluginCmd in preloadPlugins.split('|'):
-                cmd = pluginCmd.strip()
-                if cmd not in ("show", "temp") and len(cmd) > 0 and cmd[0] not in ('-', '~', '+'):
-                    moduleInfo = PluginManager.addPluginModule(cmd)
-                    if moduleInfo:
-                        arellePluginModules[cmd] = moduleInfo
-                        PluginManager.reset()
-            break
+    for pluginCmd in preloadPlugins:
+        cmd = pluginCmd.strip()
+        if cmd not in ("show", "temp") and len(cmd) > 0 and cmd[0] not in ('-', '~', '+'):
+            moduleInfo = PluginManager.addPluginModule(cmd)
+            if moduleInfo:
+                arellePluginModules[cmd] = moduleInfo
+                PluginManager.reset()
+
     # add plug-in options
     for optionsExtender in PluginManager.pluginClassMethods("CntlrCmdLine.Options"):
         optionsExtender(parser)
@@ -440,6 +475,10 @@ def parseArgs(args):
                       help=_("Show product version, copyright, and license."))
     parser.add_option("--diagnostics", action="store_true", dest="diagnostics",
                       help=_("output system diagnostics information"))
+    parser.add_option("--optionsFile", "--optionsfile",
+                      action="store", dest="optionsFile",
+                      help=_("Provide a path to a JSON file containing runtime options. "
+                             "These options will be overridden by any command line options provided."))
 
     if not args and isGAE():
         args = ["--webserver=::gae"]
@@ -518,9 +557,22 @@ def parseArgs(args):
     for optGroup in parser.option_groups[pluginOptionsGroupIndex:pluginLastOptionsGroupIndex]:
         for groupOption in optGroup.option_list:
             pluginOptionDestinations.add(groupOption.dest)
+
     baseOptions = {}
-    pluginOptions = {}
+    # Collect options from options file
+    for optionName, optionValue in optionsFileOptions.items():
+        if not hasattr(RuntimeOptions, optionName) and optionName not in pluginOptionDestinations:
+            parser.error(_("Unexpected name '{}' found in options file.").format(optionName))
+            continue
+        baseOptions[optionName] = optionValue
+    # Collect options from command line
     for optionName, optionValue in vars(options).items():
+        if optionName not in baseOptions or optionValue is not None:
+            baseOptions[optionName] = optionValue
+
+    pluginOptions = {}
+    finalOptions = {} # Validated options for RuntimeOptions
+    for optionName, optionValue in baseOptions.items():
         if optionName in pluginOptionDestinations:
             pluginOptions[optionName] = optionValue
         else:
@@ -532,9 +584,10 @@ def parseArgs(args):
                         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
+            if optionValue is not None or optionName not in finalOptions:
+                finalOptions[optionName] = optionValue
     try:
-        runtimeOptions = RuntimeOptions(pluginOptions=pluginOptions, **baseOptions)
+        runtimeOptions = RuntimeOptions(pluginOptions=pluginOptions, **finalOptions)
     except RuntimeOptionsException as e:
         parser.error(f"{e}, please try\n python CntlrCmdLine.py --help")
     if (
@@ -620,7 +673,33 @@ class ParserForDynamicPlugins:
 
 
 def _pluginHasCliOptions(moduleInfo):
-    return "CntlrCmdLine.Options" in moduleInfo["classMethods"]
+    if "CntlrCmdLine.Options" in moduleInfo["classMethods"]:
+        return True
+    if imports := moduleInfo.get("imports"):
+        return any(_pluginHasCliOptions(importedModule) for importedModule in imports)
+    return False
+
+
+def _parseOptionsFile(optionsFile: str, parser: OptionParser) -> dict:
+    """
+    Parse the JSON options within the provided filepath.
+    :param optionsFile: The path to the JSON options file.
+    :param parser: The parser to log an error to if needed.
+    :return: The parsed options as a dictionary.
+    """
+    try:
+        with open(optionsFile) as f:
+            jsonOptions = json.load(f)
+    except OSError:
+        parser.error(_("Options file path does not exist: {}").format(optionsFile))
+        return {}
+    except Exception as e:
+        parser.error(_("Unable to parse options JSON file: {}").format(e))
+        return {}
+    if not isinstance(jsonOptions, dict):
+        parser.error(_("Options JSON file must contain a JSON object at its root."))
+        return {}
+    return jsonOptions
 
 
 class CntlrCmdLine(Cntlr.Cntlr):
@@ -823,6 +902,9 @@ 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)
@@ -947,6 +1029,7 @@ class CntlrCmdLine(Cntlr.Cntlr):
         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
@@ -974,44 +1057,19 @@ class CntlrCmdLine(Cntlr.Cntlr):
             if not (options.entrypointFile or sourceZipStream):
                 return True # success
 
+        entrypointParseResult = parseEntrypointFileInput(self, options.entrypointFile, sourceZipStream)
+        if not entrypointParseResult.success:
+            return False
+        filesource = entrypointParseResult.filesource
+        _entrypointFiles = entrypointParseResult.entrypointFiles
         success = True
-        # entrypointFile may be absent (if input is a POSTED zip or file name ending in .zip)
-        #    or may be a | separated set of file names
-        _entryPoints = []
-        _checkIfXmlIsEis = self.modelManager.disclosureSystem and self.modelManager.disclosureSystem.validationType == "EFM"
-        if options.entrypointFile:
-            _f = options.entrypointFile
-            try: # may be a json list
-                _entryPoints = json.loads(_f)
-                _checkIfXmlIsEis = False # json entry objects never specify an xml EIS archive
-            except ValueError as e:
-                # is it malformed json?
-                if _f.startswith("[{") or _f.endswith("]}") or '"file:"' in _f:
-                    self.addToLog(_("File name parameter appears to be malformed JSON: {}\n{}").format(e, _f),
-                                  messageCode="FileNameFormatError",
-                                  level=logging.ERROR)
-                    success = False
-                else: # try as file names separated by '|'
-                    for f in (_f or '').split('|'):
-                        if not sourceZipStream and not isHttpUrl(f) and not os.path.isabs(f):
-                            f = os.path.normpath(os.path.join(os.getcwd(), f)) # make absolute normed path
-                        _entryPoints.append({"file":f})
-        filesource = None # file source for all instances if not None
-        if sourceZipStream:
-            filesource = FileSource.openFileSource(None, self, sourceZipStream)
-        elif len(_entryPoints) == 1 and "file" in _entryPoints[0]: # check if an archive and need to discover entry points (and not IXDS)
-            entryPath = PackageManager.mappedUrl(_entryPoints[0]["file"])
-            filesource = FileSource.openFileSource(entryPath, self, checkIfXmlIsEis=_checkIfXmlIsEis)
-        _entrypointFiles = _entryPoints
-        if filesource and not filesource.selection and not (sourceZipStream and len(_entrypointFiles) > 0):
-            try:
-                filesourceEntrypointFiles(filesource, _entrypointFiles)
-            except Exception as err:
-                self.addToLog(str(err), messageCode="error", level=logging.ERROR)
-                return False
 
         for pluginXbrlMethod in PluginManager.pluginClassMethods("CntlrCmdLine.Filing.Start"):
             pluginXbrlMethod(self, options, filesource, _entrypointFiles, sourceZipStream=sourceZipStream, responseZipStream=responseZipStream)
+
+        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)
@@ -1027,6 +1085,8 @@ class CntlrCmdLine(Cntlr.Cntlr):
             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()
@@ -1239,6 +1299,11 @@ class CntlrCmdLine(Cntlr.Cntlr):
                         self.modelManager.close(modelDiffReport)
                     elif modelXbrl:
                         self.modelManager.close(modelXbrl)
+
+        if options.validate:
+            for pluginXbrlMethod in PluginManager.pluginClassMethods("Validate.Complete"):
+                pluginXbrlMethod(self, filesource)
+
         if filesource is not None and not options.keepOpen:
             # Archive filesource potentially used by multiple reports may still be open.
             filesource.close()

arelle/CntlrWinMain.py

@@ -5,65 +5,110 @@ See COPYRIGHT.md for copyright information.
 '''
 from __future__ import annotations
 
-from arelle import ValidateDuplicateFacts
-import os, sys, subprocess, pickle, time, locale, fnmatch, platform, webbrowser
+import fnmatch
+import os
+import pickle
+import platform
+import subprocess
+import sys
+import time
+import webbrowser
+from typing import Any
+
 import regex as re
 
+from arelle import UrlUtil, ValidateDuplicateFacts
+from arelle.ValidateFileSource import ValidateFileSource
 from arelle.logging.formatters.LogFormatter import logRefsFileLines
+from arelle.utils.EntryPointDetection import parseEntrypointFileInput
 
 if sys.platform == 'win32' and getattr(sys, 'frozen', False):
     # need the .dll directory in path to be able to access Tk and Tcl DLLs efore importinng Tk, etc.
     os.environ['PATH'] = os.path.dirname(sys.executable) + ";" + os.environ['PATH']
 
-from tkinter import (Tk, Tcl, TclError, Toplevel, Menu, PhotoImage, StringVar, BooleanVar, IntVar, N, S, E, W, EW,
-                     HORIZONTAL, VERTICAL, END, font as tkFont)
+from tkinter import (
+    END,
+    EW,
+    HORIZONTAL,
+    VERTICAL,
+    BooleanVar,
+    E,
+    IntVar,
+    Menu,
+    N,
+    PhotoImage,
+    S,
+    StringVar,
+    Tcl,
+    TclError,
+    Tk,
+    W,
+)
+from tkinter import font as tkFont
+
 try:
-    from tkinter.ttk import Frame, Button, Label, Combobox, Separator, PanedWindow, Notebook
+    from tkinter.ttk import Button, Combobox, Frame, Label, Notebook, PanedWindow, Separator
 except ImportError:  # 3.0 versions of tkinter
-    from ttk import Frame, Button, Label, Combobox, Separator, PanedWindow, Notebook
+    from ttk import Button, Combobox, Frame, Label, Notebook, PanedWindow, Separator
 try:
     import syslog
 except ImportError:
     syslog = None
+
+import logging
+import multiprocessing
+import queue
+import threading
 import tkinter.filedialog
-import tkinter.messagebox, traceback
+import tkinter.messagebox
 import tkinter.simpledialog
-from arelle.Locale import format_string, setApplicationLocale
+import traceback
+
+from arelle import (
+    Cntlr,
+    DialogLanguage,
+    DialogPackageManager,
+    DialogPluginManager,
+    DialogURL,
+    ModelDocument,
+    PackageManager,
+    TableStructure,
+    Updater,
+    ViewFileConcepts,
+    ViewFileDTS,
+    ViewFileFactList,
+    ViewFileFactTable,
+    ViewFileFormulae,
+    ViewFileRelationshipSet,
+    ViewFileRoleTypes,
+    ViewFileTests,
+    ViewWinConcepts,
+    ViewWinDTS,
+    ViewWinFactList,
+    ViewWinFactTable,
+    ViewWinFormulae,
+    ViewWinProperties,
+    ViewWinRelationshipSet,
+    ViewWinRenderedGrid,
+    ViewWinRoleTypes,
+    ViewWinRssFeed,
+    ViewWinTests,
+    ViewWinTree,
+    ViewWinVersReport,
+    ViewWinXml,
+    XbrlConst,
+)
 from arelle.CntlrWinTooltip import ToolTip
-from arelle import XbrlConst
+from arelle.FileSource import openFileSource
+from arelle.Locale import format_string, setApplicationLocale
+from arelle.ModelFormulaObject import FormulaOptions
+from arelle.oim.xml.Save import saveOimReportToXmlInstance
 from arelle.PluginManager import pluginClassMethods
+from arelle.rendering import RenderingEvaluator
 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
-import multiprocessing
-
-import threading, queue
-
-from arelle import Cntlr
-from arelle import (DialogURL, DialogLanguage,
-                    DialogPluginManager, DialogPackageManager,
-                    ModelDocument,
-                    ModelManager,
-                    PackageManager,
-                    TableStructure,
-                    ViewWinDTS,
-                    ViewWinProperties, ViewWinConcepts, ViewWinRelationshipSet, ViewWinFormulae,
-                    ViewWinFactList, ViewFileFactList, ViewWinFactTable, ViewWinRenderedGrid, ViewWinXml,
-                    ViewWinRoleTypes, ViewFileRoleTypes, ViewFileConcepts,
-                    ViewWinTests, ViewWinTree, ViewWinVersReport, ViewWinRssFeed,
-                    ViewFileDTS,
-                    ViewFileFactTable,
-                    ViewFileFormulae,
-                    ViewFileTests,
-                    ViewFileRelationshipSet,
-                    Updater
-                   )
-from arelle.ModelFormulaObject import FormulaOptions
-from arelle.FileSource import openFileSource
-from arelle.rendering import RenderingEvaluator
 
 restartMain = True
 
@@ -816,15 +861,25 @@ class CntlrWinMain (Cntlr.Cntlr):
         if filename:
             for xbrlLoadedMethod in pluginClassMethods("CntlrWinMain.Xbrl.Open"):
                 filename = xbrlLoadedMethod(self, filename) # runs in GUI thread, allows mapping filename, mult return filename
-            filesource = None
+            entrypointParseResult = parseEntrypointFileInput(self, filename, fallbackSelect=False)
+            if not entrypointParseResult.success or entrypointParseResult.filesource is None:
+                return
+            filesource = entrypointParseResult.filesource
+            entrypointFiles = entrypointParseResult.entrypointFiles
             # check for archive files
-            filesource = openFileSource(filename, self,
-                                        checkIfXmlIsEis=self.modelManager.disclosureSystem and
-                                        self.modelManager.disclosureSystem.validationType == "EFM")
             if filesource.isArchive:
-                if not filesource.selection and not filesource.isReportPackage: # or filesource.isRss:
+                filenameWithoutFakeIxdsPrefix = UrlUtil.stripIxdsSurrogatePrefix(filename)
+                if all(e.get("file") == filenameWithoutFakeIxdsPrefix for e in entrypointFiles):
+                    entrypointFiles = []
+                if (
+                    len(entrypointFiles) == 0 and
+                    not filesource.selection and
+                    not filesource.isReportPackage
+                ):
                     from arelle import DialogOpenArchive
                     filename = DialogOpenArchive.askArchiveFile(self, filesource)
+                    if filename is not None:
+                        entrypointFiles.append({"file": filename})
                     if filename and filesource.basefile and not isHttpUrl(filesource.basefile):
                         self.config["fileOpenDir"] = os.path.dirname(filesource.baseurl)
                 filesource.loadTaxonomyPackageMappings() # if a package, load mappings if not loaded yet
@@ -837,7 +892,7 @@ class CntlrWinMain (Cntlr.Cntlr):
                 self.updateFileHistory(filename, importToDTS)
             elif len(filename) == 1:
                 self.updateFileHistory(filename[0], importToDTS)
-            thread = threading.Thread(target=self.backgroundLoadXbrl, args=(filesource,importToDTS,selectTopView), daemon=True).start()
+            thread = threading.Thread(target=self.backgroundLoadXbrl, args=(filesource,entrypointFiles,importToDTS,selectTopView), daemon=True).start()
 
     def webOpen(self, *ignore):
         if not self.okayToContinue():
@@ -848,12 +903,24 @@ class CntlrWinMain (Cntlr.Cntlr):
             self.updateFileHistory(url, False)
             for xbrlLoadedMethod in pluginClassMethods("CntlrWinMain.Xbrl.Open"):
                 url = xbrlLoadedMethod(self, url) # runs in GUI thread, allows mapping url, mult return url
-            filesource = openFileSource(url,self)
-            if filesource.isArchive and not filesource.isReportPackage and not filesource.selection: # or filesource.isRss:
-                from arelle import DialogOpenArchive
-                url = DialogOpenArchive.askArchiveFile(self, filesource)
-                self.updateFileHistory(url, False)
-            thread = threading.Thread(target=self.backgroundLoadXbrl, args=(filesource,False,False), daemon=True).start()
+            entrypointParseResult = parseEntrypointFileInput(self, url, fallbackSelect=False)
+            if not entrypointParseResult.success or entrypointParseResult.filesource is None:
+                return
+            filesource = entrypointParseResult.filesource
+            entrypointFiles = entrypointParseResult.entrypointFiles
+            if filesource.isArchive:
+                if (
+                        len(entrypointFiles) == 0 and
+                        not filesource.selection and
+                        not filesource.isReportPackage
+                ):
+                    from arelle import DialogOpenArchive
+                    url = DialogOpenArchive.askArchiveFile(self, filesource)
+                    if url is not None:
+                        entrypointFiles.append({"file": url})
+                    self.updateFileHistory(url, False)
+                filesource.loadTaxonomyPackageMappings()
+            thread = threading.Thread(target=self.backgroundLoadXbrl, args=(filesource,entrypointFiles,False,False), daemon=True).start()
 
     def importWebOpen(self, *ignore):
         if not self.modelManager.modelXbrl or self.modelManager.modelXbrl.modelDocument.type not in (
@@ -867,36 +934,37 @@ class CntlrWinMain (Cntlr.Cntlr):
             self.fileOpenFile(url, importToDTS=True)
 
 
-    def backgroundLoadXbrl(self, filesource, importToDTS, selectTopView):
+    def backgroundLoadXbrl(self, filesource, entrypointFiles: list[dict[str, Any]], importToDTS, selectTopView):
         startedAt = time.time()
         loadedModels = []
         try:
-            if importToDTS:
-                action = _("imported")
-                profileStat = "import"
-                modelXbrl = self.modelManager.modelXbrl
-                if modelXbrl:
-                    ModelDocument.load(modelXbrl, filesource.url, isSupplemental=importToDTS)
-                    modelXbrl.relationshipSets.clear() # relationships have to be re-cached
-                    loadedModels.append(modelXbrl)
-            else:
-                action = _("loaded")
-                profileStat = "load"
-                if (reportPackage := filesource.reportPackage) and "_IXDS#?#" not in filesource.url:
-                    for report in reportPackage.reports or []:
-                        if len(report.fullPathFiles) > 1:
-                            self.addToLog(_("Loading error. Inline document set encountered. Enable 'Inline XBRL Document Set' plug-in and use the Open Inline Doc Set dialog from the file menu to open this filing: {0}").format(filesource.url))
-                            continue
-                        filesource.select(report.fullPathPrimary)
-                        modelXbrl = self.modelManager.load(filesource, _("views loading"))
-                        if modelXbrl:
-                            loadedModels.append(modelXbrl)
+            action = _("preparing entrypoints")
+            for pluginXbrlMethod in pluginClassMethods("CntlrWinMain.Filing.Start"):
+                pluginXbrlMethod(self, filesource, entrypointFiles)
+            for entrypoint in entrypointFiles:
+                entrypointFile = entrypoint.get("file", None) if isinstance(entrypoint,dict) else entrypoint
+                if filesource and filesource.isArchive:
+                    filesource.select(entrypointFile)
                 else:
+                    entrypointFile = PackageManager.mappedUrl(entrypointFile)
+                    filesource = openFileSource(entrypointFile, self)
+                if importToDTS:
+                    action = _("imported")
+                    profileStat = "import"
+                    modelXbrl = self.modelManager.modelXbrl
+                    if modelXbrl:
+                        ModelDocument.load(modelXbrl, filesource.url, isSupplemental=importToDTS)
+                        modelXbrl.relationshipSets.clear() # relationships have to be re-cached
+                        loadedModels.append(modelXbrl)
+                else:
+                    action = _("loaded")
+                    profileStat = "load"
                     modelXbrl = self.modelManager.load(
                         filesource,
                         _("views loading"),
                         # check modified time if GUI-loading from web
                         checkModifiedTime=isHttpUrl(filesource.url),
+                        entrypoint=entrypoint,
                     )
                     if modelXbrl:
                         loadedModels.append(modelXbrl)
@@ -1135,12 +1203,17 @@ class CntlrWinMain (Cntlr.Cntlr):
 
     def backgroundValidate(self):
         from arelle import Validate
+        validatedFileSources = set()
         for loadedModelXbrl in self.modelManager.loadedModelXbrls:
             if loadedModelXbrl.modelDocument:
                 startedAt = time.time()
                 if loadedModelXbrl.modelDocument.type in ModelDocument.Type.TESTCASETYPES:
                     for pluginXbrlMethod in pluginClassMethods("Testcases.Start"):
                         pluginXbrlMethod(self, None, loadedModelXbrl)
+                if loadedModelXbrl.fileSource not in validatedFileSources:
+                    validatedFileSources.add(loadedModelXbrl.fileSource)
+                    ValidateFileSource(self, loadedModelXbrl.fileSource).validate(self.modelManager.validateAllFilesAsReportPackages)
+
                 for modelXbrl in [loadedModelXbrl] + getattr(loadedModelXbrl, "supplementalModelXbrls", []):
                     priorOutputInstance = modelXbrl.formulaOutputInstance
                     modelXbrl.formulaOutputInstance = None # prevent closing on background thread by validateFormula