delete file

.gitignore

@@ -1,2 +1,3 @@
 delete_tasks.sh
-renumber_tasks.py
+renumber_tasks.py
+test_all_tasks.py

test_task_all.py

@@ -1,336 +0,0 @@
-#!/usr/bin/env python3
-from iso639 import languages
-import json
-from os import listdir
-from os.path import isfile, join
-import argparse
-import re
-import numpy as np
-
-# get the range of task you want to test, if specified in the command line
-parser = argparse.ArgumentParser()
-parser.add_argument("--task",
-                    nargs=2,
-                    type=int,
-                    required=False,
-                    help="The range of task you want to parse")
-
-args = parser.parse_args()
-if args.task:
-    begin_task_number, end_task_number = args.task[0], args.task[1]
-    assert begin_task_number > 0, "begin task must be greater than 0"
-    assert end_task_number > begin_task_number, "please specify a range of task you would like to test; i.e. the end task number must be greater than beginning task number"
-
-# make sure that there is no json file in the root directory
-root_files = [f for f in listdir('.') if isfile(join('.', f))]
-for f in root_files:
-    assert '.json' not in f, 'looks like there is a JSON file in the main directory???'
-
-# read all the tasks and make sure that they're following the right pattern
-tasks_path = 'tasks/'
-# tasks_path = 'tasks_special_token/'
-
-expected_keys = [
-    "Definition",
-    "Input_language",
-    "Output_language",
-    "Positive Examples",
-    "Negative Examples",
-    "Instances",
-    "Contributors",
-    "Categories",
-    "Domains",
-    "Source",
-    "URL",
-    "Reasoning"
-]
-
-language_names = [
-    x.name.replace('(individual language)', '').replace(" languages", "").strip()
-    for x in list(languages)
-]
-
-
-def assert_language_name(name):
-    assert name in language_names, f"Did not find `{name}` among iso639 language names: {language_names}"
-
-
-def extract_categories(string):
-    """
-    Get all the characters between ` and `
-    """
-    return set(re.findall(r'`(.*?)`', string))
-
-
-def dict_raise_on_duplicates(ordered_pairs):
-    """Reject duplicate keys."""
-    d = {}
-    for k, v in ordered_pairs:
-        if k in d:
-            raise ValueError("duplicate key: %r" % (k,))
-        else:
-            d[k] = v
-    return d
-
-def atoi(text):
-    return int(text) if text.isdigit() else text
-
-def natural_keys(text):
-    '''
-    alist.sort(key=natural_keys) sorts in human order
-    '''
-    return [ atoi(c) for c in re.split(r'(\d+)', text) ]
-
-
-with open("tasks/README.md", 'r') as readmef:
-    task_readme_content = " ".join(readmef.readlines())
-with open("doc/task-hierarchy.md", 'r') as readmef:
-    hierarchy_content_lines = readmef.readlines()
-    hierarchy_content = " ".join(hierarchy_content_lines)
-    all_categories = extract_categories(hierarchy_content)
-
-# make sure there are no repeated lines in the task file
-task_readme_lines = [x for x in task_readme_content.split("\n") if len(x) > 5]
-if len(set(task_readme_lines)) != len(task_readme_lines):
-    diff = "\n --> ".join([x for x in task_readme_lines if task_readme_lines.count(x) > 1])
-    assert False, f'looks like there are repeated lines in the task readme file?? \n {diff}'
-
-# make sure that the lines are sorted
-task_numbers = [int(line.replace("`task", "").split("_")[0]) for line in task_readme_lines if "`task" in line]
-for i in range(0, len(task_numbers) - 1):
-    num1 = task_numbers[i]
-    num2 = task_numbers[i + 1]
-    assert num1 <= num2, f"ERROR: looks like `{num1}` appears before `{num2}`."
-
-files = [f for f in listdir(tasks_path) if isfile(join(tasks_path, f))]
-files.sort(key=natural_keys)
-
-# make sure anything that gets mentioned in the readme, correspond to an actual file
-task_names = [line.split("`")[1] for line in task_readme_lines if '`' in line]
-for name in task_names:
-    file_name = name + ".json"
-    # pqz
-    # assert file_name in files, f" Did not find `{file_name}` among {files}"
-
-# test every file (README is skipped)
-if not args.task:
-    begin_task_number, end_task_number = 1, len(files)
-
-# TODO: over time, we need to fix the skew of the following tasks
-skew_exclusion = [
-    "150"
-]
-
-contributor_stats = {}
-categories_stats = {}
-reasoning_stats = {}
-domain_stats = {}
-tasks_count = 0
-number_of_instances = 0
-for file in files[begin_task_number:end_task_number + 1]:
-    if ".json" in file:
-        print(f" --> testing file: {file}")
-        assert '.json' in file, 'the file does not seem to have a .json in it: ' + file
-        file_path = tasks_path + file
-        with open(file_path, 'r') as f:
-            try:
-                data = json.load(f)
-            except:
-                with open(file_path, 'r', encoding='utf-8') as f:
-                    data = json.load(f, object_pairs_hook=dict_raise_on_duplicates)
-            for key in expected_keys:
-                assert key in data, f'did not find the key: {key}'
-
-
-            assert len(data['Instances']) > 25, f"there must be at least 25 instances; " \
-                                                f"currently you have {len(data['Instances'])} instances"
-            # pqz
-            # assert len(data['Instances']) <= 6500, f"there must be at most 6.5k instances; " \
-                                                #    f"currently you have {len(data['Instances'])} instances"
-
-            assert type(data['Definition']) == list, f'Definition must be a list of strings.'
-            assert type(data['Source']) == list, f'Sources must be a list.'
-            assert type(data['URL']) == list, f'URL must be a list.'
-            assert type(data['Contributors']) == list, f'Contributors must be a list.'
-            assert type(data['Categories']) == list, f'Categories must be a list.'
-            assert type(data['Reasoning']) == list, f'Reasoning must be a list.'
-            assert type(data['Domains']) == list, f'Domains must be a list.'
-            
-            number_of_instances = number_of_instances + len(data['Instances'])
-            for c in data['Categories']:
-                assert c in all_categories, f'Did not find category `{c}`'
-                if c not in categories_stats:
-                    categories_stats[c] = 0
-                categories_stats[c] += 1
-
-            for d in data['Domains']:
-                assert d in hierarchy_content, f'Did not find domain `{d}`'
-                if d not in domain_stats:
-                    domain_stats[d] = 0
-                domain_stats[d] += 1
-
-            for r in data['Reasoning']:
-                assert r in hierarchy_content, f'Did not find reasoning `{r}`'
-                if r not in reasoning_stats:
-                    reasoning_stats[r] = 0
-                reasoning_stats[r] += 1
-
-            for d in data['Definition']:
-                assert type(d) == str, f'Each definition must be a string.'
-                assert all((lan in d) for lan in data['Input_language'] if
-                       lan != 'English'), f'Definition must contain non-English tasks language.'
-            assert type(data['Input_language']) == list, f'Input_language must be a list of strings.'
-            assert type(data['Output_language']) == list, f'Output_language must be a list of strings.'
-            assert type(data['Instruction_language']) == list, f'Output_language must be a list of strings.'
-
-            assert 'instruction_language' not in data, f'Found `instruction_language`, but expected `Instruction_language`.'
-            assert 'input_language' not in data, f'Found `input_language`, but expected `Input_language`.'
-            assert 'output_language' not in data, f'Found `output_language`, but expected `Output_language`.'
-
-            # make sure we use the standard language names
-            # pqz
-            # for lang in data['Input_language'] + data['Output_language'] + data['Instruction_language']:
-            #     assert_language_name(lang)
-
-            instance_ids = set()
-            for x in data['Instances']:
-                for key in ['id', 'input', 'output']:
-                    assert key in x, f'expected the key {key} in {x}'
-                assert x['id'] not in instance_ids, f'found duplicate instance id: {x["id"]}'
-                instance_ids.add(x['id'])
-                assert type(x['input']) == str, f'the input of instance {x} is not a string'
-                assert type(x['output']) == list, f'the output of instance {x} is not a list'
-                assert len(x['input']) > 0, f"looks like an input `{x['input']}` is empty?"
-                assert len(x['output']) > 0, f"looks like an output `{x['output']}` is empty?"
-                for i in x['output']:
-                    assert type(i) == str, f'the output is not a string'
-            # pqz
-            # assert len(data['Positive Examples']) > 1, "there must be at least 3 positive example"
-            # assert len(data['Negative Examples']) > 0, "there must be at least 2 negative example"
-
-            for x in data['Positive Examples'] + data['Negative Examples']:
-                for key in ['input', 'output', 'explanation']:
-                    assert key in x, f'expected the key {key} in {x}'
-                assert type(x['input']) == str, f'the input of example {x} is not a string'
-                assert type(x['output']) == str, f'the output of example {x} is not a string'
-                assert type(x['explanation']) == str, f'the explanation of example {x} is not a string'
-
-            # Make sure there are no repeated input examples
-            instances = data['Instances']
-            set_of_instances = {instance['input'] for instance in instances}
-            # Because the set length and total length are different, there must be a duplicate input
-            # pqz
-            # if len(instances) != len(set_of_instances):
-            #     for instance in instances:
-            #         # If the instance is a duplicate then it has already been removed from the set and a KeyError will be thrown
-            #         try:
-            #             set_of_instances.remove(instance['input'])
-            #         except KeyError:
-            #             raise Exception(f" * Looks like we have a repeated example here! "
-            #                             f"Merge outputs before removing duplicates. :-/ \n {instance}")
-                                        
-            # Make sure there are no link in instances
-            url_reg  = r'http[s]?://(?:[a-zA-Z]|[0-9]|[$-_@.&+]|[!*\(\),]|(?:%[0-9a-fA-F][0-9a-fA-F]))+'
-            instances = data['Instances']    
-            for instance in instances:
-                ck_url = re.findall(url_reg, instance['input'])
-                if ck_url:
-                    print(f'⚠️ WARNING: Looks like there is a link in the input: {ck_url}')
-                    break
-                    
-            # make sure classes are balanced
-            output = [ins['output'] for ins in instances]
-            # flattens the nested arrays
-            outputs = sum(output, [])
-            value, counts = np.unique(outputs, return_counts=True)
-            
-            task_number = file.replace("task", "").split("_")[0]
-            # TODO: drop this condition 
-            if int(task_number) not in [902, 903]:
-                assert len(value) > 1, f" Looks like all the instances are mapped to a single output: {value}"
-
-            if task_number not in skew_exclusion and len(value) < 15:
-                norm_counts = counts / counts.sum()
-                entropy = -(norm_counts * np.log(norm_counts) / np.log(len(value))).sum()
-                # pqz
-                # assert entropy > 0.8, f"Looks like this task is heavily skewed!\n   📋 classes: {value} \n   📋 Norm_counts: {norm_counts} \n   📋 Distribution of classes: {counts} \n   📊 entropy= {entropy}"
-            # Make sure there are no examples repeated across instances and positive examples
-            examples = [ex['input'] for ex in data['Positive Examples']]
-            for instance in instances:
-                if instance['input'] in examples:
-                    raise Exception(f" * Looks like we have a same example across positive examples and instances! "
-                                    f"Drop the example from the instances. :-/ \n {instance}")
-
-                assert len(instance['output']) > 0, "all the instances must have at least one output"
-
-            true_file = file.replace(".json", "")
-            for char in true_file:
-                if char.isupper():
-                    raise Exception(f" * Looks like there is an uppercase letter in `{true_file}`. "
-                                    f"All letters should be lowercased.")
-
-            if file in task_readme_content:
-                raise Exception(f" * Looks like the .json file extension ending is "
-                                f"present with the task name in `tasks/README.md` when it should just be `{true_file}`")
-
-            # pqz
-            # if true_file not in task_readme_content:
-            #     raise Exception(f' * Looks like the task name `{true_file}` is not included '
-            #                     f'in the task file `tasks/README.md`')
-
-            if task_readme_content.count(true_file) > 1:
-                raise Exception(f' * Looks like the task name `{true_file}` is repeated in '
-                                f'the task file `tasks/README.md`')
-
-            for c in data['Contributors']:
-                if c not in contributor_stats:
-                    contributor_stats[c] = 0
-                contributor_stats[c] += 1
-            tasks_count = tasks_count + 1
-
-# test the the official splits
-# pqz
-# for split_name in ["mol_text"]:
-    # train_tasks = [l.strip() for l in open(f"splits/{split_name}/train_tasks.txt")]
-    # test_tasks = [l.strip() for l in open(f"splits/{split_name}/test_tasks.txt")]
-    # excluded_tasks = [l.strip() for l in open(f"splits/{split_name}/excluded_tasks.txt")]
-
-    # make east task in the split actually exists
-    # pqz
-    # for task in train_tasks + test_tasks + excluded_tasks:
-    #     assert task in task_names, f" Task {task} doesn't exist, but it's included in the {split_name} split."
-    # make sure each task appears in the split 
-    # pqz
-    # for task in task_names:
-    #     assert task in train_tasks + test_tasks + excluded_tasks, f" Task {task} is missing in the {split_name} split."
-    # make sure there is no overlap between test and train task names in the splits files.
-    # assert len(set(train_tasks) & set(test_tasks)) == 0, f" {split_name} split has overlap tasks in the train & test sets."
-    # assert len(set(train_tasks) & set(excluded_tasks)) == 0, f" {split_name} split has overlap tasks in the train & excluded sets."
-    # assert len(set(test_tasks) & set(excluded_tasks)) == 0, f" {split_name} split has overlap tasks in the test & excluded sets."
-
-print("Did not find any errors! ✅")
-
-print("\n  - - - - - Contributors >= 25 tasks - - - - - ")
-keyvalues = sorted(list(contributor_stats.items()), key=lambda x: x[1])
-for author, count in keyvalues:
-    if count >= 25:
-        print(f" ✍️ {author} -> {count}")
-
-print("\n  - - - - - Category Stats - - - - - ")
-keyvalues = sorted(list(categories_stats.items()), key=lambda x: x[1])
-for cat, count in categories_stats.items():
-    print(f" ✍️ {cat} -> {count}")
-
-print("\n  - - - - - Domain Stats - - - - - ")
-keyvalues = sorted(list(domain_stats.items()), key=lambda x: x[1])
-for dom, count in domain_stats.items():
-    print(f" ✍️ {dom} -> {count}")
-
-print("\n  - - - - - Reasoning Stats - - - - - ")
-keyvalues = sorted(list(reasoning_stats.items()), key=lambda x: x[1])
-for res, count in reasoning_stats.items():
-    print(f" ✍️ {res} -> {count}")
-
-print("\n  - - - - - Instances Stats - - - - - ")
-average_number_of_instances = number_of_instances / tasks_count
-print(f" ✍️ Average number of Instances -> {average_number_of_instances}")