pair-programming/getting_started_gemini_pair_programming.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "7e80b742-0c2e-46d2-99e5-61f2982571e4",
   "metadata": {},
   "source": [
    "# Getting Started with Gemini for Pair Programming"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "2db7275e-7ba3-482c-90a5-8d470dcca05c",
   "metadata": {
    "height": 157
   },
   "outputs": [],
   "source": [
    "#!pip install python-dotenv\n",
    "import os\n",
    "from dotenv import load_dotenv, find_dotenv\n",
    "\n",
    "def get_api_key():\n",
    "    \n",
    "    _ = load_dotenv(find_dotenv()) # read local .env file\n",
    "    return os.getenv('GOOGLE_API_KEY')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a8be2f53-efa5-495f-808e-1e3189f0b73d",
   "metadata": {},
   "source": [
    "To use Gemini API on your own machine, you would first install the library:\n",
    "```Python\n",
    "!pip install -q google.generativeai\n",
    "```\n",
    "The optional flag `-q` installs \"quietly\" without printing out details of the installation.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "71786bc2",
   "metadata": {},
   "source": [
    "> Note: Get the Gemini API from this [website](https://aistudio.google.com/app/apikey) by only using your gmail account."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b5ffb615",
   "metadata": {},
   "source": [
    "```Python\n",
    "# Legacy PALM API code shown in the video\n",
    "import google.generativeai as palm\n",
    "palm.configure(api_key=get_api_key())\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "89a9a4b3-b338-4ed8-ac7b-a08143da5b63",
   "metadata": {
    "height": 217
   },
   "outputs": [],
   "source": [
    "# From now own with Gemini API\n",
    "import os\n",
    "import google.generativeai as genai\n",
    "from google.api_core import client_options as client_options_lib\n",
    "\n",
    "genai.configure(\n",
    "    api_key=get_api_key(),\n",
    "    transport=\"rest\",\n",
    "    client_options=client_options_lib.ClientOptions(\n",
    "        api_endpoint=os.getenv(\"GOOGLE_API_BASE\"),\n",
    "    )\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9648b897-5ad4-4caa-808d-97528c2fcf39",
   "metadata": {},
   "source": [
    "### Explore the available models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "77038a39-427c-4d1f-bc7e-e0692e8f6869",
   "metadata": {
    "height": 149
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "name: models/chat-bison-001\n",
      "description: A legacy text-only model optimized for chat conversations\n",
      "generation methods:['generateMessage', 'countMessageTokens']\n",
      "\n",
      "name: models/text-bison-001\n",
      "description: A legacy model that understands text and generates text as an output\n",
      "generation methods:['generateText', 'countTextTokens', 'createTunedTextModel']\n",
      "\n",
      "name: models/embedding-gecko-001\n",
      "description: Obtain a distributed representation of a text.\n",
      "generation methods:['embedText', 'countTextTokens']\n",
      "\n",
      "name: models/gemini-1.0-pro-latest\n",
      "description: The original Gemini 1.0 Pro model. This model will be discontinued on February 15th, 2025. Move to a newer Gemini version.\n",
      "generation methods:['generateContent', 'countTokens']\n",
      "\n",
      "name: models/gemini-1.0-pro\n",
      "description: The best model for scaling across a wide range of tasks\n",
      "generation methods:['generateContent', 'countTokens']\n",
      "\n",
      "name: models/gemini-pro\n",
      "description: The best model for scaling across a wide range of tasks\n",
      "generation methods:['generateContent', 'countTokens']\n",
      "\n",
      "name: models/gemini-1.0-pro-001\n",
      "description: The original Gemini 1.0 Pro model version that supports tuning. Gemini 1.0 Pro will be discontinued on February 15th, 2025. Move to a newer Gemini version.\n",
      "generation methods:['generateContent', 'countTokens', 'createTunedModel']\n",
      "\n",
      "name: models/gemini-1.0-pro-vision-latest\n",
      "description: The original Gemini 1.0 Pro Vision model version which was optimized for image understanding. Gemini 1.0 Pro Vision was deprecated on July 12, 2024. Move to a newer Gemini version.\n",
      "generation methods:['generateContent', 'countTokens']\n",
      "\n",
      "name: models/gemini-pro-vision\n",
      "description: The original Gemini 1.0 Pro Vision model version which was optimized for image understanding. Gemini 1.0 Pro Vision was deprecated on July 12, 2024. Move to a newer Gemini version.\n",
      "generation methods:['generateContent', 'countTokens']\n",
      "\n",
      "name: models/gemini-1.5-pro-latest\n",
      "description: Alias that points to the most recent production (non-experimental) release of Gemini 1.5 Pro, our mid-size multimodal model that supports up to 2 million tokens.\n",
      "generation methods:['generateContent', 'countTokens']\n",
      "\n",
      "name: models/gemini-1.5-pro-001\n",
      "description: Stable version of Gemini 1.5 Pro, our mid-size multimodal model that supports up to 2 million tokens, released in May of 2024.\n",
      "generation methods:['generateContent', 'countTokens', 'createCachedContent']\n",
      "\n",
      "name: models/gemini-1.5-pro-002\n",
      "description: Stable version of Gemini 1.5 Pro, our mid-size multimodal model that supports up to 2 million tokens, released in September of 2024.\n",
      "generation methods:['generateContent', 'countTokens', 'createCachedContent']\n",
      "\n",
      "name: models/gemini-1.5-pro\n",
      "description: Stable version of Gemini 1.5 Pro, our mid-size multimodal model that supports up to 2 million tokens, released in May of 2024.\n",
      "generation methods:['generateContent', 'countTokens']\n",
      "\n",
      "name: models/gemini-1.5-pro-exp-0801\n",
      "description: Experimental release (August 1st, 2024) of Gemini 1.5 Pro, our mid-size multimodal model that supports up to 2 million tokens, with across the board improvements. Replaced by Gemini-1.5-pro-002 (stable).\n",
      "generation methods:['generateContent', 'countTokens']\n",
      "\n",
      "name: models/gemini-1.5-pro-exp-0827\n",
      "description: Experimental release (August 27th, 2024) of Gemini 1.5 Pro, our mid-size multimodal model that supports up to 2 million tokens, with across the board improvements. Replaced by Gemini-1.5-pro-002 (stable).\n",
      "generation methods:['generateContent', 'countTokens']\n",
      "\n",
      "name: models/gemini-1.5-flash-latest\n",
      "description: Alias that points to the most recent production (non-experimental) release of Gemini 1.5 Flash, our fast and versatile multimodal model for scaling across diverse tasks.\n",
      "generation methods:['generateContent', 'countTokens']\n",
      "\n",
      "name: models/gemini-1.5-flash-001\n",
      "description: Stable version of Gemini 1.5 Flash, our fast and versatile multimodal model for scaling across diverse tasks, released in May of 2024.\n",
      "generation methods:['generateContent', 'countTokens', 'createCachedContent']\n",
      "\n",
      "name: models/gemini-1.5-flash-001-tuning\n",
      "description: Version of Gemini 1.5 Flash that supports tuning, our fast and versatile multimodal model for scaling across diverse tasks, released in May of 2024.\n",
      "generation methods:['generateContent', 'countTokens', 'createTunedModel']\n",
      "\n",
      "name: models/gemini-1.5-flash\n",
      "description: Alias that points to the most recent stable version of Gemini 1.5 Flash, our fast and versatile multimodal model for scaling across diverse tasks.\n",
      "generation methods:['generateContent', 'countTokens']\n",
      "\n",
      "name: models/gemini-1.5-flash-exp-0827\n",
      "description: Experimental release (August 27th, 2024) of Gemini 1.5 Flash, our fast and versatile multimodal model for scaling across diverse tasks, with across the board improvements. Replaced by Gemini-1.5-flash-002 (stable).\n",
      "generation methods:['generateContent', 'countTokens']\n",
      "\n",
      "name: models/gemini-1.5-flash-002\n",
      "description: Stable version of Gemini 1.5 Flash, our fast and versatile multimodal model for scaling across diverse tasks, released in September of 2024.\n",
      "generation methods:['generateContent', 'countTokens', 'createCachedContent']\n",
      "\n",
      "name: models/gemini-1.5-flash-8b\n",
      "description: Stable version of Gemini 1.5 Flash-8B, our smallest and most cost effective Flash model, released in October of 2024.\n",
      "generation methods:['createCachedContent', 'generateContent', 'countTokens']\n",
      "\n",
      "name: models/gemini-1.5-flash-8b-001\n",
      "description: Stable version of Gemini 1.5 Flash-8B, our smallest and most cost effective Flash model, released in October of 2024.\n",
      "generation methods:['createCachedContent', 'generateContent', 'countTokens']\n",
      "\n",
      "name: models/gemini-1.5-flash-8b-latest\n",
      "description: Alias that points to the most recent production (non-experimental) release of Gemini 1.5 Flash-8B, our smallest and most cost effective Flash model, released in October of 2024.\n",
      "generation methods:['createCachedContent', 'generateContent', 'countTokens']\n",
      "\n",
      "name: models/gemini-1.5-flash-8b-exp-0827\n",
      "description: Experimental release (August 27th, 2024) of Gemini 1.5 Flash-8B, our smallest and most cost effective Flash model. Replaced by Gemini-1.5-flash-8b-001 (stable).\n",
      "generation methods:['generateContent', 'countTokens']\n",
      "\n",
      "name: models/gemini-1.5-flash-8b-exp-0924\n",
      "description: Experimental release (September 24th, 2024) of Gemini 1.5 Flash-8B, our smallest and most cost effective Flash model. Replaced by Gemini-1.5-flash-8b-001 (stable).\n",
      "generation methods:['generateContent', 'countTokens']\n",
      "\n",
      "name: models/learnlm-1.5-pro-experimental\n",
      "description: Alias that points to the most recent stable version of Gemini 1.5 Pro, our mid-size multimodal model that supports up to 2 million tokens.\n",
      "generation methods:['generateContent', 'countTokens']\n",
      "\n",
      "name: models/gemini-exp-1114\n",
      "description: Experimental release (November 11th, 2024) of Gemini.\n",
      "generation methods:['generateContent', 'countTokens']\n",
      "\n",
      "name: models/gemini-exp-1121\n",
      "description: Experimental release (November 21st, 2024) of Gemini.\n",
      "generation methods:['generateContent', 'countTokens']\n",
      "\n",
      "name: models/embedding-001\n",
      "description: Obtain a distributed representation of a text.\n",
      "generation methods:['embedContent']\n",
      "\n",
      "name: models/text-embedding-004\n",
      "description: Obtain a distributed representation of a text.\n",
      "generation methods:['embedContent']\n",
      "\n",
      "name: models/aqa\n",
      "description: Model trained to return answers to questions that are grounded in provided sources, along with estimating answerable probability.\n",
      "generation methods:['generateAnswer']\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# PaLM API legacy:\n",
    "# palm.list_models()\n",
    "\n",
    "# Now, Gemini API\n",
    "for m in genai.list_models():\n",
    "    print(f\"name: {m.name}\")\n",
    "    print(f\"description: {m.description}\")\n",
    "    print(f\"generation methods:{m.supported_generation_methods}\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e8540099-fad0-4954-83a7-c2fba3f6d972",
   "metadata": {},
   "source": [
    "#### Filter models by their supported generation methods\n",
    "- `generateText` is currently recommended for coding-related prompts.\n",
    "- `generateMessage` is optimized for multi-turn chats (dialogues) with an LLM."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5d1e8e83",
   "metadata": {},
   "source": [
    "- `generateContent`, best model for scaling across a wide range of tasks."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "48e26d6a-02b9-4838-a0e6-d2e6a3ae042e",
   "metadata": {
    "height": 81
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Model(name='models/text-bison-001',\n",
       "       base_model_id='',\n",
       "       version='001',\n",
       "       display_name='PaLM 2 (Legacy)',\n",
       "       description='A legacy model that understands text and generates text as an output',\n",
       "       input_token_limit=8196,\n",
       "       output_token_limit=1024,\n",
       "       supported_generation_methods=['generateText', 'countTextTokens', 'createTunedTextModel'],\n",
       "       temperature=0.7,\n",
       "       top_p=0.95,\n",
       "       top_k=40)]"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "models = [m for m in genai.list_models() \n",
    "          if 'generateText' \n",
    "          in m.supported_generation_methods]\n",
    "models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "4eb4fc7d-2a1a-43bc-9810-25e4db3b7cb7",
   "metadata": {
    "height": 64
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Model(name='models/text-bison-001',\n",
       "      base_model_id='',\n",
       "      version='001',\n",
       "      display_name='PaLM 2 (Legacy)',\n",
       "      description='A legacy model that understands text and generates text as an output',\n",
       "      input_token_limit=8196,\n",
       "      output_token_limit=1024,\n",
       "      supported_generation_methods=['generateText', 'countTextTokens', 'createTunedTextModel'],\n",
       "      temperature=0.7,\n",
       "      top_p=0.95,\n",
       "      top_k=40)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Model Bison in 2024 is a legacy model  \n",
    "model_bison = models[0]\n",
    "model_bison"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "18a24bff-ebe0-4fd3-93f6-c2aeef4d44f7",
   "metadata": {},
   "source": [
    "#### helper function to generate text\n",
    "\n",
    "- The `@retry` decorator helps you to retry the API call if it fails.\n",
    "- We set the temperature to 0.0 so that the model returns the same output (completion) if given the same input (the prompt).\n",
    "\n",
    "```Python\n",
    "# Code legacy for PALM API\n",
    "from google.api_core import retry\n",
    "@retry.Retry()\n",
    "def generate_text(prompt,\n",
    "                  model=model_bison,\n",
    "                  temperature=0.0):\n",
    "    return palm.generate_text(prompt=prompt,\n",
    "                              model=model,\n",
    "                              temperature=temperature)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "0f2fd6e9",
   "metadata": {
    "height": 47
   },
   "outputs": [],
   "source": [
    "# Set the model to connect to the Gemini API\n",
    "model_flash = genai.GenerativeModel(model_name='gemini-1.5-flash')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "a73e1ce1",
   "metadata": {
    "height": 115
   },
   "outputs": [],
   "source": [
    "# Helper with Gemini API\n",
    "def generate_text(prompt,\n",
    "                  model=model_flash,\n",
    "                  temperature=0.0):\n",
    "    return model_flash.generate_content(prompt,\n",
    "                                  generation_config={'temperature':temperature})"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aa756beb-7e70-4575-a27e-82b733b3d3b0",
   "metadata": {},
   "source": [
    "#### Ask the LLM how to write some code\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "04080420-acd1-43a8-92bc-7d4c407a0154",
   "metadata": {
    "height": 30
   },
   "outputs": [],
   "source": [
    "prompt = \"Show me how to iterate across a list in Python.\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "32a354db-cb9b-4353-b777-4980256f4686",
   "metadata": {
    "height": 47
   },
   "outputs": [],
   "source": [
    "# Gemini API updates to generate the text\n",
    "completion = generate_text(prompt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "ef2b1688-2eb7-465c-81cd-555d5b0a5a70",
   "metadata": {
    "height": 98
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Python offers several ways to iterate across a list. Here are the most common methods, with explanations and examples:\n",
      "\n",
      "**1. Using a `for` loop:** This is the most straightforward and commonly used method.\n",
      "\n",
      "```python\n",
      "my_list = [\"apple\", \"banana\", \"cherry\"]\n",
      "\n",
      "# Iterate and print each item\n",
      "for item in my_list:\n",
      "    print(item)\n",
      "\n",
      "# Iterate and print the index and item\n",
      "for i, item in enumerate(my_list):\n",
      "    print(f\"Item at index {i}: {item}\")\n",
      "```\n",
      "\n",
      "**Explanation:**\n",
      "\n",
      "* The first loop directly iterates through each element in `my_list`, assigning it to the variable `item` in each iteration.\n",
      "* The second loop uses `enumerate()`, which provides both the index (`i`) and the value (`item`) of each element in the list.  `f-strings` (formatted string literals) are used for cleaner output.\n",
      "\n",
      "\n",
      "**2. Using a `while` loop:** This offers more control, but is generally less concise for simple list iteration.\n",
      "\n",
      "```python\n",
      "my_list = [\"apple\", \"banana\", \"cherry\"]\n",
      "i = 0\n",
      "while i < len(my_list):\n",
      "    print(my_list[i])\n",
      "    i += 1\n",
      "```\n",
      "\n",
      "**Explanation:**\n",
      "\n",
      "* A counter variable `i` keeps track of the current index.\n",
      "* The loop continues as long as `i` is less than the length of the list.\n",
      "* `my_list[i]` accesses the element at the current index.  This method is more error-prone if you accidentally modify `i` incorrectly within the loop.\n",
      "\n",
      "\n",
      "**3. List comprehension (for creating new lists):** While not strictly iteration *in* the list, list comprehensions are a concise way to create a new list based on an existing one.\n",
      "\n",
      "```python\n",
      "my_list = [1, 2, 3, 4, 5]\n",
      "squared_list = [x**2 for x in my_list]\n",
      "print(squared_list)  # Output: [1, 4, 9, 16, 25]\n",
      "\n",
      "even_numbers = [x for x in my_list if x % 2 == 0]\n",
      "print(even_numbers) # Output: [2, 4]\n",
      "```\n",
      "\n",
      "**Explanation:**\n",
      "\n",
      "* List comprehensions create a new list by applying an expression to each item in the original list (optionally with a conditional filter).\n",
      "\n",
      "\n",
      "**4. Using `iter()` and `next()` (for manual control):** This provides the most granular control but is less commonly used for simple iteration.\n",
      "\n",
      "```python\n",
      "my_list = [\"apple\", \"banana\", \"cherry\"]\n",
      "my_iterator = iter(my_list)\n",
      "\n",
      "try:\n",
      "    while True:\n",
      "        item = next(my_iterator)\n",
      "        print(item)\n",
      "except StopIteration:\n",
      "    pass\n",
      "```\n",
      "\n",
      "**Explanation:**\n",
      "\n",
      "* `iter()` creates an iterator object from the list.\n",
      "* `next()` retrieves the next item from the iterator.\n",
      "* The `try-except` block handles the `StopIteration` exception that is raised when the end of the iterator is reached.\n",
      "\n",
      "\n",
      "The `for` loop is generally preferred for its readability and simplicity when iterating through a list.  Use the other methods when you need more fine-grained control or when creating new lists based on existing ones (list comprehension).  Avoid the `while` loop unless you have a specific reason to manage the index manually, as it's more prone to errors.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# PaLM API\n",
    "## print(completion.result)\n",
    "\n",
    "# Gemini API\n",
    "print(completion.text)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1400bcb5-bfe8-4192-809d-d95b21bf8422",
   "metadata": {},
   "source": [
    "- **Tip:** The words \"show me\" tends to encourage the ~~PaLM~~ Gemini LLM to give more details and explanations compared to if you were to ask \"write code to ...\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "6b813473-15de-4672-9097-57a3d04219d6",
   "metadata": {
    "height": 30
   },
   "outputs": [],
   "source": [
    "prompt = \"write code to iterate across a list in Python\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "3557557d-2b86-4755-a44f-8846e0035d3a",
   "metadata": {
    "height": 132
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "There are several ways to iterate across a list in Python, each with its own advantages:\n",
      "\n",
      "**1. Using a `for` loop:** This is the most common and generally preferred method for iterating through a list.\n",
      "\n",
      "```python\n",
      "my_list = [10, 20, 30, 40, 50]\n",
      "\n",
      "# Iterate and print each element\n",
      "for item in my_list:\n",
      "    print(item)\n",
      "\n",
      "# Iterate and print the index and element\n",
      "for i, item in enumerate(my_list):\n",
      "    print(f\"Index: {i}, Value: {item}\")\n",
      "```\n",
      "\n",
      "**2. Using a `while` loop:** This offers more control, allowing you to iterate based on a condition rather than just the length of the list.  However, it's generally less readable and more prone to errors than a `for` loop for simple list iteration.\n",
      "\n",
      "```python\n",
      "my_list = [10, 20, 30, 40, 50]\n",
      "i = 0\n",
      "while i < len(my_list):\n",
      "    print(my_list[i])\n",
      "    i += 1\n",
      "```\n",
      "\n",
      "**3. List comprehension (for creating new lists):**  List comprehensions are concise ways to create new lists based on existing ones.  While not strictly iteration in the same sense as `for` and `while` loops, they efficiently process each element.\n",
      "\n",
      "```python\n",
      "my_list = [10, 20, 30, 40, 50]\n",
      "\n",
      "# Create a new list with each element doubled\n",
      "doubled_list = [item * 2 for item in my_list]\n",
      "print(doubled_list)\n",
      "\n",
      "# Create a new list containing only even numbers\n",
      "even_numbers = [item for item in my_list if item % 2 == 0]\n",
      "print(even_numbers)\n",
      "```\n",
      "\n",
      "**4. Using `iter()` and `next()` (for manual control):** This gives you the most fine-grained control, but is generally less readable and only necessary in specific situations.\n",
      "\n",
      "```python\n",
      "my_list = [10, 20, 30, 40, 50]\n",
      "my_iterator = iter(my_list)\n",
      "\n",
      "try:\n",
      "    while True:\n",
      "        item = next(my_iterator)\n",
      "        print(item)\n",
      "except StopIteration:\n",
      "    pass # This exception is raised when the iterator is exhausted\n",
      "```\n",
      "\n",
      "\n",
      "The `for` loop is the most straightforward and readable approach for most list iteration tasks in Python.  Choose the other methods only when they offer a specific advantage for your particular needs.  For example, use a `while` loop if you need to conditionally skip elements or stop iteration based on a specific condition other than reaching the end of the list.  Use list comprehensions for concise creation of new lists based on transformations of existing ones.  Use `iter()` and `next()` for very specific low-level control over the iteration process.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# PaLM API\n",
    "## completion = generate_text(prompt)\n",
    "## print(completion.result)\n",
    "\n",
    "# Gemini API\n",
    "completion = generate_text(prompt)\n",
    "print(completion.text)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "26114873-bb3c-4253-a679-4dda28af561c",
   "metadata": {},
   "source": [
    "#### Try out the code\n",
    "- Try copy-pasting some of the generated code and running it in the notebook.\n",
    "- Remember to test out the LLM-generated code and debug it make sure it works as intended."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "e2e76677-1b90-4ce4-a3b4-aae857e870f6",
   "metadata": {
    "height": 81
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "20\n",
      "30\n",
      "40\n",
      "50\n"
     ]
    }
   ],
   "source": [
    "my_list = [10, 20, 30, 40, 50]\n",
    "my_iterator = iter(my_list)\n",
    "\n",
    "try:\n",
    "    while True:\n",
    "        item = next(my_iterator)\n",
    "        print(item)\n",
    "except StopIteration:\n",
    "    pass\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3c649daa-781c-4c69-ac1b-d100e9747190",
   "metadata": {},
   "source": [
    "#### Try asking your own coding question"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "c69b4929-ec4f-495c-a773-a92ce2c9b36c",
   "metadata": {
    "height": 149
   },
   "outputs": [],
   "source": [
    "# Modify the prompt with your own question\n",
    "prompt = \"Show me how to calcutate average using python\"\n",
    "\n",
    "# PaLM API\n",
    "## completion = generate_text(prompt)\n",
    "\n",
    "# Gemini API\n",
    "completion = generate_text(prompt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "c759d6a4-ed38-43fd-a588-1d62308a8746",
   "metadata": {
    "height": 30
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "There are several ways to calculate the average (mean) in Python, depending on your data structure. Here are a few examples:\n",
      "\n",
      "**1. Using the `statistics` module (Recommended for simplicity and efficiency):**\n",
      "\n",
      "This is the easiest and most efficient way, especially for larger datasets.  The `statistics` module provides functions specifically designed for statistical calculations.\n",
      "\n",
      "```python\n",
      "import statistics\n",
      "\n",
      "data = [1, 2, 3, 4, 5]\n",
      "average = statistics.mean(data)\n",
      "print(f\"The average is: {average}\")  # Output: The average is: 3\n",
      "\n",
      "data2 = [10, 20, 30, 40, 50, 100]\n",
      "average2 = statistics.mean(data2)\n",
      "print(f\"The average is: {average2}\") # Output: The average is: 40.0\n",
      "\n",
      "#Handles empty lists gracefully\n",
      "empty_data = []\n",
      "try:\n",
      "    average3 = statistics.mean(empty_data)\n",
      "    print(f\"The average is: {average3}\")\n",
      "except statistics.StatisticsError:\n",
      "    print(\"Cannot calculate the average of an empty list.\") #Output: Cannot calculate the average of an empty list.\n",
      "\n",
      "```\n",
      "\n",
      "**2. Using `sum()` and `len()` (For basic calculations):**\n",
      "\n",
      "This is a more manual approach, suitable for understanding the underlying calculation.\n",
      "\n",
      "```python\n",
      "data = [1, 2, 3, 4, 5]\n",
      "average = sum(data) / len(data)\n",
      "print(f\"The average is: {average}\")  # Output: The average is: 3.0\n",
      "\n",
      "#Handles empty lists by raising a ZeroDivisionError\n",
      "empty_data = []\n",
      "try:\n",
      "    average = sum(empty_data) / len(empty_data)\n",
      "    print(f\"The average is: {average}\")\n",
      "except ZeroDivisionError:\n",
      "    print(\"Cannot calculate the average of an empty list.\") #Output: Cannot calculate the average of an empty list.\n",
      "```\n",
      "\n",
      "**3. Using NumPy (For numerical arrays):**\n",
      "\n",
      "NumPy is a powerful library for numerical computation.  It's particularly efficient for large datasets.\n",
      "\n",
      "```python\n",
      "import numpy as np\n",
      "\n",
      "data = np.array([1, 2, 3, 4, 5])\n",
      "average = np.mean(data)\n",
      "print(f\"The average is: {average}\")  # Output: The average is: 3.0\n",
      "\n",
      "#Handles empty arrays gracefully\n",
      "empty_data = np.array([])\n",
      "average = np.mean(empty_data)\n",
      "print(f\"The average is: {average}\") #Output: The average is: nan (Not a Number)\n",
      "\n",
      "```\n",
      "\n",
      "**Choosing the right method:**\n",
      "\n",
      "* For most cases, especially if you're dealing with potentially empty lists, the `statistics.mean()` function is the recommended approach because it handles errors gracefully.\n",
      "* If you're working with large numerical datasets, NumPy's `np.mean()` offers superior performance.\n",
      "* The `sum()` and `len()` method is useful for educational purposes or when you need very basic functionality and are comfortable handling potential `ZeroDivisionError` exceptions.  Remember to add error handling (like a `try-except` block) to prevent crashes if your list is empty.\n",
      "\n",
      "\n",
      "Remember to install NumPy if you haven't already:  `pip install numpy`\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(completion.text)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6a2b9e7a-4911-476d-9141-010224682d17",
   "metadata": {},
   "source": [
    "#### Note about the API key\n",
    "We've provided an API key for this classroom.  If you would like your own API key for your own projects, you can get one at [developers.generativeai.google](https://developers.generativeai.google/)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.14"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}