scr/Treebank Class.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false,
    "init_cell": true
   },
   "outputs": [],
   "source": [
    "from lxml import etree\n",
    "import re\n",
    "import os\n",
    "import inspect\n",
    "from py2neo import Graph, Node, Relationship"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# The classes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true,
    "init_cell": true
   },
   "outputs": [],
   "source": [
    "def reverseDict(dic):\n",
    "    return {v: k for k, v in dic.items()}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false,
    "init_cell": true
   },
   "outputs": [],
   "source": [
    "pos = {'-' : '-',\n",
    "           \"d\" : 'adverb',\n",
    "           'n' : 'noun',\n",
    "           'm' : 'numeral',\n",
    "           'p' : 'pron',\n",
    "           'v' : 'verb',\n",
    "           't' : 'verb', \n",
    "           'x' : 'irregular',\n",
    "           'l' : 'article',\n",
    "           'e' : 'exclamation',\n",
    "           'a' : 'adjective',\n",
    "           'r' : 'preposition',\n",
    "           'c' : 'conjunction',\n",
    "           'g' : 'adverb',\n",
    "           'u' : 'punctuation',\n",
    "      }\n",
    "person = {'1' : \"1st\", '-' : '-', '3' : '3rd' , '2' : '2nd'} \n",
    "number = {'s' : 'singular', '-' : '-', 'p' : 'plural', 'd' : 'dual'}\n",
    "tense = reverseDict({'imperfect' : 'i',\n",
    "                     'future' : 'f',\n",
    "                     'perfect' : 'r',\n",
    "                     '-' : '-',\n",
    "                     'future_perfect' : 't',\n",
    "                     'aorist' : 'a',\n",
    "                     'pluperfect' : 'l',\n",
    "                     'present' : 'p'})\n",
    "mood  = reverseDict({'optative' : 'o', '-' : '-', 'imperative' : 'm', 'indicative' : 'i', 'infintive' : 'n', 'subjunctive' : 's', 'participle' : 'p'})\n",
    "voice = reverseDict({'middle' : 'm',\n",
    "                     'passive' : 'p',\n",
    "                     '-' : '-' ,\n",
    "                     'mediopassive' : 'e',\n",
    "                     'active' : 'a'})\n",
    "gender = reverseDict({'neuter' : 'n', 'masculine' : 'm', 'feminine' : 'f', '-' : '-'})\n",
    "case = reverseDict({'accusative' : 'a',\n",
    "                    'nominative' : 'n', \n",
    "                    'vocative' : 'v', \n",
    "                    '-' : '-', \n",
    "                    'dative' : 'd', \n",
    "                    'genitive' : 'g'})\n",
    "degree = reverseDict({'superl' : 's', '-' : '-', 'comp' : 'c'})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true,
    "init_cell": true
   },
   "outputs": [],
   "source": [
    "def _setPropIfThere(el, p):\n",
    "    '''generic function that tries to set a proprety by accessing the appropriate XML attribute;\n",
    "    if the attribute is not there, an empty string is returned.\n",
    "    This is used for properties like \"cite\" or \"cid\" that might\n",
    "    or might not be set for all files'''\n",
    "    try:\n",
    "        s = el.attrib[p]\n",
    "    except KeyError:\n",
    "        s = None\n",
    "    return s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": true,
    "init_cell": true
   },
   "outputs": [],
   "source": [
    "class Sentence():\n",
    "    def __init__(self, el, **kwargs):\n",
    "        '''Takes a parsed xml sentence element, returns a Sentence object with a series of properties defined.\n",
    "        Optionally, you can pass a series of keyword:value pairs, including:\n",
    "        - author\n",
    "        - title of the work\n",
    "        - genre\n",
    "        - chronology\n",
    "        - meter'''\n",
    "        self._element = el\n",
    "        self._raw = etree.tostring(el, encoding=\"UTF-8\").decode(\"utf8\")\n",
    "        self._doc_id = el.attrib[\"document_id\"]\n",
    "        self.sent_id = el.attrib[\"id\"]\n",
    "        self.subdoc = el.attrib[\"subdoc\"]\n",
    "        self.span = el.attrib[\"span\"]\n",
    "        self._artificials = [t for t in self._tokens if type(t) is Artificial_Token]\n",
    "        self._words = [t for t in self._tokens if type(t) is Word]\n",
    "        self._stats = (len(self._tokens), len(self._artificials), len(self._tokens) - len(self._artificials))\n",
    "        self.address = self._doc_id.split(\":\")[-1] + \"#\" + self.sent_id + \"#\" + '0'\n",
    "        \n",
    "        #Some bibliographic information\n",
    "        self.author = kwargs.pop(\"author\", None)\n",
    "        self.work = kwargs.pop(\"work\", None)\n",
    "        self.genre = kwargs.pop(\"genre\", None)\n",
    "        self.chronology = kwargs.pop(\"chronology\", None)\n",
    "        \n",
    "        #Content-related information\n",
    "        self.speaker = kwargs.pop(\"speaker\", \"\")\n",
    "        self.meter = kwargs.pop(\"meter\", \"\")\n",
    "        \n",
    "    def _isArtificial(self, t):\n",
    "        try:\n",
    "            t.attrib[\"artificial\"]\n",
    "            return(True)\n",
    "        except KeyError:\n",
    "            return(False)\n",
    "\n",
    "    @property    \n",
    "    def _tokens(self):\n",
    "        tokens = []\n",
    "        toks = self._element.xpath(\"word\")\n",
    "        for t in toks:\n",
    "            if self._isArtificial(t):\n",
    "                tokens.append(Artificial_Token(t))\n",
    "            else:\n",
    "                tokens.append(Word(t))\n",
    "        return tokens\n",
    "    \n",
    "    \n",
    "    def printStats(self):\n",
    "        print('''Total tokens:\\t{};\\nWords:\\t{};\\nArtificial nodes:\\t{}'''.format(self._stats[0],\n",
    "                                                                                 self._stats[2], self._stats[1]))\n",
    "    \n",
    "    def __str__(self):\n",
    "        '''returns the plain sentence'''\n",
    "        return ' '.join([s.form for s in self._tokens if type(t) is Word])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false,
    "init_cell": true
   },
   "outputs": [],
   "source": [
    "class Token():\n",
    "    '''Super-class for both words and artificial nodes. All that is common to both should go here'''\n",
    "    def __init__(self, word_element):\n",
    "        self._element = word_element\n",
    "        self._raw =  etree.tostring(word_element, encoding=\"UTF-8\").decode(\"utf8\")\n",
    "        self._token_id = word_element.attrib[\"id\"]\n",
    "        self.rank = self._token_id\n",
    "        self.form = word_element.attrib[\"form\"]\n",
    "        #the original relation tag\n",
    "        self.original_label = word_element.attrib[\"relation\"]\n",
    "        #the relation tag split in the components:\n",
    "        #e.g. \"SBJ_AP_CO\" > [SBJ, AP, CO]\n",
    "        self._rel_components = self.original_label.split(\"_\")\n",
    "        self.head = word_element.attrib[\"head\"]\n",
    "        self._relation = self._rel_components[0]\n",
    "        #it might not be there for artificial!\n",
    "        self._lemma_original = _setPropIfThere(word_element, \"lemma\")\n",
    "        self.postag = _setPropIfThere(word_element, \"postag\")\n",
    "\n",
    "        #Getter\n",
    "        self.lemma\n",
    "        self.address\n",
    "        self._morphology\n",
    "        \n",
    "    def setIsMember(self, tag):\n",
    "        assert tag in [\"AP\", \"CO\"],\"the appendix tag must be either AP or CO!\"\n",
    "        if tag in self._rel_components:\n",
    "            return 1\n",
    "        else:\n",
    "            return 0\n",
    "        \n",
    "    @property\n",
    "    def lemma(self):\n",
    "        if self._lemma_original is not None:\n",
    "            return re.sub('[0-9]+$', '', self._lemma_original)\n",
    "        else:\n",
    "            return None\n",
    "    @property\n",
    "    def address(self):\n",
    "        sent = self._element.getparent()\n",
    "        return \"{}#{}#{}\".format(sent.attrib[\"document_id\"].split(\":\")[-1], sent.attrib[\"id\"], self._token_id)\n",
    "    \n",
    "    @property\n",
    "    def _morphology(self):\n",
    "        if self.postag == None:\n",
    "            return None \n",
    "        else:\n",
    "            return Morph(self.postag)\n",
    "            "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false,
    "init_cell": true
   },
   "outputs": [],
   "source": [
    "class Word(Token):\n",
    "    def __init__(self, word_element):\n",
    "        Token.__init__(self, word_element)\n",
    "        #These might not be there!\n",
    "        self.cid = _setPropIfThere(word_element, \"cid\")\n",
    "        self.cite = _setPropIfThere(word_element, \"cite\")\n",
    "        self.isMemberOfCoord = Token.setIsMember(self, \"CO\")\n",
    "        self.isMemberOfApos = Token.setIsMember(self, \"AP\")\n",
    "\n",
    "        #Semantics\n",
    "        #to be implemented\n",
    "        self.ne_type = ''\n",
    "        self.animacy = ''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false,
    "init_cell": true
   },
   "outputs": [],
   "source": [
    "class Artificial_Token(Token):\n",
    "    def __init__(self, word_element):\n",
    "        Token.__init__(self, word_element)\n",
    "        self._insertion_id = word_element.attrib[\"insertion_id\"]\n",
    "        self.artificial_type = word_element.attrib[\"artificial\"]\n",
    "        self.isMemberOfCoord = Token.setIsMember(self, \"CO\")\n",
    "        self.isMemberOfApos = Token.setIsMember(self, \"AP\")\n",
    "        #self.morphology = Token.setMorphs(self)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": true,
    "init_cell": true
   },
   "outputs": [],
   "source": [
    "class Morph():\n",
    "    def __init__(self, tag):\n",
    "        assert len(tag) == 9, \"Tag: {} is invalid\".format(tag)\n",
    "        self.pos = pos[tag[0]]\n",
    "        self.person = person[tag[1]]\n",
    "        self.number = number[tag[2]]\n",
    "        self.tense = tense[tag[3]] \n",
    "        self.mood = mood[tag[4]]\n",
    "        self.voice = voice[tag[5]] \n",
    "        self.gender = gender[tag[6]]\n",
    "        self.case = case[tag[7]]\n",
    "        self.degree = degree[tag[8]]\n",
    "        \n",
    "    @property\n",
    "    def full(self):\n",
    "        return {'pos' : self.pos,\n",
    "               'person' : self.person,\n",
    "               'number' : self.number,\n",
    "               'tense' : self.tense,\n",
    "               'mood' : self.mood,\n",
    "               'voice' : self.voice,\n",
    "               'gender' : self.gender,\n",
    "               'case' : self.case,\n",
    "               'degree' : self.degree,\n",
    "               }"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tests"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "t = s._tokens[4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 202,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "<lambda>() missing 1 required positional argument: 'n'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-202-0a37cd03aea2>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0msetPropDict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mt\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<ipython-input-201-68099d5f56f0>\u001b[0m in \u001b[0;36msetPropDict\u001b[0;34m(obj)\u001b[0m\n\u001b[1;32m      2\u001b[0m     \u001b[0;34m'''takes an object. Return the list of properties, excluding those that begins with \"_\"'''\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m     return {n:v for n,v in inspect.getmembers(obj,\n\u001b[0;32m----> 4\u001b[0;31m                             lambda obj,n: isinstance(getattr(type(obj), n, None), property)) if n[0] != '_'}\n\u001b[0m",
      "\u001b[0;32m/Users/fmambrini/anaconda/lib/python3.4/inspect.py\u001b[0m in \u001b[0;36mgetmembers\u001b[0;34m(object, predicate)\u001b[0m\n\u001b[1;32m    300\u001b[0m                 \u001b[0;31m# __dir__; discard and move on\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    301\u001b[0m                 \u001b[0;32mcontinue\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 302\u001b[0;31m         \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mpredicate\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0mpredicate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mvalue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    303\u001b[0m             \u001b[0mresults\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvalue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    304\u001b[0m         \u001b[0mprocessed\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0madd\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mTypeError\u001b[0m: <lambda>() missing 1 required positional argument: 'n'"
     ]
    }
   ],
   "source": [
    "setPropDict(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'tlg0011.tlg001.perseus-grc2#2898476#28'"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t.address"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'noun'"
      ]
     },
     "execution_count": 125,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t._morphology.pos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 173,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "inspect.isdatadescriptor(t._element)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 191,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 191,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "isinstance(getattr(type(t), \"lemma\", None), property)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "properties = inspect.getmembers(t, lambda o: isinstance(o, property))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'address': 'tlg0011.tlg001.perseus-grc2#2898476#5',\n",
       " 'animacy': '',\n",
       " 'cid': '36335582',\n",
       " 'cite': 'urn:cts:greekLit:tlg0011.tlg001:1',\n",
       " 'form': 'ἀνθρώπων',\n",
       " 'head': '1',\n",
       " 'isMemberOfApos': 0,\n",
       " 'isMemberOfCoord': 0,\n",
       " 'lemma': 'ἄνθρωπος',\n",
       " 'ne_type': '',\n",
       " 'original_label': 'ATR',\n",
       " 'postag': 'n-p---mg-',\n",
       " 'rank': '5'}"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "setPropDict(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('tlg0011.tlg001.perseus-grc2#2898476#1',\n",
       " 'tlg0011.tlg001.perseus-grc2#2898476#5')"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "_createHeadDep(t)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# To Graph DB"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": true,
    "init_cell": true
   },
   "outputs": [],
   "source": [
    "def _createHeadDep(t):\n",
    "    '''gets a token object (word or artificial);\n",
    "    returns a tuple (head-address, dependent-address)'''\n",
    "    add_parts = t.address.split(\"#\")\n",
    "    return (\"{}#{}#{}\".format(add_parts[0], add_parts[1], t.head), t.address)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false,
    "init_cell": true
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 't' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-11-9304e4a63553>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0m_createHeadDep\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mt\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 't' is not defined"
     ]
    }
   ],
   "source": [
    "_createHeadDep(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "init_cell": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "init_cell": true
   },
   "outputs": [],
   "source": [
    "def createRels(Sent, graph):\n",
    "    '''Takes a Sentence object and a Neo4j graph! Note that the nodes must have been already created in the DB'''\n",
    "    for t in Sent._tokens:\n",
    "        head_add,dep_add = _createHeadDep(t)\n",
    "        query = '''MATCH (h),(d)\n",
    "        WHERE h.address = \"{}\" AND d.address = \"{}\"\n",
    "        CREATE UNIQUE (h)-[r:{}]->(d)\n",
    "        RETURN r'''.format(head_add, dep_add,t._relation)\n",
    "        graph.run(query)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "init_cell": true
   },
   "outputs": [],
   "source": [
    "def setPropDict(obj):\n",
    "    '''takes an object. Return the list of properties, excluding those that begins with \"_\"'''\n",
    "    return {n:v for n,v in inspect.getmembers(obj)\n",
    "            if n[0] != '_' and not inspect.ismethod(v)}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "init_cell": true
   },
   "outputs": [],
   "source": [
    "def toGraphNodes(s):\n",
    "    '''converts the elements of a sentence into Nodes and Relationships ready to be pushed to a Neo4j db.\n",
    "    This includes the root node itself!\n",
    "    '''\n",
    "    #sent_props = {k:v for k,v in vars(t).items() if k[0] != '_'}\n",
    "    root = Node(\"Sentence\", **setPropDict(s))\n",
    "    nodes = [root]\n",
    "    for t in s._tokens:\n",
    "        if type(t) is Word:\n",
    "            n = Node(\"Token\", **setPropDict(t))\n",
    "        else:\n",
    "            n = Node(\"Artificial\", **setPropDict(t))\n",
    "        if t._morphology:\n",
    "            for k,v in t._morphology.full.items():\n",
    "                n[k] = v\n",
    "        nodes.append(n)\n",
    "    return nodes "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "init_cell": true
   },
   "outputs": [],
   "source": [
    "def createNodes(graph, nodes):\n",
    "    for n in nodes:\n",
    "        graph.create(n)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Workflow sample"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We start by transforming a sentence into a series of Graph nodes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "nodes = toGraphNodes(s)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Here is an example of a word"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(d7cad89:Artificial {address:\"tlg0011.tlg001.perseus-grc2#2898476#30\",artificial_type:\"elliptic\",form:\"[0]\",head:\"22\",isMemberOfApos:1,isMemberOfCoord:1,original_label:\"OBJ_AP_CO\",rank:\"30\"})"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nodes[30]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We connect to the Graph DB"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "g = Graph(password=\"boston4ever\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Very important, we create a **uniqueness constraint** on the node address, so that no two nodes for the same token in added to the DB"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we create the nodes and commit them to the DB!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "for n in nodes:\n",
    "    g.merge(n)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And here we create the relations!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "createRels(s, g)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(c311769:Token {address:\"tlg0011.tlg001.perseus-grc2#2898476#28\",animacy:\"\",case:\"nominative\",cid:\"36335603\",cite:\"urn:cts:greekLit:tlg0011.tlg001:3\",degree:\"-\",form:\"κακός\",gender:\"masculine\",head:\"31\",isMemberOfApos:0,isMemberOfCoord:0,lemma:\"κακός\",mood:\"-\",ne_type:\"\",number:\"singular\",original_label:\"PNOM\",person:\"-\",pos:\"adjective\",postag:\"a-s---mn-\",rank:\"28\",tense:\"-\",voice:\"-\"})"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nodes[28]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Some useful queries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Match nodes, regardless whether they're Sentences, Tokens or Artificials "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```cypher\n",
    "MATCH t\n",
    "WHERE t:Token OR t:Artificial\n",
    "RETURN t\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Get a sentence and the descendants"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```cypher\n",
    "MATCH path= (t)<-[*]-(Sentence)    \n",
    "WHERE t:Token OR t:Artificial\n",
    "RETURN path\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Delete all nodes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```cypher\n",
    "MATCH (n)\n",
    "OPTIONAL MATCH (n)-[r]-()\n",
    "DELETE n,r\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#Clear the DB"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**CAREFUL!** The following statement will clear the db.."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#g.delete_all()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Main loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "g = Graph(password=\"boston4ever\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x = etree.parse(\\\n",
    "'/Users/fmambrini/Documents/lavoro/treebank/files/AGDT2.X/data/tlg0011.tlg001.perseus-grc2.tb.xml')\n",
    "sents = x.xpath(\"//sentence\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "biblio = {\"author\" : \"Sophocles\", \"genre\" : \"tragedy\", \"chronology\" : \"5th BCE\",\n",
    "         \"work\" : \"Trachiniae\"}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 3 µs, sys: 0 ns, total: 3 µs\n",
      "Wall time: 5.01 µs\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "for s_el in sents:\n",
    "    s = Sentence(s_el, **biblio)\n",
    "    nodes = toGraphNodes(s)\n",
    "    for n in nodes:\n",
    "        g.merge(n)\n",
    "    createRels(s, g)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 363,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "ns = { 'tb' : \"http://nlp.perseus.tufts.edu/syntax/treebank/1.5\"}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 364,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "x = etree.parse('/Users/fmambrini/Documents/lavoro/treebank/files/AGDT2.X/data/tlg0011.tlg001.perseus-grc2.tb.xml')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "sents = x.xpath(\"//sentence\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "s = Sentence(sents[0], **{\"author\" : \"Sophocles\"})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "t = s._tokens[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'_element': <Element word at 0x104954a48>,\n",
       " '_lemma_original': 'λόγος1',\n",
       " '_raw': '<word xmlns:treebank=\"http://nlp.perseus.tufts.edu/syntax/treebank/1.5\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" id=\"1\" cid=\"36335578\" form=\"&#x3BB;&#x3CC;&#x3B3;&#x3BF;&#x3C2;\" lemma=\"&#x3BB;&#x3CC;&#x3B3;&#x3BF;&#x3C2;1\" postag=\"n-s---mn-\" head=\"3\" relation=\"SBJ\" cite=\"urn:cts:greekLit:tlg0011.tlg001:1\"/>\\n        ',\n",
       " '_rel_components': ['SBJ'],\n",
       " '_relation': 'SBJ',\n",
       " '_token_id': '1',\n",
       " 'animacy': '',\n",
       " 'cid': '36335578',\n",
       " 'cite': 'urn:cts:greekLit:tlg0011.tlg001:1',\n",
       " 'form': 'λόγος',\n",
       " 'head': '3',\n",
       " 'isMemberOfApos': 0,\n",
       " 'isMemberOfCoord': 0,\n",
       " 'ne_type': '',\n",
       " 'original_label': 'SBJ',\n",
       " 'postag': 'n-s---mn-',\n",
       " 'rank': '1'}"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t.__dict__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 371,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 371,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(\"p-s---fn-\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 372,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total tokens:\t31;\n",
      "Words:\t29;\n",
      "Artificial nodes:\t2\n"
     ]
    }
   ],
   "source": [
    "s.printStats()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 397,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "sentences = []\n",
    "for s in sents:\n",
    "    sentences.append(Sentence(s))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 406,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "s = sentences[0]\n",
    "t = s._tokens[4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 407,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'n-p---mg-'"
      ]
     },
     "execution_count": 407,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t._element.attrib[\"postag\"]\n",
    "#t.lemma"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 379,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'function' object has no attribute 'full'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-379-502508ed6598>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;32mfor\u001b[0m \u001b[0mk\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mv\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_morphology\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mitems\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      2\u001b[0m     \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"{}\\t{}\"\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mformat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mk\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mv\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mAttributeError\u001b[0m: 'function' object has no attribute 'full'"
     ]
    }
   ],
   "source": [
    "for k,v in t._morphology.full.items():\n",
    "    print(\"{}\\t{}\".format(k,v))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 182,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'οὐκ'"
      ]
     },
     "execution_count": 182,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "_setPropIfThere(t.element, \"form\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'λόγος'"
      ]
     },
     "execution_count": 173,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "re.sub('[0-9]+$', '', \"λόγος1\")\n",
    "#re.sub('[0-9]+$', '', \"λόγο\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 274,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SBJ => SBJ\n",
      "AuxY => AuxY\n",
      "PRED => PRED\n",
      "ATV => ATV\n",
      "ATR => ATR\n",
      "ATR => ATR\n",
      "AuxX => AuxX\n",
      "AuxC => AuxC\n",
      "AuxZ => AuxZ\n",
      "AuxY => AuxY\n",
      "OBJ_AP => OBJ\n",
      "ATR => ATR\n",
      "ATR => ATR\n",
      "AuxX => AuxX\n",
      "ADV => ADV\n",
      "AuxY => AuxY\n",
      "ADV => ADV\n",
      "SBJ => SBJ\n",
      "APOS => APOS\n",
      "AuxZ => AuxZ\n",
      "AuxY => AuxY\n",
      "AuxC => AuxC\n",
      "PNOM => PNOM\n",
      "AuxZ => AuxZ\n",
      "COORD => COORD\n",
      "AuxC => AuxC\n",
      "ADV => ADV\n",
      "PNOM => PNOM\n",
      "AuxK => AuxK\n",
      "OBJ_AP_CO => OBJ\n",
      "OBJ_AP_CO => OBJ\n"
     ]
    }
   ],
   "source": [
    "for tok in s._tokens:\n",
    "    print(\"{} => {}\".format(tok.original_label, tok._relation))\n",
    "    #print(type(t))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 196,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "root = Node(\"Sentence\", sentence_id=s.sent_id,\n",
    "                    address=s.address,\n",
    "                    document = s.doc_id,\n",
    "                    subdoc = s.subdoc,\n",
    "                    span = s.span,\n",
    "                   author = s.author,\n",
    "                   work = s.work,\n",
    "                   chronology=s.chronology,\n",
    "                   genre = s.genre,\n",
    "                   speaker = s.speaker,\n",
    "                    meter = s.meter\n",
    "                   )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 218,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 219,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'animacy': '',\n",
       " 'artificial_type': 'elliptic',\n",
       " 'element': <Element word at 0x103d11b08>,\n",
       " 'form': '[1]',\n",
       " 'head': '26',\n",
       " 'isMemberOfApos': 1,\n",
       " 'isMemberOfCoord': 1,\n",
       " 'lemma_original': None,\n",
       " 'ne_type': '',\n",
       " 'postag': None,\n",
       " 'relation': 'OBJ',\n",
       " 'token_id': '31'}"
      ]
     },
     "execution_count": 219,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "props"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 226,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "d = {'form': '[1]',\n",
    " 'head': '26',\n",
    " 'isMemberOfApos': 1, 'lemma_original': \"None\"}\n",
    "\n",
    "n = Node(\"#Artificial\", **d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 227,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(a5110f2:`#Artificial` {form:\"[1]\",head:\"26\",isMemberOfApos:1,lemma_original:\"None\"})"
      ]
     },
     "execution_count": 227,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 228,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "n[\"saint\"] = \"padre pio\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 229,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(a5110f2:`#Artificial` {form:\"[1]\",head:\"26\",isMemberOfApos:1,lemma_original:\"None\",saint:\"padre pio\"})"
      ]
     },
     "execution_count": 229,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 298,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "class Fuffa():\n",
    "    def __init__(self, par):\n",
    "        self.par = par\n",
    "    \n",
    "    @property\n",
    "    def robba(self):\n",
    "        if self.par:\n",
    "            return \"Hurra!\"\n",
    "        else:\n",
    "            return [\"pd\", \"pm\", \"pp\"][1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 299,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "f = Fuffa(None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 300,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'pm'"
      ]
     },
     "execution_count": 300,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f.robba"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "head_add,dep_add = _createHeadDep(t)\n",
    "query = '''MATCH (h),(d)\n",
    "WHERE h.address = \"{}\" AND d.address = \"{}\"\n",
    "CREATE (h)-[r:{}]->(d)\n",
    "RETURN r'''.format(head_add, dep_add,t._relation)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'MATCH (h),(d)\\nWHERE h.address = \"tlg0011.tlg001.perseus-grc2#2898476#1\" AND d.address = \"tlg0011.tlg001.perseus-grc2#2898476#5\"\\nCREATE (h)-[r:ATR]->(d)\\nRETURN r'"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "query"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on class Graph in module py2neo.database:\n",
      "\n",
      "class Graph(builtins.object)\n",
      " |  The `Graph` class represents a Neo4j graph database. Connection\n",
      " |  details are provided using URIs and/or individual settings. For any\n",
      " |  given `Graph`, the following protocol combinations are supported:\n",
      " |  \n",
      " |  - HTTP\n",
      " |  - HTTPS\n",
      " |  - Bolt + HTTP\n",
      " |  - Bolt/TLS + HTTPS\n",
      " |  \n",
      " |  Note that either HTTP or HTTPS must be enabled to allow for\n",
      " |  discovery and for some legacy features to be supported.\n",
      " |  \n",
      " |  The full set of `settings` supported are:\n",
      " |  \n",
      " |  ==============  =============================================  ==============  =============\n",
      " |  Keyword         Description                                    Type(s)         Default\n",
      " |  ==============  =============================================  ==============  =============\n",
      " |  ``bolt``        Use Bolt* protocol (`None` means autodetect)   bool, ``None``  ``None``\n",
      " |  ``secure``      Use a secure connection (Bolt/TLS + HTTPS)     bool            ``False``\n",
      " |  ``host``        Database server host name                      str             ``'localhost'``\n",
      " |  ``http_port``   Port for HTTP traffic                          int             ``7474``\n",
      " |  ``https_port``  Port for HTTPS traffic                         int             ``7473``\n",
      " |  ``bolt_port``   Port for Bolt traffic                          int             ``7687``\n",
      " |  ``user``        User to authenticate as                        str             ``'neo4j'``\n",
      " |  ``password``    Password to use for authentication             str             `no default`\n",
      " |  ==============  =============================================  ==============  =============\n",
      " |  \n",
      " |  *\\* The new Bolt binary protocol is the successor to HTTP and available in Neo4j 3.0 and above.*\n",
      " |  \n",
      " |  Each setting can be provided as a keyword argument or as part of\n",
      " |  an ``http:``, ``https:`` or ``bolt:`` URI. Therefore, the examples\n",
      " |  below are equivalent::\n",
      " |  \n",
      " |      >>> from py2neo import Graph\n",
      " |      >>> graph_1 = Graph()\n",
      " |      >>> graph_2 = Graph(host=\"localhost\")\n",
      " |      >>> graph_3 = Graph(\"http://localhost:7474/db/data/\")\n",
      " |  \n",
      " |  Once obtained, the `Graph` instance provides direct or indirect\n",
      " |  access to most of the functionality available within py2neo. If\n",
      " |  Bolt is available (Neo4j 3.0 and above) and Bolt auto-detection\n",
      " |  is enabled, this will be used for Cypher queries instead of HTTP.\n",
      " |  \n",
      " |  Methods defined here:\n",
      " |  \n",
      " |  __bool__(self)\n",
      " |  \n",
      " |  __contains__(self, entity)\n",
      " |  \n",
      " |  __hash__(self)\n",
      " |  \n",
      " |  __len__(self)\n",
      " |  \n",
      " |  __nonzero__(self)\n",
      " |  \n",
      " |  __order__(self)\n",
      " |  \n",
      " |  __repr__(self)\n",
      " |  \n",
      " |  __size__(self)\n",
      " |  \n",
      " |  begin(self, autocommit=False)\n",
      " |      Begin a new :class:`.Transaction`.\n",
      " |      \n",
      " |      :param autocommit: if :py:const:`True`, the transaction will\n",
      " |                       automatically commit after the first operation\n",
      " |  \n",
      " |  create(self, subgraph)\n",
      " |      Run a :meth:`.Transaction.create` operation within an\n",
      " |      `autocommit` :class:`.Transaction`.\n",
      " |      \n",
      " |      :param subgraph: a :class:`.Node`, :class:`.Relationship` or other\n",
      " |                     :class:`.Subgraph`\n",
      " |  \n",
      " |  degree(self, subgraph)\n",
      " |      Run a :meth:`.Transaction.degree` operation within an\n",
      " |      `autocommit` :class:`.Transaction`.\n",
      " |      \n",
      " |      :param subgraph: a :class:`.Node`, :class:`.Relationship` or other\n",
      " |                     :class:`.Subgraph` object\n",
      " |      :return: the total degree of all nodes in the subgraph\n",
      " |  \n",
      " |  delete(self, subgraph)\n",
      " |      Run a :meth:`.Transaction.delete` operation within an\n",
      " |      `autocommit` :class:`.Transaction`.\n",
      " |      \n",
      " |      :param subgraph: a :class:`.Node`, :class:`.Relationship` or other\n",
      " |                     :class:`.Subgraph` object\n",
      " |  \n",
      " |  delete_all(self)\n",
      " |      Delete all nodes and relationships from this :class:`.Graph`.\n",
      " |      \n",
      " |      .. warning::\n",
      " |          This method will permanently remove **all** nodes and relationships\n",
      " |          from the graph and cannot be undone.\n",
      " |  \n",
      " |  evaluate(self, statement, parameters=None, **kwparameters)\n",
      " |      Run a :meth:`.Transaction.evaluate` operation within an\n",
      " |      `autocommit` :class:`.Transaction`.\n",
      " |      \n",
      " |      :param statement: Cypher statement\n",
      " |      :param parameters: dictionary of parameters\n",
      " |      :return: first value from the first record returned or\n",
      " |               :py:const:`None`.\n",
      " |  \n",
      " |  exists(self, subgraph)\n",
      " |      Run a :meth:`.Transaction.exists` operation within an\n",
      " |      `autocommit` :class:`.Transaction`.\n",
      " |      \n",
      " |      :param subgraph: a :class:`.Node`, :class:`.Relationship` or other\n",
      " |                     :class:`.Subgraph` object\n",
      " |      :return:\n",
      " |  \n",
      " |  find(self, label, property_key=None, property_value=None, limit=None)\n",
      " |      Yield all nodes with a given label, optionally filtering\n",
      " |      by property key and value.\n",
      " |      \n",
      " |      :param label: node label to match\n",
      " |      :param property_key: property key to match\n",
      " |      :param property_value: property value to match; if a tuple or set is\n",
      " |                             provided, any of these values may be matched\n",
      " |      :param limit: maximum number of nodes to match\n",
      " |  \n",
      " |  find_one(self, label, property_key=None, property_value=None)\n",
      " |      Find a single node by label and optional property. This method is\n",
      " |      intended to be used with a unique constraint and does not fail if more\n",
      " |      than one matching node is found.\n",
      " |      \n",
      " |      :param label: node label to match\n",
      " |      :param property_key: property key to match\n",
      " |      :param property_value: property value to match; if a tuple or set is\n",
      " |                             provided, any of these values may be matched\n",
      " |  \n",
      " |  match(self, start_node=None, rel_type=None, end_node=None, bidirectional=False, limit=None)\n",
      " |      Match and return all relationships with specific criteria.\n",
      " |      \n",
      " |      For example, to find all of Alice's friends::\n",
      " |      \n",
      " |          for rel in graph.match(start_node=alice, rel_type=\"FRIEND\"):\n",
      " |              print(rel.end_node()[\"name\"])\n",
      " |      \n",
      " |      :param start_node: start node of relationships to match (:const:`None` means any node)\n",
      " |      :param rel_type: type of relationships to match (:const:`None` means any type)\n",
      " |      :param end_node: end node of relationships to match (:const:`None` means any node)\n",
      " |      :param bidirectional: :const:`True` if reversed relationships should also be included\n",
      " |      :param limit: maximum number of relationships to match (:const:`None` means unlimited)\n",
      " |  \n",
      " |  match_one(self, start_node=None, rel_type=None, end_node=None, bidirectional=False)\n",
      " |      Match and return one relationship with specific criteria.\n",
      " |      \n",
      " |      :param start_node: start node of relationships to match (:const:`None` means any node)\n",
      " |      :param rel_type: type of relationships to match (:const:`None` means any type)\n",
      " |      :param end_node: end node of relationships to match (:const:`None` means any node)\n",
      " |      :param bidirectional: :const:`True` if reversed relationships should also be included\n",
      " |  \n",
      " |  merge(self, subgraph, label=None, *property_keys)\n",
      " |      Run a :meth:`.Transaction.merge` operation within an\n",
      " |      `autocommit` :class:`.Transaction`.\n",
      " |      \n",
      " |      :param subgraph: a :class:`.Node`, :class:`.Relationship` or other\n",
      " |                     :class:`.Subgraph` object\n",
      " |      :param label: label on which to match any existing nodes\n",
      " |      :param property_keys: property keys on which to match any existing nodes\n",
      " |  \n",
      " |  node(self, id_)\n",
      " |      Fetch a node by ID. This method creates an object representing the\n",
      " |      remote node with the ID specified but fetches no data from the server.\n",
      " |      For this reason, there is no guarantee that the entity returned\n",
      " |      actually exists.\n",
      " |      \n",
      " |      :param id_:\n",
      " |  \n",
      " |  open_browser(self)\n",
      " |      Open a page in the default system web browser pointing at\n",
      " |      the Neo4j browser application for this graph.\n",
      " |  \n",
      " |  pull(self, subgraph)\n",
      " |      Pull data to one or more entities from their remote counterparts.\n",
      " |      \n",
      " |      :param subgraph: the collection of nodes and relationships to pull\n",
      " |  \n",
      " |  push(self, subgraph)\n",
      " |      Push data from one or more entities to their remote counterparts.\n",
      " |      \n",
      " |      :param subgraph: the collection of nodes and relationships to push\n",
      " |  \n",
      " |  relationship(self, id_)\n",
      " |      Fetch a relationship by ID.\n",
      " |      \n",
      " |      :param id_:\n",
      " |  \n",
      " |  run(self, statement, parameters=None, **kwparameters)\n",
      " |      Run a :meth:`.Transaction.run` operation within an\n",
      " |      `autocommit` :class:`.Transaction`.\n",
      " |      \n",
      " |      :param statement: Cypher statement\n",
      " |      :param parameters: dictionary of parameters\n",
      " |      :return:\n",
      " |  \n",
      " |  separate(self, subgraph)\n",
      " |      Run a :meth:`.Transaction.separate` operation within an\n",
      " |      `autocommit` :class:`.Transaction`.\n",
      " |      \n",
      " |      :param subgraph: a :class:`.Node`, :class:`.Relationship` or other\n",
      " |                     :class:`.Subgraph`\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Static methods defined here:\n",
      " |  \n",
      " |  __new__(cls, *uris, **settings)\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data descriptors defined here:\n",
      " |  \n",
      " |  __dict__\n",
      " |      dictionary for instance variables (if defined)\n",
      " |  \n",
      " |  __weakref__\n",
      " |      list of weak references to the object (if defined)\n",
      " |  \n",
      " |  dbms\n",
      " |      The database management system to which this :class:`.Graph`\n",
      " |      instance belongs.\n",
      " |  \n",
      " |  neo4j_version\n",
      " |  \n",
      " |  node_labels\n",
      " |      The set of node labels currently defined within the graph.\n",
      " |  \n",
      " |  relationship_types\n",
      " |      The set of relationship types currently defined within the graph.\n",
      " |  \n",
      " |  schema\n",
      " |      The schema resource for this graph.\n",
      " |      \n",
      " |      :rtype: :class:`Schema`\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes defined here:\n",
      " |  \n",
      " |  driver = None\n",
      " |  \n",
      " |  transaction_class = None\n",
      "\n"
     ]
    }
   ],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "toks = s._tokens"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "t = toks[22]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'PNOM'"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t._relation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "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.4.5"
  },
  "toc": {
   "colors": {
    "hover_highlight": "#DAA520",
    "running_highlight": "#FF0000",
    "selected_highlight": "#FFD700"
   },
   "moveMenuLeft": true,
   "nav_menu": {
    "height": "142px",
    "width": "252px"
   },
   "navigate_menu": true,
   "number_sections": true,
   "sideBar": true,
   "threshold": 4,
   "toc_cell": false,
   "toc_section_display": "block",
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}