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

arelle/ModelXbrl.py

@@ -3,22 +3,29 @@ See COPYRIGHT.md for copyright information.
 '''
 from __future__ import annotations
 
-import os, sys, traceback, uuid
-import regex as re
-from collections import defaultdict
-from collections.abc import Iterable
-from typing import Dict, TYPE_CHECKING, Any, Type, TypeVar, Union, cast, Optional
 import logging
-from decimal import Decimal
-from arelle import UrlUtil, XmlUtil, ModelValue, XbrlConst, XmlValidate
-from arelle.FileSource import FileNamedStringIO
-from arelle.ModelObject import ModelObject, ObjectPropertyViewWrapper
+import os
+import sys
+import traceback
+import uuid
+from collections import defaultdict
+from typing import TYPE_CHECKING, Any, TypeVar, Union, cast, Optional
+
+import regex as re
+from collections.abc import Iterable, Iterator
+
+import arelle
+from arelle import FileSource, ModelRelationshipSet, XmlUtil, ModelValue, XbrlConst, XmlValidate
+from arelle.ErrorManager import ErrorManager
 from arelle.Locale import format_string
+from arelle.ModelObject import ModelObject
+from arelle.ModelValue import dateUnionEqual
 from arelle.PluginManager import pluginClassMethods
 from arelle.PrototypeInstanceObject import FactPrototype, DimValuePrototype
-from arelle.PythonUtil import flattenSequence
 from arelle.UrlUtil import isHttpUrl
 from arelle.ValidateXbrlDimensions import isFactDimensionallyValid
+from arelle.XbrlConst import standardLabel
+from arelle.XbrlUtil import sEqual
 
 if TYPE_CHECKING:
     from datetime import date, datetime
@@ -32,7 +39,8 @@ if TYPE_CHECKING:
     from arelle.ModelRelationshipSet import ModelRelationshipSet as ModelRelationshipSetClass
     from arelle.ModelValue import QName
     from arelle.PrototypeDtsObject import LinkPrototype
-    from arelle.typing import EmptyTuple, TypeGetText, LocaleDict
+    from arelle.typing import TypeGetText, LocaleDict
+    from arelle.ValidateUtr import UtrEntry
 
     _: TypeGetText  # Handle gettext
 else:
@@ -46,10 +54,10 @@ AUTO_LOCATE_ELEMENT = '771407c0-1d0c-11e1-be5e-028037ec0200' # singleton meaning
 DEFAULT = sys.intern("default")
 NONDEFAULT = sys.intern("non-default")
 DEFAULTorNONDEFAULT = sys.intern("default-or-non-default")
-EMPTY_TUPLE: EmptyTuple = ()
+_NOT_FOUND = object()
 
 
-def load(modelManager: ModelManager, url: str | FileSourceClass, nextaction: str | None = None, base: str | None = None, useFileSource: FileSourceClass | None = None, errorCaptureLevel: str | None = None, **kwargs: str) -> ModelXbrl:
+def load(modelManager: ModelManager, url: str | FileSourceClass, nextaction: str | None = None, base: str | None = None, useFileSource: FileSourceClass | None = None, errorCaptureLevel: int | None = None, **kwargs: Any) -> ModelXbrl:
     """Each loaded instance, DTS, testcase, testsuite, versioning report, or RSS feed, is represented by an
     instance of a ModelXbrl object. The ModelXbrl object has a collection of ModelDocument objects, each
     representing an XML document (for now, with SQL whenever its time comes). One of the modelDocuments of
@@ -61,7 +69,6 @@ def load(modelManager: ModelManager, url: str | FileSourceClass, nextaction: str
     :param useFileSource: for internal use (when an entry point is in a FileSource archive and discovered files expected to also be in the entry point's archive.
    """
     if nextaction is None: nextaction = _("loading")
-    from arelle import (ModelDocument, FileSource)
     modelXbrl = create(modelManager, errorCaptureLevel=errorCaptureLevel)
     if "errors" in kwargs: # pre-load errors, such as from taxonomy package validation
         modelXbrl.errors.extend(cast(str, kwargs.get("errors")))
@@ -84,10 +91,10 @@ def load(modelManager: ModelManager, url: str | FileSourceClass, nextaction: str
         modelXbrl.closeFileSource= True
     modelXbrl.modelDocument = None
     if kwargs.get("isLoadable",True): # used for test cases to block taxonomy packages without discoverable contents
-        modelXbrl.modelDocument = ModelDocument.load(modelXbrl, url, base, isEntry=True, **kwargs)
+        modelXbrl.modelDocument = arelle.ModelDocument.load(modelXbrl, url, base, isEntry=True, **kwargs)
         if supplementalUrls:
             for url in supplementalUrls:
-                ModelDocument.load(modelXbrl, url, base, isEntry=False, isDiscovered=True, **kwargs)
+                arelle.ModelDocument.load(modelXbrl, url, base, isEntry=False, isDiscovered=True, **kwargs)
         if hasattr(modelXbrl, "entryLoadingUrl"):
             del modelXbrl.entryLoadingUrl
         loadSchemalocatedSchemas(modelXbrl)
@@ -103,24 +110,22 @@ def load(modelManager: ModelManager, url: str | FileSourceClass, nextaction: str
 
 def create(
         modelManager: ModelManager, newDocumentType: int | None = None, url: str | None = None, schemaRefs: str|None = None, createModelDocument: bool = True, isEntry: bool = False,
-        errorCaptureLevel: str | None = None, initialXml: str | None = None, initialComment: str | None = None, base: str | None = None, discover: bool = True, xbrliNamespacePrefix: str | None = None
+        errorCaptureLevel: int | None = None, initialXml: str | None = None, initialComment: str | None = None, base: str | None = None, discover: bool = True, xbrliNamespacePrefix: str | None = None
 ) -> ModelXbrl:
-    from arelle import (ModelDocument, FileSource)
     modelXbrl = ModelXbrl(modelManager, errorCaptureLevel=errorCaptureLevel)
     modelXbrl.locale = modelManager.locale
     if newDocumentType:
         modelXbrl.fileSource = FileSource.FileSource(cast(str, url), modelManager.cntlr)  # url may be an open file handle, use str(url) below
         modelXbrl.closeFileSource= True
         if createModelDocument:
-            modelXbrl.modelDocument = ModelDocument.create(modelXbrl, newDocumentType, str(url), schemaRefs=schemaRefs, isEntry=isEntry, initialXml=initialXml, initialComment=initialComment, base=base, discover=discover, xbrliNamespacePrefix=xbrliNamespacePrefix)
+            modelXbrl.modelDocument = arelle.ModelDocument.create(modelXbrl, newDocumentType, str(url), schemaRefs=schemaRefs, isEntry=isEntry, initialXml=initialXml, initialComment=initialComment, base=base, discover=discover, xbrliNamespacePrefix=xbrliNamespacePrefix)
             if isEntry:
                 del modelXbrl.entryLoadingUrl
                 loadSchemalocatedSchemas(modelXbrl)
     return modelXbrl
 
 def loadSchemalocatedSchemas(modelXbrl: ModelXbrl) -> None:
-    from arelle import ModelDocument
-    if modelXbrl.modelDocument and modelXbrl.modelDocument.type <= ModelDocument.Type.INLINEXBRLDOCUMENTSET:
+    if modelXbrl.modelDocument and modelXbrl.modelDocument.type <= arelle.ModelDocument.Type.INLINEXBRLDOCUMENTSET:
         # at this point DTS is fully discovered but schemaLocated xsd's are not yet loaded
         modelDocumentsSchemaLocated: set[ModelDocumentClass] = set()
         # loadSchemalocatedSchemas sometimes adds to modelXbrl.urlDocs
@@ -133,7 +138,7 @@ def loadSchemalocatedSchemas(modelXbrl: ModelXbrl) -> None:
             modelDocumentsSchemaLocated |= modelDocuments
 
 
-MatchSubstitutionGroupValueType = TypeVar('MatchSubstitutionGroupValueType', Type[ModelObject], bool)
+MatchSubstitutionGroupValueType = TypeVar('MatchSubstitutionGroupValueType', type[ModelObject], bool)
 
 
 class ModelXbrl:
@@ -286,7 +291,7 @@ class ModelXbrl:
     entryLoadingUrl: str
     fileSource: FileSourceClass
     ixdsDocUrls: list[str]
-    ixdsHtmlElements: list[str]
+    ixdsHtmlElements: list[Any]
     isDimensionsValidated: bool
     locale: LocaleDict | None
     modelDocument: ModelDocumentClass | None
@@ -302,20 +307,20 @@ class ModelXbrl:
     _nonNilFactsInInstance: set[ModelFact]
     _startedProfiledActivity: float
     _startedTimeStat: float
+    _qnameUtrUnits: dict[QName, UtrEntry]
 
-    def __init__(self,  modelManager: ModelManager, errorCaptureLevel: str | None = None) -> None:
+    def __init__(self,  modelManager: ModelManager, errorCaptureLevel: int | None = None) -> None:
         self.modelManager = modelManager
         self.skipDTS: bool = modelManager.skipDTS
         self.init(errorCaptureLevel=errorCaptureLevel)
 
-    def init(self, keepViews: bool = False, errorCaptureLevel: str | None = None) -> None:
+    def init(self, keepViews: bool = False, errorCaptureLevel: int | None = None) -> None:
         self.uuid: str = uuid.uuid1().urn
         self.namespaceDocs: defaultdict[str, list[ModelDocumentClass]] = defaultdict(list)
         self.urlDocs: dict[str, ModelDocumentClass] = {}
         self.urlUnloadableDocs: dict[bool, str] = {}  # if entry is True, entry is blocked and unloadable, False means loadable but warned
-        self.errorCaptureLevel: str = (errorCaptureLevel or logging._checkLevel("INCONSISTENCY"))  # type: ignore[attr-defined]
-        self.errors: list[str | None] = []
-        self.logCount: dict[str, int] = {}
+        self.errorCaptureLevel: int = (errorCaptureLevel or logging._checkLevel("INCONSISTENCY"))  # type: ignore[attr-defined]
+        self.errorManager = ErrorManager(self.modelManager, self.errorCaptureLevel)
         self.arcroleTypes: defaultdict[str, list[ModelRoleType]] = defaultdict(list)
         self.roleTypes: defaultdict[str, list[ModelRoleType]] = defaultdict(list)
         self.qnameConcepts: dict[QName, ModelConcept] = {}  # indexed by qname of element
@@ -325,13 +330,17 @@ class ModelXbrl:
         self.qnameGroupDefinitions: dict[QName, Any] = {}
         self.qnameTypes: dict[QName, ModelType] = {}  # contains ModelTypes by qname key of type
         self.baseSets: defaultdict[tuple[str, str | None, QName | None, QName | None], list[ModelObject | LinkPrototype]] = defaultdict(list)  # contains ModelLinks for keys arcrole, arcrole#linkrole
-        self.relationshipSets: dict[tuple[str] | tuple[str, tuple[str, ...] | str | None, QName | None, QName | None, bool], ModelRelationshipSetClass] = {}  # contains ModelRelationshipSets by bas set keys
+        self.relationshipSets: dict[tuple[str] | tuple[tuple[str, ...] | str, tuple[str, ...] | str | None, QName | None, QName | None, bool], ModelRelationshipSetClass] = {}  # contains ModelRelationshipSets by bas set keys
         self.qnameDimensionDefaults: dict[QName, QName] = {}  # contains qname of dimension (index) and default member(value)
         self.facts: list[ModelFact] = []
         self.factsInInstance: set[ModelFact] = set()
         self.undefinedFacts: list[ModelFact] = []  # elements presumed to be facts but not defined
-        self.contexts: dict[str, ModelDocumentClass.xmlRootElement] = {}
+        self.contexts: dict[str, ModelContext] = {}
+        self.ixdsUnmappedContexts: dict[str, ModelContext] = {}
+        self._contextsInUseMarked = False
         self.units: dict[str, ModelUnit] = {}
+        self.ixdsUnmappedUnits: dict[str, ModelUnit] = {}
+        self._unitsInUseMarked = False
         self.modelObjects: list[ModelObject] = []
         self.qnameParameters: dict[QName, Any] = {}
         self.modelVariableSets: set[ModelVariableSet] = set()
@@ -342,19 +351,18 @@ class ModelXbrl:
         if not keepViews:
             self.views: list[Any] = []
         self.langs: set[str] = {self.modelManager.defaultLang}
-        from arelle.XbrlConst import standardLabel
         self.labelroles: set[str] = {standardLabel}
         self.hasXDT: bool = False
         self.hasTableRendering: bool = False
         self.hasTableIndexing: bool = False
         self.hasFormulae: bool = False
+        self.loadedFromOIM = False
+        self.loadedFromOimErrorCount = 0
         self.formulaOutputInstance: ModelXbrl | None = None
-        self.logger: Any = logging.getLogger("arelle")
+        self.logger: logging.Logger | None = self.modelManager.cntlr.logger
         self.logRefObjectProperties: bool = getattr(self.logger, "logRefObjectProperties", False)
         self.logRefHasPluginAttrs: bool = any(True for m in pluginClassMethods("Logging.Ref.Attributes"))
         self.logRefHasPluginProperties: bool = any(True for m in pluginClassMethods("Logging.Ref.Properties"))
-        self.logHasRelevelerPlugin: bool = any(True for m in pluginClassMethods("Logging.Severity.Releveler"))
-        self.logRefFileRelUris: defaultdict[Any, dict[str, str]] = defaultdict(dict)
         self.profileStats: dict[str, tuple[int, float, float | int]] = {}
         self.schemaDocsToValidate: set[ModelDocumentClass] = set()
         self.modelXbrl = self  # for consistency in addressing modelXbrl
@@ -392,9 +400,8 @@ class ModelXbrl:
         :param nextAction: status line text string, if any, to show upon completion
         :param reloadCache: True to force clearing and reloading of web cache, if working online.
         """
-        from arelle import ModelDocument
         self.init(keepViews=True)
-        self.modelDocument = ModelDocument.load(self, self.fileSource.url, isEntry=True, reloadCache=reloadCache)
+        self.modelDocument = arelle.ModelDocument.load(self, self.fileSource.url, isEntry=True, reloadCache=reloadCache)
         self.modelManager.showStatus(_("xbrl loading finished, {0}...").format(nextaction),5000)
         self.modelManager.reloadViews(self)
 
@@ -415,7 +422,17 @@ class ModelXbrl:
         else:
             return self.fileSource.url
 
-    def relationshipSet(self, arcrole: str, linkrole: tuple[str, ...] | str | None = None, linkqname: QName | None = None, arcqname: QName | None = None, includeProhibits: bool = False) -> ModelRelationshipSetClass:
+    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).
 
         Resolve and determine relationship set.  If a relationship set of the same parameters was previously resolved, it is returned from a cache.
@@ -425,7 +442,6 @@ class ModelXbrl:
         :param arcqname: Arc element qname (wild if None)
         :param includeProhibits: True to include prohibiting arc elements as relationships
         """
-        from arelle import ModelRelationshipSet
         key = (arcrole, linkrole, linkqname, arcqname, includeProhibits)
         if key not in self.relationshipSets:
             ModelRelationshipSet.create(self, arcrole, linkrole, linkqname, arcqname, includeProhibits)
@@ -438,7 +454,7 @@ class ModelXbrl:
         return None
 
     def roleUriTitle(self, roleURI: str) -> str:
-        return re.sub(r"([A-Z])", r" \1", os.path.basename(roleURI)).title()
+        return re.sub(r"(?!^)[A-Z]", r" \g<0>", os.path.basename(roleURI)).title()
 
     def roleTypeDefinition(self, roleURI: str, lang: str | None = None) -> str:
         modelRoles  = self.roleTypes.get(roleURI, ())
@@ -463,15 +479,17 @@ class ModelXbrl:
         :param elementQname: Element/Concept QName to find substitution group
         :param subsGrpMatchTable: Table of substitutions used to determine xml proxy object class for xml elements and substitution group membership
         """
-        if elementQname in subsGrpMatchTable:
-            return subsGrpMatchTable[elementQname] # head of substitution group
+        result = subsGrpMatchTable.get(elementQname, _NOT_FOUND)
+        if result is not _NOT_FOUND:
+            return cast(MatchSubstitutionGroupValueType, result) # head of substitution group
         elementMdlObj = self.qnameConcepts.get(elementQname)
         if elementMdlObj is not None:
             subsGrpMdlObj = elementMdlObj.substitutionGroup
             while subsGrpMdlObj is not None:
                 subsGrpQname = subsGrpMdlObj.qname
-                if subsGrpQname in subsGrpMatchTable:
-                    return subsGrpMatchTable[subsGrpQname]
+                result = subsGrpMatchTable.get(subsGrpQname, _NOT_FOUND)
+                if result is not _NOT_FOUND:
+                    return cast(MatchSubstitutionGroupValueType, result)
                 subsGrpMdlObj = subsGrpMdlObj.substitutionGroup
         return subsGrpMatchTable.get(None)
 
@@ -499,8 +517,7 @@ class ModelXbrl:
 
         :param url: File name to save the new instance document
         """
-        from arelle import (ModelDocument, FileSource)
-        if self.modelDocument and self.modelDocument.type == ModelDocument.Type.INSTANCE:
+        if self.modelDocument and self.modelDocument.type == arelle.ModelDocument.Type.INSTANCE:
             # entry already is an instance, delete facts etc.
             del self.facts[:]
             self.factsInInstance.clear()
@@ -522,7 +539,7 @@ class ModelXbrl:
                 schemaRefUri = self.uri
             else:   # relativize local paths
                 schemaRefUri = os.path.relpath(self.uri, os.path.dirname(url))
-            self.modelDocument = ModelDocument.create(self, ModelDocument.Type.INSTANCE, url, schemaRefs=[schemaRefUri], isEntry=True)
+            self.modelDocument = arelle.ModelDocument.create(self, arelle.ModelDocument.Type.INSTANCE, url, schemaRefs=[schemaRefUri], isEntry=True)
             if priorFileSource:
                 priorFileSource.close()
             self.closeFileSource= True
@@ -571,13 +588,10 @@ class ModelXbrl:
         :param segOCCs: Segment non-dimensional nodes
         :param scenOCCs: Scenario non-dimensional nodes
         """
-        from arelle.ModelFormulaObject import Aspect
-        from arelle.ModelValue import dateUnionEqual
-        from arelle.XbrlUtil import sEqual
         if dims:
-            segAspect, scenAspect = (Aspect.NON_XDT_SEGMENT, Aspect.NON_XDT_SCENARIO)
+            segAspect, scenAspect = (arelle.ModelFormulaObject.Aspect.NON_XDT_SEGMENT, arelle.ModelFormulaObject.Aspect.NON_XDT_SCENARIO)
         else:
-            segAspect, scenAspect = (Aspect.COMPLETE_SEGMENT, Aspect.COMPLETE_SCENARIO)
+            segAspect, scenAspect = (arelle.ModelFormulaObject.Aspect.COMPLETE_SEGMENT, arelle.ModelFormulaObject.Aspect.COMPLETE_SCENARIO)
         for c in self.contexts.values():
             if (c.entityIdentifier == (entityIdentScheme, entityIdentValue) and
                 ((c.isInstantPeriod and periodType == "instant" and dateUnionEqual(c.instantDatetime, periodEndInstant, instantEndDate=True)) or
@@ -594,7 +608,7 @@ class ModelXbrl:
                         for cOCCs,mOCCs in ((c.nonDimValues(segAspect),segOCCs),
                                             (c.nonDimValues(scenAspect),scenOCCs)))
                 ):
-                    return cast('ModelContext', c)
+                    return c
         return None
 
     def createContext(
@@ -639,7 +653,6 @@ class ModelXbrl:
                              text=XmlUtil.dateunionValue(periodEndInstant, subtractOneDay=True))
         segmentElt = None
         scenarioElt = None
-        from arelle.ModelInstanceObject import ModelDimensionValue
         if dims: # requires primary item to determin ambiguous concepts
             ''' in theory we have to check full set of dimensions for validity in source or any other
                 context element, but for shortcut will see if each dimension is already reported in an
