Le principe est simple : arriver à exécuter une requête SPARQL puis traiter les résultats correspondants pour en faire un tableau de données. Ce tableau de données pourra ensuite être exporté, combiné, enregistré, comme vous le souhaitez.

Pour illustrer cela nous allons interroger Wikidata au travers de son service d’interrogation SPARQL en utilisant sa première requête d’exemple qui récupère… les chats !

La requête est la suivante, et voici le lien direct pour l’exécuter dans Wikidata :

SELECT ?item ?itemLabel
WHERE {
  ?item wdt:P31 wd:Q146.
  SERVICE wikibase:label { bd:serviceParam wikibase:language "[AUTO_LANGUAGE],en". }
}
LIMIT 10

Vous pouvez télécharger le job présenté ici dans ce repository Github d’exemple, et l’importer directement dans Talend.

Nous allons utiliser les composants Talend suivant :

• tRESTClient envoie des requêtes HTTP à un service REST et retourne les réponses; en effet, un service SPARQL n’est ni plus ni moins qu’une URL où on passe un paramètre “query”, comme spécifié par le protocole SPARQL.
• tExtractXMLField pour traiter le format XML de réponse SPARQL; en effet, le format de réponse d’un service SPARQL est lui-aussi standardisé, en XML ou en JSON;
• tFileOutputDelimited pour simplement écrire le résultat dans un fichier de sortie.

Création d’un Job

Pour commencer, vous devez créer un nouveau job.

• Faite un clic droit sur Jobs dans le panneau de gauche. choisissez l’option Créer un Job.

•  Remplissez les champs nécessaires de la fenêtre Nouveau Job et cliquez sur le bouton finish.

 Appel SPARQL avec tRESTClient

• Ajoutez au job le composant tRESTClient.
• Cliquez deux fois sur le composant tRESTClient, allez à la propriété Paramètres simple et remplissez les paramètres suivants:

1. URL: L’URL du service SPARQL de Wikidata est https://query.wikidata.org/sparql .
2. Méthode HTTP: Choisissez la méthode HTTP GET
3. Paramètre de la Requête: Nous devons ajouter le paramètre “query”, cliquez sur le bouton plus [+], et dans la colonne Nom entrez “query”. Dans la colonne Valeur vous allez saisir la requête SPARQL.

Attention!  La requête SPARQL est une chaîne de caractères Java, vous devez donc : 1/ L’entourer avec des guillemets doubles 2/ ajouter le caractère d’échappement \ avant les guillemets dans la requête et 3/ écrire la requête sur une seule ligne. Voici la chaîne de caractères correspondante :

