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

# Overview

This dataset contains 18,219 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. Initial raw dataset count was 25,480 down to 18,219 after preprocessing.

# 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>,
  <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>,
  <line_number> : <The line number of the function, method, or class within the file>,
  <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 following preprocessing steps were applied:

## Text Cleaning

- Removed comments
- Filtering unusual/control characters
- Removed trailing whitespaces
- Converts all whitespace into a single spaces
- Removed tags from docstrings

## AST Cleaning

- Removed noise using a custom blacklist
- Removed abnormally long nodes (>100)
- Stripped blank AST entries
- Ensured ASTs start with the proper root nodes (FunctionDef or ClassDef)

## Language Filtering

- Removed non-English documentations
- Keeps an item if detection fails

## Similarity Filtering

- Removed entries where similarity exceeds threshold (0.7)

# Split

- Dataset was split into a 70/15/15 ratio