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

arelle/XbrlUtil.py

@@ -2,7 +2,8 @@
 See COPYRIGHT.md for copyright information.
 '''
 from __future__ import annotations
-from typing import Any, Sequence, TYPE_CHECKING
+from collections.abc import Sequence
+from typing import Any, TYPE_CHECKING
 import math
 from arelle.ModelValue import QName, DateTime
 from arelle.ModelObject import ModelObject, ModelAttribute

arelle/XhtmlValidate.py

@@ -7,7 +7,8 @@ from arelle import XbrlConst, XmlUtil, XmlValidate, ValidateFilingText, UrlUtil
 from arelle.ModelXbrl import ModelXbrl
 from arelle.ModelObject import ModelObject
 from lxml import etree
-import os, posixpath
+import os
+from urllib.parse import urljoin
 
 htmlEltUriAttrs = { # attributes with URI content (for relative correction and %20 canonicalization
     "a": {"href"},
@@ -85,7 +86,7 @@ def xhtmlValidate(modelXbrl: ModelXbrl, elt: ModelObject) -> None:
     XmlValidate.lxmlSchemaValidate(elt.modelDocument, inlineSchema)
 
     # lxml bug: doesn't detect: class="" (min length 1)
-    for e in elt.getroottree().iterfind("//{http://www.w3.org/1999/xhtml}*[@class='']"):
+    for e in elt.getroottree().iterfind(".//{http://www.w3.org/1999/xhtml}*[@class='']"):
         modelXbrl.error("arelle:xhtmlClassError",
             _("Attribute class must not be empty on element ix:%(element)s"),
             modelObject=e, element=e.localName)
@@ -100,30 +101,15 @@ def xhtmlValidate(modelXbrl: ModelXbrl, elt: ModelObject) -> None:
 
 
 def containsNamespacedElements(elt: etree.ElementBase, namespace: str) -> bool:
-    return elt.getroottree().find("//ns:*", {"ns": namespace}) is not None
+    return elt.getroottree().find(".//ns:*", {"ns": namespace}) is not None
 
 
 def resolveHtmlUri(elt, name, value):
     if name == "archive": # URILIST
         return " ".join(resolveHtmlUri(elt, "archiveListElement", v) for v in value.split(" "))
-    if not UrlUtil.isAbsolute(value):
-        if elt.localName == "object" and name in ("classid", "data", "archiveListElement") and elt.get("codebase"):
-            base = elt.get("codebase") + "/"
-        else:
-            base = getattr(elt.modelDocument, "htmlBase") # None if no htmlBase, empty string if it's not set
-        if base:
-            if value.startswith("/"): # add to authority
-                value = UrlUtil.authority(base) + value
-            elif value.startswith("#"): # add anchor to base document
-                value = base + value
-            else:
-                value = os.path.dirname(base) + "/" + value
-    # canonicalize ../ and ./
-    scheme, sep, pathpart = value.rpartition("://")
-    if sep:
-        pathpart = pathpart.replace('\\','/')
-        endingSep = '/' if pathpart[-1] == '/' else ''  # normpath drops ending directory separator
-        _uri = scheme + "://" + posixpath.normpath(pathpart) + endingSep
+    if elt.localName == "object" and name in ("classid", "data", "archiveListElement") and elt.get("codebase"):
+        base = elt.get("codebase") + "/"
     else:
-        _uri = posixpath.normpath(value)
-    return _uri # .replace(" ", "%20")  requirement for this is not yet clear
+        base = getattr(elt.modelDocument, "htmlBase", "") # None if no htmlBase, empty string if it's not set
+    _uri = urljoin(base, value)
+    return _uri

arelle/XmlUtil.py

@@ -11,15 +11,8 @@ from arelle.ModelObject import ModelObject
 from arelle.ModelValue import qname, QName, tzinfoStr
 from arelle.PrototypeDtsObject import PrototypeElementTree, PrototypeObject
 from arelle.XmlValidateConst import VALID, INVALID
-from typing import TYPE_CHECKING
-from typing import Any
-from typing import cast
-from typing import Mapping
-from typing import Generator
-from typing import Collection
-from typing import Callable
-from typing import Sequence
-from typing import TextIO
+from typing import Any, TextIO, TYPE_CHECKING, cast
+from collections.abc import Callable, Collection, Sequence, Generator, Mapping
 
 if TYPE_CHECKING:
     from arelle.ModelInstanceObject import ModelContext
@@ -35,7 +28,10 @@ xmlDeclarationPattern = re.compile(r"(\s+)?(<\?xml[^><\?]*\?>)", re.DOTALL)
 xmlEncodingPattern = re.compile(r"\s*<\?xml\s.*encoding=['\"]([^'\"]*)['\"].*\?>")
 xpointerFragmentIdentifierPattern = re.compile(r"([\w.]+)(\(([^)]*)\))?")
 xmlnsStripPattern = re.compile(r'\s*xmlns(:[\w.-]+)?="[^"]*"')
-nonSpacePattern = re.compile(r"\S+")
+
+_consecutiveSpacePattern = re.compile(r" {2,}")
+_replaceWhitespaceTable = str.maketrans("\t\n\r", " " * 3)
+
 
 class XmlDeclarationLocationException(Exception):
     def __init__(self) -> None:
@@ -206,7 +202,10 @@ def innerText(
     try:
         text = "".join(text for text in innerTextNodes(element, ixExclude, ixEscape, ixContinuation, ixResolveUris))
         if strip:
-            return text.strip(" \t\r\n") # strip follows xml whitespace collapse, only blank, tab and newlines
+            # For legacy reasons, strip=True removes leading/trailing
+            # whitespace even though most callers probably want
+            # collapseWhitespace semantics instead.
+            return text.strip(" \t\r\n")
         return text
     except (AttributeError, TypeError):
         return ""
@@ -304,8 +303,16 @@ def escapedText(text: str) -> str:
                    else c
                    for c in text)
 
+
+def replaceWhitespace(s: str) -> str:
+    # https://www.w3.org/TR/xmlschema-1/#d0e1654
+    return s.translate(_replaceWhitespaceTable)
+
+
 def collapseWhitespace(s: str) -> str:
-    return ' '.join( nonSpacePattern.findall(s) )
+    # https://www.w3.org/TR/xmlschema-1/#d0e1654
+    return " ".join(_consecutiveSpacePattern.split(replaceWhitespace(s))).strip(" ")
+
 
 def parentId(
     element: ModelObject,
@@ -463,7 +470,7 @@ def children(
                 (wildLocalName or (child.qname.localName if ixTarget else child.localName) in childLocalNames)):
                 children.append(child)
     elif isinstance(element, (etree._ElementTree,PrototypeElementTree)): # document root
-        child = element.getroot()
+        child = cast(Any, element.getroot())
         if (wildNamespaceURI or child.elementNamespaceURI in childNamespaceURIs) and \
            (wildLocalName or child.localName in childLocalNames):
             children.append(child)
@@ -634,9 +641,7 @@ def schemaBaseTypeDerivedFrom(
                            "{http://www.w3.org/2001/XMLSchema}simpleType",
                            "{http://www.w3.org/2001/XMLSchema}complexContent",
                            "{http://www.w3.org/2001/XMLSchema}simpleContent"):
-            qn = schemaBaseTypeDerivedFrom(cast(ModelObject, child))
-            if qn is not None:
-                return qn  # QName
+            return schemaBaseTypeDerivedFrom(cast(ModelObject, child))
     return None
 
 def schemaFacets(
@@ -1030,7 +1035,7 @@ def dateunionValue(
 ) -> str:
     if not isinstance(datetimeValue, (datetime.datetime, datetime.date)):
         return "INVALID"
-    tz = tzinfoStr(datetimeValue)  # type: ignore[arg-type]  # ModelValue type hints
+    tz = tzinfoStr(datetimeValue)
     isDate = getattr(
         datetimeValue, 'dateOnly', False) or not hasattr(datetimeValue, 'hour')
     if isDate or (
@@ -1075,7 +1080,7 @@ def xpointerElement(modelDocument: ModelDocument, fragmentIdentifier: str) -> et
             if scheme in modelDocument.idObjects:
                 node = modelDocument.idObjects.get(scheme)
             else:
-                node = modelDocument.xmlDocument.find("//*[@id='{0}']".format(scheme))
+                node = modelDocument.xmlDocument.find(".//*[@id='{0}']".format(scheme))
             if node is not None:
                 return node    # this scheme fails
         elif scheme == "element" and parenPart and path:
@@ -1085,7 +1090,7 @@ def xpointerElement(modelDocument: ModelDocument, fragmentIdentifier: str) -> et
                 if id in modelDocument.idObjects:
                     node = modelDocument.idObjects.get(id)
                 else:
-                    node = modelDocument.xmlDocument.find("//*[@id='{0}']".format(id))
+                    node = modelDocument.xmlDocument.find(".//*[@id='{0}']".format(id))
                 if node is None:
                     continue    # this scheme fails
                 elif len(pathParts) > 1:

arelle/XmlValidate.py

@@ -2,10 +2,12 @@
 See COPYRIGHT.md for copyright information.
 '''
 from __future__ import annotations
