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]

168
169
170

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]

201
202
203
204
205
206
207
208
209
210
211

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]

172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189

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

191
192
193
194
195
196
197
198
199

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]

168
169
170

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

append(value: ExprName) -> None

290
291
292
293
294
295
296
297
298

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]

201
202
203
204
205
206
207
208
209
210
211

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]

278
279
280
281
282
283

def iterate(self, *, flat: bool = True) -> Iterator[str | Expr]:
    precedence = _get_precedence(self)
    yield from _yield(self.values[0], 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

285
286
287
288

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]

168
169
170

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]

201
202
203
204
205
206
207
208
209
210
211

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]

334
335
336
337
338
339
340
341
342

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

191
192
193
194
195
196
197
198
199

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]

168
169
170

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]

201
202
203
204
205
206
207
208
209
210
211

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]

354
355
356
357
358
359
360

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

191
192
193
194
195
196
197
198
199

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]

168
169
170

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]

201
202
203
204
205
206
207
208
209
210
211

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]

377
378
379
380
381

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

191
192
193
194
195
196
197
198
199

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]

168
169
170

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]

201
202
203
204
205
206
207
208
209
210
211

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]

395
396
397
398
399
400

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

191
192
193
194
195
196
197
198
199

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

is_classvar: bool

is_generator: bool

is_iterator: bool