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

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)
@@ -68,6 +68,22 @@ LINKBASE = 2
 VERSIONINGREPORT = 3
 RSSFEED = 4
 
+LINK_LOCALNAME_TO_MODEL_CLASS = {
+    'loc': ModelLocator,
+    'label': ModelResource,
+    'reference': ModelResource,
+    'roleType': ModelRoleType,
+    'arcroleType': ModelRoleType,
+} | {
+    q.localName: ModelObject
+    for q in [
+        XbrlConst.qnLinkCalculationArc,
+        XbrlConst.qnLinkDefinitionArc,
+        XbrlConst.qnLinkPresentationArc,
+        XbrlConst.qnLinkReferenceArc,
+    ]
+}
+
 
 class KnownNamespacesModelObjectClassLookup(etree.CustomElementClassLookup):
     def __init__(self, modelXbrl: ModelXbrl, fallback: etree.ElementClassLookup | None = None) -> None:
@@ -75,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
@@ -106,8 +123,8 @@ class KnownNamespacesModelObjectClassLookup(etree.CustomElementClassLookup):
             elif ns == XbrlConst.link:
                 if self.type is None:
                     self.type = LINKBASE
-                if ln == "roleType" or ln == "arcroleType":
-                    return ModelRoleType
+                if modelObjectClass := LINK_LOCALNAME_TO_MODEL_CLASS.get(ln):
+                    return modelObjectClass
             elif ns == "http://edgar/2009/conformance":
                 # don't force loading of test schema
                 if ln == "variation":
@@ -144,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
@@ -164,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:
@@ -192,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

@@ -12,7 +12,7 @@ from collections import defaultdict
 from typing import TYPE_CHECKING, Any, TypeVar, Union, cast, Optional
 
 import regex as re
-from collections.abc import Iterable
+from collections.abc import Iterable, Iterator
 
 import arelle
 from arelle import FileSource, ModelRelationshipSet, XmlUtil, ModelValue, XbrlConst, XmlValidate
@@ -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
@@ -335,8 +336,12 @@ class ModelXbrl:
         self.facts: list[ModelFact] = []
         self.factsInInstance: set[ModelFact] = set()
         self.undefinedFacts: list[ModelFact] = []  # elements presumed to be facts but not defined
-        self.contexts: dict[str, ModelDocumentClass.xmlRootElement] = {}
+        self.contexts: dict[str, ModelContext] = {}
+        self.ixdsUnmappedContexts: dict[str, ModelContext] = {}
+        self._contextsInUseMarked = False
         self.units: dict[str, ModelUnit] = {}
+        self.ixdsUnmappedUnits: dict[str, ModelUnit] = {}
+        self._unitsInUseMarked = False
         self.modelObjects: list[ModelObject] = []
         self.qnameParameters: dict[QName, Any] = {}
         self.modelVariableSets: set[ModelVariableSet] = set()
@@ -599,12 +604,12 @@ 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)))
                 ):
