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

arelle/ValidateXbrl.py

@@ -3,9 +3,11 @@ See COPYRIGHT.md for copyright information.
 '''
 from __future__ import annotations
 import regex as re
-from typing import Any, List, Set, Union, cast
+import math
+from typing import Any, cast
 from arelle import (XmlUtil, XbrlUtil, XbrlConst,
-                ValidateXbrlCalcs, ValidateXbrlDimensions, ValidateXbrlDTS, ValidateUtr)
+                    ValidateXbrlCalcs, ValidateXbrlDimensions, ValidateXbrlDTS, ValidateUtr, ValidateDuplicateFacts)
+from arelle.PythonUtil import strTruncate
 from arelle.formula import ValidateFormula
 from arelle.ModelDocument import ModelDocument, Type as ModelDocumentType
 from arelle import FunctionIxt
@@ -21,8 +23,9 @@ from arelle.XbrlConst import (ixbrlAll, dtrNoDecimalsItemTypes, dtrPrefixedConte
 from arelle.XhtmlValidate import ixMsgCode
 from arelle.XmlValidateConst import VALID
 from collections import defaultdict
+from arelle.oim.Validate import validateOIM
 from arelle.typing import TypeGetText
-from arelle.utils.validate.PluginValidationData import PluginValidationData
+from arelle.utils.PluginData import PluginData
 from arelle.ModelRelationshipSet import ModelRelationshipSet
 from arelle.ModelDtsObject import ModelRelationship
 from arelle.ModelFormulaObject import ModelCustomFunctionSignature
@@ -116,7 +119,8 @@ class ValidateXbrl:
                                  for concept in self.modelXbrl.nameConcepts.get("UTR",()))))
         self.validateIXDS = False # set when any inline document found
         self.validateEnum = bool(XbrlConst.enums & modelXbrl.namespaceDocs.keys())
-        self._pluginData: dict[str, PluginValidationData] = {}
+        self.validateDuplicateFacts = modelXbrl.modelManager.validateDuplicateFacts
+        self._pluginData: dict[str, PluginData] = {}
 
         for pluginXbrlMethod in pluginClassMethods("Validate.XBRL.Start"):
             pluginXbrlMethod(self, parameters)
@@ -143,6 +147,8 @@ class ValidateXbrl:
             if arcrole.startswith("XBRL-") or ELR is None or \
                 linkqname is None or arcqname is None:
                 continue
+            elif arcrole in self.modelXbrl.modelManager.disclosureSystem.arcroleCyclesAllowed:
+                cyclesAllowed, specSect = self.modelXbrl.modelManager.disclosureSystem.arcroleCyclesAllowed[arcrole]
             elif arcrole in XbrlConst.standardArcroleCyclesAllowed:
                 # TODO: table should be in this module, where it is used
                 cyclesAllowed, specSect = XbrlConst.standardArcroleCyclesAllowed[arcrole]
@@ -155,116 +161,116 @@ class ValidateXbrl:
             else:
                 cyclesAllowed = "any"
                 specSect = None
-            if cyclesAllowed != "any" or arcrole in (XbrlConst.summationItem,) \
+            if cyclesAllowed != "any" or arcrole in XbrlConst.summationItems \
                                       or arcrole in self.genericArcArcroles  \
                                       or arcrole.startswith(XbrlConst.formulaStartsWith) \
                                       or (modelXbrl.hasXDT and arcrole.startswith(XbrlConst.dimStartsWith)):
-                relsSet = modelXbrl.relationshipSet(arcrole,ELR,linkqname,arcqname)
-            if cyclesAllowed != "any" and \
-                   ((XbrlConst.isStandardExtLinkQname(linkqname) and XbrlConst.isStandardArcQname(arcqname)) \
-                    or arcrole in self.genericArcArcroles):
-                noUndirected = cyclesAllowed == "none"
-                fromRelationships = relsSet.fromModelObjects()
-                for relFrom, rels in fromRelationships.items():
-                    cycleFound = cast(List[ModelRelationship], self.fwdCycle(relsSet, rels, noUndirected, {relFrom}))
-
-                    if cycleFound is not None:
-                        pathEndsAt = len(cycleFound)  # consistently find start of path
-
-                        loopedModelObject = cycleFound[1].toModelObject
-                        for i, rel in enumerate(cycleFound[2:]):
-                            if rel.fromModelObject == loopedModelObject:
-                                pathEndsAt = 3 + i # don't report extra path elements before loop
-                                break
-
-                        reversed_list = reversed(cycleFound[1:pathEndsAt])
-                        path = str(loopedModelObject.qname) + " " + " - ".join(
-                            "{0}:{1} {2}".format(rel.modelDocument.basename, rel.sourceline, rel.toModelObject.qname)
-                            for rel in reversed_list)
-
-                        modelXbrl.error(cast(str, specSect),
-                            _("Relationships have a %(cycle)s cycle in arcrole %(arcrole)s \nlink role %(linkrole)s \nlink %(linkname)s, \narc %(arcname)s, \npath %(path)s"),
-                            modelObject=cycleFound[1:pathEndsAt], cycle=cycleFound[0], path=path,
-                            arcrole=arcrole, linkrole=ELR, linkname=linkqname, arcname=arcqname,
-                            messageCodes=("xbrlgene:violatedCyclesConstraint", "xbrl.5.1.4.3:cycles",
-                                          # from XbrlCoinst.standardArcroleCyclesAllowed
-                                          "xbrl.5.2.4.2", "xbrl.5.2.5.2", "xbrl.5.2.6.2.1", "xbrl.5.2.6.2.1", "xbrl.5.2.6.2.3", "xbrl.5.2.6.2.4"))
-                        break
-
-            # check calculation arcs for weight issues (note calc arc is an "any" cycles)
-            if arcrole == XbrlConst.summationItem:
-                for modelRel in relsSet.modelRelationships:
-                    weight = modelRel.weight
-                    fromConcept = modelRel.fromModelObject
-                    toConcept = modelRel.toModelObject
-                    if fromConcept is not None and toConcept is not None:
-                        if weight == 0:
-                            modelXbrl.error("xbrl.5.2.5.2.1:zeroWeight", # type: ignore[func-returns-value]
-                                _("Calculation relationship has zero weight from %(source)s to %(target)s in link role %(linkrole)s"),
-                                modelObject=modelRel,
-                                source=fromConcept.qname, target=toConcept.qname, linkrole=ELR),
-                        fromBalance = fromConcept.balance
-                        toBalance = toConcept.balance
-                        if fromBalance and toBalance:
-                            if (fromBalance == toBalance and weight < 0) or \
-                               (fromBalance != toBalance and weight > 0):
-                                modelXbrl.error("xbrl.5.1.1.2:balanceCalcWeightIllegal" +
-                                                ("Negative" if weight < 0 else "Positive"),
-                                    _("Calculation relationship has illegal weight %(weight)s from %(source)s, %(sourceBalance)s, to %(target)s, %(targetBalance)s, in link role %(linkrole)s (per 5.1.1.2 Table 6)"),
-                                    modelObject=modelRel, weight=weight,
+                relsSet = modelXbrl.relationshipSet(arcrole, ELR, linkqname, arcqname)
+                if cyclesAllowed != "any" and \
+                    ((XbrlConst.isStandardExtLinkQname(linkqname) and XbrlConst.isStandardArcQname(arcqname)) \
+                        or arcrole in self.genericArcArcroles):
+                    noUndirected = cyclesAllowed == "none"
+                    fromRelationships = relsSet.fromModelObjects()
+                    for relFrom, rels in fromRelationships.items():
+                        cycleFound = cast(list[ModelRelationship], self.fwdCycle(relsSet, rels, noUndirected, {relFrom}))
+
+                        if cycleFound is not None:
+                            pathEndsAt = len(cycleFound)  # consistently find start of path
+
+                            loopedModelObject = cycleFound[1].toModelObject
+                            for i, rel in enumerate(cycleFound[2:]):
+                                if rel.fromModelObject == loopedModelObject:
+                                    pathEndsAt = 3 + i # don't report extra path elements before loop
+                                    break
+
+                            reversed_list = reversed(cycleFound[1:pathEndsAt])
+                            path = str(loopedModelObject.qname) + " " + " - ".join(
+                                "{0}:{1} {2}".format(rel.modelDocument.basename, rel.sourceline, rel.toModelObject.qname)
+                                for rel in reversed_list)
+
+                            modelXbrl.error(cast(str, specSect),
+                                _("Relationships have a %(cycle)s cycle in arcrole %(arcrole)s \nlink role %(linkrole)s \nlink %(linkname)s, \narc %(arcname)s, \npath %(path)s"),
+                                modelObject=cycleFound[1:pathEndsAt], cycle=cycleFound[0], path=path,
+                                arcrole=arcrole, linkrole=ELR, linkname=linkqname, arcname=arcqname,
+                                messageCodes=("xbrlgene:violatedCyclesConstraint", "xbrl.5.1.4.3:cycles",
+                                            # from XbrlCoinst.standardArcroleCyclesAllowed
+                                            "xbrl.5.2.4.2", "xbrl.5.2.5.2", "xbrl.5.2.6.2.1", "xbrl.5.2.6.2.1", "xbrl.5.2.6.2.3", "xbrl.5.2.6.2.4"))
+                            break
+
+                # check calculation arcs for weight issues (note calc arc is an "any" cycles)
+                if arcrole in XbrlConst.summationItems:
+                    for modelRel in relsSet.modelRelationships:
+                        weight = modelRel.weight
+                        fromConcept = modelRel.fromModelObject
+                        toConcept = modelRel.toModelObject
+                        if fromConcept is not None and toConcept is not None:
+                            if weight == 0:
+                                modelXbrl.error("xbrl.5.2.5.2.1:zeroWeight", # type: ignore[func-returns-value]
+                                    _("Calculation relationship has zero weight from %(source)s to %(target)s in link role %(linkrole)s"),
+                                    modelObject=modelRel,
+                                    source=fromConcept.qname, target=toConcept.qname, linkrole=ELR),
+                            fromBalance = fromConcept.balance
+                            toBalance = toConcept.balance
+                            if fromBalance and toBalance:
+                                if (fromBalance == toBalance and weight < 0) or \
+                                (fromBalance != toBalance and weight > 0):
+                                    modelXbrl.error("xbrl.5.1.1.2:balanceCalcWeightIllegal" +
+                                                    ("Negative" if weight < 0 else "Positive"),
+                                        _("Calculation relationship has illegal weight %(weight)s from %(source)s, %(sourceBalance)s, to %(target)s, %(targetBalance)s, in link role %(linkrole)s (per 5.1.1.2 Table 6)"),
+                                        modelObject=modelRel, weight=weight,
+                                        source=fromConcept.qname, target=toConcept.qname, linkrole=ELR,
+                                        sourceBalance=fromBalance, targetBalance=toBalance,
+                                        messageCodes=("xbrl.5.1.1.2:balanceCalcWeightIllegalNegative", "xbrl.5.1.1.2:balanceCalcWeightIllegalPositive"))
+                            if not fromConcept.isNumeric or not toConcept.isNumeric:
+                                modelXbrl.error("xbrl.5.2.5.2:nonNumericCalc",
+                                    _("Calculation relationship has illegal concept from %(source)s%(sourceNumericDecorator)s to %(target)s%(targetNumericDecorator)s in link role %(linkrole)s"),
+                                    modelObject=modelRel,
+                                    source=fromConcept.qname, target=toConcept.qname, linkrole=ELR,
+                                    sourceNumericDecorator="" if fromConcept.isNumeric else _(" (non-numeric)"),
+                                    targetNumericDecorator="" if toConcept.isNumeric else _(" (non-numeric)"))
+                # check presentation relationships for preferredLabel issues
+                elif arcrole == XbrlConst.parentChild:
+                    for modelRel in relsSet.modelRelationships:
+                        preferredLabel = modelRel.preferredLabel
+                        fromConcept = modelRel.fromModelObject
+                        toConcept = modelRel.toModelObject
+                        if preferredLabel is not None and isinstance(fromConcept, ModelConcept) and isinstance(toConcept, ModelConcept):
+                            label = toConcept.label(preferredLabel=preferredLabel,fallbackToQname=False,strip=True)
+                            if label is None:
+                                modelXbrl.error("xbrl.5.2.4.2.1:preferredLabelMissing",
+                                    _("Presentation relationship from %(source)s to %(target)s in link role %(linkrole)s missing preferredLabel %(preferredLabel)s"),
+                                    modelObject=modelRel,
                                     source=fromConcept.qname, target=toConcept.qname, linkrole=ELR,
-                                    sourceBalance=fromBalance, targetBalance=toBalance,
-                                    messageCodes=("xbrl.5.1.1.2:balanceCalcWeightIllegalNegative", "xbrl.5.1.1.2:balanceCalcWeightIllegalPositive"))
-                        if not fromConcept.isNumeric or not toConcept.isNumeric:
-                            modelXbrl.error("xbrl.5.2.5.2:nonNumericCalc",
-                                _("Calculation relationship has illegal concept from %(source)s%(sourceNumericDecorator)s to %(target)s%(targetNumericDecorator)s in link role %(linkrole)s"),
-                                modelObject=modelRel,
-                                source=fromConcept.qname, target=toConcept.qname, linkrole=ELR,
-                                sourceNumericDecorator="" if fromConcept.isNumeric else _(" (non-numeric)"),
-                                targetNumericDecorator="" if toConcept.isNumeric else _(" (non-numeric)"))
-            # check presentation relationships for preferredLabel issues
-            elif arcrole == XbrlConst.parentChild:
-                for modelRel in relsSet.modelRelationships:
-                    preferredLabel = modelRel.preferredLabel
-                    fromConcept = modelRel.fromModelObject
-                    toConcept = modelRel.toModelObject
-                    if preferredLabel is not None and isinstance(fromConcept, ModelConcept) and isinstance(toConcept, ModelConcept):
-                        label = toConcept.label(preferredLabel=preferredLabel,fallbackToQname=False,strip=True)
-                        if label is None:
-                            modelXbrl.error("xbrl.5.2.4.2.1:preferredLabelMissing",
-                                _("Presentation relationship from %(source)s to %(target)s in link role %(linkrole)s missing preferredLabel %(preferredLabel)s"),
-                                modelObject=modelRel,
-                                source=fromConcept.qname, target=toConcept.qname, linkrole=ELR,
-                                preferredLabel=preferredLabel)
-                        elif not label: # empty string
-                            modelXbrl.info("arelle:info.preferredLabelEmpty",
-                                _("(Info xbrl.5.2.4.2.1) Presentation relationship from %(source)s to %(target)s in link role %(linkrole)s has empty preferredLabel %(preferredLabel)s"),
-                                modelObject=modelRel,
-                                source=fromConcept.qname, target=toConcept.qname, linkrole=ELR,
-                                preferredLabel=preferredLabel)
-            # check essence-alias relationships
-            elif arcrole == XbrlConst.essenceAlias:
-                for modelRel in relsSet.modelRelationships:
-                    fromConcept = modelRel.fromModelObject
-                    toConcept = modelRel.toModelObject
-                    if fromConcept is not None and toConcept is not None:
-                        if fromConcept.type != toConcept.type or fromConcept.periodType != toConcept.periodType:
-                            modelXbrl.error("xbrl.5.2.6.2.2:essenceAliasTypes",
-                                _("Essence-alias relationship from %(source)s to %(target)s in link role %(linkrole)s has different types or periodTypes"),
-                                modelObject=modelRel,
-                                source=fromConcept.qname, target=toConcept.qname, linkrole=ELR)
-                        fromBalance = fromConcept.balance
-                        toBalance = toConcept.balance
-                        if fromBalance and toBalance:
-                            if fromBalance and toBalance and fromBalance != toBalance:
-                                modelXbrl.error("xbrl.5.2.6.2.2:essenceAliasBalance",  # type: ignore[func-returns-value]
-                                    _("Essence-alias relationship from %(source)s to %(target)s in link role %(linkrole)s has different balances")).format(
+                                    preferredLabel=preferredLabel)
+                            elif not label: # empty string
+                                modelXbrl.info("arelle:info.preferredLabelEmpty",
+                                    _("(Info xbrl.5.2.4.2.1) Presentation relationship from %(source)s to %(target)s in link role %(linkrole)s has empty preferredLabel %(preferredLabel)s"),
+                                    modelObject=modelRel,
+                                    source=fromConcept.qname, target=toConcept.qname, linkrole=ELR,
+                                    preferredLabel=preferredLabel)
+                # check essence-alias relationships
+                elif arcrole == XbrlConst.essenceAlias:
+                    for modelRel in relsSet.modelRelationships:
+                        fromConcept = modelRel.fromModelObject
+                        toConcept = modelRel.toModelObject
+                        if fromConcept is not None and toConcept is not None:
+                            if fromConcept.type != toConcept.type or fromConcept.periodType != toConcept.periodType:
+                                modelXbrl.error("xbrl.5.2.6.2.2:essenceAliasTypes",
+                                    _("Essence-alias relationship from %(source)s to %(target)s in link role %(linkrole)s has different types or periodTypes"),
                                     modelObject=modelRel,
                                     source=fromConcept.qname, target=toConcept.qname, linkrole=ELR)
-            elif modelXbrl.hasXDT and arcrole.startswith(XbrlConst.dimStartsWith):
-                ValidateXbrlDimensions.checkBaseSet(self, arcrole, ELR, relsSet)
-            elif arcrole in ValidateFormula.arcroleChecks:
-                ValidateFormula.checkBaseSet(self, arcrole, ELR, relsSet)
+                            fromBalance = fromConcept.balance
+                            toBalance = toConcept.balance
+                            if fromBalance and toBalance:
+                                if fromBalance and toBalance and fromBalance != toBalance:
+                                    modelXbrl.error("xbrl.5.2.6.2.2:essenceAliasBalance",  # type: ignore[func-returns-value]
+                                        _("Essence-alias relationship from %(source)s to %(target)s in link role %(linkrole)s has different balances")).format(
+                                        modelObject=modelRel,
+                                        source=fromConcept.qname, target=toConcept.qname, linkrole=ELR)
+                elif modelXbrl.hasXDT and arcrole.startswith(XbrlConst.dimStartsWith):
+                    ValidateXbrlDimensions.checkBaseSet(self, arcrole, ELR, relsSet)
+                elif arcrole in ValidateFormula.arcroleChecks:
+                    ValidateFormula.checkBaseSet(self, arcrole, ELR, relsSet)
         modelXbrl.isDimensionsValidated = True
         modelXbrl.profileStat(_("validateRelationships"))
 
@@ -275,6 +281,7 @@ class ValidateXbrl:
             self.checkFacts(modelXbrl.facts)
             self.checkContexts(self.modelXbrl.contexts.values())
             self.checkUnits(self.modelXbrl.units.values())
+            self.checkDuplicateFacts(modelXbrl.facts, self.validateDuplicateFacts)
 
             modelXbrl.profileStat(_("validateInstance"))
 
@@ -400,6 +407,9 @@ class ValidateXbrl:
         for pluginXbrlMethod in pluginClassMethods("Validate.XBRL.Finally"):
             pluginXbrlMethod(self)
 
+        if modelXbrl.loadedFromOIM or modelXbrl.modelManager.validateXmlOim:
+            validateOIM(modelXbrl)
+
         modelXbrl.profileStat() # reset after plugins
 
         modelXbrl.modelManager.showStatus(_("validating DTS"))
@@ -443,7 +453,7 @@ class ValidateXbrl:
             self.factsWithDeprecatedIxNamespace = []
             factFootnoteRefs = set()
             undefinedFacts = []
-            for f in cast(Set[ModelInlineFact], modelXbrl.factsInInstance):
+            for f in cast(set[ModelInlineFact], modelXbrl.factsInInstance):
                 for footnoteID in f.footnoteRefs:
                     if footnoteID not in self.ixdsFootnotes:
                         modelXbrl.error(ixMsgCode("footnoteRef", f, name="footnote", sect="validation"),
@@ -680,6 +690,18 @@ class ValidateXbrl:
                                 linkrole=modelLink.role,
                                 xlinkLabel=resourceArcToLabel)
 
+    def checkDuplicateFacts(self, facts: list[ModelFact], duplicateType: ValidateDuplicateFacts.DuplicateType) -> None:
+        for duplicateFactSet in ValidateDuplicateFacts.getDuplicateFactSetsWithType(facts, duplicateType):
+            self.modelXbrl.warning(
+                "arelle:duplicateFacts",
+                "Duplicate fact set with %(duplicateType)s duplicate(s) %(qname)s: %(values)s, %(contextIDs)s.",
+                modelObject=duplicateFactSet.facts,
+                duplicateType=duplicateType.description,
+                qname=duplicateFactSet.facts[0].qname,
+                contextIDs=", ".join(sorted(set(f.contextID for f in duplicateFactSet.facts))),
+                values=", ".join(strTruncate(f.value, 64) for f in duplicateFactSet.facts),
+            )
+
     def checkFacts(self, facts: list[ModelFact], inTuple: dict[Any, Any] | None = None) -> None:  # do in document order
         for f in facts:
             concept = f.concept
@@ -780,13 +802,15 @@ class ValidateXbrl:
                                 self.modelXbrl.error("xbrl.4.6.3:missingPrecisionDecimals",
                                     _("Fact %(fact)s context %(contextID)s is a numeric concept and must have either precision or decimals"),
                                     modelObject=f, fact=f.qname, contextID=f.contextID)
-                            elif f.concept.instanceOfType(dtrNoDecimalsItemTypes) and inferredDecimals(f) > 0:
-                                if hasDecimals:
-                                    message = _("Fact %(fact)s context %(contextID)s must not have decimals value > 0: %(inferredDecimals)s")
-                                else:
-                                    message = _("Fact %(fact)s context %(contextID)s must not have inferred decimals value > 0: %(inferredDecimals)s")
-                                self.modelXbrl.error("dtre:noDecimalsItemType", message,
-                                    modelObject=f, fact=f.qname, contextID=f.contextID, inferredDecimals=inferredDecimals(f))
+                            elif f.concept.instanceOfType(dtrNoDecimalsItemTypes):
+                                evaluatedDecimals = inferredDecimals(f)
+                                if evaluatedDecimals > 0 and not math.isinf(evaluatedDecimals):
+                                    if hasDecimals:
+                                        message = _("Fact %(fact)s context %(contextID)s must not have decimals value > 0: %(inferredDecimals)s")
+                                    else:
+                                        message = _("Fact %(fact)s context %(contextID)s must not have inferred decimals value > 0: %(inferredDecimals)s")
+                                    self.modelXbrl.error("dtre:noDecimalsItemType", message,
+                                        modelObject=f, fact=f.qname, contextID=f.contextID, inferredDecimals=inferredDecimals(f))
                         else:
                             if hasPrecision or hasDecimals:
                                 self.modelXbrl.error("xbrl.4.6.3:extraneousPrecisionDecimals",
@@ -816,7 +840,7 @@ class ValidateXbrl:
                         #            _("Fact %(fact)s value %(value)s context %(contextID)s rounding exception %(error)s"),
                         #            modelObject=f, fact=f.qname, value=f.value, contextID=f.contextID, error = err)
                     if self.validateEnum and concept.isEnumeration and getattr(f,"xValid", 0) == 4 and not f.isNil:
-                        _qnEnums = cast(Union[List[QName], QName], f.xValue)
+                        _qnEnums = cast(list[QName] | QName, f.xValue)
                         qnEnums = _qnEnums if isinstance(_qnEnums, list) else [_qnEnums]
                         if not all(ValidateXbrlDimensions.enumerationMemberUsable(self, concept, self.modelXbrl.qnameConcepts.get(qnEnum))
                                    for qnEnum in qnEnums):
@@ -1110,14 +1134,14 @@ class ValidateXbrl:
         self.modelXbrl = modelXbrl
         ValidateFormula.executeCallTest(self, name, callTuple, testTuple)
 
-    def getPluginData(self, pluginName: str) -> PluginValidationData | None:
+    def getPluginData(self, pluginName: str) -> PluginData | None:
         allPluginData = getattr(self, "_pluginData", None)
         if allPluginData is None:
             raise RuntimeError("PluginData can't be retrieved until validation has begun.")
-        pluginData: PluginValidationData = allPluginData.get(pluginName)
+        pluginData: PluginData | None = allPluginData.get(pluginName)
         return pluginData
 
-    def setPluginData(self, pluginData: PluginValidationData) -> None:
+    def setPluginData(self, pluginData: PluginData) -> None:
         allPluginData = getattr(self, "_pluginData", None)
         if allPluginData is None:
             raise RuntimeError("PluginData can't be set until validation has begun.")

arelle/ValidateXbrlCalcs.py

@@ -12,12 +12,17 @@ from arelle import Locale, XbrlConst, XbrlUtil
 from arelle.ModelObject import ObjectPropertyViewWrapper
 from arelle.PythonUtil import flattenSequence, strTruncate
 from arelle.XmlValidateConst import UNVALIDATED, VALID
+from arelle.utils.Contexts import partitionModelXbrlContexts
+from arelle.utils.Units import partitionModelXbrlUnits
 
 if TYPE_CHECKING:
+    from _decimal import Decimal
     from arelle.ModelInstanceObject import ModelFact
+    from arelle.ModelValue import TypeXValue
 else:
     ModelFact = None # circular import with ModelInstanceObject
 
+
 def init(): # prevent circular imports
     global ModelFact
     if ModelFact is None:
@@ -144,27 +149,15 @@ class ValidateXbrlCalcs:
 
         # identify equal contexts
         modelXbrl.profileActivity()
-        uniqueContextHashes = {}
-        for context in modelXbrl.contexts.values():
-            h = context.contextDimAwareHash
-            if h in uniqueContextHashes:
-                if context.isEqualTo(uniqueContextHashes[h]):
-                    self.mapContext[context] = uniqueContextHashes[h]
-            else:
-                uniqueContextHashes[h] = context
-        del uniqueContextHashes
+        for exemplar_context, *contexts in partitionModelXbrlContexts(modelXbrl).values():
+            for context in contexts:
+                self.mapContext[context] = exemplar_context
         modelXbrl.profileActivity("... identify equal contexts", minTimeToShow=1.0)
 
         # identify equal units
-        uniqueUnitHashes = {}
-        for unit in modelXbrl.units.values():
-            h = unit.hash
-            if h in uniqueUnitHashes:
-                if unit.isEqualTo(uniqueUnitHashes[h]):
-                    self.mapUnit[unit] = uniqueUnitHashes[h]
-            else:
-                uniqueUnitHashes[h] = unit
-        del uniqueUnitHashes
+        for exemplar_unit, *units in partitionModelXbrlUnits(modelXbrl).values():
+            for unit in units:
+                self.mapUnit[unit] = exemplar_unit
         modelXbrl.profileActivity("... identify equal units", minTimeToShow=1.0)
 
         # identify concepts participating in essence-alias relationships
@@ -219,6 +212,12 @@ class ValidateXbrlCalcs:
                                                 modelObject=(siRels[itemConcept], modelRel), linkrole=modelRel.linkrole,
                                                 sumConcept=sumConcept.qname, itemConcept=itemConcept.qname)
                                         siRels[itemConcept] = modelRel
+                                        if not sumConcept.isDecimal or not itemConcept.isDecimal:
+                                            modelXbrl.error("calc11e:nonDecimalItemNode",
+                                                _("The source and target of a Calculations v1.1 relationship MUST both be decimal concepts: %(sumConcept)s, %(itemConcept)s, link role %(linkrole)s"),
+                                                modelObject=(sumConcept, itemConcept, modelRel), linkrole=modelRel.linkrole,
+                                                sumConcept=sumConcept.qname, itemConcept=itemConcept.qname)
+
                             # add up rounded items
                             boundSums = defaultdict(decimal.Decimal) # sum of facts meeting factKey
                             boundIntervals = {} # interval sum of facts meeting factKey
@@ -250,6 +249,8 @@ class ValidateXbrlCalcs:
                                                 x1, x2, iX1, iX2 = boundIntervals.get(itemBindKey, ZERO_RANGE)
                                                 y1 *= w
                                                 y2 *= w
+                                                if y2 < y1:
+                                                    y1, y2 = y2, y1
                                                 boundIntervals[itemBindKey] = (x1 + y1, x2 + y2, iX1 and iY1, iX2 and iY2)
                                                 boundIntervalItems[itemBindKey].extend(_itemFacts)
                             for sumBindKey in boundSumKeys:
@@ -284,7 +285,7 @@ class ValidateXbrlCalcs:
                                                             linkroleDefinition=modelXbrl.roleTypeDefinition(ELR),
                                                             reportedSum=Locale.format_decimal(modelXbrl.locale, roundedSum, 1, max(d,0)),
                                                             computedSum=Locale.format_decimal(modelXbrl.locale, roundedItemsSum, 1, max(d,0)),
-                                                            contextID=fact.context.id, unitID=fact.unit.id,
+                                                            contextID=fact.context.id, unitID=fact.unit.id if fact.unit is not None else "(none)",
                                                             unreportedContributors=", ".join(unreportedContribingItemQnames) or "none")
                                                         del unreportedContribingItemQnames[:]
                                     if calc11:
@@ -296,14 +297,14 @@ class ValidateXbrlCalcs:
                                             inclA = incls1 | inclx1
                                             inclB = incls2 | inclx2
                                             if (a == b and not (inclA and inclB)) or (a > b):
-                                                modelXbrl.error("calc11e:inconsistentCalculationUsing" + self.calc11suffix,
+                                                modelXbrl.log('INCONSISTENCY', "calc11e:inconsistentCalculationUsing" + self.calc11suffix,
                                                     _("Calculation inconsistent from %(concept)s in link role %(linkrole)s reported sum %(reportedSum)s computed sum %(computedSum)s context %(contextID)s unit %(unitID)s"),
                                                     modelObject=sumFacts + boundIntervalItems[sumBindKey],
                                                     concept=sumConcept.qname, linkrole=ELR,
                                                     linkroleDefinition=modelXbrl.roleTypeDefinition(ELR),
                                                     reportedSum=rangeToStr(s1,s2,incls1,incls2),
                                                     computedSum=rangeToStr(x1,x2,inclx1,inclx2),
-                                                    contextID=sumFacts[0].context.id, unitID=sumFacts[0].unit.id)
+                                                    contextID=sumFacts[0].context.id, unitID=sumFacts[0].unit.id if sumFacts[0].unit is not None else "(none)")
                             boundSummationItems.clear() # dereference facts in list
                             boundIntervalItems.clear()
                     elif arcrole == XbrlConst.essenceAlias:
@@ -450,14 +451,14 @@ class ValidateXbrlCalcs:
                         inclB |= _inclB
             _inConsistent = (a == b and not(inclA and inclB)) or (a > b)
         if _excessDigitFacts:
-            self.modelXbrl.error("calc11e:excessDigits",
+            self.modelXbrl.log('INCONSISTENCY', "calc11e:excessDigits",
                 _("Calculations check stopped for excess digits in fact values %(element)s: %(values)s, %(contextIDs)s."),
                 modelObject=fList, element=_excessDigitFacts[0].qname,
                 contextIDs=", ".join(sorted(set(f.contextID for f in _excessDigitFacts))),
                 values=", ".join(strTruncate(f.value,64) for f in _excessDigitFacts))
             return (INCONSISTENT, INCONSISTENT,True,True)
         if _inConsistent:
-            self.modelXbrl.error(
+            self.modelXbrl.log('INCONSISTENCY',
                 "calc11e:disallowedDuplicateFactsUsingTruncation" if self.calc11t else "oime:disallowedDuplicateFacts",
                 _("Calculations check stopped for duplicate fact values %(element)s: %(values)s, %(contextIDs)s."),
                 modelObject=fList, element=fList[0].qname,
@@ -685,55 +686,39 @@ def rangeValue(value, decimals=None, truncate=False) -> tuple[decimal.Decimal, d
                 return (vDecimal - dd, vDecimal + dd, False, False)
     return (vDecimal, vDecimal, True, True)
 
-def insignificantDigits(value, precision=None, decimals=None, scale=None):
+
+def insignificantDigits(
+        value: TypeXValue,
+        decimals: int | float | Decimal | str) -> tuple[Decimal, Decimal] | None:
+    # Normalize value
     try:
-        vDecimal = decimal.Decimal(value)
-        if scale:
-            iScale = int(scale)
-            vDecimal = vDecimal.scaleb(iScale)
-        if precision is not None:
-            vFloat = float(value)
-            if scale:
-                vFloat = pow(vFloat, iScale)
-    except (decimal.InvalidOperation, ValueError): # would have been a schema error reported earlier
+        valueDecimal = decimal.Decimal(value)
+    except (decimal.InvalidOperation, ValueError):  # would have been a schema error reported earlier
         return None
-    if precision is not None:
-        if not isinstance(precision, (int,float)):
-            if precision == "INF":
-                return None
-            else:
-                try:
-                    precision = int(precision)
-                except ValueError: # would be a schema error
-                    return None
-        if isinf(precision) or precision == 0 or isnan(precision) or vFloat == 0:
+    if not valueDecimal.is_normal():  # prevent exception with excessive quantization digits
+        return None
+    # Normalize decimals
+    if isinstance(decimals, str):
+        if decimals == "INF":
             return None
         else:
-            vAbs = fabs(vFloat)
-            log = log10(vAbs)
-            decimals = precision - int(log) - (1 if vAbs >= 1 else 0)
-    elif decimals is not None:
-        if not isinstance(decimals, (int,float)):
-            if decimals == "INF":
+            try:
+                decimals = int(decimals)
+            except ValueError:  # would have been a schema error reported earlier
                 return None
-            else:
-                try:
-                    decimals = int(decimals)
-                except ValueError: # would be a schema error
-                    return None
-        if isinf(decimals) or isnan(decimals):
-            return None
-    else:
+    if isinf(decimals) or isnan(decimals) or decimals <= -28:  # prevent exception with excessive quantization digits
+        return None
+    if decimals > 0:
+        divisor = ONE.scaleb(-decimals)  # fractional scaling doesn't produce scientific notation
+    else:  # extra quantize step to prevent scientific notation for decimal number
+        divisor = ONE.scaleb(-decimals).quantize(ONE, decimal.ROUND_HALF_UP) # should never round
+    try:
+        quotient, insignificant = divmod(valueDecimal, divisor)
+    except decimal.InvalidOperation:
         return None
-    if vDecimal.is_normal() and -28 <= decimals <= 28: # prevent exception with excessive quantization digits
-        if decimals > 0:
-            divisor = ONE.scaleb(-decimals) # fractional scaling doesn't produce scientific notation
-        else:  # extra quantize step to prevent scientific notation for decimal number
-            divisor = ONE.scaleb(-decimals).quantize(ONE, decimal.ROUND_HALF_UP) # should never round
-        insignificantDigits = abs(vDecimal) % divisor
-        if insignificantDigits:
-            return (vDecimal // divisor * divisor,  # truncated portion of number
-                    insignificantDigits)   # nsignificant digits portion of number
+    if insignificant:
+        significant = quotient * divisor
+        return significant, abs(insignificant)
     return None