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

arelle/plugin/validate/EFM/resources/vip-deprecated-concepts.json

@@ -1 +0,0 @@
-{}

arelle/plugin/validate/EFM/tools/CheckTxmyRefs.py

@@ -1,180 +0,0 @@
-'''
-Created by staff of the U.S. Securities and Exchange Commission.
-Data and content created by government employees within the scope of their employment are not subject
-to domestic copyright protection. 17 U.S.C. 105.
-
-To run
-   arelleCmdLine --plugin validate/EFM/tools/CheckTxmyRefs --disclosureSystem efm-pragmatic --report-file ../myReportFile.csv
-
-   if no --report-file the log entryies are printed to standard output stream
-
-pass 1: for each edgartaxonomy family, for each version,
-        load each href
-        check that it's in the standard taxonomies dict inferred from edgartaxonomies
-        check that each referenced URL from the href is also an href in edgartaxonomies
-        check that any ref and doc LBs in same cache dir are in TaxonomyAddonManager files
-
-pass 2: for each file found in an local-root directory by entries in fishInDirsForMissing
-        for pattern (such as fishing for files -sub-)
-        check if the file is loadable and if so if there are referenced files not in edgartaxonomies
-
-'''
-import os, regex as re
-from collections import defaultdict
-from lxml import etree
-from arelle.Version import authorLabel, copyrightLabel
-
-fishInDirsForMissing = {
-    "stx": {
-        "url-root": "https://xbrl.sec.gov",
-        # "local-root": r"C:/gns/w/git-osd/stx/xbrl.sec.gov",
-        "local-root": r"C:/gns/w/git-group2/sec-arelle/xbrl_taxonomies/xbrl_taxonomies/resources/System/cache/https/xbrl.sec.gov",
-        "entrypoint-pattern": "https?://xbrl.sec.gov/[^/]+/2023[^/]*/[^/]+(-sub-)[^.]+\.xsd"
-        }
-    # not sure what we load for US-GAAP and IFRS to determine needed ref and doc linkbases
-    }
-
-
-def utilityRun(cntlr, options, *args, **kwargs):
-    logLines = []
-    def log(line):
-        if options.reportFile:
-            logLines.append(line)
-        else:
-            print(line)
-    disclosureSystem = cntlr.modelManager.disclosureSystem
-    edTxmyTree = etree.parse(disclosureSystem.standardTaxonomiesUrl)
-    edTxmyFamilies = defaultdict(dict) # by Family, Version, set of Hrefs
-    edTxmyHrefs = set()
-    for locElt in edTxmyTree.iter("Loc"):
-        family = locElt.find("Family").text
-        version = locElt.find("Version").text
-        href = locElt.find("Href").text
-        txmyFamily = edTxmyFamilies[family]
-        txmyFamily.setdefault(version, set()).add(href)
-        edTxmyHrefs.add(href)
-
-    txmyAddOnTree = etree.parse(os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(os.path.dirname(__file__)))), "EdgarRenderer", "resources", "TaxonomyAddonManager.xml"))
-    txmyAddons = defaultdict(dict)
-    for txmyElt in txmyAddOnTree.iter("TaxonomyAddon"):
-        txmyAddon = txmyAddons[txmyElt.find("Taxonomy").text]
-        defsElt = txmyElt.find("DefinitionFiles")
-        if defsElt is not None:
-            for elt in defsElt.iter("string"):
-                txmyAddon.setdefault("doc", set()).add(elt.text)
-        refsElt = txmyElt.find("ReferenceFiles")
-        if refsElt is not None:
-            for elt in refsElt.iter("string"):
-                txmyAddon.setdefault("ref", set()).add(elt.text)
-
-    # check each edgartaxonomy family
-    for txmyFamily in edTxmyFamilies:
-        for familyVer in edTxmyFamilies[txmyFamily]:
-            for hRef in edTxmyFamilies[txmyFamily][familyVer]:
-                # check if it loads
-                modelXbrl = cntlr.modelManager.load(hRef)
-                if modelXbrl is not None:
-                    log(f"family {txmyFamily} ver {familyVer} href {hRef} loaded")
-                    if not hRef in disclosureSystem.standardTaxonomiesDict:
-                        log(f"family {txmyFamily} ver {familyVer} href {hRef} not in edgartaxonomies")
-                    for refUrl in modelXbrl.urlDocs:
-                        if refUrl not in edTxmyHrefs and refUrl != hRef:
-                            log(f"ref taxonomy also missing from edgartaxonomies: ref {refUrl}, loaded from {hRef}")
-                    if not re.match(".*([-_](lab|ref|pre|cal|def|sub)(-\n\n\n\n)?\.xsd)", hRef):
-                        cachePath = os.path.dirname(cntlr.webCache.getfilename(hRef))
-                        docRefs = defaultdict(set)
-                        for root, dir, files in os.walk(cachePath):
-                            for file in files:
-                                m = re.match(".*(doc|ref)\.(xsd|xml)", file)
-                                if m:
-                                    docRefs[m.group(1)].add(file)
-                        addOn = txmyAddons.get(os.path.basename(hRef))
-                        if addOn:
-                            if docRefs != addOn:
-                                for _type in ("doc", "ref"):
-                                    missing = ", ".join(set(docRefs.get(_type, {}.values())) - set(addOn.get(_type, {}.values())))
-                                    extra = ", ".join(set(addOn.get(_type, {}.values())) - set(docRefs.get(_type, {}.values())))
-                                    log(f"family {txmyFamily} ver {familyVer} href {hRef}, addon extra {_type}s: {extra}, addon missing {_type}s: {missing}")
-                        elif "-sub-" not in hRef and not hRef.endswith(".xml"):
-                            log(f"family {txmyFamily} ver {familyVer} href {hRef} not in TaxonomyAddons")
-                else:
-                    log(f"family {txmyFamily} ver {familyVer} href {hRef} DID NOT LOAD")
-    missingHrefs = set(disclosureSystem.standardTaxonomiesDict) - edTxmyHrefs
-    extraHrefs = edTxmyHrefs - set(disclosureSystem.standardTaxonomiesDict)
-    if missingHrefs:
-        log(f"disclosure system missing {', '.join(sorted(missingHrefs))}")
-    if extraHrefs:
-        log(f"disclosure system missing {', '.join(sorted(extraHrefs))}")
-    # fish in unzipped archive for file patterns
-    for repo in fishInDirsForMissing:
-        fileRoot = fishInDirsForMissing[repo]["local-root"]
-        urlRoot = fishInDirsForMissing[repo]["url-root"]
-        urlPattern = re.compile(fishInDirsForMissing[repo]["entrypoint-pattern"])
-        for root, dir, files in os.walk(fileRoot):
-            for file in files:
-                fullFilePath = os.path.join(root, file)
-                relativePath = fullFilePath[len(fileRoot)+1:]
-                hRef = os.path.join(urlRoot, relativePath)
-                if urlPattern.match(hRef):
-                    if hRef not in edTxmyHrefs:
-                        # check if it loads
-                        modelXbrl = cntlr.modelManager.load(hRef)
-                        if modelXbrl is not None:
-                            log(f"missing from edgartaxonomies: href {hRef}, loaded")
-                            for refUrl in modelXbrl.urlDocs:
-                                if refUrl not in edTxmyHrefs and refUrl != hRef:
-                                    log(f"ref taxonomy also missing from edgartaxonomies: ref {refUrl}, loaded from {hRef}")
-                            if not re.match(".*([-_](lab|ref|pre|cal|def|sub)(-\n\n\n\n)?\.xsd)", hRef):
-                                cachePath = os.path.dirname(cntlr.webCache.getfilename(hRef))
-                                docRefs = defaultdict(set)
-                                for root, dir, files in os.walk(cachePath):
-                                    for file in files:
-                                        m = re.match(".*(doc|ref)\.(xsd|xml)", file)
-                                        if m:
-                                            docRefs[m.group(1)].add(file)
-                                addOn = txmyAddons.get(os.path.basename(hRef))
-                                if not addOn:
-                                    log(f"ref {hRef} not in TaxonomyAddons")
-                                else:
-                                    if docRefs != addOn:
-                                        for _type in ("doc", "ref"):
-                                            missing = ", ".join(set(docRefs.get(_type, {}.values())) - set(addOn.get(_type, {}.values())))
-                                            extra = ", ".join(set(addOn.get(_type, {}.values())) - set(docRefs.get(_type, {}.values())))
-                                            log(f"family {txmyFamily} ver {familyVer} href {hRef}, addon extra {_type}s: {extra}, addon missing {_type}s: {missing}")
-                        else:
-                            log(f"missing from edgartaxonomies: {hRef} DID NOT LOAD")
-    if options.reportFile:
-        with open(options.reportFile, "w", encoding="utf-8") as fh:
-            fh.write("\n".join(logLines))
-
-def commandLineOptionExtender(parser, *args, **kwargs):
-    # extend command line options to store to database
-    parser.add_option("--report-file",
-                      action="store",
-                      dest="reportFile",
-                      help=_("Report file on taxonomy refs."))
-
-def dislosureSystemTypes(disclosureSystem, *args, **kwargs):
-    # return ((disclosure system name, variable name), ...)
-    return (("EFM", "EFMplugin"),)
-
-def disclosureSystemConfigURL(disclosureSystem, *args, **kwargs):
-    return os.path.join(os.path.dirname(os.path.dirname(__file__)), "config.xml")
-
-
-__pluginInfo__ = {
-    # Do not use _( ) in pluginInfo itself (it is applied later, after loading
-    'name': 'Check Taxonomy Refs',
-    'version': '1.0',
-    'description': '''
-Check edgartaxonomies.xml and taxonomyAddonManager.xml
-for completeness against supported year entry points.''',
-    'license': 'Apache-2',
-    'author': authorLabel,
-    'copyright': copyrightLabel,
-    # classes of mount points (required)
-    'CntlrCmdLine.Options': commandLineOptionExtender,
-    'CntlrCmdLine.Utility.Run': utilityRun,
-    'DisclosureSystem.Types': dislosureSystemTypes,
-    'DisclosureSystem.ConfigURL': disclosureSystemConfigURL,
-}

