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;
}

Codegen

Enum representing the different types of statements that can be parsed.

StatementType

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

Directory representation for codebase. GraphSitter abstraction of a file directory that can be used to look for files and symbols within a specific directory.

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 eg. Class, class name,  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

FlagKwargs

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

Abstract representation of the generic types of the programming langauge.

GenericType

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

An interface for any node object that has a value.

HasValue

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. All nodes that are on the graph must inherit from here
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

Destination of the message
Attributes: CODEGEN: Rendered in the diff preview GITHUB: Posted as a comment on the PR SLACK: Sent over slack

MessageType

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

An abstract representation of a named type.

NamedType

NoneType

Number

An abstract representation of a key, value pair belonging to a `Dict`

Pair

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

Span

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

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

A placeholder for a stub that does not exist. Can be populated using the `edit` method.

StubPlaceholder

Indexing onto an object (Aka using brackets on an object)
Examples: A[]

SubscriptExpression

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.
Attributes: parent_statement: Returns the parent statement that contains this expression

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

Any ternary expression in the code where a condition will determine branched execution.

TernaryExpression

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

Abstract representation of a type Used to store the types of variables, parameters, or return values in functions, classes, etc.

Type

A placeholder for a Type node that does not exist. Can be populated using the `edit` method.

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

An abstract representation of a union type. For example `str | None` or `string | number`.

UnionType

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

Unpack

An abstract representation of an expression that can be unwrapped. Expressions that can be unwrapped include binary expressions and ternary expressions.

Unwrappable

An interface for any node object that can be referenced by another node.

Getting Started

Guides

Graph Visualization

How to

GraphSitter Reference

StatementType