arelle-release 2.37.36__tar.gz → 2.37.38__tar.gz

{arelle_release-2.37.36/arelle_release.egg-info → arelle_release-2.37.38}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: arelle-release
-Version: 2.37.36
+Version: 2.37.38
 Summary: An open source XBRL platform.
 Author-email: "arelle.org" <support@arelle.org>
 License-Expression: Apache-2.0

{arelle_release-2.37.36 → arelle_release-2.37.38}/arelle/ModelTestcaseObject.py

@@ -363,7 +363,11 @@ class ModelTestcaseVariation(ModelObject):
     def expectedWarnings(self):
         warningElements = XmlUtil.descendants(self, None, "warning")
         if isinstance(warningElements, list) and len(warningElements) > 0:
-            return [w.stringValue for w in warningElements]
+            warningCodes = []
+            for warningElement in warningElements:
+                num = int(warningElement.attr("num") or 1)
+                warningCodes.extend([warningElement.stringValue] * num)
+            return warningCodes
         return None
 
     @property

{arelle_release-2.37.36 → arelle_release-2.37.38}/arelle/ModelXbrl.py

@@ -422,6 +422,16 @@ class ModelXbrl:
         else:
             return self.fileSource.url
 
+    def contextsByDocument(self) -> dict[str, list[ModelContext]]:
+        contextsByDocument = defaultdict(list)
+        for context in self.contexts.values():
+            contextsByDocument[context.modelDocument.filepath].append(context)
+        contextsByDocument.default_factory = None
+        return contextsByDocument
+
+    def entityIdentifiersInDocument(self) -> set[tuple[str, str]]:
+        return {context.entityIdentifier for context in self.contexts.values()}
+
     def relationshipSet(self, arcrole: tuple[str, ...] | str, linkrole: tuple[str, ...] | str | None = None, linkqname: QName | None = None, arcqname: QName | None = None, includeProhibits: bool = False) -> ModelRelationshipSetClass:
         """Returns a relationship set matching specified parameters (only arcrole is required).
 

{arelle_release-2.37.36 → arelle_release-2.37.38}/arelle/XbrlConst.py

@@ -38,6 +38,8 @@ builtinAttributes = {
     qnXsiSchemaLocation,
     qnXsiNoNamespaceSchemaLocation,
 }
+ref2004 = "http://www.xbrl.org/2004/ref"
+ref2006 = "http://www.xbrl.org/2006/ref"
 xml = "http://www.w3.org/XML/1998/namespace"
 xbrli = "http://www.xbrl.org/2003/instance"
 xhtmlBaseIdentifier = "{http://www.w3.org/1999/xhtml}base"
@@ -45,6 +47,7 @@ xmlBaseIdentifier = "{http://www.w3.org/XML/1998/namespace}base"
 eurofilingModelNamespace = "http://www.eurofiling.info/xbrl/ext/model"
 eurofilingModelPrefix = "model"
 qnNsmap = qname("nsmap")  # artificial parent for insertion of xmlns in saving xml documents
+qnXbrlScenario = qname("{http://www.xbrl.org/2003/instance}scenario")
 qnXbrliXbrl = qname("{http://www.xbrl.org/2003/instance}xbrli:xbrl")
 qnPrototypeXbrliXbrl = qname(
     "{http://arelle.org/prototype/xbrli}xbrl"
@@ -58,6 +61,7 @@ qnXbrliPeriod = qname("{http://www.xbrl.org/2003/instance}xbrli:period")
 qnXbrliStartDate = qname("{http://www.xbrl.org/2003/instance}xbrli:startDate")
 qnXbrliEndDate = qname("{http://www.xbrl.org/2003/instance}xbrli:endDate")
 qnXbrliInstant = qname("{http://www.xbrl.org/2003/instance}xbrli:instant")
+qnXbrliForever = qname("{http://www.xbrl.org/2003/instance}xbrli:forever")
 qnXbrliIdentifier = qname("{http://www.xbrl.org/2003/instance}xbrli:identifier")
 qnXbrliUnit = qname("{http://www.xbrl.org/2003/instance}xbrli:unit")
 qnXbrliStringItemType = qname("{http://www.xbrl.org/2003/instance}xbrli:stringItemType")
@@ -138,6 +142,7 @@ ixbrl11 = "http://www.xbrl.org/2013/inlineXBRL"
 ixbrlAll = {ixbrl, ixbrl11}
 ixbrlTags = ("{http://www.xbrl.org/2013/inlineXBRL}*", "{http://www.xbrl.org/2008/inlineXBRL}*")
 ixbrlTagPattern = re.compile("[{]http://www.xbrl.org/(2008|2013)/inlineXBRL[}]")
+ixt = "http://www.xbrl.org/inlineXBRL/transformation/2010-04-20"
 qnIXbrlResources = qname("{http://www.xbrl.org/2008/inlineXBRL}resources")
 qnIXbrlTuple = qname("{http://www.xbrl.org/2008/inlineXBRL}tuple")
 qnIXbrlNonNumeric = qname("{http://www.xbrl.org/2008/inlineXBRL}nonNumeric")

{arelle_release-2.37.36 → arelle_release-2.37.38}/arelle/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '2.37.36'
-__version_tuple__ = version_tuple = (2, 37, 36)
+__version__ = version = '2.37.38'
+__version_tuple__ = version_tuple = (2, 37, 38)

{arelle_release-2.37.36 → arelle_release-2.37.38}/arelle/plugin/validate/EDINET/rules/edinet.py

@@ -3,6 +3,7 @@ See COPYRIGHT.md for copyright information.
 """
 from __future__ import annotations
 
