/* Override font variables */
:root {
	--font-jetbrains-mono: Menlo, Monaco, "Courier New", monospace !important;
	/* --font-jetbrains-mono: Consolas, Monaco, "Andale Mono", "Ubuntu Mono", monospace !important; */
}

pre[class*="language-"],
code[class*="language-"],
pre,
code,
kbd,
samp {
	font-family: Menlo, Monaco, "Andale Mono", "Ubuntu Mono", monospace !important;
	--font-jetbrains-mono: Consolas, Monaco, "Andale Mono", "Ubuntu Mono",
		monospace !important;
	font-weight: 500 !important;
}

pre[class*="language-"] {
	font-family: Menlo, Monaco, "Andale Mono", "Ubuntu Mono", monospace !important;
	font-weight: 500 !important;
	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: #362d45;
}
pre[class*="language-"]::selection,
pre[class*="language-"] ::selection,
code[class*="language-"]::selection,
code[class*="language-"] ::selection {
	text-shadow: none;
	background: #362d45;
}
@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;
}

.language-python .language-bash {
	background-color: #15141b !important;
	font-family: Consolas, Monaco, "Andale Mono", "Ubuntu Mono", monospace !important;
	font-weight: 600 !important;
	font-size: 16px !important;
}

.dark\:bg-codeblock:is(.dark *) {
	background-color: #15141b !important;
}

.dark\:ring-gray-800\/50:is(.dark *) {
	--tw-ring-color: #15141b !important;
}

.codeblock-dark {
	background-color: #15141b !important;
	color: #edecee !important;
	font-size: 20px !important;
}

.dark .prose {
	color: #edecee !important;
	font-size: 16px !important;
}

/* single backticks are orange */
.dark .prose p code {
	color: #ffca85 !important;
}
.dark .prose p code .comment {
	color: #6d6d6d !important;
}
.dark .prose ul code {
	color: #ffca85 !important;
}
.dark .prose ul code .comment {
	color: #6d6d6d !important;
}

/* Comments in code blocks should be gray */
.token.comment {
	color: #6d6d6d !important;
}
pre .token.comment {
	color: #6d6d6d !important;
}
code .token.comment {
	color: #6d6d6d !important;
}

/* links are purple */
.prose a {
	color: #a277ff !important;
}

.token.tag {
	color: #a277ff !important;
}
.token.variable {
	color: #a277ff !important;
}
.token.keyword {
	color: #a277ff !important;
}
.token.operator {
	color: #a277ff !important;
}
.token.attr-name {
	color: #a277ff !important;
}
.token.punctuation {
	color: #a277ff !important;
}
.token.constant {
	color: #a277ff !important;
}
.token.string {
	color: #61ffca !important;
}
.token.inserted {
	color: #61ffca !important;
}
.token.changed {
	color: #ffca85 !important;
}
.token.function {
	color: #ffca85 !important;
}
.token.deleted {
	color: #ff6767 !important;
}
.token.builtin {
	color: #ffca85 !important;
}
.token.property {
	color: #ffca85 !important;
}
.token.class-name {
	color: #82e2ff !important;
}
.token.important,
.token.bold {
	font-weight: bold !important;
}
.token.italic {
	font-style: italic !important;
}

.language-bash {
	color: #ffca85 !important;
}

.language-bash .token {
	color: #ffca85 !important;
	font-weight: 700 !important;
}


.dark .bg-codeblock {
	background-color: #15141b !important;
}


BODY

DECORATOR

DEFAULT_VALUE

EXPORTED_SYMBOL

EXPORTED_WILDCARD

GENERIC

IMPORTED

IMPORTED_WILDCARD

RETURN_TYPE

SUBCLASS

TYPED_PARAMETER

TYPE_ANNOTATION

TYPE_DEFINITION

Attributes

Codegen

API Reference

Blog

Changelog

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.

UsageKind

Overview

Getting Started

Installation

IDE Usage

Using Codegen in Your IDE

AI Integration

Working with AI

How it Works

How Codegen's codebase graph works

Under the Hood

Principles

Guiding Principles

Community

Community & Contributing

About Us

Codegen, Inc.

Frequently Asked Questions

At a Glance

Learn by Example

API Migrations

Migrating APIs

This guide will show you how to create codebase visualizations using [codegen](/introduction/overview).

Visualization

Codebase Visualization

Learn how to generate training data for large language models using Codegen

Mining Data

Mining Training Data for LLMs

Organization

Organizing Your Codebase

Modularity

Improving Code Modularity

Feature Flags

Managing Feature Flags

Dead Code

Deleting Dead Code

Type Coverage

Increasing Type Coverage

Safely and systematically manage exports in your TypeScript codebase

Export Management

Managing TypeScript Exports

Convert default exports to named exports in your TypeScript codebase

Default Export Conversion

Converting Default Exports

Documentation

Creating Documentation

Modernize your React codebase with Codegen

React Modernization

Learn how to migrate unittest test suites to pytest using Codegen

Unittest to Pytest

Migrating from unittest to pytest

Learn how to migrate SQLAlchemy 1.6 codebases to 2.0 using Codegen

SQLAlchemy 1.6 to 2.0

Migrating from SQLAlchemy 1.6 to 2.0

Learn how to identify and fix problematic import loops using Codegen.

Fixing Import Loops

Learn how to migrate Python 2 codebases to Python 3 using Codegen

Python 2 to 3

Migrating from Python 2 to Python 3

Flask to FastAPI

Migrating from Flask to FastAPI

Building with Codegen

Parsing Codebases

Reusable Codemods

.codegen Directory

The .codegen Directory

@codegen.function

Function Decorator

Language Support

Commit and Reset

Git Operations

Files & Directories

Files and Directories

Editables

The Editable API

Symbols

The Symbol API

Classes

The Class API

Imports

The Import API

Exports

The Export API

Inheritable Behaviors

Statements and Code Blocks

Dependencies and Usages

Function Calls

Function Calls and Call Sites

Variable Assignments

Local Variables

Comments & Docstrings

Comments and Docstrings

External Modules

Type Annotations

Working with Type Annotations

Moving Symbols

Collections

Call Graph

Traversing the Call Graph

React and JSX

LLM Integration

Calling Out to LLMs

Reducing Conditions

Codegen CLI

init

Init Command

Open a Jupyter notebook with the current codebase loaded

notebook

Notebook Command

create

Create Command

Run Command

reset

Reset Command

expert

Expert Command

Codegen Updates

All Posts

Giving agents a more expressive way to act

Act via Code

Represents an argument passed into a FunctionCall.

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

A class that represents an assignment statement in a codebase, such as `x = 1`, `a, b = 1, 2`, `const {a: b} = myFunc(),`, etc.
This includes potentially multiple Assignments via `statement.assignments`, which represent each assignment of a value to a variable within this statement.
For example, assigning to a destructured object, or assigning multiple values to multiple variables in a single statement.

AssignmentStatement

Abstract representation of an attribute on a class definition.

Attribute

An awaited expression, only found in asynchronous contexts, e.g. await(foo(bar))

AwaitExpression

Represents binary expressions, e.g. all of +,-,*,/, as well as booleaneoperations (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

This class provides the main entrypoint for most programs to analyzing and manipulating codebases.
It provides a high-level interface to interact with the codebase graph, and provides methods to access and manipulate files, directories, symbols, and other entities in the codebase.

Codebase

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

Represents a dict (object) literal the source code.
You can use standard Python operations to operate on this dict (i.e. `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

Kwargs for the flag_instance method of the Codebase class.
Attributes: message: The message to be displayed in the diff preview or posted as a comment on the PR. message_type: Where the message will be sent (CODEGEN, GITHUB, SLACK) message_recipient: The recipient of the message.

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

API Reference

​Attributes

​BODY

​DECORATOR

​DEFAULT_VALUE

​EXPORTED_SYMBOL

​EXPORTED_WILDCARD

​GENERIC

​IMPORTED

​IMPORTED_WILDCARD

​RETURN_TYPE

​SUBCLASS

​TYPED_PARAMETER

​TYPE_ANNOTATION

​TYPE_DEFINITION