Examples with Literal org.apache.clerezza.commons.rdf.Literal used on opensource projects

Example 36 with Literal

use of org.apache.clerezza.commons.rdf.Literal in project stanbol by apache.

the class CeliLemmatizerEnhancementEngineTest method validateLemmaFormProperty.

/**
     * [1..*] values of an {@link PlainLiteral} in the same language as the
     * analyzed text
     * @param enhancements The graph with the enhancements
     * @param textAnnotation the TextAnnotation to check
     * @param lang the language of the analyzed text
     * @return The number of lemma forms found
     */
private int validateLemmaFormProperty(Graph enhancements, BlankNodeOrIRI textAnnotation, String lang) {
    Iterator<Triple> lemmaFormsIterator = enhancements.filter(textAnnotation, hasLemmaForm, null);
    assertTrue("No lemma form value found for TextAnnotation " + textAnnotation + "!", lemmaFormsIterator.hasNext());
    int lemmaFormCount = 0;
    while (lemmaFormsIterator.hasNext()) {
        lemmaFormCount++;
        RDFTerm lemmaForms = lemmaFormsIterator.next().getObject();
        assertTrue("Lemma Forms value are expected of type Literal", lemmaForms instanceof Literal);
        assertFalse("Lemma forms MUST NOT be empty", ((Literal) lemmaForms).getLexicalForm().isEmpty());
        assertNotNull("Language of the Lemma Form literal MUST BE not null", ((Literal) lemmaForms).getLanguage());
        assertEquals("Language of the Lemma Form literal MUST BE the same as for the parsed text", lang, ((Literal) lemmaForms).getLanguage().toString());
    }
    return lemmaFormCount;
}

Example 37 with Literal

use of org.apache.clerezza.commons.rdf.Literal in project stanbol by apache.

the class SpotlightEngineUtils method createEntityAnnotation.

/**
	 * Creates a fise:EntityAnnotation for the parsed parameters and
     * adds it the the {@link ContentItem#getMetadata()}. <p>
     * This method assumes a write lock on the parsed content item.
	 * @param resource the candidate resource
	 * @param engine the engine
	 * @param ci the content item
	 * @param textAnnotation the fise:TextAnnotation to dc:relate the
	 * created fise:EntityAnnotation
	 * @return the URI of the created fise:TextAnnotation
	 */
public static IRI createEntityAnnotation(CandidateResource resource, EnhancementEngine engine, ContentItem ci, IRI textAnnotation) {
    IRI entityAnnotation = EnhancementEngineHelper.createEntityEnhancement(ci, engine);
    Graph model = ci.getMetadata();
    Literal label = new PlainLiteralImpl(resource.label, new Language("en"));
    model.add(new TripleImpl(entityAnnotation, DC_RELATION, textAnnotation));
    model.add(new TripleImpl(entityAnnotation, ENHANCER_ENTITY_LABEL, label));
    model.add(new TripleImpl(entityAnnotation, ENHANCER_ENTITY_REFERENCE, resource.getUri()));
    model.add(new TripleImpl(entityAnnotation, PROPERTY_CONTEXTUAL_SCORE, literalFactory.createTypedLiteral(resource.contextualScore)));
    model.add(new TripleImpl(entityAnnotation, PROPERTY_PERCENTAGE_OF_SECOND_RANK, literalFactory.createTypedLiteral(resource.percentageOfSecondRank)));
    model.add(new TripleImpl(entityAnnotation, PROPERTY_SUPPORT, literalFactory.createTypedLiteral(resource.support)));
    model.add(new TripleImpl(entityAnnotation, PROPERTY_PRIOR_SCORE, literalFactory.createTypedLiteral(resource.priorScore)));
    model.add(new TripleImpl(entityAnnotation, PROPERTY_FINAL_SCORE, literalFactory.createTypedLiteral(resource.finalScore)));
    return entityAnnotation;
}

Example 38 with Literal

use of org.apache.clerezza.commons.rdf.Literal in project stanbol by apache.

the class DBPSpotlightDisambiguateEnhancementEngine method createEnhancements.

/**
	 * The method adds the returned DBpedia Spotlight annotations to the content
	 * item's metadata. For each DBpedia resource an EntityAnnotation is created
	 * and linked to the according TextAnnotation.
	 * 
	 * @param occs
	 *            a Collection of entity information
	 * @param ci
	 *            the content item
	 */
public void createEnhancements(Collection<Annotation> occs, ContentItem ci, Language language) {
    HashMap<RDFTerm, IRI> entityAnnotationMap = new HashMap<RDFTerm, IRI>();
    for (Annotation occ : occs) {
        if (textAnnotationsMap.get(occ.surfaceForm) != null) {
            IRI textAnnotation = textAnnotationsMap.get(occ.surfaceForm);
            Graph model = ci.getMetadata();
            IRI entityAnnotation = EnhancementEngineHelper.createEntityEnhancement(ci, this);
            entityAnnotationMap.put(occ.uri, entityAnnotation);
            Literal label = new PlainLiteralImpl(occ.surfaceForm.name, language);
            model.add(new TripleImpl(entityAnnotation, DC_RELATION, textAnnotation));
            model.add(new TripleImpl(entityAnnotation, ENHANCER_ENTITY_LABEL, label));
            Collection<String> t = occ.getTypeNames();
            if (t != null) {
                Iterator<String> it = t.iterator();
                while (it.hasNext()) model.add(new TripleImpl(entityAnnotation, ENHANCER_ENTITY_TYPE, new IRI(it.next())));
            }
            model.add(new TripleImpl(entityAnnotation, ENHANCER_ENTITY_REFERENCE, occ.uri));
        }
    }
}

Example 39 with Literal

use of org.apache.clerezza.commons.rdf.Literal in project stanbol by apache.

the class KeywordLinkingEngineTest method validateAllEntityAnnotations.

/**
     * Similar to {@link EnhancementStructureHelper#validateAllEntityAnnotations(org.apache.clerezza.commons.rdf.Graph, Map)}
     * but in addition checks fise:confidence [0..1] and entityhub:site properties
     * @param ci
     * @param expectedValues
     * @return
     */
private static int validateAllEntityAnnotations(ContentItem ci, Map<IRI, RDFTerm> expectedValues) {
    Iterator<Triple> entityAnnotationIterator = ci.getMetadata().filter(null, RDF_TYPE, ENHANCER_ENTITYANNOTATION);
    int entityAnnotationCount = 0;
    while (entityAnnotationIterator.hasNext()) {
        IRI entityAnnotation = (IRI) entityAnnotationIterator.next().getSubject();
        // test if selected Text is added
        validateEntityAnnotation(ci.getMetadata(), entityAnnotation, expectedValues);
        //validate also that the confidence is between [0..1]
        Iterator<Triple> confidenceIterator = ci.getMetadata().filter(entityAnnotation, ENHANCER_CONFIDENCE, null);
        //Confidence is now checked by the EnhancementStructureHelper (STANBOL-630)
        //            assertTrue("Expected fise:confidence value is missing (entityAnnotation "
        //                    +entityAnnotation+")",confidenceIterator.hasNext());
        //            Double confidence = LiteralFactory.getInstance().createObject(Double.class,
        //                (TypedLiteral)confidenceIterator.next().getObject());
        //            assertTrue("fise:confidence MUST BE <= 1 (value= '"+confidence
        //                    + "',entityAnnotation " +entityAnnotation+")",
        //                    1.0 >= confidence.doubleValue());
        //            assertTrue("fise:confidence MUST BE >= 0 (value= '"+confidence
        //                    +"',entityAnnotation "+entityAnnotation+")",
        //                    0.0 <= confidence.doubleValue());
        //Test the entityhub:site property (STANBOL-625)
        IRI ENTITYHUB_SITE = new IRI(RdfResourceEnum.site.getUri());
        Iterator<Triple> entitySiteIterator = ci.getMetadata().filter(entityAnnotation, ENTITYHUB_SITE, null);
        assertTrue("Expected entityhub:site value is missing (entityAnnotation " + entityAnnotation + ")", entitySiteIterator.hasNext());
        RDFTerm siteResource = entitySiteIterator.next().getObject();
        assertTrue("entityhub:site values MUST BE Literals", siteResource instanceof Literal);
        assertEquals("'" + TEST_REFERENCED_SITE_NAME + "' is expected as " + "entityhub:site value", TEST_REFERENCED_SITE_NAME, ((Literal) siteResource).getLexicalForm());
        assertFalse("entityhub:site MUST HAVE only a single value", entitySiteIterator.hasNext());
        entityAnnotationCount++;
    }
    return entityAnnotationCount;
}

