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

arelle/PluginUtils.py

@@ -0,0 +1,54 @@
+"""
+See COPYRIGHT.md for copyright information.
+"""
+from __future__ import annotations
+
+import importlib.util
+import sys
+from collections.abc import Sequence
+from concurrent.futures import ProcessPoolExecutor
+from multiprocessing.context import BaseContext
+from types import ModuleType
+
+
+def _loadPluginModules(pluginModuleLocationsByName: dict[str, str | None]) -> None:
+    for pluginModuleName, pluginModuleLocation in pluginModuleLocationsByName.items():
+        spec = importlib.util.spec_from_file_location(name=pluginModuleName, location=pluginModuleLocation)
+        if spec is None or spec.loader is None:
+            raise ModuleNotFoundError(f"Unable to import plugin module '{pluginModuleName}' from {pluginModuleLocation} in plugin subprocess.")
+        module = importlib.util.module_from_spec(spec)
+        sys.modules[pluginModuleName] = module
+        spec.loader.exec_module(module)
+
+
+class PluginProcessPoolExecutor(ProcessPoolExecutor):
+    """
+    Wrapper class for ProcessPoolExecutor which loads a plugin module before
+    executing any other code. This is necessary for dynamically loaded Arelle
+    plugins, as any functions defined within plugin modules are not imported
+    by newly spawned processes.
+    """
+
+    def __init__(
+            self,
+            pluginModules: Sequence[ModuleType] | ModuleType,
+            maxWorkers: int | None = None,
+            mpContext: BaseContext | None = None,
+    ) -> None:
+        if getattr(sys, 'frozen', False):
+            # Revisit this when cx_Freeze is upgraded to 6.16
+            # https://github.com/marcelotduarte/cx_Freeze/pull/1956
+            raise RuntimeError("Multiprocessing plugins aren't supported in frozen builds. Run Arelle from source.")
+        modules = pluginModules if isinstance(pluginModules, Sequence) else [pluginModules]
+        pluginModuleLocationsByName = {}
+        for pluginModule in modules:
+            pluginModuleSpec = pluginModule.__spec__
+            if pluginModuleSpec is None:
+                raise ValueError(f"Unable to create PluginProcessPoolExecutor for plugin '{pluginModule.__name__}' without ModuleSpec.")
+            pluginModuleLocationsByName[pluginModuleSpec.name] = pluginModuleSpec.origin
+        super().__init__(
+            initializer=_loadPluginModules,
+            initargs=(pluginModuleLocationsByName,),
+            max_workers=maxWorkers,
+            mp_context=mpContext,
+        )

arelle/PrototypeInstanceObject.py

