arelle-release 2.37.61__py3-none-any.whl → 2.37.62__py3-none-any.whl

arelle/DisclosureSystem.py

@@ -62,6 +62,7 @@ class DisclosureSystem:
         self.validateEntryText = False
         self.allowedExternalHrefPattern = None
         self.allowedImageTypes = None
+        self.arcroleCyclesAllowed = {}
         self.schemaValidateSchema = None
         self.blockDisallowedReferences = False
         self.maxSubmissionSubdirectoryEntryNesting = 0
@@ -182,6 +183,10 @@ class DisclosureSystem:
                                     self.allowedExternalHrefPattern = re.compile(dsElt.get("allowedExternalHrefPattern"))
                                 if dsElt.get("allowedImageTypes"):
                                     self.allowedImageTypes = json.loads(dsElt.get("allowedImageTypes"))
+                                if dsElt.get("arcroleCyclesAllowed"):
+                                    self.arcroleCyclesAllowed = json.loads(dsElt.get("arcroleCyclesAllowed"))
+                                    for arcrole, specSet in self.arcroleCyclesAllowed.items():
+                                        self.arcroleCyclesAllowed[arcrole] = tuple(specSet)
                                 self.blockDisallowedReferences = dsElt.get("blockDisallowedReferences") == "true"
                                 try:
                                     self.maxSubmissionSubdirectoryEntryNesting = int(dsElt.get("maxSubmissionSubdirectoryEntryNesting"))

arelle/HtmlUtil.py

@@ -1,12 +1,13 @@
 '''
 See COPYRIGHT.md for copyright information.
 '''
-import regex as re
+from __future__ import annotations
 
-def attrValue(str, name):
+
+def attrValue(attr: str) -> str:
     # retrieves attribute in a string, such as xyz="abc" or xyz='abc' or xyz=abc;
-    prestuff, matchedName, valuePart = str.lower().partition("charset")
-    value = []
+    prestuff, matchedName, valuePart = attr.lower().partition("charset")
+    value: list[str] = []
     endSep = None
     beforeEquals = True
     for c in valuePart:

arelle/ValidateDuplicateFacts.py

@@ -207,6 +207,8 @@ class DuplicateFactSet:
         :return: A subset of the facts where the fact of lower precision in every consistent pair has been removed.
         """
         facts = self.deduplicateCompleteSubsets()
+        if len(facts) < 2:
+            return facts
         if not self.areNumeric:
             # Consistency is equivalent to completeness for non-numeric facts
             return facts

arelle/ValidateXbrl.py

@@ -147,6 +147,8 @@ class ValidateXbrl:
             if arcrole.startswith("XBRL-") or ELR is None or \
                 linkqname is None or arcqname is None:
                 continue
+            elif arcrole in self.modelXbrl.modelManager.disclosureSystem.arcroleCyclesAllowed:
+                cyclesAllowed, specSect = self.modelXbrl.modelManager.disclosureSystem.arcroleCyclesAllowed[arcrole]
             elif arcrole in XbrlConst.standardArcroleCyclesAllowed:
                 # TODO: table should be in this module, where it is used
                 cyclesAllowed, specSect = XbrlConst.standardArcroleCyclesAllowed[arcrole]
@@ -163,7 +165,7 @@ class ValidateXbrl:
                                       or arcrole in self.genericArcArcroles  \
                                       or arcrole.startswith(XbrlConst.formulaStartsWith) \
                                       or (modelXbrl.hasXDT and arcrole.startswith(XbrlConst.dimStartsWith)):
-                relsSet = modelXbrl.relationshipSet(arcrole,ELR,linkqname,arcqname)
+                relsSet = modelXbrl.relationshipSet(arcrole, ELR, linkqname, arcqname)
                 if cyclesAllowed != "any" and \
                     ((XbrlConst.isStandardExtLinkQname(linkqname) and XbrlConst.isStandardArcQname(arcqname)) \
                         or arcrole in self.genericArcArcroles):

arelle/ValidateXbrlDTS.py

@@ -372,7 +372,7 @@ def checkElements(val, modelDocument, parent):
         if isinstance(parent,ModelObject): # element
             if (parent.localName == "meta" and parent.namespaceURI == XbrlConst.xhtml and
                 (parent.get("http-equiv") or "").lower() == "content-type"):
-                val.metaContentTypeEncoding = HtmlUtil.attrValue(parent.get("content"), "charset")
+                val.metaContentTypeEncoding = HtmlUtil.attrValue(parent.get("content"))
         elif isinstance(parent,etree._ElementTree): # documentNode
             val.documentTypeEncoding = modelDocument.documentEncoding # parent.docinfo.encoding
             val.metaContentTypeEncoding = ""

arelle/XbrlConst.py

@@ -27,6 +27,8 @@ qnXsdImport = qname("{http://www.w3.org/2001/XMLSchema}xsd:import")
 qnXsdSchema = qname("{http://www.w3.org/2001/XMLSchema}xsd:schema")
 qnXsdAppinfo = qname("{http://www.w3.org/2001/XMLSchema}xsd:appinfo")
 qnXsdDefaultType = qname("{http://www.w3.org/2001/XMLSchema}xsd:anyType")
+qnXsdElement = qname("{http://www.w3.org/2001/XMLSchema}xsd:element")
+qnXsdAttribute = qname("{http://www.w3.org/2001/XMLSchema}xsd:attribute")
 xsi = "http://www.w3.org/2001/XMLSchema-instance"
 qnXsiNil = qname(xsi, "xsi:nil")  # need default prefix in qname
 qnXsiType = qname(xsi, "xsi:type")
@@ -128,6 +130,7 @@ qnXlinkArcRole = qname("{http://www.w3.org/1999/xlink}xlink:arcrole")
 qnXlinkFrom = qname("{http://www.w3.org/1999/xlink}xlink:from")
 qnXlinkHref = qname("{http://www.w3.org/1999/xlink}xlink:href")
 qnXlinkLabel = qname("{http://www.w3.org/1999/xlink}xlink:label")
+qnXlinkRole = qname("{http://www.w3.org/1999/xlink}xlink:role")
 qnXlinkTo = qname("{http://www.w3.org/1999/xlink}xlink:to")
 qnXlinkType = qname("{http://www.w3.org/1999/xlink}xlink:type")
 xl = "http://www.xbrl.org/2003/XLink"
@@ -180,6 +183,21 @@ ixAttributes = set(
         "tupleID",
     )
 )
+ixbrlTargetElements = frozenset({
+    qnIXbrlFraction,
+    qnIXbrlNonFraction,
+    qnIXbrlNonNumeric,
+    qnIXbrlResources,
+    qnIXbrlTuple,
+})
+ixbrl11TargetElements = frozenset({
+    qnIXbrl11Fraction,
+    qnIXbrl11NonFraction,
+    qnIXbrl11NonNumeric,
+    qnIXbrl11Resources,
+    qnIXbrl11Tuple,
+})
+ixbrlAllTargetElements = ixbrlTargetElements | ixbrl11TargetElements
 conceptLabel = "http://www.xbrl.org/2003/arcrole/concept-label"
 conceptReference = "http://www.xbrl.org/2003/arcrole/concept-reference"
 footnote = "http://www.xbrl.org/2003/role/footnote"

arelle/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '2.37.61'
-__version_tuple__ = version_tuple = (2, 37, 61)
+__version__ = version = '2.37.62'
+__version_tuple__ = version_tuple = (2, 37, 62)
 
 __commit_id__ = commit_id = None

arelle/config/disclosuresystems.xsd

@@ -74,6 +74,7 @@
       <xs:attribute name="standardTaxonomyDatabase" />
       <xs:attribute name="standardTaxonomyUrlPattern" />
       <xs:attribute name="options" />
+      <xs:attribute name="arcroleCyclesAllowed" type="xs:string"/>
     </xs:complexType>
   </xs:element>
 </xs:schema>

arelle/plugin/validate/EDINET/Constants.py

@@ -3,6 +3,8 @@ See COPYRIGHT.md for copyright information.
 """
 from enum import Enum
 
+import regex
+
 from arelle.ModelValue import qname
 
 class AccountingStandard(Enum):
@@ -79,3 +81,96 @@ NUMERIC_LABEL_ROLES = frozenset({
     'http://www.xbrl.org/2009/role/negatedNetLabel',
     'http://www.xbrl.org/2009/role/negatedTerseLabel',
 })
+
+PATTERN_CODE = r'(?P<code>[A-Za-z\d]*)'
+PATTERN_CONSOLIDATED = r'(?P<consolidated>c|n)'
+PATTERN_COUNT = r'(?P<count>\d{2})'
+PATTERN_DATE1 = r'(?P<year1>\d{4})-(?P<month1>\d{2})-(?P<day1>\d{2})'
+PATTERN_DATE2 = r'(?P<year2>\d{4})-(?P<month2>\d{2})-(?P<day2>\d{2})'
+PATTERN_FORM = r'(?P<form>\d{6})'
+PATTERN_LINKBASE = r'(?P<linkbase>lab|lab-en|gla|pre|def|cal)'
+PATTERN_MAIN = r'(?P<main>\d{7})'
+PATTERN_NAME = r'(?P<name>[a-z]{6})'
+PATTERN_ORDINANCE = r'(?P<ordinance>[a-z]*)'
+PATTERN_PERIOD = r'(?P<period>c|p)'  # TODO: Have only seen "c" in sample/public filings, assuming "p" for previous.
+PATTERN_REPORT = r'(?P<report>[a-z0-9]*)'
+PATTERN_REPORT_SERIAL = r'(?P<report_serial>\d{3})'
+PATTERN_SERIAL = r'(?P<serial>\d{3})'
+
+PATTERN_AUDIT_REPORT_PREFIX = rf'jpaud-{PATTERN_REPORT}-{PATTERN_PERIOD}{PATTERN_CONSOLIDATED}'
+PATTERN_REPORT_PREFIX = rf'jp{PATTERN_ORDINANCE}{PATTERN_FORM}-{PATTERN_REPORT}'
+PATTERN_SUFFIX = rf'{PATTERN_REPORT_SERIAL}_{PATTERN_CODE}-{PATTERN_SERIAL}_{PATTERN_DATE1}_{PATTERN_COUNT}_{PATTERN_DATE2}'
+
+PATTERN_URI_HOST = r'http:\/\/disclosure\.edinet-fsa\.go\.jp'
+PATTERN_AUDIT_URI_PREFIX = rf'jpaud\/{PATTERN_REPORT}\/{PATTERN_PERIOD}{PATTERN_CONSOLIDATED}'
+PATTERN_REPORT_URI_PREFIX = rf'jp{PATTERN_ORDINANCE}{PATTERN_FORM}\/{PATTERN_REPORT}'
+PATTERN_URI_SUFFIX = rf'{PATTERN_REPORT_SERIAL}\/{PATTERN_CODE}-{PATTERN_SERIAL}\/{PATTERN_DATE1}\/{PATTERN_COUNT}\/{PATTERN_DATE2}'
+
+# Extension namespace URI for report
+# Example: http://disclosure.edinet-fsa.go.jp/jpcrp030000/asr/001/X99002-000/2025-03-31/01/2025-06-28
+REPORT_NAMESPACE_URI_PATTERN = regex.compile(rf'{PATTERN_URI_HOST}\/{PATTERN_REPORT_URI_PREFIX}\/{PATTERN_URI_SUFFIX}')
+
+# Extension namespace URI for audit report
+# Example: http://disclosure.edinet-fsa.go.jp/jpaud/aar/cn/001/X99002-000/2025-03-31/01/2025-06-28
+AUDIT_NAMESPACE_URI_PATTERN = regex.compile(rf'{PATTERN_URI_HOST}\/{PATTERN_AUDIT_URI_PREFIX}\/{PATTERN_URI_SUFFIX}')
+
+# Extension namespace prefix for report
+# Example: jpcrp040300-ssr_X99005-000
+REPORT_PREFIX_PATTERN = regex.compile(rf'{PATTERN_REPORT_PREFIX}_{PATTERN_CODE}-{PATTERN_SERIAL}')
+
+# Extension namespace prefix for audit report
+# Example: jpaud-qrr-cn_X99005-000
+AUDIT_PREFIX_PATTERN = regex.compile(rf'{PATTERN_AUDIT_REPORT_PREFIX}_{PATTERN_CODE}-{PATTERN_SERIAL}')
+
+# Instance file for report
+# Example: jpcrp050300-esr-001_X99007-000_2025-04-10_01_2025-04-10.xsd
+REPORT_XBRL_FILENAME_PATTERN = regex.compile(rf'{PATTERN_REPORT_PREFIX}-{PATTERN_SUFFIX}\.xbrl')
+
+# Instance file for audit report
+# Example: jpaud-aar-cn-001_X99001-000_2025-03-31_01_2025-06-28.xsd
+AUDIT_XBRL_FILENAME_PATTERN = regex.compile(rf'{PATTERN_AUDIT_REPORT_PREFIX}-{PATTERN_SUFFIX}\.xbrl')
+
+# Schema file for report
+# Example: jpcrp050300-esr-001_X99007-000_2025-04-10_01_2025-04-10.xsd
+REPORT_SCHEMA_FILENAME_PATTERN = regex.compile(rf'{PATTERN_REPORT_PREFIX}-{PATTERN_SUFFIX}\.xsd')
+
+# Schema file for audit report
+# Example: jpaud-aar-cn-001_X99001-000_2025-03-31_01_2025-06-28.xsd
+AUDIT_SCHEMA_FILENAME_PATTERN = regex.compile(rf'{PATTERN_AUDIT_REPORT_PREFIX}-{PATTERN_SUFFIX}\.xsd')
+
+# Linkbase file for report
+# Example: jpcrp020000-srs-001_X99001-000_2025-03-31_01_2025-11-20_cal.xml
+REPORT_LINKBASE_FILENAME_PATTERN = regex.compile(rf'{PATTERN_REPORT_PREFIX}-{PATTERN_SUFFIX}_{PATTERN_LINKBASE}\.xml')
+
+# Linkbase file for audit report
+# Example: jpaud-qrr-cc-001_X99001-000_2025-03-31_01_2025-11-20_pre.xml
+AUDIT_LINKBASE_FILENAME_PATTERN = regex.compile(rf'{PATTERN_AUDIT_REPORT_PREFIX}-{PATTERN_SUFFIX}_{PATTERN_LINKBASE}\.xml')
+
+# Cover page file for report
+# Example: 0000000_header_jpcrp020000-srs-001_X99001-000_2025-03-31_01_2025-11-20_ixbrl.htm
+REPORT_COVER_FILENAME_PATTERN = regex.compile(rf'{COVER_PAGE_FILENAME_PREFIX}{PATTERN_REPORT_PREFIX}-{PATTERN_SUFFIX}_ixbrl\.htm')
+
+# Main file for report
+# Example: 0205020_honbun_jpcrp020000-srs-001_X99001-000_2025-03-31_01_2025-11-20_ixbrl.htm
+REPORT_IXBRL_FILENAME_PATTERN = regex.compile(rf'{PATTERN_MAIN}_{PATTERN_NAME}_{PATTERN_REPORT_PREFIX}-{PATTERN_SUFFIX}_ixbrl\.htm')
+
+# Main file for audit report
+# Example: jpaud-qrr-cc-001_X99001-000_2025-03-31_01_2025-11-20_pre.xml
+AUDIT_IXBRL_FILENAME_PATTERN = regex.compile(rf'{PATTERN_AUDIT_REPORT_PREFIX}-{PATTERN_SUFFIX}_ixbrl\.htm')
+
+PATTERN_CONTEXT_RELATIVE_PERIOD = r'(?P<relative_period>Prior[1-9]Year|CurrentYear|Prior[1-9]Interim|Interim)'
+PATTERN_CONTEXT_PERIOD = r'(?P<relative_period>Prior[1-9]Year|CurrentYear|Prior[1-9]Interim|Interim|FilingDate|RecordDate)'
+PATTERN_CONTEXT_DURATION = r'(?P<duration>Duration|Instant)'
+PATTERN_CONTEXT_MEMBERS = r'(?P<context_members>(?:_[a-zA-Z][a-zA-Z0-9-]+)+)*'
+PATTERN_CONTEXT_NUMBER = r'(?P<context_number>[0-9]{3})'
+
+# All context IDs
+# Example: Prior2YearDuration_jpcrp020000-srs_X99001-000IndustrialMachineryReportableSegmentMember
+CONTEXT_ID_PATTERN = regex.compile(rf'{PATTERN_CONTEXT_PERIOD}{PATTERN_CONTEXT_DURATION}{PATTERN_CONTEXT_MEMBERS}(?:_{PATTERN_CONTEXT_NUMBER})?')
+
+# Context IDs for facts associated with Financial Statements
+# Example: Prior2YearDuration
+FINANCIAL_STATEMENT_CONTEXT_ID_PATTERN = regex.compile(rf'^{PATTERN_CONTEXT_RELATIVE_PERIOD}{PATTERN_CONTEXT_DURATION}.*')
+
+# Accepted language codes for Japan
+JAPAN_LANGUAGE_CODES = frozenset({'ja', 'jp', 'ja-jp', 'JA', 'JP', 'JA-JP'})

arelle/plugin/validate/EDINET/ControllerPluginData.py

@@ -16,9 +16,11 @@ from arelle.ModelValue import QName
 from arelle.typing import TypeGetText
 from arelle.utils.PluginData import PluginData
 from . import Constants
-from .CoverPageRequirements import CoverPageRequirements
+from .CoverItemRequirements import CoverItemRequirements
+from .DeiRequirements import DeiRequirements
 from .FilingFormat import FilingFormat
 from .ReportFolderType import ReportFolderType
+from .TableOfContentsBuilder import TableOfContentsBuilder
 from .UploadContents import UploadContents, UploadPathInfo
 
 if TYPE_CHECKING:
@@ -30,12 +32,14 @@ _: TypeGetText
 @dataclass
 class ControllerPluginData(PluginData):
     _manifestInstancesById: dict[str, ManifestInstance]
+    _tocBuilder: TableOfContentsBuilder
     _uploadContents: UploadContents | None
     _usedFilepaths: set[Path]
 
     def __init__(self, name: str):
         super().__init__(name)
         self._manifestInstancesById = {}
+        self._tocBuilder = TableOfContentsBuilder()
         self._usedFilepaths = set()
         self._uploadContents = None
 
@@ -49,8 +53,12 @@ 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 getCoverItemRequirements(self, jsonPath: Path) -> CoverItemRequirements:
+        return CoverItemRequirements(jsonPath)
+
+    @lru_cache(1)
+    def getDeiRequirements(self, csvPath: Path, deiItems: tuple[QName, ...], filingFormats: tuple[FilingFormat, ...]) -> DeiRequirements:
+        return DeiRequirements(csvPath, deiItems, filingFormats)
 
     def getManifestInstances(self) -> list[ManifestInstance]:
         """
@@ -58,6 +66,9 @@ class ControllerPluginData(PluginData):
         """
         return list(self._manifestInstancesById.values())
 
+    def getTableOfContentsBuilder(self) -> TableOfContentsBuilder:
+        return self._tocBuilder
+
     def getUploadContents(self) -> UploadContents | None:
         return self._uploadContents
 

arelle/plugin/validate/EDINET/CoverItemRequirements.py

@@ -0,0 +1,42 @@
+"""
+See COPYRIGHT.md for copyright information.
+"""
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+
+# Cover item requirements do not appear to be specifically documented anywhere,
+# so we have inferred them from the documentation and sample filings available to us:
+#   Cover item requirements loaded by starting with "Taxonomy Element List" (ESE140114.xlsx),
+#   which appears to give a mapping of ELR URIs to required cover items (Concepts with
+#   "*CoverPage" local names). However, the sequence of the cover items (validated by EC1004E)
+#   does not match the order in samples #10, #11, #21 and #22. In those cases, the sequences
+#   have been updated to match the samples.
+# A note at the bottom of "3-4-2 Cover Page" within "File Specification for EDINET Filing"
+# (ESE140104.pdf) indicates that cover pages are either generated within EDINET's submission
+# UI or manually. The manual process involves downloading a template cover page HTML file, editing it,
+# and then re-uploading it. This suggests that there are cover page template files that may be the most
+# reliable source of truth for cover item requirements, but we have not been able to access these templates.
+class CoverItemRequirements:
+    _jsonPath: Path
+    _data: dict[str, list[str]] | None
+
+    def __init__(self, jsonPath: Path):
+        self._jsonPath = jsonPath
+        self._data = None
+
+    def _load(self) -> dict[str, list[str]]:
+        if self._data is None:
+            with open(self._jsonPath, encoding='utf-8') as f:
+                self._data = json.load(f)
+        return self._data
+
+    def all(self) -> frozenset[str]:
+        data = self._load()
+        return frozenset(v for values in data.values() for v in values)
+
+    def get(self, roleUri: str) -> list[str]:
+        data = self._load()
+        return data.get(roleUri, [])

arelle/plugin/validate/EDINET/{CoverPageRequirements.py → DeiRequirements.py}

@@ -10,55 +10,55 @@ from arelle.ModelValue import QName
 from .FilingFormat import FilingFormat
 
 
-# Cover page requirements parsing is designed so that the contents of Attachment #5
+# DEI 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, ...]
+# can be easily exported to a CSV file where the rows correspond to DEI concepts
+# and the columns correspond to different formats.
+class DeiRequirements:
     _csvPath: Path
-    _data: dict[QName, dict[FilingFormat, CoverPageItemStatus | None]] | None
+    _data: dict[QName, dict[FilingFormat, DeiItemStatus | None]] | None
+    _deiItems: tuple[QName, ...]
     _filingFormats: tuple[FilingFormat, ...]
 
-    def __init__(self, csvPath: Path, coverPageItems: tuple[QName, ...], filingFormats: tuple[FilingFormat, ...]):
-        self._coverPageItems = coverPageItems
+    def __init__(self, csvPath: Path, deiItems: tuple[QName, ...], filingFormats: tuple[FilingFormat, ...]):
         self._csvPath = csvPath
         self._data = None
+        self._deiItems = deiItems
         self._filingFormats = filingFormats
 
-    def _load(self) -> dict[QName, dict[FilingFormat, CoverPageItemStatus | None]]:
+    def _load(self) -> dict[QName, dict[FilingFormat, DeiItemStatus | 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(',')
+                        DeiItemStatus.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."
+                assert len(data) == len(self._deiItems), \
+                    "Unexpected number of rows in DEI 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] = {}
+                        f"Unexpected number of columns in DEI requirements CSV at row {rowIndex}."
+                    deiItem = self._deiItems[rowIndex]
+                    self._data[deiItem] = {}
                     for colIndex, cell in enumerate(row):
                         filingFormat = self._filingFormats[colIndex]
-                        self._data[coverPageItem][filingFormat] = cell
+                        self._data[deiItem][filingFormat] = cell
         return self._data
 
 
-    def get(self, coverPageItem: QName, filingFormat: FilingFormat) -> CoverPageItemStatus | None:
+    def get(self, deiItem: QName, filingFormat: FilingFormat) -> DeiItemStatus | None:
         data = self._load()
-        if coverPageItem not in data:
+        if deiItem not in data:
             return None
-        if filingFormat not in data[coverPageItem]:
+        if filingFormat not in data[deiItem]:
             return None
-        return data[coverPageItem][filingFormat]
+        return data[deiItem][filingFormat]
 
 
-class CoverPageItemStatus(Enum):
+class DeiItemStatus(Enum):
     # The values of the enum correspond to the symbols used in the spreadsheet.
     PROHIBITED = '×'
     OPTIONAL = '△'
@@ -66,16 +66,16 @@ class CoverPageItemStatus(Enum):
     REQUIRED = '◎'
 
     @classmethod
-    def parse(cls, value: str) -> CoverPageItemStatus | None:
+    def parse(cls, value: str) -> DeiItemStatus | 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.
+# Column D lists the DEI concepts. 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 = (
+DEI_LOCAL_NAMES = (
     # Submitter Information (提出者情報)
     'EDINETCodeDEI',
     'FundCodeDEI',