Linked-data-2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[JSON-LD en linked data](json-ld-linked-data.ipynb) <- vorige - [Inhoudsopgave](Inhoud.ipynb) - volgende -> []()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Linked Open Data(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We gebruiken in de contact-documenten eigenschappen als `name` en `address`,\n",
    "en in de agenda-documenten `participants` en `location`.\n",
    "Door het schema en de validator weten we dat deze eigenschappen op een consistente manier gebruikt worden,\n",
    "door alle documenten in de collection.\n",
    "\n",
    "Het schema is beperkt tot de lokale database: andere contact-databases kunnen andere schema's gebruiken,\n",
    "met andere namen en types voor de verschillende properties.\n",
    "Dit maakt het uitwisselen van data en het koppelen van databases lastig.\n",
    "\n",
    "*Linked data* probeert hiervoor een oplossing te bieden.\n",
    "In zekere zin betekent *linked data* voor data in databases, wat het internet is voor computers (en toepassingen) in lokale netwerken.\n",
    "\n",
    "* Voor het *identificeren en adresseren* van computers in het internet gebruik je het IP-adres, voor toepassingen aangevuld met het poortnummer.\n",
    "* Voor *linked data* gebruik je URLs (\"webadressen\") voor identificatie en adressering.\n",
    "\n",
    "De belangrijkste principes van Linked Data, zoals beschreven door Tim Berners Lee (de uitvinder van het web):\n",
    "\n",
    "1. gebruik URIs als namen voor dingen;\n",
    "2. gebruik HTTP URIs (d.w.z. URLs) zodat mensen de betekenis van deze namen op kunnen zoeken;\n",
    "3. als iemand een URI opzoekt (via het web), geef dan zinvolle informatie;\n",
    "4. gebruik hierin links (URLs) waarmee meer dingen ontdekt kunnen worden.\n",
    "\n",
    "(Zie: https://www.w3.org/DesignIssues/LinkedData.html)\n",
    "\n",
    "In eerste instantie richten we ons op (1) en (2).\n",
    "De andere aspecten, in het bijzonder (4), behandelen we later.\n",
    "\n",
    "Een URI (Uniform Resource Identifier, zie [Wikipedia URI](https://www.w3.org/DesignIssues/LinkedData.html)) is een generalisatie van URLs zoals je die in het web tegenkomt. Een voorbeeld van een URI dat niet een web-URL is: `mailto:jan.jansen@voorbeeld.nl`.\n",
    "De suggestie van Linked Data is om zoveel mogelijk web-URIs te gebruiken (URLs), zoals `http://voorbeeld.nl/janjansen`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## URLs als veldnamen\n",
    "\n",
    "De eerste stap is het gebruiken van URLs als namen (identificatie).\n",
    "In het voorbeeld van de contacten-database betekent dit dat we URLs gebruiken als veldnamen.\n",
    "Begrippen als `address` en `telephone` zijn elders op het web gedefinieerd in gestandaardiseerde *schema's*.\n",
    "Onder andere [schema.org](https://schema.org) heeft een aantal veelgebruikte begrippen in schema's beschreven,\n",
    "bijvoorbeeld rond personen, organisaties en gebeurtenissen (events).\n",
    "\n",
    "```Python\n",
    "person = {\n",
    "    \"http://schema.org/name\": \"Henk de Vries\",\n",
    "    \"http://schema.org/telephone\": \"06 1234 5588\"\n",
    "}\n",
    "```\n",
    "\n",
    "De namen die we hier gebruiken voor de velden van een contact-document zijn URLs;\n",
    "we kunnen de betekenis van deze namen opzoeken, via de website `schema.org`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Naar leeesbare namen\n",
    "\n",
    "Een document met URLs als namen voor de eigenschappen is niet erg leesbaar.\n",
    "De JSON-LD (JSON Linked Data) notatie biedt daarom een manier om deze notatie af te korten,\n",
    "waarbij het principe van URLs als namen gehandhaafd blijft.\n",
    "Voor deze afkorting voegen we aan een document (JSON-object) een *context* toe, \n",
    "met verkorte (lokale) namen in termen van globale URLs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "person_context = {\n",
    "        \"name\": \"http://schema.org/name\",\n",
    "        \"telephone\": \"http://schema.org/telephone\"\n",
    "    }\n",
    "person = {\n",
    "    \"@context\": person_context,\n",
    "    \"name\": \"Henk de Vries\",\n",
    "    \"telephone\": \"06 1234 5588\" \n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> *Door de context met de beschrijving van de namen aan het document zelf toe te voegen,\n",
    "wordt de betekenis van deze namen onafhankelijk van de context waarin het document gebruikt wordt.*\n",
    "\n",
    "Met behulp van de pyld-library kunnen we een compacte vorm omzetten in een geëxpandeerde vorm:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pyld import jsonld\n",
    "import json\n",
    "\n",
    "expanded = jsonld.expand(person)\n",
    "expanded"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We kunnen een geëxpandeerde vorm ook omzetten in een compacte vorm:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "compacted = jsonld.compact(expanded, person_context)\n",
    "compacted"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Types van document-eigenschappen\n",
    "\n",
    "Naast de namen van de eigenschappen, kunnen we (als in een database-schema) ook de *types* van de eigenschappen beschrijven.\n",
    "Voor het identificeren van een type gebruiken we dan ook weer een URI (URL).\n",
    "\n",
    "In het geval van JSON-LD hebben we te maken met twee soorten types: *data types* en *object-types*.\n",
    "Voorbeelden van data types zijn: Number, String, Date, ...\n",
    "Voorbeelden van object types zijn: Person, Organization, Event, ...\n",
    "\n",
    "We werken beide uit in een voorbeeld.\n",
    "\n",
    "Vaak hebben we te maken met stringwaarden die aan bepaalde voorwaarden voldoen.\n",
    "Een string kan bijvoorbeeld een datum voorstellen.\n",
    "In JSON kunnen we dat niet uitdrukken; BSON heeft meer types, o.a. `Date` (datum en tijd).\n",
    "\n",
    "> Een JSON-LD-context beschrijft de namen en types die gebruikt *kunnen* worden voor de eigenschappen van een document (object).\n",
    "Een MongoDB-schema beschrijft de eigenschappen die *moeten* voorkomen in een document.\n",
    "Deze twee concepten vullen elkaar aan.\n",
    "\n",
    "Voor het beschrijven van het type van een eigenschap gebruiken we `@type`; we moeten dan `@id` gebruiken voor de URL die we als naam van de eigenschap gebruiken.\n",
    "In het geval van een URL is het type `@id`: dat is een web-id, ofwel een URL.\n",
    "\n",
    "> Hoewel het type precies beschrijft wat het formaat is van de datum-string van `birthDate`, \n",
    "  namelijk een datum in ISO_8601-formaat, \n",
    "  hebben we hier geen mechanisme om het juiste gebruik van het formaat af te dwingen of te controleren.\n",
    "  Het is in de eerste plaats een aanwijzing voor de lezer (mens of computer) van het person-document,\n",
    "  om deze stringwaarde op de juiste manier te interpreteren."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Opdracht**\n",
    "\n",
    "* bekijk de definities van `http://schema.org/Person`, `http://schema.org/birthDate`, `http://schema.org/Date`\n",
    "* "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "person_context = {\n",
    "        \"name\": \"http://schema.org/name\",\n",
    "        \"telephone\": \"http://schema.org/telephone\",\n",
    "        \"homepage\": {\"@id\": \"http://schema.org/url\", \"@type\": \"@id\"},\n",
    "        \"birthDate\": {\"@id\": \"http://schema.org/birthDate\",\n",
    "                      \"@type\": \"http://schema.org/Date\"}\n",
    "    }\n",
    "person = {\n",
    "    \"@context\": person_context,\n",
    "    \"name\": \"Henk de Vries\",\n",
    "    \"telephone\": \"06 1234 5588\" ,\n",
    "    \"homepage\": \"http://henk.devries.org\",\n",
    "    \"birthDate\": \"1970-1-1\"\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "expanded = jsonld.expand(person)\n",
    "expanded"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "compacted = jsonld.compact(expanded, person_context)\n",
    "compacted"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Object type en object id\n",
    "\n",
    "We hebben nu de mogelijkheden gebruikt om de namen en types van de eigenschappen van een document te beschrijven.\n",
    "Een volgende stap is om het type van het document zelf te beschrijven.\n",
    "Bijvoorbeeld: beschrijft dit document een persoon of een organisatie?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "person = {\n",
    "    \"http://schema.org/name\": \"Henk de Vries\",\n",
    "    \"http://schema.org/telephone\": \"06 1234 5588\"\n",
    "}\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# expand a document, removing its context\n",
    "# see: http://json-ld.org/spec/latest/json-ld/#expanded-document-form\n",
    "expanded = jsonld.expand(compacted)\n",
    "expanded"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Je zien in deze expansie dat sommige eigenschappen, zoals \"@type\" en \"birthDate\"(???), meerdere waarden kunnen hebben. (Dit is standaard in de geëxpandeerde versie?)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Object types\n",
    "\n",
    "Met een object-type kunnen we het type van een document aangeven.\n",
    "In de contacten-database kunnen we zo bijvoorbeeld verschil maken tussen *personen* en *organisaties*.\n",
    "Deze hebben een deel van de eigenschappen gemeenschappelijk, maar hebben daarnaast ook eigenschappen die alleen voor dat type betekenis hebben.\n",
    "\n",
    "> Een *object-type* is het type van een entiteit uit de wereld die je modelleert. Een *data-type* is een middel waarmee je dergelijke entiteiten modelleert.\n",
    "Een eenvoudige eigenschap heeft gewoonlijk als type een *data-type* of een eenvoudige combinatie van data-types.\n",
    "Een \"complexe\" eigenschap met als type een *object-type*, beschrijft gewoonlijk een *relatie* met een andere entiteit.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "context = {\n",
    "    \"xsd\": \"http://www.w3.org/2001/XMLSchema#\",\n",
    "    \"person\": \"http://schema.org/Person\",\n",
    "    \"birthDate\": {\"@id\": \"http://schema.org/birthDate\", \"@type\": \"xsd:date\"},\n",
    "    \"name\": \"http://schema.org/name\",\n",
    "    \"telephone\": \"http://schema.org/telephone\",\n",
    "    \"homepage\": {\"@id\": \"http://schema.org/url\", \"@type\": \"@id\"}    \n",
    "}\n",
    "person = {\n",
    "    \"@context\": context,\n",
    "    \"@type\": \"person\",\n",
    "    \"name\": \"Henk de Vries\",\n",
    "    \"telephone\": \"06 1234 5588\" ,\n",
    "    \"homepage\": \"http://henk.devries.org\",\n",
    "    \"birthDate\": \"1970-1-1\"    \n",
    "}\n",
    "jsonld.expand(person)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "jsonld.compact(jsonld.expand(person), context)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### XML data types\n",
    "\n",
    "We hebben in dit voorbeeld voor de datum gebruik gemaakt van `http://www.w3.org/2001/XMLSchema#`.\n",
    "Dit is de URI (URL?) voor XML Schema: deze definieert een groot aantal data-types.\n",
    "Deze datatypes zijn onderdeel van die URL: de *prefix-notatie* `xsd:date` wordt geëxpandeerd tot `http://www.w3.org/2001/XMLSchema#date`. (Let ook op het `#` in de URL.) Als je deze URL raadpleegt krijg je niet direct de informatie over `string`: deze wordt in een ander document beschreven. Het is dus eigenlijk eerder een URI (identificatie) dan een URL (adres).\n",
    "\n",
    "XML schema biedt veel meer mogelijkheden om data-types precies te beschrijven, bijvoorbeeld het bereik van getallen.\n",
    "\n",
    "* zie o.a. https://www.w3.org/TR/xmlschema-2/#string\n",
    "* en de figuur onder \"3 Built-in types\" op die pagina"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "context = {\n",
    "    \"xsd\": \"http://www.w3.org/2001/XMLSchema#\",\n",
    "    \"person\": \"http://schema.org/Person\",\n",
    "    \"name\": \"http://schema.org/name\",\n",
    "    \"birthDate\": {\"@id\": \"http://schema.org/birthDate\", \"@type\": \"xsd:date\"},\n",
    "    \"telephone\": \"http://schema.org/telephone\",\n",
    "    \"homepage\": {\"@id\": \"http://schema.org/url\", \"@type\": \"@id\"},\n",
    "    \"birthDate\": {\"@id\": \"http://schema.org/birthDate\",\n",
    "                  \"@type\": \"xsd:date\"}\n",
    "}\n",
    "person = {\n",
    "    \"@context\": context,\n",
    "    \"@type\": \"person\",\n",
    "    \"name\": \"Henk de Vries\",\n",
    "    \"telephone\": \"06 1234 5588\" ,\n",
    "    \"homepage\": \"http://henk.devries.org\",\n",
    "    \"birthDate\": \"1970-1-1\"\n",
    "}\n",
    "jsonld.expand(person)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Issue**\n",
    "\n",
    "(Vraag: kunnen we deze prefixnotatie ook gebruiken voor `http://schema.org/`?\n",
    "Is dat ongebruikelijk, of werkt dat niet zo?\n",
    "Volgens mij werkt het wel; wordt dit ergens in de voorbeelden gebruikt?)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Object ID\n",
    "\n",
    "Een document vormt een *beschrijving* van een entiteit, bijvoorbeeld een persoon of een organisatie.\n",
    "Het geeft je geen *identificatie* voor de entiteit.\n",
    "In het web wordt als identificatie van een \"resource\" (de web-term voor entiteit) een URI (URL) gebruikt.\n",
    "\n",
    "Als identificatie van een (natuurlijke) persoon kun je bijvoorbeeld de URL van zijn of haar persoonlijke webpagina gebruiken:\n",
    "dat is in elk geval een unieke identificatie, en hopelijk ook een stabiele.\n",
    "\n",
    "Een andere manier om een persoon te identificeren is aan het hand van het mail-adres.\n",
    "Dit is persoonlijk, en verandert niet - ook als het niet meer in gebruik is: \n",
    "een persoonlijk mail-adres wordt niet aan een andere persoon gekoppeld.\n",
    "Een mailadres heeft wel een nadeel: je wilt dit misschien niet publiek maken.\n",
    "Een oplossing (gebruikt door FOAF - http://semanticweb.org/wiki/FOAF.html) is om een hashwaarde van het mailadres te gebruiken als identificatie (zie: http://xmlns.com/foaf/spec/#term_mbox_sha1sum).\n",
    "\n",
    "Als identificatie van een organisatie kun je de homepage of het primaire domein van de organisatie gebruiken."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Wikidata geeft ook een ID voor sommige (bekende) personen.\n",
    "Zie bijvoorbeeld:\n",
    "    \n",
    "* https://www.wikidata.org/wiki/Q12345\n",
    "* https://www.wikidata.org/wiki/Q42\n",
    "* https://www.wikidata.org/wiki/Q80\n",
    "\n",
    "Ook voor auteurs van wetenschappelijke artikelen is er een dergelijke ID: zie bijvoorbeeld de verschillende IDs van \n",
    "\n",
    "Uit dit overzicht blijkt dan je meerdere ID-waarden kunt hebben voor een persoon of voor een organisatie.\n",
    "Dat is niet zo'n probleem als je middelen hebt om de gelijkheid (equivalentie) van die IDs te bepalen (zoals bijvoorbeeld via Wikidata).\n",
    "\n",
    "Merk op dat de \"expanded\" versie van de documenten hierboven altijd meerdere waarden voor een bepaalde eigenschap (attribuut, veld) toestaat.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ToDo - uitwerken in volgende Notebooks\n",
    "\n",
    "* hoe gebruik je dit in combinatie met MongoDB?\n",
    "* hoe gebruik je dit in het web?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.7.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}