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

arelle/packages/report/ReportPackage.py

@@ -0,0 +1,265 @@
+"""
+See COPYRIGHT.md for copyright information.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import zipfile
+from collections import defaultdict
+from dataclasses import dataclass
+from pathlib import Path, PurePosixPath
+from typing import TYPE_CHECKING, Any, cast
+
+from arelle.packages import PackageUtils
+from arelle.packages.report import ReportPackageConst as Const
+
+if TYPE_CHECKING:
+    from arelle.FileSource import FileSource
+
+
+def pathsContainReportsDirectory(paths: set[str], topLevelDir: str) -> bool:
+    reportDirectory = f"{topLevelDir}/{Const.REPORTS_DIRECTORY}"
+    if reportDirectory in paths:
+        return True
+    reportDirectory = f"{reportDirectory}/"
+    return any(path.startswith(reportDirectory) for path in paths)
+
+def getReportPackageTopLevelDirectory(filesource: FileSource) -> str | None:
+    packageEntries = set(filesource.dir or [])
+    potentialTopLevelReportDirs = set()
+    for topLevelDir in PackageUtils.getPackageTopLevelDirectories(filesource):
+        if (
+            f"{topLevelDir}/{Const.REPORT_PACKAGE_FILE}" in packageEntries or
+            pathsContainReportsDirectory(packageEntries, topLevelDir)
+        ):
+            potentialTopLevelReportDirs.add(topLevelDir)
+    if len(potentialTopLevelReportDirs) == 1:
+        return next(iter(potentialTopLevelReportDirs))
+    return None
+
+
+def getReportPackageJsonFile(filesource: FileSource, stld: str | None) -> str | None:
+    if not isinstance(filesource.fs, zipfile.ZipFile):
+        return None
+    # Match against original unsanitized file names and all their backslash glory.
+    packageOriginalFileNames = [f.orig_filename for f in filesource.fs.infolist()]
+    expectedFutureReportPackageJsonPath = Const.REPORT_PACKAGE_FILE
+    expectedReportPackageJsonPath = f"{stld}/{Const.REPORT_PACKAGE_FILE}"
+    futureReportPackageJsonPathPartialMatches = []
+    reportPackageJsonPathPartialMatches = []
+    for path in packageOriginalFileNames:
+        if path.startswith(expectedFutureReportPackageJsonPath):
+            futureReportPackageJsonPathPartialMatches.append(path)
+        elif path.startswith(expectedReportPackageJsonPath):
+            reportPackageJsonPathPartialMatches.append(path)
+
+    jsonPath = None
+    # Don't return content if there are duplicate entries or a directory with the same name as the json file.
+    if len(futureReportPackageJsonPathPartialMatches) == 1:
+        futureReportPackageJsonPath = futureReportPackageJsonPathPartialMatches[0]
+        if futureReportPackageJsonPath == expectedFutureReportPackageJsonPath:
+            jsonPath = expectedFutureReportPackageJsonPath
+    elif len(futureReportPackageJsonPathPartialMatches) == 0:
+        if len(reportPackageJsonPathPartialMatches) == 1:
+            reportPackageJsonPath = reportPackageJsonPathPartialMatches[0]
+            if reportPackageJsonPath == expectedReportPackageJsonPath:
+                jsonPath = expectedReportPackageJsonPath
+    return jsonPath
+
+
+def getPackageJson(filesource: FileSource, selection: str | None) -> dict[str, Any] | None:
+    if selection is None:
+        return None
+    initialSelection = filesource.selection
+    initialUrl = filesource.url
+    filesource.select(selection)
+    fullJsonFilePath = cast(str, filesource.url)
+    content = None
+    encodings = ["utf-8", "utf-8-sig"]
+    for encoding in encodings:
+        try:
+            with filesource.file(fullJsonFilePath, encoding=encoding)[0] as f:
+                content = cast(dict[str, Any], json.load(f, object_pairs_hook=forbidDuplicateKeys))
+                break
+        except (OSError, ValueError, zipfile.BadZipFile, json.JSONDecodeError):
+            continue
+    # Restore selection and url including initial taxonomy packages with url, but no selection.
+    filesource.selection = initialSelection
+    filesource.url = initialUrl
+    return content
+
+
+def forbidDuplicateKeys(pairs: list[tuple[Any, Any]]) -> Any:
+    seen = {}
+    for key, value in pairs:
+        if key in seen:
+            raise ValueError(f"duplicate key: {key}")
+        else:
+            seen[key] = value
+    return seen
+
+
+def getAllReportEntries(filesource: FileSource, stld: str | None) -> list[ReportEntry] | None:
+    if stld is None:
+        return None
+    if not isinstance(filesource.fs, zipfile.ZipFile):
+        return None
+    entries = [f.orig_filename for f in filesource.fs.infolist()]
+    if not pathsContainReportsDirectory(set(entries), stld):
+        return None
+    topReportEntries = []
+    entriesBySubDir = defaultdict(list)
+    for entry in entries:
+        if entry.endswith("/"):
+            continue
+        path = PurePosixPath(entry)
+        if path.suffix not in Const.REPORT_FILE_EXTENSIONS:
+            continue
+        if not (2 < len(path.parts) < 5):
+            continue
+        if not (path.parts[0] == stld and path.parts[1] == Const.REPORTS_DIRECTORY):
+            continue
+        if len(path.parts) == 3:
+            topReportEntries.append(entry)
+        else:
+            entriesBySubDir[path.parts[2]].append(entry)
+    assert isinstance(filesource.basefile, str)
+    reportEntries = [ReportEntry(filesource.basefile, [entry]) for entry in topReportEntries]
+    for entries in entriesBySubDir.values():
+        if len(entries) == 1 or all(PurePosixPath(entry).suffix in Const.INLINE_REPORT_FILE_EXTENSIONS for entry in entries):
+            reportEntries.append(ReportEntry(filesource.basefile, entries))
+        else:
+            reportEntries.extend(sorted(ReportEntry(filesource.basefile, [entry]) for entry in entries))
+    return sorted(reportEntries)
+
+
+@dataclass(frozen=True, order=True)
+class ReportEntry:
+    baseDir: str
+    files: list[str]
+
+    def __post_init__(self) -> None:
+        if len(self.files) == 0:
+            raise ValueError("Report entry must have at least one file")
+        elif len(self.files) > 1 and any(
+            PurePosixPath(f).suffix not in Const.INLINE_REPORT_FILE_EXTENSIONS for f in self.files
+        ):
+            raise ValueError("Non-inline report entries must be a single file")
+        primaryDir = os.path.dirname(self.primary)
+        if any(os.path.dirname(f) != primaryDir for f in self.files[1:]):
+            raise ValueError("Report entry files must all be in the same directory")
+
+    @property
+    def primary(self) -> str:
+        return self.files[0]
+
+    @property
+    def fullPathPrimary(self) -> str:
+        return f"{self.baseDir}/{self.primary}"
+
+    @property
+    def isInline(self) -> bool:
+        return PurePosixPath(self.primary).suffix in Const.INLINE_REPORT_FILE_EXTENSIONS
+
+    @property
+    def fullPathFiles(self) -> list[str]:
+        return [f"{self.baseDir}/{f}" for f in self.files]
+
+    @property
+    def isTopLevel(self) -> bool:
+        return len(PurePosixPath(self.primary).parts) == 3
+
+    @property
+    def dir(self) -> str:
+        return PurePosixPath(self.primary).parent.name
+
+
+class ReportPackage:
+    def __init__(
+        self,
+        reportPackageZip: zipfile.ZipFile,
+        stld: str | None,
+        reportType: Const.ReportType | None,
+        reportPackageJson: dict[str, Any] | None,
+        reports: list[ReportEntry] | None,
+    ) -> None:
+        self._reportPackageZip = reportPackageZip
+        self._stld = stld
+        self._reportType = reportType
+        self._reportPackageJson = reportPackageJson
+        self._allReports = reports
+        if self._allReports is None:
+            self._reports = None
+        else:
+            reportTypeFileExtensions = reportType.reportFileExtensions if reportType is not None else frozenset()
+            self._reports = [
+                report
+                for report in self._allReports
+                if all(PurePosixPath(f).suffix in reportTypeFileExtensions for f in report.files)
+            ]
+
+    @staticmethod
+    def fromFileSource(filesource: FileSource) -> ReportPackage | None:
+        if not filesource.isOpen:
+            filesource.open()
+        if not isinstance(filesource.fs, zipfile.ZipFile):
+            return None
+        if not isinstance(filesource.basefile, str):
+            raise ValueError(f"Report Package base file must be a string: {filesource.basefile}")
+        reportType = Const.ReportType.fromExtension(Path(filesource.basefile).suffix)
+        stld = getReportPackageTopLevelDirectory(filesource)
+        reportPackageJsonFile = getReportPackageJsonFile(filesource, stld)
+        reportPackageJson = None
+        if reportPackageJsonFile:
+            reportPackageJson = getPackageJson(filesource, reportPackageJsonFile)
+        reports = getAllReportEntries(filesource, stld)
+        if reportType == Const.ReportType.UNCONSTRAINED_REPORT_PACKAGE and reportPackageJsonFile is None and reports is None:
+            # A zip file, but not a report package.
+            return None
+        if reports is not None and any(report.isTopLevel for report in reports):
+            reports = [report for report in reports if report.isTopLevel]
+        return ReportPackage(
+            reportPackageZip=filesource.fs,
+            stld=stld,
+            reportType=reportType,
+            reportPackageJson=reportPackageJson,
+            reports=reports,
+        )
+
+    @property
+    def documentInfo(self) -> Any:
+        if self._reportPackageJson is None:
+            return None
+        return self._reportPackageJson.get("documentInfo")
+
+    @property
+    def documentType(self) -> Any:
+        if isinstance(self.documentInfo, dict):
+            return self.documentInfo.get("documentType")
+        return None
+
+    @property
+    def stld(self) -> str | None:
+        return self._stld
+
+    @property
+    def reportType(self) -> Const.ReportType | None:
+        return self._reportType
+
+    @property
+    def allReports(self) -> list[ReportEntry] | None:
+        return self._allReports
+
+    @property
+    def reports(self) -> list[ReportEntry] | None:
+        return self._reports
+
+    @property
+    def reportPackageJson(self) -> dict[str, Any] | None:
+        return self._reportPackageJson
+
+    @property
+    def reportPackageZip(self) -> zipfile.ZipFile:
+        return self._reportPackageZip

arelle/packages/report/ReportPackageConst.py

@@ -0,0 +1,79 @@
+"""
+See COPYRIGHT.md for copyright information.
+"""
+
+from __future__ import annotations
+
+from enum import Enum
+
+from arelle.packages.PackageConst import META_INF_DIRECTORY
+
+INLINE_XBRL_REPORT_PACKAGE_DOCUMENT_TYPE = "https://xbrl.org/report-package/2023/xbri"
+NON_INLINE_XBRL_REPORT_PACKAGE_DOCUMENT_TYPE = "https://xbrl.org/report-package/2023/xbr"
+UNCONSTRAINED_REPORT_PACKAGE_DOCUMENT_TYPE = "https://xbrl.org/report-package/2023"
+
+SUPPORTED_DOCUMENT_TYPES = frozenset(
+    [
+        INLINE_XBRL_REPORT_PACKAGE_DOCUMENT_TYPE,
+        NON_INLINE_XBRL_REPORT_PACKAGE_DOCUMENT_TYPE,
+        UNCONSTRAINED_REPORT_PACKAGE_DOCUMENT_TYPE,
+    ]
+)
+
+INLINE_XBRL_REPORT_PACKAGE_EXTENSION = ".xbri"
+NON_INLINE_XBRL_REPORT_PACKAGE_EXTENSION = ".xbr"
+UNCONSTRAINED_REPORT_PACKAGE_EXTENSION = ".zip"
+
+
+REPORT_PACKAGE_EXTENSIONS = frozenset(
+    [
+        INLINE_XBRL_REPORT_PACKAGE_EXTENSION,
+        NON_INLINE_XBRL_REPORT_PACKAGE_EXTENSION,
+        UNCONSTRAINED_REPORT_PACKAGE_EXTENSION,
+        UNCONSTRAINED_REPORT_PACKAGE_EXTENSION.upper(),
+    ]
+)
+
+REPORT_PACKAGE_FILE = f"{META_INF_DIRECTORY}/reportPackage.json"
+REPORTS_DIRECTORY = "reports"
+
+XBRL_2_1_REPORT_FILE_EXTENSION = ".xbrl"
+JSON_REPORT_FILE_EXTENSION = ".json"
+NON_INLINE_REPORT_FILE_EXTENSIONS = frozenset([
+    XBRL_2_1_REPORT_FILE_EXTENSION,
+    JSON_REPORT_FILE_EXTENSION,
+])
+INLINE_REPORT_FILE_EXTENSIONS = frozenset([".xhtml", ".html", ".htm"])
+REPORT_FILE_EXTENSIONS = frozenset(
+    [
+        *NON_INLINE_REPORT_FILE_EXTENSIONS,
+        *INLINE_REPORT_FILE_EXTENSIONS,
+    ]
+)
+
+
+class ReportType(Enum):
+    INLINE_XBRL_REPORT_PACKAGE = INLINE_XBRL_REPORT_PACKAGE_EXTENSION
+    NON_INLINE_XBRL_REPORT_PACKAGE = NON_INLINE_XBRL_REPORT_PACKAGE_EXTENSION
+    UNCONSTRAINED_REPORT_PACKAGE = UNCONSTRAINED_REPORT_PACKAGE_EXTENSION
+
+    @staticmethod
+    def fromExtension(extension: str) -> ReportType | None:
+        for reportType in ReportType:
+            if reportType.value == extension.lower():
+                return reportType
+        return None
+
+    @property
+    def reportFileExtensions(self) -> frozenset[str]:
+        if self == ReportType.INLINE_XBRL_REPORT_PACKAGE:
+            return INLINE_REPORT_FILE_EXTENSIONS
+        if self == ReportType.NON_INLINE_XBRL_REPORT_PACKAGE:
+            return NON_INLINE_REPORT_FILE_EXTENSIONS
+        if self == ReportType.UNCONSTRAINED_REPORT_PACKAGE:
+            return REPORT_FILE_EXTENSIONS
+        raise ValueError(f"Report type without defined report file extensions: {self}")
+
+    @property
+    def isConstrained(self) -> bool:
+        return self != ReportType.UNCONSTRAINED_REPORT_PACKAGE

arelle/packages/report/ReportPackageValidator.py

@@ -0,0 +1,207 @@
+"""
+See COPYRIGHT.md for copyright information.
+"""
+
+from __future__ import annotations
+
+from collections import Counter
+from collections.abc import Generator
+from pathlib import Path, PurePosixPath
+from typing import TYPE_CHECKING
+
+from arelle.packages import PackageValidation
+from arelle.packages.PackageType import PackageType
+from arelle.packages.report import ReportPackageConst as Const
+from arelle.packages.report.ReportPackage import (
+    getAllReportEntries,
+    getPackageJson,
+    getReportPackageJsonFile,
+    getReportPackageTopLevelDirectory,
+)
+from arelle.typing import TypeGetText
+from arelle.utils.validate.Validation import Validation
+
+if TYPE_CHECKING:
+    from arelle.FileSource import FileSource
+
+_: TypeGetText
+
+
+REPORT_PACKAGE_TYPE = PackageType("Report", "rpe")
+
+REPORT_PACKAGE_ABORTING_VALIDATIONS = (
+    PackageValidation.validatePackageZipFormat,
+    PackageValidation.validateZipFileSeparators,
+    PackageValidation.validatePackageNotEncrypted,
+    PackageValidation.validateTopLevelDirectories,
+    PackageValidation.validateDuplicateEntries,
+    PackageValidation.validateConflictingEntries,
+    PackageValidation.validateEntries,
+)
+
+REPORT_PACKAGE_NON_ABORTING_VALIDATIONS = (PackageValidation.validateMetadataDirectory,)
+
+
+class ReportPackageValidator:
+    def __init__(self, filesource: FileSource) -> None:
+        self._filesource = filesource
+        assert isinstance(self._filesource.basefile, str)
+        self._reportType = Const.ReportType.fromExtension(Path(self._filesource.basefile).suffix)
+        self._stld = getReportPackageTopLevelDirectory(self._filesource)
+        self._reportPackageJsonFile = getReportPackageJsonFile(self._filesource, self._stld)
+
+    def validate(self) -> Generator[Validation, None, None]:
+        if self._filesource.reportPackage is not None and self._filesource.reportPackage.reportType is None:
+            yield Validation.error(
+                "rpe:unsupportedFileExtension",
+                _("Report package has unsupported file extension."),
+            )
+            return
+        for validation in REPORT_PACKAGE_ABORTING_VALIDATIONS:
+            if error := validation(REPORT_PACKAGE_TYPE, self._filesource):
+                yield error
+                return
+        if (error := self._validatePackageJson()) or (error := self._validateReports()):
+            yield error
+        return
+
+    def _validatePackageJson(self) -> Validation | None:
+        reportPackageJson = getPackageJson(self._filesource, self._reportPackageJsonFile)
+        if reportPackageJson is None:
+            if self._reportPackageJsonFile in (self._filesource.dir or []):
+                return Validation.error(
+                    "rpe:invalidJSON",
+                    _("Report package JSON file must be a valid JSON file, per RFC 8259."),
+                )
+            elif self._reportType in {
+                Const.ReportType.NON_INLINE_XBRL_REPORT_PACKAGE,
+                Const.ReportType.INLINE_XBRL_REPORT_PACKAGE,
+            }:
+                return Validation.error(
+                    "rpe:documentTypeFileExtensionMismatch",
+                    _("%(reportType)s report package requires a report package JSON file"),
+                    reportType="Inline"
+                    if self._reportType == Const.ReportType.INLINE_XBRL_REPORT_PACKAGE
+                    else "Non-Inline",
+                )
+            return None
+        documentInfo = reportPackageJson.get("documentInfo")
+        if not isinstance(documentInfo, dict):
+            return Validation.error(
+                "rpe:invalidJSONStructure",
+                _("Report package 'documentInfo' must resolve to a JSON object: %(documentInfo)s"),
+                documentInfo=documentInfo,
+            )
+        documentType = documentInfo.get("documentType")
+        if not isinstance(documentType, str):
+            return Validation.error(
+                "rpe:invalidJSONStructure",
+                _("Report package type 'documentInfo.documentType' must resolve to a JSON string: %(documentType)s"),
+                documentType=documentType,
+            )
+        if documentType not in Const.SUPPORTED_DOCUMENT_TYPES or self._stld is None:
+            return Validation.error(
+                "rpe:unsupportedReportPackageVersion",
+                _("Report package document type '%(documentType)s' is not supported."),
+                documentType=documentType,
+            )
+        validDocumentTypeForFileExtension = True
+        if documentType == Const.INLINE_XBRL_REPORT_PACKAGE_DOCUMENT_TYPE:
+            validDocumentTypeForFileExtension = self._reportType == Const.ReportType.INLINE_XBRL_REPORT_PACKAGE
+        elif documentType == Const.NON_INLINE_XBRL_REPORT_PACKAGE_DOCUMENT_TYPE:
+            validDocumentTypeForFileExtension = self._reportType == Const.ReportType.NON_INLINE_XBRL_REPORT_PACKAGE
+        elif documentType == Const.UNCONSTRAINED_REPORT_PACKAGE_DOCUMENT_TYPE:
+            validDocumentTypeForFileExtension = self._reportType == Const.ReportType.UNCONSTRAINED_REPORT_PACKAGE
+        else:
+            return Validation.error(
+                "rpe:unsupportedReportPackageVersion",
+                _("Report package document type '%(documentType)s' is not supported."),
+                documentType=documentType,
+            )
+        if not validDocumentTypeForFileExtension:
+            return Validation.error(
+                "rpe:documentTypeFileExtensionMismatch",
+                _("Report package document type '%(documentType)s' does not match the file extension: %(reportType)s"),
+                documentType=documentType,
+                reportType=self._reportType.value if self._reportType is not None else None,
+            )
+        return None
+
+    def _validateReports(self) -> Validation | None:
+        reportEntries = getAllReportEntries(self._filesource, self._stld)
+        filesourceFiles = self._filesource.dir or []
+        topLevelDir = f"{self._stld}/" if self._stld else ""
+        reportsDirExist = any(entry.startswith(f"{topLevelDir}/reports") for entry in filesourceFiles)
+        reportPackageJsonFileExist = f"{self._stld}/{Const.REPORT_PACKAGE_FILE}" in filesourceFiles
+        if not reportsDirExist and not reportPackageJsonFileExist:
+            return None
+        if self._reportType is not None:
+            if not any(entry.startswith(f"{self._stld}/reports") for entry in self._filesource.dir or []):
+                return Validation.error(
+                    "rpe:missingReportsDirectory",
+                    _("Report package must contain a reports directory"),
+                )
+            if not reportEntries:
+                return Validation.error(
+                    "rpe:missingReport",
+                    _("Report package must contain at least one report"),
+                )
+            if len(reportEntries) > 1 and not any(report.isTopLevel for report in reportEntries):
+                reportEntriesBySubDir = Counter(report.dir for report in reportEntries or [] if not report.isTopLevel)
+                if any(subdirCount > 1 for subdirCount in reportEntriesBySubDir.values()):
+                    return Validation.error(
+                        "rpe:multipleReportsInSubdirectory",
+                        _("Report package must contain only one report"),
+                    )
+            if self._reportType == Const.ReportType.NON_INLINE_XBRL_REPORT_PACKAGE:
+                if len(reportEntries) > 1:
+                    return Validation.error(
+                        "rpe:multipleReports",
+                        _("Non-inline XBRL report package must contain only one report"),
+                    )
+                if any(
+                    PurePosixPath(entry.primary).suffix not in Const.NON_INLINE_REPORT_FILE_EXTENSIONS
+                    for entry in reportEntries
+                ):
+                    return Validation.error(
+                        "rpe:incorrectReportType",
+                        _("Non-inline XBRL report package must contain only non-inline XBRL reports"),
+                    )
+                for report in reportEntries or []:
+                    if PurePosixPath(report.primary).suffix == Const.JSON_REPORT_FILE_EXTENSION:
+                        reportContent = getPackageJson(self._filesource, report.primary)
+                        if reportContent is None:
+                            return Validation.error(
+                                "rpe:invalidJSON",
+                                _("Non-inline XBRL report package must contain only valid JSON reports"),
+                            )
+                        reportDocumentInfo = reportContent.get("documentInfo")
+                        if not isinstance(reportDocumentInfo, dict):
+                            return Validation.error(
+                                "rpe:invalidJSONStructure",
+                                _("Report package 'documentInfo' must resolve to a JSON object: %(documentInfo)s"),
+                                documentInfo=reportDocumentInfo,
+                            )
+                        reportDocumentType = reportDocumentInfo.get("documentType")
+                        if not isinstance(reportDocumentType, str):
+                            return Validation.error(
+                                "rpe:invalidJSONStructure",
+                                _("Report package type 'documentInfo.documentType' must resolve to a JSON string: %(documentType)s"),
+                                documentType=reportDocumentType,
+                            )
+
+            elif self._reportType == Const.ReportType.INLINE_XBRL_REPORT_PACKAGE:
+                if len(reportEntries) > 1:
+                    return Validation.error(
+                        "rpe:multipleReports",
+                        _("Inline XBRL report package must contain only one report"),
+                    )
+                if any(
+                    PurePosixPath(entry.primary).suffix not in Const.INLINE_REPORT_FILE_EXTENSIONS
+                    for entry in reportEntries
+                ):
+                    return Validation.error(
+                        "rpe:incorrectReportType",
+                        _("Inline XBRL report package must contain only inline XBRL reports"),
+                    )
+        return None

arelle/plugin/EdgarRendererAllReports.py

@@ -1,5 +1,5 @@
 '''
-EdgarRendererAllReports.py is a supplemental plugin to EdgarRenderer
+EdgarRendererAllReports.py is a supplemental plugin to EDGAR/render
 
 Its purpose is to generate an Rall.htm file of all reports with no menus.
 
@@ -8,9 +8,9 @@ It supplements EdgarRenderer plugin code, running after regular EdgarRenderer.Fi
 To assure that this plugin runs after EdgarRenderer's event, please specify it after
 EdgarRenderer in the list of plugins to load:
 
-e.g., --plugins 'validate/EFM|EdgarRenderer|EdgarRendererAllReports.py|transforms/SEC.py'
+e.g., --plugins 'EDGAR/validate|EDGAR/render|EdgarRendererAllReports.py|EDGAR/transforms'
 if running from command line, or
-      &plugins=validate/EFM|EdgarRenderer|EdgarRendererAllReports.py|transforms/SEC.py
+      &plugins=EDGAR/validate|EDGAR/render|EdgarRendererAllReports.py|EDGAR/transforms
 if running by web service REST API
 
 This plugin changes the default reportFormat to Xml only, avoiding generation of R1.htm,
@@ -33,7 +33,7 @@ def edgarRendererFilingStartSupplement(cntlr, options, entrypointFiles, filing,
     edgarRenderer.reportXslt = os.path.join(edgarRenderer.resourcesFolder,'InstanceReportTable.xslt')
     edgarRenderer.summaryXslt = '' # no FilingSummary.htm
 
-def edgarRendererFilingEndSupplement(cntlr, options, filesource, filing, *args, **kwargs):
+def edgarRendererFilingEndSupplementalReport(cntlr, filing, reportsFolder, *args, **kwargs):
     edgarRenderer = filing.edgarRenderer
 
     # obtain R files from
@@ -43,8 +43,8 @@ def edgarRendererFilingEndSupplement(cntlr, options, filesource, filing, *args,
     if filing.reportZip and url in filing.reportZip.namelist():
         filing.setReportZipStreamMode('r') # switch stream to read mode
         fileLikeObj = filing.reportZip.open(url)
-    elif edgarRenderer.reportsFolder and os.path.exists(os.path.join(edgarRenderer.reportsFolder, url)):
-        fileLikeObj = os.path.join(edgarRenderer.reportsFolder, url)
+    elif reportsFolder and os.path.exists(os.path.join(reportsFolder, url)):
+        fileLikeObj = os.path.join(reportsFolder, url)
     else:
         return
     edgarRenderer.logDebug("Generate all-reports htm file")
@@ -70,8 +70,8 @@ def edgarRendererFilingEndSupplement(cntlr, options, filesource, filing, *args,
         if filing.reportZip and rFile in filing.reportZip.namelist():
             with filing.reportZip.open(rFile) as f:
                 rAll.append(f.read())
-        elif edgarRenderer.reportsFolder and os.path.exists(os.path.join(edgarRenderer.reportsFolder, rFile)):
-            rFilePath = os.path.join(edgarRenderer.reportsFolder, rFile)
+        elif reportsFolder and os.path.exists(os.path.join(reportsFolder, rFile)):
+            rFilePath = os.path.join(reportsFolder, rFile)
             with open(rFilePath, mode='rb') as f:
                 rAll.append(f.read())
             os.remove(rFilePath)
@@ -86,7 +86,7 @@ def edgarRendererFilingEndSupplement(cntlr, options, filesource, filing, *args,
         filing.setReportZipStreamMode('a') # switch stream to append mode (was read mode above)
         filing.reportZip.writestr(allHtmFile, b"".join(rAll))
     else:
-        with open(os.path.join(edgarRenderer.reportsFolder, allHtmFile), mode='wb') as f:
+        with open(os.path.join(reportsFolder, allHtmFile), mode='wb') as f:
             f.write(b"".join(rAll))
     edgarRenderer.renderedFiles.add(allHtmFile)
     edgarRenderer.logDebug("Write {} complete".format(allHtmFile))
@@ -103,7 +103,7 @@ __pluginInfo__ = {
     # classes of mount points (required)
     # note that this mount point must load after EdgarRenderer's same-named mount point
     'EdgarRenderer.Filing.Start': edgarRendererFilingStartSupplement,
-    'EdgarRenderer.Filing.End': edgarRendererFilingEndSupplement,
-    'EdgarRenderer.Gui.Start': edgarRendererFilingStartSupplement,
-    'EdgarRenderer.Gui.End': edgarRendererFilingEndSupplement
+    'EdgarRenderer.FilingEnd.SupplementalReport': edgarRendererFilingEndSupplementalReport,
+    #'EdgarRenderer.Gui.Start': edgarRendererFilingStartSupplement,
+    #'EdgarRenderer.Gui.End': edgarRendererFilingEndSupplementalReport
 }

arelle/plugin/OimTaxonomy/ModelValueMore.py

@@ -0,0 +1,15 @@
+"""
+See COPYRIGHT.md for copyright information.
+"""
+
+from typing import TYPE_CHECKING, Optional, Set, Any
+
+from arelle.ModelValue import QName
+
+class QNameAt(QName):
+    def __init__(self, prefix: Optional[str], namespaceURI: Optional[str], localName: str, atSuffix:str = "end") -> None:
+        super(QNameAt, self).__init__(prefix, namespaceURI, localName)
+        self.atSuffix: str = atSuffix # The context suffix must be either @end or @start. If an @ value is not provided then the suffix defaults to @end.
+
+class SQName(QName):
+    pass # no properties added to QName, just the localName part doesn't have to be an xml identifier