05_rcsb_api.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "032153b0-0268-40be-87b6-ab11c2a15d81",
   "metadata": {},
   "source": [
    "# Retrieving Information from the PDB using the Web API\n",
    "\n",
    "<div class=\"overview\">\n",
    "<p class=\"overview-title\">Overview</p>\n",
    "<p>Questions</p>\n",
    "    <ul>\n",
    "        <li>How can I use Python to download files and get information from the internet?</li>\n",
    "        <li>What is a REST API?</li>\n",
    "    </ul>\n",
    "<p>Objectives:</p>\n",
    "    <ul>\n",
    "        <li>Manipulate URLs to use the PDB REST API.</li>\n",
    "        <li>Use Python requests to retrieve information from the PDB.</li>\n",
    "        <li>See how we might use a web API with Python to analyze many protein structures</li>\n",
    "    </ul>\n",
    "    \n",
    "<p>In this module, we will calculate initial rates from the raw data (&Delta;A<sub>405</sub>) in an enzyme kinetics experiment with alkaline phosphatase. In the process, we will import the raw data into a pandas dataframe, use some pandas tools to reorganize the data, produce a second pandas dataframe that contains the substrate concentrations and initial rates at each concentration. Finally, we will export this information to a csv file to use in the next module, where we will explore nonlinear curve fitting in python.\n",
    "    </p>\n",
    "</div>\n",
    "\n",
    "\n",
    "In this lesson, we will explore how to retrieve information from the PDB Web API.\n",
    "\n",
    "Many databases can be accessed programmatically through something called a REST API. REST stands for Representational State Transfer. API stands for Application Programming Interface. A REST API is a type of web API that is used to allow different software systems to communicate with each other over the internet.\n",
    "\n",
    "Usually a REST API is accessed by varying parameters in a web address.\n",
    "\n",
    "We will work with two types of API from the PDB in this lesson. \n",
    "\n",
    "## File Download using Biopython\n",
    "\n",
    "Biopython has functions for retrieving structure files.\n",
    "To download a structure file from the PDB, you make a `PDBList`.\n",
    "Then, you use the function `pdb_list.retrieve_pdb_file.\n",
    "This function takes the PDB ID as a parameter. \n",
    "You specify the folder where you want the file saved using `pdir=FOLDER`. \n",
    "If we want to download the structure as an MMCIF, we have to add `file_format=\"mmCif\"`.\n",
    "\n",
    "For example, the following cell downloads the PDB `4HHB`, hemoglobin."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "509a7669-3f85-4725-b348-4dfe6331a641",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "from Bio.PDB import PDBList\n",
    "\n",
    "# Create an instance of the PDBList class\n",
    "pdb_list = PDBList()\n",
    "\n",
    "# Specify the PDB ID of the structure you want to download\n",
    "pdb_id = \"4hhb\" # hemoglobin pdb ID\n",
    "\n",
    "# Download the MMCIF file using the retrieve_pdb_file method\n",
    "pdb_filename = pdb_list.retrieve_pdb_file(pdb_id, pdir=\"data/PDB_files\", file_format=\"mmCif\")\n",
    "\n",
    "# Print the name of the downloaded file\n",
    "print(pdb_filename)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "81ebef31-0aba-4b75-8feb-64ffd0efd4c8",
   "metadata": {},
   "source": [
    "If you check your data folder, you will see that you now have a file called `4hhb.cif`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dc91111b-a4b2-4a01-8261-f44d2c5c4c31",
   "metadata": {},
   "source": [
    "## PDB Data API\n",
    "\n",
    "You can use the web to retrieve information about a molecule using its PDB ID using the PDB Data API. \n",
    "This will give you access to information about the PDB entry, rather than the structure file like with the Biopython file download.\n",
    "\n",
    "As mentioned above, web APIs often work by varying text in a web address (also called URL).\n",
    "\n",
    "The PDB Data API has the following format:\n",
    "\n",
    "```\n",
    "https://data.rcsb.org/rest/v1/core/<TYPE_OF_RESOURCE>/<IDENTIFIER>\n",
    "```\n",
    "\n",
    "For example, to get the full entry for `4hhb`, you would do:\n",
    "\n",
    "https://data.rcsb.org/rest/v1/core/entry/4hhb\n",
    "\n",
    "Try clicking this link! It will display text in your browser with info about `4HHB`.\n",
    "\n",
    "There are many things you can do with the REST API that are beyond this workshop. \n",
    "However, one interesting thing you can do is to retrieve PubMed annotations for an entry's primary citation.\n",
    "\n",
    "https://data.rcsb.org/rest/v1/core/pubmed/4hhb\n",
    "\n",
    "The data in these results is in a data format called JSON.  This is a commonly used type of return format for web APIs because it can be processed using programming. \n",
    "Its format is similar to a Python dictionary, having keys and values.\n",
    "\n",
    "## Programmatic Access of APIs\n",
    "REST APIs start being more useful when you access them programmatically. We are going to use Python to retrieve the data at the URL and convert it to a format we can work with.\n",
    "\n",
    "We will use a Python library called requests. Requests is used to retrieve information from websites and URLs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dc8fae41-a527-422a-bc3c-981c3c69b03d",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "a9e0ddda-a70d-41fe-855d-338ea227dae7",
   "metadata": {},
   "source": [
    "To get information from a URL, we use the requests.get method. The argument to this function is the URL we'd like to retrieve information from."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b004b7cb-b91e-436a-b57e-c5ec48b32568",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "b98e8096-a08a-4b04-a6f0-faa48c14a604",
   "metadata": {},
   "source": [
    "Our data variable now contains the results and other information about the request we made.\n",
    "\n",
    "If our request was successful. It will have a status code of `200`. \n",
    "This is a feature of web URLs. \n",
    "If they are successfully retrieved, they send a status code of 200. \n",
    "This is true for any website you receive.\n",
    "One status code you may be familiar with is `404`, which occurs when a resources is not found.\n",
    "\n",
    "Note that `status_code` is not a function associated with data, so we do not need to use `()`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9c1d9a84-7e1a-4268-842d-323b6f979a1a",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "1fdfe418-9bfb-414e-a199-50898f0ddfe3",
   "metadata": {},
   "source": [
    "We can see the JSON associated with our request by calling the .json() method, which we will save in a variable called `info_4hhb`. Our variable is now similar to a Python dictionary, which is a data type that has key, value pairs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f7c3e828-5b72-4dda-8d3b-032005c2b155",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "f08dfa8d-cf7f-4da6-a657-cc5f5ef4fc57",
   "metadata": {},
   "source": [
    "Once we have loaded our returned values as json, we can see all of the keywords associated with an entry using variable.keys()\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "29767197-57fa-4f99-a517-425e6ad21601",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "7bf4d56c-61e0-4514-8ded-7d08bd2552b0",
   "metadata": {},
   "source": [
    "The variable `info_4hhb` is a Python dictionary, meaning that\n",
    "we can access information in the dictionary using the syntax:\n",
    "\n",
    "```python\n",
    "dictionary_name[\"key_name\"]\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0d328aff-3652-487b-841b-3fff34712a4d",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "64e7a36a-1b36-4076-b9e4-f7c7c648198b",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "54d85c3e-f610-4548-8946-36126746b740",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8ab0f17b-1499-4920-8e61-89e3686071e5",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "bc63ae59-93e2-436e-832c-5da945b94a6d",
   "metadata": {},
   "source": [
    "You can also use the PDB Data API to retrieve information about interfaces between polymeric entities (protein, or nucleic acids) using\n",
    "one of the API endpoints by changing the URL.\n",
    "\n",
    "The format for querying about interfaces is\n",
    "\n",
    "```\n",
    "https://data.rcsb.org/rest/v1/core/interface/<pdb_id>/<assembly_id>/<interface_id>\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d9f83bbd-1040-43a1-8cfd-dbffc78d75b2",
   "metadata": {},
   "source": [
    "In the cell below, we get the first interface for assembly 1 (there is only one assembly in this PDB entry)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "698a5701-6ed2-4a99-a7d2-76d1c32273fc",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "## Fill in PDB ID, Assembly ID, and Interface ID\n",
    "interface = requests.get(\"https://data.rcsb.org/rest/v1/core/interface/FILL_IN_PDB_ID/ASSEMBLY_ID/INTERFACE_ID\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5a5246cd-6939-4bf6-bbee-d9c43bdca29e",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "interface.status_code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "aa480f0e-595e-46c9-ac42-7ca5f0952fad",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "interface_info = interface.json()\n",
    "interface_info[\"rcsb_interface_info\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e4e5f5d2-e2d1-4a92-ad88-e88a63e19e74",
   "metadata": {},
   "source": [
    "Try changing the numbers in the URL. How does it change your results?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5d98c7a9-14de-40da-998a-c29c3b576d6a",
   "metadata": {},
   "source": [
    "## PDB Search API\n",
    "\n",
    "The API we were just working with is called the PDB \"Data\" API. \n",
    "\n",
    "However, the PDB has another API called the \"search\" API that let's you search based on keywords, host species, sequence similarity, and many other things.\n",
    "The search API can be complicated, but is [well documented](https://search.rcsb.org/#search-api).\n",
    "\n",
    "The format for this URL is:\n",
    "\n",
    "`https://search.rcsb.org/rcsbsearch/v2/query?json={search-request}`\n",
    "\n",
    "Where `search-request` is a JSON (similar to a Python dictionary) containing your search parameters.\n",
    "We will create a Python dictionary, then use the `json` library to convert it to a json (the data type required by the search API).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f4af664d-2835-4b50-8b7c-2ee3b6b68612",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "import json\n",
    "\n",
    "my_query = {\n",
    "  \"query\": {\n",
    "    \"type\": \"terminal\",\n",
    "    \"service\": \"full_text\",\n",
    "    \"parameters\": {\n",
    "        \"value\": '\"oxygen storage\"'\n",
    "    }\n",
    "  },\n",
    "  \n",
    "  \"return_type\": \"entry\"\n",
    "}\n",
    "\n",
    "my_query = json.dumps(my_query)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1f4172c0-8427-457e-8607-64b0538a0fb6",
   "metadata": {},
   "source": [
    "Now, we use `requests.get` with the our search query and the search API URL format."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "352b1e3e-6c6f-4536-8086-33e40c2ddb5b",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "## use requests to do the search here\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9823b35e-09a7-4fc7-aa23-88b3ac09ad63",
   "metadata": {},
   "source": [
    "Our results tell us that our query returned `619` results (`total_count`).\n",
    "The `results_set` keyword has a list of results. \n",
    "The `identifier` key in each value in `results_set` tells\n",
    "us the PDB ID of a search result.\n",
    "\n",
    "You will notice that even though the search has told us there are `619` results, we only have 10 values in our results variable.\n",
    "This is because the API always counts the number of results, but will only return 10 unless we ask for more.\n",
    "\n",
    "We could now combine this with Biopython or the data API to get information about the structures.\n",
    "For example, we will retrieve the title of the paper where this structure was published we could do so:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b270fa47-e029-4887-ab86-a5a409d7d661",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "first_result = results[\"result_set\"][0][\"identifier\"]\n",
    "print(first_result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "eae50427-22a5-49de-9a0b-f0da28f0e423",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "## use request with data API for first_result\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f0fa35aa-dcaa-44c8-ba9d-991c8e0be417",
   "metadata": {},
   "source": [
    "You can also control the format of the returned results including the\n",
    "number of results and how the results are sorted.\n",
    "The query below searchs for the phrase \"oxygen storage\" in the keywords of the structure. \n",
    "We've specified that we want 50 values returned (instead of the usual 10), and for the results to be sorted\n",
    "by the initial release date in ascending order (oldest result first).\n",
    "If you wanted to see the 10 most recently released results, you would change \n",
    "\"asc\" to \"desc\" in the query below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a0833a73-c887-459c-b8c4-3056abc7053b",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "my_query = {\n",
    "  \"query\": {\n",
    "    \"type\": \"terminal\",\n",
    "    \"service\": \"text\",\n",
    "    \"parameters\": {\n",
    "        \"attribute\": \"struct_keywords.pdbx_keywords\",\n",
    "        \"operator\": \"contains_phrase\",\n",
    "        \"value\": '\"oxygen storage\"'\n",
    "    }\n",
    "  },\n",
    "\n",
    "  \"request_options\": {\n",
    "    \"paginate\": {\n",
    "      \"start\": 0,\n",
    "      \"rows\": 50,\n",
    "    },\n",
    "    \"sort\": [\n",
    "      {\n",
    "      \"sort_by\": \"rcsb_accession_info.initial_release_date\",\n",
    "      \"direction\": \"asc\" \n",
    "    }\n",
    "    ]\n",
    "  },\n",
    "  \n",
    "  \"return_type\": \"entry\"\n",
    "}\n",
    "\n",
    "my_query = json.dumps(my_query)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d7e445fd-e5d5-4542-b73d-0ded18eb25d2",
   "metadata": {},
   "source": [
    "Now, we use `requests.get` with the our search query and the search API URL format.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "96c84c29-fcd5-4dc6-a404-5f1159101c4b",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "data = requests.get(f\"https://search.rcsb.org/rcsbsearch/v2/query?json={my_query}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "488f5cc8-5dbe-4a28-9290-3406e2b4ced5",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "data.status_code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c9461b71-741a-4d46-b586-1ee68a5ba313",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "results = data.json()\n",
    "results"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a5d17c26-d6e8-470b-bd91-224da20bc59a",
   "metadata": {},
   "source": [
    "## Using Biopython to Analyze Search Results\n",
    "\n",
    "The API becomes really interesting when we use the results for analysis.\n",
    "Keeping our example of oxygen storage, we could use Biopython to analyze the structures we have retrieved to see\n",
    "if there are heme groups in the structures and if there are common motifs in the binding of the heme groups to proteins.\n",
    "\n",
    "The following cells show a farily complicated analysis of the structures we have retrieved using Biopython in the cells just above this section.\n",
    "If you are new to programming, the next few cells will be hard to understand.\n",
    "However, they are a demonstration of the type of analysis that can be done by retrieving search results programmatically\n",
    "and analyzing data using Python.\n",
    "The end of the analysis prints the most commonly found neighboring residues to iron in the structures retrieved by the search.\n",
    "\n",
    "The program has multiple steps:\n",
    "\n",
    "1. Biopython is used to download the mmcif files for all of the structures.\n",
    "2. Biopython is used to create structure objects, sort through atoms, and find residues neighboring iron atoms.\n",
    "3. Python functions (particular [Counter](https://docs.python.org/3/library/collections.html#collections.Counter) ) are used to count residue combinations.\n",
    "\n",
    "```python\n",
    "## Step 1\n",
    "from Bio.PDB import PDBList\n",
    "\n",
    "# Create an instance of the PDBList class\n",
    "pdb_list = PDBList()\n",
    "\n",
    "# Download all of the structure files\n",
    "for result in results[\"result_set\"]:\n",
    "    pdb_id = result[\"identifier\"].lower()\n",
    "\n",
    "    # Download the MMCIF file using the retrieve_pdb_file method\n",
    "    pdb_filename = pdb_list.retrieve_pdb_file(pdb_id, pdir=\"pdb_files\", file_format=\"mmCif\")\n",
    "\n",
    "\n",
    "## Step 2\n",
    "\n",
    "from Bio.PDB.MMCIFParser import MMCIFParser\n",
    "from Bio.PDB import NeighborSearch\n",
    "from collections import Counter\n",
    "\n",
    "# Create an MMCIFParser object to parse mmCIF files.\n",
    "parser = MMCIFParser(QUIET=True)\n",
    "\n",
    "# Define the maximum distance (in Ångströms) for identifying neighboring residues.\n",
    "cutoff_distance = 5\n",
    "\n",
    "# Initialize a dictionary to store the neighboring residues for each protein structure.\n",
    "residue_neighbors = {}\n",
    "\n",
    "# The 'results' variable is a dictionary containing search results.\n",
    "# Each result in 'results[\"result_set\"]' represents a protein structure with a PDB ID.\n",
    "for result in results[\"result_set\"]:\n",
    "    # Extract the PDB ID and convert it to lowercase.\n",
    "    pdb_id = result[\"identifier\"].lower()\n",
    "\n",
    "    # Parse the mmCIF file for the protein structure using the PDB ID.\n",
    "    # The file is expected to be located in the 'pdb_files' directory.\n",
    "    structure = parser.get_structure(pdb_id, f\"pdb_files/{pdb_id}.cif\")\n",
    "    \n",
    "    # Extract all atoms from the protein structure.\n",
    "    atoms = list(structure.get_atoms())\n",
    "    \n",
    "    # Create a NeighborSearch object to perform neighbor searches.\n",
    "    neighbor_search = NeighborSearch(atoms)\n",
    "    \n",
    "    # Initialize a list to store the neighboring residues for this protein structure.\n",
    "    neighbor_list = []\n",
    "\n",
    "    # Loop through the atoms in the protein structure.\n",
    "    for atom in atoms:\n",
    "        # Check if the atom is an iron (Fe) atom.\n",
    "        if atom.element == \"FE\":\n",
    "            # Get the parent residue of the iron atom.\n",
    "            iron_residue = atom.get_parent()\n",
    "\n",
    "            # Find atoms within the cutoff distance from the iron atom.\n",
    "            neighbors = neighbor_search.search(atom.get_coord(), cutoff_distance)\n",
    "            \n",
    "            # Loop through the neighboring atoms.\n",
    "            for neighbor in neighbors:\n",
    "                # Get the parent residue of the neighboring atom.\n",
    "                residue = neighbor.get_parent()\n",
    "    \n",
    "                # Check if the neighboring residue is different from the iron-containing residue.\n",
    "                if residue != iron_residue:\n",
    "                    # Add the neighboring residue to the list.\n",
    "                    neighbor_list.append(residue)\n",
    "                    \n",
    "    # Store the unique neighboring residues in the dictionary using the PDB ID as the key.\n",
    "    residue_neighbors[pdb_id] = set(neighbor_list)\n",
    "\n",
    "# The 'residue_neighbors' dictionary contains the neighboring residues for each protein structure.\n",
    "\n",
    "\n",
    "## Step 3\n",
    "## Now we will want to count the residue neighbor types.\n",
    "# Initialize an empty Counter object to store the counts of residue combinations.\n",
    "combination_counts = Counter()\n",
    "\n",
    "# Iterate over the items in the 'residue_neighbors' dictionary.\n",
    "# Each item consists of a PDB ID ('pdb_id') and a set of neighboring residues ('neighbors') to iron atoms.\n",
    "for pdb_id, neighbors in residue_neighbors.items():\n",
    "    # Extract the residue names ('resname') for each neighboring residue using the 'get_resname' method.\n",
    "    resname = [x.get_resname() for x in neighbors if x.get_resname()]\n",
    "    \n",
    "    # Count the occurrences of each residue name in the current combination.\n",
    "    res_counts = Counter(resname)\n",
    "    \n",
    "    # Convert the residue counts to a tuple of (residue, count) pairs, sorted by residue name.\n",
    "    # This standardizes the representation of each combination.\n",
    "    combination = tuple(sorted(res_counts.items()))\n",
    "    \n",
    "    # Update the combination_counts with the current combination.\n",
    "    combination_counts.update([combination])\n",
    "\n",
    "# Use the 'most_common' method to get the most common residue combinations.\n",
    "# The result is a list of tuples, where each tuple contains a combination and its count.\n",
    "most_common_combinations = combination_counts.most_common()\n",
    "\n",
    "# For example, to get the top 5 most common combinations, use 'most_common(5)'.\n",
    "top_5_combinations = combination_counts.most_common(5)\n",
    "print(\"\\nTop 5 most common residue combinations for iron neighbors:\")\n",
    "for combination, count in top_5_combinations:\n",
    "    combination_str = ', '.join([f\"{count} {residue}\" for residue, count in combination])\n",
    "    print(f\"Combination: {combination_str}, Count: {count}\")\n",
    "```\n",
    "\n",
    "```output\n",
    "\n",
    "Top 5 most common residue combinations for iron neighbors:\n",
    "Combination: 2 HIS, 1 HOH, 1 VAL, Count: 4\n",
    "Combination: 1 CMO, 2 HIS, 1 VAL, Count: 3\n",
    "Combination: 2 HIS, 1 HOH, 1 OXY, 1 VAL, Count: 2\n",
    "Combination: 5 HIS, 2 HOH, 2 VAL, Count: 2\n",
    "Combination: 4 HIS, 2 HOH, 2 VAL, Count: 2\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fd7861b0-fd46-44c8-bc16-67e8166b971b",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.16"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}