glom_pythoncamp_2020.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Housekeeping - Jupyter Fehlermeldungen kürzen\n",
    "# Hinweis: Sorry, bei mybinder.org klappt der Ansatz nicht\n",
    "import json \n",
    "from pprint import pprint\n",
    "import sys\n",
    "ipython = get_ipython()\n",
    "unhide_traceback = None\n",
    "\n",
    "def hide_traceback(exc_tuple=None, filename=None, tb_offset=None,\n",
    "                   exception_only=False, running_compiled_code=False):\n",
    "    etype, value, tb = sys.exc_info()\n",
    "    return ipython._showtraceback(etype, value, ipython.InteractiveTB.get_exception_only(etype, value))\n",
    "\n",
    "if not unhide_traceback:\n",
    "    unhide_traceback = ipython.showtraceback\n",
    "\n",
    "ipython.showtraceback = hide_traceback\n",
    "# ipython.showtraceback = unhide_traceback\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "Pythoncamp 2020 Session Martin Borus, Twitter: @mborus\n",
    "\n",
    "# GLOM\n",
    "\n",
    "von Mahmoud Hashemi\n",
    "\n",
    "## \"Wenn Du verschachtelste Daten hast, brauchst du Glom!\"\n",
    "\n",
    "https://github.com/mahmoud/glom \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "# Hauptfunktionen\n",
    "\n",
    "- Pfadbasierender Zugriff \n",
    "- deklarative Datenumwandlung\n",
    "- lesbare, ausagekräftige Fehlermeldungen\n",
    "- mit Debugger!\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Vorbereitung\n",
    "\n",
    "pip install glom \n",
    "\n",
    "pip install --upgrade -e git+https://github.com/mahmoud/glom#egg=glom\n",
    "\n",
    "pip install requests\n",
    "\n",
    "Dokumention und Tutorial auf https://glom.readthedocs.io,\n",
    "von hier stammen auch die Code-Beispiele der Einführung"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1. Normales Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = {'a': {'b': {'c': 'd'}}}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data['a']['b']['c']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data2 = {'a': {'b': None}}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data2['a']['b']['c']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2. Glom "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from glom import glom"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "glom(data, 'a.b.c')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "glom(data2, 'a.b.c')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Mit glom lassen sich Fehler gut abfangen\n",
    "\n",
    "from glom import GlomError, PathAccessError\n",
    "\n",
    "try:\n",
    "    glom(data2, 'a.b.c')\n",
    "except PathAccessError as e:\n",
    "    print(e)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    glom(data2, 'a.b.c')\n",
    "except AttributeError as e:\n",
    "    print(e)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    glom(data2, 'a.b.c')\n",
    "except GlomError as e:\n",
    "    print(e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Glom geht auch mit Lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = [1, [2 , 3, 4] , 3, 4 ,5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "glom(data, '1.0')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Glom geht auch mit Objekten !1!!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MyClass:\n",
    "    def __init__(self):\n",
    "        self.my_hallo = \"hallo!\"\n",
    "        self.my_welt = \"welt!\"\n",
    "       \n",
    "myvar = MyClass()        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "glom(myvar, 'my_welt')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3. Target & Spec\n",
    "- \"Target\" sind die Daten, (list, dict, object)\n",
    "- \"Spec\" ist das gewünschte Ergebnis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "target = {\n",
    "     'galaxy': {\n",
    "        'system': {\n",
    "            'planet': 'jupiter'\n",
    "         }\n",
    "    }\n",
    "}\n",
    "\n",
    "spec = 'galaxy.system.planet'\n",
    "\n",
    "glom(target, spec)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "target = {\n",
    "    'system': {\n",
    "        'planets': [\n",
    "            {'name': 'earth', 'moons': 1},\n",
    "            {'name': 'jupiter', 'moons': 69}\n",
    "        ]\n",
    "    }\n",
    "}\n",
    "\n",
    "spec = {\n",
    "     'names': ('system.planets', ['name']),\n",
    "     'moons': ('system.planets', ['moons'])\n",
    "}\n",
    "\n",
    "glom(target, spec)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "target = {\n",
    "     'system': {\n",
    "         'planets': [\n",
    "            {\n",
    "                'name': 'earth',\n",
    "                'moons': [\n",
    "                    {'name': 'luna'}\n",
    "                ]\n",
    "            },\n",
    "            {\n",
    "                'name': 'jupiter',\n",
    "                'moons': [\n",
    "                    {'name': 'io'},\n",
    "                    {'name': 'europa'}\n",
    "                ]\n",
    "            }\n",
    "        ]\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "spec = {\n",
    "    'planet_names': ('system.planets', ['name']),\n",
    "    'moon_names': ('system.planets', [('moons', ['name'],  )])\n",
    "}\n",
    "pprint(glom(target, spec))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from glom import Coalesce\n",
    "\n",
    "target = {\n",
    "     'system': {\n",
    "         'planets': [\n",
    "             {'name': 'earth', 'moons': 1},\n",
    "             {'name': 'jupiter', 'moons': 69}\n",
    "         ]\n",
    "     }\n",
    "}\n",
    "\n",
    "spec = {\n",
    "     'planets': (Coalesce('system.planets', 'system.dwarf_planets'), ['name']),\n",
    "     'moons': (Coalesce('system.planets', 'system.dwarf_planets'), ['moons'])\n",
    "}\n",
    "\n",
    "glom(target, spec)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "target = {\n",
    "     'system': {\n",
    "         'dwarf_planets': [\n",
    "             {'name': 'pluto', 'moons': 5},\n",
    "             {'name': 'ceres', 'moons': 0},\n",
    "         ]\n",
    "     }\n",
    " }\n",
    "glom(target, spec)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "target = {\n",
    "     'system': {\n",
    "         'planets': [\n",
    "             {'name': 'earth', 'moons': 1},\n",
    "             {'name': 'jupiter', 'moons': 69}\n",
    "         ]\n",
    "     }\n",
    "}\n",
    "\n",
    "# glom(target, {'moon_count': ('system.planets', ['moons'], sum)})\n",
    "glom(target, {'moon_count': ('system.planets', ['moons'], lambda x: sum(x))})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MySubClass:\n",
    "    def __init__(self):\n",
    "        self.my_hey = \"Hey!\"\n",
    "\n",
    "class MyClass:\n",
    "    def __init__(self):\n",
    "        self.my_hallo = \"hallo!\"\n",
    "        self.my_welt = \"welt!\"\n",
    "        self.my_heylist = [MySubClass()] * 6\n",
    "\n",
    "        \n",
    "myvar = MyClass()  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from glom import Iter\n",
    "spec = {'hallo': 'my_hallo', 'welt': 'my_welt', 'heylist': ('my_heylist', ['my_hey'])}\n",
    "\n",
    "glom(myvar, spec)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 4. Daten eindampfen - Flatten und Merge"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from glom import Flatten, Merge"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = [[1, 2], [3], [4], [], [5]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "glom(data, Flatten())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = [{'hallo': 'welt'}, {'hello': 'world'}]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "glom(data, Merge())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 5. Tutorial: Objekte -> Ausgaben"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from glom.tutorial import * "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "contact = Contact('Julian',\n",
    "          emails=[Email(email='jlahey@svtp.info')],\n",
    "                  location='Canada')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "contact.save()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "contact.primary_email"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "contact.add_date"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "contact.id"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(Contact.objects.all())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Contact.objects.all()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "json.dumps(Contact.objects.all())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "target = Contact.objects.all()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "target[0].add_date"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "spec = {'results': [{'id': 'id',\n",
    "                      'name': 'name',\n",
    "                      'add_date': ('add_date', str),\n",
    "                      'emails': ('emails', [{'id': 'id',\n",
    "                                            'email': 'email',\n",
    "                                            'type': 'email_type'}]),\n",
    "                      'primary_email': Coalesce('primary_email.email', default=None),\n",
    "                      'pref_name': Coalesce('pref_name', 'name', skip='', default=''),\n",
    "                      'detail': Coalesce('company',\n",
    "                                         'location',\n",
    "                                         ('add_date.year', str),\n",
    "                                         skip='', default='')}]}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "resp = glom(target, spec)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(json.dumps(resp, indent=2, sort_keys=True))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 6. \"T\" - das Stunt-Double"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from glom import T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from glom import T, Flatten\n",
    "# Antwort 1. Zeile\n",
    "glom(resp, ('results', T[0]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Antwort: Alle Emails\n",
    "from glom import Flatten\n",
    "\n",
    "glom(resp, ('results', ['emails'],\n",
    "             Flatten(),\n",
    "             ['email'],\n",
    "           )\n",
    "    )\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Das T ist auch mit Objekten nutzbar. Besonders nett ist das bei Namedtuples.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import namedtuple\n",
    "HelloWorld = namedtuple('HelloWord','hello,world')\n",
    "hw = HelloWorld('hallo', 'welt')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "glom(hw, T.hello)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "glom(hw, (T._asdict(), 'hello'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 7. Loop mit Iter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from glom import glom, Iter\n",
    "\n",
    "target = ['Brummbär',\n",
    "          'Pimpel',\n",
    "          'Happy',\n",
    "          'Chef',\n",
    "          'Hatschi',\n",
    "          'Schlafmütz',\n",
    "          'Seppel']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Iter liefert erst einmal einen Generator\n",
    "spec = Iter()\n",
    "glom(target, spec)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Generator in Liste verwandeln\n",
    "spec = Iter().all()\n",
    "glom(target, spec)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Gruppieren in Chunks\n",
    "spec = Iter().chunked(2, fill='Schneewittchen').all()\n",
    "glom(target, spec)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "spec = Iter().filter(lambda x: x != 'Chef').all()\n",
    "glom(target, spec)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Maximale Größe der Rückgabe\n",
    "spec = Iter().limit(3).all()\n",
    "glom(target, spec)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Zwerge 2 bis 4 in der 0-basierten Liste finden\n",
    "spec = Iter().slice(1, 4).all()\n",
    "glom(target, spec)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Nur ein Zwerg mit dem gleichen Anfangsbuchstaben erlaubt\n",
    "spec = Iter().unique(T[0]).all()\n",
    "glom(target, spec)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Nehmen, nur bis der Chef kommt\n",
    "spec = Iter().takewhile(lambda x: x != 'Chef').all()\n",
    "glom(target, spec)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Der erste Zwerg, der nach dem Chef kommt...\n",
    "spec = Iter().dropwhile(lambda x: x != 'Chef').slice(1, 2).first()\n",
    "glom(target, spec)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Gruppentrennung\n",
    "spec = Iter().split('Chef').all() \n",
    "glom(target, spec)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Funktion anwenden\n",
    "spec = Iter().map(lambda x:x.lower()).all()\n",
    "glom(target, spec)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# oder das Stunt-Double verwenden\n",
    "spec = Iter().map(T.upper()).all()\n",
    "glom(target, spec)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 8. Literal - Feste Werte vergeben"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from glom import Literal\n",
    "spec = Iter({'Name': T, 'Grösse': Literal('Zwerg')}).all()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "glom(target, spec)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 9. Data Driven\n",
    "\n",
    "Wenn der Schlüssel aus dem Dictionary Daten enthält"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from glom import glom, T, Merge, Iter, Coalesce\n",
    "\n",
    "target = {\n",
    "    \"pluto\": {\"moons\": 6, \"population\": None},\n",
    "    \"venus\": {\"population\": {\"aliens\": 5}},\n",
    "    \"earth\": {\"moons\": 1, \"population\": {\"humans\": 7_700_000_000, \"aliens\": 1}},\n",
    "}\n",
    "\n",
    "spec = {\n",
    "    \"moons\": (\n",
    "           T.items(),\n",
    "           Iter({T[0]: (T[1], Coalesce(\"moons\", default=0))}),\n",
    "           Merge()\n",
    "    )\n",
    "}\n",
    "        \n",
    "glom(target, spec)        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 10. Werte hinzufügen & entfernen\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = {'moons': {'pluto': 6, 'venus': 0, 'earth': 1}}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from glom import Assign, Delete\n",
    "spec = Assign('moons.saturn', 7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "glom(data, spec)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "spec = Delete('moons.earth')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "glom(data, spec)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "spec = Delete('moons.mars', ignore_missing=True)\n",
    "\n",
    "glom(data, spec)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 11. Scope / Let\n",
    "\n",
    "Mit Scope weitere Daten übergeben, die sonst nicht sichtbar wären"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from glom import S, glom, Assign, Spec\n",
    "\n",
    "target = {'date': '2020-04-01',\n",
    " 'location': 'A',\n",
    " 'items': [\n",
    "     {'name': 'A', 'id': 'A1'},\n",
    "     {'name': 'B', 'id': 'B1'},\n",
    "     {'name': 'C', 'id': 'C1'}\n",
    "]}\n",
    "\n",
    "spec = ('items', \n",
    "        [Assign('date', Spec(S['date']))], \n",
    "        [Assign('location', Spec(S['location']))]\n",
    "       )\n",
    "\n",
    "glom(target, spec, scope=target)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Das gleiche Beispiel mit Let:\n",
    "\n",
    "Let schreibt zur Laufzeit in den Scope hinein    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from glom import Fill\n",
    "from glom.core import Let\n",
    "\n",
    "spec = (\n",
    "    # Äußere Werte in den Scope schreiben\n",
    "    Let(base={\"date\": \"date\", \"location\": \"location\"}),\n",
    "    # Nur \"items\" auswählen\n",
    "    \"items\",\n",
    "    [\n",
    "        # Für jedes Element: Die Werte der \"Base\" auspacken und verbinden\n",
    "        (Fill([T, S[\"base\"]]), Merge())\n",
    "    ]\n",
    ")\n",
    "\n",
    "glom(target, spec, scope=target)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 12. XML"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from glom import Ref"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "etree2dicts = Ref('ElementTree',\n",
    "    {\"tag\": \"tag\", \n",
    "     \"text\": \"text\", \n",
    "     \"attrib\": \"attrib\", \n",
    "     \"children\": (iter, [Ref('ElementTree')])})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "html_text = \"\"\"<html>\n",
    "  <head>\n",
    "    <title>the title</title>\n",
    "  </head>\n",
    "  <body id=\"the-body\">\n",
    "    <p>A paragraph</p>\n",
    "  </body>\n",
    "</html>\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from xml.etree import ElementTree\n",
    "etree = ElementTree.fromstring(html_text)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "glom(etree, etree2dicts)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 13. Weiteres...\n",
    "\n",
    "aus Zeitgründen noch nicht erwähnt\n",
    "\n",
    "- Path ( Eine andere Pfadnotation, wenn Strings nicht gehen)\n",
    "- Invoke / Call (Funktionen anwenden)\n",
    "- Check -> CheckError (Daten auf Korrektheit prüfen!)\n",
    "- Inspect (Debugger)  \n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 14. Glom, Kommentare und der Codeformatter \"Black\"\n",
    "\n",
    "Wer seinen Code mit Black (https://pypi.org/project/black/) formatiert, kann erleben,\n",
    "dass Black die Glom-Spec umformatiert und damit schlechter lesbar macht.\n",
    "\n",
    "Wenn eine Spec so kompliziert ist, dass sie schwer nachvollziehbar ist,\n",
    "kann diese mit Kommentarzeilen versehen.\n",
    "\n",
    "Das vorherige Beispiel zum Scope behält mit Kommentaren von Black seine Einrückungen und ist so leichter verständlich.\n",
    "\n",
    "    spec = (\n",
    "        # Äußere Werte in den Scope schreiben\n",
    "        Let(base={\"date\": \"date\", \"location\": \"location\"}),\n",
    "        # Nur \"items\" auswählen\n",
    "        \"items\",\n",
    "        [\n",
    "            # Für jedes Element: Die Werte der \"Base\" auspacken und verbinden\n",
    "            (Fill([T, S[\"base\"]]), Merge())\n",
    "        ],\n",
    "    )\n",
    "    \n",
    "\n",
    "\n",
    "Ohne Kommentare wird es von Black zusammengeschoben.    \n",
    "    \n",
    "    spec = (\n",
    "        Let(base={\"date\": \"date\", \"location\": \"location\"}),\n",
    "        \"items\",\n",
    "        [(Fill([T, S[\"base\"]]), Merge())],\n",
    "    )\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Übungsaufgaben\n",
    "\n",
    "### Aufgabe 1: \n",
    "\n",
    "Aus der Raumliste http://borus.de/pythoncamp/event.json ein Dictionary erstellen, das den Raumnamen in GROSSBUCHSTABEN als Schlüssel hat und die URL als Wert.\n",
    "\n",
    "Gewünschtes Ergebnis:\n",
    "\n",
    "    {\n",
    "     'BERLIN': 'https://bbb01.pythoncamp.online/b/rei-hyz-cgm',\n",
    "     'FLIEGENDER ZIRKUS': 'https://bbb01.pythoncamp.online/b/rei-hyz-cgm',\n",
    "     'TOKIO': 'https://bbb01.pythoncamp.online/b/rei-hyz-cgm'\n",
    "     ...\n",
    "     }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import requests"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "r = requests.get(r'http://borus.de/pythoncamp/event.json')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "r.json()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# hier die Spec bitte selbst schreiben\n",
    "spec = \"... ?\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "glom(r.json(), spec)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Aufgabe 2:\n",
    "\n",
    "Daten extrahieren aus der einer Online-Buchungsanfrage \n",
    "http://borus.de/pythoncamp/booking_example.json\n",
    "        \n",
    "Gewünschtes Ergebnis:\n",
    "\n",
    "    {'abfahrtshafen_hin': 'DKHNB',\n",
    "     'abfahrtsdatum_hin': '2019-09-01',\n",
    "     'abfahrtszeit_hin': '14:30',\n",
    "     'abfahrtshafen_rueck': 'DELIS',\n",
    "     'abfahrtsdatum_rueck': '2019-10-02',\n",
    "     'abfahrtszeit_rueck': '19:25',\n",
    "     'fahrkarten': ['CAR', 'AD', 'CH']\n",
    "    }\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "r = requests.get(r'http://borus.de/pythoncamp/booking_example.json')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "r.json()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Bitte hier die Spec schreiben\n",
    "spec = \"... ?\"\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "glom(r.json(), spec)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}