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

arelle/CntlrWinMain.py

@@ -949,7 +949,10 @@ class CntlrWinMain (Cntlr.Cntlr):
             self.parent.title(_("arelle - {0}").format(
                             os.path.basename(modelXbrl.modelDocument.uri)))
             self.setValidateTooltipText()
-            if modelXbrl.modelDocument.type in ModelDocument.Type.TESTCASETYPES:
+            if any(extViews(self, modelXbrl)
+                   for extViews in pluginClassMethods("CntlrWinMain.Xbrl.Views")):
+                currentAction = "ext views provided"
+            elif modelXbrl.modelDocument.type in ModelDocument.Type.TESTCASETYPES:
                 currentAction = "tree view of tests"
                 ViewWinTests.viewTests(modelXbrl, self.tabWinTopRt)
                 topView = modelXbrl.views[-1]

arelle/FileSource.py

@@ -13,7 +13,7 @@ import struct
 import tarfile
 import zipfile
 import zlib
-from typing import IO, TYPE_CHECKING, Any, TextIO, cast
+from typing import IO, TYPE_CHECKING, Any, Optional, TextIO, cast
 
 import regex as re
 from lxml import etree
@@ -452,7 +452,7 @@ class FileSource:
     def reportPackage(self) -> ReportPackage | None:
         try:
             self._reportPackage: ReportPackage | None
-            return self._reportPackage
+            return cast(Optional[ReportPackage], self._reportPackage)
         except AttributeError:
             self._reportPackage = ReportPackage.fromFileSource(self)
             return self._reportPackage

arelle/ModelInstanceObject.py

@@ -1133,7 +1133,7 @@ class ModelContext(ModelObject):
             dimValue = self.modelXbrl.qnameDimensionDefaults.get(dimQname)
         return dimValue
 
-    def dimMemberQname(self, dimQname, includeDefaults=False):
+    def dimMemberQname(self, dimQname: ModelValue.QName, includeDefaults: bool = False) -> ModelValue.QName | None:
         """(QName) -- QName of explicit dimension if reported (or defaulted if includeDefaults is True), else None"""
         dimValue = self.dimValue(dimQname)
         if isinstance(dimValue, (ModelDimensionValue,DimValuePrototype)) and dimValue.isExplicit:

arelle/ModelValue.py

