SPARQL_query_local_triple_store.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# SPARQLing to local Triple Store\n",
    "\n",
    "Within this Jupyter Notebook script, a local triple store is created using the OWLready2 Python package that can be queried afterwards.\n",
    "Accordingly, necessary and useful libraries are imported and helper functions are implemented.\n",
    "The SPARQL queries are read in from especially created files that contain only the SPARQL query body (text of SPARQL query). Such files may be created at will and then read in.\n",
    "\n",
    "They follow the general pattern of SPARQL queries:\n",
    "\n",
    "```SPARQL\n",
    "PREFIX ex: <https://example.org/my/namespace/>\n",
    "\n",
    "SELECT ?s ?p ?o\n",
    "WHERE {\n",
    "    ?s ?p ?o\n",
    "}\n",
    "```\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Import of relevant packages | Definition of helper functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%capture\n",
    "# Import relevant and useful packages\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import owlready2 as or2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Definition of helper functions\n",
    "# Function to transform inputs to IRIs.\n",
    "def to_iri(input):\n",
    "    try:\n",
    "        return input.iri\n",
    "    except:\n",
    "        pass\n",
    "    return input\n",
    "\n",
    "# Function to write the result of a SPARQL query into a (pandas) data frame.\n",
    "def sparql_result_to_df(res):\n",
    "    l = []\n",
    "    for row in res:\n",
    "        r = [ to_iri(item)  for item in row]\n",
    "        l.append(r)\n",
    "    return pd.DataFrame(l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Definition of Sources\n",
    "\n",
    "In the following cell, the sources of ontologies to be read in (parsed) as well as the source of a possible A-Box, another ontology, or file, is to be specified."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define links to ontologies, files, etc. to be loaded in the local triple store\n",
    "link_ontology_1 = \"https://materialdigital.github.io/core-ontology/ontology.rdf\" # Example: PMD Core Ontology (PMDco) hosted on corresponding GitHub repository\n",
    "link_data = \"your_data.rdf\"\n",
    "\n",
    "triple_store = or2.World()\n",
    "triple_store.get_ontology(link_ontology_1).load() # Example: https://w3id.org/pmd/co\n",
    "triple_store.get_ontology(link_data).load()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Specification of SPARQL Query\n",
    "\n",
    "In the following cell, the source of the SPARQL query file is to be selected. The query contained in this file will be used for querying in the subsequent cell."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define the location of the file containing a SPARQL query that is supposed to be run\n",
    "link_SPARQL_query = 'example_SPARQL_query.sparql'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Open the file and read the SPARQL query\n",
    "with open(link_SPARQL_query, 'r') as file:\n",
    "    query = file.read()\n",
    "\n",
    "# Execute the SPARQL query\n",
    "res = triple_store.sparql(query)\n",
    "\n",
    "# Convert the result to a DataFrame\n",
    "data = sparql_result_to_df(res)\n",
    "\n",
    "# Print (the first few rows of) the DataFrame\n",
    "# data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Depiction of Results \n",
    "\n",
    "For a probably somewhat nicer depiction / visualization of results in table format, the module tabulate may be used.\n",
    "Furthermore, as the SPARQL query is defined by a dedicated SPARQL query file (link_SPARQL_query), the headers of the result table can be read from the select clause in the query. This way, the result can be double-checked manually and consistency is ensured (did the SPARQL query select statement really address the information I wanted to obtain?). Hence, the following code includes a read in of the information queried for (the terms / concepts / entities addressed using the select clause)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import necessary packages (such as tabulate)\n",
    "import re\n",
    "from tabulate import tabulate\n",
    "\n",
    "# Step 1: Read the SPARQL file content\n",
    "with open(link_SPARQL_query, 'r') as file:\n",
    "    sparql_query = file.read()\n",
    "\n",
    "# Step 2: Extract the terms from the SELECT clause\n",
    "# This regular expression looks for the SELECT or SELECT DISTINCT clause and captures the terms.\n",
    "select_clause_match = re.search(r'SELECT\\s+(DISTINCT\\s+)?(.*?)\\s+WHERE', sparql_query, re.DOTALL)\n",
    "\n",
    "if select_clause_match:\n",
    "    select_clause = select_clause_match.group(2)  # Use group(2) to capture the variables\n",
    "    # Split the terms by whitespace and strip any leading or trailing spaces\n",
    "    headers = [term.strip().lstrip('?') for term in select_clause.split() if term.strip().startswith('?')]\n",
    "else:\n",
    "    print(\"No headers were found. Please check the select clause within the SPARQL query.\")\n",
    "\n",
    "# Step 3: Use the headers in the tabulate print statement\n",
    "# Print the data with tabulate\n",
    "print(tabulate(data, headers=headers, tablefmt='psql', showindex=True))"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}