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]

169
170
171

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]

202
203
204
205
206
207
208
209
210
211
212

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]

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

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

192
193
194
195
196
197
198
199
200

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]

169
170
171

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

append(value: ExprName) -> None

275
276
277
278
279
280
281
282
283

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]

202
203
204
205
206
207
208
209
210
211
212

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]

263
264
265
266
267
268

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

270
271
272
273

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]

169
170
171

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]

202
203
204
205
206
207
208
209
210
211
212

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]

319
320
321
322
323
324
325
326
327

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

192
193
194
195
196
197
198
199
200

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]

169
170
171

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]

202
203
204
205
206
207
208
209
210
211
212

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]

339
340
341
342
343
344
345

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

192
193
194
195
196
197
198
199
200

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]

169
170
171

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]

202
203
204
205
206
207
208
209
210
211
212

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]

362
363
364
365
366

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

192
193
194
195
196
197
198
199
200

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]

169
170
171

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]

202
203
204
205
206
207
208
209
210
211
212

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]

380
381
382
383
384
385

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):
        yield f" {op} "
        yield from _yield(comp, flat=flat, outer_precedence=precedence)

modernize() -> Expr

192
193
194
195
196
197
198
199
200

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

is_tuple: bool

iterable: str | Expr

path: str

target: str | Expr