Skip to content

synt.stmt.loop ¤

for_ module-attribute ¤

1

Alias ForLoopBuilder.

while_ module-attribute ¤

1

Alias WhileLoopBuilder.

ForLoop ¤

Bases: Statement

The for loop.

Examples:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
for_loop = for_(id_("i")).in_(id_("range").expr().call(litint(5))).block(
               if_(id_("i").expr().gt(litint(2))).block(
                   BREAK
               ).else_(
                   CONTINUE
               )
           ).else_(
               PASS
           )
assert for_loop.into_code() == '''for i in range(5):
    if i > 2:
        break
    else:
        continue
else:
    pass'''
# for i in range(5):
#     if i > 2:
#         break
#     else:
#         continue
# else:
#     pass
References

For.

Source code in synt/stmt/loop.py 
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 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
class ForLoop(Statement):
    r"""The `for` loop.

    Examples:
        ```python
        for_loop = for_(id_("i")).in_(id_("range").expr().call(litint(5))).block(
                       if_(id_("i").expr().gt(litint(2))).block(
                           BREAK
                       ).else_(
                           CONTINUE
                       )
                   ).else_(
                       PASS
                   )
        assert for_loop.into_code() == '''for i in range(5):
            if i > 2:
                break
            else:
                continue
        else:
            pass'''
        # for i in range(5):
        #     if i > 2:
        #         break
        #     else:
        #         continue
        # else:
        #     pass
        ```

    References:
        [`For`](https://docs.python.org/3/library/ast.html#ast.For).
    """

    target: Expression
    """Target item for the iteration.

    Notes:
        Tuples will be automatically unwrapped.
    """
    iter: Expression
    """The expression to iterate over."""
    body: Block
    """The body of the loop."""
    orelse: Block | None
    """The body of the fallback block, aka `for ... else`."""

    def __init__(self, target: IntoExpression, it: IntoExpression, body: Block):
        """Initialize the loop.

        **DO NOT USE THIS IN YOUR CODE!**

        Args:
            target: Target item for the iteration.
            it: The expression to iterate over.
            body: The body of the loop.
        """
        self.target = target.into_expression()
        self.iter = it.into_expression()
        self.body = body
        self.orelse = None

    def else_(self, *statements: Statement) -> Self:
        """Set the fallback `else` block.

        Args:
            statements: The body of the fallback block.
        """
        self.orelse = Block(*statements)
        return self

    def indented(self, indent_width: int, indent_atom: str) -> str:
        indent = indent_atom * indent_width
        if self.orelse is not None:
            else_text = f"\n{indent}else:\n{self.orelse.indented(indent_width + 1, indent_atom)}"
        else:
            else_text = ""
        if is_tuple(self.target):
            target_text = self.target.into_code_implicit()
        else:
            target_text = self.target.into_code()
        return (
            f"{indent}for {target_text} in {self.iter.into_code()}:\n"
            f"{self.body.indented(indent_width + 1, indent_atom)}"
            f"{else_text}"
        )

target instance-attribute ¤

1
target: Expression = into_expression()

Target item for the iteration.

Notes

Tuples will be automatically unwrapped.

iter instance-attribute ¤

1
iter: Expression = into_expression()

The expression to iterate over.

body instance-attribute ¤

1
body: Block = body

The body of the loop.

orelse instance-attribute ¤

1
orelse: Block | None = None

The body of the fallback block, aka for ... else.

__init__ ¤

1
2
3
__init__(
    target: IntoExpression, it: IntoExpression, body: Block
)

Initialize the loop.

DO NOT USE THIS IN YOUR CODE!

Parameters:

Name Type Description Default
target IntoExpression

Target item for the iteration.

 required
it IntoExpression

The expression to iterate over.

 required
body Block

The body of the loop.

 required
Source code in synt/stmt/loop.py 
74
75
76
77
78
79
80
81
82
83
84
85
86
87
def __init__(self, target: IntoExpression, it: IntoExpression, body: Block):
    """Initialize the loop.

    **DO NOT USE THIS IN YOUR CODE!**

    Args:
        target: Target item for the iteration.
        it: The expression to iterate over.
        body: The body of the loop.
    """
    self.target = target.into_expression()
    self.iter = it.into_expression()
    self.body = body
    self.orelse = None

else_ ¤

1
else_(*statements: Statement) -> Self

Set the fallback else block.

Parameters:

Name Type Description Default
statements Statement

The body of the fallback block.

 ()
Source code in synt/stmt/loop.py 
89
90
91
92
93
94
95
96
def else_(self, *statements: Statement) -> Self:
    """Set the fallback `else` block.

    Args:
        statements: The body of the fallback block.
    """
    self.orelse = Block(*statements)
    return self

indented ¤

1
indented(indent_width: int, indent_atom: str) -> str
Source code in synt/stmt/loop.py 
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
def indented(self, indent_width: int, indent_atom: str) -> str:
    indent = indent_atom * indent_width
    if self.orelse is not None:
        else_text = f"\n{indent}else:\n{self.orelse.indented(indent_width + 1, indent_atom)}"
    else:
        else_text = ""
    if is_tuple(self.target):
        target_text = self.target.into_code_implicit()
    else:
        target_text = self.target.into_code()
    return (
        f"{indent}for {target_text} in {self.iter.into_code()}:\n"
        f"{self.body.indented(indent_width + 1, indent_atom)}"
        f"{else_text}"
    )

ForLoopBuilder ¤

Builder for for loop.

References

ForLoop.

Source code in synt/stmt/loop.py 
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
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 ForLoopBuilder:
    r"""Builder for `for` loop.

    References:
        [`ForLoop`][synt.stmt.loop.ForLoop].
    """

    target: Expression
    """Target item for the iteration."""
    iter: Expression | None
    """The expression to iterate over."""

    def __init__(self, target: IntoExpression):
        """Initialize a new `for` loop builder.

        Args:
            target: Target item for the iteration.
        """
        self.target = target.into_expression()
        self.iter = None

    def in_(self, it: IntoExpression) -> Self:
        """Set the iterator of the loop.

        Args:
            it: The expression to iterate over.
        """
        self.iter = it.into_expression()
        return self

    def block(self, *statements: Statement) -> ForLoop:
        """Set the block of the loop.

        Args:
            *statements: Statements to include in the loop body.

        Raises:
            ValueError: If the required fields (`[iter,]`) are not set.
        """
        err_fields = []
        if self.iter is None:
            err_fields.append("iter")

        if err_fields:
            raise ValueError(
                f"Missing required field(s): {', '.join(f'`{t}`' for t in err_fields)}"
            )

        return ForLoop(self.target, self.iter, Block(*statements))  # type:ignore[arg-type]

target instance-attribute ¤

1
target: Expression = into_expression()

Target item for the iteration.

iter instance-attribute ¤

1
iter: Expression | None = None

The expression to iterate over.

__init__ ¤

1
__init__(target: IntoExpression)

Initialize a new for loop builder.

Parameters:

Name Type Description Default
target IntoExpression

Target item for the iteration.

 required
Source code in synt/stmt/loop.py 
127
128
129
130
131
132
133
134
def __init__(self, target: IntoExpression):
    """Initialize a new `for` loop builder.

    Args:
        target: Target item for the iteration.
    """
    self.target = target.into_expression()
    self.iter = None

in_ ¤

1
in_(it: IntoExpression) -> Self

Set the iterator of the loop.

Parameters:

Name Type Description Default
it IntoExpression

The expression to iterate over.

 required
Source code in synt/stmt/loop.py 
136
137
138
139
140
141
142
143
def in_(self, it: IntoExpression) -> Self:
    """Set the iterator of the loop.

    Args:
        it: The expression to iterate over.
    """
    self.iter = it.into_expression()
    return self

block ¤

1
block(*statements: Statement) -> ForLoop

Set the block of the loop.

Parameters:

Name Type Description Default
*statements Statement

Statements to include in the loop body.

 ()

Raises:

Type Description
ValueError

If the required fields ([iter,]) are not set.
Source code in synt/stmt/loop.py 
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
def block(self, *statements: Statement) -> ForLoop:
    """Set the block of the loop.

    Args:
        *statements: Statements to include in the loop body.

    Raises:
        ValueError: If the required fields (`[iter,]`) are not set.
    """
    err_fields = []
    if self.iter is None:
        err_fields.append("iter")

    if err_fields:
        raise ValueError(
            f"Missing required field(s): {', '.join(f'`{t}`' for t in err_fields)}"
        )

    return ForLoop(self.target, self.iter, Block(*statements))  # type:ignore[arg-type]

WhileLoop ¤

The while loop.

References

While.

Source code in synt/stmt/loop.py 
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
class WhileLoop:
    r"""The `while` loop.

    References:
        [`While`](https://docs.python.org/3/library/ast.html#ast.While).
    """

    test: Expression
    """The condition."""
    orelse: Block | None
    """The body of the fallback block, aka `while ... else`."""

    def __init__(self, test: IntoExpression, body: Block):
        """Initialize a new `while` loop.

        **DO NOT USE THIS IN YOUR CODE!**

        Args:
            test: The condition.
            body: The body of the loop.
        """
        self.test = test.into_expression()
        self.orelse = None
        self.body = body

    def else_(self, *statements: Statement) -> Self:
        """Set the fallback `else` block.

        Args:
            statements: The body of the fallback block.
        """
        self.orelse = Block(*statements)
        return self

    def indented(self, indent_width: int, indent_atom: str) -> str:
        indent = indent_atom * indent_width
        if self.orelse is not None:
            else_text = f"\n{indent}else:\n{self.orelse.indented(indent_width + 1, indent_atom)}"
        else:
            else_text = ""
        return (
            f"{indent}while {self.test.into_code()}:\n"
            f"{self.body.indented(indent_width + 1, indent_atom)}"
            f"{else_text}"
        )

test instance-attribute ¤

1
test: Expression = into_expression()

The condition.

orelse instance-attribute ¤

1
orelse: Block | None = None

The body of the fallback block, aka while ... else.

body instance-attribute ¤

1
body = body

__init__ ¤

1
__init__(test: IntoExpression, body: Block)

Initialize a new while loop.

DO NOT USE THIS IN YOUR CODE!

Parameters:

Name Type Description Default
test IntoExpression

The condition.

 required
body Block

The body of the loop.

 required
Source code in synt/stmt/loop.py 
182
183
184
185
186
187
188
189
190
191
192
193
def __init__(self, test: IntoExpression, body: Block):
    """Initialize a new `while` loop.

    **DO NOT USE THIS IN YOUR CODE!**

    Args:
        test: The condition.
        body: The body of the loop.
    """
    self.test = test.into_expression()
    self.orelse = None
    self.body = body

else_ ¤

1
else_(*statements: Statement) -> Self

Set the fallback else block.

Parameters:

Name Type Description Default
statements Statement

The body of the fallback block.

 ()
Source code in synt/stmt/loop.py 
195
196
197
198
199
200
201
202
def else_(self, *statements: Statement) -> Self:
    """Set the fallback `else` block.

    Args:
        statements: The body of the fallback block.
    """
    self.orelse = Block(*statements)
    return self

indented ¤

1
indented(indent_width: int, indent_atom: str) -> str
Source code in synt/stmt/loop.py 
204
205
206
207
208
209
210
211
212
213
214
def indented(self, indent_width: int, indent_atom: str) -> str:
    indent = indent_atom * indent_width
    if self.orelse is not None:
        else_text = f"\n{indent}else:\n{self.orelse.indented(indent_width + 1, indent_atom)}"
    else:
        else_text = ""
    return (
        f"{indent}while {self.test.into_code()}:\n"
        f"{self.body.indented(indent_width + 1, indent_atom)}"
        f"{else_text}"
    )

WhileLoopBuilder ¤

Builder for while loop.

Examples:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
while_loop = while_(id_("i").expr().lt(litint(5))).block(
                 id_("i").assign(id_("i").expr() + litint(1))
             ).else_(
                 PASS
             )
assert while_loop.into_code() == '''while i < 5:
    i = i + 1
else:
    pass'''
# while i < 5:
#     i = i + 1
# else:
#     pass
References

WhileLoop.

Source code in synt/stmt/loop.py 
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
class WhileLoopBuilder:
    r"""Builder for `while` loop.

    Examples:
        ```python
        while_loop = while_(id_("i").expr().lt(litint(5))).block(
                         id_("i").assign(id_("i").expr() + litint(1))
                     ).else_(
                         PASS
                     )
        assert while_loop.into_code() == '''while i < 5:
            i = i + 1
        else:
            pass'''
        # while i < 5:
        #     i = i + 1
        # else:
        #     pass
        ```

    References:
        [`WhileLoop`][synt.stmt.loop.WhileLoop].
    """

    test: Expression
    """The condition."""

    def __init__(self, test: IntoExpression):
        """Initialize a new `while` loop builder.

        Args:
            test: The condition.
        """
        self.test = test.into_expression()

    def block(self, *statements: Statement) -> WhileLoop:
        """Set the block of the loop.

        Args:
            *statements: Statements to include in the loop body.
        """
        return WhileLoop(self.test, Block(*statements))

test instance-attribute ¤

1
test: Expression = into_expression()

The condition.

__init__ ¤

1
__init__(test: IntoExpression)

Initialize a new while loop builder.

Parameters:

Name Type Description Default
test IntoExpression

The condition.

 required
Source code in synt/stmt/loop.py 
244
245
246
247
248
249
250
def __init__(self, test: IntoExpression):
    """Initialize a new `while` loop builder.

    Args:
        test: The condition.
    """
    self.test = test.into_expression()

block ¤

1
block(*statements: Statement) -> WhileLoop

Set the block of the loop.

Parameters:

Name Type Description Default
*statements Statement

Statements to include in the loop body.

 ()
Source code in synt/stmt/loop.py 
252
253
254
255
256
257
258
def block(self, *statements: Statement) -> WhileLoop:
    """Set the block of the loop.

    Args:
        *statements: Statements to include in the loop body.
    """
    return WhileLoop(self.test, Block(*statements))