PyClass

Extends Class for Python codebases

Inherits from

PyHasBlock, PySymbol, Class, HasBlock, Symbol, Callable, Expression, Usable, Editable, Importable, HasName

Properties

---

call_sites

Returns all call sites (invocations) of this callable in the codebase.

Finds all locations in the codebase where this callable is invoked/called. Call sites exclude imports, certain exports, and external references.

Returns: list[FunctionCall]: A list of FunctionCall objects representing each invocation of this callable. Returns empty list if the callable has no name.

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

comment

Retrieves the comment group associated with a Python symbol.

A read-only property that returns the non-inline comment group (if any) that is associated with this symbol. Comments are considered associated with a symbol if they appear immediately before the symbol’s definition.

Returns: PyCommentGroup | None: A comment group object containing the symbol’s comments, or None if no comments exist.

def comment(self) -> PyCommentGroup | None:
    ...

constructor

Returns the constructor method for this class.

Gets the constructor of the class (e.g., init in Python) by checking for a method matching the class’s constructor_keyword. This includes searching through superclasses.

Returns: TFunction | None: The constructor method if found, None otherwise.

def constructor(self) -> TFunction | None:
    ...

decorators

Returns a list of decorators associated with this symbol.

Retrieves all decorator nodes from the symbol’s parent TreeSitter node and converts them into PyDecorator objects.

Args: None

Returns: list[PyDecorator]: A list of PyDecorator objects representing the decorators on the symbol. Returns an empty list if the symbol is not decorated.

Note: This property should be used in conjunction with is_decorated to check if the symbol has any decorators.

def decorators(self) -> list[PyDecorator]:
    ...

dependencies

Returns a list of symbols that this symbol depends on.

Returns a list of symbols (including imports) that this symbol directly depends on. The returned list is sorted by file location for consistent ordering.

Returns: list[Union[Symbol, Import]]: A list of symbols and imports that this symbol directly depends on, sorted by file location.

def dependencies(self) -> list[Union["Symbol", "Import"]]:
    ...

docstring

Gets the function’s docstring.

Retrieves the docstring of the function as a PyCommentGroup object. If the function has no docstring, returns None.

Returns: PyCommentGroup | None: The docstring of the function as a PyCommentGroup, or None if no docstring exists.

def docstring(self) -> PyCommentGroup | 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_nodes

Returns a list of Editable nodes associated with this symbol, including extended symbols.

Extended symbols include export, public, decorator, comments, and inline comments.

Args: self: The symbol instance.

Returns: list[Editable]: A list of Editable nodes containing the current symbol and its extended symbols, sorted in the correct order.

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

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

full_name

Returns the full name of the object, including the namespace path.

Returns the complete qualified name of an object, including any parent class or namespace paths. For class methods, this returns the parent class’s full name followed by the method name. For chained attributes (e.g., ‘a.b’), this returns the full chained name.

Args: None

Returns: str | None: The complete qualified name of the object. Returns None if no name is available. For class methods, returns ‘ParentClass.method_name’. For chained attributes, returns the full chain (e.g., ‘a.b’). For simple names, returns just the name.

def full_name(self) -> str | None:
    ...

function_calls

Returns all function calls within the code block and its decorators.

Args: None

Returns: list[FunctionCall]: A sorted list of FunctionCall objects representing all function calls in the code block and its decorators. The list may contain duplicates.

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

inline_comment

Returns the inline comment group associated with this symbol.

Retrieves any inline comments attached to this symbol. An inline comment appears on the same line as the code it comments on.

Args: self (PySymbol): The Python symbol to check for inline comments.

Returns: PyCommentGroup | None: A comment group containing the inline comments if they exist, None otherwise.

def inline_comment(self) -> PyCommentGroup | None:
    ...

is_decorated

Returns whether the symbol is decorated with decorators.

Checks if the symbol has a parent and if that parent’s type is a decorated definition.

Returns: bool: True if the symbol has decorators, False otherwise.

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

is_exported

Indicates whether a Python symbol is exported.

In Python, all symbols are exported by default, so this property always returns True.

Returns: bool: Always True, as Python symbols are exported by default.

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

is_subclass

Indicates whether the current class is a subclass of another class.

A class is considered a subclass if it inherits from at least one parent class.

Returns: bool: True if the class has one or more parent classes, False otherwise.

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

name

Retrieves the name of the object excluding any namespace prefixes.

Returns the “base” name of the object without any namespace or module prefix. For instance, for an object ‘a.b’, this method returns ‘b’.

