Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://mkdocstrings.github.io/griffe/reference/api/expressions/ below:

Expressions - Griffe

Build an expression from an AST.

Parameters:

• node ¤ (AST | None) –

  The annotation node.

• parent ¤ (Module | Class) –

  The parent used to resolve the name.

• member ¤ (str | None, default: None ) –

  The member name (for resolution in its scope).

• parse_strings ¤ (bool | None, default: None ) –

  Whether to try and parse strings as type annotations.

Returns:

• Expr | None –

  A string or resovable name or expression.

Safely (no exception) build a resolvable annotation.

Parameters:

• node ¤ (AST | None) –

  The annotation node.

• parent ¤ (Module | Class) –

  The parent used to resolve the name.

• member ¤ (str | None, default: None ) –

  The member name (for resolution in its scope).

• parse_strings ¤ (bool | None, default: None ) –

  Whether to try and parse strings as type annotations.

• log_level ¤ (LogLevel | None, default: error ) –

  Log level to use to log a message. None to disable logging.

• msg_format ¤ (str, default: '{path}:{lineno}: Failed to get expression from {node_class}: {error}' ) –

  A format string for the log message. Available placeholders: path, lineno, node, error.

Returns:

• Expr | None –

  A string or resovable name or expression.

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.

Name of the expressed name/attribute/parameter.

Path of the expressed name/attribute.

The expression class name.

Whether this attribute is annotated with ClassVar.

Whether this expression is a generator.

Whether this expression is an iterator.

Whether this expression is a tuple.

Path of the expressed name/attribute.

Iterate on the expression syntax and elements.

Return the expression as a dictionary.

Parameters:

• **kwargs ¤ (Any, default: {} ) –

  Configuration options (none available yet).

Returns:

• dict[str, Any] –

  A dictionary.

Iterate on the expression elements.

Parameters:

• flat ¤ (bool, default: True ) –

  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.

Yields:

• str | Expr –

  Strings and names when flat, strings and expressions otherwise.

Modernize the expression.

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

Returns:

• Expr –

  A modernized expression.

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.

Name of the expressed name/attribute/parameter.

The canonical path of this attribute.

The expression class name.

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

Whether this attribute is annotated with ClassVar.

Whether this expression is a generator.

Whether this expression is an iterator.

Whether this expression is a tuple.

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

The path of this attribute.

The different parts of the dotted chain.

Iterate on the expression syntax and elements.

Append a name to this attribute.

Parameters:

• value ¤ (ExprName) –

  The expression name to append.

Return the expression as a dictionary.

Parameters:

• **kwargs ¤ (Any, default: {} ) –

  Configuration options (none available yet).

Returns:

• dict[str, Any] –

  A dictionary.

Iterate on the expression elements.

Parameters:

• flat ¤ (bool, default: True ) –

  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.

Yields:

• str | Expr –

  Strings and names when flat, strings and expressions otherwise.

Modernize the expression.

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

Returns:

• Expr –

  A modernized expression.

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.

Name of the expressed name/attribute/parameter.

Path of the expressed name/attribute.

The expression class name.

Whether this attribute is annotated with ClassVar.

Whether this expression is a generator.

Whether this expression is an iterator.

Whether this expression is a tuple.

Left part.

Binary operator.

Path of the expressed name/attribute.

Right part.

Iterate on the expression syntax and elements.

Return the expression as a dictionary.

Parameters:

• **kwargs ¤ (Any, default: {} ) –

  Configuration options (none available yet).

Returns:

• dict[str, Any] –

  A dictionary.

Iterate on the expression elements.

Parameters:

• flat ¤ (bool, default: True ) –

  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.

Yields:

• str | Expr –

  Strings and names when flat, strings and expressions otherwise.

Modernize the expression.

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

Returns:

• Expr –

  A modernized expression.

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.

Name of the expressed name/attribute/parameter.

Path of the expressed name/attribute.

The expression class name.

Whether this attribute is annotated with ClassVar.

Whether this expression is a generator.

Whether this expression is an iterator.

Whether this expression is a tuple.

Boolean operator.

Path of the expressed name/attribute.

Operands.

Iterate on the expression syntax and elements.

Return the expression as a dictionary.

Parameters:

• **kwargs ¤ (Any, default: {} ) –

  Configuration options (none available yet).

