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

arelle/ViewFileRenderedLayout.py

@@ -0,0 +1,174 @@
+'''
+See COPYRIGHT.md for copyright information.
+'''
+import os
+from datetime import timedelta
+from collections import OrderedDict
+from copy import deepcopy
+from lxml import etree
+from arelle import ViewFile
+from arelle.FunctionXs import xsString
+from arelle.ModelObject import ModelObject
+from arelle.Aspect import Aspect, aspectModels, aspectRuleAspects, aspectModelAspect, aspectStr
+from arelle.rendering.RenderingLayout import layoutTable
+from arelle import XbrlConst
+from arelle.XmlUtil import elementFragmentIdentifier, addQnameValue
+
+def viewRenderedLayout(modelXbrl, outfile, lang=None, viewTblELR=None, sourceView=None, diffToFile=False, cssExtras=""):
+    modelXbrl.modelManager.showStatus(_("saving rendering"))
+    view = ViewRenderedLayout(modelXbrl, outfile, lang, cssExtras)
+
+    if sourceView is not None:
+        if sourceView.lytMdlTblMdl:
+            lytMdlTblMdl = sourceView.lytMdlTblMdl
+        else:
+            lytMdlTblMdl = layoutTable(sourceView)
+    else:
+        layoutTable(view)
+        lytMdlTblMdl = view.lytMdlTblMdl
+    if view.tblElt is not None: # may be None if there is no table
+        view.view(lytMdlTblMdl)
+    if diffToFile and outfile:
+        from arelle.ValidateInfoset import validateRenderingInfoset
+        validateRenderingInfoset(modelXbrl, outfile, view.xmlDoc)
+        view.close(noWrite=True)
+    else:
+        view.close()
+    modelXbrl.modelManager.showStatus(_("rendering saved to {0}").format(outfile), clearAfter=5000)
+
+class ViewRenderedLayout(ViewFile.View):
+    def __init__(self, modelXbrl, outfile, lang, cssExtras):
+        # find table model namespace based on table namespace
+        self.tableModelNamespace = XbrlConst.tableModel
+        for xsdNs in modelXbrl.namespaceDocs.keys():
+            if xsdNs in (XbrlConst.tableMMDD, XbrlConst.table):
+                self.tableModelNamespace = xsdNs + "/model"
+                break
+        super(ViewRenderedLayout, self).__init__(modelXbrl, outfile,
+                                               f'tableModel xmlns="{self.tableModelNamespace}" xmlns:xbrli="http://www.xbrl.org/2003/instance"',
+                                               lang,
+                                               style="rendering",
+                                               cssExtras=cssExtras)
+        class nonTkBooleanVar():
+            def __init__(self, value=True):
+                self.value = value
+            def set(self, value):
+                self.value = value
+            def get(self):
+                return self.value
+        # context menu boolean vars (non-tkinter boolean
+        self.ignoreDimValidity = nonTkBooleanVar(value=True)
+
+
+    def tableModelQName(self, localName):
+        return '{' + self.tableModelNamespace + '}' + localName
+
+    def viewReloadDueToMenuAction(self, *args):
+        self.view()
+
+    def view(self, lytMdlTblMdl):
+
+        self.tblElt.append(etree.Comment("Entry point file: {0}".format(lytMdlTblMdl.entryPointUrl)))
+
+        for lytMdlTableSet in lytMdlTblMdl.lytMdlTableSets:
+            tableSetElt = etree.SubElement(self.tblElt, self.tableModelQName("tableSet"))
+            tableSetElt.append(etree.Comment(f"TableSet linkbase file: {lytMdlTableSet.srcFile}, line {lytMdlTableSet.srcLine}"))
+            tableSetElt.append(etree.Comment(f"TableSet linkrole: {lytMdlTableSet.srcLinkrole}"))
+            etree.SubElement(tableSetElt, self.tableModelQName("label")).text = lytMdlTableSet.label
+            for lytMdlTable in lytMdlTableSet.lytMdlTables:
+                tableElt = etree.SubElement(tableSetElt, self.tableModelQName("table"))
+                for name, value in lytMdlTable.strctMdlTable.tblParamValues.items():
+                    tableElt.append(etree.Comment(f" ${name} = \"{value}\" "))
+                for lytMdlHeaders in lytMdlTable.lytMdlHeaders:
+                    hdrsElt = etree.SubElement(tableElt, self.tableModelQName("headers"), attrib={"axis": lytMdlHeaders.axis})
+                    for lytMdlGroup in lytMdlHeaders.lytMdlGroups:
+                        groupElt = etree.SubElement(hdrsElt, self.tableModelQName("group"))
+                        groupElt.append(etree.Comment(f"Breakdown node file: {lytMdlGroup.srcFile}, line {lytMdlGroup.srcLine}"))
+                        if lytMdlGroup.label:
+                            etree.SubElement(groupElt, self.tableModelQName("label")).text=lytMdlGroup.label
+                        for lytMdlHeader in lytMdlGroup.lytMdlHeaders:
+                            if all(lytMdlCell.isOpenAspectEntrySurrogate for lytMdlCell in lytMdlHeader.lytMdlCells):
+                                continue # skip header with only open aspect entry surrogates
+                            hdrElt = etree.SubElement(groupElt, self.tableModelQName("header"))
+                            for lytMdlCell in lytMdlHeader.lytMdlCells:
+                                if lytMdlCell.isOpenAspectEntrySurrogate:
+                                    continue # strip all open aspect entry surrogates from layout model file
+                                attrib = {}
+                                if lytMdlCell.span > 1:
+                                    attrib["span"] = str(lytMdlCell.span)
+                                if lytMdlCell.rollup:
+                                    attrib["rollup"] = "true"
+                                cellElt = etree.SubElement(hdrElt, self.tableModelQName("cell"), attrib)
+                                if lytMdlCell.id:
+                                    cellElt.append(etree.Comment(f"Cell id {lytMdlCell.id}"))
+                                for label, role, lang in lytMdlCell.labels:
+                                    if role or lang:
+                                        cellElt.append(etree.Comment(f"Label role: {role}, lang {lang}"))
+                                    labelElt = etree.SubElement(cellElt, self.tableModelQName("label")).text = label
+                                for lytMdlConstraint in lytMdlCell.lytMdlConstraints:
+                                    attrib = None
+                                    if lytMdlConstraint.tag:
+                                        attrib = {"tag": lytMdlConstraint.tag}
+                                    constraintElt = etree.SubElement(cellElt, self.tableModelQName("constraint"), attrib)
+                                    etree.SubElement(constraintElt, self.tableModelQName("aspect")).text=aspectStr(lytMdlConstraint.aspect)
+                                    valueElt = etree.SubElement(constraintElt, self.tableModelQName("value"))
+                                    aspect = lytMdlConstraint.aspect
+                                    aspectValue = lytMdlConstraint.value
+                                    if aspect == Aspect.PERIOD:
+                                        if isinstance(aspectValue, ModelObject):
+                                            for perElt in aspectValue.iterchildren():
+                                                valueElt.append(deepcopy(perElt))
+                                        elif isinstance(aspectValue, dict) and "periodType" in aspectValue:
+                                            if aspectValue["periodType"] == "duration":
+                                                aspectElt = etree.Element("{http://www.xbrl.org/2003/instance}startDate")
+                                                aspectElt.text = f"{aspectValue['startDate'].strftime('%Y-%m-%dT%H:%M:%S.%f')}Z"
+                                                valueElt.append(aspectElt)
+
+                                                aspectElt = etree.Element("{http://www.xbrl.org/2003/instance}endDate")
+                                                aspectElt.text = f"{(aspectValue['endDate'] + timedelta(days=1)).strftime('%Y-%m-%dT%H:%M:%S.%f')}Z"
+                                                valueElt.append(aspectElt)
+                                            elif aspectValue["periodType"] == "instant":
+                                                aspectElt = etree.Element("{http://www.xbrl.org/2003/instance}instant")
+                                                aspectElt.text = f"{(aspectValue['instant'] + timedelta(days=1)).strftime('%Y-%m-%dT%H:%M:%S.%f')}Z"
+                                                valueElt.append(aspectElt)
+                                            elif aspectValue["periodType"] == "forever":
+                                                aspectElt = etree.Element("{http://www.xbrl.org/2003/instance}forever")
+                                                valueElt.append(aspectElt)
+                                    elif aspect == Aspect.ENTITY_IDENTIFIER:
+                                        if isinstance(aspectValue, ModelObject):
+                                            valueElt.append(deepcopy(aspectValue))
+                                        elif isinstance(aspectValue, dict):
+                                            aspectElt = etree.Element("{http://www.xbrl.org/2003/instance}identifier", {"scheme": aspectValue['scheme']})
+                                            aspectElt.text = str(aspectValue['identifier'])
+                                            valueElt.append(aspectElt)
+                                    elif aspect == Aspect.UNIT:
+                                        aspectElt = etree.SubElement(valueElt, "{http://www.xbrl.org/2003/instance}unit")
+                                        if isinstance(aspectValue, ModelObject):
+                                            for unitElt in aspectValue.iterchildren():
+                                                aspectElt.append(deepcopy(unitElt))
+                                        elif isinstance(aspectValue, dict):
+                                            for m in aspectValue['measures']:
+                                                etree.SubElement(aspectElt, "{http://www.xbrl.org/2003/instance}measure").text = str(m)
+                                    else:
+                                        if isinstance(aspectValue, ModelObject):
+                                            valueElt.append(deepcopy(aspectValue))
+                                        elif not (aspectValue is None and aspect in self.modelXbrl.qnameConcepts and self.modelXbrl.qnameConcepts[aspect].isExplicitDimension):
+                                            # don't put None for value of explicit dimension which id defaulted
+                                            valueElt.text = xsString(None, None, addQnameValue(self.xmlDoc, aspectValue))
+                for lytMdlZCell in lytMdlTable.lytMdlBodyChildren:
+                    zCellsElt = etree.SubElement(tableElt, self.tableModelQName("cells"), attrib={"axis": "z"})
+                    for lytMdlYCell in lytMdlZCell.lytMdlBodyChildren:
+                        yCellsElt = etree.SubElement(zCellsElt, self.tableModelQName("cells"), attrib={"axis": "y"})
+                        for lytMdlXCell in lytMdlYCell.lytMdlBodyChildren:
+                            if not any(lytMdlCell.isOpenAspectEntrySurrogate for lytMdlCell in lytMdlXCell.lytMdlBodyChildren):
+                                xCellsElt = etree.SubElement(yCellsElt, self.tableModelQName("cells"), attrib={"axis": "x"})
+                                for lytMdlCell in lytMdlXCell.lytMdlBodyChildren:
+                                    if lytMdlCell.isOpenAspectEntrySurrogate:
+                                        continue
+                                    cellElt = etree.SubElement(xCellsElt, self.tableModelQName("cell"))
+                                    for f, v, justify in lytMdlCell.facts:
+                                        cellElt.append(etree.Comment(
+                                            f"{f.qname}: context {f.contextID}, value {v[:32]}, file {f.modelDocument.basename}, line {f.sourceline}"))
+                                        if v is not None:
+                                            etree.SubElement(cellElt, self.tableModelQName("fact")
+                                                ).text = f"{f.modelDocument.basename}#{elementFragmentIdentifier(f)}"

