bing_image_creator_dalle3_batch_meap158.ipynb

{
  "cells": [
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "qEMNB-apVuxD"
      },
      "source": [
        "# **Bing Image Creator DALL-E 3 Batch v3**\n",
        "- For more details: [GitHub](https://github.com/meap158/bing_image_creator_dalle3_batch)\n",
        "- Feel free to [PM me on my Facebook profile](https://www.facebook.com/messages/t/meap9999) for support.\n",
        "\n",
        "---\n",
        "\n",
        "### **How to Obtain Bing Cookie**\n",
        "To use Bing Image Creator, you need to obtain the necessary cookie value. Follow these steps:\n",
        "\n",
        "1. Navigate to Bing Image Creator: https://www.bing.com/images/create.\n",
        "2. Log in to your Bing account.\n",
        "3. Open the browser's developer tools:\n",
        "   - Press `F12` or right-click on the page and select \"Inspect\" or \"Inspect Element.\"\n",
        "4. In the Developer Tools, go to the \"Application\" tab.\n",
        "5. Under \"Cookies,\" find and select `https://www.bing.com`.\n",
        "6. Look for the `_U` cookie.\n",
        "7. Copy the value of the `_U` cookie.\n",
        "\n",
        "---\n",
        "### **Okay now I have the `_U` cookie, where do I put it?**\n",
        "#### *Option 1. For single cookie use:*\n",
        "1. Just input your `_U` cookie value into the `bing_cookie` parameter.\n",
        "\n",
        "#### *Option 2. For multi-cookie use (i.e., multiple accounts):*\n",
        "\n",
        "1. Create a Secret named `bing_cookies_yaml` in the Secrets tab (the one with the key icon):\n",
        "2. Input your `_U` cookie value(s) into the Value column following this syntax (the names on the left side don't matter much as they're just for readability. You could just put the names of your accounts there):\n",
        "    ```\n",
        "    account1: {_U cookie value}\n",
        "\n",
        "    account2: {_U cookie value}\n",
        "    ```\n",
        "3. Enable Notebook access to the Secret.\n",
        "\n",
        "---\n",
        "### **How to Use**\n",
        "1. Fill in the necessary parameters: `spreadsheet_id_or_url`, `worksheet_name_or_index`, and `range_value`, as per your Google Sheets setup. The values from this specified range will be fetched and used as prompts.\n",
        "2. Press `Ctrl + F9` to run all cells."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lIYdn1woOS1n",
        "outputId": "9b5269b2-e171-41b1-d76a-a15087ae8e00",
        "vscode": {
          "languageId": "python"
        }
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Mounted at /content/drive\n"
          ]
        }
      ],
      "source": [
        "# @title Set up class GoogleDrive {display-mode: \"form\"}\n",
        "\n",
        "from google.colab import drive\n",
        "import os\n",
        "import shutil\n",
        "\n",
        "class GoogleDrive:\n",
        "    def __init__(self, mount_folder='/content/drive'):\n",
        "        self.mount_folder = mount_folder\n",
        "        if not self.is_drive_mounted():\n",
        "            drive.mount(self.mount_folder)\n",
        "\n",
        "    def is_drive_mounted(self):\n",
        "        # Check if the mount folder exists\n",
        "        return os.path.exists(self.mount_folder)\n",
        "\n",
        "    def create_folder(self, folder_name, parent_folder='MyDrive'):\n",
        "        full_parent_path = os.path.join(self.mount_folder, parent_folder)\n",
        "        folder_path = os.path.join(full_parent_path, folder_name)\n",
        "        # Create both the output folder and the step folder inside it\n",
        "        os.makedirs(folder_path, exist_ok=True)\n",
        "        return folder_path\n",
        "\n",
        "gdrive_client = GoogleDrive()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "gAOgMjIVWWk-",
        "vscode": {
          "languageId": "python"
        }
      },
      "outputs": [],
      "source": [
        "# @title Prompt auth beforehand for class GoogleSheets {display-mode: \"form\"}\n",
        "\n",
        "from google.colab import auth\n",
        "auth.authenticate_user()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "HDDDnsqpWaHX",
        "vscode": {
          "languageId": "python"
        }
      },
      "outputs": [],
      "source": [
        "# @title Install Dependencies {display-mode: \"form\"}\n",
        "\n",
        "%%capture\n",
        "\n",
        "# Update and install chromium-chromedriver\n",
        "!apt-get update\n",
        "!apt-get install chromium-chromedriver -y\n",
        "!cp /usr/lib/chromium-browser/chromedriver /usr/bin\n",
        "\n",
        "# Install Python packages\n",
        "!pip install requests\n",
        "!pip install selenium\n",
        "!pip install seleniumbase\n",
        "!pip install piexif\n",
        "!pip install gspread\n",
        "!pip install PyYAML"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "1DljUPBXWiGE"
      },
      "source": [
        "# Set up Utils and Classes"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ilmxFcoWWlNj",
        "vscode": {
          "languageId": "python"
        }
      },
      "outputs": [],
      "source": [
        "# @title Utils {display-mode: \"form\"}\n",
        "import re\n",
        "\n",
        "def remove_text_in_brackets(text):\n",
        "    # Remove all text within brackets (including the brackets themselves).\n",
        "    return re.sub(r'<[^>]+>', '', text)\n",
        "\n",
        "def print_colored_text(text, color, bold=True):\n",
        "    color_mapping = {\n",
        "        'black': '\\033[30m',\n",
        "        'blue': '\\033[34m',\n",
        "        'red': '\\033[31m',\n",
        "        'yellow': '\\033[33m',\n",
        "        'green': '\\033[32m',\n",
        "    }\n",
        "    color_code = color_mapping.get(color.lower(), '')\n",
        "    # Check if bold is requested\n",
        "    if bold:\n",
        "        color_code += '\\033[1m'\n",
        "    reset_code = '\\033[0m'\n",
        "    print(color_code + text + reset_code)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "80xtWnyXW2T7",
        "vscode": {
          "languageId": "python"
        }
      },
      "outputs": [],
      "source": [
        "# @title Set up class BingImageCreator {display-mode: \"form\"}\n",
        "import os\n",
        "import random\n",
        "import string\n",
        "import time\n",
        "import requests\n",
        "# from selenium import webdriver\n",
        "from selenium.webdriver.common.keys import Keys\n",
        "from selenium.webdriver.common.by import By\n",
        "from selenium.webdriver.support.ui import WebDriverWait\n",
        "from selenium.webdriver.support import expected_conditions as EC\n",
        "from selenium.common.exceptions import TimeoutException\n",
        "from seleniumbase import Driver\n",
        "from urllib.parse import urlparse, urlunparse\n",
        "\n",
        "from IPython.display import Image, HTML\n",
        "import piexif\n",
        "from PIL import Image as PILImage\n",
        "\n",
        "class BingImageCreator:\n",
        "    def __init__(self, prompts, cookie_value=None, save_folder=\"images\"):\n",
        "        self.prompts = prompts if isinstance(prompts, list) else [prompts]\n",
        "        self.cookie_value = cookie_value\n",
        "        self.save_folder = save_folder\n",
        "        self.current_prompt = \"\"\n",
        "        # Setup driver\n",
        "        self.driver = Driver(headless2=True, no_sandbox=True)\n",
        "\n",
        "    def set_prompts(self, new_prompts):\n",
        "        self.prompts = new_prompts if isinstance(new_prompts, list) else [new_prompts]\n",
        "\n",
        "    def set_save_folder(self, new_save_folder):\n",
        "        self.save_folder = new_save_folder\n",
        "\n",
        "    def navigate_to_bing_create_page(self):\n",
        "        self.driver.get(\"https://www.bing.com/images/create\")\n",
        "\n",
        "    def set_cookie(self):\n",
        "        cookie = {\"name\": \"_U\", \"value\": self.cookie_value}\n",
        "        self.driver.add_cookie(cookie)\n",
        "\n",
        "    def enter_prompt(self, prompt):\n",
        "        try:\n",
        "            # Find the search box by its ID and enter a new prompt\n",
        "            search_box = self.driver.find_element(\"id\", \"sb_form_q\")\n",
        "            search_box.clear()  # Clear existing text\n",
        "            formatted_prompt = prompt.replace(\"\\n\", \",\").strip()  # Replace newlines with commas and strip whitespace\n",
        "            limited_prompt = formatted_prompt[:480]  # Limit prompt to 480 characters\n",
        "            search_box.send_keys(limited_prompt)\n",
        "            time.sleep(3)\n",
        "            search_box.send_keys(Keys.RETURN)  # Press Enter\n",
        "            time.sleep(1)  # Introduce a small delay (1 second) for stability\n",
        "        except Exception as e:\n",
        "            print_colored_text(f\"Error: {e}\", \"red\")\n",
        "            self.capture_and_display_screenshot()\n",
        "\n",
        "    def wait_for_loader(self):\n",
        "        time.sleep(3)\n",
        "        try:\n",
        "            # Check if the prompt has been blocked (presence of class \"block_icon\")\n",
        "            if self.driver.find_elements(By.CLASS_NAME, \"block_icon\"):\n",
        "                # Print the error messages\n",
        "                error_mt_elements = self.driver.find_elements(By.CLASS_NAME, \"gil_err_mt\")\n",
        "                error_sbt_elements = self.driver.find_elements(By.CLASS_NAME, \"gil_err_sbt1\")\n",
        "                if error_mt_elements:\n",
        "                    print_colored_text(\"Error Message (gil_err_mt):\", error_mt_elements[0].text, \"red\")\n",
        "                if error_sbt_elements:\n",
        "                    print_colored_text(\"Error Message (gil_err_sbt1):\", error_sbt_elements[0].text, \"red\")\n",
        "                raise Exception(\"Prompt is blocked\")\n",
        "            # Default wait time\n",
        "            time_to_wait_seconds = 30  # Adjust the timeout as needed\n",
        "            wait = WebDriverWait(self.driver, time_to_wait_seconds)\n",
        "            # Wait until the element with ID \"giloader\" is present\n",
        "            wait.until(EC.presence_of_element_located((By.ID, \"giloader\")))  # self.driver.find_element(By.ID, \"giloader\")\n",
        "            # Check if boosts have run out (data-tb attribute of the element with id \"reward_c\" is 0)\n",
        "            reward_element = self.driver.find_element(By.ID, \"reward_c\")\n",
        "            data_tb_value = reward_element.get_attribute(\"data-tb\")\n",
        "            if data_tb_value == \"0\":\n",
        "                # If data-tb is 0, get wait time from the text of the span with id \"gi_rmtime\" e.g. \"1 min wait\", \"45 sec wait\"\n",
        "                time.sleep(1)\n",
        "                # Find all elements with ID \"gi_rmtime\"\n",
        "                wait_time_elements = self.driver.find_elements(By.ID, \"gi_rmtime\")\n",
        "                if wait_time_elements:\n",
        "                    # If at least one element is found, get wait time from the text of the first element\n",
        "                    wait_time_text = wait_time_elements[0].text\n",
        "                    # Split the wait time text into words\n",
        "                    wait_time_words = wait_time_text.split()\n",
        "                    # Extract the numerical value and unit from the wait time text\n",
        "                    value = int(wait_time_words[0])\n",
        "                    unit = wait_time_words[1]\n",
        "                    # Convert minutes or seconds to seconds and add it to the wait time\n",
        "                    if unit == \"min\":\n",
        "                        time_to_wait_seconds += value * 60\n",
        "                    elif unit == \"sec\":\n",
        "                        time_to_wait_seconds += value\n",
        "                else:\n",
        "                    # If no elements are found, default to 1 minute wait\n",
        "                    time_to_wait_seconds += 60\n",
        "            # Wait until the style becomes \"display: none;\"\n",
        "            wait = WebDriverWait(self.driver, time_to_wait_seconds)\n",
        "            print(\"time_to_wait_seconds:\", time_to_wait_seconds)\n",
        "            wait.until(EC.invisibility_of_element_located((By.ID, \"giloader\")))\n",
        "            time.sleep(3)\n",
        "            return True\n",
        "        except Exception as e:\n",
        "            print(f\"Error: {e}\")\n",
        "            self.capture_and_display_screenshot()\n",
        "            return False\n",
        "\n",
        "    def refresh_and_recheck(self, timeout=10):\n",
        "        # 0. Check if the \"Your images are on the way\" popup exists\n",
        "        try:\n",
        "            elements = self.driver.find_elements(By.CSS_SELECTOR, 'div.gi_nb.gi_nb_r.show_n')\n",
        "            if elements:\n",
        "                popup_text = elements[0].text.replace(\"\\n\", \". \")\n",
        "                print_colored_text(f\"Popup found: {popup_text}\", \"yellow\")\n",
        "                timeout = 150  # Change the timeout if the popup is found\n",
        "        except:\n",
        "            pass\n",
        "        print(\"Refreshing and rechecking for the loader.\")\n",
        "        self.driver.refresh()\n",
        "        time.sleep(3)\n",
        "        # 1. Check if not class=\"girr_blocked\"\n",
        "        try:\n",
        "            WebDriverWait(self.driver, timeout).until_not(\n",
        "                EC.presence_of_element_located((By.CSS_SELECTOR, '#girrcc > div:first-child.girr_blocked'))\n",
        "            )\n",
        "            print(\"The first child div does not have class 'girr_blocked'\")\n",
        "        except Exception as e:\n",
        "            print(f\"The first child div has class 'girr_blocked': {e}\")\n",
        "            return False\n",
        "        # 2. Check if not imgcount=\"0\"\n",
        "        unwanted_element = '.girr_set.seled[data-imgcount=\"0\"]'\n",
        "        try:\n",
        "            WebDriverWait(self.driver, timeout).until_not(\n",
        "                EC.presence_of_element_located((By.CSS_SELECTOR, unwanted_element))\n",
        "            )\n",
        "            print(\"The image count is greater than 0.\")\n",
        "            return True\n",
        "        # Handle timeout by refreshing the page and trying again\n",
        "        except TimeoutException:\n",
        "            print(\"Timeout exceeded. Refreshing the page and trying again.\")\n",
        "            self.driver.refresh()\n",
        "            time.sleep(3)\n",
        "            try:\n",
        "                # Check if not class=\"gislowtlt\" (Your images are currently in progress)\n",
        "                WebDriverWait(self.driver, timeout).until_not(\n",
        "                    EC.presence_of_element_located((By.CSS_SELECTOR, 'div#giloadhelpc > div.gislowtlt'))\n",
        "                )\n",
        "                timeout = 150  # Change the timeout if the loader is found\n",
        "            except:\n",
        "                pass\n",
        "            try:\n",
        "                # Wait again after refresh\n",
        "                WebDriverWait(self.driver, timeout).until_not(\n",
        "                    EC.presence_of_element_located((By.CSS_SELECTOR, unwanted_element))\n",
        "                )\n",
        "                print(\"The image count is greater than 0 after refresh.\")\n",
        "                return True\n",
        "            # Handle timeout after refresh\n",
        "            except TimeoutException:\n",
        "                print(\"Timeout exceeded after refresh. The image count is still 0.\")\n",
        "                return False\n",
        "        # Handle other exceptions\n",
        "        except Exception as e:\n",
        "            print(f\"Error: {e}\")\n",
        "            # self.capture_and_display_screenshot()\n",
        "            return False\n",
        "\n",
        "    @staticmethod\n",
        "    def remove_middle_text(text, max_length, indicator=\"___\"):\n",
        "        \"\"\"\n",
        "        Remove excess characters from the middle of the text if its length exceeds the specified maximum.\n",
        "        \"\"\"\n",
        "        if len(text) > max_length:\n",
        "            excess_chars = len(text) - max_length\n",
        "            chars_to_remove_from_middle = (\n",
        "                excess_chars + 1\n",
        "            ) // 2  # Calculate the number of characters to remove from the middle\n",
        "            start_index = (len(text) - max_length - chars_to_remove_from_middle) // 2\n",
        "            end_index = start_index + max_length\n",
        "            text = text[:start_index] + indicator + text[end_index:]\n",
        "        return text\n",
        "\n",
        "    @classmethod\n",
        "    def sanitize_filename(self, filename):\n",
        "        \"\"\"\n",
        "        Sanitize the given filename to make it compatible across different operating systems.\n",
        "        \"\"\"\n",
        "        valid_chars = set(\"-_.() %s%s\" % (string.ascii_letters, string.digits))\n",
        "        sanitized_filename = \"\".join(c if c in valid_chars else \"_\" for c in filename)\n",
        "        # Limit the filename length to 196 characters\n",
        "        max_length = 196\n",
        "        sanitized_filename = self.remove_middle_text(sanitized_filename, max_length)\n",
        "        # Remove leading and trailing underscores\n",
        "        sanitized_filename = sanitized_filename.strip(\"_\")\n",
        "        # Truncate the filename from the right to a maximum length of 196 characters\n",
        "        sanitized_filename = (\n",
        "            sanitized_filename[-max_length:]\n",
        "            if len(sanitized_filename) > max_length\n",
        "            else sanitized_filename\n",
        "        )\n",
        "        # If the filename is empty, generate a random string and append to \"unnamed\"\n",
        "        if not sanitized_filename:\n",
        "            random_string = \"\".join(\n",
        "                random.choice(string.ascii_letters + string.digits) for _ in range(8)\n",
        "            )\n",
        "            sanitized_filename = f\"unnamed_{random_string}\"\n",
        "        return sanitized_filename\n",
        "\n",
        "    @staticmethod\n",
        "    def generate_random_string():\n",
        "        random_string = ''.join(random.choices(string.ascii_letters + string.digits, k=3))\n",
        "        return random_string\n",
        "\n",
        "    def download_images(self):\n",
        "        try:\n",
        "            # Select .mimg elements that are descendants of .img_cont\n",
        "            image_elements = self.driver.find_elements(\n",
        "                By.CSS_SELECTOR, \".img_cont .mimg\"\n",
        "            )\n",
        "            image_urls = [element.get_attribute(\"src\") for element in image_elements]\n",
        "            # Create the save folder if it doesn't exist\n",
        "            os.makedirs(self.save_folder, exist_ok=True)\n",
        "            # Download images using alt values as sanitized file names\n",
        "            random_string = self.generate_random_string()\n",
        "            for url, element in zip(image_urls, image_elements):\n",
        "                alt = element.get_attribute(\"alt\")\n",
        "                sanitized_alt = self.sanitize_filename(alt)\n",
        "                # Remove unwanted parameters from the URL\n",
        "                parsed_url = urlparse(url)\n",
        "                new_url = urlunparse(\n",
        "                    (\n",
        "                        parsed_url.scheme,\n",
        "                        parsed_url.netloc,\n",
        "                        parsed_url.path,\n",
        "                        parsed_url.params,\n",
        "                        \"\",\n",
        "                        \"\",\n",
        "                    )\n",
        "                )\n",
        "                new_url += \"?pid=ImgGn\"\n",
        "                # Retrieve the full image content\n",
        "                response = requests.get(new_url)\n",
        "                # Modify the file path to save the images to Google Drive\n",
        "                file_path = os.path.join(self.save_folder, f\"{sanitized_alt}_{random_string}.jpg\")\n",
        "                # Write the image content to the file\n",
        "                with open(file_path, \"wb\") as f:\n",
        "                    f.write(response.content)\n",
        "                print_colored_text(f'Image saved to \"{file_path}\".', 'blue')\n",
        "                # Write self.prompt as description metadata of the image\n",
        "                self.add_description_to_image(file_path, self.current_prompt)\n",
        "\n",
        "            # Save self.prompt as a text file with the same name as the first sanitized_alt\n",
        "            first_sanitized_alt = self.sanitize_filename(image_elements[0].get_attribute(\"alt\"))\n",
        "            prompt_file_path = os.path.join(self.save_folder, \"prompts\", f\"{first_sanitized_alt}.txt\")\n",
        "            os.makedirs(os.path.dirname(prompt_file_path), exist_ok=True)\n",
        "            with open(prompt_file_path, \"w\", encoding=\"utf-8\") as prompt_file:\n",
        "                prompt_file.write(self.current_prompt)\n",
        "            print_colored_text(f'Prompt saved to \"{prompt_file_path}\".', 'green')\n",
        "            # Display preview images in a grid\n",
        "            self.display_images_in_grid(image_urls)\n",
        "        except Exception as e:\n",
        "            print(f\"Error: {e}\")\n",
        "\n",
        "    @staticmethod\n",
        "    def display_images_in_grid(image_urls):\n",
        "        \"\"\"\n",
        "        Display a list of images in a grid layout.\n",
        "        Args:\n",
        "            image_urls (list): A list of URLs of the images to display.\n",
        "        \"\"\"\n",
        "        # HTML code for displaying images in a grid\n",
        "        html_code = \"<div style='display: flex; flex-wrap: wrap;'>\"\n",
        "        for url in image_urls:\n",
        "            html_code += f\"<img src='{url}' style='width: 200px; height: 200px; margin: 5px;'>\"\n",
        "        html_code += \"</div>\"\n",
        "        # Display the HTML code\n",
        "        display(HTML(html_code))\n",
        "\n",
        "    def capture_and_display_screenshot(self, output_path='screenshot.png'):\n",
        "        try:\n",
        "            self.driver.save_screenshot(output_path)\n",
        "            display(Image(output_path))\n",
        "        except Exception as e:\n",
        "            print(f\"Error: {e}\")\n",
        "\n",
        "    @staticmethod\n",
        "    def add_description_to_image(file_path, description):\n",
        "        try:\n",
        "            # Open the image\n",
        "            img = PILImage.open(file_path)\n",
        "            # Get the existing Exif data (if any)\n",
        "            exif_dict = piexif.load(img.info[\"exif\"])\n",
        "            # Modify or add the 'Description' tag in the Exif data\n",
        "            exif_dict['0th'][piexif.ImageIFD.ImageDescription] = description\n",
        "            # Dump the modified Exif data back to bytes\n",
        "            exif_bytes = piexif.dump(exif_dict)\n",
        "            # Save the image with the updated Exif data\n",
        "            img.save(file_path, exif=exif_bytes)\n",
        "            # Close the image\n",
        "            img.close()\n",
        "        except Exception as e:\n",
        "            print_colored_text(f\"An error occurred while saving description to image: {str(e)}\", \"red\")\n",
        "\n",
        "    def run(self):\n",
        "        try:\n",
        "            for prompt in self.prompts:\n",
        "                self.navigate_to_bing_create_page()\n",
        "                self.set_cookie()\n",
        "                self.driver.refresh()\n",
        "                # self.capture_and_display_screenshot()\n",
        "                self.current_prompt = prompt\n",
        "                self.enter_prompt(self.current_prompt)\n",
        "                # self.capture_and_display_screenshot()\n",
        "                try:\n",
        "                    if self.wait_for_loader():\n",
        "                        self.download_images()\n",
        "                    else:\n",
        "                        if self.refresh_and_recheck():\n",
        "                            self.download_images()\n",
        "                except Exception:\n",
        "                    if self.refresh_and_recheck():\n",
        "                        self.download_images()\n",
        "            self.driver.quit()\n",
        "        except Exception as e:\n",
        "            print(f\"Error: {e}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "zHfo35yiXAvf",
        "vscode": {
          "languageId": "python"
        }
      },
      "outputs": [],
      "source": [
        "# @title Set up class GoogleSheets {display-mode: \"form\"}\n",
        "import gspread\n",
        "from google.auth import default\n",
        "from google.auth.transport.requests import Request\n",
        "from google.auth.exceptions import RefreshError\n",
        "\n",
        "class GoogleSheets:\n",
        "    def __init__(self, spreadsheet_id_or_url, worksheet_name_or_index):\n",
        "            self.spreadsheet_id_or_url = spreadsheet_id_or_url\n",
        "            self.worksheet_name_or_index = worksheet_name_or_index\n",
        "            self.gc = self.authenticate_and_authorize()\n",
        "            self.worksheet, self.title = self.open_google_sheets()\n",
        "\n",
        "    def authenticate_and_authorize(self):\n",
        "        credentials, _ = default()\n",
        "        try:\n",
        "            gc = gspread.authorize(credentials)\n",
        "        except RefreshError:\n",
        "            credentials.refresh(Request())\n",
        "            gc = gspread.authorize(credentials)\n",
        "        return gc\n",
        "\n",
        "    def open_google_sheets(self):\n",
        "        if self.spreadsheet_id_or_url.startswith(\"https://docs.google.com/spreadsheets/d/\"):\n",
        "            spreadsheet = self.gc.open_by_url(self.spreadsheet_id_or_url)\n",
        "        else:\n",
        "            spreadsheet = self.gc.open_by_key(self.spreadsheet_id_or_url)\n",
        "        worksheet = spreadsheet.worksheet(self.worksheet_name_or_index)\n",
        "        return worksheet, spreadsheet.title\n",
        "\n",
        "    def get(self, range):\n",
        "        # Fetch all values from a range of cells.\n",
        "        range_values = self.worksheet.get(range)\n",
        "        return range_values"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "j6RBdDvJX3Xa"
      },
      "source": [
        "# Execution"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "skpKv5glYXOy",
        "outputId": "2fb090aa-4559-4a15-ae1f-ea2bd3535029",
        "vscode": {
          "languageId": "python"
        }
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\u001b[30m\u001b[1mPrompt 1: origami style pikachu . paper art, pleated paper, folded, origami art, pleats, cut and fold, centered composition\u001b[0m\n",
            "Folder path: /content/drive/MyDrive/bing_image_creator_dalle3_batch/2024-02-18\n",
            "time_to_wait_seconds: 30\n",
            "\u001b[34m\u001b[1mImage saved to \"/content/drive/MyDrive/bing_image_creator_dalle3_batch/2024-02-18/origami style pikachu . paper art_ pleated paper_ folded_ origami art_ pleats_ cut and fold_ centered composition. Image 1 of 4.jpg\".\u001b[0m\n",
            "\u001b[34m\u001b[1mImage saved to \"/content/drive/MyDrive/bing_image_creator_dalle3_batch/2024-02-18/origami style pikachu . paper art_ pleated paper_ folded_ origami art_ pleats_ cut and fold_ centered composition. Image 2 of 4.jpg\".\u001b[0m\n",
            "\u001b[34m\u001b[1mImage saved to \"/content/drive/MyDrive/bing_image_creator_dalle3_batch/2024-02-18/origami style pikachu . paper art_ pleated paper_ folded_ origami art_ pleats_ cut and fold_ centered composition. Image 3 of 4.jpg\".\u001b[0m\n",
            "\u001b[34m\u001b[1mImage saved to \"/content/drive/MyDrive/bing_image_creator_dalle3_batch/2024-02-18/origami style pikachu . paper art_ pleated paper_ folded_ origami art_ pleats_ cut and fold_ centered composition. Image 4 of 4.jpg\".\u001b[0m\n",
            "\u001b[32m\u001b[1mPrompt saved to \"/content/drive/MyDrive/bing_image_creator_dalle3_batch/2024-02-18/prompts/origami style pikachu . paper art_ pleated paper_ folded_ origami art_ pleats_ cut and fold_ centered composition. Image 1 of 4.txt\".\u001b[0m\n"
          ]
        },
        {
          "data": {
            "text/html": [
              "<div style='display: flex; flex-wrap: wrap;'><img src='https://th.bing.com/th/id/OIG4.7yL1WQ3eHBEn7badRwDN?w=270&h=270&c=6&r=0&o=5&pid=ImgGn' style='width: 200px; height: 200px; margin: 5px;'><img src='https://th.bing.com/th/id/OIG4.u.Ye6zTzmEwSOqMzRCWH?w=270&h=270&c=6&r=0&o=5&pid=ImgGn' style='width: 200px; height: 200px; margin: 5px;'><img src='https://th.bing.com/th/id/OIG4.24iTJR8L4.yB1i3wFgPN?w=270&h=270&c=6&r=0&o=5&pid=ImgGn' style='width: 200px; height: 200px; margin: 5px;'><img src='https://th.bing.com/th/id/OIG4._tVnx9OUhQP1vQxFmGH4?w=270&h=270&c=6&r=0&o=5&pid=ImgGn' style='width: 200px; height: 200px; margin: 5px;'></div>"
            ],
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\n"
          ]
        }
      ],
      "source": [
        "# @title Run {display-mode: \"form\"}\n",
        "\n",
        "from google.colab import userdata\n",
        "import yaml\n",
        "from datetime import date\n",
        "from IPython.display import clear_output\n",
        "\n",
        "# Value of the _U cookie;\n",
        "# Leave this empty if you are using the bing_cookies_yaml secret.\n",
        "bing_cookie = \"\"  # @param {type:\"string\"}\n",
        "\n",
        "# Step 1: Create folder 'bing_image_creator_dalle3_batch'\n",
        "folder_name = 'bing_image_creator_dalle3_batch'\n",
        "save_folder = gdrive_client.create_folder(folder_name)\n",
        "\n",
        "# Step 2: Configure GoogleSheets client\n",
        "spreadsheet_id_or_url = \"https://docs.google.com/spreadsheets/d/...\"  # @param {type:\"string\"}\n",
        "worksheet_name_or_index = \"Sheet1\"  # @param {type:\"string\"}\n",
        "range = \"A2:A\"  # @param {type:\"string\"}\n",
        "gsheets_client = GoogleSheets(spreadsheet_id_or_url,\n",
        "                              worksheet_name_or_index)\n",
        "\n",
        "# Print formatted range\n",
        "print_colored_text(f\"{gsheets_client.title}/'{worksheet_name_or_index}'!{range}\", \"black\")\n",
        "print()\n",
        "range_values = gsheets_client.get(range) # Retrieve values from specified range\n",
        "\n",
        "# Step 3: Loop through the prompts and generate them\n",
        "for i, value in enumerate(range_values, 1):\n",
        "    if len(value) == 0:\n",
        "        print_colored_text(f\"Prompt {1}: Cell is empty, skipping...\", \"red\")\n",
        "        continue  # Skip the loop iteration if the value is empty\n",
        "    prompt = value[0].strip()\n",
        "    if prompt:\n",
        "        # Handle cookies\n",
        "        if bing_cookie.strip():  # Check if bing_cookie is not empty\n",
        "            bing_cookies = [bing_cookie]\n",
        "        else:\n",
        "            bing_cookies_yaml = userdata.get('bing_cookies_yaml')\n",
        "            parsed_data = yaml.safe_load(bing_cookies_yaml)  # Parse the YAML content\n",
        "            bing_cookies = [values for values in parsed_data.values()]  # Get all values as a flat list\n",
        "        # Configure class BingImageCreator\n",
        "        num_cookies = len(bing_cookies)  # Calculate the number of cookies in the 'bing_cookies' list\n",
        "        current_date = date.today().strftime(\"%Y-%m-%d\")  # Construct the current date in the \"YYYY-MM-DD\" format\n",
        "        save_folder_with_date = os.path.join(save_folder, current_date) # Append the current date to the save_folder\n",
        "        os.makedirs(save_folder_with_date, exist_ok=True)  # Create the folder if it doesn't exist\n",
        "        cookie_index = (i - 1) % num_cookies # Calculate the index to access the bing_cookies list\n",
        "        print_colored_text(f\"Prompt {i}: {prompt}\", \"black\")\n",
        "        print(\"Folder path:\", save_folder_with_date)\n",
        "        image_creator = BingImageCreator(prompt,\n",
        "                                        save_folder=save_folder_with_date,\n",
        "                                        cookie_value=bing_cookies[cookie_index])\n",
        "        image_creator.run()\n",
        "        print()\n",
        "    # Stop processing if i is the final index\n",
        "    if i == len(range_values):\n",
        "        break\n",
        "    # Clear the output every 5 generations\n",
        "    if i % 5 == 0:\n",
        "        clear_output(wait=True)\n",
        "        # Print the formatted range after clearing the output\n",
        "        print_colored_text(f\"{gsheets_client.title}/'{worksheet_name_or_index}'!{range}\", \"black\")\n",
        "        print()"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "provenance": [],
      "toc_visible": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}