ixbrl-viewer 1.4.14__py3-none-any.whl → 1.4.16__py3-none-any.whl

iXBRLViewerPlugin/__init__.py

@@ -9,18 +9,20 @@ import sys
 import tempfile
 import traceback
 from optparse import OptionGroup, OptionParser
+from pathlib import Path
 
 from arelle import Cntlr
 from arelle.LocalViewer import LocalViewer
 from arelle.ModelDocument import Type
+from arelle.UrlUtil import isHttpUrl
 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_JS_FILENAME, DEFAULT_VIEWER_PATH, FEATURE_CONFIGS
+from .constants import CONFIG_COPY_SCRIPT, CONFIG_FEATURE_PREFIX, CONFIG_LAUNCH_ON_LOAD, \
+    CONFIG_SCRIPT_URL, DEFAULT_COPY_SCRIPT, DEFAULT_LAUNCH_ON_LOAD, DEFAULT_OUTPUT_NAME, \
+    DEFAULT_JS_FILENAME, DEFAULT_VIEWER_PATH, ERROR_MESSAGE_CODE, \
+    EXCEPTION_MESSAGE_CODE, FEATURE_CONFIGS
 from .iXBRLViewer import IXBRLViewerBuilder, IXBRLViewerBuilderError
 
-
 #
 # GUI operation:
 #
@@ -54,7 +56,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",
@@ -102,47 +115,63 @@ def generateViewer(
         zipViewerOutput: bool = False,
         features: list[str] | None = 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 features: Optional list of features to enable.
+    :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 saveViewerDest is None:
+    abortGenerationMsg = "Skipping iXBRL Viewer generation."
+    if not saveViewerDest:
+        cntlr.addToLog(f"iXBRL Viewer destination not provided. {abortGenerationMsg}", messageCode=EXCEPTION_MESSAGE_CODE)
         return
-    if (cntlr.modelManager is None 
-        or len(cntlr.modelManager.loadedModelXbrls) == 0 
+
+    if not viewerURL:
+        cntlr.addToLog(f"iXBRL Viewer script not provided. {abortGenerationMsg}", messageCode=EXCEPTION_MESSAGE_CODE)
+        return
+
+    if (cntlr.modelManager is None
+        or len(cntlr.modelManager.loadedModelXbrls) == 0
         or any(not mx.modelDocument for mx in cntlr.modelManager.loadedModelXbrls)):
-        cntlr.addToLog("No taxonomy loaded.")
+        cntlr.addToLog(f"No taxonomy loaded. {abortGenerationMsg}", messageCode=ERROR_MESSAGE_CODE)
         return
-    modelXbrl = cntlr.modelManager.modelXbrl
-    if modelXbrl.modelDocument.type not in (Type.INLINEXBRL, Type.INLINEXBRLDOCUMENTSET):
-        cntlr.addToLog("No inline XBRL document loaded.")
+    if cntlr.modelManager.modelXbrl.modelDocument.type not in (Type.INLINEXBRL, Type.INLINEXBRLDOCUMENTSET):
+        cntlr.addToLog(f"No inline XBRL document 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:
         viewerBuilder = IXBRLViewerBuilder(cntlr.modelManager.loadedModelXbrls)
         if features:
@@ -154,20 +183,8 @@ def generateViewer(
     except IXBRLViewerBuilderError as ex:
         print(ex)
     except Exception as ex:
-        cntlr.addToLog("Exception {} \nTraceback {}".format(ex, traceback.format_tb(sys.exc_info()[2])))
-
-
-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)
+        tb = traceback.format_tb(sys.exc_info()[2])
+        cntlr.addToLog(f"Exception {ex} \nTraceback {tb}", messageCode=EXCEPTION_MESSAGE_CODE)
 
 
 def getFeaturesFromOptions(options: argparse.Namespace | OptionParser):
@@ -180,35 +197,37 @@ def getFeaturesFromOptions(options: argparse.Namespace | OptionParser):
 
 def iXBRLViewerCommandLineXbrlRun(cntlr, options, *args, **kwargs):
     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,
+        useStubViewer=options.useStubViewer,
+        zipViewerOutput=options.zipViewerOutput,
+        features=getFeaturesFromOptions(options),
+        packageDownloadURL=options.packageDownloadURL,
     )
 
 
 def iXBRLViewerSaveCommand(cntlr):
     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)
         return
     modelXbrl = cntlr.modelManager.modelXbrl
     if modelXbrl.modelDocument.type not in (Type.INLINEXBRL, Type.INLINEXBRLDOCUMENTSET):
-        cntlr.addToLog("No inline XBRL document loaded.")
+        cntlr.addToLog("No inline XBRL document loaded.", messageCode=ERROR_MESSAGE_CODE)
         return
     dialog = SaveViewerDialog(cntlr)
     dialog.render()
     if dialog.accepted and dialog.filename():
         generateViewer(
-            cntlr,
-            dialog.filename(),
-            dialog.scriptUrl() or DEFAULT_VIEWER_PATH,
+            cntlr=cntlr,
+            saveViewerDest=dialog.filename(),
+            viewerURL=dialog.scriptUrl() or DEFAULT_VIEWER_PATH,
+            copyScript=dialog.copyScript(),
             zipViewerOutput=dialog.zipViewerOutput(),
-            features=dialog.features()
+            features=dialog.features(),
         )
 
 
@@ -284,18 +303,20 @@ def guiRun(cntlr, modelXbrl, attach, *args, **kwargs):
             if cntlr.config.setdefault(f'{CONFIG_FEATURE_PREFIX}{c.key}', False)
         ]
         generateViewer(
-            cntlr,
+            cntlr=cntlr,
             saveViewerDest=tempViewer.name,
             viewerURL=cntlr.config.get(CONFIG_SCRIPT_URL) or DEFAULT_VIEWER_PATH,
+            copyScript=cntlr.config.get(CONFIG_COPY_SCRIPT, DEFAULT_COPY_SCRIPT),
             useStubViewer=True,
-            features=features
+            features=features,
         )