arelle/ViewFileRenderedStructure.py

@@ -0,0 +1,108 @@
+'''
+See COPYRIGHT.md for copyright information.
+'''
+import os, io, json
+from collections import OrderedDict
+from arelle import ViewFile
+from arelle.ModelObject import ModelObject
+from arelle.Aspect import Aspect, aspectModels, aspectRuleAspects, aspectModelAspect, aspectStr
+from arelle.ModelInstanceObject import ModelDimensionValue
+from arelle.ModelRenderingObject import (StrctMdlNode, StrctMdlTable, StrctMdlBreakdown, StrctMdlStructuralNode,
+                                         OPEN_ASPECT_ENTRY_SURROGATE, ROLLUP_SPECIFIES_MEMBER, ROLLUP_IMPLIES_DEFAULT_MEMBER,
+                                         ROLLUP_FOR_CONCEPT_RELATIONSHIP_NODE, ROLLUP_FOR_DIMENSION_RELATIONSHIP_NODE,
+                                         ROLLUP_FOR_CLOSED_DEFINITION_NODE, ROLLUP_FOR_OPEN_DEFINITION_NODE,
+                                         ROLLUP_FOR_DEFINITION_NODE)
+from arelle.rendering.RenderingResolution import resolveTableStructure
+from arelle.rendering.RenderingLayout import layoutTable
+from arelle.ModelValue import QName
+from arelle import XbrlConst
+
+def viewRenderedStructuralModel(modelXbrl, outfile, lang=None, viewTblELR=None, sourceView=None, cssExtras=""):
+    modelXbrl.modelManager.showStatus(_("saving rendered structure"))
+    view = ViewRenderedStructuralModel(modelXbrl, outfile, lang, cssExtras)
+    view.view(outfile, viewTblELR)
+    view.close(noWrite=True) # written out below
+    modelXbrl.modelManager.showStatus(_("rendering table saved to {0}").format(outfile), clearAfter=5000)
+
+class ViewRenderedStructuralModel(ViewFile.View):
+    def __init__(self, modelXbrl, outfile, lang, cssExtras):
+        # find table model namespace based on table namespace
+        self.tableModelNamespace = XbrlConst.tableModel
+        for xsdNs in modelXbrl.namespaceDocs.keys():
+            if xsdNs in (XbrlConst.tableMMDD, XbrlConst.table):
+                self.tableModelNamespace = xsdNs + "/model"
+                break
+        super(ViewRenderedStructuralModel, self).__init__(modelXbrl, outfile,
+                                               'dummyObject',
+                                               lang,
+                                               style="rendering",
+                                               cssExtras=cssExtras)
+        class nonTkBooleanVar():
+            def __init__(self, value=True):
+                self.value = value
+            def set(self, value):
+                self.value = value
+            def get(self):
+                return self.value
+        # context menu boolean vars (non-tkinter boolean
+        self.ignoreDimValidity = nonTkBooleanVar(value=True)
+
+
+    def tableModelQName(self, localName):
+        return '{' + self.tableModelNamespace + '}' + localName
+
+    def viewReloadDueToMenuAction(self, *args):
+        self.view()
+
+    def view(self, outfile, viewTblELR=None):
+        if viewTblELR is not None:
+            tblELRs = (viewTblELR,)
+        else:
+            tblELRs = self.modelXbrl.relationshipSet("Table-rendering").linkRoleUris
+
+        for tblELR in tblELRs:
+            self.zOrdinateChoices = {}
+
+            strctMdlTable = resolveTableStructure(self, tblELR)
+
+            # uncomment below for debugging Definition and Structural Models
+            def jsonStrctMdlEncoder(obj, indent="\n"):
+                if isinstance(obj, StrctMdlNode):
+                    o = OrderedDict()
+                    o["object"] = obj.__repr__()
+                    if obj.xlinkLabel is not None:
+                        o["defnMdlNode"] = f"{obj.defnMdlNode.modelXbrl.modelDocument.basename} line {obj.defnMdlNode.sourceline} {obj.xlinkLabel}"
+                    if isinstance(obj, StrctMdlTable):
+                        o["entryFile"] = obj.defnMdlNode.modelXbrl.modelDocument.basename,
+                    if obj.axis:
+                        o["axis"] = obj.axis
+                    if obj.isAbstract:
+                        o["abstract"] = True
+                    if isinstance(obj, StrctMdlStructuralNode):
+                        if obj.hasChildRollup:
+                            o["hasChildRollup"] = True
+                        if obj.rollup:
+                            o["rollup"] = {ROLLUP_SPECIFIES_MEMBER:"rollup specifies member",
+                                           ROLLUP_IMPLIES_DEFAULT_MEMBER:"rollup implies default member",
+                                           ROLLUP_FOR_CONCEPT_RELATIONSHIP_NODE:"rollup for concept relationship nesting",
+                                           ROLLUP_FOR_DIMENSION_RELATIONSHIP_NODE:"rollup for concept relationship nesting",
+                                           ROLLUP_FOR_CLOSED_DEFINITION_NODE:"rollup for closed definition node",
+                                           ROLLUP_FOR_OPEN_DEFINITION_NODE:"rollup for open definition node",
+                                           ROLLUP_FOR_DEFINITION_NODE:"rollup for definition node"}[obj.rollup]
+                        o["structuralDepth"] = obj.structuralDepth
+                        _aspectsCovered = obj.aspectsCovered()
+                        if _aspectsCovered:
+                            o["aspectsCovered"] = OrderedDict((aspectStr(a),
+                                                               str(v.stringValue if isinstance(v,ModelObject) else v
+                                                                   ).replace(OPEN_ASPECT_ENTRY_SURROGATE, "OPEN_ASPECT_ENTRY_"))
+                                                              for a in _aspectsCovered
+                                                              if a != Aspect.DIMENSIONS
+                                                              for v in (obj.aspectValue(a),))
+                    if obj.tagSelector:
+                        o["tagSelector"] = obj.tagSelector
+                    if obj.strctMdlChildNodes:
+                        o["strctMdlChildNodes"] = obj.strctMdlChildNodes
+                    return o
+                raise TypeError("Type {} is not supported for json output".format(type(obj).__name__))
+            with io.open(outfile, 'wt') as fh:
+                json.dump(strctMdlTable, fh, ensure_ascii=False, indent=2, default=jsonStrctMdlEncoder)

