def draw_MatrixPlot(identifier, species=None, limit=100): result = creat_model_input(identifier, species, limit) G = nx.from_pandas_dataframe(result, 'interactor_A', 'interactor_B', [ 'score', 'nscore', 'fscore', 'pscore', 'hscore', 'ascore', 'escore', 'dscore', 'tscore' ]) am = nv.MatrixPlot(G) am.cmap = plt.cm.get_cmap('Greens') am.draw() plt.savefig(identifier + "_MatrixPlot.png", dpi=500) # save as png plt.show()
nodes_in_selfloops.append(u) return nodes_in_selfloops # Check whether number of self loops equals the number of nodes in self loops assert T.number_of_selfloops() == len(find_selfloop_nodes(T)) #%% # ##### NEtworkX Matrix Visualisation #### # # Import nxviz # Create the MatrixPlot object: m m = nv.MatrixPlot(T) # Draw m to the screen m.draw() # Display the plot plt.show() # Convert T to a matrix format: A A = nx.to_numpy_matrix(T) # Convert A back to the NetworkX form as a directed graph: T_conv T_conv = nx.from_numpy_matrix(A, create_using=nx.DiGraph()) # Check that the `category` metadata field is lost from each node for n, d in T_conv.nodes(data=True):
for n, d in G.nodes(data=True): # Calculate the degree of each node: G.node[n]['degree'] G.node[n]['degree'] = nx.degree(G)[n] import nxviz as nv import matplotlib.pyplot as plt # Create the ArcPlot object: a a = nv.ArcPlot(G, node_order='degree', node_labels=True) a.draw() ap = nv.ArcPlot(G, node_order='date', node_color='date', node_labels=True, node_size='date') ap.draw() h = nv.MatrixPlot(G)#, node_grouping='grouping') h.draw() c = nv.CircosPlot(G, node_order='degree', node_grouping = 'date', node_color='date') c.draw() ###IDENTIFYING IMPORTANT NODES list(G.neighbors(1)) nx.degree_centrality(G) nx.betweenness_centrality(G) # Define path_exists() def path_exists(G, node1, node2): """ This function checks whether a path exists between two nodes (node1, node2) in graph G.
if u == v: # Append node u to nodes_in_selfloops nodes_in_selfloops.append(u) return nodes_in_selfloops # Check whether number of self loops equals the number of nodes in self loops assert T.number_of_selfloops() == len(find_selfloop_nodes(T)) # Import nxviz import nxviz # Create the MatrixPlot object: m m = nxviz.MatrixPlot(T) # Draw m to the screen m.draw() # Display the plot plt.show() # Convert T to a matrix format: A A = nx.to_numpy_matrix(T) # Convert A back to the NetworkX form as a directed graph: T_conv T_conv = nx.from_numpy_matrix(A, create_using=nx.DiGraph()) # Check that the `category` metadata field is lost from each node for n, d in T_conv.nodes(data=True):
edges_cmap = dict() edges_cmap['group1'] = 'darkgreen' h = HivePlot(nodes, edges, nodes_cmap, edges_cmap) h.draw() plt.savefig('./figures/hiveplot_credit_transaction.png', dpi=300, bbox_inches='tight') import nxviz as nv # this library is use for cercoplot and arcplot ## MatrixPlot A = nx.to_numpy_matrix(G) # Convert G to a matrix format: A G_conv = nx.from_numpy_matrix( A, create_using=nx.DiGraph()) # Convert A back to the NetworkX form # as a directed graph: T_conv Mat = nv.MatrixPlot(G_conv) # node_order='c', node_color='C',edge_color=None) # This creates a Matplot object Mat. Mat.draw() #plt.show() plt.savefig('./figures/Matrixplot_credit_transaction.png') x = nx.adj_matrix(G_conv) print(x.todense()) ## Cercoplot from nxviz import CircosPlot Mat = CircosPlot(G, node_labels=True, node_order='Y', font_size=32, node_color='C',
def main(arguments,output_filename): ''' Parse user input, query SQL database, generate pandas dataframes, export JSON for D3 and print HTML code ''' ###################################################### ### start the alert div that contains any output generated here ###################################################### algorithm_output_str = '' timing = {} start_all = timeit.default_timer() ###################################################### # generate an input overview table ###################################################### arg_names = ['Genes','Cluster by','Color by','Interaction type',\ 'Minimal number of experiments','Minimal number of publications', 'Minimal number of methods','Method types',\ 'Process','Compartment','Expression','Max. number nodes','Filter condition'] input_dict = { arg_names[i]:arguments[i].replace("_"," ") for i in range(len(arg_names)) } # does not include unique_str and excel_flag input_dict['Expression'] = input_dict['Expression'].replace('G1P','G1(P)') # brackets removed in PHP df_user_input = pd.DataFrame.from_dict(input_dict,orient='index') df_user_input = df_user_input.reindex(index = arg_names) df_user_input.columns = ['user input'] df_user_input_to_print = df_user_input.to_html(classes=['table','table-condensed','table-bordered']) ### process arguments primary_nodes,cluster_by,color_by,int_type,\ min_exp,min_pub,min_methods,method_types,\ process,compartment,expression,\ max_nodes,filter_condition,\ excel_flag,filter_flag,unique_str = arguments # make sure types are correct color_by = color_by.replace('_',' ') cluster_by = cluster_by.replace('_',' ') filter_condition = filter_condition.replace('_',' ') process = process.split(',') method_types = method_types.split(',') method_types = [x.replace('_',' ') for x in method_types] expression = expression.split(',') if 'G1P' in expression: # brackets removed in php ind = expression.index('G1P') expression[ind] = 'G1(P)' process = [x.replace("_"," ") for x in process] primary_nodes_str = primary_nodes if '_' in primary_nodes: primary_nodes = primary_nodes.split('_') else: primary_nodes = [primary_nodes] min_exp = int(min_exp) min_pub = int(min_pub) min_methods = int(min_methods) max_nodes = int(max_nodes) excel_flag = bool(int(excel_flag)) filter_flag = bool(int(filter_flag)) split_types = int_type.split(',') compartment = compartment.replace('_',' ') timing['input'] = timeit.default_timer() - start_all if excel_flag: ###################################################### # WRITE TO EXCEL ###################################################### # THIS HAS TO HAPPEN BEFORE HTML REPLACEMENTS start_excel = timeit.default_timer() write_excel_file(primary_nodes_str+'_'+unique_str) timing['excel'] = timeit.default_timer() - start_excel print(timing) return ###################################################### ### get all interactions related to the input IDs ###################################################### start_initial = timeit.default_timer() database = SCRIPT_DIR+"/data/DB_genes_and_interactions.db" conn = create_connection(database) # get all interactions in which the given genes takes part placeholders = ', '.join('?' for unused in primary_nodes) # '?, ?, ?, ...' # The query differs based on whether we need to subselect on the 'type' of interaction if len(split_types) == 3: query = "SELECT source,target FROM interactions WHERE ( (source IN (%s) or target IN (%s)) and num_experiments >= (%s) \ and num_publications >= (%s) and num_methods >= (%s))" % (placeholders,placeholders,min_exp,min_pub,min_methods) cursor = conn.execute(query,primary_nodes+primary_nodes) else: placeholders_type = ', '.join('?' for unused in split_types) query = "SELECT source,target FROM interactions WHERE ( (source IN (%s) or target IN (%s)) AND type IN (%s) \ AND num_experiments >= (%s) and num_publications >= (%s) and num_methods >= (%s))" % (placeholders,placeholders, \ placeholders_type,min_exp,min_pub,min_methods) cursor = conn.execute(query,primary_nodes+primary_nodes+split_types) # construct dataframe of interacting genes: the nodes node_list = list(set([x for y in cursor for x in y])) # get rid of duplicates of which there will be many if len(node_list) == 0: raise ValueError('No interactions matching these conditions.') # get the info from the database for each node to make the 'nodes' dataframe if 'No_data' in expression: query = """SELECT standard_name,systematic_name,name_desc,desc,go_term_1,go_term_2,\ GFP_abundance,GFP_localization,CYCLoPs_Excel_string,CYCLoPs_html,expression_peak_phase,\ expression_peak_time,CYCLoPs_dict FROM genes \ WHERE standard_name in (%s) AND (standard_name in (%s) OR expression_peak_phase in (%s) OR expression_peak_phase is NULL) AND (standard_name in (%s) OR go_term_1 in (%s) OR go_term_2 in (%s))""" \ % (', '.join('?' for _ in node_list), ', '.join('?' for _ in primary_nodes), ', '.join('?' for _ in expression), ', '.join('?' for _ in primary_nodes),', '.join('?' for _ in process),', '.join('?' for _ in process)) else: query = """SELECT standard_name,systematic_name,name_desc,desc,go_term_1,go_term_2,\ GFP_abundance,GFP_localization,CYCLoPs_Excel_string,CYCLoPs_html,expression_peak_phase,\ expression_peak_time,CYCLoPs_dict FROM genes \ WHERE standard_name in (%s) AND (standard_name in (%s) OR expression_peak_phase in (%s)) AND (standard_name in (%s) OR go_term_1 in (%s) OR go_term_2 in (%s))""" \ % (', '.join('?' for _ in node_list), ', '.join('?' for _ in primary_nodes), ', '.join('?' for _ in expression), ', '.join('?' for _ in primary_nodes), ', '.join('?' for _ in process),', '.join('?' for _ in process)) cursor = conn.execute(query,node_list+primary_nodes+expression+primary_nodes+process+process) data = [list(l) for l in cursor] # cursor itself is a generator, this is a list of lists nodes = pd.DataFrame(data,columns=['Standard name','Systematic name','Name description','Description', 'GO term 1','GO term 2','GFP abundance','GFP localization','CYCLoPs_Excel_string', 'CYCLoPs_html','Expression peak phase','Expression peak time','CYCLoPs_dict']) timing['Get node information from database'] = timeit.default_timer() - start_initial ### make actual dictionaries out of CYCLoPs_dict column nodes['CYCLoPs_dict'] = nodes['CYCLoPs_dict'].apply(ast.literal_eval) len_nodes_query = len(nodes) ###################################################### ### BASED ON THE COMPARTMENT FILTER: DROP NODES ###################################################### start_node_drop = timeit.default_timer() if 'GFP:' in compartment: comp_to_check = compartment.replace('GFP:','') print('Prior to compartment filtering:', len(nodes), 'nodes. Filtering on', comp_to_check) s = pd.Series([comp_to_check in x for x in nodes['GFP localization'].str.split(', ')]) nodes = nodes[s.values] nodes = nodes.reset_index(drop=True) print('After compartment filtering:', len(nodes), 'nodes.') elif 'CYCLoPs:' in compartment: comp_to_check = compartment.replace('CYCLoPs:','') print('Prior to compartment filtering:', len(nodes), 'nodes. Filtering on', comp_to_check) l_o_l = [[list(nodes.iloc[i]['CYCLoPs_dict'][x].keys()) for x in list(nodes.iloc[i]['CYCLoPs_dict'].keys()) ] for i in range(len(nodes)) ] s = pd.Series([comp_to_check in [v for WT in l_o_l[i] for v in WT] for i in range(len(l_o_l))]) nodes = nodes[s.values] nodes = nodes.reset_index(drop=True) print('After compartment filtering:', len(nodes), 'nodes.') else: #it is 'Any' pass ### Combine the expression columns nodes['Expression peak'] = nodes['Expression peak phase'] + " (" + nodes['Expression peak time'].map(str) + " min)" nodes['Expression peak'] = nodes['Expression peak'].mask(nodes['Expression peak'].isnull(), "No data") # alphabetize nodes = nodes.sort_values(by='Standard name',ascending=True) nodes = nodes.reset_index(drop=True) node_list = list(nodes['Standard name'].values) nodes['primary node'] = [x in primary_nodes for x in nodes['Standard name']] if len(nodes) == 0: raise ValueError("Filtering left no nodes.") timing['Node filter: compartment'] = timeit.default_timer() - start_node_drop ###################################################### # Clustering and coloring ###################################################### start = timeit.default_timer() ### Clustering part if cluster_by in ['GO term 1','GO term 2']: nodes['cluster'] = nodes[cluster_by] elif 'CYCLoPs WT' in cluster_by: WT_string = 'WT' + cluster_by[-1] # loop over all nodes find their highest expression compartment for the WT given by WT_string # NOTE: SOMETIMES A DICTIONARY WITH EXPRESSION DATA FOR A GIVEN WT IS EMPTY WE NEED TO CHECK FOR THIS # Example: GET1 in WT1 l = nodes['CYCLoPs_dict'].values l_max_comps = [ max(l[i][WT_string], key=lambda key: l[i][WT_string][key]) if (type(l[i]) != str and len(l[i][WT_string]) > 0) else 'No data' for i in range(len(nodes))] nodes['cluster'] = pd.Series(l_max_comps).values elif cluster_by == 'No clustering': nodes['cluster'] = ['No clustering' for i in range(len(nodes))] else: raise SystemExit(cluster_by,f"Unexpected value for clustering variable: {cluster_by}.") if color_by in ['GO term 1','GO term 2']: # set the color based on the color_by variable in a new column of 'nodes' DF nodes['color'] = nodes[color_by] elif 'CYCLoPs WT' in color_by: WT_string = 'WT' + color_by[-1] # loop over all nodes find their highest expression compartment for the WT given by WT_string # NOTE: SOMETIMES A DICTIONARY WITH EXPRESSION DATA FOR A GIVEN WT IS EMPTY WE NEED TO CHECK FOR THIS # Example: GET1 in WT1 l = nodes['CYCLoPs_dict'].values l_max_comps = [ max(l[i][WT_string], key=lambda key: l[i][WT_string][key]) if \ (type(l[i]) != str and len(l[i][WT_string]) > 0) else 'No data' for i in range(len(nodes))] # set the color based on the maximum compartment found above in a new column in the nodes DF nodes['color'] = pd.Series(l_max_comps).values elif color_by == "Peak expression phase": nodes['color'] = nodes['Expression peak phase'] elif color_by == 'No coloring': nodes['color'] = ["No data" for i in range(len(nodes))] else: raise SystemExit(color_by, f'Unexpected value for coloring variable: {color_by}') # now we can drop expression peak phase/time as separate fields nodes = nodes.drop('Expression peak phase',1) nodes = nodes.drop('Expression peak time',1) timing['Setting node cluster and color attributes'] = timeit.default_timer() - start len_nodes_filtered_comp = len(nodes) ###################################################### ### GET ALL INTERACTIONS BETWEEN ALL NODES ###################################################### start_final_sql = timeit.default_timer() max_interactions = 10000 # a too high value here seems to make the server run out of memory and this is the most time-expensive step on the server placeholders = ', '.join('?' for unused in node_list) # '?, ?, ?, ...' placeholders_primary_nodes = ', '.join('?' for unused in primary_nodes) # Multiple query options # if there are more than max_interactions satisfying the criteria then ORDEr BY: # - Pick interactions with primary_nodes first # - pick regulations/physical over genetic # - pick more over less: exp, pubs, methods # - Pick regulation over physical when equal in exp/pubs/methods because regulatory interactions are often singular in these. if len(split_types) == 3: query = "SELECT * FROM interactions \ WHERE ( (source IN (%s) AND target IN (%s)) \ AND num_experiments >= (%s) AND num_publications >= (%s) AND num_methods >= (%s)) \ ORDER BY \ CASE WHEN ((source IN (%s)) OR (target IN (%s))) THEN 1 ELSE 2 END ASC, \ CASE type WHEN 'physical' OR 'regulation' THEN 1 WHEN 'genetic' THEN 2 END ASC, \ num_experiments DESC, num_publications DESC, num_methods DESC, \ CASE type WHEN 'regulation' THEN 1 WHEN 'physical' THEN 2 WHEN 'genetic' THEN 3 END ASC \ limit (%s)" \ % (placeholders,placeholders,min_exp,min_pub,min_methods,placeholders_primary_nodes,placeholders_primary_nodes,max_interactions) interactome = pd.read_sql_query(query, conn, params=node_list+node_list+primary_nodes+primary_nodes) else: placeholders_type = ', '.join('?' for unused in split_types) query = "SELECT * FROM interactions \ WHERE ( (source IN (%s) AND target IN (%s)) AND type IN (%s) \ AND num_experiments >= (%s) and num_publications >= (%s) and num_methods >= (%s)) \ ORDER BY \ CASE WHEN ((source IN (%s)) OR (target IN (%s))) THEN 1 ELSE 2 END ASC, \ CASE type WHEN 'physical' OR 'regulation' THEN 1 WHEN 'genetic' THEN 2 END ASC, \ num_experiments DESC, num_publications DESC, num_methods DESC, \ CASE type WHEN 'regulation' THEN 1 WHEN 'physical' THEN 2 WHEN 'genetic' THEN 3 END ASC \ limit (%s)" \ % (placeholders, placeholders,placeholders_type,min_exp,min_pub,min_methods,placeholders_primary_nodes,placeholders_primary_nodes,max_interactions) interactome = pd.read_sql_query(query, conn, params=node_list+node_list+split_types+primary_nodes+primary_nodes) interactome.columns = ['source','target','type','Evidence','Evidence HTML','#Experiments',\ '#Publications','#Methods'] timing['Interactome SQL + dataframe + processing'] = timeit.default_timer() - start_final_sql ###################################################### ### BASED ON THE METHOD TYPES FILTER: DROP INTERACTIONS ###################################################### start = timeit.default_timer() to_drop = [] with open(SCRIPT_DIR+'/data/unique_experimental_methods.txt') as f: read_methods = f.read().splitlines() total_methods = len(read_methods) if len(method_types) < total_methods: # some have been deselected algorithm_output_str += '<p>' + 'We have on file: ' + str(total_methods) + ' methods. User queried for: ' + str(len(method_types)) + '</p>' len_before = len(interactome) interactome = interactome[interactome.apply(lambda x: find_methods_in_evidence(x['Evidence'],method_types),1)] algorithm_output_str += '<p>' + 'We dropped: ' + str(len_before - len(interactome)) + ' interactions based on the methods.' + '</p>' if len(interactome) == 0: raise ValueError('No interactions matching these conditions.') timing['Filter based on methods'] = timeit.default_timer() - start ###################################################### # Network properties with networkx: 1 ###################################################### start = timeit.default_timer() df_network = pd.Series() df_network['Number of nodes'] = len(nodes) df_network['Number of edges'] = len(interactome) # use networkx nodes, interactome, df_network, G = calc_network_props(primary_nodes, nodes, interactome, df_network, filter_condition) df_network = df_network.to_frame() df_network = df_network.transpose() timing['networkx properties calculation'] = timeit.default_timer() - start ###################################################### # Export visualized networkx graph to graph formats (GEFX) ###################################################### start = timeit.default_timer() nx.write_gexf(G, SCRIPT_DIR+'/../output/networkx/' + primary_nodes_str + "_" + unique_str + "_full.gexf") timing['networkx export'] = timeit.default_timer() - start ###################################################### # Save the full network information ###################################################### start = timeit.default_timer() nodes_full = nodes.copy() interactome_full = interactome.copy() timing['Save full network'] = timeit.default_timer() - start ###################################################### # Pickle the dataframes ###################################################### start = timeit.default_timer() filename_base = os.path.abspath(SCRIPT_DIR+'/../output/excel_files/') file_id = primary_nodes_str+'_'+unique_str df_user_input.to_pickle(filename_base+'/user_input_'+file_id) nodes_full.to_pickle(filename_base+'/nodes_'+file_id) interactome_full.to_pickle(filename_base+'/interactome_'+file_id) timing['Pickle full network'] = timeit.default_timer() - start # ###################################################### # # WRITE "FULL" NETWORK TO JSON # # this will include a filtering step for really big networks # ###################################################### start_json = timeit.default_timer() write_network_to_json(nodes_full,interactome_full,filter_condition,output_filename,G,'full',primary_nodes) timing['json_full'] = timeit.default_timer() - start_json ###################################################### # FILTER NODES TO MANAGEABLE VISUALIZATION if (filter_flag): start_filter = timeit.default_timer() len_interactome = len(interactome) # reduce nodes nodes = nodes.sort_values(by=['primary node',filter_condition],ascending=False) nodes = nodes.iloc[:max_nodes] nodes.reset_index(drop=True,inplace=True) # reduce interactions n = nodes['Standard name'].values # list of remaining node IDs interactome = interactome[ (interactome['source'].isin(n)) & (interactome['target'].isin(n)) ] interactome.reset_index(drop=True,inplace=True) # SHOW WARNING MESSAGE ABOUT FILTER STEP filter_message = "Note: this query returned {} nodes and {} interactions. We reduced the network to {} nodes based on {} resulting in {} interactions. \ All interactions and nodes are contained in the <i>full</i> Excel file. ".format(len_nodes_filtered_comp,len_interactome,max_nodes,filter_condition,len(interactome)) s = filter_message print("<script>create_alert(\""+s+"\",\"alert-warning\");</script>") timing['filter'] = timeit.default_timer() - start_filter ###################################################### # Network properties with networkx: 2 ###################################################### start = timeit.default_timer() # df_network = pd.Series() df_network['Number of nodes'] = len(nodes) df_network['Number of edges'] = len(interactome) # use networkx nodes, interactome, df_network, G = calc_network_props(primary_nodes, nodes, interactome, df_network, filter_condition) timing['networkx properties calculation'] += timeit.default_timer() - start ###################################################### # Export full networkx graph to graph formats (GEFX) ###################################################### start = timeit.default_timer() nx.write_gexf(G, SCRIPT_DIR+'/../output/networkx/' + primary_nodes_str + "_" + unique_str + ".gexf") timing['networkx export'] += timeit.default_timer() - start ###################################################### # Nxviz image generation: matrixplot ###################################################### start = timeit.default_timer() c = nv.MatrixPlot(G) c.draw() plt.savefig(SCRIPT_DIR+'/../output/nxviz/matrix_' + unique_str + '.png') timing['nxviz matrix plot'] = timeit.default_timer() - start ###################################################### ### Write the network to json ###################################################### start_json = timeit.default_timer() write_network_to_json(nodes,interactome,filter_condition,output_filename,G) timing['json'] = timeit.default_timer() - start_json # remove the Evidence HTML column interactome = interactome.drop('Evidence',1) interactome = interactome.rename(columns={'Evidence HTML':'Evidence'}) if not excel_flag: ###################################################### ### End output text alert div ###################################################### print("</div>") ###################################################### # Generate strings for the nodes and interactome dataframes to print ###################################################### start_print = timeit.default_timer() # drop columns nodes = nodes.drop(['Description','CYCLoPs_Excel_string','CYCLoPs_dict','cluster','color'],1) # Add HTML links to database/SGD to symbols nodes['Standard name'] = nodes['Standard name'].apply(lambda x: "<a href='index.php?id=database&gene=" + x + "' target='blank'>" + x + "</a>") # change CYCLoPs column name and export html # escape makes the HTML links work nodes = nodes.rename(columns={'CYCLoPs_html':'CYCLoPs'}) nodes = nodes.to_html(escape=False,index=False,classes=['table','table-condensed','table-bordered']) nodes = nodes.replace('<table','<table id=\"proteins_table\"',1) interactome['source'] = interactome['source'].apply(lambda x: "<a href='index.php?id=database&gene=" + x + "' target='blank'>" + x + "</a>" ) interactome['target'] = interactome['target'].apply(lambda x: "<a href='index.php?id=database&gene=" + x + "' target='blank'>" + x + "</a>") # escape makes the HTML links work interactome = interactome.to_html(escape=False,index=False,classes=['table','table-condensed','table-bordered']) interactome = interactome.replace('<table','<table id=\"interactions_table\"',1) ###################################################### # PRINT COLLAPSABLE BOOTSTRAP HTML CODE WITH THE DATAFRAMES ###################################################### # the 'in' class makes the collapse open by default: the interactions here print(""" <div class="panel-group" id="accordion"> <div class="panel panel-default"> <div class="panel-heading"> <h4 class="panel-title"> <a data-toggle="collapse" data-parent="#accordion" href="#collapse1"> User input</a> </h4> </div> <div id="collapse1" class="panel-collapse collapse"> <div class="panel-body"> <div class="table-responsive"> """) print(df_user_input_to_print) print(""" </div> </div> </div> </div> <div class="panel panel-default"> <div class="panel-heading"> <h4 class="panel-title"> <a data-toggle="collapse" data-parent="#accordion" href="#collapse2"> Network properties</a> </h4> </div> <div id="collapse2" class="panel-collapse collapse"> <div class="panel-body"> <div class="table-responsive"> """) print(df_network.to_html(classes=['table','table-condensed','table-bordered'],index=False)) print(""" </div> </div> </div> </div> <div class="panel panel-default"> <div class="panel-heading"> <h4 class="panel-title"> <a data-toggle="collapse" data-parent="#accordion" href="#collapse3"> Network nodes (proteins)</a> </h4> </div> <div id="collapse3" class="panel-collapse collapse"> <div class="panel-body"> Use the search utility to find the gene you are looking for. The table scrolls horizontally and vertically. By clicking the column headers the table will be sorted on that column. Use shift+click to sort on multiple columns. Default sorting is on number of experiments, number of publications, number of methods and alphabetical on standard name, in that order. <div class="table-responsive"> """) print(nodes) print(""" </div> </div> </div> </div> <div class="panel panel-default"> <div class="panel-heading"> <h4 class="panel-title"> <a data-toggle="collapse" data-parent="#accordion" href="#collapse4"> Interactions</a> </h4> </div> <div id="collapse4" class="panel-collapse collapse"> <div class="panel-body"> Use the search utility to find the gene you are looking for. By clicking the column headers the table will be sorted on that column. Use shift+click to sort on multiple columns. Default sorting is on number of experiments, number of publications, number of methods and alphabetical on standard name, in that order. <div class="table-responsive"> """) print(interactome) print(""" </div> </div> </div> </div> """) ###################################################### # Optional diagnostics ###################################################### print(""" <div class="panel panel-default"> <div class="panel-heading"> <h4 class="panel-title"> <a data-toggle="collapse" data-parent="#accordion" href="#collapse5"> Diagnostics: calculation time</a> </h4> </div> <div id="collapse5" class="panel-collapse collapse"> <div class="panel-body"> <div class="table-responsive"> """) timing['print frames'] = timeit.default_timer() - start_print timing['all'] = timeit.default_timer() - start_all df_timing = pd.Series(timing) df_timing = df_timing.to_frame() df_timing.columns = ['Time'] df_timing['Percentage'] = [v/timing['all']*100 for v in df_timing['Time'] ] print(df_timing.sort_values('Percentage').to_html(classes=['table','table-condensed','table-bordered'])) print("Accounted for:", sum([timing[k] for k in timing if k != 'all' ])/timing['all'] * 100, "percent of the time spent in Python.") print(""" </div> </div> </div> </div> </div> """) ###################################################### # Show algorithm output in an alert at the bottom of the page ###################################################### if algorithm_output_str != '': print("<div class=\"alert alert-dismissable alert-info\">") print(algorithm_output_str) print("</div>")
M = nx.MultiGraph() # multiDiGraph MD = nx.MultiDiGraph() # %% # you can use nxviz to for matrix plot or circos plot or arc plot # https://stackoverflow.com/questions/53366634/how-to-set-edge-color-in-nxviz-arcplot D = nx.DiGraph() D.add_nodes_from([1, 2, 3]) D.add_edge(1, 2) D.add_edge(2, 3) m = nz.MatrixPlot(D) m.draw() plt.show() a = nz.ArcPlot(D) a.draw( ) # here you can provide node_order and node_color which is provided in nodes metadata plt.show() c = nz.CircosPlot(D) c.draw() plt.show() # %% # to get the neighbours of the node D = nx.DiGraph()
import nxviz as nv import networkx as nx import matplotlib.pyplot as plt G = nx.Graph() G.add_nodes_from([1, 2, 3]) G.add_edge(1, 2) G.add_edge(1, 3) G.add_edges_from([(2, 3)]) nx.draw(G) m = nv.MatrixPlot(G) m.draw() c = nv.CircosPlot(G, node_size=1, edge_width=10, node_labels=True) c.draw() a = nv.ArcPlot(G) a.draw() plt.show()