CODE triplestore.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "from uuid import uuid4, UUID\n",
    "from collections import namedtuple, defaultdict\n",
    "from enum import Enum\n",
    "from itertools import product\n",
    "\n",
    "class StoreException(UserWarning):\n",
    "    \"\"\"All Exceptions specific to this package for easy filtering.\"\"\"\n",
    "\n",
    "class Predicate:\n",
    "    \"\"\"See django validators.\"\"\"\n",
    "    def validate(self, value):\n",
    "        return True\n",
    "    \n",
    "    @property\n",
    "    def name(self):\n",
    "        return self.__class__.__name__\n",
    "\n",
    "class E:\n",
    "    \"\"\"Entity.\n",
    "    Most entities will be anonymous, which is perfectly fine, while some can have names.\n",
    "    Entities are the same whenever they have the same id, which is unique.\n",
    "    These are NOT singletons (which could be conceivable), but due to the UUID used as\n",
    "    hash, they behave very similar, for instance as keys in dicts.\n",
    "    \n",
    "    >>> x = E(\"hello\")\n",
    "    >>> y = eval(repr(x))\n",
    "    >>> x == y\n",
    "    True\n",
    "    \"\"\"\n",
    "    def __init__(self, name=None, id_=None, url=None):        \n",
    "        \n",
    "        self.name = None\n",
    "        \n",
    "        if name is None:\n",
    "            self.name = None\n",
    "        elif not str.isidentifier(name):\n",
    "            raise StoreException(\"%s not an identifier.\"%name)\n",
    "        else:\n",
    "            self.name = name\n",
    "        \n",
    "        self.id = UUID(id_) if id_ is not None else uuid4()\n",
    "    \n",
    "    def __hash__(self):\n",
    "        return self.id.int\n",
    "    \n",
    "    def __str__(self):\n",
    "        return self.name if self.name is not None else \"_\" + str(self.id)[:5]\n",
    "    \n",
    "    def __repr__(self):\n",
    "        \"\"\"Return representation so that e == eval(repr(e))\"\"\"\n",
    "        return (\"\"\"E(\"\n",
    "                f'''{f\"name='{self.name}',\" if self.name is not None else ''}'''\n",
    "                f\"id_='{self.id}',\n",
    "                f\"url='{self.url}')\"\"\"\n",
    "               )\n",
    "    \n",
    "    def __eq__(self, other):\n",
    "        return self.id == other.id\n",
    "\n",
    "\n",
    "SPO = namedtuple(\"Triplet\", \"s p o\")\n",
    "\n",
    "class TripleStore:\n",
    "    \"\"\"A set of three dicts that work together as one.\n",
    "    \n",
    "    Keep in mind that the primary dict - spo - is a Python3 dict,\n",
    "    which works as an OrderedDict that remembers insertion order.\n",
    "    It might be a good idea to have the other two dicts as weakrefs,\n",
    "    but that still needs to be figured out.\n",
    "    \n",
    "    Subjects need to be unique Entities because\n",
    "    head = {\"eye\": {\"side\": {\"left}}, \"eye\": {\"side\": \"right\"}}\n",
    "    naturally would only count 1 eye instead of two different ones.\n",
    "    Please note that store.add returns the entity (or list of entities for\n",
    "    store.add_all) that was the target of the operation to simplify workflow and tests. \n",
    "    Since these return values matter in doctests, we assign them to dummy variables.\n",
    "    \n",
    "    >>> body = TripleStore()\n",
    "    >>> class Side(Predicate):\n",
    "    >>>    pass\n",
    "    >>> class Is_a(Predicate):\n",
    "    >>>    pass\n",
    "    >>> class Name(Predicate):\n",
    "    >>>    pass\n",
    "    \n",
    "    side = Side()\n",
    "    is_a = Is_a()\n",
    "    \n",
    "    e1 = E(\"eye\")\n",
    "    \n",
    "    >>> body.add({e1:side})\n",
    "    \n",
    "    >>> len(list(body[:P.name:\"eye\"]))\n",
    "    2\n",
    "    \n",
    "    >>> fingers = \"thumb index middle ring pinky\".split()\n",
    "    >>> sides = [\"left\", \"right\"]\n",
    "    \n",
    "    >>> body.add_all({P.name:fingers, P.side:sides, P.is_a:[\"finger\"]})\n",
    "    >>> len(list(body[:P.is_a:\"finger\"]))\n",
    "    10\n",
    "    \n",
    "    There are ways for manipulating entries:\n",
    "    \n",
    "    >>> x = body.get({P.name:\"eye\", P.side:\"left\"})\n",
    "    \n",
    "    # >>> body[x] == {x: {\"name\":{\"eye\"}, \"side\":{\"left\"}}}\n",
    "    # >>> body[x:\"color\"] = \"blue\"\n",
    "    \n",
    "    #>>> body[x:\"color\"]\n",
    "    #\"blue\"\n",
    "    \"\"\"\n",
    "    \n",
    "    def __init__(self):\n",
    "        # weakrefs would be nice to have here, but it can't be guaranteed\n",
    "        # that these are the only references to entities, which makes weakrefs \n",
    "        # quite dangerous.\n",
    "        self._spo = {}  # {subject: {predicate: set([object])}}\n",
    "        self._pos = {}  # {predicate: {object: set([subject])}}\n",
    "        self._osp = {}  # {object: {subject, set([predicate])}}\n",
    "        # sic!\n",
    "        self._checks = defaultdict(lambda: lambda o: True)\n",
    "    \n",
    "    def set_check(self, p, func):\n",
    "        self._checks[p] = func\n",
    "    \n",
    "    def __setitem__(self, key, value):\n",
    "        def add2index(index, a, b, c):\n",
    "            if a not in index:\n",
    "                index[a] = {b: set([c])}\n",
    "            else:\n",
    "                if b not in index[a]:\n",
    "                    index[a][b] = set([c])\n",
    "                else:\n",
    "                    index[a][b].add(c)\n",
    "        \n",
    "        if not isinstance(key, slice):\n",
    "            raise StoreException(\"must be store[s:p] = o\")\n",
    "        elif key.step is not None:\n",
    "            raise StoreException(\"slice must be two-part, not three\")\n",
    "        else:\n",
    "            s = key.start if isinstance(key.start, E) else E(key.start)\n",
    "            p = key.stop\n",
    "            if not isinstance(p, BasePredicate):\n",
    "                raise StoreException(\"%s must be a Predicate().\"%p)\n",
    "            o = value\n",
    "            if not self._checks[p](o):\n",
    "                raise StoreException(\"%s does not match the set criteria for this predicate\"%o)\n",
    "            add2index(self._spo, s, p, o)\n",
    "            add2index(self._pos, p, o, s)\n",
    "            add2index(self._osp, o, s, p)\n",
    "        \n",
    "    def __getitem__(self, key):\n",
    "        \"\"\"\n",
    "        Return iterator over triplets directly as result.\n",
    "        \n",
    "        This is a mechanism inspired by the brilliant way numpy handles\n",
    "        arrays and its vectorization methods. \n",
    "        Another way of querying is the .get() method inspired by django which\n",
    "        returns a Query object, representing a view on the dictionary to be evaluated lazily.\n",
    "        \n",
    "        The case dictionary here is an invention of mine after \n",
    "        researching alternatives for page-long if-clauses that \n",
    "        are detrimental to readability.\n",
    "        It works like this: \n",
    "        1) extract s, p and o from the given store[s:p:o] call\n",
    "        2) go to the bottom of the function and check which parts are given\n",
    "        3) pass the resulting tuple into the case dict as key and execute the stored func\n",
    "        4) since the anonymous funcs are closures with access to the local variables,\n",
    "           they easily can build generators with those and return them.\n",
    "        \"\"\"\n",
    "        \n",
    "        # we query for an entity directly\n",
    "        if not isinstance(key, slice):\n",
    "            assert isinstance(key, E)\n",
    "            # This is a bit tricky because P.thing is not a valid identifier.\n",
    "            # This becomes a problem if different sets of predicates are defined\n",
    "            # as namespaces with conflicting names.\n",
    "            # In this case, we resolve the conflict the django-way by mangling\n",
    "            # predicates to P__thing.\n",
    "            properties = self._spo[key]\n",
    "            try:\n",
    "                return namedtuple(f\"{str(key)}\", \n",
    "                              [p.name for p in properties.keys()])(\n",
    "                                **{k.name:v for k, v in properties.items()})\n",
    "            except ValueError:\n",
    "                return namedtuple(f\"{str(key)}\", \n",
    "                        [f\"{p.__class__.__name__}__{p.name}\"\n",
    "                         for p in properties.keys()])(\n",
    "                    **{f\"{k.__class__.__name__}__{k.name}\":v \n",
    "                         for k, v in properties.items()})\n",
    "        else:\n",
    "            s, p, o = key.start, key.stop, key.step\n",
    "            \n",
    "        case = {(True, True, True): lambda: {(s, p, o) \n",
    "                                             for x in (1,) \n",
    "                                             if o in self._spo[s][p]},\n",
    "              (True, True, False): lambda: {(s, p, OBJ) \n",
    "                                            for OBJ in self._spo[s][p]},\n",
    "              (True, False, True): lambda: {(s, PRED, o) \n",
    "                                            for PRED in self._osp[o][s]},\n",
    "              (True, False, False): lambda: {(s, PRED, OBJ) \n",
    "                                             for PRED, objset in self._spo[s].items()\n",
    "                                             for OBJ in objset},\n",
    "              (False, True, True): lambda: {(SUB, p, o) \n",
    "                                            for SUB in self._pos[p][o]},\n",
    "              (False, True, False): lambda: {(SUB, p, OBJ) \n",
    "                                             for OBJ, subset in self._pos[p].items() \n",
    "                                             for SUB in subset},\n",
    "              (False, False, True): lambda: {(SUB, PRED, o) \n",
    "                                             for SUB, predset in self._osp[o].items()\n",
    "                                             for PRED in predset},\n",
    "              (False, False, False): lambda: {(SUB, PRED, OBJ) \n",
    "                                             for SUB, predset in self._spo.items()\n",
    "                                             for PRED, objset in predset.items()\n",
    "                                             for OBJ in objset}\n",
    "             }\n",
    "        # .get with default won't work here because any of the \n",
    "        # dicts may throw KeyError\n",
    "        try:\n",
    "            return case[(s is not None,  p is not None, o is not None)]()\n",
    "        except KeyError:\n",
    "            return ()\n",
    "    \n",
    "    def __len__(self):\n",
    "        return len(self._spo)\n",
    "    \n",
    "    def __iter__(self):\n",
    "        \"\"\"Return the same iterator as Store[::] for convenience.\"\"\"\n",
    "        return ((SUB, PRED, OBJ) for SUB, predset in self._spo.items()\n",
    "                                for PRED, objset in predset.items()\n",
    "                                for OBJ in objset)\n",
    "    \n",
    "    def add(self, d, s=None):\n",
    "        \"\"\"Convenience method to add a new item to the store.\"\"\"\n",
    "        s = s if s is not None else E()\n",
    "        for p, o in d.items():\n",
    "            self[s:p] = o\n",
    "        return s\n",
    "    \n",
    "    def add_all(self, d, list_of_s=None):\n",
    "        \"\"\"Add all combinations of predicate:object to the store.\n",
    "        \n",
    "        From a dict of key:[list of values] we produce a list of all combinations\n",
    "        of [(key1,value1), (key1,value2)] from which we can build a new dict\n",
    "        to pass into self.add as parameters.\n",
    "        \n",
    "        The subjects (param S) is a list of entities that all these combinations \n",
    "        will be added to.\n",
    "        \n",
    "        >>> body = TripleStore()\n",
    "        >>> P = BasePredicate(\"P\", \"name has side\")\n",
    "        >>> torso = E(\"torso\")\n",
    "        >>> body.add({P.name:\"torso\"}, s=torso) == torso\n",
    "        True\n",
    "        >>> legs = body.add_all({P.name:[\"leg\"], P.side:[\"left\", \"right\"]})\n",
    "        >>> body.add_all({P.has:legs}, list_of_s=[torso]) == [torso]\n",
    "        True\n",
    "        >>> body[torso].has == set(legs)\n",
    "        True\n",
    "        >>> body.add_all({P.has:[\"muscle\"]}, list_of_s=legs) == legs\n",
    "        True\n",
    "        >>> x = body.get({P.name:\"leg\", P.side:\"left\"})\n",
    "        >>> \"muscle\" in body[x].has\n",
    "        True\n",
    "        \"\"\"\n",
    "\n",
    "        # simple case: no subjects were given, so we create one for each combination\n",
    "        if list_of_s is None:\n",
    "            results = []\n",
    "            combos = product(*[[(k, v) for v in d[k]] for k in d.keys()])\n",
    "            for c in combos:\n",
    "                params = {k:v for k, v in c}\n",
    "                # I'd rather yield, but that'd mean it won't return!\n",
    "                results.append(self.add(params))\n",
    "            return results\n",
    "        else:\n",
    "            # we have a list of entities, which we use as target for each combination\n",
    "            for s in list_of_s:\n",
    "                for p, O in d.items():\n",
    "                    for o in O:\n",
    "                        self[s:p] = o\n",
    "            return list_of_s\n",
    "\n",
    "    def get(self, clause_dict):\n",
    "        \"\"\"Get the item from the store that matches ALL clauses.\"\"\"\n",
    "        clauses = list(clause_dict.items())\n",
    "        # we need to init the results somehow\n",
    "        k, v = clauses.pop()\n",
    "        result = {s for s, p, o in self[:k:v]}\n",
    "        for k, v in clauses:\n",
    "            result.intersection_update({s for s, p, o in self[:k:v]})\n",
    "        if len(result) > 1:\n",
    "            raise AttributeError(\"More than a single item matches the criteria.\")\n",
    "        elif len(result) == 0:\n",
    "            return None\n",
    "        else:\n",
    "            return result.pop()\n",
    "    \n",
    "    def get_all(self, clause_dict):\n",
    "        \"\"\"Get all items from the store that match ALL clauses.\n",
    "        \n",
    "        The returned set of items can be reused in any way, including combining\n",
    "        or excluding items from different queries or manually adding items.\n",
    "        It is necessary to use a dict here in order to make use of Enum.\n",
    "        \"\"\"\n",
    "        clauses = list(clause_dict.items())\n",
    "        # we need to init the results somehow\n",
    "        k, v = clauses.pop()\n",
    "        result = {s for s, p, o in self[:k:v]}\n",
    "        for k, v in clauses:\n",
    "            result.intersection_update({s for s, p, o in self[:k:v]})\n",
    "        return result\n",
    "\n",
    "    \n",
    "    def get_last_added(self):\n",
    "        \"\"\"Get the item that was last added to the store.\"\"\"\n",
    "        return list(self._spo.keys())[-1]\n",
    "\n",
    "class Query:\n",
    "    \"\"\"Class representing a query to the store.\"\"\"\n",
    "    def __init__(self, store, triple):\n",
    "        self.store = store\n",
    "        self.triple = triple\n",
    "        \n",
    "    def __call__(self):\n",
    "        return store[triple.s: triple.p: triple.o]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%writefile store/store.py\n",
    "\n",
    "from uuid import uuid4, UUID\n",
    "from collections import namedtuple, defaultdict\n",
    "from inspect import isclass\n",
    "from itertools import product, chain\n",
    "from dataclasses import dataclass\n",
    "from warnings import warn\n",
    "from collections.abc import Set\n",
    "from enum import Enum\n",
    "from typing import List\n",
    "\n",
    "# pydantic is pretty cool :o\n",
    "from pydantic import (DSN, UUID1, UUID3, UUID4, UUID5, BaseModel, DirectoryPath, EmailStr, FilePath, NameEmail,\n",
    "                      NegativeFloat, NegativeInt, PositiveFloat, PositiveInt, PyObject, UrlStr, condecimal, confloat,\n",
    "                      conint, constr)\n",
    "\n",
    "# remove after dev\n",
    "from pprint import pprint\n",
    "\n",
    "class StoreException(UserWarning):\n",
    "    \"\"\"All Exceptions specific to this package for easy filtering.\"\"\"\n",
    "    \n",
    "class FailedToComply(StoreException):\n",
    "    pass\n",
    "\n",
    "class NotFound(StoreException):\n",
    "    pass\n",
    "\n",
    "Triple = namedtuple(\"Triple\", \"s p o\")\n",
    "    \n",
    "class Predicate(BaseModel):\n",
    "    url: UrlStr\n",
    "        \n",
    "    \n",
    "    @property\n",
    "    def name(self):\n",
    "        return self.__class__.__name__\n",
    "    \n",
    "    def __str__(self):\n",
    "        return self.name\n",
    "    \n",
    "    def __repr__(self):\n",
    "        return self.name\n",
    "\n",
    "class E:\n",
    "    \"\"\"Entity.\n",
    "    Most entities will be anonymous, which is perfectly fine, while some can have names.\n",
    "    Entities are the same whenever they have the same id, which is unique.\n",
    "    These are NOT singletons (which could be conceivable), but due to the UUID used as\n",
    "    hash, they behave very similar, for instance as keys in dicts.\n",
    "    \"\"\"\n",
    "    def __init__(self, name:str=None, id_:str=None, url:str=None):        \n",
    "        self.url = url\n",
    "        \n",
    "        if name is None:\n",
    "            self.name = None\n",
    "        elif not str.isidentifier(name):\n",
    "            raise StoreException(\"%s not an identifier.\"%name)\n",
    "        else:\n",
    "            self.name = name\n",
    "\n",
    "        self.id = UUID(id_) if id_ is not None else uuid4()\n",
    "    \n",
    "    def __hash__(self):\n",
    "        return self.id.int\n",
    "    \n",
    "    def __str__(self):\n",
    "        return self.name if self.name is not None else \"_\" + str(self.id)[:5]\n",
    "    \n",
    "    def __repr__(self):\n",
    "        \"\"\"Return representation so that e == eval(repr(e))\"\"\"\n",
    "        return (f\"\"\"E(\\\n",
    "{f\"name='{self.name}', \" if self.name is not None else ''}\\\n",
    "id_='{self.id}'\\\n",
    "{f\", url='{self.url}'\" if self.url is not None else ''})\"\"\"\n",
    "               )\n",
    "    \n",
    "    def __eq__(self, other):\n",
    "        return hash(self) == hash(other)\n",
    "\n",
    "\n",
    "class TripleStore:\n",
    "    \"\"\"A set of three dicts that work together as one.\n",
    "    \n",
    "    Keep in mind that the primary dict - spo - is a Python3 dict,\n",
    "    which works as an OrderedDict that remembers insertion order.\n",
    "    It might be a good idea to have the other two dicts as weakrefs,\n",
    "    but that still needs to be figured out.\n",
    "    \n",
    "    Subjects need to be unique Entities because\n",
    "    head = {\"eye\": {\"side\": {\"left}}, \"eye\": {\"side\": \"right\"}}\n",
    "    naturally would only count 1 eye instead of two different ones.\n",
    "    Please note that store.add returns the entity (or list of entities for\n",
    "    store.add_all) that was the target of the operation to simplify workflow and tests. \n",
    "    Since these return values matter in doctests, we assign them to dummy variables.\n",
    "    \"\"\"\n",
    "    \n",
    "    def __init__(self):\n",
    "        self._spo = {}  # {subject: {predicate: set([object])}}\n",
    "        self._pos = {}  # {predicate: {object: set([subject])}}\n",
    "        self._osp = {}  # {object: {subject, set([predicate])}}\n",
    "        \n",
    "    def __getitem__(self, key):\n",
    "        \"\"\"\n",
    "        Return iterator over triplets directly as result.\n",
    "        \n",
    "        This is a mechanism inspired by the brilliant way numpy handles\n",
    "        arrays and its vectorization methods. \n",
    "        Another way of querying is the .get() method inspired by django which\n",
    "        returns a Query object, representing a view on the dictionary to be evaluated lazily.\n",
    "        \n",
    "        The case dictionary here is an invention of mine after \n",
    "        researching alternatives for page-long if-clauses that \n",
    "        are detrimental to readability.\n",
    "        It works like this: \n",
    "        1) extract s, p and o from the given store[s:p:o] call\n",
    "        2) go to the bottom of the function and check which parts are given\n",
    "        3) pass the resulting tuple into the case dict as key and execute the stored func\n",
    "        4) since the anonymous funcs are closures with access to the local variables,\n",
    "           they easily can build generators with those and return them.\n",
    "        \"\"\"\n",
    "        \n",
    "        # we query for an entity directly\n",
    "        if not isinstance(key, slice):\n",
    "            assert isinstance(key, E) or isinstance(key, Triple)\n",
    "            # we return a dict of p:o that we can use in set_all, producing a nice symmetry\n",
    "            # this is in contrast to the slice method, which returns sets of objects\n",
    "            return self._spo[key]\n",
    "        else:\n",
    "            s, p, o = key.start, key.stop, key.step\n",
    "            \n",
    "        # Observe that cases with only one False return no Triples but the values themselves\n",
    "        # this way, the results can be used directly in an assignment.\n",
    "        case = {(True, True, True): lambda: {Triple(s, p, o) \n",
    "                                             for x in (1,) \n",
    "                                             if o in self._spo[s][p]},\n",
    "              (True, True, False): lambda: {OBJ for OBJ in self._spo[s][p]},\n",
    "              (True, False, True): lambda: {PRED \n",
    "                                            for PRED in self._osp[o][s] if PRED in self._osp[o][s]},\n",
    "              (True, False, False): lambda: {Triple(s, PRED, OBJ) \n",
    "                                             for PRED, objset in self._spo[s].items()\n",
    "                                             for OBJ in objset},\n",
    "              (False, True, True): lambda: {SUB for SUB in self._pos[p][o]},\n",
    "              (False, True, False): lambda: {Triple(SUB, p, OBJ) \n",
    "                                             for OBJ, subset in self._pos[p].items() \n",
    "                                             for SUB in subset},\n",
    "              (False, False, True): lambda: {Triple(SUB, PRED, o) \n",
    "                                             for SUB, predset in self._osp[o].items()\n",
    "                                             for PRED in predset},\n",
    "              (False, False, False): lambda: {Triple(SUB, PRED, OBJ) \n",
    "                                             for SUB, predset in self._spo.items()\n",
    "                                             for PRED, objset in predset.items()\n",
    "                                             for OBJ in objset}\n",
    "             }\n",
    "        try:\n",
    "            return case[(s is not None,  p is not None, o is not None)]()\n",
    "        except KeyError:\n",
    "            warn((s, p, o), NotFound)\n",
    "        \n",
    "    \n",
    "    def __len__(self):\n",
    "        return len(self._spo)\n",
    "    \n",
    "    def __iter__(self):\n",
    "        \"\"\"Return the same iterator as Store[::] for convenience.\"\"\"\n",
    "        return ((SUB, PRED, OBJ) for SUB, predset in self._spo.items()\n",
    "                                for PRED, objset in predset.items()\n",
    "                                for OBJ in objset)\n",
    "    \n",
    "    def __contains__(self, value):\n",
    "        s, p, o = value\n",
    "        try:\n",
    "            return o in self._spo[s][p]\n",
    "        except KeyError:\n",
    "            return False\n",
    "    \n",
    "    def add(self, *, s, p, o):\n",
    "        def add2index(index, a, b, c):\n",
    "            if a not in index:\n",
    "                index[a] = {b: set([c])}\n",
    "            else:\n",
    "                if b not in index[a]:\n",
    "                    index[a][b] = set([c])\n",
    "                else:\n",
    "                    index[a][b].add(c)\n",
    "                    \n",
    "        if s is None or (s, p, o) in self:\n",
    "            warn(f\"{s, p, o}\", FailedToComply)\n",
    "        \n",
    "        # Subject can be an existing Triple, which allows for softlink-recursion.\n",
    "        if isinstance(s, Triple):\n",
    "            if s not in self:\n",
    "                raise FailedToComply(\"Specified subject (Triple) was not found in the store.\")\n",
    "        else:\n",
    "            if not isinstance(s, E):\n",
    "                raise FailedToComply(\"Subject is neither a Triple nor an instance of E.\", s, type(s))\n",
    "        \n",
    "        assert hasattr(p, \"name\"), \"Predicate has no name!\"\n",
    "        assert hasattr(p, \"url\"), \"Predicate has no url!\"\n",
    "        \n",
    "        if not p.validate(o):\n",
    "            raise StoreException(f\"{o} does not match the criteria for predicate {p}\")\n",
    "        \n",
    "        add2index(self._spo, s, p, o)\n",
    "        add2index(self._pos, p, o, s)\n",
    "        add2index(self._osp, o, s, p)\n",
    "        return Triple(s, p, o)\n",
    "        \n",
    "    def __setitem__(self, key, value):\n",
    "        assert isinstance(key, slice), \"Must be assigned using a slice (ex: Store[:foo:] = 23).\"\n",
    "        assert isinstance(key.stop, Predicate), \"Predicate MUST be specified in slice.\"\n",
    "        \n",
    "        p = key.stop\n",
    "        o = value\n",
    "        \n",
    "        if not (isinstance(key.start, E) or isinstance(key.start, Triple)):\n",
    "            results = []\n",
    "            S = key.start\n",
    "            for s in S:\n",
    "                results.append(self.add(s=s, p=p, o=o))\n",
    "            return results\n",
    "        else:\n",
    "            s = key.start\n",
    "            return self.add(s=s, p=p, o=o)\n",
    "\n",
    "    \n",
    "    def create_subjects_with(self, predobjects):\n",
    "        \"\"\"Add all combinations of predicate:object to the store and create new entities for each combo.\n",
    "        \n",
    "        From a dict of key:[list of values] we produce a list of all combinations\n",
    "        of [(key1,value1), (key1,value2)] from which we can build a new dict\n",
    "        to pass into self.add as parameters.\n",
    "        \n",
    "        \"\"\"\n",
    "        combinations = product(*[[(k, v) for v in predobjects[k]] for k in predobjects.keys()])\n",
    "        subjects = []\n",
    "        # Trick is to create new entities with a sentinel of None so there is an indefinite amount\n",
    "        for C, s in zip(combinations, iter(E, None)):\n",
    "            for p, o in C:\n",
    "                r = self.add(s=s, p=p, o=o)\n",
    "            subjects.append(s)\n",
    "        return subjects\n",
    "\n",
    "    def set_all(self, *, subjects:List[E], predobjects:dict):\n",
    "        results = []\n",
    "        for s in subjects:\n",
    "            for p, O in predobjects.items():\n",
    "                for o in O:\n",
    "                    r = self.add(s=s, p=p, o=o)\n",
    "                    results.append(r)\n",
    "        return results\n",
    "    \n",
    "    def get(self, clause_dict):\n",
    "        \"\"\"Get the item from the store that matches ALL clauses.\"\"\"\n",
    "        clauses = list(clause_dict.items())\n",
    "        # we need to init the results somehow\n",
    "        k, v = clauses.pop()\n",
    "        result = {s for s in self[:k:v]}\n",
    "        for k, v in clauses:\n",
    "            result.intersection_update({s for s in self[:k:v]})\n",
    "        if len(result) > 1:\n",
    "            raise AttributeError(\"More than a single item matches the criteria.\")\n",
    "        elif len(result) == 0:\n",
    "            return None\n",
    "        else:\n",
    "            return result.pop()\n",
    "    \n",
    "    def get_all(self, clause_dict):\n",
    "        \"\"\"Get all items from the store that match ALL clauses.\n",
    "        \n",
    "        The returned set of items can be reused in any way, including combining\n",
    "        or excluding items from different queries or manually adding items.\n",
    "        It is necessary to use a dict here in order to make use of Enum.\n",
    "        \"\"\"\n",
    "        clauses = list(clause_dict.items())\n",
    "        # we need to init the results somehow\n",
    "        k, v = clauses.pop()\n",
    "        result = self[:k:v].copy()\n",
    "        for k, v in clauses:\n",
    "            result.intersection_update(self[:k:v])\n",
    "        return result  # Should be QuerySet\n",
    "\n",
    "    \n",
    "    def get_last_added(self):\n",
    "        \"\"\"Get the item that was last added to the store.\"\"\"\n",
    "        return list(self._spo.keys())[-1]\n",
    "    \n",
    "    def undo(self):\n",
    "        raise NotImplementedError\n",
    "    \n",
    "    def __delitem__(self, item):\n",
    "        raise NotImplementedError\n",
    "        \n",
    "    def __str__(self):\n",
    "        return \"\".join(f\"{str(s)} {str(p)} {str(o)}\\n\" for s, p, o in self)\n",
    "        \n",
    "    \n",
    "\n",
    "@dataclass\n",
    "class Query:\n",
    "    \"\"\"Class representing a query to the store.\"\"\"\n",
    "    store: TripleStore\n",
    "    spo: Triple\n",
    "        \n",
    "    def __call__(self):\n",
    "        return self.store[self.triple.s: self.triple.p: self.triple.o]\n",
    "\n",
    "\n",
    "class QuerySet:\n",
    "    def __init__(self, values):\n",
    "        self.values = values\n",
    "\n",
    "    def __getattr__(self, name):\n",
    "        \"\"\"Get the value of an attribute.\"\"\"\n",
    "        if name in self._sets:\n",
    "            return self._sets[name]\n",
    "        else:\n",
    "            raise AttributeError(f\"{name} is not a method or attribute of set or \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{Triple(s=E(name='hand', id_='3241284c-4f76-448c-aa4a-dd3d6a7c62d3'), p=Has, o=E(name='ring', id_='c0e9ddc5-6979-4a72-a63c-e150e0e0224e')),\n",
      " Triple(s=Triple(s=E(name='hand', id_='3241284c-4f76-448c-aa4a-dd3d6a7c62d3'), p=Has, o=E(name='ring', id_='c0e9ddc5-6979-4a72-a63c-e150e0e0224e')), p=Destroyed, o=True)}\n"
     ]
    }
   ],
   "source": [
    "from store.store import TripleStore, Predicate, E, Triple\n",
    "from enum import Enum\n",
    "\n",
    "side = Enum(\"side\", \"left right\")\n",
    "\n",
    "class Side(Predicate):\n",
    "    value: side\n",
    "\n",
    "class Is_a(Predicate):\n",
    "    value: str\n",
    "\n",
    "class Name(Predicate):\n",
    "    pass\n",
    "\n",
    "class Has(Predicate):\n",
    "    pass\n",
    "\n",
    "class Person(Predicate):\n",
    "    pass\n",
    "\n",
    "class PartOf(Predicate):\n",
    "    pass\n",
    "\n",
    "class Destroyed(Predicate):\n",
    "    pass\n",
    "\n",
    "destroyed = Destroyed()\n",
    "has = Has()\n",
    "\n",
    "\n",
    "body = TripleStore()\n",
    "hand = E(name=\"hand\")\n",
    "ring = E(name=\"ring\")\n",
    "\n",
    "body[hand:has] = ring\n",
    "assert Triple(hand, has, ring) in body\n",
    "body[Triple(hand, has, ring):destroyed] = True\n",
    "\n",
    "from pprint import pprint\n",
    "pprint(body[::])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Triple(s=E(id_='4f764659-5d0e-4db8-a572-dd6c3321e485'), p=Name, o='spleen'), Triple(s=E(id_='4f764659-5d0e-4db8-a572-dd6c3321e485'), p=Is_a, o='organ')]\n",
      "_db001 Is_a person\n",
      "_db001 Name Anna\n",
      "_1c739 Is_a person\n",
      "_1c739 Name Otto\n",
      "_16591 PartOf _db001\n",
      "_16591 Side left\n",
      "_16591 Name eye\n",
      "_67269 PartOf _db001\n",
      "_67269 Side left\n",
      "_67269 Name arm\n",
      "_6e4fb PartOf _db001\n",
      "_6e4fb Side left\n",
      "_6e4fb Name leg\n",
      "_158fc PartOf _db001\n",
      "_158fc Side left\n",
      "_158fc Name hand\n",
      "_5254e PartOf _db001\n",
      "_5254e Side left\n",
      "_5254e Name foot\n",
      "_55fb1 PartOf _db001\n",
      "_55fb1 Side left\n",
      "_55fb1 Name kidney\n",
      "_55fb1 Is_a organ\n",
      "_db711 PartOf _db001\n",
      "_db711 Side right\n",
      "_db711 Name eye\n",
      "_3c004 PartOf _db001\n",
      "_3c004 Side right\n",
      "_3c004 Name arm\n",
      "_62c51 PartOf _db001\n",
      "_62c51 Side right\n",
      "_62c51 Name leg\n",
      "_2962c PartOf _db001\n",
      "_2962c Side right\n",
      "_2962c Name hand\n",
      "_0a5f5 PartOf _db001\n",
      "_0a5f5 Side right\n",
      "_0a5f5 Name foot\n",
      "_19d8a PartOf _db001\n",
      "_19d8a Side right\n",
      "_19d8a Name kidney\n",
      "_19d8a Is_a organ\n",
      "_446dc PartOf _1c739\n",
      "_446dc Side left\n",
      "_446dc Name eye\n",
      "_8fbf1 PartOf _1c739\n",
      "_8fbf1 Side left\n",
      "_8fbf1 Name arm\n",
      "_9e209 PartOf _1c739\n",
      "_9e209 Side left\n",
      "_9e209 Name leg\n",
      "_c768b PartOf _1c739\n",
      "_c768b Side left\n",
      "_c768b Name hand\n",
      "_61714 PartOf _1c739\n",
      "_61714 Side left\n",
      "_61714 Name foot\n",
      "_55030 PartOf _1c739\n",
      "_55030 Side left\n",
      "_55030 Name kidney\n",
      "_55030 Is_a organ\n",
      "_2acc1 PartOf _1c739\n",
      "_2acc1 Side right\n",
      "_2acc1 Name eye\n",
      "_d12bd PartOf _1c739\n",
      "_d12bd Side right\n",
      "_d12bd Name arm\n",
      "_f9ac0 PartOf _1c739\n",
      "_f9ac0 Side right\n",
      "_f9ac0 Name leg\n",
      "_e4f7b PartOf _1c739\n",
      "_e4f7b Side right\n",
      "_e4f7b Name hand\n",
      "_8697c PartOf _1c739\n",
      "_8697c Side right\n",
      "_8697c Name foot\n",
      "_640ef PartOf _1c739\n",
      "_640ef Side right\n",
      "_640ef Name kidney\n",
      "_640ef Is_a organ\n",
      "_b585d Name brain\n",
      "_b585d Is_a organ\n",
      "_45f32 Name nose\n",
      "_45f32 Is_a organ\n",
      "_2d75d Name liver\n",
      "_2d75d Is_a organ\n",
      "_af497 Name heart\n",
      "_af497 Is_a organ\n",
      "_d0ea9 Name spleen\n",
      "_d0ea9 Is_a organ\n",
      "_4f764 Name spleen\n",
      "_4f764 Is_a organ\n",
      "\n"
     ]
    }
   ],
   "source": [
    "from store.store import TripleStore, Predicate, E, Triple\n",
    "\n",
    "body = TripleStore()\n",
    "\n",
    "class Side(Predicate):\n",
    "    pass\n",
    "class Is_a(Predicate):\n",
    "    pass\n",
    "class Name(Predicate):\n",
    "    pass\n",
    "class Has(Predicate):\n",
    "    pass\n",
    "class Person(Predicate):\n",
    "    pass\n",
    "class PartOf(Predicate):\n",
    "    pass\n",
    "\n",
    "has = Has()\n",
    "side = Side()\n",
    "is_a = Is_a()\n",
    "name = Name()\n",
    "person = Person()\n",
    "partof = PartOf()\n",
    "\n",
    "people = body.create_subjects_with({is_a:[\"person\"], name:[\"Anna\", \"Otto\"]})\n",
    "body.create_subjects_with({partof:people,\n",
    "                           side:[\"left\", \"right\"], \n",
    "                           name:[\"eye\", \"arm\", \"leg\", \"hand\", \"foot\", \"kidney\"]})\n",
    "body.create_subjects_with({name:[\"brain\", \"nose\", \"liver\", \"heart\", \"spleen\",], is_a:[\"organ\"]})\n",
    "\n",
    "\n",
    "body[body[:name:\"kidney\"]:is_a] = \"organ\"\n",
    "\n",
    "body.get_all({name:\"kidney\"}) & body.get_all({side:\"left\"}) == body.get_all({name:\"kidney\", side:\"left\"})\n",
    "\n",
    "x = body.get_last_added()\n",
    "d = body[x]\n",
    "\n",
    "new_spleen = E()\n",
    "\n",
    "print(body.set_all(predobjects=d, subjects=[new_spleen]))\n",
    "\n",
    "print(body)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections.abc import Set\n",
    "\n",
    "class QuerySet(Set):\n",
    "    def __init__(self, *b):\n",
    "        set()\n",
    "    \n",
    "    def __contains__(self, value):\n",
    "        return value in self.values\n",
    "    \n",
    "    def __iter__(self):\n",
    "        return iter(self.values)\n",
    "    \n",
    "    def __len__(self):\n",
    "        return len(self.values)\n",
    "    \n",
    "    def __getattr__(self, name):\n",
    "        \"\"\"Get the value of an attribute.\"\"\"\n",
    "        if name in self._sets:\n",
    "            return self._sets[name]\n",
    "        else:\n",
    "            raise AttributeError(f\"{name} is not a method or attribute of set or \")\n",
    "            \n",
    "a = QuerySet(1,2,3)\n",
    "b = QuerySet(2)\n",
    "\n",
    "\n",
    "list(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "lets try to use it the way intented in PL.\n",
    "Plato's \"ideas\" are the idea: define ideal things in terms of their parts - definition by as possibility.\n",
    "\n",
    "no details are defined as long as nobody looks - schroedinger code!\n",
    "parts are defined as everything that can be disassembled.\n",
    "as people should be able to define things and propose new assemblies, we start with the format."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "ename": "ComposerError",
     "evalue": "expected a single document in the stream\n  in \"<unicode string>\", line 4, column 1:\n    name: Ford Prefect\n    ^\nbut found another document\n  in \"<unicode string>\", line 8, column 1:\n    ---\n    ^",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mComposerError\u001b[0m                             Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-18-5d4e91845281>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     15\u001b[0m \"\"\"\n\u001b[1;32m     16\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 17\u001b[0;31m \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m \u001b[0;32min\u001b[0m \u001b[0myaml\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msafe_load\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ms\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     18\u001b[0m     \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/lib/python3.7/site-packages/yaml/__init__.py\u001b[0m in \u001b[0;36msafe_load\u001b[0;34m(stream)\u001b[0m\n\u001b[1;32m     92\u001b[0m     \u001b[0mResolve\u001b[0m \u001b[0monly\u001b[0m \u001b[0mbasic\u001b[0m \u001b[0mYAML\u001b[0m \u001b[0mtags\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     93\u001b[0m     \"\"\"\n\u001b[0;32m---> 94\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0mload\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstream\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mSafeLoader\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     95\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     96\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0msafe_load_all\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstream\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/lib/python3.7/site-packages/yaml/__init__.py\u001b[0m in \u001b[0;36mload\u001b[0;34m(stream, Loader)\u001b[0m\n\u001b[1;32m     70\u001b[0m     \u001b[0mloader\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mLoader\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstream\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     71\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 72\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mloader\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_single_data\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     73\u001b[0m     \u001b[0;32mfinally\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     74\u001b[0m         \u001b[0mloader\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdispose\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/lib/python3.7/site-packages/yaml/constructor.py\u001b[0m in \u001b[0;36mget_single_data\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m     33\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mget_single_data\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     34\u001b[0m         \u001b[0;31m# Ensure that the stream contains a single document and construct it.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 35\u001b[0;31m         \u001b[0mnode\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_single_node\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     36\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mnode\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     37\u001b[0m             \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mconstruct_document\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnode\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/lib/python3.7/site-packages/yaml/composer.py\u001b[0m in \u001b[0;36mget_single_node\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m     41\u001b[0m             raise ComposerError(\"expected a single document in the stream\",\n\u001b[1;32m     42\u001b[0m                     \u001b[0mdocument\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstart_mark\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"but found another document\"\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 43\u001b[0;31m                     event.start_mark)\n\u001b[0m\u001b[1;32m     44\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     45\u001b[0m         \u001b[0;31m# Drop the STREAM-END event.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mComposerError\u001b[0m: expected a single document in the stream\n  in \"<unicode string>\", line 4, column 1:\n    name: Ford Prefect\n    ^\nbut found another document\n  in \"<unicode string>\", line 8, column 1:\n    ---\n    ^"
     ]
    }
   ],
   "source": [
    "import strictyaml\n",
    "\n",
    "import yaml\n",
    "\n",
    "s = \"\"\"\n",
    "---\n",
    "# All about the character\n",
    "name: Ford #Prefect\n",
    "age: 42\n",
    "possessions:\n",
    "- Towel\n",
    "---\n",
    "name: Foo Bar\n",
    "age: 20\n",
    "\"\"\"\n",
    "\n",
    "for x in yaml.safe_load(s):\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "YAML(OrderedDict([('name', 'Ford'), ('age', 42), ('possessions', ['Towel'])]))"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from strictyaml import load, Map, Str, Int, Seq, YAMLError, Optional\n",
    "import yaml\n",
    "\n",
    "s = \"\"\"\n",
    "# All about the character\n",
    "name: Ford #Prefect\n",
    "age: 42\n",
    "possessions:\n",
    "    - Towel\n",
    "\"\"\"\n",
    "\n",
    "schema = Map({\"name\": Str(), \"age\": Int(), \"possessions\": Seq(Str())})\n",
    "\n",
    "load(s, schema)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "User id=123 name='John Doe' signup_ts=datetime.datetime(2017, 6, 1, 12, 22) friends=[1, 2, 3]\n",
      "123\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Character name='Ford' age=42 possessions=['Towel']>"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from datetime import datetime\n",
    "from typing import List\n",
    "from pydantic import BaseModel\n",
    "import yaml\n",
    "\n",
    "class User(BaseModel):\n",
    "    id: int\n",
    "    name = 'John Doe'\n",
    "    signup_ts: datetime = None\n",
    "    friends: List[int] = []\n",
    "        \n",
    "\n",
    "\n",
    "external_data = {'id': '123', 'signup_ts': '2017-06-01 12:22', 'friends': [1, '2', b'3',]}\n",
    "user = User(**external_data)\n",
    "print(user)\n",
    "# > User id=123 name='John Doe' signup_ts=datetime.datetime(2017, 6, 1, 12, 22) friends=[1, 2, 3]\n",
    "print(user.id)\n",
    "# > 123\n",
    "\n",
    "\n",
    "s = \"\"\"\n",
    "# All about the character\n",
    "name: Ford #Prefect\n",
    "age: 42\n",
    "possessions:\n",
    "    - Towel\n",
    "\"\"\"\n",
    "\n",
    "class Character(BaseModel):\n",
    "    name: str\n",
    "    age: int\n",
    "    possessions: List[str]\n",
    "\n",
    "data = yaml.safe_load(s)\n",
    "char = Character(**data)\n",
    "char"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "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.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}