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

arelle/formula/XPathContext.py

@@ -7,7 +7,8 @@ import datetime
 from decimal import Decimal, InvalidOperation
 from fractions import Fraction
 from numbers import Number
-from typing import Any, Callable, Iterable, MutableSequence, Sequence, TYPE_CHECKING, Type, Union, cast
+from collections.abc import Callable, Iterable, MutableSequence, Sequence
+from typing import Any, TYPE_CHECKING, Union, cast
 
 from lxml import etree
 
@@ -102,7 +103,7 @@ testTypeCompatibility: Callable[[
     ContextItem,
     ContextItem,
 ], None] | None = None
-Trace: Type[TraceClass] | None = None
+Trace: type[TraceClass] | None = None
 qnWild = qname("*")  # "*"
 
 
@@ -150,11 +151,13 @@ class FunctionArgType(Exception):
             expectedType: str,
             foundObject: str | QName | Sequence[FormulaToken] | None = '',
             errCode: str = 'err:XPTY0004',
+            value: str | None = None
     ) -> None:
         self.errCode = errCode
         self.argNum = (argIndex + 1) if isinstance(argIndex, int) else argIndex
         self.expectedType = expectedType
         self.foundObject = foundObject
+        self.value = value
         self.args = (self.__repr__(),)
 
     def __repr__(self) -> str:
@@ -348,8 +351,8 @@ class XPathContext:
                         raise XPathException(p, 'err:XPST0017', _('Function named {0} does not have a custom or built-in implementation.').format(op))
                 elif op in VALUE_OPS:
                     # binary arithmetic operations and value comparisons
-                    s1 = self.atomize(p, resultStack.pop()) if len(resultStack) > 0 else []
-                    s2 = self.atomize(p, self.evaluate(p.args, contextItem=contextItem))
+                    s1: Sequence[ContextItem] = self.atomize(p, resultStack.pop()) if len(resultStack) > 0 else []
+                    s2: Sequence[ContextItem] = self.atomize(p, self.evaluate(p.args, contextItem=contextItem))
                     # value comparisons
                     if len(s1) > 1 or len(s2) > 1:
                         raise XPathException(p, 'err:XPTY0004', _("Value operation '{0}' sequence length error").format(op))
@@ -380,35 +383,35 @@ class XPathContext:
                             elif isinstance(op2, Decimal) and isinstance(op1, float):
                                 op2 = float(op2)
                         if op == '+':
-                            result = op1 + op2
+                            result = op1 + op2  # type: ignore[assignment,operator]
                         elif op == '-':
-                            result = op1 - op2
+                            result = op1 - op2  # type: ignore[assignment,operator]
                         elif op == '*':
-                            result = op1 * op2
+                            result = op1 * op2  # type: ignore[assignment,operator]
                         elif op in ('div', 'idiv', "mod"):
                             try:
                                 if op == 'div':
-                                    result = op1 / op2
+                                    result = op1 / op2  # type: ignore[assignment,operator]
                                 elif op == 'idiv':
-                                    result = op1 // op2
+                                    result = op1 // op2  # type: ignore[assignment,operator]
                                 elif op == 'mod':
-                                    result = op1 % op2
+                                    result = op1 % op2  # type: ignore[assignment,operator]
                             except ZeroDivisionError:
                                 raise XPathException(p, 'err:FOAR0001', _('Attempt to divide by zero: {0} {1} {2}.').format(op1, op, op2))
                         elif op == 'ge':
-                            result = op1 >= op2
+                            result = op1 >= op2 # type: ignore[operator]
                         elif op == 'gt':
-                            result = op1 > op2
+                            result = op1 > op2 # type: ignore[operator]
                         elif op == 'le':
-                            result = op1 <= op2
+                            result = op1 <= op2 # type: ignore[operator]
                         elif op == 'lt':
-                            result = op1 < op2
+                            result = op1 < op2 # type: ignore[operator]
                         elif op == 'eq':
                             result = op1 == op2
                         elif op == 'ne':
                             result = op1 != op2
                         elif op == 'to':
-                            result = range(int(op1), int(op2) + 1)
+                            result = range(int(op1), int(op2) + 1)  # type: ignore[arg-type]
                 elif op in GENERALCOMPARISON_OPS:
                     # general comparisons
                     s1 = self.atomize(p, resultStack.pop()) if len(resultStack) > 0 else []