Returns:

• dict[str, Any] –

  A dictionary.

Iterate on the expression elements.

Parameters:

• flat ¤ (bool, default: True ) –

  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.

Yields:

• str | Expr –

  Strings and names when flat, strings and expressions otherwise.

Modernize the expression.

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

Returns:

• Expr –

  A modernized expression.

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.

Passed arguments.

Name of the expressed name/attribute/parameter.

The canonical path of this subscript's left part.

The expression class name.

Function called.

Whether this attribute is annotated with ClassVar.

Whether this expression is a generator.

Whether this expression is an iterator.

Whether this expression is a tuple.

Path of the expressed name/attribute.

Iterate on the expression syntax and elements.

Return the expression as a dictionary.

Parameters:

• **kwargs ¤ (Any, default: {} ) –

  Configuration options (none available yet).

Returns:

• dict[str, Any] –

  A dictionary.

Iterate on the expression elements.

Parameters:

• flat ¤ (bool, default: True ) –

  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.

Yields:

• str | Expr –

  Strings and names when flat, strings and expressions otherwise.

Modernize the expression.

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

Returns:

• Expr –

  A modernized expression.

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.

Name of the expressed name/attribute/parameter.

Path of the expressed name/attribute.

The expression class name.

Things compared.

Whether this attribute is annotated with ClassVar.

Whether this expression is a generator.

Whether this expression is an iterator.

Whether this expression is a tuple.

Left part.

Comparison operators.

Path of the expressed name/attribute.

Iterate on the expression syntax and elements.

Return the expression as a dictionary.

Parameters:

• **kwargs ¤ (Any, default: {} ) –

  Configuration options (none available yet).

Returns:

• dict[str, Any] –

  A dictionary.

Iterate on the expression elements.

Parameters:

• flat ¤ (bool, default: True ) –

  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.

Yields:

• str | Expr –

  Strings and names when flat, strings and expressions otherwise.

Modernize the expression.

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

Returns:

• Expr –

  A modernized expression.

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

Name of the expressed name/attribute/parameter.

Path of the expressed name/attribute.

The expression class name.

Conditions to include the target in the result.

Async comprehension or not.

Whether this attribute is annotated with ClassVar.

Whether this expression is a generator.

Whether this expression is an iterator.

Whether this expression is a tuple.

Value iterated on.

Path of the expressed name/attribute.

Comprehension target (value added to the result).

Iterate on the expression syntax and elements.

Return the expression as a dictionary.

Parameters:

• **kwargs ¤ (Any, default: {} ) –

  Configuration options (none available yet).

Returns:

• dict[str, Any] –

  A dictionary.

Iterate on the expression elements.

Parameters:

• flat ¤ (bool, default: True ) –

  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.

Yields:

• str | Expr –

  Strings and names when flat, strings and expressions otherwise.

Modernize the expression.

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

Returns:

• Expr –

  A modernized expression.

Bases: Expr

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

                              griffe._internal.expressions.Expr --> griffe.ExprConstant
                


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

Constants like "a" or 1.

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.

• value (str) –

  Constant value.

Name of the expressed name/attribute/parameter.

Path of the expressed name/attribute.

The expression class name.

Whether this attribute is annotated with ClassVar.

Whether this expression is a generator.

Whether this expression is an iterator.

Whether this expression is a tuple.

Path of the expressed name/attribute.

Constant value.

Iterate on the expression syntax and elements.

Return the expression as a dictionary.

Parameters:

• **kwargs ¤ (Any, default: {} ) –

  Configuration options (none available yet).

Returns:

• dict[str, Any] –

  A dictionary.

Iterate on the expression elements.

Parameters:

• flat ¤ (bool, default: True ) –

  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.

Yields:

• str | Expr –

  Strings and names when flat, strings and expressions otherwise.

Modernize the expression.

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

Returns:

• Expr –

  A modernized expression.

Bases: Expr

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

                              griffe._internal.expressions.Expr --> griffe.ExprDict
                


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

Dictionaries like {"a": 0}.

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.

• keys (Sequence[str | Expr | None]) –

  Dict keys.

• path (str) –

  Path of the expressed name/attribute.

• values (Sequence[str | Expr]) –

  Dict values.

Name of the expressed name/attribute/parameter.

