dpmxl.ast¶

Selected coordinates on one table axis.

parts holds single codes ("0010") and inclusive ranges (("0010", "0050")) as written, without the axis prefix. A range may repeat the axis letter before its upper bound: r0010-r0050 is ("0010", "0050"). The letter is dropped only when the lower bound does not start with it, so a code that does is read as written: rr1-rr10 is ("r1", "rr10"); write rr1-r10 for ("r1", "r10").

A parsed selector keeps its source positions; like node spans they take no part in equality, hashing or repr, and selectors built directly have none.

Attributes:

• wildcard (bool) –

  Whether the selector is * (every coordinate).

• parts (tuple[str | tuple[str, str], ...]) –

  Single codes and (low, high) ranges.

• span (Span) –

  Source span of the whole selector, such as r0010-0050 or (r0010, r0020); (0, 0) when built directly.

• spans (tuple[Span, ...]) –

  Source span of each part, in the order of parts; empty for a wildcard or a selector built directly.

Examples:

>>> from dpmxl import parse_selection
>>> rows = parse_selection("tT, (r0010, r0020-0050)").rows
>>> rows.parts, rows.span, rows.spans
(('0010', ('0020', '0050')), (4, 23), ((5, 10), (12, 22)))

wildcard: bool = False

parts: tuple[str | tuple[str, str], ...] = ()

span: Span = field(
    default=(0, 0), compare=False, repr=False, kw_only=True
)

spans: tuple[Span, ...] = field(
    default=(), compare=False, repr=False, kw_only=True
)

is_single: bool

text(prefix: str) -> str

Source, axis and option components of a {...} selection.

The source is one of table (tC_01.00), table_group (gG_01) or operation (o_v1234, another operation's result); the others are None.

Attributes:

• table (str | None) –

  Table code, such as C_01.00.

• rows (AxisSelector | None) –

  Row selector, or None when not written.

• columns (AxisSelector | None) –

  Column selector, or None.

• sheets (AxisSelector | None) –

  Sheet selector, or None.

• default (Literal_ | SetLiteral | _Missing) –

  The default: literal, or MISSING when not written.

• interval (bool | None) –

  The interval: option, or None when not written.

• table_group (str | None) –

  Table group code of a {g_...} selection.

• operation (str | None) –

  Operation code of an {o_...} reference.

• source_span (Span) –

  Source span of the table, table group or operation reference, such as tC_01.00; (0, 0) when there is none or the selection was built directly. Like the selectors' spans it takes no part in equality, hashing or repr, and merged_into keeps the span of the source it keeps.

table: str | None = None

rows: AxisSelector | None = None

columns: AxisSelector | None = None

sheets: AxisSelector | None = None

default: Literal_ | SetLiteral | _Missing = MISSING

interval: bool | None = None

table_group: str | None = None

operation: str | None = None

source_span: Span = field(
    default=(0, 0), compare=False, repr=False, kw_only=True
)

merged_into(context: SelectionSpec) -> SelectionSpec

>>> from dpmxl import parse_selection
>>> context = parse_selection("tC_01.00, c0010, interval: true")
>>> parse_selection("r0020").merged_into(context).text()
'{tC_01.00, r0020, c0010, interval: true}'

axis(name: AxisName) -> AxisSelector | None

text() -> str

>>> from dpmxl import parse_selection
>>> parse_selection("t_C_01.00 , r10-50, default: 0").text()
'{tC_01.00, r10-50, default: 0}'

Base class for expression nodes.

Every node has a public span: the half-open (start, end) character offsets of its source in the parsed expression, so expression[start:end] is the node's text. A parenthesized operand's span includes the parentheses; a clause's span runs from its operand to the closing ]. Spans take no part in equality or hashing. Nodes built directly default to (0, 0).

span: Span = field(
    default=(0, 0), compare=False, kw_only=True
)

Bases: Node

A constant: number, string, boolean, date, item or null.

Attributes:

• value (Decimal | str | bool | date | Item | None) –

  The constant: Decimal, str, bool, date (or datetime), Item or None.

• kind (Literal['number', 'string', 'boolean', 'date', 'item', 'null']) –

  number, string, boolean, date, item or null.

value: Decimal | str | bool | date | Item | None

kind: Literal[
    "number", "string", "boolean", "date", "item", "null"
]

An enumerated item literal such as [eba_qEC:qx01].

category is the namespace part without the eba_ prefix; it is None for a bare legacy element reference such as [ei86].

Attributes:

• category (str | None) –

  Category without eba_, such as qEC, or None.

• code (str) –

  Item code, such as qx01.

category: str | None

code: str

__post_init__() -> None

parse(text: str) -> Item

>>> Item.parse("eba_qEC:qx01")
Item(category='qEC', code='qx01')
>>> Item.parse("eba_qEC:qx01").matches(Item.parse("qx01"))
True

matches(other: Item) -> bool

__str__() -> str

Bases: Node

A {...} cell selection.

Attributes:

• spec (SelectionSpec) –

  The selection's components as written (without the with context; see references).

spec: SelectionSpec

Bases: Node

{v_TABLE}: true when the report declares the template.

Attributes:

• table (str) –

  The template or table code.

table: str

Bases: Node

{vName}: a report-level parameter such as ReportingLevel.

Attributes:

• name (str) –

  Parameter name without the v prefix.

name: str

Bases: Node

{p_Name, type[, default: value]}: a typed report parameter.

type is one of PARAMETER_TYPES in lower case.

Attributes:

• name (str) –

  Parameter name without the p_ prefix.

• type (str) –

  The declared type.

• default (Literal_ | SetLiteral | _Missing) –

  The default: value, or MISSING.

name: str

type: str

default: Literal_ | SetLiteral | _Missing = MISSING

Bases: Node

A bare identifier: a key component, period unit or parameter name.

Attributes:

• name (str) –

  The identifier, without backticks.

name: str

Bases: Node

A set literal {a, b, ...} or the empty set {}.

Attributes:

• items (tuple[Node, ...]) –

  The member expressions.

items: tuple[Node, ...]

Bases: Node

Prefix +, - or not.

Attributes:

• op (Literal['+', '-', 'not']) –

  The operator.

• operand (Node) –

  The operand.

op: Literal['+', '-', 'not']

operand: Node

Bases: Node

Arithmetic, comparison or boolean operator.

Attributes:

• op (str) –

  The operator as written canonically: + - * / & = != < <= > >=, and, or or xor (<> is read as !=).

• left (Node) –

  Left operand.

• right (Node) –

  Right operand.

op: str

left: Node

right: Node

Bases: Node

operand in set.

values is a SetLiteral for in {...}, otherwise any set-valued expression such as a set-* parameter or union(...).

Attributes:

• operand (Node) –

  The tested value.

• values (Node) –

  The set.

operand: Node

values: Node

Bases: Node

if c then a [else b] endif.

Attributes:

• condition (Node) –

  The condition.

• then (Node) –

  Value when the condition is true.

• otherwise (Node | None) –

  Value of the else branch, or None without one.

condition: Node

then: Node

otherwise: Node | None

Bases: Node

Function or aggregate call, optionally with group by keys.

Attributes:

• name (str) –

  Canonical function name (see canonical_function).

• args (tuple[Node, ...]) –

  Arguments in order.

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

  Key names of group by, or None without it.

name: str

args: tuple[Node, ...]

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

One end of an analytic window.

kind is unbounded preceding, preceding, current data point, following or unbounded following; offset counts data points, or for a range window units of the order key, or of period (A, S, Q, M, W, D) for a date key.

Attributes:

• kind (Literal['unbounded preceding', 'preceding', 'current data point', 'following', 'unbounded following']) –

  The bound kind, as above.

• offset (int) –

  Number of data points or order-key units.

• period (str | None) –

  Period code of a date offset, or None.

kind: Literal[
    "unbounded preceding",
    "preceding",
    "current data point",
    "following",
    "unbounded following",
]

offset: int = 0

period: str | None = None

data points|range between start and end.

Attributes:

• unit (Literal['data points', 'range']) –

  data points or range.

• start (WindowBound) –

  The lower bound.

• end (WindowBound) –

  The upper bound.

unit: Literal['data points', 'range']

start: WindowBound

end: WindowBound

Bases: Node

name(operand over (partition by … order by … window)).

name is rank or an aggregate's call name (sum, count, avg, max, min, median). order_by pairs each key with whether it sorts descending. The result keeps the operand's records.

Attributes:

• name (str) –

  rank or the aggregate's call name.

• operand (Node) –

  The aggregated expression.

• partition_by (tuple[str, ...]) –

  Partition key names.

• order_by (tuple[tuple[str, bool], ...]) –

  (key, descending) pairs.

• window (Window | None) –

  The window clause, or None when not written.

name: str

operand: Node

partition_by: tuple[str, ...] = ()

order_by: tuple[tuple[str, bool], ...] = ()

window: Window | None = None

Bases: Node

operand [where condition] filters records by key components.

Attributes:

• operand (Node) –

  The filtered expression.

• condition (Node) –

  Condition on key components.

operand: Node

condition: Node

Bases: Node

operand [get name] replaces values by a key component.

Attributes:

• operand (Node) –

  The expression.

• name (str) –

  Key component whose value becomes the record's value.

operand: Node

name: str

Bases: Node

operand [sub name = value] fixes and removes a key component.

Attributes:

• operand (Node) –

  The expression.

• name (str) –

  Key component to fix.

• value (Node) –

  The value it must have.

operand: Node

name: str

value: Node

Bases: Node

operand [rename a to b, ...] renames key components.

Attributes:

• operand (Node) –

  The expression.

• pairs (tuple[tuple[str, str], ...]) –

  (old, new) key names.

operand: Node

pairs: tuple[tuple[str, str], ...]

Bases: Node

with {context} [where condition]: body.

The optional condition filters every selection evaluated in the body.

Attributes:

• context (SelectionSpec) –

  Selection components inherited by every selection in the body.

• body (Node) –

  The expression.

• condition (Node | None) –

  The context's where condition, or None.

context: SelectionSpec

body: Node

condition: Node | None = None

Bases: Node

name := value: a temporary result later statements refer to.

Attributes:

• name (str) –

  The temporary's name.

• value (Node) –

  The assigned expression.

name: str

value: Node

Bases: Node

{target} <- value: a computed result for a cell or variable.

target is a Selection ({tT, r0010, c0010}) or a Parameter ({vX}, also written {v_X}).

Attributes:

• target (Node) –

  The assigned cell or variable.

• value (Node) –

  The computed expression.

target: Node

value: Node

Bases: Node

Statements separated by ;; the last one gives the result.

parse_program returns one; parse returns a single expression instead.

Attributes:

• statements (tuple[Node, ...]) –

  The statements in order.

statements: tuple[Node, ...]