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

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'),
-    # classes of mount points (required)
-    'CntlrCmdLine.Options': commandLineOptionExtender,
-    'CntlrCmdLine.Utility.Run': convertSuite
-}

arelle/examples/plugin/functionsCustom.py

@@ -1,59 +0,0 @@
-'''
-Sample custom functions plugin for formula custom functions
-
-See COPYRIGHT.md for copyright information.
-'''
-from arelle import XbrlUtil
-from arelle.formula import XPathContext
-from arelle.ModelValue import qname
-from arelle.ModelInstanceObject import ModelDimensionValue
-from arelle.Version import authorLabel, copyrightLabel
-from decimal import Decimal
-
-# custom function for test case 22015 v01, same as in FunctionCustom.py
-def  test_22015v01_my_fn_PDxEV(xc, p, contextItem, args):
-    if len(args) != 2: raise XPathContext.FunctionNumArgs()
-    PDseq = args[0] if isinstance(args[0],(list,tuple)) else (args[0],)
-    EVseq = args[1] if isinstance(args[1],(list,tuple)) else (args[1],)
-    dimQname = qname("{http://www.example.com/wgt-avg}ExposuresDimension")
-    PDxEV = []
-    for pd in PDseq:
-        if pd.context is not None:
-            pdDim = pd.context.dimValue(dimQname)
-            for ev in EVseq:
-                if ev.context is not None:
-                    evDim = ev.context.dimValue(dimQname)
-                    if pdDim is not None and isinstance(pdDim,ModelDimensionValue):
-                        dimEqual =  pdDim.isEqualTo(evDim, equalMode=XbrlUtil.S_EQUAL2)
-                    elif evDim is not None and isinstance(evDim,ModelDimensionValue):
-                        dimEqual =  evDim.isEqualTo(pdDim, equalMode=XbrlUtil.S_EQUAL2)
-                    else:
-                        dimEqual = (pdDim == evDim)
-                    if dimEqual:
-                        PDxEV.append(pd.xValue * ev.xValue)
-                        # type promotion required
-                        if isinstance(pdX,Decimal) and isinstance(evX,float):
-                            pdX = float(pdX)
-                        elif isinstance(evX,Decimal) and isinstance(pdX,float):
-                            pdX = float(evX)
-                        PDxEV.append(pdX * evX)
-                        break
-    return PDxEV
-
-# returns dict of function QName and method executing the function
-def customFunctions():
-    return {
-        # sample function included for formula tests
-        qname("{http://www.example.com/wgt-avg/function}my-fn:PDxEV"): test_22015v01_my_fn_PDxEV
-    }
-
-__pluginInfo__ = {
-    'name': 'Custom Formula Functions (example)',
-    'version': '1.0',
-    'description': "This plug-in adds a custom function implemented by a plug-in.  ",
-    'license': 'Apache-2',
-    'author': authorLabel,
-    'copyright': copyrightLabel,
-    # classes of mount points (required)
-    'Formula.CustomFunctions': customFunctions,
-}

arelle/examples/plugin/hello_dolly.py

@@ -1,64 +0,0 @@
-'''
-Hello dolly is a simple "Hello world" to demonstrate how plug-ins
-are written for Arelle
-
-See COPYRIGHT.md for copyright information.
-'''
-from __future__ import print_function
-from arelle.Version import copyrightLabel
-from random import randint
-
-
-LYRICS =  ["I said hello, dolly,......well, hello, dolly", \
-            "It's so nice to have you back where you belong ", \
-            "You're lookin' swell, dolly.......i can tell, dolly ", \
-            "You're still glowin'...you're still crowin'...you're still goin' strong ", \
-            "I feel that room swayin'......while the band's playin' ", \
-            "One of your old favourite songs from way back when ", \
-            "So..... take her wrap, fellas.......find her an empty lap, fellas ", \
-            "Dolly'll never go away again"
-            ]
-
-def randomLyric():
-    ''' A random lyrics.'''
-    return LYRICS[randint(0, len(LYRICS) - 1)]
-
-def helloMenuEntender(cntlr, menu):
-    menu.add_command(label="Hello Dolly", underline=0, command=lambda: helloMenuCommand(cntlr, "Hello Dolly") )
-
-def helloMenuCommand(cntlr, label):
-    hello_dolly = randomLyric();
-    cntlr.addToLog(hello_dolly)
-    import tkinter
-    tkinter.messagebox.showinfo(label, hello_dolly, parent=cntlr.parent)
-
-def helloCommandLineOptionExtender(parser):
-    parser.add_option("--hello_dolly",
-                      action="store_true",
-                      dest="hello_dolly",
-                      help=_('Print a random lyric from "Hello, Dolly"'))
-
-def helloCommandLineUtilityRun(cntlr, options, **kwargs):
-    if getattr(options, "hello_dolly", False):
-        hello_dolly = randomLyric();
-        try:
-            cntlr.addToLog("[info] " + hello_dolly)
-        except:
-            print(hello_dolly)
-
-
-__pluginInfo__ = {
-    'name': 'Hello Dolly',
-    'version': '0.9',
-    'description': "This is not just a plug-in, it symbolizes the hope and enthusiasm "
-                    "of an entire generation summed up in two words sung most famously "
-                    "by Louis Armstrong: Hello, Dolly. When activated you will randomly "
-                    "see a lyric from Hello, Dolly.",
-    'license': 'Apache-2',
-    'author': 'R\xe9gis D\xce9camps',
-    'copyright': copyrightLabel,
-    # classes of mount points (required)
-    'CntlrWinMain.Menu.Tools': helloMenuEntender,
-    'CntlrCmdLine.Options': helloCommandLineOptionExtender,
-    'CntlrCmdLine.Utility.Run': helloCommandLineUtilityRun,
-}

