ixbrl-viewer 1.4.1__py3-none-any.whl → 1.4.86__py3-none-any.whl

iXBRLViewerPlugin/__init__.py

@@ -1,26 +1,54 @@
 # See COPYRIGHT.md for copyright information
+
 from __future__ import annotations
 
 import argparse
+import atexit
 import io
 import logging
 import os
+import shutil
 import sys
 import tempfile
 import traceback
+import webbrowser
 from optparse import OptionGroup, OptionParser
-from typing import Optional, Union
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, cast
 
-from arelle import Cntlr
+from arelle.Cntlr import Cntlr
 from arelle.LocalViewer import LocalViewer
 from arelle.ModelDocument import Type
-from arelle.webserver.bottle import static_file
-
-from .constants import CONFIG_FEATURE_PREFIX, CONFIG_LAUNCH_ON_LOAD, \
-    CONFIG_SCRIPT_URL, DEFAULT_LAUNCH_ON_LOAD, DEFAULT_OUTPUT_NAME, \
-    DEFAULT_VIEWER_PATH, FEATURE_CONFIGS
-from .iXBRLViewer import IXBRLViewerBuilder, IXBRLViewerBuilderError
-
+from arelle.ModelXbrl import ModelXbrl
+from arelle.typing import TypeGetText
+from arelle.UrlUtil import isHttpUrl
+from bottle import static_file  # type: ignore[import-untyped]
+
+if TYPE_CHECKING:
+    from tkinter import Menu
+
+    from arelle.CntlrWinMain import CntlrWinMain
+
+from .constants import (
+    CONFIG_COPY_SCRIPT,
+    CONFIG_FEATURE_PREFIX,
+    CONFIG_LAUNCH_ON_LOAD,
+    CONFIG_SCRIPT_URL,
+    DEFAULT_COPY_SCRIPT,
+    DEFAULT_JS_FILENAME,
+    DEFAULT_LAUNCH_ON_LOAD,
+    DEFAULT_OUTPUT_NAME,
+    DEFAULT_VIEWER_PATH,
+    ERROR_MESSAGE_CODE,
+    EXCEPTION_MESSAGE_CODE,
+    FEATURE_CONFIGS,
+)
+from .iXBRLViewer import IXBRLViewerBuilder, IXBRLViewerBuilderError, isInlineDoc
+from .plugin import IXBRLViewerPluginData
+
+_: TypeGetText
+
+PLUGIN_NAME = 'ixbrl-viewer'
 
 #
 # GUI operation:
@@ -46,7 +74,7 @@ from .iXBRLViewer import IXBRLViewerBuilder, IXBRLViewerBuilderError
 #
 
 
-def iXBRLViewerCommandLineOptionExtender(parser, *args, **kwargs):
+def iXBRLViewerCommandLineOptionExtender(parser: OptionParser, *args: Any, **kwargs: Any) -> None:
     parser.add_option("--save-viewer",
                       action="store",
                       dest="saveViewerDest",
@@ -55,7 +83,18 @@ def iXBRLViewerCommandLineOptionExtender(parser, *args, **kwargs):
                       action="store",
                       dest="viewerURL",
                       default=DEFAULT_VIEWER_PATH,
-                      help="Specify the URL to ixbrlviewer.js")
+                      help="A filepath or URL to the iXBRL Viewer JavaScript file which will be downloaded or copied into the output directory."
+                           " If a relative filepath is to be copied it will be resolved relative to the current working directory."
+                           " If '--viewer-no-copy-script' is used, the '--viewer-url' file will not be copied or downloaded and instead directly referenced from the HTML file."
+                           " Examples: 'customViewerScript.js', '/path/to/ixbrlviewer.js', 'https://example.com/ixbrlviewer.js'."
+                           f" The default value is '{DEFAULT_JS_FILENAME}'.")
+    parser.add_option("--viewer-no-copy-script",
+                      action="store_true",
+                      dest="viewerNoCopyScript",
+                      default=False,
+                      help="Prevent copying the iXBRL Viewer's JavaScript file from '--viewer-url' into the output directory."
+                           " If used, the iXBRL Viewer HTML file will reference the '--viewer-url' directly."
+                           " It must be a valid script location at the time the viewer is opened in a browser.")
     parser.add_option("--viewer-validation-messages",
                       dest="validationMessages",
                       action="store_true",
@@ -81,136 +120,189 @@ def iXBRLViewerCommandLineOptionExtender(parser, *args, **kwargs):
                       default=False,
                       dest="zipViewerOutput",
                       help="Converts the viewer output into a self contained zip")
+
     featureGroup = OptionGroup(parser, "Viewer Features",
                             "See viewer README for information on enabling/disabling features.")
     for featureConfig in FEATURE_CONFIGS:
-        arg = f'--viewer-feature-{featureConfig.key}'
-        featureGroup.add_option(arg, arg.lower(), action="store_true", default=False, help=featureConfig.description)
+        arg = f'--viewer-feature-{featureConfig.key}'.replace('_', '-')
+        featureGroup.add_option(
+            arg,
+            arg.lower(),
+            action=featureConfig.cliAction,
+            default=featureConfig.cliDefault,
+            help=featureConfig.description
+        )
     parser.add_option_group(featureGroup)
 
+def pluginData(cntlr: Cntlr) -> IXBRLViewerPluginData:
+    pd = cast(IXBRLViewerPluginData | None, cntlr.getPluginData(PLUGIN_NAME))
+    if pd is None:
+        pd = IXBRLViewerPluginData(PLUGIN_NAME)
+        cntlr.setPluginData(pd)
+    return pd
+
+def resetPluginData(cntlr: Cntlr) -> None:
+    pluginData(cntlr).builder = None
+
+def processModel(cntlr: Cntlr, modelXbrl: ModelXbrl) -> None:
+    try:
+        if isInlineDoc(modelXbrl.modelDocument):
+            builder = pluginData(cntlr).builder
+            assert builder is not None, "iXBRL Viewer builder must be initialized before processing model"
+            builder.processModel(modelXbrl)
+    except IXBRLViewerBuilderError as ex:
+        print(ex)
+    except Exception as ex:
+        tb = traceback.format_tb(sys.exc_info()[2])
+        cntlr.addToLog(
+            "Exception %(ex)s\nTraceback %(traceback)s",
+            messageCode=EXCEPTION_MESSAGE_CODE,
+            level=logging.ERROR,
+            messageArgs={
+                'ex': ex,
+                'traceback': tb,
+            },
+        )
 
 def generateViewer(
         cntlr: Cntlr,
-        saveViewerDest: Union[io.BytesIO, str],
-        viewerURL: str = DEFAULT_VIEWER_PATH,
+        saveViewerDest: io.BytesIO | str | None,
+        viewerURL: str | None = None,
         showValidationMessages: bool = False,
-        useStubViewer: bool = False,
         zipViewerOutput: bool = False,
-        features: Optional[list[str]] = None,
-        packageDownloadURL: str = None):
+        packageDownloadURL: str | None = None,
+        copyScript: bool = True,
+) -> None:
     """
-    Generate and save a viewer at the given destination (file, directory, or in-memory file) with the given viewer URL.
-    If the viewer URL is a location on the local file system, a copy will be placed included in the output destination.
+    Generate and save an iXBRL viewer at the given destination (file, directory, or in-memory file) with the given viewer script URL.
+    If copyScript is True the viewer script will be copied into the output destination.
     :param cntlr: The arelle controller that contains the model to be included in the viewer
     :param saveViewerDest: The target that viewer data/files will be written to (path to file or directory, or a file object itself).
-    :param viewerURL: The filepath or URL location of the viewer script.
+    :param viewerURL: The filepath or URL location of the iXBRL Viewer JavaScript file.
     :param showValidationMessages: True if validation messages should be shown in the viewer.
     :param useStubViewer: True if the stub viewer should be used.
     :param zipViewerOutput: True if the destination is a zip archive.
-    :param features: List of feature names to enable via generated JSON data.
+    :param packageDownloadURL: Optional URL to use as the report package download URL.
+    :param copyScript: Controls if the script referenced by viewerURL is copied into the output directory, or directly set as the 'src' value of the script tag in the HTML iXBRL Viewer.
     """
     # extend XBRL-loaded run processing for this option
