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

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

arelle/examples/plugin/cmdWebServerExtension.py

@@ -1,42 +0,0 @@
-'''
-Example extension plugin to provide custom REST api
-
-See COPYRIGHT.md for copyright information.
-
-To run test:
-    arelleCmdLine.exe --webserver localhost:8080 --plugins ../examples/plugin/cmdWebServerExtension.py
-
-'''
-
-from arelle.CntlrWebMain import GET, Options, runOptionsAndGetResult
-from arelle.Version import copyrightLabel
-
-def my_test():
-    return _("<html><body><h1>Test</h1><p>It works!</p></body></html>")
-
-def my_run(file=None):
-    options = Options() # inspired by CntlrWebMain.validate
-    setattr(options, "entrypointFile", file)
-    setattr(options, "validate", True)
-    return runOptionsAndGetResult(options, "html", None, None)
-
-
-def startWebServer(app, cntlr, host, port, server):
-    # save
-    # register /test-response to send a test response string
-    app.route('/rest/my-test', "GET", my_test)
-    # register /test/my-run to do a normal "validate" wprkflow cycle but with custom parameters
-    app.route('/rest/my-run/<file:path>', ("GET", "POST"), my_run)
-
-    return None  # return "skip-routes" ## uncomment to block normal api REST "routes"
-
-__pluginInfo__ = {
-    'name': 'REST Extensions',
-    'version': '0.9',
-    'description': "Sample REST API extensions (or replacements).",
-    'license': 'Apache-2',
-    'author': 'R\xe9gis D\xce9camps',
-    'copyright': copyrightLabel,
-    # classes of mount points (required)
-    'CntlrWebMain.StartWebServer': startWebServer,
-}

arelle/examples/plugin/crashTest.py

@@ -1,38 +0,0 @@
-'''
-Crash test is a plug in to cause an uncaught exception to test its recover
-
-See COPYRIGHT.md for copyright information.
-'''
-from arelle.Version import authorLabel, copyrightLabel
-
-def crashMenuEntender(cntlr, menu):
-    menu.add_command(label="Crash now!!!", underline=0, command=lambda: crashMenuCommand(cntlr) )
-
-def crashMenuCommand(cntlr):
-    foo = 25
-    foo /= 0
-
-def crashCommandLineOptionExtender(parser):
-    parser.add_option("--crash-test",
-                      action="store_true",
-                      dest="crashTest",
-                      help=_('Test what happens with an exception'))
-
-def crashCommandLineXbrlRun(cntlr, options, modelXbrl, *args, **kwargs):
-    if getattr(options, "crashTest", False):
-        foo = 25
-        foo /= 0
-
-
-__pluginInfo__ = {
-    'name': 'Crash Test',
-    'version': '0.9',
-    'description': "Used to test that uncaught exceptions report their cause to the Arelle user.",
-    'license': 'Apache-2',
-    'author': authorLabel,
-    'copyright': copyrightLabel,
-    # classes of mount points (required)
-    'CntlrWinMain.Menu.Tools': crashMenuEntender,
-    'CntlrCmdLine.Options': crashCommandLineOptionExtender,
-    'CntlrCmdLine.Xbrl.Run': crashCommandLineXbrlRun,
-}

arelle/examples/plugin/formulaSuiteConverter.py