arelle/examples/plugin/multi.py

@@ -1,58 +0,0 @@
-"""
-See COPYRIGHT.md for copyright information.
-"""
-from __future__ import annotations
-
-import logging
-import sys
-from typing import Any
-
-from arelle.Cntlr import Cntlr
-from arelle.PluginUtils import PluginProcessPoolExecutor
-from arelle.RuntimeOptions import RuntimeOptions
-from arelle.Version import authorLabel, copyrightLabel
-from arelle.utils.PluginHooks import PluginHooks
-
-
-def sumPositiveNumbers(vals: tuple[int, ...]) -> int:
-    if any(val < 1 for val in vals):
-        raise ValueError("Verify exceptions are logged.")
-    return sum(vals)
-
-
-class MultiPlugin(PluginHooks):
-    @staticmethod
-    def cntlrInit(
-        cntlr: Cntlr,
-        *args: Any,
-        **kwargs: Any,
-    ) -> None:
-        jobs = (
-            (0, 1),
-            (2, 3, 4),
-            (5, 6),
-            (7, 8, 9),
-        )
-        with PluginProcessPoolExecutor(sys.modules[__name__]) as pool:
-            jobFutures = [
-                pool.submit(sumPositiveNumbers, job)
-                for job in jobs
-            ]
-            val = 0
-            for future in jobFutures:
-                try:
-                    val += future.result(1)
-                except ValueError as e:
-                    cntlr.addToLog(messageCode="multi:error", message=str(e), level=logging.ERROR)
-            cntlr.addToLog(messageCode="multi:done", message=f"Computed val={val}")
-
-
-__pluginInfo__ = {
-    "name": "multi",
-    "version": "0.0.1",
-    "description": "multiprocessing example",
-    "license": "Apache-2",
-    "author": authorLabel,
-    "copyright": copyrightLabel,
-    "Cntlr.Init": MultiPlugin.cntlrInit,
-}

arelle/examples/plugin/rssSaveOim.py