+import itertools
 from collections.abc import Iterable
 from typing import Any
 
@@ -59,3 +60,48 @@ def rule_EC5002E(
             qname=fact.qname.clarkNotation,
             modelObject=fact,
         )
+
+
+@validation(
+    hook=ValidationHook.XBRL_FINALLY,
+    disclosureSystems=[DISCLOSURE_SYSTEM_EDINET],
+)
+def rule_EC8033W(
+        pluginData: PluginValidationDataExtension,
+        val: ValidateXbrl,
+        *args: Any,
+        **kwargs: Any,
+) -> Iterable[Validation]:
+    """
+    EDINET.EC8033W: The startDate of a context whose context ID starts with
+    "CurrentYear" is not set to a date earlier than the endDate of a context
+    whose context ID starts with "Prior1Year".
+    """
+    priorYearContexts = [
+        context
+        for contextId, context in val.modelXbrl.contexts.items()
+        if contextId.startswith('Prior1Year')
+           and context.endDatetime is not None
+           and context.isStartEndPeriod
+    ]
+    currentYearContexts = [
+        context
+        for contextId, context in val.modelXbrl.contexts.items()
+        if contextId.startswith('CurrentYear')
+           and context.startDatetime is not None
+           and context.isStartEndPeriod
+    ]
+    for priorYearContext, currentYearContext in itertools.product(priorYearContexts, currentYearContexts):
+        if priorYearContext.endDatetime > currentYearContext.startDatetime:
+            yield Validation.warning(
+                codes='EDINET.EC8033W',
+                msg=_("The startDate element of the current year context (id=%(currentYearContextId)s) is "
+                      "set to a date that is earlier than the endDate element of the prior year context "
+                      "(id=%(priorYearContextId)s). Please check the corresponding context ID "
+                      "%(currentYearContextId)s and %(priorYearContextId)s. Set the startDate element of "
+                      "context ID %(currentYearContextId)s to a date that is later than or equal to the "
+                      "endDate element of context ID %(priorYearContextId)s."),
+                currentYearContextId=currentYearContext.id,
+                priorYearContextId=priorYearContext.id,
+                modelObject=(priorYearContext, currentYearContext),
+            )

arelle_release-2.37.38/arelle/plugin/validate/EDINET/rules/frta.py

