06_chem_data_APIs.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3a295354-ec9e-4a09-82ec-1e0a18cc9927",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# apply Jupyter notebook style\n",
    "from IPython.core.display import HTML\n",
    "\n",
    "from custom.styles import style_string\n",
    "\n",
    "HTML(style_string)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8cb217fd-2325-4102-8fe8-f89dba82d338",
   "metadata": {},
   "source": [
    "<div style=\"text-align:center;\">\n",
    "  <img src=\"custom/molssi_main_horizontal.png\" style=\"display: block; margin: 0 auto; max-height:200px;\">\n",
    "</div>\n",
    "\n",
    "# Chemical Data Sources and Programmatic Retrieval of Information\n",
    "\n",
    "<div class=\"overview admonition\"> \n",
    "<p class=\"admonition-title\">Overview</p>\n",
    "\n",
    "Questions:\n",
    "\n",
    "* What kinds of chemical data are available online?\n",
    "\n",
    "* How can I use Python to retrieve information from chemical databases?\n",
    "    \n",
    "* What is a REST API?\n",
    "\n",
    "Objectives:\n",
    "\n",
    "* Learn about chemical data sources available on the web.\n",
    "    \n",
    "* Use Python requests and web APIs to programmatically retrieve information.\n",
    "\n",
    "</div>\n",
    "\n",
    "## Web Databases\n",
    "\n",
    "In this lesson, we will explore online chemical databases and learn how to use Python to retrieve information from them. These databases offer data on chemical structures, properties, biological activities, and more. By the end of this lesson, you will be familiar with several popular chemical data sources and be able to access their data using Python and REST APIs.\n",
    "\n",
    "Some popular chemical databases along with their websites are listed below:\n",
    "\n",
    "[PubChem](https://pubchem.ncbi.nlm.nih.gov/): PubChem is a comprehensive public database of mostly small molecules. It is maintained by the National Institutes of Health and contains information on compound structures, properties, and in some cases, experimental properties.\n",
    "\n",
    "[ChEMBL](https://www.ebi.ac.uk/chembl/): ChEMBL is a large-scale bioactivity database for drug discovery. It is maintained by the European Molecular Biology Laboratory (EMBL) and contains information on bioactive molecules, targets, and assay data, mainly curated from scientific literature.\n",
    "\n",
    "[Protein Data Bank (PDB)](https://www.rcsb.org/): The Protein Data Bank is a repository for 3D structural data of proteins, nucleic acids, and their complexes. It provides information on atomic coordinates, experimental details. The PDB is managed by the Research Collaboratory for Structural Bioinformatics (RCSB).\n",
    "\n",
    "[Materials Project](https://materialsproject.org/): The Materials Project is a collaborative effort to provide an open-source database of materials properties. The database was established in 2011 and originally focused on battery research. It offers a variety of data, including crystal structures and electronic properties for various materials.\n",
    "\n",
    "[ChemSpider](http://www.chemspider.com/): ChemSpider is a free chemical structure database owned by the Royal Society of Chemistry. It aggregates data from various sources, providing information on chemical structures, properties, and associated biological activities.\n",
    "\n",
    "[NIST Chemistry WebBook](https://webbook.nist.gov/chemistry/): The Chemistry WebBook is maintained by the National Institutes of Standards and Technology (NIST) and provides chemical and physical property data for molecular systems.\n",
    "\n",
    "There are many more examples of chemical data sources which we were not able to list here."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5918c3e4-4f55-421e-91a3-b53653f1af5d",
   "metadata": {},
   "source": [
    "## PubChem \n",
    "\n",
    "PubChem is one of the most comprehensive databases of small molecules available.\n",
    "It contains both calculated properties like molecular descriptors, and experimental properties of molecules (though these are harder to access using the API).\n",
    "PubChem's API is open and does not require an account to use, making it one of the most accessible databases.\n",
    "The API is also very powerful, as we will see in this lesson.\n",
    "\n",
    "<div class=\"exercise admonition\">\n",
    "<p class=\"admonition-title\">Exercise</p>\n",
    "    <p>In the next section, we will work with PubChem programmatically. First, it will be useful for you to familiarize yourself with the PubChem website. \n",
    "        Go to <a href=\"https://pubchem.ncbi.nlm.nih.gov/\">PubChem </a> and look up aspirin. Retrieve the molecular weight, number of hydrogen bond\n",
    "        acceptors, and the topological polar surface area and save them in variables.</p>\n",
    "    <p>Next retrieve the same information programmatically using RDKit.**Note** - This is just a review of previous lessons.</p>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "94f2421d-b1d2-4eb9-bb49-d708f1a2934c",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "aspirin_smiles = \"CC(=O)OC1=CC=CC=C1C(=O)O\"\n",
    "#aspirin_mw = \n",
    "#aspirin_h_donors = \n",
    "#aspirin_tpsa = "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "22003e49-9ad2-494c-91e2-25fafbc80f53",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Retrieve the same information with RDKit\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "90a13344-25fb-4ce8-a956-0eb96042a8e3",
   "metadata": {},
   "source": [
    "All of these databases mentioned so far are accessible on the web through your browser. \n",
    "Some of them also provide application program interfaces (APIs) that allow you to access them programmatically.\n",
    "Today, we will be access databases which provide REST APIs using a Python library for retrieving information from the web.\n",
    "\n",
    "## Introduction to REST APIs using PUG REST\n",
    "\n",
    "Many of these databases can be accessed programmatically through something called a REST API.\n",
    "REST stands for **R**epresentational **S**tate **T**ransfer. API stands for **A**pplication **P**rogramming **I**nterface. \n",
    "A REST API is a type of web interface 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 URL.\n",
    "\n",
    "We will work with the PubChem REST API in this lesson. Although the details of every API are different, working with this API will give you some idea of how to work with other REST APIs, should you need to do so in the future.\n",
    "\n",
    "PubChem's main REST API is called [PUG REST](https://pubchem.ncbi.nlm.nih.gov/docs/pug-rest#section=URL-based-API). \"PUG\" in this case stands for \"Power User Gateway\".\n",
    "\n",
    "<div class=\"warning admonition\">\n",
    "<p class=\"admonition-title\">Warning</p>\n",
    "    <p>Please note that PUG REST is not designed for very large volumes (millions) of requests. PubChem asks that any script or application not make more than 5 requests per second, in order to avoid overloading the PubChem servers.</p>\n",
    "    <p>If you need to build a very large dataset, it is recommended that you contact PubChem</p>\n",
    "</div>\n",
    "\n",
    "To retrieve information using PUG REST, you add parameters to the base URL\n",
    "\n",
    "\n",
    "```\n",
    "https://pubchem.ncbi.nlm.nih.gov/rest/pug\n",
    "```\n",
    "\n",
    "For example, to retrieve information about aspirin using SMILES, we would add\n",
    "\n",
    "`/compound/smiles/{aspirin_smiles}`\n",
    "\n",
    "The full URL will be\n",
    "\n",
    "[https://pubchem.ncbi.nlm.nih.gov/rest/pug/compound/smiles/CC(=O)OC1=CC=CC=C1C(=O)O](https://pubchem.ncbi.nlm.nih.gov/rest/pug/compound/smiles/CC(=O)OC1=CC=CC=C1C(=O)O)\n",
    "\n",
    "Go to this URL in your browser.\n",
    "The output will be information about the molecule. \n",
    "By default, the output format is something called XML. However, you can change the format of the data returned by\n",
    "adding another field to the URL. \n",
    "A commonly used type of return format for REST APIs is called JSON.\n",
    "For example, we might want our data to be in something called JSON by adding\n",
    "`/JSON` to the end of our URL, making the URL\n",
    "\n",
    "[https://pubchem.ncbi.nlm.nih.gov/rest/pug/compound/smiles/CC(=O)OC1=CC=CC=C1C(=O)O/JSON](https://pubchem.ncbi.nlm.nih.gov/rest/pug/compound/smiles/CC(=O)OC1=CC=CC=C1C(=O)O/JSON)\n",
    "\n",
    "You could even choose to get the SDF for the molecule by changing the output to SDF.\n",
    "\n",
    "[https://pubchem.ncbi.nlm.nih.gov/rest/pug/compound/smiles/CC(=O)OC1=CC=CC=C1C(=O)O/SDF](https://pubchem.ncbi.nlm.nih.gov/rest/pug/compound/smiles/CC(=O)OC1=CC=CC=C1C(=O)O/SDF)\n",
    "\n",
    "You can retrieve a different molecule by changing the SMILES string. \n",
    "If you wanted to use a different chemical identifier, InCHI key, for example, you would change the word \"smiles\" to \"inchikey\" in the URL\n",
    "then update the chemical identifier accordingly.\n",
    "For this molecule, you could have also changed \"smiles\" to \"name\" and used the name \"aspirin\".\n",
    "\n",
    "### PUG REST URL Design\n",
    "\n",
    "The PUG Rest URL is designed with a specific format. The parts are is a \n",
    "\n",
    "* the \"prolog\" - the base of the URL that does not change.\n",
    "* the \"input\" - defines the molecule or molecules you are looking for\n",
    "* the \"operation\" - defines what you want back from PubChem.\n",
    "* the \"output\" - defines the output format\n",
    "\n",
    "<table><thead><tr><th><strong><a href=\"https://pubchem.ncbi.nlm.nih.gov/rest/pug\">https://pubchem.ncbi.nlm.nih.gov/rest/pug</a></strong></th><th><strong>/compound/name/vioxx</strong></th><th><strong>/property/InChI</strong></th><th><strong>/TXT</strong></th></tr></thead><tbody><tr><td><em>prolog</em></td><td><em>input</em></td><td><em>operation</em></td><td><em>output</em></td></tr></tbody></table>\n",
    "\n",
    "<div class=\"exercise admonition\">\n",
    "<p class=\"admonition-title\">Exercise</p>\n",
    "    <p>Use your browser to look up another molecule of interest using the PUG REST URL. Try several ways of accessing the molecule information\n",
    "    including name, SMILES, or InChi key.</p>\n",
    "    <p>Try changing JSON to something else. Some things you might try are TXT, CSV, SDF, or PNG.\n",
    "</div>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e5256db2-6a9f-4d1f-8e60-ddac32be8e91",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "535e6033-e653-4a9c-9279-32bb7066d14d",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "47048acf-2413-4cca-9c5d-947c9513b1f1",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "d16bcd79-d422-4501-a2a7-0b9bab8047dd",
   "metadata": {},
   "source": [
    "## Programmatic Access of APIs\n",
    "\n",
    "REST APIs start being more useful when you access them programmatically.\n",
    "We are going to use Python to retrieve the data at the URL and convert it to a format we can work with in Python.\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": "d1bab1f3",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "import requests"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d6c93be9-d34a-419f-9b9a-c51dee4ff710",
   "metadata": {},
   "source": [
    "To get information from a URL, we use the `requests.get` method. \n",
    "The argument to this function is the URL we'd like to retrieve information from."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8cdaf79c-0750-49ec-86c7-d87fba9e7bb9",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "data = requests.get(\"https://pubchem.ncbi.nlm.nih.gov/rest/pug/compound/smiles/CC(=O)OC1=CC=CC=C1C(=O)O/JSON\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e0b4ef3f-88d3-4f51-a557-7c5c577c7d4f",
   "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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2badb229-cf8b-40eb-be64-576177dcf374",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "data.status_code"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d6129453-7922-40b4-bb5c-f3c35469a1ef",
   "metadata": {},
   "source": [
    "We can see the JSON associated with our request by calling the `.json()` method, which we will save in a variable called `pubchem_aspirin`.\n",
    "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": "dcce1f44-b0b8-41a6-9d6d-f85df6325bef",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "pubchem_aspirin = data.json()\n",
    "print(pubchem_aspirin)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "43e7af0b-70f7-4659-848e-fdd91d284003",
   "metadata": {
    "tags": []
   },
   "source": [
    "The variable we get from this is a Python dictionary. \n",
    "Recall from Notebook 0 that Python dictionaries allow accessing data using key value pairs. \n",
    "This results gives us more information than we need, so we will make one more modification to the search. \n",
    "We will add some more arguments to specificy that we want properties only returned.\n",
    "\n",
    "For example, we will modify our request to only return molecular weight and the IUPAC name of our compound.\n",
    "To limit the data that is received, we add the property names add `/property/PROPERTY_NAMES` after the SMILES string in the URL."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "eff9aacc-636a-4bbf-bc95-391bb5467435",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "data = requests.get(\"https://pubchem.ncbi.nlm.nih.gov/rest/pug/compound/smiles/CC(=O)OC1=CC=CC=C1C(=O)O/property/MolecularWeight,IUPACName/JSON\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3a19f45c-9aa2-4618-88a2-f40bbc31e5e2",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "pubchem_aspirin = data.json()\n",
    "print(pubchem_aspirin)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dd346123-0790-4a90-8ae0-982769db7e5d",
   "metadata": {},
   "source": [
    "## Understanding JSON\n",
    "\n",
    "The return value from our last request looks like this if printed nicely.\n",
    "\n",
    "```\n",
    "{\n",
    " 'PropertyTable': \n",
    "    {\n",
    "    'Properties': [\n",
    "        {\n",
    "        'CID': 2244, \n",
    "        'MolecularWeight': '180.16', \n",
    "        'IUPACName': '2-acetyloxybenzoic acid'\n",
    "        }\n",
    "     ]\n",
    "    }\n",
    "}\n",
    "```\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "da4b03b2-8cdd-41c9-9a0e-9377e4e6c04f",
   "metadata": {},
   "source": [
    "This data is in a nested Python dictionary. Dictionaries store key, value pairs.\n",
    "The first key in this dictionary is `PropertyTable`. We can get the data in the `PropertyTable` key using the following syntax."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "68d8d051-e539-4d19-8537-081f69df4544",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "pubchem_aspirin[\"PropertyTable\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a71bd375-d7e8-449e-a54a-547f4224bac9",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "pubchem_aspirin[\"PropertyTable\"][\"Properties\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c329bb71-af2e-4a31-b3c6-3e48040ff280",
   "metadata": {},
   "source": [
    "<div class=\"exercise admonition\">\n",
    "<p class=\"admonition-title\">Exercise</p>\n",
    "    <p>Modify the request URL to also retrieve the number of hydrogen bond acceptors and the topological polar surface area.</p>\n",
    "    <p>You should to refer to the <a href=\"https://pubchem.ncbi.nlm.nih.gov/docs/pug-rest#section=Compound-Property-Tables\">list of compound properties in the PUG rest documentation to get the correct property names.</p>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ccc13a06-2e9d-4e86-b708-232e374ec6d8",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c53adbbf-6002-469e-b36e-ebfaa8dccc04",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "d7cab595-68c9-4a40-ac4f-ad26f5714f6b",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "1b0fa443-87f6-4caa-b8ba-d3f05182899f",
   "metadata": {},
   "source": [
    "The real benefit of using an API programmatically is that you can quickly retrieve information and work with it in Python. \n",
    "For example, let's consider that we wanted to retrieve information about aspirin, caffeine, serotonin, and dopamine.\n",
    "\n",
    "We make a list of our molecules of interest, then use a `for` loop to retrieve information about them all.\n",
    "Note that the data we are printing is in JSON format. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0d1d7aee-3ca8-4f43-b362-ca6114b1beff",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "molecules = [\"aspirin\", \"caffeine\", \"serotonin\", \"dopamine\"]\n",
    "\n",
    "for molecule in molecules:\n",
    "    data = requests.get(f\"https://pubchem.ncbi.nlm.nih.gov/rest/pug/compound/name/{molecule}/property/MolecularWeight,IUPACName,IsomericSmiles/JSON\")\n",
    "    molecule_data = data.json()\n",
    "    print(molecule, molecule_data[\"PropertyTable\"][\"Properties\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d13a4d35-67eb-4515-acd1-a26ed87a34da",
   "metadata": {},
   "source": [
    "You can imagine that you could save this in a pandas dataframe, or even load the SMILES into an RDKit mol object for further analysis.\n",
    "\n",
    "The PUG REST API for PubChem is very powerful. You search for molecules based on structural similarity, or even retrieve patent information for molecules. There is much more to the PubChem API that you can find from reading the [PubChem PUG REST tutorial](https://pubchem.ncbi.nlm.nih.gov/docs/pug-rest-tutorial) and [documentation](https://pubchem.ncbi.nlm.nih.gov/docs/pug-rest)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7b6c7890-2e2f-43ba-a4bd-ce6865823e35",
   "metadata": {},
   "source": [
    "## Building a Data Set using the PubChem API\n",
    "\n",
    "We can use the PUG REST API to build data sets in DataFrames. \n",
    "Depending on the information you are trying to get, there will be many ways you could approach this problem.\n",
    "\n",
    "In the example below, we will loop over the molecule names and retrieve the CID for each molecule. \n",
    "The CID is a unique identifer for PubChem.\n",
    "Then, we can do a single API call for all of our molecules using the CID. When using CID, PubChem allows you to retrieve information for more than one molecule \n",
    "at a time. Since this is just one number, we will retrieve it as text.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0101e374-6a1e-4749-b796-51bfd6833666",
   "metadata": {},
   "outputs": [],
   "source": [
    "molecules = [\"aspirin\", \"caffeine\", \"serotonin\", \"dopamine\"]\n",
    "\n",
    "cids = []\n",
    "\n",
    "for molecule in molecules:\n",
    "    url = f\"https://pubchem.ncbi.nlm.nih.gov/rest/pug/compound/name/{molecule}/cids/JSON\"\n",
    "    response = requests.get(url)\n",
    "    cid = response.json()[\"IdentifierList\"][\"CID\"]\n",
    "    cids.extend(cid)\n",
    "\n",
    "# convert to string\n",
    "cids = [str(cid) for cid in cids]\n",
    "cids_string = \",\".join(cids)\n",
    "print(cids_string)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2cfebfcd-fca9-4427-b498-d2db17d5ca11",
   "metadata": {
    "tags": []
   },
   "source": [
    "Next, we will use the list of CIDs to request information about all of the molecules at once."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dd03ea3b-277c-420f-aa83-a7e703309b59",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "data_set = requests.get(f\"https://pubchem.ncbi.nlm.nih.gov/rest/pug/compound/cid/{cids_string}/property/MolecularWeight,IUPACName,IsomericSmiles/JSON\")\n",
    "\n",
    "json_data = data_set.json()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "23110ab0-e9d5-4965-a442-d8480e1471d0",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "\n",
    "df = pd.DataFrame(json_data[\"PropertyTable\"][\"Properties\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "10e4d45c-e27f-4fac-afa9-681504a2240d",
   "metadata": {},
   "outputs": [],
   "source": [
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "79f88c33-dbc0-4c4e-b2b0-341baa613d40",
   "metadata": {},
   "source": [
    "We could modify our URL slightly to get an SDF file instead. If we do this, we have to write the text to a file, then we can load it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3da9ab2a-d42d-40c6-8ec1-6f0399b03572",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "sdfs = requests.get(f\"https://pubchem.ncbi.nlm.nih.gov/rest/pug/compound/cid/{cids_string}/record/SDF\")\n",
    "sdf_text = sdfs.text"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c0699988-8cb4-4c83-8462-ed00e69ebf08",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# write sdf to file\n",
    "\n",
    "with open(\"data/molecules.sdf\", \"w+\") as f:\n",
    "    f.write(sdf_text)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aaefe28f-b5e1-4125-a89d-3bbf48e23bfb",
   "metadata": {},
   "source": [
    "Now we can reload our data using PandasTools"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9a2f6585-177e-4a4a-97c1-8a6479b9092a",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "from rdkit.Chem import PandasTools\n",
    "\n",
    "PandasTools.RenderImagesInAllDataFrames(True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ff95eb54-39ee-418e-87d9-3902fe82769c",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "df = PandasTools.LoadSDF(\"data/molecules.sdf\")\n",
    "\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "33775212-4457-4305-8d15-0ed5f4e2e867",
   "metadata": {},
   "source": [
    "<div class=\"exercise admonition\">\n",
    "<p class=\"admonition-title\">Exercise</p>\n",
    "    Construct a data set using the set of molecules in the cell below. Some of the molecules\n",
    "    will return more than one CID.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6184f8d7-c3a1-4bbf-ad32-23bdfec8c3d6",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "food_dyes = [\"Allura Red AC\", \"Tartrazine\", \n",
    "             \"Sunset Yellow FCF\", \"Brilliant Blue FCF\",\n",
    "            \"Indigotine\", \"Fast Green FCF\"]\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cfddafb2-0958-4580-a10f-ed029dd45c1a",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7b1a05ee-0de8-4c1f-8bb5-9bd59d70f5ff",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "078e6b76-8082-40c9-bbe0-22feef69f523",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b2c5d109-8b94-417e-b89f-83ac005d5b50",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "131ba94e-344b-4669-9141-acd982bcf484",
   "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.10.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}