+from dataclasses import dataclass
 import logging, os
-from typing import TYPE_CHECKING, Any, Callable, Type, cast
+from collections.abc import Callable
+from typing import TYPE_CHECKING, Any, cast
 from lxml import etree
-from regex import Match, compile as re_compile
+from regex import Match, Pattern, compile as re_compile
 from decimal import Decimal, InvalidOperation
 from fractions import Fraction
 from arelle import UrlUtil, XbrlConst, XmlUtil, XmlValidateConst
@@ -18,7 +20,7 @@ from arelle.PythonUtil import strTruncate
 if TYPE_CHECKING:
     from arelle.Cntlr import Cntlr
     from arelle.ModelXbrl import ModelXbrl
-    from arelle.ModelDtsObject import ModelAny
+    from arelle.ModelDtsObject import ModelAny, ModelConcept
     from arelle.ModelDocument import ModelDocument
     from arelle.ModelInstanceObject import ModelFact
     from arelle.typing import TypeGetText
@@ -28,6 +30,36 @@ if TYPE_CHECKING:
 
 _: TypeGetText
 
+# patterns to replace \c and \i in names
+iNameChar = "[_A-Za-z\xC0-\xD6\xD8-\xF6\xF8-\xFF\u0100-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]"
+cNameChar = r"[_\-\.:"   "\xB7A-Za-z0-9\xC0-\xD6\xD8-\xF6\xF8-\xFF\u0100-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\u0300-\u036F\u203F-\u2040]"
+cMinusCNameChar = r"[_\-\."   "\xB7A-Za-z0-9\xC0-\xD6\xD8-\xF6\xF8-\xFF\u0100-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\u0300-\u036F\u203F-\u2040]"
+
+@dataclass(frozen=True)
+class XsdPattern:
+    xsdPattern: str
+    pyPattern: Pattern[str]
+
+    # shim class for python wrapper of xsd pattern
+    @classmethod
+    def compile(cls, p: str) -> XsdPattern:
+        if r"\i" in p or r"\c" in p:
+            p = p.replace(r"[\i-[:]]", iNameChar).replace(r"\i", iNameChar) \
+                 .replace(r"[\c-[:]]", cMinusCNameChar).replace(r"\c", cNameChar)
+        pyPattern = re_compile(p + "$") # must match whole string
+        return cls(p, pyPattern)
+
+    def match(self, string: str) -> Match[str] | None:
+        return self.pyPattern.match(string)
+
+    @property
+    def pattern(self) -> str:
+        return self.xsdPattern
+
+    def __repr__(self) -> str:
+        return self.xsdPattern
+
+
 # support legacy direct imports from this module
 UNVALIDATED      = XmlValidateConst.UNVALIDATED
 UNKNOWN          = XmlValidateConst.UNKNOWN