@@ -1,96 +0,0 @@
-'''
-Rss Save OIM is a plug-in to the RSS GUI menu that will load an RSS filing's
-instances and save them as OIM files.
-
-See COPYRIGHT.md for copyright information.
-
-ViewWinRssFeed allows the GUI user to right-click on a filing.  This plugin
-adds a menu item to save the filing as OIM Json files.
-
-The identified filing is loaded in a separate thread (so the GUI is not blocked)
-and each (of possibly multiple) instances are saved to OIM JSON files.
-
-If there is only one instance it saves to the file name provided by the Save Dialog.
-If there are multiple instances (such as a multi-IXDS inline filing), the additional
-instances are saved under their base file name with replaced suffix json, in the
-directory chosen by the Save Dialog.
-
-This plug-in imports the following plug-ins:
-  saveLoadableOIM to save the xBRL-JSON instances
-  inlineXbrlDocumentSet for multi-doc or multi-IXDS filings
-  EDGAR/validate for isolation of multi-IXDS filings into primary and supplemental modelXbrl objects
-'''
-
-import os
-from arelle import ModelXbrl
-from arelle.FileSource import openFileSource
-from arelle.PluginManager import pluginClassMethods
-from arelle.Version import authorLabel, copyrightLabel
-
-def saveFilingOim(cntlr, zippedUrl, oimFile):
-    # load filing
-    modelXbrl = ModelXbrl.load(cntlr.modelManager,
-                               openFileSource(zippedUrl, cntlr))
-    if modelXbrl is not None:
-        for saveLoadableOIM in pluginClassMethods("SaveLoadableOim.Save"):
-            saveLoadableOIM(modelXbrl, oimFile)
-            modelXbrl.info("arelle:savedOIM", _("Saved OIM File {}").format(oimFile))
-        # check for supplemental instances
-        if hasattr(modelXbrl, "supplementalModelXbrls"):
-            oimFileDir = os.path.dirname(oimFile)
-            for supplementalModelXbrl in modelXbrl.supplementalModelXbrls:
-                # use basename for the json file
-                supplementalOimFile = os.path.join(oimFileDir, os.path.splitext(supplementalModelXbrl.basename)[0] + ".json")
-                for saveLoadableOIM in pluginClassMethods("SaveLoadableOim.Save"):
-                    saveLoadableOIM(supplementalModelXbrl, supplementalOimFile)
-                    modelXbrl.info("arelle:savedOIM",_("Saved OIM File {}").format(supplementalOimFile))
-                supplementalModelXbrl.close()
-        modelXbrl.close()
-
-
-def rssFeedFilingMenuExtender(viewRssFeed, menu, *args, **kwargs):
-    # Extend menu with an item for the savedts plugin
-    menu.add_command(label="Save Filing OIM",
-                     underline=0,
-                     command=lambda: saveFilingOimMenuCommand(viewRssFeed) )
-
-def saveFilingOimMenuCommand(viewRssFeed):
-    # save DTS menu item has been invoked
-    cntlr = viewRssFeed.modelXbrl.modelManager.cntlr
-    # get rssItemObj for the currently active row (if any)
-    rssItemObj = viewRssFeed.modelXbrl.modelObject(viewRssFeed.menuRow)
-    if rssItemObj is None:
-        return
-    # get file name into which to save log file while in foreground thread
-    oimFile = cntlr.uiFileDialog("save",
-            title=_("arelle - Save Filing OIM JSON file"),
-            initialdir=cntlr.config.setdefault("loadableExcelFileDir","."),
-            filetypes=[(_("JSON file .json"), "*.json")],
-            defaultextension=".json")
-    if not oimFile:
-        return False
-    import os
-    cntlr.config["loadableOIMFileDir"] = os.path.dirname(oimFile)
-    cntlr.saveConfig()
-
-    import threading
-    thread = threading.Thread(target=lambda
-                                  _cntlr=cntlr,
-                                  _zippedUrl=rssItemObj.zippedUrl,
-                                  _oimFile=oimFile:
-                                        saveFilingOim(_cntlr, _zippedUrl, _oimFile))
-    thread.daemon = True
-    thread.start()
-
-
-__pluginInfo__ = {
-    'name': 'Load RSS item and save OIM file',
-    'version': '1.0',
-    'description': "This plug-in saves an RSS-identified XBRL filing in OIM JSON files, for each instance of the filing.",
-    'license': 'Apache-2',
-    'author': authorLabel,
-    'copyright': copyrightLabel,
-    'import': ('saveLoadableOIM', 'inlineXbrlDocumentSet', 'EDGAR/validate'), # import dependent modules
-    # classes of mount points (required)
-    'RssFeed.Menu.Filing': rssFeedFilingMenuExtender
-}

arelle/examples/plugin/validate/XYZ/DisclosureSystems.py

@@ -1,2 +0,0 @@
-DISCLOSURE_SYSTEM_2022 = "XYZ 2022"
-DISCLOSURE_SYSTEM_2023 = "XYZ 2023"

arelle/examples/plugin/validate/XYZ/PluginValidationDataExtension.py

@@ -1,10 +0,0 @@
-"""
-See COPYRIGHT.md for copyright information.
-"""
-from __future__ import annotations
-
-from arelle.utils.PluginData import PluginData
-
-
-class PluginValidationDataExtension(PluginData):
-    positiveFactConcepts: set[str] | None = None

arelle/examples/plugin/validate/XYZ/ValidationPluginExtension.py

@@ -1,49 +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.ValidateXbrl import ValidateXbrl
-from arelle.typing import TypeGetText
-from arelle.utils.validate.ValidationPlugin import ValidationPlugin
-from .PluginValidationDataExtension import PluginValidationDataExtension
-
-_: TypeGetText
-
-
-class ValidationPluginExtension(ValidationPlugin):
-    def newPluginData(self, validateXbrl: ValidateXbrl) -> PluginValidationDataExtension:
-        return PluginValidationDataExtension(self.name)
-
-    def modelDocumentPullLoader(
-        self,
-        modelXbrl: ModelXbrl,
-        normalizedUri: str,
-        filepath: str,
-        isEntry: bool,
-        namespace: str | None,
-        *args: Any,
-        **kwargs: Any,
-    ) -> ModelDocument | LoadingException | None:
-        if self.disclosureSystemFromPluginSelected(modelXbrl):
-            return LoadingException(_("XYZ validation plugin is a template for new validation plugins and shouldn't be used directly."))
-        return None
-
-    def modelXbrlLoadComplete(
-        self,
-        modelXbrl: ModelXbrl,
-        *args: Any,
-        **kwargs: Any,
-    ) -> None:
-        if self.disclosureSystemFromPluginSelected(modelXbrl):
-            if modelXbrl.modelDocument is None:
-                modelXbrl.error(
-                    codes="XYZ.01.01",
-                    msg=_("An XBRL Report Package is required but could not be loaded"),
-                    modelObject=modelXbrl,
-                )
-        return None

