243 lines
11 KiB
Python
243 lines
11 KiB
Python
#!/usr/bin/env python
|
|
# coding: utf-8
|
|
|
|
from pathlib import Path
|
|
|
|
import yaml
|
|
from collections import defaultdict
|
|
|
|
#extract all node types and generate basic yaml config part for nodes
|
|
|
|
def write_automated_schema(graph, file_path, manual_schema_path):
|
|
schema_data = {
|
|
'nodes': {},
|
|
'edges': {}
|
|
}
|
|
|
|
if Path(file_path).exists():
|
|
print("-- Using existing schema --")
|
|
schema_data = load_manual_schema(file_path)
|
|
elif isinstance(manual_schema_path, list):
|
|
print("-- Using two schema files --")
|
|
schema_data = schema_merger(manual_schema_path[0], manual_schema_path[1])
|
|
elif manual_schema_path:
|
|
print("-- Using the manual schema --")
|
|
schema_data = load_manual_schema(manual_schema_path)
|
|
|
|
|
|
if graph is not None:
|
|
for node in graph.nodes():
|
|
label = graph.nodes[node].get('label')
|
|
if label == 'resource':
|
|
label = graph.nodes[node].get('resourceType')
|
|
|
|
label = label.capitalize()
|
|
|
|
if label not in schema_data['nodes']:
|
|
schema_data['nodes'][label] = {}
|
|
|
|
if 'properties' not in schema_data['nodes'][label] or schema_data['nodes'][label]['properties'] is None:
|
|
schema_data['nodes'][label]['properties'] = {}
|
|
|
|
for k in graph.nodes[node].keys():
|
|
schema_data['nodes'][label]['properties'][k] = 'str'
|
|
|
|
#schema_data['nodes'][label]['properties'].update(graph.nodes[node].keys())
|
|
|
|
|
|
file=open(file_path, 'w')
|
|
|
|
for n in schema_data['nodes']:
|
|
temp = n+':\n'
|
|
if 'is_a' in schema_data['nodes'][n]:
|
|
is_a_value = schema_data['nodes'][n]['is_a']
|
|
temp += ' is_a: ' + (', '.join(is_a_value) if isinstance(is_a_value, list) else str(is_a_value)) + '\n'
|
|
else:
|
|
temp += ' is_a: named thing\n'
|
|
if 'represented_as' in schema_data['nodes'][n]:
|
|
represented_as_value = schema_data['nodes'][n]['represented_as']
|
|
temp += ' represented_as: ' + (', '.join(represented_as_value) if isinstance(represented_as_value, list) else str(represented_as_value)) + '\n'
|
|
else:
|
|
temp += ' represented_as: node\n'
|
|
if 'label_in_input' in schema_data['nodes'][n]:
|
|
label_in_input_value = schema_data['nodes'][n]['label_in_input']
|
|
temp += ' label_in_input: ' + (', '.join(label_in_input_value) if isinstance(label_in_input_value, list) else str(label_in_input_value)) + '\n'
|
|
if 'preferred_id' in schema_data['nodes'][n]:
|
|
preferred_id_value = schema_data['nodes'][n]['preferred_id']
|
|
temp += ' preferred_id: ' + (', '.join(preferred_id_value) if isinstance(preferred_id_value, list) else str(preferred_id_value)) + '\n'
|
|
else:
|
|
temp += ' preferred_id: fhir_id\n'
|
|
temp += ' label_in_input: ' + n + '\n'
|
|
temp += ' properties:\n'
|
|
# get property values from schema_data if exists
|
|
#print("---------->", str(schema_data['nodes'][n]))
|
|
if schema_data['nodes'][n]['properties'] is not None:
|
|
for p_key in schema_data['nodes'][n]['properties']:
|
|
prop_value = schema_data['nodes'][n]['properties'][p_key]
|
|
temp += ' ' + p_key + ': ' + (', '.join(prop_value) if isinstance(prop_value, list) else str(prop_value)) + '\n'
|
|
#elif schema_data['nodes']['properties']:
|
|
#print("----> ", schema_data['nodes']['properties'])
|
|
""" else:
|
|
for attr in schema_data['nodes'][n]:
|
|
temp += ' ' + attr + ': str\n' """
|
|
|
|
temp += '\n'
|
|
|
|
file.write(temp)
|
|
|
|
file.write('\n')
|
|
|
|
#extract all relationship types and generate basic yaml config part for relationships
|
|
#if not edgeTypes: edgeTypes = set()
|
|
|
|
if graph is not None:
|
|
for u, v, a in graph.edges(data=True):
|
|
source_label = graph.nodes[u].get('label')
|
|
target_label = graph.nodes[v].get('label')
|
|
if source_label == 'resource':
|
|
source_label = graph.nodes[u].get('resourceType', str(u))
|
|
elif source_label == 'dummy' or source_label == 'Dummy':
|
|
source_label = graph.nodes[u].get('edge_label', str(u))
|
|
|
|
if target_label == 'resource':
|
|
target_label = graph.nodes[v].get('resourceType', str(v))
|
|
elif target_label == 'dummy' or target_label == 'Dummy':
|
|
target_label = graph.nodes[v].get('edge_label', str(v))
|
|
|
|
source_label = source_label.capitalize()
|
|
target_label = target_label.capitalize()
|
|
|
|
CONST_ASSOCIATION = ' association'
|
|
if source_label + ' to ' + target_label + CONST_ASSOCIATION in schema_data['edges']:
|
|
# add missing attributes
|
|
continue
|
|
elif source_label + ' derived from ' + target_label + CONST_ASSOCIATION in schema_data['edges']:
|
|
continue
|
|
elif source_label + ' has member ' + target_label + CONST_ASSOCIATION in schema_data['edges']:
|
|
continue
|
|
elif source_label + ' reasoned by ' + target_label + CONST_ASSOCIATION in schema_data['edges']:
|
|
continue
|
|
elif source_label + ' is ' + target_label + CONST_ASSOCIATION in schema_data['edges']:
|
|
continue
|
|
else:
|
|
schema_data['edges'][source_label + ' to ' + target_label + ' association'] = {
|
|
'is_a': 'association',
|
|
'represented_as': 'edge',
|
|
'label_in_input': source_label + '_to_' + target_label,
|
|
'properties': a
|
|
}
|
|
|
|
for label in schema_data['edges']:
|
|
temp = '' + label + ':\n'
|
|
for key in schema_data['edges'][label]:
|
|
if key == 'properties':
|
|
if schema_data['edges'][label][key] is not None:
|
|
temp += ' properties:\n'
|
|
for prop in schema_data['edges'][label][key]:
|
|
prop_value = schema_data['edges'][label][key][prop]
|
|
temp += ' ' + prop + ': ' + (', '.join(prop_value) if isinstance(prop_value, list) else str(prop_value)) + '\n'
|
|
else:
|
|
field_value = schema_data['edges'][label][key]
|
|
temp += ' ' + key + ': ' + (', '.join(field_value) if isinstance(field_value, list) else str(field_value)) + '\n'
|
|
|
|
temp += '\n'
|
|
file.write(temp)
|
|
|
|
file.close()
|
|
|
|
def load_manual_schema(path):
|
|
schema_data = {
|
|
'nodes': {},
|
|
'edges': {}
|
|
}
|
|
edgeTypes = set()
|
|
|
|
with open(path, 'r') as file:
|
|
# Load YAML with comments stripped
|
|
data = yaml.safe_load(file)
|
|
|
|
for label, attrs in data.items():
|
|
cLabel = label#.capitalize() # less n, e and p with capitalize
|
|
if label != 'Title':
|
|
if attrs["represented_as"] == 'node':
|
|
if not hasattr(schema_data['nodes'], cLabel):
|
|
schema_data['nodes'][cLabel] = set()
|
|
|
|
#assuming uniqueness in schema file here. If the same node type exits twice, it will be overwritten.
|
|
schema_data['nodes'][cLabel] = attrs
|
|
#for a in attrs:
|
|
|
|
#print(v)
|
|
""" for k, v in attrs:
|
|
if not k == ''
|
|
schema_data['nodes'][label][k] = v """
|
|
else:
|
|
if not hasattr(schema_data['edges'], cLabel):
|
|
schema_data['edges'][cLabel] = set()
|
|
|
|
#assuming uniqueness in schema file here. If the same node type exits twice, it will be overwritten.
|
|
schema_data['edges'][cLabel] = attrs
|
|
|
|
return schema_data
|
|
|
|
|
|
def schema_merger(schema_path1, schema_path2):
|
|
schema1 = load_manual_schema(schema_path1)
|
|
schema2 = load_manual_schema(schema_path2)
|
|
|
|
merged = {
|
|
'nodes': {**schema1['nodes'], **schema2['nodes']},
|
|
'edges': {**schema1['edges'], **schema2['edges']}
|
|
}
|
|
|
|
return merged
|
|
|
|
|
|
def schema_diff_report(manual_path, auto_path):
|
|
#manual_path = "config/manual_schema_config.yaml"
|
|
#auto_path = "config/automated_schema.yaml"
|
|
|
|
man_schema = load_manual_schema(manual_path)
|
|
automated_schema = load_manual_schema(auto_path)
|
|
|
|
print("\nNODES:\n")
|
|
for label, attributes in automated_schema['nodes'].items():
|
|
if 'nodes' in man_schema and label in man_schema['nodes']: # node already exists
|
|
print("Found in man schema: ", label)
|
|
for prop, val in attributes.items():
|
|
if prop in man_schema['nodes'][label]: # property exists
|
|
if isinstance(val, dict):
|
|
for attr, attr_val in val.items():
|
|
if attr not in man_schema['nodes'][label][prop]:
|
|
print("Added the property " + attr + " to " + prop + " of " + label)
|
|
elif attr_val != man_schema['nodes'][label][prop][attr]:
|
|
print("Updated property value of " + label + "." + prop + "." + attr + "to: " + attr_val)
|
|
elif val != man_schema['nodes'][label][prop]: # property value is not the same
|
|
print("Updated property value of " + label + "." + prop + " to: " + val)
|
|
else:
|
|
print(label + "." + prop + " has not changed")
|
|
else:
|
|
print(label + ": added property " + prop + ". Value: " + val)
|
|
else: # node not found in manual schema
|
|
print('Resource type added: ' + label)
|
|
|
|
print("\nEDGES:\n")
|
|
for label, attributes in automated_schema['edges'].items():
|
|
if 'edges' in man_schema and label in man_schema['edges']: # node already exists
|
|
print("Found in man schema: ", label)
|
|
for prop, val in attributes.items():
|
|
if prop in man_schema['edges'][label]: # property exists
|
|
if isinstance(val, dict):
|
|
for attr, attr_val in val.items():
|
|
if attr not in man_schema['edges'][label][prop]:
|
|
print("Added the property " + attr + " to " + prop)
|
|
elif attr_val != man_schema['edges'][label][prop][attr]:
|
|
print("Updated property value of " + label + "." + prop + "." + attr + "to: " + attr_val)
|
|
elif val != man_schema['edges'][label][prop]: # property value is not the same
|
|
print("Updated property value of " + label + "." + prop + " to: " + val)
|
|
else:
|
|
print(label + "." + prop + " has not changed")
|
|
else:
|
|
print(label + ": added property " + prop + ". Value: " + val)
|
|
else: # node not found in manual schema
|
|
print('Resource type added: ' + label) |