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

arelle/ModelDocument.py

@@ -3,12 +3,15 @@ See COPYRIGHT.md for copyright information.
 '''
 from __future__ import annotations
 import os, io
+import regex as re
 from collections import defaultdict
+from pathlib import Path
 from typing import Any
 from lxml import etree
 from xml.sax import SAXParseException
 from arelle import (PackageManager, XbrlConst, XmlUtil, UrlUtil, ValidateFilingText,
                     XhtmlValidate, XmlValidateSchema, FunctionIxt)
+from arelle.conformance.CSVTestcaseLoader import CSVTestcaseException, loadCsvTestcase
 from arelle.FileSource import FileSource
 from arelle.ModelObject import ModelObject
 from arelle.ModelValue import qname
@@ -17,12 +20,14 @@ from arelle.ModelInstanceObject import ModelFact
 from arelle.ModelObjectFactory import parser
 from arelle.PrototypeDtsObject import LinkPrototype, LocPrototype, ArcPrototype, DocumentPrototype, PrototypeElementTree
 from arelle.PluginManager import pluginClassMethods
-from arelle.PythonUtil import OrderedDefaultDict, normalizeSpace
+from arelle.PythonUtil import OrderedDefaultDict, isLegacyAbs, normalizeSpace
 from arelle.XhtmlValidate import ixMsgCode
 from arelle.XmlValidateConst import VALID
 from arelle.XmlValidate import validate as xmlValidate, lxmlSchemaValidate
 from arelle.ModelTestcaseObject import ModelTestcaseVariation
 
+urlMatchPattern = re.compile("^https?://(?:www.)?(xbrl.org)/(.*)$") # for checking allowable schemaLocation mismatches
+
 creationSoftwareNames = None
 
 def load(modelXbrl, uri, base=None, referringElement=None, isEntry=False, isDiscovered=False, isIncluded=None, isSupplemental=False, namespace=None, reloadCache=False, **kwargs) -> ModelDocument | None:
@@ -48,6 +53,7 @@ def load(modelXbrl, uri, base=None, referringElement=None, isEntry=False, isDisc
     :type reloadCache: bool
     :param checkModifiedTime: True if desired to check modifed time of web cached entry point (ahead of usual time stamp checks).
     :type checkModifiedTime: bool
+    :param entrypoint (in kwargs) might contain securityClassification ("unclassified", "confidential", "secret", etc)
     """
 
     if referringElement is None: # used for error messages
@@ -72,10 +78,10 @@ def load(modelXbrl, uri, base=None, referringElement=None, isEntry=False, isDisc
             modelXbrl.uriDir = os.path.dirname(modelXbrl.uriDir)
     if modelXbrl.modelManager.validateDisclosureSystem and \
        not normalizedUri.startswith(modelXbrl.uriDir) and \
-       not modelXbrl.modelManager.disclosureSystem.hrefValid(normalizedUri):
+       not modelXbrl.modelManager.disclosureSystem.hrefValidForDisclosureSystem(normalizedUri):
         blocked = modelXbrl.modelManager.disclosureSystem.blockDisallowedReferences
         if normalizedUri not in modelXbrl.urlUnloadableDocs:
-            # HMRC note, HMRC.blockedFile should be in this list if hmrc-taxonomies.xml is maintained an dup to date
+            # HMRC note, HMRC.blockedFile should be in this list if uk-taxonomies.xml is maintained an dup to date
             modelXbrl.error(("EFM.6.22.00", "GFM.1.1.3", "SBR.NL.2.1.0.06" if normalizedUri.startswith("http") else "SBR.NL.2.2.0.17"),
                     _("Prohibited file for filings %(blockedIndicator)s: %(url)s"),
                     edgarCode="cp-2200-Prohibited-Href-Or-Schema-Location",
@@ -99,7 +105,7 @@ def load(modelXbrl, uri, base=None, referringElement=None, isEntry=False, isDisc
         mappedUri = modelXbrl.modelManager.disclosureSystem.mappedUrl(normalizedUri)
 
     if isEntry:
-        modelXbrl.entryLoadingUrl = mappedUri   # for error loggiong during loading
+        modelXbrl.entryLoadingUrl = mappedUri   # for error logging during loading
 
     # don't try reloading if not loadable
 
@@ -130,9 +136,9 @@ def load(modelXbrl, uri, base=None, referringElement=None, isEntry=False, isDisc
     isPullLoadable = any(pluginMethod(modelXbrl, mappedUri, normalizedUri, filepath, isEntry=isEntry, namespace=namespace, **kwargs)
                          for pluginMethod in pluginClassMethods("ModelDocument.IsPullLoadable"))
 
-    if not isPullLoadable and os.path.splitext(filepath)[1] in (".xlsx", ".xls", ".csv", ".json"):
+    if not isPullLoadable and os.path.splitext(filepath)[1] in (".xlsx", ".xls"):
         modelXbrl.error("FileNotLoadable",
-                _("File can not be loaded, requires loadFromExcel or loadFromOIM plug-in: %(fileName)s"),
+                _("File can not be loaded, requires loadFromExcel plug-in: %(fileName)s"),
                 modelObject=referringElement, fileName=normalizedUri)
         return None
 
@@ -148,6 +154,20 @@ def load(modelXbrl, uri, base=None, referringElement=None, isEntry=False, isDisc
                 return None
             if modelDocument is not None:
                 return modelDocument
+        if Path(filepath).suffix == ".csv":
+            try:
+                modelDocument = loadCsvTestcase(modelXbrl, normalizedUri)
+                if modelDocument is not None:
+                    return modelDocument
+            except CSVTestcaseException:
+                modelDocument = None
+        from arelle.oim.Load import isOimLoadable, oimLoader
+        if isOimLoadable(normalizedUri, filepath):
+            modelDocument = oimLoader(modelXbrl, normalizedUri, filepath)
+            if isinstance(modelDocument, Exception):
+                return None
+            if modelDocument is not None:
+                return modelDocument
         if (modelXbrl.modelManager.validateDisclosureSystem and (
             (isEntry and modelXbrl.modelManager.disclosureSystem.validateEntryText) or
             (modelXbrl.modelManager.disclosureSystem.validateFileText and
@@ -171,6 +191,20 @@ def load(modelXbrl, uri, base=None, referringElement=None, isEntry=False, isDisc
                     fileName=os.path.basename(uri),
                     error=error.message, line=error.line, column=error.column)
         file.close()
+    except FileNotFoundError as err:
+        if file:
+            file.close()
+        msg = _("Could not load file from local filesystem.")
+        offlineMode = modelXbrl.modelManager.cntlr.webCache.workOffline
+        if offlineMode:
+            msg += _(" Disable offline mode to attempt download.")
+        msg += " file: %(url)s"
+        modelXbrl.error("IOerror", msg,
+            modelObject=referringElement, url=uri, error=str(err))
+        if modelXbrl.modelManager.abortOnMajorError and (isEntry or isDiscovered):
+            raise LoadingException() from err
+        modelXbrl.urlUnloadableDocs[normalizedUri] = True  # not loadable due to IO issue
+        return None
     except (EnvironmentError, KeyError, UnicodeDecodeError) as err:  # missing zip file raises KeyError
         if file:
             file.close()
@@ -210,10 +244,15 @@ def load(modelXbrl, uri, base=None, referringElement=None, isEntry=False, isDisc
                 modelObject=(referringElement, os.path.basename(uri)), fileName=os.path.basename(uri), error=str(err))
         return None
     except Exception as err:
-        modelXbrl.error(type(err).__name__,
-                _("Unrecoverable error: %(error)s, %(fileName)s"),
-                modelObject=referringElement, fileName=os.path.basename(uri),
-                error=str(err), exc_info=True)
+        if len(err.args) >= 2 and err.args[0] == "rpe:unsupportedFileExtension":
+            modelXbrl.error(err.args[0],
+                _("Unsupported file extension for zip contents: %(fileName)s"),
+                modelObject=referringElement, fileName=os.path.basename(uri))
+        else:
+            modelXbrl.error(type(err).__name__,
+                    _("Unrecoverable error: %(error)s, %(fileName)s"),
+                    modelObject=referringElement, fileName=os.path.basename(uri),
+                    error=str(err), exc_info=True)
         modelXbrl.urlUnloadableDocs[normalizedUri] = True  # not loadable due to exception issue
         return None
 
@@ -241,9 +280,13 @@ def load(modelXbrl, uri, base=None, referringElement=None, isEntry=False, isDisc
                     if otherModelDoc.basename == os.path.basename(uri):
                         if os.path.normpath(otherModelDoc.uri) != os.path.normpath(uri): # tolerate \ vs / or ../ differences
                             modelXbrl.urlDocs[uri] = otherModelDoc
-                            modelXbrl.warning("info:duplicatedSchema",
-                                    _("Schema file with same targetNamespace %(targetNamespace)s loaded from %(fileName)s and %(otherFileName)s"),
-                                    modelObject=referringElement, targetNamespace=targetNamespace, fileName=uri, otherFileName=otherModelDoc.uri)
+                            # tolerate certain schemaLocation mismatches
+                            m1 = urlMatchPattern.match(otherModelDoc.uri)
+                            m2 = urlMatchPattern.match(uri)
+                            if not (m1 and m2 and m1.groups() == m2.groups()):
+                                modelXbrl.warning("info:duplicatedSchema",
+                                        _("Schema file with same targetNamespace %(targetNamespace)s loaded from %(fileName)s and %(otherFileName)s"),
+                                        modelObject=referringElement, targetNamespace=targetNamespace, fileName=uri, otherFileName=otherModelDoc.uri)
                         return otherModelDoc
         elif (isEntry or isDiscovered or isSupplemental) and ns == XbrlConst.link:
             if ln == "linkbase":
@@ -376,6 +419,9 @@ def load(modelXbrl, uri, base=None, referringElement=None, isEntry=False, isDisc
                         if referencedDoc.type == Type.SCHEMA:
                             modelDocument.targetDocumentSchemaRefs.add(doc.relativeUri(referencedDoc.uri))
 
+        if (kwargs.get("entrypoint") or {}).get("securityClassification"):
+            modelDocument.securityClassification = kwargs["entrypoint"]["securityClassification"]
+
         if isEntry or isSupplemental:
             # re-order base set keys for entry point or supplemental linkbase addition
             modelXbrl.baseSets = OrderedDefaultDict( # order by linkRole, arcRole of key
@@ -400,7 +446,7 @@ def loadSchemalocatedSchema(modelXbrl, element, relativeUrl, namespace, baseUrl)
             doc.inDTS = False
     return doc
 
-def create(modelXbrl, type, uri, schemaRefs=None, isEntry=False, initialXml=None, initialComment=None, base=None, discover=True, documentEncoding="utf-8", xbrliNamespacePrefix=None) -> ModelDocument:
+def create(modelXbrl, type, uri, schemaRefs=None, isEntry=False, initialXml=None, initialComment=None, base=None, discover=True, documentEncoding="utf-8", xbrliNamespacePrefix=None, entrypoint=None) -> ModelDocument:
     """Returns a new modelDocument, created from scratch, with any necessary header elements
 
     (such as the schema, instance, or RSS feed top level elements)
@@ -424,7 +470,7 @@ def create(modelXbrl, type, uri, schemaRefs=None, isEntry=False, initialXml=None
     if initialComment:
         initialComment = "<!--" + initialComment + "-->"
     # XML document has nsmap root element to replace nsmap as new xmlns entries are required
-    if initialXml and type in (Type.INSTANCE, Type.SCHEMA, Type.LINKBASE, Type.RSSFEED):
+    if initialXml and type in (Type.INSTANCE, Type.SCHEMA, Type.LINKBASE, Type.RSSFEED, Type.TESTCASE):
         Xml = '<nsmap>{}{}</nsmap>'.format(initialComment or '', initialXml or '')
     elif type == Type.INSTANCE:
         # modelXbrl.uriDir = os.path.dirname(normalizedUri)
@@ -492,6 +538,7 @@ def create(modelXbrl, type, uri, schemaRefs=None, isEntry=False, initialXml=None
         modelDocument.isQualifiedElementFormDefault = False
         modelDocument.isQualifiedAttributeFormDefault = False
     modelDocument.definesUTR = False
+    modelDocument.entrypoint = entrypoint
     return modelDocument
 
 class Type:
@@ -596,7 +643,7 @@ fractionParts = {"{http://www.xbrl.org/2003/instance}numerator",
 
 class ModelDocument:
     """
-    .. class:: ModelDocment(modelXbrl, type, uri, filepath, xmlDocument)
+    .. class:: ModelDocument(modelXbrl, type, uri, filepath, xmlDocument)
 
     The modelDocument performs discovery and initialization when loading documents.
     For instances, schema and linkbase references are resolved, as well as non-DTS schema locations needed
@@ -678,11 +725,15 @@ class ModelDocument:
         Qualifies as a discovered schema per XBRL 2.1
     """
 
+    # The document encoding. The XML declaration is stripped from the document
+    # before lxml parses the document making the lxml DocInfo encoding unreliable.
     documentEncoding: str
+    entrypoint: dict[str, Any] | None
     xmlRootElement: Any
     targetXbrlRootElement: ModelObject
 
     def __init__(self, modelXbrl, type, uri, filepath, xmlDocument):
+        self.entrypoint = None
         self.modelXbrl = modelXbrl
         self.skipDTS = modelXbrl.skipDTS
         self.type = type
@@ -779,7 +830,7 @@ class ModelDocument:
             except AttributeError:
                 pass
 
-    def save(self, overrideFilepath=None, outputZip=None, outputFile=None, updateFileHistory=True, encoding="utf-8", **kwargs) -> None:
+    def save(self, overrideFilepath=None, outputZip=None, outputFile=None, updateFileHistory=True, encoding="utf-8", zipDir=None, **kwargs) -> None:
         """Saves current document file.
 
         :param overrideFilepath: specify to override saving in instance's modelDocument.filepath
@@ -793,7 +844,7 @@ class ModelDocument:
         XmlUtil.writexml(fh, self.xmlDocument, encoding=encoding, **kwargs)
         if outputZip:
             fh.seek(0)
-            outputZip.writestr(os.path.basename(overrideFilepath or self.filepath),fh.read())
+            outputZip.writestr((zipDir or "") + os.path.basename(overrideFilepath or self.filepath),fh.read())
         if outputFile is None:
             fh.close()
         if overrideFilepath:
@@ -874,11 +925,48 @@ class ModelDocument:
             return self._creationSoftwareComment
 
     @property
-    def creationSoftware(self):
+    def creationSoftware(self) -> str:
+        """
+        Extract software product name from root level comment elements.
+        If no comment text is found, returns string "None".
+        If no software product name is found, returns the comment text.
+        If any software product names are found, returns the first.
+        :return: Extracted text.
+        """
+        text = self.creationSoftwareComment
+        if not text:
+            return "None"
+        matches = self.creationSoftwareMatches(text)
+        if len(matches) > 0:
+            return matches[0]
+        return text
+
+    def creationSoftwareMatches(self, text: str | None) -> list[str]:
+        """
+        Given text, extract software product names.
+        If explicit pattern ("Software Credit: ...") is matched, only
+        returns those matches.
+        Otherwise, will check against a table of known software names and patterns.
+        Interested parties can add to the table by opening a pull request,
+        or by sending a request via email to support@arelle.org.
+        :param text:
+        :return: List of matched software names in order found.
+        """
+        matches = []
+        if text is None:
+            return matches
+        import regex as re
+        creditPattern = re.compile(r'Software Credit: (.*)', re.IGNORECASE)
+        for line in text.split('\n'):
+            if creditPattern.search(line):
+                creditMatch = creditPattern.sub(r'\1', line).strip()
+                matches.append(creditMatch)
+        if matches:
+            return matches
+
         global creationSoftwareNames
         if creationSoftwareNames is None:
             import json
-            import regex as re
             creationSoftwareNames = []
             try:
                 with io.open(os.path.join(self.modelXbrl.modelManager.cntlr.configDir, "creationSoftwareNames.json"),
@@ -890,13 +978,11 @@ class ModelDocument:
                 self.modelXbrl.error("arelle:creationSoftwareNamesTable",
                                      _("Error loading creation software names table %(error)s"),
                                      modelObject=self, error=ex)
-        creationSoftwareComment = self.creationSoftwareComment
-        if not creationSoftwareComment:
-            return "None"
         for productKey, productNamePattern in creationSoftwareNames:
-            if productNamePattern.search(creationSoftwareComment):
-                return productKey
-        return creationSoftwareComment # "Other"
+            if productNamePattern.search(text):
+                matches.append(productKey)
+                return matches  # Each document only matches on software name
+        return matches
 
     @property
     def processingInstructions(self):
@@ -1023,7 +1109,7 @@ class ModelDocument:
                         break # break because it is now absolute
             baseElt = baseElt.getparent()
         if base: # neither None nor ''
-            if base.startswith('http://') or os.path.isabs(base):
+            if base.startswith('http://') or isLegacyAbs(base):
                 return base
             else:
                 return os.path.dirname(self.uri) + "/" + base
@@ -1183,6 +1269,8 @@ class ModelDocument:
                                             linkrole = XbrlConst.defaultLinkRole
                                         #index by both arcrole and linkrole#arcrole and dimensionsions if applicable
                                         baseSetKeys = [(arcrole, linkrole, linkQn, arcQn)]
+                                        baseSetKeys.append((arcrole, linkrole, linkQn, None))
+                                        baseSetKeys.append((arcrole, linkrole, None, arcQn))
                                         baseSetKeys.append((arcrole, linkrole, None, None))
                                         baseSetKeys.append((arcrole, None, None, None))
                                         if XbrlConst.isDimensionArcrole(arcrole) and not dimensionArcFound:
@@ -1279,9 +1367,9 @@ class ModelDocument:
                     modelObject=undefFacts,
                     elements=", ".join(sorted(set(str(f.prefixedName) for f in undefFacts))))
 
-    def contextDiscover(self, modelContext) -> None:
+    def contextDiscover(self, modelContext, setTargetModelXbrl=False) -> None:
         if not self.skipDTS:
-            xmlValidate(self.modelXbrl, modelContext) # validation may have not completed due to errors elsewhere
+            xmlValidate(self.modelXbrl, modelContext, setTargetModelXbrl=setTargetModelXbrl) # validation may have not completed due to errors elsewhere
         id = modelContext.id
         self.modelXbrl.contexts[id] = modelContext
         for container in (("{http://www.xbrl.org/2003/instance}segment", modelContext.segDimValues, modelContext.segNonDimValues),
@@ -1293,7 +1381,11 @@ class ModelDocument:
                         if sElt.namespaceURI == XbrlConst.xbrldi and sElt.localName in ("explicitMember","typedMember"):
                             dimQn = sElt.dimensionQname
                             if dimQn: # may be null if schema error omits dimension element
-                                #xmlValidate(self.modelXbrl, sElt)
+                                if setTargetModelXbrl: # ixds possibly-shared context
+                                    if hasattr(sElt, "_dimension") and sElt._dimension is None:
+                                        del sElt._dimension
+                                    if hasattr(sElt, "_member") and sElt._member is None:
+                                        del sElt._member
                                 modelContext.qnameDims[dimQn] = sElt # both seg and scen
                                 if not self.skipDTS:
                                     dimension = sElt.dimension
@@ -1304,9 +1396,9 @@ class ModelDocument:
                         else:
                             containerNonDimValues.append(sElt)
 
-    def unitDiscover(self, unitElement) -> None:
+    def unitDiscover(self, unitElement, setTargetModelXbrl=False) -> None:
         if not self.skipDTS:
-            xmlValidate(self.modelXbrl, unitElement) # validation may have not completed due to errors elsewhere
+            xmlValidate(self.modelXbrl, unitElement, setTargetModelXbrl=setTargetModelXbrl) # validation may have not completed due to errors elsewhere
         self.modelXbrl.units[unitElement.id] = unitElement
 
     def inlineXbrlDiscover(self, htmlElement):
@@ -1401,7 +1493,7 @@ class ModelDocument:
                             doc = load(self.modelXbrl, uriAttr, base=base, referringElement=testcaseElement)
                             self.addDocumentReference(doc, "testcaseIndex", testcaseElement)
 
-    def testcaseDiscover(self, testcaseElement, validateTestcaseSchema):
+    def testcaseDiscover(self, testcaseElement: etree._Element, validateTestcaseSchema: bool) -> None:
         if validateTestcaseSchema:
             lxmlSchemaValidate(self)
         isTransformTestcase = testcaseElement.namespaceURI == "http://xbrl.org/2011/conformance-rendering/transforms"
@@ -1458,13 +1550,13 @@ class ModelDocument:
 # inline document set level compilation
 # modelIxdsDocument is an inlineDocumentSet or entry inline document (if not a document set)
 #   note that multi-target and multi-instance facts may have html elements belonging to primary ixds instead of this instance ixds
-def inlineIxdsDiscover(modelXbrl, modelIxdsDocument):
+def inlineIxdsDiscover(modelXbrl, modelIxdsDocument, setTargetModelXbrl=False, **kwargs):
     for pluginMethod in pluginClassMethods("ModelDocument.SelectIxdsTarget"):
-        pluginMethod(modelXbrl, modelIxdsDocument)
+        pluginMethod(modelXbrl, modelIxdsDocument, **kwargs)
     # extract for a single target document
     ixdsTarget = getattr(modelXbrl, "ixdsTarget", None)
     # compile inline result set
-    ixdsEltById = defaultdict(list)
+    ixdsEltById = modelXbrl.ixdsEltById = defaultdict(list)
     for htmlElement in modelXbrl.ixdsHtmlElements:
         for elt in htmlElement.iterfind(".//*[@id]"):
             if isinstance(elt,ModelObject) and elt.id:
@@ -1516,8 +1608,12 @@ def inlineIxdsDiscover(modelXbrl, modelIxdsDocument):
         for modelInlineFact in htmlElement.iterdescendants(ixNStag + "nonNumeric", ixNStag + "nonFraction", ixNStag + "fraction"):
             if isinstance(modelInlineFact,ModelObject):
                 _target = modelInlineFact.get("target")
-                factTargetContextRefs[_target].add(modelInlineFact.get("contextRef"))
-                factTargetUnitRefs[_target].add(modelInlineFact.get("unitRef"))
+                contextRef = modelInlineFact.get("contextRef")
+                if contextRef is not None:
+                    factTargetContextRefs[_target].add(contextRef.strip())
+                unitRef = modelInlineFact.get("unitRef")
+                if unitRef is not None:
+                    factTargetUnitRefs[_target].add(unitRef.strip())
                 if modelInlineFact.id:
                     factsByFactID[modelInlineFact.id] = modelInlineFact
         for elt in htmlElement.iterdescendants(tag=ixNStag + "continuation"):
@@ -1609,24 +1705,58 @@ def inlineIxdsDiscover(modelXbrl, modelIxdsDocument):
                             for _target in sourceFactTargets:
                                 targetRoleUris[_target].add(footnoteRole)
 
+    for htmlElement in modelXbrl.ixdsHtmlElements:
+        # Discover iXBRL 1.0 footnote roles and arcroles.
+        iXBRL1_0Footnotes = list(htmlElement.iterdescendants(tag=XbrlConst.qnIXbrlFootnote.clarkNotation))
+        if not iXBRL1_0Footnotes:
+            continue
+        footnoteRefElems = (
+            XbrlConst.qnIXbrlFraction.clarkNotation,
+            XbrlConst.qnIXbrlNonFraction.clarkNotation,
+            XbrlConst.qnIXbrlNonNumeric.clarkNotation,
+            XbrlConst.qnIXbrlTuple.clarkNotation,
+        )
+        targetsByFootnoteId = defaultdict(set)
+        for elem in htmlElement.iterdescendants(footnoteRefElems):
+            if isinstance(elem, ModelObject):
+                refs = elem.get("footnoteRefs")
+                if refs:
+                    _target = elem.get("target")
+                    for footnoteRef in refs.split():
+                        targetsByFootnoteId[footnoteRef].add(_target)
+        for modelInlineFootnote in iXBRL1_0Footnotes:
+            arcrole = modelInlineFootnote.get("arcrole", XbrlConst.factFootnote)
+            footnoteLinkRole = modelInlineFootnote.get("footnoteLinkRole", XbrlConst.defaultLinkRole)
+            footnoteRole = modelInlineFootnote.get("footnoteRole")
+            for _target in targetsByFootnoteId[modelInlineFootnote.footnoteID]:
+                targetRoleUris[_target].add(footnoteLinkRole)
+                targetArcroleUris[_target].add(arcrole)
+                if footnoteRole:
+                    targetRoleUris[_target].add(footnoteRole)
+
+    contextRefs = factTargetContextRefs[ixdsTarget]
+    contextRefsForAllTargets = {ref for refs in factTargetContextRefs.values() for ref in refs}
+    unitRefs = factTargetUnitRefs[ixdsTarget]
+    unitRefsForAllTargets = {ref for refs in factTargetUnitRefs.values() for ref in refs}
+
     # discovery of contexts, units and roles which are used by target document
     for htmlElement in modelXbrl.ixdsHtmlElements:
         mdlDoc = htmlElement.modelDocument
         ixNStag = mdlDoc.ixNStag
 
         for inlineElement in htmlElement.iterdescendants(tag=ixNStag + "resources"):
-            contextRefs = factTargetContextRefs[ixdsTarget]
-            allContextRefs = set.union(*factTargetContextRefs.values())
-            unitRefs = factTargetUnitRefs[ixdsTarget]
-            allUnitRefs = set.union(*factTargetUnitRefs.values())
             for elt in inlineElement.iterchildren("{http://www.xbrl.org/2003/instance}context"):
-                id = elt.get("id")
-                if id in contextRefs or (not ixdsTarget and id not in allContextRefs):
-                    modelIxdsDocument.contextDiscover(elt)
+                contextId = elt.get("id")
+                if contextId in contextRefs:
+                    modelIxdsDocument.contextDiscover(elt, setTargetModelXbrl)
+                elif contextId not in contextRefsForAllTargets:
+                    modelXbrl.ixdsUnmappedContexts[contextId] = elt
             for elt in inlineElement.iterchildren("{http://www.xbrl.org/2003/instance}unit"):
-                id = elt.get("id")
-                if id in unitRefs or (not ixdsTarget and id not in allUnitRefs):
-                    modelIxdsDocument.unitDiscover(elt)
+                unitId = elt.get("id")
+                if unitId in unitRefs:
+                    modelIxdsDocument.unitDiscover(elt, setTargetModelXbrl)
+                elif unitId not in unitRefsForAllTargets:
+                    modelXbrl.ixdsUnmappedUnits[unitId] = elt
             for refElement in inlineElement.iterchildren("{http://www.xbrl.org/2003/linkbase}roleRef"):
                 r = refElement.get("roleURI")
                 if r in targetRoleUris[ixdsTarget]:
@@ -1751,6 +1881,8 @@ def inlineIxdsDiscover(modelXbrl, modelIxdsDocument):
                 checkTupleIxDescendants(tupleFact, childElt)
 
     def addItemFactToTarget(modelInlineFact):
+        if setTargetModelXbrl:
+            modelInlineFact.targetModelXbrl = modelXbrl # fact's owning IXDS overrides initial loading document IXDS
         if modelInlineFact.concept is None:
                 modelXbrl.error(ixMsgCode("missingReferences", modelInlineFact, name="references", sect="validation"),
                                 _("Instance fact missing schema definition: %(qname)s of Inline Element %(localName)s"),

arelle/ModelDtsObject.py

@@ -22,7 +22,7 @@ objects to interface to SQL-obtained data.
 
 ModelType represents an anonymous or explicit element type.  It includes methods that determine
 the base XBRL type (such as monetaryItemType), the base XML type (such as decimal), substitution
-group chains, facits, and attributes.
+group chains, facets, and attributes.
 
 ModelAttributeGroup and ModelAttribute provide sufficient mechanism to identify element attributes,
 their types, and their default or fixed values.
@@ -468,6 +468,15 @@ class ModelConcept(ModelNamableTerm, ModelParticle):
             self._isNumeric = XbrlConst.isNumericXsdType(self.baseXsdType)
             return self._isNumeric
 
+    @property
+    def isDecimal(self):
+        """(bool) -- True for a decimal xsd base type (not including xbrl fractions, float or double)"""
+        try:
+            return self._isDecimal
+        except AttributeError:
+            self._isDecimal = XbrlConst.isDecimalXsdType(self.baseXsdType)
+            return self._isDecimal
+
     @property
     def isInteger(self):
         """(bool) -- True for elements of, or derived from, integer base type (not including fractionItemType)"""
@@ -747,10 +756,10 @@ class ModelConcept(ModelNamableTerm, ModelParticle):
     def isEnumeration2Item(self):
         """(bool) -- True if derived from enum2 item types"""
         try:
-            return self._isEnum
+            return self._isEnum2
         except AttributeError:
-            self._isEnum = self.instanceOfType(XbrlConst.qnEnumeration2ItemTypes)
-            return self._isEnum
+            self._isEnum2 = self.instanceOfType(XbrlConst.qnEnumeration2ItemTypes)
+            return self._isEnum2
 
     @property
     def enumDomainQname(self):
@@ -1116,11 +1125,11 @@ class ModelType(ModelNamableTerm):
                 self._baseXsdType = "XBRLI_PRECISIONUNION"
             elif self.qname == XbrlConst.qnXbrliNonZeroDecimalUnion:
                 self._baseXsdType = "XBRLI_NONZERODECIMAL"
+            elif self.qname.namespaceURI == XbrlConst.xsd:
+                self._baseXsdType = self.qname.localName
             else:
                 qnameDerivedFrom = self.qnameDerivedFrom
                 if qnameDerivedFrom is None:
-                    # want None if base type has no content (not mixed content, TBD)
-                    #self._baseXsdType =  "anyType"
                     self._baseXsdType =  "noContent"
                 elif isinstance(qnameDerivedFrom,list): # union
                     if qnameDerivedFrom == XbrlConst.qnDateUnionXsdTypes:
@@ -1399,7 +1408,7 @@ class ModelType(ModelNamableTerm):
                 ("QName", self.qname),
                 ("xsd type", self.baseXsdType),
                 ("derived from", self.qnameDerivedFrom),
-                ("facits", self.facets))
+                ("facets", self.facets))
 
     def __repr__(self):
         return ("modelType[{0}, qname: {1}, derivedFrom: {2}, {3}, line {4}]"
@@ -1681,6 +1690,7 @@ class RelationStatus:
     INEFFECTIVE = 4
 
 arcCustAttrsExclusions = {XbrlConst.xlink, "use","priority","order","weight","preferredLabel"}
+modelObjectAttrs = frozenset(dir(ModelObject))
 
 class ModelRelationship(ModelObject):
     """
@@ -1712,10 +1722,15 @@ class ModelRelationship(ModelObject):
         .. attribute:: toModelObject
 
         ModelObject of the xlink:to (dereferenced if via xlink:locator)
+
+        .. attribute:: linkrole
+
+        Value of xlink:role attribute of parent extended link element
     """
     def __init__(self, modelDocument, arcElement, fromModelObject, toModelObject):
         # copy model object properties from arcElement
         self.arcElement = arcElement
+        self.linkrole = arcElement.getparent().get("{http://www.w3.org/1999/xlink}role")
         self.init(modelDocument)
         self.fromModelObject = fromModelObject
         self.toModelObject = toModelObject
@@ -1832,7 +1847,7 @@ class ModelRelationship(ModelObject):
 
     @property
     def orderDecimal(self):
-        """(decimal) -- Value of xlink:order attribute, NaN if not convertable to float, or None if not specified"""
+        """(decimal) -- Value of xlink:order attribute, NaN if not convertible to float, or None if not specified"""
         try:
             return decimal.Decimal(self.order)
         except decimal.InvalidOperation:
@@ -1923,11 +1938,6 @@ class ModelRelationship(ModelObject):
         varName = self.variablename
         return ModelValue.qname(self.arcElement, varName, noPrefixIsNoNamespace=True) if varName else None
 
-    @property
-    def linkrole(self):
-        """(str) -- Value of xlink:role attribute of parent extended link element"""
-        return self.arcElement.getparent().get("{http://www.w3.org/1999/xlink}role")
-
     @property
     def linkQname(self):
         """(QName) -- qname of the parent extended link element"""
@@ -1998,19 +2008,9 @@ class ModelRelationship(ModelObject):
             return self._isCovered
 
     @property
-    def axisDisposition(self):
-        """(str) -- Value of axisDisposition (on applicable table linkbase arcs"""
-        try:
-            return self._tableAxis
-        except AttributeError:
-            aType = (self.get("axis") or # XII 2013
-                     self.get("axisDisposition") or # XII 2011
-                     self.get("axisType"))  # Eurofiling
-            if aType in ("xAxis","x"): self._axisDisposition = "x"
-            elif aType in ("yAxis","y"): self._axisDisposition = "y"
-            elif aType in ("zAxis","z"): self._axisDisposition = "z"
-            else: self._axisDisposition = None
-            return self._axisDisposition
+    def axis(self):
+        """(str) -- Value of axis (on applicable table linkbase arcs)"""
+        return self.get("axis")
 
     @property
     def equivalenceHash(self): # not exact, use equivalenceKey if hashes are the same
@@ -2065,7 +2065,7 @@ class ModelRelationship(ModelObject):
     def propertyView(self):
         return self.toModelObject.propertyView + \
                (("arcrole", self.arcrole),
-                ("weight", self.weight) if self.arcrole == XbrlConst.summationItem else (),
+                ("weight", self.weight) if self.arcrole in XbrlConst.summationItems else (),
                 ("preferredLabel", self.preferredLabel)  if self.arcrole == XbrlConst.parentChild and self.preferredLabel else (),
                 ("contextElement", self.contextElement)  if self.arcrole in (XbrlConst.all, XbrlConst.notAll)  else (),
                 ("typedDomain", self.toModelObject.typedDomainElement.qname)
@@ -2087,6 +2087,11 @@ class ModelRelationship(ModelObject):
                         self.toModelObject.qname if isinstance(self.toModelObject, ModelObject) else "??",
                         self.modelDocument.basename, self.sourceline))
 
+    def __dir__(self):
+        # Ignore ModelObject attributes because most relate to the underlying lxml element,
+        # which ModelRelationship does not have.
+        return [a for a in object.__dir__(self) if a.startswith('__') or a not in modelObjectAttrs]
+
     @property
     def viewConcept(self):
         if isinstance(self.toModelObject, ModelConcept):