​
Inherits from

IfBlockStatement, Statement, Expression, Editable

​
Properties

​
alternative_blocks

Returns a list of alternative if/elif/else blocks for the current block.

Gets the alternative blocks (elif/else blocks) based on the type of the current block:

  • For if blocks: returns all alternative blocks
  • For else blocks: returns empty list
  • For elif blocks: returns all subsequent alternative blocks in the main if block

Returns: list[TIfBlockStatement]: A list of alternative if/elif/else blocks that are executed if the condition is False.

def alternative_blocks(self) -> list[TIfBlockStatement]:
    ...

​
else_statement

Returns the else block within the if-statement.

Gets the else block from the if-statement’s alternative blocks if one exists. Only returns the else block, not elif blocks.

Returns: TIfBlockStatement | None: The else block statement if it exists, None otherwise.

def else_statement(self) -> TIfBlockStatement | None:
    ...

​
extended

Returns a SymbolGroup of all extended nodes associated with this element.

Creates a SymbolGroup that provides a common interface for editing all extended nodes, such as decorators, modifiers, and comments associated with the element.

Args: None

Returns: SymbolGroup: A group containing this node and its extended nodes that allows batch modification through a common interface.

def extended(self) -> SymbolGroup:
    ...

​
extended_source

Returns the source text representation of all extended nodes.

Gets the source text of all extended nodes combined. This property allows reading the source text of all extended nodes (e.g. decorators, export statements) associated with this node.

Returns: str: The combined source text of all extended nodes.

def extended_source(self) -> str:
    ...

​
file

The file object that this Editable instance belongs to.

Retrieves or caches the file object associated with this Editable instance.

Returns: File: The File object containing this Editable instance.

def file(self) -> SourceFile:
    ...

​
filepath

The file path of the file that this Editable instance belongs to.

Returns a string representing the absolute file path of the File that contains this Editable instance.

Returns: str: The absolute file path.

def filepath(self) -> str:
    ...

​
function_calls

Returns all function calls within the if block statement and its alternative blocks.

Collects all function calls from the if block’s condition, consequence block, and any alternative blocks (elif/else) including their conditions and consequence blocks.

Returns: list[FunctionCall]: A list of function call objects found within this if block statement and its alternative blocks.

def function_calls(self) -> list[FunctionCall]:
    ...

​
index

The 0-based index of the statement in the parent code block.

Returns the sequential position of this statement within its containing code block.

Returns: int: The 0-based index of this statement within its parent code block.

def index(self) -> int:
    ...

​
is_elif_statement

Returns True if the current block is an elif block.

Determines whether the current block is an ‘elif’ clause in an if/elif/else statement structure.

Returns: bool: True if the current block is an elif clause, False otherwise.

def is_elif_statement(self) -> bool:
    ...

​
is_else_statement

Determines if the current block is an else block.

A property that checks if the current TreeSitter node represents an else clause in an if-elif-else statement chain.

Returns: bool: True if the current block is an else block, False otherwise.

def is_else_statement(self) -> bool:
    ...

​
is_if_statement

Returns whether the current block is an if block.

Determines if the current block is an if statement block by checking the type of the TreeSitter node.

Returns: bool: True if the current block is an if statement, False otherwise.

def is_if_statement(self) -> bool:
    ...

​
nested_code_blocks

Returns all nested code blocks within an if/elif/else statement block.

Returns a list of all CodeBlocks that are part of the current if/elif/else statement block, including the main if block’s consequence block and all alternative (elif/else) blocks’ consequence blocks.

Returns: list[TCodeBlock]: A list of CodeBlock objects representing all nested code blocks within the statement.

def nested_code_blocks(self) -> list[TCodeBlock]:
    ...

​
nested_statements

Returns a list of statement collections within nested code blocks.

Accesses and retrieves the statements from each code block nested within the current statement, such as the statements within if/else branches or loop bodies.

Returns: A list where each element is a collection of statements from one nested code block. Returns an empty list if there are no nested code blocks.

def nested_statements(self) -> list[MultiLineCollection[Statement[Self], Parent]]:
    ...

​
resolved_value

Returns the resolved type of an Expression.

Returns the inferred type of the expression. For example a function call’s resolved value will be it’s definition.

Returns: Union[Expression, list[Expression]]: The resolved expression type(s). Returns a single Expression if there is only one resolved type, or a list of Expressions if there are multiple resolved types. Returns self if the expression is not resolvable or has no resolved types.

def resolved_value(self) -> Expression | list[Expression]:
    ...

​
source

Text representation of the Editable instance.

Returns the source text of the Editable instance. This is the main property used to access the text content of any code element in GraphSitter.

Returns: str: The text content of this Editable instance.

def source(self) -> str:
    ...

​
variable_usages

Returns Editables for all TreeSitter node instances of variable usages within this node’s scope.

This method finds all variable identifier nodes in the TreeSitter AST, excluding:

  • Function names in function calls
  • Import names in import statements
  • Property access identifiers (except the base object)
  • Keyword argument names (in Python and TypeScript)

This is useful for variable renaming and usage analysis within a scope.

Returns: list[Editable]: A list of Editable nodes representing variable usages. Each Editable corresponds to a TreeSitter node instance where the variable is referenced.

def variable_usages(self) -> list[Editable]:
    ...

​
Attributes

​
condition

The condition expression for the if block. None if the block is an else block.

condition: Expression[Self] | None

​
consequence_block

The code block that is executed if the condition is True.

consequence_block: TCodeBlock

​
Methods

​
edit

Replace the source of this Editable with new_src.

Replaces the text representation of this Editable instance with new text content. The method handles indentation adjustments and transaction management.

Args: new_src (str): The new source text to replace the current text with. fix_indentation (bool): If True, adjusts the indentation of new_src to match the current text’s indentation level. Defaults to False. priority (int): The priority of the edit transaction. Higher priority edits are applied first. Defaults to 0. dedupe (bool): If True, deduplicates identical transactions. Defaults to True.

Returns: None

def edit(self, new_src: str, fix_indentation: bool = False, priority: int = 0, dedupe: bool = True) -> None:
    ...

​
elif_statements

Returns all elif blocks within the if block.

Gets all alternative blocks that are specifically elif blocks (i.e., excluding else blocks) from an if statement. Can be called on any if/elif/else block to get subsequent elif blocks.

Note: This method can be called as both a property and a method. If used as a property, it is equivalent to invoking it without arguments.

Returns: list[TIfBlockStatement]: A list of elif block statements. Empty list if no elif blocks exist.

def elif_statements(self) -> list[TIfBlockStatement]:
    ...

​
find

Find and return matching nodes or substrings within an Editable instance.

This method searches through the extended_nodes of the Editable instance and returns all nodes or substrings that match the given search criteria.

Args: strings_to_match (Union[list[str], str]): One or more strings to search for. exact (bool): If True, only return nodes whose source exactly matches one of the strings_to_match. If False, return nodes that contain any of the strings_to_match as substrings. Defaults to False.

Returns: list[Editable]: A list of Editable instances that match the search criteria.

def find(self, strings_to_match: list[str] | str, *, exact: bool = False) -> list[Editable]:
    ...

​
find_string_literals

Returns a list of string literals within this node’s source that match any of the given strings.

Args: strings_to_match (list[str]): A list of strings to search for in string literals. fuzzy_match (bool): If True, matches substrings within string literals. If False, only matches exact strings. Defaults to False.

Returns: list[Editable]: A list of Editable objects representing the matching string literals.

def find_string_literals(self, strings_to_match: list[str], fuzzy_match: bool = False) -> list[Editable]:
    ...

​
flag

Adds a visual flag comment to the end of this Editable’s source text.

Flags this Editable by appending a comment with emoji flags at the end of its source text. This is useful for visually highlighting specific nodes in the source code during development and debugging.

Returns: None

def flag(self, **kwargs: Unpack[FlagKwargs]) -> CodeFlag[Self]:
    ...

​
get_variable_usages

Returns Editables for all TreeSitter nodes corresponding to instances of variable usage that matches the given variable name.

Retrieves a list of variable usages that match a specified name, with an option for fuzzy matching. By default, excludes property identifiers and argument keywords.

Args: var_name (str): The variable name to search for. fuzzy_match (bool): If True, matches variables where var_name is a substring. If False, requires exact match. Defaults to False.

Returns: list[Editable]: List of Editable objects representing variable usage nodes matching the given name.

def get_variable_usages(self, var_name: str, fuzzy_match: bool = False) -> list[Editable]:
    ...

​
insert_after

Inserts code after this node.

Args: new_src (str): The source code to insert after this node. fix_indentation (bool, optional): Whether to adjust the indentation of new_src to match the current node. Defaults to False. newline (bool, optional): Whether to add a newline before the new_src. Defaults to True. priority (int, optional): Priority of the insertion transaction. Defaults to 0. dedupe (bool, optional): Whether to deduplicate identical transactions. Defaults to True.

Returns: None

def insert_after(self, new_src: str, fix_indentation: bool = False, newline: bool = True, priority: int = 0, dedupe: bool = True) -> None:
    ...

​
insert_before

Inserts text before this node’s source with optional indentation and newline handling.

This method inserts the provided text before the current node’s source code. It can automatically handle indentation and newline placement.

Args: new_src (str): The text to insert before this node. fix_indentation (bool): Whether to fix the indentation of new_src to match the current node. Defaults to False. newline (bool): Whether to add a newline after new_src. Defaults to True. priority (int): Transaction priority for managing multiple edits. Defaults to 0. dedupe (bool): Whether to deduplicate identical transactions. Defaults to True.

Returns: None

def insert_before(self, new_src: str, fix_indentation: bool = False, newline: bool = True, priority: int = 0, dedupe: bool = True) -> None:
    ...

​
is_wrapped_in

Check if this node is contained another node of the given class

def is_wrapped_in(self, cls: type[Expression]) -> bool:
    ...

​
json

def json(self, max_depth: int = 2, methods: bool = True) -> JSON:
    ...

​
reduce_condition

Simplifies a conditional block by reducing its condition to a boolean value.

This method modifies the if/elif/else block structure based on the provided boolean value. When reducing to True, it unwraps the consequence block and adjusts subsequent elif/else blocks. When reducing to False, it handles different cases for elif statements and main if blocks.

Args: bool_condition (bool): The boolean value to reduce the condition to. If True, unwraps the consequence block and adjusts alternative blocks. If False, removes or modifies the current block based on its type.

Returns: None

Raises: ValueError: If attempting to reduce a condition on an IfBlockStatement that doesn’t have a condition (like an else block).

def reduce_condition(self, bool_condition: bool, node: Editable | None = None) -> None:
    ...

​
remove

Deletes this Node and its related extended nodes (e.g. decorators, comments).

Removes the current node and its extended nodes (e.g. decorators, comments) from the codebase. After removing the node, it handles cleanup of any surrounding formatting based on the context.

Args: delete_formatting (bool): Whether to delete surrounding whitespace and formatting. Defaults to True. priority (int): Priority of the removal transaction. Higher priority transactions are executed first. Defaults to 0. dedupe (bool): Whether to deduplicate removal transactions at the same location. Defaults to True.

Returns: None

def remove(self, delete_formatting: bool = True, priority: int = 0, dedupe: bool = True) -> None:
    ...

​
replace

Search and replace occurrences of text within this node’s source and its extended nodes.

This method performs string replacement similar to Python’s string.replace(), with support for regex patterns. It operates on both the main node and any extended nodes (e.g. decorators, exports).

Args: old (str): The text or pattern to search for. new (str): The text to replace matches with. count (int, optional): Maximum number of replacements to make. Defaults to -1 (replace all). is_regex (bool, optional): Whether to treat ‘old’ as a regex pattern. Defaults to False. priority (int, optional): Priority of the replacement operation. Defaults to 0.

Returns: int: The total number of replacements made.

Raises: ValueError: If there are multiple occurrences of the substring in a node’s source.

def replace(self, old: str, new: str, count: int = -1, is_regex: bool = False, priority: int = 0) -> int:
    ...

Returns a list of all regex match of regex_pattern, similar to python’s re.search().

Searches for matches of a regular expression pattern within the text of this node and its extended nodes.

Args: regex_pattern (str): The regular expression pattern to search for. include_strings (bool): When False, excludes the contents of string literals from the search. Defaults to True. include_comments (bool): When False, excludes the contents of comments from the search. Defaults to True.

Returns: list[Editable]: A list of Editable objects corresponding to the matches found.

def search(self, regex_pattern: str, include_strings: bool = True, include_comments: bool = True) -> list[Editable]:
    ...

Was this page helpful?

PyHasBlockPyImport