-    if cntlr.modelManager is None or cntlr.modelManager.modelXbrl is None or not cntlr.modelManager.modelXbrl.modelDocument:
-        cntlr.addToLog("No taxonomy loaded.")
+    abortGenerationMsg = "Skipping iXBRL Viewer generation."
+    if not saveViewerDest:
+        cntlr.addToLog(f"iXBRL Viewer destination not provided. {abortGenerationMsg}", messageCode=EXCEPTION_MESSAGE_CODE)
         return
-    modelXbrl = cntlr.modelManager.modelXbrl
-    if modelXbrl.modelDocument.type not in (Type.INLINEXBRL, Type.INLINEXBRLDOCUMENTSET):
-        cntlr.addToLog("No inline XBRL document loaded.")
+
+    viewerURL = viewerURL or DEFAULT_VIEWER_PATH
+
+    bldr = pluginData(cntlr).builder
+    assert bldr is not None, "iXBRL Viewer builder must be initialized before generating viewer"
+
+    if bldr.reportCount == 0:
+        cntlr.addToLog(f"No inline XBRL documents loaded. {abortGenerationMsg}", messageCode=ERROR_MESSAGE_CODE)
         return
+
     copyScriptPath = None
-    if isinstance(saveViewerDest, str):
-        # Note on URLs: Rather than rely on logic to determine if the input is a file
-        # path or web address, we can allow web addresses to be considered relative paths.
-        # Unless the URL happens to resolve to an existing file on the local filesystem,
-        # it will skip this step and pass through into the viewer as expected.
-        if os.path.isabs(viewerURL):
-            viewerAbsolutePath = viewerURL
-        else:
-            viewerAbsolutePath = getAbsoluteViewerPath(saveViewerDest, viewerURL)
-
-        if os.path.isfile(viewerAbsolutePath):
-            # The script was found on the local file system and will be copied into the
-            # destination directory, so the local path (just the basename) of viewerURL should
-            # be passed to the script tag
-            copyScriptPath = viewerURL
-            viewerURL = os.path.basename(viewerURL)
+    if copyScript:
+        originalViewerURL = viewerURL
+        viewerPath = None
+        if isHttpUrl(originalViewerURL):
+            cacheScript = cntlr.webCache.getfilename(originalViewerURL)
+            if cacheScript and (cacheScriptPath := Path(cacheScript)).is_file():
+                viewerPath = cacheScriptPath
+            else:
+                downloadFailedErrorMessage = f"Unable to download iXBRL Viewer script '{originalViewerURL}'."
+                if cntlr.webCache.workOffline:
+                    downloadFailedErrorMessage += " Disable offline mode and try again."
+                cntlr.addToLog(f"{downloadFailedErrorMessage} {abortGenerationMsg}", messageCode=EXCEPTION_MESSAGE_CODE)
+                return
+
+        if not viewerPath:
+            viewerPath = Path(viewerURL)
+        copyScriptPath = viewerPath.resolve()
+        viewerURL = viewerPath.name
+        if not viewerPath.is_file():
+            cntlr.addToLog(f"iXBRL Viewer script not found at '{viewerPath}'. {abortGenerationMsg}", messageCode=EXCEPTION_MESSAGE_CODE)
+            return
+
     try:
