arelle-release 2.37.46__py3-none-any.whl → 2.38.0__py3-none-any.whl

arelle/archive/plugin/streamingExtensions.py

@@ -1,335 +0,0 @@
-'''
-StreamingExtensions is a plug-in to both GUI menu and command line/web service
-that provides an alternative approach to big instance documents without building a DOM, to save
-memory footprint.  lxml iterparse is used to parse the big instance.  ModelObjects are specialized by features
-for efficiency and to avoid dependency on an underlying DOM.
-
-(Note that this module is based on iterparse, the module under the installation/plugs is much faster.)
-
-See COPYRIGHT.md for copyright information.
-'''
-
-import io, sys, os, time
-from decimal import Decimal, InvalidOperation
-from lxml import etree
-from collections import defaultdict
-from arelle import XbrlConst, XmlUtil, XmlValidate, ValidateXbrlDimensions
-from arelle.ModelDocument import ModelDocument, Type
-from arelle.ModelObject import ModelObject
-from arelle.ModelObjectFactory import parser
-from arelle.ModelValue import QName
-from arelle.ModelInstanceObject import ModelContext, ModelFact, ModelUnit
-from arelle.Validate import Validate
-from arelle.Version import authorLabel, copyrightLabel
-
-_streamingExtensionsValidate = False
-_streamingExtensionsCheck = False
-
-def precedingProcessingInstruction(elt, target):
-    pi = elt.getprevious()
-    while pi is not None:
-        if isinstance(pi, etree._ProcessingInstruction) and pi.target == target:
-            return pi
-        pi = pi.getprevious()
-    return None
-
-def streamingExtensionsLoader(modelXbrl, mappedUri, filepath):
-    # check if big instance and has header with an initial incomplete tree walk (just 2 elements
-    def logSyntaxErrors(parsercontext):
-        for error in parsercontext.error_log:
-            modelXbrl.error("xmlSchema:syntax",
-                    _("%(error)s, %(fileName)s, line %(line)s, column %(column)s, %(sourceAction)s source element"),
-                    modelObject=modelDocument, fileName=os.path.basename(filepath),
-                    error=error.message, line=error.line, column=error.column, sourceAction="streaming")
-    #### note: written for iterparse of lxml prior to version 3.3, otherwise rewrite to use XmlPullParser ###
-    #### note: iterparse wants a binary file, but file is text mode
-    _file, = modelXbrl.fileSource.file(filepath, binary=True)
-    startedAt = time.time()
-    modelXbrl.profileActivity()
-    parsercontext = etree.iterparse(_file, events=("start","end"), huge_tree=True)
-    foundInstance = False
-    foundErrors = False
-    streamingAspects = None
-    numRootFacts1 = 0
-    numElts = 0
-    elt = None
-    for event, elt in parsercontext:
-        if event == "start":
-            if elt.getparent() is not None:
-                if elt.getparent().tag == "{http://www.xbrl.org/2003/instance}xbrl":
-                    if not foundInstance:
-                        foundInstance = True
-                        pi = precedingProcessingInstruction(elt, "xbrl-streamable-instance")
-                        if pi is None:
-                            break
-                        else:
-                            streamingAspects = dict(pi.attrib.copy())
-                    if not elt.tag.startswith("{http://www.xbrl.org/"):
-                        numRootFacts1 += 1
-                        if numRootFacts1 % 1000 == 0:
-                            modelXbrl.profileActivity("... streaming tree check", minTimeToShow=20.0)
-                elif not foundInstance:
-                    break
-            elif elt.tag == "{http://www.xbrl.org/2003/instance}xbrl" and precedingProcessingInstruction(elt, "xbrl-streamable-instance") is not None:
-                modelXbrl.error("streamingExtensions:headerMisplaced",
-                        _("Header is misplaced: %(error)s, must follow xbrli:xbrl element"),
-                        modelObject=elt)
-        elif event == "end":
-            elt.clear()
-            numElts += 1
-            if numElts % 1000 == 0 and elt.getparent() is not None:
-                while elt.getprevious() is not None and elt.getparent() is not None:
-                    del elt.getparent()[0]
-    if elt is not None:
-        elt.clear()
-    _file.seek(0,io.SEEK_SET) # allow reparsing
-    if not foundInstance or streamingAspects is None:
-        del elt, parsercontext
-        _file.close()
-        return None
-    modelXbrl.profileStat(_("streaming tree check"), time.time() - startedAt)
-    startedAt = time.time()
-    try:
-        version = Decimal(streamingAspects.get("version"))
-        if int(version) != 1:
-            modelXbrl.error("streamingExtensions:unsupportedVersion",
-                    _("Streaming version %(version)s, major version number must be 1"),
-                    modelObject=elt, version=version)
-            foundErrors = True
-    except (InvalidOperation, OverflowError):
-        modelXbrl.error("streamingExtensions:versionError",
-                _("Version %(version)s, number must be 1.n"),
-                modelObject=elt, version=streamingAspects.get("version", "(none)"))
-        foundErrors = True
-    for bufAspect in ("contextBuffer", "unitBuffer", "footnoteBuffer"):
-        try:
-            bufLimit = Decimal(streamingAspects.get(bufAspect, "INF"))
-            if bufLimit < 1 or (bufLimit.is_finite() and bufLimit % 1 != 0):
-                raise InvalidOperation
-            elif bufAspect == "contextBuffer":
-                contextBufferLimit = bufLimit
-            elif bufAspect == "unitBuffer":
-                unitBufferLimit = bufLimit
-            elif bufAspect == "footnoteBuffer":
-                footnoteBufferLimit = bufLimit
-        except InvalidOperation:
-            modelXbrl.error("streamingExtensions:valueError",
-                    _("Streaming %(attrib)s %(value)s, number must be a positive integer or INF"),
-                    modelObject=elt, attrib=bufAspect, value=streamingAspects.get(bufAspect))
-            foundErrors = True
-    if parsercontext.error_log:
-        foundErrors = True
-    logSyntaxErrors(parsercontext)
-
-    if foundErrors:
-        _file.close()
-        return None
-    parsercontext = etree.iterparse(_file, events=("start","end"), huge_tree=True)
-    _parser, _parserLookupName, _parserLookupClass = parser(modelXbrl,filepath)
-    eltMdlObjs = {}
-    beforeInstanceStream = True
-    validator = None
-    contextBuffer = []
-    unitBuffer = []
-    footnoteBuffer = []
-    factBuffer = []
-    numFacts = numRootFacts2 = 1
-    for event, elt in parsercontext:
-        if event == "start":
-            mdlObj = _parser.makeelement(elt.tag, attrib=elt.attrib, nsmap=elt.nsmap)
-            mdlObj.sourceline = elt.sourceline
-            eltMdlObjs[elt] = mdlObj
-            if elt.getparent() is None:
-                modelDocument = ModelDocument(modelXbrl, Type.INSTANCE, mappedUri, filepath, etree.ElementTree(mdlObj))
-                modelDocument.xmlRootElement = mdlObj
-                modelXbrl.modelDocument = modelDocument # needed for incremental validation
-                mdlObj.init(modelDocument)
-                modelXbrl.info("streamingExtensions:streaming",
-                               _("Stream processing this instance."),
-                               modelObject = modelDocument)
-            else:
-                eltMdlObjs[elt.getparent()].append(mdlObj)
-                mdlObj._init()
-                ns = mdlObj.namespaceURI
-                ln = mdlObj.localName
-                if (beforeInstanceStream and (
-                    (ns == XbrlConst.link and ln not in ("schemaRef", "linkbaseRef")) or
-                    (ns == XbrlConst.xbrli and ln in ("context", "unit")) or
-                    (ns not in (XbrlConst.link, XbrlConst.xbrli)))):
-                    beforeInstanceStream = False
-                    if _streamingExtensionsValidate:
-                        validator = Validate(modelXbrl)
-                        validator.instValidator.validate(modelXbrl, modelXbrl.modelManager.formulaOptions.typedParameters(modelXbrl.prefixedNamespaces))
-                    else: # need default dimensions
-                        ValidateXbrlDimensions.loadDimensionDefaults(modelXbrl)
-            mdlObj = None # deref
-
-        elif event == "end":
-            mdlObj = eltMdlObjs.pop(elt)
-            if elt.text: # text available after child nodes processed
-                mdlObj.text = elt.text
-            ns = mdlObj.namespaceURI
-            ln = mdlObj.localName
-            parentMdlObj = mdlObj.getparent()
-            if ns == XbrlConst.xbrli:
-                if ln == "context":
-                    if mdlObj.get("sticky"):
-                        del mdlObj.attrib["sticky"]
-                        modelDocument.contextDiscover(mdlObj)
-                    else:
-                        if _streamingExtensionsValidate and len(contextBuffer) >= contextBufferLimit:
-                            # drop before adding as dropped may have same id as added
-                            cntx = contextBuffer.pop(0)
-                            dropContext(modelXbrl, cntx)
-                            del parentMdlObj[parentMdlObj.index(cntx)]
-                            cntx = None
-                        modelDocument.contextDiscover(mdlObj)
-                        if contextBufferLimit.is_finite():
-                            contextBuffer.append(mdlObj)
-                    if _streamingExtensionsValidate:
-                        contextsToCheck = (mdlObj,)
-                        validator.instValidator.checkContexts(contextsToCheck)
-                        if modelXbrl.hasXDT:
-                            validator.instValidator.checkContextsDimensions(contextsToCheck)
-                        del contextsToCheck # dereference
-                elif ln == "unit":
-                    if _streamingExtensionsValidate and len(unitBuffer) >= unitBufferLimit:
-                        # drop before additing as dropped may have same id as added
-                        unit = unitBuffer.pop(0)
-                        dropUnit(modelXbrl, unit)
-                        del parentMdlObj[parentMdlObj.index(unit)]
-                        unit = None
-                    modelDocument.unitDiscover(mdlObj)
-                    if unitBufferLimit.is_finite():
-                        unitBuffer.append(mdlObj)
-                    if _streamingExtensionsValidate:
-                        validator.instValidator.checkUnits( (mdlObj,) )
-                elif ln == "xbrl": # end of document
-                    # check remaining footnote refs
-                    for footnoteLink in footnoteBuffer:
-                        checkFootnoteHrefs(modelXbrl, footnoteLink)
-                elt.clear()
-            elif ns == XbrlConst.link:
-                if ln in ("schemaRef", "linkbaseRef"):
-                    modelDocument.discoverHref(mdlObj)
-                elif ln in ("roleRef", "arcroleRef"):
-                    modelDocument.linkbaseDiscover((mdlObj,), inInstance=True)
-                elif ln == "footnoteLink":
-                    footnoteLinks = (mdlObj,)
-                    modelDocument.linkbaseDiscover(footnoteLinks, inInstance=True)
-                    if footnoteBufferLimit.is_finite():
-                        footnoteBuffer.append(mdlObj)
-                    if _streamingExtensionsValidate:
-                        validator.instValidator.checkLinks(footnoteLinks)
-                        if len(footnoteBuffer) > footnoteBufferLimit:
-                            # check that hrefObjects for locators were all satisfied
-                                # drop before addition as dropped may have same id as added
-                            footnoteLink = footnoteBuffer.pop(0)
-                            checkFootnoteHrefs(modelXbrl, footnoteLink)
-                            dropFootnoteLink(modelXbrl, footnoteLink)
-                            del parentMdlObj[parentMdlObj.index(footnoteLink)]
-                            footnoteLink = None
-                    footnoteLinks = None
-                elt.clear()
-            elif parentMdlObj.qname == XbrlConst.qnXbrliXbrl:
-                numRootFacts2 += 1
-                modelDocument.factDiscover(mdlObj, modelXbrl.facts)
-                XmlValidate.validate(modelXbrl, mdlObj)
-                if _streamingExtensionsValidate:
-                    factsToCheck = (mdlObj,)
-                    validator.instValidator.checkFacts(factsToCheck)
-                    if modelXbrl.hasXDT:
-                        validator.instValidator.checkFactsDimensions(factsToCheck)
-                    del factsToCheck
-                    dropFact(modelXbrl, mdlObj, modelXbrl.facts)
-                    del parentMdlObj[parentMdlObj.index(mdlObj)]
-                if numRootFacts2 % 1000 == 0:
-                    modelXbrl.profileActivity("... streaming fact {0} of {1} {2:.2f}%".format(numRootFacts2, numRootFacts1, 100.0 * numRootFacts2 / numRootFacts1),
-                                              minTimeToShow=20.0)
-                # get rid of root element from iterparse's tree
-                elt.clear()
-                while elt.getprevious() is not None:  # cleans up any prior siblings
-                    del elt.getparent()[0]
-            mdlObj = None # deref
-    logSyntaxErrors(parsercontext)
-    del parsercontext
-    if validator is not None:
-        validator.close()
-    _file.close()
-    modelXbrl.profileStat(_("streaming complete"), time.time() - startedAt)
-    return modelDocument
-
-def checkFootnoteHrefs(modelXbrl, footnoteLink):
-    for locElt in footnoteLink.iterchildren(tag="{http://www.xbrl.org/2003/linkbase}loc"):
-        for hrefElt, doc, id in footnoteLink.modelDocument.hrefObjects:
-            if locElt == hrefElt and id not in footnoteLink.modelDocument.idObjects:
-                modelXbrl.error("streamingExtensions:footnoteId",
-                        _("Footnote id %(id)s not matched to fact in buffered region"),
-                        modelObject=footnoteLink, id=id)
-
-def dropContext(modelXbrl, cntx):
-    del modelXbrl.contexts[cntx.id]
-    dropObject(modelXbrl, cntx)
-
-def dropUnit(modelXbrl, unit):
-    del modelXbrl.units[unit.id]
-    dropObject(modelXbrl, unit)
-
-def dropFootnoteLink(modelXbrl, footnoteLink):
-    for baseSet in modelXbrl.baseSets.values():
-        if footnoteLink in baseSet:
-            baseSet.remove(footnoteLink)
-    dropObject(modelXbrl, footnoteLink)
-
-def dropFact(modelXbrl, fact, facts):
-    while fact.modelTupleFacts:
-        dropFact(modelXbrl, fact.modelTupleFacts[0], fact.modelTupleFacts)
-    modelXbrl.factsInInstance.discard(fact)
-    facts.remove(fact)
-    modelXbrl.modelObjects[fact.objectIndex] = None # objects found by index, can't remove position from list
-    fact.modelDocument.modelObjects.remove(fact)
-    fact.clear()
-
-def dropObject(modelXbrl, mdlObj):
-    for childObj in mdlObj.iterchildren():
-        dropObject(modelXbrl, childObj)
-    if mdlObj.qname == XbrlConst.qnLinkLoc:
-        hrefs = mdlObj.modelDocument.hrefObjects
-        removedHrefs = [i for i, hrefObj in enumerate(hrefs) if mdlObj == hrefObj[0]]
-        for i in removedHrefs:
-            del hrefs[i]
-    modelXbrl.modelObjects[mdlObj.objectIndex] = None # objects found by index, can't remove position from list
-    mdlObj.modelDocument.modelObjects.remove(mdlObj)
-    mdlObj.modelDocument.idObjects.pop(mdlObj.id, None)
-    mdlObj.clear()
-
-def streamingOptionsExtender(parser):
-    parser.add_option("--check-streaming",
-                      action="store_true",
-                      dest="check_streaming",
-                      help=_('Check streamability of instance document."'))
-
-def streamingExtensionsSetup(self, options, **kwargs):
-    global _streamingExtensionsCheck, _streamingExtensionsValidate
-    _streamingExtensionsCheck = getattr(options, 'check_streaming', False)
-    _streamingExtensionsValidate = options.validate
-    if options.validate:
-        options.validate = False # prevent cmdLine calling validation
-
-'''
-   Do not use _( ) in pluginInfo itself (it is applied later, after loading
-'''
-
-__pluginInfo__ = {
-    'name': 'Streaming Extensions Loader',
-    'version': '0.9',
-    'description': "This plug-in loads big XBRL instances without building a DOM in memory.  "
-                    "lxml iterparse parses XBRL directly into an object model without a DOM.  ",
-    'license': 'Apache-2',
-    'author': authorLabel,
-    'copyright': copyrightLabel,
-    # classes of mount points (required)
-    'CntlrCmdLine.Options': streamingOptionsExtender,
-    'CntlrCmdLine.Utility.Run': streamingExtensionsSetup,
-    'ModelDocument.PullLoader': streamingExtensionsLoader,
-}

