file cleaning

data/wordle_humans.csv

@@ -1,40 +0,0 @@
-player,target,first_guess,second_guess,third_guess,fourth_guess,fifth_guess,sixth_guess
-human,vague,arose,plate,cache,mauve,vague,none
-human,apple,douce,lairy,slave,algae,apple,none
-human,ninth,douce,lairy,gimps,ninth,none,none
-human,flail,douce,lairy,snail,flail,none,none
-human,stage,douce,lairy,phase,stage,none,none
-human,heady,douce,lairy,ready,beady,heady,none
-human,none,douce,dairy,dunes,debug,none,none
-human,usage,douce,lairy,aunts,swamp,usage,none
-human,sound,douce,pound,found,bound,mound,sound
-human,salsa,douce,lairy,palms,salts,ghost,salsa
-human,magic,douce,lairy,cabin,manic,magic,none
-human,none,douce,lairy,cache,none,none,none
-human,avail,douce,lairy,snail,flail,avail,none
-human,kiosk,douce,lairy,lions,moist,frosh,kiosk
-human,sweat,douce,lairy,wheat,sweat,none,none
-human,ruddy,douce,lairy,ruddy,none,none,none
-human,riper,douce,lairy,tries,miner,viper,wiper
-human,vague,douce,lairy,mauve,vague,none,none
-human,syrup,arose,unity,rubby,syrup,none,none
-human,above,adore,above,none,none,none,none
-human,moose,arose,those,close,unity,moose,none
-human,polka,arose,unity,polar,polka,none,none
-human,syrup,audio,plume,usurp,syrup,none,none
-human,worse,audio,store,horse,worse,none,none
-human,worse,audio,stone,posse,worse,none,none
-human,polka,audio,polar,polka,none,none,none
-human,polka,audio,groan,poach,polka,none,none
-human,moose,audio,store,chose,loose,goose,moose
-human,moose,audio,store,close,moose,none,none
-human,squat,homes,start,squat,none,none,none
-human,above,audio,alone,above,none,none,none
-human,squat,audio,usual,squat,none,none,none
-human,squat,audio,taupe,squat,none,none,none
-human,Trend,Audio,Nerdy,Trend,none,none,none
-human,Trend,Audio,Depth,Trend,none,none,none
-human,Trend,Later,Rents,Trend,none,none,none
-human,toxic,Later,throw,toxic,none,none,none
-human,toxic,AUDIO,CHOIR,toxic,none,none,none
-human,toxic,audio,movie,colic,robin,toxic,none

wordle_testing.ipynb

@@ -1,1654 +0,0 @@
-{
- "cells": [
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Imports"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import numpy as np\n",
-    "import random\n",
-    "import operator\n",
-    "import time\n",
-    "import pandas as pd\n",
-    "from wordle_functions import *"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Importing datasets"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### official words\n",
-    "- official wordle word list"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "2310\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "['wince', 'thyme', 'mower', 'horde', 'heard']"
-      ]
-     },
-     "execution_count": 2,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "### Official list\n",
-    "official_words = []\n",
-    "\n",
-    "with open(\"data/official_words_processed.txt\", \"r\", encoding = \"utf-8\") as f:\n",
-    "    for word in f.read().split(\"\\n\"):\n",
-    "        official_words.append(word)\n",
-    "\n",
-    "f.close() # closes connection to file\n",
-    "\n",
-    "print(len(official_words))\n",
-    "official_words[:5]"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### alternative list 1\n",
-    "- an alternate list of 5-letter words found on the web"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [
-    {
-     "ename": "FileNotFoundError",
-     "evalue": "[Errno 2] No such file or directory: 'data/alt_words_1.txt'",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[0;31mFileNotFoundError\u001b[0m                         Traceback (most recent call last)",
-      "\u001b[1;32m/Users/kmaurinjones/Desktop/data_science/data_science_projects/wordle_wizard/wordle_testing.ipynb Cell 7\u001b[0m in \u001b[0;36m<cell line: 4>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      <a href='vscode-notebook-cell:/Users/kmaurinjones/Desktop/data_science/data_science_projects/wordle_wizard/wordle_testing.ipynb#W6sZmlsZQ%3D%3D?line=0'>1</a>\u001b[0m \u001b[39m### Official list\u001b[39;00m\n\u001b[1;32m      <a href='vscode-notebook-cell:/Users/kmaurinjones/Desktop/data_science/data_science_projects/wordle_wizard/wordle_testing.ipynb#W6sZmlsZQ%3D%3D?line=1'>2</a>\u001b[0m alt_words_1 \u001b[39m=\u001b[39m []\n\u001b[0;32m----> <a href='vscode-notebook-cell:/Users/kmaurinjones/Desktop/data_science/data_science_projects/wordle_wizard/wordle_testing.ipynb#W6sZmlsZQ%3D%3D?line=3'>4</a>\u001b[0m \u001b[39mwith\u001b[39;00m \u001b[39mopen\u001b[39;49m(\u001b[39m\"\u001b[39;49m\u001b[39mdata/alt_words_1.txt\u001b[39;49m\u001b[39m\"\u001b[39;49m, \u001b[39m\"\u001b[39;49m\u001b[39mr\u001b[39;49m\u001b[39m\"\u001b[39;49m, encoding \u001b[39m=\u001b[39;49m \u001b[39m\"\u001b[39;49m\u001b[39mutf-8\u001b[39;49m\u001b[39m\"\u001b[39;49m) \u001b[39mas\u001b[39;00m f:\n\u001b[1;32m      <a href='vscode-notebook-cell:/Users/kmaurinjones/Desktop/data_science/data_science_projects/wordle_wizard/wordle_testing.ipynb#W6sZmlsZQ%3D%3D?line=4'>5</a>\u001b[0m     \u001b[39mfor\u001b[39;00m word \u001b[39min\u001b[39;00m f\u001b[39m.\u001b[39mread()\u001b[39m.\u001b[39msplit(\u001b[39m\"\u001b[39m\u001b[39m\\n\u001b[39;00m\u001b[39m\"\u001b[39m):\n\u001b[1;32m      <a href='vscode-notebook-cell:/Users/kmaurinjones/Desktop/data_science/data_science_projects/wordle_wizard/wordle_testing.ipynb#W6sZmlsZQ%3D%3D?line=5'>6</a>\u001b[0m         alt_words_1\u001b[39m.\u001b[39mappend(word)\n",
-      "\u001b[0;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: 'data/alt_words_1.txt'"
-     ]
-    }
-   ],
-   "source": [
-    "### Official list\n",
-    "alt_words_1 = []\n",
-    "\n",
-    "with open(\"data/alt_words_1.txt\", \"r\", encoding = \"utf-8\") as f:\n",
-    "    for word in f.read().split(\"\\n\"):\n",
-    "        alt_words_1.append(word)\n",
-    "\n",
-    "f.close() # closes connection to file\n",
-    "\n",
-    "print(len(alt_words_1))\n",
-    "alt_words_1[:5]"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### nltk grand corpus\n",
-    "- Amalgamation of all words in various NLTK corpora to have as big a dataset as possible\n",
-    "- Developed manually"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "### grand corpus tokens\n",
-    "nltk_tokens = []\n",
-    "\n",
-    "with open(\"data/nltk_grand_corpus_tokens_5.txt\", \"r\", encoding = \"utf-8\") as f:\n",
-    "    for word in f.read().split(\"\\n\"):\n",
-    "        nltk_tokens.append(word)\n",
-    "\n",
-    "f.close() # closes connection to file\n",
-    "\n",
-    "print(len(nltk_tokens))\n",
-    "nltk_tokens[:5]"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### nltk grand corpus types and counts"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "### grand corpus types and counts\n",
-    "nltk_counts = {}\n",
-    "\n",
-    "with open(\"data/nltk_grand_corpus_types_and_counts_5.txt\", \"r\", encoding = \"utf-8\") as f:\n",
-    "    for line in f.read().split(\"\\n\"):\n",
-    "        if len(line.split(\"\\t\")) == 2:\n",
-    "            word = line.split(\"\\t\")[0]\n",
-    "            count = line.split(\"\\t\")[1]\n",
-    "            nltk_counts[word] = count\n",
-    "        else:\n",
-    "            continue\n",
-    "\n",
-    "f.close() # closes connection to file\n",
-    "\n",
-    "print(len(nltk_counts))\n",
-    "nltk_counts['which']"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "### Official list\n",
-    "official_words = []\n",
-    "\n",
-    "with open(\"data/official_words_processed.txt\", \"r\", encoding = \"utf-8\") as f:\n",
-    "    for word in f.read().split(\"\\n\"):\n",
-    "        if len(word) > 0: # there's one blank entry at the start\n",
-    "            official_words.append(word)\n",
-    "\n",
-    "f.close() # closes connection to file\n",
-    "\n",
-    "print(len(official_words))\n",
-    "official_words[:10]"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Wordle functions + Testing"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Testing `wordle_wizard()`"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 13,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "-----------------------------\n",
-      "\n",
-      "Guess 1: 'poesy'\n",
-      "Letters in correct positions:\n",
-      "\t[]\n",
-      "\n",
-      "Letters in incorrect positions:\n",
-      "\t[('e', 2)]\n",
-      "\n",
-      "Letters to guess again:\n",
-      "\t['e']\n",
-      "\n",
-      "Letters to not guess again:\n",
-      "\t['o', 'p', 's', 'y']\n",
-      "\n",
-      "At this point:\n",
-      "\t1905, 82.47% of total words have been eliminated, and\n",
-      "\t405, 17.53% of total words remain possible.\n",
-      "\n",
-      "The top 40 potential next guesses are:\n",
-      "\t[('alter', 100.0), ('later', 100.0), ('irate', 98.33), ('renal', 94.34), ('learn', 94.34), ('react', 91.3), ('crate', 91.3), ('trace', 91.3), ('cater', 91.3), ('trade', 88.34), ('leant', 88.3), ('heart', 88.13), ('earth', 88.13), ('hater', 88.13), ('aider', 86.22), ('alien', 86.18), ('crane', 85.68), ('tamer', 85.55), ('grate', 85.35), ('realm', 85.1), ('regal', 84.89), ('glare', 84.89), ('lager', 84.89), ('large', 84.89), ('eclat', 84.76), ('blare', 83.81), ('baler', 83.81), ('inter', 83.81), ('liner', 83.35), ('after', 82.43), ('flare', 81.93), ('feral', 81.93), ('delta', 81.81), ('dealt', 81.81), ('taker', 81.72), ('lathe', 81.6), ('water', 81.14), ('trice', 80.31), ('afire', 80.31), ('ramen', 79.93)]\n",
-      "\n",
-      "Words guessed so far:\n",
-      "\t['poesy'].\n",
-      "\n",
-      "Next guess:\n",
-      "\t'alter'\n",
-      "\n",
-      "-----------------------------\n",
-      "\n",
-      "Guess 2: 'alter'\n",
-      "Letters in correct positions:\n",
-      "\t[]\n",
-      "\n",
-      "Letters in incorrect positions:\n",
-      "\t[('a', 0), ('e', 2), ('t', 2), ('e', 3), ('r', 4)]\n",
-      "\n",
-      "Letters to guess again:\n",
-      "\t['a', 'e', 'r', 't']\n",
-      "\n",
-      "Letters to not guess again:\n",
-      "\t['l', 'o', 'p', 's', 'y']\n",
-      "\n",
-      "At this point:\n",
-      "\t2301, 99.61% of total words have been eliminated, and\n",
-      "\t9, 0.39% of total words remain possible.\n",
-      "\n",
-      "All potential next guesses:\n",
-      "\t[('irate', 100.0), ('crate', 70.91), ('trace', 70.91), ('react', 70.91), ('trade', 58.69), ('heart', 57.83), ('earth', 57.83), ('grate', 46.3), ('terra', 0.0)]\n",
-      "\n",
-      "Words guessed so far:\n",
-      "\t['poesy', 'alter'].\n",
-      "\n",
-      "Next guess:\n",
-      "\t'irate'\n",
-      "\n",
-      "-----------------------------\n",
-      "\n",
-      "Guess 3: 'irate'\n",
-      "Letters in correct positions:\n",
-      "\t[('r', 1), ('a', 2), ('t', 3), ('e', 4)]\n",
-      "\n",
-      "Letters in incorrect positions:\n",
-      "\t[('a', 0), ('e', 2), ('t', 2), ('e', 3), ('r', 4)]\n",
-      "\n",
-      "Letters to guess again:\n",
-      "\t['a', 'e', 'r', 't']\n",
-      "\n",
-      "Letters to not guess again:\n",
-      "\t['i', 'l', 'o', 'p', 's', 'y']\n",
-      "\n",
-      "At this point:\n",
-      "\t2308, 99.91% of total words have been eliminated, and\n",
-      "\t2, 0.09% of total words remain possible.\n",
-      "\n",
-      "All potential next guesses:\n",
-      "\t[('crate', 100.0), ('grate', 0.0)]\n",
-      "\n",
-      "Words guessed so far:\n",
-      "\t['poesy', 'alter', 'irate'].\n",
-      "\n",
-      "Next guess:\n",
-      "\t'crate'\n",
-      "\n",
-      "-----------------------------\n",
-      "\n",
-      "Guess 4: 'crate'\n",
-      "Letters in correct positions:\n",
-      "\t[('r', 1), ('a', 2), ('t', 3), ('e', 4)]\n",
-      "\n",
-      "Letters in incorrect positions:\n",
-      "\t[('a', 0), ('e', 2), ('t', 2), ('e', 3), ('r', 4)]\n",
-      "\n",
-      "Letters to guess again:\n",
-      "\t['a', 'e', 'r', 't']\n",
-      "\n",
-      "Letters to not guess again:\n",
-      "\t['c', 'i', 'l', 'o', 'p', 's', 'y']\n",
-      "\n",
-      "At this point:\n",
-      "\t2309, 99.96% of total words have been eliminated, and\n",
-      "\t1, 0.04% of total words remain possible.\n",
-      "\n",
-      "The only remaining possible word is:\n",
-      "\t'grate'\n",
-      "\n",
-      "Next guess:\n",
-      "\t'grate'\n",
-      "\n",
-      "-----------------------------\n",
-      "\n",
-      "Guess 5: 'grate'\n",
-      "\n",
-      "Congratulations! The Wordle has been solved in 5 guesses!\n",
-      "There were still 1 guesses remaining.\n",
-      "\n",
-      "The target word was 'grate'.\n",
-      "\n",
-      "-----------------------------\n"
-     ]
-    }
-   ],
-   "source": [
-    "test_1 = wordle_wizard(word_list = official_words, max_guesses = 6, \n",
-    "                guess = \"paint\", target = \"force\",\n",
-    "                random_guess = True, random_target = True, \n",
-    "                verbose = True, drama = 0, return_stats = False, record = False)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "for val in [False, True]:\n",
-    "        wordle_wizard(word_list = official_words, max_guesses = 6, \n",
-    "                guess = \"arose\", target = \"syrup\", bias = 'entropy', \n",
-    "                random_guess = False, random_target = False, \n",
-    "                verbose = val, drama = 0, return_stats = False, record = True)"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Testing on 3-letter words"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "### 3 letters\n",
-    "words_3_letters = []\n",
-    "words_3_types_counts = {}\n",
-    "\n",
-    "with open(\"data/nltk_grand_corpus_types_and_counts_3.txt\", \"r\", encoding = \"utf-8\") as f:\n",
-    "    for line in f.read().split(\"\\n\"):\n",
-    "        word_freq = line.split(\"\\t\")\n",
-    "        if len(word_freq) == 2: # how many items are in each line, NOT the len of the word in the line\n",
-    "            word = word_freq[0]\n",
-    "            freq = word_freq[1]\n",
-    "            if word.isascii() == True:\n",
-    "                words_3_letters.append(word)\n",
-    "                words_3_types_counts[word] = freq\n",
-    "\n",
-    "f.close() # closes connection to file\n",
-    "\n",
-    "print(len(words_3_letters))\n",
-    "print(words_3_letters[:5])\n",
-    "words_3_types_counts['the']"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "for val in [False, True]:\n",
-    "        wordle_wizard(word_list = words_3_letters, max_guesses = 6, \n",
-    "                guess = \"the\", target = \"his\", bias = 'entropy', \n",
-    "                random_guess = False, random_target = False, \n",
-    "                verbose = val, drama = 0, return_stats = False, record = True)"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Testing on 4-letter words"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "### 3 letters\n",
-    "words_4_letters = []\n",
-    "words_4_types_counts = {}\n",
-    "\n",
-    "with open(\"data/nltk_grand_corpus_types_and_counts_4.txt\", \"r\", encoding = \"utf-8\") as f:\n",
-    "    for line in f.read().split(\"\\n\"):\n",
-    "        word_freq = line.split(\"\\t\")\n",
-    "        if len(word_freq) == 2: # how many items are in each line, NOT the len of the word in the line\n",
-    "            word = word_freq[0]\n",
-    "            freq = word_freq[1]\n",
-    "            if word.isascii() == True:\n",
-    "                words_4_letters.append(word)\n",
-    "                words_4_types_counts[word] = freq\n",
-    "\n",
-    "f.close() # closes connection to file\n",
-    "\n",
-    "print(len(words_4_letters))\n",
-    "print(words_4_letters[:5])\n",
-    "words_4_types_counts['that']"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "for val in [False, True]:\n",
-    "        wordle_wizard(word_list = words_4_letters, max_guesses = 6, \n",
-    "                guess = \"have\", target = \"this\", bias = 'entropy', \n",
-    "                random_guess = False, random_target = False, \n",
-    "                verbose = val, drama = 0, return_stats = False, record = True)"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Testing on 6-letter words"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "### 6 letters\n",
-    "words_6_letters = []\n",
-    "words_6_types_counts = {}\n",
-    "\n",
-    "with open(\"data/nltk_grand_corpus_types_and_counts_6.txt\", \"r\", encoding = \"utf-8\") as f:\n",
-    "    for line in f.read().split(\"\\n\"):\n",
-    "        word_freq = line.split(\"\\t\")\n",
-    "        if len(word_freq) == 2: # how many items are in each line, NOT the len of the word in the line\n",
-    "            word = word_freq[0]\n",
-    "            freq = word_freq[1]\n",
-    "            if word.isascii() == True:\n",
-    "                words_6_letters.append(word)\n",
-    "                words_6_types_counts[word] = freq\n",
-    "\n",
-    "f.close() # closes connection to file\n",
-    "\n",
-    "print(len(words_6_letters))\n",
-    "print(words_6_letters[:5])\n",
-    "words_6_types_counts[words_6_letters[0]]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "for val in [False, True]:\n",
-    "        wordle_wizard(word_list = words_6_letters, max_guesses = 6, \n",
-    "                guess = \"little\", target = \"before\", bias = 'entropy', \n",
-    "                random_guess = False, random_target = False, \n",
-    "                verbose = val, drama = 0, return_stats = False, record = True)"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Testing on 7-letter words"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "### 7 letters\n",
-    "words_7_letters = []\n",
-    "words_7_types_counts = {}\n",
-    "\n",
-    "with open(\"data/nltk_grand_corpus_types_and_counts_7.txt\", \"r\", encoding = \"utf-8\") as f:\n",
-    "    for line in f.read().split(\"\\n\"):\n",
-    "        word_freq = line.split(\"\\t\")\n",
-    "        if len(word_freq) == 2: # how many items are in each line, NOT the len of the word in the line\n",
-    "            word = word_freq[0]\n",
-    "            freq = word_freq[1]\n",
-    "            if word.isascii() == True:\n",
-    "                words_7_letters.append(word)\n",
-    "                words_7_types_counts[word] = freq\n",
-    "\n",
-    "f.close() # closes connection to file\n",
-    "\n",
-    "print(len(words_7_letters))\n",
-    "print(words_7_letters[:5])\n",
-    "words_7_types_counts[words_7_letters[0]]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "for val in [False, True]:\n",
-    "        wordle_wizard(word_list = words_7_letters, max_guesses = 6, \n",
-    "                guess = \"because\", target = \"through\", bias = 'entropy', \n",
-    "                random_guess = True, random_target = True, \n",
-    "                verbose = val, drama = 0, return_stats = False, record = True)"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Testing on 8-letter words"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "### 8 letters\n",
-    "words_8_letters = []\n",
-    "words_8_types_counts = {}\n",
-    "\n",
-    "with open(\"data/nltk_grand_corpus_types_and_counts_8.txt\", \"r\", encoding = \"utf-8\") as f:\n",
-    "    for line in f.read().split(\"\\n\"):\n",
-    "        word_freq = line.split(\"\\t\")\n",
-    "        if len(word_freq) == 2: # how many items are in each line, NOT the len of the word in the line\n",
-    "            word = word_freq[0]\n",
-    "            freq = word_freq[1]\n",
-    "            if word.isascii() == True:\n",
-    "                words_8_letters.append(word)\n",
-    "                words_8_types_counts[word] = freq\n",
-    "\n",
-    "f.close() # closes connection to file\n",
-    "\n",
-    "print(len(words_8_letters))\n",
-    "print(words_8_letters[:5])\n",
-    "words_8_types_counts[words_8_letters[0]]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "for val in [False, True]:\n",
-    "        wordle_wizard(word_list = words_8_letters, max_guesses = 6, \n",
-    "                guess = \"trinidad\", target = \"together\", bias = 'entropy', \n",
-    "                random_guess = False, random_target = False, \n",
-    "                verbose = val, drama = 0, return_stats = False, record = True)"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Testing on 9-letter words"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "### 9 letters\n",
-    "words_9_letters = []\n",
-    "words_9_types_counts = {}\n",
-    "\n",
-    "with open(\"data/nltk_grand_corpus_types_and_counts_9.txt\", \"r\", encoding = \"utf-8\") as f:\n",
-    "    for line in f.read().split(\"\\n\"):\n",
-    "        word_freq = line.split(\"\\t\")\n",
-    "        if len(word_freq) == 2: # how many items are in each line, NOT the len of the word in the line\n",
-    "            word = word_freq[0]\n",
-    "            freq = word_freq[1]\n",
-    "            if word.isascii() == True:\n",
-    "                words_9_letters.append(word)\n",
-    "                words_9_types_counts[word] = freq\n",
-    "\n",
-    "f.close() # closes connection to file\n",
-    "\n",
-    "print(len(words_9_letters))\n",
-    "print(words_9_letters[:5])\n",
-    "words_9_types_counts[words_9_letters[0]]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "for val in [False, True]:\n",
-    "        wordle_wizard(word_list = words_9_letters, max_guesses = 6, \n",
-    "                guess = \"something\", target = \"character\", bias = 'entropy', \n",
-    "                random_guess = True, random_target = False, \n",
-    "                verbose = val, drama = 0, return_stats = False, record = True)"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Testing on 10-letter words"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "### 10 letters\n",
-    "words_10_letters = []\n",
-    "words_10_types_counts = {}\n",
-    "\n",
-    "with open(\"data/nltk_grand_corpus_types_and_counts_10.txt\", \"r\", encoding = \"utf-8\") as f:\n",
-    "    for line in f.read().split(\"\\n\"):\n",
-    "        word_freq = line.split(\"\\t\")\n",
-    "        if len(word_freq) == 2: # how many items are in each line, NOT the len of the word in the line\n",
-    "            word = word_freq[0]\n",
-    "            freq = word_freq[1]\n",
-    "            if word.isascii() == True:\n",
-    "                words_10_letters.append(word)\n",
-    "                words_10_types_counts[word] = freq\n",
-    "\n",
-    "f.close() # closes connection to file\n",
-    "\n",
-    "print(len(words_10_letters))\n",
-    "print(words_10_letters[:5])\n",
-    "words_10_types_counts[words_10_letters[0]]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "for val in [False, True]:\n",
-    "        wordle_wizard(word_list = words_10_letters, max_guesses = 6, \n",
-    "                guess = \"characters\", target = \"theologies\", bias = 'entropy', \n",
-    "                random_guess = True, random_target = False, \n",
-    "                verbose = val, drama = 0, return_stats = False, record = True)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "wordle_wizard(word_list = official_words, max_guesses = 5, \n",
-    "                guess = \"quote\", target = \"silly\", bias = 'entropy', \n",
-    "                random_guess = False, random_target = False, \n",
-    "                verbose = True, drama = 0, return_stats = False, record = False)"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### `compare_wordle()` testing"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "df = pd.read_csv(\"compared_data/wordle_humans - Sheet1.csv\")\n",
-    "print(df.shape)\n",
-    "df"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "df = pd.read_csv(\"compared_data/wordle_humans - Sheet1.csv\")\n",
-    "df\n",
-    "convert_row(df, 37)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "### TESTING DF INTERPRETATION\n",
-    "\n",
-    "df = pd.read_csv(\"compared_data/wordle_humans - Sheet1.csv\")\n",
-    "\n",
-    "row = 37\n",
-    "\n",
-    "print(convert_row(df, row))\n",
-    "player = convert_row(df, row)[0]\n",
-    "target_word = convert_row(df, row)[1]\n",
-    "guess_list = convert_row(df, row)[2]\n",
-    "\n",
-    "compare_wordle(word_list = official_words, max_guesses = 6, \n",
-    "                    guess_list = guess_list, player = player, target = target_word,\n",
-    "                    verbose = False, return_stats = True, record = False)"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Comparing player solutions against wizard solutions"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def create_compared_df(player_df, to_csv: bool = False, show_shapes: bool = False):\n",
-    "    \"\"\"\n",
-    "    Creates master df of player wordle scores compared to how wordle_wizard would perform on the same puzzles\n",
-    "\n",
-    "    Parameters:\n",
-    "    -----\n",
-    "    `player_df`: Pandas dataFrame object\n",
-    "        df of player scores of wordle puzzles\n",
-    "    `to_csv`: bool\n",
-    "        If True, writes returned df to csv\n",
-    "    `show_shapes`: bool\n",
-    "        If True, prints shape of new df before and after deleting duplicate rows (created by wordle_wizard running the same puzzles multiple times)\n",
-    "    \n",
-    "    Returns:\n",
-    "    -----\n",
-    "    `df_master`: Pandas dataFrame object\n",
-    "        df of player scores and wordle_wizard scores of wordle puzzles\n",
-    "    \"\"\"\n",
-    "\n",
-    "    stats_master = {}\n",
-    "    excepts = []\n",
-    "    for row in player_df.index:\n",
-    "        player = convert_row(player_df, row)[0]\n",
-    "        target_word = convert_row(player_df, row)[1]\n",
-    "        guess_list = convert_row(player_df, row)[2]\n",
-    "        try:\n",
-    "            complete = compare_wordle(word_list = official_words, max_guesses = 6, \n",
-    "                        guess_list = guess_list, player = player, target = target_word,\n",
-    "                        verbose = True, return_stats = True, record = False)\n",
-    "            for metric, results in complete.items():\n",
-    "                if metric in stats_master:\n",
-    "                    for result in results:\n",
-    "                        stats_master[metric].append(result)\n",
-    "                else:\n",
-    "                    stats_master[metric] = []\n",
-    "                    for result in results:\n",
-    "                        stats_master[metric].append(result)\n",
-    "        except:\n",
-    "            AttributeError\n",
-    "            excepts.append(guess_list)\n",
-    "\n",
-    "    df_master = pd.DataFrame(stats_master)\n",
-    "    print(df_master.columns.tolist())\n",
-    "\n",
-    "    # Re-organizing columns to a more logical order (for viewing)\n",
-    "    df_master = df_master[['first_guess', 'target_word', 'player', 'num_guesses', 'expected_guesses', 'luck', 'first_guess_vowels', 'first_guess_consonants',\n",
-    "                        'target_vowels', 'target_consonants', 'first_guess_entropy', 'target_entropy',\n",
-    "                        'target_guessed', 'mid_guesses_avg_vows', 'mid_guesses_avg_cons', 'avg_perf_letters',\n",
-    "                        'avg_wrong_pos_letters', 'avg_wrong_letters', 'avg_remaining', 'avg_intermediate_guess_entropy',\n",
-    "                        'valid_success']]\n",
-    "\n",
-    "    # print(excepts)\n",
-    "    if show_shapes == True:\n",
-    "        print(df_master.shape) # check shape before deleting dups\n",
-    "\n",
-    "    # Delete duplicate rows (some created by process)\n",
-    "    df_master.drop_duplicates(inplace = True)\n",
-    "    \n",
-    "    if to_csv == True:\n",
-    "        df_master.to_csv('compared_data/players_compared.csv') # write new data to csv\n",
-    "    \n",
-    "    if show_shapes == True:\n",
-    "        print(df_master.shape) # check shape after deleting dups\n",
-    "    \n",
-    "    return df_master.reset_index().drop(columns = \"index\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "test_word = \"test 1 \"\n",
-    "test_word.strip().lower()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "df = pd.read_csv(\"compared_data/wordle_humans - Sheet1.csv\")\n",
-    "\n",
-    "df_master = create_compared_df(df, to_csv = True, show_shapes = True)\n",
-    "df_master"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "print(df_master.query(\"player == 'aidan'\")['num_guesses'].mean())\n",
-    "print(df_master.query(\"player == 'aidan'\").shape)\n",
-    "df_master.query(\"player == 'aidan'\").head()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "print(df_master.query(\"player == 'dad'\")['num_guesses'].mean())\n",
-    "print(df_master.query(\"player == 'dad'\").shape)\n",
-    "df_master.query(\"player == 'dad'\").head()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "print(df_master.query(\"player == 'diane'\")['num_guesses'].mean())\n",
-    "print(df_master.query(\"player == 'diane'\").shape)\n",
-    "df_master.query(\"player == 'diane'\").head()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "print(df_master.query(\"player == 'wizard'\")['num_guesses'].mean())\n",
-    "print(df_master.query(\"player == 'wizard'\").shape)\n",
-    "df_master.query(\"player == 'wizard'\").head(40)"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Prefix/Suffix bias"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def get_gram_freq(word_list: list, letters_length: int = 2, position: bool = \"start\", search: any = None):\n",
-    "    \"\"\"\n",
-    "    Given a word list, a selected number of letter, a selected word position to start from (\"start\" or \"end\"),\n",
-    "    and an optional gram to search within the list, this function will get a frequency distribution of all n-grams\n",
-    "    from the passed word list and returned a frequency distribution in descending order.\n",
-    "\n",
-    "    Parameters:\n",
-    "    ------\n",
-    "    `word_list`: list\n",
-    "        list of words of the same \n",
-    "    `letters_length`: int\n",
-    "        number of letters in succession. Size/length of \"gram\". Must be between 1 and length of words in word list\n",
-    "    `position`: bool\n",
-    "        Whether to start the gram from the start of the word (like a prefix) or the end of the word (like a suffix)\n",
-    "    `search`: str\n",
-    "        If != None, string of characters to search for within the generated list. If string not found in list, function will print an error message.\n",
-    "\n",
-    "    Returns:\n",
-    "    ------\n",
-    "    `tup`: tuple\n",
-    "        If search != None, will return a tuple with the passed search criteria, and its count\n",
-    "    `sorted_gram_list`: list\n",
-    "        List of tuples in the form of (gram, count) for each combination of the gram size in the pass word_list\n",
-    "    \"\"\"\n",
-    "\n",
-    "    gram_freq_dist = {}\n",
-    "\n",
-    "    for word in word_list:\n",
-    "        if position == \"start\":\n",
-    "            gram = word[:letters_length] # first 2 letters\n",
-    "        if position == \"end\":\n",
-    "            gram = word[-(letters_length):] # first 2 letters\n",
-    "\n",
-    "        if gram not in gram_freq_dist:\n",
-    "            gram_freq_dist[gram] = 1\n",
-    "        else:\n",
-    "            gram_freq_dist[gram] += 1\n",
-    "\n",
-    "    sorted_gram_dist = sorted(gram_freq_dist.items(), key = operator.itemgetter(1), reverse = True)\n",
-    "\n",
-    "    if search:\n",
-    "        nos = []\n",
-    "        for tup in sorted_gram_dist:\n",
-    "            if tup[0] == search:\n",
-    "                return tup\n",
-    "            else:\n",
-    "                nos.append(\"not here\")\n",
-    "        \n",
-    "        if len(nos) == len(sorted_gram_dist):\n",
-    "            print (\"Search criteria not found in list. Please enter a gram from within the list.\")\n",
-    "    else:\n",
-    "        return sorted_gram_dist\n",
-    "\n",
-    "get_gram_freq(word_list = official_words, letters_length = 2, position = \"start\", search = None)[:10]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "test_starts = get_gram_freq(word_list = official_words, letters_length = 2, position = \"start\", search = None)[:10]\n",
-    "test_ends = get_gram_freq(word_list = official_words, letters_length = 2, position = \"end\", search = None)[:10]\n",
-    "\n",
-    "test_words = official_words\n",
-    "\n",
-    "for start_gram, start_count in test_starts:\n",
-    "    for end_gram, end_count in test_ends:\n",
-    "        for word in [\"natal\", 'fatal']:\n",
-    "        # for word in test_words:\n",
-    "            if word[:2] == start_gram and word[-2:] == end_gram:\n",
-    "                print (word, start_gram, end_gram)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def wordle_wizard(word_list: list, max_guesses: int = None, \n",
-    "                  guess: str = None, target: str = None,\n",
-    "                  random_guess: bool = False, random_target: bool = False, \n",
-    "                  verbose: bool = False, drama: float = None, \n",
-    "                  return_stats: bool = False, record: bool = False, hf_mod: bool = True):\n",
-    "    \"\"\"\n",
-    "    Mimicking the popular web game, this function matches a current word to a target word automatically, in the most statistically optimal way possible.\n",
-    "\n",
-    "    Parameters:\n",
-    "    ------\n",
-    "    `word_list`: list\n",
-    "        list of valid words to be considered\n",
-    "    `guess`: str\n",
-    "        a string -- must be the same length as `target_word`\n",
-    "    `target`: str\n",
-    "        a string -- must be the same length as `opening_word`\n",
-    "    `max_guesses`: int\n",
-    "        the maximum number of attempts allowed to solve the Wordle\n",
-    "    `random_guess`: bool\n",
-    "        if True, randomly chooses a starting word from all words within `word_list`. If False, passed starting word must be used instead\n",
-    "    `random_target`: bool\n",
-    "        if True, randomly chooses a target word from all words within `word_list`. If False, passed target word must be used instead\n",
-    "    `verbose`: bool\n",
-    "        if True, prints progress and explanation of how function solves the puzzle. If False, prints only the guessed word at each guess.\n",
-    "    `drama`: float or int\n",
-    "        if int provided, each guess' output is delayed by that number of seconds, else each output is shown as quickly as possible. For ~dRaMaTiC eFfEcT~\n",
-    "    `return_stats`: bool\n",
-    "        if True, prints nothing and returns a dictionary of various statistics about the function's performance trying to solve the puzzle\n",
-    "    `record`: bool\n",
-    "        if True, creates a .txt file with the same information printed according to the indicated verbosity\n",
-    "\n",
-    "    Returns:\n",
-    "    ------\n",
-    "    `stats_dict`: dict\n",
-    "        dictionary containing various statistics about the function's performance trying to solve the puzzle\n",
-    "    \"\"\"\n",
-    "\n",
-    "    guess = guess.lower()\n",
-    "    target = target.lower()\n",
-    "\n",
-    "    sugg_words = []\n",
-    "\n",
-    "    for i in range(0, 20):\n",
-    "        ran_int = random.randint(0, len(word_list) - 1)\n",
-    "        word = word_list[ran_int]\n",
-    "        sugg_words.append(word)\n",
-    "\n",
-    "    if guess not in word_list:\n",
-    "        print (\"Guess word not in passed word list.\\nOnly words within the given word list are valid.\")\n",
-    "        print (f\"Here are some examples of valid words from the passed word list.\\n\\t{sugg_words[:10]}\")\n",
-    "        return None\n",
-    "    \n",
-    "    if target not in word_list:\n",
-    "        print (\"Target word not in passed word list.\\nOnly words within the given word list are valid.\")\n",
-    "        print (f\"Here are some examples of valid words from the passed word list.\\n\\t{sugg_words[-10:]}\")\n",
-    "        return None\n",
-    "\n",
-    "    if random_guess == True:\n",
-    "        randomint_guess = random.randint(0, len(word_list) - 1)\n",
-    "        guess = word_list[randomint_guess]\n",
-    "\n",
-    "    if random_target == True:\n",
-    "        randomint_target = random.randint(0, len(word_list) - 1)\n",
-    "        target = word_list[randomint_target]\n",
-    "\n",
-    "    stats_dict = {}\n",
-    "    stats_dict['first_guess'] = guess\n",
-    "    stats_dict['target_word'] = target\n",
-    "    stats_dict['first_guess_vowels'] = float(count_vows_cons(guess, y_vow = True)['vows'])\n",
-    "    stats_dict['first_guess_consonants'] = float(count_vows_cons(guess, y_vow = True)['cons'])\n",
-    "    stats_dict['target_vowels'] = float(count_vows_cons(target, y_vow = True)['vows'])\n",
-    "    stats_dict['target_consonants'] = float(count_vows_cons(target, y_vow = True)['cons'])\n",
-    "    \n",
-    "    # get entropy of the first guess word and target word in the entire word_list\n",
-    "    for tup in get_word_entropy(word_list, word_list, normalized = True):\n",
-    "        if tup[0] == guess:\n",
-    "            stats_dict['first_guess_entropy'] = tup[1]\n",
-    "        if tup[0] == target:\n",
-    "            stats_dict['target_entropy'] = tup[1]\n",
-    "\n",
-    "    guess_entropies = []\n",
-    "    guess_entropies.append(stats_dict['first_guess_entropy'])\n",
-    "\n",
-    "    # luck_guess_1 = round(1 - ((1 / len(word_list)) * guess_entropies[0] / 100), 2) * 100\n",
-    "\n",
-    "    english_alphabet = \"abcdefghijklmnopqrstuvwxyz\"\n",
-    "\n",
-    "    word_list_sorted_counts = get_letter_counts(english_alphabet, word_list, sort = \"descending\")\n",
-    "    \n",
-    "    wordlen = len(guess)\n",
-    "    letter_positions = set(i for i in range(0, wordlen))\n",
-    "\n",
-    "    guess_set = set()\n",
-    "    perfect_dict = {}\n",
-    "    wrong_pos_dict = {}\n",
-    "    wrong_pos_set = set()\n",
-    "    dont_guess_again = set()\n",
-    "\n",
-    "    guessed_words = [] # running set of guessed words\n",
-    "    guess_num = 0 # baseline for variable\n",
-    "    dont_guess_words = set()\n",
-    "    incorrect_positions = []\n",
-    "    reduction_per_guess = []\n",
-    "\n",
-    "    if max_guesses == None: # if no value is passed, default is len(guess)\n",
-    "        max_guesses = wordlen\n",
-    "    else: # else it is the value passed\n",
-    "        max_guesses = max_guesses\n",
-    "\n",
-    "    perfect_letts_per_guess = []\n",
-    "    wrong_pos_per_guess = []\n",
-    "    wrong_letts_per_guess = []\n",
-    "\n",
-    "    record_list = []\n",
-    "\n",
-    "    while guess: # while there is any guess -- there are conditions to break it at the bottom\n",
-    "\n",
-    "        guess_num += 1\n",
-    "\n",
-    "        guessed_words.append(guess)\n",
-    "\n",
-    "        if drama:\n",
-    "            time.sleep(drama)\n",
-    "\n",
-    "        # guess_num += 1 # each time the guess is processed\n",
-    "        if return_stats == False:\n",
-    "            if guess_num == 1:\n",
-    "                print(\"-----------------------------\\n\")\n",
-    "                record_list.append(\"-----------------------------\\n\")\n",
-    "    \n",
-    "        if return_stats == False:\n",
-    "            print(f\"Guess {guess_num}: '{guess}'\")\n",
-    "            record_list.append(f\"Guess {guess_num}: '{guess}'\")\n",
-    "\n",
-    "        if guess == target:\n",
-    "            stats_dict['target_guessed'] = True\n",
-    "            if return_stats == False:\n",
-    "                if guess_num == 1:\n",
-    "                    print(f\"Congratulations! The Wordle has been solved in {guess_num} guess, that's amazingly lucky!\")\n",
-    "                    print(f\"The target word was {target}\")\n",
-    "                    record_list.append(f\"Congratulations! The Wordle has been solved in {guess_num} guess, that's amazingly lucky!\")\n",
-    "                    record_list.append(f\"The target word was '{target}'.\")\n",
-    "                    perfect_letts_per_guess.append(5)\n",
-    "                    wrong_pos_per_guess.append(0)\n",
-    "                    wrong_letts_per_guess.append(0)\n",
-    "            break\n",
-    "\n",
-    "        guess_set = set()\n",
-    "        wrong_pos_set = set()\n",
-    "\n",
-    "        #### Step 2 -- ALL PERFECT\n",
-    "        for i in letter_positions: # number of letters in each word (current word and target word)\n",
-    "            guess_set.add(guess[i])\n",
-    "\n",
-    "            if guess[i] not in perfect_dict:\n",
-    "                perfect_dict[guess[i]] = set()\n",
-    "            if guess[i] not in wrong_pos_dict:\n",
-    "                wrong_pos_dict[guess[i]] = set()\n",
-    "\n",
-    "            ### EVALUATE CURRENT GUESS\n",
-    "            if guess[i] == target[i]: # letter == correct and position == correct\n",
-    "                perfect_dict[guess[i]].add(i)\n",
-    "\n",
-    "            if (guess[i] != target[i] and  guess[i] in target): # letter == correct and position != correct\n",
-    "                wrong_pos_dict[guess[i]].add(i)\n",
-    "                wrong_pos_set.add(guess[i])\n",
-    "\n",
-    "            if guess[i] not in target: # if letter is not relevant at all\n",
-    "                dont_guess_again.add(guess[i])\n",
-    "\n",
-    "        #### Step 3 -- ALL PERFECT\n",
-    "        next_letters = set()\n",
-    "        for letter, positions in perfect_dict.items():\n",
-    "            if len(positions) > 0:\n",
-    "                next_letters.add(letter)\n",
-    "\n",
-    "        for letter, positions in wrong_pos_dict.items():\n",
-    "            if len(positions) > 0:\n",
-    "                next_letters.add(letter)\n",
-    "\n",
-    "        #### List of tuples of correct letter positions in new valid words. Eg: [('e', 2), ('a', 3)]\n",
-    "        perfect_letters = []\n",
-    "        for letter, positions in perfect_dict.items():\n",
-    "            for pos in positions:\n",
-    "                if len(positions) > 0:\n",
-    "                    perfect_letters.append((letter, pos))\n",
-    "\n",
-    "        #### all words that have correct letters in same spots\n",
-    "        words_matching_correct_all = []\n",
-    "        for word in word_list:\n",
-    "            word_set = set()\n",
-    "            for letter, pos in perfect_letters:\n",
-    "                if pos < len(word):\n",
-    "                    if word[pos] == letter:\n",
-    "                        words_matching_correct_all.append(word)\n",
-    "\n",
-    "        #### excluding words with letters in known incorrect positions\n",
-    "        for letter, positions in wrong_pos_dict.items():\n",
-    "            for pos in positions:\n",
-    "                if len(positions) > 0:\n",
-    "                    if (letter, pos) not in incorrect_positions:\n",
-    "                        incorrect_positions.append((letter, pos))\n",
-    "\n",
-    "        # sorting lists of tuples just to make them look nice in the printout\n",
-    "        incorrect_positions = sorted(incorrect_positions, key = operator.itemgetter(1), reverse = False)\n",
-    "        perfect_letters = sorted(perfect_letters, key = operator.itemgetter(1), reverse = False)\n",
-    "\n",
-    "        #### all words that have correct letters in incorrect spots -- so they can be excluded efficiently\n",
-    "        \n",
-    "        # print(incorrect_positions)\n",
-    "        \n",
-    "        for word in word_list:\n",
-    "            word_set = set()\n",
-    "            for letter, pos in incorrect_positions:\n",
-    "                if pos < len(word):\n",
-    "                    if word[pos] == letter:\n",
-    "                        dont_guess_words.add(word)\n",
-    "        for word in word_list:\n",
-    "            word_set = set()\n",
-    "            for letter, pos in incorrect_positions:\n",
-    "                if pos < len(word):\n",
-    "                    if word[pos] == letter:\n",
-    "                        dont_guess_words.add(word)\n",
-    "\n",
-    "        for bad_letter in dont_guess_again:\n",
-    "            for word in word_list:\n",
-    "                if (bad_letter in word and word not in dont_guess_words):\n",
-    "                    dont_guess_words.add(word)\n",
-    "\n",
-    "        if return_stats == False:\n",
-    "            if verbose == True:\n",
-    "                print(f\"Letters in correct positions:\\n\\t{perfect_letters}\\n\")\n",
-    "                print(f\"Letters in incorrect positions:\\n\\t{incorrect_positions}\\n\")\n",
-    "                print (f\"Letters to guess again:\\n\\t{sorted(list(next_letters), reverse = False)}\\n\")\n",
-    "                print(f\"Letters to not guess again:\\n\\t{sorted(list(dont_guess_again), reverse = False)}\\n\") # works\n",
-    "                \n",
-    "                if len(perfect_letters) == 0:\n",
-    "                    record_list.append(f\"Letters in correct positions: None\\n\")\n",
-    "                else:\n",
-    "                    record_list.append(f\"Letters in correct positions: {perfect_letters}\\n\")\n",
-    "                \n",
-    "                if len(incorrect_positions) == 0:\n",
-    "                    record_list.append(f\"Letters in incorrect positions: None\\n\")\n",
-    "                else:\n",
-    "                    record_list.append(f\"Letters in incorrect positions: {incorrect_positions}\\n\")\n",
-    "                \n",
-    "                if len(next_letters) == 0:\n",
-    "                    record_list.append(f\"Letters to guess again: None\\n\")\n",
-    "                else:\n",
-    "                    record_list.append(f\"Letters to guess again: {sorted(list(next_letters), reverse = False)}\\n\")\n",
-    "                # if\n",
-    "                #     record_list.append(f\"Letters to not guess again: {sorted(list(dont_guess_again), reverse = False)}\\n\") # works\n",
-    "\n",
-    "        # Returns True\n",
-    "        # print(A.issubset(B)) # \"if everything in A is in B\", returns Bool\n",
-    "\n",
-    "        perfect_letts_per_guess.append(len(perfect_letters))\n",
-    "        wrong_pos_per_guess.append(len(incorrect_positions))\n",
-    "        wrong_letts_per_guess.append(len(dont_guess_again))\n",
-    "\n",
-    "        potential_next_guesses = set()\n",
-    "        middle_set = set()\n",
-    "\n",
-    "        if len(perfect_letters) == 0 and len(incorrect_positions) == 0: # if there are NEITHER perfect letters, NOR incorrect positions, ....\n",
-    "            for word in word_list:\n",
-    "                if word not in dont_guess_words:\n",
-    "                    if word not in guessed_words:\n",
-    "                        potential_next_guesses.add(word)\n",
-    "                                        \n",
-    "            # print(f\"GUESS {guess_num} : TEST 1-1\")\n",
-    "\n",
-    "        if len(perfect_letters) == 0 and len(incorrect_positions) != 0: # if there are no perfect letters whatsoever, but there ARE incorrect positions ....\n",
-    "            for word in word_list:\n",
-    "                for incor_letter, incor_pos in incorrect_positions:\n",
-    "                    if incor_pos < len(word):\n",
-    "                        if word[incor_pos] != incor_letter:\n",
-    "                            if word not in dont_guess_words: # just in case\n",
-    "                                word_set = set()\n",
-    "                                for letter in word:\n",
-    "                                    word_set.add(letter)\n",
-    "    \n",
-    "                                    if next_letters.issubset(word_set):\n",
-    "                                        if word not in guessed_words:\n",
-    "                                            if len(dont_guess_again) > 0:\n",
-    "                                                for bad_letter in dont_guess_again:\n",
-    "                                                    if bad_letter not in word:\n",
-    "                                                        # potential_next_guesses.append(word)\n",
-    "                                                        potential_next_guesses.add(word)\n",
-    "                                            else:\n",
-    "                                                potential_next_guesses.add(word)\n",
-    "            \n",
-    "            # print(f\"GUESS {guess_num} : TEST 2-1\")\n",
-    "\n",
-    "        else:\n",
-    "            for word in word_list:\n",
-    "                if word not in dont_guess_words: # just in case\n",
-    "                    word_set = set()\n",
-    "                    for letter in word:\n",
-    "                        word_set.add(letter)\n",
-    "                        if next_letters.issubset(word_set):\n",
-    "                            if word not in guessed_words:\n",
-    "                                # print (\"TEST 3-2\")\n",
-    "\n",
-    "                                if len(dont_guess_again) > 0:\n",
-    "                                    for bad_letter in dont_guess_again:\n",
-    "                                        if bad_letter not in word:\n",
-    "                                            middle_set.add(word)\n",
-    "                                else:\n",
-    "                                    middle_set.add(word)\n",
-    "            for word in middle_set:\n",
-    "                dummy_list = []\n",
-    "                for good_lett, good_pos in perfect_letters:\n",
-    "                    if word[good_pos] == good_lett:\n",
-    "                        dummy_list.append(1)\n",
-    "                        if len(dummy_list) == len(perfect_letters):\n",
-    "                            potential_next_guesses.add(word)\n",
-    "            for word in middle_set:\n",
-    "                dummy_list = []\n",
-    "                for bad_lett, bad_pos in incorrect_positions:\n",
-    "                    if bad_pos < len(word):\n",
-    "                        if word[bad_pos] == bad_lett:\n",
-    "                            dummy_list.append(1)\n",
-    "                            if len(dummy_list) > 0:\n",
-    "                                potential_next_guesses.remove(word)\n",
-    "                                        \n",
-    "            # print(f\"GUESS {guess_num} : TEST 3-1\")\n",
-    "\n",
-    "        if return_stats == False:\n",
-    "            if verbose == True:\n",
-    "                print(f\"At this point:\")\n",
-    "                print(f\"\\t{len(word_list) - len(potential_next_guesses)}, {round((len(word_list) - len(potential_next_guesses)) / len(word_list) * 100, 2)}% of total words have been eliminated, and\")\n",
-    "                print(f\"\\t{len(potential_next_guesses)}, {round(len(potential_next_guesses) / len(word_list) * 100, 2)}% of total words remain possible.\\n\")\n",
-    "                # record_list.append(f\"At this point:\")\n",
-    "                record_list.append(f\"{len(word_list) - len(potential_next_guesses)} ({round((len(word_list) - len(potential_next_guesses)) / len(word_list) * 100, 2)}% of all) words have been eliminated, and {len(potential_next_guesses)} ({round(len(potential_next_guesses) / len(word_list) * 100, 2)}% of all) words are still possible.\\n\")\n",
-    "        \n",
-    "        reduction_per_guess.append(len(potential_next_guesses))\n",
-    "                \n",
-    "        #### Guessing next word\n",
-    "        if len(potential_next_guesses) == 1:\n",
-    "\n",
-    "            if return_stats == False:\n",
-    "                if verbose == True:\n",
-    "                    print(f\"The only remaining possible word is:\\n\\t'{list(potential_next_guesses)[0]}'\\n\")\n",
-    "                    record_list.append(f\"The only remaining possible word is: '{list(potential_next_guesses)[0]}'\\n\")\n",
-    "                \n",
-    "            guess = list(potential_next_guesses)[0]\n",
-    "            guess_entropies.append(get_word_entropy([guess], word_list, normalized = True, ascending = False)[0][1])\n",
-    "\n",
-    "        else:\n",
-    "\n",
-    "            best_next_guesses = list(potential_next_guesses)                \n",
-    "            # print (best_next_guesses)\n",
-    "            word_ratings = get_word_entropy(best_next_guesses, word_list, normalized = True, ascending = False) # \"internal\" ratings\n",
-    "            \n",
-    "            # Get max rating of all words\n",
-    "            max_rating = -np.inf\n",
-    "            for word, rating in word_ratings:\n",
-    "                if rating > max_rating:\n",
-    "                    max_rating = rating\n",
-    "\n",
-    "            # add best rated words (all equally best entropy in next guess list) to set\n",
-    "            best_of_the_best_1 = []\n",
-    "            for word, rating in word_ratings:\n",
-    "                if rating == max_rating:\n",
-    "                    best_of_the_best_1.append(word)\n",
-    "\n",
-    "            # only using top ten most frequent prefixes suffixes to bias. After that it the impact is especially negligible\n",
-    "            test_starts = get_gram_freq(word_list = word_list, letters_length = 2, position = \"start\", search = None)[:10]\n",
-    "            test_ends = get_gram_freq(word_list = word_list, letters_length = 2, position = \"end\", search = None)[:10]\n",
-    "\n",
-    "            # list of the best words that also have the best suffixes and prefixes\n",
-    "            best_of_the_best_2 = []\n",
-    "            for start_gram, start_count in test_starts:\n",
-    "                for end_gram, end_count in test_ends:\n",
-    "                    for word in test_words:\n",
-    "                        if word[:2] == start_gram and word[-2:] == end_gram:\n",
-    "                            best_of_the_best_2.append(word)\n",
-    "\n",
-    "            if len(best_of_the_best_2) > 0:\n",
-    "                guess = best_of_the_best_1[0]\n",
-    "            else:\n",
-    "                guess = best_of_the_best_2[0] # they're all equally the best of the best possible guesses so just pick the first\n",
-    "            \n",
-    "            # guess_entropies.append(get_word_entropy([guess], word_list, normalized = True, ascending = False)[0][1])\n",
-    "\n",
-    "            if return_stats == False:\n",
-    "                if verbose == True:\n",
-    "                    if len(word_ratings) <= 40:\n",
-    "                        print(f\"All potential next guesses:\\n\\t{word_ratings}\\n\")\n",
-    "                        print(f\"Words guessed so far:\\n\\t{guessed_words}.\\n\")\n",
-    "                        record_list.append(f\"Potential next guesses: {word_ratings}\\n\")\n",
-    "                        record_list.append(f\"Words guessed so far: {guessed_words}.\\n\")\n",
-    "                    else:\n",
-    "                        print(f\"The top 40 potential next guesses are:\\n\\t{word_ratings[:40]}\\n\")\n",
-    "                        print(f\"Words guessed so far:\\n\\t{guessed_words}.\\n\")\n",
-    "                        record_list.append(f\"The top 40 potential next guesses are: {word_ratings[:40]}\\n\")\n",
-    "                        record_list.append(f\"Words guessed so far: {guessed_words}.\\n\")\n",
-    "\n",
-    "            guess_entropies.append(get_word_entropy([guess], word_list, normalized = True, ascending = False)[0][1])\n",
-    "\n",
-    "        #### Guess has now been made -- what to do next\n",
-    "        if guess_num == max_guesses: # if at max guesses allowed\n",
-    "            guessed_words.append(guess)\n",
-    "            stats_dict['target_guessed'] = False\n",
-    "            if return_stats == False:\n",
-    "                if verbose == True:\n",
-    "                    # print(\"-----------------------------\\n\")\n",
-    "                    print(f\"Unfortunately, the Wordle could not be solved in {max_guesses} guesses.\\n\")\n",
-    "                    print(f\"The target word was '{target}'. Better luck next time!\\n\")\n",
-    "                    print(\"-----------------------------\\n\")\n",
-    "                    record_list.append(f\"Unfortunately, the Wordle could not be solved in {max_guesses} guesses.\\n\")\n",
-    "                    record_list.append(f\"The target word was '{target}'. Better luck next time!\\n\")\n",
-    "                    record_list.append(\"-----------------------------\\n\")\n",
-    "                else:\n",
-    "                    print(f\"\\nUnfortunately, the Wordle could not be solved in {max_guesses} guesses.\")\n",
-    "                    print(f\"The target word was '{target}'. Better luck next time!\\n\")\n",
-    "                    record_list.append(f\"Unfortunately, the Wordle could not be solved in {max_guesses} guesses.\")\n",
-    "                    record_list.append(f\"The target word was '{target}'. Better luck next time!\\n\")\n",
-    "            break\n",
-    "        else: # if not at max guesses yet allowed\n",
-    "            # stats_dict['target_guessed'] = False\n",
-    "            if return_stats == False:\n",
-    "                if verbose == True:\n",
-    "                    print(f\"Next guess:\\n\\t'{guess}'\")\n",
-    "                    print(\"\\n-----------------------------\\n\")\n",
-    "                    record_list.append(f\"Next guess: '{guess}'\")\n",
-    "                    record_list.append(\"-----------------------------\\n\")\n",
-    "\n",
-    "        if guess == target:\n",
-    "            guess_num += 1\n",
-    "            guessed_words.append(guess)\n",
-    "            stats_dict['target_guessed'] = True\n",
-    "\n",
-    "            if return_stats == False:\n",
-    "                print(f\"Guess {guess_num}: '{guess}'\\n\")\n",
-    "                print(f\"Congratulations! The Wordle has been solved in {guess_num} guesses!\")\n",
-    "                record_list.append(f\"Guess {guess_num}: '{guess}'\\n\")\n",
-    "                record_list.append(f\"Congratulations! The Wordle has been solved in {guess_num} guesses!\")\n",
-    "\n",
-    "                if max_guesses - guess_num == 0:\n",
-    "                    print(f\"Lucky! It was the last guess.\")\n",
-    "                    record_list.append(f\"Lucky! It was the last guess.\")\n",
-    "                else:\n",
-    "                    print(f\"There were still {max_guesses - guess_num} guesses remaining.\")\n",
-    "                    record_list.append(f\"There were still {max_guesses - guess_num} guesses remaining.\")\n",
-    "\n",
-    "            if return_stats == False:   \n",
-    "                # stats_dict['target_guessed'] = True                 \n",
-    "                print(f\"\\nThe target word was '{target}'.\")\n",
-    "                print(\"\\n-----------------------------\")\n",
-    "                record_list.append(f\"The target word was '{target}'.\")\n",
-    "                record_list.append(\"-----------------------------\")\n",
-    "            break\n",
-    "\n",
-    "    #### STATS STUFF    \n",
-    "    mid_guesses_vows = 0\n",
-    "    mid_guesses_cons = 0\n",
-    "    avg_perf_letters = 0\n",
-    "    avg_wrong_pos_letters = 0\n",
-    "    avg_wrong_letters = 0\n",
-    "\n",
-    "    for i, word in enumerate(guessed_words):\n",
-    "        mid_guesses_vows += count_vows_cons(word, y_vow = True)['vows']\n",
-    "        mid_guesses_cons += count_vows_cons(word, y_vow = True)['cons']\n",
-    "        \n",
-    "    for i in range(0, len(guessed_words) - 1):\n",
-    "        avg_perf_letters += perfect_letts_per_guess[i]\n",
-    "        avg_wrong_pos_letters += wrong_pos_per_guess[i]\n",
-    "        avg_wrong_letters += wrong_letts_per_guess[i]\n",
-    "\n",
-    "    stats_dict['mid_guesses_avg_vows'] = float(round(mid_guesses_vows / len(guessed_words), 2))\n",
-    "    stats_dict['mid_guesses_avg_cons'] = float(round(mid_guesses_cons / len(guessed_words), 2))\n",
-    "\n",
-    "    stats_dict['avg_perf_letters'] = float(round(np.mean(avg_perf_letters), 2))\n",
-    "    stats_dict['avg_wrong_pos_letters'] = float(round(np.mean(avg_wrong_pos_letters), 2))\n",
-    "    stats_dict['avg_wrong_letters'] = float(round(np.mean(avg_wrong_letters), 2))\n",
-    "    \n",
-    "    # average number of words remaining after each guess -- the higher this is, the luckier the person got (the lower, the more guesses it took)\n",
-    "    stats_dict['avg_remaining'] = float(round(np.mean(reduction_per_guess), 2))\n",
-    "\n",
-    "    # avg entropy of each guessed word relative to all other words possible at that moment -- this should consistently be 100 for the algorithm, but will be different for user\n",
-    "    if len(guess_entropies) > 1: # in case of guessing it correctly on the first try\n",
-    "        sum_entropies = 0\n",
-    "        for entropy in guess_entropies:\n",
-    "            sum_entropies += entropy\n",
-    "\n",
-    "        average_entropy = float(round(sum_entropies / len(guess_entropies), 2))\n",
-    "        stats_dict['avg_intermediate_guess_entropy'] = average_entropy\n",
-    "    else:\n",
-    "        stats_dict['avg_intermediate_guess_entropy'] = float(100)\n",
-    "\n",
-    "    expected_guesses = 3.85\n",
-    "\n",
-    "    # guess_num = 3\n",
-    "    # average_entropy = 95\n",
-    "    luck = round(1 - ((((guess_num / expected_guesses) * (stats_dict['avg_intermediate_guess_entropy'] / 100)) / max_guesses) * 5), 2)\n",
-    "    stats_dict['luck'] = luck\n",
-    "\n",
-    "    if record == True:\n",
-    "        if verbose == True:\n",
-    "            with open(f\"solutions/{guessed_words[0]}_{target}_wizard_detailed.txt\", \"w\") as fout:\n",
-    "                for line in record_list:\n",
-    "                    fout.write(line + \"\\n\") # write each line of list of printed text to .txt file\n",
-    "        else:\n",
-    "            with open(f\"solutions/{guessed_words[0]}_{target}_wizard_summary.txt\", \"w\") as fout:\n",
-    "                for line in record_list:\n",
-    "                    fout.write(line + \"\\n\") # write\n",
-    "\n",
-    "    # if guess_num <= len(guess):\n",
-    "    if guess_num <= 6:\n",
-    "        stats_dict['valid_success'] = True\n",
-    "    else:\n",
-    "        stats_dict['valid_success'] = False\n",
-    "\n",
-    "    stats_dict['num_guesses'] = float(guess_num)\n",
-    "\n",
-    "    # if return_stats == True:\n",
-    "    #     return stats_dict\n",
-    "    if hf_mod == True:\n",
-    "        return record_list"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "test_1 = wordle_wizard(word_list = official_words, max_guesses = 6, \n",
-    "                guess = \"quota\", target = \"fatAl\",\n",
-    "                random_guess = False, random_target = False, \n",
-    "                verbose = True, drama = 0, return_stats = False, record = False)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "suffix_freq_dist = {}\n",
-    "prefix_freq_dist = {}\n",
-    "\n",
-    "for word in official_words:\n",
-    "    prefix = word[:2] # first 2 letters\n",
-    "    suffix = word[-2:] # last 2 letters\n",
-    "    if prefix not in prefix_freq_dist:\n",
-    "        prefix_freq_dist[prefix] = 1\n",
-    "    else:\n",
-    "        prefix_freq_dist[prefix] += 1\n",
-    "\n",
-    "    if suffix not in suffix_freq_dist:\n",
-    "        suffix_freq_dist[suffix] = 1\n",
-    "    else:\n",
-    "        suffix_freq_dist[suffix] += 1\n",
-    "\n",
-    "suffix_types = [key for key in suffix_freq_dist.keys()]\n",
-    "prefix_types = [key for key in prefix_freq_dist.keys()]\n",
-    "\n",
-    "sorted_prefix_dist = sorted(prefix_freq_dist.items(), key = operator.itemgetter(1), reverse = True)\n",
-    "sorted_suffix_dist = sorted(suffix_freq_dist.items(), key = operator.itemgetter(1), reverse = True)\n",
-    "\n",
-    "print(\"Prefixes:\")\n",
-    "print(len(sorted_prefix_dist))\n",
-    "print(sorted_prefix_dist[:10])\n",
-    "print(\"-----\")\n",
-    "print(\"Suffixes:\")\n",
-    "print(len(sorted_suffix_dist))\n",
-    "print(sorted_suffix_dist[:10])\n",
-    "\n",
-    "for tup in sorted_prefix_dist:\n",
-    "    if tup[0] in [\"ho\", 'jo', 'go']:\n",
-    "        print (tup)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "grams_freq_dist = {}\n",
-    "gram_len = 3\n",
-    "\n",
-    "for word in official_words:\n",
-    "    for i in range(0, len(word) - (gram_len - 1)): # so it doesn't index out of range\n",
-    "        gram = word[i:i + gram_len]\n",
-    "\n",
-    "        if gram not in grams_freq_dist:\n",
-    "            grams_freq_dist[gram] = 1\n",
-    "        else:\n",
-    "            grams_freq_dist[gram] += 1\n",
-    "\n",
-    "print(len(grams_freq_dist))\n",
-    "sorted_gram_dist = sorted(grams_freq_dist.items(), key = operator.itemgetter(1), reverse = True)\n",
-    "sorted_gram_dist[:15]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "base",
-   "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.10.4"
-  },
-  "orig_nbformat": 4,
-  "vscode": {
-   "interpreter": {
-    "hash": "3d597f4c481aa0f25dceb95d2a0067e73c0966dcbd003d741d821a7208527ecf"
-   }
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}