-        out = saveViewerDest
-        if out:
-            viewerBuilder = IXBRLViewerBuilder(modelXbrl)
-            if features:
-                for feature in features:
-                    viewerBuilder.enableFeature(feature)
-            iv = viewerBuilder.createViewer(scriptUrl=viewerURL, showValidations=showValidationMessages, useStubViewer=useStubViewer, packageDownloadURL=packageDownloadURL)
-            if iv is not None:
-                iv.save(out, zipOutput=zipViewerOutput, copyScriptPath=copyScriptPath)
+        iv = bldr.createViewer(scriptUrl=viewerURL, showValidations=showValidationMessages, packageDownloadURL=packageDownloadURL)
+        if iv is not None:
+            iv.save(saveViewerDest, zipOutput=zipViewerOutput, copyScriptPath=copyScriptPath)
     except IXBRLViewerBuilderError as ex:
-        print(ex.message)
+        print(ex)
     except Exception as ex:
-        cntlr.addToLog("Exception {} \nTraceback {}".format(ex, traceback.format_tb(sys.exc_info()[2])))
+        tb = traceback.format_tb(sys.exc_info()[2])
+        cntlr.addToLog(f"Exception {ex} \nTraceback {tb}", messageCode=EXCEPTION_MESSAGE_CODE)
+    resetPluginData(cntlr)
 
 
-def getAbsoluteViewerPath(saveViewerPath: str, relativeViewerPath: str) -> str:
-    """
-    Generate a path to the viewer script given the save destination path as a starting point.
-    :param saveViewerPath: Path to file or directory where viewer output will be saved.
-    :param relativeViewerPath: Path to save destination relative to viewer save path.
-    :return: An absolute file path to the viewer.
-    """
-    saveViewerDir = saveViewerPath
-    if os.path.isfile(saveViewerDir):
-        saveViewerDir = os.path.dirname(os.path.join(os.getcwd(), saveViewerDir))
-    return os.path.join(saveViewerDir, relativeViewerPath)
-
-
-def getFeaturesFromOptions(options: Union[argparse.Namespace, OptionParser]):
-    return [
-        featureConfig.key
-        for featureConfig in FEATURE_CONFIGS
-        if getattr(options, f'viewer_feature_{featureConfig.key}') or getattr(options, f'viewer_feature_{featureConfig.key.lower()}')
-    ]
+def getFeaturesFromOptions(options: argparse.Namespace | OptionParser) -> dict[str, Any]:
+    features = {}
+    for featureConfig in FEATURE_CONFIGS:
+        key = featureConfig.key
+        option = f'viewer_feature_{key}'
+        value = getattr(options, option, None)
+        if value is not None:
+            features[key] = value
+    return features
 
 
-def iXBRLViewerCommandLineXbrlRun(cntlr, options, *args, **kwargs):
+def iXBRLViewerCommandLineXbrlRun(
+        cntlr: Cntlr,
+        options: argparse.Namespace,
+        modelXbrl: ModelXbrl,
+        *args: Any,
+        **kwargs: Any,
+) -> None:
+    pd = pluginData(cntlr)
+    if pd.builder is None:
+        pd.builder = IXBRLViewerBuilder(cntlr, useStubViewer = options.useStubViewer, features=getFeaturesFromOptions(options))
+    processModel(cntlr, modelXbrl)
+
+def iXBRLViewerCommandLineFilingEnd(cntlr: Cntlr, options: argparse.Namespace, *args: Any, **kwargs: Any) -> None:
     generateViewer(
-        cntlr,
-        options.saveViewerDest or kwargs.get("responseZipStream"),
-        options.viewerURL,
-        options.validationMessages,
-        options.useStubViewer,
-        options.zipViewerOutput,
-        getFeaturesFromOptions(options),
-        options.packageDownloadURL,
+        cntlr=cntlr,
+        saveViewerDest=options.saveViewerDest or kwargs.get("responseZipStream"),
+        viewerURL=options.viewerURL,
+        copyScript=not options.viewerNoCopyScript,
+        showValidationMessages=options.validationMessages,
+        zipViewerOutput=options.zipViewerOutput,
+        packageDownloadURL=options.packageDownloadURL,
     )
 
 
