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

arelle/CntlrWebMain.py

@@ -1,37 +1,78 @@
 '''
-Use this module to start Arelle in web server mode
+Use this module to start Arelle in web server mode.
 
 See COPYRIGHT.md for copyright information.
-
 '''
-from arelle.webserver.bottle import Bottle, request, response, static_file
-from arelle.Cntlr import LogFormatter
-import os, io, sys, time, threading, uuid, zipfile
+from __future__ import annotations
+
+import io
+import os
+import sys
+import threading
+import time
+import uuid
+import zipfile
+from collections.abc import Iterable
+from copy import deepcopy
+
+from bottle import Bottle, HTTPResponse, request, response, static_file  # type: ignore[import-untyped]
+
 from arelle import Version
-from arelle.FileSource import FileNamedStringIO
+from arelle.CntlrCmdLine import CntlrCmdLine
+from arelle.FileSource import FileNamedBytesIO, FileNamedStringIO
+from arelle.logging.formatters.LogFormatter import LogFormatter
+from arelle.logging.handlers.LogToBufferHandler import LogToBufferHandler
 from arelle.PluginManager import pluginClassMethods
-from arelle.PythonUtil import STR_NUM_TYPES
+from arelle.RuntimeOptions import RuntimeOptions
+from arelle.typing import TypeGetText
+
+_: TypeGetText
+
+# Variable is imported but not used by ferc renderer plugin.
+# RuntimeOptions should be imported by plugins instead.
+Options = None
+
 _os_pid = os.getpid()
 
 GETorPOST = ('GET', 'POST')
 GET = 'GET'
 POST = 'POST'
 
-def startWebserver(_cntlr, options):
-    """Called once from main program in CmtlrCmdLine to initiate web server on specified local port.
-    To test WebServer run from source in IIS, use an entry like this: c:\python33\python.exe c:\\users\\myname\\mySourceFolder\\arelleCmdLine.py %s
+_CNTLR: CntlrCmdLine | None = None
+
+def getCntlr() -> CntlrCmdLine:
+    if _CNTLR is None:
+        raise ValueError(_('_CNTLR accessed before it was set.'))
+    return _CNTLR
+
+def setCntlr(cntlr: CntlrCmdLine) -> None:
+    global _CNTLR
+    _CNTLR = cntlr
+
+def getLogHandler() -> LogToBufferHandler:
+    cntlr = getCntlr()
+    if isinstance(cntlr.logHandler, LogToBufferHandler):
+        return cntlr.logHandler
+    raise ValueError(_('webserver requires log to buffer.'))
+
+_RUNTIME_OPTIONS: RuntimeOptions | None = None
 
-    :param options: OptionParser options from parse_args of main argv arguments (the argument *webserver* provides hostname and port), port being used to startup the webserver on localhost.
-    :type options: optparse.Values
+def getRuntimeOptions() -> RuntimeOptions:
+    if _RUNTIME_OPTIONS is None:
+        raise ValueError(_('_RUNTIME_OPTIONS accessed before it was set.'))
+    options = deepcopy(_RUNTIME_OPTIONS)
+    return options
+
+def setRuntimeOptions(runtimeOptions: RuntimeOptions) -> None:
+    global _RUNTIME_OPTIONS
+    _RUNTIME_OPTIONS = deepcopy(runtimeOptions)
+
+def startWebserver(cntlr: CntlrCmdLine, options: RuntimeOptions) -> Bottle | None:
+    """Called once from main program in CmtlrCmdLine to initiate web server on specified local port.
     """
-    global imagesDir, cntlr, optionsPrototype
-    cntlr = _cntlr
-    imagesDir = cntlr.imagesDir
-    optionValuesTypes = STR_NUM_TYPES + (type(None),)
-    optionsPrototype = dict((option,value if isinstance(value, STR_NUM_TYPES) else None)
-                            for option in dir(options)
-                            for value in (getattr(options, option),)
-                            if isinstance(value,optionValuesTypes) and not option.startswith('_'))
+    setCntlr(cntlr)
+    setRuntimeOptions(options)
+    assert options.webserver is not None
     host, sep, portServer = options.webserver.partition(":")
     port, sep, server = portServer.partition(":")
     # start a Bottle application
@@ -102,8 +143,9 @@ def startWebserver(_cntlr, options):
             app.run(host=host, port=port or 80, server=server)
         else:
             app.run(host=host, port=port or 80)
+    return None
 
-def cgiInterface(cgiAppPath):
+def cgiInterface(cgiAppPath: str) -> str | HTTPResponse:
     # route request according to content
     #with open(r"c:\temp\tracecgi.log", "at", encoding="utf-8") as fh:
     #    fh.write("trace 2 arg={}\n".format(cgiAppPath))
@@ -119,7 +161,7 @@ def cgiInterface(cgiAppPath):
         return indexPageCGI()
 
 
-def login_form():
+def login_form() -> str:
     """Request for a login form (get to */rest/login*).  Corresponds to login from other providers of XBRL validation services, but
     this version of Arelle does not perform accounting or charges for validation requests, so the login is ignored.
 
