io.redlink.sdk.impl.analysis.model.RDFStructureParser Maven / Gradle / Ivy
/**
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package io.redlink.sdk.impl.analysis.model;
import com.google.common.base.Optional;
import com.google.common.base.Predicate;
import com.google.common.collect.*;
import io.redlink.sdk.util.ModelRepository;
import org.openrdf.model.Literal;
import org.openrdf.model.Model;
import org.openrdf.model.Value;
import org.openrdf.model.impl.LiteralImpl;
import org.openrdf.model.vocabulary.DCTERMS;
import org.openrdf.query.*;
import org.openrdf.repository.Repository;
import org.openrdf.repository.RepositoryConnection;
import org.openrdf.repository.RepositoryException;
import java.util.*;
/**
* @author [email protected]
* @author [email protected]
*/
final class RDFStructureParser extends EnhancementsParser {
/**
*
*/
private Repository repository;
public RDFStructureParser(Model model)
throws EnhancementParserException {
try {
this.repository = ModelRepository.create(model);
} catch (RepositoryException e) {
throw new EnhancementParserException(
"There was an error initializing the Enhancement Parser", e);
}
}
public RDFStructureParser(Repository repository) {
this.repository = repository;
}
/*
* (non-Javadoc)
*
* @see
* io.redlink.sdk.impl.analysis.model.EnhancementsParser#parseLanguages()
*/
public Collection parseLanguages() throws EnhancementParserException {
Collection languages = Sets.newHashSet();
String textAnnotationsQuery = "PREFIX fise: parseEnhancements()
throws EnhancementParserException {
Multimap relations = ArrayListMultimap.create();
Map enhancementsByUri = Maps.newHashMap();
try {
RepositoryConnection conn = repository.getConnection();
try {
conn.begin();
parseTextAnnotations(conn, relations, enhancementsByUri);
parseEntityAnnotations(conn, relations, enhancementsByUri);
for (Enhancement e : relations.keys()) {
Collection relationsUris = relations.get(e);
Collection relationsEnhans = Sets.newHashSet();
for (String uri : relationsUris) {
relationsEnhans.add(enhancementsByUri.get(uri));
}
e.setRelations(relationsEnhans);
}
conn.commit();
} finally {
conn.close();
}
} catch (RepositoryException e) {
throw new EnhancementParserException(
"Error querying the RDF Model obtained as Service Response",
e);
}
return enhancementsByUri.values();
}
/*
* (non-Javadoc)
*
* @see
* io.redlink.sdk.impl.analysis.model.EnhancementsParser#parseTextAnnotations
* ()
*/
@SuppressWarnings({"unchecked", "rawtypes"})
public Collection parseTextAnnotations()
throws EnhancementParserException {
Multimap relations = ArrayListMultimap.create();
Map enhancementsByUri = Maps.newHashMap();
try {
RepositoryConnection conn = repository.getConnection();
conn.begin();
Collection tas = parseTextAnnotations(conn,
relations, enhancementsByUri);
Collection result = (Collection) resolveRelations(
relations, conn); // Safe Casting
for (TextAnnotation ta : tas)
if (!result.contains(ta))
result.add(ta);
conn.close();
return result;
} catch (RepositoryException e) {
throw new EnhancementParserException(
"Error querying the RDF Model obtained as Service Response",
e);
}
}
private Collection parseTextAnnotations(
RepositoryConnection conn,
Multimap relations,
Map enhancementsByUri)
throws EnhancementParserException {
Collection tas = Sets.newHashSet();
String textAnnotationsQuery = "PREFIX fise: relations)
throws RepositoryException {
if (!relations.containsKey(textAnnotation)) {
setEnhancementData(textAnnotation, result);
if (result.hasBinding("start")) {
textAnnotation.setStarts(Integer.parseInt(result
.getBinding("start").getValue().stringValue()));
textAnnotation.setEnds(Integer.parseInt(result
.getBinding("end").getValue().stringValue()));
}
if (result.hasBinding("relation")) {
String nextRelationUri = result.getBinding("relation")
.getValue().stringValue();
relations.put(textAnnotation, nextRelationUri);
}
if (result.hasBinding("selectionContext")) {
textAnnotation.setSelectionContext(result
.getBinding("selectionContext").getValue()
.stringValue());
}
if (result.hasBinding("selectedText")) {
Binding selectedText = result.getBinding("selectedText");
textAnnotation.setSelectedText(selectedText.getValue()
.stringValue());
if (!result.hasBinding("language")
&& (selectedText.getValue() instanceof Literal))
textAnnotation.setLanguage(((Literal) selectedText
.getValue()).getLanguage());
}
if (result.hasBinding("type")) {
Binding type = result.getBinding("type");
textAnnotation.setType(type.getValue().stringValue());
}
} else {
if (result.hasBinding("relation")) {
String nextRelationUri = result.getBinding("relation")
.getValue().stringValue();
relations.put(textAnnotation, nextRelationUri);
}
}
}
/*
* (non-Javadoc)
*
* @see
* io.redlink.sdk.impl.analysis.model.EnhancementsParser#parseEntityAnnotations
* ()
*/
@SuppressWarnings({"unchecked", "rawtypes"})
public Collection parseEntityAnnotations()
throws EnhancementParserException {
Multimap relations = ArrayListMultimap.create();
Map enhancementsByUri = Maps.newHashMap();
try {
RepositoryConnection conn = repository.getConnection();
conn.begin();
Collection eas = parseEntityAnnotations(conn,
relations, enhancementsByUri);
Collection result = (Collection) resolveRelations(
relations, conn); // Safe Casting
for (EntityAnnotation ea : eas)
if (!result.contains(ea))
result.add(ea);
conn.close();
return result;
} catch (RepositoryException e) {
throw new EnhancementParserException(
"Error querying the RDF Model obtained as Service Response",
e);
}
}
private Collection parseEntityAnnotations(
RepositoryConnection conn,
Multimap relations,
Map enhancementsByUri)
throws EnhancementParserException {
Collection eas = Sets.newHashSet();
String entityAnnotationsQuery = "PREFIX fise: \n"
+ "SELECT * { \n"
+ " ?annotation a fise:EntityAnnotation . \n"
+ " OPTIONAL { ?annotation fise:confidence ?confidence } \n"
+ " OPTIONAL { ?language a dct:language } \n"
+ " OPTIONAL { ?annotation dct:relation ?relation } \n"
+ " OPTIONAL { ?annotation fise:entity-label ?entityLabel } \n"
+ " OPTIONAL { ?annotation fise:entity-reference ?entityReference } \n"
+ " OPTIONAL { ?annotation fise:entity-type ?entityType } \n"
+ " OPTIONAL { ?annotation entityhub:site ?site } \n" + "}";
try {
TupleQueryResult entityAnnotationsResults = conn.prepareTupleQuery(
QueryLanguage.SPARQL, entityAnnotationsQuery).evaluate();
while (entityAnnotationsResults.hasNext()) {
BindingSet result = entityAnnotationsResults.next();
final String uri = result.getBinding("annotation").getValue()
.stringValue();
Enhancement entityAnnotation = enhancementsByUri.get(uri);
if (entityAnnotation == null) {
entityAnnotation = new EntityAnnotation();
enhancementsByUri.put(uri, entityAnnotation);
}
setEntityAnnotationData((EntityAnnotation) entityAnnotation,
result, conn, relations);
if (!eas.contains(entityAnnotation))
eas.add((EntityAnnotation) entityAnnotation);
}
} catch (QueryEvaluationException | MalformedQueryException e) {
throw new EnhancementParserException(
"Error parsing text annotations", e);
} catch (RepositoryException e) {
throw new EnhancementParserException(
"Error querying the RDF Model obtained as Service Response",
e);
}
return eas;
}
private void setEntityAnnotationData(EntityAnnotation entityAnnotation,
BindingSet result, RepositoryConnection conn,
Multimap relations)
throws RepositoryException, EnhancementParserException {
if (!relations.containsKey(entityAnnotation)) {
setEnhancementData(entityAnnotation, result);
if (result.hasBinding("entityLabel")) {
Binding entityLabel = result.getBinding("entityLabel");
entityAnnotation.setEntityLabel(entityLabel.getValue()
.stringValue());
if (!result.hasBinding("language")
&& (entityLabel.getValue() instanceof Literal))
entityAnnotation.setLanguage(((Literal) entityLabel
.getValue()).getLanguage());
}
if (result.hasBinding("site")) {
entityAnnotation.setDataset(result.getBinding("site").getValue()
.stringValue());
}
if (result.hasBinding("entityReference")) {
entityAnnotation
.setEntityReference(parseEntity(conn, result
.getBinding("entityReference").getValue()
.stringValue(),
entityAnnotation.getDataset()));
}
if (result.hasBinding("relation")) {
String nextRelationUri = result.getBinding("relation")
.getValue().stringValue();
relations.put(entityAnnotation, nextRelationUri);
}
Collection types = new HashSet();
if (result.hasBinding("entityType")) {
types.add(result.getBinding("entityType").getValue()
.stringValue());
}
entityAnnotation.setEntityTypes(types);
} else {
if (result.hasBinding("relation")) {
final String nextRelationUri = result.getBinding("relation")
.getValue().stringValue();
if (!relations.containsEntry(entityAnnotation, nextRelationUri))
relations.put(entityAnnotation, nextRelationUri);
}
if (result.hasBinding("entityType")) {
final String entityType = result.getBinding("entityType")
.getValue().stringValue();
Collection types = entityAnnotation.getEntityTypes();
Optional eType = Iterables.tryFind(types,
new Predicate() {
@Override
public boolean apply(String arg0) {
return arg0.equals(entityType);
}
});
if (!eType.isPresent())
types.add(entityType);
}
}
}
private Collection resolveRelations(
Multimap relations, RepositoryConnection conn)
throws EnhancementParserException {
Queue toParse = new LinkedList();
toParse.addAll(Sets.newHashSet(relations.values()));
Map allRelations = new HashMap();
Collection initialEnhancements = relations.keys();
while (!toParse.isEmpty()) {
String nextRelation = toParse.poll();
Enhancement nextEnhancement = parseEnhancement(nextRelation, conn,
toParse, relations);
if (nextEnhancement != null)
allRelations.put(nextRelation, nextEnhancement);
}
for (Enhancement e : relations.keys()) {
Collection relationsUris = relations.get(e);
Collection nextRelEnhancements = Sets.newHashSet();
for (String uri : relationsUris)
if (uri != null)
nextRelEnhancements.add(allRelations.get(uri));
e.setRelations(nextRelEnhancements);
}
return initialEnhancements;
}
private Enhancement parseEnhancement(String nextRelation,
RepositoryConnection conn, Queue toParse,
Multimap relations)
throws EnhancementParserException {
String enhancementQuery = "PREFIX fise: toParse,
Multimap relations)
throws RepositoryException, EnhancementParserException {
TextAnnotation enhancement = new TextAnnotation();
String textAnnotationQuery = "PREFIX fise: \n"
+ "SELECT * { \n OPTIONAL { <"
+ taUri
+ "> fise:confidence ?confidence } \n"
+ " OPTIONAL { <"
+ taUri
+ "> dct:language ?language } \n"
+ " OPTIONAL { <"
+ taUri
+ "> fise:start ?start ; fise:end ?end } \n"
+ " OPTIONAL { <"
+ taUri
+ "> dct:type ?type } \n"
+ " OPTIONAL { <"
+ taUri
+ "> dct:relation ?relation } \n"
+ " OPTIONAL { <"
+ taUri
+ "> fise:selection-context ?selectionContext } \n"
+ " OPTIONAL { <"
+ taUri
+ "> fise:selected-text ?selectedText } \n" + "}";
try {
TupleQueryResult textAnnotationResults = conn.prepareTupleQuery(
QueryLanguage.SPARQL, textAnnotationQuery).evaluate();
while (textAnnotationResults.hasNext()) {
BindingSet result = textAnnotationResults.next();
int i = 0;
if (i == 0) {
setEnhancementData(enhancement, result);
if (result.hasBinding("start")) {
enhancement.setStarts(Integer.parseInt(result
.getBinding("start").getValue().stringValue()));
enhancement.setEnds(Integer.parseInt(result
.getBinding("end").getValue().stringValue()));
}
if (result.hasBinding("relation")) {
String nextRelationUri = result.getBinding("relation")
.getValue().stringValue();
if (!relations.values().contains(nextRelationUri))
toParse.add(nextRelationUri);
relations.put(enhancement, nextRelationUri);
}
if (result.hasBinding("selectionContext")) {
enhancement.setSelectionContext(result
.getBinding("selectionContext").getValue()
.stringValue());
}
if (result.hasBinding("selectedText")) {
Binding selectedText = result
.getBinding("selectedText");
enhancement.setSelectedText(selectedText.getValue()
.stringValue());
if (!result.hasBinding("language")
&& (selectedText.getValue() instanceof Literal))
enhancement.setLanguage(((Literal) selectedText
.getValue()).getLanguage());
}
} else {
if (result.hasBinding("relation")) {
String nextRelationUri = result.getBinding("relation")
.getValue().stringValue();
if (!relations.values().contains(nextRelationUri))
toParse.add(nextRelationUri);
relations.put(enhancement, nextRelationUri);
}
}
i++;
}
} catch (QueryEvaluationException | MalformedQueryException e) {
throw new EnhancementParserException(
"Error parsing text annotation with URI: " + taUri, e);
}
return enhancement;
}
private EntityAnnotation parseEntityAnnotation(String eaUri,
RepositoryConnection conn, Queue toParse,
Multimap relations)
throws RepositoryException, EnhancementParserException {
EntityAnnotation enhancement = new EntityAnnotation();
String entityAnnotationsQuery = "PREFIX fise: \n"
+ "SELECT * { \n OPTIONAL { <"
+ eaUri
+ "> fise:confidence ?confidence ; \n"
+ eaUri
+ "> dct:language ?language . \n"
+ " OPTIONAL { <"
+ eaUri
+ "> dct:relation ?relation } \n"
+ " OPTIONAL { <"
+ eaUri
+ "> fise:entity-label ?entityLabel } \n"
+ " OPTIONAL { <"
+ eaUri
+ "> fise:entity-reference ?entityReference } \n"
+ " OPTIONAL { <"
+ eaUri
+ "> fise:entity-type ?entityType } \n"
+ " OPTIONAL { <"
+ eaUri + "> entityhub:site ?site } \n" + "}";
try {
TupleQueryResult entityAnnotationsResults = conn.prepareTupleQuery(
QueryLanguage.SPARQL, entityAnnotationsQuery).evaluate();
int i = 0;
while (entityAnnotationsResults.hasNext()) {
BindingSet result = entityAnnotationsResults.next();
if (i == 0) {
setEnhancementData(enhancement, result);
if (result.hasBinding("entityLabel")) {
Binding entityLabel = result.getBinding("entityLabel");
enhancement.setEntityLabel(entityLabel.getValue()
.stringValue());
if (!result.hasBinding("language")
&& (entityLabel.getValue() instanceof Literal))
enhancement.setLanguage(((Literal) entityLabel
.getValue()).getLanguage());
}
if (result.hasBinding("site")) {
enhancement.setDataset(result.getBinding("site")
.getValue().stringValue());
}
if (result.hasBinding("entityReference")) {
enhancement.setEntityReference(parseEntity(conn, result
.getBinding("entityReference").getValue()
.stringValue(),
enhancement.getDataset()));
}
if (result.hasBinding("relation")) {
String nextRelationUri = result.getBinding("relation")
.getValue().stringValue();
if (!relations.values().contains(nextRelationUri))
toParse.add(nextRelationUri);
relations.put(enhancement, nextRelationUri);
}
if (result.hasBinding("entityType")) {
Collection types = new HashSet();
types.add(result.getBinding("entityType").getValue()
.stringValue());
enhancement.setEntityTypes(types);
}
} else {
if (result.hasBinding("relation")) {
String nextRelationUri = result.getBinding("relation")
.getValue().stringValue();
Collection eRelations = relations
.get(enhancement);
if (!eRelations.contains(nextRelationUri)) {
if (!relations.values().contains(nextRelationUri))
toParse.add(nextRelationUri);
relations.put(enhancement, nextRelationUri);
}
}
if (result.hasBinding("entityType")) {
String nextType = result.getBinding("entityType")
.getValue().stringValue();
if (!enhancement.getEntityTypes().contains(nextType))
enhancement.getEntityTypes().add(nextType);
}
}
i++;
}
} catch (QueryEvaluationException | MalformedQueryException e) {
throw new EnhancementParserException(
"Error parsing entity annotation with URI: " + eaUri, e);
}
return enhancement;
}
/*
* (non-Javadoc)
*
* @see
* io.redlink.sdk.impl.analysis.model.EnhancementsParser#parseEntity(java
* .lang.String)
*/
public Entity parseEntity(String entityUri, String dataset)
throws EnhancementParserException {
try {
RepositoryConnection conn = repository.getConnection();
conn.begin();
Entity result = parseEntity(conn, entityUri, dataset);
conn.close();
return result;
} catch (RepositoryException e) {
throw new EnhancementParserException(
"Error querying the RDF Model obtained as Service Response",
e);
}
}
private Entity parseEntity(RepositoryConnection conn, String entityUri, String dataset)
throws EnhancementParserException {
String entityQuery = "SELECT ?p ?o { \n" + " <" + entityUri
+ "> ?p ?o ; \n" + "}";
Entity entity = new Entity(entityUri, dataset);
try {
TupleQueryResult entityResults = conn.prepareTupleQuery(
QueryLanguage.SPARQL, entityQuery).evaluate();
while (entityResults.hasNext()) {
BindingSet result = entityResults.next();
Value object = result.getBinding("o").getValue();
if (object instanceof LiteralImpl) {
String language = ((LiteralImpl) object).getLanguage();
if (language == null) {
entity.addPropertyValue(result.getBinding("p")
.getValue().stringValue(), object.stringValue());
} else {
entity.addPropertyValue(result.getBinding("p")
.getValue().stringValue(), language,
object.stringValue());
}
} else {
entity.addPropertyValue(result.getBinding("p").getValue()
.stringValue(), object.stringValue());
}
}
} catch (QueryEvaluationException | MalformedQueryException e) {
throw new EnhancementParserException(
"Error parsing text annotations", e);
} catch (RepositoryException e) {
throw new EnhancementParserException(
"Error querying the RDF Model obtained as Service Response",
e);
}
return entity;
}
private void setEnhancementData(Enhancement enhancement, BindingSet result) {
if (result.hasBinding("confidence")) {
enhancement.setConfidence(Double.parseDouble(result
.getBinding("confidence").getValue().stringValue()));
} else {
enhancement.setConfidence(1.0); // Rupert says this should be the default value...
}
enhancement.setLanguage(result.getBinding("language") != null ? result
.getBinding("language").getValue().stringValue() : null);
}
/*
* (non-Javadoc)
* @see io.redlink.sdk.impl.analysis.model.EnhancementsParser#parseTopicAnnotation()
*/
@SuppressWarnings({"rawtypes", "unchecked"})
@Override
public Collection parseTopicAnnotation()
throws EnhancementParserException {
Multimap relations = ArrayListMultimap.create();
Map enhancementsByUri = Maps.newHashMap();
try {
RepositoryConnection conn = repository.getConnection();
conn.begin();
Collection tas = parseTopicAnnotations(conn,
relations, enhancementsByUri);
Collection result = (Collection) resolveRelations(
relations, conn); // Safe Casting
for (TopicAnnotation ta : tas)
if (!result.contains(ta))
result.add(ta);
conn.close();
return result;
} catch (RepositoryException e) {
throw new EnhancementParserException(
"Error querying the RDF Model obtained as Service Response",
e);
}
}
private Collection parseTopicAnnotations(
RepositoryConnection conn, Multimap relations,
Map enhancementsByUri) throws EnhancementParserException {
Collection tas = Sets.newHashSet();
String topicAnnotationsQuery = "PREFIX fise: \n"
+ "SELECT * { \n"
+ " ?annotation a fise:TopicAnnotation . \n"
+ " OPTIONAL { fise:confidence ?confidence } \n"
+ " OPTIONAL { ?language a dct:language } \n"
+ " OPTIONAL { ?annotation dct:relation ?relation } \n"
+ " OPTIONAL { ?annotation fise:entity-label ?entityLabel } \n"
+ " OPTIONAL { ?annotation fise:entity-reference ?entityReference } \n"
+ " OPTIONAL { ?annotation entityhub:site ?site } \n" + "}";
try {
TupleQueryResult topicAnnotationsResults = conn.prepareTupleQuery(
QueryLanguage.SPARQL, topicAnnotationsQuery).evaluate();
while (topicAnnotationsResults.hasNext()) {
BindingSet result = topicAnnotationsResults.next();
final String uri = result.getBinding("annotation").getValue()
.stringValue();
Enhancement topicAnnotation = enhancementsByUri.get(uri);
if (topicAnnotation == null) {
topicAnnotation = new TopicAnnotation();
enhancementsByUri.put(uri, topicAnnotation);
}
setTopicAnnotationData((TopicAnnotation) topicAnnotation,
result, conn, relations);
if (!tas.contains(topicAnnotation))
tas.add((TopicAnnotation) topicAnnotation);
}
} catch (QueryEvaluationException | MalformedQueryException e) {
throw new EnhancementParserException(
"Error parsing text annotations", e);
} catch (RepositoryException e) {
throw new EnhancementParserException(
"Error querying the RDF Model obtained as Service Response",
e);
}
return tas;
}
private void setTopicAnnotationData(TopicAnnotation topicAnnotation,
BindingSet result, RepositoryConnection conn,
Multimap relations) {
if (!relations.containsKey(topicAnnotation)) {
setEnhancementData(topicAnnotation, result);
if (result.hasBinding("entityLabel")) {
Binding entityLabel = result.getBinding("entityLabel");
topicAnnotation.setTopicLabel(entityLabel.getValue()
.stringValue());
if (!result.hasBinding("language")
&& (entityLabel.getValue() instanceof Literal))
topicAnnotation.setLanguage(((Literal) entityLabel
.getValue()).getLanguage());
}
if (result.hasBinding("entityReference")) {
topicAnnotation
.setTopicReference(result
.getBinding("entityReference").getValue()
.stringValue());
}
if (result.hasBinding("relation")) {
String nextRelationUri = result.getBinding("relation")
.getValue().stringValue();
relations.put(topicAnnotation, nextRelationUri);
}
if (result.hasBinding("site")) {
topicAnnotation.setDataset(result.getBinding("site").getValue()
.stringValue());
}
} else {
if (result.hasBinding("relation")) {
final String nextRelationUri = result.getBinding("relation")
.getValue().stringValue();
if (!relations.containsEntry(topicAnnotation, nextRelationUri))
relations.put(topicAnnotation, nextRelationUri);
}
}
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy