arelle-release 2.37.56__tar.gz → 2.37.58__tar.gz

{arelle_release-2.37.56 → arelle_release-2.37.58}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: arelle-release
-Version: 2.37.56
+Version: 2.37.58
 Summary: An open source XBRL platform.
 Author-email: "arelle.org" <support@arelle.org>
 License-Expression: Apache-2.0

{arelle_release-2.37.56 → arelle_release-2.37.58}/arelle/Cntlr.py

@@ -161,6 +161,7 @@ class Cntlr:
         disable_persistent_config: bool = False,
         betaFeatures: dict[str, bool] | None = None
     ) -> None:
+        self.logger = None
         if betaFeatures is None:
             betaFeatures = {}
         self.betaFeatures = {

{arelle_release-2.37.56 → arelle_release-2.37.58}/arelle/CntlrCmdLine.py

@@ -950,6 +950,7 @@ class CntlrCmdLine(Cntlr.Cntlr):
         if options.testcaseFilters:
             fo.testcaseFilters = options.testcaseFilters
         if options.testcaseResultsCaptureWarnings:
+            self.errorManager.setErrorCaptureLevel(logging._checkLevel("WARNING"))
             fo.testcaseResultsCaptureWarnings = True
         if options.testcaseResultOptions:
             fo.testcaseResultOptions = options.testcaseResultOptions

{arelle_release-2.37.56 → arelle_release-2.37.58}/arelle/DialogPluginManager.py

@@ -386,15 +386,17 @@ class DialogPluginManager(Toplevel):
         group = {
             "ixbrl-viewer": "1",  # pip installed Arelle viewer
             "iXBRLViewerPlugin": "2",  # git clone installed Arelle viewer
-            "Edgar Renderer": "3",
+            "EDGAR": "3",
+            "Inline XBRL Document Set": "4",
+            "XBRL rule processor (xule)": "5",
         }.get(key)
         if not group:
             if key.startswith("Validate"):
-                group = "4"
+                group = "6"
             elif key.startswith("xbrlDB"):
-                group = "5"
+                group = "7"
             else:
-                group = "6"
+                group = "8"
         return group + key.lower()
 
     @staticmethod

{arelle_release-2.37.56 → arelle_release-2.37.58}/arelle/ErrorManager.py

@@ -180,7 +180,10 @@ class ErrorManager:
                             objectUrl = arg
                         else:
                             try:
-                                objectUrl = arg.modelDocument.displayUri
+                                if isinstance(arg, ObjectPropertyViewWrapper):
+                                    objectUrl = arg.modelObject.modelDocument.displayUri
+                                else:
+                                    objectUrl = arg.modelDocument.displayUri
                             except AttributeError:
                                 try:
                                     objectUrl = arg.displayUri
@@ -313,3 +316,6 @@ class ErrorManager:
         if isinstance(argValue, dict):
             return dict((self._loggableValue(k), self._loggableValue(v)) for k, v in argValue.items())
         return str(argValue)
+
+    def setErrorCaptureLevel(self, errorCaptureLevel: int) -> None:
+        self._errorCaptureLevel = errorCaptureLevel

{arelle_release-2.37.56 → arelle_release-2.37.58}/arelle/PluginManager.py

@@ -1,31 +1,41 @@
 '''
 See COPYRIGHT.md for copyright information.
-
-based on pull request 4
-
 '''
 from __future__ import annotations
-import os, sys, types, time, ast, importlib, io, json, gettext, traceback
-from dataclasses import dataclass
-from importlib.metadata import entry_points, EntryPoint
+
+import ast
+import gettext
+from glob import glob
 import importlib.util
+import json
 import logging
-
+import os
+import sys
+import time
+import traceback
+import types
+from collections import defaultdict
+from collections.abc import Callable, Iterator
+from dataclasses import dataclass
+from importlib.metadata import EntryPoint, entry_points
+from numbers import Number
+from pathlib import Path
 from types import ModuleType
 from typing import TYPE_CHECKING, Any, cast
-from arelle.Locale import getLanguageCodes
+
 import arelle.FileSource
+from arelle.Locale import getLanguageCodes
 from arelle.PythonUtil import isLegacyAbs
+from arelle.typing import TypeGetText
 from arelle.UrlUtil import isAbsolute
-from pathlib import Path
-from collections import OrderedDict, defaultdict
-from collections.abc import Callable, Iterator
-
 
 if TYPE_CHECKING:
     # Prevent potential circular import error
     from .Cntlr import Cntlr
 
+
+_: TypeGetText
+
 PLUGIN_TRACE_FILE = None
 # PLUGIN_TRACE_FILE = "c:/temp/pluginerr.txt"
 PLUGIN_TRACE_LEVEL = logging.WARNING
@@ -58,7 +68,7 @@ def init(cntlr: Cntlr, loadPluginConfig: bool = True) -> None:
     if loadPluginConfig:
         try:
             pluginJsonFile = cntlr.userAppDir + os.sep + "plugins.json"
-            with io.open(pluginJsonFile, 'rt', encoding='utf-8') as f:
+            with open(pluginJsonFile, encoding='utf-8') as f:
                 pluginConfig = json.load(f)
             freshenModuleInfos()
         except Exception:
@@ -79,29 +89,45 @@ def reset() -> None:  # force reloading modules and plugin infos
         pluginMethodsForClasses.clear() # dict by class of list of ordered callable function objects
 
 def orderedPluginConfig():
-    return OrderedDict(
-        (('modules',OrderedDict((moduleName,
-                                 OrderedDict(sorted(moduleInfo.items(),
-                                                    key=lambda k: {'name': '01',
-                                                                   'status': '02',
-                                                                   'version': '03',
-                                                                   'fileDate': '04',                                                             'version': '05',
-                                                                   'description': '05',
-                                                                   'moduleURL': '06',
-                                                                   'localeURL': '07',
-                                                                   'localeDomain': '08',
-                                                                   'license': '09',
-                                                                   'author': '10',
-                                                                   'copyright': '11',
-                                                                   'classMethods': '12'}.get(k[0],k[0]))))
-                                for moduleName, moduleInfo in sorted(pluginConfig['modules'].items()))),
-         ('classes',OrderedDict(sorted(pluginConfig['classes'].items())))))
+    fieldOrder = [
+        'name',
+        'status',
+        'fileDate',
+        'version',
+        'description',
+        'moduleURL',
+        'localeURL',
+        'localeDomain',
+        'license',
+        'author',
+        'copyright',
+        'classMethods',
+    ]
+    priorityIndex = {k: i for i, k in enumerate(fieldOrder)}
+
+    def sortModuleInfo(moduleInfo):
+        # Prioritize known fields by the index in fieldOrder; sort others alphabetically
+        orderedKeys = sorted(
+            moduleInfo.keys(),
+            key=lambda k: (priorityIndex.get(k, len(priorityIndex)), k)
+        )
+        return {k: moduleInfo[k] for k in orderedKeys}
+
+    orderedModules = {
+        moduleName: sortModuleInfo(pluginConfig['modules'][moduleName])
+        for moduleName in sorted(pluginConfig['modules'].keys())
+    }
+
+    return {
+        'modules': orderedModules,
+        'classes': dict(sorted(pluginConfig['classes'].items()))
+    }
 
 def save(cntlr: Cntlr) -> None:
     global pluginConfigChanged
     if pluginConfigChanged and cntlr.hasFileSystem and not cntlr.disablePersistentConfig:
         pluginJsonFile = cntlr.userAppDir + os.sep + "plugins.json"
-        with io.open(pluginJsonFile, 'wt', encoding='utf-8') as f:
+        with open(pluginJsonFile, 'w', encoding='utf-8') as f:
             jsonStr = str(json.dumps(orderedPluginConfig(), ensure_ascii=False, indent=2)) # might not be unicode in 2.7
             f.write(jsonStr)
         pluginConfigChanged = False
@@ -155,7 +181,6 @@ moduleInfo = {
 
 '''
 
-
 def logPluginTrace(message: str, level: Number) -> None:
     """
     If plugin trace file logging is configured, logs `message` to it.
@@ -274,6 +299,14 @@ def getModuleFilename(moduleURL: str, reload: bool, normalize: bool, base: str |
         if moduleFilename:
             # `moduleFilename` normalized to an existing script
             return moduleFilename, None
+    if base and not _isAbsoluteModuleURL(moduleURL):
+        # Search for a matching plugin deeper in the plugin directory tree.
+        # Handles cases where a plugin exists in a nested structure, such as
+        # when a developer clones an entire repository into the plugin directory.
+        # Example: arelle/plugin/xule/plugin/xule/__init__.py
+        for path in glob("**/" + moduleURL.replace('\\', '/'), recursive=True):
+            if normalizedPath := normalizeModuleFilename(path):
+                return normalizedPath, None
     # `moduleFilename` did not map to a local filepath or did not normalize to a script
     # Try using `moduleURL` to search for pip-installed entry point
     entryPointRef = EntryPointRef.get(moduleURL)
@@ -416,7 +449,7 @@ def moduleModuleInfo(
 
     if moduleFilename:
         try:
-            logPluginTrace("Scanning module for plug-in info: {}".format(moduleFilename), logging.INFO)
+            logPluginTrace(f"Scanning module for plug-in info: {moduleFilename}", logging.INFO)
             moduleInfo = parsePluginInfo(moduleURL, moduleFilename, entryPoint)
             if moduleInfo is None:
                 return None
@@ -426,38 +459,50 @@ def moduleModuleInfo(
             del moduleInfo["importURLs"]
             moduleImports = moduleInfo["moduleImports"]
             del moduleInfo["moduleImports"]
-            _moduleImportsSubtree = False
+            moduleImportsSubtree = False
             mergedImportURLs = []
 
-            for _url in importURLs:
-                if _url.startswith("module_import"):
+            for url in importURLs:
+                if url.startswith("module_import"):
                     for moduleImport in moduleImports:
                         mergedImportURLs.append(moduleImport + ".py")
-                    if _url == "module_import_subtree":
-                        _moduleImportsSubtree = True
-                elif _url == "module_subtree":
+                    if url == "module_import_subtree":
+                        moduleImportsSubtree = True
+                elif url == "module_subtree":
                     for _dir in os.listdir(moduleDir):
-                        _subtreeModule = os.path.join(moduleDir,_dir)
-                        if os.path.isdir(_subtreeModule) and _dir != "__pycache__":
-                            mergedImportURLs.append(_subtreeModule)
+                        subtreeModule = os.path.join(moduleDir,_dir)
+                        if os.path.isdir(subtreeModule) and _dir != "__pycache__":
+                            mergedImportURLs.append(subtreeModule)
                 else:
-                    mergedImportURLs.append(_url)
-            if parentImportsSubtree and not _moduleImportsSubtree:
-                _moduleImportsSubtree = True
+                    mergedImportURLs.append(url)
+            if parentImportsSubtree and not moduleImportsSubtree:
+                moduleImportsSubtree = True
                 for moduleImport in moduleImports:
                     mergedImportURLs.append(moduleImport + ".py")
             imports = []
-            for _url in mergedImportURLs:
-                if isAbsolute(_url) or isLegacyAbs(_url):
-                    _importURL = _url # URL is absolute http or local file system
-                else: # check if exists relative to this module's directory
-                    _importURL = os.path.join(os.path.dirname(moduleURL), os.path.normpath(_url))
-                    if not os.path.exists(_importURL): # not relative to this plugin, assume standard plugin base
-                        _importURL = _url # moduleModuleInfo adjusts relative URL to plugin base
-                _importModuleInfo = moduleModuleInfo(moduleURL=_importURL, reload=reload, parentImportsSubtree=_moduleImportsSubtree)
-                if _importModuleInfo:
-                    _importModuleInfo["isImported"] = True
-                    imports.append(_importModuleInfo)
+            for url in mergedImportURLs:
+                importURL = url
+                if not _isAbsoluteModuleURL(url):
+                    # Handle relative imports when plugin is loaded from external directory.
+                    # When EDGAR/render imports EDGAR/validate, this works if EDGAR is in the plugin directory
+                    # but fails if loaded externally (e.g., dev repo clone at /dev/path/to/EDGAR/).
+                    # Solution: Find common path segments to resolve /dev/path/to/EDGAR/validate
+                    # from the importing module at /dev/path/to/EDGAR/render.
+                    modulePath = Path(moduleFilename)
+                    importPath = Path(url)
+                    if importPath.parts:
+                        importFirstPart = importPath.parts[0]
+                        for i, modulePathPart in enumerate(reversed(modulePath.parts)):
+                            if modulePathPart != importFirstPart:
+                                continue
+                            # Found a potential branching point, construct and check a new path
+                            candidateImportURL = str(modulePath.parents[i] / importPath)
+                            if normalizeModuleFilename(candidateImportURL):
+                                importURL = candidateImportURL
+                importModuleInfo = moduleModuleInfo(moduleURL=importURL, reload=reload, parentImportsSubtree=moduleImportsSubtree)
+                if importModuleInfo:
+                    importModuleInfo["isImported"] = True
+                    imports.append(importModuleInfo)
             moduleInfo["imports"] = imports
             logPluginTrace(f"Successful module plug-in info: {moduleFilename}", logging.INFO)
             return moduleInfo
@@ -477,43 +522,30 @@ def moduleInfo(pluginInfo):
             moduleInfo.getdefault('classes', []).append(name)
 
 
-def _get_name_dir_prefix(
-    controller: Cntlr,
-    pluginBase: str,
-    moduleURL: str,
-    packagePrefix: str = "",
-) -> tuple[str, str, str] | tuple[None, None, None]:
-    """Get the name, directory and prefix of a module."""
-    moduleFilename: str
-    moduleDir: str
-    packageImportPrefix: str
+def _isAbsoluteModuleURL(moduleURL: str) -> bool:
+    return isAbsolute(moduleURL) or isLegacyAbs(moduleURL)
 
-    moduleFilename = controller.webCache.getfilename(
-        url=moduleURL, normalize=True, base=pluginBase, allowTransformation=False
-    )
 
-    if moduleFilename:
-        if os.path.basename(moduleFilename) == "__init__.py" and os.path.isfile(
-            moduleFilename
-        ):
-            moduleFilename = os.path.dirname(
-                moduleFilename
-            )  # want just the dirpart of package
-
-        if os.path.isdir(moduleFilename) and os.path.isfile(
-            os.path.join(moduleFilename, "__init__.py")
-        ):
-            moduleDir = os.path.dirname(moduleFilename)
-            moduleName = os.path.basename(moduleFilename)
-            packageImportPrefix = moduleName + "."
-        else:
-            moduleName = os.path.basename(moduleFilename).partition(".")[0]
-            moduleDir = os.path.dirname(moduleFilename)
-            packageImportPrefix = packagePrefix
+def _get_name_dir_prefix(modulePath: Path, packagePrefix: str = "") -> tuple[str, str, str] | tuple[None, None, None]:
+    """Get the name, directory and prefix of a module."""
+    moduleName = None
+    moduleDir = None
+    packageImportPrefix = None
+    initFileName = "__init__.py"
+
+    if modulePath.is_file() and modulePath.name == initFileName:
+        modulePath = modulePath.parent
 
-        return (moduleName, moduleDir, packageImportPrefix)
+    if modulePath.is_dir() and (modulePath / initFileName).is_file():
+        moduleName = modulePath.name
+        moduleDir = str(modulePath.parent)
+        packageImportPrefix = moduleName + "."
+    elif modulePath.is_file() and modulePath.suffix == ".py":
+        moduleName = modulePath.stem
+        moduleDir = str(modulePath.parent)
+        packageImportPrefix = packagePrefix
 
-    return (None, None, None)
+    return (moduleName, moduleDir, packageImportPrefix)
 
 def _get_location(moduleDir: str, moduleName: str) -> str:
     """Get the file name of a plugin."""
@@ -543,13 +575,9 @@ def _find_and_load_module(moduleDir: str, moduleName: str) -> ModuleType | None:
 def loadModule(moduleInfo: dict[str, Any], packagePrefix: str="") -> None:
     name = moduleInfo['name']
     moduleURL = moduleInfo['moduleURL']
+    modulePath = Path(moduleInfo['path'])
 
-    moduleName, moduleDir, packageImportPrefix = _get_name_dir_prefix(
-        controller=_cntlr,
-        pluginBase=_pluginBase,
-        moduleURL=moduleURL,
-        packagePrefix=packagePrefix,
-    )
+    moduleName, moduleDir, packageImportPrefix = _get_name_dir_prefix(modulePath, packagePrefix)
 
     if all(p is None for p in [moduleName, moduleDir, packageImportPrefix]):
         _cntlr.addToLog(message=_ERROR_MESSAGE_IMPORT_TEMPLATE.format(name), level=logging.ERROR)
@@ -566,10 +594,12 @@ def loadModule(moduleInfo: dict[str, Any], packagePrefix: str="") -> None:
                     localeDir = os.path.dirname(module.__file__) + os.sep + pluginInfo['localeURL']
                     try:
                         _gettext = gettext.translation(pluginInfo['localeDomain'], localeDir, getLanguageCodes())
-                    except IOError:
-                        _gettext = lambda x: x # no translation
+                    except OSError:
+                        def _gettext(x):
+                            return x # no translation
                 else:
-                    _gettext = lambda x: x
+                    def _gettext(x):
+                        return x
                 for key, value in pluginInfo.items():
                     if key == 'name':
                         if name:
@@ -627,8 +657,7 @@ def pluginClassMethods(className: str) -> Iterator[Callable[..., Any]]:
                                 if className in pluginInfo:
                                     pluginMethodsForClass.append(pluginInfo[className])
             pluginMethodsForClasses[className] = pluginMethodsForClass
-        for method in pluginMethodsForClass:
-            yield method
+        yield from pluginMethodsForClass
 
 
 def addPluginModule(name: str) -> dict[str, Any] | None:

{arelle_release-2.37.56 → arelle_release-2.37.58}/arelle/ValidateDuplicateFacts.py

@@ -402,7 +402,7 @@ def getAspectEqualFacts(
                 fact.qname,
                 (
                     cast(str, fact.xmlLang or "").lower()
-                    if useLang and fact.concept.type.isWgnStringFactType
+                    if useLang and fact.concept.type.isOimTextFactType
                     else None
                 ),
             )

{arelle_release-2.37.56 → arelle_release-2.37.58}/arelle/XbrlConst.py

@@ -139,6 +139,7 @@ qnXlLocatorType = qname("{http://www.xbrl.org/2003/XLink}xl:locatorType")
 qnXlResourceType = qname("{http://www.xbrl.org/2003/XLink}xl:resourceType")
 qnXlArcType = qname("{http://www.xbrl.org/2003/XLink}xl:arcType")
 xhtml = "http://www.w3.org/1999/xhtml"
+qnXhtmlMeta = qname("{http://www.w3.org/1999/xhtml}meta")
 ixbrl = "http://www.xbrl.org/2008/inlineXBRL"
 ixbrl11 = "http://www.xbrl.org/2013/inlineXBRL"
 ixbrlAll = {ixbrl, ixbrl11}

{arelle_release-2.37.56 → arelle_release-2.37.58}/arelle/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '2.37.56'
-__version_tuple__ = version_tuple = (2, 37, 56)
+__version__ = version = '2.37.58'
+__version_tuple__ = version_tuple = (2, 37, 58)
 
-__commit_id__ = commit_id = 'g672ebed7e'
+__commit_id__ = commit_id = 'gfe089ce9d'

{arelle_release-2.37.56 → arelle_release-2.37.58}/arelle/plugin/validate/EDINET/Constants.py

@@ -10,25 +10,7 @@ class AccountingStandard(Enum):
     JAPAN_GAAP = 'Japan GAAP'
     US_GAAP = 'US GAAP'
 
-class FormType(Enum):
-    FORM_2_4 = '第二号の四様式'
-    FORM_2_7 = '第二号の七様式'
-    FORM_3 = '第三号様式'
-    FORM_4 = '第四号様式'
 
-    @property
-    def isStockReport(self) -> bool:
-        return self in STOCK_REPORT_FORMS
-
-CORPORATE_FORMS =frozenset([
-    FormType.FORM_2_4,
-    FormType.FORM_2_7,
-    FormType.FORM_3,
-])
-STOCK_REPORT_FORMS = frozenset([
-    FormType.FORM_3,
-    FormType.FORM_4,
-])
 qnEdinetManifestInsert = qname("{http://disclosure.edinet-fsa.go.jp/2013/manifest}insert")
 qnEdinetManifestInstance = qname("{http://disclosure.edinet-fsa.go.jp/2013/manifest}instance")
 qnEdinetManifestItem = qname("{http://disclosure.edinet-fsa.go.jp/2013/manifest}item")
@@ -76,3 +58,22 @@ PROHIBITED_HTML_TAGS = frozenset({
     'select',
     'textarea',
 })
+
+NUMERIC_LABEL_ROLES = frozenset({
+    'http://www.xbrl.org/2003/role/positiveLabel',
+    'http://www.xbrl.org/2003/role/positiveTerseLabel',
+    'http://www.xbrl.org/2003/role/positiveVerboseLabel',
+    'http://www.xbrl.org/2003/role/negativeLabel',
+    'http://www.xbrl.org/2003/role/negativeTerseLabel',
+    'http://www.xbrl.org/2003/role/negativeVerboseLabel',
+    'http://www.xbrl.org/2003/role/zeroLabel',
+    'http://www.xbrl.org/2003/role/zeroTerseLabel',
+    'http://www.xbrl.org/2003/role/zeroVerboseLabel',
+    'http://www.xbrl.org/2003/role/totalLabel',
+    'http://www.xbrl.org/2009/role/negatedLabel',
+    'http://www.xbrl.org/2009/role/negatedPeriodEndLabel',
+    'http://www.xbrl.org/2009/role/negatedPeriodStartLabel',
+    'http://www.xbrl.org/2009/role/negatedTotalLabel',
+    'http://www.xbrl.org/2009/role/negatedNetLabel',
+    'http://www.xbrl.org/2009/role/negatedTerseLabel',
+})

{arelle_release-2.37.56 → arelle_release-2.37.58}/arelle/plugin/validate/EDINET/ControllerPluginData.py

@@ -12,9 +12,12 @@ from typing import TYPE_CHECKING
 
 from arelle.Cntlr import Cntlr
 from arelle.FileSource import FileSource
+from arelle.ModelValue import QName
 from arelle.typing import TypeGetText
 from arelle.utils.PluginData import PluginData
 from . import Constants
+from .CoverPageRequirements import CoverPageRequirements
+from .FilingFormat import FilingFormat
 from .ReportFolderType import ReportFolderType
 from .UploadContents import UploadContents, UploadPathInfo
 
@@ -45,6 +48,10 @@ class ControllerPluginData(PluginData):
         """
         self._manifestInstancesById[manifestInstance.id] = manifestInstance
 
+    @lru_cache(1)
+    def getCoverPageRequirements(self, csvPath: Path, coverPageItems: tuple[QName, ...], filingFormats: tuple[FilingFormat, ...]) -> CoverPageRequirements:
+        return CoverPageRequirements(csvPath, coverPageItems, filingFormats)
+
     def getManifestInstances(self) -> list[ManifestInstance]:
         """
         Retrieve all loaded manifest instances.
@@ -147,10 +154,10 @@ class ControllerPluginData(PluginData):
         if (fileSource.fs is None or
                 not isinstance(fileSource.fs, zipfile.ZipFile)):
             if fileSource.cntlr is not None:
-                fileSource.cntlr.error(
-                    level="WARNING",
-                    codes="EDINET.uploadNotValidated",
-                    msg=_("The target file is not a zip file, so upload validation could not be performed.")
+                fileSource.cntlr.addToLog(
+                    _("The target file is not a zip file, so upload validation was not performed."),
+                    messageCode="EDINET.uploadNotValidated",
+                    file=str(fileSource.url)
                 )
             return False
         return True

arelle_release-2.37.58/arelle/plugin/validate/EDINET/CoverPageRequirements.py

@@ -0,0 +1,118 @@
+"""
+See COPYRIGHT.md for copyright information.
+"""
+from __future__ import annotations
+
+from enum import Enum
+from pathlib import Path
+
+from arelle.ModelValue import QName
+from .FilingFormat import FilingFormat
+
+
+# Cover page requirements parsing is designed so that the contents of Attachment #5
+# in "(Appendix) Taxonomy Extension Guideline" (ESE140111.zip), or future versions,
+# can be easily exported to a CSV file where the rows correspond to Cover Page items
+# andt the columns correspond to different formats.
+class CoverPageRequirements:
+    _coverPageItems: tuple[QName, ...]
+    _csvPath: Path
+    _data: dict[QName, dict[FilingFormat, CoverPageItemStatus | None]] | None
+    _filingFormats: tuple[FilingFormat, ...]
+
+    def __init__(self, csvPath: Path, coverPageItems: tuple[QName, ...], filingFormats: tuple[FilingFormat, ...]):
+        self._coverPageItems = coverPageItems
+        self._csvPath = csvPath
+        self._data = None
+        self._filingFormats = filingFormats
+
+    def _load(self) -> dict[QName, dict[FilingFormat, CoverPageItemStatus | None]]:
+        if self._data is None:
+            with open(self._csvPath, encoding='utf-8') as f:
+                data = [
+                    [
+                        CoverPageItemStatus.parse(cell) for cell in line.strip().split(',')
+                    ]
+                    for line in f.readlines()
+                ]
+                self._data = {}
+                assert len(data) == len(self._coverPageItems), \
+                    "Unexpected number of rows in cover page requirements CSV."
+                for rowIndex, row in enumerate(data):
+                    assert len(row) == len(self._filingFormats), \
+                        f"Unexpected number of columns in cover page requirements CSV at row {rowIndex}."
+                    coverPageItem = self._coverPageItems[rowIndex]
+                    self._data[coverPageItem] = {}
+                    for colIndex, cell in enumerate(row):
+                        filingFormat = self._filingFormats[colIndex]
+                        self._data[coverPageItem][filingFormat] = cell
+        return self._data
+
+
+    def get(self, coverPageItem: QName, filingFormat: FilingFormat) -> CoverPageItemStatus | None:
+        data = self._load()
+        if coverPageItem not in data:
+            return None
+        if filingFormat not in data[coverPageItem]:
+            return None
+        return data[coverPageItem][filingFormat]
+
+
+class CoverPageItemStatus(Enum):
+    # The values of the enum correspond to the symbols used in the spreadsheet.
+    PROHIBITED = '×'
+    OPTIONAL = '△'
+    CONDITIONAL = '○'
+    REQUIRED = '◎'
+
+    @classmethod
+    def parse(cls, value: str) -> CoverPageItemStatus | None:
+        try:
+            return cls(value)
+        except ValueError:
+            return None
+
+# The below values are based on Attachment #5 in "(Appendix) Taxonomy Extension Guideline" (ESE140111.zip).
+# Column D lists the elements of the cover page. Rows purely for grouping are omitted.
+# The order is preserved. The index is used to map to other data structures.
+COVER_PAGE_ITEM_LOCAL_NAMES = (
+    # Submitter Information (提出者情報)
+    'EDINETCodeDEI',
+    'FundCodeDEI',
+    'SecurityCodeDEI',
+    'FilerNameInJapaneseDEI',
+    'FilerNameInEnglishDEI',
+    'FundNameInJapaneseDEI',
+    'FundNameInEnglishDEI',
+
+    # Document Submission Information (提出書類情報)
+    'CabinetOfficeOrdinanceDEI',
+    'DocumentTypeDEI',
+    'AccountingStandardsDEI',
+    'WhetherConsolidatedFinancialStatementsArePreparedDEI',
+    'IndustryCodeWhenConsolidatedFinancialStatementsArePreparedInAccordanceWithIndustrySpecificRegulationsDEI',
+    'IndustryCodeWhenFinancialStatementsArePreparedInAccordanceWithIndustrySpecificRegulationsDEI',
+
+    # Current Fiscal Year (当会計期間)
+    'CurrentFiscalYearStartDateDEI',
+    'CurrentPeriodEndDateDEI',
+    'TypeOfCurrentPeriodDEI',
+    'CurrentFiscalYearEndDateDEI',
+
+    # Previous Fiscal Year (比較対象会計期間)
+    'PreviousFiscalYearStartDateDEI',
+    'ComparativePeriodEndDateDEI',
+    'PreviousFiscalYearEndDateDEI',
+
+    # Next Fiscal Year (次の中間期の会計期間)
+    'NextFiscalYearStartDateDEI',
+    'EndDateOfQuarterlyOrSemiAnnualPeriodOfNextFiscalYearDEI',
+
+    'NumberOfSubmissionDEI',
+    'AmendmentFlagDEI',
+    'IdentificationOfDocumentSubjectToAmendmentDEI',
+
+    # Type of Correction (訂正の種類)
+    'ReportAmendmentFlagDEI',
+    'XBRLAmendmentFlagDEI',
+)