@@ -131,7 +173,7 @@ def login_form():
                 <tr><td>&nbsp;</td><td><input type="submit" value="Submit" /></td></tr>
                 </table></form></body></html>''')
 
-def login_submit():
+def login_submit() -> str:
     """Login of fields from login form (post to */rest/login*).  Saves user ID for future use.
 
     :param name: User ID
@@ -144,7 +186,9 @@ def login_submit():
     else:
         return _("<p>Login failed</p>")
 
-def checkLogin(_user, _password):
+user: str | None = None
+
+def checkLogin(_user: str | None, _password: str | None) -> bool:
     """Save user ID for future use.  Password not currently processed.
 
     :returns: bool -- True (for now, future user may interact with authentication and accounting services.)
@@ -153,7 +197,7 @@ def checkLogin(_user, _password):
     user = _user
     return True
 
-def logout():
+def logout() -> str:
     """Request to log out (get */rest/logout*).  Removes any proior user ID from session.
 
     :returns: html -- Message that user has logged out
@@ -162,19 +206,21 @@ def logout():
     user = None
     return _("<p>You are logged out.</p>")
 
-def arelleIcon():
+def arelleIcon() -> HTTPResponse:
     """Request for icon for URL display (get */favicon.ico*).
 
     :returns: ico -- Icon file for browsers
     """
-    return static_file("arelle.ico", root=imagesDir, mimetype='image/vnd.microsoft.icon')
+    cntlr = getCntlr()
+    return static_file("arelle.ico", root=cntlr.imagesDir, mimetype='image/vnd.microsoft.icon')
 
-def image(imgFile):
+def image(imgFile: str) -> HTTPResponse:
     """Request for an image file for URL display (get */images/<imgFile>*).
 
     :returns: image file -- Requested image file from images directory of application for browsers
     """
-    return static_file(imgFile, root=imagesDir)
+    cntlr = getCntlr()
+    return static_file(imgFile, root=cntlr.imagesDir)
 
 validationOptions = {
     # these options have no value (after + in query)
@@ -185,8 +231,9 @@ validationOptions = {
     "esef": ("disclosureSystemName", "esef"),
     "disclosure-system": ("disclosureSystemName", None),
     "ifrs": ("gfmName", "ifrs"),
-    "hmrc": ("gfmName", "hmrc"),
+    "hmrc": ("gfmName", "uk"),
     "sbr-nl": ("gfmName", "sbr-nl"),
+    "uk": ("gfmName", "uk"),
     "utr": ("utrValidate", True),
     "infoset": ("infosetValidate", True),
     # these parameters pass through the value after + in query
@@ -200,15 +247,9 @@ validationKeyVarName = {
     "arcroleTypes": "arcroleTypesFile"
     }
 
-class Options():
-    """Class to emulate options needed by CntlrCmdLine.run"""
-    def __init__(self):
-        for option, defaultValue in optionsPrototype.items():
-            setattr(self, option, defaultValue)
-
 supportedViews = {'DTS', 'concepts', 'pre', 'table', 'cal', 'dim', 'facts', 'factTable', 'formulae', 'roleTypes', 'arcroleTypes'}
 
-def validation(file=None):
+def validation(file: str | None = None) -> str | bytes:
     """REST request to validate, by *get* or *post*, to URL patterns including */rest/xbrl/<file:path>/{open|close|validation|DTS...}*,
     and */rest/xbrl/{view|open|close}*.
     Sets up CntrlCmdLine options for request, performed by runOptionsAndGetResult using CntlrCmdLine.run with get or post arguments.
@@ -222,20 +263,18 @@ def validation(file=None):
     isValidation = 'validation' == requestPathParts[-1] or 'validation' == requestPathParts[-2]
     view = request.query.view
     viewArcrole = request.query.viewArcrole
+    sourceZipStream = None
     if request.method == 'POST':
         mimeType = request.get_header("Content-Type")
-        if mimeType.startswith("multipart/form-data"):
-            _upload = request.files.get("upload")
-            if not _upload or not _upload.filename.endswith(".zip"):
-                errors.append(_("POST file upload must be a zip file"))
-                sourceZipStream = None
+        if mimeType and mimeType.startswith("multipart/form-data"):
+            if upload := request.files.get("upload"):
+                sourceZipStream = FileNamedBytesIO(upload.filename, upload.file.read())
             else:
-                sourceZipStream = _upload.file
-        elif mimeType not in ('application/zip', 'application/x-zip', 'application/x-zip-compressed', 'multipart/x-zip'):
-            errors.append(_("POST must provide a zip file, Content-Type '{0}' not recognized as a zip file.").format(mimeType))
-        sourceZipStream = request.body
-    else:
-        sourceZipStream = None
+                errors.append(_("POST 'multipart/form-data' request must include 'upload' part containing the XBRL file to process."))
+        elif mimeType in ('application/zip', 'application/x-zip', 'application/x-zip-compressed', 'multipart/x-zip'):
+            sourceZipStream = FileNamedBytesIO(request.get_header("X-File-Name"), request.body.read())
+        else:
+            errors.append(_("POST request must provide an XBRL zip file to process. Content-Type '{0}' not recognized as a zip file.").format(mimeType))
     if not view and not viewArcrole:
         if requestPathParts[-1] in supportedViews:
             view = requestPathParts[-1]
@@ -257,22 +296,22 @@ def validation(file=None):
     if errors:
         errors.insert(0, _("URL: ") + (file or request.query.file or '(no file)'))
         return errorReport(errors, media)
-    options = Options() # need named parameters to simulate options
+    options = getRuntimeOptions()
     isFormulaOnly = False
     for key, value in request.query.items():
         if key == "file":
-            setattr(options, "entrypointFile", value)
+            options.entrypointFile = value
         elif key == "flavor":
             if value.startswith("sec") or value.startswith("edgar"):
-                setattr(options, "validateEFM", True)
+                options.validateEFM = True
             elif value == "formula-compile-only":
                 isFormulaOnly = True
-                setattr(options, "formulaAction", "validate")
+                options.formulaAction = "validate"
             elif value == "formula-compile-and-run":
                 isFormulaOnly = True
-                setattr(options, "formulaAction", "run")
+                options.formulaAction = "run"
             elif value == "standard-except-formula":
-                setattr(options, "formulaAction", "none")
+                options.formulaAction = "none"
         elif key in("media", "view", "viewArcrole"):
             pass
         elif key in validationOptions:
@@ -280,27 +319,41 @@ def validation(file=None):
             setattr(options, optionKey, optionValue if optionValue is not None else value)
         elif key in validationKeyVarName:
             setattr(options, validationKeyVarName[key], value or True)
+        elif key == "calc":
+            # common support issue.
+            options.calcs = value
+        elif key == "packages":
+            packages = value.split('|')
+            if options.packages:
+                options.packages.extend(packages)
+            else:
+                options.packages = packages
         elif not value: # convert plain str parameter present to True parameter
             setattr(options, key, True)
         else:
             setattr(options, key, value)
     if file:
-        setattr(options, "entrypointFile", file.replace(';','/'))
+        options.entrypointFile = file.replace(';','/')
     requestPathParts = set(request.urlparts[2].split('/'))
     viewFile = None
     if isValidation:
         if not isFormulaOnly:
-            setattr(options, "validate", True)
+            options.validate = True
     elif view:
         viewFile = FileNamedStringIO(media)
         setattr(options, view + "File", viewFile)
     elif viewArcrole:
         viewFile = FileNamedStringIO(media)
-        setattr(options, "viewArcrole", viewArcrole)
-        setattr(options, "viewFile", viewFile)
+        options.viewArcrole = viewArcrole
+        options.viewFile = viewFile
     return runOptionsAndGetResult(options, media, viewFile, sourceZipStream)
 
-def runOptionsAndGetResult(options, media, viewFile, sourceZipStream=None):
+def runOptionsAndGetResult(
+        options: RuntimeOptions,
+        media: str,
+        viewFile: FileNamedStringIO | None,
+        sourceZipStream: FileNamedBytesIO | None = None,
+        ) -> str | bytes:
     """Execute request according to options, for result in media, with *post*ed file in sourceZipStream, if any.
 
     :returns: html, xml, csv, text -- Return per media type argument and request arguments
@@ -309,12 +362,10 @@ def runOptionsAndGetResult(options, media, viewFile, sourceZipStream=None):
     if media == "zip" and not viewFile:
         responseZipStream = io.BytesIO()
         # add any needed plugins to load from OIM or save into OIM
-        if (hasattr(options, "saveOIMinstance") or
-            (getattr(options, "entrypointFile", "") or "").rpartition(".")[2] in ("json", "csv", "xlsx")):
-            plugins = (getattr(options, "plugins", "") or "").split("|")
-            if getattr(options, "entrypointFile", "").rpartition(".")[2] in ("json", "csv", "xlsx"):
-                if "loadFromOIM" not in plugins:
-                    plugins.append("loadFromOIM")
+        entryIsOIM = (options.entrypointFile or "").rpartition(".")[2] in ("json", "csv", "xlsx")
+        if hasattr(options, "saveOIMinstance") or entryIsOIM:
+            plugins = options.plugins.split("|") if options.plugins else []
+            if entryIsOIM:
                 addLogToZip = True
             if getattr(options, "saveOIMinstance", "").rpartition(".")[2] in ("json", "csv", "xlsx"):
                 if "saveLoadableOIM" not in plugins:
@@ -322,9 +373,10 @@ def runOptionsAndGetResult(options, media, viewFile, sourceZipStream=None):
                 addLogToZip = True
                 setattr(options, "saveLoadableOIM", getattr(options, "saveOIMinstance"))
                 setattr(options, "saveOIMinstance", None) # this parameter is for saving xBRL-XML when loaded from JSON/CSV
-            setattr(options, "plugins", "|".join(p for p in plugins if p) or None) # ignore empty string plugin names
+            options.plugins = "|".join(p for p in plugins if p) or None # ignore empty string plugin names
     else:
         responseZipStream = None
+    cntlr = getCntlr()
     successful = cntlr.run(options, sourceZipStream, responseZipStream)
     if media == "xml":
         response.content_type = 'text/xml; charset=UTF-8'
@@ -338,80 +390,83 @@ def runOptionsAndGetResult(options, media, viewFile, sourceZipStream=None):
         response.content_type = 'application/zip; charset=UTF-8'
     else:
         response.content_type = 'text/html; charset=UTF-8'
+    logHandler = getLogHandler()
+    result: bytes | str
     if successful and viewFile:
         # defeat re-encoding
         result = viewFile.getvalue().replace("&nbsp;","\u00A0").replace("&shy;","\u00AD").replace("&amp;","&")
         viewFile.close()
     elif media == "zip":
+        assert responseZipStream is not None
         responseZipStream.seek(0)
         if addLogToZip:
-            _zip = zipfile.ZipFile(responseZipStream, "a", zipfile.ZIP_DEFLATED, True)
-            _zip.writestr("log.txt", cntlr.logHandler.getText())
-            _zip.close()
+            with zipfile.ZipFile(responseZipStream, "a", zipfile.ZIP_DEFLATED, True) as _zip:
+                _zip.writestr("log.txt", logHandler.getText())
             responseZipStream.seek(0)
         result = responseZipStream.read()
         responseZipStream.close()
-        cntlr.logHandler.clearLogBuffer() # zip response file may contain non-cleared log entries
+        logHandler.clearLogBuffer() # zip response file may contain non-cleared log entries
     elif media == "xml":
-        result = cntlr.logHandler.getXml()
+        result = logHandler.getXml()
     elif media == "json":
-        result = cntlr.logHandler.getJson()
+        result = logHandler.getJson()
     elif media == "text":
         _logFormat = request.query.logFormat
         if _logFormat:
-            _stdLogFormatter = cntlr.logHandler.formatter
-            cntlr.logHandler.formatter = LogFormatter(_logFormat)
-        result = cntlr.logHandler.getText()
+            _stdLogFormatter = logHandler.formatter
+            logHandler.formatter = LogFormatter(_logFormat)
+        result = logHandler.getText()
         if _logFormat:
-            cntlr.logHandler.formatter = _stdLogFormatter
+            logHandler.formatter = _stdLogFormatter
             del _stdLogFormatter # dereference
     else:
-        result = htmlBody(tableRows(cntlr.logHandler.getLines(), header=_("Messages")))
+        result = htmlBody(tableRows(logHandler.getLines(), header=_("Messages")))
     return result
 
-def diff():
+def diff() -> str:
     """Execute versioning diff request for *get* request to */rest/xbrl/diff*.
 
     :returns: xml -- Versioning report.
     """
     if not request.query.fromDTS or not request.query.toDTS or not request.query.report:
         return _("From DTS, to DTS, and report must be specified")
-    options = Options()
-    setattr(options, "entrypointFile", request.query.fromDTS)
-    setattr(options, "diffFile", request.query.toDTS)
-    fh = FileNamedStringIO(request.query.report)
-    setattr(options, "versReportFile", fh)
-    cntlr.run(options)
-    reportContents = fh.getvalue()
-    fh.close()
+    options = getRuntimeOptions()
+    options.entrypointFile = request.query.fromDTS
+    options.diffFile = request.query.toDTS
+    with FileNamedStringIO(request.query.report) as fh:
+        options.versReportFile = fh
+        getCntlr().run(options)
+        reportContents = fh.getvalue()
     response.content_type = 'text/xml; charset=UTF-8'
     return reportContents
 
-def configure():
+def configure() -> str:
     """Set up features for *get* requests to */rest/configure*, e.g., proxy or plug-ins.
 
     :returns: html -- Status of configuration request (e.g., proxy or plug-ins).
     """
     if not request.query.proxy and not request.query.plugins and not request.query.packages and 'environment' not in request.query:
         return _("proxy, plugins, packages or environment must be specified")
-    options = Options()
+    options = getRuntimeOptions()
     if request.query.proxy:
-        setattr(options, "proxy", request.query.proxy)
+        options.proxy = request.query.proxy
     if request.query.plugins:
-        setattr(options, "plugins", request.query.plugins)
+        options.plugins = request.query.plugins
     if request.query.packages:
-        setattr(options, "packages", request.query.packages)
+        options.packages = request.query.packages.split('|')
+    setRuntimeOptions(options)
     if 'environment' in request.query:
-        setattr(options, "showEnvironment", True)
+        options.showEnvironment = True
+    cntlr = getCntlr()
     cntlr.run(options)
     response.content_type = 'text/html; charset=UTF-8'
-    return htmlBody(tableRows(cntlr.logHandler.getLines(), header=_("Configuration Request")))
+    logHandler = getLogHandler()
+    return htmlBody(tableRows(logHandler.getLines(), header=_("Configuration Request")))
 
-def stopWebServer():
+def stopWebServer() -> str:
     """Stop the web server by *get* requests to */rest/stopWebServer*.
-
     """
-    def stopSoon(delaySeconds):
+    def stopSoon(delaySeconds: float) -> None:
         time.sleep(delaySeconds)
         import signal
         os.kill(_os_pid, signal.SIGTERM)
@@ -421,29 +476,30 @@ def stopWebServer():
                                "Good bye...",),
                               header=_("Stop Request")))
 
-def testTest():
+def testTest() -> str:
     return "Results attached:\n" + multipartResponse((
         ("file1", "text/plain", "test text 1"),
         ("file2", "text/plain", "test text 2"),
         ("file3", "text/plain", "test text 3"),
         ))
 
-def quickbooksServer():
+def quickbooksServer() -> str:
     """Interface to QuickBooks server responding to  *post* requests to */quickbooks/server.asmx*.
 
     (Part of QuickBooks protocol, see module CntlrQuickBooks.)
     """
     from arelle import CntlrQuickBooks
     response.content_type = 'text/xml; charset=UTF-8'
+    cntlr = getCntlr()
     return CntlrQuickBooks.server(cntlr, request.body, request.urlparts)
 
 
-def quickbooksGLrequest(qbReport=None, file=None):
+def quickbooksGLrequest(qbReport: str | None = None, file: str | None = None) -> str:
     """Initiate request to QuickBooks server for *get* requests to */rest/quickbooks/<qbReport>/xbrl-gl/...*.
 
     :returns: html, xml, csv, text -- Return per media type argument and request arguments
     """
-    from arelle.CntlrQuickBooks import supportedQbReports, qbRequest
+    from arelle.CntlrQuickBooks import qbRequest, supportedQbReports
     from arelle.ModelValue import dateTime
     errors = []
     requestPathParts = request.urlparts[2].split('/')
@@ -473,7 +529,7 @@ function autoRefresh(){{location.href = "/rest/quickbooks/response?ticket={0}&me
 '''.format(ticket, media, viewRequested))
     return result
 
