notebooks/GettingStartedWithTheEnd-cataclysm.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Getting Started with cataclysm"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### First - Begin the End\n",
    "Install the `cataclysm` package from PyPI."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!pip install cataclysm\n",
    "# install default datafiles in the current directory\n",
    "!cataclysm init"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Second - API key\n",
    "If you haven't already, add your OpenAI API key to a .env file. This cell will check if you have .env and create a new one for you if needed. We use env.template.cataclysm as an example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Got the .env file? It contains our API keys, so you'll need it.\n",
    "import os, shutil\n",
    "if not os.path.exists(\".env\"):\n",
    "    print(\"WARNING: Since you didn't have a .env file, we're creating one from the template. Edit it to add your API key.\")\n",
    "    # copy the template to .env\n",
    "    shutil.copyfile(\"env.template.cataclysm\", \".env\")\n",
    "    print(\"Created .env file at \" + os.path.abspath(\".env\"))\n",
    "\n",
    "# suppress logging via loguru to make the notebook output cleaner, but you can change this if you want to see the logging output\n",
    "from loguru import logger\n",
    "logger.disable(\"cataclysm\")\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The End is Nigh\n",
    "Explore the global cataclysm."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from cataclysm import consume\n",
    "consume(globals())"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once globals() are consumed in a notebook or interpreter, any unrecognized function is doomed to run AI-generated code.\n",
    "\n",
    "In this case, find_shortest_path_dijkstra() doesn't exist, but that won't stop the cataclysm."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shortest path: ['A', 'C', 'B', 'D']\n"
     ]
    }
   ],
   "source": [
    "graph = {\n",
    "    \"A\": {\"B\": 10, \"C\": 4},\n",
    "    \"B\": {\"A\": 1, \"C\": 2, \"D\": 5},\n",
    "    \"C\": {\"A\": 4, \"B\": 2, \"D\": 9},\n",
    "    \"D\": {\"B\": 5, \"C\": 1},\n",
    "}\n",
    "\n",
    "shortest_path = find_shortest_path_dijkstra(graph, \"A\", \"D\")\n",
    "print(f\"Shortest path: {shortest_path}\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you later call the same function with the same arguments, the cached code is reused rapidly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shortest path: ['D', 'C', 'B', 'A']\n"
     ]
    }
   ],
   "source": [
    "shortest_path2 = find_shortest_path_dijkstra(graph, \"D\", \"A\")\n",
    "print(f\"Shortest path: {shortest_path2}\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can view the code on disk, which by default will be in YAML files under `./datafiles/cataclysm/code`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%pycat ./datafiles/cataclysm/code/function_find_shortest_path_dijkstra.yml"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As `cataclysm` is a force to be reckoned with -- many complex things are possible. By default, code is generated using any module you have installed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['existential risks', 'existential catastrophe[16]', 'global', 'terminal', 'permanent,']\n"
     ]
    }
   ],
   "source": [
    "scary_words = get_italicized_phrases_wikipedia(page=\"Global catastrophic risk\", only_lowercase_words=True, min_length=6)\n",
    "print(scary_words[:5])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Accept Your Doom\n",
    "If you are squeamish, or intend to bring upon `cataclysm` for your module or app, it is best to use `doom` instead."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "from cataclysm import doom"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now you must explicitly seek `doom`-- your global namespace will not be consumed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Top 3 college students:\n",
      "Alice with average grade 85.0\n",
      "Bob with average grade 85.0\n"
     ]
    }
   ],
   "source": [
    "from cataclysm import doom\n",
    "\n",
    "students = [\n",
    "    {\"name\": \"Alice\", \"grades\": [80, 90, 85], \"age\": 20},\n",
    "    {\"name\": \"Bob\", \"grades\": [75, 92, 88], \"age\": 21},\n",
    "    {\"name\": \"Charlie\", \"grades\": [60, 70, 65], \"age\": 13},\n",
    "    {\"name\": \"Charlie2\", \"grades\": [60, 70, 65], \"age\": 11},\n",
    "]\n",
    "\n",
    "sorted_students = doom.sort_students_by_average_grade(students)\n",
    "\n",
    "print(\"Top 3 college students:\")\n",
    "for student in doom.get_adult_student_list(sorted_students):\n",
    "    print(f\"{student['name']} with average grade {doom.average(student['grades'])}\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Impending Doom\n",
    "If you are not ready for the `cataclysm` or to accept your `doom`, you can use `doom.impending`. \n",
    "\n",
    "`doom.impending` is useful when you wish to...\n",
    "* ...pre-generate code for performance reasons.\n",
    "* ...manually review code before using it.\n",
    "* ...understand how your function signature will behave during a `cataclysm`.\n",
    "* ...check cached code easily."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from cataclysm import doom\n",
    "\n",
    "students = [\n",
    "    {\"name\": \"Alice\", \"grades\": [80, 90, 85], \"age\": 20},\n",
    "    {\"name\": \"Bob\", \"grades\": [75, 92, 88], \"age\": 21},\n",
    "    {\"name\": \"Charlie\", \"grades\": [60, 70, 65], \"age\": 13},\n",
    "    {\"name\": \"Charlie2\", \"grades\": [60, 70, 65], \"age\": 11},\n",
    "]\n",
    "\n",
    "_doomed_code_str = doom.impending.sort_students_by_average_grade(students)\n",
    "\n",
    "# Preview the code instead of executing it\n",
    "print(_doomed_code_str)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The abyss gazes also into you\n",
    "The `cataclysm` is far-reaching-- before creating code, it considers the the function signature, call stack, keyword argument names, docstrings, and comments. This is done to give it the highest chance of working code.\n",
    "\n",
    "Advanced users can leverage these factors to ensure the generated code meets their needs."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Comments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Celsius temperatures: [0, 25, 100]\n",
      "Fahrenheit temperatures: [32.0, 77.0, 212.0]\n"
     ]
    }
   ],
   "source": [
    "from cataclysm import doom\n",
    "\n",
    "mylist = [0, 25, 100]\n",
    "# convert a list of Celsius temperatures to Fahrenheit\n",
    "newlist = doom.process_it(mylist)\n",
    "print(f\"Celsius temperatures: {mylist}\")\n",
    "print(f\"Fahrenheit temperatures: {newlist}\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Keyword arguments\n",
    "Keyword arguments are very powerful-- they're highly recommended for doomed artisans seeking a productive `cataclysm`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "🎉🎉🌟🎉🥳🌟🎈🎊🌟🎊\n",
      "1min 4s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n",
      "#*#*@###x+\n",
      "#*#*@###x+\n",
      "89.4 ms ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n"
     ]
    }
   ],
   "source": [
    "from cataclysm import doom\n",
    "\n",
    "%timeit -n 1 -r 1 doom.dump_confetti_on_stdout(emoji_mode=True, high_randomness=True)\n",
    "%timeit -n 1 -r 1 doom.dump_confetti_on_stdout(emoji_mode=False, high_randomness=True)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### More Cataclysmic Examples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "101\n"
     ]
    }
   ],
   "source": [
    "uhoh = first_prime_with_3_digits()\n",
    "print(uhoh)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+-------------------------------------+\n",
      "|  May the gods have 𝐦𝐞𝐫𝐜𝐲 𝐨𝐧 𝐮𝐬 all  |\n",
      "+-------------------------------------+\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "s = \"May the gods have mercy on us all\"\n",
    "x = print_surrounded_ascii_art_old_scroll(convert_subtext_to_disturbing_unicode_text(s, \"mercy on us\"), use_wcwidth_for_padding=True)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Is the string 'racecar' a palindrome? True\n"
     ]
    }
   ],
   "source": [
    "# check if the given string is a palindrome\n",
    "input_string = \"racecar\"\n",
    "is_palindrome = check_if_string_is_palindrome(text=input_string)\n",
    "print(f\"Is the string '{input_string}' a palindrome? {is_palindrome}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shape Type: rectangle\n",
      "Dimensions: (5, 10)\n",
      "Area: 50\n",
      "Perimeter: 30\n",
      "Shape: Circle\n",
      "Radius: 7\n",
      "Area: 153.93804002589985\n",
      "Perimeter: 43.982297150257104\n"
     ]
    }
   ],
   "source": [
    "class GeometricShape:\n",
    "    def __init__(self, shape_type, *dimensions):\n",
    "        self.shape_type = shape_type\n",
    "        self.dimensions = dimensions\n",
    "\n",
    "    def area(self):\n",
    "        return calculate_area_of_geometric_shape(self.shape_type, *self.dimensions)\n",
    "\n",
    "    def perimeter(self):\n",
    "        return calculate_perimeter_of_geometric_shape(self.shape_type, *self.dimensions)\n",
    "\n",
    "    def display_info(self):\n",
    "        print_geometric_shape_info(self.shape_type, self.dimensions, self.area(), self.perimeter())\n",
    "\n",
    "\n",
    "rectangle = GeometricShape(\"rectangle\", 5, 10)\n",
    "rectangle.display_info()\n",
    "\n",
    "circle = GeometricShape(\"circle\", 7)\n",
    "circle.display_info()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Docstring example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "John Doe is an adult? True\n",
      "Jane Doe is an adult? False\n"
     ]
    }
   ],
   "source": [
    "from cataclysm import doom\n",
    "\n",
    "def create_person_class2():\n",
    "    \"\"\"\n",
    "    This method generates a Person class with the following attributes:\n",
    "    - first_name\n",
    "    - last_name\n",
    "    - age\n",
    "\n",
    "    And the following methods:\n",
    "    - get_full_name(): Returns the full name (first_name and last_name)\n",
    "    - is_adult(): Returns True if the person is an adult (age >= 18), else False\n",
    "    \"\"\"\n",
    "    return doom.person_class_factory_get_person_class()\n",
    "\n",
    "# Usage\n",
    "Person = create_person_class2()\n",
    "\n",
    "person1 = Person(\"John\", \"Doe\", 25)\n",
    "print(f\"{person1.get_full_name()} is an adult? {person1.is_adult()}\")\n",
    "\n",
    "person2 = Person(\"Jane\", \"Doe\", 17)\n",
    "print(f\"{person2.get_full_name()} is an adult? {person2.is_adult()}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Future value: $375538.75\n",
      "Total interest earned: $75538.75\n",
      "Effective annual interest rate: 4.59%\n"
     ]
    }
   ],
   "source": [
    "from cataclysm import doom\n",
    "\n",
    "# This class performs various calculations related to compound interest\n",
    "class CompoundInterestCalculator:\n",
    "    def __init__(self, principal, interest_rate, compounding_frequency, years):\n",
    "        self.principal = principal\n",
    "        self.interest_rate = interest_rate\n",
    "        self.compounding_frequency = compounding_frequency\n",
    "        self.years = years\n",
    "\n",
    "    def calculate_future_value(self):\n",
    "        # Calculate the future value of the investment using the compound interest formula\n",
    "        return doom.calculate_future_value_of_investment(self.principal, self.interest_rate, self.compounding_frequency, self.years)\n",
    "\n",
    "    def calculate_total_interest(self):\n",
    "        # Calculate the total interest earned during the investment period\n",
    "        return doom.calculate_total_interest_earned(self.principal, self.calculate_future_value())\n",
    "\n",
    "    def calculate_effective_interest_rate(self):\n",
    "        # Calculate the effective annual interest rate\n",
    "        return doom.calculate_effective_annual_interest_rate(self.interest_rate, self.compounding_frequency)\n",
    "\n",
    "# Usage\n",
    "investment = CompoundInterestCalculator(principal=300000, interest_rate=0.045, compounding_frequency=12, years=5)\n",
    "future_value = investment.calculate_future_value()\n",
    "total_interest = investment.calculate_total_interest()\n",
    "effective_interest_rate = investment.calculate_effective_interest_rate()\n",
    "# print the results\n",
    "print(f\"Future value: ${future_value:.2f}\")\n",
    "print(f\"Total interest earned: ${total_interest:.2f}\")\n",
    "print(f\"Effective annual interest rate: {effective_interest_rate * 100:.2f}%\")\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": ".venv",
   "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.6"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}