@@ -1,212 +0,0 @@
-'''
-XBRL formula conf suite converter
-   from Formula 1.0 to XF
-
-   arelleCmdline
-     --plugin formulaSuiteConverter
-     --source-test-suite-dir {directory containing index.xml file for suite)
-     --converted-test-suite-dir {directory receiving converted suite)
-
-
-See COPYRIGHT.md for copyright information.
-'''
-from arelle import ModelXbrl, XmlUtil
-from arelle.ModelDocument import Type
-from arelle.ModelValue import qname
-from arelle.ViewUtilFormulae import rootFormulaObjects, formulaObjSortKey
-from arelle.PluginManager import pluginClassMethods
-from arelle.PrototypeDtsObject import PrototypeObject
-from arelle.PythonUtil import attrdict
-from arelle.Version import authorLabel, copyrightLabel
-import os, shutil
-from lxml import etree
-import regex as re
-
-oimErrPattern = re.compile("(oime|xbrlxe):")
-QN_SCHEMA_REF = qname("{http://www.xbrl.org/2003/linkbase}schemaRef")
-
-def convertVariation(cntlr, variationFile, variationElt, inPath, outPath, entryPoint, resultInstFile):
-    entryFile = os.path.join(inPath, entryPoint)
-    modelXbrl = ModelXbrl.load(cntlr.modelManager, entryFile)
-    doc = modelXbrl.modelDocument
-    formulaRootObjects = rootFormulaObjects(modelXbrl) # sets var sets up
-    formulaFile = None
-    for formulaRootObject in sorted(formulaRootObjects, key=formulaObjSortKey):
-        formulaFile = formulaRootObject.modelDocument.basename # first formula file
-        break
-    # convert formula linkbaseRefs into shim schema refs
-    if doc.type in (Type.INSTANCE, Type.INLINEXBRL, Type.INLINEXBRLDOCUMENTSET):
-        for lbDoc, ref in doc.referencesDocument.items():
-            if lbDoc.type == Type.LINKBASE:
-                lbRef = lbDoc.basename
-                if lbRef == formulaFile:
-                    lbRef = os.path.splitext(lbRef)[0] + ".xf"
-                    lbDoc.uri = os.path.splitext(lbDoc.uri)[0] + ".xsd"
-                lbXsdFile = os.path.splitext(lbRef)[0] + ".xsd"
-                with open(os.path.join(outPath, lbXsdFile), "w", encoding="utf-8") as fh:
-                    fh.write("""
-<?xml version="1.0" encoding="utf-8"?>
-<schema
-    xmlns="http://www.w3.org/2001/XMLSchema"
-    xmlns:link="http://www.xbrl.org/2003/linkbase"
-    xmlns:xlink="http://www.w3.org/1999/xlink"
-    elementFormDefault="qualified">
-  <annotation>
-    <appinfo>
-      <link:linkbaseRef
-        xlink:href="{}"
-        xlink:type="simple"
-        xlink:arcrole="http://www.w3.org/1999/xlink/properties/linkbase"/>
-    </appinfo>
-  </annotation>
-</schema>
-""".format(lbRef))
-                lbDoc.type = Type.SCHEMA
-                ref.referringModelObject = PrototypeObject(ref.referringModelObject.modelDocument, ref.referringModelObject)
-                ref.referringModelObject.qname = QN_SCHEMA_REF
-
-    # perform OIM validation on xBRL-XML source instance
-    for pluginXbrlMethod in pluginClassMethods("Validate.XBRL.Finally"):
-        pluginXbrlMethod(doc)
-    if any(oimErrPattern.match(err) for err in modelXbrl.errors):
-        modelXbrl.error("testSuiteConverter:unconvertableTestcase",
-                        f"Variation {variationFile} {variationElt.get('id')} has OIM errors",
-                        modelObject=modelXbrl)
-        variationElt.getparent().remove(variationElt)
-        return {}
-    transformedFiles = {}
-    convertedFiles = {}
-    if formulaFile:
-        formulaOutFile = os.path.splitext(formulaFile)[0] + ".xf"
-        transformedFiles["xbrlFormulaFile"] = os.path.join(outPath, formulaOutFile)
-        convertedFiles[formulaFile] = formulaOutFile
-    if doc.type in (Type.INSTANCE, Type.INLINEXBRL, Type.INLINEXBRLDOCUMENTSET):
-        instOutFile = os.path.splitext(doc.basename)[0] + ".json"
-        transformedFiles["saveLoadableOIM"] = os.path.join(outPath, instOutFile)
-        convertedFiles[doc.basename] = instOutFile
-    # CntlrCmdLine.Xbrl.Run invokes both saveLoadableOIM for instance and formulaSaver for xf
-    options = attrdict(**transformedFiles)
-    try:
-        for pluginXbrlMethod in pluginClassMethods("CntlrCmdLine.Xbrl.Run"):
-            pluginXbrlMethod(cntlr, options, modelXbrl)
-    except Exception as ex:
-        modelXbrl.error("testSuiteConverter:unconvertableTestcase",
-                        f"Variation {variationFile} {variationElt.get('id')} is not transformable to XF or OIM: {ex}",
-                        modelObject=modelXbrl)
-        variationElt.getparent().remove(variationElt)
-        return {}
-    if resultInstFile:
-        resultOutFile = os.path.splitext(resultInstFile)[0] + ".json"
-        options = attrdict(saveLoadableOIM=os.path.join(outPath, resultOutFile))
-        convertedFiles[resultInstFile] = resultOutFile
-        try:
-            for pluginXbrlMethod in pluginClassMethods("CntlrCmdLine.Xbrl.Run"):
-                pluginXbrlMethod(cntlr, options, modelXbrl)
-        except Exception as ex:
-            modelXbrl.error("testSuiteConverter:unconvertableTestcase",
-                            f"Variation {variationFile} {variationElt.get('id')} is not transformable to XF or OIM: {ex}",
-                            modelObject=modelXbrl)
-            variationElt.getparent().remove(variationElt)
-            return {}
-    return convertedFiles
-
-def convertTestcase(cntlr, inPath, outPath, testcaseFile):
-    testcaseDir = os.path.dirname(testcaseFile)
-    indexTree = etree.parse(os.path.join(inPath, testcaseFile))
-    # check if an index to testcases
-    if indexTree.find("testcases") is not None:
-        for testcasesElt in indexTree.iter("testcases"):
-            # index to testcases
-            testcaseRoot = testcasesElt.get("root")
-            if testcaseRoot:
-                tcInPath = os.path.join(inPath, testcaseRoot)
-                tcOutPath = os.path.join(outPath, testcaseRoot)
-            else:
-                tcInPath = inPath
-                tcOutPath = outPath
-            if not os.path.exists(tcOutPath):
-                os.mkdir(tcOutPath)
-            for testcaseElt in testcasesElt.iter("testcase"):
-                convertTestcase(cntlr, tcInPath, tcOutPath, testcaseElt.get("uri"))
-    else:
-        # testcase file
-        convertedFiles = {}
-        for variationElt in indexTree.iter("{*}variation"):
-            readMeFirstElt = variationElt.find("*/*[@readMeFirst='true']")
-            readMeFirstFile = readMeFirstElt.text
-            resultInstElt = variationElt.find("{*}result/{*}instance")
-            if resultInstElt is not None:
-                resultInstFile = resultInstElt.text
-            else:
-                resultInstFile = None
-            if testcaseDir:
-                tcInPath = os.path.join(inPath, testcaseDir)
-                tcOutPath = os.path.join(outPath, testcaseDir)
-            else:
-                tcInPath = inPath
-                tcOutPath = outPath
-            if not os.path.exists(tcOutPath):
-                os.mkdir(tcOutPath)
-            if os.path.exists(os.path.join(tcInPath, readMeFirstFile)):
-                convertedFiles |= convertVariation(cntlr, os.path.basename(testcaseFile), variationElt, tcInPath, tcOutPath, readMeFirstFile, resultInstFile)
-        if convertedFiles:
-            # update testcase and copy over un-converted files
-            if testcaseDir:
-                tcInPath = os.path.join(inPath, testcaseDir)
-                tcOutPath = os.path.join(outPath, testcaseDir)
-            else:
-                tcInPath = inPath
-                tcOutPath = outPath
-            if not os.path.exists(tcOutPath):
-                os.mkdir(tcOutPath)
-            for elt in indexTree.iter():
-                if isinstance(elt.tag, str) and (elt.tag.endswith("schema") or elt.tag.endswith("linkbase") or elt.tag.endswith("instance")):
-                    if elt.text in convertedFiles:
-                        elt.text = convertedFiles[elt.text]
-                    else:
-                        srcFile = os.path.join(tcInPath, elt.text)
-                        if os.path.exists(srcFile):
-                            dstFile = os.path.join(tcOutPath, elt.text)
-                            dstdir = os.path.dirname(dstFile)
-                            if not os.path.exists(dstdir):
-                                os.mkdir(dstdir)
-                            shutil.copyfile(srcFile, dstFile)
-        tcOutFile = os.path.join(outPath, testcaseFile)
-        tcOutDir = os.path.dirname(tcOutFile)
-        if not os.path.exists(tcOutDir):
-            os.mkdir(tcOutDir)
-        with open(tcOutFile, "w", encoding="utf-8") as fh:
-            XmlUtil.writexml(fh, indexTree, indent="  ", encoding="utf-8")
-
-def convertSuite(cntlr, options, *args, **kwargs):
-    sourceSuiteDir = getattr(options, "sourceTestSuiteDir", None)
-    convertedSuiteDir = getattr(options, "convertedTestSuiteDir", None)
-    if not os.path.exists(sourceSuiteDir):
-        os.mkdir(sourceSuiteDir)
-    for testcaseFile in ("index.xml",):
-        convertTestcase(cntlr, sourceSuiteDir, convertedSuiteDir, testcaseFile)
-        shutil.copyfile(os.path.join(sourceSuiteDir, testcaseFile), os.path.join(convertedSuiteDir, testcaseFile))
-
-def commandLineOptionExtender(parser, *args, **kwargs):
-    parser.add_option("--source-test-suite-dir",
-                      action="store",
-                      dest="sourceTestSuiteDir",
-                      help=_("The source directory containing formula linkbase files to convert to XF."))
-    parser.add_option("--converted-test-suite-dir",
-                      action="store",
-                      dest="convertedTestSuiteDir",
-                      help=_("The destination directory to save the converted XF files."))
-
-__pluginInfo__ = {
-    'name': 'Formula Suite Converter',
-    'version': '0.9',
-    'description': "Convert XBRL Formula conformance suite to XF.",
-    'license': 'Apache-2',
-    'author': authorLabel,
-    'copyright': copyrightLabel,
-    # use formulaSaver tt output XF and saveLoadableOIM to output json instance
-    'import': ('formulaSaver', 'saveLoadableOIM', 'loadFromOIM'),
-    # classes of mount points (required)
-    'CntlrCmdLine.Options': commandLineOptionExtender,
-    'CntlrCmdLine.Utility.Run': convertSuite
-}