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": [
    "import os"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ! pip install genanki"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import genanki"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "import re"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ! pip install duden"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "import duden"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "import json"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Card-HTMLs hardcoden"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def videoFrontside(videonumber):\n",
    "    return f\"\"\"\\\n",
    "<div class=\"container\">\n",
    "  <iframe width=\"400\" height=\"300\" frameborder=\"0\"\n",
    "    src=\"{{{{Video {videonumber}}}}}?autoplay=true\"\n",
    "    allow=\"autoplay; encrypted-media\" allowfullscreen></iframe>\n",
    "  {{{{#Video {videonumber} contains text}}}}\n",
    "  <div class=\"cover\"></div>\n",
    "  {{{{/Video {videonumber} contains text}}}}\n",
    "</div>\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def videoBackside(videonumber):\n",
    "    return f\"\"\"\\\n",
    "{{{{FrontSide}}}}\n",
    "\n",
    "<hr id=\"answer\">\n",
    "\n",
    "{{{{Meaning}}}}\n",
    "{{{{#Video {videonumber} Extra}}}}\n",
    "  <div class=\"videoextra\">{{{{Video {videonumber} Extra}}}}</div>\n",
    "{{{{/Video {videonumber} Extra}}}}\n",
    "\n",
    "{{{{#Note}}}}\n",
    "  <div class=\"note\">{{{{Note}}}}</div>\n",
    "{{{{/Note}}}}\n",
    "\n",
    "{{{{#Extra}}}}\n",
    "  <div class=\"extra\">{{{{Extra}}}}</div>\n",
    "{{{{/Extra}}}}\n",
    "\n",
    "{{{{#Commonness}}}}\n",
    "  <div class=\"commonness\">\n",
    "    <span class=\"commonness-label\">Häufigkeit:</span>\n",
    "    <span class=\"commonness-value\">{{{{Commonness}}}}</span>\n",
    "  </div>\n",
    "{{{{/Commonness}}}}\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "meaningFront = \"\"\"\\\n",
    "{{Meaning}}\n",
    "\n",
    "{{#Note}}\n",
    "  <div class=\"note\">{{Note}}</div>\n",
    "{{/Note}}\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "getMeaningHTMLStringBack = \"\\n\\n\".join([f\"\"\"\\\n",
    "{{{{#Video {i}}}}}\n",
    "  <iframe width=\"400\" height=\"300\" frameborder=\"0\" \n",
    "          src=\"{{{{Video {i}}}}}?autoplay=true\" allow=\"autoplay; \n",
    "          encrypted-media\" scrolling=\"no\"></iframe>\n",
    "  {{{{#Video {i} Extra}}}}\n",
    "    <div class=\"videoextra\">{{{{Video {i} Extra}}}}</div>\n",
    "  {{{{/Video {i} Extra}}}}\n",
    "{{{{/Video {i}}}}}\n",
    "\"\"\" for i in range(1,6)])\n",
    "\n",
    "meaningBack = f\"\"\"\\\n",
    "{{{{FrontSide}}}}\n",
    "\n",
    "<hr id=\"answer\">\n",
    "\n",
    "{{{{#Extra}}}}\n",
    "  <div class=\"extra\">{{{{Extra}}}}</div>\n",
    "{{{{/Extra}}}}\n",
    "\n",
    "{{{{#Commonness}}}}\n",
    "  <div class=\"commonness\">\n",
    "    <span class=\"commonness-label\">Häufigkeit:</span>\n",
    "    <span class=\"commonness-value\">{{{{Commonness}}}}</span>\n",
    "  </div>\n",
    "{{{{/Commonness}}}}\n",
    "\n",
    "{getMeaningHTMLStringBack}\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('style.css', 'r') as f:\n",
    "    css=f.read()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "templatesArray = [ {\n",
    "    \"name\": f\"Video {str(i)}\",\n",
    "    \"qfmt\": videoFrontside(i),\n",
    "    \"afmt\": videoBackside(i)\n",
    "} for i in range(1,6) ]\n",
    "\n",
    "templatesArray.append({\n",
    "    \"name\": \"Meaning\",\n",
    "    \"qfmt\": meaningFront,\n",
    "    \"afmt\": meaningBack\n",
    "})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Erstellung des Models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "dgs_model = genanki.Model(\n",
    "  model_id = 564315,\n",
    "  name = 'DGS Model',\n",
    "  fields = [\n",
    "    {'name': 'Meaning'},\n",
    "    {'name': 'Note'},\n",
    "    {'name': 'Extra'},\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",
    "    {'name': 'Video 1 Extra'},\n",
    "    {'name': 'Video 2 Extra'},\n",
    "    {'name': 'Video 3 Extra'},\n",
    "    {'name': 'Video 4 Extra'},\n",
    "    {'name': 'Video 5 Extra'},\n",
    "    {'name': 'Video 6 Extra'},\n",
    "    {'name': 'Commonness'}\n",
    "  ],\n",
    "  templates = templatesArray,\n",
    "  css = css\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Ein Beispieldeck erzeugen"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "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",
    "           extra = '',\n",
    "           video2 = '',\n",
    "           video3 = '',\n",
    "           video4 = '',\n",
    "           video5 = '',\n",
    "           video6 = '',\n",
    "           video1t = '',\n",
    "           video2t = '',\n",
    "           video3t = '',\n",
    "           video4t = '',\n",
    "           video5t = '',\n",
    "           video6t = '',\n",
    "           video1e = '',\n",
    "           video2e = '',\n",
    "           video3e = '',\n",
    "           video4e = '',\n",
    "           video5e = '',\n",
    "           video6e = '',\n",
    "           commonness = ''):\n",
    "    return [str(meaning),\n",
    "            str(note),\n",
    "            str(extra),\n",
    "            str(video1),\n",
    "            str(video2),\n",
    "            str(video3),\n",
    "            str(video4),\n",
    "            str(video5),\n",
    "            str(video6),\n",
    "            str(video1t),\n",
    "            str(video2t),\n",
    "            str(video3t),\n",
    "            str(video4t),\n",
    "            str(video5t),\n",
    "            str(video6t),\n",
    "            str(video1e),\n",
    "            str(video2e),\n",
    "            str(video3e),\n",
    "            str(video4e),\n",
    "            str(video5e),\n",
    "            str(video6e),\n",
    "            str(commonness)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "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": 20,
   "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": 21,
   "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": 22,
   "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": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(\"entries\", \"r\", encoding=\"utf-8\") as f:\n",
    "    entrylist = \\\n",
    "      [ x[:-1].replace(\"/entry/\", \"/embed/\").split('\\t') for x in f ]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "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": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[x for x in entrylist if x[1]=='Morgen']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['21', '36', '40', '114', '132']"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "with open(\"containtext\", \"r\", encoding=\"utf-8\") as f:\n",
    "    textlist = [ x[:-1].split()[0] for x in f ]\n",
    "textlist[:5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('Schwanz',), ('Beenden',), ('Hai',), ('fröhlich',), ('malen',)]"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "entry_note_keys = list(set(map(lambda x: tuple(x[1:]), entrylist)))\n",
    "entry_note_keys[:5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Der Duden teilt Worte in 5 Häufigkeitsklassen ein. Diese wollen wir nutzen um die Worte zu sortieren.\n",
    "Leider haben nicht alle Worte Häufigkeitsinformationen. Sogar *die* nicht. Daher müssen wir hier noch nachbessern.\n",
    "Des weiteren müssen wir uns überlegen, wie wir die Häufigkeit für komplexere Übersetzungen festlegen.\n",
    "\n",
    "- Wie üblich ist *Abfahrt, Abreise*? In solchen Fällen nehmen wir die höhere Häufigkeit der beiden Worte.\n",
    "- Wie üblich ist *Immer cool bleiben*? Hier nehmen wir die niedrigste Häufigkeit aus der Liste der Worte.\n",
    "- Aber *Immer* ist nur groß geschreiben weil es am Satzanfang steht. Deswegen nehmen wir die höhere Häufigkeit aus dem groß- und dem kleingeschriebenen Wort"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def readCommonnessMap(file):\n",
    "    def parseEntry(entry):\n",
    "        key, val = entry[:-1].split(\"::\")\n",
    "\n",
    "        try: parsedVal = int(val)\n",
    "        except ValueError: parsedVal = val\n",
    "\n",
    "        return (key, parsedVal)\n",
    "\n",
    "    with open(file, \"r\", encoding=\"utf-8\") as f:\n",
    "        return dict([parseEntry(entry) for entry in f if entry.strip() != \"\"])\n",
    "\n",
    "commonnessCache = readCommonnessMap(\"commonness_cache\")\n",
    "commonnessOverride = readCommonnessMap(\"commonness_override\")\n",
    "\n",
    "def orderCommonnessMax(x):\n",
    "    if   x == \"not found\": return -1\n",
    "    elif x == \"no info\":   return  0\n",
    "    else:                  return  x\n",
    "\n",
    "def orderCommonnessMin(x):\n",
    "    if   x == \"not found\": return  11\n",
    "    elif x == \"no info\":   return  10\n",
    "    else:                  return  x\n",
    "\n",
    "def commonness(meaning):\n",
    "    override = commonnessOverride.get(meaning)\n",
    "    if override: return override\n",
    "    \n",
    "    \n",
    "    def actualWordCommonness(word):\n",
    "        if word == \"\": return \"not found\"\n",
    "        cached = commonnessOverride.get(word) or commonnessCache.get(word)\n",
    "        if cached != None: return cached\n",
    "        \n",
    "        lookupResult = max([x.frequency or \"no info\" for x in duden.search(word)],\n",
    "                           key=orderCommonnessMax,\n",
    "                           default=\"not found\")\n",
    "        \n",
    "        with open(\"commonness_cache\", \"a\", encoding=\"utf-8\") as f:\n",
    "            f.write(f\"{word}::{lookupResult}\\n\")\n",
    "        commonnessCache[word] = lookupResult\n",
    "        \n",
    "        return toReturn(lookupResult)\n",
    "\n",
    "    def wordCommonness(word):\n",
    "        cOrig = actualWordCommonness(word)\n",
    "        if cOrig != \"not found\": return cOrig\n",
    "        else: return \\\n",
    "            max([actualWordCommonness(word)\n",
    "                 for word in [word.lower(), word.capitalize()]],\n",
    "                key=orderCommonnessMax)\n",
    "\n",
    "    def phraseCommonness(phrase):\n",
    "        return min([wordCommonness(word)\n",
    "                    for word in phrase.split(\" \") if word != \"\"],\n",
    "                   key=orderCommonnessMin,\n",
    "                   default=0)\n",
    "\n",
    "    return max([phraseCommonness(phrase) for phrase in meaning.split(\",\")],\n",
    "               key=orderCommonnessMax)\n",
    "\n",
    "commonness(\"Immer cool bleiben\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Viel Spaß beim Lernen ;)'"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "with open(\"card_override.json\", \"r\", encoding=\"utf-8\") as f:\n",
    "    overrideDict = json.load(f)\n",
    "\n",
    "def overrideFunc(key):\n",
    "    dictEntry = overrideDict.get(str(key))\n",
    "    if dictEntry == None: return lambda _, given: given\n",
    "    else: return lambda field, given: \\\n",
    "        dictEntry[field] if dictEntry.get(field) != None else given\n",
    "\n",
    "overrideFunc((\"Hallo\",))(\"Video 1 Extra\", \"\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.71337890625"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def cardOrder(key):\n",
    "    h = hash(key) / 2**20\n",
    "    return orderCommonnessMax(commonness(key[0])) + (h - math.floor(h))\n",
    "\n",
    "cardOrder((\"Immer cool bleiben\",))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_deck = genanki.Deck(\n",
    "  76560167,\n",
    "  'SignDict Alles Sorted')\n",
    "allnotelist = [] # for debugging\n",
    "for key in sorted(entry_note_keys, key=cardOrder, reverse=True):\n",
    "    key_data = [x for x in entrylist if tuple(x[1:]) == key]\n",
    "    videos = [f'https://signdict.org{key_data[i][0]}' if len(key_data)>i else ''\n",
    "              for i in range (6)]\n",
    "    override = overrideFunc(key)\n",
    "    fields = noteFields(meaning = override(\"Meaning\", key_data[0][1]),\n",
    "                        note    = override(\"Note\", key_data[0][2] if len(key_data[0])>2 else ''),\n",
    "                        extra   = override(\"Extra\", \"\"),\n",
    "                        video1  = override(\"Video 1\",  videos[0]),\n",
    "                        video2  = override(\"Video 2\",  videos[1]),\n",
    "                        video3  = override(\"Video 3\",  videos[2]),\n",
    "                        video4  = override(\"Video 4\",  videos[3]),\n",
    "                        video5  = override(\"Video 5\",  videos[4]),\n",
    "                        video6  = override(\"Video 6\",  videos[5]),\n",
    "                        video1t = override(\"Video 1 contains text\", \"yes\" if videos[0].split('/')[-1] in textlist else \"\"),\n",
    "                        video2t = override(\"Video 2 contains text\", \"yes\" if videos[1].split('/')[-1] in textlist else \"\"),\n",
    "                        video3t = override(\"Video 3 contains text\", \"yes\" if videos[2].split('/')[-1] in textlist else \"\"),\n",
    "                        video4t = override(\"Video 4 contains text\", \"yes\" if videos[3].split('/')[-1] in textlist else \"\"),\n",
    "                        video5t = override(\"Video 5 contains text\", \"yes\" if videos[4].split('/')[-1] in textlist else \"\"),\n",
    "                        video6t = override(\"Video 6 contains text\", \"yes\" if videos[5].split('/')[-1] in textlist else \"\"),\n",
    "                        video1e = override(\"Video 1 Extra\", \"\"),\n",
    "                        video2e = override(\"Video 2 Extra\", \"\"),\n",
    "                        video3e = override(\"Video 3 Extra\", \"\"),\n",
    "                        video4e = override(\"Video 4 Extra\", \"\"),\n",
    "                        video5e = override(\"Video 5 Extra\", \"\"),\n",
    "                        video6e = override(\"Video 6 Extra\", \"\"),\n",
    "                        commonness = commonness(key[0]))\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": 31,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[['Hallo',\n",
       "  '',\n",
       "  '',\n",
       "  'https://signdict.org/embed/293-hallo/video/332',\n",
       "  'https://signdict.org/embed/293-hallo/video/2119',\n",
       "  'https://signdict.org/embed/293-hallo/video/4630',\n",
       "  '',\n",
       "  '',\n",
       "  '',\n",
       "  '',\n",
       "  '',\n",
       "  '',\n",
       "  '',\n",
       "  '',\n",
       "  '',\n",
       "  'Viel Spaß beim Lernen ;)',\n",
       "  '',\n",
       "  '',\n",
       "  '',\n",
       "  '',\n",
       "  '',\n",
       "  '7'],\n",
       " ['gebärden',\n",
       "  '',\n",
       "  '',\n",
       "  'https://signdict.org/embed/1719-geb%C3%A4rden/video/290',\n",
       "  'https://signdict.org/embed/1719-geb%C3%A4rden/video/291',\n",
       "  'https://signdict.org/embed/1719-geb%C3%A4rden/video/1943',\n",
       "  '',\n",
       "  '',\n",
       "  '',\n",
       "  '',\n",
       "  '',\n",
       "  '',\n",
       "  '',\n",
       "  '',\n",
       "  '',\n",
       "  'Dann mal los',\n",
       "  '',\n",
       "  '',\n",
       "  '',\n",
       "  '',\n",
       "  '',\n",
       "  '6'],\n",
       " ['noch nicht',\n",
       "  '',\n",
       "  '',\n",
       "  'https://signdict.org/embed/2617-noch-nicht/video/2940',\n",
       "  '',\n",
       "  '',\n",
       "  '',\n",
       "  '',\n",
       "  '',\n",
       "  '',\n",
       "  '',\n",
       "  '',\n",
       "  '',\n",
       "  '',\n",
       "  '',\n",
       "  '',\n",
       "  '',\n",
       "  '',\n",
       "  '',\n",
       "  '',\n",
       "  '',\n",
       "  '5']]"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "allnotelist[:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "genanki.Package(my_deck).write_to_file('Custom Decks/2 SignDictAllesSorted.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": 33,
   "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": 34,
   "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": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "someset[:10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('Morgen', 'Tageszeit'), ('Morgen', 'kommender Tag')]"
      ]
     },
     "execution_count": 35,
     "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": 36,
   "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": 37,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(['a', 'b', 'c', 'd', 'e'], '...', ['9', '9', 'ä', 'ö', 'ü'])"
      ]
     },
     "execution_count": 37,
     "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": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(29, ['a', 'b', 'c'], '...', ['ä', 'ö', 'ü'])"
      ]
     },
     "execution_count": 38,
     "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": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(30, ['a', 'b', 'c'], '...', ['ä', 'ö', 'ü'])"
      ]
     },
     "execution_count": 39,
     "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": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('a',), ('b',), ('c',), ('d',), ('e',)]"
      ]
     },
     "execution_count": 40,
     "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": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "createDeck('Fingeralphabet', '3 Fingeralphabet', letterkeys)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Beispiel: Zahlen von 1 bis 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(16, ['1', '1', '10'], '...', ['8', '9', '9'])"
      ]
     },
     "execution_count": 42,
     "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": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['1', '10', '2', '3', '4', '5', '6', '7', '8', '9']"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(sorted(set(numberentries)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Gut, das wollen wir"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "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": 44,
     "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": 45,
   "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": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(82, ['0', '1', '1'], '...', ['9', '90', '90'])"
      ]
     },
     "execution_count": 46,
     "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": 47,
   "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": 47,
     "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": 48,
   "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": 49,
   "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": 50,
   "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 gefunden in: [\"['Übelkeit']\"]\n",
      "_____________\n",
      "'Kopfschmerzen' -> [\"['Kopfschmerzen']\"]\n",
      "_____________\n",
      "'Schwindel' wurde nicht gefunden\n",
      "_____________\n",
      "'mittel' wurde gefunden in: [\"['Lebensmittel']\", \"['Mittelalter']\", \"['Mittelfeld']\", \"['Mittelfinger']\", \"['Mittelmeer']\", \"['Nahrungsmittel']\", \"['öffentliche Verkehrsmittel']\"]\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": 51,
   "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": 52,
   "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": 53,
   "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": 54,
   "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": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "_____________\n",
      "'frisch' -> [\"['frisch']\"]\n"
     ]
    }
   ],
   "source": [
    "zusatzVocab = 'frisch'\n",
    "getResults(zusatzVocab)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "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": 57,
   "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": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('ich',), ('Du',), ('du',), ('er',), ('sie',), '...']"
      ]
     },
     "execution_count": 58,
     "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": 59,
   "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.8.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}