@@ -655,13 +668,13 @@ class ModelXbrl:
                     self.info("arelle:info",
                         _("Create context for %(priItem)s, cannot determine valid context elements, no suitable hypercubes"),
                         modelObject=self, priItem=priItem)
-                    # fp.context.qnameDims is actually of type Dict[QName, DimValuePrototype]
-                fpDims = cast(Dict[Union[int, 'QName'], Union['QName', DimValuePrototype]], fp.context.qnameDims)
+                    # fp.context.qnameDims is actually of type dict[QName, DimValuePrototype]
+                fpDims = cast(dict[Union[int, 'QName'], Union['QName', DimValuePrototype]], fp.context.qnameDims)
             else:
                 fpDims = dims # dims known to be valid (such as for inline extraction)
             for dimQname in sorted(fpDims.keys()):
                 dimValue:DimValuePrototype | ModelDimensionValue | QName = fpDims[dimQname]
-                if isinstance(dimValue, (DimValuePrototype,ModelDimensionValue)):
+                if isinstance(dimValue, (DimValuePrototype,arelle.ModelInstanceObject.ModelDimensionValue)):
                     dimMemberQname = dimValue.memberQname  # None if typed dimension
                     contextEltName = dimValue.contextElement
                 else: # qname for explicit or node for typed
