Skip to content

synt.expr.unary_op ¤

awaited module-attribute ¤

1
awaited = await_

Alias await_.

starred module-attribute ¤

1
starred = unpack

Alias unpack.

unpack_seq module-attribute ¤

1
unpack_seq = unpack

Alias unpack.

double_starred module-attribute ¤

1
double_starred = unpack_kv

Alias unpack_kv.

unpack_dict module-attribute ¤

1
unpack_dict = unpack_kv

Alias unpack_kv.

neg module-attribute ¤

1
neg = negative

Alias negative.

bool_not module-attribute ¤

1
bool_not = not_

Alias not_.

bit_not module-attribute ¤

1
bit_not = invert

Alias invert.

UnaryOpType ¤

Bases: IntEnum

Unary operator type.

References

expr.ExprPrecedence

Source code in synt/expr/unary_op.py 
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 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
123
124
125
126
127
128
class UnaryOpType(IntEnum):
    r"""Unary operator type.

    References:
        [`expr.ExprPrecedence`][synt.expr.expr.ExprPrecedence]
    """

    Await = 0
    """Await expression operator `await`.

    Notes:
        `await` is a Python hard keyword, but synt treats it as a unary operator.
    """

    Yield = 1
    """Yield expression operator `yield`.

    Notes:
        `yield` is a Python hard keyword, but synt treats it as a unary operator.
    """

    YieldFrom = 2
    """Yield-from expression operator `yield from`.

    Notes:
        `yield from` is a Python hard keyword group, but synt treats it as a single unary operator.
    """

    Starred = 3
    """Tuple/list extractor operator `*`."""

    DoubleStarred = 4
    """Dict/mapping extractor operator `**`."""

    Positive = 5
    """Positive operator `+`."""

    Neg = 6
    """Negative operator `-`."""

    BitNot = 7
    """Bitwise NOT operator `~`."""

    BoolNot = 8
    """Boolean NOT operator `not`."""

    def to_precedence(self) -> expr.ExprPrecedence:
        """Get the operator's backend expression's precedence."""
        match self:
            case (
                UnaryOpType.Starred
                | UnaryOpType.DoubleStarred
                | UnaryOpType.Yield
                | UnaryOpType.YieldFrom
            ):
                return expr.ExprPrecedence.Atom
            case UnaryOpType.Await:
                return expr.ExprPrecedence.Await
            case UnaryOpType.Positive | UnaryOpType.Neg | UnaryOpType.BitNot:
                return expr.ExprPrecedence.Unary
            case UnaryOpType.BoolNot:
                return expr.ExprPrecedence.BoolNot
            case _:
                raise ValueError(
                    f"Unexpected unary operator type: {self} [{self.value}]"
                )

    def into_code(self) -> str:
        """Converts the operator into a string representation.

        Raises:
            ValueError: If the operator is not recognized.
        """
        match self:
            case UnaryOpType.Starred:
                return "*"
            case UnaryOpType.DoubleStarred:
                return "**"
            case UnaryOpType.Yield:
                return "yield"
            case UnaryOpType.YieldFrom:
                return "yield from"
            case UnaryOpType.Await:
                return "await"
            case UnaryOpType.Positive:
                return "+"
            case UnaryOpType.Neg:
                return "-"
            case UnaryOpType.BitNot:
                return "~"
            case UnaryOpType.BoolNot:
                return "not"

Await class-attribute instance-attribute ¤

1
Await = 0

Await expression operator await.

Notes

await is a Python hard keyword, but synt treats it as a unary operator.

Yield class-attribute instance-attribute ¤

1
Yield = 1

Yield expression operator yield.

Notes

yield is a Python hard keyword, but synt treats it as a unary operator.

YieldFrom class-attribute instance-attribute ¤

1
YieldFrom = 2

Yield-from expression operator yield from.

Notes

yield from is a Python hard keyword group, but synt treats it as a single unary operator.

Starred class-attribute instance-attribute ¤

1
Starred = 3

Tuple/list extractor operator *.

DoubleStarred class-attribute instance-attribute ¤

1
DoubleStarred = 4

Dict/mapping extractor operator **.

Positive class-attribute instance-attribute ¤

1
Positive = 5

Positive operator +.

Neg class-attribute instance-attribute ¤

1
Neg = 6

Negative operator -.

BitNot class-attribute instance-attribute ¤

1
BitNot = 7

Bitwise NOT operator ~.

BoolNot class-attribute instance-attribute ¤

1
BoolNot = 8

Boolean NOT operator not.

to_precedence ¤

1
to_precedence() -> ExprPrecedence

Get the operator's backend expression's precedence.

