File size: 3,547 Bytes
55dff4e 23a91b1 de5560e 4ed4f59 de5560e |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 |
---
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 |