@@ -0,0 +1,182 @@
+"""
+See COPYRIGHT.md for copyright information.
+"""
+from __future__ import annotations
+
+from collections import defaultdict
+from typing import Any, Iterable
+
+from arelle import XbrlConst
+from arelle.ModelDtsObject import ModelResource, ModelConcept
+from arelle.ValidateXbrl import ValidateXbrl
+from arelle.typing import TypeGetText
+from arelle.utils.PluginHooks import ValidationHook
+from arelle.utils.validate.Decorator import validation
+from arelle.utils.validate.Validation import Validation
+from ..DisclosureSystems import (DISCLOSURE_SYSTEM_EDINET)
+from ..PluginValidationDataExtension import PluginValidationDataExtension
+
+_: TypeGetText
+
+
+@validation(
+    hook=ValidationHook.XBRL_FINALLY,
+    disclosureSystems=[DISCLOSURE_SYSTEM_EDINET],
+)
+def rule_frta_2_1_9(
+        pluginData: PluginValidationDataExtension,
+        val: ValidateXbrl,
+        *args: Any,
+        **kwargs: Any,
+) -> Iterable[Validation]:
+    """
+    EDINET.EC5710W: [FRTA.2.1.9] All documentation of a concept must be contained
+    in XBRL linkbases. Do not use the xsd:documentation element in an element definition.
+    """
+    errors = []
+    for modelDocument in val.modelXbrl.urlDocs.values():
+        if pluginData.isStandardTaxonomyUrl(modelDocument.uri, val.modelXbrl):
+            continue
+        rootElt = modelDocument.xmlRootElement
+        for elt in rootElt.iterdescendants(XbrlConst.qnXsdDocumentation.clarkNotation):
+            errors.append(elt)
+    if len(errors) > 0:
+        yield Validation.warning(
+            codes='EDINET.EC5710W.FRTA.2.1.9',
+            msg=_("All documentation of a concept must be contained in XBRL linkbases. "
+                  "Taxonomy element declarations should not use the XML Schema documentation element."),
+            modelObject=errors,
+        )
+
+
+@validation(
+    hook=ValidationHook.XBRL_FINALLY,
+    disclosureSystems=[DISCLOSURE_SYSTEM_EDINET],
+)
+def rule_frta_2_1_10(
+        pluginData: PluginValidationDataExtension,
+        val: ValidateXbrl,
+        *args: Any,
+        **kwargs: Any,
+) -> Iterable[Validation]:
+    """
+    EDINET: [FRTA.2.1.10] All extension taxonomy concepts must have a standard label.
+    """
+    errors = []
+    for concept in val.modelXbrl.qnameConcepts.values():
+        if pluginData.isStandardTaxonomyUrl(concept.modelDocument.uri, val.modelXbrl):
+            continue
+        if not concept.label(XbrlConst.standardLabel, fallbackToQname=False):
+            errors.append(concept)
+    if len(errors) > 0:
+        yield Validation.warning(
+            codes='EDINET.FRTA.2.1.10',  # Not associated with EC5710W code.
+            msg=_("All extension taxonomy concepts must have a standard label. "
+                  "A standard label is not specified for a concept in an "
+                  "extension taxonomy. When adding a concept to an extension taxonomy, "
+                  "please provide Japanese and English labels in the standard, verbose, and "
+                  "documentation roles."),
+            modelObject=errors,
+        )
+
+
+@validation(
+    hook=ValidationHook.XBRL_FINALLY,
+    disclosureSystems=[DISCLOSURE_SYSTEM_EDINET],
+)
+def rule_frta_2_1_11(
+        pluginData: PluginValidationDataExtension,
+        val: ValidateXbrl,
+        *args: Any,
+        **kwargs: Any,
+) -> Iterable[Validation]:
+    """
+    EDINET.EC5710W: [FRTA.2.1.11] All concepts within a taxonomy schema should have a
+    unique label for the standard or verbose role in each language used.
+    """
+    labelsRelationshipSet = val.modelXbrl.relationshipSet(XbrlConst.conceptLabel)
+    labelGroupsByLang: dict[str, dict[str, dict[str, set[ModelConcept]]]] = (
+        defaultdict(lambda: defaultdict(lambda: defaultdict(set)))
+    )
+    relevantRoles = frozenset({
+        XbrlConst.standardLabel,
+        XbrlConst.verboseLabel
+    })
+    for concept, modelLabelRels in labelsRelationshipSet.fromModelObjects().items():
+        if pluginData.isStandardTaxonomyUrl(concept.modelDocument.uri, val.modelXbrl):
+            continue
+        for modelLabelRel in modelLabelRels:
+            modelLabel = modelLabelRel.toModelObject
+            if not isinstance(modelLabel, ModelResource):
+                continue
+            if modelLabel.role not in relevantRoles:
+                continue
+            if not modelLabel.modelDocument.inDTS:
+                continue
+            if not modelLabel.xmlLang:
+                continue
+            labelGroupsByLang[modelLabel.xmlLang][modelLabel.role][modelLabel.textValue].add(concept)
+    for lang, labelGroupsByRole in labelGroupsByLang.items():
+        duplicateLabelsByRole = defaultdict(list)
+        conceptsWithVerboseLabel = {
+            concept: False
+            for concept in val.modelXbrl.qnameConcepts.values()
+            if not pluginData.isStandardTaxonomyUrl(concept.modelDocument.uri, val.modelXbrl)
+        }
+        for role, labelGroupsByValue in labelGroupsByRole.items():
+            for value, concepts in labelGroupsByValue.items():
+                if role == XbrlConst.verboseLabel:
+                    for concept in concepts:
+                        conceptsWithVerboseLabel[concept] = True
+                if len(concepts) < 2:
+                    continue
+                duplicateLabelsByRole[role].append((value, concepts))
+        if len(duplicateLabelsByRole[XbrlConst.standardLabel]) == 0:
+            # There are no duplicate standard labels, so we don't need to check verbose labels
+            continue
+        conceptsWithoutVerboseLabel = {concept for concept, value in conceptsWithVerboseLabel.items() if not value}
+        if len(duplicateLabelsByRole[XbrlConst.verboseLabel]) == 0 and len(conceptsWithoutVerboseLabel) == 0:
+            # All concepts have a verbose label, and there are no duplicate verbose labels,
+            return
+        for role, duplicateLabels in duplicateLabelsByRole.items():
+            for value, concepts in duplicateLabels:
+                yield Validation.warning(
+                    codes='EDINET.EC5710W.FRTA.2.1.11',
+                    msg=_("All concepts within a taxonomy schema should have a unique label for the "
+                          "standard or verbose role in each language used. "
+                          "The %(role)s label contains a duplicate label ('%(value)s') in the same "
+                          "language ('%(lang)s'). Define either the standard label or the verbose label "
+                          "so that they are unique in the same language."),
+                    role='standard' if role == XbrlConst.standardLabel else 'verbose',
+                    value=value,
+                    lang=lang,
+                    modelObject=concepts,
+                )
+
+
+@validation(
+    hook=ValidationHook.XBRL_FINALLY,
+    disclosureSystems=[DISCLOSURE_SYSTEM_EDINET],
+)
+def rule_frta_3_1_10(
+        pluginData: PluginValidationDataExtension,
+        val: ValidateXbrl,
+        *args: Any,
+        **kwargs: Any,
+) -> Iterable[Validation]:
+    """
+    EDINET.EC5710W: [FRTA.3.1.10] Role types defined in the extension taxonomy must have a definition.
+    """
+    errors = []
+    for uri, roleTypes in val.modelXbrl.roleTypes.items():
+        for roleType in roleTypes:
+            if pluginData.isStandardTaxonomyUrl(roleType.document.uri, val.modelXbrl):
+                continue
+            if not roleType.definition:
+                errors.append(roleType)
+    if len(errors) > 0:
+        yield Validation.warning(
+            codes='EDINET.EC5710W.FRTA.3.1.10',
+            msg=_("Role types defined in the extension taxonomy must have a definition."),
+            modelObject=errors,
+        )

