arelle-release 2.37.71__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

@@ -35,6 +35,7 @@ from arelle.logging.handlers.StructuredMessageLogHandler import StructuredMessag
 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
@@ -166,7 +167,7 @@ class Cntlr:
             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
@@ -298,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(

arelle/CntlrCmdLine.py

@@ -11,6 +11,7 @@ import datetime
 import fnmatch
 import gettext
 import glob
+import json
 import logging
 import multiprocessing
 import os
@@ -97,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
@@ -411,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)
@@ -439,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"]
@@ -517,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:
@@ -531,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 (
@@ -626,6 +680,28 @@ def _pluginHasCliOptions(moduleInfo):
     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):
     """
     .. class:: CntlrCmdLin()

arelle/CntlrWinMain.py

@@ -17,7 +17,7 @@ from typing import Any
 
 import regex as re
 
-from arelle import ValidateDuplicateFacts
+from arelle import UrlUtil, ValidateDuplicateFacts
 from arelle.ValidateFileSource import ValidateFileSource
 from arelle.logging.formatters.LogFormatter import logRefsFileLines
 from arelle.utils.EntryPointDetection import parseEntrypointFileInput
@@ -868,6 +868,9 @@ class CntlrWinMain (Cntlr.Cntlr):
             entrypointFiles = entrypointParseResult.entrypointFiles
             # check for archive files
             if filesource.isArchive:
+                filenameWithoutFakeIxdsPrefix = UrlUtil.stripIxdsSurrogatePrefix(filename)
+                if all(e.get("file") == filenameWithoutFakeIxdsPrefix for e in entrypointFiles):
+                    entrypointFiles = []
                 if (
                     len(entrypointFiles) == 0 and
                     not filesource.selection and

arelle/DialogFind.py

@@ -186,7 +186,7 @@ class DialogFind(Toplevel):
         else:
             if not self.modelManager.modelXbrl or not docType in (
                  ModelDocument.Type.SCHEMA, ModelDocument.Type.LINKBASE, ModelDocument.Type.INSTANCE, ModelDocument.Type.INLINEXBRL,
-                 ModelDocument.Type.RSSFEED):
+                 ModelDocument.Type.RSSFEED, ModelDocument.Type.INLINEXBRLDOCUMENTSET):
                 messagebox.showerror(_("Find cannot be completed"),
                          _("Find requires an opened DTS or RSS Feed"), parent=self.parent)
                 return

arelle/ModelDtsObject.py

@@ -2015,6 +2015,7 @@ class ModelRelationship(ModelObject):
     @property
     def equivalenceHash(self): # not exact, use equivalenceKey if hashes are the same
         return hash((self.qname,
+                     self.arcrole,
                      self.linkQname,
                      self.linkrole,  # needed when linkrole=None merges multiple links
                      self.fromModelObject.objectIndex if isinstance(self.fromModelObject, ModelObject) else -1,
@@ -2028,6 +2029,7 @@ class ModelRelationship(ModelObject):
         """(tuple) -- Key to determine relationship equivalence per 2.1 spec"""
         # cannot be cached because this is unique per relationship
         return (self.qname,
+                self.arcrole,
                 self.linkQname,
                 self.linkrole,  # needed when linkrole=None merges multiple links
                 self.fromModelObject.objectIndex if isinstance(self.fromModelObject, ModelObject) else -1,

arelle/ModelObject.py

@@ -8,7 +8,6 @@ from lxml import etree
 from arelle import Locale
 from arelle import ModelValue
 from arelle.XmlValidateConst import VALID_NO_CONTENT
-from arelle.model import CommentBase, ElementBase, PIBase
 
 if TYPE_CHECKING:
     from arelle.ModelDocument import ModelDocument
@@ -21,7 +20,7 @@ if TYPE_CHECKING:
     from arelle.ModelInstanceObject import ModelInlineFootnote
     from arelle.ModelInstanceObject import ModelInlineFact
     from arelle.ModelInstanceObject import ModelDimensionValue
-    from arelle.ModelValue import qname, qnameEltPfxName, QName, TypeSValue, TypeXValue
+    from arelle.ModelValue import QName, TypeSValue, TypeXValue
 
 XmlUtil: Any = None
 
@@ -32,7 +31,7 @@ def init() -> None: # init globals
     if XmlUtil is None:
         from arelle import XmlUtil
 
-class ModelObject(ElementBase):
+class ModelObject(etree.ElementBase):
     """ModelObjects represent the XML elements within a document, and are implemented as custom
     lxml proxy objects.  Each modelDocument has a parser with the parser objects in ModelObjectFactory.py,
     to determine the type of model object to correspond to a proxied lxml XML element.