@@ -3,9 +3,10 @@ See COPYRIGHT.md for copyright information.
 '''
 from __future__ import annotations
 
-from arelle import XmlUtil
+import uuid
+from arelle import XbrlConst, XmlUtil
 from arelle.ModelDtsObject import ModelConcept
-from arelle.ModelValue import QName
+from arelle.ModelValue import QName, DateTime, dateTime, DATETIME
 from arelle.ModelObject import ModelObject
 Aspect = None
 
@@ -13,7 +14,7 @@ class FactPrototype():      # behaves like a fact for dimensional validity testi
     def __init__(self, v, aspectValues=None) -> None:
         global Aspect
         if Aspect is None:
-            from arelle.ModelFormulaObject import Aspect
+            from arelle.Aspect import Aspect
         self.modelXbrl = v.modelXbrl
         if aspectValues is None:
             aspectValues = {}
@@ -39,11 +40,13 @@ class FactPrototype():      # behaves like a fact for dimensional validity testi
             self.parent = v.modelXbrl.modelDocument.xmlRootElement
         self.isNumeric = self.concept is not None and self.concept.isNumeric
         self.context = ContextPrototype(v, aspectValues)
-        if Aspect.UNIT in aspectValues:
+        if {Aspect.UNIT, Aspect.UNIT_MEASURES, Aspect.MULTIPLY_BY, Aspect.DIVIDE_BY} & aspectValues.keys():
             self.unit = UnitPrototype(v, aspectValues)
         else:
             self.unit = None
         self.factObjectId = None
+        v.modelXbrl.factPrototypeNextIndex = self.objectIndex = getattr(v.modelXbrl, "factPrototypeNextIndex", 0) + 1
+        self.uniqueUUID = uuid.uuid4()
 
     def clear(self):
         if self.context is not None:
@@ -76,9 +79,12 @@ class ContextPrototype():  # behaves like a context
         self.modelXbrl = v.modelXbrl
         self.segDimVals = {}
         self.scenDimVals = {}
+        self._nonDimValues = {}
         self.qnameDims = {}
-        self.entityIdentifierHash = self.entityIdentifier = None
+        self.entityIdentifierHash = None
+        self.entityIdentifier = (None, None)
         self.isStartEndPeriod = self.isInstantPeriod = self.isForeverPeriod = False
+        self.startDatetime = self.endDatetime = self.instantDatetime = None
 
         for aspect, aspectValue in aspectValues.items():
             if aspect == Aspect.PERIOD_TYPE:
@@ -93,17 +99,34 @@ class ContextPrototype():  # behaves like a context
                 self.startDatetime = aspectValue
             elif aspect == Aspect.END:
                 self.isStartEndPeriod = True
+                if isinstance(aspectValue, DateTime) and aspectValue.dateOnly: # passed by reference, need a new datetime object
+                    aspectValue = dateTime(aspectValue, addOneDay=True, type=DATETIME)
                 self.endDatetime = aspectValue
             elif aspect == Aspect.INSTANT:
                 self.isInstantPeriod = True
+                if isinstance(aspectValue, DateTime) and aspectValue.dateOnly: # passed by reference, need a new datetime object
+                    aspectValue = dateTime(aspectValue, addOneDay=True, type=DATETIME)
                 self.endDatetime = self.instantDatetime = aspectValue
+            elif aspect == Aspect.VALUE:
+                self.entityIdentifier = (self.entityIdentifier[0], aspectValue)
+                self.entityIdentifierHash = hash(self.entityIdentifier)
+            elif aspect == Aspect.SCHEME:
+                self.entityIdentifier = (aspectValue, self.entityIdentifier[1])
+                self.entityIdentifierHash = hash(self.entityIdentifier)
+            elif aspect in (Aspect.COMPLETE_SEGMENT, Aspect.COMPLETE_SCENARIO, "segment", Aspect.NON_XDT_SEGMENT, "scenario", Aspect.NON_XDT_SCENARIO):
+                if aspectValue == [XbrlConst.qnFormulaOccEmpty]:
+                    self._nonDimValues[aspect] = []
+                else:
+                    self._nonDimValues[aspect] = aspectValue
             elif isinstance(aspect, QName):
                 try: # if a DimVal, then it has a suggested context element
                     contextElement = aspectValue.contextElement
+                    isTyped = aspectValue.isTyped
                     aspectValue = (aspectValue.memberQname or aspectValue.typedMember)
                 except AttributeError: # probably is a QName, not a dim value or dim prototype
                     contextElement = v.modelXbrl.qnameDimensionContextElement.get(aspect)
-                if v.modelXbrl.qnameDimensionDefaults.get(aspect) != aspectValue: # not a default
+                    isTyped = False
+                if v.modelXbrl.qnameDimensionDefaults.get(aspect) != aspectValue or isTyped: # not a default
                     try:
                         dimConcept = v.modelXbrl.qnameConcepts[aspect]
                         dimValPrototype = DimValuePrototype(v, dimConcept, aspect, aspectValue, contextElement)
@@ -139,10 +162,13 @@ class ContextPrototype():  # behaves like a context
 
     def dimValue(self, dimQname):
         """(ModelDimension or QName) -- ModelDimension object if dimension is reported (in either context element), or QName of dimension default if there is a default, otherwise None"""
-        dimValue = self.qnameDims.get(dimQname)
-        if dimValue is None:
-            dimValue = self.modelXbrl.qnameDimensionDefaults.get(dimQname)
-        return dimValue
+        try:
+            return self.qnameDims[dimQname]
+        except KeyError:
+            try:
+                return self.modelXbrl.qnameDimensionDefaults[dimQname]
+            except KeyError:
+                return None
 
     def dimValues(self, contextElement, oppositeContextElement=False):
         if not oppositeContextElement:
@@ -151,7 +177,7 @@ class ContextPrototype():  # behaves like a context
             return self.scenDimVals if contextElement == "segment" else self.segDimVals
 
     def nonDimValues(self, contextElement):
-        return []
+        return self._nonDimValues.get(contextElement, [])
 
     def isEntityIdentifierEqualTo(self, cntx2):
         return self.entityIdentifierHash is None or self.entityIdentifierHash == cntx2.entityIdentifierHash
@@ -209,9 +235,24 @@ class UnitPrototype():  # behaves like a context
         self.modelXbrl = v.modelXbrl
         self.hash = self.measures = self.isSingleMeasure = None
         for aspect, aspectValue in aspectValues.items():
-            if aspect == Aspect.UNIT: # entitytIdentifier xml object
+            if aspect == Aspect.UNIT and aspectValue is not None: # entitytIdentifier xml object
                 for unitAttribute in ("measures", "hash", "isSingleMeasure", "isDivide"):
                     setattr(self, unitAttribute, getattr(aspectValue, unitAttribute, None))
+            elif aspect == Aspect.MULTIPLY_BY:
+                measuresList = tuple(sorted(aspectValue))
+                if not self.measures:
+                    self.measures = (measuresList,())
+                else:
+                    self.measures = (measuresList, self.measures[1])
+                self.hash = hash(self.measures)
+            elif aspect == Aspect.DIVIDE_BY:
+                measuresList = tuple(sorted(aspectValue))
+                if not self.measures:
+                    self.measures = ((),measuresList)
+                    self.hash = hash(self.measures)
+                else:
+                    self.measures = (self.measures[0], measuresList)
+                self.hash = hash(self.measures)
 
     def clear(self):
         self.__dict__.clear()  # delete local attributes

arelle/PythonUtil.py

@@ -5,16 +5,20 @@ Python version specific utilities
 do not convert 3 to 2
 '''
 from __future__ import annotations
