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

arelle/plugin/saveOIMTaxonomy.py

@@ -0,0 +1,311 @@
+# -*- coding: utf-8 -*-
+'''
+saveOIMTaxonomy.py is a plug-in that saves an extension taxonomy in the json OIM taxonomy format
+
+See COPYRIGHT.md for copyright information.
+'''
+import os, io, json
+from arelle.Version import authorLabel, copyrightLabel
+from arelle import XbrlConst
+from collections import OrderedDict
+
+jsonDocumentType = "https://xbrl.org/PWD/2023-05-17/cti"
+jsonTxmyVersion = "1.0"
+primaryLang = "en"
+
+excludeImportNamespaces = {XbrlConst.xbrli, XbrlConst.xbrldt}
+
+def saveOIMTaxonomy(dts, jsonFile):
+    from arelle import ModelDocument, XmlUtil
+
+    # identify extension schema
+    namespacePrefixes = dict((ns, prefix) for prefix, ns in dts.prefixedNamespaces.items())
+    namespacesInUse = set()
+    extensionSchemaDoc = None
+    if dts.modelDocument.type == ModelDocument.Type.SCHEMA:
+        extensionSchemaDoc = dts.modelDocument
+    elif dts.modelDocument.type in (ModelDocument.Type.INSTANCE, ModelDocument.Type.INLINEXBRL, ModelDocument.Type.INLINEXBRLDOCUMENTSET):
+        for doc, docReference in dts.modelDocument.referencesDocument.items():
+            if "href" in docReference.referenceTypes:
+                extensionSchemaDoc = doc
+                extensionPrefix = namespacePrefixes[extensionSchemaDoc.targetNamespace]
+                namespacesInUse.add(extensionSchemaDoc.targetNamespace)
+                break
+    if extensionSchemaDoc is None:
+        dts.info("error:saveLoadableOIMTaxonomy",
+         _("Unable to identify extension taxonomy."),
+         modelObject=dts)
+        return
+
+    oimTxmy = OrderedDict()
+    oimTxmy["documentInfo"] = docInfo = OrderedDict()
+    docInfo["documentType"] = jsonDocumentType
+    docInfo["namespaces"] = namespaces = []
+    oimTxmy["taxonomy"] = txmy = OrderedDict()
+
+    # provide consistent order to taxonomy properties and objects
+    txmy["name"] = os.path.splitext(extensionSchemaDoc.basename)[0]
+    txmy["namespace"] = extensionSchemaDoc.targetNamespace
+    txmy["version"] = jsonTxmyVersion
+    txmy["entryPoint"] = os.path.basename(jsonFile)
+    txmy["importedTaxonomies"] = imports = []
+    txmy["concepts"] = concepts = []
+    txmy["cubes"] = cubes = []
+    txmy["domains"] = domains = []
+    txmy["networks"] = networks = []
+    txmy["relationships"] = relationships = []
+    txmy["labels"] = labels = []
+    sharedLabelRefs = {}
+    txmy["references"] = references = []
+
+    # taxonomy object
+    extensionLinkbaseDocs = {doc
+                             for doc, docReference in extensionSchemaDoc.referencesDocument.items()
+                             if "href" in docReference.referenceTypes and docReference.referringModelObject.elementQname == XbrlConst.qnLinkLinkbaseRef}
+    extensionLinkbaseDocs.add(extensionSchemaDoc)
+
+    labelsRelationshipSet = dts.relationshipSet(XbrlConst.conceptLabel)
+    for concept in sorted(set(dts.qnameConcepts.values()), key=lambda c:c.name): # may be twice if unqualified, with and without namespace
+        if concept.modelDocument == extensionSchemaDoc:
+            c = OrderedDict()
+            concepts.append(c)
+            c["name"] = str(concept.qname)
+            if concept.typeQname: # may be absent
+                c["dataType"] = str(concept.typeQname)
+            if concept.substitutionGroupQname:
+                c["substitutionGroup"] = str(concept.substitutionGroupQname)
+            if concept.periodType:
+                c["periodType"] = concept.periodType
+            if concept.balance:
+                c["balance"] = concept.balance
+            c["abstract"] = str(concept.abstract).lower()
+            c["nillable"] = str(concept.nillable).lower()
+        conceptLabels = dict(((lbl.role, lbl.xmlLang), lbl)
+                             for rel in labelsRelationshipSet.fromModelObject(concept)
+                             for lbl in (rel.toModelObject,)
+                             if lbl is not None)
+        for _key, label in sorted(conceptLabels.items(), key=lambda i:i[0]):
+            labelDupKey = (label.xmlLang, label.role, label.textValue)
+            if labelDupKey in sharedLabelRefs:
+                sharedLabelRefs[labelDupKey]["relatedId"].append(str(concept.qname))
+            else:
+                l = OrderedDict((
+                    ("relatedId", [str(concept.qname)]),
+                    ("language", label.xmlLang),
+                    ("labelType", os.path.basename(label.role)),
+                    ("value", label.textValue)))
+                labels.append(l)
+                sharedLabelRefs[labelDupKey] = l
+        # TBD add references here
+
+    # extended link roles defined in this document
+    networkOrder = 0
+    for roleURI, roleTypes in sorted(dts.roleTypes.items(),
+            # sort on definition if any else URI
+            key=lambda item: (item[1][0].definition if len(item[1]) and item[1][0].definition else item[0])):
+        for roleType in roleTypes:
+            if roleType.modelDocument == extensionSchemaDoc:
+                name = f"{extensionPrefix}:_{os.path.basename(roleURI)}_"
+                definition = roleType.definition
+                # define network concept (not in XBRL 2.1
+                c = OrderedDict((("name", name),
+                                 ("dataType","dtr:networkItemType"),
+                                 ("periodType", "duration"),
+                                 ("substitutionGroup", "xbrli:item"),
+                                 ("abstract", True),
+                                 ("nillable", True)))
+                concepts.append(c)
+                networks.append( OrderedDict((
+                    ("networkURI", roleType.roleURI),
+                    ("name", name))))
+                networkOrder += 1
+                relationships.append( OrderedDict((
+                    ("source", "xbrli:networkConcept"),
+                    ("target", name),
+                    ("order", networkOrder),
+                    ("networkURI", "https://www.xbrl.org/Network"),
+                    ("relationshipType", "root-child"))))
+                if definition:
+                    labels.append( OrderedDict((
+                        ("relatedId", [name]),
+                        ("language", primaryLang),
+                        ("labelType", XbrlConst.standardLabel),
+                        ("value", definition))))
+
+    # cubes by linkrole
+    for arcrole, linkrole, arcQN, linkQN in dts.baseSets.keys():
+        if arcrole == XbrlConst.all and linkrole is not None and arcQN is None and linkQN is None:
+            for rel in dts.relationshipSet(XbrlConst.all, linkrole).modelRelationships:
+                if rel.modelDocument not in extensionLinkbaseDocs:
+                    continue
+                hc = rel.toModelObject
+                priItem = rel.fromModelObject
+                if hc is not None and priItem is not None:
+                    dims = []
+                    dim = OrderedDict((("dimensionConcept", "xbrl:PrimaryDimension"),
+                                       ("domainID", priItem.name),
+                                       ("dimensionType", "xbrl:concept")))
+                    dims.append(dim)
+                    # priItem domains
+                    rels = []
+                    domains.append( OrderedDict((
+                        ("domainId", priItem.name),
+                        ("domainConcept", str(priItem.qname)),
+                        ("networkURI", rel.linkrole),
+                        ("relationships", rels))) )
+                    for domRel in dts.relationshipSet(XbrlConst.domainMember, rel.consecutiveLinkrole).fromModelObject(priItem):
+                        domObj = domRel.toModelObject
+                        if domObj is not None:
+                            rels.append( OrderedDict((
+                                ("source", str(priItem.qname)),
+                                ("target", str(domObj.qname)),
+                                ("order", domRel.order))) )
+                    # dimension domains
+                    for dimRel in dts.relationshipSet(XbrlConst.hypercubeDimension, rel.consecutiveLinkrole).fromModelObject(hc):
+                        dimObj = dimRel.toModelObject
+                        if dimObj is not None:
+                            dim = OrderedDict((("dimensionConcept", str(dimObj.qname)),
+                                               ("domainId", dimObj.name),
+                                               ("dimensionType", "explicit")))
+                            dims.append(dim)
+                            domRels = []
+                            domains.append( OrderedDict((
+                                ("domainId", dimObj.name),
+                                ("domainConcept", str(dimObj.qname)),
+                                ("networkURI", rel.linkrole),
+                                ("relationships", domRels))) )
+                            for domRel in dts.relationshipSet(XbrlConst.dimensionDomain, rel.consecutiveLinkrole).fromModelObject(dimObj):
+                                domObj = domRel.toModelObject
+                                if domObj is not None:
+                                    domRels.append( OrderedDict((
+                                        ("source", str(dimObj.qname)),
+                                        ("target", str(domObj.qname)),
+                                        ("order", domRel.order))) )
+                cubes.append( OrderedDict((
+                    ("name", str(hc.qname)),
+                    ("networkURI", rel.linkrole),
+                    ("cubeType", "aggregate"),
+                    ("dimensions", dims))) )
+
+    # domains
+
+    # tree walk recursive function
+    def treeWalk(depth, concept, arcrole, relSet, visited):
+        if concept is not None:
+            if concept not in visited:
+                visited.add(concept)
+                for rel in relSet.fromModelObject(concept):
+                    toConcept = rel.toModelObject
+                    if toConcept is not None:
+                        namespacesInUse.add(concept.qname.namespaceURI)
+                        namespacesInUse.add(toConcept.qname.namespaceURI)
+                        if rel.modelDocument in extensionLinkbaseDocs:
+                            relationships.append( OrderedDict((
+                                ("source", str(concept.qname)),
+                                ("target", str(toConcept.qname)),
+                                ("order", rel.order),
+                                ("networkURI", rel.linkrole),
+                                ("relationshipType", os.path.basename(rel.arcrole))) +
+                                ((("weight", rel.weight),) if rel.weight is not None else ())
+                                ) )
+                        row = treeWalk(depth + 1, toConcept, arcrole, relSet, visited)
+                visited.remove(concept)
+
+    # use presentation relationships for conceptsWs
+    for arcrole in (XbrlConst.parentChild,) + XbrlConst.summationItems:
+        # sort URIs by definition
+        linkroleUris = []
+        relationshipSet = dts.relationshipSet(arcrole)
+        if relationshipSet:
+            for linkroleUri in relationshipSet.linkRoleUris:
+                modelRoleTypes = dts.roleTypes.get(linkroleUri)
+                if modelRoleTypes:
+                    roledefinition = (modelRoleTypes[0].genLabel(strip=True) or modelRoleTypes[0].definition or linkroleUri)
+                else:
+                    roledefinition = linkroleUri
+                linkroleUris.append((roledefinition, linkroleUri))
+            linkroleUris.sort()
+
+            # for each URI in definition order
+            for roledefinition, linkroleUri in linkroleUris:
+                # elr relationships for tree walk
+                linkRelationshipSet = dts.relationshipSet(arcrole, linkroleUri)
+                for rootConcept in linkRelationshipSet.rootConcepts:
+                    # is root child required?
+                    treeWalk(0, rootConcept, arcrole, linkRelationshipSet, set())
+
+    for ns in sorted(namespacesInUse, key=lambda ns: namespacePrefixes[ns]):
+        namespaces.append(OrderedDict((("prefix", namespacePrefixes[ns]),
+                                       ("uri", ns))))
+
+    try:
+        with open(jsonFile, "w") as fh:
+            fh.write(json.dumps(oimTxmy, indent=3))
+
+        dts.info("info:saveOIMTaxonomy",
+            _("Saved OIM Taxonomy file: %(excelFile)s"),
+            excelFile=os.path.basename(jsonFile),
+            modelXbrl=dts)
+    except Exception as ex:
+        dts.error("exception:saveOIMTaxonomy",
+            _("File saving exception: %(error)s"), error=ex,
+            modelXbrl=dts)
+
+def saveOIMTaxonomyMenuEntender(cntlr, menu, *args, **kwargs):
+    # Extend menu with an item for the savedts plugin
+    menu.add_command(label="Save OIM Taxonomy",
+                     underline=0,
+                     command=lambda: saveOIMTaxonomyMenuCommand(cntlr) )
+
+def saveOIMTaxonomyMenuCommand(cntlr):
+    # save DTS menu item has been invoked
+    if cntlr.modelManager is None or cntlr.modelManager.modelXbrl is None:
+        cntlr.addToLog("No taxonomy loaded.")
+        return
+        # get file name into which to save log file while in foreground thread
+    jsonFile = cntlr.uiFileDialog("save",
+            title=_("arelle - Save OIM Taxonomy file"),
+            initialdir=cntlr.config.setdefault("OIMTaxonomyFileDir","."),
+            filetypes=[(_("OIM Taxonomy .json"), "*.json")],
+            defaultextension=".json")
+    if not jsonFile:
+        return False
+    import os
+    cntlr.config["OIMTaxonomyFileDir"] = os.path.dirname(jsonFile)
+    cntlr.saveConfig()
+
+    import threading
+    thread = threading.Thread(target=lambda
+                                  _dts=cntlr.modelManager.modelXbrl,
+                                  _jsonFile=jsonFile:
+                                        saveOIMTaxonomy(_dts, _jsonFile))
+    thread.daemon = True
+    thread.start()
+
+def saveOIMTaxonomyCommandLineOptionExtender(parser, *args, **kwargs):
+    # extend command line options with a save DTS option
+    parser.add_option("--save-OIM-taxonomy",
+                      dest="saveOIMTaxonomy",
+                      help=_("Save OIM Taxonomy file"))
+
+def saveOIMTaxonomyCommandLineXbrlRun(cntlr, options, modelXbrl, *args, **kwargs):
+    # extend XBRL-loaded run processing for this option
+    jsonFile = getattr(options, "saveOIMTaxonomy", None)
+    if jsonFile:
+        if cntlr.modelManager is None or cntlr.modelManager.modelXbrl is None:
+            cntlr.addToLog("No taxonomy loaded.")
+            return
+        saveOIMTaxonomy(cntlr.modelManager.modelXbrl, jsonFile)
+
+__pluginInfo__ = {
+    'name': 'Save OIM Taxonomy',
+    'version': '0.9',
+    'description': "This plug-in saves an OIM Taxonomy.",
+    'license': 'Apache-2',
+    'author': authorLabel,
+    'copyright': copyrightLabel,
+    # classes of mount points (required)
+    'CntlrWinMain.Menu.Tools': saveOIMTaxonomyMenuEntender,
+    'CntlrCmdLine.Options': saveOIMTaxonomyCommandLineOptionExtender,
+    'CntlrCmdLine.Xbrl.Run': saveOIMTaxonomyCommandLineXbrlRun,
+}