arelle/plugin/validate/EFM-htm/Const.py

@@ -1,205 +0,0 @@
-'''
-See COPYRIGHT.md for copyright information.
-'''
-from regex import compile as re_compile, match as re_match, DOTALL as re_DOTALL
-
-edgarAdditionalTags = {
-    "listing",
-    "plaintext",
-    "strike",
-    "xmp",
-    "page",
-    "exibitindex",
-    "r",
-    "segments",
-    "segment",
-    "module",
-    "name",
-    "cik",
-    "ccc"
-    } | set("f{}".format(i) for i in range(1,100))
-disallowedElements = {
-    "abbrev",
-    "acronym",
-    "applet",
-    "area",
-    "au",
-    "banner",
-    "base",
-    "basefont",
-    "bgsound",
-    "blink",
-    "col",
-    "colgroup",
-    "credit",
-    "del",
-    "embed",
-    "fig",
-    "fn",
-    "form",
-    "frame",
-    "frameset",
-    "input",
-    "ins",
-    "lang",
-    "lh",
-    "map",
-    "marquee",
-    "nextid",
-    "nobr",
-    "noembed",
-    "noframe",
-    "noframes",
-    "note",
-    "noscript",
-    "object",
-    "option",
-    "overlay",
-    "param",
-    "person",
-    "q",
-    "range",
-    "s",
-    "script",
-    "select",
-    "spot",
-    "style",
-    "tab",
-    "tbody",
-    "textarea",
-    "tfoot",
-    "thead",
-    "wbr",
-    "empty"
-    }
-
-disallowedElementAttrs = {
-    "body": ("background",),
-    "meta": ("http-equiv",),
-    "*": {
-        "onabort",
-        "onafterprint",
-        "onbeforeprint",
-        "onbeforeunload",
-        "onblur",
-        "oncanplay",
-        "oncanplaythrough",
-        "onchange",
-        "onclick",
-        "oncontextmenu",
-        "oncopy",
-        "oncuechange",
-        "oncut",
-        "ondblclick",
-        "ondrag",
-        "ondragend",
-        "ondragenter",
-        "ondragleave",
-        "ondragover",
-        "ondragstart",
-        "ondrop",
-        "ondurationchange",
-        "onemptied",
-        "onended",
-        "onerror",
-        "onfocus",
-        "onhashchange",
-        "oninput",
-        "oninvalid",
-        "onkeydown",
-        "onkeypress",
-        "onkeyup",
-        "onload",
-        "onloadeddata",
-        "onloadedmetadata",
-        "onloadstart",
-        "onmessage",
-        "onmousedown",
-        "onmousemove",
-        "onmouseout",
-        "onmouseover",
-        "onmouseup",
-        "onmousewheel",
-        "onoffline",
-        "ononline",
-        "onpagehide",
-        "onpageshow",
-        "onpaste",
-        "onpause",
-        "onplay",
-        "onplaying",
-        "onpopstate",
-        "onprogress",
-        "onratechange",
-        "onreset",
-        "onresize",
-        "onscroll",
-        "onsearch",
-        "onseeked",
-        "onseeking",
-        "onselect",
-        "onshow",
-        "onstalled",
-        "onstorage",
-        "onsubmit",
-        "onsuspend",
-        "ontimeupdate",
-        "ontoggle",
-        "onunload",
-        "onvolumechange",
-        "onwaiting",
-        "onwheel"
-        }
-    }
-requiredElementAttrs = {
-    "img": {"src"}
-    }
-recognizedElements = {
-    "address",
-    "b",
-    "big",
-    "blockquote",
-    "br",
-    "caption",
-    "center",
-    "cite",
-    "code",
-    "dd",
-    "dfn",
-    "dir",
-    "div",
-    "dl",
-    "dt",
-    "em",
-    "font",
-    "h1",
-    "h2",
-    "h3",
-    "h4",
-    "h5",
-    "h6",
-    "head",
-    "hr",
-    "i",
-    "img",
-    "isindex",
-    "kbd",
-    "li",
-    "menu",
-    "ol",
-    "p",
-    "pre",
-    "samp",
-    "small",
-    "strong",
-    "sub",
-    "sup",
-    "td",
-    "th",
-    "title",
-    "tr",
-    "tt",
-    "u",
-    "ul",
-    "var"
-    } | edgarAdditionalTags

arelle/plugin/validate/EFM-htm/__init__.py

@@ -1,217 +0,0 @@
-'''
-See COPYRIGHT.md for copyright information.
-'''
-import os, io
-from lxml.etree import HTMLParser, parse, DTD, _ElementTree, _Comment, _ProcessingInstruction
-from regex import compile as re_compile, match as re_match, DOTALL as re_DOTALL
-from arelle import ValidateFilingText
-from arelle.ModelDocument import Type, create as createModelDocument
-from arelle.UrlUtil import isHttpUrl, scheme
-from arelle.Version import authorLabel, copyrightLabel
-from .Const import edgarAdditionalTags, disallowedElements, disallowedElementAttrs, recognizedElements
-
-def dislosureSystemTypes(disclosureSystem, *args, **kwargs):
-    # return ((disclosure system name, variable name), ...)
-    return (("EFM", "EFMHTMplugin"),)
-
-def disclosureSystemConfigURL(disclosureSystem, *args, **kwargs):
-    return os.path.join(os.path.dirname(__file__), "config.xml")
-
-def validateXbrlStart(val, parameters=None, *args, **kwargs):
-    val.validateEFMHTMplugin = val.validateDisclosureSystem and getattr(val.disclosureSystem, "EFMHTMplugin", False)
-    if not (val.validateEFMHTMplugin):
-        return
-
-def validateXbrlFinally(val, *args, **kwargs):
-    if not (val.validateEFMHTMplugin):
-        return
-
-    modelXbrl = val.modelXbrl
-    allowedExternalHrefPattern = modelXbrl.modelManager.disclosureSystem.allowedExternalHrefPattern
-    #efmHtmDTD = None
-    #with open(os.path.join(os.path.dirname(__file__), "resources", "efm-htm.dtd")) as fh:
-    #    efmHtmDTD = DTD(fh)
-    #if efmHtmDTD and not efmHtmDTD.validate( modelXbrl.modelDocument.xmlRootElement ):
-    #    for e in efmHtmDTD.error_log.filter_from_errors():
-    #        if "declared in the external subset contains white spaces nodes" not in e.message:
-    #            modelXbrl.error("html.syntax",
-    #                _("HTML error %(error)s"),
-    #                error=e.message)
-    numHtmlTags = 0
-    inBody = False
-    for elt in modelXbrl.modelDocument.xmlRootElement.iter():
-        if isinstance(elt, (_ElementTree, _Comment, _ProcessingInstruction)):
-            continue # comment or other non-parsed element
-        eltTag = elt.tag.lower()
-        for attrTag, attrValue in elt.items():
-            if ((attrTag == "href" and eltTag == "a") or
-                (attrTag == "src" and eltTag == "img")):
-                if "javascript:" in attrValue:
-                    modelXbrl.error("EFM.5.02.02.10.activeContent",
-                        _("Element has javascript in '%(attribute)s' for <%(element)s>"),
-                        modelObject=elt, attribute=attrTag, element=eltTag)
-                elif eltTag == "a" and (not allowedExternalHrefPattern or allowedExternalHrefPattern.match(attrValue)):
-                    pass
-                elif scheme(attrValue) in ("http", "https", "ftp", "mailto"):
-                    modelXbrl.error("EFM.6.05.16.externalReference",
-                        _("Element has an invalid external reference in '%(attribute)s' for <%(element)s>"),
-                        modelObject=elt, attribute=attrTag, element=eltTag)
-                if attrTag == "src":
-                    if scheme(attrValue)  == "data":
-                        modelXbrl.error("EFM.5.02.02.10.graphicDataUrl",
-                            _("Element references a graphics data URL which isn't accepted '%(attribute)s' for <%(element)s>"),
-                            modelObject=elt, attribute=attrValue[:32], element=eltTag)
-                    elif attrValue.lower()[-4:] not in ('.jpg', '.gif'):
-                        modelXbrl.error("EFM.5.02.02.10.graphicFileType",
-                            _("Element references a graphics file which isn't .gif or .jpg '%(attribute)s' for <%(element)s>"),
-                            modelObject=elt, attribute=attrValue, element=eltTag)
-            elif attrTag in disallowedElementAttrs.get(eltTag,()) or attrTag in disallowedElementAttrs["*"]:
-                modelXbrl.error("EFM.5.02.02.05.disallowedAttribute",
-                    _("Element has disallowed attribute '%(attribute)s' for <%(element)s>"),
-                    modelObject=elt, attribute=attrTag, element=eltTag)
-            elif attrTag.startswith("xmlns"):
-                modelXbrl.error("EFM.5.02.02.05.xmlns",
-                    _("Element has disallowed xmlns declaration '%(attribute)s' for <%(element)s>"),
-                    modelObject=elt, attribute=attrTag, element=eltTag)
-        if eltTag == "html":
-            numHtmlTags += 1
-            if numHtmlTags > 1:
-                modelXbrl.error("EFM.5.02.02.02.htmlTags",
-                    _("Document can only have one html tag"),
-                    modelObject=elt)
-        elif eltTag in ("head", "meta", "isindex", "title"):
-            pass # these are allowed
-        elif eltTag == "body":
-            inBody = True
-        elif eltTag == "table":
-            if any(a is not None for a in elt.iterancestors("table")):
-                modelXbrl.error("EFM.5.02.02.10.nestedTable",
-                    _("Element is a disallowed nested <table>."),
-                    modelObject=elt)
-        elif eltTag in disallowedElements:
-            modelXbrl.error("EFM.5.02.02.04.disallowedElement",
-                _("Element is disallowed: <%(element)s>"),
-                modelObject=elt, element=eltTag)
-        elif eltTag not in recognizedElements:
-            modelXbrl.error("EFM.5.02.02.03.unrecognizedElement",
-                _("Element is not recognized: <%(element)s>"),
-                modelObject=elt, element=eltTag)
-        elif not inBody:
-            modelXbrl.error("EFM.5.02.02.03.bodyTags",
-                _("Element is not in a body: <%(element)s>"),
-                modelObject=elt, element=eltTag)
-
-def filingStart(cntlr, options, filesource, entrypointFiles, sourceZipStream=None, responseZipStream=None, *args, **kwargs):
-    modelManager = cntlr.modelManager
-    if modelManager.validateDisclosureSystem and (getattr(modelManager.disclosureSystem, "EFMHTMplugin", False)):
-        pass
-
-def xbrlLoaded(cntlr, options, modelXbrl, entryPoint, *args, **kwargs):
-    # cntlr.addToLog("TRACE EFM xbrl loaded")
-    modelManager = cntlr.modelManager
-
-
-def xbrlRun(cntlr, options, modelXbrl, *args, **kwargs):
-    # cntlr.addToLog("TRACE EFM xbrl run")
-    modelManager = cntlr.modelManager
-
-def filingValidate(cntlr, options, filesource, entrypointFiles, sourceZipStream=None, responseZipStream=None, *args, **kwargs):
-    # cntlr.addToLog("TRACE EFM xbrl validate")
-    modelManager = cntlr.modelManager
-
-def filingEnd(cntlr, options, filesource, entrypointFiles, sourceZipStream=None, responseZipStream=None, *args, **kwargs):
-    #cntlr.addToLog("TRACE EFM filing end")
-    modelManager = cntlr.modelManager
-
-def isLoadableHtml(modelXbrl, mappedUri, normalizedUri, filepath, **kwargs):
-    global lastFilePath, lastFilePathIsHTML
-    lastFilePath = filepath
-    lastFilePathIsHTML = False
-    _ext = os.path.splitext(filepath)[1]
-    if _ext.lower() in (".htm", ".html"):
-        try:
-            file, _encoding = modelXbrl.fileSource.file(filepath, stripDeclaration=False)
-            _fileStart = file.read(4096)
-            file.close()
-            if _fileStart and re_match(r"(?!.*<[?]xml\s).*<html.*>", _fileStart):
-                lastFilePathIsHTML = True
-        except Exception as err:
-            return False
-    return lastFilePathIsHTML
-
-def htmlLoader(modelXbrl, mappedUri, filepath, *args, **kwargs):
-    if filepath != lastFilePath or not lastFilePathIsHTML:
-        return None # not an HTML file
-
-    cntlr = modelXbrl.modelManager.cntlr
-    cntlr.showStatus(_("Loading HTML file: {0}").format(os.path.basename(filepath)))
-    # parse html
-    try:
-        if (modelXbrl.modelManager.validateDisclosureSystem and
-            modelXbrl.modelManager.disclosureSystem.validateFileText):
-            file, _encoding = ValidateFilingText.checkfile(modelXbrl,filepath)
-        else:
-            file, _encoding = modelXbrl.fileSource.file(filepath, stripDeclaration=False)
-        _parser = HTMLParser()
-        htmlTree = parse(file, _parser, base_url=filepath)
-        for error in _parser.error_log:
-            if not (error.type_name == "HTML_UNKNOWN_TAG" and
-                    error.message.startswith("Tag ") and
-                    error.message.lower()[4:].partition(" ")[0] in edgarAdditionalTags):
-                modelXbrl.error("html:syntax",
-                        _("%(error)s, %(fileName)s, line %(line)s, column %(column)s"),
-                        fileName=os.path.basename(mappedUri),
-                        error=error.message, line=error.line, column=error.column)
-        file.close()
-    except Exception as err:
-        modelXbrl.error(type(err).__name__,
-                _("Unrecoverable error: %(error)s, %(fileName)s"),
-                fileName=os.path.basename(mappedUri),
-                error=str(err), exc_info=True)
-        return None
-    if modelXbrl: # pull loader implementation
-        modelXbrl.blockDpmDBrecursion = True
-        modelXbrl.modelDocument = doc = createModelDocument(
-              modelXbrl,
-              Type.HTML,
-              filepath,
-              isEntry=True,
-              documentEncoding="utf-8",
-              base=filepath)
-    else: # API implementation
-        modelXbrl = ModelXbrl.create(
-            cntlr.modelManager,
-            Type.HTML,
-            filepath,
-            isEntry=True,
-            base=filepath)
-        doc = modelXbrl.modelDocument
-    doc.xmlRootElement = htmlTree.getroot()
-
-    if doc is None:
-        return None # not an HTML file
-    modelXbrl.loadedFromHTML = True
-    return doc
-
-
-__pluginInfo__ = {
-    # Do not use _( ) in pluginInfo itself (it is applied later, after loading
-    'name': 'Validate EFM non-XBRL HTM',
-    'version': '1.20.3', # SEC EDGAR release 20.3
-    'description': '''EFM non-XBRL HTM Validation.''',
-    'license': 'Apache-2',
-    'author': authorLabel,
-    'copyright': copyrightLabel,
-    # classes of mount points (required)
-    'ModelDocument.IsPullLoadable': isLoadableHtml,
-    'ModelDocument.PullLoader': htmlLoader,
-    'DisclosureSystem.Types': dislosureSystemTypes,
-    'DisclosureSystem.ConfigURL': disclosureSystemConfigURL,
-    'Validate.XBRL.Start': validateXbrlStart,
-    'Validate.XBRL.Finally': validateXbrlFinally,
-    'CntlrCmdLine.Filing.Start': filingStart,
-    'CntlrCmdLine.Xbrl.Loaded': xbrlLoaded,
-    'CntlrCmdLine.Xbrl.Run': xbrlRun,
-    'CntlrCmdLine.Filing.Validate': filingValidate,
-    'CntlrCmdLine.Filing.End': filingEnd,
-}

arelle/plugin/validate/EFM-htm/config.xml

@@ -1,17 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- (c) Copyright 2017 Mark V Systems Limited, All rights reserved. -->
-<DisclosureSystems  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
-      xsi:noNamespaceSchemaLocation="../../../config/disclosuresystems.xsd" >
-  <!-- see ../config/disclosuresystem.xml for full comments -->
-   
-  <DisclosureSystem 
-     names="US SEC HTML (Edgar Filing Manual 5.2.2)|efm-htm"
-     description="US SEC non-XBRL HTML Edgar Filing Manual v54 Release 20.3"
-     validationType="EFM"
-     exclusiveTypesPattern="EFM|GFM|FERC|HMRC|SBR.NL|EFM"
-     validateFileText="true"
-     validateEntryText="true"
-     allowedExternalHrefPattern="https?://www.sec.gov/(ix[?]doc=/)?Archives/edgar/data/"
-     />
-
-</DisclosureSystems>