arelle/ViewWinDTS.py

@@ -30,7 +30,10 @@ class ViewDTS(ViewWinTree.ViewTree):
 
     def viewDtsElement(self, modelDocument, parentNode, n, parents, siblings):
         if modelDocument.type == ModelDocument.Type.INLINEXBRLDOCUMENTSET:
-            text = modelDocument.gettype() # no file name to display
+            if modelDocument.entrypoint is not None and "id" in modelDocument.entrypoint:
+                text = f"{modelDocument.entrypoint['id']} (IXDS)"
+            else:
+                text = "Inline XBRL Document Set" # no file name or ID to display
         else:
             text = "{0} - {1}".format(os.path.basename(modelDocument.uri), modelDocument.gettype())
         node = self.treeView.insert(parentNode, "end",

arelle/ViewWinFactList.py

@@ -108,7 +108,7 @@ class ViewFactList(ViewWinTree.ViewTree):
                     self.treeView.set(node, "language", lang)
                     if self.footnotesRelationshipSet.fromModelObject(modelFact):
                         self.treeView.set(node, "footnoted", "*")
-                    self.treeView.set(node, "value", modelFact.effectiveValue.strip())
+                    self.treeView.set(node, "value", modelFact.effectiveValue)
                 self.id += 1;
                 n += 1
                 self.viewFacts(modelFact.modelTupleFacts, node, n)

arelle/ViewWinFactTable.py

@@ -204,7 +204,7 @@ class ViewFactTable(ViewWinTree.ViewTree):
             for i, modelRel in enumerate(relationshipSet.fromModelObject(concept)):
                 nestedRelationshipSet = relationshipSet
                 targetRole = modelRel.targetRole
-                if self.arcrole == XbrlConst.summationItem:
+                if self.arcrole in XbrlConst.summationItems:
                     childPrefix = "({:0g}) ".format(modelRel.weight) # format without .0 on integer weights
                 elif targetRole is None or len(targetRole) == 0:
                     targetRole = relationshipSet.linkrole

arelle/ViewWinRelationshipSet.py

@@ -7,6 +7,8 @@ from arelle import ViewWinTree, ModelDtsObject, ModelInstanceObject, ModelRender
 from arelle.ModelRelationshipSet import ModelRelationshipSet
 from arelle.ModelDtsObject import ModelRelationship
 from arelle.ModelFormulaObject import ModelFilter
+from arelle.ModelObject import ModelObject
+from arelle.ViewFileRelationshipSet import hasCalcArcrole
 from arelle.ViewUtil import viewReferences, groupRelationshipSet, groupRelationshipLabel
 from arelle.XbrlConst import conceptNameLabelRole, documentationLabel, widerNarrower
 
@@ -88,7 +90,7 @@ class ViewRelationshipSet(ViewWinTree.ViewTree):
                     self.treeView.heading("type", text=_("Type"))
                     self.treeView.column("references", width=200, anchor="w", stretch=False)
                     self.treeView.heading("references", text=_("References"))
-                elif self.arcrole == XbrlConst.summationItem: # extra columns
+                elif hasCalcArcrole(self.arcrole):
                     self.treeView.column("#0", width=300, anchor="w")
                     self.treeView["columns"] = ("weight", "balance")
                     self.treeView.column("weight", width=48, anchor="w", stretch=False)
@@ -252,7 +254,7 @@ class ViewRelationshipSet(ViewWinTree.ViewTree):
                     self.treeView.set(childnode, "preferredLabel", preferredLabel)
                 self.treeView.set(childnode, "type", concept.niceType)
                 self.treeView.set(childnode, "references", viewReferences(concept))
-            elif self.arcrole == XbrlConst.summationItem:
+            elif hasCalcArcrole(self.arcrole):
                 if isRelation:
                     self.treeView.set(childnode, "weight", "{:+0g} ".format(modelObject.weight))
                 self.treeView.set(childnode, "balance", concept.balance)
@@ -279,11 +281,15 @@ class ViewRelationshipSet(ViewWinTree.ViewTree):
                 if concept.get("merge") == "true":
                     self.treeView.set(childnode, "merge", '\u2713') # checkmark unicode character
                 if isRelation:
-                    self.treeView.set(childnode, "axis", modelObject.axisDisposition)
-                    if isinstance(concept, (ModelEuAxisCoord,ModelRuleDefinitionNode)):
+                    self.treeView.set(childnode, "axis", modelObject.axis)
+                    if isinstance(concept, DefnMdlRuleDefinitionNode):
                         self.treeView.set(childnode, "priItem", concept.aspectValue(None, Aspect.CONCEPT))
-                        self.treeView.set(childnode, "dims", ' '.join(("{0},{1}".format(dim, concept.aspectValue(None, dim))
-                                                                       for dim in (concept.aspectValue(None, Aspect.DIMENSIONS, inherit=False) or []))))
+                        self.treeView.set(childnode, "dims", ' '.join(("{0},{1}".format(dim, dimAspectVal.stringValue if isinstance(dimAspectVal,ModelObject) else
+                                                                                        (dimAspectVal or concept.variableRefs()))
+                                                                       for dim in (concept.aspectValue(None, Aspect.DIMENSIONS, inherit=False) or [])
+                                                                       for dimAspectVal in (concept.aspectValue(None, dim),)
+                                                                       if dimAspectVal is not None))
+            )
             elif self.arcrole == widerNarrower:
                 if isRelation:
                     otherWider = [modelRel.fromModelObject
@@ -308,7 +314,7 @@ class ViewRelationshipSet(ViewWinTree.ViewTree):
                 for modelRel in childRelationshipSet.fromModelObject(concept):
                     nestedRelationshipSet = childRelationshipSet
                     targetRole = modelRel.targetRole
-                    if self.arcrole == XbrlConst.summationItem:
+                    if hasCalcArcrole(self.arcrole):
                         childPrefix = "({:0g}) ".format(modelRel.weight) # format without .0 on integer weights
                     elif targetRole is None or len(targetRole) == 0:
                         targetRole = relationshipSet.linkrole
@@ -407,5 +413,5 @@ class ViewRelationshipSet(ViewWinTree.ViewTree):
             return self.hasAncestor(self.treeView.parent(node), ancestor)
         return False
 
-from arelle.ModelRenderingObject import ModelEuAxisCoord, ModelRuleDefinitionNode
+from arelle.ModelRenderingObject import DefnMdlRuleDefinitionNode
 from arelle.ModelFormulaObject import Aspect