Statistics
| Branch: | Revision:

## iof-tools / networkxMiCe / networkx-master / networkx / algorithms / bipartite / edgelist.py @ 5cef0f13

History | View | Annotate | Download (11.1 KB)

 1 ```""" ``` ```********** ``` ```Bipartite Edge Lists ``` ```********** ``` ```Read and write NetworkX graphs as bipartite edge lists. ``` ``` ``` ```Format ``` ```------ ``` ```You can read or write three formats of edge lists with these functions. ``` ``` ``` ```Node pairs with no data:: ``` ``` ``` ``` 1 2 ``` ``` ``` ```Python dictionary as data:: ``` ``` ``` ``` 1 2 {'weight':7, 'color':'green'} ``` ``` ``` ```Arbitrary data:: ``` ``` ``` ``` 1 2 7 green ``` ``` ``` ```For each edge (u, v) the node u is assigned to part 0 and the node v to part 1. ``` ```""" ``` ```# Copyright (C) 2015 by ``` ```# Aric Hagberg ``` ```# Dan Schult ``` ```# Pieter Swart ``` ```# All rights reserved. ``` ```# BSD license. ``` ```__all__ = ['generate_edgelist', ``` ``` 'write_edgelist', ``` ``` 'parse_edgelist', ``` ``` 'read_edgelist'] ``` ```import networkx as nx ``` ```from networkx.utils import open_file, make_str, not_implemented_for ``` ```@open_file(1, mode='wb') ``` ```def write_edgelist(G, path, comments="#", delimiter=' ', data=True, ``` ``` encoding='utf-8'): ``` ``` """Write a bipartite graph as a list of edges. ``` ``` ``` ``` Parameters ``` ``` ---------- ``` ``` G : Graph ``` ``` A NetworkX bipartite graph ``` ``` path : file or string ``` ``` File or filename to write. If a file is provided, it must be ``` ``` opened in 'wb' mode. Filenames ending in .gz or .bz2 will be compressed. ``` ``` comments : string, optional ``` ``` The character used to indicate the start of a comment ``` ``` delimiter : string, optional ``` ``` The string used to separate values. The default is whitespace. ``` ``` data : bool or list, optional ``` ``` If False write no edge data. ``` ``` If True write a string representation of the edge data dictionary.. ``` ``` If a list (or other iterable) is provided, write the keys specified ``` ``` in the list. ``` ``` encoding: string, optional ``` ``` Specify which encoding to use when writing file. ``` ``` ``` ``` Examples ``` ``` -------- ``` ``` >>> G=nx.path_graph(4) ``` ``` >>> G.add_nodes_from([0,2], bipartite=0) ``` ``` >>> G.add_nodes_from([1,3], bipartite=1) ``` ``` >>> nx.write_edgelist(G, "test.edgelist") ``` ``` >>> fh=open("test.edgelist",'wb') ``` ``` >>> nx.write_edgelist(G, fh) ``` ``` >>> nx.write_edgelist(G, "test.edgelist.gz") ``` ``` >>> nx.write_edgelist(G, "test.edgelist.gz", data=False) ``` ``` ``` ``` >>> G=nx.Graph() ``` ``` >>> G.add_edge(1,2,weight=7,color='red') ``` ``` >>> nx.write_edgelist(G,'test.edgelist',data=False) ``` ``` >>> nx.write_edgelist(G,'test.edgelist',data=['color']) ``` ``` >>> nx.write_edgelist(G,'test.edgelist',data=['color','weight']) ``` ``` ``` ``` See Also ``` ``` -------- ``` ``` write_edgelist() ``` ``` generate_edgelist() ``` ``` """ ``` ``` for line in generate_edgelist(G, delimiter, data): ``` ``` line += '\n' ``` ``` path.write(line.encode(encoding)) ``` ```@not_implemented_for('directed') ``` ```def generate_edgelist(G, delimiter=' ', data=True): ``` ``` """Generate a single line of the bipartite graph G in edge list format. ``` ``` ``` ``` Parameters ``` ``` ---------- ``` ``` G : NetworkX graph ``` ``` The graph is assumed to have node attribute `part` set to 0,1 representing ``` ``` the two graph parts ``` ``` ``` ``` delimiter : string, optional ``` ``` Separator for node labels ``` ``` ``` ``` data : bool or list of keys ``` ``` If False generate no edge data. If True use a dictionary ``` ``` representation of edge data. If a list of keys use a list of data ``` ``` values corresponding to the keys. ``` ``` ``` ``` Returns ``` ``` ------- ``` ``` lines : string ``` ``` Lines of data in adjlist format. ``` ``` ``` ``` Examples ``` ``` -------- ``` ``` >>> from networkx.algorithms import bipartite ``` ``` >>> G = nx.path_graph(4) ``` ``` >>> G.add_nodes_from([0,2], bipartite=0) ``` ``` >>> G.add_nodes_from([1,3], bipartite=1) ``` ``` >>> G[1][2]['weight'] = 3 ``` ``` >>> G[2][3]['capacity'] = 12 ``` ``` >>> for line in bipartite.generate_edgelist(G, data=False): ``` ``` ... print(line) ``` ``` 0 1 ``` ``` 2 1 ``` ``` 2 3 ``` ``` ``` ``` >>> for line in bipartite.generate_edgelist(G): ``` ``` ... print(line) ``` ``` 0 1 {} ``` ``` 2 1 {'weight': 3} ``` ``` 2 3 {'capacity': 12} ``` ``` ``` ``` >>> for line in bipartite.generate_edgelist(G,data=['weight']): ``` ``` ... print(line) ``` ``` 0 1 ``` ``` 2 1 3 ``` ``` 2 3 ``` ``` """ ``` ``` try: ``` ``` part0 = [n for n, d in G.nodes.items() if d['bipartite'] == 0] ``` ``` except: ``` ``` raise AttributeError("Missing node attribute `bipartite`") ``` ``` if data is True or data is False: ``` ``` for n in part0: ``` ``` for e in G.edges(n, data=data): ``` ``` yield delimiter.join(map(make_str, e)) ``` ``` else: ``` ``` for n in part0: ``` ``` for u, v, d in G.edges(n, data=True): ``` ``` e = [u, v] ``` ``` try: ``` ``` e.extend(d[k] for k in data) ``` ``` except KeyError: ``` ``` pass # missing data for this edge, should warn? ``` ``` yield delimiter.join(map(make_str, e)) ``` ```def parse_edgelist(lines, comments='#', delimiter=None, ``` ``` create_using=None, nodetype=None, data=True): ``` ``` """Parse lines of an edge list representation of a bipartite graph. ``` ``` ``` ``` Parameters ``` ``` ---------- ``` ``` lines : list or iterator of strings ``` ``` Input data in edgelist format ``` ``` comments : string, optional ``` ``` Marker for comment lines ``` ``` delimiter : string, optional ``` ``` Separator for node labels ``` ``` create_using: NetworkX graph container, optional ``` ``` Use given NetworkX graph for holding nodes or edges. ``` ``` nodetype : Python type, optional ``` ``` Convert nodes to this type. ``` ``` data : bool or list of (label,type) tuples ``` ``` If False generate no edge data or if True use a dictionary ``` ``` representation of edge data or a list tuples specifying dictionary ``` ``` key names and types for edge data. ``` ``` ``` ``` Returns ``` ``` ------- ``` ``` G: NetworkX Graph ``` ``` The bipartite graph corresponding to lines ``` ``` ``` ``` Examples ``` ``` -------- ``` ``` Edgelist with no data: ``` ``` ``` ``` >>> from networkx.algorithms import bipartite ``` ``` >>> lines = ["1 2", ``` ``` ... "2 3", ``` ``` ... "3 4"] ``` ``` >>> G = bipartite.parse_edgelist(lines, nodetype = int) ``` ``` >>> sorted(G.nodes()) ``` ``` [1, 2, 3, 4] ``` ``` >>> sorted(G.nodes(data=True)) ``` ``` [(1, {'bipartite': 0}), (2, {'bipartite': 0}), (3, {'bipartite': 0}), (4, {'bipartite': 1})] ``` ``` >>> sorted(G.edges()) ``` ``` [(1, 2), (2, 3), (3, 4)] ``` ``` ``` ``` Edgelist with data in Python dictionary representation: ``` ``` ``` ``` >>> lines = ["1 2 {'weight':3}", ``` ``` ... "2 3 {'weight':27}", ``` ``` ... "3 4 {'weight':3.0}"] ``` ``` >>> G = bipartite.parse_edgelist(lines, nodetype = int) ``` ``` >>> sorted(G.nodes()) ``` ``` [1, 2, 3, 4] ``` ``` >>> sorted(G.edges(data = True)) ``` ``` [(1, 2, {'weight': 3}), (2, 3, {'weight': 27}), (3, 4, {'weight': 3.0})] ``` ``` ``` ``` Edgelist with data in a list: ``` ``` ``` ``` >>> lines = ["1 2 3", ``` ``` ... "2 3 27", ``` ``` ... "3 4 3.0"] ``` ``` >>> G = bipartite.parse_edgelist(lines, nodetype = int, data=(('weight',float),)) ``` ``` >>> sorted(G.nodes()) ``` ``` [1, 2, 3, 4] ``` ``` >>> sorted(G.edges(data = True)) ``` ``` [(1, 2, {'weight': 3.0}), (2, 3, {'weight': 27.0}), (3, 4, {'weight': 3.0})] ``` ``` ``` ``` See Also ``` ``` -------- ``` ``` """ ``` ``` from ast import literal_eval ``` ``` G = nx.empty_graph(0, create_using) ``` ``` for line in lines: ``` ``` p = line.find(comments) ``` ``` if p >= 0: ``` ``` line = line[:p] ``` ``` if not len(line): ``` ``` continue ``` ``` # split line, should have 2 or more ``` ``` s = line.strip().split(delimiter) ``` ``` if len(s) < 2: ``` ``` continue ``` ``` u = s.pop(0) ``` ``` v = s.pop(0) ``` ``` d = s ``` ``` if nodetype is not None: ``` ``` try: ``` ``` u = nodetype(u) ``` ``` v = nodetype(v) ``` ``` except: ``` ``` raise TypeError("Failed to convert nodes %s,%s to type %s." ``` ``` % (u, v, nodetype)) ``` ``` if len(d) == 0 or data is False: ``` ``` # no data or data type specified ``` ``` edgedata = {} ``` ``` elif data is True: ``` ``` # no edge types specified ``` ``` try: # try to evaluate as dictionary ``` ``` edgedata = dict(literal_eval(' '.join(d))) ``` ``` except: ``` ``` raise TypeError( ``` ``` "Failed to convert edge data (%s) to dictionary." % (d)) ``` ``` else: ``` ``` # convert edge data to dictionary with specified keys and type ``` ``` if len(d) != len(data): ``` ``` raise IndexError( ``` ``` "Edge data %s and data_keys %s are not the same length" % ``` ``` (d, data)) ``` ``` edgedata = {} ``` ``` for (edge_key, edge_type), edge_value in zip(data, d): ``` ``` try: ``` ``` edge_value = edge_type(edge_value) ``` ``` except: ``` ``` raise TypeError( ``` ``` "Failed to convert %s data %s to type %s." ``` ``` % (edge_key, edge_value, edge_type)) ``` ``` edgedata.update({edge_key: edge_value}) ``` ``` G.add_node(u, bipartite=0) ``` ``` G.add_node(v, bipartite=1) ``` ``` G.add_edge(u, v, **edgedata) ``` ``` return G ``` ```@open_file(0, mode='rb') ``` ```def read_edgelist(path, comments="#", ``` ``` delimiter=None, create_using=None, ``` ``` nodetype=None, data=True, edgetype=None, ``` ``` encoding='utf-8'): ``` ``` """Read a bipartite graph from a list of edges. ``` ``` ``` ``` Parameters ``` ``` ---------- ``` ``` path : file or string ``` ``` File or filename to read. If a file is provided, it must be ``` ``` opened in 'rb' mode. ``` ``` Filenames ending in .gz or .bz2 will be uncompressed. ``` ``` comments : string, optional ``` ``` The character used to indicate the start of a comment. ``` ``` delimiter : string, optional ``` ``` The string used to separate values. The default is whitespace. ``` ``` create_using : Graph container, optional, ``` ``` Use specified container to build graph. The default is networkx.Graph, ``` ``` an undirected graph. ``` ``` nodetype : int, float, str, Python type, optional ``` ``` Convert node data from strings to specified type ``` ``` data : bool or list of (label,type) tuples ``` ``` Tuples specifying dictionary key names and types for edge data ``` ``` edgetype : int, float, str, Python type, optional OBSOLETE ``` ``` Convert edge data from strings to specified type and use as 'weight' ``` ``` encoding: string, optional ``` ``` Specify which encoding to use when reading file. ``` ``` ``` ``` Returns ``` ``` ------- ``` ``` G : graph ``` ``` A networkx Graph or other type specified with create_using ``` ``` ``` ``` Examples ``` ``` -------- ``` ``` >>> from networkx.algorithms import bipartite ``` ``` >>> G = nx.path_graph(4) ``` ``` >>> G.add_nodes_from([0,2], bipartite=0) ``` ``` >>> G.add_nodes_from([1,3], bipartite=1) ``` ``` >>> bipartite.write_edgelist(G, "test.edgelist") ``` ``` >>> G = bipartite.read_edgelist("test.edgelist") ``` ``` ``` ``` >>> fh = open("test.edgelist", 'rb') ``` ``` >>> G = bipartite.read_edgelist(fh) ``` ``` >>> fh.close() ``` ``` ``` ``` >>> G=bipartite.read_edgelist("test.edgelist", nodetype=int) ``` ``` ``` ``` Edgelist with data in a list: ``` ``` ``` ``` >>> textline = '1 2 3' ``` ``` >>> fh = open('test.edgelist','w') ``` ``` >>> d = fh.write(textline) ``` ``` >>> fh.close() ``` ``` >>> G = bipartite.read_edgelist('test.edgelist', nodetype=int, data=(('weight',float),)) ``` ``` >>> list(G) ``` ``` [1, 2] ``` ``` >>> list(G.edges(data=True)) ``` ``` [(1, 2, {'weight': 3.0})] ``` ``` ``` ``` See parse_edgelist() for more examples of formatting. ``` ``` ``` ``` See Also ``` ``` -------- ``` ``` parse_edgelist ``` ``` ``` ``` Notes ``` ``` ----- ``` ``` Since nodes must be hashable, the function nodetype must return hashable ``` ``` types (e.g. int, float, str, frozenset - or tuples of those, etc.) ``` ``` """ ``` ``` lines = (line.decode(encoding) for line in path) ``` ``` return parse_edgelist(lines, comments=comments, ``` ``` delimiter=delimiter, ``` ``` create_using=create_using, ``` ``` nodetype=nodetype, ``` ``` data=data) ```