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

arelle/plugin/inlineXbrlDocumentSet.py

@@ -1,78 +1,159 @@
-'''
-Inline XBRL Document Set plug-in.
+"""
+See COPYRIGHT.md for copyright information.
 
-Supports opening manifest file that identifies inline documents of a document set or an
-Inline XBRL Document Set ("IXDS") identified by multiple files.
+## Overview
 
-Saves extracted instance document for the ixdsTarget (if specified) or default target (if no ixdsTarget).
-(For SEC-compatible inline extractions from command line please specify --encodeSavedXmlChars or use
-EdgarRenderer plugin features to save extracted instance with characters € and above encoded.)
+The Inline XBRL Document Set (IXDS) plugin facilitates the handling of inline XBRL documents.
+It allows for opening and extracting XBRL data from document sets, either defined as an Inline XBRL Document Set or in a
+manifest file (such as JP FSA) that identifies inline XBRL documents.
 
-(Does not simultaneously load/extract multiple target instance documents in a document set.)
+## Key Features
 
-CmdLine allows --file '[{"ixds":[{"file":file1},{"file":file2}...]}]'
+- **XBRL Document Set Detection**: Detect and load iXBRL documents from a zip file or directory.
+- **Target Document Selection**: Load one or more Target Documents from an Inline Document Set.
+- **Extract XML Instance**: Extract and save XML Instance of a Target Document.
+- **Command Line Support**: Detailed syntax for file and target selection.
+- **GUI Interaction**: Selection dialog for loading inline documents and saving target documents.
 
-If there are non-default target documents, the target document identifier can be specified by ixdsTarget
+## Usage Instructions
 
-    --file '[{"ixds":[{"file":file1},{"file":file2}...],"ixdsTarget":"xyz"}]'
+### Command Line Usage
 
-If the file source is a zip, CmdLine will discover the inline files in the zip as thus:
-    --file '[{"ixds":[{"file":file1.zip}]}]'
+- **Load from a ZIP file**:
 
-If the file source is a local directory, CmdLine will discover the inline files in the directory as thus:
-    --file '[{"ixds":[{"file":dir1}]}]'
+    Simple:
+    ```bash
+    python arelleCmdLine.py --plugins inlineXbrlDocumentSet --file report.zip
+    ```
 
-If there is a JSON structure in --file without ixdsTarget the default target is assumed.
+    Verbose:
+    ```bash
+    python arelleCmdLine.py --plugins inlineXbrlDocumentSet --file '[{"ixds": [{"file": "report.zip"}]}]'
+    ```
 
-If no JSON structure then formula parameter ixdsTarget may be used to specify a non-default target or the
-special value "(default)" for the default target (e.g., resources with no @target attribute).
+- **Load from a directory**:
 
-For GUI instance loading a pop up selection dialog is provided when there is no formula parameter and there are multiple targets.
+  Simple:
+  ```bash
+  python arelleCmdLine.py --plugins inlineXbrlDocumentSet --file filing-documents-directory
+  ```
 
-Example to load multi-document IXDS and save extracted xBRL-XML target document:
+  Verbose:
+  ```bash
+  python arelleCmdLine.py --plugins inlineXbrlDocumentSet --file '[{"ixds": [{"file": "filing-documents-directory"}]}]'
+  ```
 
-  For GUI using ix11 conformance suite directory multi-io test case "PASS-multiple-input-multiple-output"
-     File->Open File Inline Doc Set->multi-select PASS-multiple-input-multiple-output-ID1.html and PASS-multiple-input-multiple-output-ID2.html
-     Select Target -> (default)
-     Tools->Save Target Document
-     new file PASS-multiple-input-multiple-output-ID1_extracted.xbrl has (default) target xBRL-XML instance
-     close instance
-     Reopen as above and Select Target -> TARGET
-     Tools->Save Target Document
-     replaced file PASS-multiple-input-multiple-output-ID1_extracted.xbrl now has TARGET target xBRL-XML instance
-  For Command Line:
-     arelleCmdLine --plugin inlineXbrlDocumentSet
-                   --file '[{"ixds":[{"file":".../PASS-multiple-input-multiple-output-ID1.html"},
-                                     {"file":".../PASS-multiple-input-multiple-output-ID2.html"}],
-                             "ixdsTarget":"(default)"}]'
-                   --saveInstance
-     For second target specify "ixdsTarget":"TARGET"
-     For default target either omit ixdsTarget or specify (default).
-     File will be saved as PASS-multiple-input-multiple-output-ID1_extracted.xbrl regardless of ixdsTarget parameter
-     For EDGAR style encoding of non-ASCII characters add --encodeSavedXmlChars
+- **Load multiple documents**:
 
-See COPYRIGHT.md for copyright information.
-'''
-from arelle import FileSource, ModelXbrl, ValidateXbrlDimensions, XbrlConst
-DialogURL = None # dynamically imported when first used
-from arelle.PrototypeDtsObject import LocPrototype, ArcPrototype
+  Simple:
+  ```bash
+  python arelleCmdLine.py --plugins inlineXbrlDocumentSet --file 'document-1.html|document-2.html'
+  ```
+
+  Verbose:
+  ```bash
+  python arelleCmdLine.py --plugins inlineXbrlDocumentSet --file '[{"ixds": [{"file1": "document-1.html", "file2": "document-2.html"}]}]'
+  ```
+
+- **Specify target document**:
+
+  - **Default target**:
+
+    Simple:
+    ```bash
+    python arelleCmdLine.py --plugins inlineXbrlDocumentSet --file report.zip --inlineTarget "(default)"
+    ```
+
+    Verbose:
+    ```bash
+    python arelleCmdLine.py --plugins inlineXbrlDocumentSet --file '[{"ixds": [{"file": "report.zip"}], "ixdsTarget": "(default)"}]'
+    ```
+
+  - **Named target (e.g., DKGAAP)**:
+
+    Simple:
+    ```bash
+    python arelleCmdLine.py --plugins inlineXbrlDocumentSet --file report.zip --inlineTarget DKGAAP
+    ```
+
+    Verbose:
+    ```bash
+    python arelleCmdLine.py --plugins inlineXbrlDocumentSet --file '[{"ixds": [{"file": "report.zip"}], "ixdsTarget": "DKGAAP"}]'
+    ```
+
+- **Load multiple IXDS sets**:
+
+  ```bash
+  python arelleCmdLine.py --plugins inlineXbrlDocumentSet --file '[{"ixds": [{"file": "report-1.zip"}]}, {"ixds": [{"file": "report-2.zip"}]}]'
+  ```
+
+- **Extract XML instance**:
+
+  ```bash
+  python arelleCmdLine.py --plugins inlineXbrlDocumentSet --file reports/report.html --saveInstance
+  ```
+
+### GUI Usage
+
+- **Load IXDS documents**:
+
+  1. Go to the File menu.
+  2. Select "Open File Inline Doc Set".
+  3. Ctrl/Cmd-click to select multiple files as an IXDS.
+
+- **Save XML instance**:
+
+  1. Load the IXDS.
+  2. Open the Tools menu.
+  3. Select "Save target document" to export the XML instance.
+
+## Additional Notes
+
+- On Windows, escape quotes and backslashes when using verbose JSON:
+  ```pwsh
+  .\\arelleCmdLine.exe --plugins inlineXbrlDocumentSet --file
+  "[{""ixds"":[{""file"":""C:\\\\report.zip""}], ""ixdsTarget"":""DKGAAP""}]"
+  ```
+- If no "ixdsTarget" is specified in JSON, all targets are loaded.
+- "(default)" matches the default IXDS target (i.e., no target defined in the instance).
+- Use "--encodeSavedXmlChars" to apply EDGAR-style encoding to non-ASCII characters.
+- The extracted XML instance is saved in the same directory with the suffix "_extracted.xbrl".
+"""
+from __future__ import annotations
+
+import os
+import zipfile
+from collections import defaultdict
+from optparse import SUPPRESS_HELP
+from typing import BinaryIO
+
+import regex as re
+from lxml.etree import XML, XMLSyntaxError
+
+from arelle import FileSource, ModelXbrl, ValidateDuplicateFacts, ValidateXbrlDimensions, XbrlConst
 from arelle.FileSource import archiveFilenameParts, archiveFilenameSuffixes
+from arelle.ModelDocument import ModelDocument, ModelDocumentReference, Type, create, inlineIxdsDiscover, load
 from arelle.ModelInstanceObject import ModelInlineFootnote
 from arelle.ModelObject import ModelObject
-from arelle.ModelDocument import ModelDocument, ModelDocumentReference, Type, load, create, inlineIxdsDiscover
 from arelle.ModelValue import INVALIDixVALUE, qname
 from arelle.PluginManager import pluginClassMethods
-from arelle.PythonUtil import attrdict
+from arelle.PrototypeDtsObject import ArcPrototype, LocPrototype
+from arelle.PythonUtil import attrdict, isLegacyAbs
+from arelle.RuntimeOptions import RuntimeOptions
 from arelle.UrlUtil import isHttpUrl
+from arelle.utils.EntryPointDetection import filesourceEntrypointFiles
+from arelle.ValidateDuplicateFacts import DeduplicationType
 from arelle.ValidateFilingText import CDATApattern
 from arelle.Version import authorLabel, copyrightLabel
-from arelle.XmlUtil import addChild, copyIxFootnoteHtml, elementFragmentIdentifier, elementChildSequence, xmlnsprefix, setXmlns
-from arelle.XmlValidate import validate as xmlValidate, VALID
-import os, zipfile
-import regex as re
-from optparse import SUPPRESS_HELP
-from lxml.etree import XML, XMLSyntaxError
-from collections import defaultdict
+from arelle.XmlUtil import (
+    addChild,
+    copyIxFootnoteHtml,
+    elementFragmentIdentifier,
+    setXmlns,
+    xmlnsprefix,
+)
+from arelle.XmlValidate import NONE, VALID
+from arelle.XmlValidate import validate as xmlValidate
 
 DEFAULT_TARGET = "(default)"
 IXDS_SURROGATE = "_IXDS#?#" # surrogate (fake) file name for inline XBRL doc set (IXDS)
@@ -91,7 +172,6 @@ class ModelInlineXbrlDocumentSet(ModelDocument):
             targetId = instanceElt.id
             self.targetDocumentId = targetId
             self.targetDocumentPreferredFilename = instanceElt.get('preferredFilename')
-            self.targetDocumentSchemaRefs = set()  # union all the instance schemaRefs
             for ixbrlElt in instanceElt.iter(tag="{http://disclosure.edinet-fsa.go.jp/2013/manifest}ixbrl"):
                 uri = ixbrlElt.textValue.strip()
                 if uri:
@@ -102,10 +182,14 @@ class ModelInlineXbrlDocumentSet(ModelDocument):
                         referencedDocument = ModelDocumentReference("inlineDocument", instanceElt)
                         referencedDocument.targetId = targetId
                         self.referencesDocument[doc] = referencedDocument
-                        self.ixNS = doc.ixNS
-                        for referencedDoc in doc.referencesDocument.keys():
-                            if referencedDoc.type == Type.SCHEMA:
-                                self.targetDocumentSchemaRefs.add(doc.relativeUri(referencedDoc.uri))
+                        if doc.type == Type.INLINEXBRL:
+                            self.ixNS = doc.ixNS
+                        elif doc.type == Type.UnknownXML:
+                            # Japanese manifests can include reports without tagging which are parsed as unknown XML
+                            for ns in doc.xmlRootElement.nsmap.values():
+                                if ns in XbrlConst.ixbrlAll:
+                                    self.ixNS = ns
+                                    break
         return True
 
 def loadDTS(modelXbrl, modelIxdsDocument):
@@ -124,7 +208,7 @@ def inlineXbrlDocumentSetLoader(modelXbrl, normalizedUri, filepath, isEntry=Fals
             elif "ixdsTarget" in kwargs: # passed from validate (multio test cases)
                 _target = kwargs["ixdsTarget"]
             else:
-                _target = modelXbrl.modelManager.formulaOptions.parameterValues["ixdsTarget"][1]
+                _target = modelXbrl.modelManager.formulaOptions.parameterValues[qname("ixdsTarget")][1]
             modelXbrl.ixdsTarget = None if _target == DEFAULT_TARGET else _target or None
         except (KeyError, AttributeError, IndexError, TypeError):
             pass # set later in selectTargetDocument plugin method
@@ -164,23 +248,31 @@ def inlineXbrlDocumentSetLoader(modelXbrl, normalizedUri, filepath, isEntry=Fals
         for url in modelXbrl.ixdsDocUrls:
             xml.append("<instance>{}</instance>\n".format(url))
         xml.append("</instances>\n")
-        ixdocset = create(modelXbrl, Type.INLINEXBRLDOCUMENTSET, docsetUrl, isEntry=True, initialXml="".join(xml))
+        ixdocset = create(modelXbrl, Type.INLINEXBRLDOCUMENTSET, docsetUrl, isEntry=True, initialXml="".join(xml), entrypoint=kwargs.get('entrypoint'))
         ixdocset.type = Type.INLINEXBRLDOCUMENTSET
-        ixdocset.targetDocumentSchemaRefs = set()  # union all the instance schemaRefs
+        ixdocset.targetDocumentPreferredFilename = None # possibly no inline docs in this doc set
         for i, elt in enumerate(ixdocset.xmlRootElement.iter(tag="instance")):
             # load ix document
             if ixdocs:
                 ixdoc = ixdocs[i]
-                ixdoc.modelXbrl = modelXbrl # TODO: this won't work for multi-targets sharing same html
             else:
-                ixdoc = load(modelXbrl, elt.text, referringElement=elt, isDiscovered=True)
+                # find entrypoint if any for this doc
+                entrypoint = None
+                if "ixds" in (kwargs.get("entrypoint") or {}):
+                    for ep in kwargs["entrypoint"]["ixds"]:
+                        if isinstance(ep,dict) and ep.get("file") == elt.text:
+                            entrypoint = ep
+                            break
+                elif kwargs.get("entrypoint", {}).get("file") == elt.text:
+                    entrypoint = ep
+                ixdoc = load(modelXbrl, elt.text, referringElement=elt, isDiscovered=True, entrypoint=entrypoint)
             if ixdoc is not None:
                 if ixdoc.type == Type.INLINEXBRL:
                     # set reference to ix document in document set surrogate object
                     referencedDocument = ModelDocumentReference("inlineDocument", elt)
                     ixdocset.referencesDocument[ixdoc] = referencedDocument
                     ixdocset.ixNS = ixdoc.ixNS # set docset ixNS
-                    if i == 0:
+                    if ixdocset.targetDocumentPreferredFilename is None:
                         ixdocset.targetDocumentPreferredFilename = os.path.splitext(ixdoc.uri)[0] + ".xbrl"
                     ixdoc.inDTS = True # behaves like an entry
                 else:
@@ -193,20 +285,27 @@ def inlineXbrlDocumentSetLoader(modelXbrl, normalizedUri, filepath, isEntry=Fals
         if hasattr(modelXbrl, "ixdsHtmlElements"): # has any inline root elements
             if ixdocs:
                 loadDTS(modelXbrl, ixdocset)
-            inlineIxdsDiscover(modelXbrl, ixdocset) # compile cross-document IXDS references
-            for referencedDoc in ixdocset.referencesDocument.keys():
-                if referencedDoc.type == Type.SCHEMA:
-                    ixdocset.targetDocumentSchemaRefs.add(ixdoc.relativeUri(referencedDoc.uri))
+                modelXbrl.isSupplementalIxdsTarget = True
+            inlineIxdsDiscover(modelXbrl, ixdocset, bool(ixdocs), **kwargs) # compile cross-document IXDS references
             return ixdocset
     return None
 
 # baseXmlLang: set on root xbrli:xbrl element
 # defaultXmlLang: if a fact/footnote has a different lang, provide xml:lang on it.
-def createTargetInstance(modelXbrl, targetUrl, targetDocumentSchemaRefs, filingFiles, baseXmlLang=None, defaultXmlLang=None, skipInvalid=False, xbrliNamespacePrefix=None):
+def createTargetInstance(
+        modelXbrl,
+        targetUrl,
+        targetDocumentSchemaRefs,
+        filingFiles,
+        baseXmlLang=None,
+        defaultXmlLang=None,
+        skipInvalid=False,
+        xbrliNamespacePrefix=None,
+        deduplicationType: ValidateDuplicateFacts.DeduplicationType | None = None):
     def addLocallyReferencedFile(elt,filingFiles):
         if elt.tag in ("a", "img"):
             for attrTag, attrValue in elt.items():
-                if attrTag in ("href", "src") and not isHttpUrl(attrValue) and not os.path.isabs(attrValue):
+                if attrTag in ("href", "src") and not isHttpUrl(attrValue) and not isLegacyAbs(attrValue):
                     attrValue = attrValue.partition('#')[0] # remove anchor
                     if attrValue: # ignore anchor references to base document
                         attrValue = os.path.normpath(attrValue) # change url path separators to host separators
@@ -266,10 +365,20 @@ def createTargetInstance(modelXbrl, targetUrl, targetDocumentSchemaRefs, filingF
     modelXbrl.modelManager.showStatus(_("Creating and validating facts"))
     newFactForOldObjId = {}
     invalidFacts = []
+    duplicateFacts = frozenset()
+    if deduplicationType is not None:
+        modelXbrl.modelManager.showStatus(_("Deduplicating facts"))
+        deduplicatedFacts = frozenset(ValidateDuplicateFacts.getDeduplicatedFacts(modelXbrl, deduplicationType))
+        duplicateFacts = frozenset(f for f in modelXbrl.facts if f not in deduplicatedFacts)
+
     def createFacts(facts, parent):
         for fact in facts:
+            if fact in duplicateFacts:
+                ValidateDuplicateFacts.logDeduplicatedFact(modelXbrl, fact)
+                continue
             if fact.xValid < VALID and skipInvalid:
-                invalidFacts.append(fact)
+                if fact.xValid < NONE: # don't report Redacted facts
+                    invalidFacts.append(fact)
             elif fact.isItem: # HF does not de-duplicate, which is currently-desired behavior
                 modelConcept = fact.concept # isItem ensures concept is not None
                 attrs = {"contextRef": fact.contextID}
@@ -332,7 +441,7 @@ def createTargetInstance(modelXbrl, targetUrl, targetDocumentSchemaRefs, filingF
         arcrole, linkrole, linkqname, arcqname = linkKey
         if (linkrole and linkqname and arcqname and  # fully specified roles
             arcrole != "XBRL-footnotes" and
-            any(lP.modelDocument.type == Type.INLINEXBRL for lP in linkPrototypes)):
+            any(lP.modelDocument.type in (Type.INLINEXBRL, Type.INLINEXBRLDOCUMENTSET) for lP in linkPrototypes)):
             for linkPrototype in linkPrototypes:
                 if linkPrototype not in footnoteLinks[linkrole]:
                     footnoteLinks[linkrole].append(linkPrototype)
@@ -371,7 +480,15 @@ def createTargetInstance(modelXbrl, targetUrl, targetDocumentSchemaRefs, filingF
                             addLocallyReferencedFile(elt,filingFiles)
     return targetInstance
 
-def saveTargetDocument(modelXbrl, targetDocumentFilename, targetDocumentSchemaRefs, outputZip=None, filingFiles=None, xbrliNamespacePrefix=None, *args, **kwargs):
+def saveTargetDocument(
+        modelXbrl,
+        targetDocumentFilename,
+        targetDocumentSchemaRefs,
+        outputZip=None,
+        filingFiles=None,
+        xbrliNamespacePrefix=None,
+        deduplicationType: DeduplicationType | None = None,
+        *args, **kwargs):
     targetUrl = modelXbrl.modelManager.cntlr.webCache.normalizeUrl(targetDocumentFilename, modelXbrl.modelDocument.filepath)
     targetUrlParts = targetUrl.rpartition(".")
     targetUrl = targetUrlParts[0] + "_extracted." + targetUrlParts[2]
@@ -381,7 +498,10 @@ def saveTargetDocument(modelXbrl, targetDocumentFilename, targetDocumentSchemaRe
     baseXmlLang = htmlRootElt.get("{http://www.w3.org/XML/1998/namespace}lang") or htmlRootElt.get("lang")
     for ixElt in modelXbrl.modelDocument.xmlRootElement.iterdescendants(tag="{http://www.w3.org/1999/xhtml}body"):
         baseXmlLang = ixElt.get("{http://www.w3.org/XML/1998/namespace}lang") or htmlRootElt.get("lang") or baseXmlLang
-    targetInstance = createTargetInstance(modelXbrl, targetUrl, targetDocumentSchemaRefs, filingFiles, baseXmlLang, xbrliNamespacePrefix=xbrliNamespacePrefix)
+    targetInstance = createTargetInstance(
+        modelXbrl, targetUrl, targetDocumentSchemaRefs, filingFiles, baseXmlLang,
+        xbrliNamespacePrefix=xbrliNamespacePrefix, deduplicationType=deduplicationType,
+    )
     targetInstance.saveInstance(overrideFilepath=targetUrl, outputZip=outputZip, xmlcharrefreplace=kwargs.get("encodeSavedXmlChars", False))
     if getattr(modelXbrl, "isTestcaseVariation", False):
         modelXbrl.extractedInlineInstance = True # for validation comparison
@@ -399,9 +519,6 @@ def discoverInlineXbrlDocumentSet(modelDocument, *args, **kwargs):
     return False  # not discoverable by this plug-in
 
 def fileOpenMenuEntender(cntlr, menu, *args, **kwargs):
-    # install DialogURL for GUI menu operation of runOpenWebInlineDocumentSetMenuCommand
-    global DialogURL
-    from arelle import DialogURL
     # Extend menu with an item for the savedts plugin
     menu.insert_command(2, label="Open Web Inline Doc Set",
                         underline=0,
@@ -426,6 +543,7 @@ def runOpenFileInlineDocumentSetMenuCommand(cntlr, runInBackground=False, saveTa
     runOpenInlineDocumentSetMenuCommand(cntlr, filenames, runInBackground, saveTargetFiling)
 
 def runOpenWebInlineDocumentSetMenuCommand(cntlr, runInBackground=False, saveTargetFiling=False):
+    from arelle import DialogURL
     url = DialogURL.askURL(cntlr.parent, buttonSEC=True, buttonRSS=True)
     if url:
         runOpenInlineDocumentSetMenuCommand(cntlr, re.split(r",\s*|\s+", url), runInBackground, saveTargetFiling)
@@ -441,8 +559,22 @@ def runOpenInlineDocumentSetMenuCommand(cntlr, filenames, runInBackground=False,
         from arelle.FileSource import openFileSource
         filesource = openFileSource(filenames[0], cntlr)
         if filesource.isArchive:
-            from arelle import DialogOpenArchive
-            archiveEntries = DialogOpenArchive.askArchiveFile(cntlr, filesource, multiselect=True)
+            # identify entrypoint files
+            try:
+                entrypointFiles = filesourceEntrypointFiles(filesource, inlineOnly=True)
+                l = len(filesource.baseurl) + 1 # len of the base URL of the archive
+                selectFiles = [e["file"][l:] for e in entrypointFiles if "file" in e] + \
+                              [e["file"][l:] for i in entrypointFiles if "ixds" in i for e in i["ixds"] if "file" in e]
+            except FileSource.ArchiveFileIOError:
+                selectFiles = None
+            if filesource.isReportPackage:
+                archiveEntries = [
+                    f.get("file") for ixds in entrypointFiles
+                    for f in ixds.get("ixds", [])
+                ]
+            else:
+                from arelle import DialogOpenArchive
+                archiveEntries = DialogOpenArchive.askArchiveFile(cntlr, filesource, multiselect=True, selectFiles=selectFiles)
             if archiveEntries:
                 ixdsFirstFile = archiveEntries[0]
                 _archiveFilenameParts = archiveFilenameParts(ixdsFirstFile)
@@ -472,11 +604,18 @@ def runOpenInlineDocumentSetMenuCommand(cntlr, filenames, runInBackground=False,
         cntlr.fileOpenFile(filename)
 
 
-def runSaveTargetDocumentMenuCommand(cntlr, runInBackground=False, saveTargetFiling=False, encodeSavedXmlChars=False, xbrliNamespacePrefix=None):
-    # skip if another class handles saving (e.g., EdgarRenderer)
-    for pluginXbrlMethod in pluginClassMethods('InlineDocumentSet.SavesTargetInstance'):
-        if pluginXbrlMethod():
-            return # saving of target instance is handled by another class
+def runSaveTargetDocumentMenuCommand(
+        cntlr,
+        runInBackground=False,
+        saveTargetFiling=False,
+        encodeSavedXmlChars=False,
+        xbrliNamespacePrefix=None,
+        sourceZipStream: BinaryIO | None = None,
+        responseZipStream: BinaryIO | None = None,
+        deduplicationType: DeduplicationType | None = None):
+    # skip if another class handles saving (e.g., EDGAR/render)
+    if saveTargetInstanceOverriden(deduplicationType):
+        return
     # save DTS menu item has been invoked
     if (cntlr.modelManager is None or
         cntlr.modelManager.modelXbrl is None or
@@ -487,6 +626,9 @@ def runSaveTargetDocumentMenuCommand(cntlr, runInBackground=False, saveTargetFil
     if modelDocument.type == Type.INLINEXBRLDOCUMENTSET:
         targetFilename = modelDocument.targetDocumentPreferredFilename
         targetSchemaRefs = modelDocument.targetDocumentSchemaRefs
+        if targetFilename is None:
+            cntlr.addToLog("No inline XBRL document in the inline XBRL document set.")
+            return
     else:
         filepath, fileext = os.path.splitext(modelDocument.filepath)
         if fileext not in (".xml", ".xbrl"):
@@ -498,13 +640,17 @@ def runSaveTargetDocumentMenuCommand(cntlr, runInBackground=False, saveTargetFil
     if runInBackground:
         import threading
         thread = threading.Thread(target=lambda _x = modelDocument.modelXbrl, _f = targetFilename, _s = targetSchemaRefs:
-                                        saveTargetDocument(_x, _f, _s))
+                                        saveTargetDocument(_x, _f, _s, deduplicationType=deduplicationType))
         thread.daemon = True
         thread.start()
     else:
+        filingZip = None
+        filingFiles = set()
+        if responseZipStream is not None:
+            filingZip = zipfile.ZipFile(responseZipStream, 'w', zipfile.ZIP_DEFLATED, True)
         if saveTargetFiling:
-            filingZip = zipfile.ZipFile(os.path.splitext(targetFilename)[0] + ".zip", 'w', zipfile.ZIP_DEFLATED, True)
-            filingFiles = set()
+            if filingZip is None:
+                filingZip = zipfile.ZipFile(os.path.splitext(targetFilename)[0] + ".zip", 'w', zipfile.ZIP_DEFLATED, True)
             # copy referencedDocs to two levels
             def addRefDocs(doc):
                 for refDoc in doc.referencesDocument.keys():
@@ -513,14 +659,25 @@ def runSaveTargetDocumentMenuCommand(cntlr, runInBackground=False, saveTargetFil
                         addRefDocs(refDoc)
             addRefDocs(modelDocument)
         else:
-            filingZip = None
             filingFiles = None
-        saveTargetDocument(modelDocument.modelXbrl, targetFilename, targetSchemaRefs, filingZip, filingFiles, encodeSavedXmlChars=encodeSavedXmlChars, xbrliNamespacePrefix=xbrliNamespacePrefix)
+        saveTargetDocument(modelDocument.modelXbrl, targetFilename, targetSchemaRefs, filingZip, filingFiles,
+                           encodeSavedXmlChars=encodeSavedXmlChars, xbrliNamespacePrefix=xbrliNamespacePrefix,
+                           deduplicationType=deduplicationType)
         if saveTargetFiling:
             instDir = os.path.dirname(modelDocument.uri.split(IXDS_DOC_SEPARATOR)[0])
-            for refFile in filingFiles:
-                if refFile.startswith(instDir):
-                    filingZip.write(refFile, modelDocument.relativeUri(refFile))
+            copyFilingPaths = [
+                (f, modelDocument.relativeUri(f))
+                for f in filingFiles if f.startswith(instDir)
+            ]
+            if sourceZipStream is not None:
+                with zipfile.ZipFile(sourceZipStream, 'r') as sourceZip:
+                    for filingFile, arcname in copyFilingPaths:
+                        filingFile = filingFile.replace(instDir + os.sep, "")
+                        sourceFile = sourceZip.read(filingFile)
+                        filingZip.writestr(arcname, sourceFile)
+            else:
+                for filingFile, arcname in copyFilingPaths:
+                    filingZip.write(filingFile, arcname)
 
 
 def commandLineOptionExtender(parser, *args, **kwargs):
@@ -563,10 +720,54 @@ def commandLineOptionExtender(parser, *args, **kwargs):
                       dest="xbrliNamespacePrefix",
                       help=SUPPRESS_HELP,
                       type="string")
+    parser.add_option("--deduplicateIxbrlFacts",
+                      action="store",
+                      choices=[a.value for a in ValidateDuplicateFacts.DeduplicationType],
+                      dest="deduplicateIxbrlFacts",
+                      help=_("Remove duplicate facts when extracting XBRL instance."))
+    parser.add_option("--deduplicateixbrlfacts",  # for WEB SERVICE use
+                      action="store",
+                      choices=[a.value for a in ValidateDuplicateFacts.DeduplicationType],
+                      dest="deduplicateIxbrlFacts",
+                      help=SUPPRESS_HELP)
+    parser.add_option("--inlineTarget",
+                      action="store",
+                      dest="inlineTarget",
+                      help=_("Specify an inline target to load. By default, all targets are loaded. Use '{}' to select the default target.").format(DEFAULT_TARGET),
+                      type="string")
 
 def commandLineFilingStart(cntlr, options, filesource, entrypointFiles, *args, **kwargs):
     global skipExpectedInstanceComparison
     skipExpectedInstanceComparison = getattr(options, "skipExpectedInstanceComparison", False)
+    filingStart(
+        cntlr,
+        entrypointFiles,
+        getattr(options, "inlineTarget", None),
+    )
+
+def guiFilingStart(cntlr, filesource, entrypointFiles, *args, **kwargs):
+    global skipExpectedInstanceComparison
+    skipExpectedInstanceComparison = False
+    filingStart(
+        cntlr,
+        entrypointFiles,
+        inlineTarget=None
+    )
+
+def filingStart(cntlr, entrypointFiles, inlineTarget):
+    if inlineTarget:
+        if isinstance(entrypointFiles, dict):
+            entrypointFiles = [entrypointFiles]
+        if isinstance(entrypointFiles, list):
+            for i, entry in enumerate(entrypointFiles):
+                entryTarget = entry.get("ixdsTarget")
+                if entryTarget and entryTarget != inlineTarget:
+                    raise RuntimeError(_("Conflicting ixds targets specified: inlineTarget '{}', ixdsTarget '{}'").format(inlineTarget, entryTarget))
+                ixds = entry.get("ixds")
+                if ixds is None:
+                    entry = {"ixds": [entry]}
+                    entrypointFiles[i] = entry
+                entry["ixdsTarget"] = inlineTarget
     if isinstance(entrypointFiles, list):
         # check for any inlineDocumentSet in list
         for entrypointFile in entrypointFiles:
@@ -608,11 +809,28 @@ def commandLineFilingStart(cntlr, options, filesource, entrypointFiles, *args, *
                     entrypointFile["file"] = docsetSurrogatePath + IXDS_DOC_SEPARATOR.join(_files)
 
 
-def commandLineXbrlRun(cntlr, options, modelXbrl, *args, **kwargs):
-    # skip if another class handles saving (e.g., EdgarRenderer)
+def saveTargetInstanceOverriden(deduplicationType: DeduplicationType | None) -> bool:
+    """
+    Checks if another plugin implements instance extraction, and throws an exception
+    if the provided arguments are not compatible.
+    :param deduplicationType: The deduplication type to be used, if set.
+    :return: True if instance extraction is overridden by another plugin.
+    """
     for pluginXbrlMethod in pluginClassMethods('InlineDocumentSet.SavesTargetInstance'):
         if pluginXbrlMethod():
-            return # saving of target instance is handled by another class
+            if deduplicationType is not None:
+                raise RuntimeError(_('Deduplication is enabled but could not be performed because instance '
+                                   'extraction was performed by another plugin.'))
+            return True
+    return False
+
+
+def commandLineXbrlRun(cntlr, options: RuntimeOptions, modelXbrl, *args, **kwargs):
+    deduplicationTypeArg = getattr(options, "deduplicateIxbrlFacts", None)
+    deduplicationType = None if deduplicationTypeArg is None else DeduplicationType(deduplicationTypeArg)
+    # skip if another class handles saving (e.g., EDGAR/render)
+    if saveTargetInstanceOverriden(deduplicationType):
+        return
     # extend XBRL-loaded run processing for this option
     if getattr(options, "saveTargetInstance", False) or getattr(options, "saveTargetFiling", False):
         if cntlr.modelManager is None or cntlr.modelManager.modelXbrl is None or (
@@ -623,7 +841,10 @@ def commandLineXbrlRun(cntlr, options, modelXbrl, *args, **kwargs):
                                          runInBackground=False,
                                          saveTargetFiling=getattr(options, "saveTargetFiling", False),
                                          encodeSavedXmlChars=getattr(options, "encodeSavedXmlChars", False),
-                                         xbrliNamespacePrefix=getattr(options, "xbrliNamespacePrefix"))
+                                         xbrliNamespacePrefix=getattr(options, "xbrliNamespacePrefix"),
+                                         sourceZipStream=kwargs.get("sourceZipStream", None),
+                                         responseZipStream=kwargs.get("responseZipStream", None),
+                                         deduplicationType=deduplicationType)
 
 def testcaseVariationReadMeFirstUris(modelTestcaseVariation):
     _readMeFirstUris = [os.path.join(modelTestcaseVariation.modelDocument.filepathdir,
@@ -706,7 +927,7 @@ def discoverIxdsDts(modelXbrl):
 
 class TargetChoiceDialog:
     def __init__(self,parent, choices):
-        from tkinter import Toplevel, Label, Listbox, StringVar
+        from tkinter import Listbox, StringVar, Toplevel
         parentGeometry = re.match(r"(\d+)x(\d+)[+]?([-]?\d+)[+]?([-]?\d+)", parent.geometry())
         dialogX = int(parentGeometry.group(3))
         dialogY = int(parentGeometry.group(4))
@@ -733,12 +954,12 @@ def ixdsTargets(ixdsHtmlElements):
                               for htmlElt in ixdsHtmlElements
                               for elt in htmlElt.iterfind(f".//{{{htmlElt.modelDocument.ixNS}}}references")))
 
-def selectTargetDocument(modelXbrl, modelIxdsDocument):
+def selectTargetDocument(modelXbrl, modelIxdsDocument, **kwargs):
     if not hasattr(modelXbrl, "ixdsTarget"): # DTS discoverey deferred until all ix docs loaded
         # isolate any documents to separate IXDSes according to authority submission rules
         modelXbrl.targetIXDSesToLoad = [] # [[target,[ixdsHtmlElements], ...]
         for pluginXbrlMethod in pluginClassMethods('InlineDocumentSet.IsolateSeparateIXDSes'):
-            separateIXDSesHtmlElements = pluginXbrlMethod(modelXbrl)
+            separateIXDSesHtmlElements = pluginXbrlMethod(modelXbrl, modelIxdsDocument, **kwargs)
             if len(separateIXDSesHtmlElements) > 1: # [[ixdsHtml1, ixdsHtml2], [ixdsHtml3...] ...]
                 for separateIXDSHtmlElements in separateIXDSesHtmlElements[1:]:
                     toLoadIXDS = [ixdsTargets(separateIXDSHtmlElements),[]]
@@ -766,10 +987,12 @@ def selectTargetDocument(modelXbrl, modelIxdsDocument):
                 dlg = TargetChoiceDialog(modelXbrl.modelManager.cntlr.parent, _targets)
                 _target = dlg.selection
         else:
+            # load all targets (supplemental are accessed from first via modelXbrl.loadedModelXbrls)
+            modelXbrl.targetIXDSesToLoad.insert(0, [_targets[1:],modelXbrl.ixdsHtmlElements])
             _target = _targets[0]
-            modelXbrl.warning("arelle:unspecifiedTargetDocument",
-                              _("Target document not specified, loading %(target)s, found targets %(targets)s"),
-                              modelObject=modelXbrl, target=_target, targets=_targets)
+            #modelXbrl.warning("arelle:unspecifiedTargetDocument",
+            #                  _("Target document not specified, loading %(target)s, found targets %(targets)s"),
+            #                  modelObject=modelXbrl, target=_target, targets=_targets)
         modelXbrl.ixdsTarget = None if _target == DEFAULT_TARGET else _target or None
         # load referenced schemas and linkbases (before validating inline HTML
         loadDTS(modelXbrl, modelIxdsDocument)
@@ -791,6 +1014,11 @@ def ixdsTargetDiscoveryCompleted(modelXbrl, modelIxdsDocument):
                                    useFileSource=modelXbrl.fileSource, ixdsTarget=target, ixdsHtmlElements=ixdsHtmlElements)
                 )
         modelXbrl.modelManager.loadedModelXbrls.extend(modelXbrl.supplementalModelXbrls)
+    # provide schema references for IXDS document
+    modelIxdsDocument.targetDocumentSchemaRefs = set()  # union all the instance schemaRefs
+    for referencedDoc in modelIxdsDocument.referencesDocument.keys():
+        if referencedDoc.type == Type.SCHEMA:
+            modelIxdsDocument.targetDocumentSchemaRefs.add(modelIxdsDocument.relativeUri(referencedDoc.uri))
 
 __pluginInfo__ = {
     'name': 'Inline XBRL Document Set',
@@ -805,6 +1033,7 @@ __pluginInfo__ = {
     'InlineDocumentSet.Discovery': inlineDocsetDiscovery,
     'InlineDocumentSet.Url.Separator': inlineDocsetUrlSeparator,
     'InlineDocumentSet.CreateTargetInstance': createTargetInstance,
+    'CntlrWinMain.Filing.Start': guiFilingStart,
     'CntlrWinMain.Menu.File.Open': fileOpenMenuEntender,
     'CntlrWinMain.Menu.Tools': saveTargetDocumentMenuEntender,
     'CntlrCmdLine.Options': commandLineOptionExtender,