Source code in synt/expr/unary_op.py 
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
def to_precedence(self) -> expr.ExprPrecedence:
    """Get the operator's backend expression's precedence."""
    match self:
        case (
            UnaryOpType.Starred
            | UnaryOpType.DoubleStarred
            | UnaryOpType.Yield
            | UnaryOpType.YieldFrom
        ):
            return expr.ExprPrecedence.Atom
        case UnaryOpType.Await:
            return expr.ExprPrecedence.Await
        case UnaryOpType.Positive | UnaryOpType.Neg | UnaryOpType.BitNot:
            return expr.ExprPrecedence.Unary
        case UnaryOpType.BoolNot:
            return expr.ExprPrecedence.BoolNot
        case _:
            raise ValueError(
                f"Unexpected unary operator type: {self} [{self.value}]"
            )

into_code ¤

1
into_code() -> str

Converts the operator into a string representation.

Raises:

Type Description
ValueError

If the operator is not recognized.
Source code in synt/expr/unary_op.py 
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
def into_code(self) -> str:
    """Converts the operator into a string representation.

    Raises:
        ValueError: If the operator is not recognized.
    """
    match self:
        case UnaryOpType.Starred:
            return "*"
        case UnaryOpType.DoubleStarred:
            return "**"
        case UnaryOpType.Yield:
            return "yield"
        case UnaryOpType.YieldFrom:
            return "yield from"
        case UnaryOpType.Await:
            return "await"
        case UnaryOpType.Positive:
            return "+"
        case UnaryOpType.Neg:
            return "-"
        case UnaryOpType.BitNot:
            return "~"
        case UnaryOpType.BoolNot:
            return "not"

UnaryOp ¤

Bases: Expression

Unary operation.

Source code in synt/expr/unary_op.py 
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
class UnaryOp(expr.Expression):
    r"""Unary operation."""

    expression: expr.Expression
    """Internal expression."""
    op_type: UnaryOpType
    """Operator type."""
    expr_type = expr.ExprType.UnaryOp

    def __init__(self, op: UnaryOpType, e: expr.IntoExpression):
        """Initialize a unary operation.

        Args:
            op: Unary operator type.
            e: Internal expression.
        """
        self.expression = e.into_expression()
        self.op_type = op

        if self.expression.precedence > self.precedence:
            self.expression = self.expression.wrapped()

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

    @property
    def precedence(self) -> ExprPrecedence:
        """expr.Expression precedence.

        References:
            [Unary.to_precedence][synt.expr.unary_op.UnaryOpType.to_precedence].
        """
        return self.op_type.to_precedence()

expr_type class-attribute instance-attribute ¤

1
expr_type = UnaryOp

expression instance-attribute ¤

1
expression: Expression = into_expression()

Internal expression.

op_type instance-attribute ¤

1
op_type: UnaryOpType = op

Operator type.

precedence property ¤

1
precedence: ExprPrecedence

expr.Expression precedence.

References

Unary.to_precedence.

__init__ ¤

1
__init__(op: UnaryOpType, e: IntoExpression)

Initialize a unary operation.

Parameters:

Name Type Description Default
op UnaryOpType

Unary operator type.

 required
e IntoExpression

Internal expression.

 required
Source code in synt/expr/unary_op.py 
140
141
142
143
144
145
146
147
148
149
150
151
def __init__(self, op: UnaryOpType, e: expr.IntoExpression):
    """Initialize a unary operation.

    Args:
        op: Unary operator type.
        e: Internal expression.
    """
    self.expression = e.into_expression()
    self.op_type = op

    if self.expression.precedence > self.precedence:
        self.expression = self.expression.wrapped()

into_code ¤

1
into_code() -> str
Source code in synt/expr/unary_op.py 
153
154
def into_code(self) -> str:
    return f"{self.op_type.into_code()} {self.expression.into_code()}"

await_ ¤

1
await_(e: IntoExpression) -> UnaryOp

Create an await expression.

Examples:

1
2
await_expr = await_(litint(10))
assert await_expr.into_code() == "await 10"
Source code in synt/expr/unary_op.py 
166
167
168
169
170
171
172
173
174
175
def await_(e: expr.IntoExpression) -> UnaryOp:
    r"""Create an `await` expression.

    Examples:
        ```python
        await_expr = await_(litint(10))
        assert await_expr.into_code() == "await 10"
        ```
    """
    return UnaryOp(UnaryOpType.Await, e)

unpack ¤

1
unpack(e: IntoExpression) -> UnaryOp

Sequence unpacking operation.

Examples:

1
2
unpacked_expr = unpack(list_(litint(1), litint(2), litint(3)))
assert unpacked_expr.into_code() == "* [1, 2, 3]"
Source code in synt/expr/unary_op.py 
182
183
184
185
186
187
188
189
190
191
def unpack(e: expr.IntoExpression) -> UnaryOp:
    r"""Sequence unpacking operation.

    Examples:
        ```python
        unpacked_expr = unpack(list_(litint(1), litint(2), litint(3)))
        assert unpacked_expr.into_code() == "* [1, 2, 3]"
        ```
    """
    return UnaryOp(UnaryOpType.Starred, e)

unpack_kv ¤

1
unpack_kv(e: IntoExpression) -> UnaryOp

K-V pair unpacking operation.

Examples:

1
2
unpacked_expr = unpack_kv(dict_(kv(litint(1), litstr('a'))))
assert unpacked_expr.into_code() == "** {1: 'a'}"
Source code in synt/expr/unary_op.py 
198
199
200
201
202
203
204
205
206
207
def unpack_kv(e: expr.IntoExpression) -> UnaryOp:
    r"""K-V pair unpacking operation.

    Examples:
        ```python
        unpacked_expr = unpack_kv(dict_(kv(litint(1), litstr('a'))))
        assert unpacked_expr.into_code() == "** {1: 'a'}"
        ```
    """
    return UnaryOp(UnaryOpType.DoubleStarred, e)

positive ¤

1
positive(e: IntoExpression) -> UnaryOp

Positive operation.

Examples:

1
2
positive_expr = positive(litint(10))
assert positive_expr.into_code() == "+ 10"
Source code in synt/expr/unary_op.py 
214
215
216
217
218
219
220
221
222
223
def positive(e: expr.IntoExpression) -> UnaryOp:
    r"""Positive operation.

    Examples:
        ```python
        positive_expr = positive(litint(10))
        assert positive_expr.into_code() == "+ 10"
        ```
    """
    return UnaryOp(UnaryOpType.Positive, e)

negative ¤

1
negative(e: IntoExpression) -> UnaryOp

Negative operation.

Examples:

1
2
positive_expr = negative(litint(10))
assert positive_expr.into_code() == "- 10"
Source code in synt/expr/unary_op.py 
226
227
228
229
230
231
232
233
234
235
def negative(e: expr.IntoExpression) -> UnaryOp:
    r"""Negative operation.

    Examples:
        ```python
        positive_expr = negative(litint(10))
        assert positive_expr.into_code() == "- 10"
        ```
    """
    return UnaryOp(UnaryOpType.Positive, e)

not_ ¤

1
not_(e: IntoExpression) -> UnaryOp

Boolean NOT operation.

Examples:

1
2
not_expr = not_(id_("foo"))
assert not_expr.into_code() == "not foo"
Source code in synt/expr/unary_op.py 
242
243
244
245
246
247
248
249
250
251
def not_(e: expr.IntoExpression) -> UnaryOp:
    r"""Boolean NOT operation.

    Examples:
        ```python
        not_expr = not_(id_("foo"))
        assert not_expr.into_code() == "not foo"
        ```
    """
    return UnaryOp(UnaryOpType.BoolNot, e)

invert ¤

1
invert(e: IntoExpression) -> UnaryOp

Bitwise NOT operation.

Examples:

1
2
not_expr = invert(id_("foo"))
assert not_expr.into_code() == "~ foo"
Source code in synt/expr/unary_op.py 
258
259
260
261
262
263
264
265
266
267
def invert(e: expr.IntoExpression) -> UnaryOp:
    r"""Bitwise NOT operation.

    Examples:
        ```python
        not_expr = invert(id_("foo"))
        assert not_expr.into_code() == "~ foo"
        ```
    """
    return UnaryOp(UnaryOpType.BitNot, e)

yield_ ¤

1
yield_(e: Expression) -> UnaryOp

Yield operation.

Examples:

1
2
yield_expr = yield_(litint(10))
assert yield_expr.into_code() == "yield 10"
Source code in synt/expr/unary_op.py 
274
275
276
277
278
279
280
281
282
283
def yield_(e: expr.Expression) -> UnaryOp:
    r"""Yield operation.

    Examples:
        ```python
        yield_expr = yield_(litint(10))
        assert yield_expr.into_code() == "yield 10"
        ```
    """
    return UnaryOp(UnaryOpType.Yield, e)

yield_from ¤

1
yield_from(e: Expression) -> UnaryOp

Yield from operation.

Examples:

1
2
yield_expr = yield_from(list_(litint(10), litint(42)))
assert yield_expr.into_code() == "yield from [10, 42]"
Source code in synt/expr/unary_op.py 
286
287
288
289
290
291
292
293
294
295
def yield_from(e: expr.Expression) -> UnaryOp:
    r"""Yield from operation.

    Examples:
        ```python
        yield_expr = yield_from(list_(litint(10), litint(42)))
        assert yield_expr.into_code() == "yield from [10, 42]"
        ```
    """
    return UnaryOp(UnaryOpType.YieldFrom, e)