@@ -40,28 +72,26 @@ VALID_NO_CONTENT = XmlValidateConst.VALID_NO_CONTENT
 
 validateElementSequence: Callable[..., Any] | None = None  #dynamic import to break dependency loops
 modelGroupCompositorTitle: Callable[[Any], str] | None = None
-ModelInlineValueObject: Type[Any] | None = None
+ModelInlineValueObject: type[Any] | None = None
 ixMsgCode: Callable[..., str] | None = None
 
-normalizeWhitespacePattern = re_compile(r"[\t\n\r]") # replace tab, line feed, return with space (XML Schema Rules, note: does not include NBSP)
-collapseWhitespacePattern = re_compile(r"[ \t\n\r]+") # collapse multiple spaces, tabs, line feeds and returns to single space
 entirelyWhitespacePattern = re_compile(r"^[ \t\n\r]+$") # collapse multiple spaces, tabs, line feeds and returns to single space
 languagePattern = re_compile("[a-zA-Z]{1,8}(-[a-zA-Z0-9]{1,8})*$")
-NCNamePattern = re_compile("^[_A-Za-z\xC0-\xD6\xD8-\xF6\xF8-\xFF\u0100-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]"
+NCNamePattern = re_compile("^[_A-Za-z\xC0-\xD6\xD8-\xF6\xF8-\xFF\u0100-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF]"
                             r"[_\-\."
-                               "\xB7A-Za-z0-9\xC0-\xD6\xD8-\xF6\xF8-\xFF\u0100-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\u0300-\u036F\u203F-\u2040]*$")
-QNamePattern = re_compile("^([_A-Za-z\xC0-\xD6\xD8-\xF6\xF8-\xFF\u0100-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]"
+                               "\xB7A-Za-z0-9\xC0-\xD6\xD8-\xF6\xF8-\xFF\u0100-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\u0300-\u036F\u203F-\u2040]*$")
+QNamePattern = re_compile("^([_A-Za-z\xC0-\xD6\xD8-\xF6\xF8-\xFF\u0100-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF]"
                              r"[_\-\."
-                               "\xB7A-Za-z0-9\xC0-\xD6\xD8-\xF6\xF8-\xFF\u0100-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\u0300-\u036F\u203F-\u2040]*:)?"
-                          "[_A-Za-z\xC0-\xD6\xD8-\xF6\xF8-\xFF\u0100-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]"
+                               "\xB7A-Za-z0-9\xC0-\xD6\xD8-\xF6\xF8-\xFF\u0100-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\u0300-\u036F\u203F-\u2040]*:)?"
+                          "[_A-Za-z\xC0-\xD6\xD8-\xF6\xF8-\xFF\u0100-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF]"
                             r"[_\-\."
-                               "\xB7A-Za-z0-9\xC0-\xD6\xD8-\xF6\xF8-\xFF\u0100-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\u0300-\u036F\u203F-\u2040]*$")
-namePattern = re_compile("^[_A-Za-z\xC0-\xD6\xD8-\xF6\xF8-\xFF\u0100-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]"
+                               "\xB7A-Za-z0-9\xC0-\xD6\xD8-\xF6\xF8-\xFF\u0100-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\u0300-\u036F\u203F-\u2040]*$")
+namePattern = re_compile("^[_A-Za-z\xC0-\xD6\xD8-\xF6\xF8-\xFF\u0100-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF]"
                             r"[_\-\.:"
-                               "\xB7A-Za-z0-9\xC0-\xD6\xD8-\xF6\xF8-\xFF\u0100-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\u0300-\u036F\u203F-\u2040]*$")
+                               "\xB7A-Za-z0-9\xC0-\xD6\xD8-\xF6\xF8-\xFF\u0100-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\u0300-\u036F\u203F-\u2040]*$")
 
 NMTOKENPattern = re_compile(r"[_\-\.:"
-                               "\xB7A-Za-z0-9\xC0-\xD6\xD8-\xF6\xF8-\xFF\u0100-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\u0300-\u036F\u203F-\u2040]+$")
+                               "\xB7A-Za-z0-9\xC0-\xD6\xD8-\xF6\xF8-\xFF\u0100-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\u0300-\u036F\u203F-\u2040]+$")
 
 decimalPattern = re_compile(r"^[+-]?([0-9]+(\.[0-9]*)?|\.[0-9]+)$")
 integerPattern = re_compile(r"^[+-]?([0-9]+)$")