@@ -117,6 +116,7 @@ class ModelObject(ElementBase):
     xValueError: Exception | None
     xValid: int
     xlinkLabel: str
+    tag: str
     targetModelXbrl: ModelXbrl
 
     def _init(self) -> None:
@@ -125,9 +125,9 @@ class ModelObject(ElementBase):
         if parent is not None and hasattr(parent, "modelDocument"):
             self.init(parent.modelDocument)
 
-    def clear(self) -> None:
+    def clear(self, keep_tail: bool = False) -> None:
         self.__dict__.clear()  # delete local attributes
-        super(ModelObject, self).clear()  # delete children
+        super().clear(keep_tail)  # delete children
 
     def init(self, modelDocument: ModelDocument) -> None:
         self.modelDocument = modelDocument
@@ -160,9 +160,10 @@ class ModelObject(ElementBase):
         return emptySet
 
     def setNamespaceLocalName(self) -> None:
-        ns, sep, self._localName = self.tag.rpartition("}")
+        tag = self.tag
+        ns, sep, self._localName = tag.rpartition("}")
         if sep:
-            self._namespaceURI = ns[1:]
+            self._namespaceURI: str | None = ns[1:]
         else:
             self._namespaceURI = None
         if self.prefix:
@@ -257,7 +258,7 @@ class ModelObject(ElementBase):
             return self._parentQname
         except AttributeError:
             parentObj = self.getparent()
-            self._parentQname = parentObj.elementQname if parentObj is not None else None  # type: ignore[attr-defined]
+            self._parentQname = parentObj.elementQname if parentObj is not None else None
             return self._parentQname
 
 
@@ -267,18 +268,18 @@ class ModelObject(ElementBase):
 
     @property
     def stringValue(self) -> str:    # "string value" of node, text of all Element descendants
-        return ''.join(self._textNodes(recurse=True))  # return text of Element descendants
+        return ''.join(self.textNodes(recurse=True))  # return text of Element descendants
 
     @property
     def textValue(self) -> str:  # xml axis text() differs from string value, no descendant element text
-        return ''.join(self._textNodes())  # no text nodes returns ''
+        return ''.join(self.textNodes())  # no text nodes returns ''
 
-    def _textNodes(self, recurse:bool = False) ->  Generator[str | Any, None, None]:
+    def textNodes(self, recurse:bool = False) ->  Generator[str | Any, None, None]:
         if self.text and getattr(self,"xValid", 0) != VALID_NO_CONTENT: # skip tuple whitespaces
                 yield self.text
         for c in self.iterchildren():
             if recurse and isinstance(c, ModelObject):
-                for nestedText in c._textNodes(recurse):
+                for nestedText in c.textNodes(recurse):
                     yield nestedText
             if c.tail and getattr(self,"xValid", 0) != VALID_NO_CONTENT: # skip tuple whitespaces
                 yield c.tail  # get tail of nested element, comment or processor nodes
@@ -305,10 +306,7 @@ class ModelObject(ElementBase):
 
     @property
     def elementAttributesStr(self) -> str:
-        # Note 2022-09-09:
-        # Mypy raises the following error. Not sure why this is the case, this returns a str not binary data?
-        # On Python 3 formatting "b'abc'" with "{}" produces "b'abc'", not "abc"; use "{!r}" if this is desired behavior
-        return ', '.join(["{0}='{1}'".format(name, value) for name, value in self.items()]) # type: ignore[str-bytes-safe]
+        return ', '.join(["{0}='{1}'".format(name, value) for name, value in self.items()])
 
     def resolveUri(
         self,
@@ -398,7 +396,7 @@ class ModelObject(ElementBase):
     def __repr__(self) -> str:
         return ("{0}[{1}, {2} line {3})".format(type(self).__name__, self.objectIndex, self.modelDocument.basename, self.sourceline))
 
-class ModelComment(CommentBase): # type: ignore[misc]
+class ModelComment(etree.CommentBase):
     """ModelConcept is a custom proxy objects for etree.
     """
     def _init(self) -> None:
@@ -410,7 +408,7 @@ class ModelComment(CommentBase): # type: ignore[misc]
     def init(self, modelDocument: ModelDocument) -> None:
         self.modelDocument = modelDocument
 
-class ModelProcessingInstruction(PIBase): # type: ignore[misc]
+class ModelProcessingInstruction(etree.PIBase):
     """ModelProcessingInstruction is a custom proxy object for etree.
     """
     def _init(self) -> None:

arelle/ModelObjectFactory.py

@@ -4,7 +4,7 @@ See COPYRIGHT.md for copyright information.
 from __future__ import annotations
 
 from arelle.ModelObject import ModelObject, init as moduleObject_init
-from typing import Any, Optional, TYPE_CHECKING, Type
+from typing import Any, cast, Optional, TYPE_CHECKING, Type
 
 if TYPE_CHECKING:
     from arelle.ModelValue import QName
@@ -45,18 +45,18 @@ def parser(
         modelXbrl: ModelXbrl,
         baseUrl: str | None,
         target: None = None
-) -> tuple[etree.XMLParser, KnownNamespacesModelObjectClassLookup, DiscoveringClassLookup]:
+) -> tuple[etree.XMLParser[etree._Element], KnownNamespacesModelObjectClassLookup, DiscoveringClassLookup]:
     moduleObject_init()  # init ModelObject globals
-    _parser = etree.XMLParser(recover=True, huge_tree=True, target=target,
-                              resolve_entities=False)
+    _parser = etree.XMLParser(recover=True, huge_tree=True, target=target,  # type: ignore[call-overload]
+                               resolve_entities=False)
     return setParserElementClassLookup(_parser, modelXbrl, baseUrl)
 
 
 def setParserElementClassLookup(
-        _parser: etree.XMLParser,
+        _parser: etree.XMLParser[etree._Element],
         modelXbrl: ModelXbrl,
         baseUrl: str | None = None,
-) -> tuple[etree.XMLParser, KnownNamespacesModelObjectClassLookup, DiscoveringClassLookup]:
+) -> tuple[etree.XMLParser[etree._Element], KnownNamespacesModelObjectClassLookup, DiscoveringClassLookup]:
     classLookup = DiscoveringClassLookup(modelXbrl, baseUrl)
     nsNameLookup = KnownNamespacesModelObjectClassLookup(modelXbrl, fallback=classLookup)
     _parser.set_element_class_lookup(nsNameLookup)
@@ -91,9 +91,10 @@ class KnownNamespacesModelObjectClassLookup(etree.CustomElementClassLookup):
         self.modelXbrl = modelXbrl
         self.type: int | None = None
 
-    def lookup(self, node_type: str, document: etree._Document, ns: str | None, ln: str) -> Type[etree.ElementBase] | None:
+    def lookup(self, node_type: str, document: object, ns: str | None, ln: str | None) -> type[etree._Element] | None:
         # node_type is "element", "comment", "PI", or "entity"
         if node_type == "element":
+            assert ln is not None, "element nodes must have a local name"
             if ns == XbrlConst.xsd:
                 if self.type is None:
                     self.type = SCHEMA
@@ -160,14 +161,14 @@ class KnownNamespacesModelObjectClassLookup(etree.CustomElementClassLookup):
 
             return ModelComment
         elif node_type == "PI":
-            return etree.PIBase  # type: ignore[no-any-return]
+            return etree.PIBase
         elif node_type == "entity":
-            return etree.EntityBase  # type: ignore[no-any-return]
+            return etree.EntityBase
         # returning None delegates to fallback lookup classes
         return None
 
 