arelle/archive/plugin/updateTableLB.py

@@ -1,242 +0,0 @@
-'''
-Update Table Linkbase is an example of a plug-in to both GUI menu and command line/web service
-that updates a table linkbase from Eurofiling 2010 syntax to XII 2011 PWD syntax and saves it.
-
-See COPYRIGHT.md for copyright information.
-'''
-from arelle.Version import authorLabel, copyrightLabel
-
-def generateUpdatedTableLB(dts, updatedTableLinkbaseFile):
-    import os, io
-    from arelle import XmlUtil, XbrlConst
-    from arelle.ViewUtil import viewReferences, referenceURI
-    from arelle.ModelRenderingObject import ModelEuAxisCoord
-
-    if dts.fileSource.isArchive:
-        dts.error("genTblLB:outFileIsArchive",
-                 _("Updated Table Linkbase file cannot be an archive: %(tableLBOutputFile)s."),
-                 modelObject=dts, tableLBOutputFile=updatedTableLinkbaseFile)
-        return
-    tblAxisRelSet = dts.relationshipSet(XbrlConst.euTableAxis)
-    axisMbrRelSet = dts.relationshipSet(XbrlConst.euAxisMember)
-    if len(tblAxisRelSet.modelRelationships) == 0:
-        dts.error("genTblLB:noInputTables",
-                 _("DTS does not contain Eurofiling 2010 tables and axes: %(entryFile)s."),
-                 modelObject=dts, entryFile=dts.uri)
-        return
-
-    file = io.StringIO('''
-<nsmap>
-<link:linkbase
-xmlns:label="http://xbrl.org/2008/label"
-xmlns:gen="http://xbrl.org/2008/generic"
-xmlns:df="http://xbrl.org/2008/filter/dimension"
-xmlns:xlink="http://www.w3.org/1999/xlink"
-xmlns:reference="http://xbrl.org/2008/reference"
-xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-xmlns:link="http://www.xbrl.org/2003/linkbase"
-xmlns:table="http://xbrl.org/2011/table"
-xmlns:formula="http://xbrl.org/2008/formula"
-xsi:schemaLocation="
-http://www.xbrl.org/2003/linkbase http://www.xbrl.org/2003/xbrl-linkbase-2003-12-31.xsd
-http://xbrl.org/2008/generic http://www.xbrl.org/2008/generic-link.xsd
-http://xbrl.org/2008/reference http://www.xbrl.org/2008/generic-reference.xsd
-http://xbrl.org/2008/label http://www.xbrl.org/2008/generic-label.xsd
-http://xbrl.org/2011/table http://www.xbrl.org/2011/table.xsd
-http://xbrl.org/2008/filter/dimension http://www.xbrl.org/2008/dimension-filter.xsd">
-  <link:arcroleRef arcroleURI="http://xbrl.org/arcrole/2011/table-filter" xlink:type="simple"
-   xlink:href="http://www.xbrl.org/2011/table.xsd#table-filter"/>
-  <link:arcroleRef arcroleURI="http://xbrl.org/arcrole/2011/table-axis" xlink:type="simple"
-   xlink:href="http://www.xbrl.org/2011/table.xsd#table-axis"/>
-  <link:arcroleRef arcroleURI="http://xbrl.org/arcrole/2011/axis-subtree" xlink:type="simple"
-   xlink:href="http://www.xbrl.org/2011/table.xsd#axis-subtree"/>
-  <link:arcroleRef arcroleURI="http://xbrl.org/arcrole/2011/axis-filter" xlink:type="simple"
-   xlink:href="http://www.xbrl.org/2011/filter-axis.xsd#axis-filter"/>
-</link:linkbase>
-</nsmap>
-<!--  Generated by Arelle(r) http://arelle.org -->
-'''
-     )
-    from arelle.ModelObjectFactory import parser
-    parser, parserLookupName, parserLookupClass = parser(dts,None)
-    from lxml import etree
-    xmlDocument = etree.parse(file,parser=parser,base_url=updatedTableLinkbaseFile)
-    file.close()
-    nsmapElt = xmlDocument.getroot()
-    #xmlDocument.getroot().init(self)  ## is this needed ??
-    for lbElement in  xmlDocument.iter(tag="{http://www.xbrl.org/2003/linkbase}linkbase"):
-        break
-
-    class DocObj:  # fake ModelDocument for namespaces
-        def __init__(self):
-            self.xmlRootElement = lbElement
-            self.xmlDocument = xmlDocument
-    docObj = DocObj()
-
-    numELRs = 0
-    numTables = 0
-
-    def copyAttrs(fromElt, toElt, attrTags):
-        for attr in attrTags:
-            if fromElt.get(attr):
-                toElt.set(attr, fromElt.get(attr))
-
-    def generateTable(newLinkElt, newTblElt, srcTblElt, tblAxisRelSet, axisMbrRelSet, visited):
-        if srcTblElt is not None:
-            for rel in tblAxisRelSet.fromModelObject(srcTblElt):
-                srcAxisElt = rel.toModelObject
-                if isinstance(srcAxisElt, ModelEuAxisCoord):
-                    visited.add(srcAxisElt)
-                    newAxisElt = etree.SubElement(newLinkElt, "{http://xbrl.org/2011/table}ruleAxis")
-                    copyAttrs(srcAxisElt, newAxisElt, ("id",
-                                                       "{http://www.w3.org/1999/xlink}type",
-                                                       "{http://www.w3.org/1999/xlink}label"))
-                    newAxisElt.set("abstract", "true") # always true on root element
-                    newArcElt = etree.SubElement(newLinkElt, "{http://xbrl.org/2011/table}axisArc")
-                    copyAttrs(rel, newArcElt, ("id",
-                                               "{http://www.w3.org/1999/xlink}type",
-                                               "{http://www.w3.org/1999/xlink}from",
-                                               "{http://www.w3.org/1999/xlink}to",
-                                               "order"))
-                    newArcElt.set("{http://www.w3.org/1999/xlink}arcrole", XbrlConst.tableBreakdown)
-                    newArcElt.set("axisDisposition", rel.axisDisposition)
-                    generateAxis(newLinkElt, newAxisElt, srcAxisElt, axisMbrRelSet, visited)
-                    visited.discard(srcAxisElt)
-
-    def generateAxis(newLinkElt, newAxisParentElt, srcAxisElt, axisMbrRelSet, visited):
-        for rel in axisMbrRelSet.fromModelObject(srcAxisElt):
-            tgtAxisElt = rel.toModelObject
-            if isinstance(tgtAxisElt, ModelEuAxisCoord) and tgtAxisElt not in visited:
-                visited.add(tgtAxisElt)
-                newAxisElt = etree.SubElement(newLinkElt, "{http://xbrl.org/2011/table}ruleAxis")
-                copyAttrs(tgtAxisElt, newAxisElt, ("id",
-                                                   "abstract",
-                                                   "{http://www.w3.org/1999/xlink}type",
-                                                   "{http://www.w3.org/1999/xlink}label"))
-                if tgtAxisElt.primaryItemQname:
-                    newRuleElt = etree.SubElement(newAxisElt, "{http://xbrl.org/2008/formula}concept")
-                    newQnameElt = etree.SubElement(newRuleElt, "{http://xbrl.org/2008/formula}qname")
-                    newQnameElt.text = XmlUtil.addQnameValue(docObj, tgtAxisElt.primaryItemQname)
-                for dimQname, memQname in tgtAxisElt.explicitDims:
-                    newRuleElt = etree.SubElement(newAxisElt, "{http://xbrl.org/2008/formula}explicitDimension")
-                    newRuleElt.set("dimension", XmlUtil.addQnameValue(docObj, dimQname))
-                    newMbrElt = etree.SubElement(newRuleElt, "{http://xbrl.org/2008/formula}member")
-                    newQnameElt = etree.SubElement(newMbrElt, "{http://xbrl.org/2008/formula}qname")
-                    newQnameElt.text = XmlUtil.addQnameValue(docObj, memQname)
-                newArcElt = etree.SubElement(newLinkElt, "{http://xbrl.org/2011/table}axisArc")
-                copyAttrs(rel, newArcElt, ("id",
-                                           "{http://www.w3.org/1999/xlink}type",
-                                           "{http://www.w3.org/1999/xlink}from",
-                                           "{http://www.w3.org/1999/xlink}to",
-                                           "order"))
-                newArcElt.set("{http://www.w3.org/1999/xlink}arcrole", XbrlConst.tableAxisSubtree)
-                generateAxis(newLinkElt, newAxisElt, tgtAxisElt, axisMbrRelSet, visited)
-                visited.discard(tgtAxisElt)
-
-    # sort URIs
-    linkroleUris = sorted([linkroleUri
-                           for linkroleUri in tblAxisRelSet.linkRoleUris])
-
-    firstNewLinkElt = None
-    roleRefUris = set()
-    for linkroleUri in linkroleUris:
-        numELRs += 1
-        newLinkElt = etree.SubElement(lbElement, "{http://xbrl.org/2008/generic}link")
-        newLinkElt.set("{http://www.w3.org/1999/xlink}type", "extended")
-        newLinkElt.set("{http://www.w3.org/1999/xlink}role", linkroleUri)
-        if firstNewLinkElt is None: firstNewLinkElt = newLinkElt
-        # To do: add roleRef if needed
-        tblAxisRelSet = dts.relationshipSet(XbrlConst.euTableAxis, linkroleUri)
-        axisMbrRelSet = dts.relationshipSet(XbrlConst.euAxisMember, linkroleUri)
-        for srcTblElt in tblAxisRelSet.rootConcepts:
-            if srcTblElt.tag == "{http://www.eurofiling.info/2010/rendering}table":
-                numTables += 1
-                newTblElt = etree.SubElement(newLinkElt, "{http://xbrl.org/2011/table}table")
-                newTblElt.set("aspectModel", "dimensional")
-                copyAttrs(srcTblElt, newTblElt, ("id",
-                                                 "{http://www.w3.org/1999/xlink}type",
-                                                 "{http://www.w3.org/1999/xlink}label"))
-                generateTable(newLinkElt, newTblElt, srcTblElt, tblAxisRelSet, axisMbrRelSet, set())
-
-                if linkroleUri not in roleRefUris:
-                    srcRoleRefElt = XmlUtil.descendant(srcTblElt.getroottree(), XbrlConst.link, "roleRef", "roleURI", linkroleUri)
-                    if srcRoleRefElt is not None:
-                        roleRefUris.add(linkroleUri)
-                        newRoleRefElt = etree.Element("{http://www.xbrl.org/2003/linkbase}roleRef")
-                        copyAttrs(srcRoleRefElt, newRoleRefElt, ("roleURI",
-                                                                 "{http://www.w3.org/1999/xlink}type",
-                                                                 "{http://www.w3.org/1999/xlink}href"))
-                        firstNewLinkElt.addprevious(newRoleRefElt)
-
-    fh = open(updatedTableLinkbaseFile, "w", encoding="utf-8")
-    XmlUtil.writexml(fh, xmlDocument, encoding="utf-8")
-    fh.close()
-
-    dts.info("info:updateTableLinkbase",
-             _("Updated Table Linkbase of %(entryFile)s has %(numberOfLinkroles)s linkroles, %(numberOfTables)s tables in file %(tableLBOutputFile)s."),
-             modelObject=dts,
-             entryFile=dts.uri, numberOfLinkroles=numELRs, numberOfTables=numTables, tableLBOutputFile=updatedTableLinkbaseFile)
-
-def updateTableLBMenuEntender(cntlr, menu):
-    # Extend menu with an item for the savedts plugin
-    menu.add_command(label="Update table linkbase",
-                     underline=0,
-                     command=lambda: updateTableLBMenuCommand(cntlr) )
-
-def updateTableLBMenuCommand(cntlr):
-    # save DTS menu item has been invoked
-    if cntlr.modelManager is None or cntlr.modelManager.modelXbrl is None:
-        cntlr.addToLog("No taxonomy loaded.")
-        return
-
-        # get file name into which to save log file while in foreground thread
-    updatedTableLinkbaseFile = cntlr.uiFileDialog("save",
-                                                  title=_("arelle - Save Updated Table Linkbase file"),
-            initialdir=cntlr.config.setdefault("tableLinkbaseFileDir","."),
-            filetypes=[(_("Linkbase file .xml"), "*.xml")],
-            defaultextension=".xml")
-    if not updatedTableLinkbaseFile:
-        return False
-    import os
-    cntlr.config["tableLinkbaseFileDir"] = os.path.dirname(updatedTableLinkbaseFile)
-    cntlr.saveConfig()
-
-    try:
-        generateUpdatedTableLB(cntlr.modelManager.modelXbrl, updatedTableLinkbaseFile)
-    except Exception as ex:
-        dts = cntlr.modelManager.modelXbrl
-        dts.error("exception",
-            _("Updated table linkbase generation exception: %(error)s"), error=ex,
-            modelXbrl=dts,
-            exc_info=True)
-
-def updateTableLBCommandLineOptionExtender(parser):
-    # extend command line options with a save DTS option
-    parser.add_option("--save-updated-table-linkbase",
-                      action="store",
-                      dest="updatedTableLinkbaseFile",
-                      help=_("Update table linkbase file from Eurofiling 2010 to XII 2011 syntax."))
-
-def updateTableLBCommandLineXbrlRun(cntlr, options, modelXbrl, *args, **kwargs):
-    # extend XBRL-loaded run processing for this option
-    if getattr(options, "updatedTableLinkbaseFile", None):
-        if cntlr.modelManager is None or cntlr.modelManager.modelXbrl is None:
-            cntlr.addToLog("No taxonomy loaded.")
-            return
-        generateUpdatedTableLB(cntlr.modelManager.modelXbrl, options.updatedTableLinkbaseFile)
-
-
-__pluginInfo__ = {
-    'name': 'Update Table Linkbase',
-    'version': '0.9',
-    'description': "This plug-in updates a table linkbase from Eurofiling 2010 syntax to XII 2011 PWD syntax. "
-                   "The updated linkbase is saved to a local file.  "
-                   "Hrefs in the new file are identical the prior hrefs (not offset considering save-to directory).  ",
-    'license': 'Apache-2',
-    'author': authorLabel,
-    'copyright': copyrightLabel,
-    # classes of mount points (required)
-    'CntlrWinMain.Menu.Tools': updateTableLBMenuEntender,
-    'CntlrCmdLine.Options': updateTableLBCommandLineOptionExtender,
-    'CntlrCmdLine.Xbrl.Run': updateTableLBCommandLineXbrlRun,
-}