@@ -684,7 +697,7 @@ class ModelXbrl:
                 if cast('DimValuePrototype | ModelDimensionValue', dimValue).isTyped:  #Typing thinks that this can also be a QName
                     dimElt = XmlUtil.addChild(contextElt, XbrlConst.xbrldi, "xbrldi:typedMember",
                                               attributes=dimAttr)
-                    if isinstance(dimValue, (ModelDimensionValue, DimValuePrototype)) and dimValue.isTyped:
+                    if isinstance(dimValue, (arelle.ModelInstanceObject.ModelDimensionValue, DimValuePrototype)) and dimValue.isTyped:
                         XmlUtil.copyNodes(dimElt, cast(ModelObject, dimValue.typedMember))
                 elif dimMemberQname:
                     dimElt = XmlUtil.addChild(contextElt, XbrlConst.xbrldi, "xbrldi:explicitMember",
@@ -803,7 +816,7 @@ class ModelXbrl:
             self._factsByDatatype[notStrict, typeQname] = fbdt = set()
             for f in self.factsInInstance:
                 c = f.concept
-                if c.typeQname == typeQname or (notStrict and c.type.isDerivedFrom(typeQname)):
+                if c is not None and (c.typeQname == typeQname or (notStrict and c.type is not None and c.type.isDerivedFrom(typeQname))):
                     fbdt.add(f)
             return fbdt
 
@@ -859,23 +872,30 @@ class ModelXbrl:
             return fbdq[memQname]
 
     @property
-    def contextsInUse(self) -> Any:
-        try:
-            if self._contextsInUseMarked:
-                return (cntx for cntx in self.contexts.values() if getattr(cntx, "_inUse", False))
-        except AttributeError:
+    def contextsInUse(self) -> Iterator[ModelContext]:
+        if not self._contextsInUseMarked:
             for fact in self.factsInInstance:
                 cntx = fact.context
                 if cntx is not None:
                     cntx._inUse = True
-            self._contextsInUseMarked: bool = True
-            return self.contextsInUse
+            self._contextsInUseMarked = True
+        return (cntx for cntx in self.contexts.values() if getattr(cntx, "_inUse", False))
+
+    @property
+    def unitsInUse(self) -> Iterator[ModelUnit]:
+        if not self._unitsInUseMarked:
+            for fact in self.factsInInstance:
+                unit = fact.unit
+                if unit is not None:
+                    unit._inUse = True
+            self._unitsInUseMarked = True
+        return (unit for unit in self.units.values() if getattr(unit, "_inUse", False))
 
     @property
     def dimensionsInUse(self) -> set[Any]:
         self._dimensionsInUse: set[Any]
         try:
-            return self._dimensionsInUse
+            return cast(set[Any], self._dimensionsInUse)
         except AttributeError:
             self._dimensionsInUse = set(dim.dimension
                                         for cntx in self.contexts.values()  # use contextsInUse?  slower?
@@ -925,16 +945,13 @@ class ModelXbrl:
             assert self.modelDocument is not None
             parent = self.modelDocument.xmlRootElement
         self.makeelementParentModelObject = parent
-        global ModelFact
-        if ModelFact is None:
-            from arelle.ModelInstanceObject import ModelFact
         newFact = cast(
-            ModelFact, XmlUtil.addChild(parent, conceptQname, attributes=attributes, text=text,
+            'ModelFact', XmlUtil.addChild(parent, conceptQname, attributes=attributes, text=text,
                                         afterSibling=afterSibling, beforeSibling=beforeSibling)
         )
         if hasattr(self, "_factsByQname"):
             self._factsByQname[newFact.qname].add(newFact)
-        if not isinstance(newFact, ModelFact):
+        if not isinstance(newFact, arelle.ModelInstanceObject.ModelFact):
             return newFact # unable to create fact for this concept OR DTS not loaded for target instance (e.g., inline extraction, summary output)
         del self.makeelementParentModelObject
         if validate:
@@ -1001,188 +1018,12 @@ class ModelXbrl:
                             modelObject,
                             err, traceback.format_tb(sys.exc_info()[2])))
 
-    def effectiveMessageCode(self, messageCodes: tuple[Any] | str) -> str | None:
-        """
-        If codes includes EFM, GFM, HMRC, or SBR-coded error then the code chosen (if a sequence)
-        corresponds to whether EFM, GFM, HMRC, or SBR validation is in effect.
-        """
-        effectiveMessageCode = None
-        _validationType = self.modelManager.disclosureSystem.validationType
-        _exclusiveTypesPattern = self.modelManager.disclosureSystem.exclusiveTypesPattern
-
-        for argCode in messageCodes if isinstance(messageCodes,tuple) else (messageCodes,):
-            if (isinstance(argCode, ModelValue.QName) or
-                (_validationType and argCode.startswith(_validationType)) or
-                (not _exclusiveTypesPattern or _exclusiveTypesPattern.match(argCode) == None)):
-                effectiveMessageCode = argCode
-                break
-        return effectiveMessageCode
-
     # isLoggingEffectiveFor( messageCodes= messageCode= level= )
-    def isLoggingEffectiveFor(self, **kwargs: Any) -> QName | str | bool | None:  # args can be messageCode(s) and level
+    def isLoggingEffectiveFor(self, **kwargs: Any) -> bool:  # args can be messageCode(s) and level
         logger = self.logger
-        if "messageCodes" in kwargs or "messageCode" in kwargs:
-            if "messageCodes" in kwargs:
-                messageCodes = kwargs["messageCodes"]
-            else:
-                messageCodes = kwargs["messageCode"]
-            messageCode = self.effectiveMessageCode(messageCodes)
-            codeEffective = (messageCode and
-                             (not logger.messageCodeFilter or logger.messageCodeFilter.match(messageCode)))
-        else:
-            codeEffective = True
-        if "level" in kwargs and logger.messageLevelFilter:
-            levelEffective = logger.messageLevelFilter.match(kwargs["level"].lower())
-        else:
-            levelEffective = True
-        return codeEffective and levelEffective
-
-    def logArguments(self, messageCode: str, msg: str, codedArgs: dict[str, str]) -> Any:
-        # Prepares arguments for logger function as per info() below.
-
-        def propValues(properties: Any) -> Any:
-            # deref objects in properties
-            return [(p[0], str(p[1])) if len(p) == 2 else (p[0], str(p[1]), propValues(p[2]))
-                    for p in properties if 2 <= len(p) <= 3]
-        # determine message and extra arguments
-        fmtArgs = {}
-        extras: dict[str, Any] = {"messageCode":messageCode}
-        modelObjectArgs: tuple[Any, ...] | list[Any] = ()
-
-        for argName, argValue in codedArgs.items():
-            if argName in ("modelObject", "modelXbrl", "modelDocument"):
-                try:
-                    entryUrl = self.modelDocument.uri  # type: ignore[union-attr]
-                except AttributeError:
-                    try:
-                        entryUrl = self.entryLoadingUrl
-                    except AttributeError:
-                        entryUrl = self.fileSource.url
-                refs: list[dict[str, Any]] = []
-                modelObjectArgs_complex = argValue if isinstance(argValue, (tuple,list,set)) else (argValue,)
-                modelObjectArgs = flattenSequence(modelObjectArgs_complex)
-                for arg in modelObjectArgs:
-                    if arg is not None:
-                        if isinstance(arg, str):
-                            objectUrl = arg
-                        else:
-                            try:
-                                objectUrl = arg.modelDocument.displayUri
-                            except AttributeError:
-                                try:
-                                    objectUrl = arg.displayUri
-                                except AttributeError:
-                                    try:
-                                        objectUrl = self.modelDocument.displayUri  # type: ignore[union-attr]
-                                    except AttributeError:
-                                        objectUrl = getattr(self, "entryLoadingUrl", "")
-                        try:
-                            if objectUrl.endswith("/_IXDS"):
-                                file = objectUrl[:-6] # inline document set or report package
-                            elif objectUrl in self.logRefFileRelUris.get(entryUrl, EMPTY_TUPLE):
-                                file = self.logRefFileRelUris[entryUrl][objectUrl]
-                            else:
-                                file = UrlUtil.relativeUri(entryUrl, objectUrl)
-                                self.logRefFileRelUris[entryUrl][objectUrl] = file
-                        except:
-                            file = ""
-                        ref: dict[str, Any] = {}
-                        if isinstance(arg,(ModelObject, ObjectPropertyViewWrapper)):
-                            _arg:ModelObject = arg.modelObject if isinstance(arg, ObjectPropertyViewWrapper) else arg
-                            if len(modelObjectArgs) > 1 and getattr(arg,"tag",None) == "instance":
-                                continue # skip IXDS top level element
-                            ref["href"] = file + "#" + cast(str, XmlUtil.elementFragmentIdentifier(_arg))
-                            ref["sourceLine"] = _arg.sourceline
-                            ref["objectId"] = _arg.objectId()
-                            if self.logRefObjectProperties:
-                                try:
-                                    ref["properties"] = propValues(arg.propertyView)
-                                except AttributeError:
-                                    pass # is a default properties entry appropriate or needed?
-                            if self.logRefHasPluginProperties:
-                                refProperties: Any = ref.get("properties", {})
-                                for pluginXbrlMethod in pluginClassMethods("Logging.Ref.Properties"):
-                                    pluginXbrlMethod(arg, refProperties, codedArgs)
-                                if refProperties:
-                                    ref["properties"] = refProperties
-                        else:
-                            ref["href"] = file
-                            try:
-                                ref["sourceLine"] = arg.sourceline
-                            except AttributeError:
-                                pass # arg may not have sourceline, ignore if so
-                        if self.logRefHasPluginAttrs:
-                            refAttributes: dict[str, str] = {}
-                            for pluginXbrlMethod in pluginClassMethods("Logging.Ref.Attributes"):
-                                pluginXbrlMethod(arg, refAttributes, codedArgs)
-                            if refAttributes:
-                                ref["customAttributes"] = refAttributes
-                        refs.append(ref)
-                extras["refs"] = refs
-            elif argName == "sourceFileLine":
-                # sourceFileLines is pairs of file and line numbers, e.g., ((file,line),(file2,line2),...)
-                ref = {}
-                if isinstance(argValue, (tuple,list)):
-                    ref["href"] = str(argValue[0])
-                    if len(argValue) > 1 and argValue[1]:
-                        ref["sourceLine"] = str(argValue[1])
-                else:
-                    ref["href"] = str(argValue)
-                extras["refs"] = [ref]
-            elif argName == "sourceFileLines":
-                # sourceFileLines is tuple/list of pairs of file and line numbers, e.g., ((file,line),(file2,line2),...)
-                sf_refs: list[dict[str, str]] = []
-                argvalues: tuple[Any, ...] | list[Any] = argValue if isinstance(argValue, (tuple, list)) else (argValue,)
-                for arg in argvalues:
-                    ref = {}
-                    if isinstance(arg, (tuple, list)):
-                        arg_: tuple[Any, ...] | list[Any] = arg
-                        ref["href"] = str(arg_[0])
-                        if len(arg_) > 1 and arg_[1]:
-                            ref["sourceLine"] = str(arg_[1])
-                    else:
-                        ref["href"] = str(arg)
-                    sf_refs.append(ref)
-                extras["refs"] = sf_refs
-            elif argName == "sourceLine":
-                if isinstance(argValue, int):    # must be sortable with int's in logger
-                    extras["sourceLine"] = argValue
-            elif argName not in ("exc_info", "messageCodes"):
-                fmtArgs[argName] = self.loggableValue(argValue) # dereference anything not loggable
-
-        if "refs" not in extras:
-            try:
-                file = os.path.basename(cast('ModelDocumentClass', self.modelDocument).displayUri)
-            except AttributeError:
-                try:
-                    file = os.path.basename(self.entryLoadingUrl)
-                except:
-                    file = ""
-            extras["refs"] = [{"href": file}]
-        for pluginXbrlMethod in pluginClassMethods("Logging.Message.Parameters"):
-            # plug in can rewrite msg string or return msg if not altering msg
-            msg = pluginXbrlMethod(messageCode, msg, modelObjectArgs, fmtArgs) or msg
-        return (messageCode,
-                (msg, fmtArgs) if fmtArgs else (msg,),
-                extras)
-
-    def loggableValue(self, argValue: Any) -> str | dict[Any, Any]:  # must be dereferenced and not related to object lifetimes
-        if isinstance(argValue, (ModelValue.QName, ModelObject, FileNamedStringIO, tuple, list, set)):  # might be a set of lxml objects not dereferencable at shutdown
-            return str(argValue)
-        elif argValue is None:
-            return "(none)"
-        elif isinstance(argValue, bool):
-            return str(argValue).lower() # show lower case true/false xml values
-        elif isinstance(argValue, int):
-            # need locale-dependent formatting
-            return format_string(self.modelManager.locale, '%i', argValue)
-        elif isinstance(argValue,(float,Decimal)):
-            # need locale-dependent formatting
-            return format_string(self.modelManager.locale, '%f', argValue)
-        elif isinstance(argValue, dict):
-            return dict((self.loggableValue(k), self.loggableValue(v)) for k,v in argValue.items())
-        else:
-            return str(argValue)
+        if logger is None:
+            return False
+        return self.errorManager.isLoggingEffectiveFor(logger, **kwargs)
 
     def debug(self, codes: str | tuple[str, ...], msg: str, **args: Any) -> None:
         """Same as error(), but as info
@@ -1205,29 +1046,24 @@ class ModelXbrl:
     def log(self, level: str, codes: Any, msg: str, **args: Any) -> None:
         """Same as error(), but level passed in as argument
         """
-        logger = self.logger
-        # determine logCode
-        messageCode = self.effectiveMessageCode(codes)
-        if messageCode == "asrtNoLog":
-            self.errors.append(args["assertionResults"])
+        if self.logger is None:
             return
-        if self.logHasRelevelerPlugin:
-            for pluginXbrlMethod in pluginClassMethods("Logging.Severity.Releveler"):
-                level, messageCode = pluginXbrlMethod(self, level, messageCode, args) # args must be passed as dict because it may contain modelXbrl or messageCode key value
-        if (messageCode and
-              (not logger.messageCodeFilter or logger.messageCodeFilter.match(messageCode)) and
-              (not logger.messageLevelFilter or logger.messageLevelFilter.match(level.lower()))):
-            # note that plugin Logging.Message.Parameters may rewrite messageCode which now occurs after filtering on messageCode
-            messageCode, logArgs, extras = self.logArguments(messageCode, msg, args)
-            numericLevel = logging._checkLevel(level)  #type: ignore[attr-defined]
-            self.logCount[numericLevel] = self.logCount.get(numericLevel, 0) + 1
-            if numericLevel >= self.errorCaptureLevel:
-                try: # if there's a numeric errorCount arg, extend messages codes by count
-                    self.errors.extend([messageCode] * int(logArgs[1]["errorCount"]))
-                except (IndexError, KeyError, ValueError): # no msgArgs, no errorCount, or not int
-                    self.errors.append(messageCode) # assume one error occurence
-            """@messageCatalog=[]"""
-            logger.log(numericLevel, *logArgs, exc_info=args.get("exc_info"), extra=extras)
+        entryLoadingUrl = None
+        try:
+            entryLoadingUrl = self.entryLoadingUrl
+        except AttributeError:
+            pass
+        self.errorManager.log(
+            self.logger,
+            level,
+            codes,
+            msg,
+            sourceModelXbrl=self,
+            fileSource=self.fileSource,
+            entryLoadingUrl=entryLoadingUrl,
+            logRefObjectProperties=self.logRefObjectProperties,
+            **args
+        )
 
     def error(self, codes: str | tuple[str, ...], msg: str, **args: Any) -> None:
         """Logs a message as info, by code, logging-system message text (using %(name)s named arguments
@@ -1336,3 +1172,27 @@ class ModelXbrl:
                   _("DTS of %(entryFile)s has %(numberOfFiles)s files packaged into %(packageOutputFile)s"),
                 modelObject=self,
                 entryFile=os.path.basename(entryFilename), packageOutputFile=pkgFilename, numberOfFiles=numFiles)
+
+    @property
+    def qnameUtrUnits(self) -> dict[QName, UtrEntry]:
+        try:
+            return self._qnameUtrUnits
+        except AttributeError:
+            from arelle.ValidateUtr import ValidateUtr
+            utrEntries = ValidateUtr(self).utrItemTypeEntries
+            qnameUtrUnits = {}
+            for unitType, unitMap in utrEntries.items():
+                for unitId, unit in unitMap.items():
+                    unitQName = unit.qname()
+                    if unitQName:
+                        qnameUtrUnits[unitQName] = unit
+            self._qnameUtrUnits = qnameUtrUnits
+            return self._qnameUtrUnits
+
+    @property
+    def errors(self) -> list[str | None]:
+        return self.errorManager.errors
+
+    @property
+    def logCount(self) -> dict[str, int]:
+        return self.errorManager.logCount