Skip to content

synt.expr.dict ¤

dict_ module-attribute ¤

1
dict_ = DictVerbatim

Alias DictVerbatim.

Notes

dict is a built-in type in Python, so it's renamed to dict_ with a suffix.

dict_comp module-attribute ¤

1
dict_comp = DictComprehension

Alias DictComprehension.

DictDisplay ¤

Bases: Expression

Literal dict expression.

References

Dictionary display.

Source code in synt/expr/dict.py 
24
25
26
27
28
29
30
31
32
class DictDisplay(expr.Expression, metaclass=ABCMeta):
    r"""Literal dict expression.

    References:
        [Dictionary display](https://docs.python.org/3/reference/expressions.html#dictionary-displays).
    """

    precedence = expr.ExprPrecedence.Atom
    expr_type = expr.ExprType.Dict

precedence class-attribute instance-attribute ¤

1
precedence = Atom

expr_type class-attribute instance-attribute ¤

1
expr_type = Dict

DictVerbatim ¤

Bases: DictDisplay

Verbatim dict expression.

Examples:

1
2
d = dict_(kv(litstr("a"), id_("b")))
assert d.into_code() == "{'a': b}"
Source code in synt/expr/dict.py 
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
class DictVerbatim(DictDisplay):
    r"""Verbatim dict expression.

    Examples:
        ```python
        d = dict_(kv(litstr("a"), id_("b")))
        assert d.into_code() == "{'a': b}"
        ```
    """

    items: list[KVPair]
    """Dict items."""

    def __init__(self, *items: KVPair):
        """Initialize a new verbatim dict expression.

        Args:
            items: dictionary items.
        """
        self.items = list(items)

    def into_code(self) -> str:
        item_text = ", ".join(x.into_code() for x in self.items)
        return f"{{{item_text}}}"

items instance-attribute ¤

1
items: list[KVPair] = list(items)

Dict items.

__init__ ¤

1
__init__(*items: KVPair)

Initialize a new verbatim dict expression.

Parameters:

Name Type Description Default
items KVPair

dictionary items.

 ()
Source code in synt/expr/dict.py 
48
49
50
51
52
53
54
def __init__(self, *items: KVPair):
    """Initialize a new verbatim dict expression.

    Args:
        items: dictionary items.
    """
    self.items = list(items)

into_code ¤

1
into_code() -> str
Source code in synt/expr/dict.py 
56
57
58
def into_code(self) -> str:
    item_text = ", ".join(x.into_code() for x in self.items)
    return f"{{{item_text}}}"

DictComprehension ¤

Bases: DictDisplay

Dict comprehension expression.

Note that you can also directly insert a comprehension expression into a normal dictionary, but that will become a generator comprehension and returns a pair of extra parenthesis.

Examples:

1
2
d = dict_comp(kv(id_("a"), litint(1)).for_(id_("a")).in_(id_("range").call(litint(5)))
assert d.into_code() == "{a: 1 for a in range(5)}"
References

comprehension.

Source code in synt/expr/dict.py 
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
class DictComprehension(DictDisplay):
    r"""Dict comprehension expression.

    Note that you can also directly insert a comprehension expression into a normal dictionary,
    but that will become a generator comprehension and returns a pair of extra parenthesis.

    Examples:
        ```python
        d = dict_comp(kv(id_("a"), litint(1)).for_(id_("a")).in_(id_("range").call(litint(5)))
        assert d.into_code() == "{a: 1 for a in range(5)}"
        ```

    References:
        [`comprehension`](https://docs.python.org/3/reference/
        expressions.html#grammar-tokens-python-grammar-comprehension).
    """

    comprehension: comp_expr.Comprehension
    """Internal comprehension expression."""

    def __init__(
        self,
        comprehension: comp_expr.Comprehension
        | comp_expr.ComprehensionBuilder
        | comp_expr.ComprehensionNodeBuilder,
    ):
        """Initialize a new dict comprehension expression.

        Args:
            comprehension: Internal comprehension expression.

        Raises:
            ExpressionTypeException: Invalid dict comprehension result type,
                typically not a [`KVPair`][synt.tokens.kv_pair.KVPair].
        """
        if isinstance(comprehension, comp_expr.Comprehension):
            comp = comprehension
        elif isinstance(comprehension, comp_expr.ComprehensionBuilder):
            comp = comprehension.build()
        elif isinstance(comprehension, comp_expr.ComprehensionNodeBuilder):
            comp = comprehension.build_comp()
        else:
            raise ValueError(
                "Expect expression of type `Comprehension`, found `Unknown`."
            )

        if comp.elt.expr_type != expr.ExprType.KeyValuePair:
            raise ValueError(
                "Expect expression of type `KeyValuePair`, found `Unknown`."
            )
        self.comprehension = comp

    def into_code(self) -> str:
        return f"{{{self.comprehension.into_code()}}}"

comprehension instance-attribute ¤

1
comprehension: Comprehension = comp

Internal comprehension expression.

__init__ ¤

1
2
3
4
5
6
7
__init__(
    comprehension: (
        Comprehension
        | ComprehensionBuilder
        | ComprehensionNodeBuilder
    ),
)

Initialize a new dict comprehension expression.

Parameters:

Name Type Description Default
comprehension Comprehension | ComprehensionBuilder | ComprehensionNodeBuilder

Internal comprehension expression.

 required

Raises:

Type Description
ExpressionTypeException

Invalid dict comprehension result type, typically not a KVPair.
Source code in synt/expr/dict.py 
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
def __init__(
    self,
    comprehension: comp_expr.Comprehension
    | comp_expr.ComprehensionBuilder
    | comp_expr.ComprehensionNodeBuilder,
):
    """Initialize a new dict comprehension expression.

    Args:
        comprehension: Internal comprehension expression.

    Raises:
        ExpressionTypeException: Invalid dict comprehension result type,
            typically not a [`KVPair`][synt.tokens.kv_pair.KVPair].
    """
    if isinstance(comprehension, comp_expr.Comprehension):
        comp = comprehension
    elif isinstance(comprehension, comp_expr.ComprehensionBuilder):
        comp = comprehension.build()
    elif isinstance(comprehension, comp_expr.ComprehensionNodeBuilder):
        comp = comprehension.build_comp()
    else:
        raise ValueError(
            "Expect expression of type `Comprehension`, found `Unknown`."
        )

    if comp.elt.expr_type != expr.ExprType.KeyValuePair:
        raise ValueError(
            "Expect expression of type `KeyValuePair`, found `Unknown`."
        )
    self.comprehension = comp

into_code ¤

1
into_code() -> str
Source code in synt/expr/dict.py 
121
122
def into_code(self) -> str:
    return f"{{{self.comprehension.into_code()}}}"