arelle/examples/plugin/validate/XYZ/__init__.py

@@ -1,75 +0,0 @@
-"""
-See COPYRIGHT.md for copyright information.
-
-Filer Manual Guidelines: https://www.example.com/fake-xyz-filer-manual-v0.0.1.pdf
-"""
-from __future__ import annotations
-
-from pathlib import Path
-from typing import Any
-
-from arelle.ModelDocument import LoadingException, ModelDocument
-from arelle.Version import authorLabel, copyrightLabel
-from .ValidationPluginExtension import ValidationPluginExtension
-from .rules import rules01, rules02
-
-PLUGIN_NAME = "Validate XYZ"
-DISCLOSURE_SYSTEM_VALIDATION_TYPE = "XYZ"
-
-
-validationPlugin = ValidationPluginExtension(
-    name=PLUGIN_NAME,
-    disclosureSystemConfigUrl=Path(__file__).parent / "resources" / "config.xml",
-    validationTypes=[DISCLOSURE_SYSTEM_VALIDATION_TYPE],
-    validationRuleModules=[rules01, rules02],
-)
-
-
-def disclosureSystemTypes(*args: Any, **kwargs: Any) -> tuple[tuple[str, str], ...]:
-    return validationPlugin.disclosureSystemTypes
-
-
-def disclosureSystemConfigURL(*args: Any, **kwargs: Any) -> str:
-    return validationPlugin.disclosureSystemConfigURL
-
-
-def modelDocumentPullLoader(*args: Any, **kwargs: Any) -> ModelDocument | LoadingException | None:
-    return validationPlugin.modelDocumentPullLoader(*args, **kwargs)
-
-
-def modelXbrlLoadComplete(*args: Any, **kwargs: Any) -> None:
-    return validationPlugin.modelXbrlLoadComplete(*args, **kwargs)
-
-
-def validateXbrlStart(*args: Any, **kwargs: Any) -> None:
-    return validationPlugin.validateXbrlStart(*args, **kwargs)
-
-
-def validateXbrlFinally(*args: Any, **kwargs: Any) -> None:
-    return validationPlugin.validateXbrlFinally(*args, **kwargs)
-
-
-def validateXbrlDtsDocument(*args: Any, **kwargs: Any) -> None:
-    return validationPlugin.validateXbrlDtsDocument(*args, **kwargs)
-
-
-def validateFinally(*args: Any, **kwargs: Any) -> None:
-    return validationPlugin.validateFinally(*args, **kwargs)
-
-
-__pluginInfo__ = {
-    "name": PLUGIN_NAME,
-    "version": "0.0.1",
-    "description": "Example validation plugin for the fictitious XYZ taxonomy.",
-    "license": "Apache-2",
-    "author": authorLabel,
-    "copyright": copyrightLabel,
-    "DisclosureSystem.Types": disclosureSystemTypes,
-    "DisclosureSystem.ConfigURL": disclosureSystemConfigURL,
-    "ModelDocument.PullLoader": modelDocumentPullLoader,
-    "ModelXbrl.LoadComplete": modelXbrlLoadComplete,
-    "Validate.XBRL.Start": validateXbrlStart,
-    "Validate.XBRL.Finally": validateXbrlFinally,
-    "Validate.XBRL.DTS.document": validateXbrlDtsDocument,
-    "Validate.Finally": validateFinally,
-}

arelle/examples/plugin/validate/XYZ/resources/config.xml

@@ -1,16 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<DisclosureSystems
-        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-        xsi:noNamespaceSchemaLocation="../../../../config/disclosuresystems.xsd">
-    <!-- see arelle/config/disclosuresystems.xml for full comments -->
-    <DisclosureSystem
-            names="XYZ 2023|XYZ-2023|xyz-2023|XYZ|xyz"
-            description="Checks for example XYZ validation plugin for year 2023"
-            validationType="XYZ"
-    />
-    <DisclosureSystem
-            names="XYZ 2022|XYZ-2022|xyz-2022"
-            description="Checks for example XYZ validation plugin for year 2022"
-            validationType="XYZ"
-    />
-</DisclosureSystems>