-def iXBRLViewerSaveCommand(cntlr):
+def iXBRLViewerSaveCommand(cntlr: CntlrWinMain) -> None:
     from .ui import SaveViewerDialog
     if cntlr.modelManager is None or cntlr.modelManager.modelXbrl is None:
-        cntlr.addToLog("No document loaded.")
+        cntlr.addToLog("No document loaded.", messageCode=ERROR_MESSAGE_CODE)  # type: ignore[no-untyped-call]
         return
     modelXbrl = cntlr.modelManager.modelXbrl
-    if modelXbrl.modelDocument.type not in (Type.INLINEXBRL, Type.INLINEXBRLDOCUMENTSET):
-        cntlr.addToLog("No inline XBRL document loaded.")
+    if modelXbrl.modelDocument is None or modelXbrl.modelDocument.type not in (Type.INLINEXBRL, Type.INLINEXBRLDOCUMENTSET):
+        cntlr.addToLog("No inline XBRL document loaded.", messageCode=ERROR_MESSAGE_CODE)  # type: ignore[no-untyped-call]
         return
     dialog = SaveViewerDialog(cntlr)
     dialog.render()
+    features = {
+        feature: True
+        for feature in dialog.features()
+    }
+    pluginData(cntlr).builder = IXBRLViewerBuilder(cntlr, features=features)
+    processModel(cntlr, modelXbrl)
     if dialog.accepted and dialog.filename():
         generateViewer(
-            cntlr,
-            dialog.filename(),
-            dialog.scriptUrl(),
+            cntlr=cntlr,
+            saveViewerDest=dialog.filename(),
+            viewerURL=dialog.scriptUrl(),
+            copyScript=dialog.copyScript(),
             zipViewerOutput=dialog.zipViewerOutput(),
-            features=dialog.features()
         )
 
 
-def iXBRLViewerSettingsCommand(cntlr):
+def iXBRLViewerSettingsCommand(cntlr: CntlrWinMain) -> None:
     from .ui import SettingsDialog
     SettingsDialog(cntlr).render()
 
 
-def iXBRLViewerToolsMenuExtender(cntlr, menu, *args, **kwargs):
+def iXBRLViewerToolsMenuExtender(cntlr: CntlrWinMain, menu: Menu, *args: Any, **kwargs: Any) -> None:
     # Add Tools menu
     from tkinter import Menu  # must only import if GUI present (no tkinter on GUI-less servers)
     viewerMenu = Menu(cntlr.menubar, tearoff=0)
@@ -227,79 +319,90 @@ def iXBRLViewerToolsMenuExtender(cntlr, menu, *args, **kwargs):
         command=lambda: iXBRLViewerSaveCommand(cntlr))
 
 
-def toolsMenuExtender(cntlr, menu, *args, **kwargs):
+def toolsMenuExtender(cntlr: CntlrWinMain, menu: Menu, *args: Any, **kwargs: Any) -> None:
     iXBRLViewerToolsMenuExtender(cntlr, menu, *args, **kwargs)
 
 
-def commandLineOptionExtender(*args, **kwargs):
+def commandLineOptionExtender(*args: Any, **kwargs: Any) -> None:
     iXBRLViewerCommandLineOptionExtender(*args, **kwargs)
 
 
-def commandLineRun(*args, **kwargs):
-    iXBRLViewerCommandLineXbrlRun(*args, **kwargs)
+def commandLineRun(cntlr: Cntlr, options: argparse.Namespace, modelXbrl: ModelXbrl, *args: Any, **kwargs: Any) -> None:
+    iXBRLViewerCommandLineXbrlRun(cntlr, options, modelXbrl, *args, **kwargs)
 
