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

arelle/examples/plugin/sakaCalendar.py

@@ -1,215 +0,0 @@
-#! /usr/bin/env python
-# -*- coding: utf-8 -*-
-# Calendar Program
-# Copyright 2008 Santhosh Thottingal <santhosh.thottingal@gmail.com>
-# http://www.smc.org.in
-#####
-# Arelle modification: interfaces to allow operation as a run-time user-discretion plug in
-# Hindi month names
-#
-# Note that this plug-in is LGPL-v3 and not Apache-2 see http://www.apache.org/licenses/GPL-compatibility.html
-#####
-#
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of the GNU Lesser General Public License as published by
-# the Free Software Foundation; either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU Library General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
-#
-# If you find any bugs or have any suggestions email: santhosh.thottingal@gmail.com
-
-import math
-class SakaCalendar:
-    JULIAN_EPOCH = 1721425.5
-    SAKA_MONTH_NAMES= ["Chaitra", "Vaisakha", "Jyaishta", "Asadha", "Sravana", "Bhadra","Aswina", "Kartiak", "Agrahayana","Pausa","Magha","Phalguna"]
-    SAKA_WEEK_NAMES= ["Ravivar", "Somavar", "Mangalvar", "Budhvar", "Sukhravar", "Guruvar","Sanivar"]
-    IE = 0
-    # The only practical difference from a Gregorian calendar is that years
-    #are numbered since the Saka Era.  A couple of overrides will
-    #take care of that....
-    # Starts in 78 AD,
-    INDIAN_ERA_START = 78
-    # The Indian year starts 80 days later than the Gregorian year.
-    INDIAN_YEAR_START = 80
-    def get_month_length(self, extendedYear,  month):
-        if  month < 0  or  month > 11:
-            extendedYear += month/12 # floorDivide(month, 12, remainder)
-            month =  month%12
-        if self.is_gregorian_leap(extendedYear + self.INDIAN_ERA_START) and month == 0:
-            return 31
-        if month >= 1 and  month <=5 :
-            return 31
-        return 30
-
-
-    """
-     This routine converts an Indian date to the corresponding Julian date
-     @param year   The year in Saka Era according to Indian calendar.
-     @param month  The month according to Indian calendar (between 1 to 12)
-     @param date   The date in month
-    """
-    def saka_to_julian_date(self,year,month, date):
-        gyear = year + self.INDIAN_ERA_START
-        if self.is_gregorian_leap(gyear) :
-            leapMonth = 31
-            start = self.gregorian_to_julian_date(gyear, 3, 21)
-        else :
-            leapMonth = 30
-            start = self.gregorian_to_julian_date(gyear, 3, 22)
-        if month == 1  :
-            jd = start + (date - 1)
-        else:
-            jd = start + leapMonth
-            m = month - 2
-            m = m if m <= 5 else 5
-            jd += m * 31
-            if  month >= 8  :
-                m = month - 7
-                jd += m * 30
-            jd += date - 1
-        return jd
-
-
-    """
-      The following function is not needed for basic calendar functioning.
-      This routine converts a gregorian date to the corresponding Julian date"
-      @param year   The year in standard Gregorian calendar (AD/BC) .
-      @param month  The month according to Gregorian calendar (between 0 to 11)
-      @param date   The date in month
-    """
-    def gregorian_to_julian_date(self, year, month, date) :
-        jd = ((self.JULIAN_EPOCH - 1) +
-            (365 * (year - 1)) +
-            math.floor((year - 1) / 4) +
-            (-math.floor((year - 1) / 100)) +
-            math.floor((year - 1) / 400) +
-            math.floor((((367 * month) - 362) / 12) +
-            ( 0 if (month <= 2) else -1 if self.is_gregorian_leap(year) else -2) ) +
-            date)
-
-        return jd
-
-
-    """
-       The following function is not needed for basic calendar functioning.
-       This routine converts a julian day (jd) to the corresponding date in Gregorian calendar"
-       @param jd The Julian date in Julian Calendar which is to be converted to Indian date"
-    """
-    def julian_date_to_gregorian(self, jd) :
-        julianDate=[None, None,None]
-        wjd = math.floor(jd - 0.5) + 0.5
-        depoch = wjd - self.JULIAN_EPOCH
-        quadricent = math.floor(depoch / 146097)
-        dqc = depoch % 146097
-        cent = math.floor(dqc / 36524)
-        dcent = dqc % 36524
-        quad = math.floor(dcent / 1461)
-        dquad = dcent % 1461
-        yindex = math.floor(dquad / 365)
-        year = int((quadricent * 400) + (cent * 100) + (quad * 4) + yindex)
-        if  not ((cent == 4)  or (yindex == 4)) :
-            year+=1
-        yearday = wjd - self.gregorian_to_julian_date(year, 1, 1)
-        leapadj = ( 0 if (wjd < self.gregorian_to_julian_date(year, 3, 1)) else  1 if self.is_gregorian_leap(year) else 2)
-        month = int(math.floor((((yearday + leapadj) * 12) + 373) / 367))
-        day = int((wjd - self.gregorian_to_julian_date(year, month, 1)) + 1)
-        julianDate[0] = year
-        julianDate[1] = month
-        julianDate[2] = day
-        return julianDate
-
-
-    """
-      The following function is not needed for basic calendar functioning.
-      This routine checks if the Gregorian year is a leap year"
-      @param year      The year in Gregorian Calendar
-    """
-    def is_gregorian_leap(self,year):
-        return ((year % 4) == 0) and (not(((year % 100) == 0) and ((year % 400) != 0)))
-
-    def gregorian_to_saka_date(self, gregorianDay):
-        indDate=[None,None,None]
-        IndianYear = gregorianDay[0] - self.INDIAN_ERA_START            # Year in Saka era
-        jdAtStartOfGregYear = self. gregorian_to_julian_date(gregorianDay[0], 1, 1) # JD at start of Gregorian year
-        julianDay = self.gregorian_to_julian_date( gregorianDay[0],  gregorianDay[1],  gregorianDay[2])
-        yday = int(julianDay - jdAtStartOfGregYear)              # Day number in Gregorian year (starting from 0)
-        if  yday < self.INDIAN_YEAR_START  :
-            #  Day is at the end of the preceding Saka year
-            IndianYear -= 1
-            leapMonth = 31 if self.is_gregorian_leap(gregorianDay[0] - 1) else 30 # Days in leapMonth this year, previous Gregorian year
-            yday += leapMonth + (31 * 5) + (30 * 3) + 10
-        else:
-            leapMonth =  31 if self.is_gregorian_leap(gregorianDay[0]) else 30 # Days in leapMonth this year
-            yday -= self.INDIAN_YEAR_START
-        if  yday < leapMonth  :
-            IndianMonth = 0
-            IndianDayOfMonth = yday + 1
-        else :
-            mday = yday - leapMonth
-            if mday < (31 * 5) :
-                IndianMonth = int(math.floor(mday / 31) + 1)
-                IndianDayOfMonth = (mday % 31) + 1
-            else :
-                mday -= 31 * 5
-                IndianMonth = int(math.floor(mday / 30)) + 6
-                IndianDayOfMonth = (mday % 30) + 1
-
-        #Month is 0 based.converting it to 1 based
-        if  IndianMonth == 12  :
-            IndianMonth = 1
-        else :
-            IndianMonth = IndianMonth +1
-        indDate[0]=IndianYear
-        indDate[1]=IndianMonth
-        indDate[2]=IndianDayOfMonth
-        return indDate
-    def get_month_name(self, month_index):
-        return self.SAKA_MONTH_NAMES[month_index-1]
-    def get_week_name(self, week_index)  :
-        return self.SAKA_WEEK_NAMES[week_index-1]
-
-# Arelle modifications follow this comment.  They do not modify the behavior of the original module.
-
-def gregorianToSaka(gregorianDateArray):
-    if (not isinstance(gregorianDateArray, (tuple,list)) or
-        len(gregorianDateArray) != 3):
-        raise ValueError("sakaCalendar:Invalid argument, must be tuple or list of yr,mo,day: {}".format(gregorianDateArray))
-    return SakaCalendar().gregorian_to_saka_date(gregorianDateArray)
-
-def sakaToGregorian(sakaDateArray):
-    if (not isinstance(sakaDateArray, (tuple,list)) or
-        len(sakaDateArray) != 3):
-        raise ValueError("sakaCalendar:Invalid argument, must be tuple or list of yr,mo,day: {}".format(sakaDateArray))
-    sakaCal = SakaCalendar()
-    sakaYr = sakaDateArray[0]
-    sakaMo = sakaDateArray[1]
-    sakaDay = sakaDateArray[2]
-    # validate date
-    if (not isinstance(sakaDateArray, (tuple,list)) or
-        len(sakaDateArray) != 3 or
-        not 1 <= sakaYr <= 9999 or
-        not 1 <= sakaMo <= 12 or
-        not 1 <= sakaDay <= sakaCal.get_month_length(sakaYr, sakaMo)):
-        raise ValueError("sakaCalendar:InvalidDate: {} {} {}".format(sakaYr, sakaMo, sakaDay))
-    # convert to gregorian calendar
-    return sakaCal.julian_date_to_gregorian(sakaCal.saka_to_julian_date(sakaYr, sakaMo, sakaDay))
-
-__pluginInfo__ = {
-    'name': 'Saka Calendar',
-    'version': '1.0',
-    'description': "India National Calendar date validation and conversion. ",
-    'license': 'LGPL-v3',
-    'author': 'Santhosh Thottingal',
-    'copyright': '(c) Copyright 2008 Santhosh Thottingal <santhosh.thottingal@gmail.com>.',
-    # classes of mount points (required)
-    'SakaCalendar.FromGregorian': gregorianToSaka,
-    'SakaCalendar.ToGregorian': sakaToGregorian,
-}

arelle/examples/plugin/saveInstanceInfoset.py

@@ -1,121 +0,0 @@
-'''
-Save Instance Infoset is an example of a plug-in to both GUI menu and command line/web service
-that will save facts decorated with ptv:periodType, ptv:balance, ptv:decimals and ptv:precision (inferred).
-
-See COPYRIGHT.md for copyright information.
-'''
-from arelle.Version import authorLabel, copyrightLabel
-
-def generateInstanceInfoset(dts, instanceInfosetFile):
-    if dts.fileSource.isArchive:
-        return
-    import os, io
-    from arelle import XmlUtil, XbrlConst
-    from arelle.ValidateXbrlCalcs import inferredPrecision, inferredDecimals
-
-    XmlUtil.setXmlns(dts.modelDocument, "ptv", "http://www.xbrl.org/2003/ptv")
-
-    numFacts = 0
-
-    for fact in dts.facts:
-        try:
-            if fact.concept.periodType:
-                fact.set("{http://www.xbrl.org/2003/ptv}periodType", fact.concept.periodType)
-            if fact.concept.balance:
-                fact.set("{http://www.xbrl.org/2003/ptv}balance", fact.concept.balance)
-            if fact.isNumeric and not fact.isNil:
-                fact.set("{http://www.xbrl.org/2003/ptv}decimals", str(inferredDecimals(fact)))
-                fact.set("{http://www.xbrl.org/2003/ptv}precision", str(inferredPrecision(fact)))
-            numFacts += 1
-        except Exception as err:
-            dts.error("saveInfoset.exception",
-                     _("Facts exception %(fact)s %(value)s %(error)s."),
-                     modelObject=fact, fact=fact.qname, value=fact.effectiveValue, error = err)
-
-    fh = open(instanceInfosetFile, "w", encoding="utf-8")
-    XmlUtil.writexml(fh, dts.modelDocument.xmlDocument, encoding="utf-8")
-    fh.close()
-
-    dts.info("info:saveInstanceInfoset",
-             _("Instance infoset of %(entryFile)s has %(numberOfFacts)s facts in infoset file %(infosetOutputFile)s."),
-             modelObject=dts,
-             entryFile=dts.uri, numberOfFacts=numFacts, infosetOutputFile=instanceInfosetFile)
-
-def saveInstanceInfosetMenuEntender(cntlr, menu):
-    # Extend menu with an item for the save infoset plugin
-    menu.add_command(label="Save infoset",
-                     underline=0,
-                     command=lambda: saveInstanceInfosetMenuCommand(cntlr) )
-
-def saveInstanceInfosetMenuCommand(cntlr):
-    # save Infoset menu item has been invoked
-    from arelle.ModelDocument import Type
-    if cntlr.modelManager is None or cntlr.modelManager.modelXbrl is None or cntlr.modelManager.modelXbrl.modelDocument.type != Type.INSTANCE:
-        cntlr.addToLog("No instance loaded.")
-        return
-
-        # get file name into which to save log file while in foreground thread
-    instanceInfosetFile = cntlr.uiFileDialog("save",
-            title=_("arelle - Save instance infoset file"),
-            initialdir=cntlr.config.setdefault("infosetFileDir","."),
-            filetypes=[(_("Infoset file .xml"), "*.xml")],
-            defaultextension=".xml")
-    if not instanceInfosetFile:
-        return False
-    import os
-    cntlr.config["infosetFileDir"] = os.path.dirname(instanceInfosetFile)
-    cntlr.saveConfig()
-
-    try:
-        generateInstanceInfoset(cntlr.modelManager.modelXbrl, instanceInfosetFile)
-    except Exception as ex:
-        dts = cntlr.modelManager.modelXbrl
-        dts.error("exception",
-            _("Instance infoset generation exception: %(error)s"), error=ex,
-            modelXbrl=dts,
-            exc_info=True)
-
-def saveInstanceInfosetCommandLineOptionExtender(parser):
-    # extend command line options with a save DTS option
-    parser.add_option("--save-instance-infoset",
-                      action="store",
-                      dest="instanceInfosetFile",
-                      help=_("Save instance infoset in specified file, or to send testcase infoset out files to out directory specify 'generateOutFiles'."))
-
-def saveInstanceInfosetCommandLineXbrlLoaded(cntlr, options, modelXbrl, *args, **kwargs):
-    # extend XBRL-loaded run processing for this option
-    from arelle.ModelDocument import Type
-    if getattr(options, "instanceInfosetFile", None) and options.infosetFile == "generateOutFiles" and modelXbrl.modelDocument.type in (Type.TESTCASESINDEX, Type.TESTCASE):
-        cntlr.modelManager.generateInfosetOutFiles = True
-
-def saveInstanceInfosetCommandLineXbrlRun(cntlr, options, modelXbrl, *args, **kwargs):
-    # extend XBRL-loaded run processing for this option
-    if getattr(options, "instanceInfosetFile", None) and options.instanceInfosetFile != "generateOutFiles":
-        if cntlr.modelManager is None or cntlr.modelManager.modelXbrl is None:
-            cntlr.addToLog("No taxonomy loaded.")
-            return
-        generateInstanceInfoset(cntlr.modelManager.modelXbrl, options.instanceInfosetFile)
-
-def validateInstanceInfoset(dts, instanceInfosetFile):
-    if getattr(dts.modelManager, 'generateInfosetOutFiles', False):
-        generateInstanceInfoset(dts,
-                        # normalize file to instance
-                        dts.modelManager.cntlr.webCache.normalizeUrl(instanceInfosetFile, dts.uri))
-
-
-__pluginInfo__ = {
-    'name': 'Save Instance Infoset (PTV)',
-    'version': '0.9',
-    'description': "This plug-in adds a feature to output an instance \"ptv\" infoset.  "
-                    "(Does not offset infoset hrefs and schemaLocations for directory offset from DTS.) "
-                    "The ptv infoset is the source instance with facts having ptv:periodType, ptv:balance (where applicable), ptv:decimals and ptv:precision (inferred).  ",
-    'license': 'Apache-2',
-    'author': authorLabel,
-    'copyright': copyrightLabel,
-    # classes of mount points (required)
-    'CntlrWinMain.Menu.Tools': saveInstanceInfosetMenuEntender,
-    'CntlrCmdLine.Options': saveInstanceInfosetCommandLineOptionExtender,
-    'CntlrCmdLine.Xbrl.Loaded': saveInstanceInfosetCommandLineXbrlLoaded,
-    'CntlrCmdLine.Xbrl.Run': saveInstanceInfosetCommandLineXbrlRun,
-    'Validate.Infoset': validateInstanceInfoset,
-}

arelle/examples/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,
-}