@@ -1013,6 +1013,7 @@ TypeXValue = Union[
     gMonthDay,
     gYearMonth,
     gYear,
+    IsoDuration,
     Fraction,
     list[Optional[QName]],
     None,

arelle/ModelXbrl.py

@@ -878,7 +878,7 @@ class ModelXbrl:
     def dimensionsInUse(self) -> set[Any]:
         self._dimensionsInUse: set[Any]
         try:
-            return self._dimensionsInUse
+            return cast(set[Any], self._dimensionsInUse)
         except AttributeError:
             self._dimensionsInUse = set(dim.dimension
                                         for cntx in self.contexts.values()  # use contextsInUse?  slower?

arelle/PythonUtil.py

@@ -6,18 +6,19 @@ do not convert 3 to 2
 '''
 from __future__ import annotations
 
+import fractions
 import os
 import subprocess
 import sys
 from collections import OrderedDict
-from collections.abc import MappingView, MutableSet
+from collections.abc import Iterable, Iterator, Mapping, MappingView, MutableSet, Set
 from decimal import Decimal
-from fractions import Fraction
-from typing import Any
+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'):
@@ -163,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))

arelle/ViewWinTree.py

@@ -220,14 +220,16 @@ class ViewTree:
                                     modelObject=self.modelXbrl.modelDocument, title=self.tabTitle, error=str(ex))
                 self.menu = None
 
-    def menuAddLabelRoles(self, includeConceptName=False, menulabel=None):
+    def menuAddLabelRoles(self, includeConceptName=False, menulabel=None, usedLabelroles=None):
         if self.menu:
             try:
                 if menulabel is None: menulabel = _("Label role")
                 rolesMenu = Menu(self.viewFrame, tearoff=0)
                 self.menu.add_cascade(label=menulabel, menu=rolesMenu, underline=0)
-                from arelle.ModelRelationshipSet import labelroles
-                for x in labelroles(self.modelXbrl, includeConceptName):
+                if usedLabelroles is None: # provided for OIM taxonomy
+                    from arelle.ModelRelationshipSet import labelroles
+                    usedLabelroles = labelroles(self.modelXbrl, includeConceptName) # arelle infrastructure
+                for x in usedLabelroles:
                     rolesMenu.add_command(label=x[0][1:], underline=0, command=lambda a=x[1]: self.setLabelrole(a))
             except Exception as ex: # tkinter menu problem maybe
                 self.modelXbrl.info("arelle:internalException",
@@ -263,7 +265,7 @@ class ViewTree:
                                     modelObject=self.modelXbrl.modelDocument, title=self.tabTitle, error=str(ex))
                 self.menu = None
 
-    def menuAddViews(self, addClose=True, tabWin=None):
+    def menuAddViews(self, addClose=True, tabWin=None, additionalViews=None, additionalViewMethod=None):
         if self.menu:
             try:
                 if tabWin is None: tabWin = self.tabWin
@@ -273,10 +275,14 @@ class ViewTree:
                 if addClose:
                     viewMenu.add_command(label=_("Close"), underline=0, command=self.close)
                 viewMenu.add_cascade(label=_("Additional view"), menu=newViewsMenu, underline=0)
-                newViewsMenu.add_command(label=_("Arcrole group..."), underline=0, command=lambda: self.newArcroleGroupView(tabWin))
-                from arelle.ModelRelationshipSet import baseSetArcroles
-                for x in baseSetArcroles(self.modelXbrl) + [( " Role Types","!CustomRoleTypes!"), (" Arcrole Types", "!CustomArcroleTypes!")]:
-                    newViewsMenu.add_command(label=x[0][1:], underline=0, command=lambda a=x[1]: self.newView(a, tabWin))
+                if not additionalViews: # 2.1 view
+                    newViewsMenu.add_command(label=_("Arcrole group..."), underline=0, command=lambda: self.newArcroleGroupView(tabWin))
+                    from arelle.ModelRelationshipSet import baseSetArcroles
+                    for x in baseSetArcroles(self.modelXbrl) + [( " Role Types","!CustomRoleTypes!"), (" Arcrole Types", "!CustomArcroleTypes!")]:
+                        newViewsMenu.add_command(label=x[0][1:], underline=0, command=lambda a=x[1]: self.newView(a, tabWin))
+                else:
+                    for viewParams in additionalViews:
+                        newViewsMenu.add_command(label=viewParams[2], underline=0, command=lambda a=additionalViewMethod, b=viewParams, c=additionalViews: a(self.modelXbrl, *b, additionalViews=c))
             except Exception as ex: # tkinter menu problem maybe
                 self.modelXbrl.info("arelle:internalException",
                                     _("Exception creating context add-views menu in %(title)s: %(error)s"),
@@ -324,7 +330,7 @@ class ViewTree:
             self.sortImages = (PhotoImage(file=os.path.join(self.modelXbrl.modelManager.cntlr.imagesDir, "columnSortUp.gif")),
                                PhotoImage(file=os.path.join(self.modelXbrl.modelManager.cntlr.imagesDir, "columnSortDown.gif")),
                                PhotoImage())
-        for col in ("#0",) + self.treeView["columns"]:
+        for col in ("#0",) + (self.treeView["columns"] or () ):
             self.treeView.heading(col, command=lambda c=col: self.sortColumn(c))
         if not startUnsorted:
             self.treeView.heading(initialSortCol, image=self.sortImages[not initialSortDirForward])

arelle/_version.py

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

arelle/formula/XPathContext.py

@@ -351,8 +351,8 @@ class XPathContext:
                         raise XPathException(p, 'err:XPST0017', _('Function named {0} does not have a custom or built-in implementation.').format(op))
                 elif op in VALUE_OPS:
                     # binary arithmetic operations and value comparisons
-                    s1 = self.atomize(p, resultStack.pop()) if len(resultStack) > 0 else []
-                    s2 = self.atomize(p, self.evaluate(p.args, contextItem=contextItem))
+                    s1: Sequence[ContextItem] = self.atomize(p, resultStack.pop()) if len(resultStack) > 0 else []
+                    s2: Sequence[ContextItem] = self.atomize(p, self.evaluate(p.args, contextItem=contextItem))
                     # value comparisons
                     if len(s1) > 1 or len(s2) > 1:
                         raise XPathException(p, 'err:XPTY0004', _("Value operation '{0}' sequence length error").format(op))
@@ -383,35 +383,35 @@ class XPathContext:
                             elif isinstance(op2, Decimal) and isinstance(op1, float):
                                 op2 = float(op2)
                         if op == '+':
-                            result = op1 + op2
+                            result = op1 + op2  # type: ignore[assignment,operator]
                         elif op == '-':
-                            result = op1 - op2
+                            result = op1 - op2  # type: ignore[assignment,operator]
                         elif op == '*':
-                            result = op1 * op2
+                            result = op1 * op2  # type: ignore[assignment,operator]
                         elif op in ('div', 'idiv', "mod"):
                             try:
                                 if op == 'div':
-                                    result = op1 / op2
+                                    result = op1 / op2  # type: ignore[assignment,operator]
                                 elif op == 'idiv':
-                                    result = op1 // op2
+                                    result = op1 // op2  # type: ignore[assignment,operator]
                                 elif op == 'mod':
-                                    result = op1 % op2
+                                    result = op1 % op2  # type: ignore[assignment,operator]
                             except ZeroDivisionError:
                                 raise XPathException(p, 'err:FOAR0001', _('Attempt to divide by zero: {0} {1} {2}.').format(op1, op, op2))
                         elif op == 'ge':
-                            result = op1 >= op2
+                            result = op1 >= op2 # type: ignore[operator]
                         elif op == 'gt':
-                            result = op1 > op2
+                            result = op1 > op2 # type: ignore[operator]
                         elif op == 'le':
-                            result = op1 <= op2
+                            result = op1 <= op2 # type: ignore[operator]
                         elif op == 'lt':
-                            result = op1 < op2
+                            result = op1 < op2 # type: ignore[operator]
                         elif op == 'eq':
                             result = op1 == op2
                         elif op == 'ne':
                             result = op1 != op2
                         elif op == 'to':
-                            result = range(int(op1), int(op2) + 1)
+                            result = range(int(op1), int(op2) + 1)  # type: ignore[arg-type]
                 elif op in GENERALCOMPARISON_OPS:
                     # general comparisons
                     s1 = self.atomize(p, resultStack.pop()) if len(resultStack) > 0 else []
@@ -440,23 +440,23 @@ class XPathContext:
                 elif op in NODECOMPARISON_OPS:
                     # node comparisons
                     s1 = resultStack.pop() if len(resultStack) > 0 else []
-                    s2 = self.evaluate(p.args, contextItem=contextItem)
-                    if len(s1) > 1 or len(s2) > 1 or not self.isNodeSequence(s1) or not self.isNodeSequence(s2[0]):
+                    _s2 = self.evaluate(p.args, contextItem=contextItem)
+                    if len(s1) > 1 or len(_s2) > 1 or not self.isNodeSequence(s1) or not self.isNodeSequence(_s2[0]):
                         raise XPathException(p, 'err:XPTY0004', _('Node comparison sequence error'))
-                    if len(s1) == 0 or len(s2[0]) == 0:
+                    if len(s1) == 0 or len(_s2[0]) == 0:
                         result = []
                     else:
                         n1 = s1[0]
-                        n2 = s2[0][0]
+                        n2 = _s2[0][0]
                         result = False
                         for op1 in s1:
-                            for op2 in s2:
+                            for _op2 in _s2:
                                 if op == 'is':
                                     result = n1 == n2
                                 elif op == '>>':
-                                    result = op1 > op2
+                                    result = op1 > _op2  # type: ignore[operator]
                                 elif op == '<<':
-                                    result = op1 <= op2
+                                    result = op1 <= _op2  # type: ignore[operator]
                             if result:
                                 break
                 elif op in COMBINING_OPS:
@@ -503,7 +503,7 @@ class XPathContext:
                         if op == 'u+':
                             result = op1
                         elif op == 'u-':
-                            result = -op1
+                            result = -op1 # type: ignore[assignment,operator]
                 elif op == 'instance':
                     result = False
                     s1 = self.flattenSequence(resultStack.pop()) if len(resultStack) > 0 else []
@@ -671,7 +671,7 @@ class XPathContext:
                     if hasPrevValue:
                         prevValue = self.inScopeVars[rvQname]
                     for rv in r:
-                        self.inScopeVars[rvQname] = rv  # type: ignore[assignment]
+                        self.inScopeVars[rvQname] = rv
                         self.evaluateRangeVars(op, args[0], args[1:], contextItem, result)
                         if op != 'for' and len(result) > 0:
                             break  # short circuit evaluation

arelle/formula/XPathParser.py

@@ -9,7 +9,7 @@ import time
 import traceback
 from collections.abc import Iterable, Sequence
 from decimal import Decimal
-from typing import Any, TYPE_CHECKING, Union
+from typing import Any, TYPE_CHECKING, Union, cast
 from xml.dom import minidom
 
 from pyparsing import (
@@ -954,7 +954,7 @@ def staticExpressionFunctionContext() -> minidom.Element:
             ' xmlns:fn="http://www.w3.org/2005/xpath-functions"'
             '/>'
         ).documentElement
-    return _staticExpressionFunctionContext
+    return cast(minidom.Element, _staticExpressionFunctionContext)
 
 
 def parse(

arelle/plugin/OimTaxonomy/ModelValueMore.py

@@ -0,0 +1,15 @@
+"""
+See COPYRIGHT.md for copyright information.
+"""
+
+from typing import TYPE_CHECKING, Optional, Set, Any
+
+from arelle.ModelValue import QName
+
+class QNameAt(QName):
+    def __init__(self, prefix: Optional[str], namespaceURI: Optional[str], localName: str, atSuffix:str = "end") -> None:
+        super(QNameAt, self).__init__(prefix, namespaceURI, localName)
+        self.atSuffix: str = atSuffix # The context suffix must be either @end or @start. If an @ value is not provided then the suffix defaults to @end.
+
+class SQName(QName):
+    pass # no properties added to QName, just the localName part doesn't have to be an xml identifier