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

arelle/typing.py

@@ -4,16 +4,21 @@ Type hints for Arelle.
 """
 from __future__ import annotations
 
-import sys
-from typing import Callable, Tuple, TypeVar
+from collections.abc import Callable
+from typing import Any, TypedDict, TypeVar  # pylint: disable=no-name-in-module
 
-from typing import TypedDict  # pylint: disable=no-name-in-module
+try:
+    from typing import assert_type as assert_type
+except ImportError:
+    T = TypeVar('T')
+    def assert_type(x: T, _: Any, /) -> T:
+        return x
 
 TypeGetText = Callable[[str], str]
 
 OptionalString = TypeVar("OptionalString", str, None)
 
-EmptyTuple = Tuple[()]
+EmptyTuple = tuple[()]
 
 
 class LocaleDict(TypedDict):

arelle/utils/Contexts.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from arelle.utils.Equivalence import partitionIntoEquivalenceClasses
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable
+    from arelle.ModelXbrl import ModelXbrl
+    from arelle.ModelInstanceObject import ModelContext
+
+class ContextHashKey:
+    __slots__ = ('context', 'dimensionalAspectModel', 'hash')
+    context: ModelContext
+    dimensionalAspectModel: bool
+    hash: int
+
+    def __init__(self, context: ModelContext, dimensionalAspectModel: bool) -> None:
+        self.context = context
+        self.dimensionalAspectModel = dimensionalAspectModel
+        self.hash = self.context.contextDimAwareHash if dimensionalAspectModel else self.context.contextNonDimAwareHash
+
+    def __eq__(self, o: Any) -> bool:
+        if isinstance(o, ContextHashKey):
+            return self.dimensionalAspectModel == o.dimensionalAspectModel and self.context.isEqualTo(o.context, self.dimensionalAspectModel)
+        return NotImplemented
+
+    def __hash__(self) -> int:
+        return self.hash
+
+def partitionContexts(contexts: Iterable[ModelContext], dimensionalAspectModel: bool) -> dict[ContextHashKey, tuple[ModelContext, ...]]:
+    return partitionIntoEquivalenceClasses(contexts, lambda c: ContextHashKey(c, dimensionalAspectModel))
+
+def partitionModelXbrlContexts(modelXbrl: ModelXbrl) -> dict[ContextHashKey, tuple[ModelContext, ...]]:
+    return partitionContexts(modelXbrl.contexts.values(), dimensionalAspectModel=modelXbrl.hasXDT)
+
+def getDuplicateContextGroups(modelXbrl: ModelXbrl) -> list[tuple[ModelContext, ...]]:
+    return [partition for partition in partitionModelXbrlContexts(modelXbrl).values() if len(partition) > 1]

arelle/utils/EntryPointDetection.py

@@ -0,0 +1,139 @@
+"""
+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, 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 | 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, fallbackSelect=True):
+    if entrypointFiles is None:
+        entrypointFiles = []
+    for pluginXbrlMethod in PluginManager.pluginClassMethods("FileSource.EntrypointFiles"):
+        resultEntrypointFiles = pluginXbrlMethod(filesource, inlineOnly)
+        if resultEntrypointFiles is not None:
+            del entrypointFiles[:]  # clear list
+            entrypointFiles.extend(resultEntrypointFiles)
+            return entrypointFiles
+    if filesource.isArchive:
+        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
+        if reportPackage := filesource.reportPackage:
+            assert isinstance(filesource.basefile, str)
+            for report in reportPackage.reports or []:
+                if report.isInline:
+                    reportEntries = [{"file": f} for f in report.fullPathFiles]
+                    ixdsDiscovered = False
+                    for pluginXbrlMethod in PluginManager.pluginClassMethods("InlineDocumentSet.Discovery"):
+                        pluginXbrlMethod(filesource, reportEntries)
+                        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)
+                elif not inlineOnly:
+                    entrypointFiles.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
+                filesource.select(_archiveFile)
+                identifiedType = ModelDocument.Type.identify(filesource, filesource.url)
+                if identifiedType in (ModelDocument.Type.INSTANCE, ModelDocument.Type.INLINEXBRL, ModelDocument.Type.HTML):
+                    urlsByType.setdefault(identifiedType, []).append(filesource.url)
+            # 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:
+                    if identifiedType == ModelDocument.Type.INLINEXBRL:
+                        for pluginXbrlMethod in PluginManager.pluginClassMethods("InlineDocumentSet.Discovery"):
+                            pluginXbrlMethod(filesource, entrypointFiles) # 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:
+                for url in urlsByType.get(ModelDocument.Type.HTML, []):
+                    entrypointFiles.append({"file":url})
+            if not entrypointFiles and filesource.taxonomyPackage is not None:
+                for packageEntry in filesource.taxonomyPackage.get('entryPoints', {}).values():
+                    for _resolvedUrl, remappedUrl, _closest in packageEntry:
+                        entrypointFiles.append({"file": remappedUrl})
+
+
+    elif os.path.isdir(filesource.url):
+        del entrypointFiles[:] # clear list
+        hasInline = False
+        for _file in os.listdir(filesource.url):
+            _path = os.path.join(filesource.url, _file)
+            if os.path.isfile(_path):
+                identifiedType = ModelDocument.Type.identify(filesource, _path)
+                if identifiedType == ModelDocument.Type.INLINEXBRL:
+                    hasInline = True
+                if identifiedType in (ModelDocument.Type.INSTANCE, ModelDocument.Type.INLINEXBRL):
+                    entrypointFiles.append({"file":_path})
+        if hasInline: # group into IXDS if plugin feature is available
+            for pluginXbrlMethod in PluginManager.pluginClassMethods("InlineDocumentSet.Discovery"):
+                pluginXbrlMethod(filesource, entrypointFiles)
+
+    return entrypointFiles

arelle/utils/Equivalence.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+
+from collections import defaultdict
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    TypeVar,
+)
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable
+    from arelle.ModelXbrl import ModelXbrl
+
+T = TypeVar('T')
+K = TypeVar('K')
+
+def partitionIntoEquivalenceClasses(items: Iterable[T], key: Callable[[T], K]) -> dict[K, tuple[T, ...]]:
+    d = defaultdict(list)
+    for item in items:
+        d[key(item)].append(item)
+    return {k: tuple(v) for k, v in d.items()}

arelle/utils/{validate/PluginValidationData.py → PluginData.py}

@@ -1,9 +1,12 @@
+"""
+See COPYRIGHT.md for copyright information.
+"""
 from dataclasses import dataclass
 
 
 @dataclass
-class PluginValidationData:
+class PluginData:
     """
-    Base dataclass which should be extended with fields by plugins that need to cache data between validation rules.
+    Base dataclass which should be extended with fields by plugins that need to cache data while processing a report.
     """
     name: str

arelle/utils/PluginHooks.py

@@ -1,11 +1,12 @@
 """
 See COPYRIGHT.md for copyright information.
 """
+
 from __future__ import annotations
 
 from abc import ABC
 from enum import Enum
-from typing import Any, TYPE_CHECKING
+from typing import TYPE_CHECKING, Any, BinaryIO
 
 from arelle.RuntimeOptions import RuntimeOptions
 
@@ -14,17 +15,18 @@ if TYPE_CHECKING:
     from optparse import OptionParser
     from tkinter import Menu
 
+    from bottle import Bottle  # type: ignore[import-untyped]
+
     from arelle.Cntlr import Cntlr
     from arelle.CntlrCmdLine import CntlrCmdLine
     from arelle.CntlrWinMain import CntlrWinMain
     from arelle.DisclosureSystem import DisclosureSystem
     from arelle.FileSource import FileSource
+    from arelle.formula.XPathContext import XPathContext
     from arelle.ModelDocument import LoadingException, ModelDocument
     from arelle.ModelManager import ModelManager
     from arelle.ModelXbrl import ModelXbrl
     from arelle.ValidateXbrl import ValidateXbrl
-    from arelle.formula.XPathContext import XPathContext
-    from arelle.webserver.bottle import Bottle
 
 
 class ValidationHook(Enum):
@@ -32,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"
@@ -39,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,
@@ -71,7 +111,7 @@ class PluginHooks(ABC):
         cntlr: Cntlr,
         options: RuntimeOptions,
         *args: Any,
-        **kwargs: Any
+        **kwargs: Any,
     ) -> None:
         """
         Plugin hook: `CntlrCmdLine.Utility.Run`
@@ -93,6 +133,62 @@ class PluginHooks(ABC):
         """
         raise NotImplementedError
 
+    @staticmethod
+    def cntlrCmdLineXbrlLoaded(
+        cntlr: CntlrCmdLine,
+        options: RuntimeOptions,
+        modelXbrl: ModelXbrl,
+        entrypoint: dict[str, str] | None = None,
+        responseZipStream: BinaryIO | None = None,
+        *args: Any,
+        **kwargs: Any,
+    ) -> None:
+        """
+        Plugin hook: `CntlrCmdLine.Xbrl.Loaded`
+
+        This hook is triggered after loading, but prior to validation (if requested) and loading views.
+        It's useful if you need to perform operations with the XBRL model prior to rendering views.
+
+        :param cntlr: The [Cntlr](#arelle.Cntlr.Cntlr) being initialized.
+        :param options: Parsed options object.
+        :param modelXbrl: The loaded [ModelXbrl](#arelle.ModelXbrl.ModelXbrl).
+        :param entrypoint: The entrypoint that was parsed to load the model.
+        :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 cntlrCmdLineXbrlRun(
+        cntlr: CntlrCmdLine,
+        options: RuntimeOptions,
+        modelXbrl: ModelXbrl,
+        entrypoint: dict[str, str] | None = None,
+        sourceZipStream: BinaryIO | None = None,
+        responseZipStream: BinaryIO | None = None,
+        *args: Any,
+        **kwargs: Any,
+    ) -> None:
+        """
+        Plugin hook: `CntlrCmdLine.Xbrl.Run`
+
+        This hook is triggered after loading and validation if requested.
+        It's useful for generating reports or exporting the XBRL model to other formats.
+
+        :param cntlr: The [Cntlr](#arelle.Cntlr.Cntlr) being initialized.
+        :param options: Parsed options object.
+        :param modelXbrl: The loaded [ModelXbrl](#arelle.ModelXbrl.ModelXbrl).
+        :param entrypoint: The entrypoint that was parsed to load the model.
+        :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 cntlrInit(
         cntlr: Cntlr,
@@ -134,7 +230,7 @@ class PluginHooks(ABC):
         app.route('/rest/my-run/<file:path>', ("GET", "POST"), my_run)
         ```
 
-        :param app: The [Bottle](#arelle.webserver.bottle.Bottle) server.
+        :param app: The Bottle server.
         :param cntlr: The [controller](#arelle.CntlrCmdLine.CntlrCmdLine) for the server.
         :param host: The webserver host.
         :param port: The webserver port.
@@ -159,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,
@@ -510,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,
@@ -688,3 +871,71 @@ class PluginHooks(ABC):
         :return: None
         """
         raise NotImplementedError
+
+    @staticmethod
+    def testcaseVariationValidated(
+        testcaseDTS: ModelXbrl,
+        testInstanceDTS: ModelXbrl,
+        extraErrors: list[str],
+        inputDTSes: dict[str, ModelXbrl],
+        *args: Any,
+        **kwargs: Any,
+    ) -> None:
+        """
+        Plugin hook: `TestcaseVariation.Validated`
+
+        Testcase validation hook which can be used to log additional test case errors or perform post validation operations.
+
+        :param testcaseDTS: The [ModelXbrl](#arelle.ModelXbrl.ModelXbrl) of the testcase file.
+        :param testInstanceDTS: The [ModelXbrl](#arelle.ModelXbrl.ModelXbrl) of the instance being tested.
+        :param extraErrors: A list that the plugin may append to to log additional errors.
+        :param inputDTSes: The dict of testcase input DTSes.
+        :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 saveLoadableOimSave(
+        modelXbrl: ModelXbrl,
+        oimFile: str,
+        *args: Any,
+        **kwargs: Any,
+    ) -> None:
+        """
+        Plugin hook: `SaveLoadableOim.Save`
+
+        Hook that can be called by other plugins to save the provided model to disk using an OIM file format.
+        The OIM format is controlled by the requested file extension (json or csv.)
+
+        :param modelXbrl: The [ModelXbrl](#arelle.ModelXbrl.ModelXbrl) to save.
+        :param oimFile: The file path to save the model to. The extension controls which OIM format to use.
+        :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 webCacheTransformUrl(
+            cntlr: CntlrCmdLine,
+            url: str | None,
+            base: str | None,
+            *args: Any,
+            **kwargs: Any,
+    ) -> tuple[str | None, bool]:
+        """
+        Plugin hook: `WebCache.TransformURL`
+
+        This hook is triggered before the web cache maps a URL to a file path.
+        It's useful if you need to map certain URLs to a location other than the web cache.
+
+        :param cntlr: The [Cntlr](#arelle.Cntlr.Cntlr) being initialized.
+        :param url: The URL to transform.
+        :param base: The base URL.
+        :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: Tuple of transformed URL or filepath and a boolean indicating if the URL should be returned as the final filename.
+        """
+        raise NotImplementedError

arelle/utils/Units.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from arelle.utils.Equivalence import partitionIntoEquivalenceClasses
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable
+    from arelle.ModelXbrl import ModelXbrl
+    from arelle.ModelInstanceObject import ModelUnit
+
+class UnitHashKey:
+    __slots__ = ('unit', 'hash')
+    unit: ModelUnit
+    hash: int
+
+    def __init__(self, unit: ModelUnit) -> None:
+        self.unit = unit
+        self.hash = self.unit.hash
+
+    def __eq__(self, o: Any) -> bool:
+        if isinstance(o, UnitHashKey):
+            return self.unit.isEqualTo(o.unit)
+        return NotImplemented
+
+    def __hash__(self) -> int:
+        return self.hash
+
+def partitionUnits(units: Iterable[ModelUnit]) -> dict[UnitHashKey, tuple[ModelUnit, ...]]:
+    return partitionIntoEquivalenceClasses(units, UnitHashKey)
+
+def partitionModelXbrlUnits(modelXbrl: ModelXbrl) -> dict[UnitHashKey, tuple[ModelUnit, ...]]:
+    return partitionUnits(modelXbrl.units.values())
+
+def getDuplicateUnitGroups(modelXbrl: ModelXbrl) -> list[tuple[ModelUnit, ...]]:
+    return [partition for partition in partitionModelXbrlUnits(modelXbrl).values() if len(partition) > 1]

arelle/utils/validate/Decorator.py

@@ -4,13 +4,15 @@ See COPYRIGHT.md for copyright information.
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import Any, Callable, Iterable, Optional
-
-from typing_extensions import TypeAlias
+from collections.abc import Callable, Iterable
+from typing import TYPE_CHECKING, Any, Optional
 
 from arelle.utils.PluginHooks import ValidationHook
 from arelle.utils.validate.Validation import Validation
 
+if TYPE_CHECKING:
+    from typing_extensions import TypeAlias
+
 ValidationFunction: TypeAlias = Callable[..., Optional[Iterable[Validation]]]