Update parquet files

.gitattributes

@@ -1,27 +0,0 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bin.* filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zstandard filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text

README.md

@@ -1,229 +0,0 @@
----
-annotations_creators:
-- found
-language_creators:
-- found
-language:
-- code
-license:
-- c-uda
-multilinguality:
-- monolingual
-size_categories:
-- 1K<n<10K
-- n<1K
-source_datasets:
-- original
-task_categories:
-- text-generation
-- fill-mask
-task_ids:
-- slot-filling
-pretty_name: CodeXGlueCcCodeCompletionLine
-configs:
-- go
-- java
-- javascript
-- php
-- python
-- ruby
-dataset_info:
-- config_name: java
-  features:
-  - name: id
-    dtype: int32
-  - name: input
-    dtype: string
-  - name: gt
-    dtype: string
-  splits:
-  - name: train
-    num_bytes: 5454783
-    num_examples: 3000
-  download_size: 5523586
-  dataset_size: 5454783
-- config_name: python
-  features:
-  - name: id
-    dtype: int32
-  - name: input
-    dtype: string
-  - name: gt
-    dtype: string
-  splits:
-  - name: train
-    num_bytes: 24021562
-    num_examples: 10000
-  download_size: 24266715
-  dataset_size: 24021562
----
-# Dataset Card for "code_x_glue_cc_code_completion_line"
-
-## Table of Contents
-- [Dataset Description](#dataset-description)
-  - [Dataset Summary](#dataset-summary)
-  - [Supported Tasks and Leaderboards](#supported-tasks)
-  - [Languages](#languages)
-- [Dataset Structure](#dataset-structure)
-  - [Data Instances](#data-instances)
-  - [Data Fields](#data-fields)
-  - [Data Splits](#data-splits-sample-size)
-- [Dataset Creation](#dataset-creation)
-  - [Curation Rationale](#curation-rationale)
-  - [Source Data](#source-data)
-  - [Annotations](#annotations)
-  - [Personal and Sensitive Information](#personal-and-sensitive-information)
-- [Considerations for Using the Data](#considerations-for-using-the-data)
-  - [Social Impact of Dataset](#social-impact-of-dataset)
-  - [Discussion of Biases](#discussion-of-biases)
-  - [Other Known Limitations](#other-known-limitations)
-- [Additional Information](#additional-information)
-  - [Dataset Curators](#dataset-curators)
-  - [Licensing Information](#licensing-information)
-  - [Citation Information](#citation-information)
-  - [Contributions](#contributions)
-
-## Dataset Description
-
-- **Homepage:** https://github.com/microsoft/CodeXGLUE/tree/main/Code-Code/CodeCompletion-line
-
-### Dataset Summary
-
-CodeXGLUE CodeCompletion-line dataset, available at https://github.com/microsoft/CodeXGLUE/tree/main/Code-Code/CodeCompletion-line
-
-Complete the unfinished line given previous context. Models are evaluated by exact match and edit similarity.
-We propose line completion task to test model's ability to autocomplete a line. Majority code completion systems behave well in token level completion, but fail in completing an unfinished line like a method call with specific parameters, a function signature, a loop condition, a variable definition and so on. When a software develop finish one or more tokens of the current line, the line level completion model is expected to generate the entire line of syntactically correct code.
-Line level code completion task shares the train/dev dataset with token level completion. After training a model on CodeCompletion-token, you could directly use it to test on line-level completion.
-
-### Supported Tasks and Leaderboards
-
-- `slot-filling`: The dataset can be used to train a model for completing entire code lines.
-
-### Languages
-
-- Java **programming** language
-- Python **programming** language
-
-## Dataset Structure
-
-### Data Instances
-
-#### java
-
-An example of 'train' looks as follows.
-```
-{
-    "gt": "", 
-    "id": 0, 
-    "input": "<s> package org . rubypeople . rdt . internal . ui . rubyeditor ; import java . util . Iterator ; import org . eclipse . core . resources . IMarker ; import org . eclipse . ui . texteditor . MarkerAnnotation ; import org . eclipse . ui . texteditor . MarkerUtilities ; import org . rubypeople . rdt . core . IRubyElement ; import org . rubypeople . rdt . core . IRubyModelMarker ; import org . rubypeople . rdt . core . IRubyScript ; import org . rubypeople . rdt . core . RubyCore ; public class RubyMarkerAnnotation extends MarkerAnnotation implements IRubyAnnotation { public static final String RUBY_MARKER_TYPE_PREFIX = \"\" ; public static final String ERROR_ANNOTATION_TYPE = \"\" ; public static final String WARNING_ANNOTATION_TYPE = \"\" ; public static final String INFO_ANNOTATION_TYPE = \"\" ; public static final String TASK_ANNOTATION_TYPE = \"\" ; private IRubyAnnotation fOverlay ; public RubyMarkerAnnotation ( IMarker marker ) { super ( marker ) ; } public String [ ] getArguments ( ) { return null ; } public int getId ( ) { IMarker marker = getMarker ( ) ; if ( marker == null || ! marker . exists ( ) ) return - 1 ; if ( isProblem ( ) ) return marker . getAttribute ( IRubyModelMarker . ID , - 1 ) ; return - 1 ; } public boolean isProblem ( ) { String type = getType ( ) ; return WARNING_ANNOTATION_TYPE . equals ( type ) || ERROR_ANNOTATION_TYPE . equals"
-}
-```
-
-#### python
-
-An example of 'train' looks as follows.
-```
-{
-    "gt": "", 
-    "id": 0, 
-    "input": "<s> from __future__ import absolute_import <EOL> import weakref <EOL> import operator <EOL> from . compat import threading , itertools_filterfalse <EOL> from . import py2k <EOL> import types <EOL> EMPTY_SET = frozenset ( ) <EOL> class KeyedTuple ( tuple ) : <EOL> def __new__ ( cls , vals , labels = None ) : <EOL> t = tuple . __new__ ( cls , vals ) <EOL> t . _labels = [ ] <EOL> if labels : <EOL> t . __dict__ . update ( zip ( labels , vals ) ) <EOL> t . _labels = labels <EOL> return t <EOL> def keys ( self ) : <EOL> return [ l for l in self . _labels if l is not None ] <EOL> @ property <EOL> def _fields ( self ) : <EOL> return tuple ( self . keys ( ) ) <EOL> def _asdict ( self ) : <EOL> return dict ( ( key , self . __dict__ [ key ] ) for key in self . keys ( ) ) <EOL> class ImmutableContainer ( object ) : <EOL> def _immutable ( self , * arg , ** kw ) : <EOL> raise TypeError ( \"\" % self . __class__ . __name__ ) <EOL> __delitem__ = __setitem__ = __setattr__ = _immutable <EOL> class immutabledict ( ImmutableContainer , dict ) : <EOL> clear = pop = popitem = setdefault = update = ImmutableContainer . _immutable <EOL> def __new__ ( cls , * args ) : <EOL> new = dict . __new__ ( cls ) <EOL> dict . __init__ ( new , * args ) <EOL> return new <EOL> def __init__ ( self , * args ) : <EOL> pass <EOL> def __reduce__ ( self ) : <EOL> return immutabledict , ( dict ( self ) , ) <EOL> def union ( self , d ) : <EOL> if not self : <EOL> return immutabledict ( d ) <EOL> else : <EOL> d2 = immutabledict ( self ) <EOL> dict . update ( d2 , d ) <EOL> return d2 <EOL> def __repr__ ( self ) : <EOL> return \"\" % dict . __repr__ ( self ) <EOL> class Properties ( object ) : <EOL> def __init__ ( self , data ) : <EOL> self . __dict__ [ '_data' ] = data <EOL> def __len__ ( self ) : <EOL> return len ( self . _data ) <EOL> def __iter__ ( self ) : <EOL> return iter ( list ( self . _data . values ( ) ) ) <EOL> def __add__ ( self , other ) : <EOL> return list ( self ) + list ( other ) <EOL> def __setitem__ ( self , key , object ) : <EOL> self . _data [ key ] = object <EOL> def __getitem__ ( self , key ) : <EOL> return self . _data [ key ] <EOL> def __delitem__ ( self , key ) : <EOL> del self . _data [ key ] <EOL> def __setattr__ ( self , key , object ) : <EOL> self . _data [ key ] = object <EOL> def __getstate__ ( self ) : <EOL> return { '_data' : self . __dict__ [ '_data' ] } <EOL> def __setstate__ ( self , state ) : <EOL> self . __dict__ [ '_data' ] = state [ '_data' ] <EOL> def __getattr__ ( self , key ) : <EOL> try : <EOL> return self . _data [ key ] <EOL> except KeyError : <EOL> raise AttributeError ( key ) <EOL> def __contains__ ( self , key ) : <EOL> return key in self . _data <EOL> def as_immutable ( self ) : <EOL> return ImmutableProperties ( self . _data ) <EOL> def update ( self , value ) : <EOL> self . _data . update ( value ) <EOL> def get ( self , key , default = None ) : <EOL> if key in self : <EOL> return self [ key ] <EOL> else : <EOL> return default <EOL> def keys ( self ) : <EOL> return list ( self . _data ) <EOL> def values ( self ) : <EOL> return list ( self . _data . values ( ) ) <EOL> def items ( self ) : <EOL> return list ( self . _data . items ( ) ) <EOL> def has_key ( self , key ) : <EOL> return key in self . _data <EOL> def clear ( self ) : <EOL> self . _data . clear ( ) <EOL> class OrderedProperties ( Properties ) : <EOL> def __init__ ( self ) : <EOL> Properties . __init__ ( self , OrderedDict ( ) ) <EOL> class ImmutableProperties ( ImmutableContainer , Properties ) : <EOL> class OrderedDict ( dict ) : <EOL> def __init__ ( self , ____sequence = None , ** kwargs ) : <EOL> self . _list = [ ] <EOL> if ____sequence is None : <EOL> if kwargs : <EOL> self . update ( ** kwargs ) <EOL> else : <EOL> self . update ( ____sequence , ** kwargs ) <EOL> def clear ( self ) : <EOL> self . _list = [ ] <EOL> dict . clear ( self ) <EOL> def copy ( self ) : <EOL> return self . __copy__ ( ) <EOL> def __copy__ ( self ) : <EOL> return OrderedDict ( self ) <EOL> def sort ( self , * arg , ** kw ) : <EOL> self . _list . sort ( * arg , ** kw ) <EOL> def update ( self , ____sequence = None , ** kwargs ) : <EOL> if ____sequence is not None : <EOL> if hasattr ( ____sequence , 'keys' ) : <EOL> for key in ____sequence . keys ( ) : <EOL> self . __setitem__ ( key , ____sequence [ key ] ) <EOL> else : <EOL> for key , value in ____sequence : <EOL> self [ key ] = value <EOL> if kwargs : <EOL> self . update ( kwargs ) <EOL> def setdefault ( self , key , value ) : <EOL> if key not in self : <EOL> self . __setitem__ ( key , value ) <EOL> return value <EOL> else : <EOL> return self . __getitem__ ( key ) <EOL> def __iter__ ( self ) : <EOL> return iter ( self . _list ) <EOL> def keys ( self ) : <EOL> return list ( self ) <EOL> def values ( self ) : <EOL> return [ self [ key ] for key in self . _list ] <EOL> def items ( self ) : <EOL> return [ ( key , self [ key ] ) for key in self . _list ] <EOL> if py2k : <EOL> def itervalues ( self ) : <EOL> return iter ( self . values ( ) ) <EOL> def iterkeys ( self ) : <EOL> return iter ( self ) <EOL> def iteritems ( self ) : <EOL> return iter ( self . items ( ) ) <EOL> def __setitem__ ( self , key , object ) : <EOL> if key not in self : <EOL> try : <EOL> self . _list . append ( key ) <EOL> except AttributeError : <EOL> self . _list = [ key ] <EOL> dict . __setitem__ ( self , key , object ) <EOL> def __delitem__ ( self , key ) : <EOL> dict . __delitem__ ( self , key ) <EOL> self . _list . remove ( key ) <EOL> def pop ( self , key , * default ) : <EOL> present = key in self <EOL> value = dict . pop ( self , key , * default ) <EOL> if present : <EOL> self . _list . remove ( key ) <EOL> return value <EOL> def popitem ( self ) : <EOL> item = dict . popitem ( self ) <EOL> self . _list . remove ( item [ 0 ] ) <EOL> return item <EOL> class OrderedSet ( set ) : <EOL> def __init__ ( self , d = None ) : <EOL> set . __init__ ( self ) <EOL> self . _list = [ ] <EOL> if d is not None : <EOL>"
-}
-```
-
-### Data Fields
-
-In the following each data field in go is explained for each config. The data fields are the same among all splits.
-
-#### java, python
-
-|field name| type |        description         |
-|----------|------|----------------------------|
-|id        |int32 | Index of the sample        |
-|input     |string| Input code string          |
-|gt        |string| Code string to be predicted|
-
-### Data Splits
-
-| name |train|
-|------|----:|
-|java  | 3000|
-|python|10000|
-
-## Dataset Creation
-
-### Curation Rationale
-
-[More Information Needed]
-
-### Source Data
-
-#### Initial Data Collection and Normalization
-
-[More Information Needed]
-
-#### Who are the source language producers?
-
-[More Information Needed]
-
-### Annotations
-
-#### Annotation process
-
-[More Information Needed]
-
-#### Who are the annotators?
-
-[More Information Needed]
-
-### Personal and Sensitive Information
-
-[More Information Needed]
-
-## Considerations for Using the Data
-
-### Social Impact of Dataset
-
-[More Information Needed]
-
-### Discussion of Biases
-
-[More Information Needed]
-
-### Other Known Limitations
-
-[More Information Needed]
-
-## Additional Information
-
-### Dataset Curators
-
-https://github.com/microsoft, https://github.com/madlag
-
-### Licensing Information
-
-Computational Use of Data Agreement (C-UDA) License.
-
-### Citation Information
-
-```
-@article{raychev2016probabilistic,
-  title={Probabilistic Model for Code with Decision Trees},
-  author={Raychev, Veselin and Bielik, Pavol and Vechev, Martin},
-  journal={ACM SIGPLAN Notices},
-  pages={731--747},
-  year={2016},
-  publisher={ACM New York, NY, USA}
-}
-@inproceedings{allamanis2013mining,
-  title={Mining Source Code Repositories at Massive Scale using Language Modeling},
-  author={Allamanis, Miltiadis and Sutton, Charles},
-  booktitle={2013 10th Working Conference on Mining Software Repositories (MSR)},
-  pages={207--216},
-  year={2013},
-  organization={IEEE}
-}
-```
-
-### Contributions
-
-Thanks to @madlag (and partly also @ncoop57) for adding this dataset.

code_x_glue_cc_code_completion_line.py

@@ -1,80 +0,0 @@
-import json
-from typing import List
-
-import datasets
-
-from .common import Child
-from .generated_definitions import DEFINITIONS
-
-
-_DESCRIPTION = """Complete the unfinished line given previous context. Models are evaluated by exact match and edit similarity.
-We propose line completion task to test model's ability to autocomplete a line. Majority code completion systems behave well in token level completion, but fail in completing an unfinished line like a method call with specific parameters, a function signature, a loop condition, a variable definition and so on. When a software develop finish one or more tokens of the current line, the line level completion model is expected to generate the entire line of syntactically correct code.
-Line level code completion task shares the train/dev dataset with token level completion. After training a model on CodeCompletion-token, you could directly use it to test on line-level completion."""
-
-_CITATION = """@article{raychev2016probabilistic,
-title={Probabilistic Model for Code with Decision Trees},
-author={Raychev, Veselin and Bielik, Pavol and Vechev, Martin},
-journal={ACM SIGPLAN Notices},
-pages={731--747},
-year={2016},
-publisher={ACM New York, NY, USA}
-}
-@inproceedings{allamanis2013mining,
-title={Mining Source Code Repositories at Massive Scale using Language Modeling},
-author={Allamanis, Miltiadis and Sutton, Charles},
-booktitle={2013 10th Working Conference on Mining Software Repositories (MSR)},
-pages={207--216},
-year={2013},
-organization={IEEE}
-}"""
-
-
-class CodeXGlueCcCodeCompletionLineImpl(Child):
-    _DESCRIPTION = _DESCRIPTION
-    _CITATION = _CITATION
-
-    _FEATURES = {
-        "id": datasets.Value("int32"),  # Index of the sample
-        "input": datasets.Value("string"),  # Input code string
-        "gt": datasets.Value("string"),  # Code string to be predicted
-    }
-
-    _SUPERVISED_KEYS = ["gt"]
-
-    def generate_urls(self, split_name):
-        yield "data", "test.json"
-
-    def _generate_examples(self, split_name, file_paths):
-        with open(file_paths["data"], encoding="utf-8") as f:
-            for idx, line in enumerate(f):
-                entry = json.loads(line)
-                entry["id"] = idx
-                yield idx, entry
-
-
-CLASS_MAPPING = {
-    "CodeXGlueCcCodeCompletionLine": CodeXGlueCcCodeCompletionLineImpl,
-}
-
-
-class CodeXGlueCcCodeCompletionLine(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)

common.py

@@ -1,75 +0,0 @@
-from typing import List
-
-import datasets
-
-
-# Citation, taken from https://github.com/microsoft/CodeXGLUE
-_DEFAULT_CITATION = """@article{CodeXGLUE,
-         title={CodeXGLUE: A Benchmark Dataset and Open Challenge for Code Intelligence},
-         year={2020},}"""
-
-
-class Child:
-    _DESCRIPTION = None
-    _FEATURES = None
-    _CITATION = None
-    SPLITS = {"train": datasets.Split.TRAIN}
-    _SUPERVISED_KEYS = None
-
-    def __init__(self, info):
-        self.info = info
-
-    def homepage(self):
-        return self.info["project_url"]
-
-    def _info(self):
-        # This is the description that will appear on the datasets page.
-        return datasets.DatasetInfo(
-            description=self.info["description"] + "\n\n" + self._DESCRIPTION,
-            features=datasets.Features(self._FEATURES),
-            homepage=self.homepage(),
-            citation=self._CITATION or _DEFAULT_CITATION,
-            supervised_keys=self._SUPERVISED_KEYS,
-        )
-
-    def _split_generators(self, dl_manager: datasets.DownloadManager) -> List[datasets.SplitGenerator]:
-        SPLITS = self.SPLITS
-        _URL = self.info["raw_url"]
-        urls_to_download = {}
-        for split in SPLITS:
-            if split not in urls_to_download:
-                urls_to_download[split] = {}
-
-            for key, url in self.generate_urls(split):
-                if not url.startswith("http"):
-                    url = _URL + "/" + url
-                urls_to_download[split][key] = url
-
-        downloaded_files = {}
-        for k, v in urls_to_download.items():
-            downloaded_files[k] = dl_manager.download_and_extract(v)
-
-        return [
-            datasets.SplitGenerator(
-                name=SPLITS[k],
-                gen_kwargs={"split_name": k, "file_paths": downloaded_files[k]},
-            )
-            for k in SPLITS
-        ]
-
-    def check_empty(self, entries):
-        all_empty = all([v == "" for v in entries.values()])
-        all_non_empty = all([v != "" for v in entries.values()])
-
-        if not all_non_empty and not all_empty:
-            raise RuntimeError("Parallel data files should have the same number of lines.")
-
-        return all_empty
-
-
-class TrainValidTestChild(Child):
-    SPLITS = {
-        "train": datasets.Split.TRAIN,
-        "valid": datasets.Split.VALIDATION,
-        "test": datasets.Split.TEST,
-    }

dataset_infos.json

@@ -1 +0,0 @@
-{"java": {"description": "CodeXGLUE CodeCompletion-line dataset, available at https://github.com/microsoft/CodeXGLUE/tree/main/Code-Code/CodeCompletion-line\n\nComplete the unfinished line given previous context. Models are evaluated by exact match and edit similarity.\nWe propose line completion task to test model's ability to autocomplete a line. Majority code completion systems behave well in token level completion, but fail in completing an unfinished line like a method call with specific parameters, a function signature, a loop condition, a variable definition and so on. When a software develop finish one or more tokens of the current line, the line level completion model is expected to generate the entire line of syntactically correct code.\nLine level code completion task shares the train/dev dataset with token level completion. After training a model on CodeCompletion-token, you could directly use it to test on line-level completion.", "citation": "@article{raychev2016probabilistic,\ntitle={Probabilistic Model for Code with Decision Trees},\nauthor={Raychev, Veselin and Bielik, Pavol and Vechev, Martin},\njournal={ACM SIGPLAN Notices},\npages={731--747},\nyear={2016},\npublisher={ACM New York, NY, USA}\n}\n@inproceedings{allamanis2013mining,\ntitle={Mining Source Code Repositories at Massive Scale using Language Modeling},\nauthor={Allamanis, Miltiadis and Sutton, Charles},\nbooktitle={2013 10th Working Conference on Mining Software Repositories (MSR)},\npages={207--216},\nyear={2013},\norganization={IEEE}\n}", "homepage": "https://github.com/madlag/CodeXGLUE/tree/main/Code-Code/CodeCompletion-line", "license": "", "features": {"id": {"dtype": "int32", "id": null, "_type": "Value"}, "input": {"dtype": "string", "id": null, "_type": "Value"}, "gt": {"dtype": "string", "id": null, "_type": "Value"}}, "post_processed": null, "supervised_keys": {"input": "gt", "output": ""}, "task_templates": null, "builder_name": "code_x_glue_cc_code_completion_line", "config_name": "java", "version": {"version_str": "0.0.0", "description": null, "major": 0, "minor": 0, "patch": 0}, "splits": {"train": {"name": "train", "num_bytes": 5454783, "num_examples": 3000, "dataset_name": "code_x_glue_cc_code_completion_line"}}, "download_checksums": {"https://raw.githubusercontent.com/madlag/CodeXGLUE/main/Code-Code/CodeCompletion-line/dataset/javaCorpus/line_completion/test.json": {"num_bytes": 5523586, "checksum": "188e4ae5a8751871adb50fe48e8f1d50c6e2dca778fe53ff03c13b5a63f132af"}}, "download_size": 5523586, "post_processing_size": null, "dataset_size": 5454783, "size_in_bytes": 10978369}, "python": {"description": "CodeXGLUE CodeCompletion-line dataset, available at https://github.com/microsoft/CodeXGLUE/tree/main/Code-Code/CodeCompletion-line\n\nComplete the unfinished line given previous context. Models are evaluated by exact match and edit similarity.\nWe propose line completion task to test model's ability to autocomplete a line. Majority code completion systems behave well in token level completion, but fail in completing an unfinished line like a method call with specific parameters, a function signature, a loop condition, a variable definition and so on. When a software develop finish one or more tokens of the current line, the line level completion model is expected to generate the entire line of syntactically correct code.\nLine level code completion task shares the train/dev dataset with token level completion. After training a model on CodeCompletion-token, you could directly use it to test on line-level completion.", "citation": "@article{raychev2016probabilistic,\ntitle={Probabilistic Model for Code with Decision Trees},\nauthor={Raychev, Veselin and Bielik, Pavol and Vechev, Martin},\njournal={ACM SIGPLAN Notices},\npages={731--747},\nyear={2016},\npublisher={ACM New York, NY, USA}\n}\n@inproceedings{allamanis2013mining,\ntitle={Mining Source Code Repositories at Massive Scale using Language Modeling},\nauthor={Allamanis, Miltiadis and Sutton, Charles},\nbooktitle={2013 10th Working Conference on Mining Software Repositories (MSR)},\npages={207--216},\nyear={2013},\norganization={IEEE}\n}", "homepage": "https://github.com/madlag/CodeXGLUE/tree/main/Code-Code/CodeCompletion-line", "license": "", "features": {"id": {"dtype": "int32", "id": null, "_type": "Value"}, "input": {"dtype": "string", "id": null, "_type": "Value"}, "gt": {"dtype": "string", "id": null, "_type": "Value"}}, "post_processed": null, "supervised_keys": {"input": "gt", "output": ""}, "task_templates": null, "builder_name": "code_x_glue_cc_code_completion_line", "config_name": "python", "version": {"version_str": "0.0.0", "description": null, "major": 0, "minor": 0, "patch": 0}, "splits": {"train": {"name": "train", "num_bytes": 24021562, "num_examples": 10000, "dataset_name": "code_x_glue_cc_code_completion_line"}}, "download_checksums": {"https://raw.githubusercontent.com/madlag/CodeXGLUE/main/Code-Code/CodeCompletion-line/dataset/py150/line_completion/test.json": {"num_bytes": 24266715, "checksum": "39cb31c2263b25506d94384e9ace954cf3ec8d1fd7a4b7f62beb0c3846e5555c"}}, "download_size": 24266715, "post_processing_size": null, "dataset_size": 24021562, "size_in_bytes": 48288277}}

generated_definitions.py

@@ -1,24 +0,0 @@
-DEFINITIONS = {
-    "java": {
-        "class_name": "CodeXGlueCcCodeCompletionLine",
-        "dataset_type": "Code-Code",
-        "description": "CodeXGLUE CodeCompletion-line dataset, available at https://github.com/microsoft/CodeXGLUE/tree/main/Code-Code/CodeCompletion-line",
-        "dir_name": "CodeCompletion-line",
-        "name": "java",
-        "parameters": {"language": "java", "original_language_name": "javaCorpus"},
-        "project_url": "https://github.com/madlag/CodeXGLUE/tree/main/Code-Code/CodeCompletion-line",
-        "raw_url": "https://raw.githubusercontent.com/madlag/CodeXGLUE/main/Code-Code/CodeCompletion-line/dataset/javaCorpus/line_completion",
-        "sizes": {"train": 3000},
-    },
-    "python": {
-        "class_name": "CodeXGlueCcCodeCompletionLine",
-        "dataset_type": "Code-Code",
-        "description": "CodeXGLUE CodeCompletion-line dataset, available at https://github.com/microsoft/CodeXGLUE/tree/main/Code-Code/CodeCompletion-line",
-        "dir_name": "CodeCompletion-line",
-        "name": "python",
-        "parameters": {"language": "python", "original_language_name": "py150"},
-        "project_url": "https://github.com/madlag/CodeXGLUE/tree/main/Code-Code/CodeCompletion-line",
-        "raw_url": "https://raw.githubusercontent.com/madlag/CodeXGLUE/main/Code-Code/CodeCompletion-line/dataset/py150/line_completion",
-        "sizes": {"train": 10000},
-    },
-}

java/code_x_glue_cc_code_completion_line-train.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0ddf258b914ada27cf327b8bdd3e440c0f641aaa8316975282afd9d6149d5d65
+size 1696678

python/code_x_glue_cc_code_completion_line-train.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5565acfa660afc8f78f799b15b4345988c6caeebe241e155f01e573ff65f3d6f
+size 8140669