for-scripters/Python/advanced-view-api.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/advanced-view-api.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "O8dQ0kzFvQCQ"
   },
   "source": [
    "# py4cytoscape: View API Examples\n",
    "\n",
    "## Yihang Xin and Alex Pico\n",
    "\n",
    "## 2023-05-30\n",
    "\n",
    "\n",
    "## Introduction\n",
    "\n",
    "This is a sample Jupyter Notebook to demonstrate how users can manipulate Cytoscape network views directly from Python code.\n",
    "\n",
    "    \n",
    "#### Use Cases\n",
    "* __Create your own layout algorithms__\n",
    "* __Create annimations__\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ddakX0jGvQCS"
   },
   "source": [
    "## Installation\n",
    "The following chunk of code installs the `py4cytoscape` module."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "id": "JlU4WsSGvQCT"
   },
   "outputs": [],
   "source": [
    "%%capture\n",
    "!python3 -m pip install python-igraph requests pandas networkx\n",
    "!python3 -m pip install py4cytoscape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "TWar7aefvuE_"
   },
   "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": "iSD3KPvgvurG"
   },
   "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: pandas in /opt/anaconda3/lib/python3.8/site-packages (from py4cytoscape) (1.1.3)\n",
      "Requirement already satisfied: python-igraph in /opt/anaconda3/lib/python3.8/site-packages (from py4cytoscape) (0.8.3)\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: requests in /opt/anaconda3/lib/python3.8/site-packages (from py4cytoscape) (2.24.0)\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: numpy>=1.15.4 in /opt/anaconda3/lib/python3.8/site-packages (from pandas->py4cytoscape) (1.19.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: 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: certifi>=2017.4.17 in /opt/anaconda3/lib/python3.8/site-packages (from requests->py4cytoscape) (2020.6.20)\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: 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"
     ]
    },
    {
     "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 ... cce958d8-a19c-4801-a3c9-63b895e8d4c4 on https://jupyter-bridge.cytoscape.org\n"
     ]
    },
    {
     "data": {
      "application/javascript": [
       "var Channel = \"cce958d8-a19c-4801-a3c9-63b895e8d4c4\"; \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": "1yVGtnLrvQCU"
   },
   "source": [
    "## Basic Setup\n",
    "\n",
    "* Import required packages\n",
    "* Load a network(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Tptg6vI5vQCU"
   },
   "source": [
    "## Import the required packages\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "id": "ALNAKMHkvQCU"
   },
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import json\n",
    "import py4cytoscape as p4c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "id": "UXfGcaJwvQCV",
    "outputId": "2a899a71-91ed-49ad-ca38-64b56c60afb2"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Opening sampleData/sessions/Yeast Perturbation.cys...\n"
     ]
    }
   ],
   "source": [
    "# Reset current session for fresh start\n",
    "p4c.close_session(False)\n",
    "\n",
    "# Load a sample network\n",
    "network1 = p4c.open_session()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "id": "8TYWKrmrvQCW",
    "outputId": "7697dc5f-8c11-4682-c6c3-ef6c0f5ff569"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['COMPOUND_NODE_PADDING',\n",
       " 'COMPOUND_NODE_SHAPE',\n",
       " 'DING_RENDERING_ENGINE_ROOT',\n",
       " 'EDGE',\n",
       " 'EDGE_BEND',\n",
       " 'EDGE_CURVED',\n",
       " 'EDGE_LABEL',\n",
       " 'EDGE_LABEL_COLOR',\n",
       " 'EDGE_LABEL_FONT_FACE',\n",
       " 'EDGE_LABEL_FONT_SIZE',\n",
       " 'EDGE_LABEL_ROTATION',\n",
       " 'EDGE_LABEL_TRANSPARENCY',\n",
       " 'EDGE_LABEL_WIDTH',\n",
       " 'EDGE_LINE_TYPE',\n",
       " 'EDGE_PAINT',\n",
       " 'EDGE_SELECTED',\n",
       " 'EDGE_SELECTED_PAINT',\n",
       " 'EDGE_SOURCE_ARROW_SELECTED_PAINT',\n",
       " 'EDGE_SOURCE_ARROW_SHAPE',\n",
       " 'EDGE_SOURCE_ARROW_SIZE',\n",
       " 'EDGE_SOURCE_ARROW_UNSELECTED_PAINT',\n",
       " 'EDGE_STACKING',\n",
       " 'EDGE_STACKING_DENSITY',\n",
       " 'EDGE_STROKE_SELECTED_PAINT',\n",
       " 'EDGE_STROKE_UNSELECTED_PAINT',\n",
       " 'EDGE_TARGET_ARROW_SELECTED_PAINT',\n",
       " 'EDGE_TARGET_ARROW_SHAPE',\n",
       " 'EDGE_TARGET_ARROW_SIZE',\n",
       " 'EDGE_TARGET_ARROW_UNSELECTED_PAINT',\n",
       " 'EDGE_TOOLTIP',\n",
       " 'EDGE_TRANSPARENCY',\n",
       " 'EDGE_UNSELECTED_PAINT',\n",
       " 'EDGE_VISIBLE',\n",
       " 'EDGE_WIDTH',\n",
       " 'EDGE_Z_ORDER',\n",
       " 'NETWORK',\n",
       " 'NETWORK_ANNOTATION_SELECTION',\n",
       " 'NETWORK_BACKGROUND_PAINT',\n",
       " 'NETWORK_CENTER_X_LOCATION',\n",
       " 'NETWORK_CENTER_Y_LOCATION',\n",
       " 'NETWORK_CENTER_Z_LOCATION',\n",
       " 'NETWORK_DEPTH',\n",
       " 'NETWORK_EDGE_SELECTION',\n",
       " 'NETWORK_FORCE_HIGH_DETAIL',\n",
       " 'NETWORK_HEIGHT',\n",
       " 'NETWORK_NODE_LABEL_SELECTION',\n",
       " 'NETWORK_NODE_SELECTION',\n",
       " 'NETWORK_SCALE_FACTOR',\n",
       " 'NETWORK_SIZE',\n",
       " 'NETWORK_TITLE',\n",
       " 'NETWORK_WIDTH',\n",
       " 'NODE',\n",
       " 'NODE_BORDER_PAINT',\n",
       " 'NODE_BORDER_STROKE',\n",
       " 'NODE_BORDER_TRANSPARENCY',\n",
       " 'NODE_BORDER_WIDTH',\n",
       " 'NODE_CUSTOMGRAPHICS_1',\n",
       " 'NODE_CUSTOMGRAPHICS_2',\n",
       " 'NODE_CUSTOMGRAPHICS_3',\n",
       " 'NODE_CUSTOMGRAPHICS_4',\n",
       " 'NODE_CUSTOMGRAPHICS_5',\n",
       " 'NODE_CUSTOMGRAPHICS_6',\n",
       " 'NODE_CUSTOMGRAPHICS_7',\n",
       " 'NODE_CUSTOMGRAPHICS_8',\n",
       " 'NODE_CUSTOMGRAPHICS_9',\n",
       " 'NODE_CUSTOMGRAPHICS_POSITION_1',\n",
       " 'NODE_CUSTOMGRAPHICS_POSITION_2',\n",
       " 'NODE_CUSTOMGRAPHICS_POSITION_3',\n",
       " 'NODE_CUSTOMGRAPHICS_POSITION_4',\n",
       " 'NODE_CUSTOMGRAPHICS_POSITION_5',\n",
       " 'NODE_CUSTOMGRAPHICS_POSITION_6',\n",
       " 'NODE_CUSTOMGRAPHICS_POSITION_7',\n",
       " 'NODE_CUSTOMGRAPHICS_POSITION_8',\n",
       " 'NODE_CUSTOMGRAPHICS_POSITION_9',\n",
       " 'NODE_CUSTOMGRAPHICS_SIZE_1',\n",
       " 'NODE_CUSTOMGRAPHICS_SIZE_2',\n",
       " 'NODE_CUSTOMGRAPHICS_SIZE_3',\n",
       " 'NODE_CUSTOMGRAPHICS_SIZE_4',\n",
       " 'NODE_CUSTOMGRAPHICS_SIZE_5',\n",
       " 'NODE_CUSTOMGRAPHICS_SIZE_6',\n",
       " 'NODE_CUSTOMGRAPHICS_SIZE_7',\n",
       " 'NODE_CUSTOMGRAPHICS_SIZE_8',\n",
       " 'NODE_CUSTOMGRAPHICS_SIZE_9',\n",
       " 'NODE_CUSTOMPAINT_1',\n",
       " 'NODE_CUSTOMPAINT_2',\n",
       " 'NODE_CUSTOMPAINT_3',\n",
       " 'NODE_CUSTOMPAINT_4',\n",
       " 'NODE_CUSTOMPAINT_5',\n",
       " 'NODE_CUSTOMPAINT_6',\n",
       " 'NODE_CUSTOMPAINT_7',\n",
       " 'NODE_CUSTOMPAINT_8',\n",
       " 'NODE_CUSTOMPAINT_9',\n",
       " 'NODE_DEPTH',\n",
       " 'NODE_FILL_COLOR',\n",
       " 'NODE_HEIGHT',\n",
       " 'NODE_LABEL',\n",
       " 'NODE_LABEL_COLOR',\n",
       " 'NODE_LABEL_FONT_FACE',\n",
       " 'NODE_LABEL_FONT_SIZE',\n",
       " 'NODE_LABEL_POSITION',\n",
       " 'NODE_LABEL_ROTATION',\n",
       " 'NODE_LABEL_TRANSPARENCY',\n",
       " 'NODE_LABEL_WIDTH',\n",
       " 'NODE_NESTED_NETWORK_IMAGE_VISIBLE',\n",
       " 'NODE_PAINT',\n",
       " 'NODE_SELECTED',\n",
       " 'NODE_SELECTED_PAINT',\n",
       " 'NODE_SHAPE',\n",
       " 'NODE_SIZE',\n",
       " 'NODE_TOOLTIP',\n",
       " 'NODE_TRANSPARENCY',\n",
       " 'NODE_VISIBLE',\n",
       " 'NODE_WIDTH',\n",
       " 'NODE_X_LOCATION',\n",
       " 'NODE_Y_LOCATION',\n",
       " 'NODE_Z_LOCATION']"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# You can check all available Visual Properties with this function call:\n",
    "vps = p4c.get_visual_property_names()\n",
    "vps"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "7zzUzCKwvQCX"
   },
   "source": [
    "## Get Network View"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "id": "7GxvFak_vQCY",
    "outputId": "8fb591d4-7661-4c8c-b7e3-1fee7e68adfe"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1800841]\n"
     ]
    }
   ],
   "source": [
    "# Get views for a network: Cytoscape \"may\" have multiple views, and that's why it returns list instead of an object.\n",
    "view_id_list = p4c.get_network_views()\n",
    "\n",
    "# Display IDs of available views\n",
    "print(view_id_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "id": "TQNG-TgxvQCY"
   },
   "outputs": [],
   "source": [
    "# Choose visual_property from vps\n",
    "x_loc_dict = p4c.get_node_property(visual_property='NODE_X_LOCATION')\n",
    "y_loc_dict = p4c.get_node_property(visual_property='NODE_Y_LOCATION')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "3sOtHi9pvQCZ"
   },
   "source": [
    "### Convert to Pandas Data Frame\n",
    "Since it's a simple dictionary, you can easily convert it into Data Frame."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "id": "e4ih658RvQCZ",
    "outputId": "88dd232e-e791-47cc-8353-876e0ade0104"
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>NODE_X_LOCATION</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>YBR045C</th>\n",
       "      <td>1658.702983</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>YPR010C</th>\n",
       "      <td>3396.704051</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>YMR005W</th>\n",
       "      <td>1820.682109</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>YJL194W</th>\n",
       "      <td>2463.772197</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>YDL078C</th>\n",
       "      <td>1177.669830</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         NODE_X_LOCATION\n",
       "YBR045C      1658.702983\n",
       "YPR010C      3396.704051\n",
       "YMR005W      1820.682109\n",
       "YJL194W      2463.772197\n",
       "YDL078C      1177.669830"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x_loc_df = pd.DataFrame.from_dict(x_loc_dict, orient='index' )\n",
    "x_loc_df.columns = ['NODE_X_LOCATION']\n",
    "x_loc_df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "id": "wegL9v5bvQCa",
    "outputId": "24f3fca8-1b42-4466-de81-945648c58cba"
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>NODE_Y_LOCATION</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>YBR045C</th>\n",
       "      <td>844.886463</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>YPR010C</th>\n",
       "      <td>2113.540119</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>YMR005W</th>\n",
       "      <td>2267.999927</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>YJL194W</th>\n",
       "      <td>2621.401966</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>YDL078C</th>\n",
       "      <td>3331.536427</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         NODE_Y_LOCATION\n",
       "YBR045C       844.886463\n",
       "YPR010C      2113.540119\n",
       "YMR005W      2267.999927\n",
       "YJL194W      2621.401966\n",
       "YDL078C      3331.536427"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_loc_df = pd.DataFrame.from_dict(y_loc_dict, orient='index' )\n",
    "y_loc_df.columns = ['NODE_Y_LOCATION']\n",
    "y_loc_df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "id": "XJhAPzXLvQCa",
    "outputId": "28494d20-35c0-4a2c-e523-8b605ec15196"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "YHR171W\n"
     ]
    }
   ],
   "source": [
    "nodes_name = p4c.get_all_nodes()\n",
    "nv1 = nodes_name[0]\n",
    "print(nv1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "id": "Maw5WUlZvQCa",
    "outputId": "5ebcf81c-5534-43c5-e24b-a6fa077babed"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'YHR171W': '#F1F7FC'}\n"
     ]
    }
   ],
   "source": [
    "# Access single value\n",
    "nv1_color = p4c.get_node_property(visual_property='NODE_FILL_COLOR', node_names=nv1)\n",
    "print(nv1_color)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "F9-ZMoyDvQCa"
   },
   "source": [
    "## Directly set Visual Property values\n",
    "\n",
    "Setting values are also easy with py4cytoscape.  All you have to do is creating a dictionary for the target nodes and edges.\n",
    "\n",
    "###  Set random colors to nodes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "id": "u0IStQbzvQCb",
    "outputId": "ff6c7abe-a1f9-41bf-9f6e-cb30615ce0fa"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'message': 'Visual Style applied.'}"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Switch current visual stye to a simple one...\n",
    "p4c.create_visual_style('Minimal')\n",
    "p4c.set_visual_style('Minimal', network=network1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "id": "AYRdjUS1vQCb",
    "outputId": "2227f79d-041f-410a-cd71-059d23abccc7"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "''"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Change background color to black\n",
    "p4c.set_background_color_default('#000000', style_name='Minimal')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "id": "HdW2pUAWvQCb"
   },
   "outputs": [],
   "source": [
    "target_nodes = p4c.get_node_property(visual_property='NODE_LABEL')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "id": "wyKoEcqFvQCb"
   },
   "outputs": [],
   "source": [
    "# Generate random colors for each node\n",
    "import random\n",
    "\n",
    "def get_color():\n",
    "    r = random.randint(0, 255)\n",
    "    g = random.randint(0, 255)\n",
    "    b = random.randint(0, 255)\n",
    "    return '#' + hex(r)[2:] + hex(g)[2:] + hex(b)[2:]\n",
    "\n",
    "# Assign key-value pair.  For this example, node SUID to color.\n",
    "def generate_randome_color_dict(node_ids):\n",
    "    new_values = {}\n",
    "    for n in node_ids:\n",
    "        new_values[n] = get_color()\n",
    "    return new_values\n",
    "\n",
    "new_values = generate_randome_color_dict(target_nodes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "id": "ouNZ_20gvQCc",
    "outputId": "e86ea6a6-7b22-4f97-9212-982bdb56e5c9"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'message': 'Visual Style applied.'}"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Set new values for a set of nodes.  In this case, all nodes in the network\n",
    "NODE_FILL_COLOR = p4c.map_visual_property('node fill color', 'name', 'd', list(new_values.keys()), list(new_values.values()))\n",
    "p4c.update_style_mapping('Minimal', NODE_FILL_COLOR)\n",
    "p4c.set_visual_style('Minimal')"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "include_colab_link": true,
   "name": "advanced-view-api.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
}