@@ -437,23 +440,23 @@ class XPathContext:
                 elif op in NODECOMPARISON_OPS:
                     # node comparisons
                     s1 = resultStack.pop() if len(resultStack) > 0 else []
-                    s2 = self.evaluate(p.args, contextItem=contextItem)
-                    if len(s1) > 1 or len(s2) > 1 or not self.isNodeSequence(s1) or not self.isNodeSequence(s2[0]):
+                    _s2 = self.evaluate(p.args, contextItem=contextItem)
+                    if len(s1) > 1 or len(_s2) > 1 or not self.isNodeSequence(s1) or not self.isNodeSequence(_s2[0]):
                         raise XPathException(p, 'err:XPTY0004', _('Node comparison sequence error'))
-                    if len(s1) == 0 or len(s2[0]) == 0:
+                    if len(s1) == 0 or len(_s2[0]) == 0:
                         result = []
                     else:
                         n1 = s1[0]
-                        n2 = s2[0][0]
+                        n2 = _s2[0][0]
                         result = False
                         for op1 in s1:
-                            for op2 in s2:
+                            for _op2 in _s2:
                                 if op == 'is':
                                     result = n1 == n2
                                 elif op == '>>':
-                                    result = op1 > op2
+                                    result = op1 > _op2  # type: ignore[operator]
                                 elif op == '<<':
-                                    result = op1 <= op2
+                                    result = op1 <= _op2  # type: ignore[operator]
                             if result:
                                 break
                 elif op in COMBINING_OPS:
@@ -500,7 +503,7 @@ class XPathContext:
                         if op == 'u+':
                             result = op1
                         elif op == 'u-':
-                            result = -op1
+                            result = -op1 # type: ignore[assignment,operator]
                 elif op == 'instance':
                     result = False
                     s1 = self.flattenSequence(resultStack.pop()) if len(resultStack) > 0 else []
@@ -612,10 +615,17 @@ class XPathContext:
             exprStack: Sequence[FormulaToken],
             _type: QName | str | None,
             contextItem: ContextItem | None = None,
+            resultMayBeNode: bool = False,
     ) -> Any:
         if exprStack and len(exprStack) > 0 and isinstance(exprStack[0], ProgHeader):
             progHeader = exprStack[0]
-            result = self.atomize(progHeader, self.evaluate(exprStack, contextItem=contextItem))
+            eval = self.evaluate(exprStack, contextItem=contextItem)
+            # TLB test case 200 v02i requires a node result (should xs:element be allowed?)
+            if not _type and resultMayBeNode:
+                result = self.flattenSequence(eval)
+                if len(result) > 0 and self.isNodeSequence(result):
+                    return result[0]
+            result = self.atomize(progHeader, eval)
             if isinstance(_type, QName) and _type.namespaceURI == XbrlConst.xsd:
                 _type = "xs:" + _type.localName
             if isinstance(_type, str):
@@ -661,7 +671,7 @@ class XPathContext:
                     if hasPrevValue:
                         prevValue = self.inScopeVars[rvQname]
                     for rv in r:
-                        self.inScopeVars[rvQname] = rv  # type: ignore[assignment]
+                        self.inScopeVars[rvQname] = rv
                         self.evaluateRangeVars(op, args[0], args[1:], contextItem, result)
                         if op != 'for' and len(result) > 0:
                             break  # short circuit evaluation
@@ -858,7 +868,7 @@ class XPathContext:
         if isinstance(x, ModelFact):
             if x.isTuple:
                 raise XPathException(p, 'err:FOTY0012', _('Atomizing tuple {0} that does not have a typed value').format(x))
-            if x.isNil:
+            if x.isNil or x.concept is None:
                 return []
             baseXsdType = x.concept.baseXsdType
             v = x.value  # resolves default value
@@ -917,8 +927,10 @@ class XPathContext:
             x = qname(e, v)
         elif baseXsdType == "anyURI":
             x = anyURI(v.strip())