-        localViewer = iXBRLViewerLocalViewer("iXBRL Viewer",  os.path.dirname(__file__))
-        localhost = localViewer.init(cntlr, tempViewer.name)
-        webbrowser.open(f'{localhost}/{viewer_file_name}')
+        if Path(tempViewer.name, viewer_file_name).exists():
+            localViewer = iXBRLViewerLocalViewer("iXBRL Viewer",  os.path.dirname(__file__))
+            localhost = localViewer.init(cntlr, tempViewer.name)
+            webbrowser.open(f'{localhost}/{viewer_file_name}')
     except Exception as ex:
         modelXbrl.error(
-            "viewer:exception",
+            EXCEPTION_MESSAGE_CODE,
             "Exception %(exception)s \nTraceback %(traceback)s",
             modelObject=modelXbrl, exception=ex, traceback=traceback.format_tb(sys.exc_info()[2])
         )

iXBRLViewerPlugin/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '1.4.14'
-__version_tuple__ = version_tuple = (1, 4, 14)
+__version__ = version = '1.4.16'
+__version_tuple__ = version_tuple = (1, 4, 16)

iXBRLViewerPlugin/constants.py

@@ -7,11 +7,17 @@ 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_JS_FILENAME = 'ixbrlviewer.js'
 DEFAULT_VIEWER_PATH = os.path.join(os.path.dirname(__file__), "viewer", "dist", DEFAULT_JS_FILENAME)

iXBRLViewerPlugin/iXBRLViewer.py

@@ -12,6 +12,7 @@ import urllib.parse
 import zipfile
 from collections import defaultdict
 from copy import deepcopy
+from pathlib import Path
 
 import pycountry
 from arelle import XbrlConst
@@ -23,7 +24,7 @@ from arelle.UrlUtil import isHttpUrl
 from arelle.ValidateXbrlCalcs import inferredDecimals
 from lxml import etree
 
-from .constants import DEFAULT_OUTPUT_NAME, DEFAULT_VIEWER_PATH, FEATURE_CONFIGS
+from .constants import DEFAULT_JS_FILENAME, DEFAULT_OUTPUT_NAME, ERROR_MESSAGE_CODE, FEATURE_CONFIGS, INFO_MESSAGE_CODE
 from .xhtmlserialize import XHTMLSerializer
 
 
@@ -265,11 +266,15 @@ class IXBRLViewerBuilder:
             factData["v"] = None
         elif f.concept is not None and f.concept.isEnumeration:
             qnEnums = f.xValue
-            if not isinstance(qnEnums, list):
-                qnEnums = (qnEnums,)
-            factData["v"] = " ".join(self.nsmap.qname(qn) for qn in qnEnums)
-            for qn in qnEnums:
-                self.addConcept(report, report.qnameConcepts.get(qn))
+            if qnEnums is None:
+                factData["v"] = f.value
+                factData["err"] = 'INVALID_IX_VALUE'
+            else:
+                if not isinstance(qnEnums, list):
+                    qnEnums = (qnEnums,)
+                factData["v"] = " ".join(self.nsmap.qname(qn) for qn in qnEnums)
+                for qn in qnEnums:
+                    self.addConcept(report, report.qnameConcepts.get(qn))
         else:
             factData["v"] = f.value 
             if f.value == INVALIDixVALUE:
@@ -348,7 +353,7 @@ class IXBRLViewerBuilder:
             if child.tag == '{http://www.w3.org/1999/xhtml}body':
                 for body_child in child:
                     if body_child.tag == '{http://www.w3.org/1999/xhtml}script' and body_child.get('type','') == 'application/x.ixbrl-viewer+json':
-                        self.logger_model.error("viewer:error", "File already contains iXBRL viewer")
+                        self.logger_model.error(ERROR_MESSAGE_CODE, "File already contains iXBRL viewer")
                         return False
 
                 child.append(etree.Comment("BEGIN IXBRL VIEWER EXTENSIONS"))
