Python API¶

Everything needed to generate one module's report.

Build one with load_template.

Attributes:

• release (str) –

  The DPM release, such as 4.3.

• module (str) –

  The module code, such as COREP_OF.

• entry_point (str | None) –

  The module's entry point, written to report.json.

• tables (tuple[TemplateTable, ...]) –

  The module's tables.

• rules (tuple[TemplateRule, ...]) –

  The rules the report should satisfy.

• reference_date (date | None) –

  The report's reference date; 2026-12-31 when None.

• decimals (Mapping[str, int]) –

  Reporting decimals by data type code; m 0, p 4, i 0 and r 2 unless given.

release: str

module: str

entry_point: str | None

tables: tuple[TemplateTable, ...]

rules: tuple[TemplateRule, ...]

reference_date: date | None = None

decimals: Mapping[str, int] = field(default_factory=dict)

table(code: str) -> TemplateTable | None

>>> template = load_template("minimal.json")
>>> template.table("t_01.00").code
'T_01.00'

A table, its filing indicator, open keys and cells.

Attributes:

• code (str) –

  The table code, such as C_07.00.a; it names the CSV file.

• filing_indicator (str) –

  The filing indicator the table is reported under.

• cells (tuple[TemplateCell, ...]) –

  The reportable cells.

• open_keys (tuple[OpenKey, ...]) –

  The open-axis key columns; empty for a closed table.

code: str

filing_indicator: str

cells: tuple[TemplateCell, ...]

open_keys: tuple[OpenKey, ...] = ()

An open-axis key column of a table.

Attributes:

• code (str) –

  The key's property code, as rules name it, such as qEBB.

• column (str) –

  The column of the key in the table's CSV file.

• items (tuple[str, ...] | None) –

  Allowed item qnames for an enumerated key; None for a typed key, which gets generated identifiers.

code: str

column: str

items: tuple[str, ...] | None = None

One reportable cell and the datapoint that carries its value.

Attributes:

• id (str) –

  An identifier of the cell, unique within the template.

• datapoint (str) –

  The datapoint code written in the datapoint column.

• data_type (str | None) –

  The DPM data type code, such as m or e; None or an unknown code is text.

• row (str | None) –

  The row code, such as 0010; None for a table without rows, * for every row of an open table.

• column (str | None) –

  The column code.

• sheet (str | None) –

  The sheet code, * for every sheet, or None.

• items (tuple[str, ...] | None) –

  Allowed item qnames of an enumerated cell.

id: str

datapoint: str

data_type: str | None

row: str | None = None

column: str | None = None

sheet: str | None = None

items: tuple[str, ...] | None = None

A validation rule with its precondition.

Attributes:

• code (str) –

  The rule code, such as v0001_m.

• expression (str) –

  The DPM-XL expression.

• precondition (str | None) –

  An optional DPM-XL precondition, such as {v_C_01.00}.

• source (str) –

  Who defined the rule, such as eba.

code: str

expression: str

precondition: str | None = None

source: str = 'eba'

Bases: ValueError

Raised when a template cannot be read or is not a valid template.

The message names the offending field by its path in the document, such as tables[2].cells[0].datapoint.

Examples:

>>> load_template({"format": "dpm-synth-template/1", "module": "M"})
Traceback (most recent call last):
...
dpmsynth.template.TemplateError: release: required

The generated report and how far the repair loop got.

passed, failed, not_evaluated and not_applicable together count every rule of the template once.

Attributes:

• report (Report) –

  The report, ready for dpmxbrl.write_xbrl_csv.

• data (SyntheticData) –

  The generated values, a dpm-xl data provider; pass it to write_scaled_package or evaluate rules on it.

• rules (int) –

  Rules in the template.

• passed (int) –

  Rules that pass on the final, rounded values.

• failed (list[str]) –

  Codes of the rules that still fail.

• not_evaluated (dict[str, str]) –

  Rules dpm-xl could not evaluate, such as time_shift without a previous report or a syntax error, with the reason, by rule code.

• not_applicable (list[str]) –

  Codes of the rules whose precondition is false or that select no cell of the template.

• rounds (int) –

  Evaluate-and-repair rounds run.

• repairs (int) –

  Failing records repaired over all rounds.

• history (list[int]) –

  Failing rules at the start of each round.

report: Report

data: SyntheticData

rules: int

passed: int

failed: list[str]

not_evaluated: dict[str, str]

not_applicable: list[str]

rounds: int

repairs: int

history: list[int] = field(default_factory=list)

Generated values for a template, readable as a dpm-xl data provider.

generate creates and repairs one; it is GenerationResult.data. It implements the dpmxl.DataProvider protocol, with the optional open_keys, so dpmxl.evaluate_rule(expression, data) evaluates any rule on the generated values.

Attributes:

• template –

  The template, with the reference date the report uses.

• values (dict[Slot, Value]) –

  Cell values by (datapoint, keys), where keys is a tuple of (key code, value) pairs of an open table's row, and () for a closed table. Numbers are dpmxl.Number, enumerated values dpmxl.Item.

• key_rows (dict[str, list[tuple[tuple[str, Any], ...]]]) –

  Key rows by table code; [()] for a closed table.

• entity –

  The LEI of the reporting entity.

• reporting_level –

  CON or IND, the suffix of the entity identifier and the ReportingLevel parameter.

• decimals (dict[str, int]) –

  Reporting decimals by data type code.

Create initial values and open-table key rows.

Parameters:

• template (ModuleTemplate) –

  Module template.

• rng (Random) –

  Random source.

• open_rows (int) –

  Key rows to generate per open table.

• entity (str, default: DEFAULT_ENTITY ) –

  LEI of the reporting entity.

• reporting_level (str, default: 'CON' ) –

  Suffix of the entity identifier.

template = template

rng = rng

entity = entity

reporting_level = reporting_level

decimals: dict[str, int] = {
    **_DEFAULT_DECIMALS,
    **template.decimals,
}

values: dict[Slot, Value] = {}

key_rows: dict[str, list[tuple[tuple[str, Any], ...]]] = {}

select(query: CellQuery) -> Sequence[DataPoint]

table_reported(table: str) -> bool | None

parameter(name: str) -> Value

open_keys(table: str) -> tuple[str, ...]