pre[class*="language-"] {
  color: #edecee;
  font-family: Consolas, Monaco, "Andale Mono", "Ubuntu Mono", monospace;
  text-align: left;
  white-space: pre;
  word-spacing: normal;
  word-break: normal;
  word-wrap: normal;
  line-height: 1.5;
  -moz-tab-size: 4;
  -o-tab-size: 4;
  tab-size: 4;
  -webkit-hyphens: none;
  -moz-hyphens: none;
  -ms-hyphens: none;
  hyphens: none;
}
pre[class*="language-"]::-moz-selection,
pre[class*="language-"] ::-moz-selection,
code[class*="language-"]::-moz-selection,
code[class*="language-"] ::-moz-selection {
  text-shadow: none;
  background: #15141b;
}
pre[class*="language-"]::selection,
pre[class*="language-"] ::selection,
code[class*="language-"]::selection,
code[class*="language-"] ::selection {
  text-shadow: none;
  background: #15141b;
}
@media print {
  code[class*="language-"],
  pre[class*="language-"] {
    text-shadow: none;
  }
}
/* Code blocks */
pre[class*="language-"] {
  padding: 1em;
  margin: 0.5em 0;
  overflow: auto;
}
:not(pre) > code[class*="language-"],
pre[class*="language-"] {
  color: white;
}
:not(pre) > code[class*="language-"] {
  padding: 0.1em;
  border-radius: 0.3em;
  white-space: normal;
}
.token.tag {
  color: #A277FF;

}
.token.variable {
  color: #A277FF;

}
.token.keyword {
  color: #A277FF;

}
.token.operator {
  color: #A277FF;

}
.token.attr-name {
  color: #A277FF;

}
.token.punctuation {
  color: #A277FF;

}
.token.constant {
  color: #A277FF;

}
.token.string {
  color: #61FFCA;

}
.token.inserted {
  color: #61FFCA;

}
.token.changed {
  color: #FFCA85;

}
.token.function {
  color: #FFCA85;

}
.token.deleted {
  color: #FF6767;

}
.token.builtin {
  color: #FFCA85;

}
.token.property {
  color: #FFCA85;

}
.token.comment {
  color: #6D6D6D;

}
.token.class-name {
  color: #82E2FF;

}
.token.important,
.token.bold {
  font-weight: bold;
}
.token.italic {
  font-style: italic;
}

value

Properties

set_value

Methods

Codegen

An interface for any node object that has a value

HasValue

Overview

Installation

Build, run and merge a code transformation

Quickstart

How it Works

How Codegen Works

Learn how to efficiently edit docstrings and add documentation with Codegen

Add & Edit Documentation

Adding and Editing Documentation

Safely and systematically move symbols with Codegen

Organize your Codebase

Learn how to manipulate type annotations in Codegen's GraphSitter library.

Increase Type Coverage

Manage Feature Flags

Learn how to efficiently delete dead code with Codegen

Delete Dead Code

Learn how to leverage LLMs for structured code generation

codebase.ai

Learn how to perform complex renaming operations with Codegen

Complex Renaming

Complex Renaming Operations

Learn how to manipulate function call sites with Codegen

Manipulate Call Sites

Manipulate Function Call Sites

Learn how to manipulate datastructures (like Lists and Dicts) in Codegen's GraphSitter library.

Manipulating datastructures

Import loops

Large files

Missing documentation

Unnamed kwargs

Untyped attributes

Untyped parameters

Untyped return types

Getting Started

Create your own graphs

Customize

Customize your Graphs

Function Usages

Inheritance Tree

Visualize your project's directory structure

Directory Tree

Enhance your data visualizations with Plotly's extensive customization options

Customize your Plotly Charts

Visualize data distributions with bar charts

Bar Chart

Generating PRs

Learn how to split PRs into smaller chunks for faster review

Splitting PRs

Main interface for codemods to interact with codebases, including utility methods etc..

Codebase

Skills

Interface to the arguments being passed into a function call

Argument

Represents an assignment for a single variable within an assignment statement.
Attributes: left: The left side of the assignment right: The right side of the assignment
Example: ```typescript var z var z = 5 ```

Assignment

Represents an assignment statement with left and right hand expressions e.g. variable assignments, attribute assignments, multiple assignments

AssignmentStatement

Abstract representation of an attribute on a class definition

Attribute

An awaited expression, only found in asynchronous context.
Example: ```python await (get_db(user_id)) ```

AwaitExpression

Any binary expression in the code. Includes all set of +,-,*,/, as well as logic operations (and, or) etc.

BinaryExpression

BlockStatement

Boolean

Any symbol that can be invoked with arguments eg. Function, Class, Decorator, ExternalModule

Callable

Abstract representation catch clause.
Attributes: code_block: The code block that may trigger an exception condition: The condition which triggers this clause

CatchStatement

An attribute of an object. (IE a method on a class, a function from a module, etc)
Examples: A.method()

ChainedAttribute

Abstract representation of a Class definition

Class

Container class for a list of code Statements that share an indentation level, e.g. a function body or class body. Enables various types of queries and operations on the code block.

CodeBlock

Abstract representation of comment statements

Comment

A group of comments that form a larger comment block.

CommentGroup

Any comparison expression in the code. Includes all set of `<`, `<=`, `>`, `>=`, `==`, `!=` etc.

ComparisonExpression

Decorator

A dict object. You can use standard operations to operate on this dict (IE len, del, set, get, etc)

Dict

An editable instance is an abstract text representation of any text in a file. The editable APIs enables text search and edit within the given Editable wrapper around any group of text in a file.

Editable

Represents a single symbol being exported.

Export

Abstract representation of a single export statement that appears in a file. One export statement can export multiple symbols from a single source.
Attributes: exports: A list of the individual exports this statement represents

ExportStatement

An interface for any node object that can be exported and referenced external to the file it is defined in. eg. Class, class name, class attributes, decorators, top-level functions, imports

Exportable

Represents an arbitrary Expression, such as List, Dict, Binary Expression, String

Expression

ExpressionGroup

Abstract representation of any expression statements that resolves to an expression. In some languages without a statement delimiter, expression statement and the enclosed expression looks the same in text.
For example, in Python: ```python x = 1 ``` The above code is an expression statement, but its expression value is an assignment.
In Typescript: ```typescript x = 1; ``` The above code is also an expression statement, but its expression value is an assignment excluding the semicolon.

ExpressionStatement

Represents an external module, like `datetime`, that can be referenced
These are only added to the graph during import resolution and will not exist in a local file's subgraph. This is because we don't know what an import is referencing or resolves to until we see the full codebase.

ExternalModule

Represents a generic file. Could represent a source file or a non-code file such as a markdown file or image file.

File

Abstract representation of the for loop.
Attributes: code_block: The code block that is executed in each iteration of the loop

ForLoopStatement

Abstract representation of a Function
Attributes: return_type: the return type annotation of the function

Function

Abstract representation of a function invocation, e.g. in Python: ``` def f(): g() # FunctionCall ```

FunctionCall

GenericType

GraphSitterBase

An interface for any code object that has a block of code, e.g. a function, class, etc.

HasBlock

An interface for any node object that has a name

HasName

Abstract representation of the if/elif/else statement block. For example, if there is a code block like: if condition1: block1 elif condition2: block2 else: block3 This class represents the entire block, including the conditions and nested code blocks.
Attributes: condition: The condition expression for the if block. None if the block is an else block. consequence_block: The code block that is executed if the condition is True.

IfBlockStatement

Represents a single symbol being imported.
For example, this is one `Import` in Python (and similar applies to Typescript, etc.): ``` from a.b import c ```
This is two separate `Import` in Python: ``` from a.b import c, d  # one import for each `c` and `d` ``` Attributes: symbol_name: The name of the symbol being imported. For instance import a as b has a symbol_name of a.

Import

Abstract representation of a single import statement that appears in a file. One import statement can import multiple symbols from a single source.
Attributes: imports: A collection of the individual imports this statement represents

ImportStatement

An interface for any node object that can import (or reference) an exportable symbol eg. Class, function, imports, exports, etc.

Importable

A list object. You can use standard operations to operate on this list (IE len, del, append, insert, etc)

List

Represents an group of Expressions, such as List, Dict, Binary Expression, String

MultiExpression

A list containing multi-line objects. Example: A list of function definitions, class definitions You can use standard operations to operate on this list (IE len, del, append, insert, etc)

MultiLineCollection

Editable attribute on any given code objects that has a name. For example, function, classes, global variable, interfaces, attributes, parameters are all composed of a name.

Name

NamedType

NoneType

Number

Abstract representation of a parameter in a Function definition

Parameter