Path of the expressed name/attribute.

The expression class name.

Whether this attribute is annotated with ClassVar.

Whether this expression is a generator.

Whether this expression is an iterator.

Whether this expression is a tuple.

Dict keys.

Path of the expressed name/attribute.

Dict values.

Iterate on the expression syntax and elements.

Return the expression as a dictionary.

Parameters:

• **kwargs ¤ (Any, default: {} ) –

  Configuration options (none available yet).

Returns:

• dict[str, Any] –

  A dictionary.

Iterate on the expression elements.

Parameters:

• flat ¤ (bool, default: True ) –

  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.

Yields:

• str | Expr –

  Strings and names when flat, strings and expressions otherwise.

Modernize the expression.

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

Returns:

• Expr –

  A modernized expression.

Bases: Expr

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

                              griffe._internal.expressions.Expr --> griffe.ExprDictComp
                


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

Dict comprehensions like {k: v for k, v in a}.

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.

• generators (Sequence[Expr]) –

  Generators iterated on.

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

• key (str | Expr) –

  Target key.

• path (str) –

  Path of the expressed name/attribute.

• value (str | Expr) –

  Target value.

Name of the expressed name/attribute/parameter.

Path of the expressed name/attribute.

The expression class name.

Generators iterated on.

Whether this attribute is annotated with ClassVar.

Whether this expression is a generator.

Whether this expression is an iterator.

Whether this expression is a tuple.

Target key.

Path of the expressed name/attribute.

Target value.

Iterate on the expression syntax and elements.

Return the expression as a dictionary.

Parameters:

• **kwargs ¤ (Any, default: {} ) –

  Configuration options (none available yet).

Returns:

• dict[str, Any] –

  A dictionary.

Iterate on the expression elements.

Parameters:

• flat ¤ (bool, default: True ) –

  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.

Yields:

• str | Expr –

  Strings and names when flat, strings and expressions otherwise.

Modernize the expression.

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

Returns:

• Expr –

  A modernized expression.

Bases: Expr

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

                              griffe._internal.expressions.Expr --> griffe.ExprExtSlice
                


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

Extended slice like a[x:y, z].

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.

• dims (Sequence[str | Expr]) –

  Dims.

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

Name of the expressed name/attribute/parameter.

Path of the expressed name/attribute.

The expression class name.

Dims.

Whether this attribute is annotated with ClassVar.

Whether this expression is a generator.

Whether this expression is an iterator.

Whether this expression is a tuple.

Path of the expressed name/attribute.

Iterate on the expression syntax and elements.

Return the expression as a dictionary.

Parameters:

• **kwargs ¤ (Any, default: {} ) –

  Configuration options (none available yet).

Returns:

• dict[str, Any] –

  A dictionary.

Iterate on the expression elements.

Parameters:

• flat ¤ (bool, default: True ) –

  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.

Yields:

• str | Expr –

  Strings and names when flat, strings and expressions otherwise.

Modernize the expression.

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

Returns:

• Expr –

  A modernized expression.

Bases: Expr

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

                              griffe._internal.expressions.Expr --> griffe.ExprFormatted
                


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

Formatted string like {1 + 1}.

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.

• value (str | Expr) –

  Formatted value.

Name of the expressed name/attribute/parameter.

Path of the expressed name/attribute.

The expression class name.

Whether this attribute is annotated with ClassVar.

Whether this expression is a generator.

Whether this expression is an iterator.

Whether this expression is a tuple.

Path of the expressed name/attribute.

Formatted value.

Iterate on the expression syntax and elements.

Return the expression as a dictionary.

Parameters:

• **kwargs ¤ (Any, default: {} ) –

  Configuration options (none available yet).

Returns:

• dict[str, Any] –

  A dictionary.

Iterate on the expression elements.

Parameters:

• flat ¤ (bool, default: True ) –

  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.

Yields:

• str | Expr –

  Strings and names when flat, strings and expressions otherwise.

Modernize the expression.

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

Returns:

• Expr –

  A modernized expression.

Bases: Expr

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

                              griffe._internal.expressions.Expr --> griffe.ExprGeneratorExp
                


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

Generator expressions like a for b in c for d in e.

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.

• element (str | Expr) –

  Yielded element.