+def commandLineFilingEnd(*args: Any, **kwargs: Any) -> None:
+    iXBRLViewerCommandLineFilingEnd(*args, **kwargs)
 
 class iXBRLViewerLocalViewer(LocalViewer):
     # plugin-specific local file handler
-    def getLocalFile(self, file, relpath, request):
-        _report, _sep, _file = file.partition("/")
-        if file == 'ixbrlviewer.js':
-            return static_file('ixbrlviewer.js', os.path.dirname(DEFAULT_VIEWER_PATH))
-        elif _report.isnumeric():  # in reportsFolder folder
+    def getLocalFile(self, file: str, relpath: str, request: Any) -> Any:
+        if file == DEFAULT_JS_FILENAME:
+            return static_file(DEFAULT_JS_FILENAME, os.path.dirname(DEFAULT_VIEWER_PATH))
+        _report, _, _file = file.partition("/")
+        if _report.isnumeric():  # in reportsFolder folder
             # check if file is in the current or parent directory
             _fileDir = self.reportsFolders[int(_report)]
             _fileExists = False
             if os.path.exists(os.path.join(_fileDir, _file)):
                 _fileExists = True
-            elif "/" in _file and os.path.exists(os.path.join(_fileDir, os.path.filepart(_file))):
+            elif "/" in _file and os.path.exists(os.path.join(_fileDir, os.path.basename(_file))):
                 # xhtml in a subdirectory for output files may refer to an image file in parent directory
                 _fileExists = True
-                _file = os.path.filepart(_file)
-            if not _fileExists:
-                self.cntlr.addToLog("http://localhost:{}/{}".format(self.port, file), messageCode="localViewer:fileNotFound", level=logging.DEBUG)
+                _file = os.path.basename(_file)
+            if not _fileExists and self.cntlr is not None:
+                self.cntlr.addToLog(
+                    f"http://localhost:{self.port}/{file}",
+                    messageCode="localViewer:fileNotFound",
+                    level=logging.DEBUG,
+                )
             return static_file(_file, root=_fileDir, headers=self.noCacheHeaders)  # extra_headers modification to py-bottle
-        return static_file(file, root="/")  # probably can't get here unless path is wrong
+        return static_file(file, root="/")  # absolute path used for ixbrlviewer.js.
 
 
-def guiRun(cntlr, modelXbrl, attach, *args, **kwargs):
+def guiRun(cntlr: CntlrWinMain, modelXbrl: ModelXbrl, attach: Any, *args: Any, **kwargs: Any) -> None:
     """ run iXBRL Viewer using GUI interactions for a single instance or testcases """
+    if cntlr.config is None:
+        return
     if not cntlr.config.setdefault(CONFIG_LAUNCH_ON_LOAD, DEFAULT_LAUNCH_ON_LOAD):
         # Don't run on launch if the option has been disabled
         return
     try:
-        import webbrowser
-        global tempViewer
-        tempViewer = tempfile.TemporaryDirectory()
+        tempViewerDir = tempfile.mkdtemp()
+        atexit.register(shutil.rmtree, tempViewerDir, ignore_errors=True)
         viewer_file_name = DEFAULT_OUTPUT_NAME
-        features = [
-            c.key
-            for c in FEATURE_CONFIGS
-            if cntlr.config.setdefault(f'{CONFIG_FEATURE_PREFIX}{c.key}', False)
-        ]
+        features: dict[str, bool] = {}
+        for featureConfig in FEATURE_CONFIGS:
+            if cntlr.config.setdefault(f'{CONFIG_FEATURE_PREFIX}{featureConfig.key}', False):
+                features[featureConfig.key] = True
+        pluginData(cntlr).builder = IXBRLViewerBuilder(cntlr, useStubViewer=True, features=features)
+        processModel(cntlr, modelXbrl)
         generateViewer(
-            cntlr,
-            saveViewerDest=tempViewer.name,
-            viewerURL=cntlr.config.setdefault(CONFIG_SCRIPT_URL, DEFAULT_VIEWER_PATH),
-            useStubViewer=True,
-            features=features
+            cntlr=cntlr,
+            saveViewerDest=tempViewerDir,
+            viewerURL=cntlr.config.get(CONFIG_SCRIPT_URL),
+            copyScript=cntlr.config.get(CONFIG_COPY_SCRIPT, DEFAULT_COPY_SCRIPT),
         )