Returns: str | None: The base name of the object as a string, or None if there is no associated name node.

def name(self) -> str | None:
    ...

nested_classes

Retrieves the nested classes defined within this class.

Args: None

Returns: list[Self]: A list of Class objects representing nested class definitions within this class.

def nested_classes(self) -> list[Self]:
    ...

parameters

Retrieves all parameters of a callable symbol.

This property provides access to all parameters of a callable symbol (function, class, decorator, or external module). Parameters are stored as a SymbolGroup containing Parameter objects.

Returns: SymbolGroup[TParameter, Self] | None: A group of Parameter objects representing the callable’s parameters, or None if the callable has no parameters.

def parameters(self) -> SymbolGroup[TParameter, Self] | None:
    ...

parent_class_names

Returns a list of the parent class names that this class inherits from.

Gets the list of parent class names from Parents object. Returns empty list if class has no parents.

Returns: list[Name | ChainedAttribute]: A list of parent class identifiers. Each identifier can be either a simple name (Name) or a chained attribute (e.g., ‘module.Class’).

def parent_class_names(self) -> list[Name | ChainedAttribute]:
    ...

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

Returns the source code of the symbol.

Gets the source code of the symbol from its extended representation, which includes any comments, docstrings, access identifiers, or decorators.

Returns: str: The complete source code of the symbol including any extended nodes.

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

---

parent_statement

Returns the parent statement that contains this expression

parent_statement: Statement | None

Methods

---

add_attribute

Adds an attribute to a class from another class.

This method adds an attribute to a class, optionally including its dependencies. If dependencies are included, it will add any necessary imports to the class’s file.

Args: attribute (Attribute): The attribute to add to the class. include_dependencies (bool, optional): Whether to include the attribute’s dependencies. If True, adds any necessary imports to the class’s file. Defaults to False.

Returns: None

def add_attribute(self, attribute: Attribute, include_dependencies: bool = False) -> None:
    ...

add_attribute_from_source

Adds an attribute to a class from raw source code, placing it in a specific location based on the class structure.

This method intelligently places the new attribute after existing attributes and docstrings but before methods to maintain a clean class structure.

Args: source (str): The source code of the attribute to be added.

Returns: None

def add_attribute_from_source(self, source: str) -> None:
    ...

add_comment

Adds a new comment to the symbol.

Appends a comment to the symbol either adding it to an existing comment group or creating a new one.

Args: comment (str): The comment text to be added. auto_format (bool): Whether to automatically format the text into a proper comment format. Defaults to True. clean_format (bool): Whether to clean and normalize the comment text before adding. Defaults to True. comment_type (PyCommentType): The style of comment to add (e.g., single-line, multi-line). Defaults to PyCommentType.SINGLE_LINE.

Returns: None

Raises: None

def add_comment(self, comment: str, auto_format: bool = True, clean_format: bool = True, comment_type: PyCommentType = PyCommentType.SINGLE_LINE) -> None:
    ...

add_decorator

Adds a decorator to a function or method.

Adds a new decorator to the symbol’s definition. The decorator is inserted before the first non-comment extended node with proper indentation.

Args: new_decorator (str): The decorator to add. Should be a complete decorator string including the ’@’ symbol. skip_if_exists (bool, optional): If True, will not add the decorator if it already exists. Defaults to False.

Returns: bool: True if the decorator was added, False if skipped due to existing decorator.

def add_decorator(self, new_decorator: str, skip_if_exists: bool = False) -> bool:
    ...

add_keyword

Insert a keyword in the appropriate place before this symbol if it doesn’t already exist.

This method adds a keyword (e.g., ‘public’, ‘async’, ‘static’) in the syntactically appropriate position relative to other keywords. If the keyword already exists, no action is taken.

Args: keyword (str): The keyword to be inserted. Must be a valid keyword in the language context.

Raises: AssertionError: If the provided keyword is not in the language’s valid keywords list.

def add_keyword(self, keyword: str):
    ...

add_source

Adds source code to the class definition.

Adds the provided source code string to the body of the class definition. The method handles proper indentation of the source code within the class body.

Args: source (str): The source code to be added to the class definition. If the source doesn’t start with a newline, it will be indented with 4 spaces.

Raises: ValueError: If the class body cannot be found.

def add_source(self, source: str) -> None:
    ...

attributes

Retrieves all attributes from this Class including those from its superclasses up to a specified depth.

Args: max_depth (int | None): The maximum depth of superclass traversal. None means no limit, 0 means only this class. private (bool): Whether to include private attributes. Defaults to True.

Returns: list[Attribute]: A list of unique attributes from this class and its superclasses. If an attribute is defined in multiple classes, the first definition encountered is used.

def attributes(self, *, max_depth: int | None = 0, private: bool = True) -> list[Attribute]:
    ...

call_graph_successors

Returns all function call definitions that are reachable from this callable.

Analyzes the callable’s implementation to find all function calls and their corresponding definitions. For classes, if a constructor exists, returns the call graph successors of the constructor; otherwise returns an empty list.

Args: include_classes (bool): If True, includes class definitions in the results. Defaults to True. include_external (bool): If True, includes external module definitions in the results. Defaults to True.

Returns: list[FunctionCallDefinition]: A list of FunctionCallDefinition objects, each containing a function call and its possible callable definitions (Functions, Classes, or ExternalModules based on include flags). Returns empty list for non-block symbols or classes without constructors.

def call_graph_successors(
        self,
        *,
        include_classes: bool = True,
        include_external: bool = True,
    ) -> list[FunctionCallDefinition]:
    ...

edit

Replace the source of this node with new_src.

Edits the source code of this node by replacing it with the provided new source code. If specified, the indentation of the new source can be adjusted to match the current text’s indentation.

Args: new_src (str): The new source code to replace the current source with. fix_indentation (bool): If True, adjusts the indentation of new_src to match the current text’s indentation. Defaults to False. priority (int): The priority of this edit. Higher priority edits take precedence. Defaults to 0. dedupe (bool): If True, prevents duplicate edits. Defaults to True.

Returns: None

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

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_attribute

Returns a specific attribute by name.

Searches for an attribute with the given name in the current class and its superclasses.

Args: name (str): The name of the attribute to search for.

Returns: Attribute | None: The matching attribute if found, None otherwise. If multiple attributes with the same name exist in the inheritance hierarchy, returns the first one found.

def get_attribute(self, name: str) -> Attribute | None:
    ...

get_import_string

Generates an import string for a Python symbol.

Returns a string representation of how to import this symbol, with support for different import types and aliasing.

Args: alias (str | None): Optional alias name for the import. If provided and different from symbol name, creates aliased import. module (str | None): Optional module name to import from. If not provided, uses the symbol’s file’s module name. import_type (ImportType): Type of import to generate. If WILDCARD, generates star import. Defaults to UNKNOWN. is_type_import (bool): Whether this is a type import. Currently unused. Defaults to False.

Returns: str: The formatted import string. Will be one of:

• “from import * as ” (for WILDCARD imports)
• “from import as ” (for aliased imports)
• “from import ” (for standard imports)

def get_import_string(
        self,
        alias: str | None = None,
        module: str | None = None,
        import_type: ImportType = ImportType.UNKNOWN,
        is_type_import: bool = False,
    ) -> str:
    ...

get_method

Returns a specific method by name from the class or any of its superclasses.

Searches through the class’s methods and its superclasses’ methods to find a method with the specified name.

Args: name (str): The name of the method to find.

Returns: TFunction | None: The method if found, None otherwise.

def get_method(self, name: str) -> TFunction | None:
    ...

get_name

Returns the Name node of the object.

Retrieves the name node of the object which can be used for modification operations.

Returns: Name | ChainedAttribute | None: The name node of the object. Can be a Name node for simple names, a ChainedAttribute for names with namespaces (e.g., a.b), or None if the object has no name.

def get_name(self) -> Name | ChainedAttribute | None:
    ...

get_nested_class

Returns a nested class by name from the current class.

Searches through the nested classes defined in the class and returns the first one that matches the given name.

Args: name (str): The name of the nested class to find.

Returns: Self | None: The nested class if found, None otherwise.

def get_nested_class(self, name: str) -> Self | None:
    ...

get_parameter

Gets a specific parameter from the callable’s parameters list by name.

Args: name (str): The name of the parameter to retrieve.

Returns: TParameter | None: The parameter with the specified name, or None if no parameter with that name exists or if there are no parameters.

def get_parameter(self, name: str) -> TParameter | None:
    ...

get_parameter_by_index

Returns the parameter at the given index.

Retrieves a parameter from the callable’s parameter list based on its positional index.

Args: index (int): The index of the parameter to retrieve.

Returns: TParameter | None: The parameter at the specified index, or None if the parameter list is empty or the index does not exist.

def get_parameter_by_index(self, index: int) -> TParameter | None:
    ...

get_parameter_by_type

Retrieves a parameter from the callable by its type.

Searches through the callable’s parameters to find a parameter with the specified type.

Args: type (Symbol): The type to search for.

Returns: TParameter | None: The parameter with the specified type, or None if no parameter is found or if the callable has no parameters.

def get_parameter_by_type(self, type: "Symbol") -> TParameter | None:
    ...

get_parent_class

Returns the parent class node with the specified name.

Retrieves a parent class Name or ChainedAttribute node from this class’s list of parent class names that matches the specified name.

Args: parent_class_name (str): The name of the parent class to find.

Returns: Editable | None: The matching parent class node, or None if no match is found.

def get_parent_class(self, parent_class_name: str) -> Editable | None:
    ...

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 the current symbol node in the Abstract Syntax Tree.

Handles insertion of new source code before a symbol, with special handling for extended nodes like comments and decorators. The insertion can be done either before the symbol itself or before its extended nodes.

Args: new_src (str): The source code text to insert. fix_indentation (bool): Whether to adjust the indentation of new_src to match current text. Defaults to False. newline (bool): Whether to add a newline after insertion. Defaults to True. priority (int): Priority of this edit operation. Higher priority edits are applied first. Defaults to 0. dedupe (bool): Whether to remove duplicate insertions. Defaults to True. extended (bool): Whether to insert before extended nodes like comments and decorators. 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, extended: bool = True) -> None:
    ...

is_subclass_of

Checks if the class inherits from a specified parent class.

Determines whether this class is a subclass (direct or indirect) of the specified parent class. The search can be limited to a certain depth in the inheritance tree.

Args: parent_class (str | Class): The parent class to check for. Can be specified either as a class name string or Class object. max_depth (int | None): Maximum inheritance depth to search. None means no limit.

Returns: bool: True if this class inherits from the parent class, False otherwise.

def is_subclass_of(self, parent_class: str | Class, max_depth: int | None = None) -> bool:
    ...

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

methods

Retrieves all methods that exist on this Class, including methods from superclasses, with filtering options.

Args: max_depth (int | None, optional): Include parent classes up to max_depth. None means no limit, 0 means only current class. Defaults to 0. private (bool, optional): Whether to include private methods. Defaults to True. magic (bool, optional): Whether to include magic methods. Defaults to False.

Returns: A list of methods that match the filtering criteria. Methods are ordered by class hierarchy (methods from the current class appear before methods from parent classes). For methods with the same name, only the first occurrence is included. Methods are returned as a MultiLineCollection for efficient access and manipulation if max depth is 0 and private and magic methods are included.

def methods(self, *, max_depth: int | None = 0, private: bool = True, magic: bool = True) -> list[TFunction] | MultiLineCollection[TFunction, Self]:
    ...

move_to_file

Moves the given symbol to a new file and updates its imports and references.

This method moves a symbol to a new file and updates all references to that symbol throughout the codebase. The way imports are handled can be controlled via the strategy parameter.

Args: file (SourceFile): The destination file to move the symbol to. include_dependencies (bool): If True, moves all dependencies of the symbol to the new file. If False, adds imports for the dependencies. Defaults to True. strategy (str): The strategy to use for updating imports. Can be either ‘add_back_edge’ or ‘update_all_imports’. Defaults to ‘update_all_imports’.

• ‘add_back_edge’: Moves the symbol and adds an import in the original file
• ’update_all_imports’: Updates all imports and usages of the symbol to reference the new file

Returns: None

Raises: AssertionError: If an invalid strategy is provided.

def move_to_file(self, file: SourceFile, include_dependencies: bool = True, strategy: str = "update_all_imports") -> None:
    ...

reduce_condition

Reduces an editable to the following condition

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

rename

Renames the symbol and all its references in the codebase.

Renames a symbol to a new name and updates all references to that symbol throughout the codebase, including imports and call sites.

Args: new_name (str): The new name for the symbol. priority (int): Priority of the edit operation. Defaults to 0.

Returns: tuple[NodeId, NodeId]: A tuple containing the file node ID and the new node ID of the renamed symbol.

def rename(self, new_name: str, priority: int = 0):
    ...

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

search

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]:
    ...

set_comment

Sets a comment for the Python symbol.

Adds or modifies a comment associated with the Python symbol. If a comment already exists, it will be edited. If no comment exists, a new comment group will be created.