• generators (Sequence[Expr]) –

  Generators iterated on.

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

Name of the expressed name/attribute/parameter.

Path of the expressed name/attribute.

The expression class name.

Yielded element.

Generators iterated on.

Whether this attribute is annotated with ClassVar.

Whether this expression is a generator.

Whether this expression is an iterator.

Whether this expression is a tuple.

Path of the expressed name/attribute.

Iterate on the expression syntax and elements.

Return the expression as a dictionary.

Parameters:

• **kwargs ¤ (Any, default: {} ) –

  Configuration options (none available yet).

Returns:

• dict[str, Any] –

  A dictionary.

Iterate on the expression elements.

Parameters:

• flat ¤ (bool, default: True ) –

  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.

Yields:

• str | Expr –

  Strings and names when flat, strings and expressions otherwise.

Modernize the expression.

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

Returns:

• Expr –

  A modernized expression.

Bases: Expr

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

                              griffe._internal.expressions.Expr --> griffe.ExprIfExp
                


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

Conditions like a if b else c.

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:

• body (str | Expr) –

  Value if test.

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

• orelse (str | Expr) –

  Other expression.

• path (str) –

  Path of the expressed name/attribute.

• test (str | Expr) –

  Condition.

Value if test.

Name of the expressed name/attribute/parameter.

Path of the expressed name/attribute.

The expression class name.

Whether this attribute is annotated with ClassVar.

Whether this expression is a generator.

Whether this expression is an iterator.

Whether this expression is a tuple.

Other expression.

Path of the expressed name/attribute.

Condition.

Iterate on the expression syntax and elements.

Return the expression as a dictionary.

Parameters:

• **kwargs ¤ (Any, default: {} ) –

  Configuration options (none available yet).

Returns:

• dict[str, Any] –

  A dictionary.

Iterate on the expression elements.

Parameters:

• flat ¤ (bool, default: True ) –

  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.

Yields:

• str | Expr –

  Strings and names when flat, strings and expressions otherwise.

Modernize the expression.

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

Returns:

• Expr –

  A modernized expression.

Bases: Expr

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

                              griffe._internal.expressions.Expr --> griffe.ExprJoinedStr
                


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

Joined strings like f"a {b} c".

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.

• values (Sequence[str | Expr]) –

  Joined values.

Name of the expressed name/attribute/parameter.

Path of the expressed name/attribute.

The expression class name.

Whether this attribute is annotated with ClassVar.

Whether this expression is a generator.

Whether this expression is an iterator.

Whether this expression is a tuple.

Path of the expressed name/attribute.

Joined values.

Iterate on the expression syntax and elements.

Return the expression as a dictionary.

Parameters:

• **kwargs ¤ (Any, default: {} ) –

  Configuration options (none available yet).

Returns:

• dict[str, Any] –

  A dictionary.

Iterate on the expression elements.

Parameters:

• flat ¤ (bool, default: True ) –

  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.

Yields:

• str | Expr –

  Strings and names when flat, strings and expressions otherwise.

Modernize the expression.

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

Returns:

• Expr –

  A modernized expression.

ExprKeyword(
    name: str,
    value: str | Expr,
    function: Expr | None = None,
)

Bases: Expr

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

                              griffe._internal.expressions.Expr --> griffe.ExprKeyword
                


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

Keyword arguments 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 keyword.

• classname (str) –

  The expression class name.

• function (Expr | None) –

  Expression referencing the function called with this parameter.

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

• name (str) –

  Name.

• path (str) –

  Path of the expressed name/attribute.

• value (str | Expr) –

  Value.

Name of the expressed name/attribute/parameter.

Path of the expressed keyword.

The expression class name.

function: Expr | None = None

Expression referencing the function called with this parameter.

Whether this attribute is annotated with ClassVar.

Whether this expression is a generator.

Whether this expression is an iterator.

Whether this expression is a tuple.

Name.

Path of the expressed name/attribute.

Value.

Iterate on the expression syntax and elements.

Return the expression as a dictionary.

Parameters:

• **kwargs ¤ (Any, default: {} ) –

  Configuration options (none available yet).

Returns:

• dict[str, Any] –

  A dictionary.

Iterate on the expression elements.

Parameters:

• flat ¤ (bool, default: True ) –

  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.

Yields:

• str | Expr –

  Strings and names when flat, strings and expressions otherwise.

Modernize the expression.

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

Returns:

• Expr –

  A modernized expression.

ExprVarPositional(value: Expr)

Bases: Expr

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

                              griffe._internal.expressions.Expr --> griffe.ExprVarPositional
                


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

Variadic positional parameters like *args.

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.

• value (Expr) –

  Starred value.

Name of the expressed name/attribute/parameter.

Path of the expressed name/attribute.

The expression class name.

Whether this attribute is annotated with ClassVar.

Whether this expression is a generator.

Whether this expression is an iterator.

Whether this expression is a tuple.

Path of the expressed name/attribute.

Starred value.

Iterate on the expression syntax and elements.

Return the expression as a dictionary.

Parameters:

• **kwargs ¤ (Any, default: {} ) –

  Configuration options (none available yet).

Returns:

• dict[str, Any] –

  A dictionary.

Iterate on the expression elements.

Parameters:

• flat ¤ (bool, default: True ) –

  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.

Yields:

• str | Expr –

  Strings and names when flat, strings and expressions otherwise.

Modernize the expression.

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

Returns:

• Expr –

  A modernized expression.

ExprVarKeyword(value: Expr)

Bases: Expr

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

                              griffe._internal.expressions.Expr --> griffe.ExprVarKeyword
                


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

Variadic keyword parameters like **kwargs.

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.

• value (Expr) –

  Double-starred value.

Name of the expressed name/attribute/parameter.

Path of the expressed name/attribute.

The expression class name.

Whether this attribute is annotated with ClassVar.

Whether this expression is a generator.

Whether this expression is an iterator.

Whether this expression is a tuple.

Path of the expressed name/attribute.

Double-starred value.

Iterate on the expression syntax and elements.

Return the expression as a dictionary.

Parameters:

• **kwargs ¤ (Any, default: {} ) –

  Configuration options (none available yet).

Returns:

• dict[str, Any] –

  A dictionary.

Iterate on the expression elements.

Parameters:

• flat ¤ (bool, default: True ) –

  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.

Yields:

• str | Expr –

  Strings and names when flat, strings and expressions otherwise.

Modernize the expression.

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

Returns:

• Expr –

  A modernized expression.

Bases: Expr

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

                              griffe._internal.expressions.Expr --> griffe.ExprLambda
                


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

Lambda expressions like lambda a: 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:

• body (str | Expr) –

  Lambda's body.

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

• parameters (Sequence[ExprParameter]) –

  Lambda's parameters.

• path (str) –

  Path of the expressed name/attribute.

Lambda's body.

Name of the expressed name/attribute/parameter.

Path of the expressed name/attribute.

The expression class name.

Whether this attribute is annotated with ClassVar.

Whether this expression is a generator.

Whether this expression is an iterator.

Whether this expression is a tuple.

Lambda's parameters.

Path of the expressed name/attribute.

Iterate on the expression syntax and elements.

Return the expression as a dictionary.

Parameters:

• **kwargs ¤ (Any, default: {} ) –

  Configuration options (none available yet).

Returns:

• dict[str, Any] –

  A dictionary.

Iterate on the expression elements.

Parameters:

• flat ¤ (bool, default: True ) –

  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.

Yields:

• str | Expr –

  Strings and names when flat, strings and expressions otherwise.

Modernize the expression.

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

Returns:

• Expr –

  A modernized expression.

Bases: Expr

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

                              griffe._internal.expressions.Expr --> griffe.ExprList
                


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

Lists like [0, 1, 2].

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.

• elements (Sequence[Expr]) –

  List elements.

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

Name of the expressed name/attribute/parameter.

Path of the expressed name/attribute.

The expression class name.

List elements.

Whether this attribute is annotated with ClassVar.

Whether this expression is a generator.

Whether this expression is an iterator.

Whether this expression is a tuple.

Path of the expressed name/attribute.

Iterate on the expression syntax and elements.

Return the expression as a dictionary.

Parameters:

• **kwargs ¤ (Any, default: {} ) –

  Configuration options (none available yet).

Returns:

• dict[str, Any] –

  A dictionary.

Iterate on the expression elements.

Parameters:

• flat ¤ (bool, default: True ) –

  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.

Yields:

• str | Expr –

  Strings and names when flat, strings and expressions otherwise.

Modernize the expression.

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

Returns:

• Expr –

  A modernized expression.

Bases: Expr

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

                              griffe._internal.expressions.Expr --> griffe.ExprListComp
                


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

List comprehensions like [a for b in c].

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.

• element (str | Expr) –

  Target value.

• generators (Sequence[Expr]) –

  Generators iterated on.

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

Name of the expressed name/attribute/parameter.

Path of the expressed name/attribute.

The expression class name.

Target value.

Generators iterated on.

Whether this attribute is annotated with ClassVar.

Whether this expression is a generator.

Whether this expression is an iterator.

Whether this expression is a tuple.

Path of the expressed name/attribute.

Iterate on the expression syntax and elements.

Return the expression as a dictionary.

Parameters:

• **kwargs ¤ (Any, default: {} ) –

  Configuration options (none available yet).

Returns:

• dict[str, Any] –

  A dictionary.

Iterate on the expression elements.

Parameters:

• flat ¤ (bool, default: True ) –

  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.

Yields:

• str | Expr –

  Strings and names when flat, strings and expressions otherwise.

Modernize the expression.

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

Returns:

• Expr –

  A modernized expression.

Bases: Expr

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

                              griffe._internal.expressions.Expr --> griffe.ExprName
                


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

This class represents a Python object identified by a name in a given scope.

Methods:

• __eq__ –

  Two name expressions are equal if they have the same name value (parent is ignored).

• __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) –

  The canonical name (resolved one, not alias name).

• classname (str) –

  The expression class name.

• is_classvar (bool) –

  Whether this attribute is annotated with ClassVar.

• is_enum_class (bool) –

  Whether this name resolves to an enumeration class.

• is_enum_instance (bool) –

  Whether this name resolves to an enumeration instance.

• is_enum_value (bool) –

  Whether this name resolves to an enumeration value.

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

• is_type_parameter (bool) –

  Whether this name resolves to a type parameter.

• member (str | None) –

  Member name (for resolution in its scope).

• name (str) –

  Actual name.

• parent (str | ExprName | Module | Class | Function | None) –

  Parent (for resolution in its scope).

• path (str) –

  The full, resolved name.

• resolved (Module | Class | None) –

  The resolved object this name refers to.

Name of the expressed name/attribute/parameter.

The canonical name (resolved one, not alias name).

The expression class name.

Whether this attribute is annotated with ClassVar.

Whether this name resolves to an enumeration class.

Whether this name resolves to an enumeration instance.

Whether this name resolves to an enumeration value.

Whether this expression is a generator.

Whether this expression is an iterator.

Whether this expression is a tuple.

Whether this name resolves to a type parameter.

member: str | None = None

Member name (for resolution in its scope).

Actual name.

Parent (for resolution in its scope).

The full, resolved name.

If it was given when creating the name, return that. If a callable was given, call it and return its result. It the name cannot be resolved, return the source.

The resolved object this name refers to.

Two name expressions are equal if they have the same name value (parent is ignored).

Iterate on the expression syntax and elements.

Return the expression as a dictionary.

Parameters:

• **kwargs ¤ (Any, default: {} ) –

  Configuration options (none available yet).

Returns:

• dict[str, Any] –

  A dictionary.

Iterate on the expression elements.

Parameters:

• flat ¤ (bool, default: True ) –

  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.

Yields:

• str | Expr –

  Strings and names when flat, strings and expressions otherwise.

Modernize the expression.

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

Returns:

• Expr –

  A modernized expression.

Bases: Expr

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

                              griffe._internal.expressions.Expr --> griffe.ExprNamedExpr
                


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

Named/assignment expressions 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.

• path (str) –

  Path of the expressed name/attribute.

• target (Expr) –

  Target name.

• value (str | Expr) –

  Value.

Name of the expressed name/attribute/parameter.

Path of the expressed name/attribute.

The expression class name.

Whether this attribute is annotated with ClassVar.

Whether this expression is a generator.

Whether this expression is an iterator.

Whether this expression is a tuple.

Path of the expressed name/attribute.

Target name.

Value.

Iterate on the expression syntax and elements.

Return the expression as a dictionary.

Parameters:

• **kwargs ¤ (Any, default: {} ) –

  Configuration options (none available yet).

