for-scripters/Python/automation-of-the-pathLinker-app-paper-lovastatin-analysis.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "view-in-github"
   },
   "source": [
    "<a href=\"https://colab.research.google.com/github/cytoscape/cytoscape-automation/blob/master/for-scripters/Python/automation-of-the-pathLinker-app-paper-lovastatin-analysis.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "iBDRio33xAhy"
   },
   "source": [
    "## Automation of the PathLinker App paper Lovastatin Analysis\n",
    "\n",
    "## Yihang Xin and Alex Pico\n",
    "\n",
    "## 2023-05-30"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "xKGwJ0MbxAh0"
   },
   "source": [
    "## Installation\n",
    "The following chunk of code installs the `py4cytoscape` module."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "id": "WDX6mK5GxAh1"
   },
   "outputs": [],
   "source": [
    "%%capture\n",
    "!python3 -m pip install python-igraph requests pandas networkx\n",
    "!python3 -m pip install py4cytoscape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "zxOo-fwlxBh6"
   },
   "source": [
    "If you are using a remote notebook environment such as Google Colab, please execute the cell below. (If you're running on your local notebook, you don't need to do that.)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "id": "btKY0U1NxC5b"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requirement already satisfied: py4cytoscape in /opt/anaconda3/lib/python3.8/site-packages (0.0.10)\n",
      "Requirement already satisfied: python-igraph in /opt/anaconda3/lib/python3.8/site-packages (from py4cytoscape) (0.8.3)\n",
      "Requirement already satisfied: requests in /opt/anaconda3/lib/python3.8/site-packages (from py4cytoscape) (2.24.0)\n",
      "Requirement already satisfied: networkx in /opt/anaconda3/lib/python3.8/site-packages (from py4cytoscape) (2.5)\n",
      "Requirement already satisfied: colorbrewer in /opt/anaconda3/lib/python3.8/site-packages (from py4cytoscape) (0.2.0)\n",
      "Requirement already satisfied: pandas in /opt/anaconda3/lib/python3.8/site-packages (from py4cytoscape) (1.1.3)\n",
      "Requirement already satisfied: six in /opt/anaconda3/lib/python3.8/site-packages (from colorbrewer->py4cytoscape) (1.15.0)\n",
      "Requirement already satisfied: decorator>=4.3.0 in /opt/anaconda3/lib/python3.8/site-packages (from networkx->py4cytoscape) (4.4.2)\n",
      "Requirement already satisfied: python-dateutil>=2.7.3 in /opt/anaconda3/lib/python3.8/site-packages (from pandas->py4cytoscape) (2.8.1)\n",
      "Requirement already satisfied: pytz>=2017.2 in /opt/anaconda3/lib/python3.8/site-packages (from pandas->py4cytoscape) (2020.1)\n",
      "Requirement already satisfied: numpy>=1.15.4 in /opt/anaconda3/lib/python3.8/site-packages (from pandas->py4cytoscape) (1.19.2)\n",
      "Requirement already satisfied: texttable>=1.6.2 in /opt/anaconda3/lib/python3.8/site-packages (from python-igraph->py4cytoscape) (1.6.3)\n",
      "Requirement already satisfied: idna<3,>=2.5 in /opt/anaconda3/lib/python3.8/site-packages (from requests->py4cytoscape) (2.10)\n",
      "Requirement already satisfied: urllib3!=1.25.0,!=1.25.1,<1.26,>=1.21.1 in /opt/anaconda3/lib/python3.8/site-packages (from requests->py4cytoscape) (1.25.11)\n",
      "Requirement already satisfied: chardet<4,>=3.0.2 in /opt/anaconda3/lib/python3.8/site-packages (from requests->py4cytoscape) (3.0.4)\n",
      "Requirement already satisfied: certifi>=2017.4.17 in /opt/anaconda3/lib/python3.8/site-packages (from requests->py4cytoscape) (2020.6.20)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING: You are using pip version 21.0; however, version 21.3.1 is available.\n",
      "You should consider upgrading via the '/opt/anaconda3/bin/python -m pip install --upgrade pip' command.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loading Javascript client ... 3e888b06-2bcf-4c50-880f-e86c3398c388 on https://jupyter-bridge.cytoscape.org\n"
     ]
    },
    {
     "data": {
      "application/javascript": [
       "var Channel = \"3e888b06-2bcf-4c50-880f-e86c3398c388\"; \n",
       "\n",
       "var JupyterBridge = \"https://jupyter-bridge.cytoscape.org\"; \n",
       "\n",
       "  /*\n",
       "    These functions serve as a connector between a remote Jupyter server and Cytoscape.\n",
       "    They run in the user's browser, which also shows the Jupyter Notebook.\n",
       "\n",
       "    A remote Jupyter Notebook call to the py4cytoscape package is forwarded to the Jupyter Bridge,\n",
       "    which is a standalone server. The functions in this connector execute in the Jupyter Notebook\n",
       "    browser, which executes on the same PC as Cytoscape. So, that's 4 components: (A) remote\n",
       "    Jupyter Notebook, (B) separate Jupyter Bridge server, (C) this browser-based component, and\n",
       "    (D) Cytoscape. (A) is on a remote server, (B) is on a different remote server, and (C) and (D)\n",
       "    are on the user's PC.\n",
       "\n",
       "    (A) calls its py4cytoscape module, which forwards the request (in a JSON wrapper) to (B).\n",
       "    (C) picks up the request from (B), unpacks the request and forwards it to (D). (C) awaits a\n",
       "    reply from (D), and when it gets it, it forwards the reply (in a JSON wrapper) to (B).\n",
       "    (A)'s py4cytoscape module picks up the reply on (B) when it becomes available, unpacks it,\n",
       "    and returns it to (A).\n",
       "\n",
       "    A Jupyter Notebook can talk to only one Cytoscape (i.e., the one on the machine running the\n",
       "    Jupyter Notebook browser), and Cytoscape should be called by only one Jupyter Notebook. The\n",
       "    Jupyter Bridge differentiates between Notebook-Cytoscape conversations via a channel UUID.\n",
       "    The UUID is prepended to this browser component by py4Cytoscape, and the component is\n",
       "    started by the Jupyter Notebook. (I wish py4Cytoscape could start the component, too, but I\n",
       "    haven't figured out how to do that yet, so startup code *is* required in the Jupyter\n",
       "    Notebook.)\n",
       "\n",
       "    Note that for the case of a Jupyter server running on the same machine as Cytoscape, this\n",
       "    bridge isn't necessary because the Jupyter server's HTTP calls can easily connect to\n",
       "    Cytoscape over a localhost socket. So, the combination of Jupyter Bridge and this browser\n",
       "    component solves the problem of a Jupyter server (e.g., Google's Colab) that can't\n",
       "    connect to Cytoscape that sits behind a firewall.\n",
       "\n",
       "    The request represents an HTTP call that py4cytoscape would normally make via HTTP directly\n",
       "    to Cytoscape via localhost when both py4cytoscape and Cytoscape are running on the same machine.\n",
       " */\n",
       "\n",
       "const VERSION = '0.0.2'\n",
       "\n",
       "var showDebug; // Flag indicating whether to show Jupyter-bridge progress\n",
       "if (typeof showDebug === 'undefined') {\n",
       "    showDebug = false\n",
       "}\n",
       "if (showDebug) {\n",
       "    alert(\"Starting Jupyter-bridge browser component\")\n",
       "}\n",
       "\n",
       "//const JupyterBridge = 'http://127.0.0.1:5000' // for testing against local Jupyter-bridge\n",
       "var JupyterBridge; // URL of Jupyter-bridge server could be defined by assignment pre-pended to this file\n",
       "if (typeof JupyterBridge === 'undefined') {\n",
       "    JupyterBridge = 'https://jupyter-bridge.cytoscape.org' // for production\n",
       "}\n",
       "var Channel; // Unique constant that could be defined by assignment pre-pended to this file\n",
       "if (typeof Channel === 'undefined') { // ... but if not assigned, use a debugging value\n",
       "    Channel = 1\n",
       "}\n",
       "\n",
       "\n",
       "var httpR = new XMLHttpRequest(); // for sending reply to Jupyter-bridge\n",
       "var httpRE = new XMLHttpRequest(); // for sending backup error reply to Jupyter-bridge\n",
       "var httpC = new XMLHttpRequest(); // for sending command to Cytoscape\n",
       "var httpJ = new XMLHttpRequest(); // for fetching request from Jupyter-bridge\n",
       "\n",
       "const HTTP_OK = 200\n",
       "const HTTP_SYS_ERR = 500\n",
       "const HTTP_TIMEOUT = 408\n",
       "const HTTP_TOO_MANY = 429\n",
       "\n",
       "\n",
       " /* This function is useful if we want to rewrite the incoming URL to resolve just to our local one.\n",
       "    Doing this stops the Jupyter component from abusing this client to call out to endpoints other\n",
       "    than local Cytoscape. On the other hand, it makes it hard to detect when the Jupyter component\n",
       "    has specified a genuinely bad URL and really should get an error result. For now, we'll execute\n",
       "    the Jupyter-supplied URL and return the result, whatever it may be.\n",
       "\n",
       "const LocalCytoscape = 'http://127.0.0.1:1234'\n",
       "\n",
       "function parseURL(url) {\n",
       "    var reURLInformation = new RegExp([\n",
       "        '^(https?:)//', // protocol\n",
       "        '(([^:/?#]*)(?::([0-9]+))?)', // host (hostname and port)\n",
       "        '(/{0,1}[^?#]*)', // pathname\n",
       "        '(\\\\?[^#]*|)', // search\n",
       "        '(#.*|)$' // hash\n",
       "    ].join(''));\n",
       "    var match = url.match(reURLInformation);\n",
       "    return match && {\n",
       "        url: url,\n",
       "        protocol: match[1],\n",
       "        host: match[2],\n",
       "        hostname: match[3],\n",
       "        port: match[4],\n",
       "        pathname: match[5],\n",
       "        search: match[6],\n",
       "        hash: match[7]\n",
       "    }\n",
       "}\n",
       "*/\n",
       "\n",
       "function replyCytoscape(replyStatus, replyStatusText, replyText) {\n",
       "\n",
       "    // Clean up after Jupyter bridge accepts reply\n",
       "    httpR.onreadystatechange = function() {\n",
       "        if (httpR.readyState === 4) {\n",
       "            if (showDebug) {\n",
       "                console.log(' status from queue_reply: ' + httpR.status + ', reply: ' + httpR.responseText)\n",
       "            }\n",
       "        }\n",
       "    }\n",
       "\n",
       "    httpR.onerror = function() {\n",
       "        // Clean up after Jupyter bridge accepts backup reply\n",
       "        httpRE.onreadystatechange = function() {\n",
       "            if (httpRE.readyState === 4) {\n",
       "                if (showDebug) {\n",
       "                    console.log(' status from backup queue_reply: ' + httpRE.status + ', reply: ' + httpRE.responseText)\n",
       "                }\n",
       "            }\n",
       "        }\n",
       "\n",
       "        if (showDebug) {\n",
       "            console.log(' error from queue_reply -- could be Jupyter-Bridge server reject')\n",
       "        }\n",
       "        var errReply = {'status': HTTP_SYS_ERR, 'reason': 'Jupyter-Bridge rejected reply', 'text': 'Possibly reply is too long for Jupyter-Bridge server'}\n",
       "        httpRE.open('POST', jupyterBridgeURL, true)\n",
       "        httpRE.setRequestHeader('Content-Type', 'text/plain')\n",
       "        httpRE.send(JSON.stringify(errReply))\n",
       "    }\n",
       "\n",
       "    var reply = {'status': replyStatus, 'reason': replyStatusText, 'text': replyText}\n",
       "\n",
       "    // Send reply to Jupyter bridge\n",
       "    var jupyterBridgeURL = JupyterBridge + '/queue_reply?channel=' + Channel\n",
       "    if (showDebug) {\n",
       "        console.log('Starting queue to Jupyter bridge: ' + jupyterBridgeURL)\n",
       "    }\n",
       "    httpR.open('POST', jupyterBridgeURL, true)\n",
       "    httpR.setRequestHeader('Content-Type', 'text/plain')\n",
       "    httpR.send(JSON.stringify(reply))\n",
       "}\n",
       "\n",
       "function callCytoscape(callSpec) {\n",
       "\n",
       "    // Captures Cytoscape reply and sends it on\n",
       "    httpC.onreadystatechange = function() {\n",
       "        if (httpC.readyState === 4) {\n",
       "            if (showDebug) {\n",
       "                console.log(' status from CyREST: ' + httpC.status + ', statusText: ' + httpC.statusText + ', reply: ' + httpC.responseText)\n",
       "            }\n",
       "            // Note that httpC.status is 0 if the URL can't be reached *OR* there is a CORS violation.\n",
       "            // I wish I could tell the difference because for a CORS violation, I'd return a 404,\n",
       "            // which would roughly match what Python's native request package would return.\n",
       "            // The practical consequence is that the ultimate caller (e.g., py4cytoscape)\n",
       "            // returns different exceptions, depending on wither this module is doing the\n",
       "            // HTTP operation or the native Python requests package is. This is minor, but\n",
       "            // messes up tests that verify the exception type.\n",
       "            replyCytoscape(httpC.status, httpC.statusText, httpC.responseText)\n",
       "            waitOnJupyterBridge()\n",
       "        }\n",
       "    }\n",
       "\n",
       "//  Build up request to Cytoscape, making sure host is local.\n",
       "//    Too heavy handed: localURL = LocalCytoscape + parseURL(callSpec.url).pathname\n",
       "    var localURL = callSpec.url // Try using what was passed in ... is there a security risk??\n",
       "\n",
       "    if (showDebug) {\n",
       "        console.log('Command to CyREST: ' + callSpec.command + ' (' + localURL + ')')\n",
       "        if (callSpec.params) {\n",
       "            console.log(' params: ' + JSON.stringify(callSpec.params))\n",
       "        }\n",
       "        if (callSpec.headers) {\n",
       "            console.log(' header: ' + JSON.stringify(callSpec.headers))\n",
       "        }\n",
       "        if (callSpec.data) {\n",
       "            console.log('   data: ' + JSON.stringify(callSpec.data))\n",
       "        }\n",
       "    }\n",
       "\n",
       "    if (callSpec.command === 'webbrowser') {\n",
       "        if (window.open(callSpec.url)) {\n",
       "            replyCytoscape(HTTP_OK, 'OK', '')\n",
       "        } else {\n",
       "            replyCytoscape(HTTP_SYS_ERR, 'BAD BROWSER OPEN', '')\n",
       "        }\n",
       "        waitOnJupyterBridge()\n",
       "    } else if (callSpec.command === 'version') {\n",
       "        replyCytoscape(HTTP_OK, 'OK',\n",
       "            JSON.stringify({\"jupyterBridgeVersion\": VERSION}))\n",
       "        waitOnJupyterBridge()\n",
       "    } else {\n",
       "        var joiner = '?'\n",
       "        for (let param in callSpec.params) {\n",
       "            localURL = localURL + joiner + param + '=' + encodeURIComponent(callSpec.params[param])\n",
       "            joiner = '&'\n",
       "        }\n",
       "\n",
       "        httpC.open(callSpec.command, localURL, true)\n",
       "        for (let header in callSpec.headers) {\n",
       "            httpC.setRequestHeader(header, callSpec.headers[header])\n",
       "        }\n",
       "\n",
       "        // Send request to Cytoscape ... reply goes to onreadystatechange handler\n",
       "        httpC.send(JSON.stringify(callSpec.data))\n",
       "    }\n",
       "}\n",
       "\n",
       "function waitOnJupyterBridge() {\n",
       "\n",
       "    // Captures request from Jupyter bridge\n",
       "    httpJ.onreadystatechange = function() {\n",
       "        if (httpJ.readyState === 4) {\n",
       "            if (showDebug) {\n",
       "                console.log(' status from dequeue_request: ' + httpJ.status + ', reply: ' + httpJ.responseText)\n",
       "            }\n",
       "            try {\n",
       "                if (httpJ.status == HTTP_TOO_MANY) {\n",
       "                    // Nothing more to do ... the browser has created too many listeners,\n",
       "                    // and it's time to stop listening because the server saw a listener\n",
       "                    // listening on this channel before we got there.\n",
       "                    console.log('  shutting down because of redundant reader on channel: ' + Channel)\n",
       "                } else {\n",
       "                    if (httpJ.status === HTTP_TIMEOUT) {\n",
       "                        waitOnJupyterBridge()\n",
       "                    } else {\n",
       "                        callCytoscape(JSON.parse(httpJ.responseText))\n",
       "                    }\n",
       "                }\n",
       "            } catch(err) {\n",
       "                if (showDebug) {\n",
       "                    console.log(' exception calling Cytoscape: ' + err)\n",
       "                }\n",
       "                // Bad responseText means something bad happened that we don't understand.\n",
       "                // Go wait on another request, as there's nothing to call Cytoscape with.\n",
       "                waitOnJupyterBridge()\n",
       "            }\n",
       "        }\n",
       "    }\n",
       "\n",
       "    // Wait for request from Jupyter bridge\n",
       "    var jupyterBridgeURL = JupyterBridge + '/dequeue_request?channel=' + Channel\n",
       "    if (showDebug) {\n",
       "        console.log('Starting dequeue on Jupyter bridge: ' + jupyterBridgeURL)\n",
       "    }\n",
       "    httpJ.open('GET', jupyterBridgeURL, true)\n",
       "    httpJ.send()\n",
       "}\n",
       "\n",
       "// This kicks off a loop that ends by calling waitOnJupyterBridge again. This first call\n",
       "// ejects any dead readers before we start a read\n",
       "waitOnJupyterBridge() // Wait for message from Jupyter bridge, execute it, and return reply\n",
       "\n",
       "if (showDebug) {\n",
       "    alert(\"Jupyter-bridge browser component is started on \" + JupyterBridge + ', channel ' + Channel)\n",
       "}\n"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#_PY4CYTOSCAPE = 'git+https://github.com/cytoscape/py4cytoscape@1.7.0' # optional\n",
    "import requests\n",
    "exec(requests.get(\"https://raw.githubusercontent.com/cytoscape/jupyter-bridge/master/client/p4c_init.py\").text)\n",
    "IPython.display.Javascript(_PY4CYTOSCAPE_BROWSER_CLIENT_JS) # Start browser client"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "4ypehfMwxAh3"
   },
   "source": [
    "## Setup Cytoscape\n",
    "* Launch Cytoscape on your local machine. If you haven't already installed Cytoscape, then download the latest version from http://cytoscape.org.\n",
    "* Install the filetransfer app from https://apps.cytoscape.org/apps/filetransfer\n",
    "* Install the PathLinker app from http://apps.cytoscape.org/apps/pathlinker\n",
    "* Leave Cytoscape running in the background during the remainder of the tutorial.\n",
    "* Check cytoscape connection.\n",
    "\n",
    "You can also install app inside Python notebook by running \"py4cytoscape.install_app('Your App')\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "qeoKyxk8xAh4"
   },
   "source": [
    "## Import the required packages\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "id": "siatlRxgxAh4"
   },
   "outputs": [],
   "source": [
    "import sys\n",
    "import py4cytoscape as p4c\n",
    "import networkx as nx\n",
    "import pandas as pd\n",
    "import json\n",
    "import requests"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "id": "jllsUqoUxAh5",
    "outputId": "7b03937a-85cf-4ca7-9907-c983ade19f4f"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'apiVersion': 'v1',\n",
       " 'cytoscapeVersion': '3.9.0',\n",
       " 'automationAPIVersion': '1.2.0',\n",
       " 'py4cytoscapeVersion': '0.0.10'}"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p4c.cytoscape_version_info() # Check cytoscape connection."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{}"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Install PathLinker App, the return is an empty dictionry.\n",
    "p4c.install_app(\"PathLinker\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "TUsEGvTLxAh7"
   },
   "source": [
    "## Create network using networkx\n",
    "The PathLinker app paper uses the same interactome as the original PathLinker pap (available on the [PathLinker supplementary website](http://bioinformatics.cs.vt.edu/~murali/supplements/2016-sys-bio-applications-pathlinker/) here: [background-interactome-pathlinker-2015.txt](https://raw.githubusercontent.com/Murali-group/PathLinker-Cytoscape/master/src/test/resources/input/graph-dir_human-interactome.txt))."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "id": "lYX6mpXHxAh8",
    "outputId": "9491e7df-ae7e-4d0a-880e-a44098215947"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8914828"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "url = \"https://raw.githubusercontent.com/Murali-group/PathLinker-Cytoscape/master/src/test/resources/input/graph-dir_human-interactome.txt\"\n",
    "r = requests.get(url, allow_redirects=True)\n",
    "open('background-interactome-pathlinker-2015.txt', 'wb').write(r.content)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "id": "NNycmBe9xAh9"
   },
   "outputs": [],
   "source": [
    "# Import/Create the network that PathLinker will run on\n",
    "network_file = 'background-interactome-pathlinker-2015.txt'\n",
    "\n",
    "# create a new network by importing the data from a sample using pandas\n",
    "df = pd.read_csv(network_file, header=None, sep='\\t', lineterminator='\\n',\n",
    "                 names=[\"source\", 'target', 'weight', 'evidence'])\n",
    "\n",
    "# and create the networkx Graph from the pandas dataframe\n",
    "# this is a directed network, so I'm using the networkx DiGraph instead of the default undirected Graph\n",
    "G = nx.from_pandas_edgelist(df, \"source\", \"target\", edge_attr=['weight'], create_using=nx.MultiDiGraph())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "id": "NEN4XgHoxAh-",
    "outputId": "600890bb-2376-4682-d1e1-86d69e2f655a"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Applying default style...\n",
      "Applying preferred layout\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'networkSUID': 113541}"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p4c.create_network_from_networkx(G) # Take a while"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "B4JllssyxAh-"
   },
   "source": [
    "\n",
    "## Run PathLinker using the API function\n",
    "The function takes user sources, targets, and a set of parameters, and computes the k shortest paths. The function returns the paths in JSON format. Based on the user input, the function could generate a subnetwork (and view) containing those paths, and returns the computed paths and subnetwork/view SUIDs.\n",
    "\n",
    "Additional description of the parameters are available in the PathLinker app [documentation](https://pathlinker-cytoscape-app.readthedocs.io/en/latest/PathLinker_Cytoscape.html#sources-and-targets).\n",
    "\n",
    "The sources, targets and parameters used below are the same parameters used to run PathLinker in the paper \"The PathLinker app: Connect the dots in protein interaction networks\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "id": "-4ob8SQQxAh_"
   },
   "outputs": [],
   "source": [
    "# Construct input data to pass to PathLinker API function\n",
    "\n",
    "# construct PathLinker input data parameters for API request\n",
    "params = {}\n",
    "\n",
    "# the node names for the sources and targets are space separated \n",
    "# and must match the \"name\" column in the Node Table in Cytoscape\n",
    "params[\"sources\"] = \"P35968 P00533 Q02763\"\n",
    "params[\"targets\"] = \"Q15797 Q14872 Q16236 P14859 P36956\"\n",
    "\n",
    "# the number of shortest path to compute, must be greater than 0\n",
    "# Default: 50\n",
    "params[\"k\"] = 50\n",
    "\n",
    "# Edge weight type, must be one of the three: [UNWEIGHTED, ADDITIVE, PROBABILITIES]\n",
    "params[\"edgeWeightType\"] = \"PROBABILITIES\" \n",
    "\n",
    "# Edge penalty. Not needed for UNWEIGHTED \n",
    "# Must be 0 or greater for ADDITIVE, and 1 or greater for PROBABILITIES \n",
    "params[\"edgePenalty\"] = 1\n",
    "\n",
    "# The column name in the Edge Table in Cytoscape containing edge weight property, \n",
    "# column type must be numerical type \n",
    "params[\"edgeWeightColumnName\"] = \"weight\"\n",
    "\n",
    "# The option to ignore directionality of edges when computing paths\n",
    "# Default: False\n",
    "params[\"treatNetworkAsUndirected\"] = False\n",
    "\n",
    "# Allow source/target nodes to appear as intermediate nodes in computed paths\n",
    "# Default: False\n",
    "params[\"allowSourcesTargetsInPaths\"] = False\n",
    "\n",
    "# Include more than k paths if the path length/score is equal to kth path length/score\n",
    "# Default: False\n",
    "params[\"includeTiedPaths\"] = False\n",
    "\n",
    "# Option to disable the generation of the subnetwork/view, path rank column, and result panel\n",
    "# and only return the path result in JSON format\n",
    "# Default: False\n",
    "params[\"skipSubnetworkGeneration\"] = False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "id": "XSVplZaZxAh_"
   },
   "outputs": [],
   "source": [
    "cy_network_suid = p4c.get_network_suid()\n",
    "# perform REST API call\n",
    "headers = {'Content-Type': 'application/json', 'Accept': 'application/json'}\n",
    "\n",
    "# construct REST API request url\n",
    "url = \"http://localhost:1234/pathlinker/v1/\" + str(cy_network_suid) + \"/run\"\n",
    "# to just run on the network currently in view on cytoscape, use the following:\n",
    "#url = \"http://localhost:1234/pathlinker/v1/currentView/run\"\n",
    "\n",
    "# store request output\n",
    "result_json = requests.request(\"POST\", \n",
    "                          url,\n",
    "                          data = json.dumps(params),\n",
    "                          params = None,\n",
    "                          headers = headers)\n",
    "#print(json.loads(result_json.content))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "cFPSYRPtxAiA"
   },
   "source": [
    "## Output\n",
    "The following section stores the subnetwork/view references and prints out the path output returned by the run function.\n",
    "\n",
    "The output consist of path result in JSON format, and based on user input: subnetwork SUID, subnetwork view SUID, and path rank column name."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "id": "BTRepriSxAiA",
    "outputId": "ca361f70-82c8-48d8-a9a9-4827d2146bf4"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Output:\n",
      "\n",
      "subnetwork SUID:       1317147\n",
      "subnetwork view SUID:  1317385\n",
      "Path rank column name: path rank 1\n",
      "\n",
      "path rank:  1\n",
      "path score: 0.5625\n",
      "path:       P00533|P0CG47|Q16236\n",
      "path rank:  2\n",
      "path score: 0.5625\n",
      "path:       P00533|P10275|P14859\n",
      "path rank:  3\n",
      "path score: 0.5625\n",
      "path:       P00533|P10275|Q15797\n"
     ]
    }
   ],
   "source": [
    "# Store result, parse, and print\n",
    "results = json.loads(result_json.content)\n",
    "\n",
    "print(\"Output:\\n\")\n",
    "\n",
    "# access the suid, references, and path rank column name\n",
    "subnetwork_suid = results[\"subnetworkSUID\"]\n",
    "subnetwork_view_suid = results[\"subnetworkViewSUID\"]\n",
    "# The path rank column shows for each edge, the rank of the first path in which it appears\n",
    "path_rank_column_name = results[\"pathRankColumnName\"]\n",
    "    \n",
    "print(\"subnetwork SUID:       %s\" % (subnetwork_suid))\n",
    "print(\"subnetwork view SUID:  %s\" % (subnetwork_view_suid))\n",
    "print(\"Path rank column name: %s\" % (path_rank_column_name))\n",
    "print(\"\")\n",
    "\n",
    "# access the paths generated by PathLinker\n",
    "paths = results[\"paths\"]\n",
    "\n",
    "# print the first 10 paths out of 50 paths\n",
    "for path in paths[:3]:\n",
    "    print(\"path rank:  %d\" % (path['rank']))\n",
    "    print(\"path score: %s\" % (str(path['score'])))\n",
    "    print(\"path:       %s\" % (\"|\".join(path['nodeList'])))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "id": "T83fXwxSxAiB",
    "outputId": "3f6331ef-e02e-4edc-ca08-a08f61438eab"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Writing paths to pathlinker-50-paths.txt\n"
     ]
    }
   ],
   "source": [
    "# write the paths to a file\n",
    "paths_file = \"pathlinker-50-paths.txt\"\n",
    "print(\"Writing paths to %s\" % (paths_file))\n",
    "with open(paths_file, 'w') as out:\n",
    "    out.write(\"path rank\\tpath score\\tpath\\n\")\n",
    "    for path in paths:\n",
    "        out.write('%d\\t%s\\t%s\\n' % (path['rank'], str(path['score']), \"|\".join(path['nodeList'])))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "hZhszAutxAiB"
   },
   "source": [
    "## View the subnetwork and store the image\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "id": "XHI79kUhxAiB",
    "outputId": "dfbc7445-9ff6-40fc-88d5-1858fb889053"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'file': '/Users/yxin/CytoscapeConfiguration/filetransfer/default_sandbox/pathlinker-50-paths.png'}"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p4c.fit_content()\n",
    "p4c.export_image('pathlinker-50-paths', type='PNG')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "id": "ST3AZkIZxAiC",
    "outputId": "e0ee19cf-f002-4c1c-bcdc-ca7cd0d97e31"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p4c.sandbox_get_from(\"pathlinker-50-paths.png\")\n",
    "from IPython.display import Image\n",
    "Image('pathlinker-50-paths.png')"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "include_colab_link": true,
   "name": "automation-of-the-pathLinker-app-paper-lovastatin-analysis.ipynb",
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3",
   "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}