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.

• reference_path (str | None) –

  Cross-reference target, or None if no target can be determined.

canonical_name: str

canonical_path: str

classname: str

is_classvar: bool

is_generator: bool

is_iterator: bool

is_tuple: bool

path: str

reference_path: str | None

__iter__() -> Iterator[str | Expr]

356
357
358

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]

389
390
391
392
393
394
395
396
397
398
399

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]

360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377

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

379
380
381
382
383
384
385
386
387

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.

• reference_path (str | None) –

  Cross-reference target of this attribute, or None if its root is unresolved.

• 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

reference_path: str | None

values: list[str | Expr]

__iter__() -> Iterator[str | Expr]

356
357
358

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

append(value: ExprName) -> None

493
494
495
496
497
498
499
500
501

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]

389
390
391
392
393
394
395
396
397
398
399

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]

476
477
478
479
480
481
482
483
484
485
486

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

488
489
490
491

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.

• reference_path (str | None) –

  Cross-reference target, or None if no target can be determined.

• 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

reference_path: str | None

right: str | Expr

__iter__() -> Iterator[str | Expr]

356
357
358

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]

389
390
391
392
393
394
395
396
397
398
399

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]

542
543
544
545
546
547
548
549
550

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

379
380
381
382
383
384
385
386
387

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.

• reference_path (str | None) –

  Cross-reference target, or None if no target can be determined.

• 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

reference_path: str | None

values: Sequence[str | Expr]

__iter__() -> Iterator[str | Expr]

356
357
358

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]

389
390
391
392
393
394
395
396
397
398
399

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]

562
563
564
565
566
567
568

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

379
380
381
382
383
384
385
386
387

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 the called function.

• 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.

• reference_path (str | None) –

  Cross-reference target of the called function, or None if unresolved.

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

reference_path: str | None

__iter__() -> Iterator[str | Expr]

356
357
358

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]

389
390
391
392
393
394
395
396
397
398
399

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]

590
591
592
593
594

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

379
380
381
382
383
384
385
386
387

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.

• reference_path (str | None) –

  Cross-reference target, or None if no target can be determined.

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

reference_path: str | None

__iter__() -> Iterator[str | Expr]

356
357
358

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]

389
390
391
392
393
394
395
396
397
398
399

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]

608
609
610
611
612
613

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

379
380
381
382
383
384
385
386
387

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.

• reference_path (str | None) –

  Cross-reference target, or None if no target can be determined.

• target (str | Expr) –

  Comprehension target (value added to the result).