“SELECT ?item ?itemLabel WHERE { ?item wdt:P31 wd:Q146. SERVICE wikibase:label { bd:serviceParam wikibase:language \"[AUTO_LANGUAGE],en\". } } LIMIT 10”

Transformation des résultats SPARQL avec tExtractXMLField

• Ajoutez dans le projet un composant tExtractXMLField.
• Connectez le composant tRESTClient au tExtractXMLField.

Nous allons paramétrer le tExtractXMLField :

1. Cliquez sur le bouton Modifier le schéma pour ouvrir la fenêtre des colonnes d’entrée et sortie du composant tExtractXMLField.
2. Ajoutez deux nouvelles colonnes Uri et Label de type String avec le bouton plus [+] et cliquez sur le bouton Ok. 
3. Allez à Paramètres simple et modifiez les options suivantes:

• Champ XML: Choisissez le champs “body”, qui est le champ qui contient la réponse à l’appel SPARQL du composant précédent;
• Requête XPath boucle: Saisissez « /sparql/results/result » qui est d’après la spec du format de résultat SPARQL le chemin vers chaque ligne de résultats dans la réponse.
• La table Mapping : c’est ici que tout se joue !!! ce mapping va vous permettre d’associer les colonnes de votre résultat SPARQL au champs de sortie du composant, par le biais de chemins XPath:
  1. Pour la colonne Uri la valeur de la colonne Requête Xpath sera « binding[@name=’item’]/uri »
  2. pour la colonne Label la valeur de la colonne Requête Xpath sera « binding[@name=’itemLabel’]/literal ».
  3. Si la requête SPARQL retournait plus de colonnes, il faudrait ajouter ici les mappings correspondants pour alimenter les autres colonnes du résultat.

 Génération du fichier de sortie

• Ajoutez le composant de sortie tFileOutputDelimited.
• Connectez le composant tExtractXMLField au composant tFileOutputDelimited.
• Paramétrez le composant dans la section de Paramètres simple → Nom de fichier: le chemin dans lequel vous souhaitez sauvegarder le fichier de sortie.

 Lancer le Job

• Allez à la section Exécuter.
• Cliquez sur le bouton Exécuter.

 Profitez !

Naviguez vers l’emplacement du fichier pour le récupérer.

Et voilà le résultat :

Uri;Label
 http://www.wikidata.org/entity/Q378619;CC
 http://www.wikidata.org/entity/Q498787;Muezza
 http://www.wikidata.org/entity/Q677525;Orangey
 http://www.wikidata.org/entity/Q851190;Mrs. Chippy
 http://www.wikidata.org/entity/Q1050083;Catmando
 http://www.wikidata.org/entity/Q1201902;Tama
 http://www.wikidata.org/entity/Q1207136;Dewey Readmore Books
 http://www.wikidata.org/entity/Q1371145;Socks
 http://www.wikidata.org/entity/Q1386318;F. D. C. Willard
 http://www.wikidata.org/entity/Q1413628;Nora

Vous savez donc maintenant comment alimenter Talend à partir d’une base accessible en SPARQL, en quelques clics et sans code ! Cela permet de valoriser votre graphe de connaissances pour l’intégrer dans le reste du système d’information.

Cet article Alimenter Talend avec SPARQL (sur Wikidata) est apparu en premier sur Sparna Blog.

On le rencontre parfois en lien avec des projets de graphes de connaissances RDF, sans toutefois l’avoir jamais réellement mis en œuvre. Nous vous proposons ici d’explorer comment Talend peut être utilisé pour convertir des données CSV en RDF (RDF/XML plus précisément), tout cela uniquement avec des composants graphiques et sans écrire de code. C’est là un des gros avantages de l’approche : l’agencement de composants graphiques, de façon (relativement) simple, permet le paramétrage de jobs de conversion par des profils qui ne sont pas des développeurs.

Le code source du Job Talend pour produire du RDF que nous vous proposons de suivre ici peut être téléchargé depuis ce repository Github pour être importé dans Talend.

Les projets de mise en place de graphes de connaissances nécessitent en effet invariablement de la conversion de données vers du RDF pour alimenter le graphe. Ces conversions peuvent être faites :

• de façon massive et une seule fois (reprise intégrale d’une source de données pour basculer dans le graphe)
• de façon massive et répétées plusieurs fois (synchronisation périodique d’une source de données avec le graphe, pour maintenir les deux en synchro, mais sans temps réel)
• de façon unitaire au fil de l’eau (synchronisation des enregistrements un par un, à chaque modification dans les données source, pour maintenir les données source et le graphe synchronisés en temps réel ou quasi temps-réel)

Il y a de nombreuses techniques de conversion des données source pour alimenter le graphe, on citera :

• les feuilles de style XSLT pour traiter du XML (pour moi la “voie royale”), à l’expressivité quasi sans limite et aux performances excellentes (technique utilisée dans le développement du convertisseur Records in Context par exemple);
• L’ajout d’entêtes de @context JSON-LD sur des flux JSON, pour que le flux JSON soit interprétable directement comme du RDF;
• L’écriture de scripts custom, bien sûr, Python, Java, etc.
• L’utilisation d’outils de mapping de base relationnelles basés sur R2RML comme OnTop;
• L’utilisation de la nouvelle interface de mapping RDF de GraphDB, comme une extension d’OpenRefine (il faudra qu’on en reparle);
• L’utilisation du convertisseur Excel vers RDF de SKOS Play, lorsque les données source sont saisies à la main dans des tableurs (on fait plein de choses avec ça, y compris créer des règles SHACL);

Et donc, en plus de tout cela, nous pouvons maintenant ajouter Talend à la panoplie des techniques possibles de production de graphes RDF !

Installez Talend et paramétrez un Job avec 3 composants

Pour suivre l’exemple de job de conversion proposé ici, téléchargez et installez Talend Open Studio For Data Integration.

Le job d’exemple que nous allons paramétrer utilise les composants suivants :

• Un composant tFixedFlowInput pour lire (ici, générer) les données d’entrée.
• Un composant tMap pour transformer les données et en particulier générer tout ce qui est nécessaire pour produire le RDF, en particulier les URIs des sujets et des objets.
• Un composant tAdvancedFileOutputXML pour créer le fichier RDF/XML de sortie.

Créez un nouveau Job Talend, et à partir de la palette de composants sur la droite de l’écran, ajoutez les 3 composants dans votre job.

Configurer les données d’entrée

Nous allons configurer des données d’entrée d’exemple, type CSV, avec 3 colonnes qui décrivent des personnes : ID, Prénom et Nom.

1. Dans l’espace de travail, sélectionnez le tFixedFlowInput_1 .
2. Cliquez sur la vue Component pour paramétrer ses propriétés de base dans l’onglet Basic settings.
3. Cliquez sur le bouton […] à côté du champ Edit Schema pour décrire la structure des données que vous souhaitez à partir des variables internes. Dans ce scénario, le schéma est constitué de trois colonnes : ID, first et last, toutes de type String.
4. Cliquez sur OK pour fermer la boîte de dialogue.
5.  Dans les propriétés Basic settings du composant tFixedFlowInput 1 sélectionnez “Use Inline Content (delimited file)”. Dans le champ contenu, ajoutez les informations:  
   
1;John;Doe
2;Rutherford;McKinley
3;Marc;Van Buren
4;Theodore;Roosevelt
5;John;Truman

7. Connectez le composant tFixedFlowInput_1  au tMAP_1 avec le bouton gauche de la souris. Choisir l’option Row > Main et connectez au composant tMAP.

Mapper les données pour générer des URIs (et le reste)

La seconde étape consiste à produire tout ce dont on a besoin pour générer le RDF, en particulier générer les URI des ressources. Nous allons donc générer une URI pour chaque personne à partir de son ID.

1. Configurez le composant tMAP_1.

• Éditez le composant avec l’option éditeur de mapping. Cette option ouvrira une fenêtre séparée.   

• Ajoutez une table de sortie avec le bouton plus [+] et donner un nom : out1.
• Ajoutez les colonnes dans la section correspondante comme affiché dans l’image ci-dessous : en sortie nous allons produire une colonne “URI” à la place de “ID”, et les colonnes “First” et “Last” restent les même.

• Glissez chaque colonne d’entrée à la table de sortie :
  • First va sur First
  • Last va sur Last
  • et ID va vers URI

• Nous allons transformer la colonne ID pour générer l’URI, en utilisant une expression de concaténation « http://sparna.fr/dataset/persons/person_ »+row1.ID.toString(). Pour cela, dans le champs “Expression” de la colonne “URI, copiez/collez l’expression de concaténation « http://sparna.fr/dataset/persons/person_ »+row1.ID.toString(). Vous pouvez également cliquer sur le bouton “constructeur d’expression” pour ouvrir une fenêtre dédiée où vous pourrez saisir l’expression.  

• Cliquez sur OKpour valider et revenir à l’espace de modélisation.
• Reliez le composant tMap_1 au composant tAdvancedFileOutputXML_1

Configurer la sortie RDF/XML

Une fois que toutes les informations nécessaires à la génération du RDF (en particulier les URIs) ont été produites, on peut mapper les différentes informations vers la structure d’un fichier RDF/XML de sortie.

1. Nous allons définir l’arbre XML dans le composant tAdvancedFileOutputXML_1.
2. Double-cliquez sur le composant tAdvancedFileOutputXML_1 pour ouvrir l’interface dédiée ou cliquez sur le bouton […] du champ Configure Xml Tree de l’onglet Basic settings dans la vue Component.
3. Dans la section Linked Target (cible du lien),  définissez la structure XML comme sortie.
   • Cliquez sur la ligne  rootTag et renommer par rdf:RDF.
   • Cliquez sur le bouton plus [+] et ajoutez une ligne de type namespace avec son prefix rdf et son namespace “http://www.w3.org/1999/02/22-rdf-syntax-ns#”.
     • Etape 1:
     • Étape 2: Choisissez l’option create as name space.
     •  Étape 3: Tapez le prefix et le Namespace.

• Ajoutez autre namespace comment les pas précédents. et avec le prefix foaf et le namespace “http://xmlns.com/foaf/0.1/”.
• Choisissez la ligne racine (rdf:RDF) et  Créer une sous élément qui doit s’appelle foaf:Person et cliquez sur le bouton OK.  

• Cliquez sur la ligne foaf:Person et créer un attribut rdf:about et cliquez sur le bouton OK.

• Cliquez sur la ligne foaf:Person et ajoutez les sous éléments foaf:firstName et foaf:lastName.
• Pour connecter les sources avec la structure, glissez chaque champ source  avec le champ cible.  URI → @rdf:about et immédiatement s’afficher une  fenêtre où nous devons choisir l’option Add linker to target node.

1. Cliquez sur le bouton OK pour confirmer.

1. Dans le Basic Settings du composant tAdvancedFileOutputXML_1, entrez le chemin de sauvegarde du fichier XML de sortie.

Lancer notre Job.

1. Aller à la section Exécuter.
2. Cliquez sur le bouton Exécuter.

1. Le résultat final est la création du fichier RDF/XML, qui est stocké à l’endroit configuré.

Et voilà un magnifique fichier RDF/XML, produit à partir de CSV, en quelques clics et avec des composants graphiques ! Pas belle la vie ?

<rdf:RDF 
	xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
	xmlns:foaf="http://xmlns.com/foaf/0.1/">
   
    <foaf:Person rdf:about="http://sparna.fr/dataset/persons/person_1">
        <foaf:firstName>Theodore</foaf:firstName>
        <foaf:lastName>Roosevelt</foaf:lastName>
    </foaf:Person>
    <foaf:Person rdf:about="http://sparna.fr/dataset/persons/person_2">
        <foaf:firstName>Ulysses</foaf:firstName>
        <foaf:lastName>Clinton</foaf:lastName>
    </foaf:Person>
    <foaf:Person rdf:about="http://sparna.fr/dataset/persons/person_3">
        <foaf:firstName>John</foaf:firstName>
        <foaf:lastName>Truman</foaf:lastName>
    </foaf:Person>
    <foaf:Person rdf:about="http://sparna.fr/dataset/persons/person_4">
        <foaf:firstName>Chester</foaf:firstName>
        <foaf:lastName>Van Buren</foaf:lastName>
    </foaf:Person>
    <foaf:Person rdf:about="http://sparna.fr/dataset/persons/person_5">
        <foaf:firstName>Rutherford</foaf:firstName>
        <foaf:lastName>McKinley</foaf:lastName>
    </foaf:Person>
</rdf:RDF>

Crédit illustration : Talend et RDF

Cet article Générer du RDF avec Talend (un tutorial) est apparu en premier sur Sparna Blog.