arelle-release 2.36.33__tar.gz → 2.36.35__tar.gz

{arelle_release-2.36.33/arelle_release.egg-info → arelle_release-2.36.35}/PKG-INFO

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

{arelle_release-2.36.33 → arelle_release-2.36.35}/arelle/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '2.36.33'
-__version_tuple__ = version_tuple = (2, 36, 33)
+__version__ = version = '2.36.35'
+__version_tuple__ = version_tuple = (2, 36, 35)

{arelle_release-2.36.33 → arelle_release-2.36.35}/arelle/oim/Load.py

@@ -318,7 +318,7 @@ CsvMemberTypes = {
     "/documentInfo/baseURL": URIType,
     "/documentInfo/documentType": str,
     "/documentInfo/features": dict,
-    "/documentInfo/features/*:*": (int,float,bool,str,type(None)),
+    "/documentInfo/features/*:*": (int,float,bool,str,dict,list,type(None),NoRecursionCheck),
     "/documentInfo/final": dict,
     "/documentInfo/namespaces": dict,
     "/documentInfo/namespaces/*": URIType,
@@ -377,6 +377,7 @@ CsvMemberTypes = {
     "/tableTemplates/*/columns/*/propertiesFrom/": str,
     "/tableTemplates/*/columns/*/propertyGroups": dict,
     "/tableTemplates/*/columns/*/propertyGroups/*": dict,
+    "/tableTemplates/*/columns/*/propertyGroups/*/*:*": (int,float,bool,str,dict,list,type(None),NoRecursionCheck,CheckPrefix), # custom extensions
     "/tableTemplates/*/columns/*/propertyGroups/*/decimals": (int,str),
     "/tableTemplates/*/columns/*/propertyGroups/*/dimensions": dict,
     "/tableTemplates/*/columns/*/propertyGroups/*/dimensions/concept": str,
@@ -1316,8 +1317,8 @@ def _loadFromOIM(cntlr, error, warning, modelXbrl, oimFile, mappedUri):
                         # check table parameters
                         tableParameterReferenceNames = set()
                         def checkParamRef(paramValue, factColName=None, dimName=None):
-                            if isinstance(paramValue, str) and paramValue.startswith("$") and not paramValue.startswith("$$"):
-                                paramName = paramValue[1:].partition("@")[0]
+                            if _isParamRef(paramValue):
+                                paramName = _getParamRefName(paramValue)
                                 tableParameterReferenceNames.add(paramName)
                         unitDims = set()
                         for factColName, colDims in factDimensions.items():
@@ -1540,16 +1541,21 @@ def _loadFromOIM(cntlr, error, warning, modelXbrl, oimFile, mappedUri):
                                     for propFromColName in propFromColNames:
                                         if propFromColName in rowPropGroups:
                                             for prop, val in rowPropGroups[propFromColName].items():
+                                                if ":" in prop:
+                                                    # Extension property
+                                                    continue
                                                 if isinstance(val, dict):
                                                     _valDict = cellPropGroup.setdefault(prop, {})
                                                     for dim, _val in val.items():
                                                         _valDict[dim] = _val
                                                         propGroupDimSource[dim] = propFromColName
-                                                        if _val.startswith("$") and not _val.startswith("$$"):
-                                                            rowPropGrpParamRefs.add(_val.partition("@")[0][1:])
+                                                        if _isParamRef(_val):
+                                                            rowPropGrpParamRefs.add(_getParamRefName(_val))
                                                 else:
                                                     cellPropGroup[prop] = val
                                                     propGroupDimSource[prop] = propFromColName
+                                                    if _isParamRef(val):
+                                                        rowPropGrpParamRefs.add(_getParamRefName(val))
                                     if factDimensions[colName] is None:
                                         if colName in paramRefColNames:
                                             value = _cellValue(row[colNameIndex[colName]])
@@ -1560,8 +1566,14 @@ def _loadFromOIM(cntlr, error, warning, modelXbrl, oimFile, mappedUri):
                                         if not cellPropGroup:
                                             continue # not a fact column
                                     for rowPropGrpParamRef in rowPropGrpParamRefs:
-                                        value = _cellValue(row[colNameIndex[rowPropGrpParamRef]])
-                                        if value is EMPTY_CELL or value is NONE_CELL:
+                                        value = None
+                                        if rowPropGrpParamRef in colNameIndex:
+                                            value = _cellValue(row[colNameIndex[rowPropGrpParamRef]])
+                                        elif rowPropGrpParamRef in tableParameters:
+                                            value = tableParameters.get(rowPropGrpParamRef)
+                                        elif rowPropGrpParamRef in reportParameters:
+                                            value = reportParameters.get(rowPropGrpParamRef)
+                                        if value in (None, EMPTY_CELL, NONE_CELL):
                                             emptyCols.add(rowPropGrpParamRef)
                                     # assemble row and fact Ids
                                     if idColIndex is not None and not rowId:
@@ -1628,8 +1640,10 @@ def _loadFromOIM(cntlr, error, warning, modelXbrl, oimFile, mappedUri):
                                                                 factDimensionSourceCol[dimName] = paramName
                                                         elif paramName in tableParameters:
                                                             dimValue = tableParameters[paramName]
+                                                            factDimensionSourceCol[dimName] = paramName
                                                         elif paramName in reportParameters:
                                                             dimValue = reportParameters[paramName]
+                                                            factDimensionSourceCol[dimName] = paramName
                                                         elif paramName in unreportedFactDimensionColumns:
                                                             dimValue = NONE_CELL
                                                         else:
@@ -1659,7 +1673,10 @@ def _loadFromOIM(cntlr, error, warning, modelXbrl, oimFile, mappedUri):
                                     elif "decimals" in cellPropGroup:
                                         dimValue = cellPropGroup["decimals"]
                                         dimSource = "propertyGroup " + propFromColName
-                                        factDimensionPropGrpCol["decimals"] = propGroupDimSource[dimName]
+                                        if _isParamRef(dimValue):
+                                            factDimensionPropGrpCol["decimals"] = _getParamRefName(dimValue)
+                                        else:
+                                            factDimensionPropGrpCol["decimals"] = dimValue
                                     elif tableDecimals is not None:
                                         dimValue = tableDecimals
                                         dimSource = "table decimals"
@@ -1840,7 +1857,7 @@ def _loadFromOIM(cntlr, error, warning, modelXbrl, oimFile, mappedUri):
                         error("xbrlce:invalidJSONStructure",
                               _("Invalid value: %(value)s at %(path)s"),
                               modelObject=modelXbrl, value=dimValue, path="/".join(pathSegs+(dimName,)))
-                    elif isinstance(dimValue,str) and dimValue.startswith("$") and not dimValue.startswith("$$"):
+                    elif _isParamRef(dimValue):
                         paramName, _sep, periodSpecifier = dimValue[1:].partition("@")
                         if _sep and periodSpecifier not in ("start", "end"):
                             error("xbrlce:invalidPeriodSpecifier",
@@ -2800,6 +2817,18 @@ def _loadFromOIM(cntlr, error, warning, modelXbrl, oimFile, mappedUri):
 
     return _return
 
+def _isParamRef(value):
+    if not isinstance(value, str):
+        return False
+    if not value.startswith("$"):
+        return False
+    return not value.startswith("$$")
+
+def _getParamRefName(paramRef):
+    prefixStripped = paramRef.removeprefix("$")
+    periodSpecifierRemoved = prefixStripped.partition("@")[0]
+    return periodSpecifierRemoved
+
 def isOimLoadable(normalizedUri, filepath):
     _ext = os.path.splitext(filepath)[1]
     if _ext in (".csv", ".json", ".xlsx", ".xls"):

{arelle_release-2.36.33 → arelle_release-2.36.35/arelle_release.egg-info}/PKG-INFO

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

{arelle_release-2.36.33 → arelle_release-2.36.35}/arelle_release.egg-info/SOURCES.txt

@@ -774,6 +774,7 @@ docs/source/build_docs.md
 docs/source/command_line.md
 docs/source/conf.py
 docs/source/contributing.md
+docs/source/esef.md
 docs/source/faq.md
 docs/source/index.md
 docs/source/install.md

arelle_release-2.36.35/docs/source/esef.md

@@ -0,0 +1,118 @@
+# ESEF (European Single Electronic Format)
+
+:::{index} ESEF
+:::
+
+## Overview
+
+The European Single Electronic Format (ESEF) is a digital reporting requirement mandated by the European Securities and Markets Authority (ESMA) for publicly listed companies in the European Union. It requires annual financial reports to be prepared in XHTML format with XBRL tags embedded within the document using the Inline XBRL (iXBRL) format for consolidated financial statements.
+
+## Validation in Arelle
+
+### XBRL Core Validation
+
+Arelle automatically validates that all XBRL reports meet the standards defined in the XBRL specifications and executes any validation rules implemented using the XBRL Formula specification.
+
+### ESEF-Specific Validation
+
+ESMA defines additional validation rules and requirements in their Regulatory Technical Standards (RTS) and ESEF Reporting Manual. Since these rules are published as plain text and cannot be automatically derived from the specifications, Arelle provides a dedicated plugin called `Validate ESMA ESEF` that implements these additional validation rules.
+
+## ESEF Disclosure Systems
+
+Arelle's validation plugins can provide multiple collections of validation rules. Each of these collections is called a disclosure system. The ESEF disclosure systems in Arelle correspond to the year of the reporting manual that the plugin validates against:
+
+### Types of ESEF Disclosure Systems
+
+- **Annual consolidated systems**:
+  - Format: `esef-YYYY` (e.g., `esef-2023`)
+  - Purpose: Validates against rules published in that year's reporting manual
+  - Use for: XHTML reports with Inline XBRL tagging of consolidated statements
+
+- **Unconsolidated systems**:
+  - Format: `esef-unconsolidated-YYYY` (e.g., `esef-unconsolidated-2023`)
+  - Purpose: Validates XHTML reports without XBRL tagging
+  - Use for: Annual reports without consolidated IFRS statements
+
+> **Important**: Always select the appropriate disclosure system version that matches your reporting period requirements, as validation rules evolve between reporting years.
+
+## GUI Validation
+
+To enable ESEF validation in the Arelle graphical user interface:
+
+1. **Enable the ESEF Plugin**:
+   - Use the plugin manager to [select][select-esef-gui-plugin] the `Validate ESMA ESEF` plugin to enable it
+   - Restart Arelle if required
+
+2. **Select the ESEF Disclosure System**:
+   - Navigate to `Tools` > `Validation` > `Select disclosure system...`
+   - Choose the appropriate ESEF disclosure system:
+     - For reports with Inline XBRL: Select year-specific system matching your requirements (e.g., `ESMA RTS on ESEF-2023`)
+     - For reports without XBRL tagging: Select `ESMA RTS on ESEF-2023 Unconsolidated` or equivalent for your reporting year
+
+3. **Set Formula Parameters (Optional)**:
+   - Navigate to `Tools` > `Formula` > `Parameters...`
+   - Set parameters as needed:
+     - `authority`: For country-specific validations (e.g., `DK` for Denmark or `UK` for UKSEF)
+     - `eps_threshold`: Custom calculation tolerance for numeric accuracy checks
+
+4. **Open the ESEF Report**:
+   - Use `File` > `Open File...` to open the ESEF report (can be .zip package, or .xbri report package.)
+
+5. **Trigger Validation**:
+   - Select `Tools` > `Validation` > `Validate`
+   - Validation results will appear in the messages window at the bottom of the screen
+
+[select-esef-gui-plugin]: project:/plugins/using_with_gui.md#select
+
+## CLI Validation
+
+Arelle's command-line interface provides flexible options for validating ESEF reports in automated workflows or batch processing.
+
+### Basic CLI Usage Patterns
+
+#### Basic Validation (Latest Supported Reporting Manual)
+
+```bash
+python arelleCmdLine.py --plugin validate/ESEF --disclosureSystem esef --validate --file report.xbri
+```
+
+#### Year-Specific Validation
+
+```bash
+python arelleCmdLine.py --plugin validate/ESEF --disclosureSystem esef-2023 --validate --file report.zip
+```
+
+#### Country-Specific Validation Rules
+
+For authority-specific validations (e.g., Denmark or United Kingdom):
+
+```bash
+python arelleCmdLine.py --plugin validate/ESEF --disclosureSystem esef-2023 --parameters "authority=DK" --validate --file report.zip
+```
+
+### Including ESEF Taxonomy Packages
+
+If you need to include ESEF taxonomy packages:
+
+```bash
+python arelleCmdLine.py --plugin validate/ESEF --package path/to/esef_taxonomy.zip --disclosureSystem esef-2023 --validate --file report.zip
+```
+
+### Output Formats
+
+Control the validation output format:
+
+```bash
+python arelleCmdLine.py --plugin validate/ESEF --disclosureSystem esef-2023 --validate --file report.zip --logFile results.xml
+```
+
+Available log file formats:
+
+- `xml`: Structured XML output for automated processing
+- `json`: JSON-formatted results
+- `text`: Plain text (default)
+
+## Reference Documentation
+
+- [ESMA ESEF Reporting Manual](https://www.esma.europa.eu/document/esef-reporting-manual) - Latest guidelines and best practices
+- [ESMA RTS on ESEF](https://eur-lex.europa.eu/legal-content/EN/TXT/?uri=CELEX:32019R0815) - Regulatory Technical Standards

{arelle_release-2.36.33 → arelle_release-2.36.35}/docs/source/index.md

@@ -6,6 +6,7 @@
 install
 command_line
 faq
+esef
 user_guides/user_guides
 plugins/plugins
 python_api/python_api