Returns:

• dict[str, Any] –

  A dictionary.

Iterate on the expression elements.

Parameters:

• flat ¤ (bool, default: True ) –

  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.

Yields:

• str | Expr –

  Strings and names when flat, strings and expressions otherwise.

Modernize the expression.

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

Returns:

• Expr –

  A modernized expression.

Bases: Expr

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

                              griffe._internal.expressions.Expr --> griffe.ExprParameter
                


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

Parameters in function signatures like a: int = 0.

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:

• annotation (Expr | None) –

  Parameter type.

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

• default (str | Expr | None) –

  Parameter default.

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

• kind (ParameterKind) –

  Parameter kind.

• name (str) –

  Parameter name.

• path (str) –

  Path of the expressed name/attribute.

annotation: Expr | None = None

Parameter type.

Name of the expressed name/attribute/parameter.

Path of the expressed name/attribute.

The expression class name.

Parameter default.

Whether this attribute is annotated with ClassVar.

Whether this expression is a generator.

Whether this expression is an iterator.

Whether this expression is a tuple.

Parameter kind.

Parameter name.

Path of the expressed name/attribute.

Iterate on the expression syntax and elements.

Return the expression as a dictionary.

Parameters:

• **kwargs ¤ (Any, default: {} ) –

  Configuration options (none available yet).

Returns:

• dict[str, Any] –

  A dictionary.

Iterate on the expression elements.

Parameters:

• flat ¤ (bool, default: True ) –

  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.

Yields:

• str | Expr –

  Strings and names when flat, strings and expressions otherwise.

Modernize the expression.

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

Returns:

• Expr –

  A modernized expression.

Bases: Expr

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

                              griffe._internal.expressions.Expr --> griffe.ExprSet
                


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

Sets like {0, 1, 2}.

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.

• elements (Sequence[str | Expr]) –

  Set elements.

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

Name of the expressed name/attribute/parameter.

Path of the expressed name/attribute.

The expression class name.

Set elements.

Whether this attribute is annotated with ClassVar.

Whether this expression is a generator.

Whether this expression is an iterator.

Whether this expression is a tuple.

Path of the expressed name/attribute.

Iterate on the expression syntax and elements.

Return the expression as a dictionary.

Parameters:

• **kwargs ¤ (Any, default: {} ) –

  Configuration options (none available yet).

Returns:

• dict[str, Any] –

  A dictionary.

Iterate on the expression elements.

Parameters:

• flat ¤ (bool, default: True ) –

  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.

Yields:

• str | Expr –

  Strings and names when flat, strings and expressions otherwise.

Modernize the expression.

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

Returns:

• Expr –

  A modernized expression.

Bases: Expr

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

                              griffe._internal.expressions.Expr --> griffe.ExprSetComp
                


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

Set comprehensions like {a for b in c}.

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.

• element (str | Expr) –

  Target value.

• generators (Sequence[Expr]) –

  Generators iterated on.

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

Name of the expressed name/attribute/parameter.

Path of the expressed name/attribute.

The expression class name.

Target value.

Generators iterated on.

Whether this attribute is annotated with ClassVar.

Whether this expression is a generator.

Whether this expression is an iterator.

Whether this expression is a tuple.

Path of the expressed name/attribute.

Iterate on the expression syntax and elements.

Return the expression as a dictionary.

Parameters:

• **kwargs ¤ (Any, default: {} ) –

  Configuration options (none available yet).

Returns:

• dict[str, Any] –

  A dictionary.

Iterate on the expression elements.

Parameters:

• flat ¤ (bool, default: True ) –

  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.

Yields:

• str | Expr –

  Strings and names when flat, strings and expressions otherwise.

Modernize the expression.

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

Returns:

• Expr –

  A modernized expression.

ExprSlice(
    lower: str | Expr | None = None,
    upper: str | Expr | None = None,
    step: str | Expr | None = None,
)

Bases: Expr

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

                              griffe._internal.expressions.Expr --> griffe.ExprSlice
                


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

Slices like [a:b:c].

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.

• lower (str | Expr | None) –

  Lower bound.

• path (str) –

  Path of the expressed name/attribute.

• step (str | Expr | None) –

  Iteration step.

• upper (str | Expr | None) –

  Upper bound.