+
+import fractions
+import os
+import subprocess
 import sys
-from decimal import Decimal
-from fractions import Fraction
 from collections import OrderedDict
-from collections.abc import MappingView, MutableSet
-from typing import Any
+from collections.abc import Iterable, Iterator, Mapping, MappingView, MutableSet, Set
+from decimal import Decimal
+from types import MappingProxyType
+from typing import Any, Generic, TypeVar
 
 from arelle.typing import OptionalString
 
-STR_NUM_TYPES = (str, int, float, Decimal, Fraction)
+STR_NUM_TYPES = (str, int, float, Decimal, fractions.Fraction)
 
 # python 3 unquote, because py2 unquote doesn't do utf-8 correctly
 def py3unquote(string, encoding='utf-8', errors='replace'):
@@ -160,71 +164,178 @@ class OrderedDefaultDict(OrderedDict):
         self[key] = _missingValue
         return _missingValue
 
-class OrderedSet(MutableSet):
 
-    def __init__(self, iterable=None):
-        self.end = end = []
-        end += [None, end, end]         # sentinel node for doubly linked list
-        self.map = {}                   # key --> [key, prev, next]
+T = TypeVar('T')
+
+class OrderedSet(MutableSet[T]):
+    """
+    OrderedSet implementation copied from Python recipe:
+    https://code.activestate.com/recipes/576694/
+    """
+
+    def __init__(self, iterable: Iterable[T] | None = None) -> None:
+        self.end: list[Any] = []
+        end = self.end
+        end += [None, end, end]            # sentinel node for doubly linked list
+        self.map: dict[T, list[Any]] = {}  # key --> [key, prev, next]
         if iterable is not None:
-            self |= iterable
+            self.update(iterable)
+
+    def __getitem__(self, index: int) -> T:
+        if not isinstance(index, int):
+            raise TypeError("Index must be an integer")
+        if index < 0:
+            index += len(self)
+        if index < 0 or index >= len(self):
+            raise IndexError("Index out of range")
+        end = self.end
+        curr = end[2]
+        for _ in range(index):
+            curr = curr[2]
+        return curr[0]
 
-    def __len__(self):
+    def __len__(self) -> int:
         return len(self.map)
 
-    def __contains__(self, key):
+    def __contains__(self, key: object) -> bool:
         return key in self.map
 
-    def add(self, key):
+    def add(self, key: T) -> None:
         if key not in self.map:
             end = self.end
             curr = end[1]
             curr[2] = end[1] = self.map[key] = [key, curr, end]
 
-    def update(self, other):
+    def update(self, other: Iterable[T]) -> None:
         for key in other:
             self.add(key)
 
-    def discard(self, key):
+    def discard(self, key: T) -> None:
         if key in self.map:
             key, prev, next = self.map.pop(key)
             prev[2] = next
             next[1] = prev
 
-    def __iter__(self):
+    def __iter__(self) -> Iterator[T]:
         end = self.end
         curr = end[2]
         while curr is not end:
             yield curr[0]
             curr = curr[2]
 
-    def __reversed__(self):
+    def __reversed__(self) -> Iterator[T]:
         end = self.end
         curr = end[1]
         while curr is not end:
             yield curr[0]
             curr = curr[1]
 
-    def pop(self, last=True):
+    def pop(self, last: bool = True) -> T:
         if not self:
             raise KeyError('set is empty')
         key = self.end[1][0] if last else self.end[2][0]
         self.discard(key)
         return key
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         if not self:
-            return '%s()' % (self.__class__.__name__,)
-        return '%s(%r)' % (self.__class__.__name__, list(self))
+            return f'{self.__class__.__name__}()'
+        return f'{self.__class__.__name__}({list(self)!r})'
 
-    def __eq__(self, other):
+    def __eq__(self, other: object) -> bool:
         if isinstance(other, OrderedSet):
             return len(self) == len(other) and list(self) == list(other)
-        return set(self) == set(other)
+        if isinstance(other, Iterable):
+            return set(self) == set(other)
+        return NotImplemented
+
+class FrozenOrderedSet(Set[T]):
+    """
+    Like frozenset vs set, this is the immutable counterpart to OrderedSet.
+    Maintains insertion order and provides set-like operations without mutation.
+    """
+
+    def __init__(self, iterable: Iterable[T] | None = None) -> None:
+        if iterable is None:
+            self._items: tuple[T, ...] = ()
+            self._set: frozenset[T] = frozenset()
+        else:
+            unique_items = dict.fromkeys(iterable)
+            self._items = tuple(unique_items.keys())
+            self._set = frozenset(unique_items.keys())
+        self._hash: int | None = None
+
+    def __getitem__(self, index: int) -> T:
+        return self._items[index]
+
+    def __len__(self) -> int:
+        return len(self._items)
+
+    def __contains__(self, key: object) -> bool:
+        return key in self._set
+
+    def __iter__(self) -> Iterator[T]:
+        return iter(self._items)
+
+    def __reversed__(self) -> Iterator[T]:
+        return reversed(self._items)
+
+    def __repr__(self) -> str:
+        if not self:
+            return f'{self.__class__.__name__}()'
+        return f'{self.__class__.__name__}({self._items!r})'
+
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, (FrozenOrderedSet, OrderedSet)):
+            return len(self) == len(other) and list(self) == list(other)
+        if isinstance(other, Iterable):
+            return set(self) == set(other)
+        return NotImplemented
+
+    def __hash__(self) -> int:
+        if self._hash is None:
+            self._hash = hash(self._items)
+        return self._hash
+
+KT = TypeVar('KT')
+VT = TypeVar('VT')
+
+
+class FrozenDict(Generic[KT, VT], Mapping[KT, VT]):
+    def __init__(self, data: Mapping[KT, VT] | None = None) -> None:
+        self._dict: Mapping[KT, VT] = MappingProxyType(dict(data) if data is not None else dict())
+        self._hash: int | None = None
+
+    def __getitem__(self, key: KT) -> VT:
+        return self._dict[key]
+
+    def __iter__(self) -> Iterator[KT]:
+        return iter(self._dict)
+
+    def __len__(self) -> int:
+        return len(self._dict)
+
+    def __repr__(self) -> str:
+        if not self:
+            return f'{self.__class__.__name__}()'
+        return f"{self.__class__.__name__}({self._dict})"
+
+    def __eq__(self, other: Any) -> bool:
+        if isinstance(other, FrozenDict):
+            return self._dict == other._dict
+        if isinstance(other, Mapping):
+            return self._dict == other
+        return NotImplemented
+
+    def __hash__(self) -> int:
+        if self._hash is None:
+            self._hash = hash(tuple(sorted(self._dict.items())))
+        return self._hash
+
 
 def Fraction(numerator,denominator=None):
     if denominator is None:
-        if isinstance(numerator, (Fraction,str,Decimal)):
+        if isinstance(numerator, (fractions.Fraction,str,Decimal)):
             return Fraction(numerator)
     elif isinstance(numerator, Decimal) and isinstance(denominator, Decimal):
         return Fraction(int(numerator), int(denominator))
@@ -249,3 +360,33 @@ def pyObjectSize(obj, seen=None):
     elif hasattr(obj, '__iter__') and not isinstance(obj, (str, bytes, bytearray)):
         size += sum([pyObjectSize(i, seen) for i in obj])
     return size
+
+
+def tryRunCommand(*args: str) -> str | None:
+    """
+    Tries to return the results of the provided command.
+    Returns stdout or None if the command exists with a non-zero code.
+    """
+    try:
+        return subprocess.run(
+            args,
+            capture_output=True,
+            check=True,
+            text=True,
+            # A call to get std handle throws an OSError if stdin is not specified when run on Windows as a service.
+            stdin=subprocess.PIPE,
+        ).stdout.strip()
+    except (OSError, subprocess.SubprocessError):
+        return None
+
+def isLegacyAbs(path: str) -> bool:
+    """
+    Implements legacy behavior of os.path.isabs() prior to Python 3.13
+    where True was returned for paths beginning with single slashes on Windows.
+    """
+    if os.path.isabs(path):
+        return True
+    from arelle.SystemInfo import PlatformOS
+    if PlatformOS.getPlatformOS() == PlatformOS.WINDOWS:
+        return path.startswith(("/", "\\"))
+    return False

arelle/RuntimeOptions.py

@@ -1,10 +1,16 @@
+'''
+See COPYRIGHT.md for copyright information.
+'''
 from __future__ import annotations
-from arelle.typing import TypeGetText
-from arelle.SystemInfo import hasWebServer
+
 from dataclasses import InitVar, dataclass
-from typing import Optional, Union, Any
+from typing import Any, Optional, Union
 
-_: TypeGetText
+import regex as re
+
+from arelle.FileSource import FileNamedStringIO
+from arelle.SystemInfo import hasWebServer
+from arelle.ValidateDuplicateFacts import DeduplicationType
 
 RuntimeOptionValue = Union[bool, int, str, None]
 
@@ -27,7 +33,9 @@ class RuntimeOptions:
     about: Optional[str] = None
     anchFile: Optional[str] = None
     arcroleTypesFile: Optional[str] = None
+    baseTaxonomyValidationMode: Optional[str] = None
     betaObjectModel: Optional[bool] = False
+    cacheDirectory: Optional[str] = None
     calFile: Optional[str] = None
     calcDecimals: Optional[int] = None
     calcDeduplicate: Optional[bool] = None
@@ -35,6 +43,7 @@ class RuntimeOptions:
     calcs: Optional[str] = None
     collectProfileStats: Optional[bool] = None
     conceptsFile: Optional[str] = None