{arelle_release-2.37.36 → arelle_release-2.37.38}/arelle/plugin/validate/EDINET/rules/gfm.py

@@ -13,7 +13,7 @@ from arelle.PrototypeDtsObject import LocPrototype, ArcPrototype
 from arelle.UrlUtil import isHttpUrl, splitDecodeFragment
 from arelle.ValidateXbrl import ValidateXbrl
 from arelle.ValidateXbrlCalcs import insignificantDigits
-from arelle.XbrlConst import xhtmlBaseIdentifier, xmlBaseIdentifier
+from arelle.XbrlConst import qnXbrlScenario, qnXbrldiExplicitMember, xhtmlBaseIdentifier, xmlBaseIdentifier
 from arelle.XmlValidate import VALID
 from arelle.typing import TypeGetText
 from arelle.utils.PluginHooks import ValidationHook
@@ -26,6 +26,21 @@ from ..PluginValidationDataExtension import PluginValidationDataExtension
 _: TypeGetText
 
 GFM_CONTEXT_DATE_PATTERN = regex.compile(r"^[12][0-9]{3}-[01][0-9]-[0-3][0-9]$")
+GFM_RECOMMENDED_NAMESPACE_PREFIXES = {
+    XbrlConst.xbrli: ("xbrli",),
+    XbrlConst.xsi: ("xsi",),
+    XbrlConst.xsd: ("xs", "xsd",),
+    XbrlConst.link: ("link",),
+    XbrlConst.xl: ("xl",),
+    XbrlConst.xlink: ("xlink",),
+    XbrlConst.ref2004: ("ref",),
+    XbrlConst.ref2006: ("ref",),
+    XbrlConst.xbrldt: ("xbrldt",),
+    XbrlConst.xbrldi: ("xbrldi",),
+    XbrlConst.ixbrl: ("ix",),
+    XbrlConst.ixt: ("ixt",),
+    XbrlConst.xhtml: ("xhtml",),
+}
 
 
 @validation(
@@ -117,6 +132,88 @@ def rule_gfm_1_1_7(
         )
 
 
+@validation(
+    hook=ValidationHook.XBRL_FINALLY,
+    disclosureSystems=[DISCLOSURE_SYSTEM_EDINET],
+)
+def rule_gfm_1_2_3(
+        pluginData: PluginValidationDataExtension,
+        val: ValidateXbrl,
+        *args: Any,
+        **kwargs: Any,
+) -> Iterable[Validation]:
+    """
+    EDINET.EC5700W: [GFM 1.2.3] All xbrli:identifier elements in an instance must have identical content.
+    """
+    entityIdentifierValues = val.modelXbrl.entityIdentifiersInDocument()
+    if len(entityIdentifierValues) >1:
+        yield Validation.warning(
+            codes='EDINET.EC5700W.GFM.1.2.3',
+            msg=_('All identifier elements must be identical.'),
+                modelObject = val.modelXbrl
+            )
+
+
+@validation(
+    hook=ValidationHook.XBRL_FINALLY,
+    disclosureSystems=[DISCLOSURE_SYSTEM_EDINET],
+)
+def rule_gfm_1_2_4(
+        pluginData: PluginValidationDataExtension,
+        val: ValidateXbrl,
+        *args: Any,
+        **kwargs: Any,
+) -> Iterable[Validation]:
+    """
+    EDINET.EC5700W: [GFM 1.2.4] Segment must not be used in the context.
+    """
+    allContexts = val.modelXbrl.contextsByDocument()
+    contextsWithSegments =[]
+    for contexts in allContexts.values():
+        for context in contexts:
+            if context.hasSegment:
+                contextsWithSegments.append(context)
+    if len(contextsWithSegments) > 0:
+        yield Validation.warning(
+            codes='EDINET.EC5700W.GFM.1.2.4',
+            msg=_('Set the scenario element in the context. Do not set the segment element.'),
+            modelObject = contextsWithSegments
+        )
+
+
+@validation(
+    hook=ValidationHook.XBRL_FINALLY,
+    disclosureSystems=[DISCLOSURE_SYSTEM_EDINET],
+)
+def rule_gfm_1_2_5(
+        pluginData: PluginValidationDataExtension,
+        val: ValidateXbrl,
+        *args: Any,
+        **kwargs: Any,
+) -> Iterable[Validation]:
+    """
+    EDINET.EC5700W: [GFM 1.2.5] If an xbrli:scenario element appears in a context, then its children
+    must be one or more xbrldi:explicitMember elements.
+    """
+    allContexts = val.modelXbrl.contextsByDocument()
+    contextsWithDisallowedScenarioChildren =[]
+    for contexts in allContexts.values():
+        for context in contexts:
+            for elt in context.iterdescendants(qnXbrlScenario.clarkNotation):
+                if isinstance(elt, ModelObject):
+                    if any(isinstance(child, ModelObject) and child.tag != qnXbrldiExplicitMember.clarkNotation
+                           for child in elt.iterchildren()):
+                        contextsWithDisallowedScenarioChildren.append(context)
+    if len(contextsWithDisallowedScenarioChildren) > 0:
+        yield Validation.warning(
+            codes='EDINET.EC5700W.GFM.1.2.5',
+            msg=_('Please delete all child elements other than the xbrldi:explicitMember '
+                  'element from the segment element or scenario element.'),
+            modelObject = contextsWithDisallowedScenarioChildren
+        )
+
+
+
 @validation(
     hook=ValidationHook.XBRL_FINALLY,
     disclosureSystems=[DISCLOSURE_SYSTEM_EDINET],
@@ -268,3 +365,85 @@ def rule_gfm_1_2_26(
                   "decimals attribute."),
             modelObject=errors,
         )
+
+
+@validation(
+    hook=ValidationHook.XBRL_FINALLY,
+    disclosureSystems=[DISCLOSURE_SYSTEM_EDINET],
+)
+def rule_gfm_1_2_27(
+        pluginData: PluginValidationDataExtension,
+        val: ValidateXbrl,
+        *args: Any,
+        **kwargs: Any,
+) -> Iterable[Validation]:
+    """
+    EDINET.EC5700W: [GFM 1.2.27] An instance must not contain unused units.
+    """
+    # TODO: Consolidate validations involving unused units
+    unusedUnits = set(val.modelXbrl.units.values()) - {fact.unit for fact in val.modelXbrl.facts if fact.unit is not None}
+    if len(unusedUnits) > 0:
+        yield Validation.warning(
+            codes='EDINET.EC5700W.GFM.1.2.27',
+            msg=_("Delete unused units from the instance."),
+            modelObject=list(unusedUnits)
+        )
+
+
+@validation(
+    hook=ValidationHook.XBRL_FINALLY,
+    disclosureSystems=[DISCLOSURE_SYSTEM_EDINET],
+)
+def rule_gfm_1_2_28(
+        pluginData: PluginValidationDataExtension,
+        val: ValidateXbrl,
+        *args: Any,
+        **kwargs: Any,
+) -> Iterable[Validation]:
+    """
+    EDINET.EC5700W: [GFM 1.2.28] The prefix declaration for the namespace is incorrect.
+    """
+    for doc in val.modelXbrl.urlDocs.values():
+        rootElt = doc.xmlRootElement
+        for prefix, namespace in rootElt.nsmap.items():
+            if prefix is None:
+                continue
+            if namespace not in GFM_RECOMMENDED_NAMESPACE_PREFIXES:
+                continue
+            if prefix in GFM_RECOMMENDED_NAMESPACE_PREFIXES[namespace]:
+                continue
+            yield Validation.warning(
+                codes='EDINET.EC5700W.GFM.1.2.28',
+                msg=_("The prefix declaration '%(prefix)s' for the namespace '%(namespace)s' "
+                      "is incorrect. "
+                      "Correct the prefix (%(prefixes)s)."),
+                prefix=prefix,
+                namespace=namespace,
+                prefixes=", ".join(GFM_RECOMMENDED_NAMESPACE_PREFIXES[namespace]),
+                modelObject=rootElt
+            )
+
+
+@validation(
+    hook=ValidationHook.XBRL_FINALLY,
+    disclosureSystems=[DISCLOSURE_SYSTEM_EDINET],
+)
+def rule_gfm_1_2_30(
+        pluginData: PluginValidationDataExtension,
+        val: ValidateXbrl,
+        *args: Any,
+        **kwargs: Any,
+) -> Iterable[Validation]:
+    """
+    EDINET.EC5700W: [GFM 1.2.30] A context must not contain the xbrli:forever element.
+    """
+    errors = []
+    for context in val.modelXbrl.contexts.values():
+        for elt in context.iterdescendants(XbrlConst.qnXbrliForever.clarkNotation):
+            errors.append(elt)
+    if len(errors) > 0:
+        yield Validation.warning(
+            codes='EDINET.EC5700W.GFM.1.2.30',
+            msg=_("A context must not contain the xbrli:forever element."),
+            modelObject=errors
+        )

{arelle_release-2.37.36 → arelle_release-2.37.38}/arelle/plugin/validate/ESEF/resources/authority-validations.json

@@ -344,10 +344,19 @@
         "formulaRunIDs": "(?!con_IdentifierSchemeMustBeLEI|lei-identifier-scheme)"
     },
     "UKFRC-2023": {
+        "name": "United Kingdom Multiple Targets",
+        "authorityName": "FRC",
+        "comment": "This is a deprecated authority that will be removed. Use UKFRC instead.",
+        "reference": "https://media.frc.org.uk/documents/XBRL_Tagging_Guide_-_FRC_Taxonomies_2024_On9jOuS.pdf",
+        "reportPackageMaxMB": "150",
+        "reportPackageMeasurement": "zipped",
+        "ixTargetUsage": "allowed"
+    },
+    "UKFRC": {
         "name": "United Kingdom Multiple Targets",
         "authorityName": "FRC",
         "comment": "Pertains to multi target UKSEF Guidance",
-        "comment2": "See UKFRC for reports prior to 2023 which did not use separate targets for FRC and ESEF",
+        "comment2": "See UKFRC-2022 for reports prior to 2023 which did not use separate targets for FRC and ESEF",
         "reference": "https://media.frc.org.uk/documents/XBRL_Tagging_Guide_-_FRC_Taxonomies_2024_On9jOuS.pdf",
         "reportPackageMaxMB": "150",
         "reportPackageMeasurement": "zipped",

{arelle_release-2.37.36 → arelle_release-2.37.38}/arelle/plugin/validate/NL/PluginValidationDataExtension.py

@@ -225,7 +225,7 @@ class PluginValidationDataExtension(PluginData):
     financialReportingPeriodCurrentEndDateQn: QName
     financialReportingPeriodPreviousStartDateQn: QName
     financialReportingPeriodPreviousEndDateQn: QName
-    formattedExplanationItemTypeQn: QName
+    formattedExplanationItemTypeQn: QName | None
     ifrsIdentifier: str
     permissibleGAAPRootAbstracts: frozenset[QName]
     permissibleIFRSRootAbstracts: frozenset[QName]
@@ -242,17 +242,10 @@ class PluginValidationDataExtension(PluginData):
             for domMbrRel in modelXbrl.relationshipSet(XbrlConst.domainMember, ELR).fromModelObject(sourceDomMbr):
                 self.addDomMbrs(modelXbrl, domMbrRel.toModelObject, domMbrRel.consecutiveLinkrole, membersSet)
 
-    @lru_cache(1)
-    def contextsByDocument(self, modelXbrl: ModelXbrl) -> dict[str, list[ModelContext]]:
-        contextsByDocument = defaultdict(list)
-        for context in modelXbrl.contexts.values():
-            contextsByDocument[context.modelDocument.filepath].append(context)
-        contextsByDocument.default_factory = None
-        return contextsByDocument
 
     @lru_cache(1)
     def checkContexts(self, modelXbrl: ModelXbrl) -> ContextData:
-        allContexts = self.contextsByDocument(modelXbrl)
+        allContexts = modelXbrl.contextsByDocument()
         contextsWithImproperContent: list[ModelContext | None] = []
         contextsWithPeriodTime: list[ModelContext | None] = []
         contextsWithPeriodTimeZone: list[ModelContext | None] = []
@@ -395,9 +388,6 @@ class PluginValidationDataExtension(PluginData):
             tupleElements=tupleElements,
         )
 