@@ -83,15 +113,13 @@ lexicalPatterns = {
 
 # patterns difficult to compile into python
 xmlSchemaPatterns = {
-    r"\c+": NMTOKENPattern,
-    r"\i\c*": namePattern,
-    r"[\i-[:]][\c-[:]]*": NCNamePattern,
-    }
-
-# patterns to replace \c and \i in names
-iNameChar = "[_A-Za-z\xC0-\xD6\xD8-\xF6\xF8-\xFF\u0100-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]"
-cNameChar = r"[_\-\.:"   "\xB7A-Za-z0-9\xC0-\xD6\xD8-\xF6\xF8-\xFF\u0100-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\u0300-\u036F\u203F-\u2040]"
-cMinusCNameChar = r"[_\-\."   "\xB7A-Za-z0-9\xC0-\xD6\xD8-\xF6\xF8-\xFF\u0100-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\u0300-\u036F\u203F-\u2040]"
+    pattern: XsdPattern(xsdPattern=pattern, pyPattern=pyPattern)
+    for pattern, pyPattern in (
+        (r"\c+", NMTOKENPattern),
+        (r"\i\c*", namePattern),
+        (r"[\i-[:]][\c-[:]]*", NCNamePattern),
+    )
+}
 
 baseXsdTypePatterns = {
                 "Name": namePattern,
@@ -115,7 +143,9 @@ def validate(
     recurse: bool = True,
     attrQname: QName | None = None,
     ixFacts: bool = False,
-) -> None:
+    setTargetModelXbrl: bool = False, # when true also revalidate previously validated elements
+    elementDeclarationType: ModelType | None = None,
+)  -> None:
     global ModelInlineValueObject, ixMsgCode
     if ModelInlineValueObject is None:
         from arelle.ModelInstanceObject import ModelInlineValueObject