-def quickbooksGLresponse():
+def quickbooksGLresponse() -> str | bytes:
     """Poll for QuickBooks protocol responses for *get* requests to */rest/quickbooks/response*.
 
     :returns: html, xml, csv, text -- Return per media type argument and request arguments, if response is ready, otherwise javascript to requery this *get* request periodicially.
@@ -503,20 +559,20 @@ function autoRefresh(){{clearInterval(timer);self.location.reload(true);}}
 
     instanceUuid = CntlrQuickBooks.xbrlInstances[ticket]
     CntlrQuickBooks.xbrlInstances.pop(ticket)
-    options = Options()
-    setattr(options, "entrypointFile", instanceUuid)
+    options = getRuntimeOptions()
+    options.entrypointFile = instanceUuid
     viewFile = FileNamedStringIO(media)
-    setattr(options, "factsFile", viewFile)
+    options.factsFile = viewFile
     return runOptionsAndGetResult(options, media, viewFile)
 
-def quickbooksWebPage():
+def quickbooksWebPage() -> str:
     return htmlBody(_('''<table width="700p">
 <tr><th colspan="2">Arelle QuickBooks Global Ledger Interface</th></tr>
 <tr><td>checkbox</td><td>Trial Balance.</td></tr>
 <tr><td>close button</td><td>Done</td></tr>
 </table>'''))
 
-def localhostCertificate():
+def localhostCertificate() -> str:
     """Interface to QuickBooks server responding to  *get* requests for a host certificate */quickbooks/localhost.crt* or */localhost.crt*.
 
     (Supports QuickBooks protocol.)
