def test_parse_person(self):
print('Number of Persons: {}'.format(Person.objects.all().count()))
o = GenericRDFParser(self.uriP, self.kindP)
o2 = o.save()
print('got following person: {}'.format(o2))
self.assertEqual(o.objct.name, 'Eosander')
self.assertEqual(o.objct.first_name, 'Johann Friedrich')
def test_merge_places(self):
txt = Text.objects.create(text='test text')
src = Source.objects.create(orig_id=24, pubinfo='test pub')
pp = Place(name="Wien")
pp.source = src
pp.save()
pp.text.add(txt)
rel_type_birth = PersonPlaceRelation.objects.create(
name='place of birth')
pers = Person.objects.create(name="tesdt", first_name="test3")
rel_1 = PersonPlace.objects.create(related_person=pers,
relation_type=rel_type_birth,
related_place=pp)
ow = GenericRDFParser(self.uriGeon, 'Place')
print('name: {}, lat: {}, long: {}, labels: {}'.format(
ow.objct.name, ow.objct.lat, ow.objct.lng, ' / '.join(
Label.objects.filter(temp_entity=ow.objct).values_list(
'label', flat=True))))
if ow.created:
print('created triggered')
ow.save()
ow2 = ow.merge(pp)
print(ow)
print(ow2)
self.assertEqual(pp.source.pubinfo, ow.objct.source.pubinfo)
self.assertEqual(txt.text, ow.objct.text.all()[0].text)
for x in PersonPlace.objects.all():
self.assertEqual(x.related_place.pk, ow.objct.pk)
def test_merge_place(self):
col = Collection.objects.create(name='test coll one')
col2 = Collection.objects.create(name='test coll 2')
w1 = Place.objects.create(name='Wien 21 test')
w1.collection.add(col)
w1.collection.add(col2)
w1_label = Label.objects.create(label='Wien label 1', temp_entity=w1)
w1_uri = Uri.objects.create(uri='http://test.uri.ac.at/orig:id',
entity=w1)
o = GenericRDFParser(self.uriGeon, self.kindP)
o2 = o.save()
o.merge(w1)
for col in o2.collection.all():
print('collection: {}'.format(col.name))
self.assertEqual(
Label.objects.filter(temp_entity=o2, label='Wien label 1').count(),
1)
self.assertEqual(
Uri.objects.filter(entity=o2,
uri='http://test.uri.ac.at/orig:id').count(), 1)
self.assertEqual(
Label.objects.filter(label='Wien 21 test',
temp_entity=o2,
label_type__name='legacy name').count(), 1)
self.assertEqual(o2.collection.all().count(), 3)
def test_related_places(self):
o = GenericRDFParser(self.uriGeon, self.kindP)
o2 = o.save()
print(o2)
print('related_objects: {}'.format(o.related_objcts))
print('number of placeplace: {}'.format(
PlacePlace.objects.all().count()))
pp = PlacePlace.objects.filter(
Q(related_placeA=o2) | Q(related_placeB=o2))
self.assertEqual(pp.count(), 2)
def resolve_ambigue_place(request, pk, uri):
'''Only used to resolve place names.'''
with reversion.create_revision():
uri = 'http://' + uri
entity = Place.objects.get(pk=pk)
pl_n = GenericRDFParser(uri, kind='Place')
pl_n_1 = pl_n.save()
pl_n_1 = pl_n.merge(entity)
url = pl_n_1.get_absolute_url()
if pl_n.created:
pl_n_1.status = 'distinct (manually resolved)'
pl_n_1.save()
UriCandidate.objects.filter(entity=entity).delete()
reversion.set_user(request.user)
return HttpResponseRedirect(url)
def test_place_of_birth_death(self):
o = GenericRDFParser(self.uriP, self.kindP)
p2 = o.save()
print(p2.start_date)
print(p2.end_date)
rel_type_birth = PersonPlaceRelation.objects.get(name='place of birth')
rel_type_death = PersonPlaceRelation.objects.get(name='place of death')
rel_birth = PersonPlace.objects.get(related_person=o.objct,
relation_type=rel_type_birth)
rel_death = PersonPlace.objects.get(related_person=o.objct,
relation_type=rel_type_death)
self.assertEqual(rel_birth.related_place.name, 'Stralsund')
self.assertEqual(rel_death.related_place.name, 'Dresden')
plc_list = Label.objects.filter(
temp_entity=rel_death.related_place).values_list('label',
flat=True)
print(plc_list)
self.assertTrue('Dressden' in plc_list)
self.assertEqual(rel_death.related_place.lat, 13.738319)
print('lat: {}, lng: {}'.format(rel_death.related_place.lat,
rel_death.related_place.lng))
def test_existing_place(self):
c = GenericRDFParser('http://sws.geonames.org/2782113/', self.kindP)
c.save()
o = GenericRDFParser(self.uriGeon, self.kindP)
o2 = o.save()
Uri.objects.create(uri='http://test.at', entity=o2)
pp = PlacePlace.objects.filter(
Q(related_placeA=o2) | Q(related_placeB=o2))
self.assertEqual(pp.count(), 2)
for p in Place.objects.all():
print('name: {}, uri: {}'.format(
p.name, ' / '.join(p.uri_set.all().values_list('uri',
flat=True))))
cc = Place.objects.filter(
uri__uri__icontains='http://sws.geonames.org/2782113').distinct()
self.assertEqual(cc.count(), 1)
i = GenericRDFParser(self.uriGeon, self.kindP)
i2 = i.save()
print(' / '.join(i.objct.uri_set.all().values_list('uri', flat=True)))
print(i.objct)
cc = Place.objects.filter(uri__uri=self.uriGeon).distinct()
self.assertEqual(cc.count(), 1)
def save(self, site_instance, instance=None, commit=True):
"""
Save function of the GenericRelationForm.
:param site_instance: Instance where the form is used on
:param instance: PK of the relation that is saved
:param commit: Whether to already commit the save.
:type site_instance: object
:type instance: int
:type commit: bool
:rtype: object
:return: instance of relation
"""
cd = self.cleaned_data
if instance:
x = self.relation_form.objects.get(pk=instance)
else:
x = self.relation_form()
x.relation_type_id = cd['relation_type']
x.start_date_written = cd['start_date_written']
x.end_date_written = cd['end_date_written']
x.notes = cd['notes']
x.references = cd['references']
setattr(x, self.rel_accessor[3], site_instance)
target = ContentType.objects.get(app_label='apis_entities', model=self.rel_accessor[0].lower()).model_class()
t1 = target.get_or_create_uri(cd['target'])
if not t1:
t1 = GenericRDFParser(cd['target'], self.rel_accessor[0]).get_or_create()
setattr(x, self.rel_accessor[2], t1)
if commit:
x.save()
if self.highlighter:
if not commit:
x.save()
txt = Text.objects.get(pk=cd['HL_text_id'][5:])
a = Annotation(
start=cd['HL_start'],
end=cd['HL_end'],
text=txt,
user_added=self.request.user,
annotation_project_id=int(self.request.session.get('annotation_project', 1)))
a.save()
a.entity_link.add(x)
print('saved: {}'.format(x))
return x
def test_parse_place(self):
o = GenericRDFParser(self.uriGeon, self.kindP)
o2 = o.save()
print('name: {}, lat: {}, long: {}, labels: {}, kind: {}'.format(
o2.place.name, o2.place.lat, o2.place.lng, ' / '.join(
Label.objects.filter(temp_entity=o2.place).values_list(
'label', flat=True)), o2.kind.name))
t = GenericRDFParser(self.uri_gnd_geo, self.kindP)
t2 = t.save()
print('name: {}, lat: {}, long: {}, labels: {}'.format(
t2.name, t2.lat, t2.lng, ' / '.join(
Label.objects.filter(temp_entity=t2).values_list('label',
flat=True))))
self.assertEqual(o2.lat, '48.20849')
self.assertEqual(t2.lat, '053.583329')
def get(self, request):
entity = request.query_params.get("entity2", None)
uri = request.query_params.get("uri", None)
if uri.startswith('http:'):
ent = GenericRDFParser(uri, entity.title()).get_or_create()
else:
print(uri)
r1 = re.search(r"^[^<]+", uri)
r2 = re.search(r"<([^>]+)>", uri)
q_d = dict()
q_d['name'] = r1
if r2:
for x in r2.group(1).split(';'):
x2 = x.split('=')
q_d[x2[0].strip()] = x2[1].strip()
if entity == 'person':
r1_2 = r1.group(0).split(',')
if len(r1_2) == 2:
q_d['first_name'] = r1_2[1].strip()
q_d['name'] = r1_2[0].strip()
ent = ContentType.objects.get(
app_label="apis_entities",
model=entity.lower()).model_class().objects.create(**q_d)
res = {
"id":
ent.pk,
"url":
reverse_lazy(
"apis:apis_entities:generic_entities_edit_view",
request=request,
kwargs={
"pk": ent.pk,
"entity": entity
},
),
}
return Response(res)
def save(self, *args, **kwargs):
cd = self.cleaned_data
entity = GenericRDFParser(cd['entity'],
self.entity.title()).get_or_create()
return entity
def save(self, *args, **kwargs):
cd = self.cleaned_data
pl = Place.get_or_create_uri(cd['place_uri'])
if not pl:
pl = GenericRDFParser(cd['place_uri'], 'Place').get_or_create()
return pl