Args: comment (str): The comment text to be added or set. auto_format (bool, optional): If True, automatically formats the text as a comment. Defaults to True. clean_format (bool, optional): If True, cleans the format of the comment before inserting. Defaults to True. comment_type (PyCommentType, optional): Type of comment to add (e.g., single line, multi line). Defaults to PyCommentType.SINGLE_LINE.

Returns: None: This method modifies the symbol’s comment in place.

def set_comment(self, comment: str, auto_format: bool = True, clean_format: bool = True, comment_type: PyCommentType = PyCommentType.SINGLE_LINE) -> None:
    ...

set_docstring

Sets or updates a docstring for a Python function or class.

Updates the existing docstring if one exists, otherwise creates a new docstring. The docstring can be automatically formatted and cleaned before being set.

Args: docstring (str): The docstring content to set. auto_format (bool, optional): Whether to format the text into a proper docstring format. Defaults to True. clean_format (bool, optional): Whether to clean and normalize the docstring format before insertion. Defaults to True. force_multiline (bool, optional): Whether to force single-line comments to be converted to multi-line format. Defaults to False.

Returns: None

def set_docstring(self, docstring: str, auto_format: bool = True, clean_format: bool = True, force_multiline: bool = False) -> None:
    ...

set_inline_comment

Sets an inline comment to the symbol.

Adds or replaces an inline comment for a Python symbol. If an inline comment exists, it will be replaced with the new comment. If no inline comment exists, a new one will be created at the end of the line.

Args: comment (str): The inline comment text to add. auto_format (bool, optional): If True, formats the text into a proper inline comment with appropriate prefixes and spacing. Defaults to True. clean_format (bool, optional): If True, cleans the comment text before insertion by removing extra whitespace and comment markers. Defaults to True.

Returns: None

def set_inline_comment(self, comment: str, auto_format: bool = True, clean_format: bool = True) -> None:
    ...

set_name

Sets the name of a code element.

Modifies the name of the object’s underlying name node. Works with both simple names and chained attributes (e.g., ‘a.b’).

Args: name (str): The new name to set for the object.

Returns: None

def set_name(self, name: str) -> None:
    ...

subclasses

Returns all classes which subclass this class.

Retrieves a list of all classes in the codebase that inherit from this class, up to a specified depth.

Args: max_depth (int | None, optional): Maximum inheritance depth to search. If None, searches all depths. Defaults to None.

Returns: list[Class]: A list of Class objects that inherit from this class.

def subclasses(self, max_depth: int | None = None) -> list[Class]:
    ...

superclasses

Returns a list of all classes that this class extends, up to max_depth.

Gets all classes that this class extends, traversing up the inheritance tree up to max_depth. The traversal follows Python’s Method Resolution Order (MRO), meaning superclasses are searched breadth-first.

Args: max_depth (int | None): The maximum depth to traverse up the inheritance tree. If None, traverses the entire tree.

Returns: list[Class | ExternalModule | Interface]: A list of all superclass symbols in MRO order, up to max_depth. Returns an empty list if the class has no parent classes.

def superclasses(self, max_depth: int | None = None) -> list[Class | ExternalModule | Interface]:
    ...

symbol_usages

Returns a list of symbols that use the exportable object or import it. Returns symbols that use this exportable object, including imports that import this exportable object. By default, returns all usages. This shows where this symbol is imported, but not where it is subsequently used.

Args: usage_types: The types of usages to search for. Defaults to any.

• DIRECT: Direct uses of the symbol
• CHAINED: Uses through method/attribute chains
• INDIRECT: Uses through renamed imports
• ALIASED: Uses through aliases

Returns: list[Import | Symbol | Export]: A list of symbols that use this exportable object, including imports that import it.

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

def symbol_usages(self, usage_types: UsageType | None = None) -> list[Import | Symbol | Export]:
    ...

usages

Returns a list of usages of the exportable object.

Retrieves a list of all locations where the exportable object is used in the codebase. By default, returns all usages, such as imports or references within the same file.

Args: usage_types: Specifies which types of usages to include in the results. Default is any usages. (graph_sitter.core.dataclasses.usage.UsageType)

Returns: list[Usage]: A sorted list of Usage objects representing where this exportable is used, ordered by source location in reverse.

Raises: ValueError: If no usage types are specified or if only ALIASED and DIRECT types are specified together.

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

def usages(self, usage_types: UsageType | None = None) -> list[Usage]:
    ...