arelle/archive/plugin/validate/SBRnl/CustomLoader.py

@@ -1,19 +0,0 @@
-'''
-See COPYRIGHT.md for copyright information.
-'''
-import regex as re
-
-def checkForBOMs(modelXbrl, file, mappedUri, filepath, *args, **kwargs):
-    # callback is for all opened docs, must only process when SBRNL validation active
-    if (modelXbrl.modelManager.validateDisclosureSystem and
-        # corrected merge of pre-plugin code per LOGIUS
-        getattr(modelXbrl.modelManager.validateDisclosureSystem, "SBRNLplugin", False)):
-        #must read file in binary and return nothing to not replace standard loading
-        with open(filepath, 'rb') as fb:
-            startingBytes = fb.read(8)
-            if re.match(b"\\x00\\x00\\xFE\\xFF|\\xFF\\xFE\\x00\\x00|\\x2B\\x2F\\x76\\x38|\\x2B\\x2F\\x76\\x39|\\x2B\\x2F\\x76\\x2B|\\x2B\\x2F\\x76\\x2F|\\xDD\\x73\\x66\\x73|\\xEF\\xBB\\xBF|\\x0E\\xFE\\xFF|\\xFB\\xEE\\x28|\\xFE\\xFF|\\xFF\\xFE",
-                        startingBytes):
-                modelXbrl.error("SBR.NL.2.1.0.09",
-                    _("File MUST not start with a Byte Order Mark (BOM): %(filename)s"),
-                    modelObject=modelXbrl, filename=mappedUri)
-    return None # must return None for regular document loading to continue