@@ -548,11 +604,12 @@ QhpLdqly7hWJ23blbQQv4ILT2CiPDotJslcKDT7GzvPoDu6rIs2MpsB/4RDYejYU
 -----END CERTIFICATE-----
 '''
 
-def helpREST():
+def helpREST() -> str:
     """Help web page for *get* requests to */help*.
 
     :returns: html - Table of CntlrWebMain web API
     """
+    cntlr = getCntlr()
     return htmlBody(_('''<table>
 <tr><th colspan="2">Arelle web API</th></tr>
 <tr><td>/help</td><td>This web page.</td></tr>
@@ -582,7 +639,7 @@ document at c:/a/b/c.xbrl (on local drive) and return structured xml results.</t
 <tr><td style="text-align=right;">Example:</td><td><code>/rest/xbrl/validation?file=c:/a/b/c.xbrl&amp;media=xml</code>: Validate entry instance
 document at c:/a/b/c.xbrl (on local drive) and return structured xml results.</td></tr>
 ''')) +
-_('''
+_(r'''
 <tr><td></td><td>Parameters are optional after "?" character, and are separated by "&amp;" characters,
 as follows:</td></tr>
 <tr><td style="text-indent: 1em;">flavor</td><td><code>standard</code>: XBRL 2.1 and XDT validation.  (If formulas are present they will also be compiled and run.)  (default)
@@ -593,14 +650,15 @@ as follows:</td></tr>
 <tr><td style="text-indent: 1em;">media</td><td><code>html</code> or <code>xhtml</code>: Html text results. (default)
 <br/><code>xml</code>: XML structured results.
 <br/><code>json</code>: JSON results.
-<br/><code>text</code>: Plain text results (no markup).</td></tr>
+<br/><code>text</code>: Plain text results (no markup).
+<br/><code>zip</code>: Zip results (for multi-file results, such as from EDGAR/render).</td></tr>
 <tr><td style="text-indent: 1em;">file</td><td>Alternate way to specify file name or url by a parameter.  Files ending in .json will be loaded as xBRL-JSON.</td></tr>
 <tr><td style="text-indent: 1em;">import</td><td>A list of files to import to the DTS, such as additional formula
 or label linkbases.  Multiple file names are separated by a '|' character.</td></tr>
 <tr><td style="text-indent: 1em;">labelLang</td><td>Label language to override system settings, e.g., <code>&labelLang=ja</code>.</td></tr>
 <tr><td style="text-indent: 1em;">labelRole</td><td>Label role instead of standard label, e.g., <code>&labelRole=http://www.xbrl.org/2003/role/verboseLabel</code>.  To use the concept QName instead of a label, specify <code>&labelRole=XBRL-concept-name</code>.</td></tr>
 <tr><td style="text-indent: 1em;">uiLang</td><td>User interface language to override system settings, e.g., <code>&uiLang=fr</code>.  Changes setting for current session (but not saved setting).</td></tr>
-<tr><td style="text-indent: 1em;">calc</td><td>Specify calculation validation:<br/>
+<tr><td style="text-indent: 1em;">calcs</td><td>Specify calculation validation:<br/>
 <code>c10</code> or <code>xbrl21</code>: Calc 1.0 (XBRL 2.1) calculations<br/>
 <code>c10d</code> or <code>xbrl21-dedup</code>: Calc 1.0 (XBRL 2.1) calculations<br/>
 <code>c11r</code> or <code>round-to-nearest</code>: Calc 1.1 round-to-nearest mode<br/>
@@ -644,8 +702,8 @@ as follows:</td></tr>
 
 <tr><th colspan="2">Views</th></tr>
 <tr><td>/rest/xbrl/{file}/{view}</td><td>View document at {file}.</td></tr>
-<tr><td>\u00A0</td><td>{file} may be local or web url, and may have "/" characters replaced by ";" characters (but that is not necessary).</td></tr>
-<tr><td>\u00A0</td><td>{view} may be <code>DTS</code>, <code>concepts</code>, <code>pre</code>, <code>table</code>, <code>cal</code>, <code>dim</code>, <code>facts</code>, <code>factTable</code>, <code>formulae</code>, <code>roleTypes</code>, or <code>arcroleTypes</code>.</td></tr>
+<tr><td>&nbsp;</td><td>{file} may be local or web url, and may have "/" characters replaced by ";" characters (but that is not necessary).</td></tr>
+<tr><td>&nbsp;</td><td>{view} may be <code>DTS</code>, <code>concepts</code>, <code>pre</code>, <code>table</code>, <code>cal</code>, <code>dim</code>, <code>facts</code>, <code>factTable</code>, <code>formulae</code>, <code>roleTypes</code>, or <code>arcroleTypes</code>.</td></tr>
 <tr><td style="text-align=right;">Example:</td><td><code>/rest/xbrl/c:/a/b/c.xbrl/dim?media=html</code>: View dimensions of
 document at c:/a/b/c.xbrl (on local drive) and return html result.</td></tr>
 <tr><td>/rest/xbrl/view</td><td>(Alternative syntax) View document, file and view are provided as parameters (see below).</td></tr>
@@ -747,12 +805,13 @@ Enter 'show' to view packages configuration, , or '|' separated package URLs:
 ''') if cntlr.isGAE else '') +
 '</table>')
 