-class DiscoveringClassLookup(etree.PythonElementClassLookup):  # type: ignore[misc]
+class DiscoveringClassLookup(etree.PythonElementClassLookup):
     def __init__(self, modelXbrl: ModelXbrl, baseUrl: str | None, fallback: etree.ElementClassLookup | None = None) -> None:
         super(DiscoveringClassLookup, self).__init__(fallback)
         self.modelXbrl = modelXbrl
@@ -180,10 +181,11 @@ class DiscoveringClassLookup(etree.PythonElementClassLookup):  # type: ignore[mi
         if self.streamingOrSkipDTS and ModelFact is None:
             from arelle.ModelInstanceObject import ModelFact
 
-    def lookup(self, document: etree._Document, proxyElement: etree._Element) -> Type[ModelObject]:
+    def lookup(self, document: object, proxyElement: etree._Element) -> type[etree._Element] | None:
         # check if proxyElement's namespace is not known
         ns: str | None
-        ns, sep, ln = proxyElement.tag.partition("}")
+        tag = cast(str, proxyElement.tag)
+        ns, sep, ln = tag.partition("}")
         if sep:
             ns = ns[1:]
         else:
@@ -208,9 +210,9 @@ class DiscoveringClassLookup(etree.PythonElementClassLookup):  # type: ignore[mi
             # self.makeelementParentModelObject is set in streamingExtensions.py and ModelXbrl.createFact
             ancestor = proxyElement.getparent() or getattr(self.modelXbrl, "makeelementParentModelObject", None)
             while ancestor is not None:
-                tag = ancestor.tag  # not a modelObject yet, just parser prototype
-                if tag.startswith("{http://www.xbrl.org/2003/instance}") or tag.startswith("{http://www.xbrl.org/2003/linkbase}"):
-                    if tag == "{http://www.xbrl.org/2003/instance}xbrl":
+                ancestorTag = cast(str, ancestor.tag)  # not a modelObject yet, just parser prototype
+                if ancestorTag.startswith("{http://www.xbrl.org/2003/instance}") or ancestorTag.startswith("{http://www.xbrl.org/2003/linkbase}"):
+                    if ancestorTag == "{http://www.xbrl.org/2003/instance}xbrl":
                         # element not parented by context or footnoteLink
                         return ModelFact  # type: ignore[no-any-return]
                     else:

arelle/ModelXbrl.py

@@ -26,6 +26,7 @@ from arelle.UrlUtil import isHttpUrl
 from arelle.ValidateXbrlDimensions import isFactDimensionallyValid
 from arelle.XbrlConst import standardLabel
 from arelle.XbrlUtil import sEqual
+from arelle.utils.validate.Validation import Validation
 
 if TYPE_CHECKING:
     from datetime import date, datetime
@@ -603,7 +604,7 @@ class ModelXbrl:
                         all([cDim.isEqualTo(dims[cDimQn]) for cDimQn, cDim in c.qnameDims.items()]))) and
                  # OCCs match for either dimensional or non-dimensional modle
                  all(
-                   all([sEqual(self, cOCCs[i], mOCCs[i]) for i in range(len(mOCCs))])  # type: ignore[arg-type]
+                   all([sEqual(self, cOCCs[i], mOCCs[i]) for i in range(len(mOCCs))])
                      if len(cOCCs) == len(mOCCs) else False
                         for cOCCs,mOCCs in ((c.nonDimValues(segAspect),segOCCs),
                                             (c.nonDimValues(scenAspect),scenOCCs)))
@@ -1043,6 +1044,11 @@ class ModelXbrl:
         """@messageCatalog=[]"""
         self.log('WARNING', codes, msg, **args)
 
+    def validation(self, val: Validation) -> None:
+        """Same as log, but parameters passed in from Validation object
+        """
+        self.log(level=val.level.name, codes=val.codes, msg=val.msg, **val.args)
+
     def log(self, level: str, codes: Any, msg: str, **args: Any) -> None:
         """Same as error(), but level passed in as argument
         """

arelle/PluginManager.py

