"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"from py2cytoscape.data.cynetwork import CyNetwork\n",
"from py2cytoscape.data.cyrest_client import CyRestClient\n",
"from py2cytoscape.data.style import StyleUtil\n",
"import py2cytoscape.util.cytoscapejs as cyjs\n",
"import py2cytoscape.cytoscapejs as renderer\n",
"\n",
"import networkx as nx\n",
"import pandas as pd\n",
"import json"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/html": [
"\n",
"
\n",
" \n",
" \n",
" | \n",
" alias | \n",
" annotation.DB_Object_Name | \n",
" annotation.GO BIOLOGICAL_PROCESS | \n",
" annotation.GO CELLULAR_COMPONENT | \n",
" annotation.GO MOLECULAR_FUNCTION | \n",
" label | \n",
" kegg | \n",
" uniprot | \n",
" sgd | \n",
" entrez | \n",
"
\n",
" \n",
" \n",
" \n",
" | YAL003W | \n",
" translation elongation factor EF-1beta, EF-1 b... | \n",
" EF-1 beta, translation elongation factor EF-1beta | \n",
" translational elongation | \n",
" eukaryotic translation elongation factor 1 com... | \n",
" translation elongation factor activity | \n",
" EF1B | \n",
" sce:YAL003W | \n",
" EF1B_YEAST | \n",
" S000000003 | \n",
" 851260 | \n",
"
\n",
" \n",
" | YAL030W | \n",
" S000000028, SNC1 | \n",
" NaN | \n",
" Golgi to plasma membrane transport, endocytosi... | \n",
" Golgi trans face, SNARE complex, endosome, tra... | \n",
" v-SNARE activity | \n",
" SNC1 | \n",
" sce:YAL030W | \n",
" SNC1_YEAST | \n",
" S000000028 | \n",
" 851203 | \n",
"
\n",
" \n",
" | YAL038W | \n",
" CDC19, PYK1, S000000036, pyruvate kinase | \n",
" pyruvate kinase | \n",
" glycolysis, pyruvate metabolic process | \n",
" cytosol | \n",
" pyruvate kinase activity | \n",
" KPYK1 | \n",
" sce:YAL038W | \n",
" KPYK1_YEAST | \n",
" S000000036 | \n",
" 851193 | \n",
"
\n",
" \n",
" | YAL040C | \n",
" CLN3, DAF1, FUN10, G1 cyclin, S000000038, WHI1 | \n",
" G1 cyclin | \n",
" G1/S transition of mitotic cell cycle, regulat... | \n",
" nucleus | \n",
" cyclin-dependent protein kinase regulator acti... | \n",
" CG13 | \n",
" sce:YAL040C | \n",
" CG13_YEAST | \n",
" S000000038 | \n",
" 851191 | \n",
"
\n",
" \n",
" | YAR007C | \n",
" heterotrimeric RPA (RF-A) single-stranded DNA ... | \n",
" RF-A, heterotrimeric RPA (RF-A) single-strande... | \n",
" DNA recombination, DNA replication, synthesis ... | \n",
" DNA replication factor A complex, chromosome, ... | \n",
" damaged DNA binding, single-stranded DNA binding | \n",
" RFA1 | \n",
" sce:YAR007C | \n",
" RFA1_YEAST | \n",
" S000000065 | \n",
" 851266 | \n",
"
\n",
" \n",
"
\n",
"
\n",
"\n",
"\n",
""
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"color_gradient = StyleUtil.create_2_color_gradient(min=degrees.min(), max=degrees.max(), colors=('white', '#6AACB8'))\n",
"degree_to_size = StyleUtil.create_slope(min=degrees.min(), max=degrees.max(), values=(10, 100))\n",
"my_yeast_style.create_continuous_mapping(column='degree.layout', vp='NODE_FILL_COLOR', col_type='Integer', points=color_gradient)\n",
"my_yeast_style.create_continuous_mapping(column='degree.layout', vp='NODE_SIZE', col_type='Integer', points=degree_to_size)\n",
"my_yeast_style.create_continuous_mapping(column='degree.layout', vp='NODE_WIDTH', col_type='Integer', points=degree_to_size)\n",
"my_yeast_style.create_continuous_mapping(column='degree.layout', vp='NODE_HEIGHT', col_type='Integer', points=degree_to_size)\n",
"\n",
"my_yeast_style.create_continuous_mapping(column='degree.layout', vp='NODE_LABEL_FONT_SIZE', col_type='Integer', points=degree_to_size)\n",
"\n",
"cy.style.apply(my_yeast_style, yeast_net)\n",
"\n",
"# Step 7: (Optional) Embed as interactive Cytoscape.js widget\n",
"yeast_net_view = yeast_net.get_first_view()\n",
"style_for_widget = cy.style.get(my_yeast_style.get_name(), data_format='cytoscapejs')\n",
"renderer.render(yeast_net_view, style=style_for_widget['style'], background='radial-gradient(#FFFFFF 15%, #DDDDDD 105%)')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Long Description\n",
"From version 0.4.0, ___py2cytoscape___ has wrapper modules for [cyREST](http://apps.cytoscape.org/apps/cyrest) RESTful API. This means you can access Cytoscape features in more _Pythonic_ way instead of calling raw REST API via HTTP. \n",
"\n",
"\n",
"## Features\n",
"\n",
"### Pandas for basic data exchange\n",
"Since [pandas](http://pandas.pydata.org/) is a standard library for data mangling/analysis in Python, this new version uses its [DataFrame](http://pandas.pydata.org/pandas-docs/stable/generated/pandas.DataFrame.html#pandas.DataFrame) as its basic data object.\n",
"\n",
"### Embedded Cytoscaep.js Widget\n",
"You can use Cytoscape.js widget to embed your final result as a part of your notebook.\n",
"\n",
"### Simpler Code to access Cytoscape\n",
"cyREST provides language-agnostic RESTful API, but you need to use a lot of template code to access raw API. Here is an example. Both of the following do the same task, which is creating an empty network in Cytoscape. You will notice it is significantly simpler if you use _py2cytoscape_ wrapper API.\n",
"\n",
"#### Raw cyREST"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"# HTTP Client for Python\n",
"import requests\n",
"\n",
"# Standard JSON library\n",
"import json\n",
"\n",
"# Basic Setup\n",
"PORT_NUMBER = 1234\n",
"BASE = 'http://localhost:' + str(PORT_NUMBER) + '/v1/'\n",
"\n",
"# Header for posting data to the server as JSON\n",
"HEADERS = {'Content-Type': 'application/json'}\n",
"\n",
"# Define dictionary of empty network\n",
"empty_network = {\n",
" 'data': {\n",
" 'name': 'I\\'m empty!'\n",
" },\n",
" 'elements': {\n",
" 'nodes':[],\n",
" 'edges':[]\n",
" }\n",
"}\n",
"\n",
"res = requests.post(BASE + 'networks?collection=My%20Collection', data=json.dumps(empty_network), headers=HEADERS)\n",
"new_network_id = res.json()['networkSUID']\n",
"print('New network created with raw REST API. Its SUID is ' + str(new_network_id))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### With py2cytoscape"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"network = cy.network.create(name='My Network', collection='My network collection')\n",
"print('New network created with py2cytoscape. Its SUID is ' + str(network.get_id()))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Status\n",
"\n",
"As of 6/4/2015, this is still in alpha status and feature requests are always welcome. If youi have questions or feature requests, please send them to our Google Groups:\n",
"\n",
"* https://groups.google.com/forum/#!forum/cytoscape-discuss"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Quick Tour of py2cytoscape Features\n",
"\n",
"----\n",
"\n",
"## Create a client object to connect to Cytoscape"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"# Create an instance of cyREST client. Default IP is 'localhost', and port number is 1234.\n",
"# cy = CyRestClient() - This default constructor creates connection to http://localhost:1234/v1\n",
"cy = CyRestClient(ip='127.0.0.1', port=1234)\n",
"\n",
"# Cleanup: Delete all existing networks and tables in current Cytoscape session\n",
"cy.session.delete()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Creating empty networks"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"# Empty network\n",
"empty1 = cy.network.create()\n",
"\n",
"# With name\n",
"empty2 = cy.network.create(name='Created in Jupyter Notebook')\n",
"\n",
"# With name and collection name\n",
"empty3 = cy.network.create(name='Also created in Jupyter', collection='New network collection')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Load networks from files, URLs or web services"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"# Load a single local file\n",
"net_from_local2 = cy.network.create_from('../tests/data/galFiltered.json')\n",
"net_from_local1 = cy.network.create_from('sample_yeast_network.xgmml', collection='My Collection')\n",
"net_from_local2 = cy.network.create_from('../tests/data/galFiltered.gml', collection='My Collection')\n",
"\n",
"# Load from multiple locations\n",
"network_locations = [\n",
" 'sample_yeast_network.xgmml', # Local file\n",
" 'http://chianti.ucsd.edu/cytoscape-data/galFiltered.sif', # Static file on a web server\n",
" 'http://www.ebi.ac.uk/Tools/webservices/psicquic/intact/webservices/current/search/query/brca1?format=xml25' # or a web service\n",
"]\n",
"\n",
"# This requrns Series\n",
"networks = cy.network.create_from(network_locations)\n",
"pd.DataFrame(networks, columns=['CyNetwork'])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Create networks from various types of data\n",
"Currently, py2cytoscape accepts the following data as input:\n",
"\n",
"* Cytoscape.js\n",
"* NetworkX\n",
"* Pandas DataFrame\n",
"\n",
"\n",
"* igraph (TBD)\n",
"* Numpy adjacency matrix (binary or weighted) (TBD)\n",
"* GraphX (TBD)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"# Cytoscape.js JSON\n",
"n1 = cy.network.create(data=cyjs.get_empty_network(), name='Created from Cytoscape.js JSON')"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"# Pandas DataFrame\n",
"\n",
"# Example 1: From a simple text table\n",
"df_from_sif = pd.read_csv('../tests/data/galFiltered.sif', names=['source', 'interaction', 'target'], sep=' ')\n",
"df_from_sif.head()"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"# By default, it uses 'source' for source node column, 'target' for target node column, and 'interaction' for interaction\n",
"yeast1 = cy.network.create_from_dataframe(df_from_sif, name='Yeast network created from pandas DataFrame')\n",
"\n",
"# Example 2: from more complicated table\n",
"df_from_mitab = pd.read_csv('intact_pubid_22094256.txt', sep='\\t')\n",
"df_from_mitab.head()"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"source = df_from_mitab.columns[0]\n",
"target = df_from_mitab.columns[1]\n",
"interaction = 'Interaction identifier(s)'\n",
"title='A Systematic Screen for CDK4/6 Substrates Links FOXM1 Phosphorylation to Senescence Suppression in Cancer Cells.'\n",
"\n",
"human1 = cy.network.create_from_dataframe(df_from_mitab, source_col=source, target_col=target, interaction_col=interaction, name=title)\n",
"\n",
"\n",
"# Import edge attributes and node attributes at the same time (TBD)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"# NetworkX\n",
"nx_graph = nx.scale_free_graph(100)\n",
"nx.set_node_attributes(nx_graph, 'Degree', nx.degree(nx_graph))\n",
"nx.set_node_attributes(nx_graph, 'Betweenness_Centrality', nx.betweenness_centrality(nx_graph))\n",
"scale_free100 = cy.network.create_from_networkx(nx_graph, collection='Generated by NetworkX')\n",
"\n",
"# TODO: igraph\n",
"# TODO: Numpy adj. martix\n",
"# TODO: GraphX"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Get Network from Cytoscape\n",
"\n",
"You can get network data in the following forms:\n",
"\n",
"* Cytoscape.js\n",
"* NetworkX\n",
"* DataFrame"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"# As Cytoscape.js (dict)\n",
"yeast1_json = yeast1.to_json()\n",
"\n",
"# print(json.dumps(yeast1_json, indent=4))"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"# As NetworkX graph object\n",
"sf100 = scale_free100.to_networkx()\n",
"\n",
"num_nodes = sf100.number_of_nodes()\n",
"num_edges = sf100.number_of_edges()\n",
"\n",
"print('Number of Nodes: ' + str(num_nodes))\n",
"print('Number of Edges: ' + str(num_edges))"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"# As a simple, SIF-like DataFrame\n",
"yeast1_df = yeast1.to_dataframe()\n",
"yeast1_df.head()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Working with CyNetwork API\n",
"___CyNetwork___ class is a simple wrapper for network-related cyREST raw REST API. __It does not hold the actual network data. It's a reference to a network in current Cytoscape session__. With CyNetwork API, you can access Cytoscape data objects in more Pythonista-friendly way."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"network_suid = yeast1.get_id()\n",
"print('This object references to Cytoscape network with SUID ' + str(network_suid) + '\\n')\n",
"print('And its name is: ' + str(yeast1.get_network_value(column='name')) + '\\n')\n",
"\n",
"nodes = yeast1.get_nodes()\n",
"edges = yeast1.get_edges()\n",
"\n",
"print('* This network has ' + str(len(nodes)) + ' nodes and ' + str(len(edges)) + ' edges\\n') \n",
"\n",
"# Get a row in the node table as pandas Series object\n",
"node0 = nodes[0]\n",
"row = yeast1.get_node_value(id=node0)\n",
"print(row)\n",
"\n",
"# Or, pick one cell in the table\n",
"cell = yeast1.get_node_value(id=node0, column='name')\n",
"print('\\nThis node has name: ' + str(cell))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Get references from existing networks\n",
"And of course, you can grab references to existing Cytoscape networks:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"# Create a new CyNetwork object from existing network\n",
"network_ref1 = cy.network.create(suid=yeast1.get_id())\n",
"\n",
"# And they are considered as same objects.\n",
"print(network_ref1 == yeast1)\n",
"print(network_ref1.get_network_value(column='name'))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Tables as DataFrame\n",
"Cytoscape has two main data types: ___Network___ and ___Table___. Network is the graph topology, and Tables are properties for those graphs. For simplicity, this library has access to three basic table objects:\n",
"\n",
"* Node Table\n",
"* Edge Table\n",
"* Network Table\n",
"\n",
"For 99% of your use cases, you can use these three to store properties. Since [pandas](http://pandas.pydata.org/) is extremely useful to handle table data, default data type for tables is __DataFrame__. However, you can also use other data types including:\n",
"\n",
"* Cytoscape.js style JSON\n",
"* CSV\n",
"* TSV\n",
"* CX (TBD)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"# Get table from Cytoscape\n",
"node_table = scale_free100.get_node_table()\n",
"edge_table = scale_free100.get_edge_table()\n",
"network_table = scale_free100.get_network_table()\n",
"node_table.head()"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"network_table.transpose().head()"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"names = scale_free100.get_node_column('Degree')\n",
"print(names.head())\n",
"\n",
"# Node Column information. \"name\" is the unique Index\n",
"scale_free100.get_node_columns()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Edit Network Topology\n",
"\n",
"### Adding and deleteing nodes/edges"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"# Add new nodes: Simply send the list of node names. NAMES SHOULD BE UNIQUE!\n",
"new_node_names = ['a', 'b', 'c']\n",
"# Return value contains dictionary from name to SUID.\n",
"new_nodes = scale_free100.add_nodes(new_node_names)\n",
"\n",
"# Add new edges\n",
"# Send a list of tuples: (source node SUID, target node SUID, interaction type\n",
"new_edges = []\n",
"new_edges.append((new_nodes['a'], new_nodes['b'], 'type1'))\n",
"new_edges.append((new_nodes['a'], new_nodes['c'], 'type2'))\n",
"new_edges.append((new_nodes['b'], new_nodes['c'], 'type3'))\n",
"\n",
"new_edge_ids = scale_free100.add_edges(new_edges)\n",
"new_edge_ids"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"# Delete node\n",
"scale_free100.delete_node(new_nodes['a'])\n",
"\n",
"# Delete edge\n",
"scale_free100.delete_edge(new_edge_ids.index[0])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Update Table\n",
"Let's do something a bit more realistic. You can update any Tables by using DataFrame objects.\n",
"\n",
"### 1. ID conversion with external service\n",
"Let's use [ID Conversion web service by Uniprot](http://www.uniprot.org/help/programmatic_access) to add more information to existing yeast network in current session."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"# Small utility function to convert ID sets\n",
"import requests\n",
"\n",
"def uniprot_id_mapping_service(query=None, from_id=None, to_id=None):\n",
" # Uniprot ID Mapping service\n",
" url = 'http://www.uniprot.org/mapping/'\n",
" payload = {\n",
" 'from': from_id,\n",
" 'to': to_id,\n",
" 'format':'tab',\n",
" 'query': query\n",
" }\n",
" \n",
" res = requests.get(url, params=payload)\n",
" \n",
" df = pd.read_csv(res.url, sep='\\t')\n",
" res.close()\n",
" return df"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"# Get node table from Cytoscape\n",
"yeast_node_table = yeast1.get_node_table()\n",
"\n",
"# From KEGG ID to UniprotKB ID\n",
"query1 = ' '.join(yeast_node_table['name'].map(lambda gene_id: 'sce:' + gene_id).values)\n",
"id_map_kegg2uniprot = uniprot_id_mapping_service(query1, from_id='KEGG_ID', to_id='ID')\n",
"id_map_kegg2uniprot.columns = ['kegg', 'uniprot']\n",
"\n",
"# From UniprotKB to SGD\n",
"query2 = ' '.join(id_map_kegg2uniprot['uniprot'].values)\n",
"id_map_uniprot2sgd = uniprot_id_mapping_service(query2, from_id='ID', to_id='SGD_ID')\n",
"id_map_uniprot2sgd.columns = ['uniprot', 'sgd']\n",
"\n",
"# From UniprotKB to Entrez Gene ID\n",
"query3 = ' '.join(id_map_kegg2uniprot['uniprot'].values)\n",
"id_map_uniprot2ncbi = uniprot_id_mapping_service(query3, from_id='ID', to_id='P_ENTREZGENEID')\n",
"id_map_uniprot2ncbi.columns = ['uniprot', 'entrez']\n",
"\n",
"# Merge them\n",
"merged = pd.merge(id_map_kegg2uniprot, id_map_uniprot2sgd, on='uniprot')\n",
"merged = pd.merge(merged, id_map_uniprot2ncbi, on='uniprot')\n",
"\n",
"# Add key column by removing prefix\n",
"merged['name'] = merged['kegg'].map(lambda kegg_id : kegg_id[4:])\n",
"merged.head()"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"update_url = BASE + 'networks/' + str(yeast1.get_id()) + '/tables/defaultnode'\n",
"print(update_url)\n",
"\n",
"ut = {\n",
" 'key': 'name',\n",
" 'dataKey': 'name',\n",
" 'data': [\n",
" {\n",
" 'name': 'YBR112C',\n",
" 'foo': 'aaaaaaaa'\n",
" }\n",
" ]\n",
"}\n",
"\n",
"requests.put(update_url, json=ut, headers=HEADERS)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"# Now update existing node table with the data frame above.\n",
"yeast1.update_node_table(merged, network_key_col='name', data_key_col='name')\n",
"\n",
"# Check the table is actually updated\n",
"yeast1.get_node_table().head()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Create / Delete Table Data\n",
"Currently, ___you cannot delete the table or rows___ due to the Cytoscape data model design. However, it is easy to create / delete columns:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"# Delete columns\n",
"yeast1.delete_node_table_column('kegg')\n",
"\n",
"# Create columns\n",
"yeast1.create_node_column(name='New Empty Double Column', data_type='Double', is_immutable=False, is_list=False)\n",
"\n",
"# Default is String, mutable column.\n",
"yeast1.create_node_column(name='Empty String Col')\n",
"\n",
"yeast1.get_node_table().head()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Visual Styles\n",
"You can also use wrapper API to access Visual Styles.\n",
"\n",
"Current limitations are:\n",
"\n",
"* You need to use unique name for the Styles\n",
"* Need to know how to write serialized form of objects"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"# Get all existing Visual Styles\n",
"import json\n",
"styles = cy.style.get_all()\n",
"print(json.dumps(styles, indent=4))\n",
"\n",
"# Create a new style\n",
"style1 = cy.style.create('sample_style1')\n",
"\n",
"# Get a reference to the existing style\n",
"default_style = cy.style.create('default')\n",
"\n",
"print(style1.get_name())\n",
"print(default_style.get_name())\n",
"\n",
"# Get all available Visual Properties\n",
"print(len(cy.style.vps.get_all()))\n",
"\n",
"# Get Visual Properties for each data type\n",
"node_vps = cy.style.vps.get_node_visual_props()\n",
"edge_vps = cy.style.vps.get_edge_visual_props()\n",
"network_vps = cy.style.vps.get_network_visual_props()\n",
"\n",
"print(pd.Series(edge_vps).head())"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Set default values\n",
"To set default values for Visual Properties, simply pass key-value pairs as dictionary."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"# Prepare key-value pair for Style defaults\n",
"\n",
"new_defaults = {\n",
" # Node defaults\n",
" 'NODE_FILL_COLOR': '#eeeeff',\n",
" 'NODE_SIZE': 20,\n",
" 'NODE_BORDER_WIDTH': 0,\n",
" 'NODE_TRANSPARENCY': 120,\n",
" 'NODE_LABEL_COLOR': 'white',\n",
" \n",
" # Edge defaults\n",
" 'EDGE_WIDTH': 3,\n",
" 'EDGE_STROKE_UNSELECTED_PAINT': '#aaaaaa',\n",
" 'EDGE_LINE_TYPE': 'LONG_DASH',\n",
" 'EDGE_TRANSPARENCY': 120,\n",
" \n",
" # Network defaults\n",
" 'NETWORK_BACKGROUND_PAINT': 'black'\n",
"}\n",
"\n",
"# Update\n",
"style1.update_defaults(new_defaults)\n",
"\n",
"# Apply the new style\n",
"cy.style.apply(style1, yeast1)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Visual Mappings"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"# Passthrough mapping\n",
"style1.create_passthrough_mapping(column='name', col_type='String', vp='NODE_LABEL')\n",
"\n",
"# Discrete mapping: Simply prepare key-value pairs and send it\n",
"kv_pair = {\n",
" 'pp': 'pink',\n",
" 'pd': 'green'\n",
"}\n",
"style1.create_discrete_mapping(column='interaction', \n",
" col_type='String', vp='EDGE_STROKE_UNSELECTED_PAINT', mappings=kv_pair)\n",
"\n",
"# Continuous mapping\n",
"points = [\n",
" {\n",
" 'value': '1.0',\n",
" 'lesser':'white',\n",
" 'equal':'white',\n",
" 'greater': 'white'\n",
" },\n",
" {\n",
" 'value': '20.0',\n",
" 'lesser':'green',\n",
" 'equal':'green',\n",
" 'greater': 'green'\n",
" }\n",
"]\n",
"\n",
"minimal_style = cy.style.create('Minimal')\n",
"minimal_style.create_continuous_mapping(column='Degree', col_type='Double', vp='NODE_FILL_COLOR', points=points)\n",
"\n",
"# Or, use utility for simple mapping\n",
"simple_slope = StyleUtil.create_slope(min=1, max=20, values=(10, 60))\n",
"minimal_style.create_continuous_mapping(column='Degree', col_type='Double', vp='NODE_SIZE', points=simple_slope)\n",
"\n",
"# Apply the new style\n",
"cy.style.apply(minimal_style, scale_free100)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Layouts\n",
"Currently, this supports automatic layouts with default parameters."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"# Get list of available layout algorithms\n",
"layouts = cy.layout.get_all()\n",
"print(json.dumps(layouts, indent=4))"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"# Apply layout\n",
"cy.layout.apply(name='circular', network=yeast1)\n",
"\n",
"yeast1.get_views()\n",
"yeast_view1 = yeast1.get_first_view()\n",
"node_views = yeast_view1['elements']['nodes']\n",
"df3 = pd.DataFrame(node_views)\n",
"df3.head()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Embed Interactive Widget"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"from py2cytoscape.cytoscapejs import viewer as cyjs\n",
"cy.layout.apply(network=scale_free100)\n",
"view1 = scale_free100.get_first_view()\n",
"view2 = yeast1.get_first_view()\n",
"# print(view1)\n",
"cyjs.render(view2, 'default2', background='#efefef')"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"# Use Cytoscape.js style JSON\n",
"cyjs_style = cy.style.get(minimal_style.get_name(), data_format='cytoscapejs')\n",
"cyjs.render(view1, style=cyjs_style['style'], background='white')"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": []
}
],
"metadata": {
"anaconda-cloud": {},
"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.5.1"
}
},
"nbformat": 4,
"nbformat_minor": 0
}