Spacedust.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/soedinglab/spacedust/blob/master/Spacedust.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tpODUT424Iw5"
      },
      "source": [
        "# Spacedust: *de novo* discovery of conserved gene clusters in microbial genomes\n",
        "---\n",
        "\n",
        "<img src=\"https://raw.githubusercontent.com/soedinglab/spacedust/master/.github/spacedust.png\" height=\"200\" align=\"right\" style=\"height:200px\"/>\n",
        "\n",
        "Spacedust is a modular toolkit for identification of conserved gene clusters among multiple genomes based on homology and conservation of gene neighborhood. Spacedust adapts the fast and sensitive structure comparisons of [Foldseek](https://github.com/steineggerlab/foldseek) and homology search capabilities of [MMseqs2](https://github.com/soedinglab/MMseqs2). It introduces a novel approach of aggregating sets of homologous hits between pairs of genomes and identifies cluster of hits with conserved gene neighborhood between each using agglomerative hierarchical clustering algorithm. Spacedust is GPLv3-licensed open source software implemented in C++ and available for Linux and macOS. The software is designed to run efficiently on multiple cores.\n",
        "\n",
        "<!-- [Zhang, R., Mirdita, M., Levy Karin, E., Norroy, C., Galiez, C., & Söding, J.  SpacePHARER: Sensitive identification of phages from CRISPR spacers in prokaryotic hosts. Bioinformatics, doi:10.1093/bioinformatics/btab222 (2021).](https://doi.org/10.1093/bioinformatics/btab222) -->\n",
        "\n",
        "**Input**\n",
        "\n",
        "* Each file should contain one genome. Genomes should be uploaded as:\n",
        "  * `.fna` files and turn on the `run_prodigal` option, or\n",
        "  * `.faa` files with header in Prodigal format\n",
        "  "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rA59mKzFQlKu",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 93
        },
        "outputId": "103ae88d-feb9-4622-acb5-44385d2867b2",
        "cellView": "form"
      },
      "source": [
        "#@title Set parameters, hit `Runtime` -> `Run all`, wait for file input box to appear below this cell to upload  1) all your query genome files and 2) your target genome files\n",
        "jobname = 'test' #@param {type:\"string\"}\n",
        "#@markdown ---\n",
        "#@markdown Input options (`target_db` is ignored if `input_mode` is `all-against-all`)\n",
        "input_mode = \"query-target\" #@param [\"query-target\", \"all-against-all\"]\n",
        "target_db=\"KEGG_70\" #@param [\"self-uploaded\", \"KEGG_70\"]\n",
        "search_mode = \"MMseqs2\" #@param [\"MMseqs2\"]\n",
        "run_prodigal = True #@param {type:\"boolean\"}\n",
        "#@markdown ---\n",
        "#@markdown Advanced options\n",
        "max_gene_gap = 3 #@param {type:\"integer\"}\n",
        "num_iterations = 1 #@param {type:\"integer\"}\n",
        "#@markdown ---\n",
        "#@markdown Don't forget to hit `Runtime` -> `Run all` after updating the form. A input box will appear below this text. Upload your genomes.\n",
        "\n",
        "jobname = \"\".join(jobname.split())\n",
        "\n",
        "input_type = 0\n",
        "if input_mode == \"all-against-all\":\n",
        "  input_type = 1\n",
        "\n",
        "target_type = 0\n",
        "if target_db != \"self-uploaded\":\n",
        "  target_type = 1\n",
        "\n",
        "search_type = 0\n",
        "if search_mode == \"Foldseek\":\n",
        "  search_type = 1\n",
        "\n",
        "\n",
        "import os\n",
        "import shutil\n",
        "from google.colab import files\n",
        "\n",
        "# Clear and recreate the input directory\n",
        "shutil.rmtree(jobname + \"_input\", ignore_errors=True)\n",
        "os.makedirs(jobname + \"_input\", exist_ok=True)\n",
        "\n",
        "# Upload files and count them\n",
        "uploaded = files.upload()\n",
        "num_queries = len(uploaded.keys())\n",
        "\n",
        "# Check if the number of queries is more than 1 for all-against-all mode\n",
        "if input_type == 1 and num_queries <= 1:\n",
        "    raise ValueError(\"Error: 'all-against-all' mode requires more than 1 query file.\")\n",
        "\n",
        "# Move uploaded files to the input directory\n",
        "for fn in uploaded.keys():\n",
        "    os.replace(fn, os.path.join(jobname + \"_input\", fn))\n",
        "\n",
        "# Handle target database upload if needed\n",
        "if input_type == 0 and target_type == 0:\n",
        "    shutil.rmtree(jobname + \"_target\", ignore_errors=True)\n",
        "    os.makedirs(jobname + \"_target\", exist_ok=True)\n",
        "    uploaded = files.upload()\n",
        "    for fn in uploaded.keys():\n",
        "        os.replace(fn, os.path.join(jobname + \"_target\", fn))\n"
      ],
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ],
            "text/html": [
              "\n",
              "     <input type=\"file\" id=\"files-cd061ffb-f186-4382-998d-ad75bd3056e7\" name=\"files[]\" multiple disabled\n",
              "        style=\"border:none\" />\n",
              "     <output id=\"result-cd061ffb-f186-4382-998d-ad75bd3056e7\">\n",
              "      Upload widget is only available when the cell has been executed in the\n",
              "      current browser session. Please rerun this cell to enable.\n",
              "      </output>\n",
              "      <script>// Copyright 2017 Google LLC\n",
              "//\n",
              "// Licensed under the Apache License, Version 2.0 (the \"License\");\n",
              "// you may not use this file except in compliance with the License.\n",
              "// You may obtain a copy of the License at\n",
              "//\n",
              "//      http://www.apache.org/licenses/LICENSE-2.0\n",
              "//\n",
              "// Unless required by applicable law or agreed to in writing, software\n",
              "// distributed under the License is distributed on an \"AS IS\" BASIS,\n",
              "// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
              "// See the License for the specific language governing permissions and\n",
              "// limitations under the License.\n",
              "\n",
              "/**\n",
              " * @fileoverview Helpers for google.colab Python module.\n",
              " */\n",
              "(function(scope) {\n",
              "function span(text, styleAttributes = {}) {\n",
              "  const element = document.createElement('span');\n",
              "  element.textContent = text;\n",
              "  for (const key of Object.keys(styleAttributes)) {\n",
              "    element.style[key] = styleAttributes[key];\n",
              "  }\n",
              "  return element;\n",
              "}\n",
              "\n",
              "// Max number of bytes which will be uploaded at a time.\n",
              "const MAX_PAYLOAD_SIZE = 100 * 1024;\n",
              "\n",
              "function _uploadFiles(inputId, outputId) {\n",
              "  const steps = uploadFilesStep(inputId, outputId);\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  // Cache steps on the outputElement to make it available for the next call\n",
              "  // to uploadFilesContinue from Python.\n",
              "  outputElement.steps = steps;\n",
              "\n",
              "  return _uploadFilesContinue(outputId);\n",
              "}\n",
              "\n",
              "// This is roughly an async generator (not supported in the browser yet),\n",
              "// where there are multiple asynchronous steps and the Python side is going\n",
              "// to poll for completion of each step.\n",
              "// This uses a Promise to block the python side on completion of each step,\n",
              "// then passes the result of the previous step as the input to the next step.\n",
              "function _uploadFilesContinue(outputId) {\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  const steps = outputElement.steps;\n",
              "\n",
              "  const next = steps.next(outputElement.lastPromiseValue);\n",
              "  return Promise.resolve(next.value.promise).then((value) => {\n",
              "    // Cache the last promise value to make it available to the next\n",
              "    // step of the generator.\n",
              "    outputElement.lastPromiseValue = value;\n",
              "    return next.value.response;\n",
              "  });\n",
              "}\n",
              "\n",
              "/**\n",
              " * Generator function which is called between each async step of the upload\n",
              " * process.\n",
              " * @param {string} inputId Element ID of the input file picker element.\n",
              " * @param {string} outputId Element ID of the output display.\n",
              " * @return {!Iterable<!Object>} Iterable of next steps.\n",
              " */\n",
              "function* uploadFilesStep(inputId, outputId) {\n",
              "  const inputElement = document.getElementById(inputId);\n",
              "  inputElement.disabled = false;\n",
              "\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  outputElement.innerHTML = '';\n",
              "\n",
              "  const pickedPromise = new Promise((resolve) => {\n",
              "    inputElement.addEventListener('change', (e) => {\n",
              "      resolve(e.target.files);\n",
              "    });\n",
              "  });\n",
              "\n",
              "  const cancel = document.createElement('button');\n",
              "  inputElement.parentElement.appendChild(cancel);\n",
              "  cancel.textContent = 'Cancel upload';\n",
              "  const cancelPromise = new Promise((resolve) => {\n",
              "    cancel.onclick = () => {\n",
              "      resolve(null);\n",
              "    };\n",
              "  });\n",
              "\n",
              "  // Wait for the user to pick the files.\n",
              "  const files = yield {\n",
              "    promise: Promise.race([pickedPromise, cancelPromise]),\n",
              "    response: {\n",
              "      action: 'starting',\n",
              "    }\n",
              "  };\n",
              "\n",
              "  cancel.remove();\n",
              "\n",
              "  // Disable the input element since further picks are not allowed.\n",
              "  inputElement.disabled = true;\n",
              "\n",
              "  if (!files) {\n",
              "    return {\n",
              "      response: {\n",
              "        action: 'complete',\n",
              "      }\n",
              "    };\n",
              "  }\n",
              "\n",
              "  for (const file of files) {\n",
              "    const li = document.createElement('li');\n",
              "    li.append(span(file.name, {fontWeight: 'bold'}));\n",
              "    li.append(span(\n",
              "        `(${file.type || 'n/a'}) - ${file.size} bytes, ` +\n",
              "        `last modified: ${\n",
              "            file.lastModifiedDate ? file.lastModifiedDate.toLocaleDateString() :\n",
              "                                    'n/a'} - `));\n",
              "    const percent = span('0% done');\n",
              "    li.appendChild(percent);\n",
              "\n",
              "    outputElement.appendChild(li);\n",
              "\n",
              "    const fileDataPromise = new Promise((resolve) => {\n",
              "      const reader = new FileReader();\n",
              "      reader.onload = (e) => {\n",
              "        resolve(e.target.result);\n",
              "      };\n",
              "      reader.readAsArrayBuffer(file);\n",
              "    });\n",
              "    // Wait for the data to be ready.\n",
              "    let fileData = yield {\n",
              "      promise: fileDataPromise,\n",
              "      response: {\n",
              "        action: 'continue',\n",
              "      }\n",
              "    };\n",
              "\n",
              "    // Use a chunked sending to avoid message size limits. See b/62115660.\n",
              "    let position = 0;\n",
              "    do {\n",
              "      const length = Math.min(fileData.byteLength - position, MAX_PAYLOAD_SIZE);\n",
              "      const chunk = new Uint8Array(fileData, position, length);\n",
              "      position += length;\n",
              "\n",
              "      const base64 = btoa(String.fromCharCode.apply(null, chunk));\n",
              "      yield {\n",
              "        response: {\n",
              "          action: 'append',\n",
              "          file: file.name,\n",
              "          data: base64,\n",
              "        },\n",
              "      };\n",
              "\n",
              "      let percentDone = fileData.byteLength === 0 ?\n",
              "          100 :\n",
              "          Math.round((position / fileData.byteLength) * 100);\n",
              "      percent.textContent = `${percentDone}% done`;\n",
              "\n",
              "    } while (position < fileData.byteLength);\n",
              "  }\n",
              "\n",
              "  // All done.\n",
              "  yield {\n",
              "    response: {\n",
              "      action: 'complete',\n",
              "    }\n",
              "  };\n",
              "}\n",
              "\n",
              "scope.google = scope.google || {};\n",
              "scope.google.colab = scope.google.colab || {};\n",
              "scope.google.colab._files = {\n",
              "  _uploadFiles,\n",
              "  _uploadFilesContinue,\n",
              "};\n",
              "})(self);\n",
              "</script> "
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Saving sequence.fna to sequence (1).fna\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rlUrgJA9Px8G",
        "cellView": "form",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "bda9d20e-3bdd-419b-aac8-9e340ed44d58"
      },
      "source": [
        "#@title Download dependencies and databases\n",
        "%%bash -s $jobname $input_type $search_type $run_prodigal $target_type $target_db\n",
        "JOBNAME=$1\n",
        "INPUT_TYPE=$2\n",
        "SEARCH_TYPE=$3\n",
        "NEED_PRODIGAL=$4\n",
        "TARGET_TYPE=$5\n",
        "TARGET_DB=$6\n",
        "\n",
        "if [ ! -e SPACEDUST_READY ]; then\n",
        "  wget -q wget https://mmseqs.com/spacedust/spacedust-linux-avx2.tar.gz\n",
        "  tar -xzf spacedust-linux-avx2.tar.gz\n",
        "  rm -f spacedust-linux-avx2.tar.gz\n",
        "  touch SPACEDUST_READY\n",
        "fi\n",
        "\n",
        "if [ ! -e FOLDSEEK_READY ] && [ \"${SEARCH_TYPE}\" = \"1\" ]; then\n",
        "  wget -q wget https://mmseqs.com/foldseek/foldseek-linux-avx2.tar.gz\n",
        "  tar -xzf foldseek-linux-avx2.tar.gz\n",
        "  rm -f foldseek-linux-avx2.tar.gz\n",
        "  touch FOLDSEEK_READY\n",
        "fi\n",
        "\n",
        "if [ ! -e PRORIGAL_READY ] && [ \"${NEED_PRODIGAL}\" = \"True\" ]; then\n",
        "  wget -q wget https://github.com/hyattpd/Prodigal/releases/download/v2.6.3/prodigal.linux\n",
        "  cp prodigal.linux /usr/local/bin/prodigal\n",
        "  chmod +x /usr/local/bin/prodigal\n",
        "  touch PRODIGAL_READY\n",
        "fi\n",
        "\n",
        "mkdir -p database\n",
        "cd database\n",
        "if [ ! -e SPACEDUST_DB_READY ] && [ \"${INPUT_TYPE}\" = \"0\" ] && [ \"${TARGET_TYPE}\" = \"1\" ]; then\n",
        "  wget -N -np -nv http://wwwuser.gwdg.de/~compbiol/spacedust/${TARGET_DB}.tar.gz\n",
        "  tar -xzf ${TARGET_DB}.tar.gz\n",
        "  rm -f ${TARGET_DB}.tar.gz\n",
        "  touch ../SPACEDUST_DB_READY\n",
        "fi"
      ],
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "2024-10-04 16:17:13 URL:https://wwwuser.gwdguser.de/~compbiol/spacedust/KEGG_70.tar.gz [972659708/972659708] -> \"KEGG_70.tar.gz\" [1]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QhUUbtePShi_",
        "cellView": "form"
      },
      "source": [
        "#@title Run Spacedust\n",
        "%%bash -s $jobname $input_type $search_type $run_prodigal $target_type $max_gene_gap\n",
        "JOBNAME=$1\n",
        "INPUT_TYPE=$2\n",
        "SEARCH_TYPE=$3\n",
        "NEED_PRODIGAL=$4\n",
        "TARGET_TYPE=$5\n",
        "MAX_GENE_GAP=$6\n",
        "NUM_ITERATIONS=$7\n",
        "\n",
        "\n",
        "\n",
        "if [ ! -e PRORIGAL_FAA_READY ] && [ \"${NEED_PRODIGAL}\" = \"True\" ] ; then\n",
        "    if ! ls \"${JOBNAME}_input/\"*.fna 1> /dev/null 2>&1; then\n",
        "      echo \"Error: No query .fna file is found! Please make sure you input the query files with the correct extension!\"\n",
        "      exit 1\n",
        "    fi\n",
        "\n",
        "    for filename in \"${JOBNAME}_input/\"*.fna; do\n",
        "      base=$(basename \"$filename\" .fna)\n",
        "      if [ ! -f \"${JOBNAME}_input/$base.faa\" ]; then\n",
        "          prodigal -i \"$filename\" -a \"${JOBNAME}_input/$base.faa\" &> /dev/null\n",
        "      fi\n",
        "    done\n",
        "\n",
        "    if [ \"$INPUT_TYPE\" = \"0\" ] && [ \"$TARGET_TYPE\" = \"0\" ] ; then\n",
        "\n",
        "    if ! ls \"${JOBNAME}_input/\"*.fna 1> /dev/null 2>&1; then\n",
        "      echo \"Error: No target .fna file is found! Please make sure you input the target files with the correct extension!\"\n",
        "      exit 1\n",
        "    fi\n",
        "\n",
        "      for filename in \"${JOBNAME}_target/\"*.fna; do\n",
        "        base=$(basename \"$filename\" .fna)\n",
        "        if [ ! -f \"${JOBNAME}_target/$base.faa\" ]; then\n",
        "            prodigal -i \"$filename\" -a \"${JOBNAME}_target/$base.faa\" &> /dev/null\n",
        "        fi\n",
        "      done\n",
        "    fi\n",
        "    touch PRODIGAL_FAA_READY\n",
        "fi\n",
        "\n",
        "if [ \"$INPUT_TYPE\" = \"1\" ]; then\n",
        "    spacedust/bin/spacedust createsetdb \"${JOBNAME}_input/\"*.faa database/${JOBNAME}_input tmp -v 0 &> /dev/null\n",
        "    spacedust/bin/spacedust clustersearch database/${JOBNAME}_input database/${JOBNAME}_input \"$JOBNAME\" tmp --filter-self-match --search-mode \"$SEARCH_TYPE\" --max-gene-gap \"$MAX_GENE_GAP\" -v 0 &> /dev/null\n",
        "else\n",
        "    spacedust/bin/spacedust createsetdb \"${JOBNAME}_input/\"*.faa database/${JOBNAME}_input tmp -v 0 &> /dev/null\n",
        "    if [ \"$TARGET_TYPE\" = \"0\" ]; then\n",
        "      spacedust/bin/spacedust createsetdb \"${JOBNAME}_target/\"*.faa database/${JOBNAME}_db tmp -v 0 &> /dev/null\n",
        "      spacedust/bin/spacedust clustersearch database/${JOBNAME}_input database/${JOBNAME}_db \"$JOBNAME\" tmp --search-mode \"$SEARCH_TYPE\" --max-gene-gap \"$MAX_GENE_GAP\"  -v 0 &> /dev/null\n",
        "    else\n",
        "      spacedust/bin/spacedust clustersearch database/${JOBNAME}_input database/keggclusterdb \"$JOBNAME\" tmp --search-mode \"$SEARCH_TYPE\"  --max-gene-gap \"$MAX_GENE_GAP\" -v 0\n",
        "    fi\n",
        "fi\n",
        "\n",
        "spacedust/bin/spacedust prefixid tmp/latest/clusters \"${JOBNAME}_pref\" --tsv -v 0 &> /dev/null\n",
        "\n",
        "awk '{ print $2\"\\t\"$3 }' \"${JOBNAME}_pref\" > qid_tid\n",
        "awk '{ print $1 }' \"${JOBNAME}_pref\" > cluid\n",
        "rm \"${JOBNAME}_pref\"\n",
        "\n",
        "awk 'BEGIN{OFS=FS=\"\\t\"} NR==FNR{clr[$1]=$2; next} {$1=clr[$1]; print}' database/${JOBNAME}_input\".lookup\" qid_tid > 1\n",
        "if [ \"$INPUT_TYPE\" = \"1\" ]; then\n",
        "    awk 'BEGIN{OFS=FS=\"\\t\"} NR==FNR{clr[$1]=$2; next} {$2=clr[$2]; print}' database/${JOBNAME}_input\".lookup\" 1 > qname_tname\n",
        "elif [ \"$TARGET_TYPE\" = \"0\" ]; then\n",
        "    awk 'BEGIN{OFS=FS=\"\\t\"} NR==FNR{clr[$1]=$2; next} {$2=clr[$2]; print}' database/${JOBNAME}_db\".lookup\" 1 > qname_tname\n",
        "else\n",
        "    awk 'BEGIN{OFS=FS=\"\\t\"} NR==FNR{clr[$1]=$2; next} {$2=clr[$2]; print}' database/keggclusterdb.lookup 1 > qname_tname\n",
        "fi\n",
        "sed -i 's/NZ_/NZ./g' qname_tname\n",
        "sed -i 's/NC_/NC./g' qname_tname\n",
        "tr '_' '\\t' <qname_tname > qname_tname_sep\n",
        "rm 1\n",
        "rm qname_tname\n",
        "\n",
        "awk 'BEGIN{OFS=FS=\"\\t\"} NR==FNR{clr[$1]=$3; next} {$1=clr[$1]; print}' database/${JOBNAME}_input\".lookup\" qid_tid > 2\n",
        "if [ \"$INPUT_TYPE\" = \"1\" ]; then\n",
        "    awk 'BEGIN{OFS=FS=\"\\t\"} NR==FNR{clr[$1]=$3; next} {$2=clr[$2]; print}' database/${JOBNAME}_input\".lookup\" 2 > qset_tset\n",
        "elif [ \"$TARGET_TYPE\" = \"0\" ]; then\n",
        "    awk 'BEGIN{OFS=FS=\"\\t\"} NR==FNR{clr[$1]=$3; next} {$2=clr[$2]; print}' database/${JOBNAME}_db\".lookup\" 2 > qset_tset\n",
        "else\n",
        "    awk 'BEGIN{OFS=FS=\"\\t\"} NR==FNR{clr[$1]=$3; next} {$2=clr[$2]; print}' database/keggclusterdb.lookup 2 > qset_tset\n",
        "fi\n",
        "rm 2\n",
        "\n",
        "paste cluid qset_tset qid_tid qname_tname_sep > \"${JOBNAME}_plot\"\n",
        "rm qid_tid\n",
        "rm qname_tname_sep\n",
        "rm qset_tset\n",
        "rm cluid\n",
        "\n",
        "spacedust/bin/spacedust prefixid \"database/${JOBNAME}_input\" \"database/${JOBNAME}_input_pref\" --tsv -v 0 &> /dev/null"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#@title Show cluster matches\n",
        "from pathlib import Path\n",
        "from IPython.display import HTML\n",
        "from IPython.core.display import display\n",
        "from pathlib import Path\n",
        "\n",
        "html = '''\n",
        "<style>\n",
        "tbody tr.head {\n",
        "  font-weight: bold;\n",
        "  background-color: #f2f2f2;\n",
        "}\n",
        "</style>\n",
        "<table style='text-align:left'>\n",
        "  <thead>\n",
        "    <tr>\n",
        "      <th>Cluster Match ID</th>\n",
        "      <th>Query Acc.</th>\n",
        "      <th>Target Acc.</th>\n",
        "      <th>Cluster Match Pval</th>\n",
        "      <th colspan=\"8\">Num. Hits</th>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th colspan='2'>Query ID</th>\n",
        "      <th>Target ID</th>\n",
        "      <th>SeqId</th>\n",
        "      <th>Eval</th>\n",
        "      <th>qStart</th>\n",
        "      <th>qEnd</th>\n",
        "      <th>qLength</th>\n",
        "      <th>tStart</th>\n",
        "      <th>tEnd</th>\n",
        "      <th>tLength</th>\n",
        "      <th>Aln Cigar</th>\n",
        "    </tr>\n",
        "  </thead>\n",
        "<tbody>\n",
        "'''\n",
        "\n",
        "for line in Path(jobname).read_text().split('\\n'):\n",
        "  if len(line) == 0:\n",
        "    continue\n",
        "  if line[0] == '#':\n",
        "    cols = line.split('\\t')\n",
        "    if len(cols) == 6:\n",
        "      html += \"<tr class='head'>\"\n",
        "      html += \"<td>\" + cols[0][1:] + \"</td>\"\n",
        "      html += \"<td>\" + cols[1] + \"</td>\"\n",
        "      html += \"<td>\" + cols[2] + \"</td>\"\n",
        "      html += \"<td>\" + cols[4] + \"</td>\"\n",
        "      html += \"<td colspan='8'>\" + cols[5] + \"</td>\"\n",
        "      html += \"</tr>\\n\"\n",
        "  elif line[0] == '>':\n",
        "    cols = line.split('\\t')\n",
        "    if len(cols) == 12:\n",
        "      html += \"<tr>\"\n",
        "      html += \"<td colspan='2'>\" + cols[0][1:] + \"</td>\"\n",
        "      html += \"<td>\" + cols[1] + \"</td>\"\n",
        "      html += \"<td>\" + cols[3] + \"</td>\"\n",
        "      html += \"<td>\" + cols[4] + \"</td>\"\n",
        "      html += \"<td>\" + cols[5] + \"</td>\"\n",
        "      html += \"<td>\" + cols[6] + \"</td>\"\n",
        "      html += \"<td>\" + cols[7] + \"</td>\"\n",
        "      html += \"<td>\" + cols[8] + \"</td>\"\n",
        "      html += \"<td>\" + cols[9] + \"</td>\"\n",
        "      html += \"<td>\" + cols[10] + \"</td>\"\n",
        "      html += \"<td>\" + cols[11] + \"</td>\"\n",
        "    html += \"</tr>\\n\"\n",
        "html += '''\n",
        "</tbody>\n",
        "</table>\n",
        "'''\n",
        "display(HTML(html))"
      ],
      "metadata": {
        "cellView": "form",
        "id": "75eL9BYn2-Om"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#@title Download result\n",
        "\n",
        "download_path = \"/content/\"+ jobname\n",
        "files.download(download_path)"
      ],
      "metadata": {
        "cellView": "form",
        "id": "RSkbJGD0hirl"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Visualization**"
      ],
      "metadata": {
        "id": "IjmoVoE6WfE2"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#@title Prepare result for visualization\n",
        "!python3 -m pip install -q -U ipympl\n",
        "!python3 -m pip install -q -U rpy2==3.5.1\n",
        "import os\n",
        "import shutil\n",
        "from google.colab import files\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "import seaborn as sns\n",
        "\n",
        "matchhit = pd.read_csv(jobname + \"_plot\", sep=\"\\t\", names=['cluid','qsetid', 'tsetid', 'qseqid','tseqid','qname', 'qid_p','qid','qstart','qend', 'tname','tid','tstart','tend'])\n",
        "\n",
        "lookup = pd.read_csv(\"database/\" + jobname + \"_input.lookup\", sep=\"\\t\", names=['seqid','header','setid'])\n",
        "\n",
        "all_seq = pd.read_csv(\"database/\" + jobname + \"_input_pref\", sep=\"\\t\", names=['id','seq'], header=None, dtype={'id' : int, 'seq': str})\n"
      ],
      "metadata": {
        "id": "kwVbraLqRyyA",
        "cellView": "form"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#@title Select query genome\n",
        "\n",
        "from ipywidgets import interact, widgets\n",
        "\n",
        "# Load your data file into a DataFrame\n",
        "# Replace 'your_file.csv' with the actual file path\n",
        "df = pd.read_csv('database/'+jobname + '_input.source', sep=\"\\t\",names=['query_genome_id','query_genome_name'],dtype={'query_genome_id' : int, 'query_genome_name': str})\n",
        "\n",
        "values = df['query_genome_name']\n",
        "\n",
        "if len(values) == 1 :\n",
        "    query_genome = 0\n",
        "else:\n",
        "  # Initialize a global variable to store the selected query_genome_id\n",
        "  query_genome = None\n",
        "\n",
        "  # Create an interactive dropdown menu\n",
        "  @interact(selected_value=widgets.Dropdown(options=unique_values, description='Select Value:'))\n",
        "  def set_query_genome_id(selected_value):\n",
        "      global query_genome\n",
        "\n",
        "      # Set query_genome_id based on the selected value\n",
        "      query_genome = df.loc[df['query_genome_name'] == selected_value, 'query_genome_id'].iloc[0]\n",
        "\n",
        "      # Display information based on the selected value and set query_genome_id\n",
        "      selected_data = df[df['query_genome_name'] == selected_value]\n",
        "\n",
        "\n",
        "\n",
        "#calculate match barplot\n",
        "#create array for counting\n",
        "matchhit_temp = matchhit[matchhit['qsetid'] == query_genome]\n",
        "qid = matchhit_temp.drop_duplicates(['qid','tsetid'],keep= 'last')['qid'].to_numpy()\n",
        "matchhit_array = np.zeros(qid.max()+1, dtype=int)\n",
        "for i in qid:\n",
        "    matchhit_array[i]+=1\n",
        "#create array for counting neighboring pairs crossing clusters (conservation matrix)\n",
        "qid = matchhit.sort_values(['cluid', 'qid'])['qid'].to_numpy()\n",
        "tid = matchhit.sort_values(['cluid', 'qid'])['tid'].to_numpy()\n",
        "cluid = matchhit.sort_values(['cluid', 'qid'])['cluid'].to_numpy()\n",
        "matchpair_array = np.zeros(qid.max(), dtype=int)\n",
        "for i in np.arange(len(qid)-1):\n",
        "    if(cluid[i] == cluid[i+1]):\n",
        "        if(qid[i] == qid[i+1]-1):\n",
        "            matchpair_array[qid[i]]+=1\n",
        "        else:\n",
        "            if(abs(qid[i+1]-qid[i])==abs(tid[i+1]-tid[i])):\n",
        "                for x in np.arange(qid[i],qid[i+1]):\n",
        "                    matchpair_array[x]+=1\n",
        "\n",
        "count=np.zeros(matchhit_array.max()+1)\n",
        "for i in matchhit_array.tolist():\n",
        "    count[i]+=1\n",
        "\n",
        "#process lookup\n",
        "lookup_temp= lookup[lookup['setid'] == query_genome]\n",
        "\n",
        "lookup_temp['idx'] = lookup_temp['header'].str.split('_').str[-3].astype(int)\n",
        "lookup_temp['qstart'] = lookup_temp['header'].str.split('_').str[-2].astype(int)\n",
        "lookup_temp['qend'] = lookup_temp['header'].str.split('_').str[-1].astype(int)"
      ],
      "metadata": {
        "id": "ZQZM7PnOa_c8",
        "cellView": "form"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#@title Cluster matches heatmap/bar plot\n",
        "\n",
        "Zoom = False #@param {type:\"boolean\"}\n",
        "#@markdown Zoom in to the plot by setting a lower and upper bound of the protein id (ignored if `zoom` is not selected)\n",
        "lower_bound = 1 #@param {type:\"integer\"}\n",
        "upper_bound = 100 #@param {type:\"integer\"}\n",
        "\n",
        "# Ensure that lower_bound is always smaller than upper_bound\n",
        "if lower_bound >= upper_bound:\n",
        "    raise ValueError(\"Lower bound must be smaller than upper bound\")\n",
        "\n",
        "\n",
        "#combined bar plot\n",
        "%matplotlib widget\n",
        "\n",
        "from google.colab import output\n",
        "output.enable_custom_widget_manager()\n",
        "import matplotlib.pyplot as plt\n",
        "import math\n",
        "import matplotlib.cm as cm\n",
        "from matplotlib.widgets import Slider\n",
        "import matplotlib.ticker as ticker\n",
        "\n",
        "# from matplotlib.colors import ListedColormap\n",
        "from ipywidgets import *\n",
        "\n",
        "from mpl_toolkits.axes_grid1 import make_axes_locatable\n",
        "\n",
        "# Get the maximum protein ID and genome ID\n",
        "max_protein_id = np.max(matchhit['qid'])\n",
        "max_genome_id = np.max(matchhit['tsetid'])\n",
        "\n",
        "# Create an empty matrix of the correct size\n",
        "matrix = np.zeros((max_genome_id + 1, max_protein_id + 1))\n",
        "matrix[query_genome,:] = 1\n",
        "# Fill the matrix with the protein hits data\n",
        "for _, row in matchhit.iterrows():\n",
        "    matrix[row['tsetid'], row['qid']] = 1\n",
        "\n",
        "# Create an empty matrix for the strand plot\n",
        "strand_plot = np.zeros( len(lookup_temp['idx']), dtype=int)\n",
        "\n",
        "# Loop through the gene dataframe to mark positive and negative strands\n",
        "for _, row in lookup_temp.iterrows():\n",
        "    if (row['qstart'] < row['qend']):\n",
        "        # Set positive strand positions to 1\n",
        "        strand_plot[row['idx']] = 1\n",
        "\n",
        "# Create the figure and axes with adjusted height ratio\n",
        "fig, (ax1, ax3, ax2) = plt.subplots(nrows=3, sharex=True, figsize=(10, 12), gridspec_kw={'height_ratios': [4, 0.1, 1]})\n",
        "\n",
        "# Create the heatmap\n",
        "heatmap = ax1.imshow(matrix, cmap='Blues', interpolation='none', aspect='auto')\n",
        "\n",
        "# Set the title, y-axis label, and y-axis tick labels\n",
        "# ax1.set_title('Presence/Absence Heatmap')\n",
        "ax1.set_ylabel('Genome ID')\n",
        "y_labels = range(0, max_genome_id + 1)\n",
        "ax1.set_yticks(range(0, max_genome_id + 1))\n",
        "ax1.set_yticklabels(y_labels)\n",
        "\n",
        "# Use AutoLocator for x-axis ticks to adjust dynamically based on zoom level\n",
        "ax1.xaxis.set_major_locator(ticker.AutoLocator())\n",
        "\n",
        "# Use AutoLocator for y-axis ticks to adjust dynamically based on zoom level\n",
        "ax1.yaxis.set_major_locator(ticker.AutoLocator())\n",
        "\n",
        "# Set the x-axis tick labels and rotation\n",
        "x_labels = range(0, max_protein_id + 1)\n",
        "ax2.set_xticks(range(0, max_protein_id + 1))\n",
        "ax2.set_xticklabels(x_labels, rotation=90)\n",
        "\n",
        "# Add a bar plot below the heatmap\n",
        "ax2.bar(np.arange(len(matchpair_array)), matchpair_array,width=1,align='edge',ecolor='black',color='lightpink')\n",
        "ax2.bar(np.arange(len(matchhit_array)), matchhit_array,width=0.5,align='center')\n",
        "ax2.set_ylabel('Hits Count')\n",
        "ax2.set_xlabel('Query Protein Position Index')\n",
        "\n",
        "# Adjust the limits of the x-axis to match the heatmap\n",
        "if Zoom:\n",
        "    ax2.set_xlim(lower_bound-0.5, upper_bound + 0.5)\n",
        "else:\n",
        "    ax2.set_xlim(-0.5, max_protein_id+1 - 0.5)\n",
        "\n",
        "ax2.set_yscale('log')\n",
        "\n",
        "# Use AutoLocator for x-axis ticks to adjust dynamically based on zoom level\n",
        "ax2.xaxis.set_major_locator(ticker.AutoLocator())\n",
        "\n",
        "# Add the strand plot as a thin line\n",
        "cmap_binary = cm.binary\n",
        "ax3.imshow(strand_plot.reshape(1, -1), cmap=cmap_binary, aspect='auto')\n",
        "ax3.yaxis.set_ticks([])\n",
        "ax3.set_ylabel('Strand')\n",
        "\n",
        "# Enable interactive mode\n",
        "plt.ion()\n",
        "\n",
        "# Function to resize the plot when zooming in\n",
        "def on_zoom(event):\n",
        "    current_xlim = ax1.get_xlim()\n",
        "    current_ylim = ax1.get_ylim()\n",
        "    current_ylim2 = ax2.get_ylim()\n",
        "    ax1.set_xlim(*current_xlim)\n",
        "    ax1.set_ylim(*current_ylim)\n",
        "    ax2.set_ylim(*current_ylim2)\n",
        "    ax3.set_xlim(*current_xlim)\n",
        "\n",
        "# Connect the on_zoom function to the zoom event\n",
        "fig.canvas.mpl_connect('resize_event', on_zoom)\n",
        "\n",
        "# Save the plot to a file (e.g., PNG)\n",
        "plt.savefig('heatmap.pdf')\n",
        "\n",
        "# # Display the saved plot in the notebook\n",
        "# display(Image(filename='sample_plot.png'))\n",
        "# Show the plot\n",
        "plt.tight_layout()\n",
        "plt.show()"
      ],
      "metadata": {
        "cellView": "form",
        "id": "_eYTUX_pn8dE"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#@title Cluster matches bar plot\n",
        "#combined bar plot\n",
        "%matplotlib widget\n",
        "\n",
        "from google.colab import output\n",
        "output.enable_custom_widget_manager()\n",
        "import matplotlib.pyplot as plt\n",
        "import math\n",
        "from matplotlib.widgets import Slider\n",
        "from ipywidgets import *\n",
        "\n",
        "fig,ax=plt.subplots(figsize=(10,6))\n",
        "fig.patch.set_facecolor('white')\n",
        "\n",
        "# Simple mouse click function to store coordinates\n",
        "def onclick(event):\n",
        "    global ix, iy\n",
        "    ix, iy = event.xdata, event.ydata\n",
        "\n",
        "    # assign global variable to access outside of function\n",
        "    global coords\n",
        "    coords.append((ix, iy))\n",
        "\n",
        "    # Disconnect after x clicks\n",
        "    if len(coords) == 100:\n",
        "        fig.canvas.mpl_disconnect(cid)\n",
        "        plt.close(1)\n",
        "    return\n",
        "\n",
        "def on_move(event):\n",
        "    if event.inaxes:\n",
        "        print(f'data coords {event.xdata} {event.ydata},',\n",
        "              f'pixel coords {event.x} {event.y}')\n",
        "\n",
        "\n",
        "x = np.arange(qid.max()+1)\n",
        "y1 = matchhit_array\n",
        "y2 = matchpair_array\n",
        "\n",
        "N=100\n",
        "\n",
        "def bar(pos):\n",
        "    pos = int(pos)\n",
        "    ax.clear()\n",
        "    if pos+N > len(x):\n",
        "        n=len(x)-pos\n",
        "    else:\n",
        "        n=N\n",
        "    X=x[pos:pos+n]\n",
        "    Y=y1[pos:pos+n]\n",
        "    Y2=y2[pos:pos+n]\n",
        "    ax.bar(X,Y2,width=1,align='edge',ecolor='black',color='lightgrey')\n",
        "    ax.bar(X,Y,width=0.5,align='edge',ecolor='black')\n",
        "\n",
        "    # ax.axhline(10,color='r', linestyle='--')\n",
        "\n",
        "#     ax.set_yscale('log')\n",
        "\n",
        "barpos = plt.axes([0.18, 0.05, 0.55, 0.03], facecolor=\"skyblue\")\n",
        "slider = Slider(barpos, 'Gene pos', 50, len(x)-N, valinit=0)\n",
        "slider.on_changed(bar)\n",
        "\n",
        "bar(0)\n",
        "\n",
        "coords = []\n",
        "\n",
        "# Call click func\n",
        "cid = fig.canvas.mpl_connect('button_press_event', onclick)\n",
        "\n",
        "plt.show()"
      ],
      "metadata": {
        "cellView": "form",
        "id": "s5eQod4cYUQj"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#@title Select proteins(s) of interest, extract all cluster matches containing the protein-encoded gene(s).\n",
        "\n",
        "#@markdown Input: Query Protein ID (single integer or range, e.g., '1' or '1-10')\n",
        "\n",
        "# Query protein ID parameter\n",
        "query_protein_id_input = '1' #@param {type:\"string\"}\n",
        "\n",
        "# Function to parse the input string to get lower and upper bounds\n",
        "def parse_input(input_str):\n",
        "    parts = input_str.split('-')\n",
        "    if len(parts) == 1:\n",
        "        # Single integer\n",
        "        return [int(parts[0])]\n",
        "    elif len(parts) == 2:\n",
        "        # Range\n",
        "        return list(range(int(parts[0]), int(parts[1]) + 1))\n",
        "    else:\n",
        "        raise ValueError(\"Invalid input format. Please enter either a single integer or a range.\")\n",
        "\n",
        "# Print all numbers within the range\n",
        "query_protein_id = parse_input(query_protein_id_input)\n",
        "\n",
        "# Filter clusterid to include only clusters with all query_protein_ids\n",
        "clusterid = matchhit.loc[matchhit['qid'].isin(query_protein_id), 'cluid'].unique().tolist()\n",
        "\n",
        "# Check if all query_protein_ids are present in each cluster\n",
        "filtered_clusterid = [cluster for cluster in clusterid if all(matchhit[matchhit['cluid'] == cluster]['qid'].isin(query_protein_id))]\n",
        "\n",
        "appended_data = pd.DataFrame()\n",
        "for i in clusterid:\n",
        "    appended_data = pd.concat([appended_data, matchhit[matchhit['cluid'] == i]])\n",
        "\n",
        "appended_data = appended_data[appended_data['qseqid'].map(appended_data['qseqid'].value_counts()) > 1]\n",
        "# query_protein_id = 1 #@param {type:\"integer\"}\n",
        "# clusterid = matchhit['cluid'][matchhit['qid'] ==query_protein_id].values.tolist()\n",
        "# appended_data = pd.DataFrame()\n",
        "# for i in clusterid:\n",
        "#     appended_data = pd.concat([appended_data, matchhit[matchhit['cluid'] == i]])\n"
      ],
      "metadata": {
        "cellView": "form",
        "id": "edc5oVtUy79C"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#@title Convert to R dataframe\n",
        "%reload_ext rpy2.ipython\n",
        "from rpy2.robjects import pandas2ri\n",
        "# clusterid = matchhit['cluid'][matchhit['qid'] ==query_protein_id[0]].values.tolist()\n",
        "# appended_data = pd.DataFrame()\n",
        "# for i in clusterid:\n",
        "#     appended_data = appended_data.append(matchhit[matchhit['cluid'] == i],ignore_index=True)\n",
        "\n",
        "# condition = np.sign(appended_data['qstart']-appended_data['qend']) != np.sign(appended_data['tstart']-appended_data['tend'])\n",
        "# appended_data['tstart'] = np.where(condition, -appended_data['tstart'],appended_data['tstart'])\n",
        "# appended_data['tend'] = np.where(condition, -appended_data['tend'],appended_data['tend'])\n",
        "\n",
        "predefined_qseqid = query_protein_id[0]\n",
        "\n",
        "def invert_sign(group):\n",
        "    matching_rows = group[group['qseqid'] == predefined_qseqid]\n",
        "\n",
        "    if not matching_rows.empty:\n",
        "        predefined_row = matching_rows.iloc[0]\n",
        "        q_direction = np.sign(predefined_row['qstart'] - predefined_row['qend'])\n",
        "        t_direction = np.sign(predefined_row['tstart'] - predefined_row['tend'])\n",
        "\n",
        "        if q_direction != t_direction:\n",
        "            group['tstart'], group['tend'] = -group['tstart'].values, -group['tend'].values\n",
        "\n",
        "    return group\n",
        "\n",
        "appended_data_g = appended_data.groupby('cluid', group_keys=False).apply(invert_sign)\n",
        "\n",
        "center = str(query_protein_id[0])\n",
        "appended_data_g = appended_data_g[appended_data_g['tname']!= appended_data_g['qname']]\n",
        "gggene_df = appended_data_g.groupby(by=\"qid\", as_index = False).first()[['qname','qid','qstart','qend']]\n",
        "gggene_df = gggene_df.append(appended_data_g[['tname','qid','tstart','tend']].rename(columns={\"tname\": \"qname\", \"tstart\": \"qstart\",\"tend\": \"qend\"})).reset_index()\n",
        "pandas2ri.activate()\n",
        "r_dataframe = pandas2ri.py2rpy(gggene_df)\n"
      ],
      "metadata": {
        "id": "MVtTAEG-JLAY",
        "cellView": "form"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#@title Visualize genome context\n",
        "%%R -i r_dataframe,center\n",
        "install.packages(\"gggenes\",quiet = TRUE)\n",
        "library(gggenes)\n",
        "library(ggplot2)\n",
        "library(RColorBrewer)\n",
        "library(IRdisplay)\n",
        "\n",
        "nb.cols <- length(unique(r_dataframe$qid))\n",
        "mycolors <- colorRampPalette(brewer.pal(8, \"Set3\"))(nb.cols)\n",
        "\n",
        "dummies <- make_alignment_dummies(\n",
        "  r_dataframe,\n",
        "  aes(xmin = qstart, xmax = qend, y = qname, id = qid),\n",
        "  on = center\n",
        ")\n",
        "\n",
        "ggplot(r_dataframe, aes(xmin = qstart, xmax = qend, y = qname, fill = factor(qid))) +\n",
        "  geom_gene_arrow() +\n",
        "  geom_blank(data = dummies) +\n",
        "  facet_wrap(~ qname, scales = \"free\", ncol = 1) +\n",
        "  scale_fill_manual(values = mycolors) +\n",
        "  theme_genes()+\n",
        "  labs(fill = \"Gene\", y = \"Genome\")\n",
        "\n",
        "width <- 1.5 * length(unique(r_dataframe$qid))\n",
        "height <- 0.5 * length(unique(r_dataframe$qname))\n",
        "\n",
        "# Save the ggplot to a PDF file (temporarily)\n",
        "ggsave(\"spacedust_plot.png\", width = width, height = height)"
      ],
      "metadata": {
        "id": "p1DkX3gVJy1H",
        "cellView": "form"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#@title View genome context and save image\n",
        "from IPython.display import Image\n",
        "from google.colab import files\n",
        "\n",
        "\n",
        "image_path = \"/content/spacedust_plot.png\"\n",
        "\n",
        "# Trigger download of the image\n",
        "files.download(image_path)\n",
        "\n",
        "# Display the image\n",
        "Image(filename=image_path, width=500)\n",
        "\n"
      ],
      "metadata": {
        "cellView": "form",
        "id": "w6EVDEAjf667"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Instructions**\n",
        "**Quick start**\n",
        "1. Set parameters. Press \"Runtime\" -> \"Run all\".\n",
        "2. Wait for file input box to appear below this cell to upload 1) all your query genome files and 2) your target genome files\n",
        "3. The currently running step is indicated by a circle with a stop sign next to it.\n",
        "\n",
        "**Result file contents**\n",
        "\n",
        "1. Tab-separated text file (`.tsv`) of all reported cluster matches.\n",
        "2. (If applicable) Protein sequences (`.faa`) predicted by prodigal.\n",
        "\n",
        "<!--At the end of the job a download modal box will pop up with a `jobname.result.zip` file. Additionally, if the `save_to_google_drive` option was selected, the `jobname.result.zip` will be uploaded to your Google Drive. -->\n",
        "\n",
        "**Troubleshooting**\n",
        "<!--* If you wish to use ProtNLM for function annotation, check that the runtime type is set to GPU at \"Runtime\" -> \"Change runtime type\".-->\n",
        "* Try to restart the session \"Runtime\" -> \"Factory reset runtime\".\n",
        "* Check if your input genomes are unzipped.\n",
        "\n",
        "**Limitations**\n",
        "* Computing resources: Due to resource limitations, homology search is currently only available with MMseqs2 instead of Foldseek, which might affect sensitivity of detecting remote homology.\n",
        "\n",
        "**Bugs**\n",
        "- If you encounter any bugs, please report the issue to https://github.com/soedinglab/spacedust/issues"
      ],
      "metadata": {
        "id": "ULtdJI3CgOQe"
      }
    }
  ]
}