@@ -856,11 +856,7 @@ class EntryPointRef:
         Retrieve all installed plugin entry points.
         :return: List of all discovered entry points.
         """
-        entryPoints: list[EntryPoint]
-        if sys.version_info < (3, 10):
-            entryPoints = [e for e in entry_points().get('arelle.plugin', [])]
-        else:
-            entryPoints = list(entry_points(group='arelle.plugin'))
+        entryPoints = list(entry_points(group='arelle.plugin'))
         entryPointRefs = []
         for entryPoint in entryPoints:
             entryPointRef = EntryPointRef.fromEntryPoint(entryPoint)

arelle/RuntimeOptions.py

@@ -106,6 +106,7 @@ class RuntimeOptions:
     logXmlMaxAttributeLength: Optional[int] = None
     monitorParentProcess: Optional[bool] = None
     noCertificateCheck: Optional[bool] = None
+    optionsFile: Optional[str] = None
     outputAttribution: Optional[str] = None
     packageManifestName: Optional[str] = None
     packages: Optional[list[str]] = None

arelle/UrlUtil.py

@@ -12,6 +12,17 @@ from email.utils import parsedate
 from datetime import datetime
 from typing import overload
 
+IXDS_DOC_SEPARATOR = "#?#" # the files of the document set follow the "surrogate" with these separators
+IXDS_SURROGATE = f"_IXDS{IXDS_DOC_SEPARATOR}" # surrogate (fake) file name for inline XBRL doc set (IXDS)
+
+def stripIxdsSurrogatePrefix(path: str) -> str:
+    """If path contains IXDS surrogate prefix, strip it and return the rest."""
+    if path:
+        _, found, after = path.partition(IXDS_SURROGATE)
+        if found:
+            return after
+    return path
+
 def authority(url: str, includeScheme: bool=True) -> str:
     if url:
         authSep = url.find(':')

arelle/Validate.py

@@ -136,7 +136,7 @@ class Validate:
                     instance=self.modelXbrl.modelDocument.basename if hasattr(self.modelXbrl, "modelDocument") and hasattr(self.modelXbrl.modelDocument, "basename") else "(closed)",
                     error=err,
                     # traceback=traceback.format_tb(sys.exc_info()[2]),
-                    exc_info=(type(err) is not AssertionError))
+                    exc_info=True)
         self.close()
 
     def validateRssFeed(self):
@@ -489,7 +489,7 @@ class Validate:
                 except Exception as err:
                     model.error("exception:" + type(err).__name__,
                         _("Testcase variation validation exception: %(error)s, instance: %(instance)s"),
-                        modelXbrl=model, instance=model.modelDocument.basename, error=err, exc_info=(type(err) is not AssertionError))
+                        modelXbrl=model, instance=model.modelDocument.basename, error=err, exc_info=True)
                 model.hasFormulae = _hasFormulae
         for pluginXbrlMethod in pluginClassMethods("Validate.Complete"):
             pluginXbrlMethod(self.modelXbrl.modelManager.cntlr, filesource)
@@ -575,7 +575,7 @@ class Validate:
             except Exception as err:
                 modelXbrl.error("exception:" + type(err).__name__,
                     _("Testcase formula variation validation exception: %(error)s, instance: %(instance)s"),
-                    modelXbrl=modelXbrl, instance=modelXbrl.modelDocument.basename, error=err, exc_info=(type(err) is not AssertionError))
+                    modelXbrl=modelXbrl, instance=modelXbrl.modelDocument.basename, error=err, exc_info=True)
         if modelTestcaseVariation.resultIsInfoset and self.modelXbrl.modelManager.validateInfoset:
             for pluginXbrlMethod in pluginClassMethods("Validate.Infoset"):
                 pluginXbrlMethod(modelXbrl, modelTestcaseVariation.resultInfosetUri)

arelle/ValidateXbrl.py

@@ -428,7 +428,8 @@ class ValidateXbrl:
 
         if self.validateCalcs:
             modelXbrl.modelManager.showStatus(_("Validating instance calculations"))
-            ValidateXbrlCalcs.validate(modelXbrl, self.validateCalcs)
+            for val in ValidateXbrlCalcs.validate(modelXbrl, self.validateCalcs):
+                modelXbrl.validation(val)
             modelXbrl.profileStat(_("validateCalculations"))
 
         if self.validateUTR: