Anki DGS.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Anmerkung: Dieses Notebook ist Teil von https://github.com/SamuelVilz/anki-german-sign-language und es ergibt wenig Sinn, es unabhängig von den dortigen Dateien zu verwenden."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ! pip install genanki"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import genanki"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "import re"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Card-HTMLs hardcoden"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def getVideoHTMLStringFront(videonumber):\n",
    "    returnstring = '<div class=\"container\">\\n'\n",
    "    returnstring += '<iframe width=\"400\" height=\"300\" frameborder=\"0\" src=\"{{Video '+str(videonumber)+'}}\" allow=\"autoplay; encrypted-media\" allowfullscreen></iframe>\\n'\n",
    "    returnstring += '{{#Video '+str(videonumber)+' contains text}}\\n'\n",
    "    returnstring += '<div class=\"cover\"></div>\\n'\n",
    "    returnstring += '{{/Video '+str(videonumber)+' contains text}}\\n'\n",
    "    returnstring += '</div>'\n",
    "    return returnstring"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "meaningFront = '{{Meaning}}\\n\\n{{#Note}}\\n<div class=\"note\">{{Note}}</div>\\n{{/Note}}'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "videoBackside = '{{FrontSide}}\\n\\n<hr id=answer>\\n\\n{{Meaning}}\\n\\n{{#Note}}\\n<div class=\"note\">{{Note}}</div>\\n{{/Note}}'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def getMeaningHTMLStringBack():\n",
    "    returnstring = ''\n",
    "    for i in range(1,7):\n",
    "        returnstring+='\\n{{#Video '+str(i)+'}}\\n<iframe width=\"400\" height=\"300\" frameborder=\"0\" src=\"{{Video '+str(i)+'}}\" allow=\"autoplay; encrypted-media\" scrolling=\"no\"></iframe>\\n{{/Video '+str(i)+'}}\\n'\n",
    "    return returnstring\n",
    "meaningBack = '{{FrontSide}}\\n\\n<hr id=answer>\\n' + getMeaningHTMLStringBack()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "stylingstring = ''\n",
    "with open('Styling.txt', 'r') as f:\n",
    "    stylingstring=f.read()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "templatesArray = []\n",
    "for i in range(1,7):\n",
    "    dicti = {}\n",
    "    dicti['name'] = 'Video '+str(i)\n",
    "    dicti['qfmt'] = getVideoHTMLStringFront(i)\n",
    "    dicti['afmt'] = videoBackside\n",
    "    templatesArray.append(dicti)\n",
    "dictmeaning = {}\n",
    "dictmeaning['name'] = 'Meaning'\n",
    "dictmeaning['qfmt'] = meaningFront\n",
    "dictmeaning['afmt'] = meaningBack\n",
    "templatesArray.append(dictmeaning)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Erstellung des Models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "dgs_model = genanki.Model(\n",
    "  model_id=5,\n",
    "  name='DGS Model',\n",
    "  fields=[\n",
    "    {'name': 'Meaning'},\n",
    "    {'name': 'Note'},\n",
    "    {'name': 'Video 1'},\n",
    "    {'name': 'Video 2'},\n",
    "    {'name': 'Video 3'},\n",
    "    {'name': 'Video 4'},\n",
    "    {'name': 'Video 5'},\n",
    "    {'name': 'Video 6'},\n",
    "    {'name': 'Video 1 contains text'},\n",
    "    {'name': 'Video 2 contains text'},\n",
    "    {'name': 'Video 3 contains text'},\n",
    "    {'name': 'Video 4 contains text'},\n",
    "    {'name': 'Video 5 contains text'},\n",
    "    {'name': 'Video 6 contains text'}\n",
    "  ],\n",
    "  templates=templatesArray,\n",
    "  css = stylingstring\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Ein Beispieldeck erzeugen"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Diese Methode ist später vor allem deshalb nützlich, weil man beim Eingeben der Werte die Parameternamen sieht, statt\n",
    "# sie blind in eine Liste zu packen\n",
    "def noteFields(meaning,\n",
    "           video1,\n",
    "           note = '',\n",
    "           video2 = '',\n",
    "           video3 = '',\n",
    "           video4 = '',\n",
    "           video5 = '',\n",
    "           video6 = '',\n",
    "           video1t = '',\n",
    "           video2t = '',\n",
    "           video3t = '',\n",
    "           video4t = '',\n",
    "           video5t = '',\n",
    "           video6t = ''):\n",
    "    return [meaning,\n",
    "            note,\n",
    "            video1,\n",
    "            video2,\n",
    "            video3,\n",
    "            video4,\n",
    "            video5,\n",
    "            video6,\n",
    "            video1t,\n",
    "            video2t,\n",
    "            video3t,\n",
    "            video4t,\n",
    "            video5t,\n",
    "            video6t]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "dankenote = genanki.Note(\n",
    "  model=dgs_model,\n",
    "  fields=noteFields(meaning = 'danke',\n",
    "                    video1 = 'https://signdict.org/embed/1360-danke/video/151',\n",
    "                    video2 = 'https://signdict.org/embed/1360-danke/video/1526'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "merkelnote = genanki.Note(\n",
    "  model=dgs_model,\n",
    "  fields=noteFields(meaning = 'Merkel',\n",
    "                    video1 = 'https://signdict.org/embed/2456-merkel/video/2757'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "dnkmrkl_deck = genanki.Deck(\n",
    "  6,\n",
    "  'Danke Merkel')\n",
    "\n",
    "dnkmrkl_deck.add_note(dankenote)\n",
    "dnkmrkl_deck.add_note(merkelnote)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "genanki.Package(dnkmrkl_deck).write_to_file('Custom Decks/1 dnkmrkl.apkg')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Einträge parsen"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Achtung!** Hierfür muss die Datei \"entries\" im gleichen Ordner wie das Notebook vorliegen. Zur Erzeugung (und Aktualisierung) dieser Datei muss der Ruby-Code `crawl.rb` ausgeführt werden."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "f = open(\"entries\", \"r\", encoding=\"utf-8\")\n",
    "entrylist = []\n",
    "for x in f:\n",
    "  entrylist.append(x[:-1].replace(\"/entry/\", \"/embed/\").split('\\t'))\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[['/embed/507-morgen/video/573', 'Morgen', 'kommender Tag'],\n",
       " ['/embed/507-morgen/video/574', 'Morgen', 'kommender Tag'],\n",
       " ['/embed/507-morgen/video/575', 'Morgen', 'kommender Tag'],\n",
       " ['/embed/507-morgen/video/576', 'Morgen', 'kommender Tag'],\n",
       " ['/embed/507-morgen/video/2824', 'Morgen', 'kommender Tag'],\n",
       " ['/embed/506-morgen/video/572', 'Morgen', 'Tageszeit'],\n",
       " ['/embed/506-morgen/video/2825', 'Morgen', 'Tageszeit']]"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[x for x in entrylist if x[1]=='Morgen']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['21', '36', '40', '114', '132']"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f = open(\"containtext\", \"r\", encoding=\"utf-8\")\n",
    "textlist = []\n",
    "for x in f:\n",
    "  textlist.append(x[:-1].split()[0])\n",
    "f.close()\n",
    "textlist[:5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('0',), ('1',), ('10',), ('100',), ('1000',)]"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "entry_note_keys = list(sorted(set(map(lambda x: tuple(x[1:]), entrylist))))\n",
    "entry_note_keys[:5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_deck = genanki.Deck(\n",
    "  7,\n",
    "  'SignDict Alles')\n",
    "allnotelist = [] # for debugging\n",
    "for key in entry_note_keys:\n",
    "    key_data = [x for x in entrylist if tuple(x[1:]) == key]\n",
    "    videos = []\n",
    "    for i in range(6):\n",
    "        videos.append('https://signdict.org'+key_data[i][0] if len(key_data)>i else '')\n",
    "    fields = noteFields(meaning = key_data[0][1],\n",
    "                        note = key_data[0][2] if len(key_data[0])>2 else '',\n",
    "                        video1 = videos[0],\n",
    "                        video2 = videos[1],\n",
    "                        video3 = videos[2],\n",
    "                        video4 = videos[3],\n",
    "                        video5 = videos[4],\n",
    "                        video6 = videos[5],\n",
    "                        video1t = \"yes\" if videos[0].split('/')[-1] in textlist else \"\",\n",
    "                        video2t = \"yes\" if videos[1].split('/')[-1] in textlist else \"\",\n",
    "                        video3t = \"yes\" if videos[2].split('/')[-1] in textlist else \"\",\n",
    "                        video4t = \"yes\" if videos[3].split('/')[-1] in textlist else \"\",\n",
    "                        video5t = \"yes\" if videos[4].split('/')[-1] in textlist else \"\",\n",
    "                        video6t = \"yes\" if videos[5].split('/')[-1] in textlist else \"\")\n",
    "    thisnote = genanki.Note(\n",
    "      model=dgs_model,\n",
    "      fields=fields)\n",
    "    allnotelist.append(fields) # for debugging\n",
    "    my_deck.add_note(thisnote)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[['0',\n",
       "  '',\n",
       "  'https://signdict.org/embed/2636-0/video/2962',\n",
       "  '',\n",
       "  '',\n",
       "  '',\n",
       "  '',\n",
       "  '',\n",
       "  '',\n",
       "  '',\n",
       "  '',\n",
       "  '',\n",
       "  '',\n",
       "  ''],\n",
       " ['1',\n",
       "  '',\n",
       "  'https://signdict.org/embed/181-1/video/206',\n",
       "  'https://signdict.org/embed/181-1/video/1668',\n",
       "  '',\n",
       "  '',\n",
       "  '',\n",
       "  '',\n",
       "  '',\n",
       "  '',\n",
       "  '',\n",
       "  '',\n",
       "  '',\n",
       "  ''],\n",
       " ['10',\n",
       "  '',\n",
       "  'https://signdict.org/embed/826-10/video/940',\n",
       "  'https://signdict.org/embed/826-10/video/4221',\n",
       "  '',\n",
       "  '',\n",
       "  '',\n",
       "  '',\n",
       "  '',\n",
       "  '',\n",
       "  '',\n",
       "  '',\n",
       "  '',\n",
       "  '']]"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "allnotelist[:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "genanki.Package(my_deck).write_to_file('Custom Decks/2 SignDictAlles.apkg')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Custom Decks einfacher erstellen"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Zunächst ein Wort der Vorsicht: Wenn ein Deck in Anki importiert wird, das Karten enthält, die bereits in einem anderen Deck vorliegen, dann werden diese Karten nicht im neuen Deck auftauchen."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Noch ein Blick auf den Umgang mit den Daten"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Wie soll der Nutzer seine gewünschten Karten angeben? Wie behandeln wir Fälle, in denen \"Meaning\" nicht eindeutig ist?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "someset = list(sorted(set([tuple(x[1:]) for x in entrylist\n",
    "                           if len([y for y in entrylist if x[1]==y[1] and (len(x)!=len(y) or (len(x)>2 and x[2]!=y[2]))])\n",
    "                               >0])))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('Amerika',),\n",
       " ('Amerika', 'Kontinent'),\n",
       " ('Bahn',),\n",
       " ('Bahn', 'Parcours'),\n",
       " ('Bank', 'Geld'),\n",
       " ('Bank', 'Park'),\n",
       " ('Bar',),\n",
       " ('Bar', 'Geld'),\n",
       " ('Bedienung',),\n",
       " ('Bedienung', 'Handhabung')]"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "someset[:10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('Morgen', 'Tageszeit'), ('Morgen', 'kommender Tag')]"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[x for x in someset if 'Morgen' in x[0]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Funktion zur Erstellung"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "def createDeck(deckname, filename, keys):\n",
    "    custom_deck = genanki.Deck(\n",
    "      random.randrange(1 << 30, 1 << 31),\n",
    "      deckname)\n",
    "#     allnotelist = [] # for debugging\n",
    "    for key in keys:\n",
    "        key_data = [x for x in entrylist if tuple(x[1:]) == key]\n",
    "        videos = []\n",
    "        for i in range(6):\n",
    "            videos.append('https://signdict.org'+key_data[i][0] if len(key_data)>i else '')\n",
    "        fields = noteFields(meaning = key_data[0][1],\n",
    "                            note = key_data[0][2] if len(key_data[0])>2 else '',\n",
    "                            video1 = videos[0],\n",
    "                            video2 = videos[1],\n",
    "                            video3 = videos[2],\n",
    "                            video4 = videos[3],\n",
    "                            video5 = videos[4],\n",
    "                            video6 = videos[5],\n",
    "                            video1t = \"yes\" if videos[0].split('/')[-1] in textlist else \"\",\n",
    "                            video2t = \"yes\" if videos[1].split('/')[-1] in textlist else \"\",\n",
    "                            video3t = \"yes\" if videos[2].split('/')[-1] in textlist else \"\",\n",
    "                            video4t = \"yes\" if videos[3].split('/')[-1] in textlist else \"\",\n",
    "                            video5t = \"yes\" if videos[4].split('/')[-1] in textlist else \"\",\n",
    "                            video6t = \"yes\" if videos[5].split('/')[-1] in textlist else \"\")\n",
    "        thisnote = genanki.Note(\n",
    "          model=dgs_model,\n",
    "          fields=fields)\n",
    "#         allnotelist.append(fields) # for debugging\n",
    "        custom_deck.add_note(thisnote)\n",
    "    genanki.Package(custom_deck).write_to_file('Custom Decks/'+filename+'.apkg')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Beispiel: Alphabet-Deck"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(['a', 'b', 'c', 'd', 'e'], '...', ['7', '7', '8', '9', '9'])"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "singlecharacterentrys = [x[1] for x in entrylist if len(x[1])==1]\n",
    "singlecharacterentrys[:5], \"...\", singlecharacterentrys[-5:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Diese Liste enthält leider auch Ziffern, daher müssen wir uns regulärer Ausdrücke (RegEx) bedienen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(26, ['a', 'b', 'c'], '...', ['x', 'y', 'z'])"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "letterentries = [x[1] for x in entrylist if re.fullmatch('[A-Za-zßÄÖÜäöü]',x[1])]\n",
    "len(letterentries), letterentries[:3],'...',letterentries[-3:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Umlaute und ß gibt es bisher nicht, aber dafür kann unser Code ja nichts. \"sch\" hätten wir gerne trotzdem noch als Teil des Alphabets:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(27, ['a', 'b', 'c'], '...', ['x', 'y', 'z'])"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "letterentries = [x[1] for x in entrylist if re.fullmatch('[A-Za-zßÄÖÜäöü]|sch',x[1])]\n",
    "len(letterentries), letterentries[:3],'...',letterentries[-3:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Jetzt generieren wir die notwendigen Keys und überreichen diese an die oben definierte Funktion"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('a',), ('b',), ('c',), ('d',), ('e',)]"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "letterkeys = list(sorted(set(map(lambda x: tuple(x[1:]),\n",
    "                                [x for x in entrylist if re.fullmatch('[A-Za-zßÄÖÜäöü]|sch',x[1])]))))\n",
    "letterkeys[:5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "createDeck('Fingeralphabet', '3 Fingeralphabet', letterkeys)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Beispiel: Zahlen von 1 bis 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(16, ['1', '1', '10'], '...', ['8', '9', '9'])"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numberentries = [x[1] for x in entrylist if re.fullmatch('[1-9]|10',x[1])]\n",
    "len(numberentries), numberentries[:3],'...',numberentries[-3:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Das sind einige Duplikate. Mal Übersicht schaffen:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['1', '10', '2', '3', '4', '5', '6', '7', '8', '9']"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(sorted(set(numberentries)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Gut, das wollen wir"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('1',),\n",
       " ('10',),\n",
       " ('2',),\n",
       " ('3',),\n",
       " ('4',),\n",
       " ('5',),\n",
       " ('6',),\n",
       " ('7',),\n",
       " ('8',),\n",
       " ('9',)]"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numberkeys = list(sorted(set(map(lambda x: tuple(x[1:]),\n",
    "                                [x for x in entrylist if re.fullmatch('[1-9]|10',x[1])]))))\n",
    "numberkeys"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "createDeck('Zahlen bis 10', '4 Zahlen bis 10', numberkeys)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Beispiel: Alle Zahlen"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(82, ['0', '1', '1'], '...', ['9', '90', '90'])"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "allnumberentries = [x[1] for x in entrylist if re.fullmatch('[0-9]*',x[1])]\n",
    "len(allnumberentries), allnumberentries[:3],'...',allnumberentries[-3:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('0',),\n",
       " ('1',),\n",
       " ('10',),\n",
       " ('100',),\n",
       " ('1000',),\n",
       " ('11',),\n",
       " ('12',),\n",
       " ('13',),\n",
       " ('14',),\n",
       " ('15',),\n",
       " ('16',),\n",
       " ('17',),\n",
       " ('18',),\n",
       " ('19',),\n",
       " ('2',),\n",
       " ('20',),\n",
       " ('200',),\n",
       " ('2000',),\n",
       " ('21',),\n",
       " ('22',),\n",
       " ('23',),\n",
       " ('24',),\n",
       " ('25',),\n",
       " ('26',),\n",
       " ('27',),\n",
       " ('28',),\n",
       " ('29',),\n",
       " ('3',),\n",
       " ('30',),\n",
       " ('31',),\n",
       " ('32',),\n",
       " ('33',),\n",
       " ('34',),\n",
       " ('35',),\n",
       " ('36',),\n",
       " ('37',),\n",
       " ('38',),\n",
       " ('39',),\n",
       " ('4',),\n",
       " ('40',),\n",
       " ('5',),\n",
       " ('50',),\n",
       " ('6',),\n",
       " ('60',),\n",
       " ('6000',),\n",
       " ('66',),\n",
       " ('7',),\n",
       " ('70',),\n",
       " ('8',),\n",
       " ('80',),\n",
       " ('9',),\n",
       " ('90',)]"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "allnumberkeys = list(sorted(set(map(lambda x: tuple(x[1:]),\n",
    "                                [x for x in entrylist if re.fullmatch('[0-9]*',x[1])]))))\n",
    "allnumberkeys"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "createDeck('Alle Zahlen', '5 Alle Zahlen', allnumberkeys)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Beispiel: Selbstgewählte Einträge"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Welche Einträge wollen wir?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hierfür erstellen wir zunächst eine handliche Liste mit allen Vokabeln, die wir in einem Deck haben wollen:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "vocablist = [\n",
    "    'ich',\n",
    "    'du',\n",
    "    'er',\n",
    "    'sie',\n",
    "    'es',\n",
    "    'wir',\n",
    "    'ihr',\n",
    "    'gehörlos',\n",
    "    'wir beide',\n",
    "    'mein',\n",
    "    'dein',\n",
    "    'sein, ihr',\n",
    "    'unser',\n",
    "    'euer',\n",
    "    'Name',\n",
    "    'was',\n",
    "    'Körper',\n",
    "    'gut',\n",
    "    \"wie geht's\",\n",
    "    'nicht gut gehen',\n",
    "    'schlecht',\n",
    "    'super',\n",
    "    'einigermaßen',\n",
    "    'hallo',\n",
    "    'tschüss',\n",
    "    'taub',\n",
    "    'hörend',\n",
    "    'ertaubt',\n",
    "    'Stimme weglassen',\n",
    "    'vorstellen',\n",
    "    'schwerhörig',\n",
    "    'kennenlernen',\n",
    "    'Fingeralphabet',\n",
    "    'Vorname',\n",
    "    'Nachname',\n",
    "    'Gebärdensprache',\n",
    "    'Gebärde',\n",
    "    'Sprache',\n",
    "    'nach',\n",
    "    'wer',\n",
    "    'wo',\n",
    "    'Wort',\n",
    "    'Vokabeln',\n",
    "    'Satz',\n",
    "    'Grammatik',\n",
    "    'Mimik',\n",
    "    'müde',\n",
    "    'prima',\n",
    "    'übel',\n",
    "    'Kopfschmerzen',\n",
    "    'Schwindel',\n",
    "    'mittel',\n",
    "    'wohl',\n",
    "    'fit'\n",
    "]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dann lesen wir die Liste ein und lassen uns ausgeben, wenn es Probleme oder Mehrdeutigkeiten gibt:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "_____________\n",
      "'ich' -> [\"['ich']\"]\n",
      "_____________\n",
      "'du' -> [\"['Du']\", \"['du']\"]\n",
      "_____________\n",
      "'er' -> [\"['er']\"]\n",
      "_____________\n",
      "'sie' -> [\"['sie']\"]\n",
      "_____________\n",
      "'es' wurde gefunden in: [\"['Abendessen']\", \"['Adresse, Anschrift']\", \"['Alles']\", \"['Angestellter']\", \"['Anästhesie']\", \"['Atembeschwerden']\", \"['Bescheid sagen']\", \"['Besen']\", \"['Besitz']\", \"['Besteck']\", '...']\n",
      "_____________\n",
      "'wir' -> [\"['wir']\"]\n",
      "_____________\n",
      "'ihr' -> [\"['ihr', 'Besitz']\", \"['ihr']\"]\n",
      "_____________\n",
      "'gehörlos' -> [\"['gehörlos']\"]\n",
      "_____________\n",
      "'wir beide' -> [\"['wir beide', 'Person und ich']\", \"['wir beide', 'du und ich']\"]\n",
      "_____________\n",
      "'mein' -> [\"['mein']\"]\n",
      "_____________\n",
      "'dein' -> [\"['dein']\"]\n",
      "_____________\n",
      "'sein, ihr' -> [\"['sein, ihr']\"]\n",
      "_____________\n",
      "'unser' -> [\"['unser']\"]\n",
      "_____________\n",
      "'euer' -> [\"['euer']\"]\n",
      "_____________\n",
      "'Name' -> [\"['Name']\"]\n",
      "_____________\n",
      "'was' -> [\"['was']\"]\n",
      "_____________\n",
      "'Körper' -> [\"['Körper']\"]\n",
      "_____________\n",
      "'gut' -> [\"['Gut']\", \"['gut']\"]\n",
      "_____________\n",
      "'wie geht's' -> ['[\"wie geht\\'s\"]']\n",
      "_____________\n",
      "'nicht gut gehen' -> [\"['nicht gut gehen']\"]\n",
      "_____________\n",
      "'schlecht' -> [\"['schlecht']\"]\n",
      "_____________\n",
      "'super' -> [\"['super']\"]\n",
      "_____________\n",
      "'einigermaßen' -> [\"['einigermaßen']\"]\n",
      "_____________\n",
      "'hallo' -> [\"['Hallo']\"]\n",
      "_____________\n",
      "'tschüss' -> [\"['tschüss']\"]\n",
      "_____________\n",
      "'taub' -> [\"['taub']\"]\n",
      "_____________\n",
      "'hörend' -> [\"['hörend']\"]\n",
      "_____________\n",
      "'ertaubt' -> [\"['ertaubt']\"]\n",
      "_____________\n",
      "'Stimme weglassen' -> [\"['Stimme weglassen']\"]\n",
      "_____________\n",
      "'vorstellen' -> [\"['vorstellen', 'dir - Person']\", \"['vorstellen', 'mich - dir']\"]\n",
      "_____________\n",
      "'schwerhörig' -> [\"['schwerhörig']\"]\n",
      "_____________\n",
      "'kennenlernen' -> [\"['kennenlernen']\"]\n",
      "_____________\n",
      "'Fingeralphabet' -> [\"['Fingeralphabet']\"]\n",
      "_____________\n",
      "'Vorname' -> [\"['Vorname']\"]\n",
      "_____________\n",
      "'Nachname' -> [\"['Nachname']\"]\n",
      "_____________\n",
      "'Gebärdensprache' -> [\"['Gebärdensprache']\"]\n",
      "_____________\n",
      "'Gebärde' wurde gefunden in: [\"['Gebärdensprache']\", \"['Spezialgebärden']\", \"['gebärden']\", \"['lexikalische Gebärden']\"]\n",
      "_____________\n",
      "'Sprache' -> [\"['Sprache']\"]\n",
      "_____________\n",
      "'nach' wurde gefunden in: [\"['Gute Nacht']\", \"['Mitternacht']\", \"['Nach Hause']\", \"['Nachahmung']\", \"['Nachbar']\", \"['Nachmittag']\", \"['Nachnahme']\", \"['Nachname']\", \"['Nachricht']\", \"['Nachrichten']\", '...']\n",
      "_____________\n",
      "'wer' -> [\"['wer']\"]\n",
      "_____________\n",
      "'wo' -> [\"['wo']\"]\n",
      "_____________\n",
      "'Wort' -> [\"['Wort']\"]\n",
      "_____________\n",
      "'Vokabeln' -> [\"['Vokabeln']\"]\n",
      "_____________\n",
      "'Satz' -> [\"['Satz']\"]\n",
      "_____________\n",
      "'Grammatik' -> [\"['Grammatik']\"]\n",
      "_____________\n",
      "'Mimik' -> [\"['Mimik']\"]\n",
      "_____________\n",
      "'müde' -> [\"['müde']\"]\n",
      "_____________\n",
      "'prima' -> [\"['prima']\"]\n",
      "_____________\n",
      "'übel' wurde nicht gefunden\n",
      "_____________\n",
      "'Kopfschmerzen' -> [\"['Kopfschmerzen']\"]\n",
      "_____________\n",
      "'Schwindel' wurde nicht gefunden\n",
      "_____________\n",
      "'mittel' wurde gefunden in: [\"['Lebensmittel']\", \"['Mittelalter']\", \"['Mittelfeld']\", \"['Mittelfinger']\", \"['Mittelmeer']\", \"['Nahrungsmittel']\"]\n",
      "_____________\n",
      "'wohl' -> [\"['wohl']\"]\n",
      "_____________\n",
      "'fit' wurde gefunden in: [\"['Fitness']\"]\n"
     ]
    }
   ],
   "source": [
    "def getResults(vocab):\n",
    "    print(\"_____________\")\n",
    "    perfectmatches = list(sorted(set([str(x[1:]) for x in entrylist if vocab.lower() == x[1].lower()])))\n",
    "    if len(perfectmatches)>0:\n",
    "        print(\"'\" + vocab + \"' -> \" + str(perfectmatches))\n",
    "        return\n",
    "    okaymatches = list(sorted(set([str(x[1:]) for x in entrylist if vocab.lower() in x[1].lower()])))\n",
    "    if len(okaymatches)>0:\n",
    "        if len(okaymatches)>10:\n",
    "            okaymatches = okaymatches[:10] + ['...']\n",
    "        print(\"'\" + vocab + \"' wurde gefunden in: \" + str(okaymatches))\n",
    "        return\n",
    "    print(\"'\" + vocab + \"' wurde nicht gefunden\")\n",
    "    \n",
    "for v in vocablist:\n",
    "    getResults(v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nun müssen wir manuell jeden Eintrag löschen, der uns nur schlechte Ergebnisse gegeben hat. Einträge, die gar nichts ergeben haben, können wir ignorieren - diese werden am Schluss einfach nicht zum Deck hinzugefügt."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "toRemove = [\n",
    "    'es',\n",
    "    'nach',\n",
    "    'mittel',\n",
    "    'fit',\n",
    "]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So löscht man alle zum Löschen gesammelten Einträge:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "for rem in toRemove:\n",
    "    vocablist.remove(rem)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So ersetzt man alte Einträge durch neue, um die Schreibweise an die SignDict-Datenbank anzupassen:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "def replace(fromList, oldValue, newValue):\n",
    "    assert oldValue in fromList, \"Der angegebene Eintrag muss in der Liste sein. Bitte Rechtschreibung prüfen\"\n",
    "    return [newValue if x==oldValue else x for x in fromList]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "vocablist = replace(vocablist, 'Gebärde', 'gebärden')\n",
    "vocablist = replace(vocablist, 'Schwindel', 'schwindlig')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Und so fügt man einen zusätzlichen Eintrag hinzu, nachdem man geprüft hat, dass es die Vokabel auch auf SignDict gibt:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "_____________\n",
      "'frisch' -> [\"['frisch']\"]\n"
     ]
    }
   ],
   "source": [
    "zusatzVocab = 'frisch'\n",
    "getResults(zusatzVocab)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "vocablist.append(zusatzVocab)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Wir sind nun zufrieden mit den Deckeinträgen"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Daher können wir nun die folgenden Zellen laufen lassen:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "def addKeys(keylist, vocab):\n",
    "    perfectmatches = list(sorted(set([tuple(x[1:]) for x in entrylist if vocab.lower() == x[1].lower()])))\n",
    "    if len(perfectmatches)>0:\n",
    "        keylist += perfectmatches\n",
    "        return\n",
    "    okaymatches = list(sorted(set([tuple(x[1:]) for x in entrylist if vocab.lower() in x[1].lower()])))\n",
    "    if len(okaymatches)>0:\n",
    "        keylist += okaymatches\n",
    "        return"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('ich',), ('Du',), ('du',), ('er',), ('sie',), '...']"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vocabKeys = []\n",
    "for v in vocablist:\n",
    "    addKeys(vocabKeys, v)\n",
    "vocabKeys[:5] + ['...']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Zu guter Letzt generieren wir noch die Anki-Datei!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "createDeck('Kapitel 1', '6 ViKo DGS Kapitel 1', vocabKeys)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Und: Daran denken, das Deck noch manuell zu mischen, bevor du es verwendest."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Das war's! Bei weiteren Fragen bitte auf [GitHub](https://github.com/SamuelVilz/anki-german-sign-language) einen \"Issue\" öffnen"
   ]
  }
 ],
 "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}