arelle-release 2.37.46__py3-none-any.whl → 2.38.0__py3-none-any.whl

arelle/utils/EntryPointDetection.py

@@ -1,12 +1,72 @@
+"""
+See COPYRIGHT.md for copyright information.
+"""
+from __future__ import annotations
+
+import json
+import logging
 import os
+from dataclasses import dataclass
+from typing import Any, TYPE_CHECKING
 
 from arelle import (
     ModelDocument,
-    PluginManager,
+    PluginManager, FileSource, PackageManager,
 )
+from arelle.UrlUtil import isHttpUrl
+from arelle.typing import TypeGetText
+
+_: TypeGetText
+
+if TYPE_CHECKING:
+    from arelle.Cntlr import Cntlr
+
+
+@dataclass(frozen=True)
+class EntrypointParseResult:
+    success: bool
+    entrypointFiles: list[dict[str, Any]]
+    filesource: FileSource.FileSource | None
+
+
+def parseEntrypointFileInput(cntlr: Cntlr, entrypointFile: str | None, sourceZipStream=None, fallbackSelect=True) -> EntrypointParseResult:
+    # entrypointFile may be absent (if input is a POSTED zip or file name ending in .zip)
+    #    or may be a | separated set of file names
+    _entryPoints = []
+    _checkIfXmlIsEis = cntlr.modelManager.disclosureSystem and cntlr.modelManager.disclosureSystem.validationType == "EFM"
+    if entrypointFile:
+        _f = entrypointFile
+        try: # may be a json list
+            _entryPoints = json.loads(_f)
+            _checkIfXmlIsEis = False # json entry objects never specify an xml EIS archive
+        except ValueError as e:
+            # is it malformed json?
+            if _f.startswith("[{") or _f.endswith("]}") or '"file:"' in _f:
+                cntlr.addToLog(_("File name parameter appears to be malformed JSON: {}\n{}").format(e, _f),
+                              messageCode="FileNameFormatError",
+                              level=logging.ERROR)
+            else: # try as file names separated by '|'
+                for f in (_f or '').split('|'):
+                    if not sourceZipStream and not isHttpUrl(f) and not os.path.isabs(f):
+                        f = os.path.normpath(os.path.join(os.getcwd(), f)) # make absolute normed path
+                    _entryPoints.append({"file":f})
+    filesource = None # file source for all instances if not None
+    if sourceZipStream:
+        filesource = FileSource.openFileSource(None, cntlr, sourceZipStream)
+    elif len(_entryPoints) == 1 and "file" in _entryPoints[0]: # check if an archive and need to discover entry points (and not IXDS)
+        entryPath = PackageManager.mappedUrl(_entryPoints[0]["file"])
+        filesource = FileSource.openFileSource(entryPath, cntlr, checkIfXmlIsEis=_checkIfXmlIsEis)
+    _entrypointFiles = _entryPoints
+    if filesource and not filesource.selection and not (sourceZipStream and len(_entrypointFiles) > 0):
+        try:
+            filesourceEntrypointFiles(filesource, _entrypointFiles, fallbackSelect=fallbackSelect)
+        except Exception as err:
+            cntlr.addToLog(str(err), messageCode="error", level=logging.ERROR)
+            return EntrypointParseResult(success=False, entrypointFiles=_entrypointFiles, filesource=filesource)
+    return EntrypointParseResult(success=True, entrypointFiles=_entrypointFiles, filesource=filesource)
 
 
-def filesourceEntrypointFiles(filesource, entrypointFiles=None, inlineOnly=False):
+def filesourceEntrypointFiles(filesource, entrypointFiles=None, inlineOnly=False, fallbackSelect=True):
     if entrypointFiles is None:
         entrypointFiles = []
     for pluginXbrlMethod in PluginManager.pluginClassMethods("FileSource.EntrypointFiles"):
@@ -19,8 +79,9 @@ def filesourceEntrypointFiles(filesource, entrypointFiles=None, inlineOnly=False
         if filesource.isTaxonomyPackage:  # if archive is also a taxonomy package, activate mappings
             filesource.loadTaxonomyPackageMappings()
         # HF note: a web api request to load a specific file from archive is ignored, is this right?
-        del entrypointFiles[:] # clear out archive from entrypointFiles
+        discoveredEntrypointFiles = []
         if reportPackage := filesource.reportPackage:
+            del entrypointFiles[:]
             assert isinstance(filesource.basefile, str)
             for report in reportPackage.reports or []:
                 if report.isInline:
@@ -31,10 +92,10 @@ def filesourceEntrypointFiles(filesource, entrypointFiles=None, inlineOnly=False
                         ixdsDiscovered = True
                     if not ixdsDiscovered and len(reportEntries) > 1:
                         raise RuntimeError(_("Loading error. Inline document set encountered. Enable 'InlineXbrlDocumentSet' plug-in to load this filing: {0}").format(filesource.url))
-                    entrypointFiles.extend(reportEntries)
+                    discoveredEntrypointFiles.extend(reportEntries)
                 elif not inlineOnly:
-                    entrypointFiles.append({"file": report.fullPathPrimary})
-        else:
+                    discoveredEntrypointFiles.append({"file": report.fullPathPrimary})
+        elif fallbackSelect:
             # attempt to find inline XBRL files before instance files, .xhtml before probing others (ESMA)
             urlsByType = {}
             for _archiveFile in (filesource.dir or ()): # .dir might be none if IOerror
@@ -45,20 +106,25 @@ def filesourceEntrypointFiles(filesource, entrypointFiles=None, inlineOnly=False
             # use inline instances, if any, else non-inline instances
             for identifiedType in ((ModelDocument.Type.INLINEXBRL,) if inlineOnly else (ModelDocument.Type.INLINEXBRL, ModelDocument.Type.INSTANCE)):
                 for url in urlsByType.get(identifiedType, []):
-                    entrypointFiles.append({"file":url})
-                if entrypointFiles:
+                    discoveredEntrypointFiles.append({"file":url})
+                if discoveredEntrypointFiles:
                     if identifiedType == ModelDocument.Type.INLINEXBRL:
                         for pluginXbrlMethod in PluginManager.pluginClassMethods("InlineDocumentSet.Discovery"):
-                            pluginXbrlMethod(filesource, entrypointFiles) # group into IXDS if plugin feature is available
+                            pluginXbrlMethod(filesource, discoveredEntrypointFiles) # group into IXDS if plugin feature is available
                     break # found inline (or non-inline) entrypoint files, don't look for any other type
             # for ESEF non-consolidated xhtml documents accept an xhtml entry point
-            if not entrypointFiles and not inlineOnly:
+            if not discoveredEntrypointFiles and not inlineOnly:
                 for url in urlsByType.get(ModelDocument.Type.HTML, []):
-                    entrypointFiles.append({"file":url})
-            if not entrypointFiles and filesource.taxonomyPackage is not None:
+                    discoveredEntrypointFiles.append({"file":url})
+            if not discoveredEntrypointFiles and filesource.taxonomyPackage is not None:
                 for packageEntry in filesource.taxonomyPackage.get('entryPoints', {}).values():
                     for _resolvedUrl, remappedUrl, _closest in packageEntry:
-                        entrypointFiles.append({"file": remappedUrl})
+                        discoveredEntrypointFiles.append({"file": remappedUrl})
+        if discoveredEntrypointFiles:
+            # Only clear archive entry points if we discovered new ones.
+            # This could be a plugin loaded archive, such as an Excel file.
+            del entrypointFiles[:]
+            entrypointFiles.extend(discoveredEntrypointFiles)
 
 
     elif os.path.isdir(filesource.url):

arelle/utils/PluginHooks.py

@@ -34,6 +34,8 @@ class ValidationHook(Enum):
     These hooks are called at different stages of validation, but all provide a common interface (ValidateXbrl is the first param).
     """
 
+    COMPLETE = "Validate.Complete"
+    FILESOURCE = "Validate.FileSource"
     XBRL_START = "Validate.XBRL.Start"
     XBRL_FINALLY = "Validate.XBRL.Finally"
     XBRL_DTS_DOCUMENT = "Validate.XBRL.DTS.document"
@@ -41,6 +43,42 @@ class ValidationHook(Enum):
 
 
 class PluginHooks(ABC):
+
+    @staticmethod
+    def cntlrCmdLineFilingStart(
+            cntlr: CntlrCmdLine,
+            options: RuntimeOptions,
+            filesource: FileSource | None,
+            entrypoints: list[dict[str, Any]] | None = None,
+            sourceZipStream: BinaryIO | None = None,
+            responseZipStream: BinaryIO | None = None,
+            *args: Any,
+            **kwargs: Any,
+    ) -> None:
+        """
+        Plugin hook: `CntlrCmdLine.Filing.Start`
+
+        This hook is triggered after entrypoints have been discovered and parsed, but before
+        models have been loaded.
+
+        Example:
+        ```python
+        timeAtStart = time.time()
+        myOptionEnabled = options.myOption
+        ```
+
+        :param cntlr: The [CntlrCmdLine](#arelle.CntlrCmdLine.CntlrCmdLine) that is currently running.
+        :param options: Parsed options object.
+        :param filesource: FileSource, if available.
+        :param entrypoints: A list of entrypoint configurations.
+        :param sourceZipStream: The source zip stream if the model was loaded from a zip that was POSTed to the webserver.
+        :param responseZipStream: The response zip stream if loaded from the webserver and the user requested a zip response.
+        :param args: Argument capture to ensure new parameters don't break plugin hook.
+        :param kwargs: Argument capture to ensure new named parameters don't break plugin hook.
+        :return: None
+        """
+        raise NotImplementedError
+
     @staticmethod
     def cntlrCmdLineOptions(
         parser: OptionParser,
@@ -217,6 +255,34 @@ class PluginHooks(ABC):
         """
         raise NotImplementedError
 
+    @staticmethod
+    def cntlrWinMainFilingStart(
+            cntlr: CntlrWinMain,
+            filesource: FileSource | None,
+            entrypoints: list[dict[str, Any]] | None = None,
+            *args: Any,
+            **kwargs: Any,
+    ) -> None:
+        """
+        Plugin hook: `CntlrWinMain.Filing.Start`
+
+        This hook is triggered after entrypoints have been discovered and parsed, but before
+        models have been loaded.
+
+        Example:
+        ```python
+        timeAtStart = time.time()
+        ```
+
+        :param cntlr: The [CntlrWinMain](#arelle.CntlrWinMain.CntlrWinMain) that is currently running.
+        :param filesource: FileSource, if available.
+        :param entrypoints: A list of entrypoint configurations.
+        :param args: Argument capture to ensure new parameters don't break plugin hook.
+        :param kwargs: Argument capture to ensure new named parameters don't break plugin hook.
+        :return: None
+        """
+        raise NotImplementedError
+
     @staticmethod
     def cntlrWinMainMenuHelp(
         cntlr: CntlrWinMain,
@@ -568,6 +634,65 @@ class PluginHooks(ABC):
         """
         raise NotImplementedError
 
+    @staticmethod
+    def validateComplete(
+            cntlr: Cntlr,
+            fileSource: FileSource,
+            *args: Any,
+            **kwargs: Any,
+    ) -> None:
+        """
+        Plugin hook: `Validate.Complete`
+
+        Hook for executing controller-level validation rules after model-level validation is complete.
+        This can be useful for validating multi-instance filings when a rule requires information that
+        is only available after all instances have been parsed and validated.
+
+        Example:
+        ```python
+        unusedFilepaths = pluginData.getExistingFilepaths() - pluginData.getUsedFilepaths()
+        if len(unusedSubdirectoryFilepaths) > 0:
+            yield Validation.error(codes="0.0.0", msg="Unused files exist.")
+        ```
+
+        :param cntlr: The [Cntlr](#arelle.Cntlr.Cntlr) instance.
+        :param fileSource: The [FileSource](#arelle.FileSource.FileSource) involved in loading the entrypoint files.
+        :param args: Argument capture to ensure new parameters don't break plugin hook.
+        :param kwargs: Argument capture to ensure new named parameters don't break plugin hook.
+        :return: None
+        """
+        raise NotImplementedError
+
+    @staticmethod
+    def validateFileSource(
+            cntlr: Cntlr,
+            fileSource: FileSource,
+            *args: Any,
+            **kwargs: Any,
+    ) -> None:
+        """
+        Plugin hook: `Validate.FileSource`
+
+        Hook for validating FileSource. This is useful for validations that apply to the filesource and not the
+        XBRL models loaded from it.
+
+        Example:
+        ```python
+        size = fileSource.getBytesSize()
+        if size is None:
+            return
+        if size > 100_000_000:
+            yield Validation.error(codes="0.0.0", msg="File size exceeds 100MB.")
+        ```
+
+        :param cntlr: The [Cntlr](#arelle.Cntlr.Cntlr) instance.
+        :param fileSource: The [FileSource](#arelle.FileSource.FileSource) to validate.
+        :param args: Argument capture to ensure new parameters don't break plugin hook.
+        :param kwargs: Argument capture to ensure new named parameters don't break plugin hook.
+        :return: None
+        """
+        raise NotImplementedError
+
     @staticmethod
     def validateFinally(
         val: ValidateXbrl,

arelle/utils/validate/ESEFImage.py

@@ -17,7 +17,7 @@ from arelle import ModelDocument
 from arelle.ModelObjectFactory import parser
 from arelle.ModelXbrl import ModelXbrl
 from arelle.typing import TypeGetText
-from arelle.UrlUtil import decodeBase64DataImage, scheme
+from arelle.UrlUtil import decodeBase64DataImage, isExternalUrl
 from arelle.utils.validate.Validation import Validation
 from arelle.ValidateFilingText import parseImageDataURL, validateGraphicHeaderType
 from arelle.ValidateXbrl import ValidateXbrl
@@ -105,15 +105,15 @@ def validateImage(
         if minExternalRessourceSize != -1:
             # transform kb to b
             minExternalRessourceSize = minExternalRessourceSize * 1024
-    if scheme(image) in ("http", "https", "ftp"):
+    if isExternalUrl(image):
         yield Validation.error(("ESEF.4.1.6.xHTMLDocumentContainsExternalReferences" if not params.consolidated
                                else "ESEF.3.5.1.inlineXbrlDocumentContainsExternalReferences",
-                               "NL.NL-KVK.3.6.2.1.inlineXbrlDocumentContainsExternalReferences"),
+                               "NL.NL-KVK.3.6.2.1.inlineXbrlDocumentSetContainsExternalReferences"),
                                _("Inline XBRL instance documents MUST NOT contain any reference pointing to resources outside the reporting package: %(element)s"),
                                modelObject=elts, element=elts[0].tag, evaluatedMsg=evaluatedMsg,
                                messageCodes=("ESEF.3.5.1.inlineXbrlDocumentContainsExternalReferences",
                                              "ESEF.4.1.6.xHTMLDocumentContainsExternalReferences",
-                                             "NL.NL-KVK.3.6.2.1.inlineXbrlDocumentContainsExternalReferences"))
+                                             "NL.NL-KVK.3.6.2.1.inlineXbrlDocumentSetContainsExternalReferences"))
     elif image.startswith("data:image"):
         dataURLParts = parseImageDataURL(image)
         if not dataURLParts or not dataURLParts.isBase64:
@@ -277,7 +277,7 @@ def checkSVGContentElt(
                 yield Validation.error((f"{guidance}.executableCodePresent", "NL.NL-KVK.3.5.1.1.executableCodePresent"),
                                        _("Inline XBRL images MUST NOT contain executable code: %(element)s"),
                                        modelObject=imgElts, element=eltTag)
-            elif scheme(href) in ("http", "https", "ftp"):
-                yield Validation.error((f"{guidance}.referencesPointingOutsideOfTheReportingPackagePresent", "NL.NL-KVK.3.6.2.1.inlineXbrlDocumentContainsExternalReferences"),
+            elif isExternalUrl(href):
+                yield Validation.error((f"{guidance}.referencesPointingOutsideOfTheReportingPackagePresent", "NL.NL-KVK.3.6.2.1.inlineXbrlDocumentSetContainsExternalReferences"),
                                        _("Inline XBRL instance document [image] MUST NOT contain any reference pointing to resources outside the reporting package: %(element)s"),
                                        modelObject=imgElts, element=eltTag)

arelle/utils/validate/Validation.py

@@ -10,6 +10,7 @@ from typing import Any
 
 class Level(Enum):
     ERROR = "ERROR"
+    INCONSISTENCY = "INCONSISTENCY"
     WARNING = "WARNING"
 
 @dataclass(frozen=True)
@@ -19,6 +20,15 @@ class Validation:
     msg: str
     args: dict[str, Any] = field(default_factory=dict)
 
+    @staticmethod
+    def build(
+            level: Level,
+            codes: str | tuple[str, ...],
+            msg: str,
+            **kwargs: Any,
+    ) -> Validation:
+        return Validation(level=level, codes=codes, msg=msg, args=kwargs)
+
     @staticmethod
     def error(
         codes: str | tuple[str, ...],
@@ -27,6 +37,14 @@ class Validation:
     ) -> Validation:
         return Validation(level=Level.ERROR, codes=codes, msg=msg, args=kwargs)
 
+    @staticmethod
+    def inconsistency(
+            codes: str | tuple[str, ...],
+            msg: str,
+            **kwargs: Any,
+    ) -> Validation:
+        return Validation(level=Level.INCONSISTENCY, codes=codes, msg=msg, args=kwargs)
+
     @staticmethod
     def warning(
         codes: str | tuple[str, ...],

arelle/utils/validate/ValidationPlugin.py

@@ -8,17 +8,20 @@ from pathlib import Path
 from types import ModuleType
 from typing import Any
 
+from arelle.Cntlr import Cntlr
 from arelle.DisclosureSystem import DisclosureSystem
+from arelle.FileSource import FileSource
 from arelle.ModelDocument import LoadingException, ModelDocument
+from arelle.ModelManager import ModelManager
 from arelle.ModelXbrl import ModelXbrl
 from arelle.ValidateXbrl import ValidateXbrl
+from arelle.utils.PluginData import PluginData
 from arelle.utils.PluginHooks import ValidationHook
 from arelle.utils.validate.Decorator import (
     ValidationAttributes,
     ValidationFunction,
     getValidationAttributes,
 )
-from arelle.utils.PluginData import PluginData
 
 
 class ValidationPlugin:
@@ -55,7 +58,7 @@ class ValidationPlugin:
             ValidationHook, dict[ValidationFunction, set[str]]
         ] = {}
 
-    def newPluginData(self, validateXbrl: ValidateXbrl) -> PluginData:
+    def newPluginData(self, cntlr: Cntlr, validateXbrl: ValidateXbrl | None) -> PluginData:
         """
         Returns a dataclass intended to be overriden by plugins to facilitate caching and passing data between rule functions.
         The default implementation doesn't provide any fields other than the plugin name.
@@ -99,6 +102,46 @@ class ValidationPlugin:
     ) -> ModelDocument | LoadingException | None:
         raise NotImplementedError
 
+    def validateComplete(
+            self,
+            cntlr: Cntlr,
+            fileSource: FileSource,
+            *args: Any,
+            **kwargs: Any,
+    ) -> None:
+        """
+        Executes validation functions in the rules module that was provided to the constructor of this class.
+        Each function decorated with [@validation](#arelle.utils.validate.Decorator.validation) will be run if:
+        1. the decorator was used with the validation complete hook: `@validation(hook=ValidationHook.COMPLETE)`
+
+        :param cntlr: The [Cntlr](#arelle.Cntlr.Cntlr) instance.
+        :param fileSource: The [FileSource](#arelle.FileSource.FileSource) involved in loading the entrypoint files.
+        :param args: Argument capture to ensure new parameters don't break plugin hook.
+        :param kwargs: Argument capture to ensure new named parameters don't break plugin hook.
+        :return: None
+        """
+        self._executeCntlrValidations(ValidationHook.COMPLETE, cntlr, fileSource, *args, **kwargs)
+
+    def validateFileSource(
+        self,
+        cntlr: Cntlr,
+        fileSource: FileSource,
+        *args: Any,
+        **kwargs: Any,
+    ) -> None:
+        """
+        Executes validation functions in the rules module that was provided to the constructor of this class.
+        Each function decorated with [@validation](#arelle.utils.validate.Decorator.validation) will be run if:
+        1. the decorator was used with the FileSource validation hook: `@validation(hook=ValidationHook.FILESOURCE)`
+
+        :param cntlr: The [Cntlr](#arelle.Cntlr.Cntlr) instance.
+        :param fileSource: The [FileSource](#arelle.FileSource.FileSource) to validate.
+        :param args: Argument capture to ensure new parameters don't break plugin hook.
+        :param kwargs: Argument capture to ensure new named parameters don't break plugin hook.
+        :return: None
+        """
+        self._executeCntlrValidations(ValidationHook.FILESOURCE, cntlr, fileSource, *args, **kwargs)
+
     def validateXbrlStart(
         self,
         val: ValidateXbrl,
@@ -118,7 +161,7 @@ class ValidationPlugin:
         :param kwargs: Argument capture to ensure new named parameters don't break plugin hook.
         :return: None
         """
-        self._executeValidations(ValidationHook.XBRL_START, val, parameters, *args, **kwargs)
+        self._executeModelValidations(ValidationHook.XBRL_START, val, parameters, *args, **kwargs)
 
     def validateXbrlFinally(
         self,
@@ -137,7 +180,7 @@ class ValidationPlugin:
         :param kwargs: Argument capture to ensure new named parameters don't break plugin hook.
         :return: None
         """
-        self._executeValidations(ValidationHook.XBRL_FINALLY, val, *args, **kwargs)
+        self._executeModelValidations(ValidationHook.XBRL_FINALLY, val, *args, **kwargs)
 
     def validateXbrlDtsDocument(
         self,
@@ -158,7 +201,7 @@ class ValidationPlugin:
         :param kwargs: Argument capture to ensure new named parameters don't break plugin hook.
         :return: None
         """
-        self._executeValidations(ValidationHook.XBRL_DTS_DOCUMENT, val, modelDocument, isFilingDocument, *args, **kwargs)
+        self._executeModelValidations(ValidationHook.XBRL_DTS_DOCUMENT, val, modelDocument, isFilingDocument, *args, **kwargs)
 
     def validateFinally(
         self,
@@ -177,9 +220,28 @@ class ValidationPlugin:
         :param kwargs: Argument capture to ensure new named parameters don't break plugin hook.
         :return: None
         """
-        self._executeValidations(ValidationHook.FINALLY, val, *args, **kwargs)
+        self._executeModelValidations(ValidationHook.FINALLY, val, *args, **kwargs)
+
+    def _executeCntlrValidations(
+            self,
+            pluginHook: ValidationHook,
+            cntlr: Cntlr,
+            fileSource: FileSource | None = None,
+            *args: Any,
+            **kwargs: Any,
+    ) -> None:
+        if self.disclosureSystemFromPluginSelected(cntlr.modelManager):
+            pluginData = self.newPluginData(
+                cntlr=cntlr,
+                validateXbrl=None
+            )
+            for rule in self._getValidations(cntlr.modelManager.disclosureSystem, pluginHook):
+                validations = rule(pluginData, cntlr, fileSource, *args, **kwargs)
+                if validations is not None:
+                    for val in validations:
+                        cntlr.validation(val, fileSource=fileSource)
 
-    def _executeValidations(
+    def _executeModelValidations(
         self,
         pluginHook: ValidationHook,
         validateXbrl: ValidateXbrl,
@@ -189,20 +251,23 @@ class ValidationPlugin:
         if self.disclosureSystemFromPluginSelected(validateXbrl):
             pluginData = validateXbrl.getPluginData(self.name)
             if pluginData is None:
-                pluginData = self.newPluginData(validateXbrl)
+                pluginData = self.newPluginData(
+                    cntlr=validateXbrl.modelXbrl.modelManager.cntlr,
+                    validateXbrl=validateXbrl
+                )
                 validateXbrl.setPluginData(pluginData)
             for rule in self._getValidations(validateXbrl.disclosureSystem, pluginHook):
                 validations = rule(pluginData, validateXbrl, *args, **kwargs)
                 if validations is not None:
                     modelXbrl = validateXbrl.modelXbrl
                     for val in validations:
-                        modelXbrl.log(level=val.level.name, codes=val.codes, msg=val.msg, **val.args)
+                        modelXbrl.validation(val)
 
     def disclosureSystemFromPluginSelected(
         self,
-        model: ValidateXbrl | ModelXbrl,
+        model: ValidateXbrl | ModelManager | ModelXbrl,
     ) -> bool:
-        if isinstance(model, ValidateXbrl):
+        if isinstance(model, (ModelManager, ValidateXbrl)):
             disclosureSystem = model.disclosureSystem
         elif isinstance(model, ModelXbrl):
             disclosureSystem = model.modelManager.disclosureSystem

arelle/utils/validate/ValidationUtil.py

@@ -1,13 +1,18 @@
 """
 See COPYRIGHT.md for copyright information.
 """
+
 from __future__ import annotations
 
-from collections.abc import Generator
+from collections.abc import Generator, Iterable
 
 from lxml.etree import _Element
 
+from arelle import XbrlConst
+from arelle.ModelDtsObject import ModelConcept
 from arelle.ModelObject import ModelObject
+from arelle.ModelValue import QName
+from arelle.ModelXbrl import ModelXbrl
 from arelle.typing import TypeGetText
 
 _: TypeGetText
@@ -19,5 +24,32 @@ def etreeIterWithDepth(
 ) -> Generator[tuple[ModelObject | _Element, int], None, None]:
     yield node, depth
     for child in node.iterchildren():
-        for n_d in etreeIterWithDepth(child, depth + 1):
-            yield n_d
+        yield from etreeIterWithDepth(child, depth + 1)
+
+
+def hasPresentationalConceptsWithFacts(
+        modelXbrl: ModelXbrl,
+        roleUris: Iterable[str],
+        memberQnameFilter: set[QName] | None = None,
+) -> bool:
+    """
+    Returns True if any concepts used in the presentation network of the role URIs have been tagged with facts.
+    This DOES NOT check if the facts are dimensionally valid against hypercubes defined in the roles.
+    """
+    roleRelSet = modelXbrl.relationshipSet(XbrlConst.parentChild, tuple(roleUris))
+    concepts = set(roleRelSet.fromModelObjects().keys()) | set(roleRelSet.toModelObjects().keys())
+    for concept in concepts:
+        if not isinstance(concept, ModelConcept):
+            continue
+        if concept.qname is None:
+            continue
+        if concept.isAbstract:
+            continue
+        for fact in modelXbrl.factsByQname.get(concept.qname, set()):
+            if memberQnameFilter is None:
+                return True
+            if fact.context is not None:
+                for dimValue in fact.context.qnameDims.values():
+                    if dimValue.memberQname in memberQnameFilter:
+                        return True
+    return False

{arelle_release-2.37.46.dist-info → arelle_release-2.38.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: arelle-release
-Version: 2.37.46
+Version: 2.38.0
 Summary: An open source XBRL platform.
 Author-email: "arelle.org" <support@arelle.org>
 License-Expression: Apache-2.0
@@ -18,47 +18,57 @@ Classifier: Intended Audience :: End Users/Desktop
 Classifier: Intended Audience :: Developers
 Classifier: Natural Language :: English
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Operating System :: OS Independent
 Classifier: Topic :: Text Processing :: Markup :: XML
-Requires-Python: <3.14,>=3.9
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE.md
 Requires-Dist: bottle<0.14,>=0.13
 Requires-Dist: certifi
 Requires-Dist: filelock
-Requires-Dist: jsonschema==4.*
-Requires-Dist: isodate==0.*
-Requires-Dist: lxml<6,>=4
+Requires-Dist: isodate<1,>=0
+Requires-Dist: jaconv<1,>=0
+Requires-Dist: jsonschema<5,>=4
+Requires-Dist: lxml!=6.0.0,<7,>=4
 Requires-Dist: numpy<3,>=1
-Requires-Dist: openpyxl==3.*
-Requires-Dist: pillow<12,>=10
-Requires-Dist: pyparsing==3.*
-Requires-Dist: python-dateutil==2.*
+Requires-Dist: openpyxl<4,>=3
+Requires-Dist: pillow<13,>=10
+Requires-Dist: pyparsing<4,>=3
+Requires-Dist: python-dateutil<3,>=2
 Requires-Dist: regex
-Requires-Dist: truststore==0.*; python_version > "3.9"
-Requires-Dist: typing-extensions==4.*
+Requires-Dist: truststore<1,>=0
+Requires-Dist: typing-extensions<5,>=4
 Provides-Extra: crypto
-Requires-Dist: pycryptodome==3.*; extra == "crypto"
+Requires-Dist: pycryptodome<4,>=3; extra == "crypto"
 Provides-Extra: db
-Requires-Dist: pg8000==1.*; extra == "db"
-Requires-Dist: PyMySQL==1.*; extra == "db"
+Requires-Dist: cx_Oracle<9,>=8; extra == "db"
+Requires-Dist: pg8000<2,>=1; extra == "db"
+Requires-Dist: PyMySQL<2,>=1; extra == "db"
 Requires-Dist: pyodbc<6,>=4; extra == "db"
 Requires-Dist: rdflib<8,>=5; extra == "db"
 Provides-Extra: efm
-Requires-Dist: holidays==0.*; extra == "efm"
+Requires-Dist: aniso8601<11,>=10; extra == "efm"
+Requires-Dist: holidays<1,>=0; extra == "efm"
+Requires-Dist: matplotlib<4,>=3; extra == "efm"
 Requires-Dist: pytz; extra == "efm"
 Provides-Extra: esef
-Requires-Dist: tinycss2==1.*; extra == "esef"
+Requires-Dist: tinycss2<2,>=1; extra == "esef"
+Provides-Extra: gui
+Requires-Dist: pywin32<400,>=300; sys_platform == "win32" and extra == "gui"
 Provides-Extra: objectmaker
-Requires-Dist: graphviz==0.*; extra == "objectmaker"
+Requires-Dist: graphviz<1,>=0; extra == "objectmaker"
+Provides-Extra: viewer
+Requires-Dist: ixbrl-viewer<2,>=1; extra == "viewer"
 Provides-Extra: webserver
-Requires-Dist: cheroot<11,>=8; extra == "webserver"
-Requires-Dist: tornado==6.*; extra == "webserver"
+Requires-Dist: cheroot<12,>=8; extra == "webserver"
+Requires-Dist: tornado<7,>=6; extra == "webserver"
+Provides-Extra: xule
+Requires-Dist: aniso8601<11,>=10; extra == "xule"
 Dynamic: license-file
 
 # Arelle