-    @lru_cache(1)
-    def entityIdentifiersInDocument(self, modelXbrl: ModelXbrl) -> set[tuple[str, str]]:
-        return {context.entityIdentifier for context in modelXbrl.contexts.values()}
 
     @lru_cache(1)
     def factsByDocument(self, modelXbrl: ModelXbrl) -> dict[str, list[ModelFact]]:

{arelle_release-2.37.36 → arelle_release-2.37.38}/arelle/plugin/validate/NL/ValidationPluginExtension.py

@@ -192,44 +192,45 @@ class ValidationPluginExtension(ValidationPlugin):
             jenvNamespace = 'https://www.nltaxonomie.nl/bw2-titel9/2024-12-31/bw2-titel9-cor'
             kvkINamespace = 'https://www.nltaxonomie.nl/kvk/2024-12-31/kvk-cor'
             nlTypesNamespace = None
-            rjNamespace =  'https://www.nltaxonomie.nl/rj/2024-12-31/rj-cor'
+            rjNamespace = 'https://www.nltaxonomie.nl/rj/2024-12-31/rj-cor'
             entrypointRoot = 'http://www.nltaxonomie.nl/kvk/2024-12-31/'
             entrypoints = {entrypointRoot + e for e in [
                 'kvk-annual-report-other-gaap.xsd',
             ]}
         else:
             raise ValueError(f'Invalid NL disclosure system: {disclosureSystem}')
