Haiku.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "view-in-github"
   },
   "source": [
    "<a href=\"https://colab.research.google.com/github/iplusplus42/haiku-gen/blob/main/Haiku.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The blackcellmagic extension is already loaded. To reload it, use:\n",
      "  %reload_ext blackcellmagic\n"
     ]
    }
   ],
   "source": [
    "# NOTE: don't run this cell on Colab, it might break something. It loads my code formatter locally.\n",
    "%load_ext blackcellmagic"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "id": "guhi3mKQxLzD",
    "pycharm": {
     "name": "#%%\n"
    },
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "HaikuGenerator v0.2.0\n",
      "Absurd haiku\n",
      "sevenfold stump meld \n",
      "proconsulates overrules \n",
      "locally samphire \n",
      "\n",
      "Adjective noun verb rule\n",
      "backless glare chimneyed \n",
      "covinous intrusion spares \n",
      "vain gawk discipline \n",
      "\n",
      "Adjective noun rule\n",
      "uranic spigots \n",
      "titulary allergies \n",
      "speedless latria \n",
      "\n",
      "Noun verb rule\n",
      "sip duplicating \n",
      "cyclopropane pluralised \n",
      "plexor deciphers \n",
      "\n",
      "Verb adjective noun\n",
      "cleaves far atrophy \n",
      "practices hidden surfings \n",
      "hucksters frail yeses \n",
      "\n",
      "Random rules\n",
      "Was unable to meet the rule in the iterations requested: 20\n",
      "lobectomies mustier \n",
      "postdate platinized \n",
      "\n",
      "Line length rules\n",
      "tart destriers delve \n",
      "Was unable to meet the rule in the iterations requested: 20\n",
      "cagier store \n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "import os\n",
    "from urllib import request\n",
    "import zipfile\n",
    "from typing import List, Tuple\n",
    "\n",
    "DEBUG = False\n",
    "LOCAL = os.path.exists(os.path.join(os.getcwd(), \".gitignore\"))\n",
    "\n",
    "\n",
    "class Utils:\n",
    "    @staticmethod\n",
    "    def is_palindrome(string, ignore_whitespace=True):\n",
    "        if ignore_whitespace:\n",
    "            string = string.replace(\" \", \"\")\n",
    "        return string == string[::-1]\n",
    "\n",
    "    @staticmethod\n",
    "    def get_files():\n",
    "        with request.urlopen(\"https://insertplus.keybase.pub/words.zip\") as f:\n",
    "            fd = open(\"words.zip\", \"wb\")\n",
    "            fd.write(f.read())\n",
    "            fd.close()\n",
    "\n",
    "            fd = open(\"words.zip\", \"rb\")\n",
    "            words_zip = zipfile.ZipFile(fd)\n",
    "            words_zip.extractall()\n",
    "            words_zip.close()\n",
    "            fd.close()\n",
    "\n",
    "    @staticmethod\n",
    "    def get_adjectives(syllable=1):\n",
    "        adjectives = set()\n",
    "        path = os.path.join(os.getcwd(), \"words/adjectives\")\n",
    "\n",
    "        if syllable in range(1, 5):\n",
    "            fd = open(os.path.join(path, f\"{syllable}syllableadjectives.txt\"))\n",
    "            words = [i for i in fd.read().split(\"\\n\") if i != \"\"]\n",
    "            adjectives.update({i for i in words})\n",
    "        else:\n",
    "            for i in os.listdir(path):\n",
    "                fd = open(os.path.join(path, i), \"r\")\n",
    "                words = [i for i in fd.read().split(\"\\n\") if i != \"\"]\n",
    "                adjectives.update({i for i in words})\n",
    "                fd.close()\n",
    "        return adjectives\n",
    "\n",
    "    @staticmethod\n",
    "    def get_adj(syllable=1):\n",
    "        return random.choice([i for i in Utils.get_adjectives(syllable)])\n",
    "\n",
    "    get_adjective = get_adj\n",
    "\n",
    "    @staticmethod\n",
    "    def get_adverbs(syllable=1):\n",
    "        adverbs = set()\n",
    "        path = os.path.join(os.getcwd(), \"words/adverbs\")\n",
    "\n",
    "        if syllable in range(1, 5):\n",
    "            fd = open(os.path.join(path, f\"{syllable}syllableadverbs.txt\"))\n",
    "            words = [i for i in fd.read().split(\"\\n\") if i != \"\"]\n",
    "            adverbs.update({i for i in words})\n",
    "        else:\n",
    "            for i in os.listdir(path):\n",
    "                fd = open(os.path.join(path, i), \"r\")\n",
    "                words = [i for i in fd.read().split(\"\\n\") if i != \"\"]\n",
    "                adverbs.update({i for i in words})\n",
    "                fd.close()\n",
    "        return adverbs\n",
    "\n",
    "    @staticmethod\n",
    "    def get_adverb(syllable=1):\n",
    "        return random.choice([i for i in Utils.get_adverbs(syllable)])\n",
    "\n",
    "    @staticmethod\n",
    "    def get_nouns(syllable=1):\n",
    "        nouns = set()\n",
    "        path = os.path.join(os.getcwd(), \"words/nouns\")\n",
    "\n",
    "        if syllable in range(1, 5):\n",
    "            fd = open(os.path.join(path, f\"{syllable}syllablenouns.txt\"))\n",
    "            words = [i for i in fd.read().split(\"\\n\") if i != \"\"]\n",
    "            nouns.update({i for i in words})\n",
    "        else:\n",
    "            for i in os.listdir(path):\n",
    "                fd = open(os.path.join(path, i), \"r\")\n",
    "                words = [i for i in fd.read().split(\"\\n\") if i != \"\"]\n",
    "                nouns.update({i for i in words})\n",
    "                fd.close()\n",
    "        return nouns\n",
    "\n",
    "    @staticmethod\n",
    "    def get_noun(syllable=1):\n",
    "        return random.choice([i for i in Utils.get_nouns(syllable)])\n",
    "\n",
    "    @staticmethod\n",
    "    def get_verbs(syllable=1):\n",
    "        verbs = set()\n",
    "        path = os.path.join(os.getcwd(), \"words/verbs\")\n",
    "\n",
    "        if syllable in range(1, 5):\n",
    "            fd = open(os.path.join(path, f\"{syllable}syllableverbs.txt\"))\n",
    "            words = [i for i in fd.read().split(\"\\n\") if i != \"\"]\n",
    "            verbs.update({i for i in words})\n",
    "        else:\n",
    "            for i in os.listdir(path):\n",
    "                fd = open(os.path.join(path, i), \"r\")\n",
    "                words = [i for i in fd.read().split(\"\\n\") if i != \"\"]\n",
    "                verbs.update({i for i in words})\n",
    "                fd.close()\n",
    "        return verbs\n",
    "\n",
    "    @staticmethod\n",
    "    def get_verb(syllable=1):\n",
    "        return random.choice([i for i in Utils.get_verbs(syllable)])\n",
    "\n",
    "    @staticmethod\n",
    "    def get_words(syllable=1):\n",
    "        return random.choice([Utils.get_verbs, Utils.get_nouns, Utils.get_adverbs, Utils.get_adjectives])(syllable)\n",
    "\n",
    "    @staticmethod\n",
    "    def get_word(syllable=1):\n",
    "        return random.choice(\n",
    "            [\n",
    "                i\n",
    "                for i in random.choice([Utils.get_verbs, Utils.get_nouns, Utils.get_adverbs, Utils.get_adjectives])(\n",
    "                    syllable\n",
    "                )\n",
    "            ]\n",
    "        )\n",
    "\n",
    "\n",
    "class Rules:\n",
    "    @staticmethod\n",
    "    def do_element_rule(elements: List[str], total_syllables: int):\n",
    "        if len(elements) > total_syllables:\n",
    "            raise IndexError(\"elements list cannot be longer than total_syllables!\")\n",
    "        syllables = [{\"name\": i, \"count\": 1} for i in elements]\n",
    "        syllable_bank = total_syllables - len(elements)\n",
    "        while syllable_bank:\n",
    "            syllables[random.randrange(len(elements))][\"count\"] += 1\n",
    "            syllable_bank -= 1\n",
    "        debug(f\"element rule syllables{syllables}\")\n",
    "        line = \"\"\n",
    "        for i in range(len(elements)):\n",
    "            line += f\"{getattr(Utils, f'get_{elements[i]}')(syllables[i]['count'])} \"\n",
    "        return line\n",
    "\n",
    "    @staticmethod\n",
    "    def _do_word_length_rule(element: str, syllables: int, length: Tuple[str, int] = (\"eq\", 7), breakout=20):\n",
    "        if syllables not in range(1, 5):\n",
    "            raise RuntimeError(\"syllables must be between 1 and 4!\")\n",
    "        for _i in range(breakout):\n",
    "            word = getattr(Rules, f\"get_{element}\")(syllables)\n",
    "            word_length = len(word)\n",
    "            (operator, value) = length\n",
    "            if (\n",
    "                (operator == \"eq\" and word_length == value)\n",
    "                or (operator == \"lt\" and word_length < value)\n",
    "                or (operator == \"gt\" and word_length > value)\n",
    "                or (operator == \"le\" and word_length <= value)\n",
    "                or (operator == \"ge\" and word_length >= value)\n",
    "            ):\n",
    "                return word\n",
    "        return InterruptedError(f\"Was unable to meet the rule in the iterations requested: {breakout}\")\n",
    "\n",
    "    @staticmethod\n",
    "    def do_line_length_rule(\n",
    "        elements: List[str], total_syllables: int, length: Tuple[str, int] = (\"eq\", 20), breakout=20\n",
    "    ):\n",
    "        for _i in range(breakout):\n",
    "            line = Rules.do_element_rule(elements, total_syllables)\n",
    "            line_length = len(line)\n",
    "            (operator, value) = length\n",
    "            if (\n",
    "                (operator == \"eq\" and line_length == value)\n",
    "                or (operator == \"lt\" and line_length < value)\n",
    "                or (operator == \"gt\" and line_length > value)\n",
    "                or (operator == \"le\" and line_length <= value)\n",
    "                or (operator == \"ge\" and line_length >= value)\n",
    "            ):\n",
    "                return line\n",
    "        return InterruptedError(f\"Was unable to meet the rule in the iterations requested: {breakout}\")\n",
    "\n",
    "    @staticmethod\n",
    "    def random_rule(total_syllables: int):\n",
    "        rule = random.choice([i for i in Rules().__dir__() if i.startswith(\"do_\")])\n",
    "        elements = [\"adj\", \"noun\", \"verb\"]\n",
    "        random_elements = []\n",
    "        for i in range(random.randint(2, total_syllables)):\n",
    "            random_elements.append(random.choice(elements))\n",
    "        return getattr(Rules, rule)(random_elements, total_syllables)\n",
    "\n",
    "\n",
    "def debug(content):\n",
    "    if DEBUG:\n",
    "        print(content)\n",
    "\n",
    "\n",
    "def absurd_haiku():\n",
    "    line_1_syllables = 5\n",
    "    line_2_syllables = 7\n",
    "    line_3_syllables = 5\n",
    "    temp = {\"line1\": \"\", \"line2\": \"\", \"line3\": \"\"}\n",
    "\n",
    "    debug(\"Line 1\")\n",
    "    while line_1_syllables > 0:\n",
    "        syllable = random.randint(1, 4 if line_1_syllables > 4 else line_1_syllables)\n",
    "        debug(f\"Remaining syllables: {line_1_syllables}\")\n",
    "        debug(f\"Syllable: {syllable}\")\n",
    "        if syllable > line_1_syllables:\n",
    "            continue\n",
    "        word = Utils.get_word(syllable)\n",
    "        debug(f\"Word: {word}\")\n",
    "        temp[\"line1\"] += f\"{word} \"\n",
    "        line_1_syllables -= syllable\n",
    "\n",
    "    debug(\"Line 2\")\n",
    "    while line_2_syllables > 0:\n",
    "        syllable = random.randint(1, 4 if line_2_syllables > 4 else line_2_syllables)\n",
    "        debug(f\"Remaining syllables: {line_2_syllables}\")\n",
    "        debug(f\"Syllable: {syllable}\")\n",
    "        if syllable > line_2_syllables:\n",
    "            continue\n",
    "        word = Utils.get_word(syllable)\n",
    "        debug(f\"Word: {word}\")\n",
    "        temp[\"line2\"] += f\"{word} \"\n",
    "        line_2_syllables -= syllable\n",
    "\n",
    "    debug(\"Line 3\")\n",
    "    while line_3_syllables > 0:\n",
    "        syllable = random.randint(1, 4 if line_3_syllables > 4 else line_3_syllables)\n",
    "        debug(f\"Remaining syllables: {line_3_syllables}\")\n",
    "        debug(f\"Syllable: {syllable}\")\n",
    "        if syllable > line_3_syllables:\n",
    "            continue\n",
    "        word = Utils.get_word(syllable)\n",
    "        debug(f\"Word: {word}\")\n",
    "        temp[\"line3\"] += f\"{word} \"\n",
    "        line_3_syllables -= syllable\n",
    "\n",
    "    return f\"{temp['line1']}\\n{temp['line2']}\\n{temp['line3']}\"\n",
    "\n",
    "\n",
    "class InteractiveMenu:\n",
    "    def main(self):\n",
    "        last_input = \"\"\n",
    "        while last_input != \"q\":\n",
    "            print(\n",
    "                \"\"\"\n",
    "            1) Generate haiku\n",
    "            2) View haikus\n",
    "            q) Quit\n",
    "            \"\"\"\n",
    "            )\n",
    "            last_input = input()\n",
    "            if last_input == \"1\":\n",
    "                self.generate_haiku_menu()\n",
    "\n",
    "    def generate_haiku_menu(self):\n",
    "        last_input = \"\"\n",
    "        while last_input != \"b\":\n",
    "            print(\n",
    "                \"\"\"\n",
    "            1) Select elements\n",
    "            2) Select rules\n",
    "\n",
    "            r) Random haiku\n",
    "            b) Back\n",
    "            \"\"\"\n",
    "            )\n",
    "            last_input = input()\n",
    "            if last_input == \"1\":\n",
    "                self.select_elements_menu()\n",
    "\n",
    "    def select_elements_menu(self):\n",
    "        last_input = \"\"\n",
    "        while last_input != \"b\":\n",
    "            print(\n",
    "                \"\"\"\n",
    "            1) Adjective\n",
    "            2) Adverb\n",
    "            3) Noun\n",
    "            4) Verb\n",
    "\n",
    "            u) Undo\n",
    "            c) Clear\n",
    "            b) Back\n",
    "            \"\"\"\n",
    "            )\n",
    "            last_input = input()\n",
    "\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    if not LOCAL:\n",
    "        Utils.get_files()\n",
    "    print(\"HaikuGenerator v0.2.0\")\n",
    "    # menu = InteractiveMenu()\n",
    "    # menu.main()\n",
    "    print(\"Absurd haiku\")\n",
    "    print(absurd_haiku())\n",
    "    print(\"\\nAdjective noun verb rule\")\n",
    "    print(Rules.do_element_rule([\"adj\", \"noun\", \"verb\"], 5))\n",
    "    print(Rules.do_element_rule([\"adj\", \"noun\", \"verb\"], 7))\n",
    "    print(Rules.do_element_rule([\"adj\", \"noun\", \"verb\"], 5))\n",
    "    print(\"\\nAdjective noun rule\")\n",
    "    print(Rules.do_element_rule([\"adj\", \"noun\"], 5))\n",
    "    print(Rules.do_element_rule([\"adj\", \"noun\"], 7))\n",
    "    print(Rules.do_element_rule([\"adj\", \"noun\"], 5))\n",
    "    print(\"\\nNoun verb rule\")\n",
    "    print(Rules.do_element_rule([\"noun\", \"verb\"], 5))\n",
    "    print(Rules.do_element_rule([\"noun\", \"verb\"], 7))\n",
    "    print(Rules.do_element_rule([\"noun\", \"verb\"], 5))\n",
    "    print(\"\\nVerb adjective noun\")\n",
    "    print(Rules.do_element_rule([\"verb\", \"adj\", \"noun\"], 5))\n",
    "    print(Rules.do_element_rule([\"verb\", \"adj\", \"noun\"], 7))\n",
    "    print(Rules.do_element_rule([\"verb\", \"adj\", \"noun\"], 5))\n",
    "    print(\"\\nRandom rules\")\n",
    "    print(Rules.random_rule(5))\n",
    "    print(Rules.random_rule(7))\n",
    "    print(Rules.random_rule(5))\n",
    "    print(\"\\nLine length rules\")\n",
    "    print(Rules.do_line_length_rule([\"adj\", \"noun\", \"verb\"], 5, (\"gt\", 10)))\n",
    "    print(Rules.do_line_length_rule([\"verb\", \"noun\"], 7, (\"eq\", 15)))\n",
    "    print(Rules.do_line_length_rule([\"adj\", \"verb\"], 5, (\"lt\", 15), 50))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "colab": {
   "authorship_tag": "ABX9TyN2MU+I/kvQKCsmBR62oxk/",
   "collapsed_sections": [],
   "include_colab_link": true,
   "name": "Untitled1.ipynb",
   "provenance": []
  },
  "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}