arelle/plugin/streamingExtensions.py

@@ -824,7 +824,7 @@ def streamingOptionsExtender(parser):
 '''
 
 def streamingExtensionsSetup(cntlr, options, *args, **kwargs):
-    global _streamingExtensionsCheck, _streamingExtensionsValidate
+    global _streamingExtensionsValidate
     # streaming only checked in CmdLine/web server mode if requested
     # _streamingExtensionsCheck = getattr(options, 'check_streaming', False)
     _streamingExtensionsValidate = options.validate

arelle/plugin/systemInfo.py

@@ -0,0 +1,46 @@
+"""
+System Info plugin provides python path display for debugging frozen code installation issues.
+
+See COPYRIGHT.md for copyright information.
+"""
+
+import logging
+import os
+import sys
+from typing import Any
+
+from arelle.Cntlr import Cntlr
+from arelle.RuntimeOptions import RuntimeOptions
+from arelle.utils.PluginHooks import PluginHooks
+from arelle.Version import authorLabel, copyrightLabel
+
+
+class ShowInfoPlugin(PluginHooks):
+
+    @staticmethod
+    def cntlrCmdLineUtilityRun(
+        cntlr: Cntlr,
+        options: RuntimeOptions,
+        *args: Any,
+        **kwargs: Any
+    ) -> None:
+        cntlr.addToLog(f"Python {sys.version}", messageCode="info", level=logging.DEBUG)
+        cntlr.addToLog("environment variables...", messageCode="info", level=logging.DEBUG)
+        cntlr.addToLog(f"sys.path={sys.path}", messageCode="info", level=logging.DEBUG)
+        cntlr.addToLog(f"LD_LIBRARY_PATH={os.environ.get('LD_LIBRARY_PATH', '')}", messageCode="info", level=logging.DEBUG)
+        cntlr.addToLog("options...")
+        for name, value in sorted(vars(options).items()):
+            if value is not None:
+                cntlr.addToLog(f"{name}={value}", messageCode="info", level=logging.DEBUG)
+
+
+__pluginInfo__ = {
+    "name": "System Info",
+    "version": "1.0",
+    "description": "This plug-in displays system information such as system path for debugging frozen installation.",
+    "license": "Apache-2",
+    "author": authorLabel,
+    "copyright": copyrightLabel,
+    # classes of mount points (required)
+    "CntlrCmdLine.Utility.Run": ShowInfoPlugin.cntlrCmdLineUtilityRun,
+}

arelle/plugin/transforms/tester.py

@@ -4,7 +4,7 @@ See COPYRIGHT.md for copyright information.
 This plugin allows GUI and command line users to test transforms.
 
 Custom extensions are also made available when their plugin has been loaded
-(e.g., for SEC custom transforms use plugin transforms/SEC, validate/EFM or EdgarRenderer)
+(e.g., for SEC custom transforms use plugin EDGAR/transforms, EDGAR/validate or EDGAR/render)
 
 Errors are shown both in results field as well as reported in the message pane (GUI) and reported in log (command line).
 
@@ -27,12 +27,12 @@ For command line operation:
 
     SEC transform example:
 
-    arelleCmdLine --plugins 'transforms/tester|transforms/SEC' --testTransform "ixt-sec durwordsen 23 days"
+    arelleCmdLine --plugins 'transforms/tester|EDGAR/SEC' --testTransform "ixt-sec durwordsen 23 days"
 
     Help instructions and list of available transforms:
 
     arelleCmdLine --plugins transforms/tester --testTransform 'help'  (or '?') or
-    arelleCmdLine --plugins 'transforms/tester|transforms/SEC' --testTransform 'help'
+    arelleCmdLine --plugins 'transforms/tester|EDGAR/transforms' --testTransform 'help'
 
 For REST API operation:
     web browser: http://localhost:8080/rest/xbrl/validation?plugins=transforms/tester&testTransform=ixt v3 datedaymonthen 29th February
@@ -154,7 +154,7 @@ def transformationTesterMenuExtender(cntlr, menu, *args, **kwargs):
             parent = self.mainWin.parent
             super(DialogTransformTester, self).__init__(parent)
             self.parent = parent
-            parentGeometry = re.match("(\d+)x(\d+)[+]?([-]?\d+)[+]?([-]?\d+)", parent.geometry())
+            parentGeometry = re.match(r"(\d+)x(\d+)[+]?([-]?\d+)[+]?([-]?\d+)", parent.geometry())
             dialogX = int(parentGeometry.group(3))
             dialogY = int(parentGeometry.group(4))
             self.selectedGroup = None

arelle/plugin/validate/CIPC/Const.py

@@ -12,6 +12,24 @@ cipcModules = {
     "ifrs_for_smes": "ifrs-smes"
     }
 
+mustNotBeHiddenElements = [
+    "cipc-ca:BusinessAddressCity",
+    "cipc-ca:BusinessAddressPostalCode",
+    "cipc-ca:BusinessAddressStreetName",
+    "cipc-ca:DisclosureOfDirectorsReportExplanatory",
+    "cipc-ca:DisclosureOfDirectorsResponsibilityExplanatory",
+    "cipc-ca:FullRegisteredNameOfCompany",
+    "cipc-ca:RegistrationNumberOfCompany",
+    "ifrs-full:DateOfEndOfReportingPeriod2013",
+    "ifrs-full:DescriptionOfNatureOfFinancialStatements",
+    "ifrs-full:DescriptionOfPresentationCurrency",
+    "ifrs-full:Revenue",
+    "ifrs-smes:DateOfEndOfReportingPeriod2013",
+    "ifrs-smes:DescriptionOfNatureOfFinancialStatements",
+    "ifrs-smes:DescriptionOfPresentationCurrency",
+    "ifrs-smes:Revenue",
+]
+
 ''' these validations now done by CIPC formulas
 mandatoryElements = {
     "ca_fas": {

arelle/plugin/validate/CIPC/__init__.py

@@ -1,28 +1,32 @@
-'''
-Filer Guidelines: http://www.cipc.co.za/files/8615/1333/0514/25082017_Guidelines_for_Filing__AFSs_in_XBRL_by_Client_Companies_Technical_Aspects_v1-7_HVMZ.pdf
+"""
+See COPYRIGHT.md for copyright information.
 
-Taxonomy Architecture: http://www.cipc.co.za/files/1715/1325/5802/CIPC_XBRL_Taxonomy_Framework_Architecture_-_2017-12-15.pdf
+Filer Guidelines:
+- [Technical Aspects](https://www.cipc.co.za/wp-content/uploads/2022/06/25082017_Guidelines_for_Filing_-AFSs_in_XBRL_by_Client_Companies_Technical_Aspects-v1-24-HV.pdf)
 
-Taxonomy package expected to be installed: http://xbrl.cipc.co.za/cipc_2017-12-15.zip
+Taxonomy Architecture:
+- [CIPC XBRL Taxonomy 2021 Framework architecture document](https://www.cipc.co.za/wp-content/uploads/2021/09/Taxonomy_Architecture_Framework.pdf)
 
-See COPYRIGHT.md for copyright information.
-'''
+Taxonomy packages:
+- [CIPC 2023](https://www.cipc.co.za/wp-content/uploads/2023/08/cipc_2023-09-07.zip)
+"""
 import os
 import regex as re
-from lxml.etree import _ElementTree, _Comment, _ProcessingInstruction
+from lxml.etree import _ElementTree, _Comment, _ProcessingInstruction, _Entity
 from arelle import ModelDocument, XbrlConst
 from arelle.ModelDtsObject import ModelResource
 from arelle.ModelInstanceObject import ModelFact, ModelInlineFact, ModelInlineFootnote
 from arelle.ModelObject import ModelObject
+from arelle.ModelValue import qname
 from arelle.Version import authorLabel, copyrightLabel
-from arelle.XbrlConst import ixbrlAll, xhtml
-from .Const import cipcModules # , mandatoryElements
+from arelle.XbrlConst import xhtml, qnIXbrl11Hidden
+from .Const import cipcModules, mustNotBeHiddenElements
 
 cipcBlockedInlineHtmlElements = {
     'object', 'script'}
 
 namePattern = re.compile(r"^(.*) - ((18|19|20)\d{2}-[0-9]+-(06|07|08|09|10|12|20|21|22|23|24|25|26|30|31)) - (20[1-9]\d)$")
-reportingModulePattern = re.compile(r"http://xbrl.cipc.co.za/taxonomy/.*/\w*(ca_fas|full_ifrs|ifrs_for_smes)\w*[_-]20[12][0-9]-[0-9]{2}-[0-9]{2}.xsd")
+reportingModulePattern = re.compile(r"https?://xbrl.cipc.co.za/taxonomy/.*/\w*(ca_fas|full_ifrs|ifrs_for_smes)\w*[_-]20[12][0-9]-[0-9]{2}-[0-9]{2}.xsd")
 
 TRANSFORMATION_REGISTRY_3 = {
     'namespace': 'http://www.xbrl.org/inlineXBRL/transformation/2015-02-26',
@@ -121,7 +125,7 @@ def validateXbrlFinally(val, *args, **kwargs):
                 eltTag = elt.tag
                 if isinstance(elt, ModelObject) and elt.namespaceURI == xhtml:
                     eltTag = elt.localName
-                elif isinstance(elt, (_ElementTree, _Comment, _ProcessingInstruction)):
+                elif isinstance(elt, (_ElementTree, _Comment, _ProcessingInstruction, _Entity)):
                     continue # comment or other non-parsed element
                 else:
                     eltTag = elt.tag
@@ -176,15 +180,32 @@ def validateXbrlFinally(val, *args, **kwargs):
         # build namespace maps
         nsMap = {}
         for ns in modelXbrl.namespaceDocs.keys():
-            if ns.endswith("/ca"):
+            if ns.endswith("taxonomy/ca"):
                 nsMap["cipc-ca"] = ns
-            elif ns.endswith("/ca/enum"):
+            elif ns.endswith("taxonomy/ca/enum"):
                 nsMap["cipc-ca-enum"] = ns
             elif ns.endswith("/ifrs-full"):
                 nsMap["ifrs-full"] = ns
             elif ns.endswith("/ifrs-smes"):
                 nsMap["ifrs-smes"] = ns
 
+        foundHiddenFacts = []
+        mustNotBeHiddenQnames = set()
+        for prefixedName in mustNotBeHiddenElements:
+            prefix, _sep, name = prefixedName.rpartition(":")
+            mustNotBeHiddenQnames.add(qname(nsMap.get(prefix), name))
+        for concept in mustNotBeHiddenQnames:
+            facts = val.modelXbrl.factsByQname.get(concept, ())
+            for fact in facts:
+                if qnIXbrl11Hidden in fact.ancestorQnames:
+                    foundHiddenFacts.append(fact)
+        if foundHiddenFacts:
+            modelXbrl.error("CIPC.MandatoryElementInHiddenSection",
+                            _("These mandatory concepts can not appear in a hidden section: %(facts)s."),
+                            modelObject=foundHiddenFacts,
+                            facts=", ".join(sorted(set(str(fact.qname) for fact in foundHiddenFacts)))
+                            )
+
         ''' checked by CIPC formula
         # build mandatory and footnoteIfNil tables by ns qname in use
         mandatory = set()

arelle/plugin/validate/DBA/DisclosureSystems.py

@@ -0,0 +1,12 @@
+ARL_2022_PREVIEW = "arl-2022-preview"
+ARL_2024_PREVIEW = "arl-2024-preview"
+ARL_2024_MULTI_TARGET_PREVIEW = "arl-2024-multi-target-preview"
+
+STAND_ALONE_DISCLOSURE_SYSTEMS = [
+    ARL_2022_PREVIEW,
+    ARL_2024_PREVIEW
+]
+
+MULTI_TARGET_DISCLOSURE_SYSTEMS = [
+    ARL_2024_MULTI_TARGET_PREVIEW
+]