@@ -126,8 +156,10 @@ def validate(
     facets = None
 
     # attrQname can be provided for attributes that are global and LAX
-    if (getattr(elt,"xValid", UNVALIDATED) == UNVALIDATED) and (not isIxFact or ixFacts):
+    if (getattr(elt,"xValid", UNVALIDATED) == UNVALIDATED or setTargetModelXbrl) and (not isIxFact or ixFacts):
         assert modelXbrl is not None
+        if setTargetModelXbrl and modelXbrl != elt.modelXbrl: # change of element's targetModelXbrl
+            elt.targetModelXbrl = modelXbrl
         qnElt = elt.qname if ixFacts and isIxFact else elt.elementQname
         modelConcept = modelXbrl.qnameConcepts.get(qnElt)
         isAbstract = False
@@ -139,9 +171,17 @@ def validate(
                 isAbstract = True
             elif modelConcept.isFraction:
                 baseXsdType = "fraction"
-            else:
+            elif (
+                elementDeclarationType is None
+                or elementDeclarationType.qname == XbrlConst.qnXsdDefaultType
+                or modelConcept.type.qname == elementDeclarationType.qname
+                or modelConcept.type.isDerivedFrom(elementDeclarationType.qname)
+            ):
                 baseXsdType = modelConcept.baseXsdType
                 facets = modelConcept.facets
+            else:
+                baseXsdType = elementDeclarationType.baseXsdType
+                facets = elementDeclarationType.facets
         elif qnElt == XbrlConst.qnXbrldiExplicitMember: # not in DTS
             baseXsdType = "QName"
             type = None
@@ -322,7 +362,7 @@ def validate(
                                 modelObject=elt,
                                 element=qnElt)
                     else:
-                        errResult = validateElementSequence(modelXbrl, type, childElts, ixFacts)
+                        errResult = validateElementSequence(modelXbrl, type, childElts, ixFacts, setTargetModelXbrl)
                         if errResult is not None and errResult[2]:
                             iElt, occured, errDesc, errArgs = errResult
                             errElt1 = childElts[iElt] if iElt < len(childElts) else elt
@@ -337,7 +377,7 @@ def validate(
                             if qnElt.namespaceURI == XbrlConst.xbrli and iElt < len(childElts):
                                 for childElt in childElts[iElt:]:
                                     if (getattr(childElt,"xValid", UNVALIDATED) == UNVALIDATED):
-                                        validate(modelXbrl, childElt, ixFacts=ixFacts)
+                                        validate(modelXbrl, childElt, ixFacts=ixFacts, setTargetModelXbrl=setTargetModelXbrl)
                     recurse = False # cancel child element validation below, recursion was within validateElementSequence
                 except AttributeError as ex:
                     raise ex
@@ -345,7 +385,7 @@ def validate(
     if recurse: # if there is no complex or simple type (such as xbrli:measure) then this code is used
         for child in (cast('ModelFact', elt).modelTupleFacts if ixFacts and isIxFact else elt):
             if isinstance(child, ModelObject):
-                validate(modelXbrl, child, recurse, attrQname, ixFacts)
+                validate(modelXbrl, child, recurse, attrQname, ixFacts, setTargetModelXbrl)
 
 def validateValue(
     modelXbrl: ModelXbrl | None,
@@ -387,9 +427,9 @@ def validateValue(
                 if "whiteSpace" in facets:
                     whitespaceReplace, whitespaceCollapse = {"preserve":(False,False), "replace":(True,False), "collapse":(False,True)}[facets["whiteSpace"]]
             if whitespaceReplace:
-                value = normalizeWhitespacePattern.sub(' ', value) # replace tab, line feed, return with space
+                value = XmlUtil.replaceWhitespace(value)
             elif whitespaceCollapse:
-                value = collapseWhitespacePattern.sub(' ', value).strip(' ') # collapse multiple spaces, tabs, line feeds and returns to single space
+                value = XmlUtil.collapseWhitespace(value)
             if baseXsdType == "noContent":
                 if len(value) > 0 and not entirelyWhitespacePattern.match(value): # only xml schema pattern whitespaces removed
                     raise ValueError("value content not permitted")
@@ -418,9 +458,8 @@ def validateValue(
                     xValue = sValue = value
                     xValid = VALID_ID
                 elif baseXsdType == "anyURI":
-                    if value:  # allow empty strings to be valid anyURIs
-                        if UrlUtil.isValidUriReference(value) is None:
-                            raise ValueError("IETF RFC 2396 4.3 syntax")
+                    if not UrlUtil.isValidUriReference(value):
+                        raise ValueError("IETF RFC 2396 4.3 syntax")
                     # encode PSVI xValue similarly to Xerces and other implementations
                     xValue = anyURI(UrlUtil.anyUriQuoteForPSVI(value))
                     sValue = value
@@ -461,10 +500,10 @@ def validateValue(
                          and xValue < 0) or
                         (baseXsdType == "nonPositiveInteger" and xValue > 0) or
                         (baseXsdType == "positiveInteger" and xValue <= 0) or
-                        (baseXsdType == "byte" and not -128 <= xValue < 127) or
-                        (baseXsdType == "unsignedByte" and not 0 <= xValue < 255) or
-                        (baseXsdType == "short" and not -32768 <= xValue < 32767) or
-                        (baseXsdType == "unsignedShort" and not 0 <= xValue < 65535) or
+                        (baseXsdType == "byte" and not -128 <= xValue <= 127) or
+                        (baseXsdType == "unsignedByte" and not 0 <= xValue <= 255) or
+                        (baseXsdType == "short" and not -32768 <= xValue <= 32767) or
+                        (baseXsdType == "unsignedShort" and not 0 <= xValue <= 65535) or
                         (baseXsdType == "positiveInteger" and xValue <= 0)):
                         raise ValueError("{0} is not {1}".format(value, baseXsdType))
                     if facets:
@@ -507,10 +546,6 @@ def validateValue(
                     sValue = value
                 elif baseXsdType in ("XBRLI_DECIMALSUNION", "XBRLI_PRECISIONUNION"):
                     xValue = sValue = value if value == "INF" else int(value)
-                elif baseXsdType in ("XBRLI_NONZERODECIMAL"):
-                    xValue = sValue = int(value)
-                    if xValue == 0:
-                        raise ValueError("invalid value")
                 elif baseXsdType == "xsd-pattern":
                     # for facet compiling
                     try:
@@ -518,7 +553,7 @@ def validateValue(
                         if value in xmlSchemaPatterns:
                             xValue = xmlSchemaPatterns[value]
                         else:
-                            xValue = XsdPattern().compile(value)
+                            xValue = XsdPattern.compile(value)
                     except Exception as err:
                         raise ValueError(err)
                 elif baseXsdType == "fraction":
@@ -716,19 +751,32 @@ def lxmlSchemaValidate(modelDocument: ModelDocument, extraSchema : str | None =
             etreeXMLSchema = etree.XMLSchema(xsdTree)
             etreeXMLSchema.assertValid(docTree)
         except etree.DocumentInvalid as err:
+            nsmap = {
+                key: val
+                for key, val in docTree.getroot().nsmap.items()
+                if key
+            }
             for e in err.error_log:  # type: ignore[attr-defined]
                 if not any(s in e.message for s in (": The QName value", "is not a valid value of the atomic type 'xs:QName'")):
                     # do newer lxml validations have QName whitespace collapsing issue?
+                    userFriendlyElementPath = ''
+                    errorElements = docTree.xpath(e.path, namespaces=nsmap)
+                    if len(errorElements) == 1:
+                        userFriendlyElementPath = docTree.getelementpath(errorElements[0])
+                        for prefix, namespace in docTree.getroot().nsmap.items():
+                            replacementText = f"{prefix}:" if prefix else ''
+                            userFriendlyElementPath = userFriendlyElementPath.replace(f"{{{namespace}}}", replacementText)
                     msgCode = f"lxml.{e.type_name}"
-                    cntlr.addToLog(_("XML file syntax error %(error)s, line %(sourceLine)s, path %(path)s"),
+                    cntlr.addToLog(_("XML file syntax error %(error)s, line %(sourceLine)s, path '%(path)s', xpath '%(xpath)s'"),
                                    messageArgs={"error": e.message,
-                                                "path": e.path,
+                                                "path": userFriendlyElementPath,
+                                                "xpath": e.path,
                                                 "sourceLine": e.line},
                                    messageCode=msgCode,
                                    file=modelDocument.basename,
                                    level=logging.ERROR)
                     modelDocument.modelXbrl.errors.append(msgCode)
-        except etree.XMLSyntaxError as err:
+        except (etree.XMLSyntaxError, etree.XMLSchemaError) as err:
             msgCode = "lxml.schemaError"
             cntlr.addToLog(_("XML file syntax error %(error)s"),
                            messageArgs={"error": str(err)},
@@ -736,23 +784,3 @@ def lxmlSchemaValidate(modelDocument: ModelDocument, extraSchema : str | None =
                            file=modelDocument.basename,
                            level=logging.ERROR)
             modelDocument.modelXbrl.errors.append(msgCode)
-
-class XsdPattern():
-    # shim class for python wrapper of xsd pattern
-    def compile(self, p: str) -> XsdPattern:
-        self.xsdPattern = p
-        if r"\i" in p or r"\c" in p:
-            p = p.replace(r"[\i-[:]]", iNameChar).replace(r"\i", iNameChar) \
-                 .replace(r"[\c-[:]]", cMinusCNameChar).replace(r"\c", cNameChar)
-        self.pyPattern = re_compile(p + "$") # must match whole string
-        return self
-
-    def match(self, string: str) -> Match[str] | None:
-        return self.pyPattern.match(string)
-
-    @property
-    def pattern(self) -> str:
-        return self.xsdPattern
-
-    def __repr__(self) -> str:
-        return self.xsdPattern

arelle/XmlValidateParticles.py

@@ -10,7 +10,7 @@ from arelle.XbrlConst import xsd
 from arelle.XmlValidate import validate
 
 
-def validateElementSequence(modelXbrl, compositor, children, ixFacts, iNextChild=0):
+def validateElementSequence(modelXbrl, compositor, children, ixFacts, setTargetModelXbrl, iNextChild=0):
     if compositor.modelDocument.targetNamespace == xsd:
         return (iNextChild, True, None, None)
     particles = compositor.dereference().particles
@@ -27,7 +27,7 @@ def validateElementSequence(modelXbrl, compositor, children, ixFacts, iNextChild
         for particle in particles:
             occurrences = 0
             if isinstance(particle, (ModelConcept, ModelAny)):
-                elementDeclaration = particle.dereference()
+                elementDeclaration = particle.dereference() # note that types in structures may share quames with other structures
                 while iNextChild < len(children):
                     elt = children[iNextChild]
                     # children now only contains ModelObjects, no comments or other lxml elements
@@ -41,7 +41,7 @@ def validateElementSequence(modelXbrl, compositor, children, ixFacts, iNextChild
                           (vQname in modelXbrl.qnameConcepts and
                            modelXbrl.qnameConcepts[vQname].substitutesForQname(elementDeclaration.qname))))):
                         occurrences += 1
-                        validate(modelXbrl, elt, ixFacts=ixFacts)
+                        validate(modelXbrl, elt, ixFacts=ixFacts, setTargetModelXbrl=setTargetModelXbrl, elementDeclarationType=getattr(elementDeclaration, "type", None))
                         iNextChild += 1
                         if occurrences == particle.maxOccurs:
                             break
@@ -50,7 +50,7 @@ def validateElementSequence(modelXbrl, compositor, children, ixFacts, iNextChild
             else:  # group definition or compositor
                 while occurrences < particle.maxOccurs:
                     iPrevChild = iNextChild
-                    iNextChild, occurred, errDesc, errArgs = validateElementSequence(modelXbrl, particle, children, ixFacts, iNextChild)
+                    iNextChild, occurred, errDesc, errArgs = validateElementSequence(modelXbrl, particle, children, ixFacts, setTargetModelXbrl, iNextChild)
                     if occurred:
                         # test if occurrence was because of minOccurs zero but no match occurred (HF 2012-09-07)
                         if occurred and iNextChild == iPrevChild and particle.minOccurs == 0: # nothing really occurred

arelle/_version.py

@@ -1,4 +1,34 @@
-# file generated by setuptools_scm
+# file generated by setuptools-scm
 # don't change, don't track in version control
-__version__ = version = '2.17.1'
-__version_tuple__ = version_tuple = (2, 17, 1)
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple
+    from typing import Union
+
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+    COMMIT_ID = Union[str, None]
+else:
+    VERSION_TUPLE = object
+    COMMIT_ID = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+commit_id: COMMIT_ID
+__commit_id__: COMMIT_ID
+
+__version__ = version = '2.37.71'
+__version_tuple__ = version_tuple = (2, 37, 71)
+
+__commit_id__ = commit_id = None