+        elif baseXsdType == "normalizedString":
+            # https://www.w3.org/TR/xmlschema-2/#normalizedString
+            x = XmlUtil.replaceWhitespace(v)
         elif baseXsdType in (
-            "normalizedString",
             "token",
             "language",
             "NMTOKEN",
@@ -928,7 +940,9 @@ class XPathContext:
             "IDREF",
             "ENTITY",
         ):
-            x = v.strip()
+            # https://www.w3.org/TR/xmlschema-2/#token
+            # That is token and its derived built-in types
+            x = XmlUtil.collapseWhitespace(v)
         elif baseXsdType == "XBRLI_DATEUNION":
             x = dateTime(v, type=DATEUNION)
         elif baseXsdType == "date":

arelle/formula/XPathParser.py

@@ -3,12 +3,13 @@ See COPYRIGHT.md for copyright information.
 '''
 from __future__ import annotations
 
+import logging
 import sys
 import time
 import traceback
-from collections.abc import Iterable
+from collections.abc import Iterable, Sequence
 from decimal import Decimal
-from typing import Any, List, Sequence, TYPE_CHECKING, Union
+from typing import Any, TYPE_CHECKING, Union, cast
 from xml.dom import minidom
 
 from pyparsing import (
@@ -67,7 +68,7 @@ FormulaToken = Union[
 
 RecursiveFormulaTokens = Sequence[Union[FormulaToken, 'RecursiveFormulaTokens']]
 
-ExpressionStack = List[FormulaToken]
+ExpressionStack = list[FormulaToken]
 
 ixtFunctionNamespaces: set[str] = set()
 
@@ -817,7 +818,7 @@ expr <<= orExpr
 # doesn't reset the streamlined setting of the Forward expression instance.
 assert isinstance(expr.expr, ParserElement)
 expr.streamlined = expr.expr.streamlined
-xpathExpr = expr + StringEnd()  # type: ignore[no-untyped-call]
+xpathExpr = expr + StringEnd()
 
 
 # map operator symbols to corresponding arithmetic operations
@@ -898,7 +899,7 @@ isInitialized = False
 
 
 def initializeParser(modelManager: ModelManager) -> bool:
-    global isInitialized, ixtFunctionNamespaces
+    global isInitialized
     if not isInitialized:
         from arelle import FunctionIxt
         ixtFunctionNamespaces.update(FunctionIxt.ixtNamespaceFunctions.keys())
@@ -906,9 +907,14 @@ def initializeParser(modelManager: ModelManager) -> bool:
         modelManager.showStatus(_("initializing formula xpath2 grammar"))
         startedAt = time.time()
         xpathExpr.parse_string("0", parseAll=True)
-        modelManager.addToLog(format_string(modelManager.locale,
-                                    _("Formula xpath2 grammar initialized in %.2f secs"),
-                                    time.time() - startedAt))
+        modelManager.addToLog(
+            format_string(
+                modelManager.locale,
+                _("Formula xpath2 grammar initialized in %.2f secs"),
+                time.time() - startedAt
+            ),
+            level=logging.DEBUG
+        )
         modelManager.showStatus(None)
         isInitialized = True
         return True  # was initialized on this call
@@ -948,7 +954,7 @@ def staticExpressionFunctionContext() -> minidom.Element:
             ' xmlns:fn="http://www.w3.org/2005/xpath-functions"'
             '/>'
         ).documentElement
-    return _staticExpressionFunctionContext
+    return cast(minidom.Element, _staticExpressionFunctionContext)
 
 
 def parse(

arelle/locale/ar_EG/LC_MESSAGES/ar_EG.po

@@ -520,13 +520,13 @@ msgstr "تجميع إحصاءات تعريفية، مثل توقيتات اعم
 msgid ""
 "start web server on host:port[:server] for REST and web access, e.g., --"
 "webserver locahost:8080, or specify nondefault a server name, such as "
-"cherrypy, --webserver locahost:8080:cherrypy. (It is possible to specify "
+"cheroot, --webserver locahost:8080:cheroot. (It is possible to specify "
 "options to be defaults for the web server, such as disclosureSystem and "
 "validations, but not including file names.) "
 msgstr ""
 "تشغيل الويب سيرفير على عنوان host:port[:server] لعمليات REST، مثال webserver "
-"locahost:8080--، او تحديد نوع سيرفير اخر مثل cherrypy على سبيل المثال "
-"webserver locahost:8080:cherrypy--. (يمكن تحديد خيارات مفترضة للويب سيرفير "
+"locahost:8080--، او تحديد نوع سيرفير اخر مثل cheroot على سبيل المثال "
+"webserver locahost:8080:cheroot--. (يمكن تحديد خيارات مفترضة للويب سيرفير "
 "مثل disclosureSystem و validations ولا يتضمن ذلك اسم الملف.) "
 
 #: CntlrCmdLine.py:379
@@ -2599,7 +2599,6 @@ msgstr ""
 msgid ""
 "\n"
 "   Bottle \\u00a9 2011-2013 Marcel Hellkamp\n"
-"   CherryPy \\u00a9 2002-2013 CherryPy Team"
 msgstr ""
 
 #: CntlrWinMain.py:1343

arelle/locale/messages.pot

@@ -297,7 +297,7 @@ msgid "Collect profile statistics, such as timing of validation activities and f
 msgstr ""
 
 #: arelle\CntlrCmdLine.py:328
-msgid "start web server on host:port[:server] for REST and web access, e.g., --webserver locahost:8080, or specify nondefault a server name, such as cherrypy, --webserver locahost:8080:cherrypy. (It is possible to specify options to be defaults for the web server, such as disclosureSystem and validations, but not including file names.) "
+msgid "start web server on host:port[:server] for REST and web access, e.g., --webserver locahost:8080, or specify nondefault a server name, such as cheroot, --webserver locahost:8080:cheroot. (It is possible to specify options to be defaults for the web server, such as disclosureSystem and validations, but not including file names.) "
 msgstr ""
 
 #: arelle\CntlrCmdLine.py:356
@@ -1572,7 +1572,6 @@ msgstr ""
 msgid ""
 "\n"
 "   Bottle © 2011-2013 Marcel Hellkamp\n"
-"   CherryPy © 2002-2013 CherryPy Team"
 msgstr ""
 
 #: arelle\CntlrWinMain.py:1327

arelle/locale/ru/LC_MESSAGES/ru.po

@@ -261,8 +261,8 @@ msgid "Collect profile statistics, such as timing of validation activities and f
 msgstr "Собирать статистику профиля, например, время исполнения валидации."
 
 #: arelle\CntlrCmdLine.py:308
-msgid "start web server on host:port[:server] for REST and web access, e.g., --webserver locahost:8080, or specify nondefault a server name, such as cherrypy, --webserver locahost:8080:cherrypy. (It is possible to specify options to be defaults for the web server, such as disclosureSystem and validations, but not including file names.) "
-msgstr "запустите веб-сервер на host:port[:server] для REST и веб-доступа, например, --webserver locahost:8080, или укажите имя сервера не по умолчанию, например cherrypy, --webserver locahost:8080:cherrypy. (Можно указать параметры по умолчанию для веб-сервера, такие как системы раскрытия информации и валиидаций, но не включая имена файлов.) "
+msgid "start web server on host:port[:server] for REST and web access, e.g., --webserver locahost:8080, or specify nondefault a server name, such as cheroot, --webserver locahost:8080:cheroot. (It is possible to specify options to be defaults for the web server, such as disclosureSystem and validations, but not including file names.) "
+msgstr "запустите веб-сервер на host:port[:server] для REST и веб-доступа, например, --webserver locahost:8080, или укажите имя сервера не по умолчанию, например cheroot, --webserver locahost:8080:cheroot. (Можно указать параметры по умолчанию для веб-сервера, такие как системы раскрытия информации и валиидаций, но не включая имена файлов.) "
 
 #: arelle\CntlrCmdLine.py:336
 msgid "Show product version, copyright, and license."

arelle/logging/formatters/LogFormatter.py

@@ -0,0 +1,47 @@
+"""
+See COPYRIGHT.md for copyright information.
+"""
+from __future__ import annotations
+
+import logging
+from collections import defaultdict
+from typing import Any
+
+
+class LogFormatter(logging.Formatter):
+    def __init__(self, fmt: str | None = None, datefmt: str | None = None) -> None:
+        super(LogFormatter, self).__init__(fmt, datefmt)
+
+    def fileLines(self, record: logging.LogRecord) -> str:
+        # provide a file parameter made up from refs entries
+        return logRefsFileLines(getattr(record, "refs", []))
+
+    def format(self, record: logging.LogRecord) -> str:
+        record.file = self.fileLines(record)
+        try:
+            formattedMessage = super(LogFormatter, self).format(record)
+        except (KeyError, TypeError, ValueError) as ex:
+            formattedMessage = "Message: "
+            if getattr(record, "messageCode", ""):
+                formattedMessage += "[{0}] ".format(getattr(record, "messageCode", ""))
+            if getattr(record, "msg", ""):
+                formattedMessage += record.msg + " "
+            if isinstance(record.args, dict) and 'error' in record.args: # args may be list or empty
+                formattedMessage += record.args['error']
+            formattedMessage += " \nMessage log error: " + str(ex)
+        if hasattr(record, "file"):
+            delattr(record, "file")
+        return formattedMessage
+
+
+def logRefsFileLines(refs: list[dict[str, Any]]) -> str:
+    fileLines = defaultdict(set)
+    for ref in refs:
+        href = ref.get("href")
+        if href:
+            hrefWithoutFakeIxdsPrefix = href.rpartition("_IXDS#?#")[2]
+            fileLines[hrefWithoutFakeIxdsPrefix.partition("#")[0]].add(ref.get("sourceLine") or 0)
+    return ", ".join(file + " " + ', '.join(str(line)
+                                            for line in sorted(lines, key=lambda l: l)
+                                            if line)
+                     for file, lines in sorted(fileLines.items()))

arelle/logging/handlers/LogHandlerWithXml.py

@@ -0,0 +1,94 @@
+"""
+See COPYRIGHT.md for copyright information.
+"""
+from __future__ import annotations
+
+import logging
+from collections.abc import Mapping
+from typing import Any
+
+DEFAULT_JSON_MAX_ATTRIBUTE_LENGTH = 4096000
+DEFAULT_XML_MAX_ATTRIBUTE_LENGTH = 128
+
+class LogHandlerWithXml(logging.Handler):
+    logTextMaxLength: int
+
+    def __init__(self, logXmlMaxAttributeLength: int | None = None ) -> None:
+        super(LogHandlerWithXml, self).__init__()
+        self.logJsonMaxAttributeLength = logXmlMaxAttributeLength or DEFAULT_JSON_MAX_ATTRIBUTE_LENGTH
+        self.logXmlMaxAttributeLength = logXmlMaxAttributeLength or DEFAULT_XML_MAX_ATTRIBUTE_LENGTH
+
+    def recordToXml(self, logRec: logging.LogRecord) -> str:
+        def entityEncode(arg: Any, truncateAt: int = self.logTextMaxLength) -> str:  # be sure it's a string, vs int, etc, and encode &, <, ".
+            s = str(arg)
+            s = s if len(s) <= truncateAt else s[:truncateAt] + '...'
+            return s.replace("&","&amp;").replace("<","&lt;").replace('"','&quot;')
+
+        def ncNameEncode(arg: str) -> str:
+            s = []
+            for c in arg:
+                if c.isalnum() or c in ('.','-','_'):
+                    s.append(c)
+                else: # covers : and any other non-allowed character
+                    s.append('_') # change : into _ for xml correctness
+            return "".join(s)
+
+        def propElts(properties: list[tuple[Any, Any, Any]], indent: str, truncateAt: int = 128) -> str:
+            nestedIndent = indent + ' '
+            return indent.join('<property name="{0}" value="{1}"{2}>'.format(
+                entityEncode(p[0]),
+                entityEncode(p[1], truncateAt=truncateAt),
+                '/' if len(p) == 2
+                else '>' + nestedIndent + propElts(p[2],nestedIndent) + indent + '</property')
+                               for p in properties
+                               if 2 <= len(p) <= 3)
+
+        msg = self.format(logRec)
+        if logRec.args and isinstance(logRec.args, Mapping):
+            args = "".join([' {0}="{1}"'.format(
+                ncNameEncode(n), entityEncode(v, truncateAt=(self.logJsonMaxAttributeLength if n == "json" else self.logXmlMaxAttributeLength))
+            )
+                            for n, v in logRec.args.items()])
+        else:
+            args = ""
+        refs = "\n ".join('\n <ref href="{0}"{1}{2}{3}>'.format(
+            entityEncode(ref["href"]),
+            ' sourceLine="{0}"'.format(ref["sourceLine"]) if "sourceLine" in ref else '',
+            ''.join(' {}="{}"'.format(ncNameEncode(k),entityEncode(v))
+                    for k,v in ref["customAttributes"].items())
+            if 'customAttributes' in ref else '',
+            (">\n  " + propElts(ref["properties"],"\n  ", truncateAt=self.logTextMaxLength) + "\n </ref" )
+            if ("properties" in ref) else '/')
+                          for ref in getattr(logRec, "refs", []))
+        return ('<entry code="{0}" level="{1}">'
+                '\n <message{2}>{3}</message>{4}'
+                '</entry>\n'.format(getattr(logRec, "messageCode", ""),
+                                    logRec.levelname.lower(),
+                                    args,
+                                    entityEncode(msg),
+                                    refs))
+    def recordToJson(self, logRec: logging.LogRecord) -> dict[str, Any]:
+        message = {
+            "text": self.format(logRec),
+            "args": self._buildJsonMessageArgs(logRec),
+        }
+        return {"code": getattr(logRec, "messageCode", ""),
+                "level": logRec.levelname.lower(),
+                "refs": getattr(logRec, "refs", []),
+                "message": message}
+
+    def _buildJsonMessageArgs(self, logRec: logging.LogRecord) -> dict[str, Any]:
+        if logRec.args and isinstance(logRec.args, Mapping):
+            return {
+                n: str(v)
+                for n, v in logRec.args.items()
+            }
+        return {}
+
+    def recordToHtml(self, logRec: logging.LogRecord) -> str:
+        record = ["<tr>"]
+        record.append(f"<td>{getattr(logRec, 'messageCode', '')}</td>")
+        record.append(f"<td>{logRec.levelname.lower()}</td>")
+        record.append(f"<td>{self.format(logRec)}</td>")
+        record.append("</tr>")
+        return "\n".join(record)

arelle/logging/handlers/LogToBufferHandler.py

@@ -0,0 +1,20 @@
+"""
+See COPYRIGHT.md for copyright information.
+"""
+from __future__ import annotations
+
+from arelle.logging.handlers.LogToXmlHandler import LogToXmlHandler
+
+
+class LogToBufferHandler(LogToXmlHandler):
+    """
+    .. class:: LogToBufferHandler()
+
+    A log handler that writes log entries to a memory buffer for later retrieval (to a string) in XML, JSON, or text lines,
+    usually for return to a web service or web page call.
+    """
+    def __init__(self) -> None:
+        super(LogToBufferHandler, self).__init__()
+
+    def flush(self) -> None:
+        pass # do nothing -- overrides LogToXmlHandler's flush

arelle/logging/handlers/LogToPrintHandler.py

@@ -0,0 +1,41 @@
+"""
+See COPYRIGHT.md for copyright information.
+"""
+from __future__ import annotations
+
+import logging
+import sys
+from typing import TextIO
+
+
+class LogToPrintHandler(logging.Handler):
+    """
+    .. class:: LogToPrintHandler()
+
+    A log handler that emits log entries to standard out as they are logged.
+
+    CAUTION: Output is utf-8 encoded, which is fine for saving to files, but may not display correctly in terminal windows.
+
+    :param logOutput: 'logToStdErr' to cause log print to stderr instead of stdout
+    :type logOutput: str
+    """
+    logFile: str | TextIO | None
+
+    def __init__(self, logOutput: str) -> None:
+        super(LogToPrintHandler, self).__init__()
+        if logOutput == "logToStdErr":
+            self.logFile = sys.stderr
+        else:
+            self.logFile = None
+
+    def emit(self, logRecord: logging.LogRecord) -> None:
+        file = sys.stderr if self.logFile else None
+        logEntry = self.format(logRecord)
+        try:
+            print(logEntry, file=file)
+        except UnicodeEncodeError:
+            # extra parentheses in print to allow for 3-to-2 conversion
+            print((logEntry
+                   .encode(sys.stdout.encoding, 'backslashreplace')
+                   .decode(sys.stdout.encoding, 'strict')),
+                  file=file)