gremlin-test.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "pycharm": {
     "is_executing": false
    }
   },
   "outputs": [],
   "source": [
    "from IPython.core.display import display\n",
    "from gremlin_python import statics\n",
    "from gremlin_python.process.anonymous_traversal import traversal\n",
    "from gremlin_python.process.graph_traversal import __\n",
    "from gremlin_python.structure.graph import Graph, Vertex, Edge, Element\n",
    "from gremlin_python.process.strategies import *\n",
    "from gremlin_python.driver.driver_remote_connection import DriverRemoteConnection\n",
    "from gremlin_python.process.traversal import T\n",
    "from gremlin_python.process.traversal import Order\n",
    "from gremlin_python.process.traversal import Cardinality\n",
    "from gremlin_python.process.traversal import Column\n",
    "from gremlin_python.process.traversal import Direction\n",
    "from gremlin_python.process.traversal import Operator\n",
    "from gremlin_python.process.traversal import P\n",
    "from gremlin_python.process.traversal import Pop\n",
    "from gremlin_python.process.traversal import Scope\n",
    "from gremlin_python.process.traversal import Barrier\n",
    "from gremlin_python.process.traversal import Bindings\n",
    "from gremlin_python.process.traversal import WithOptions\n",
    "\n",
    "from functools import reduce\n",
    "from pprint import pprint\n",
    "import rdflib\n",
    "import pathlib\n",
    "import logging\n",
    "\n",
    "import rdf2g"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "pycharm": {
     "is_executing": false
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2019-10-19 16:23:10,034 [INFO] Successfully connected to the graph server\n"
     ]
    }
   ],
   "source": [
    "g = rdf2g.setup_graph() "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "pycharm": {
     "is_executing": false
    }
   },
   "outputs": [],
   "source": [
    "# OUTPUT_FILE_LAM_PROPERTIES = pathlib.Path(\"../output/lam_project_properties_v2.ttl\").resolve()\n",
    "# gg = rdflib.Graph()\n",
    "# gg.parse(str(OUTPUT_FILE_LAM_PROPERTIES), format=\"ttl\")\n",
    "# print(\"dfdf\")\n",
    "\n",
    "# for s, p, o in gg:\n",
    "#     # find s in the property graph\n",
    "#     #     existentURIlist = g.V().has(\"iri\",str(s)).id().toList()\n",
    "#     #     if existentURIlist:\n",
    "#     #         v1 = g.V(existentURIlist[0])\n",
    "#     #\n",
    "#     # if o is literal add it as value to key p\n",
    "#     # else create node o and add propoerty to o\n",
    "#     v1 = create_node(g,s,gg)\n",
    "#     v1 = create_node(g,o,gg)\n",
    "#     #v1 = g.addV(s).property('iri',str(s) ).next()\n",
    "#     #v2 = g.addV(o).property('iri',str(o) ).next()\n",
    "#     #     g.V(Bindings.of('id',v1)).addE(p).to(v2).iterate()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {
    "pycharm": {
     "is_executing": false
    }
   },
   "outputs": [],
   "source": [
    "# g.V().drop().iterate()\n",
    "\n",
    "\n",
    "# s = g.V().has('iri','http://publications.europa.eu/resources/authority/celex/md_CODE').union(__.valueMap(), __.out().valueMap().tree()).toList()\n",
    "# pprint(s)\n",
    "\n",
    "# s = g.V().has('iri','http://publications.europa.eu/resources/authority/celex/md_CODE').outE().inV().tree().next()\n",
    "\n",
    "# pprint(s)\n",
    "# pprint( s[\"@value\"][0][\"value\"][\"@value\"][0][\"key\"].label  )\n",
    "# ss = g.V(s[\"@value\"][0][\"key\"]).propertyMap().next()  \n",
    "# print (ss[\"dct:created\"][0].value)\n",
    "\n",
    "\n",
    "# {'@type': 'g:Tree',\n",
    "#  '@value': [{'key': v[309],\n",
    "#              'value': {'@type': 'g:Tree',\n",
    "#                        '@value': [{'key': v[337],\n",
    "#                                    'value': {'@type': 'g:Tree', '@value': []}},\n",
    "#                                   {'key': v[386],\n",
    "#                                    'value': {'@type': 'g:Tree', '@value': []}},\n",
    "#                                   {'key': v[349],\n",
    "#                                    'value': {'@type': 'g:Tree',\n",
    "#                                              '@value': []}}]}}]}\n",
    "\n",
    "\n",
    "# def flatten_list_of_dicts(list_of_dicts):\n",
    "#     \"\"\"\n",
    "#         Flatten the list of dictionaries:\n",
    "#         This is an expression for Python 3.5 or greater that merges dictionaries using reduce\n",
    "#         Warning: repeating kets will be overwitten.\n",
    "#     \"\"\"\n",
    "#     return reduce(lambda x, y: {**x, **y}, list_of_dicts, {})\n",
    "\n",
    "\n",
    "# def node_properties(node, g):\n",
    "#     \"\"\"\n",
    "#         return the node propoerties as simple dictionary\n",
    "#     \"\"\"\n",
    "#     props = g.V(node).propertyMap().next()\n",
    "#     # reduction of props to simple dict\n",
    "#     props = {key: [e.value for e in props[key]] for key in props }\n",
    "#     # deflating the values from lists to simple values if there is a single element provided\n",
    "#     return {key: props[key] if len(props[key])>1 else props[key][0] for key in props}\n",
    "    \n",
    "    \n",
    "# def expand_tree(tree_dict, g):\n",
    "#     \"\"\"\n",
    "#         Given a tree with a single root node, return the simple dict corresponding to the tree\n",
    "#         If multiple roots are provided, they are treated as individual tree and the result is a list of dict trees\n",
    "\n",
    "#         The tree must be specified in a sequence of node-edge-node. Otherwise the behaviour is not predictable.\n",
    "\n",
    "#         expecting a gremlin tree of vertices/edges, for example:\n",
    "#         g.V(233).outE().inV().tree().next()\n",
    "#     \"\"\"\n",
    "#     logging.debug('Expanding the tree and casting it into plain dict')\n",
    "#     if \"@type\" in tree_dict and \"@value\" in tree_dict:\n",
    "#         if not tree_dict[\"@value\"]:\n",
    "#             # reached a leaf\n",
    "#             return None\n",
    "#         else:\n",
    "#             # iterate the tree nodes on 'key' and their children on 'value'\n",
    "#             expected_list_of_dicts = [expand_tree(kv, g) for kv in tree_dict[\"@value\"]]\n",
    "\n",
    "#             # prime if the list of dicts are edges or nodes, nodes have '@id' and '@label' property while edges don't\n",
    "#             if expected_list_of_dicts and \"@id\" in expected_list_of_dicts[0]:\n",
    "#                 # we have a list of node descriptions\n",
    "#                 return expected_list_of_dicts\n",
    "#             else:\n",
    "#                 # we have a list od edges, which need to be flattened because in the upper step they\n",
    "#                 # are merged with the data properties of the node\n",
    "#                 return flatten_list_of_dicts(expected_list_of_dicts)\n",
    "\n",
    "#     elif \"key\" in tree_dict and \"value\" in tree_dict:\n",
    "#         # process edge\n",
    "#         if isinstance(tree_dict[\"key\"], Edge):\n",
    "#             return {tree_dict[\"key\"].label: expand_tree(tree_dict[\"value\"], g)}\n",
    "#         # process node (expand the node properties and merge with edges)\n",
    "#         elif isinstance(tree_dict[\"key\"], Vertex):\n",
    "#             #             props = {k:(v[0].value if v[0] else None) for k,v in props}\n",
    "#             props = get_node_properties(g, tree_dict[\"key\"])\n",
    "#             props[\"@id\"] = tree_dict[\"key\"].id\n",
    "#             props[\"@label\"] = tree_dict[\"key\"].label\n",
    "\n",
    "#             expected_dict_of_edge_props = expand_tree(tree_dict[\"value\"], g)\n",
    "#             if expected_dict_of_edge_props:\n",
    "#                 # deflating the values from lists to simple values if there is a single element provided\n",
    "#                 expected_dict_of_edge_props = {\n",
    "#                     key: expected_dict_of_edge_props[key] if len(expected_dict_of_edge_props[key]) > 1 else\n",
    "#                     expected_dict_of_edge_props[key][0] for key in expected_dict_of_edge_props}\n",
    "#                 # merge the two dictionaries, second overwriting the existing keys of the first one (Python3.5+)\n",
    "#                 return {**props, **expected_dict_of_edge_props}\n",
    "#             else:\n",
    "#                 return props\n",
    "            \n",
    "                        \n",
    "# TODO: ADD to the library\n",
    "\n",
    "def nodes_by_type_label(g, label):\n",
    "    \"\"\"\n",
    "        return nodes with a rdf type @label\n",
    "    \"\"\"\n",
    "    return g.V().as_(\"node\").where(__.out(\"rdf:type\").hasLabel(label)).select(\"node\").dedup().toList()    \n",
    "\n",
    "def nodes_by_type_iri(g,iri):\n",
    "    \"\"\"\n",
    "        return nodes with a rdf type @iri\n",
    "    \"\"\"\n",
    "    return g.V().as_(\"node\").where(__.out(\"rdf:type\").properties(\"iri\").hasValue(iri)).select(\"node\").dedup().toList()\n",
    "\n",
    "def node_traversal_tree(g, node, max_depth=3):\n",
    "    \"\"\"\n",
    "        retreive the traversal tree with depth @depth for the @node\n",
    "    \"\"\"\n",
    "    return g.V(node).repeat(__.outE().inV().dedup()).until(__.outE().count().is_(0).or_().loops().is_(max_depth)).dedup().tree().next()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {
    "pycharm": {
     "is_executing": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "v[864]\n",
      "{'@type': 'g:Tree',\n",
      " '@value': [{'key': v[864],\n",
      "             'value': {'@type': 'g:Tree',\n",
      "                       '@value': [{'key': e[947][864-rdf:type->880],\n",
      "                                   'value': {'@type': 'g:Tree',\n",
      "                                             '@value': [{'key': v[880],\n",
      "                                                         'value': {'@type': 'g:Tree',\n",
      "                                                                   '@value': []}}]}},\n",
      "                                  {'key': e[903][864-skos:inScheme->899],\n",
      "                                   'value': {'@type': 'g:Tree',\n",
      "                                             '@value': [{'key': v[899],\n",
      "                                                         'value': {'@type': 'g:Tree',\n",
      "                                                                   '@value': []}}]}},\n",
      "                                  {'key': e[942][864-sh:path->940],\n",
      "                                   'value': {'@type': 'g:Tree',\n",
      "                                             '@value': [{'key': v[940],\n",
      "                                                         'value': {'@type': 'g:Tree',\n",
      "                                                                   '@value': []}}]}}]}}]}\n",
      "[{'@id': 864,\n",
      "  '@label': 'celexd:md_DTN',\n",
      "  'dct:created': '2019-09-27',\n",
      "  'dct:type': 'data property',\n",
      "  'iri': 'http://publications.europa.eu/resources/authority/celex/md_DTN',\n",
      "  'rdf:type': {'@id': 880,\n",
      "               '@label': 'skos:Concept',\n",
      "               'iri': 'http://www.w3.org/2004/02/skos/core#Concept'},\n",
      "  'sh:path': {'@id': 940,\n",
      "              '@label': 'lam:dtn',\n",
      "              'iri': 'http://publications.europa.eu/ontology/lam-skos-ap#dtn'},\n",
      "  'skos:definition': 'A sequential number representing the original reference '\n",
      "                     'number of the act.\\n'\n",
      "                     '\\n'\n",
      "                     'In some instances composed or non-standardised numbers '\n",
      "                     'are attributed (e.g. treaties).',\n",
      "  'skos:example': '<cdm:resource_legal_number_natural_celex '\n",
      "                  'rdf:datatype=\"http://www.w3.org/2001/XMLSchema#positiveInteger\">0556</cdm:resource_legal_number_natural_celex>',\n",
      "  'skos:inScheme': {'@id': 899,\n",
      "                    '@label': 'lamd:DocumentProperty',\n",
      "                    'iri': 'http://publications.europa.eu/resources/authority/lam/DocumentProperty',\n",
      "                    'skos:prefLabel': 'Document metadata'},\n",
      "  'skos:notation': 'DTN',\n",
      "  'skos:prefLabel': 'CELEX number - source',\n",
      "  'skos:scopeNote': 'The sequential number is usually present in the natural '\n",
      "                    'number of document (e.g. regulations) or on its internal '\n",
      "                    'number attributed by the author (e.g. COM documents). If '\n",
      "                    'any of those numbers is not available, the CELEX natural '\n",
      "                    'number might be based on the date of publication '\n",
      "                    '(international agreements).\\n'\n",
      "                    '\\n'\n",
      "                    'The date of publication is derived from the publication '\n",
      "                    'reference.\\n'\n",
      "                    '\\n'\n",
      "                    'Numbers in parentheses (called \"splits\" – e.g. (01), '\n",
      "                    '(02), …) may be added to avoid double application (if the '\n",
      "                    'CELEX number of several similar documents is based on the '\n",
      "                    'same date of publication; for several Court decisions on '\n",
      "                    'the same case for several documentary units for a '\n",
      "                    'preparatory document).\\n'\n",
      "                    '\\n'\n",
      "                    'For a corrigendum an “R” is added to the four digits (see '\n",
      "                    'CELEX type corrigendum).'}]\n"
     ]
    }
   ],
   "source": [
    "# s = g.V().has('iri','http://publications.europa.eu/resources/authority/lam/md_CODE').outE().inV().tree().next()\n",
    "# s = g.V().outE().inV().tree().next()\n",
    "# s = g.V().as_(\"a\").where(__.outE(\"rdf:type\").inV(\"skos:ConceptScheme\")).select(\"a\").label().toList()\n",
    "\n",
    "# s = g.V().as_(\"concept_scheme\").where(__.out(\"rdf:type\").hasLabel(\"skos:ConceptScheme\")).select(\"concept_scheme\").label().toList()\n",
    "#\n",
    "# s = g.V().as_(\"node\").where(__.out(\"rdf:type\").hasLabel(\"skos:Concept\")).select(\"node\").repeat(__.outE().inV().dedup()).times(1).label().toList()\n",
    "# s = g.V().as_(\"node\").where(__.out(\"rdf:type\").properties(\"iri\").hasValue(\"http://www.w3.org/2004/02/skos/core#ConceptScheme\")).select(\"node\").dedup().toList()\n",
    "\n",
    "# pprint(get_nodes_by_type_label(g,\"skos:ConceptScheme\"))\n",
    "# pprint(get_nodes_by_type_label(g,\"skos:Concept\"))\n",
    "\n",
    "# pprint (get_nodes_by_type_iri(g, \"http://www.w3.org/2004/02/skos/core#Cept\") )\n",
    "\n",
    "iri1 = \"http://publications.europa.eu/resources/authority/celex/md_CODE\"\n",
    "iri2 = \"http://www.w3.org/2004/02/skos/core#Concept\"\n",
    "\n",
    "source_iri = iri1\n",
    "target_iri = iri2\n",
    "\n",
    "# two known nodes\n",
    "# edges = g.V().has(\"iri\", str(source_iri)).outE().as_(\"q\").inV().has(\"iri\", str(target_iri)).select(\"q\").toList()\n",
    "\n",
    "# target unspecified\n",
    "## edges = g.V().has(\"iri\", str(source_iri)).outE().as_(\"q\").inV().select(\"q\").toList()\n",
    "edges = g.V().has(\"iri\", str(source_iri)).outE().toList()\n",
    "\n",
    "# source unspecified\n",
    "## edges = g.V().outE().as_(\"q\").inV().has(\"iri\", str(target_iri)).select(\"q\").toList()\n",
    "# edges = g.V().has(\"iri\", str(target_iri)).inE().toList()\n",
    "\n",
    "\n",
    "\n",
    "pprint ( g.V().hasLabel(\"celexd:md_DTN\").next())\n",
    "\n",
    "cs = get_nodes_by_type_label(g,\"skos:Concept\")\n",
    "\n",
    "# pprint (cs)\n",
    "\n",
    "# tr = get_node_traversal_tree(g, g.V(864).next(), 1)\n",
    "tr = g.V(864).repeat(__.outE().inV().dedup()).until(__.outE().count().is_(0).or_().loops().is_(1)).dedup().tree().next()\n",
    "\n",
    "pprint(tr)\n",
    "\n",
    "# # pprint(s)\n",
    "j = rdf2g.expand_tree(tr, g)\n",
    "pprint(j)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": ".venv",
   "language": "python",
   "name": ".venv"
  },
  "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.3"
  },
  "pycharm": {
   "stem_cell": {
    "cell_type": "raw",
    "metadata": {
     "collapsed": false
    },
    "source": []
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}