def reconcile_predicate_var(self, des_field_obj):
""" reconciles a predicate variable from the Import Field
"""
output = False
self.setup_field(des_field_obj)
if len(self.label) > 0:
output = True
pm = PredicateManagement()
pm.project_uuid = self.project_uuid
pm.source_id = self.source_id
pm.sort = self.sort
predicate = pm.get_make_predicate(self.label,
'variable',
self.data_type)
self.uuid = predicate.uuid
self.predicate = predicate
if predicate.uuid != self.candidate_uuid:
if self.des_import_cell is False:
# update the reconcilted UUID with for the import field object
des_field_obj.f_uuid = self.uuid
des_field_obj.save()
else:
# update the reconcilted UUID for import cells with same rec_hash
up_cells = ImportCell.objects\
.filter(source_id=self.source_id,
field_num=self.des_import_cell.field_num,
rec_hash=self.des_import_cell.rec_hash)
for up_cell in up_cells:
# save each cell with the correct UUID
up_cell.fl_uuid = self.uuid
up_cell.uuids_save()
return output
def make_reconcile_link_pred(self, label):
""" Makes a linking predicate from a given predicate label """
self.label = label
pm = PredicateManagement()
pm.project_uuid = self.project_uuid
pm.source_id = self.source_id
pm.data_type = self.data_type
pm.sort = self.sort
pm.get_make_predicate(label, self.class_uri, self.data_type)
self.uuid = pm.predicate.uuid
def make_reconcile_link_pred(self, label):
""" Makes a linking predicate from a given predicate label """
self.label = label
pm = PredicateManagement()
pm.project_uuid = self.project_uuid
pm.source_id = self.source_id
pm.data_type = self.data_type
pm.sort = self.sort
pm.get_make_predicate(label,
self.class_uri,
self.data_type)
self.uuid = pm.predicate.uuid
def create_pred_parents(self, new_hierachic_list):
""" Creates new types for
superior (more general) types from a list
of types that have hiearchies implicit in their labels
once the superior types are created,
linked data annotations noting hierarchy are stored
"""
parent_children_pairs = []
for manifest in new_hierachic_list:
try:
oc_pred = Predicate.objects.get(uuid=manifest.uuid)
except Predicate.DoesNotExist:
oc_pred = False
if (oc_pred is not False):
child_parts = manifest.label.split(self.HIERARCHY_DELIM)
act_delim = ''
act_new_label = ''
current_parent = False
for label_part in child_parts:
act_new_label = act_new_label + act_delim + label_part
act_delim = self.HIERARCHY_DELIM
pred_manage = PredicateManagement()
pred_manage.project_uuid = manifest.project_uuid
pred_manage.source_id = self.source_id
pred_manage.sort = oc_pred.sort
pred_manage.data_type = oc_pred.data_type
ppred = pred_manage.get_make_predicate(
act_new_label, manifest.class_uri)
if (ppred is not False and current_parent is not False):
parent_child = {
'parent': current_parent,
'child': ppred.uuid
}
parent_children_pairs.append(parent_child)
current_parent = ppred.uuid
if (len(parent_children_pairs) > 0):
# now make some linked data annotations
for parent_child in parent_children_pairs:
if (parent_child['parent'] is not False):
new_la = LinkAnnotation()
new_la.subject = parent_child['child']
new_la.subject_type = 'predicates'
new_la.project_uuid = manifest.project_uuid
new_la.source_id = self.source_id
new_la.predicate_uri = self.p_for_superobjs
new_la.object_uri = URImanagement.make_oc_uri(
parent_child['parent'], 'predicates')
new_la.creator_uuid = ''
new_la.save()
return parent_children_pairs
def create_pred_parents(self, new_hierachic_list):
""" Creates new types for
superior (more general) types from a list
of types that have hiearchies implicit in their labels
once the superior types are created,
linked data annotations noting hierarchy are stored
"""
parent_children_pairs = []
for manifest in new_hierachic_list:
try:
oc_pred = Predicate.objects.get(uuid=manifest.uuid)
except Predicate.DoesNotExist:
oc_pred = False
if oc_pred is not False:
child_parts = manifest.label.split(self.HIERARCHY_DELIM)
act_delim = ""
act_new_label = ""
current_parent = False
for label_part in child_parts:
act_new_label = act_new_label + act_delim + label_part
act_delim = self.HIERARCHY_DELIM
pred_manage = PredicateManagement()
pred_manage.project_uuid = manifest.project_uuid
pred_manage.source_id = self.source_id
pred_manage.sort = oc_pred.sort
pred_manage.data_type = oc_pred.data_type
ppred = pred_manage.get_make_predicate(act_new_label, manifest.class_uri)
if ppred is not False and current_parent is not False:
parent_child = {"parent": current_parent, "child": ppred.uuid}
parent_children_pairs.append(parent_child)
current_parent = ppred.uuid
if len(parent_children_pairs) > 0:
# now make some linked data annotations
for parent_child in parent_children_pairs:
if parent_child["parent"] is not False:
new_la = LinkAnnotation()
new_la.subject = parent_child["child"]
new_la.subject_type = "predicates"
new_la.project_uuid = manifest.project_uuid
new_la.source_id = self.source_id
new_la.predicate_uri = self.p_for_superobjs
new_la.object_uri = URImanagement.make_oc_uri(parent_child["parent"], "predicates")
new_la.creator_uuid = ""
new_la.save()
return parent_children_pairs
def make_datatype_wrong_assertion(self, predicate_uuid, content):
""" Makes an assertion for records that don't fit the
expected data_type / object_type
"""
pm = PredicateManagement()
pm.project_uuid = self.project_uuid
pm.source_id = self.source_id
pm.sort = self.sort
new_note_predicate = pm.get_make_related_note_predicate(predicate_uuid, ' (Note)')
if new_note_predicate is not False:
note_pred_uuid = new_note_predicate.uuid
# save a skos:related assertion linking the old and new predicates
ptm = PredicateTypeAssertions()
ptm.skos_relate_old_new_predicates(self.project_uuid,
self.source_id,
predicate_uuid,
note_pred_uuid)
sm = StringManagement()
sm.project_uuid = self.project_uuid
sm.source_id = self.source_id
oc_string = sm.get_make_string(content)
object_uuid = oc_string.uuid
if self.check_description_new(self.subject_uuid,
self.obs_num,
note_pred_uuid,
object_uuid,
None,
None):
# this asertion does not exist yet, OK to make it
new_ass = Assertion()
new_ass.uuid = self.subject_uuid
new_ass.subject_type = self.subject_type
new_ass.project_uuid = self.project_uuid
new_ass.source_id = self.source_id
new_ass.obs_node = self.obs_node
new_ass.obs_num = self.obs_num
new_ass.sort = self.sort + .1
new_ass.visibility = 1
new_ass.predicate_uuid = note_pred_uuid
new_ass.object_uuid = object_uuid
new_ass.object_type = 'xsd:string'
new_ass.save()
def seperate_inconsistent_data_type(self, predicate_uuid):
""" This looks for assertions that have different object types than the
required main data_type of a given predicate. If such different assertions
are found, the offending assertion is deleted and replaced by a new predicate
and that new predicate is related back to the old predicate via 'skos:related'
"""
plabel = False
ptype = False
pdata_type = False
new_rel_predicates = [] # list of new predicates made from old
try:
pman = Manifest.objects.get(uuid=predicate_uuid)
plabel = pman.label
ptype = pman.class_uri
except Manifest.DoesNotExist:
pman = False
try: # look for the predicate item
pred = Predicate.objects.get(uuid=predicate_uuid)
pdata_type = pred.data_type
except Predicate.DoesNotExist:
pred = False
if (plabel is not False and ptype is not False
and pdata_type is not False):
adistinct = Assertion.objects.filter(predicate_uuid=predicate_uuid)\
.exclude(object_type=pdata_type)\
.order_by('object_type')\
.distinct('object_type') # get distinct list of object_types
for aitem in adistinct: # list of assertions that are not using the good data type
pm = PredicateManagement()
pm.source_id = pman.source_id
pm.project_uuid = pman.project_uuid
pm.sort = pred.sort
cpred = pm.get_make_predicate(plabel, ptype, aitem.object_type)
if (cpred is not False):
if (cpred.uuid not in new_rel_predicates):
new_rel_predicates.append(cpred.uuid)
if (len(new_rel_predicates) > 0):
# add annotations storing the relationship between the new predicates and the old
print('---- New predicates: ' + str(len(new_rel_predicates)))
for new_pred_uuid in new_rel_predicates:
print('New predicate: ' + str(new_pred_uuid))
self.skos_relate_old_new_predicates(
pman.project_uuid, pman.source_id, predicate_uuid,
new_pred_uuid)
alist = Assertion.objects.filter(
predicate_uuid=predicate_uuid).exclude(
object_type=pdata_type)
for aitem in alist: # list of assertions that are not using the good data type
pm = PredicateManagement()
pm.source_id = pman.source_id
pm.project_uuid = pman.project_uuid
pm.sort = pred.sort
cpred = pm.get_make_predicate(plabel, ptype,
aitem.object_type)
if (cpred is not False):
if (cpred.uuid not in new_rel_predicates):
new_rel_predicates.append(cpred.uuid)
Assertion.objects.filter(
hash_id=aitem.hash_id).delete()
# delete the old instance of the assertion
aitem.predicate_uuid = cpred.uuid # change the predicate to the new predicate
aitem.save(
) # save the assertion with the new predicate
else:
print('--OK Predicate--: ' + str(predicate_uuid))
def seperate_inconsistent_data_type(self, predicate_uuid):
""" This looks for assertions that have different object types than the
required main data_type of a given predicate. If such different assertions
are found, the offending assertion is deleted and replaced by a new predicate
and that new predicate is related back to the old predicate via 'skos:related'
"""
plabel = False
ptype = False
pdata_type = False
new_rel_predicates = [] # list of new predicates made from old
try:
pman = Manifest.objects.get(uuid=predicate_uuid)
plabel = pman.label
ptype = pman.class_uri
except Manifest.DoesNotExist:
pman = False
try: # look for the predicate item
pred = Predicate.objects.get(uuid=predicate_uuid)
pdata_type = pred.data_type
except Predicate.DoesNotExist:
pred = False
if(plabel is not False
and ptype is not False
and pdata_type is not False):
adistinct = Assertion.objects.filter(predicate_uuid=predicate_uuid)\
.exclude(object_type=pdata_type)\
.order_by('object_type')\
.distinct('object_type') # get distinct list of object_types
for aitem in adistinct: # list of assertions that are not using the good data type
pm = PredicateManagement()
pm.source_id = pman.source_id
pm.project_uuid = pman.project_uuid
pm.sort = pred.sort
cpred = pm.get_make_predicate(plabel, ptype, aitem.object_type)
if(cpred is not False):
if(cpred.uuid not in new_rel_predicates):
new_rel_predicates.append(cpred.uuid)
if(len(new_rel_predicates) > 0):
# add annotations storing the relationship between the new predicates and the old
print('---- New predicates: ' + str(len(new_rel_predicates)))
for new_pred_uuid in new_rel_predicates:
print('New predicate: ' + str(new_pred_uuid))
self.skos_relate_old_new_predicates(pman.project_uuid,
pman.source_id,
predicate_uuid,
new_pred_uuid)
alist = Assertion.objects.filter(predicate_uuid=predicate_uuid).exclude(object_type=pdata_type)
for aitem in alist: # list of assertions that are not using the good data type
pm = PredicateManagement()
pm.source_id = pman.source_id
pm.project_uuid = pman.project_uuid
pm.sort = pred.sort
cpred = pm.get_make_predicate(plabel, ptype, aitem.object_type)
if(cpred is not False):
if(cpred.uuid not in new_rel_predicates):
new_rel_predicates.append(cpred.uuid)
Assertion.objects.filter(hash_id=aitem.hash_id).delete()
# delete the old instance of the assertion
aitem.predicate_uuid = cpred.uuid # change the predicate to the new predicate
aitem.save() # save the assertion with the new predicate
else:
print('--OK Predicate--: ' + str(predicate_uuid))
