/* 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

SymbolUsageType is an enumeration class that defines different types of symbol usage within Python code.

UsageKind

Codegen

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

Code Agent

Building a Code Agent with LangChain

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

Mining Data

Mining Training Data for LLMs

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

Visualization

Codebase Visualization

API Migrations

Migrating APIs

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

Learn how to use symbol flags for debugging, tracking changes, and marking code for review

Flagging Symbols

LLM Integration

Calling Out to LLMs

Semantic Code Search

Reducing Conditions

API Reference

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

All Posts

Giving agents a more expressive way to act

Act via Code

Identifying and visualizing import loops in the PyTorch codebase

Import Loops in PyTorch

Codegen Updates

Blog

Changelog

GitHub

Represents an argument passed into a FunctionCall.

Argument

Represents an assignment for a single variable within an assignment statement. 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 boolean operations (and, or) etc.

BinaryExpression

BlockStatement

Boolean

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

Callable

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.

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.

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.

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

API Reference

​Attributes

​BODY

​DECORATOR

​DEFAULT_VALUE

​EXPORTED_SYMBOL

​EXPORTED_WILDCARD

​GENERIC

​IMPORTED

​IMPORTED_WILDCARD

​RETURN_TYPE

​SUBCLASS

​TYPED_PARAMETER

​TYPE_ANNOTATION

​TYPE_DEFINITION