generate_mutation_pdbs.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "code",
      "source": [
        "! pip install biopython"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NM1BvSBlF6x7",
        "outputId": "5ac35774-39e2-4494-9394-7ba170f40704"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Collecting biopython\n",
            "  Downloading biopython-1.84-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (12 kB)\n",
            "Requirement already satisfied: numpy in /usr/local/lib/python3.10/dist-packages (from biopython) (1.26.4)\n",
            "Downloading biopython-1.84-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (3.2 MB)\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m3.2/3.2 MB\u001b[0m \u001b[31m19.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hInstalling collected packages: biopython\n",
            "Successfully installed biopython-1.84\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mUmNMYanFejD",
        "outputId": "dfbf9250-35df-41e4-896c-e92fc8d41639"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mutated G12 to A12\n",
            "Mutant PDB saved: mutant_pdbs/mutant_G12A.pdb\n",
            "Mutated G12 to D12\n",
            "Mutant PDB saved: mutant_pdbs/mutant_G12D.pdb\n",
            "Mutated G12 to R12\n",
            "Mutant PDB saved: mutant_pdbs/mutant_G12R.pdb\n",
            "Mutated G12 to V12\n",
            "Mutant PDB saved: mutant_pdbs/mutant_G12V.pdb\n",
            "Mutated A146 to T146\n",
            "Mutant PDB saved: mutant_pdbs/mutant_A146T.pdb\n",
            "Mutated A59 to G59\n",
            "Mutant PDB saved: mutant_pdbs/mutant_A59G.pdb\n",
            "Mutated D33 to E33\n",
            "Mutant PDB saved: mutant_pdbs/mutant_D33E.pdb\n",
            "Mutated G13 to D13\n",
            "Mutant PDB saved: mutant_pdbs/mutant_G13D.pdb\n",
            "Mutated Q61 to L61\n",
            "Mutant PDB saved: mutant_pdbs/mutant_Q61L.pdb\n",
            "Mutated V14 to I14\n",
            "Mutant PDB saved: mutant_pdbs/mutant_V14I.pdb\n"
          ]
        }
      ],
      "source": [
        "from Bio import PDB\n",
        "import os\n",
        "\n",
        "# Use single chain pdb\n",
        "# You can edit the mutations in 87 no. line\n",
        "\n",
        "# One-letter to three-letter amino acid mapping\n",
        "one_to_three_dict = {\n",
        "    \"A\": \"ALA\", \"R\": \"ARG\", \"N\": \"ASN\", \"D\": \"ASP\", \"C\": \"CYS\",\n",
        "    \"E\": \"GLU\", \"Q\": \"GLN\", \"G\": \"GLY\", \"H\": \"HIS\", \"I\": \"ILE\",\n",
        "    \"L\": \"LEU\", \"K\": \"LYS\", \"M\": \"MET\", \"F\": \"PHE\", \"P\": \"PRO\",\n",
        "    \"S\": \"SER\", \"T\": \"THR\", \"W\": \"TRP\", \"Y\": \"TYR\", \"V\": \"VAL\",\n",
        "    \"U\": \"SEC\",  # Selenocysteine\n",
        "    \"O\": \"PYL\"   # Pyrrolysine\n",
        "}\n",
        "\n",
        "# Function to mutate the residue\n",
        "def mutate_residue(structure, mutation):\n",
        "    # Parse the mutation (e.g., \"G12A\" -> \"G\", \"12\", \"A\")\n",
        "    wt_residue = mutation[0]  # Wild-type amino acid\n",
        "    mut_residue = mutation[-1]  # Mutant amino acid\n",
        "    res_id = int(mutation[1:-1])  # Residue number\n",
        "\n",
        "    # Ensure that the wild-type amino acid matches the PDB residue\n",
        "    model = structure[0]  # Considering the first model of the structure\n",
        "    for chain in model:\n",
        "        for residue in chain:\n",
        "            if residue.get_id()[1] == res_id:\n",
        "                if residue.get_resname() != one_to_three_dict[wt_residue]:\n",
        "                    print(f\"Residue at position {res_id} is not {wt_residue}. Skipping mutation.\")\n",
        "                    return structure\n",
        "\n",
        "                # Store the index of the original residue\n",
        "                residue_index = chain.child_list.index(residue)\n",
        "\n",
        "                # Now perform the mutation: Remove old residue and add new one\n",
        "                chain.detach_child(residue.get_id())\n",
        "                mutant_residue = PDB.Residue.Residue((' ', res_id, ' '), one_to_three_dict[mut_residue], '')\n",
        "\n",
        "                # Add atoms to the new residue, excluding CB for glycine and handling special cases\n",
        "                for atom in residue:\n",
        "                    if mut_residue == 'G' and atom.get_name() == 'CB':\n",
        "                        continue\n",
        "                    if mut_residue == 'P' and atom.get_name() == 'H':\n",
        "                        continue  # Proline does not have a hydrogen atom on the nitrogen\n",
        "                    if mut_residue == 'C' and atom.get_name() == 'HG':\n",
        "                        continue  # Cysteine does not have a hydrogen atom on the sulfur when forming disulfide bonds\n",
        "                    if mut_residue == 'H' and atom.get_name() in ['HD1', 'HE2']:\n",
        "                        continue  # Histidine can be protonated or deprotonated, exclude hydrogen atoms for non-protonated form\n",
        "\n",
        "                    new_atom = PDB.Atom.Atom(atom.get_name(), atom.get_coord(), atom.get_bfactor(), atom.get_occupancy(), atom.get_altloc(), atom.get_fullname(), res_id, element=atom.element)\n",
        "                    mutant_residue.add(new_atom)\n",
        "\n",
        "                # Insert the new residue at the correct position in the chain\n",
        "                chain.child_list.insert(residue_index, mutant_residue)\n",
        "                print(f\"Mutated {wt_residue}{res_id} to {mut_residue}{res_id}\")\n",
        "                break\n",
        "    return structure\n",
        "\n",
        "# Generate mutant PDB files for a list of mutations\n",
        "def generate_mutant_pdbs(input_pdb_file, mutations, output_dir):\n",
        "    # Load the input structure\n",
        "    parser = PDB.PDBParser(QUIET=True)\n",
        "    structure = parser.get_structure('input', input_pdb_file)\n",
        "\n",
        "    # Create output directory if it doesn't exist\n",
        "    if not os.path.exists(output_dir):\n",
        "        os.makedirs(output_dir)\n",
        "\n",
        "    for mutation in mutations:\n",
        "        # Reload the structure for each mutation to avoid cumulative changes\n",
        "        structure = parser.get_structure('input', input_pdb_file)\n",
        "\n",
        "        # Mutate the structure\n",
        "        mutated_structure = mutate_residue(structure, mutation)\n",
        "\n",
        "        # Save the mutated pdb\n",
        "        output_pdb = os.path.join(output_dir, f\"mutant_{mutation}.pdb\")\n",
        "        io = PDB.PDBIO()\n",
        "        io.set_structure(mutated_structure)\n",
        "        io.save(output_pdb)\n",
        "        print(f\"Mutant PDB saved: {output_pdb}\")\n",
        "\n",
        "if __name__ == \"__main__\":\n",
        "    # List of mutations (e.g., G12A, G12D, etc.)\n",
        "    mutations = [\"G12A\", \"G12D\", \"G12R\", \"G12V\", \"A146T\", \"A59G\", \"D33E\", \"G13D\", \"Q61L\", \"V14I\"]\n",
        "\n",
        "    # Input PDB filename\n",
        "    wild_pdb = \"wild.pdb\"\n",
        "\n",
        "    # Output directory for mutated PDB files\n",
        "    output_dir = \"mutant_pdbs\"\n",
        "\n",
        "    # Generate mutant PDBs\n",
        "    generate_mutant_pdbs(wild_pdb, mutations, output_dir)\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import shutil\n",
        "import os\n",
        "\n",
        "def zip_directory(directory_path, output_zip):\n",
        "    shutil.make_archive(output_zip, 'zip', directory_path)\n",
        "    print(f\"Directory {directory_path} zipped to {output_zip}.zip\")\n",
        "\n",
        "if __name__ == \"__main__\":\n",
        "    directory_path = \"mutant_pdbs\"  # Directory to be zipped\n",
        "    output_zip = \"mutant_pdbs\"  # Output zip file name without extension\n",
        "\n",
        "    zip_directory(directory_path, output_zip)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KJjkf7I2yAvI",
        "outputId": "695f6f03-40ce-46d9-ef76-171982ba226b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Directory mutant_pdbs zipped to mutant_pdbs.zip\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Detailed explanation of the script:**\n",
        "\n",
        "### Overview\n",
        "The script automates the mutation of amino acid residues in a protein structure. It reads an input PDB file, applies specified mutations, and saves the mutated structures as new PDB files.\n",
        "\n",
        "### Key Components\n",
        "\n",
        "1. **Imports and Amino Acid Mapping**\n",
        "   ```python\n",
        "   from Bio import PDB\n",
        "   import os\n",
        "\n",
        "   one_to_three_dict = {\n",
        "       \"A\": \"ALA\", \"R\": \"ARG\", \"N\": \"ASN\", \"D\": \"ASP\", \"C\": \"CYS\",\n",
        "       \"E\": \"GLU\", \"Q\": \"GLN\", \"G\": \"GLY\", \"H\": \"HIS\", \"I\": \"ILE\",\n",
        "       \"L\": \"LEU\", \"K\": \"LYS\", \"M\": \"MET\", \"F\": \"PHE\", \"P\": \"PRO\",\n",
        "       \"S\": \"SER\", \"T\": \"THR\", \"W\": \"TRP\", \"Y\": \"TYR\", \"V\": \"VAL\",\n",
        "       \"U\": \"SEC\",  # Selenocysteine\n",
        "       \"O\": \"PYL\"   # Pyrrolysine\n",
        "   }\n",
        "   ```\n",
        "   - **Imports**: The script uses the `Bio.PDB` module from Biopython for handling PDB files and `os` for file operations.\n",
        "   - **Amino Acid Mapping**: A dictionary maps one-letter amino acid codes to three-letter codes.\n",
        "\n",
        "2. **Mutation Function**\n",
        "   ```python\n",
        "   def mutate_residue(structure, mutation):\n",
        "       wt_residue = mutation[0]  # Wild-type amino acid\n",
        "       mut_residue = mutation[-1]  # Mutant amino acid\n",
        "       res_id = int(mutation[1:-1])  # Residue number\n",
        "\n",
        "       model = structure[0]  # Considering the first model of the structure\n",
        "       for chain in model:\n",
        "           for residue in chain:\n",
        "               if residue.get_id()[1] == res_id:\n",
        "                   if residue.get_resname() != one_to_three_dict[wt_residue]:\n",
        "                       print(f\"Residue at position {res_id} is not {wt_residue}. Skipping mutation.\")\n",
        "                       return structure\n",
        "\n",
        "                   residue_index = chain.child_list.index(residue)\n",
        "                   chain.detach_child(residue.get_id())\n",
        "                   mutant_residue = PDB.Residue.Residue((' ', res_id, ' '), one_to_three_dict[mut_residue], '')\n",
        "\n",
        "                   for atom in residue:\n",
        "                       if mut_residue == 'G' and atom.get_name() == 'CB':\n",
        "                           continue\n",
        "                       if mut_residue == 'P' and atom.get_name() == 'H':\n",
        "                           continue\n",
        "                       if mut_residue == 'C' and atom.get_name() == 'HG':\n",
        "                           continue\n",
        "                       if mut_residue == 'H' and atom.get_name() in ['HD1', 'HE2']:\n",
        "                           continue\n",
        "\n",
        "                       new_atom = PDB.Atom.Atom(atom.get_name(), atom.get_coord(), atom.get_bfactor(), atom.get_occupancy(), atom.get_altloc(), atom.get_fullname(), res_id, element=atom.element)\n",
        "                       mutant_residue.add(new_atom)\n",
        "\n",
        "                   chain.child_list.insert(residue_index, mutant_residue)\n",
        "                   print(f\"Mutated {wt_residue}{res_id} to {mut_residue}{res_id}\")\n",
        "                   break\n",
        "       return structure\n",
        "   ```\n",
        "   - **Function Definition**: `mutate_residue` takes a structure and a mutation string (e.g., \"G12A\").\n",
        "   - **Parsing Mutation**: Extracts the wild-type residue, mutant residue, and residue number from the mutation string.\n",
        "   - **Model and Chain**: Considers the first model of the structure and iterates through chains and residues.\n",
        "   - **Residue Matching**: Checks if the residue at the specified position matches the wild-type residue.\n",
        "   - **Mutation Process**:\n",
        "     - Stores the index of the original residue.\n",
        "     - Removes the original residue and creates a new mutant residue.\n",
        "     - Adds atoms to the new residue, handling special cases (e.g., glycine, proline, cysteine, histidine).\n",
        "     - Inserts the new residue at the correct position in the chain.\n",
        "\n",
        "3. **Generating Mutant PDB Files**\n",
        "   ```python\n",
        "   def generate_mutant_pdbs(input_pdb_file, mutations, output_dir):\n",
        "       parser = PDB.PDBParser(QUIET=True)\n",
        "       structure = parser.get_structure('input', input_pdb_file)\n",
        "\n",
        "       if not os.path.exists(output_dir):\n",
        "           os.makedirs(output_dir)\n",
        "\n",
        "       for mutation in mutations:\n",
        "           structure = parser.get_structure('input', input_pdb_file)\n",
        "           mutated_structure = mutate_residue(structure, mutation)\n",
        "\n",
        "           output_pdb = os.path.join(output_dir, f\"mutant_{mutation}.pdb\")\n",
        "           io = PDB.PDBIO()\n",
        "           io.set_structure(mutated_structure)\n",
        "           io.save(output_pdb)\n",
        "           print(f\"Mutant PDB saved: {output_pdb}\")\n",
        "   ```\n",
        "   - **Function Definition**: `generate_mutant_pdbs` takes an input PDB file, a list of mutations, and an output directory.\n",
        "   - **PDB Parsing**: Loads the input structure using `PDBParser`.\n",
        "   - **Output Directory**: Creates the output directory if it doesn't exist.\n",
        "   - **Mutation Loop**: Iterates through the list of mutations:\n",
        "     - Reloads the structure for each mutation to avoid cumulative changes.\n",
        "     - Applies the mutation using `mutate_residue`.\n",
        "     - Saves the mutated structure to a new PDB file.\n",
        "\n",
        "4. **Main Execution**\n",
        "   ```python\n",
        "   if __name__ == \"__main__\":\n",
        "       mutations = [\"G12A\", \"G12D\", \"G12R\", \"G12V\", \"A146T\", \"A59G\", \"D33E\", \"G13D\", \"Q61L\", \"V14I\"]\n",
        "       wild_pdb = \"wild.pdb\"\n",
        "       output_dir = \"mutant_pdbs\"\n",
        "       generate_mutant_pdbs(wild_pdb, mutations, output_dir)\n",
        "   ```\n",
        "   - **Mutation List**: Specifies the list of mutations to apply.\n",
        "   - **Input and Output**: Defines the input PDB file and output directory.\n",
        "   - **Generate Mutants**: Calls `generate_mutant_pdbs` to create the mutated PDB files.\n",
        "\n",
        "This script should now correctly handle the specified mutations and generate the appropriate mutant PDB files. If you have any further questions or need additional explanations, feel free to ask!"
      ],
      "metadata": {
        "id": "rHhFlqPMkmlE"
      }
    }
  ]
}