arelle-release 2.37.17__py3-none-any.whl → 2.37.19__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/ModelValue.py

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

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.17'
-__version_tuple__ = version_tuple = (2, 37, 17)
+__version__ = version = '2.37.19'
+__version_tuple__ = version_tuple = (2, 37, 19)

arelle/plugin/OimTaxonomy/ModelValueMore.py

@@ -0,0 +1,15 @@
+"""
+See COPYRIGHT.md for copyright information.
+"""
+
+from typing import TYPE_CHECKING, Set, Any
+
+from arelle.ModelValue import QName
+
+class QNameAt(QName):
+    def __init__(self, prefix: str | None, namespaceURI: str | None, 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