def test_create_context_template(self):
new_context = create_context_template(
self.person_schema, self.base,
process_schema_name(self.schema_name))
self.assertTrue('sdo' in new_context['sdo']["@context"].keys())
self.assertTrue(
new_context['sdo']["@context"]['sdo'] == "https://schema.org")
self.assertTrue(
'IdentifierInfo' in new_context['sdo']["@context"].keys())
self.assertTrue(new_context['sdo']["@context"]['@language'] == 'en')
self.assertTrue('lastName' in new_context['sdo']["@context"].keys())
self.assertTrue('identifier' in new_context['sdo']["@context"].keys())
self.assertTrue('obo' in new_context['obo']["@context"].keys())
self.assertTrue(new_context['obo']["@context"]['obo'] ==
"http://purl.obolibrary.org/obo/")
self.assertTrue(
'IdentifierInfo' in new_context['obo']["@context"].keys())
self.assertTrue(new_context['obo']["@context"]['@language'] == 'en')
self.assertTrue('lastName' in new_context['obo']["@context"].keys())
self.assertTrue('identifier' in new_context['obo']["@context"].keys())
def create_context(self, user_input):
""" Resolve a network a creates the associated context files templates
:param user_input: a dict that should contain a "schema_url" and a "vocab" attributes.
vocab should contain the ontology names as keys and their base URL as value
:type user_input: dict
:return: a dict containing the context files of all schema in the network and
for all given vocabulary
"""
if 'schema_url' not in user_input.keys():
raise falcon.HTTPError(falcon.HTTP_400,
"Query error, no schema url was provided")
elif 'vocab' not in user_input.keys() \
or type(user_input["vocab"]) != dict or \
not len(user_input['vocab']) > 0:
raise falcon.HTTPError(falcon.HTTP_400,
"Query error, no vocabulary was provided ")
else:
output = {}
network = resolve_network(user_input["schema_url"])
for semantic_type in user_input['vocab']:
output[semantic_type] = {}
for schema in network.keys():
schema_name = process_schema_name(
network[schema]['id']).lower()
local_context = create_context_template(
network[schema], user_input['vocab'], schema_name)
for vocab_name in local_context:
output[vocab_name][schema_name] = local_context[vocab_name]
return json.dumps(output, indent=4)
def __init__(self, overlaps):
self.overlaps = overlaps["overlaps"]
self.output = {
"schemas": copy.deepcopy(overlaps["network1"]['schemas']),
"contexts": copy.deepcopy(overlaps["network1"]['contexts'])
}
self.content = overlaps
self.name_mapping = {} # {"oldName":"newName"}
self.output_name = \
self.content['network1']['name'].lower() + \
"_" + self.content['network2']['name'].lower() + "_merge"
self.output_dir = os.path.join(
os.path.dirname(__file__),
"../tests/fullDiffOutput/merges/" + self.output_name + "/")
self.errors = {}
self.main_schema_name = overlaps['network1']['name'].lower().replace(
' ', '_').capitalize()
if "fields_to_merge" not in overlaps:
print("Nothing to merge for current setup")
exit()
# Process mergings
for schemaName in overlaps['fields_to_merge']:
merging_schema_name = schemaName.replace('_schema.json', '')
merge_with_schema_name = overlaps['fields_to_merge'][schemaName][
'merge_with'].replace('_schema.json', '')
if merge_with_schema_name != merging_schema_name:
merged_schema_name = merge_with_schema_name + "_" \
+ merging_schema_name \
+ "_merged_schema.json"
merged_type = merge_with_schema_name.capitalize(
) + merging_schema_name.capitalize()
else:
merged_schema_name = merge_with_schema_name + "_merged_schema.json"
merged_type = merge_with_schema_name.capitalize() + 'Merged'
self.name_mapping[overlaps['fields_to_merge'][schemaName]
['merge_with']] = merged_schema_name
self.name_mapping[schemaName] = merged_schema_name
merged_title = overlaps["network1"]['schemas'][overlaps[
'fields_to_merge'][schemaName]['merge_with']]['title'] + " - " + \
overlaps["network2"]['schemas'][schemaName]['title'] + " merging"
merged_description = "Merge between the " + overlaps["network1"]['schemas'][overlaps[
'fields_to_merge'][schemaName]['merge_with']]['title'] + " and the " + \
overlaps["network2"]['schemas'][schemaName]['title']
merged_schema = copy.deepcopy(overlaps["network1"]['schemas'][
overlaps['fields_to_merge'][schemaName]['merge_with']])
merged_context = copy.deepcopy(overlaps["network1"]['contexts'][
overlaps['fields_to_merge'][schemaName]['merge_with']])
del self.output['schemas'][overlaps['fields_to_merge'][schemaName]
['merge_with']]
del self.output['contexts'][overlaps['fields_to_merge'][schemaName]
['merge_with']]
# process the fields to merge
for field in overlaps['fields_to_merge'][schemaName]['fields']:
merged_schema['properties'][field] = overlaps['network2'][
'schemas'][schemaName]['properties'][field]
merged_schema['title'] = merged_title
merged_schema['description'] = merged_description
merged_context[field] = overlaps['network2']['contexts'][
schemaName][field]
self.find_references(overlaps['network2']['schemas']
[schemaName]['properties'][field])
if 'enum' in merged_schema['properties']['@type']:
type_iterator = 0
for schema_type in merged_schema['properties']['@type'][
'enum']:
if schema_type == merge_with_schema_name.capitalize():
del merged_schema['properties']['@type']['enum'][
type_iterator]
merged_schema['properties']['@type']['enum'].append(
merged_type)
type_iterator += 1
self.output['schemas'][merged_schema_name] = merged_schema
self.output['contexts'][merged_schema_name] = merged_context
# processing main schema name
for overlap in self.overlaps:
if self.main_schema_name in overlap[0] and float(
overlap[1]['coverage'][0]) >= 100:
old_schema1_name = self.main_schema_name.lower()
old_schema2_name = overlap[0][1].lower()
new_schema_name = old_schema1_name \
+ "_" + old_schema2_name + '_merged_schema.json'
new_description = "A merge between " \
+ old_schema1_name + " and " \
+ old_schema2_name + " schemas"
new_title = "Merge between " + old_schema1_name + " and " + old_schema2_name
new_schema = self.content['network1']['schemas'][
old_schema1_name + "_schema.json"]
new_schema['description'] = new_description
new_schema['title'] = new_title
if 'enum' in new_schema['properties']['@type']:
print()
type_iterator = 0
for schema_type in new_schema['properties']['@type'][
'enum']:
if schema_type == self.main_schema_name:
del new_schema['properties']['@type']['enum'][
type_iterator]
new_schema['properties']['@type']['enum'].append(
process_schema_name(new_schema_name))
self.output['schemas'][new_schema_name] = new_schema
del self.output['schemas'][old_schema1_name + "_schema.json"]
# Context
self.output['contexts'][new_schema_name] = self.content[
'network1']['contexts'][old_schema1_name + '_schema.json']
self.output['contexts'][new_schema_name][process_schema_name(
new_schema_name)] = self.output['contexts'][
old_schema1_name +
'_schema.json'][process_schema_name(old_schema1_name)]
del self.output['contexts'][new_schema_name][
process_schema_name(old_schema1_name)]
del self.output['contexts'][old_schema1_name + '_schema.json']
self.modify_references()
def modify_references(self):
""" Modify the $ref names
:return:
"""
look_for = ["anyOf", "oneOf", "allOf"]
delete_schemas = []
for schema in self.output['schemas']:
if schema in self.name_mapping:
delete_schemas.append(schema)
else:
if 'properties' in self.output['schemas'][schema]:
for item in self.output['schemas'][schema]['properties']:
field = self.output['schemas'][schema]['properties'][
item]
if '$ref' in field:
field_ref = field['$ref'].replace('#', '')
if field_ref in self.name_mapping:
self.output['schemas'][schema]['properties'][item]['$ref'] = \
self.name_mapping[field_ref] + '#'
for reference in look_for:
if reference in field:
sub_item_iterator = 0
for sub_item in field[reference]:
if '$ref' in sub_item:
field_ref = sub_item['$ref']
if field_ref in self.name_mapping:
self.output['schemas'][schema]['properties'][
reference][sub_item_iterator]['$ref'] = \
self.name_mapping[field_ref] + "#"
sub_item_iterator += 1
if 'items' in field:
if '$ref' in field['items']:
field_ref = field['items']['$ref'].replace(
'#', '')
if field_ref in self.name_mapping:
self.output['schemas'][
schema]['properties'][item]['items']['$ref'] = \
self.name_mapping[field_ref] + '#'
for reference in look_for:
if reference in field['items']:
sub_item_iterator = 0
for sub_item in field['items'][reference]:
if '$ref' in sub_item:
field_ref = sub_item['$ref']
if field_ref in self.name_mapping:
self.output['schemas'][schema]['properties'][
reference]['items'][
sub_item_iterator]['$ref'] = \
self.name_mapping[field_ref] + "#"
sub_item_iterator += 1
for schema in delete_schemas:
del self.output['schemas'][schema]
change_names = {v: k for k, v in self.name_mapping.items()}
for context in self.output['contexts']:
new_field_base_name = process_schema_name(context)
if context in change_names:
old_schema_name = change_names[context]
old_field_base_name = process_schema_name(old_schema_name)
# set the new context field
self.output["contexts"][context][new_field_base_name] = \
copy.copy(self.content['network2'][
"contexts"][old_schema_name][old_field_base_name])
def test_process_schema_name(self):
self.assertTrue(
process_schema_name(self.schema_name) == "IdentifierInfo")