README.md

---
task_categories:
- summarization
- text-generation
language:
- en
tags:
- code
size_categories:
- 10K<n<100K
---

# Overview

This dataset contains 25,000+ rows of code-docstring-ast data along with additional metadata. Data was gathered from various Python libraries and frameworks and their
publicly available GitHub repos. This dataset was created for the purpose of training the [CodeT5+](https://arxiv.org/abs/2305.07922) transformer on AST-enhanced code-to-doc tasks.

# Sources

The dataset was gathered from various GitHub repos sampled from [this repo by Vinta.](https://github.com/vinta/awesome-python)

The 26 repos are:
- matplotlib
- pytorch
- cryptography
- django
- prospector
- scikit-learn
- pandas
- numpy
- uvicorn
- feincms
- algorithms
- scrapy
- authlib
- seaborn
- coconut
- tensorflow
- flexx
- salmon
- mongo-python-driver
- virtualenv
- sphinx
- schema
- kornia
- scipy
- cherrypy
- pygame

Sampling was at random; I simply browsed through each category from Vinta's list and chose one from a random interesting category. 

# Dataset Instance

An instance of the dataset is as follows:

```
{
  <library> : <The library from which the source code came from>,
  <name> : <The name of the function/class/method>,
  <source_code> : <The raw source code itself stripped of its docstrings and comments>,
  <docstring> : <The corresponding docstring of the code>,
  <type> : <Whether it's a function, method, or class>,
  <file_path> : <The relative path of the file containing the function>,
  <ast_sequence> : <The ast sequence of the raw source code. Scroll down for more info about this>
}
```

# The AST Sequence

A function recursively converts the AST tree into a linear sequence. It uses depth markers (├1>, └2>, etc.) to show parent-child relationships. It also adds node identifiers by pairing
each node type with a meaningful identifier. Furthermore, pruning is also applied to irrelevant and shallow identifiers to denoise the dataset. 

Here's an example of how the AST sequence is generated:

Example Code
```
def calculate_area(radius):
    """
    Calculate the area of a circle.
    
    Parameters:
        radius (float): The radius of the circle
        
    Returns:
        float: The area of the circle
    """
    PI = 3.14159
    area = PI * radius * radius
    return area
```

Resulting AST Sequence
```
FunctionDef:calculate_area
├1> args:[radius]
├1> Assign:PI
│ └2> Constant:
├1> Assign:area
│ └2> BinOp:
│   ├3> BinOp:
│   │ ├4> Name:PI
│   │ └4> Name:radius
│   └3> Name:radius
└1> Return:
  └2> Name:area
```

1. The code is parsed via Python's `ast` module
2. A method traverses this tree and linearizes the sequence
3. Each node is then converted to a string with type-identifier keys
4. Structural relationships are preserved using the depth markers
5. Denoising of irrelevant and shallow nodes are applied

# Preprocessing

The dataset generally follows [CodeBERT's code2nl](https://github.com/microsoft/CodeBERT/tree/master/CodeBERT/code2nl) dataset cleaning standards which are as follows:

- Removed comments from the code
- Removed examples where code cannot be parsed into an AST
- Remove examples that codes cannot be parsed into an abstract syntax tree.
- Remove examples where the number of tokens of documents is < 3 or >256
- Remove examples that documents contain special tokens (e.g. <img ...> or https:...)
- Remove examples that documents are not English

Furthermore, the following cleaning steps specific to this dataset were applied:
- Docstrings from source codes was stripped
- Standard text cleaning procedures (normalized whitespaces and special characters)
- Removed abnormally long AST sequences (>100)
- Structural pruning of the AST sequence (removing irrelevant or shallow identifiers/nodes)

# Final Statistics

## Final Count : 25,489

## Average Docstring Length : 51

## Average Source Code Length : 591

## Average AST Sequence Length : 72

## Type Distribution

**Methods: 13,149(52.1%)**

**Functions: 8,671(34.3%)**

**Classes: 3,444(13.6%)**

## Major Contributors

**TensorFlow (5,455)**

**PyTorch (5,448)**

**Matplotlib (2,190)**

**Django (2,138)**

**Scipy (1,715)**

# NOTE

This dataset is *imperfect*. Due to the varying degrees of code complexity, some fields are inaccurate representations.