arelle-release 2.37.47__py3-none-any.whl → 2.37.49__py3-none-any.whl

arelle/archive/SaveTableToExelle.py

@@ -1,140 +0,0 @@
-'''
-This module is an example to convert Html Tables into Xlsx (Excel) tables
-Preconfigured here to use SEC Edgar Rendering R files as input
-
-See COPYRIGHT.md for copyright information.
-'''
-import os, sys
-import regex as re
-from lxml import etree, html
-from openpyxl.workbook import Workbook
-from openpyxl.worksheet import ColumnDimension
-from openpyxl.cell import get_column_letter
-from openpyxl.style import Alignment
-
-class Report():
-    def __init__(self, longName, shortName, htmlFileName):
-        self.longName = longName
-        self.shortName = shortName
-        self.htmlFileName = htmlFileName
-    def __repr__(self):
-        return ("report(longName='{}', shortName='{}', htmlFileName='{}')"
-                .format(self.longName, self.shortName, self.htmlFileName))
-
-def intCol(elt, attrName, default=None):
-    try:
-        return int(elt.get(attrName, default))
-    except (TypeError, ValueError):
-        return default
-
-numberPattern = re.compile(r"\s*([$]\s*)?[(]?\s*[+-]?[0-9,]+([.][0-9]*)?[)-]?\s*$")
-displayNonePattern = re.compile(r"\s*display:\s*none;")
-
-def saveTableToExelle(rFilesDir):
-
-    # get reports from FilingSummary
-    reports = []
-    try:
-        fsdoc = etree.parse(os.path.join(rFilesDir, "FilingSummary.xml"))
-        for rElt in fsdoc.iter(tag="Report"):
-            reports.append(Report(rElt.findtext("LongName"),
-                                  rElt.findtext("ShortName"),
-                                  rElt.findtext("HtmlFileName")))
-    except (EnvironmentError,
-            etree.LxmlError) as err:
-        print("FilingSummary.xml: directory {0} error: {1}".format(rFilesDir, err))
-
-    wb = Workbook(encoding='utf-8')
-    # remove predefined sheets
-    for sheetName in wb.get_sheet_names():
-        ws = wb.get_sheet_by_name(sheetName)
-        if ws is not None:
-            wb.remove_sheet(ws)
-
-    sheetNames = set() # prevent duplicates
-
-    for reportNum, report in enumerate(reports):
-        sheetName = report.shortName[:31]  # max length 31 for excel title
-        if sheetName in sheetNames:
-            sheetName = sheetName[:31-len(str(reportNum))] + str(reportNum)
-        sheetNames.add(sheetName)
-        ws = wb.create_sheet(title=sheetName)
-
-        try:
-            # doesn't detect utf-8 encoding the normal way, pass it a string
-            #htmlSource = ''
-            #with open(os.path.join(rFilesDir, report.htmlFileName), 'rt', encoding='utf-8') as fh:
-            #    htmlSource = fh.read()
-            #rdoc = html.document_fromstring(htmlSource)
-            rdoc = html.parse(os.path.join(rFilesDir, report.htmlFileName))
-            row = -1
-            mergedAreas = {}  # colNumber: (colspan,lastrow)
-            for tableElt in rdoc.iter(tag="table"):
-                # skip pop up tables
-                if tableElt.get("class") ==  "authRefData":
-                    continue
-                if tableElt.getparent().tag == "div":
-                    style = tableElt.getparent().get("style")
-                    if style and displayNonePattern.match(style):
-                        continue
-                colWidths = {}
-                for rowNum, trElt in enumerate(tableElt.iter(tag="tr")):
-                    # remove passed mergedAreas
-                    for mergeCol in [col
-                                     for col, mergedArea in mergedAreas.items()
-                                     if mergedArea[1] > rowNum]:
-                        del mergedAreas[mergeCol]
-                    col = 0
-                    for coltag in ("th", "td"):
-                        for cellElt in trElt.iter(tag=coltag):
-                            if col == 0:
-                                row += 1 # new row
-                            if col in mergedAreas:
-                                col += mergedAreas[col][0] - 1
-                            text = cellElt.text_content()
-                            colspan = intCol(cellElt, "colspan", 1)
-                            rowspan = intCol(cellElt, "rowspan", 1)
-                            #if col not in colWidths:
-                            #    colWidths[col] = 10.0 # some kind of default width
-                            for elt in cellElt.iter():
-                                style = elt.get("style")
-                                if style and "width:" in style:
-                                    try:
-                                        kw, sep, width = style.partition("width:")
-                                        if "px" in width:
-                                            width, sep, kw = width.partition("px")
-                                            width = float(width) * 0.67777777
-                                        else:
-                                            width = float(width)
-                                        colWidths[col] = width
-                                    except ValueError:
-                                        pass
-                            if rowspan > 1:
-                                mergedAreas[col] = (colspan, row + rowspan - 1)
-                            cell = ws.cell(row=row,column=col)
-                            if text:
-                                cell.value = text
-                                if numberPattern.match(text):
-                                    cell.style.alignment.horizontal = Alignment.HORIZONTAL_RIGHT
-                                else:
-                                    cell.style.alignment.wrap_text = True
-                            if colspan > 1 or rowspan > 1:
-                                ws.merge_cells(start_row=row, end_row=row+rowspan-1, start_column=col, end_column=col+colspan-1)
-                            cell.style.alignment.vertical = Alignment.VERTICAL_TOP
-                            if coltag == "th":
-                                cell.style.alignment.horizontal = Alignment.HORIZONTAL_CENTER
-                                cell.style.font.bold = True
-                            cell.style.font.size = 9  # some kind of default size
-                            col += colspan
-                for col, width in colWidths.items():
-                    ws.column_dimensions[get_column_letter(col+1)].width = width
-        except (EnvironmentError,
-                etree.LxmlError) as err:
-            print("{0}: directory {1} error: {2}".format(report.htmlFileName, rFilesDir, err))
-
-    wb.save(os.path.join(rFilesDir, "exelleOut.xlsx"))
-
-if __name__ == "__main__":
-
-    # test directory
-    saveTableToExelle(r"C:\Users\Herm Fischer\Documents\mvsl\projects\SEC\14.1\R-files\wpoRfiles")

arelle/archive/TR3toTR4.py

@@ -1,88 +0,0 @@
-'''
-See COPYRIGHT.md for copyright information.
-License: https://www.apache.org/licenses/LICENSE-2.0
-
-usage: python3 {tr2 or tr3 input-file} {tr4 output-file}
-'''
-
-import io, os, sys, time
-from lxml import etree
-
-if len(sys.argv) < 3:
-    print("Please enter input and output filename arguments")
-    exit(1)
-INFILE = sys.argv[1]
-OUTFILE = sys.argv[2]
-
-if not INFILE or not os.path.isfile(INFILE) or not OUTFILE:
-    print("Please enter existing input filename and output filename")
-    exit(1)
-
-xhtmlNs = "http://www.w3.org/1999/xhtml"
-ixNS = "http://www.xbrl.org/2013/inlineXBRL"
-ixEltsWithFormat = ["{{{}}}{}".format(ixNS, localName) for localName in ("denominator", "numerator", "nonFraction", "nonNumeric")]
-xhtmlRootElts = ["{{{}}}{}".format(xhtmlNs, localName) for localName in ("html", "xhtml")]
-TR2NS = "http://www.xbrl.org/inlineXBRL/transformation/2011-07-31"
-TR3NS = "http://www.xbrl.org/inlineXBRL/transformation/2015-02-26"
-TR4NS = "http://www.xbrl.org/inlineXBRL/transformation/2020-02-12"
-TR23to4 = {
-    "booleanfalse": "fixed-false",
-    "booleantrue": "fixed-true",
-    "calindaymonthyear": "date-ind-day-monthname-year-hi",
-    "datedaymonth": "date-day-month",
-    "datedaymonthdk": "date-day-monthname-da",
-    "datedaymonthen": "date-day-monthname-en",
-    "datedaymonthyear": "date-day-month-year",
-    "datedaymonthyeardk": "date-day-monthname-year-da",
-    "datedaymonthyearen": "date-day-monthname-year-en",
-    "datedaymonthyearin": "date-day-monthname-year-hi", # does not handle this: Use date-day-month-year when using Devanagari numerals for the month, otherwise use date-day-monthname-year-hi.
-    "dateerayearmonthdayjp": "date-jpn-era-year-month-day",
-    "dateerayearmonthjp": "date-jpn-era-year-month",
-    "datemonthday": "date-month-day",
-    "datemonthdayen": "date-monthname-day-en",
-    "datemonthdayyear": "date-month-day-year",
-    "datemonthdayyearen": "date-monthname-day-year-en",
-    "datemonthyear": "date-month-year",
-    "datemonthyeardk": "date-monthname-year-da",
-    "datemonthyearen": "date-monthname-year-en",
-    "datemonthyearin": "date-monthname-year-hi",
-    "dateyearmonthday": "date-year-month-day",
-    "dateyearmonthdaycjk": "date-year-month-day",
-    "dateyearmonthcjk": "date-year-month",
-    "dateyearmonthen": "date-year-monthname-en",
-    "nocontent": "fixed-empty",
-    "numcommadecimal": "num-comma-decimal",
-    "numdotdecimal": "num-dot-decimal",
-    "numdotdecimalin": "num-dot-decimal",
-    "numunitdecimal": "num-unit-decimal",
-    "numunitdecimalin": "num-unit-decimal",
-    "zerodash": "fixed-zero"
-    }
-
-print("Parsing TR3 file {}".format(INFILE))
-startedAt = time.time()
-parser = etree.XMLParser(recover=True, huge_tree=True)
-with io.open(INFILE, "rb") as fh:
-    doc = etree.parse(fh,parser=parser,base_url=INFILE)
-
-# replace format TR3 with TR4
-nsToChange = set()
-for elt in doc.iter(*ixEltsWithFormat):
-    prefix, _sep, localName = elt.get("format", "").rpartition(":")
-    if localName:
-        ns = elt.nsmap.get(prefix)
-        if ns in (TR2NS, TR3NS):
-            if localName in TR23to4:
-                elt.set("format", "ixt:" + TR23to4[localName])
-                nsToChange.add(ns)
-            else:
-                print("{} line {}: nable to convert transform {}".format(elt.tag, elt.sourceline, elt.get("format")))
-
-# replace TR2 and TR3 namespaces in any xmlns'ed element
-outXhtml = etree.tostring(doc, encoding=doc.docinfo.encoding, xml_declaration=True)
-for ns in nsToChange:
-    outXhtml = outXhtml.replace(ns.encode(), TR4NS.encode())
-
-with io.open(OUTFILE, "wb", ) as fh:
-    fh.write(outXhtml)
-print("Converted in {:.3f} secs, TR4 file {}".format(time.time()-startedAt, INFILE))

arelle/archive/plugin/ESEF_2022/__init__.py

@@ -1,47 +0,0 @@
-"""
-See COPYRIGHT.md for copyright information.
-"""
-from __future__ import annotations
-
-from typing import Any
-
-from arelle.ModelDocument import LoadingException, ModelDocument
-from arelle.ModelXbrl import ModelXbrl
-from arelle.Version import authorLabel, copyrightLabel
-from arelle.typing import TypeGetText
-from arelle.utils.PluginHooks import PluginHooks
-
-_: TypeGetText
-
-
-class DeprecatedESEF2022Plugin(PluginHooks):
-    """
-    The 'validate/ESEF_2022' plugin has been merged into the `validate/ESEF` plugin using disclosure systems to select the year.
-    This implementation only exists to raise an error and inform users to migrate their configuration.
-    """
-
-    @staticmethod
-    def modelDocumentPullLoader(
-        modelXbrl: ModelXbrl,
-        normalizedUri: str,
-        filepath: str,
-        isEntry: bool,
-        namespace: str | None,
-        *args: Any,
-        **kwargs: Any,
-    ) -> ModelDocument | LoadingException | None:
-        message = _("The 'validate/ESEF_2022' plugin has been combined with the 'validate/ESEF' plugin. Please use the 'validate/ESEF' plugin with a 2022 disclosure system.")
-        modelXbrl.error("plugin:deprecated", message)
-        return LoadingException(message)
-
-
-__pluginInfo__ = {
-    "name": "Validate ESMA ESEF-2022",
-    "version": "1.2023.00",
-    "description": "Deprecated: use the 'validate/ESEF' plugin with a 2022 disclosure system instead.",
-    "license": "Apache-2",
-    "author": authorLabel,
-    "copyright": copyrightLabel,
-    "import": ("inlineXbrlDocumentSet",),
-    "ModelDocument.PullLoader": DeprecatedESEF2022Plugin.modelDocumentPullLoader,
-}

arelle/archive/plugin/bigInstance.py

@@ -1,394 +0,0 @@
-'''
-BigInstance is an example of 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.  SAX is used to parse the big instance.  ModelObjects are specialized by features
-for efficiency and to avoid dependency on an underlying DOM.
-
-See COPYRIGHT.md for copyright information.
-'''
-
-import xml.sax, io, sys
-from collections import defaultdict
-from arelle import XbrlConst, XmlUtil, XmlValidate
-from arelle.ModelDocument import ModelDocument, Type
-from arelle.ModelObject import ModelObject
-from arelle.ModelValue import QName
-from arelle.ModelInstanceObject import ModelContext, ModelFact, ModelUnit
-from arelle.Version import authorLabel, copyrightLabel
-
-class NotInstanceDocumentException(Exception):
-    def __init__(self):
-        pass
-
-sharedEmptyDict = {}
-sharedEmptyList = []
-
-qnIDattr = QName(None, None, "id")
-qnContextRefAttr = QName(None, None, "contextRef")
-qnUnitRefAttr = QName(None, None, "unitRef")
-qnPrecisionAttr = QName(None, None, "precision")
-qnDecimalsAttr = QName(None, None, "decimals")
-
-def initModelObject(obj, saxhandler, qname, attrs):
-    obj._elementQname = qname
-    obj._namespaceURI = qname.namespaceURI
-    obj._localName = qname.localName
-    obj.modelDocument = saxhandler.modelDocument
-    obj._sourceline = saxhandler.saxParser.getLineNumber()
-    obj._parent = saxhandler.qnameStack[0] if saxhandler.qnameStack else None
-    obj._attrs = dict((('{{{0}}}{1}'.format(*name) if name[0] else name[1]), value)
-                      for name, value in attrs.items())
-    obj._elementText = ''
-
-class BigInstModelObject(ModelObject):
-    def __init__(self, saxhandler, qname, attrs):
-        initModelObject(self, saxhandler, qname, attrs)
-        super(BigInstModelObject, self).init(saxhandler.modelDocument)
-
-    def getparent(self):
-        return self._parent
-
-    def items(self):
-        return self._attrs.items()
-
-    def get(self, clarkName):
-        return self._attrs.get(clarkName)
-
-    @property
-    def sourceline(self):
-        return self._sourceline
-
-    @property
-    def elementText(self):
-        return self._elementText
-
-class BigInstContext(ModelContext):
-    def __init__(self, saxhandler, qname, attrs):
-        initModelObject(self, saxhandler, qname, attrs)
-        super(BigInstContext, self).init(saxhandler.modelDocument)
-        self._isStartEndPeriod = self._isInstantPeriod = self._isForeverPeriod = False
-
-    def getparent(self):
-        return self._parent
-
-    def items(self):
-        return self._attrs.items()
-
-    def get(self, clarkName):
-        return self._attrs.get(clarkName)
-
-    @property
-    def sourceline(self):
-        return self._sourceline
-
-    @property
-    def elementText(self):
-        return self._elementText
-
-class BigInstUnit(ModelUnit):
-    def __init__(self, saxhandler, qname, attrs):
-        initModelObject(self, saxhandler, qname, attrs)
-        super(BigInstUnit, self).init(saxhandler.modelDocument)
-        self._measures = [[],[]]
-
-    def getparent(self):
-        return self._parent
-
-    def items(self):
-        return self._attrs.items()
-
-    def get(self, clarkName):
-        return self._attrs.get(clarkName)
-
-    @property
-    def sourceline(self):
-        return self._sourceline
-
-    @property
-    def elementText(self):
-        return self._elementText
-
-class BigInstFact(ModelFact):
-    __slots__ = ("_parent", "_concept", "_attrs", "_sourceline", "_elementText",
-                 "_context", "_conceptContextUnitLangHash",
-                 "_isItem", "_isTuple", "_isNumeric", "_isFraction",
-                 "_id", "_decimals", "_precision",
-                 "modelDocument", "objectIndex", "modelTupleFacts",
-                 "_parentBigInstObj", "_prevObj", "_nextObj",
-                 "xValid", "xValue", "sValue", "xAttributes")
-
-    # reimplement ancestorQnames, parentQname
-
-    def __init__(self, saxhandler, qname, attrs):
-        self._concept = saxhandler.modelXbrl.qnameConcepts.get(qname) # use the qname object of the DTS, not parser
-        self.modelDocument = saxhandler.modelDocument
-        self._sourceline = saxhandler.saxParser.getLineNumber()
-        self._parent = saxhandler.qnameStack[0] if saxhandler.qnameStack else None
-        self._context = self._unit = self._decimals = self._precision = self._id = None
-        self.xValid = 0 # unvalidated
-        self._attrs = sharedEmptyDict  # try with common shared emptyDict if no separate attributes
-        self._parentBigInstObj = self._prevObj = self._nextObj = 1234
-        for names, value in attrs.items():
-            attrNameURI, attrLocalName= names
-            if not attrNameURI:
-                if attrLocalName == "id":
-                    self._id = value
-                elif attrLocalName == "decimals":
-                    self._decimals = value
-                elif attrLocalName == "precision":
-                    self._precision = value
-                elif attrLocalName == "contextRef":
-                    self._context =  saxhandler.modelXbrl.contexts.get(value, 0)
-                    if self._context == 0: # provide dummmy non-none so attribute is present for validation
-                        saxhandler.contextRefedFacts[value].append(self)
-                elif attrLocalName == "unitRef":
-                    self._unit =  saxhandler.modelXbrl.units.get(value, 0)
-                    if self._unit == 0:
-                        saxhandler.unitRefedFacts[value].append(self)
-                else:
-                    if not self._attrs: self.attrs = {}  # stop using common shared emptyDict
-                    self._attrs[attrLocalName] = value
-            else:
-                if not self._attrs: self.attrs = {}  # stop using common shared emptyDict
-                self._attrs['{{{0}}}{1}'.format(attrNameURI, attrLocalName)] = value
-        self._elementText = ''
-        self.modelTupleFacts = sharedEmptyList
-        super(ModelFact, self).init(saxhandler.modelDocument)
-
-    def getparent(self):
-        return self._parent
-
-    def items(self):
-        return self._attrs.items()
-
-    def get(self, clarkName):
-        return self._attrs.get(clarkName)
-
-    @property
-    def sourceline(self):
-        return self._sourceline
-
-    @property
-    def concept(self):
-        return self._concept
-
-    @property
-    def qname(self):
-        return self._concept.qname
-
-    @property
-    def elementQname(self):
-        return self._concept.qname
-
-    @property
-    def namespaceURI(self):
-        return self._concept.qname.namespaceURI
-
-    @property
-    def localName(self):
-        return self._concept.qname.localName
-
-    @property
-    def elementText(self):
-        return self._elementText
-
-    @property
-    def contextID(self):
-        if self._context is not None:
-            return self._context.id
-        return None
-
-    @property
-    def slottedAttributesNames(self):
-        names = set()
-        if self._id: names.add(qnIDattr)
-        if self._context is not None: names.add(qnContextRefAttr)
-        if self._unit is not None: names.add(qnUnitRefAttr)
-        if self._decimals is not None: names.add(qnDecimalsAttr)
-        if self._precision is not None: names.add(qnPrecisionAttr)
-        return names
-
-    @property
-    def unitID(self):
-        if self._unit is not None:
-            return self._unit.id
-        return None
-
-class saxHandler(xml.sax.ContentHandler):
-    def __init__(self, saxParser, modelXbrl, mappedUri, filepath):
-        self.saxParser = saxParser
-        self.modelXbrl = modelXbrl
-        self.mappedUri = mappedUri
-        self.filepath = filepath
-        self.nsmap = {}
-        self.prefixmap = {}
-        self.qnameStack = []
-        self.currentNamespaceURI = None
-        self.modelDocument = None
-        self.contextRefedFacts = defaultdict(list)
-        self.unitRefedFacts = defaultdict(list)
-
-    def qname(self, prefixedName):
-        prefix, sep, localName = prefixedName.rpartition(":")
-        return QName(prefix, self.nsmap.get(prefix,None), localName)
-
-    def startPrefixMapping(self, prefix, uri):
-        self.nsmap[prefix] = uri
-        self.prefixmap[uri] = prefix
-
-    def endPrefixMapping(self, prefix):
-        if prefix in self.nsmap:
-            self.prefixmap.pop(self.nsmap[prefix], None)
-        self.nsmap.pop(prefix, None)
-
-    def startElementNS(self, name, qname, attrs):
-        namespaceURI, localName = name
-        prefix = self.prefixmap.get(namespaceURI, None)
-        thisQname = QName(prefix, namespaceURI, localName)
-        if not self.qnameStack:
-            if thisQname != XbrlConst.qnXbrliXbrl:  # not an instance document
-                self.modelXbrl = None # dereference
-                self.saxParser = None
-                raise NotInstanceDocumentException()
-            if self.modelDocument is None:
-                self.modelDocument = ModelDocument(self.modelXbrl, Type.INSTANCE, self.mappedUri, self.filepath, None)
-            parentQname = None
-        elif self.qnameStack:
-            parentElement = self.qnameStack[0]
-            parentQname = parentElement.elementQname
-        if namespaceURI in (XbrlConst.xbrli, XbrlConst.link):
-            if parentQname == XbrlConst.qnXbrliContext:
-                if localName == "identifier":
-                    parentElement._entityIdentifier = (attrs.get(None,"scheme"), "")
-                elif localName == "forever":
-                    parentElement._isForeverPeriod = True
-            else:
-                if localName == "context":
-                    thisModelObject = BigInstContext(self, thisQname, attrs)
-                    self.modelXbrl.contexts[thisModelObject.id] = thisModelObject
-                elif localName == "unit":
-                    thisModelObject = BigInstUnit(self, thisQname, attrs)
-                    self.modelXbrl.units[thisModelObject.id] = thisModelObject
-                else:
-                    thisModelObject = BigInstModelObject(self, thisQname, attrs)
-                if localName in ("schemaRef", "linkbaseRef"):
-                    self.modelDocument.discoverHref(thisModelObject)
-                else:
-                    self.qnameStack.insert(0, thisModelObject)
-        elif parentQname:
-            if parentQname == XbrlConst.qnXbrliContext:
-                if namespaceURI == XbrlConst.xbrldi:
-                    if localName == "explicitMember":
-                        self.dimensionPrefixedName = attrs.get(None,"dimension")
-            else: # might be a fact
-                thisModelObject = BigInstFact(self, thisQname, attrs)
-                if len(self.qnameStack) > 1:
-                    tuple = self.qnameStack[0]
-                    if not tuple.modelTupleFacts:
-                        tuple.modelTupleFacts = [] # allocate unshared list
-                    tuple.modelTupleFacts.append(thisModelObject)
-                else:
-                    self.modelXbrl.facts.append(thisModelObject)
-                self.qnameStack.insert(0, thisModelObject)  # build content
-        self.currentNamespaceURI = namespaceURI
-        self.currentLocalName = localName
-
-    def endElementNS(self, name, qname):
-        thisQname = QName(None, *name)
-        if self.qnameStack and self.qnameStack[0].elementQname == thisQname:
-            elt = self.qnameStack.pop(0)
-            if elt.namespaceURI == XbrlConst.xbrli:
-                if elt.localName == "unit":
-                    elt._measures = (sorted(elt._measures[0]), sorted(elt._measures[1]))
-                    if elt.id in self.unitRefedFacts:
-                        for fact in self.unitRefedFacts[elt.id]:
-                            fact._unit = elt
-                        del self.unitRefedFacts[elt.id]
-                elif elt.localName == "context":
-                    if elt.id in self.contextRefedFacts:
-                        for fact in self.contextRefedFacts[elt.id]:
-                            fact._context = elt
-                        del self.contextRefedFacts[elt.id]
-            self.currentNamespaceURI = None
-            self.currentLocalName = None
-            XmlValidate.validate(self.modelXbrl, elt, recurse=False)
-            pass
-
-    def characters(self, content):
-        if self.currentNamespaceURI:
-            elt = self.qnameStack[0]
-            if self.currentNamespaceURI == XbrlConst.xbrli:
-                s = content.strip()
-                if s:
-                    if self.currentLocalName == "identifier":
-                        elt._entityIdentifier = (elt._entityIdentifier[0], elt._entityIdentifier[1] + content)
-                    elif self.currentLocalName == "startDate":
-                        elt._startDatetime = XmlUtil.datetimeValue(s)
-                        elt._isStartEndPeriod = True
-                    elif self.currentLocalName == "endDate":
-                        elt._endDatetime = XmlUtil.datetimeValue(s, addOneDay=True)
-                        elt._isStartEndPeriod = True
-                    elif self.currentLocalName == "instant":
-                        elt._endDatetime = elt._instantDatetime = XmlUtil.datetimeValue(s, addOneDay=True)
-                        elt._isInstantPeriod = True
-                    elif self.currentLocalName == "measure":
-                        m = self.qname(content)
-                        parentEltLocalName = self.qnameStack[1].localName
-                        if parentEltLocalName == "unit":
-                            self.qnameStack[1]._measures[0].append(m)
-                        elif parentEltLocalName == "unitNumerator" and self.qnameStack[2].localName == "unit":
-                            self.qnameStack[2]._measures[0].append(m)
-                        elif parentEltLocalName == "unitDenominator" and self.qnameStack[2].localName == "unit":
-                            self.qnameStack[2]._measures[1].append(m)
-            elif self.currentNamespaceURI == XbrlConst.xbrldi:
-                s = content.strip()
-                if s:
-                    if self.currentLocalName == "explicitMember" and self.dimensionPrefixedName:
-                        dimQname = self.qname(self.currentLocalName)
-                        memQname = self.qname(s)
-                        dimConcept = self.modelXbrl.qnameConcepts.get(dimQname)
-                        memConcept = self.modelXbrl.qnameConcepts.get(memQname)
-            elif elt is not None:
-                elt._elementText += content
-
-    def skippedEntity(self, name):
-        print ("skipped entity={0}".format(name))
-
-class BigInstDocument:
-    def __init__(self, file, xbrlParser, saxParser, saxHandler):
-        self.file = file
-        self.xbrlParser = xbrlParser
-        self.saxParser = saxParser
-        self.saxHandler = saxHandler
-
-    def getroot(self):
-        return self.saxHandler.qnameStack[-1]
-
-def bigInstLoader(modelXbrl, file, mappedUri, filepath):
-    saxParser = xml.sax.make_parser()
-    saxParser.setFeature("http://xml.org/sax/features/namespaces", True)
-    saxParser.setFeature("http://xml.org/sax/features/external-general-entities", True)
-    saxhandler = saxHandler(saxParser, modelXbrl, mappedUri, filepath)
-    saxParser.setContentHandler(saxhandler)
-    try:
-        saxParser.parse(file)
-        return saxhandler.modelDocument
-    except NotInstanceDocumentException:
-        file.seek(0,io.SEEK_SET) # allow reparsing
-        return None
-
-'''
-   Do not use _( ) in pluginInfo itself (it is applied later, after loading
-'''
-
-__pluginInfo__ = {
-    'name': 'Big Instance Loader',
-    'version': '0.9',
-    'description': "This plug-in loads big XBRL instances without building a DOM in memory.  "
-                    "SAX parses XBRL directly into an object model without a DOM.  ",
-    'license': 'Apache-2',
-    'author': authorLabel,
-    'copyright': copyrightLabel,
-    # classes of mount points (required)
-    'ModelDocument.CustomLoader': bigInstLoader,
-}