An expression surrounded in a set of parenthesis.
Example: ```typescript (5 + 5) ```

ParenthesizedExpression

A placeholder for a node that does not exist yet. Use bool checks (ie is node) to check if the node exists. You can call edit to replace the placeholder with a real node and it will automatically insert formatting.

Placeholder

Represents a type that has not been implemented yet.

PlaceholderType

Abstract representation of raise statements, e.g. in Python: ```python def f(x): raise ValueError() ```

RaiseStatement

Abstract representation of return statements, e.g. in Python: ```python def f(x): if x: return x**2  # ReturnStatement else: return 1  # ReturnStatement ```

ReturnStatement

Represents a file with source code in the codebase. Enables creating, reading, updating, and deleting files and searching through their contents, etc.

SourceFile

Interface for a single code statement. Enables analysis/editing of more complex code structures Examples include: - a chain of function calls, assignment expression, if/else statement, for/while loop - in context of a block in a class definition, a statement can be a function definition or attribute

Statement

StatementType

GraphSitter representation of String.
Attributes: content: The content of the string expressions: embedded expressions in the string, only applicable for templated or formatted strings

String

StubPlaceholder

Abstract representation for a switch case.
Attributes: code_block: The code block that is executed if the condition is met condition: The condition which triggers this case

SwitchCase

Abstract representation of the switch statement
Attributes: value: The value to switch on

SwitchStatement

Abstract representation of a Symbol in a Codebase. A Symbol is a top-level entity in a file, e.g. a Function, Class, GlobalVariable, etc.

Symbol

These are groups of symbols that form some kind of logical grouping, like a class or module, that do not follow the traditional tree structure.

SymbolGroup

A statement that represents a symbol definition in a codeblock. Examples include: - a function definition, class definition, global variable assignment

SymbolStatement

Represents a usage of a Symbol in a file by another Symbol, e.g.: - A Function calling another Function - A Class inheriting from another Class - A Function using a specific Type as its return type - etc.

SymbolUsage

SymbolUsageType is an enumeration class that defines different types of symbol usage within Python code.
Attributes: SUBCLASS: Used in symbol inheritance. TYPE_ANNOTATION:  Used as a type annotation on a parameter or assignment statement. BODY: Usage within the body of a function/method. DECORATOR: Usage within a decorator. RETURN_TYPE: Used as a return type annotation TYPE_DEFINITION: Used in a type alias. EXPORTED_SYMBOL: Used in an export statement. EXPORTED_WILDCARD: Re-exported by a wildcard export. GENERIC: Used as a type parameter to another type. IMPORTED: Imported with an import statement. DEFAULT_VALUE: Represents a default value in a function/method parameter.

SymbolUsageType

Abstract representation of the try catch statement block.
Attributes: code_block: The code block that may trigger an exception finalizer: The code block executed regardless of if an exception is thrown or not

TryCatchStatement

A tuple object. You can use standard operations to operate on this list (IE len, del, append, insert, etc)

Tuple

Type

TypePlaceholder

An interface for any node object that can be typed, eg. function parameters, variables, etc.
Attributes: type: The type annotation associated with this node

Typeable

Unary expression which is a single operation on a single operand. eg. -5, !true
Attributes: argument: The argument of the unary expression

UnaryExpression

UnionType

Unpacking of an iterable.
Example: ```python [a, *b] ```

Unpack

A reference to an exportable object in a file.
Attributes: match: The exact match of the usage usage_symbol: The symbol this object is used in usage_type: How this symbol was used kind: Where this symbol was used (IE: in a type parameter or in the body of the class, etc)

Usage

UsageType

Editable attribute on any given code objects that has a value. For example, function, classes, global variable, interfaces, expressions, parameters are all composed of a value.

Value

Abstract representation of the while statement block.

WhileStatement

Pythons implementation of the with statement.
Examples: with feature_flag_enabled(...): # code block
with open("file.txt") as file: # code block
with (context_manager1 as var1, context_manager2 as var2, context_manager3 as var3): # code block
Attributes: code_block: (PyCodeBlock) the code block of the with statement clause: the expression of the with clause

Getting Started

Guides

Graph Visualization

How to

GraphSitter Reference

HasValue

Properties

`value`

Methods

`set_value`

Getting Started

Guides

Graph Visualization

How to

GraphSitter Reference

​Properties

​value

​Methods

​set_value

Properties

`value`

Methods

`set_value`