extract_keywords.py

import collections
import copy
import glob
import json
import os
import random
import sys

import json5
import jsonpath_ng.ext
import tqdm

REMOVE_KEYS = [
    "$comment",
    "$id",
    "$ref",
    "Description",
    "description",
    "markdownDescription",
    "title",
]

KEYWORDS = {
    "integer": [
        "minimum",
        "maximum",
        "exclusiveMinimum",
        "exclusiveMaximum",
        "multipleOf",
    ],
    "object": [
        "minProperties",
        "maxProperties",
    ],
    "string": [
        "minLength",
        "maxLength",
        "format",
        "pattern",
    ],
    "array": [
        "minContains",
        "maxContains",
        "minItems",
        "maxItems",
        "uniqueItems",
    ],
}

# Numeric and integer types use the same keywords
KEYWORDS["numeric"] = KEYWORDS["integer"]


def find_type_paths(obj, json_type, path=jsonpath_ng.Root()):
    if isinstance(obj, dict):
        for k, v in obj.items():
            # If we have the type keyword and it's value matches, we found one
            if k == "type" and v == json_type:
                yield path

            # Continue recursively through the object's children
            yield from find_type_paths(
                v, json_type, jsonpath_ng.Child(path, jsonpath_ng.Fields(k))
            )
    elif isinstance(obj, list):
        # Check each list element
        for i, v in enumerate(obj):
            yield from find_type_paths(
                v, json_type, jsonpath_ng.Child(path, jsonpath_ng.Index(i))
            )


def write_obj(schema, obj, path, keyword, is_neg):
    # Skip any objects that are too large
    if len(json.dumps(obj, indent=4)) <= 1024:
        print(
            json.dumps(
                {
                    "schema": schema,
                    "obj": obj,
                    "path": path,
                    "keyword": keyword,
                    "is_neg": is_neg,
                }
            )
        )


def build_obj(path, value):
    # Build an object with the same shape it has in the entire document
    # For example, a path of $.foo.bar[0] would create an object
    # that looks like {"foo": {"bar": [value]}}
    if isinstance(path, jsonpath_ng.Root):
        return value
    if isinstance(path.right, (jsonpath_ng.Index, jsonpath_ng.Slice)):
        return build_obj(path.left, [value])
    elif isinstance(path.right, jsonpath_ng.Fields):
        return build_obj(path.left, {path.right.fields[0]: value})
    else:
        return value


def clean_obj(obj, keep_keyword):
    if isinstance(obj, dict):
        return {k: clean_obj(v, None) for k, v in obj.items() if k == keep_keyword}
    elif isinstance(obj, list):
        return [clean_obj(v, keep_keyword) for v in obj]
    else:
        return obj


def get_examples(data):
    neg_pos = collections.defaultdict(lambda: ([], []))
    for keyword_type, keywords in KEYWORDS.items():
        # Find all schema elements with the given type
        found_paths = find_type_paths(data, keyword_type)
        for found_path in found_paths:
            for found_obj in found_path.find(data):
                # For each keyword, check if it is included
                for keyword in keywords:
                    # Append to the 1st or 2nd list depending on
                    # whether the keyword is used in this object
                    has_keyword = keyword in found_obj.value

                    # Remove the keyword since we can't use it to predict
                    # obj_without_keyword.pop(keyword, None)
                    obj_without_keyword = clean_obj(found_obj.value, keyword)

                    # Remove keys we don't expect to have at inference time
                    for key in REMOVE_KEYS:
                        obj_without_keyword.pop(key, None)

                    path_obj = build_obj(found_path, obj_without_keyword)
                    neg_pos[keyword][has_keyword].append((path_obj, str(found_path)))

    return neg_pos


def write_examples(schema, neg_pos):
    for keyword, (neg, pos) in neg_pos.items():
        # Only include cases where we have at least
        # two positive and negative examples
        if len(pos) > 1 and len(neg) > 1:
            # Write out the positive and negative examples
            for pos_item, path in pos:
                write_obj(schema, pos_item, path, keyword, False)

            # For negative items, generate at most the number of positives
            # for (neg_item, path) in random.sample(neg, min(len(pos), len(neg))):
            for neg_item, path in neg:
                write_obj(schema, neg_item, path, keyword, True)


def main():
    schemas = []
    for line in sys.stdin:
        obj = json.loads(line)
        schemas.append(obj)

    for schema in tqdm.tqdm(schemas):
        data = json5.loads(schema["content"])
        neg_pos = get_examples(data)
        write_examples(schema["name"], neg_pos)


if __name__ == "__main__":
    main()