-                    return cast('ModelContext', c)
+                    return c
         return None
 
     def createContext(
@@ -868,17 +873,24 @@ class ModelXbrl:
             return fbdq[memQname]
 
     @property
-    def contextsInUse(self) -> Any:
-        try:
-            if self._contextsInUseMarked:
-                return (cntx for cntx in self.contexts.values() if getattr(cntx, "_inUse", False))
-        except AttributeError:
+    def contextsInUse(self) -> Iterator[ModelContext]:
+        if not self._contextsInUseMarked:
             for fact in self.factsInInstance:
                 cntx = fact.context
                 if cntx is not None:
                     cntx._inUse = True
-            self._contextsInUseMarked: bool = True
-            return self.contextsInUse
+            self._contextsInUseMarked = True
+        return (cntx for cntx in self.contexts.values() if getattr(cntx, "_inUse", False))
+
+    @property
+    def unitsInUse(self) -> Iterator[ModelUnit]:
+        if not self._unitsInUseMarked:
+            for fact in self.factsInInstance:
+                unit = fact.unit
+                if unit is not None:
+                    unit._inUse = True
+            self._unitsInUseMarked = True
+        return (unit for unit in self.units.values() if getattr(unit, "_inUse", False))
 
     @property
     def dimensionsInUse(self) -> set[Any]:
@@ -1032,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

@@ -1,31 +1,41 @@
 '''
 See COPYRIGHT.md for copyright information.
-
-based on pull request 4
-
 '''
 from __future__ import annotations
-import os, sys, types, time, ast, importlib, io, json, gettext, traceback
-from dataclasses import dataclass
-from importlib.metadata import entry_points, EntryPoint
+
+import ast
+import gettext
+from glob import glob
 import importlib.util
+import json
 import logging
-
+import os
+import sys
+import time
+import traceback
+import types
+from collections import defaultdict
+from collections.abc import Callable, Iterator
+from dataclasses import dataclass
+from importlib.metadata import EntryPoint, entry_points
+from numbers import Number
+from pathlib import Path
 from types import ModuleType
 from typing import TYPE_CHECKING, Any, cast
-from arelle.Locale import getLanguageCodes
+
 import arelle.FileSource
+from arelle.Locale import getLanguageCodes
 from arelle.PythonUtil import isLegacyAbs
+from arelle.typing import TypeGetText
 from arelle.UrlUtil import isAbsolute
-from pathlib import Path
-from collections import OrderedDict, defaultdict
-from collections.abc import Callable, Iterator
-
 
 if TYPE_CHECKING:
     # Prevent potential circular import error
     from .Cntlr import Cntlr
 
+
+_: TypeGetText
+
 PLUGIN_TRACE_FILE = None
 # PLUGIN_TRACE_FILE = "c:/temp/pluginerr.txt"
 PLUGIN_TRACE_LEVEL = logging.WARNING
@@ -58,7 +68,7 @@ def init(cntlr: Cntlr, loadPluginConfig: bool = True) -> None:
     if loadPluginConfig:
         try:
             pluginJsonFile = cntlr.userAppDir + os.sep + "plugins.json"
-            with io.open(pluginJsonFile, 'rt', encoding='utf-8') as f:
+            with open(pluginJsonFile, encoding='utf-8') as f:
                 pluginConfig = json.load(f)
             freshenModuleInfos()
         except Exception:
@@ -79,29 +89,45 @@ def reset() -> None:  # force reloading modules and plugin infos
         pluginMethodsForClasses.clear() # dict by class of list of ordered callable function objects
 
 def orderedPluginConfig():
-    return OrderedDict(
-        (('modules',OrderedDict((moduleName,
-                                 OrderedDict(sorted(moduleInfo.items(),
-                                                    key=lambda k: {'name': '01',
-                                                                   'status': '02',
-                                                                   'version': '03',
-                                                                   'fileDate': '04',                                                             'version': '05',
-                                                                   'description': '05',
-                                                                   'moduleURL': '06',
-                                                                   'localeURL': '07',
-                                                                   'localeDomain': '08',
-                                                                   'license': '09',
-                                                                   'author': '10',
-                                                                   'copyright': '11',
-                                                                   'classMethods': '12'}.get(k[0],k[0]))))
-                                for moduleName, moduleInfo in sorted(pluginConfig['modules'].items()))),
-         ('classes',OrderedDict(sorted(pluginConfig['classes'].items())))))
+    fieldOrder = [
+        'name',
+        'status',
+        'fileDate',
+        'version',
+        'description',
+        'moduleURL',
+        'localeURL',
+        'localeDomain',
+        'license',
+        'author',
+        'copyright',
+        'classMethods',
+    ]
+    priorityIndex = {k: i for i, k in enumerate(fieldOrder)}
+
+    def sortModuleInfo(moduleInfo):
+        # Prioritize known fields by the index in fieldOrder; sort others alphabetically
+        orderedKeys = sorted(
+            moduleInfo.keys(),
+            key=lambda k: (priorityIndex.get(k, len(priorityIndex)), k)
+        )
+        return {k: moduleInfo[k] for k in orderedKeys}
+
+    orderedModules = {
+        moduleName: sortModuleInfo(pluginConfig['modules'][moduleName])
+        for moduleName in sorted(pluginConfig['modules'].keys())
+    }
+
+    return {
+        'modules': orderedModules,
+        'classes': dict(sorted(pluginConfig['classes'].items()))
+    }
 
 def save(cntlr: Cntlr) -> None:
     global pluginConfigChanged
     if pluginConfigChanged and cntlr.hasFileSystem and not cntlr.disablePersistentConfig:
         pluginJsonFile = cntlr.userAppDir + os.sep + "plugins.json"
-        with io.open(pluginJsonFile, 'wt', encoding='utf-8') as f:
+        with open(pluginJsonFile, 'w', encoding='utf-8') as f:
             jsonStr = str(json.dumps(orderedPluginConfig(), ensure_ascii=False, indent=2)) # might not be unicode in 2.7
             f.write(jsonStr)
         pluginConfigChanged = False
@@ -155,7 +181,6 @@ moduleInfo = {
 
 '''
 
-
 def logPluginTrace(message: str, level: Number) -> None:
     """
     If plugin trace file logging is configured, logs `message` to it.
@@ -274,6 +299,14 @@ def getModuleFilename(moduleURL: str, reload: bool, normalize: bool, base: str |
         if moduleFilename:
             # `moduleFilename` normalized to an existing script
             return moduleFilename, None
+    if base and not _isAbsoluteModuleURL(moduleURL):
+        # Search for a matching plugin deeper in the plugin directory tree.
+        # Handles cases where a plugin exists in a nested structure, such as
+        # when a developer clones an entire repository into the plugin directory.
+        # Example: arelle/plugin/xule/plugin/xule/__init__.py
+        for path in glob("**/" + moduleURL.replace('\\', '/'), recursive=True):
+            if normalizedPath := normalizeModuleFilename(path):
+                return normalizedPath, None
     # `moduleFilename` did not map to a local filepath or did not normalize to a script
     # Try using `moduleURL` to search for pip-installed entry point
     entryPointRef = EntryPointRef.get(moduleURL)
@@ -416,7 +449,7 @@ def moduleModuleInfo(
 
     if moduleFilename:
         try:
-            logPluginTrace("Scanning module for plug-in info: {}".format(moduleFilename), logging.INFO)
+            logPluginTrace(f"Scanning module for plug-in info: {moduleFilename}", logging.INFO)
             moduleInfo = parsePluginInfo(moduleURL, moduleFilename, entryPoint)
             if moduleInfo is None:
                 return None
@@ -426,38 +459,50 @@ def moduleModuleInfo(
             del moduleInfo["importURLs"]
             moduleImports = moduleInfo["moduleImports"]
             del moduleInfo["moduleImports"]
-            _moduleImportsSubtree = False
+            moduleImportsSubtree = False
             mergedImportURLs = []
 
-            for _url in importURLs:
-                if _url.startswith("module_import"):
+            for url in importURLs:
+                if url.startswith("module_import"):
                     for moduleImport in moduleImports:
                         mergedImportURLs.append(moduleImport + ".py")
-                    if _url == "module_import_subtree":
-                        _moduleImportsSubtree = True
-                elif _url == "module_subtree":
+                    if url == "module_import_subtree":
+                        moduleImportsSubtree = True
+                elif url == "module_subtree":
                     for _dir in os.listdir(moduleDir):
-                        _subtreeModule = os.path.join(moduleDir,_dir)
-                        if os.path.isdir(_subtreeModule) and _dir != "__pycache__":
-                            mergedImportURLs.append(_subtreeModule)
+                        subtreeModule = os.path.join(moduleDir,_dir)
+                        if os.path.isdir(subtreeModule) and _dir != "__pycache__":
+                            mergedImportURLs.append(subtreeModule)
                 else:
-                    mergedImportURLs.append(_url)
-            if parentImportsSubtree and not _moduleImportsSubtree:
-                _moduleImportsSubtree = True
+                    mergedImportURLs.append(url)
+            if parentImportsSubtree and not moduleImportsSubtree:
+                moduleImportsSubtree = True
                 for moduleImport in moduleImports:
                     mergedImportURLs.append(moduleImport + ".py")
             imports = []
-            for _url in mergedImportURLs:
-                if isAbsolute(_url) or isLegacyAbs(_url):
-                    _importURL = _url # URL is absolute http or local file system
-                else: # check if exists relative to this module's directory
-                    _importURL = os.path.join(os.path.dirname(moduleURL), os.path.normpath(_url))
-                    if not os.path.exists(_importURL): # not relative to this plugin, assume standard plugin base
-                        _importURL = _url # moduleModuleInfo adjusts relative URL to plugin base
-                _importModuleInfo = moduleModuleInfo(moduleURL=_importURL, reload=reload, parentImportsSubtree=_moduleImportsSubtree)
-                if _importModuleInfo:
-                    _importModuleInfo["isImported"] = True
-                    imports.append(_importModuleInfo)
+            for url in mergedImportURLs:
+                importURL = url
+                if not _isAbsoluteModuleURL(url):
+                    # Handle relative imports when plugin is loaded from external directory.
+                    # When EDGAR/render imports EDGAR/validate, this works if EDGAR is in the plugin directory
+                    # but fails if loaded externally (e.g., dev repo clone at /dev/path/to/EDGAR/).
+                    # Solution: Find common path segments to resolve /dev/path/to/EDGAR/validate
+                    # from the importing module at /dev/path/to/EDGAR/render.
+                    modulePath = Path(moduleFilename)
+                    importPath = Path(url)
+                    if importPath.parts:
+                        importFirstPart = importPath.parts[0]
+                        for i, modulePathPart in enumerate(reversed(modulePath.parts)):
+                            if modulePathPart != importFirstPart:
+                                continue
+                            # Found a potential branching point, construct and check a new path
+                            candidateImportURL = str(modulePath.parents[i] / importPath)
+                            if normalizeModuleFilename(candidateImportURL):
+                                importURL = candidateImportURL
+                importModuleInfo = moduleModuleInfo(moduleURL=importURL, reload=reload, parentImportsSubtree=moduleImportsSubtree)
+                if importModuleInfo:
+                    importModuleInfo["isImported"] = True
+                    imports.append(importModuleInfo)
             moduleInfo["imports"] = imports
             logPluginTrace(f"Successful module plug-in info: {moduleFilename}", logging.INFO)
             return moduleInfo
@@ -477,43 +522,30 @@ def moduleInfo(pluginInfo):
             moduleInfo.getdefault('classes', []).append(name)
 
 
-def _get_name_dir_prefix(
-    controller: Cntlr,
-    pluginBase: str,
-    moduleURL: str,
-    packagePrefix: str = "",
-) -> tuple[str, str, str] | tuple[None, None, None]:
-    """Get the name, directory and prefix of a module."""
-    moduleFilename: str
-    moduleDir: str
-    packageImportPrefix: str
+def _isAbsoluteModuleURL(moduleURL: str) -> bool:
+    return isAbsolute(moduleURL) or isLegacyAbs(moduleURL)
 
-    moduleFilename = controller.webCache.getfilename(
-        url=moduleURL, normalize=True, base=pluginBase, allowTransformation=False
-    )
 
-    if moduleFilename:
-        if os.path.basename(moduleFilename) == "__init__.py" and os.path.isfile(
-            moduleFilename
-        ):
-            moduleFilename = os.path.dirname(
-                moduleFilename
-            )  # want just the dirpart of package
-
-        if os.path.isdir(moduleFilename) and os.path.isfile(
-            os.path.join(moduleFilename, "__init__.py")
-        ):
-            moduleDir = os.path.dirname(moduleFilename)
-            moduleName = os.path.basename(moduleFilename)
-            packageImportPrefix = moduleName + "."
-        else:
-            moduleName = os.path.basename(moduleFilename).partition(".")[0]
-            moduleDir = os.path.dirname(moduleFilename)
-            packageImportPrefix = packagePrefix
+def _get_name_dir_prefix(modulePath: Path, packagePrefix: str = "") -> tuple[str, str, str] | tuple[None, None, None]:
+    """Get the name, directory and prefix of a module."""
+    moduleName = None
+    moduleDir = None
+    packageImportPrefix = None
+    initFileName = "__init__.py"
+
+    if modulePath.is_file() and modulePath.name == initFileName:
+        modulePath = modulePath.parent
 
-        return (moduleName, moduleDir, packageImportPrefix)
+    if modulePath.is_dir() and (modulePath / initFileName).is_file():
+        moduleName = modulePath.name
+        moduleDir = str(modulePath.parent)
+        packageImportPrefix = moduleName + "."
+    elif modulePath.is_file() and modulePath.suffix == ".py":
+        moduleName = modulePath.stem
+        moduleDir = str(modulePath.parent)
+        packageImportPrefix = packagePrefix
 
-    return (None, None, None)
+    return (moduleName, moduleDir, packageImportPrefix)
 
 def _get_location(moduleDir: str, moduleName: str) -> str:
     """Get the file name of a plugin."""
@@ -543,13 +575,9 @@ def _find_and_load_module(moduleDir: str, moduleName: str) -> ModuleType | None:
 def loadModule(moduleInfo: dict[str, Any], packagePrefix: str="") -> None:
     name = moduleInfo['name']
     moduleURL = moduleInfo['moduleURL']
+    modulePath = Path(moduleInfo['path'])
 
-    moduleName, moduleDir, packageImportPrefix = _get_name_dir_prefix(
-        controller=_cntlr,
-        pluginBase=_pluginBase,
-        moduleURL=moduleURL,
-        packagePrefix=packagePrefix,
-    )
+    moduleName, moduleDir, packageImportPrefix = _get_name_dir_prefix(modulePath, packagePrefix)
 
     if all(p is None for p in [moduleName, moduleDir, packageImportPrefix]):
         _cntlr.addToLog(message=_ERROR_MESSAGE_IMPORT_TEMPLATE.format(name), level=logging.ERROR)
@@ -566,10 +594,12 @@ def loadModule(moduleInfo: dict[str, Any], packagePrefix: str="") -> None:
                     localeDir = os.path.dirname(module.__file__) + os.sep + pluginInfo['localeURL']
                     try:
                         _gettext = gettext.translation(pluginInfo['localeDomain'], localeDir, getLanguageCodes())
-                    except IOError:
-                        _gettext = lambda x: x # no translation
+                    except OSError:
+                        def _gettext(x):
+                            return x # no translation
                 else:
-                    _gettext = lambda x: x
+                    def _gettext(x):
+                        return x
                 for key, value in pluginInfo.items():
                     if key == 'name':
                         if name:
@@ -627,8 +657,7 @@ def pluginClassMethods(className: str) -> Iterator[Callable[..., Any]]:
                                 if className in pluginInfo:
                                     pluginMethodsForClass.append(pluginInfo[className])
             pluginMethodsForClasses[className] = pluginMethodsForClass
-        for method in pluginMethodsForClass:
-            yield method
+        yield from pluginMethodsForClass
 
 
 def addPluginModule(name: str) -> dict[str, Any] | None:
@@ -827,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(':')
@@ -31,6 +42,9 @@ def authority(url: str, includeScheme: bool=True) -> str:
 def scheme(url: str) -> str | None: # returns None if no scheme part
     return (url or "").rpartition(":")[0] or None
 
+def isExternalUrl(url: str) -> bool:
+    return scheme(url) in ("http", "https", "ftp")
+
 absoluteUrlPattern = None
 # http://www.ietf.org/rfc/rfc2396.txt section 4.3
 # this pattern doesn't allow some valid unicode characters