Skip to content

Datamodel

messageformat2.datamodel.Pattern = list[str | Expression | Markup]

messageformat2.datamodel.Declaration = InputDeclaration | LocalDeclaration | UnsupportedStatement

messageformat2.datamodel.Message = PatternMessage | SelectMessage

messageformat2.datamodel.Node

Base class for all nodes in the data model AST.

Source code in messageformat2/datamodel.py 
14
15
16
17
18
19
class Node:
    """Base class for all nodes in the data model AST."""

    @property
    def fields(self) -> tuple[str, ...]:
        return ()

fields property

messageformat2.datamodel.VariableRef dataclass

Bases: Node

Source code in messageformat2/datamodel.py 
37
38
39
40
41
42
@dataclass
class VariableRef(Node):
    name: str

    def __str__(self) -> str:
        return f"${self.name}"

name instance-attribute

messageformat2.datamodel.Literal dataclass

Bases: Node

Source code in messageformat2/datamodel.py 
45
46
47
48
49
50
51
@dataclass
class Literal(Node):
    value: str

    def __str__(self) -> str:
        value = self.value.replace("|", r"\|").replace("\\", r"\\")
        return f"|{value}|"

value instance-attribute

messageformat2.datamodel.Attribute dataclass

Bases: Node

Source code in messageformat2/datamodel.py 
54
55
56
57
58
59
60
61
62
63
64
65
66
@dataclass
class Attribute(Node):
    name: str
    value: Literal | VariableRef | None

    @property
    def fields(self) -> tuple[str, ...]:
        return ("value",)

    def __str__(self) -> str:
        if not self.value:
            return f"@{self.name}"
        return f"@{self.name}={self.value}"

name instance-attribute

value instance-attribute

fields property

messageformat2.datamodel.Option dataclass

Bases: Node

Source code in messageformat2/datamodel.py 
69
70
71
72
73
74
75
76
77
78
79
@dataclass
class Option(Node):
    name: str
    value: Literal | VariableRef

    @property
    def fields(self) -> tuple[str, ...]:
        return ("value",)

    def __str__(self) -> str:
        return f"{self.name}={self.value}"

name instance-attribute

value instance-attribute

fields property

messageformat2.datamodel.FunctionAnnotation dataclass

Bases: Node

Source code in messageformat2/datamodel.py 
82
83
84
85
86
87
88
89
90
91
92
93
94
95
@dataclass
class FunctionAnnotation(Node):
    name: str
    options: list[Option]

    @property
    def fields(self) -> tuple[str, ...]:
        return ("options",)

    def __str__(self) -> str:
        options = " ".join([str(opt) for opt in self.options])
        if options:
            options = f" {options}"
        return f":{self.name}{options}"

name instance-attribute

options instance-attribute

fields property

messageformat2.datamodel.UnsupportedAnnotation dataclass

Bases: Node

Source code in messageformat2/datamodel.py 
 98
 99
100
101
102
103
@dataclass
class UnsupportedAnnotation(Node):
    source: str

    def __str__(self) -> str:
        return self.source

source instance-attribute

messageformat2.datamodel.Expression

Bases: Node

Source code in messageformat2/datamodel.py 
106
107
class Expression(Node):
    pass

messageformat2.datamodel.VariableExpression dataclass

Bases: Expression

Source code in messageformat2/datamodel.py 
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
@dataclass
class VariableExpression(Expression):
    arg: VariableRef
    annotation: FunctionAnnotation | UnsupportedAnnotation | None
    attributes: list[Attribute]

    @property
    def fields(self) -> tuple[str, ...]:
        return ("arg", "annotation", "attributes")

    def __str__(self) -> str:
        annotation = f" {self.annotation}" if self.annotation else ""
        attributes = " ".join([str(attr) for attr in self.attributes])
        if attributes:
            attributes = f" {attributes}"
        return f"{{{self.arg}{annotation}{attributes}}}"

arg instance-attribute

annotation instance-attribute

attributes instance-attribute

fields property

messageformat2.datamodel.LiteralExpression dataclass

Bases: Expression

Source code in messageformat2/datamodel.py 
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
@dataclass
class LiteralExpression(Expression):
    arg: Literal
    annotation: FunctionAnnotation | UnsupportedAnnotation | None
    attributes: list[Attribute]

    @property
    def fields(self) -> tuple[str, ...]:
        return ("arg", "annotation", "attributes")

    def __str__(self) -> str:
        annotation = f" {self.annotation}" if self.annotation else ""
        attributes = " ".join([str(attr) for attr in self.attributes])
        if attributes:
            attributes = f" {attributes}"
        return f"{{{self.arg}{annotation}{attributes}}}"

arg instance-attribute

annotation instance-attribute

attributes instance-attribute

fields property

messageformat2.datamodel.FunctionExpression dataclass

Bases: Expression

Source code in messageformat2/datamodel.py 
146
147
148
149
150
151
152
153
154
155
156
157
158
159
@dataclass
class FunctionExpression(Expression):
    annotation: FunctionAnnotation
    attributes: list[Attribute]

    @property
    def fields(self) -> tuple[str, ...]:
        return ("annotation", "attributes")

    def __str__(self) -> str:
        attributes = " ".join([str(attr) for attr in self.attributes])
        if attributes:
            attributes = f" {attributes}"
        return f"{{{self.annotation}{attributes}}}"

annotation instance-attribute

attributes instance-attribute

fields property

messageformat2.datamodel.UnsupportedExpression dataclass

Bases: Expression

Source code in messageformat2/datamodel.py 
162
163
164
165
166
167
168
169
170
171
172
173
174
175
@dataclass
class UnsupportedExpression(Expression):
    annotation: UnsupportedAnnotation
    attributes: list[Attribute]

    @property
    def fields(self) -> tuple[str, ...]:
        return ("annotation", "attributes")

    def __str__(self) -> str:
        attributes = " ".join([str(attr) for attr in self.attributes])
        if attributes:
            attributes = f" {attributes}"
        return f"{{{self.annotation}{attributes}}}"

annotation instance-attribute

attributes instance-attribute

fields property

messageformat2.datamodel.Markup dataclass

Bases: Node

Source code in messageformat2/datamodel.py 
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
@dataclass
class Markup(Node):
    kind: TypingLiteral["open", "standalone", "close"]
    name: str
    options: list[Option]
    attributes: list[Attribute]

    @property
    def fields(self) -> tuple[str, ...]:
        return ("options", "attributes")

    def __str__(self) -> str:
        options = " ".join([str(opt) for opt in self.options])
        attributes = " ".join([str(attr) for attr in self.attributes])
        if options:
            options = f" {options}"
        if attributes:
            attributes = f" {attributes}"
        if self.kind == "open":
            return f"{{#{self.name}{options}{attributes}}}"
        if self.kind == "standalone":
            return f"{{#{self.name}{options}{attributes}/}}"
        return f"{{/{self.name}{options}{attributes}}}"

kind instance-attribute

name instance-attribute

options instance-attribute

attributes instance-attribute

fields property

messageformat2.datamodel.CatchallKey dataclass

Bases: Node

Source code in messageformat2/datamodel.py 
206
207
208
209
210
211
@dataclass
class CatchallKey(Node):
    value: str | None

    def __str__(self) -> str:
        return "*"

value instance-attribute

messageformat2.datamodel.Variant dataclass

Bases: Node

Source code in messageformat2/datamodel.py 
214
215
216
217
218
219
220
221
222
223
224
225
226
@dataclass
class Variant(Node):
    keys: list[Literal | CatchallKey]
    value: Pattern

    @property
    def fields(self) -> tuple[str, ...]:
        return ("keys", "value")

    def __str__(self) -> str:
        keys = " ".join([str(key) for key in self.keys])
        pattern = "".join([str(part) for part in self.value])
        return f"{keys} {{{{{pattern}}}}}"

keys instance-attribute

value instance-attribute

fields property

messageformat2.datamodel.InputDeclaration dataclass

Bases: Node

Source code in messageformat2/datamodel.py 
236
237
238
239
240
241
242
243
244
245
246
@dataclass
class InputDeclaration(Node):
    name: str
    value: VariableExpression

    @property
    def fields(self) -> tuple[str, ...]:
        return ("value",)

    def __str__(self) -> str:
        return f".input {self.value}"

name instance-attribute

value instance-attribute

fields property

messageformat2.datamodel.LocalDeclaration dataclass

Bases: Node

Source code in messageformat2/datamodel.py 
249
250
251
252
253
254
255
256
257
258
259
@dataclass
class LocalDeclaration(Node):
    name: str
    value: Expression

    @property
    def fields(self) -> tuple[str, ...]:
        return ("value",)

    def __str__(self) -> str:
        return f".local {self.name} = {self.value}"

name instance-attribute

value instance-attribute

fields property

messageformat2.datamodel.UnsupportedStatement dataclass

Bases: Node

Source code in messageformat2/datamodel.py 
262
263
264
265
266
267
268
269
270
271
272
273
274
275
@dataclass
class UnsupportedStatement(Node):
    keyword: str
    body: str | None
    expressions: list[Expression]

    @property
    def fields(self) -> tuple[str, ...]:
        return ("expressions",)

    def __str__(self) -> str:
        body = self.body or ""
        expressions = "\n".join([str(expr) for expr in self.expressions])
        return f".{self.keyword}{body}\n{expressions}"

keyword instance-attribute

body instance-attribute

expressions instance-attribute

fields property

messageformat2.datamodel.PatternMessage dataclass

Bases: Node

Source code in messageformat2/datamodel.py 
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
@dataclass
class PatternMessage(Node):
    declarations: list[Declaration]
    pattern: Pattern

    @property
    def fields(self) -> tuple[str, ...]:
        return ("declarations", "pattern")

    def __str__(self) -> str:
        declarations = "\n".join([str(decl) for decl in self.declarations])
        pattern = "".join([str(part) for part in self.pattern])
        if not declarations:
            return pattern
        return f"{declarations}\n{{{pattern}}}"

declarations instance-attribute

pattern instance-attribute

fields property

messageformat2.datamodel.SelectMessage dataclass

Bases: Node

Source code in messageformat2/datamodel.py 
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
@dataclass
class SelectMessage(Node):
    declarations: list[Declaration]
    selectors: list[Expression]
    variants: list[Variant]

    @property
    def fields(self) -> tuple[str, ...]:
        return ("declarations", "selectors", "variants")

    def __str__(self) -> str:
        declarations = "\n".join([str(decl) for decl in self.declarations])
        selectors = " ".join([str(sel) for sel in self.selectors])
        variants = "\n".join([str(var) for var in self.variants])
        if not declarations:
            return f".match {selectors}\n{variants}"
        return f"{declarations}\n.match {selectors}\n{variants}"

declarations instance-attribute

selectors instance-attribute

variants instance-attribute

fields property

messageformat2.datamodel.DataModelVisitor

Data model AST visitor.

Works the same way as the ast.NodeVisitor from the Python stdlib.

Examples:

>>> from messageformat2 import Message
>>> from messageformat2.datamodel import DataModelVisitor
>>> class VariableVisitor(DataModelVisitor):
...     def visit_VariableRef(self, node):
...         print(f"${node.name}")
...         self.generic_visit(node)
...
>>> message = Message("Hello, {$name}!")
>>> visitor = VariableVisitor()
>>> visitor.visit(message.datamodel)
$name
Source code in messageformat2/datamodel.py 
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
class DataModelVisitor:
    """Data model AST visitor.

    Works the same way as the ast.NodeVisitor from the Python stdlib.

    Examples:
        >>> from messageformat2 import Message
        >>> from messageformat2.datamodel import DataModelVisitor
        >>> class VariableVisitor(DataModelVisitor):
        ...     def visit_VariableRef(self, node):
        ...         print(f"${node.name}")
        ...         self.generic_visit(node)
        ...
        >>> message = Message("Hello, {$name}!")
        >>> visitor = VariableVisitor()
        >>> visitor.visit(message.datamodel)
        $name
    """

    def visit(self, node: Node) -> Any:
        method_name = f"visit_{type(node).__name__}"
        visitor = getattr(self, method_name, self.generic_visit)
        return visitor(node)

    def generic_visit(self, node: Node) -> Any:
        for name in node.fields:
            if (value := getattr(node, name)) is None:
                continue
            match value:
                case [*items]:
                    for item in items:
                        if isinstance(item, Node):
                            self.visit(item)
                case _:
                    self.visit(value)

visit(node)

Source code in messageformat2/datamodel.py 
339
340
341
342
def visit(self, node: Node) -> Any:
    method_name = f"visit_{type(node).__name__}"
    visitor = getattr(self, method_name, self.generic_visit)
    return visitor(node)

generic_visit(node)

Source code in messageformat2/datamodel.py 
344
345
346
347
348
349
350
351
352
353
354
def generic_visit(self, node: Node) -> Any:
    for name in node.fields:
        if (value := getattr(node, name)) is None:
            continue
        match value:
            case [*items]:
                for item in items:
                    if isinstance(item, Node):
                        self.visit(item)
            case _:
                self.visit(value)

messageformat2.datamodel.DataModelTransformer

Bases: DataModelVisitor

Data model AST transformer.

Works the same way as the ast.NodeTransformer from the Python stdlib.

Examples:

>>> from messageformat2 import Message
>>> from messageformat2.datamodel import Literal, DataModelTransformer
>>> class LiteralTransformer(DataModelTransformer):
...     def visit_Literal(self, node):
...         return Literal(node.value.upper())
...
>>> message = Message("{|foo|}")
>>> ast = LiteralTransformer().visit(message.datamodel)
>>> str(ast)
'{|FOO|}'
Source code in messageformat2/datamodel.py 
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
class DataModelTransformer(DataModelVisitor):
    """Data model AST transformer.

    Works the same way as the ast.NodeTransformer from the Python stdlib.

    Examples:
        >>> from messageformat2 import Message
        >>> from messageformat2.datamodel import Literal, DataModelTransformer
        >>> class LiteralTransformer(DataModelTransformer):
        ...     def visit_Literal(self, node):
        ...         return Literal(node.value.upper())
        ...
        >>> message = Message("{|foo|}")
        >>> ast = LiteralTransformer().visit(message.datamodel)
        >>> str(ast)
        '{|FOO|}'
    """

    def generic_visit[T: Node](self, node: T) -> T:
        for name in node.fields:
            old_value = getattr(node, name)
            if old_value is None:
                continue
            match old_value:
                case [*items]:
                    new_value = []
                    for item in items:
                        if not isinstance(item, Node):
                            new_value.append(item)
                            continue
                        value = self.visit(item)
                        if isinstance(value, list):
                            new_value.extend(value)
                        elif value is not None:
                            new_value.append(value)
                    setattr(node, name, new_value)
                case _:
                    new_value = self.visit(old_value)
                    if new_value is None:
                        delattr(node, name)
                    else:
                        setattr(node, name, new_value)
        return node

generic_visit(node)

Source code in messageformat2/datamodel.py 
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
def generic_visit[T: Node](self, node: T) -> T:
    for name in node.fields:
        old_value = getattr(node, name)
        if old_value is None:
            continue
        match old_value:
            case [*items]:
                new_value = []
                for item in items:
                    if not isinstance(item, Node):
                        new_value.append(item)
                        continue
                    value = self.visit(item)
                    if isinstance(value, list):
                        new_value.extend(value)
                    elif value is not None:
                        new_value.append(value)
                setattr(node, name, new_value)
            case _:
                new_value = self.visit(old_value)
                if new_value is None:
                    delattr(node, name)
                else:
                    setattr(node, name, new_value)
    return node

messageformat2.datamodel.dump(node)

Return a string representation of the node and its children.

Parameters:

Name Type Description Default
node Node

The node to dump.

 required

Examples:

>>> from messageformat2.message import Message
>>> msg = Message("Hello, {$name}!")
>>> dump(msg.datamodel)
'Hello, {$name}!'
Source code in messageformat2/datamodel.py 
22
23
24
25
26
27
28
29
30
31
32
33
34
def dump(node: Node) -> str:
    """Return a string representation of the node and its children.

    Args:
        node: The node to dump.

    Examples:
        >>> from messageformat2.message import Message
        >>> msg = Message("Hello, {$name}!")
        >>> dump(msg.datamodel)
        'Hello, {$name}!'
    """
    return str(node)