Name of the expressed name/attribute/parameter.

Path of the expressed name/attribute.

The expression class name.

Whether this attribute is annotated with ClassVar.

Whether this expression is a generator.

Whether this expression is an iterator.

Whether this expression is a tuple.

Lower bound.

Path of the expressed name/attribute.

Iteration step.

Upper bound.

Iterate on the expression syntax and elements.

Return the expression as a dictionary.

Parameters:

• **kwargs ¤ (Any, default: {} ) –

  Configuration options (none available yet).

Returns:

• dict[str, Any] –

  A dictionary.

Iterate on the expression elements.

Parameters:

• flat ¤ (bool, default: True ) –

  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.

Yields:

• str | Expr –

  Strings and names when flat, strings and expressions otherwise.

Modernize the expression.

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

Returns:

• Expr –

  A modernized expression.

Bases: Expr

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

                              griffe._internal.expressions.Expr --> griffe.ExprSubscript
                


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

Subscripts 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) –

  The canonical path of this subscript's left part.

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

• path (str) –

  The path of this subscript's left part.

• slice (str | Expr) –

  Slice part.

Name of the expressed name/attribute/parameter.

The canonical path of this subscript's left part.

The expression class name.

Whether this attribute is annotated with ClassVar.

Whether this expression is a generator.

Whether this expression is an iterator.

Whether this expression is a tuple.

Left part.

The path of this subscript's left part.

Slice part.

Iterate on the expression syntax and elements.

Return the expression as a dictionary.

Parameters:

• **kwargs ¤ (Any, default: {} ) –

  Configuration options (none available yet).

Returns:

• dict[str, Any] –

  A dictionary.

Iterate on the expression elements.

Parameters:

• flat ¤ (bool, default: True ) –

  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.

Yields:

• str | Expr –

  Strings and names when flat, strings and expressions otherwise.

Modernize the expression.

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

Returns:

• Expr –

  A modernized expression.

Bases: Expr

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

                              griffe._internal.expressions.Expr --> griffe.ExprTuple
                


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

Tuples like (0, 1, 2).

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.

• elements (Sequence[str | Expr]) –

  Tuple elements.

• implicit (bool) –

  Whether the tuple is implicit (e.g. without parentheses in a subscript's slice).

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

Name of the expressed name/attribute/parameter.

Path of the expressed name/attribute.

The expression class name.

Tuple elements.

Whether the tuple is implicit (e.g. without parentheses in a subscript's slice).

Whether this attribute is annotated with ClassVar.

Whether this expression is a generator.

Whether this expression is an iterator.

Whether this expression is a tuple.

Path of the expressed name/attribute.

Iterate on the expression syntax and elements.

Return the expression as a dictionary.

Parameters:

• **kwargs ¤ (Any, default: {} ) –

  Configuration options (none available yet).

Returns:

• dict[str, Any] –

  A dictionary.

Iterate on the expression elements.

Parameters:

• flat ¤ (bool, default: True ) –

  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.

Yields:

• str | Expr –

  Strings and names when flat, strings and expressions otherwise.

Modernize the expression.

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

Returns:

• Expr –

  A modernized expression.

Bases: Expr

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

                              griffe._internal.expressions.Expr --> griffe.ExprUnaryOp
                


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

Unary operations like -1.

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) –

  Unary operator.

• path (str) –

  Path of the expressed name/attribute.

• value (str | Expr) –

  Value.

Name of the expressed name/attribute/parameter.

Path of the expressed name/attribute.

The expression class name.

Whether this attribute is annotated with ClassVar.

Whether this expression is a generator.

Whether this expression is an iterator.

Whether this expression is a tuple.

Unary operator.

Path of the expressed name/attribute.

Value.

Iterate on the expression syntax and elements.

Return the expression as a dictionary.

Parameters:

• **kwargs ¤ (Any, default: {} ) –

  Configuration options (none available yet).

Returns:

• dict[str, Any] –

  A dictionary.

Iterate on the expression elements.

Parameters:

• flat ¤ (bool, default: True ) –

  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.

Yields:

• str | Expr –

  Strings and names when flat, strings and expressions otherwise.

Modernize the expression.

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

Returns:

• Expr –

  A modernized expression.

ExprYield(value: str | Expr | None = None)