+        permissibleMandatoryFactsRootAbstracts=frozenset([
+            qname(kvkINamespace, 'AnnualReportFilingInformationTitle'),
+        ]) if kvkINamespace else frozenset()
         return PluginValidationDataExtension(
             self.name,
-            chamberOfCommerceRegistrationNumberQn=qname(f'{{{jenvNamespace}}}ChamberOfCommerceRegistrationNumber'),
-            documentAdoptionDateQn=qname(f'{{{jenvNamespace}}}DocumentAdoptionDate'),
-            documentAdoptionStatusQn=qname(f'{{{jenvNamespace}}}DocumentAdoptionStatus'),
-            documentResubmissionUnsurmountableInaccuraciesQn=qname(f'{{{kvkINamespace}}}DocumentResubmissionDueToUnsurmountableInaccuracies'),
+            chamberOfCommerceRegistrationNumberQn=qname(jenvNamespace, 'ChamberOfCommerceRegistrationNumber'),
+            documentAdoptionDateQn=qname(jenvNamespace, 'DocumentAdoptionDate'),
+            documentAdoptionStatusQn=qname(jenvNamespace, 'DocumentAdoptionStatus'),
+            documentResubmissionUnsurmountableInaccuraciesQn=qname(kvkINamespace, 'DocumentResubmissionDueToUnsurmountableInaccuracies'),
             entrypointRoot=entrypointRoot,
             entrypoints=entrypoints,
-            financialReportingPeriodQn=qname(f'{{{jenvNamespace}}}FinancialReportingPeriod'),
-            financialReportingPeriodCurrentStartDateQn=qname(f'{{{jenvNamespace}}}FinancialReportingPeriodCurrentStartDate'),
-            financialReportingPeriodCurrentEndDateQn=qname(f'{{{jenvNamespace}}}FinancialReportingPeriodCurrentEndDate'),
-            financialReportingPeriodPreviousStartDateQn=qname(f'{{{jenvNamespace}}}FinancialReportingPeriodPreviousStartDate'),
-            financialReportingPeriodPreviousEndDateQn=qname(f'{{{jenvNamespace}}}FinancialReportingPeriodPreviousEndDate'),
-            formattedExplanationItemTypeQn=qname(f'{{{nlTypesNamespace}}}formattedExplanationItemType'),
+            financialReportingPeriodQn=qname(jenvNamespace, 'FinancialReportingPeriod'),
+            financialReportingPeriodCurrentStartDateQn=qname(jenvNamespace, 'FinancialReportingPeriodCurrentStartDate'),
+            financialReportingPeriodCurrentEndDateQn=qname(jenvNamespace, 'FinancialReportingPeriodCurrentEndDate'),
+            financialReportingPeriodPreviousStartDateQn=qname(jenvNamespace, 'FinancialReportingPeriodPreviousStartDate'),
+            financialReportingPeriodPreviousEndDateQn=qname(jenvNamespace, 'FinancialReportingPeriodPreviousEndDate'),
+            formattedExplanationItemTypeQn=qname(nlTypesNamespace, 'formattedExplanationItemType') if nlTypesNamespace else None,
             ifrsIdentifier = 'https://xbrl.ifrs.org',
-            permissibleGAAPRootAbstracts=frozenset([
-                qname(f'{{{jenvNamespace}}}BalanceSheetTitle'),
-                qname(f'{{{jenvNamespace}}}IncomeStatementTitle'),
-                qname(f'{{{jenvNamespace}}}StatementOfComprehensiveIncomeTitle'),
-                qname(f'{{{jenvNamespace}}}EquityStatementOfChangesTitle'),
-                qname(f'{{{kvkINamespace}}}AnnualReportFilingInformationTitle'),
-                qname(f'{{{rjNamespace}}}StatementOfCashFlowsTitle'),
-            ]),
-            permissibleIFRSRootAbstracts=frozenset([
-                qname(f'{{{ifrsNamespace}}}StatementOfFinancialPositionAbstract'),
-                qname(f'{{{ifrsNamespace}}}IncomeStatementAbstract'),
-                qname(f'{{{ifrsNamespace}}}StatementOfComprehensiveIncomeAbstract'),
-                qname(f'{{{ifrsNamespace}}}StatementOfCashFlowsAbstract'),
-                qname(f'{{{ifrsNamespace}}}StatementOfChangesInEquityAbstract'),
-                qname(f'{{{kvkINamespace}}}AnnualReportFilingInformationTitle'),
-            ]),
+            permissibleGAAPRootAbstracts=permissibleMandatoryFactsRootAbstracts | frozenset([
+                qname(jenvNamespace, 'BalanceSheetTitle'),
+                qname(jenvNamespace, 'IncomeStatementTitle'),
+                qname(jenvNamespace, 'StatementOfComprehensiveIncomeTitle'),
+                qname(jenvNamespace, 'EquityStatementOfChangesTitle'),
+                qname(rjNamespace, 'CashFlowStatementTitle'),
+            ]) if jenvNamespace and rjNamespace else frozenset(),
+            permissibleIFRSRootAbstracts=permissibleMandatoryFactsRootAbstracts | frozenset([
+                qname(ifrsNamespace, 'StatementOfFinancialPositionAbstract'),
+                qname(ifrsNamespace, 'IncomeStatementAbstract'),
+                qname(ifrsNamespace, 'StatementOfComprehensiveIncomeAbstract'),
+                qname(ifrsNamespace, 'StatementOfCashFlowsAbstract'),
+                qname(ifrsNamespace, 'StatementOfChangesInEquityAbstract'),
+            ]) if ifrsNamespace else frozenset(),
             textFormattingSchemaPath='sbr-text-formatting.xsd',
             textFormattingWrapper='<formattedText xmlns="http://www.nltaxonomie.nl/2017/xbrl/sbr-text-formatting">{}</formattedText>',
         )