Datasets:
File size: 5,921 Bytes
f602910 2364569 f602910 |
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 145 146 147 148 149 150 151 152 153 154 155 156 |
import json
import os
import os.path
from typing import List
import datasets
from .common import TrainValidTestChild
from .generated_definitions import DEFINITIONS
_DESCRIPTION = """The dataset we use comes from CodeSearchNet and we filter the dataset as the following:
- Remove examples that codes cannot be parsed into an abstract syntax tree.
- Remove examples that #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.
"""
_CITATION = """@article{husain2019codesearchnet,
title={Codesearchnet challenge: Evaluating the state of semantic code search},
author={Husain, Hamel and Wu, Ho-Hsiang and Gazit, Tiferet and Allamanis, Miltiadis and Brockschmidt, Marc},
journal={arXiv preprint arXiv:1909.09436},
year={2019}
}"""
class CodeXGlueCtCodeToTextBaseImpl(TrainValidTestChild):
_DESCRIPTION = _DESCRIPTION
_CITATION = _CITATION
# For each file, each line in the uncompressed file represents one function.
_FEATURES = {
"id": datasets.Value("int32"), # Index of the sample
"repo": datasets.Value("string"), # repo: the owner/repo
"path": datasets.Value("string"), # path: the full path to the original file
"func_name": datasets.Value("string"), # func_name: the function or method name
"original_string": datasets.Value("string"), # original_string: the raw string before tokenization or parsing
"language": datasets.Value("string"), # language: the programming language name
"code": datasets.Value("string"), # code/function: the part of the original_string that is code
"code_tokens": datasets.features.Sequence(
datasets.Value("string")
), # code_tokens/function_tokens: tokenized version of code
"docstring": datasets.Value(
"string"
), # docstring: the top-level comment or docstring, if it exists in the original string
"docstring_tokens": datasets.features.Sequence(
datasets.Value("string")
), # docstring_tokens: tokenized version of docstring
"sha": datasets.Value("string"), # sha of the file
"url": datasets.Value("string"), # url of the file
}
_SUPERVISED_KEYS = ["docstring", "docstring_tokens"]
def generate_urls(self, split_name, language):
yield "language", f"https://huggingface.co/datasets/code_search_net/resolve/main/data/{language}.zip"
yield "dataset", "dataset.zip"
def get_data_files(self, split_name, file_paths, language):
language_specific_path = file_paths["language"]
final_path = os.path.join(language_specific_path, language, "final")
# Make some cleanup to save space
for path in os.listdir(final_path):
if path.endswith(".pkl"):
os.unlink(path)
data_files = []
for root, dirs, files in os.walk(final_path):
for file in files:
temp = os.path.join(root, file)
if ".jsonl" in temp:
if split_name in temp:
data_files.append(temp)
return data_files
def post_process(self, split_name, language, js):
return js
def _generate_examples(self, split_name, file_paths, language):
import gzip
data_set_path = file_paths["dataset"]
data_files = self.get_data_files(split_name, file_paths, language)
urls = {}
f1_path_parts = [data_set_path, "dataset", language, f"{split_name}.txt"]
if self.SINGLE_LANGUAGE:
del f1_path_parts[2]
f1_path = os.path.join(*f1_path_parts)
with open(f1_path, encoding="utf-8") as f1:
for line in f1:
line = line.strip()
urls[line] = True
idx = 0
for file in data_files:
if ".gz" in file:
f = gzip.open(file)
else:
f = open(file, encoding="utf-8")
for line in f:
line = line.strip()
js = json.loads(line)
if js["url"] in urls:
js["id"] = idx
js = self.post_process(split_name, language, js)
if "partition" in js:
del js["partition"]
yield idx, js
idx += 1
f.close()
class CodeXGlueCtCodeToTextImpl(CodeXGlueCtCodeToTextBaseImpl):
SINGLE_LANGUAGE = False
def generate_urls(self, split_name):
language = self.info["parameters"]["language"]
for e in super().generate_urls(split_name, language):
yield e
def _generate_examples(self, split_name, file_paths):
language = self.info["parameters"]["language"]
for e in super()._generate_examples(split_name, file_paths, language):
yield e
CLASS_MAPPING = {
"CodeXGlueCtCodeToText": CodeXGlueCtCodeToTextImpl,
}
class CodeXGlueCtCodeToText(datasets.GeneratorBasedBuilder):
BUILDER_CONFIG_CLASS = datasets.BuilderConfig
BUILDER_CONFIGS = [
datasets.BuilderConfig(name=name, description=info["description"]) for name, info in DEFINITIONS.items()
]
def _info(self):
name = self.config.name
info = DEFINITIONS[name]
if info["class_name"] in CLASS_MAPPING:
self.child = CLASS_MAPPING[info["class_name"]](info)
else:
raise RuntimeError(f"Unknown python class for dataset configuration {name}")
ret = self.child._info()
return ret
def _split_generators(self, dl_manager: datasets.DownloadManager) -> List[datasets.SplitGenerator]:
return self.child._split_generators(dl_manager=dl_manager)
def _generate_examples(self, split_name, file_paths):
return self.child._generate_examples(split_name, file_paths)
|