-def about(arelleImgFile=None):
+def about(arelleImgFile: str | None = None) -> str:
     from lxml import etree
     """About web page for *get* requests to */about*.
 
     :returns: html - About web page
     """
+    cntlr = getCntlr()
     return htmlBody(_('''<table width="700p">
 <tr><th colspan="2">About arelle</th></tr>
 <tr><td rowspan="12" style="vertical-align:top;"><img src="%s"/></td><td>arelle&reg; %s (%sbit). An open source XBRL platform</td></tr>
@@ -775,7 +834,7 @@ See the License for the specific language governing permissions and limitations
                 sys.version_info[0],sys.version_info[1],sys.version_info[2],
                 etree.LXML_VERSION[0],etree.LXML_VERSION[1],etree.LXML_VERSION[2]) )
 
-def indexPageREST():
+def indexPageREST() -> str:
     """Index (default) web page for *get* requests to */*.
 
     :returns: html - Web page of choices to navigate to */help* or */about*.
@@ -786,7 +845,7 @@ def indexPageREST():
 <tr><td>/about</td><td>About web page, copyrights, license, included software.</td></tr>
 </table>'''))
 
-def indexPageCGI():
+def indexPageCGI() -> str:
     """Default web page response for *get* CGI request with no parameters.
 
     :returns: html - Web page of choices to navigate to *?help* or *?about*.
@@ -799,7 +858,7 @@ def indexPageCGI():
 </table>'''))
 
 
-def htmlBody(body, script=""):
+def htmlBody(body: str, script: str = "") -> str:
     """Wraps body html string in a css-styled html web page
 
     :param body: Contents for the *<body>* element