-        localViewer = iXBRLViewerLocalViewer("iXBRL Viewer",  os.path.dirname(__file__))
-        localhost = localViewer.init(cntlr, tempViewer.name)
-        webbrowser.open(f'{localhost}/{viewer_file_name}')
+        if Path(tempViewerDir, viewer_file_name).exists():
+            localViewer = iXBRLViewerLocalViewer("iXBRL Viewer", os.path.dirname(__file__))  # type: ignore[no-untyped-call]
+            localhost = localViewer.init(cntlr, tempViewerDir)  # type: ignore[no-untyped-call]
+            webbrowser.open(f'{localhost}/{viewer_file_name}')
     except Exception as ex:
         modelXbrl.error(
-            "viewer:exception",
-            "Exception %(exception)s \sTraceback %(traceback)s",
+            EXCEPTION_MESSAGE_CODE,
+            "Exception %(exception)s \nTraceback %(traceback)s",
             modelObject=modelXbrl, exception=ex, traceback=traceback.format_tb(sys.exc_info()[2])
         )
 
 
-def load_plugin_url():
+def load_plugin_url() -> str:
     return __file__
 
 
 __pluginInfo__ = {
-    'name': 'ixbrl-viewer',
+    'name': PLUGIN_NAME,
+    'aliases': [
+        'iXBRLViewerPlugin',
+    ],
     'version': '0.1',
     'description': "iXBRL Viewer creator",
     'license': 'License :: OSI Approved :: Apache License, Version 2.0 (Apache-2.0)',
@@ -307,6 +410,7 @@ __pluginInfo__ = {
     'copyright': 'Copyright :: Workiva Inc. :: 2019',
     'CntlrCmdLine.Options': commandLineOptionExtender,
     'CntlrCmdLine.Xbrl.Run': commandLineRun,
+    'CntlrCmdLine.Filing.End': commandLineFilingEnd,
     'CntlrWinMain.Menu.Tools': toolsMenuExtender,
     'CntlrWinMain.Xbrl.Loaded': guiRun,
 }

iXBRLViewerPlugin/_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 = '1.4.1'
-__version_tuple__ = version_tuple = (1, 4, 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 = '1.4.86'
+__version_tuple__ = version_tuple = (1, 4, 86)
+
+__commit_id__ = commit_id = None

iXBRLViewerPlugin/constants.py

@@ -1,5 +1,7 @@
 # See COPYRIGHT.md for copyright information
 
+from __future__ import annotations
+
 import os
 
 from .featureConfig import FeatureConfig
@@ -7,22 +9,114 @@ from .featureConfig import FeatureConfig
 CONFIG_FEATURE_PREFIX = 'iXBRLViewerFeature_'
 CONFIG_FILE_DIRECTORY = 'iXBRLViewerFileDir'
 CONFIG_LAUNCH_ON_LOAD = 'iXBRLViewerLaunchOnLoad'
+CONFIG_COPY_SCRIPT = 'iXBRLViewerCopyScript'
 CONFIG_OUTPUT_FILE = 'iXBRLViewerOutputFile'
 CONFIG_SCRIPT_URL = 'iXBRLViewerScriptURL'
 CONFIG_ZIP_OUTPUT = 'iXBRLViewerZipOutput'
 
+ERROR_MESSAGE_CODE = 'viewer:error'
+EXCEPTION_MESSAGE_CODE = 'viewer:exception'
+INFO_MESSAGE_CODE = 'viewer:info'
+
 DEFAULT_LAUNCH_ON_LOAD = True
+DEFAULT_COPY_SCRIPT = True
 DEFAULT_OUTPUT_NAME = 'ixbrlviewer.html'
-DEFAULT_VIEWER_PATH = os.path.join(os.path.dirname(__file__), "viewer", "dist", "ixbrlviewer.js")
+DEFAULT_JS_FILENAME = 'ixbrlviewer.js'
+DEFAULT_VIEWER_PATH = os.path.join(os.path.dirname(__file__), "viewer", "dist", DEFAULT_JS_FILENAME)
 
 FEATURE_CONFIGS = [
+    FeatureConfig(
+        key='home_link_label',
+        label='Home Link (Label)',
+        description='Customizes the label of the "Home" link enabled by "home_link_url".',
+        cliAction='store',
+        cliDefault=None,
+        guiVisible=False,
+        guiDefault=None,
+    ),
+    FeatureConfig(
+        key='home_link_url',
+        label='Home Link (URL)',
+        description='Adds a "Home" link that directs to the specified URL. Label can be customized with "home_link_label".',
+        cliAction='store',
+        cliDefault=None,
+        guiVisible=False,
+        guiDefault=None,
+    ),
+    FeatureConfig(
+        key='support_link',
+        label='Support Link',
+        description='Adds a "Support" link that directs to the specified URL.',
+        cliAction='store',
+        cliDefault=None,
+        guiVisible=False,
+        guiDefault=None,
+    ),
+    FeatureConfig(
+        key='survey_link',
+        label='Survey Link',
+        description='Adds a "Survey" link that directs to the specified URL.',
+        cliAction='store',
+        cliDefault=None,
+        guiVisible=False,
+        guiDefault=None,
+    ),
     FeatureConfig(
         key='review',
         label='Review Mode',
         description='Enables highlighting of untagged numbers and dates.',
+        cliAction='store_true',
+        cliDefault=False,
+        guiVisible=True,
+        guiDefault=False
+    ),
+    FeatureConfig(
+        key='mandatory_facts',
+        label='Mandatory Facts',
+        description='Enables the display of mandatory facts for the selected taxonomy.',
+        cliAction='store',
+        cliDefault=None,
+        guiVisible=False,
+        guiDefault=None
+    ),
+    FeatureConfig(
+        key='search_on_startup',
+        label='Search on startup',
+        description='Show the search pane by default on startup.',
+        cliAction='store_true',
+        cliDefault=None,
+        guiVisible=True,
+        guiDefault=False
+    ),
+    FeatureConfig(
+        key='highlight_facts_on_startup',
+        label='Highlight facts on startup',
+        description='Default "Highlight all facts" to on.',
+        cliAction='store_true',
+        cliDefault=None,
         guiVisible=True,
         guiDefault=False
     )
 ]
-
 GUI_FEATURE_CONFIGS = [c for c in FEATURE_CONFIGS if c.guiVisible]
+
+MANDATORY_FACTS = {
+    "companies-house": [
+            "UKCompaniesHouseRegisteredNumber",
+            "EntityCurrentLegalOrRegisteredName",
+            "BalanceSheetDate",
+            "DateAuthorisationFinancialStatementsForIssue",
+            "DirectorSigningFinancialStatements",
+            "EntityDormantTruefalse",
+            "EntityTradingStatus",
+            "AccountsStatusAuditedOrUnaudited",
+            "AccountsTypeFullOrAbbreviated",
+            "AccountingStandardsApplied",
+            "LegalFormEntity",
+            "StartDateForPeriodCoveredByReport",
+            "EndDateForPeriodCoveredByReport",
+            "CharityRegistrationNumberEnglandWales",
+            "CharityRegistrationNumberScotland",
+            "CharityRegistrationNumberNorthernIreland"
+    ]
+}