volatile_concentration_localux_colab.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "view-in-github"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/etherealxx/volatile-concentration-localux-colab/blob/main/volatile_concentration_localux_colab.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "e78dCt3JZ6UX"
      },
      "source": [
        "##***Project `VCL-colab`***\n",
        "### All camenduru colab in one spot, synced in realtime\n",
        "###### Last time updated: Feb 12, 24\n",
        "###### (something doesn't work properly? Make sure you use the [latest version](https://colab.research.google.com/github/etherealxx/volatile-concentration-localux-colab/blob/main/volatile_concentration_localux_colab.ipynb), or [report a bug](https://github.com/etherealxx/volatile-concentration-localux-colab/issues).)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mRkHg3INcszO"
      },
      "source": [
        "######  \n",
        "To use:\n",
        "- Click the play button\n",
        "- Wait for less than a minute, until a UI with **big orange button** shows up\n",
        "- Choose the model you want, **wait** for the **extension checkboxes** to shows up, choose the extension that you wanted, then click the orange button\n",
        "- Just wait for about 8 minute until the webui links shows up on the bottom\n",
        "\n",
        "About the options:\n",
        "- `repo_branch`: Read [here](https://github.com/camenduru/stable-diffusion-webui-colab) (just use `stable` as default)\n",
        "- `choose_models`: Untick this if you're relaunching the UI, or if you don't want to choose model (The webui will always download sd 1.4 model instead)\n",
        "- `controlnet_model`: Tick this if you want to download controlnet models (for controlnet usage). Untick this if you're relaunching the UI. Note that `lite` branch won't download any controlnet model regardless if this checkbox is being ticked or not.\n",
        "\n",
        "Got an Error 403 instead of the UI with big orange button? Read [here](https://github.com/etherealxx/volatile-concentration-localux-colab/blob/main/error403guide.md) to fix it."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4bsCMAOQcSIn"
      },
      "source": [
        "## ⠀\n",
        "(open the hidden cell to show help☝️)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "HRLSD-HXLRNk"
      },
      "outputs": [],
      "source": [
        "#@title 👇 Run this\n",
        "repo_branch = 'stable' #@param [\"lite\", \"stable\", \"nightly\"]\n",
        "choose_models = True #@param {type:\"boolean\"}\n",
        "controlnet_models = False #@param {type:\"boolean\"}\n",
        "\n",
        "print(\"\u001b[1;32mWait for about a minute until a UI with a big orange button shows up below\")\n",
        "print('\u001b[0m')\n",
        "\n",
        "from IPython.display import clear_output\n",
        "import time\n",
        "%cd /content\n",
        "\n",
        "try:\n",
        "  start_colab\n",
        "except:\n",
        "  start_colab = int(time.time())-5\n",
        "# clear_output()\n",
        "\n",
        "%env TF_CPP_MIN_LOG_LEVEL=1\n",
        "!git clone https://github.com/etherealxx/volatile-concentration-localux-colab /content/vcltools\n",
        "!pip install -q gradio==3.41.2\n",
        "!pip install -q pastebin-replace httpx==0.24.1\n",
        "from pastebin_replace import pbreplace\n",
        "\n",
        "emptymodel = False\n",
        "\n",
        "colaboptions = {\n",
        "  \"branch\": repo_branch,\n",
        "  \"filename\": \"stable_diffusion_1_5_webui_colab.ipynb\",\n",
        "  \"part\": \"part2\",\n",
        "  \"controlnet\": controlnet_models,\n",
        "  \"download_model\": choose_models,\n",
        "  \"empty_model\": emptymodel\n",
        "} #default\n",
        "\n",
        "import os, pickle, sys, re, shutil\n",
        "import gradio as gr\n",
        "\n",
        "vclvarpath = '/content/vclvariables'\n",
        "os.makedirs(vclvarpath, exist_ok=True)\n",
        "!python /content/vcltools/cloneall3.py\n",
        "\n",
        "# This will dumps 'sortedcolabname'\n",
        "!python /content/vcltools/choosemodel4.py {repo_branch}\n",
        "\n",
        "def pickledump(vartodump, outputfile):\n",
        "  outputpath = os.path.join(vclvarpath, outputfile + '.pkl')\n",
        "  with open(outputpath, 'wb') as f:\n",
        "      pickle.dump(vartodump, f)\n",
        "\n",
        "def pickleload(prevvalue, inputfile):\n",
        "  inputpath = os.path.join(vclvarpath, inputfile + '.pkl')\n",
        "  if os.path.exists(inputpath):\n",
        "      with open(inputpath, 'rb') as f:\n",
        "          vartopass = pickle.load(f)\n",
        "          return vartopass\n",
        "  else:\n",
        "    return prevvalue\n",
        "\n",
        "vclpath = \"/content/volatile-concentration-localux\"\n",
        "prevbranch = pickleload(None, 'prevbranch')\n",
        "if prevbranch and prevbranch != repo_branch:\n",
        "  !python /content/vcltools/changebranch.py backup\n",
        "  pass\n",
        "\n",
        "# 'sortedcolabname' will not be accessed anymore\n",
        "sortedcolabname = pickleload(None, 'sortedcolabname')\n",
        "\n",
        "!pip install base58\n",
        "import base58\n",
        "# The extension name of that must have extension for sd colabs, enabling multiple gradio UI tunneling at once\n",
        "tunneltext = base58.b58decode(\"FFSgE5cGo6ewBdZ8cwDovS\".encode()).decode()\n",
        "\n",
        "if choose_models:\n",
        "  clear_output(wait=True)\n",
        "\n",
        "everycolab = f'/content/camendurus/{repo_branch}'\n",
        "modelischosen = False\n",
        "modelchosenmessage = ''\n",
        "chosencolabname = ''\n",
        "extensionlines = []\n",
        "extensiontoremove = []\n",
        "\n",
        "def list_additional_ext():\n",
        "  addext_txtpath = \"/content/vcltools/additionalextensions.txt\"\n",
        "  with open(addext_txtpath, 'r') as file:\n",
        "    lines = [line.rstrip('\\n') for line in file]\n",
        "    exts = [ext for ext in lines if ext != \"\" and not ext.startswith(\"#\")]\n",
        "    return exts\n",
        "\n",
        "additionalextension_names = [x.split(\"/\")[-1] for x in list_additional_ext()]\n",
        "\n",
        "def no_model_install_extension():\n",
        "  global choose_models\n",
        "  global colaboptions\n",
        "  global emptymodel\n",
        "  global extensionlines\n",
        "  \n",
        "  extensionlist = []\n",
        "  choose_models = False\n",
        "  colaboptions[\"download_model\"] = False\n",
        "  emptymodel = True\n",
        "\n",
        "  # This script extracts every \"git clone\" line from selected camenduru's colab notebook\n",
        "  # The result is 'extensions' pickle file, containing git clone lines as a python list\n",
        "  !python /content/vcltools/extensioninstaller3.py\n",
        "  \n",
        "  extensionlines = pickleload(extensionlines, 'extensions')\n",
        "\n",
        "  for ext_gitcloneline in extensionlines:\n",
        "      pattern = r\"https://github.com/\\S+/(\\S+)\"\n",
        "      match = re.search(pattern, ext_gitcloneline)\n",
        "      if match:\n",
        "          ext_name = match.group(1)\n",
        "          if not ext_name == tunneltext:\n",
        "            extensionlist.append(ext_name)\n",
        "          # print(repo_name)\n",
        "  pickledump(extensionlist, 'fullextensions')\n",
        "\n",
        "def modelchosen(chosenmodel, chosenextension):\n",
        "  global modelischosen\n",
        "  global modelchosenmessage\n",
        "  global chosencolabname\n",
        "  global colaboptions\n",
        "  global choose_models\n",
        "  global extensionlines\n",
        "  global extensiontoremove\n",
        "  global emptymodel\n",
        "\n",
        "  # for link in extensionlines:\n",
        "  #     match = re.search(r\"https://github.com/\\S+/(\\S+)\", link)\n",
        "  #     if match:\n",
        "  #         repo_name = match.group(1)\n",
        "  #         if repo_name in chosenextension:\n",
        "  #             usedextensionlinks.append(link)\n",
        "  # pickledump(usedextensionlinks, '/content/extensions.pkl')\n",
        "  \n",
        "  # For the first time launching the colab, there will be no 'chosenextension' pickle file\n",
        "  # This will later get accessed after the user choose the model, to preserve the user's chosen extension from previous cell run\n",
        "  pickledump(chosenextension, 'chosenextensions')\n",
        "  \n",
        "  # This will also being accessed by `additionalextension.py`\n",
        "  # WIP\n",
        "  fullextension = pickleload(None, 'fullextensions')\n",
        "  \n",
        "  if fullextension:\n",
        "    extensiontoremove = [x for x in fullextension if x not in chosenextension]\n",
        "  \n",
        "  # This will later accessed by `camendurucolab3.py` to filter only chosen extension that will be cloned\n",
        "  # ... and those who aren't chosen will be removed\n",
        "  pickledump(extensiontoremove, 'removedextensions')\n",
        "  \n",
        "  if chosenmodel:\n",
        "    modelchosenmessage = \"\u001b[1;32mModel \" + chosenmodel + \" was chosen. It'll be downloaded soon. Continue scroll down and wait for the webui to be loaded.\"\n",
        "    textbox_text = f\"Model '{chosenmodel} was chosen. It'll be downloaded soon. Continue scroll down and wait for the webui to be loaded.\"\n",
        "    chosencolabname = chosenmodel\n",
        "    emptymodel = False\n",
        "  else:\n",
        "    modelchosenmessage = \"\u001b[1;32mNo model was chosen. Continue scroll down and wait for the webui to be loaded.\"\n",
        "    textbox_text = f\"No model was chosen. Continue scroll down and wait for the webui to be loaded.\"\n",
        "    \n",
        "    no_model_install_extension()\n",
        "\n",
        "  modelischosen = True\n",
        "  return [gr.Button.update(visible=False), gr.Textbox.update(value=textbox_text, visible=True), gr.CheckboxGroup.update(visible=False),  gr.Dropdown.update(interactive=False)]\n",
        "\n",
        "def extensionschoose(modelthatischosen):\n",
        "    extensionlist = []\n",
        "    global colaboptions\n",
        "    global extensionlines\n",
        "    global additionalextension_names\n",
        "    if modelthatischosen:\n",
        "        colabfilename = modelthatischosen + '_webui_colab.ipynb'\n",
        "        colaboptions[\"filename\"] = colabfilename\n",
        "        # chosencolabfilepath = os.path.join(everycolab, colabfilename)\n",
        "        \n",
        "    # Contains branch name, camenduru's colab notebook name, part (unused),\n",
        "    # ... and three booleans: :controlnet\", \"download_model\", \"empty_model\"\n",
        "    # Need to be loaded in \"camendurucolab3.py\", \"extensioninstaller3.py\", and \"runaria3.py\"\n",
        "    pickledump(colaboptions, 'colaboptions')\n",
        "\n",
        "    # This script extracts every \"git clone\" line from selected camenduru's colab notebook\n",
        "    # The result is 'extensions' pickle file, containing git clone lines as a python list\n",
        "    !python /content/vcltools/extensioninstaller3.py\n",
        "    extensionlines = pickleload(extensionlines, 'extensions')\n",
        "\n",
        "    for ext_gitcloneline in extensionlines:\n",
        "        pattern = r\"https://github.com/\\S+/(\\S+)\"\n",
        "        match = re.search(pattern, ext_gitcloneline)\n",
        "        if match:\n",
        "            ext_name = match.group(1)\n",
        "            if not ext_name == tunneltext:\n",
        "              extensionlist.append(ext_name)\n",
        "            # print(repo_name)\n",
        "            \n",
        "    # Contains only the extension name, excluding the tunnel extension\n",
        "    # This also includes the additional extensions\n",
        "    pickledump(extensionlist, 'fullextensions')\n",
        "\n",
        "    !python /content/vcltools/additionalextension.py\n",
        "    \n",
        "    # Extensions that are from camenduru's repo. Used only as a fallback of 'chosenextensions'\n",
        "    templist = pickleload(None, 'tempext')\n",
        "    \n",
        "    # List of extensions that were choosen by the user\n",
        "    chosenextension = pickleload(templist, 'chosenextensions')\n",
        "\n",
        "    # Group the extensions based from the source (camenduru's colab or additional exts)\n",
        "    # ... and then sort them alphabetically\n",
        "    extensionlist = list(set(extensionlist) - set(additionalextension_names))\n",
        "    extensionlist.sort()\n",
        "    additionalextension_names.sort()\n",
        "    # extensionlist.extend(chosenextension)\n",
        "    for extname in additionalextension_names:\n",
        "      extensionlist.append(extname)\n",
        "\n",
        "    return gr.CheckboxGroup.update(choices=extensionlist, value=chosenextension, visible=True)\n",
        "\n",
        "def dumpchoice(extensionthatischosen):\n",
        "  # Always update whenever user modifies the extensions checkboxes\n",
        "  pickledump(extensionthatischosen, 'chosenextensions')\n",
        "\n",
        "with gr.Blocks() as vclcolab:\n",
        "    with gr.Column():\n",
        "      choose = gr.Dropdown(sortedcolabname, label=\"Choose Your Model\", interactive=True)\n",
        "      confirm = gr.Button(\"Use This Model\", variant=\"primary\", visible=True)\n",
        "      donetext = gr.Textbox(\"\", label=\"\", visible=False)\n",
        "      extchooser = gr.CheckboxGroup([\"placeholder\"], label=\"Extensions\", info=\"Untick the checkboxes on those extensions that you want to disable\", visible=False, interactive=True)\n",
        "      confirm.click(modelchosen, inputs=[choose, extchooser], outputs=[confirm, donetext, extchooser, choose])\n",
        "      choose.change(extensionschoose, inputs=[choose], outputs=[extchooser])\n",
        "      extchooser.change(dumpchoice, inputs=[extchooser])\n",
        "\n",
        "gr.close_all()\n",
        "if choose_models:\n",
        "  tryport = 7860\n",
        "  while True:\n",
        "    tryport += 1\n",
        "    try:\n",
        "      print(\"\u001b[1;32mNo need to click on the public url yet. Just wait until a UI with a big orange button shows up below\")\n",
        "      print(\"\u001b[1;32mIf 'Error 403' shows instead, click the stop button twice until 'Gradio UI interrupted' message shows up, then read here: https://github.com/etherealxx/volatile-concentration-localux-colab/blob/main/error403guide.md\")\n",
        "      print('\u001b[0m')\n",
        "      vclcolab.launch(server_port=tryport)\n",
        "      break\n",
        "    except OSError:\n",
        "      pass\n",
        "\n",
        "  while True:\n",
        "    try:\n",
        "      if modelischosen:\n",
        "        clear_output(wait=True)\n",
        "        print(modelchosenmessage)\n",
        "        print('\u001b[0m')\n",
        "        vclcolab.close()\n",
        "        break\n",
        "    except KeyboardInterrupt:\n",
        "      clear_output(wait=True)\n",
        "      print(\"\u001b[1;33mGradio UI interrupted\")\n",
        "      print('\u001b[0m')\n",
        "      vclcolab.close()\n",
        "      # sys.exit()\n",
        "      # os._exit(1)\n",
        "      break\n",
        "\n",
        "aria2c_lines = []\n",
        "colabfilename = ''\n",
        "chosencolabfilepath = os.path.join(everycolab, colaboptions[\"filename\"])\n",
        "\n",
        "if chosencolabname:\n",
        "   colabfilename = chosencolabname + '_webui_colab.ipynb'\n",
        "   colaboptions[\"filename\"] = colabfilename\n",
        "   chosencolabfilepath = os.path.join(everycolab, colabfilename)\n",
        "\n",
        "if os.path.exists(chosencolabfilepath):\n",
        "  print(\"\u001b[1;32mGathering aria2c code from \" + chosencolabfilepath + \"...\")\n",
        "  print('\u001b[0m')\n",
        "  with open(chosencolabfilepath, 'r', encoding='utf-8') as f:\n",
        "      for line in f:\n",
        "          stripped_line = line.strip()\n",
        "          if stripped_line.startswith('\"!aria2c'):\n",
        "              aria2c_lines.append(stripped_line)\n",
        "\n",
        "if aria2c_lines:\n",
        "  # Every aria2c lines in camenduru's notebook, in which case it's either a checkpoint model, controlnet model, or a vae link\n",
        "  pickledump(aria2c_lines, 'arialist')\n",
        "\n",
        "colaboptions[\"empty_model\"] = emptymodel\n",
        "\n",
        "pickledump(colaboptions, 'colaboptions')\n",
        "\n",
        "# !python /content/vcltools/camendurucolab.py {colabfilename} {repo_branch} part1\n",
        "!apt -y update -qq\n",
        "#👇 Memory fix by camenduru & slowargo\n",
        "if not os.path.exists(\"/content/libtcmalloc_minimal.so.4\"):\n",
        "  !git clone -b colab https://github.com/camenduru/gperftools\n",
        "  %cd /content/gperftools\n",
        "  %env CXXFLAGS=-std=c++14\n",
        "  !chmod +x /content/gperftools/configure\n",
        "  print(\"building libtcmalloc_minimal.so.4, please wait...\")\n",
        "  !(./configure --enable-minimal --enable-libunwind --enable-frame-pointers --enable-dynamic-sized-delete-support --enable-sized-delete --enable-emergency-malloc; make -j4) > /content/libtcmalloc_buildlog.txt 2>&1\n",
        "  !cp .libs/libtcmalloc*.so* /content\n",
        "%env LD_PRELOAD=/content/libtcmalloc_minimal.so.4\n",
        "%cd /content\n",
        "\n",
        "def thispickleexist(filename):\n",
        "  return os.path.exists(os.path.join(vclvarpath, filename + \".pkl\"))\n",
        "\n",
        "if not thispickleexist(\"extensions\") or not thispickleexist(\"removedextensions\"):\n",
        "  no_model_install_extension()\n",
        "\n",
        "# This runs every download process from camenduru's notebook, like git clones\n",
        "# Needs 'colaboptions', 'extensions', and 'removedextensions'\n",
        "!python /content/vcltools/camendurucolab3.py #{colabfilename} {repo_branch} part2\n",
        "\n",
        "# This runs the aria2c lines\n",
        "!python /content/vcltools/runaria3.py\n",
        "\n",
        "%cd /content/volatile-concentration-localux\n",
        "\n",
        "# if extensiontoremove and not emptymodel:\n",
        "#   for ext in extensiontoremove:\n",
        "#     extpath = os.path.join('/content/volatile-concentration-localux/extensions', ext)\n",
        "#     if os.path.exists(extpath):\n",
        "#       shutil.rmtree(extpath)\n",
        "#       print(f\"removed {ext} extension\")\n",
        "\n",
        "# !python /content/vcltools/camendurucolab.py {colabfilename} {repo_branch} part3\n",
        "\n",
        "if prevbranch and prevbranch != repo_branch:\n",
        "  !python /content/vcltools/changebranch.py restore\n",
        "pickledump(repo_branch, \"prevbranch\")\n",
        "\n",
        "# 👇 Now it's being handled in camendurucolab3.py\n",
        "# !sed -i -e '''/from modules import launch_utils/a\\import os''' /content/volatile-concentration-localux/launch.py\n",
        "# !sed -i -e '''/        prepare_environment()/a\\        os.system\\(f\\\"\"\"sed -i -e ''\\\"s/dict()))/dict())).cuda()/g\\\"'' /content/volatile-concentration-localux/repositories/stable-diffusion-stability-ai/ldm/util.py\"\"\")''' /content/volatile-concentration-localux/launch.py\n",
        "# !sed -i -e 's/\\\"sd_model_checkpoint\\\"\\]/\\\"sd_model_checkpoint\\\"\\,\\\"sd_vae\\\"\\,\\\"CLIP_stop_at_last_layers\\\"\\]/g' /content/volatile-concentration-localux/modules/shared.py\n",
        "\n",
        "print(\"\u001b[1;32mlaunching the webui...\")\n",
        "print('\u001b[0m')\n",
        "\n",
        "!python /content/vcltools/setuptimer.py\n",
        "!echo -n {start_colab} > /content/volatile-concentration-localux/static/colabTimer.txt\n",
        "!wget -q https://raw.githubusercontent.com/etherealxx/batchlinks-webui/main/notification.mp3 -P /content/volatile-concentration-localux\n",
        "\n",
        "!python launch.py --listen --xformers --enable-insecure-extension-access --theme dark --gradio-queue --multiple --disable-model-loading-ram-optimization"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZGlOpxFdEIB5"
      },
      "source": [
        "(If you got 'Error 403' when the big orange button is supposed to shows up, read [here](https://github.com/etherealxx/volatile-concentration-localux-colab/blob/main/error403guide.md) for the fix)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dYiw0gLVRpTz"
      },
      "source": [
        "## ⠀"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0BEVRlWUcbj3"
      },
      "source": [
        " ### (debug area)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ZokmtbXibfQf"
      },
      "outputs": [],
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "pij1YzxGDw7y"
      },
      "outputs": [],
      "source": [
        "!rm -rf /content/vclvariables\n",
        "!rm -rf /content/volatile-concentration-localux\n",
        "!rm -rf /content/vcltools\n",
        "%cd /content\n",
        "!git clone -b dev9 https://github.com/etherealxx/volatile-concentration-localux-colab /content/vcltools"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "e-bXoxXtbgeY"
      },
      "outputs": [],
      "source": [
        "import os\n",
        "import shutil\n",
        "\n",
        "def copy_files(source_dir, destination_dir):\n",
        "    # Create destination directory if it doesn't exist\n",
        "    if not os.path.exists(destination_dir):\n",
        "        os.makedirs(destination_dir)\n",
        "        print(f\"Created directory: {destination_dir}\")\n",
        "\n",
        "    # Get the list of files in the source directory\n",
        "    files = os.listdir(source_dir)\n",
        "\n",
        "    for file in files:\n",
        "        source_file = os.path.join(source_dir, file)\n",
        "        destination_file = os.path.join(destination_dir, file)\n",
        "\n",
        "        # Copy the file to the destination directory\n",
        "        shutil.copy2(source_file, destination_file)\n",
        "\n",
        "        # Print success message with the filename\n",
        "        print(f\"Successfully copied {file}.\")\n",
        "\n",
        "# Specify the source and destination directories\n",
        "folder_A = \"/content/volatile-concentration-localux/outputs/txt2img-images/xxx\"\n",
        "folder_B = \"/content/drive/MyDrive/xxx\"\n",
        "\n",
        "# Copy files from folder A to folder B\n",
        "copy_files(folder_A, folder_B)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "# to remove folder and it's subdirectories from a specific path. Need this bcoz of the keyword ban\n",
        "import os\n",
        "keyword = \"reactor\"\n",
        "\n",
        "extpath = \"/content/volatile-concentration-localux/extensions\"\n",
        "for folder in os.listdir(extpath):\n",
        "  if keyword in folder:\n",
        "    folderpath = os.path.join(extpath, folder)\n",
        "    !rm -rf {folderpath}"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "nSGdJN0OAqDL"
      },
      "outputs": [],
      "source": [
        "%cd /content\n",
        "!git clone https://github.com/etherealxx/volatile-concentration-localux-colab /content/colabtools"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "g4UAZfaZ4wgo"
      },
      "outputs": [],
      "source": [
        "!rm -rf /content/volatile-concentration-localux\n",
        "!rm -rf /content/camendurus\n",
        "!rm /content/frpc_linux_amd64"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "--HDCkoxCHnT"
      },
      "outputs": [],
      "source": [
        "import os, pickle\n",
        "\n",
        "toopen = '/content/vclvariables/extensions.pkl'\n",
        "\n",
        "if os.path.exists(toopen):\n",
        "  with open(toopen, 'rb') as f:\n",
        "      arialines2 = pickle.load(f)\n",
        "\n",
        "for line in arialines2:\n",
        "  print(line)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "pE0A4A_jGXkR"
      },
      "outputs": [],
      "source": [
        "repo_branch = 'nightly' #@param [\"lite\", \"stable\", \"nightly\"]\n",
        "\n",
        "colaboptions = {\n",
        "  \"branch\": repo_branch,\n",
        "  \"filename\": \"stable_diffusion_1_5_webui_colab.ipynb\",\n",
        "  \"part\": \"part2\"\n",
        "} #default\n",
        "\n",
        "\n",
        "print(colaboptions['branch'])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ouZRtBpEMq3V"
      },
      "outputs": [],
      "source": [
        "with open('/content/camendurus/nightly/a_certain_model_webui_colab.ipynb', 'r', encoding='utf-8') as f:\n",
        "    for line in f:\n",
        "        stripped_line = line.strip()\n",
        "        if stripped_line.startswith('\"!aria2c'):\n",
        "            # aria2c_lines.append(stripped_line)\n",
        "            print(\"\u001b[1;32m\" + stripped_line)\n",
        "            print('\u001b[0m')\n",
        "        else:\n",
        "          print(stripped_line)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "jKUgiWbaN-TW"
      },
      "outputs": [],
      "source": [
        "checktest = None\n",
        "with open('/content/arialist.pkl', 'rb') as f:\n",
        "  checktest = pickle.load(f)\n",
        "print(checktest)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "uYmGyckPbZaQ"
      },
      "outputs": [],
      "source": []
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "collapsed_sections": [
        "e78dCt3JZ6UX",
        "0BEVRlWUcbj3"
      ],
      "include_colab_link": true,
      "private_outputs": true,
      "provenance": []
    },
    "gpuClass": "standard",
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "name": "python",
      "version": "3.9.6"
    },
    "vscode": {
      "interpreter": {
        "hash": "31f2aee4e71d21fbe5cf8b01ff0e069b9275f58929596ceb00d14d90e3e16cd6"
      }
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}