@@ -808,6 +867,7 @@ def htmlBody(body, script=""):
     :type script: javascript str
     :returns: html - Web page of choices to navigate to */help* or */about*.
     """
+    cntlr = getCntlr()
     return '''
 <?xml version="1.0" encoding="utf-8"?>
 <html xmlns="http://www.w3.org/1999/xhtml" dir="%s">
@@ -828,7 +888,7 @@ def htmlBody(body, script=""):
 </html>
 ''' % (cntlr.uiLangDir, script, body)
 
-def tableRows(lines, header=None):
+def tableRows(lines: Iterable[str], header: str | None = None) -> str:
     """Wraps lines of text into a one-column table (for display of text results of operations, such as processing messages and status, to web browser).
     Replaces any *&* with *&amp;* and *<* with *&lt;*.
 
@@ -842,7 +902,7 @@ def tableRows(lines, header=None):
             ("<tr><th>%s</th></tr>" % header if header else "") +
             "\n".join("<tr><td>%s</td></tr>" % line.replace("&","&amp;").replace("<","&lt;") for line in lines))
 
-def errorReport(errors, media="html"):
+def errorReport(errors: list[str], media: str = "html") -> str:
     """Wraps lines of error text into specified media type for return of result to a request.
 
     :param errors: Sequence (list or tuple) of error strings.
@@ -858,7 +918,7 @@ def errorReport(errors, media="html"):
         response.content_type = 'text/html; charset=UTF-8'
         return htmlBody(tableRows(errors, header=_("Messages")))
 
-def multipartResponse(parts):
+def multipartResponse(parts: tuple[tuple[str, str, str], ...]) -> str:
     # call with ( (filename, contentType, content), ...)
     boundary='----multipart-boundary-%s----' % (uuid.uuid1(),)
     response.content_type = 'multipart/mixed; boundary=%s' % (boundary,)