arelle-release 2.37.20__py3-none-any.whl → 2.37.22__py3-none-any.whl

arelle/CntlrCmdLine.py

@@ -537,6 +537,14 @@ def parseArgs(args):
         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
 
 

arelle/RuntimeOptions.py

@@ -183,12 +183,6 @@ class RuntimeOptions:
                 raise RuntimeOptionsException('Provided plugin options already exist as base options {}'.format(existingBaseOptions))
             for optionName, optionValue in pluginOptions.items():
                 setattr(self, optionName, optionValue)
-        if (self.entrypointFile is None and
-                not self.proxy and
-                not self.plugins and
-                not pluginOptions and
-                not self.webserver):
-            raise RuntimeOptionsException('Incorrect arguments')
         if self.webserver and not hasWebServer():
             raise RuntimeOptionsException("Webserver option requires webserver module")
         if self.webserver and any((

arelle/XbrlConst.py

@@ -101,6 +101,7 @@ elementLabel = "http://xbrl.org/arcrole/2008/element-label"
 genLabel = "http://xbrl.org/2008/label"
 qnGenLabel = qname("{http://xbrl.org/2008/label}label")
 xbrldt = "http://xbrl.org/2005/xbrldt"
+qnXbrldtClosed = qname("{http://xbrl.org/2005/xbrldt}xbrldt:closed")
 qnXbrldtHypercubeItem = qname("{http://xbrl.org/2005/xbrldt}xbrldt:hypercubeItem")
 qnXbrldtDimensionItem = qname("{http://xbrl.org/2005/xbrldt}xbrldt:dimensionItem")
 qnXbrldtContextElement = qname("{http://xbrl.org/2005/xbrldt}xbrldt:contextElement")
@@ -108,6 +109,9 @@ xbrldi = "http://xbrl.org/2006/xbrldi"
 qnXbrldiExplicitMember = qname("{http://xbrl.org/2006/xbrldi}xbrldi:explicitMember")
 qnXbrldiTypedMember = qname("{http://xbrl.org/2006/xbrldi}xbrldi:typedMember")
 xlink = "http://www.w3.org/1999/xlink"
+qnXlinkArcRole = qname("{http://www.w3.org/1999/xlink}xlink:arcrole")
+qnXlinkFrom = qname("{http://www.w3.org/1999/xlink}xlink:from")
+qnXlinkType = qname("{http://www.w3.org/1999/xlink}xlink:type")
 xl = "http://www.xbrl.org/2003/XLink"
 qnXlExtended = qname("{http://www.xbrl.org/2003/XLink}xl:extended")
 qnXlLocator = qname("{http://www.xbrl.org/2003/XLink}xl:locator")

arelle/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '2.37.20'
-__version_tuple__ = version_tuple = (2, 37, 20)
+__version__ = version = '2.37.22'
+__version_tuple__ = version_tuple = (2, 37, 22)

arelle/api/Session.py

@@ -1,26 +1,49 @@
 """
 See COPYRIGHT.md for copyright information.
 
-The Arelle Python Beta API (located in `arelle.api` module) is an in-progress API module.
-A roadmap for this API is in development.
-
-Users of this API should expect changes in future releases.
+The `arelle.api` module is the supported method for integrating Arelle into other Python applications.
 """
 from __future__ import annotations
 
 import logging
+import threading
 from types import TracebackType
 from typing import Any, BinaryIO
 
-from arelle import PluginManager, PackageManager
+from arelle import PackageManager, PluginManager
 from arelle.CntlrCmdLine import CntlrCmdLine, createCntlrAndPreloadPlugins
 from arelle.ModelXbrl import ModelXbrl
 from arelle.RuntimeOptions import RuntimeOptions
 
+_session_lock = threading.Lock()
+
 
 class Session:
+    """
+    CRITICAL THREAD SAFETY WARNING:
+
+    Arelle uses shared global state (PackageManager, PluginManager) which is NOT thread-safe.
+    Only ONE Session can run at a time across the entire process.
+
+    Safe usage:
+    - Use one Session at a time per process
+    - Use a process pool instead of thread pool for parallelism
+
+    Unsafe usage:
+    - Running multiple Sessions concurrently in any threads
+    - Threading.Thread with Session.run()
+    """
+
     def __init__(self) -> None:
         self._cntlr: CntlrCmdLine | None = None
+        self._thread_id = threading.get_ident()
+
+    def _check_thread(self) -> None:
+        """Ensure session is only used from the thread that created it."""
+        if threading.get_ident() != self._thread_id:
+            raise RuntimeError(
+                "Session objects cannot be shared between threads. Create a new Session instance in each thread."
+            )
 
     def __enter__(self) -> Any:
         return self
@@ -34,9 +57,11 @@ class Session:
         self.close()
 
     def close(self) -> None:
-        if self._cntlr is not None:
-            self._cntlr.close()
-        PluginManager.close()
+        with _session_lock:
+            self._check_thread()
+            if self._cntlr is not None:
+                self._cntlr.close()
+            PluginManager.close()
 
     def get_log_messages(self) -> list[dict[str, Any]]:
         """
@@ -81,6 +106,7 @@ class Session:
         responseZipStream: BinaryIO | None = None,
         logHandler: logging.Handler | None = None,
         logFilters: list[logging.Filter] | None = None,
+        sourceZipStreamFileName: str | None = None,
     ) -> bool:
         """
         Perform a run using the given options.
@@ -88,59 +114,65 @@ class Session:
         :param sourceZipStream: Optional stream to read source data from.
         :param responseZipStream: Options stream to write response data to.
         :param logHandler: Optional log handler to use for logging.
+        :param sourceZipStreamFileName: Optional file name to use for the passed zip stream.
         :return: True if the run was successful, False otherwise.
         """
-        PackageManager.reset()
-        PluginManager.reset()
-        if self._cntlr is None:
-            # Certain options must be passed into the controller constructor to have the intended effect
-            self._cntlr = createCntlrAndPreloadPlugins(
-                uiLang=options.uiLang,
-                disablePersistentConfig=options.disablePersistentConfig,
-                arellePluginModules={},
-            )
-        else:
-            # Certain options passed into the controller constructor need to be updated
-            if self._cntlr.uiLang != options.uiLang:
-                self._cntlr.setUiLanguage(options.uiLang)
-            self._cntlr.disablePersistentConfig = options.disablePersistentConfig or False
-        logRefObjectProperties = True
-        if options.logRefObjectProperties is not None:
-            logRefObjectProperties = options.logRefObjectProperties
-        if options.webserver:
-            assert sourceZipStream is None, "Source streaming is not supported with webserver"
-            assert responseZipStream is None, "Response streaming is not supported with webserver"
-            if not self._cntlr.logger:
-                self._cntlr.startLogging(
-                    logFileName='logToBuffer',
-                    logFilters=logFilters,
-                    logHandler=logHandler,
-                    logTextMaxLength=options.logTextMaxLength,
-                    logRefObjectProperties=logRefObjectProperties,
-                    logPropagate=options.logPropagate,
+        with _session_lock:
+            self._check_thread()
+            if sourceZipStreamFileName is not None and sourceZipStream is None:
+                raise ValueError("sourceZipStreamFileName may only be provided if sourceZipStream is not None.")
+            PackageManager.reset()
+            PluginManager.reset()
+            if self._cntlr is None:
+                # Certain options must be passed into the controller constructor to have the intended effect
+                self._cntlr = createCntlrAndPreloadPlugins(
+                    uiLang=options.uiLang,
+                    disablePersistentConfig=options.disablePersistentConfig,
+                    arellePluginModules={},
                 )
-                self._cntlr.postLoggingInit()
-            from arelle import CntlrWebMain
-            CntlrWebMain.startWebserver(self._cntlr, options)
-            return True
-        else:
-            if not self._cntlr.logger:
-                self._cntlr.startLogging(
-                    logFileName=(options.logFile or "logToPrint"),
-                    logFileMode=options.logFileMode,
-                    logFormat=(options.logFormat or "[%(messageCode)s] %(message)s - %(file)s"),
-                    logLevel=(options.logLevel or "DEBUG"),
-                    logFilters=logFilters,
-                    logHandler=logHandler,
-                    logToBuffer=options.logFile == 'logToBuffer',
-                    logTextMaxLength=options.logTextMaxLength,  # e.g., used by EDGAR/render to require buffered logging
-                    logRefObjectProperties=logRefObjectProperties,
-                    logXmlMaxAttributeLength=options.logXmlMaxAttributeLength,
-                    logPropagate=options.logPropagate,
+            else:
+                # Certain options passed into the controller constructor need to be updated
+                if self._cntlr.uiLang != options.uiLang:
+                    self._cntlr.setUiLanguage(options.uiLang)
+                self._cntlr.disablePersistentConfig = options.disablePersistentConfig or False
+            logRefObjectProperties = True
+            if options.logRefObjectProperties is not None:
+                logRefObjectProperties = options.logRefObjectProperties
+            if options.webserver:
+                assert sourceZipStream is None, "Source streaming is not supported with webserver"
+                assert responseZipStream is None, "Response streaming is not supported with webserver"
+                if not self._cntlr.logger:
+                    self._cntlr.startLogging(
+                        logFileName='logToBuffer',
+                        logFilters=logFilters,
+                        logHandler=logHandler,
+                        logTextMaxLength=options.logTextMaxLength,
+                        logRefObjectProperties=logRefObjectProperties,
+                        logPropagate=options.logPropagate,
+                    )
+                    self._cntlr.postLoggingInit()
+                from arelle import CntlrWebMain
+                CntlrWebMain.startWebserver(self._cntlr, options)
+                return True
+            else:
+                if not self._cntlr.logger:
+                    self._cntlr.startLogging(
+                        logFileName=(options.logFile or "logToPrint"),
+                        logFileMode=options.logFileMode,
+                        logFormat=(options.logFormat or "[%(messageCode)s] %(message)s - %(file)s"),
+                        logLevel=(options.logLevel or "DEBUG"),
+                        logFilters=logFilters,
+                        logHandler=logHandler,
+                        logToBuffer=options.logFile == 'logToBuffer',
+                        logTextMaxLength=options.logTextMaxLength,  # e.g., used by EDGAR/render to require buffered logging
+                        logRefObjectProperties=logRefObjectProperties,
+                        logXmlMaxAttributeLength=options.logXmlMaxAttributeLength,
+                        logPropagate=options.logPropagate,
+                    )
+                    self._cntlr.postLoggingInit()  # Cntlr options after logging is started
+                return self._cntlr.run(
+                    options,
+                    sourceZipStream=sourceZipStream,
+                    responseZipStream=responseZipStream,
+                    sourceZipStreamFileName=sourceZipStreamFileName,
                 )
-                self._cntlr.postLoggingInit()  # Cntlr options after logging is started
-            return self._cntlr.run(
-                options,
-                sourceZipStream=sourceZipStream,
-                responseZipStream=responseZipStream,
-            )

arelle/plugin/validate/NL/DisclosureSystems.py

@@ -3,3 +3,17 @@ DISCLOSURE_SYSTEM_NT17 = 'NT17'
 DISCLOSURE_SYSTEM_NT18 = 'NT18'
 DISCLOSURE_SYSTEM_NT19 = 'NT19'
 DISCLOSURE_SYSTEM_NL_INLINE_2024 = 'NL-INLINE-2024'
+DISCLOSURE_SYSTEM_NL_INLINE_2024_GAAP_OTHER = 'NL-INLINE-2024-GAAP-OTHER'
+
+ALL_NL_INLINE_DISCLOSURE_SYSTEMS = [
+    DISCLOSURE_SYSTEM_NL_INLINE_2024,
+    DISCLOSURE_SYSTEM_NL_INLINE_2024_GAAP_OTHER,
+]
+
+NL_INLINE_GAAP_IFRS_DISCLOSURE_SYSTEMS = [
+    DISCLOSURE_SYSTEM_NL_INLINE_2024,
+]
+
+NL_INLINE_GAAP_OTHER_DISCLOSURE_SYSTEMS = [
+    DISCLOSURE_SYSTEM_NL_INLINE_2024_GAAP_OTHER,
+]

arelle/plugin/validate/NL/LinkbaseType.py

@@ -0,0 +1,77 @@
+'''
+See COPYRIGHT.md for copyright information.
+'''
+from __future__ import annotations
+
+from enum import Enum
+
+from arelle import XbrlConst
+from arelle.ModelValue import QName
+
+
+class LinkbaseType(Enum):
+    CALCULATION = "calculation"
+    DEFINITION = "definition"
+    LABEL = "label"
+    PRESENTATION = "presentation"
+    REFERENCE = "reference"
+
+    @staticmethod
+    def fromRefUri(refUri: str | None) -> LinkbaseType | None:
+        """
+        Returns the LinkbaseType corresponding to the given ref URI.
+        If the URI does not match any known linkbase reference type, returns None.
+        """
+        if refUri is None:
+            return None
+        return LINKBASE_TYPE_BY_REF_URI.get(refUri, None)
+
+    def getArcQn(self) -> QName:
+        """
+        Returns the qname of the arc associated with this LinkbaseType.
+        """
+        return LINKBASE_ARC_QN[self]
+
+    def getLinkQn(self) -> QName:
+        """
+        Returns the qname of the link associated with this LinkbaseType.
+        """
+        return LINKBASE_LINK_QN[self]
+
+    def getLowerName(self) -> str:
+        """
+        Returns the lower-case name of this LinkbaseType.
+        """
+        return self.value.lower()
+
+    def getRefUri(self) -> str:
+        """
+        Returns the ref URI associated with this LinkbaseType.
+        """
+        return LINKBASE_REF_URIS[self]
+
+
+LINKBASE_ARC_QN = {
+    LinkbaseType.CALCULATION: XbrlConst.qnLinkCalculationArc,
+    LinkbaseType.DEFINITION: XbrlConst.qnLinkDefinitionArc,
+    LinkbaseType.LABEL: XbrlConst.qnLinkLabelArc,
+    LinkbaseType.PRESENTATION: XbrlConst.qnLinkPresentationArc,
+    LinkbaseType.REFERENCE: XbrlConst.qnLinkReferenceArc,
+}
+
+LINKBASE_LINK_QN = {
+    LinkbaseType.CALCULATION: XbrlConst.qnLinkCalculationLink,
+    LinkbaseType.DEFINITION: XbrlConst.qnLinkDefinitionLink,
+    LinkbaseType.LABEL: XbrlConst.qnLinkLabelLink,
+    LinkbaseType.PRESENTATION: XbrlConst.qnLinkPresentationLink,
+    LinkbaseType.REFERENCE: XbrlConst.qnLinkReferenceLink,
+}
+
+LINKBASE_REF_URIS = {
+    LinkbaseType.CALCULATION: "http://www.xbrl.org/2003/role/calculationLinkbaseRef",
+    LinkbaseType.DEFINITION: "http://www.xbrl.org/2003/role/definitionLinkbaseRef",
+    LinkbaseType.LABEL: "http://www.xbrl.org/2003/role/labelLinkbaseRef",
+    LinkbaseType.PRESENTATION: "http://www.xbrl.org/2003/role/presentationLinkbaseRef",
+    LinkbaseType.REFERENCE: "http://www.xbrl.org/2003/role/referenceLinkbaseRef",
+}
+LINKBASE_TYPE_BY_REF_URI = {v: k for k, v in LINKBASE_REF_URIS.items()}