Example 40 with Literal

use of org.apache.clerezza.commons.rdf.Literal in project stanbol by apache.

the class EnhancementStructureHelper method validateTextAnnotation.

/**
     * Validates fise:TextAnnotations. If <code>validatePrefixSuffix</code> is
     * enabled the fise:selection-prefix and fise:selection-suffix (as defined by
     * <a href="https://issues.apache.org/jira/browse/STANBOL-987">STANBOL-987</a>
     * are enforced and validated. If disabled those properties are not enforced but still
     * validated when present.
     * @param enhancements the enhancements graph containing the text annotation
     * @param textAnnotation the TextAnnotation to validate
     * @param content the enhanced content
     * @param expectedValues expected values (properties for the values are used as keys)
     * @param validatePrefixSuffix enforce the presence of fise:selection-prefix and 
     * fise:selection-suffix if fise:start and fise:end are set.
     */
public static void validateTextAnnotation(Graph enhancements, IRI textAnnotation, String content, Map<IRI, RDFTerm> expectedValues, boolean validatePrefixSuffix) {
    //validate the rdf:type
    Iterator<Triple> rdfTypeIterator = enhancements.filter(textAnnotation, RDF_TYPE, ENHANCER_TEXTANNOTATION);
    assertTrue("Parsed Enhancement " + textAnnotation + " is missing the fise:TextAnnotation type ", rdfTypeIterator.hasNext());
    Iterator<Triple> selectedTextIterator = enhancements.filter(textAnnotation, ENHANCER_SELECTED_TEXT, null);
    // check if the selected text is added (or not)
    RDFTerm selectedTextResource;
    if (selectedTextIterator.hasNext()) {
        // test if the selected text is part of the TEXT_TO_TEST
        selectedTextResource = selectedTextIterator.next().getObject();
        assertTrue("fise:selected-text MUST BE of type PlainLiteral (uri: " + textAnnotation + ")", selectedTextResource instanceof Literal);
        Literal selectedText = (Literal) selectedTextResource;
        assertTrue("The parsed content MUST contain the fise:selected-text value '" + selectedText.getLexicalForm() + "' (uri: " + textAnnotation + ")!", content.contains(selectedText.getLexicalForm()));
        Assert.assertFalse("fise:selected-text MUST be single valued (uri: " + textAnnotation + ")", selectedTextIterator.hasNext());
    } else {
        //no selected text
        selectedTextResource = null;
    }
    //check against an expected value
    RDFTerm expectedSelectedText = expectedValues.get(ENHANCER_SELECTED_TEXT);
    if (expectedSelectedText != null) {
        assertEquals("The fise:selected-text is not the expected value " + expectedSelectedText + " (uri: " + textAnnotation + ")!", expectedSelectedText, selectedTextResource);
    }
    //check for fise:selection-head and fise:selection-tail (STANBOL-987)
    Iterator<Triple> selectionHeadIterator = enhancements.filter(textAnnotation, Properties.ENHANCER_SELECTION_HEAD, null);
    if (selectedTextResource != null) {
        Assert.assertFalse("If fise:selected-text is present fise:selection-head MUST NOT be present", selectionHeadIterator.hasNext());
    }
    RDFTerm selectionHeadResource;
    if (selectionHeadIterator.hasNext()) {
        // test if the selected text is part of the TEXT_TO_TEST
        selectionHeadResource = selectionHeadIterator.next().getObject();
        assertTrue("fise:selection-head MUST BE of type PlainLiteral (uri: " + textAnnotation + ")", selectionHeadResource instanceof Literal);
        Literal selectionHeadText = (Literal) selectionHeadResource;
        assertTrue("The parsed content MUST contain the fise:selected-head value '" + selectionHeadText.getLexicalForm() + "' (uri: " + textAnnotation + ")!", content.contains(selectionHeadText.getLexicalForm()));
        Assert.assertFalse("fise:selection-head MUST be single valued (uri: " + textAnnotation + ")", selectionHeadIterator.hasNext());
    } else {
        selectionHeadResource = null;
    }
    Iterator<Triple> selectionTailIterator = enhancements.filter(textAnnotation, Properties.ENHANCER_SELECTION_TAIL, null);
    if (selectedTextResource != null) {
        Assert.assertFalse("If fise:selected-text is present fise:selection-tail MUST NOT be present", selectionTailIterator.hasNext());
    }
    RDFTerm selectionTailResource;
    if (selectionTailIterator.hasNext()) {
        // test if the selected text is part of the TEXT_TO_TEST
        selectionTailResource = selectionTailIterator.next().getObject();
        assertTrue("fise:selection-head MUST BE of type PlainLiteral (uri: " + textAnnotation + ")", selectionTailResource instanceof Literal);
        Literal selectionTailText = (Literal) selectionTailResource;
        assertTrue("The parsed content MUST contain the fise:selected-tail value '" + selectionTailText.getLexicalForm() + "' (uri: " + textAnnotation + ")!", content.contains(selectionTailText.getLexicalForm()));
        Assert.assertFalse("fise:selection-tail MUST be single valued (uri: " + textAnnotation + ")", selectionTailIterator.hasNext());
    } else {
        selectionTailResource = null;
    }
    Assert.assertTrue("Both fise:selection-tail AND fise:selection-head MUST BE defined " + "(if one of them is present) (uri: " + textAnnotation + ")", (selectionHeadResource != null && selectionTailResource != null) || (selectionHeadResource == null && selectionTailResource == null));
    RDFTerm selectionContextResource;
    // test if context is added
    Iterator<Triple> selectionContextIterator = enhancements.filter(textAnnotation, ENHANCER_SELECTION_CONTEXT, null);
    if (selectionContextIterator.hasNext()) {
        //context is optional
        //selection context is not allowed without selected-text
        assertTrue("If fise:selection-context is present also fise:selected-text or fise:selection-head and fise:selection-tail MUST BE present (uri: " + textAnnotation + ")", selectedTextResource != null || (selectionHeadResource != null && selectionTailResource != null));
        // test if the selected text is part of the TEXT_TO_TEST
        selectionContextResource = selectionContextIterator.next().getObject();
        assertTrue("The fise:selection-context MUST BE of type PlainLiteral (uri: " + textAnnotation + ")", selectionContextResource instanceof Literal);
        //check that the content contains the context
        assertTrue("The fise:selection-context MUST BE contained in the Content | context= " + selectionContextResource, content.contains(((Literal) selectionContextResource).getLexicalForm()));
        //check that the context contains the selected text
        if (selectedTextResource != null) {
            assertTrue("The fise:selected-text value MUST BE containted within the fise:selection-context value", ((Literal) selectionContextResource).getLexicalForm().contains(((Literal) selectedTextResource).getLexicalForm()));
        }
        if (selectionHeadResource != null) {
            assertTrue("The fise:selection-head value MUST BE containted within the fise:selection-context value", ((Literal) selectionContextResource).getLexicalForm().contains(((Literal) selectionHeadResource).getLexicalForm()));
        }
        if (selectionTailResource != null) {
            assertTrue("The fise:selection-tail value MUST BE containted within the fise:selection-context value", ((Literal) selectionContextResource).getLexicalForm().contains(((Literal) selectionTailResource).getLexicalForm()));
        }
    } else {
        assertNull("If no fise:selection-context is present also fise:selected-text MUST BE NOT present!", selectedTextResource);
        selectionContextResource = null;
    }
    RDFTerm expectedSelectionContext = expectedValues.get(ENHANCER_SELECTION_CONTEXT);
    if (expectedSelectionContext != null) {
        assertEquals("The value of fise:selection-context has not the expected value " + expectedSelectionContext, expectedSelectionContext, selectionContextResource);
    }
    //test start/end if present
    Iterator<Triple> startPosIterator = enhancements.filter(textAnnotation, ENHANCER_START, null);
    Iterator<Triple> endPosIterator = enhancements.filter(textAnnotation, ENHANCER_END, null);
    //start end is optional, but if start is present, that also end needs to be set
    Literal startPosLiteral;
    Literal endPosLiteral;
    if (startPosIterator.hasNext()) {
        //NOTE: TextAnnotations might be use to select whole sections of a text
        //      (e.g. see STANBOL-617) in those cases adding the text of the
        //      whole section is not feasible.
        //assertNotNull("If fise:start is present the fise:selection-context MUST also be present (uri: "+textAnnotation+")!",
        //    selectionContextResource);
        RDFTerm resource = startPosIterator.next().getObject();
        //only a single start position is supported
        assertFalse("fise:start MUST HAVE only a single value (uri: " + textAnnotation + ")!", startPosIterator.hasNext());
        assertTrue("fise:start MUST be a typed Literal (uri: " + textAnnotation + ")!", resource instanceof Literal);
        startPosLiteral = (Literal) resource;
        assertEquals("fise:start MUST use xsd:int as data type (uri: " + textAnnotation + ")", XSD.int_, startPosLiteral.getDataType());
        resource = null;
        Integer start = LiteralFactory.getInstance().createObject(Integer.class, startPosLiteral);
        assertNotNull("Unable to parse Integer from TypedLiteral " + startPosLiteral, start);
        //now get the end
        //end must be defined if start is present
        assertTrue("If fise:start is present also fise:end MUST BE defined (uri: " + textAnnotation + ")!", endPosIterator.hasNext());
        resource = endPosIterator.next().getObject();
        //only a single end position is supported
        assertFalse("fise:end MUST HAVE only a single value (uri: " + textAnnotation + ")!", endPosIterator.hasNext());
        assertTrue("fise:end values MUST BE TypedLiterals (uri: " + textAnnotation + ")", resource instanceof Literal);
        endPosLiteral = (Literal) resource;
        assertEquals("fise:end MUST use xsd:int as data type (uri: " + textAnnotation + ")", XSD.int_, endPosLiteral.getDataType());
        resource = null;
        Integer end = LiteralFactory.getInstance().createObject(Integer.class, endPosLiteral);
        assertNotNull("Unable to parse Integer from TypedLiteral " + endPosLiteral, end);
        //System.out.println("TA ["+start+"|"+end+"]"+selectedText.getLexicalForm()+"<->"+content.substring(start,end));
        if (selectedTextResource != null) {
            assertEquals("the substring [fise:start,fise:end] does not correspond to " + "the fise:selected-text value '" + ((Literal) selectedTextResource).getLexicalForm() + "' of this TextAnnotation!", content.substring(start, end), ((Literal) selectedTextResource).getLexicalForm());
        }
    // else no selected-text present ... unable to test this
    } else {
        assertNull("if fise:selected-text is present also fise:start AND fise:end MUST BE present!", selectedTextResource);
        assertNull("If fise:selection-context is present also fise:start AND fise:end MUST BE present!", selectionContextResource);
        assertFalse("if fise:end is presnet also fise:start AND fise:selection-context MUST BE present!", endPosIterator.hasNext());
        startPosLiteral = null;
        endPosLiteral = null;
    }
    RDFTerm expectedStartPos = expectedValues.get(ENHANCER_START);
    if (expectedStartPos != null) {
        assertEquals("The fise:start value is not the expected " + expectedStartPos, expectedStartPos, startPosLiteral);
    }
    RDFTerm expectedEndPos = expectedValues.get(ENHANCER_END);
    if (expectedEndPos != null) {
        assertEquals("The fise:end value is not the expected " + expectedEndPos, expectedEndPos, endPosLiteral);
    }
    //fise:selection-prefix and fise:selection-suffix (STANBOL-987)
    Literal prefixLiteral;
    Iterator<Triple> selectionPrefixIterator = enhancements.filter(textAnnotation, Properties.ENHANCER_SELECTION_PREFIX, null);
    if (startPosLiteral != null) {
        // check if the selectionPrefix text is present
        assertTrue("fise:selection-prefix property is missing for fise:TextAnnotation " + textAnnotation, selectionPrefixIterator.hasNext() || //to support old and new fise:TextAnnotation model
        !validatePrefixSuffix);
        // test if the selected text is part of the TEXT_TO_TEST
        if (selectionPrefixIterator.hasNext()) {
            RDFTerm selectionPrefixResource = selectionPrefixIterator.next().getObject();
            assertTrue("fise:selection-prefix MUST BE of type PlainLiteral (uri: " + textAnnotation + ")", selectionPrefixResource instanceof Literal);
            prefixLiteral = (Literal) selectionPrefixResource;
            assertTrue("The parsed content MUST contain the fise:selection-prefix value '" + prefixLiteral.getLexicalForm() + "' (uri: " + textAnnotation + ")!", content.contains(prefixLiteral.getLexicalForm()));
            assertFalse("fise:selection-prefix MUST BE single valued (uri: " + textAnnotation + ")!", selectionPrefixIterator.hasNext());
        } else {
            prefixLiteral = null;
        }
    } else {
        prefixLiteral = null;
    }
    Literal suffixLiteral;
    Iterator<Triple> selectionSuffixIterator = enhancements.filter(textAnnotation, Properties.ENHANCER_SELECTION_SUFFIX, null);
    if (endPosLiteral != null) {
        // check if the selectionPrefix text is present
        assertTrue("fise:selection-suffix property is missing for fise:TextAnnotation " + textAnnotation, selectionSuffixIterator.hasNext() || //to support old and new fise:TextAnnotation model
        !validatePrefixSuffix);
        if (selectionSuffixIterator.hasNext()) {
            // test if the selected text is part of the TEXT_TO_TEST
            RDFTerm selectionSuffixResource = selectionSuffixIterator.next().getObject();
            assertTrue("fise:selection-suffix MUST BE of type PlainLiteral (uri: " + textAnnotation + ")", selectionSuffixResource instanceof Literal);
            suffixLiteral = (Literal) selectionSuffixResource;
            assertTrue("The parsed content MUST contain the fise:selection-suffix value '" + suffixLiteral.getLexicalForm() + "' (uri: " + textAnnotation + ")!", content.contains(suffixLiteral.getLexicalForm()));
            assertFalse("fise:selection-suffix MUST BE single valued (uri: " + textAnnotation + ")!", selectionSuffixIterator.hasNext());
        } else {
            suffixLiteral = null;
        }
    } else {
        suffixLiteral = null;
    }
    Assert.assertTrue("Both fise:selection-prefix AND fise:selection-suffix need to be present " + "(if one of them is present) (uri: " + textAnnotation + ")", (suffixLiteral != null && prefixLiteral != null) || (suffixLiteral == null && prefixLiteral == null));
    if (prefixLiteral != null && selectedTextResource != null) {
        String occurrence = prefixLiteral.getLexicalForm() + ((Literal) selectedTextResource).getLexicalForm() + suffixLiteral.getLexicalForm();
        assertTrue("The parsed content MUST contain the concated value of fise:selection-prefix," + "fise:selected-text and fise:selection-suffix (value: '" + occurrence + "' (uri: " + textAnnotation + ")!", content.contains(occurrence));
    }
    if (prefixLiteral != null && selectionHeadResource != null) {
        String occurrence = prefixLiteral.getLexicalForm() + ((Literal) selectionHeadResource).getLexicalForm();
        assertTrue("The parsed content MUST contain the concated value of fise:selection-prefix," + "fise:selection-head (value: '" + occurrence + "' (uri: " + textAnnotation + ")!", content.contains(occurrence));
        occurrence = ((Literal) selectionTailResource).getLexicalForm() + suffixLiteral.getLexicalForm();
        assertTrue("The parsed content MUST contain the concated value of fise:selection-tail " + "and fise:selection-suffix (value: '" + occurrence + "' (uri: " + textAnnotation + ")!", content.contains(occurrence));
    }
    //validate fise:Enhancement specific rules
    validateEnhancement(enhancements, textAnnotation, expectedValues);
    //validate for special TextAnnotations
    validateLanguageAnnotations(enhancements, textAnnotation);
    validateNERAnnotations(enhancements, textAnnotation, selectedTextResource);
}