@@ -391,7 +396,7 @@ class IXBRLViewerBuilder:
 
     def createViewer(
             self,
-            scriptUrl: str = DEFAULT_VIEWER_PATH,
+            scriptUrl: str = DEFAULT_JS_FILENAME,
             useStubViewer: bool = False,
             showValidations: bool = True,
             packageDownloadURL: str | None = None,
@@ -426,7 +431,7 @@ class IXBRLViewerBuilder:
             self.currentTargetReport["rels"] = self.getRelationships(report)
 
             docSetFiles = None
-            report.info("viewer:info", "Creating iXBRL viewer (%d of %d)" % (n+1, len(self.reports)))
+            report.info(INFO_MESSAGE_CODE, "Creating iXBRL viewer (%d of %d)" % (n+1, len(self.reports)))
             if report.modelDocument.type == Type.INLINEXBRLDOCUMENTSET:
                 # Sort by object index to preserve order in which files were specified.
                 xmlDocsByFilename = {
@@ -531,7 +536,7 @@ class iXBRLViewer:
     def addFilingDoc(self, filingDocuments):
         self.filingDocuments = filingDocuments
 
-    def save(self, destination: io.BytesIO | str, zipOutput: bool = False, copyScriptPath: str | None = None):
+    def save(self, destination: io.BytesIO | str, zipOutput: bool = False, copyScriptPath: Path | None = None):
         """
         Save the iXBRL viewer.
         :param destination: The target that viewer data/files will be written to (path to file/directory, or a file object itself).
@@ -549,15 +554,15 @@ class iXBRLViewer:
                 fileMode = 'w'
             elif destination.endswith(os.sep):
                 # Looks like a directory, but isn't one
-                self.logger_model.error("viewer:error", "Directory %s does not exist" % destination)
+                self.logger_model.error(ERROR_MESSAGE_CODE, "Directory %s does not exist" % destination)
                 return
             elif not os.path.isdir(os.path.dirname(os.path.abspath(destination))):
                 # Directory part of filename doesn't exist
-                self.logger_model.error("viewer:error", "Directory %s does not exist" % os.path.dirname(os.path.abspath(destination)))
+                self.logger_model.error(ERROR_MESSAGE_CODE, "Directory %s does not exist" % os.path.dirname(os.path.abspath(destination)))
                 return
             elif not destination.endswith('.zip'):
                 # File extension isn't a zip
-                self.logger_model.error("viewer:error", "File extension %s is not a zip" % os.path.splitext(destination)[0])
+                self.logger_model.error(ERROR_MESSAGE_CODE, "File extension %s is not a zip" % os.path.splitext(destination)[0])
                 return
             else:
                 file = destination
@@ -565,57 +570,56 @@ class iXBRLViewer:
 
             with zipfile.ZipFile(file, fileMode, zipfile.ZIP_DEFLATED, True) as zout:
                 for f in self.files:
-                    self.logger_model.info("viewer:info", "Saving in output zip %s" % f.filename)
+                    self.logger_model.info(INFO_MESSAGE_CODE, "Saving in output zip %s" % f.filename)
                     with zout.open(f.filename, "w") as fout:
                         writer = XHTMLSerializer(fout)
                         writer.serialize(f.xmlDocument)
                 if self.filingDocuments:
                     filename = os.path.basename(self.filingDocuments)
-                    self.logger_model.info("viewer:info", "Writing %s" % filename)
+                    self.logger_model.info(INFO_MESSAGE_CODE, "Writing %s" % filename)
                     zout.write(self.filingDocuments, filename)
                 if copyScriptPath is not None:
-                    scriptSrc = os.path.join(destination, copyScriptPath)
-                    self.logger_model.info("viewer:info", "Writing script from %s" % scriptSrc)
-                    zout.write(scriptSrc, os.path.basename(copyScriptPath))
+                    self.logger_model.info(INFO_MESSAGE_CODE, f"Writing script from {copyScriptPath}")
+                    zout.write(copyScriptPath, copyScriptPath.name)
         elif os.path.isdir(destination):
             # If output is a directory, write each file in the doc set to that
             # directory using its existing filename
             for f in self.files:
                 filename = os.path.join(destination, f.filename)
-                self.logger_model.info("viewer:info", "Writing %s" % filename)
+                self.logger_model.info(INFO_MESSAGE_CODE, "Writing %s" % filename)
                 with open(filename, "wb") as fout:
                     writer = XHTMLSerializer(fout)
                     writer.serialize(f.xmlDocument)
             if self.filingDocuments:
                 filename = os.path.basename(self.filingDocuments)
-                self.logger_model.info("viewer:info", "Writing %s" % filename)
+                self.logger_model.info(INFO_MESSAGE_CODE, "Writing %s" % filename)
                 shutil.copy2(self.filingDocuments, os.path.join(destination, filename))
             if copyScriptPath is not None:
-                self._copyScript(destination, copyScriptPath)
+                self._copyScript(Path(destination), copyScriptPath)
         else:
             if len(self.files) > 1:
-                self.logger_model.error("viewer:error", "More than one file in input, but output is not a directory")
+                self.logger_model.error(ERROR_MESSAGE_CODE, "More than one file in input, but output is not a directory")
             elif destination.endswith(os.sep):
                 # Looks like a directory, but isn't one
-                self.logger_model.error("viewer:error", "Directory %s does not exist" % destination)
+                self.logger_model.error(ERROR_MESSAGE_CODE, "Directory %s does not exist" % destination)
             elif not os.path.isdir(os.path.dirname(os.path.abspath(destination))):
                 # Directory part of filename doesn't exist
-                self.logger_model.error("viewer:error", "Directory %s does not exist" % os.path.dirname(os.path.abspath(destination)))
+                self.logger_model.error(ERROR_MESSAGE_CODE, "Directory %s does not exist" % os.path.dirname(os.path.abspath(destination)))
             else:
-                self.logger_model.info("viewer:info", "Writing %s" % destination)
+                self.logger_model.info(INFO_MESSAGE_CODE, "Writing %s" % destination)
                 with open(destination, "wb") as fout:
                     writer = XHTMLSerializer(fout)
                     writer.serialize(self.files[0].xmlDocument)
                 if self.filingDocuments:
                     filename = os.path.basename(self.filingDocuments)
-                    self.logger_model.info("viewer:info", "Writing %s" % filename)
+                    self.logger_model.info(INFO_MESSAGE_CODE, "Writing %s" % filename)
                     shutil.copy2(self.filingDocuments, os.path.join(os.path.dirname(destination), filename))
                 if copyScriptPath is not None:
-                    outDirectory = os.path.dirname(os.path.join(os.getcwd(), destination))
+                    outDirectory = Path(destination).parent
                     self._copyScript(outDirectory, copyScriptPath)
 
-    def _copyScript(self, directory: str, scriptPath: str):
-        scriptSrc = os.path.join(directory, scriptPath)
-        scriptDest = os.path.join(directory, os.path.basename(scriptPath))
-        self.logger_model.info("viewer:info", "Copying script from %s to %s" % (scriptSrc, scriptDest))
-        shutil.copy2(scriptSrc, scriptDest)
+    def _copyScript(self, destDirectory: Path, scriptPath: Path):
+        scriptDest = destDirectory / scriptPath.name
+        if scriptPath != scriptDest:
+            self.logger_model.info(INFO_MESSAGE_CODE, f"Copying script from {scriptDest} to {scriptDest}.")
+            shutil.copy2(scriptPath, scriptDest)

iXBRLViewerPlugin/ui.py

@@ -8,9 +8,9 @@ except ImportError:
 
 import os
 
-from .constants import CONFIG_FEATURE_PREFIX, CONFIG_FILE_DIRECTORY, CONFIG_LAUNCH_ON_LOAD, \
-    CONFIG_OUTPUT_FILE, CONFIG_SCRIPT_URL, CONFIG_ZIP_OUTPUT, DEFAULT_LAUNCH_ON_LOAD, \
-    GUI_FEATURE_CONFIGS
+from .constants import CONFIG_COPY_SCRIPT, CONFIG_FEATURE_PREFIX, CONFIG_FILE_DIRECTORY, \
+    CONFIG_LAUNCH_ON_LOAD, CONFIG_OUTPUT_FILE, CONFIG_SCRIPT_URL, CONFIG_ZIP_OUTPUT, \
+    DEFAULT_COPY_SCRIPT, DEFAULT_LAUNCH_ON_LOAD, GUI_FEATURE_CONFIGS
 
 UNSET_SCRIPT_URL = ''
 
@@ -30,6 +30,8 @@ class BaseViewerDialog(Toplevel):
             self._features[featureConfig.key] = featureVar
         self._scriptUrl = StringVar()
         self._scriptUrl.set(self.cntlr.config.setdefault(CONFIG_SCRIPT_URL, UNSET_SCRIPT_URL))
+        self._copyScript = BooleanVar()
+        self._copyScript.set(self.cntlr.config.setdefault(CONFIG_COPY_SCRIPT, DEFAULT_COPY_SCRIPT))
 
     def addButtons(self, frame: Frame, x: int, y: int) -> int:
         """
@@ -62,6 +64,12 @@ class BaseViewerDialog(Toplevel):
         scriptUrlLabel.grid(row=y, column=0, sticky=W, pady=3, padx=3)
         scriptUrlEntry.grid(row=y, column=1, columnspan=2, sticky=EW, pady=3, padx=3)
 
+        y += 1
+        copyScriptCheckbutton = Checkbutton(frame, text="Copy Script", variable=self._copyScript, onvalue=True, offvalue=False)
+        copyScriptLabel = Label(frame, text="Copy the iXBRL Viewer script into the output directory.")
+        copyScriptCheckbutton.grid(row=y, column=0, pady=3, padx=3, sticky=W)
+        copyScriptLabel.grid(row=y, column=1, columnspan=3, pady=3, padx=3, sticky=W)
+
         y += 1
         featuresLabel = Label(frame, text="Generate with optional features:")
         featuresLabel.grid(row=y, column=0, columnspan=2, pady=3, padx=3, sticky=W)
@@ -130,6 +138,9 @@ class BaseViewerDialog(Toplevel):
         self.grab_set()
         self.wait_window(self)
 
+    def copyScript(self):
+        return self._copyScript.get()
+
     def features(self):
         # Return list of feature keys with corresponding BooleanVar is set to True
         return [feature for feature, value in self._features.items() if value.get()]
@@ -238,6 +249,7 @@ class SettingsDialog(BaseViewerDialog):
         """
         self.cntlr.config[CONFIG_LAUNCH_ON_LOAD] = self._launchOnLoad.get()
         self.cntlr.config[CONFIG_SCRIPT_URL] = self._scriptUrl.get()
+        self.cntlr.config[CONFIG_COPY_SCRIPT] = self._copyScript.get()
         for key, var in self._features.items():
             self.cntlr.config[f'{CONFIG_FEATURE_PREFIX}{key}'] = var.get()
         self.cntlr.saveConfig()
@@ -249,5 +261,6 @@ class SettingsDialog(BaseViewerDialog):
         """
         self._launchOnLoad.set(DEFAULT_LAUNCH_ON_LOAD)
         self._scriptUrl.set(UNSET_SCRIPT_URL)
+        self._copyScript.set(DEFAULT_COPY_SCRIPT)
         for featureConfig in GUI_FEATURE_CONFIGS:
             self._features[featureConfig.key].set(featureConfig.guiDefault)