+    deduplicateFacts: Optional[DeduplicationType] = None
     diagnostics: Optional[bool] = None
     diffFile: Optional[str] = None
     dimFile: Optional[str] = None
@@ -46,7 +55,7 @@ class RuntimeOptions:
     factListCols: Optional[int] = None
     factTableCols: Optional[int] = None
     factTableFile: Optional[str] = None
-    factsFile: Optional[str] = None
+    factsFile: Optional[str | FileNamedStringIO] = None
     formulaAction: Optional[str] = None
     formulaAsserResultCounts: Optional[bool] = None
     formulaCacheSize: Optional[int] = None
@@ -56,6 +65,7 @@ class RuntimeOptions:
     formulaCallExprSource: Optional[bool] = None
     formulaCompileOnly: Optional[bool] = None
     formulaFormulaRules: Optional[bool] = None
+    formulaMaximumMessageInterpolationLength: Optional[int] = None
     formulaParamExprResult: Optional[bool] = None
     formulaParamInputValue: Optional[bool] = None
     formulaRunIDs: Optional[int] = None
@@ -90,23 +100,29 @@ class RuntimeOptions:
     logFormat: Optional[str] = None
     logLevel: Optional[str] = None
     logLevelFilter: Optional[str] = None
-    logRefObjectProperties: Optional[str] = None
+    logPropagate: Optional[bool] = None
+    logRefObjectProperties: Optional[bool] = None
     logTextMaxLength: Optional[int] = None
+    logXmlMaxAttributeLength: Optional[int] = None
     monitorParentProcess: Optional[bool] = None
     noCertificateCheck: Optional[bool] = None
     outputAttribution: Optional[str] = None
     packageManifestName: Optional[str] = None
-    packages: Optional[str] = None
+    packages: Optional[list[str]] = None
     parameterSeparator: Optional[str] = None
     parameters: Optional[str] = None
     password: Optional[str] = None
     plugins: Optional[str] = None
     preFile: Optional[str] = None
     proxy: Optional[str] = None
+    redirectFallbacks: Optional[dict[re.Pattern[str], str]] = None
     relationshipCols: Optional[int] = None
+    reportPackage: Optional[bool] = None
     roleTypesFile: Optional[str] = None
     rssReport: Optional[str] = None
     rssReportCols: Optional[int] = None
+    saveDeduplicatedInstance: Optional[bool] = None
+    saveOIMToXMLReport: Optional[str] = None
     showEnvironment: Optional[bool] = None
     showOptions: Optional[bool] = None
     skipDTS: Optional[bool] = None
@@ -115,6 +131,8 @@ class RuntimeOptions:
     tableFile: Optional[str] = None
     testReport: Optional[str] = None
     testReportCols: Optional[int] = None
+    testcaseExpectedErrors: Optional[dict[str, list[str]]] = None
+    testcaseFilters: Optional[list[str]] = None
     testcaseResultOptions: Optional[str] = None
     testcaseResultsCaptureWarnings: Optional[bool] = None
     timeVariableSetEvaluation: Optional[bool] = None
@@ -123,13 +141,15 @@ class RuntimeOptions:
     utrUrl: Optional[str] = None
     utrValidate: Optional[bool] = None
     validate: Optional[bool] = None
+    validateDuplicateFacts: Optional[str] = None
+    validateXmlOim: Optional[bool] = None
     validateEFM: Optional[bool] = None
     validateEFMCalcTree: Optional[bool] = None
     validateHMRC: Optional[bool] = None
     validateTestcaseSchema: Optional[bool] = None
-    versReportFile: Optional[str] = None
+    versReportFile: Optional[str | FileNamedStringIO] = None
     viewArcrole: Optional[bool] = None
-    viewFile: Optional[str] = None
+    viewFile: Optional[str | FileNamedStringIO] = None
     webserver: Optional[str] = None
     xdgConfigHome: Optional[str] = None
 
@@ -160,17 +180,11 @@ class RuntimeOptions:
                 if hasattr(self, optionName)
             )
             if existingBaseOptions:
-                raise RuntimeOptionsException(_('Provided plugin options already exist as base options {}').format(existingBaseOptions))
+                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"))
+            raise RuntimeOptionsException("Webserver option requires webserver module")
         if self.webserver and any((
                 self.entrypointFile, self.importFiles, self.diffFile, self.versReportFile,
                 self.factsFile, self.factListCols, self.factTableFile, self.factTableCols,
@@ -178,4 +192,4 @@ class RuntimeOptions:
                 self.dimFile, self.anchFile, self.formulaeFile, self.viewArcrole, self.viewFile,
                 self.roleTypesFile, self.arcroleTypesFile
         )):
-            raise RuntimeOptionsException(_('Incorrect arguments with webserver'))
+            raise RuntimeOptionsException('Incorrect arguments with webserver')

arelle/SocketUtils.py

@@ -1,3 +1,6 @@
+"""
+See COPYRIGHT.md for copyright information.
+"""
 from __future__ import annotations
 import socket
 

arelle/SystemInfo.py

@@ -20,7 +20,7 @@ class PlatformOS(Enum):
     def getPlatformOS() -> PlatformOS:
         """
         Using system.platform() raises a value error exception
-        in windows testing envs and macOS with Python 3.8
+        in windows testing envs
         """
         if sys.platform == "darwin":
             return PlatformOS.MACOS

arelle/TkTableWrapper.py

@@ -32,7 +32,12 @@ __author__ = "Guilherme Polo <ggpolo@gmail.com>"
 __all__ = ["ArrayVar", "Table"]
 
 import os
-import collections
+from pathlib import Path
+import collections.abc
+import platform
+
+from arelle.SystemInfo import PlatformOS
+
 try:
     import tkinter
 except ImportError:
@@ -119,19 +124,42 @@ class Table(tkinter.Widget):
         global _TKTABLE_LOADED
         if not _TKTABLE_LOADED:
             tktable_lib = os.environ.get('TKTABLE_LIBRARY')
+            if not tktable_lib:
+                plat = PlatformOS.getPlatformOS()
+                machine = platform.machine()
+                lib_dir = Path(__file__).parent / "resources" / "libs" / "Tktable2.11"
+                if plat == PlatformOS.MACOS:
+                    if machine == "arm64":
+                        lib_dir = lib_dir / "macos-arm64"
+                    else:
+                        lib_dir = lib_dir / "macos-x86_64"
+                elif plat == PlatformOS.WINDOWS:
+                    lib_dir = lib_dir / "win-x86_64"
+                else:
+                    lib_dir = lib_dir / "linux-x86_64"
+                if lib_dir.exists():
+                    tktable_lib = str(lib_dir)
             if tktable_lib:
                 master.tk.eval('global auto_path; '
                                'lappend auto_path {%s}' % tktable_lib)
-            master.tk.call('package', 'require', 'Tktable')
-            _TKTABLE_LOADED = True
+            try:
+                master.tk.call('package', 'require', 'Tktable')
+                _TKTABLE_LOADED = True
+            except Exception as ex:
+                tkinter.messagebox.showerror(_("Exception"),
+                    _("Unable to locate or to load Tktable.  \n\n"
+                      "GUI functions requiring tables, such as TableLinkbase, are likely to be unusable. \n\n"
+                      "Environment parameter TKTABLE_LIBRARY may be used to specify the location of Tktable. \n\n"
+                      "Details: {}").format(ex))
         # force minimum padding
         if not 'padx' in kw:
             kw['padx'] = 1
         if not 'pady' in kw:
             kw['pady'] = 1
-        tkinter.Widget.__init__(self, master, 'table', kw)
+        if _TKTABLE_LOADED:
+            tkinter.Widget.__init__(self, master, 'table', kw)
         self.contextMenuClick = "<Button-2>" if sys.platform=="darwin" else "<Button-3>"
-
+        self.isInitialized = _TKTABLE_LOADED
 
     def _options(self, cnf, kw=None):
         if kw: