Expressions¤

Base class for expressions.

Methods:

• __iter__ –

  Iterate on the expression syntax and elements.

• as_dict –

  Return the expression as a dictionary.

• iterate –

  Iterate on the expression elements.

• modernize –

  Modernize the expression.

Attributes:

• canonical_name (str) –

  Name of the expressed name/attribute/parameter.

• canonical_path (str) –

  Path of the expressed name/attribute.

• classname (str) –

  The expression class name.

• is_classvar (bool) –

  Whether this attribute is annotated with ClassVar.

• is_generator (bool) –

  Whether this expression is a generator.

• is_iterator (bool) –

  Whether this expression is an iterator.

• is_tuple (bool) –

  Whether this expression is a tuple.

• path (str) –

  Path of the expressed name/attribute.

canonical_name: str

canonical_path: str

classname: str

is_classvar: bool

is_generator: bool

is_iterator: bool

is_tuple: bool

path: str

__iter__() -> Iterator[str | Expr]

193
194
195

def __iter__(self) -> Iterator[str | Expr]:
    """Iterate on the expression syntax and elements."""
    yield from self.iterate(flat=False)

as_dict(**kwargs: Any) -> dict[str, Any]

226
227
228
229
230
231
232
233
234
235
236

def as_dict(self, **kwargs: Any) -> dict[str, Any]:
    """Return the expression as a dictionary.

    Parameters:
        **kwargs: Configuration options (none available yet).


    Returns:
        A dictionary.
    """
    return _expr_as_dict(self, **kwargs)

iterate(*, flat: bool = True) -> Iterator[str | Expr]

197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214

def iterate(self, *, flat: bool = True) -> Iterator[str | Expr]:  # noqa: ARG002
    """Iterate on the expression elements.

    Parameters:
        flat: Expressions are trees.

            When flat is false, this method iterates only on the first layer of the tree.
            To iterate on all the subparts of the expression, you have to do so recursively.
            It allows to handle each subpart specifically (for example subscripts, attribute, etc.),
            without them getting rendered as strings.

            On the contrary, when flat is true, the whole tree is flattened as a sequence
            of strings and instances of [Names][griffe.ExprName].

    Yields:
        Strings and names when flat, strings and expressions otherwise.
    """
    yield from ()

modernize() -> Expr

216
217
218
219
220
221
222
223
224

def modernize(self) -> Expr:
    """Modernize the expression.

    For example, use PEP 604 type unions `|` instead of `typing.Union`.

    Returns:
        A modernized expression.
    """
    return self

Bases: Expr

              flowchart TD
              griffe.ExprAttribute[ExprAttribute]
              griffe._internal.expressions.Expr[Expr]

                              griffe._internal.expressions.Expr --> griffe.ExprAttribute
                


              click griffe.ExprAttribute href "" "griffe.ExprAttribute"
              click griffe._internal.expressions.Expr href "" "griffe._internal.expressions.Expr"
            

Attributes like a.b.

Methods:

• __iter__ –

  Iterate on the expression syntax and elements.

• append –

  Append a name to this attribute.

• as_dict –

  Return the expression as a dictionary.

• iterate –

  Iterate on the expression elements.

• modernize –

  Modernize the expression.

Attributes:

• canonical_name (str) –

  Name of the expressed name/attribute/parameter.

• canonical_path (str) –

  The canonical path of this attribute.

• classname (str) –

  The expression class name.

• first (str | Expr) –

  The first part of this attribute (on the left).

• is_classvar (bool) –

  Whether this attribute is annotated with ClassVar.

• is_generator (bool) –

  Whether this expression is a generator.

• is_iterator (bool) –

  Whether this expression is an iterator.

• is_tuple (bool) –

  Whether this expression is a tuple.

• last (ExprName) –

  The last part of this attribute (on the right).

• path (str) –

  The path of this attribute.

• values (list[str | Expr]) –

  The different parts of the dotted chain.

canonical_name: str

canonical_path: str

classname: str

first: str | Expr

is_classvar: bool

is_generator: bool

is_iterator: bool

is_tuple: bool

last: ExprName

path: str

values: list[str | Expr]

__iter__() -> Iterator[str | Expr]

193
194
195

def __iter__(self) -> Iterator[str | Expr]:
    """Iterate on the expression syntax and elements."""
    yield from self.iterate(flat=False)

append(value: ExprName) -> None

320
321
322
323
324
325
326
327
328

def append(self, value: ExprName) -> None:
    """Append a name to this attribute.

    Parameters:
        value: The expression name to append.
    """
    if value.parent is None:
        value.parent = self.last
    self.values.append(value)

as_dict(**kwargs: Any) -> dict[str, Any]

226
227
228
229
230
231
232
233
234
235
236

def as_dict(self, **kwargs: Any) -> dict[str, Any]:
    """Return the expression as a dictionary.

    Parameters:
        **kwargs: Configuration options (none available yet).


    Returns:
        A dictionary.
    """
    return _expr_as_dict(self, **kwargs)

iterate(*, flat: bool = True) -> Iterator[str | Expr]

303
304
305
306
307
308
309
310
311
312
313

def iterate(self, *, flat: bool = True) -> Iterator[str | Expr]:
    precedence = _get_precedence(self)
    first = self.values[0]
    if isinstance(first, str) and first.isdigit():
        # Integer literals need parentheses: `1.bit_length()` is a syntax error.
        yield f"({first})"
    else:
        yield from _yield(first, flat=flat, outer_precedence=precedence, is_left=True)
    for value in self.values[1:]:
        yield "."
        yield from _yield(value, flat=flat, outer_precedence=precedence)

modernize() -> ExprName | ExprAttribute

315
316
317
318

def modernize(self) -> ExprName | ExprAttribute:
    if modern := _modern_types.get(self.canonical_path):
        return ExprName(modern, parent=self.last.parent)
    return self

Bases: Expr

              flowchart TD
              griffe.ExprBinOp[ExprBinOp]
              griffe._internal.expressions.Expr[Expr]

                              griffe._internal.expressions.Expr --> griffe.ExprBinOp
                


              click griffe.ExprBinOp href "" "griffe.ExprBinOp"
              click griffe._internal.expressions.Expr href "" "griffe._internal.expressions.Expr"
            

Binary operations like a + b.

Methods:

• __iter__ –

  Iterate on the expression syntax and elements.

• as_dict –

  Return the expression as a dictionary.

• iterate –

  Iterate on the expression elements.

• modernize –

  Modernize the expression.

Attributes:

• canonical_name (str) –

  Name of the expressed name/attribute/parameter.

• canonical_path (str) –

  Path of the expressed name/attribute.

• classname (str) –

  The expression class name.

• is_classvar (bool) –

  Whether this attribute is annotated with ClassVar.

• is_generator (bool) –

  Whether this expression is a generator.

• is_iterator (bool) –

  Whether this expression is an iterator.

• is_tuple (bool) –

  Whether this expression is a tuple.

• left (str | Expr) –

  Left part.

• operator (str) –

  Binary operator.

• path (str) –

  Path of the expressed name/attribute.

• right (str | Expr) –

  Right part.

canonical_name: str

canonical_path: str

classname: str

is_classvar: bool

is_generator: bool

is_iterator: bool

is_tuple: bool

left: str | Expr

operator: str

path: str

right: str | Expr

__iter__() -> Iterator[str | Expr]

193
194
195

def __iter__(self) -> Iterator[str | Expr]:
    """Iterate on the expression syntax and elements."""
    yield from self.iterate(flat=False)

as_dict(**kwargs: Any) -> dict[str, Any]

226
227
228
229
230
231
232
233
234
235
236

def as_dict(self, **kwargs: Any) -> dict[str, Any]:
    """Return the expression as a dictionary.

    Parameters:
        **kwargs: Configuration options (none available yet).


    Returns:
        A dictionary.
    """
    return _expr_as_dict(self, **kwargs)

iterate(*, flat: bool = True) -> Iterator[str | Expr]

364
365
366
367
368
369
370
371
372

def iterate(self, *, flat: bool = True) -> Iterator[str | Expr]:
    precedence = _get_precedence(self)
    right_precedence = precedence
    if self.operator == "**" and isinstance(self.right, ExprUnaryOp):
        # Unary operators on the right have higher precedence, e.g. `a ** -b`.
        right_precedence = _OperatorPrecedence(precedence - 1)
    yield from _yield(self.left, flat=flat, outer_precedence=precedence, is_left=True)
    yield f" {self.operator} "
    yield from _yield(self.right, flat=flat, outer_precedence=right_precedence, is_left=False)

modernize() -> Expr

216
217
218
219
220
221
222
223
224

def modernize(self) -> Expr:
    """Modernize the expression.

    For example, use PEP 604 type unions `|` instead of `typing.Union`.

    Returns:
        A modernized expression.
    """
    return self

Bases: Expr

              flowchart TD
              griffe.ExprBoolOp[ExprBoolOp]
              griffe._internal.expressions.Expr[Expr]

                              griffe._internal.expressions.Expr --> griffe.ExprBoolOp
                


              click griffe.ExprBoolOp href "" "griffe.ExprBoolOp"
              click griffe._internal.expressions.Expr href "" "griffe._internal.expressions.Expr"
            

Boolean operations like a or b.

Methods:

• __iter__ –

  Iterate on the expression syntax and elements.

• as_dict –

  Return the expression as a dictionary.

• iterate –

  Iterate on the expression elements.

• modernize –

  Modernize the expression.

Attributes:

• canonical_name (str) –

  Name of the expressed name/attribute/parameter.

• canonical_path (str) –

  Path of the expressed name/attribute.

• classname (str) –

  The expression class name.

• is_classvar (bool) –

  Whether this attribute is annotated with ClassVar.

• is_generator (bool) –

  Whether this expression is a generator.

• is_iterator (bool) –

  Whether this expression is an iterator.

• is_tuple (bool) –

  Whether this expression is a tuple.

• operator (str) –

  Boolean operator.

• path (str) –

  Path of the expressed name/attribute.

• values (Sequence[str | Expr]) –

  Operands.

canonical_name: str

canonical_path: str

classname: str

is_classvar: bool

is_generator: bool

is_iterator: bool

is_tuple: bool

operator: str

path: str

values: Sequence[str | Expr]

__iter__() -> Iterator[str | Expr]

193
194
195

def __iter__(self) -> Iterator[str | Expr]:
    """Iterate on the expression syntax and elements."""
    yield from self.iterate(flat=False)

as_dict(**kwargs: Any) -> dict[str, Any]

226
227
228
229
230
231
232
233
234
235
236

def as_dict(self, **kwargs: Any) -> dict[str, Any]:
    """Return the expression as a dictionary.

    Parameters:
        **kwargs: Configuration options (none available yet).


    Returns:
        A dictionary.
    """
    return _expr_as_dict(self, **kwargs)

iterate(*, flat: bool = True) -> Iterator[str | Expr]

384
385
386
387
388
389
390

def iterate(self, *, flat: bool = True) -> Iterator[str | Expr]:
    precedence = _get_precedence(self)
    it = iter(self.values)
    yield from _yield(next(it), flat=flat, outer_precedence=precedence, is_left=True)
    for value in it:
        yield f" {self.operator} "
        yield from _yield(value, flat=flat, outer_precedence=precedence, is_left=False)

modernize() -> Expr

216
217
218
219
220
221
222
223
224

def modernize(self) -> Expr:
    """Modernize the expression.

    For example, use PEP 604 type unions `|` instead of `typing.Union`.

    Returns:
        A modernized expression.
    """
    return self

Bases: Expr

              flowchart TD
              griffe.ExprCall[ExprCall]
              griffe._internal.expressions.Expr[Expr]

                              griffe._internal.expressions.Expr --> griffe.ExprCall
                


              click griffe.ExprCall href "" "griffe.ExprCall"
              click griffe._internal.expressions.Expr href "" "griffe._internal.expressions.Expr"
            

Calls like f().

Methods:

• __iter__ –

  Iterate on the expression syntax and elements.

• as_dict –

  Return the expression as a dictionary.

• iterate –

  Iterate on the expression elements.

• modernize –

  Modernize the expression.

Attributes:

• arguments (Sequence[str | Expr]) –

  Passed arguments.

• canonical_name (str) –

  Name of the expressed name/attribute/parameter.

• canonical_path (str) –

  The canonical path of this subscript's left part.

• classname (str) –

  The expression class name.

• function (Expr) –

  Function called.

• is_classvar (bool) –

  Whether this attribute is annotated with ClassVar.

• is_generator (bool) –

  Whether this expression is a generator.

• is_iterator (bool) –

  Whether this expression is an iterator.

• is_tuple (bool) –

  Whether this expression is a tuple.

• path (str) –

  Path of the expressed name/attribute.

arguments: Sequence[str | Expr]

canonical_name: str

canonical_path: str

classname: str

function: Expr

is_classvar: bool

is_generator: bool

is_iterator: bool

is_tuple: bool

path: str

__iter__() -> Iterator[str | Expr]

193
194
195

def __iter__(self) -> Iterator[str | Expr]:
    """Iterate on the expression syntax and elements."""
    yield from self.iterate(flat=False)

as_dict(**kwargs: Any) -> dict[str, Any]

226
227
228
229
230
231
232
233
234
235
236

def as_dict(self, **kwargs: Any) -> dict[str, Any]:
    """Return the expression as a dictionary.

    Parameters:
        **kwargs: Configuration options (none available yet).


    Returns:
        A dictionary.
    """
    return _expr_as_dict(self, **kwargs)

iterate(*, flat: bool = True) -> Iterator[str | Expr]

407
408
409
410
411

def iterate(self, *, flat: bool = True) -> Iterator[str | Expr]:
    yield from _yield(self.function, flat=flat, outer_precedence=_get_precedence(self))
    yield "("
    yield from _join(self.arguments, ", ", flat=flat)
    yield ")"

modernize() -> Expr

216
217
218
219
220
221
222
223
224

def modernize(self) -> Expr:
    """Modernize the expression.

    For example, use PEP 604 type unions `|` instead of `typing.Union`.

    Returns:
        A modernized expression.
    """
    return self

Bases: Expr

              flowchart TD
              griffe.ExprCompare[ExprCompare]
              griffe._internal.expressions.Expr[Expr]

                              griffe._internal.expressions.Expr --> griffe.ExprCompare
                


              click griffe.ExprCompare href "" "griffe.ExprCompare"
              click griffe._internal.expressions.Expr href "" "griffe._internal.expressions.Expr"
            

Comparisons like a > b.

Methods:

• __iter__ –

  Iterate on the expression syntax and elements.

• as_dict –

  Return the expression as a dictionary.

• iterate –

  Iterate on the expression elements.

• modernize –

  Modernize the expression.

Attributes:

• canonical_name (str) –

  Name of the expressed name/attribute/parameter.

• canonical_path (str) –

  Path of the expressed name/attribute.

• classname (str) –

  The expression class name.

• comparators (Sequence[str | Expr]) –

  Things compared.

• is_classvar (bool) –

  Whether this attribute is annotated with ClassVar.

• is_generator (bool) –

  Whether this expression is a generator.

• is_iterator (bool) –

  Whether this expression is an iterator.

• is_tuple (bool) –

  Whether this expression is a tuple.

• left (str | Expr) –

  Left part.

• operators (Sequence[str]) –

  Comparison operators.

• path (str) –

  Path of the expressed name/attribute.

canonical_name: str

canonical_path: str

classname: str

comparators: Sequence[str | Expr]

is_classvar: bool

is_generator: bool

is_iterator: bool

is_tuple: bool

left: str | Expr

operators: Sequence[str]

path: str

__iter__() -> Iterator[str | Expr]

193
194
195

def __iter__(self) -> Iterator[str | Expr]:
    """Iterate on the expression syntax and elements."""
    yield from self.iterate(flat=False)

as_dict(**kwargs: Any) -> dict[str, Any]

226
227
228
229
230
231
232
233
234
235
236

def as_dict(self, **kwargs: Any) -> dict[str, Any]:
    """Return the expression as a dictionary.

    Parameters:
        **kwargs: Configuration options (none available yet).


    Returns:
        A dictionary.
    """
    return _expr_as_dict(self, **kwargs)

iterate(*, flat: bool = True) -> Iterator[str | Expr]

425
426
427
428
429
430

def iterate(self, *, flat: bool = True) -> Iterator[str | Expr]:
    precedence = _get_precedence(self)
    yield from _yield(self.left, flat=flat, outer_precedence=precedence, is_left=True)
    for op, comp in zip(self.operators, self.comparators, strict=False):
        yield f" {op} "
        yield from _yield(comp, flat=flat, outer_precedence=precedence)

modernize() -> Expr

216
217
218
219
220
221
222
223
224

def modernize(self) -> Expr:
    """Modernize the expression.

    For example, use PEP 604 type unions `|` instead of `typing.Union`.

    Returns:
        A modernized expression.
    """
    return self

Bases: Expr

              flowchart TD
              griffe.ExprComprehension[ExprComprehension]
              griffe._internal.expressions.Expr[Expr]

                              griffe._internal.expressions.Expr --> griffe.ExprComprehension
                


              click griffe.ExprComprehension href "" "griffe.ExprComprehension"
              click griffe._internal.expressions.Expr href "" "griffe._internal.expressions.Expr"
            

Comprehensions like a for b in c if d.

Methods:

• __iter__ –

  Iterate on the expression syntax and elements.

• as_dict –

  Return the expression as a dictionary.

• iterate –

  Iterate on the expression elements.

• modernize –

  Modernize the expression.

Attributes:

• canonical_name (str) –

  Name of the expressed name/attribute/parameter.

• canonical_path (str) –

  Path of the expressed name/attribute.

• classname (str) –

  The expression class name.

• conditions (Sequence[str | Expr]) –

  Conditions to include the target in the result.

• is_async (bool) –

  Async comprehension or not.

• is_classvar (bool) –

  Whether this attribute is annotated with ClassVar.

• is_generator (bool) –

  Whether this expression is a generator.

• is_iterator (bool) –

  Whether this expression is an iterator.

• is_tuple (bool) –

  Whether this expression is a tuple.

• iterable (str | Expr) –

  Value iterated on.

• path (str) –

  Path of the expressed name/attribute.

• target (str | Expr) –

  Comprehension target (value added to the result).

canonical_name: str

canonical_path: str

classname: str

conditions: Sequence[str | Expr]

is_async: bool = False