def read_file(self, path): if self.folder: nx_graph = [] for file in listdir(path): nx_graph.extend(nx.read_graph6(os.path.join(path, file))) return nx_graph return nx.read_graph6(path)
def get_number_of_total_sequences(numberNodes, numberBlocks): # each block have generated a "optimalSequences_n{n}_{0}.g6.txt" that contains a amount of optimal sequences for its block # for "optimalSequences_n10_0.g6.txt" there are 120052 optimal sequences, # for "optimalSequences_n10_99.g6.txt" there are 120020 optimal sequences Graphs = nx.read_graph6(f'{PATH_TO_GRAPHS_DATASETS}/n{numberNodes}_blocks/n{numberNodes}_0.g6') total = (numberBlocks - 1) * len(Graphs) # numberBlocks - 1, because until the last, all blocks has the same number of graphs, thus same number of sequences, # if only 1 block, total = 0 Graphs = nx.read_graph6(f'{PATH_TO_GRAPHS_DATASETS}/n{numberNodes}_blocks/n{numberNodes}_{numberBlocks - 1}.g6') # numberBlocks - 1, it's 0 indexed total += len(Graphs) return total
def build_dataset(num_files, show): rows = num_files * 120052 # 120052 rows from each file cols = 100 + 10 # 10x10 adj list + 10 optimal labels data = np.zeros((rows, cols)) row = 0 processed = 0 for idx in range(num_files): # get Y target_file_path = '{}opt_seq_n10_{}.g6.txt'.format( RESULT_DATA_PATH, idx) df = pd.read_csv(target_file_path, sep=';', dtype=int, header=None, skiprows=1, usecols=list(range(1, 11))) Y = df.values # get x and store it in data data_file_path = '{}n10_{}.g6'.format(G6_GRAPH_PATH, idx) G = nx.read_graph6(data_file_path) for i, graph in enumerate(G): x = nx.to_numpy_array(graph).ravel() data[row] = np.concatenate((x, Y[i])) row += 1 if idx % show == 0: processed += show print('{} files processed.'.format(processed)) np.save(TARGET, data)
def load_graph(fname): if fname.endswith('.g6'): return nx.read_graph6(fname) elif not os.path.exists(fname) and fname.endswith('.json'): return load_graph(fname.replace('.json', '.g6')) with open(fname, 'r') as f: return deserialize_graph(f.read())
def vrcholovoBimagickyGrafTest(n): G = [] G = read_graph6("zoznam grafov/graph" + str(n) + "c.g6") for i in range(len(G)): susedia = [] for _ in range(n): susedia.append(set()) for hrana in G[i].edges(): susedia[hrana[0]].add(hrana[1]) susedia[hrana[1]].add(hrana[0]) vyhovuje = True for v1, v2 in combinations((i for i in range(n)), r=2): x = len(susedia[v1].difference(susedia[v2])) y = len(susedia[v2].difference(susedia[v1])) if (x * y == 0 and x + y > 0) or x == 1 or y == 1 or (x == 2 and y == 2): vyhovuje = False break if not vyhovuje: break if vyhovuje: vypisRiesenie( "potencialne vrcholovo bimagicky graf s nasledovnymi hranami", G[i].edges(), {"pocet vrcholov: " + str(n)})
def test_read_graph6(self): data="""DF{""" G=nx.parse_graph6(data) fh = StringIO(data) Gin=nx.read_graph6(fh) assert_equal(sorted(G.nodes()),sorted(Gin.nodes())) assert_equal(sorted(G.edges()),sorted(Gin.edges()))
def test_read_equals_from_bytes(self): data = b"DF{" G = nx.from_graph6_bytes(data) fh = BytesIO(data) Gin = nx.read_graph6(fh) assert nodes_equal(G.nodes(), Gin.nodes()) assert edges_equal(G.edges(), Gin.edges())
def execute_graphs_file(file_name):#read graph file and create file of graph string file = open('bfs_tree_of_' + file_name + '.txt', "w+") for graph in nx.read_graph6(file_name + ".g6"): graph_str = find_graph_string(graph) file.write(graph_str + '\n')#write graph string in file file.close() return 'bfs_tree_of_'+ file_name + '.txt'
def test_read_graph6(self): data = """DF{""" G = nx.parse_graph6(data) fh = StringIO(data) Gin = nx.read_graph6(fh) assert_nodes_equal(G.nodes(), Gin.nodes()) assert_edges_equal(G.edges(), Gin.edges())
def test_read_equals_from_bytes(self): data = b'DF{' G = nx.from_graph6_bytes(data) fh = BytesIO(data) Gin = nx.read_graph6(fh) assert_nodes_equal(G.nodes(), Gin.nodes()) assert_edges_equal(G.edges(), Gin.edges())
def test_read_many_graph6(self): # Read many graphs into list data="""DF{\nD`{\nDqK\nD~{\n""" fh = StringIO(data) glist=nx.read_graph6(fh) assert_equal(len(glist),4) for G in glist: assert_equal(sorted(G.nodes()),[0, 1, 2, 3, 4])
def seed_graph(M, connected=False): if connected: suffix = "c" else: suffix = "d1" for idx, seed in enumerate( nx.read_graph6(f"data/undirected/{M}{suffix}.g6")): yield nx.convert_node_labels_to_integers(nx.line_graph(seed))
def test_read_many_graph6(self): # Read many graphs into list data = """DF{\nD`{\nDqK\nD~{\n""" fh = StringIO(data) glist = nx.read_graph6(fh) assert_equal(len(glist), 4) for G in glist: assert_equal(sorted(G.nodes()), [0, 1, 2, 3, 4])
def test_read_many_graph6(self): """Test for reading many graphs from a file into a list.""" data = b"DF{\nD`{\nDqK\nD~{\n" fh = BytesIO(data) glist = nx.read_graph6(fh) assert len(glist) == 4 for G in glist: assert sorted(G) == list(range(5))
def test_read_many_graph6(self): """Test for reading many graphs from a file into a list.""" data = b'DF{\nD`{\nDqK\nD~{\n' fh = BytesIO(data) glist = nx.read_graph6(fh) assert_equal(len(glist), 4) for G in glist: assert_equal(sorted(G), list(range(5)))
def test_roundtrip(self): for i in list(range(13)) + [31, 47, 62, 63, 64, 72]: G = nx.random_graphs.gnm_random_graph(i, i * i // 4, seed=i) f = BytesIO() nx.write_graph6(G, f) f.seek(0) H = nx.read_graph6(f) assert_nodes_equal(G.nodes(), H.nodes()) assert_edges_equal(G.edges(), H.edges())
def read_graph6(file_path): """ Reads the file and returns array of nx.Graph object, one for each line of input file. :param file_path: :return: """ G = nx.read_graph6(file_path) return G
def test_roundtrip(self): for i in list(range(13)) + [31, 47, 62, 63, 64, 72]: G = nx.random_graphs.gnm_random_graph(i, i * i // 4, seed=i) f = BytesIO() nx.write_graph6(G, f) f.seek(0) H = nx.read_graph6(f) assert nodes_equal(G.nodes(), H.nodes()) assert edges_equal(G.edges(), H.edges())
def test_read_graph6(self): data="""DF{""" G=nx.parse_graph6(data) (fd,fname)=tempfile.mkstemp() fh=open(fname,'w') b=fh.write(data) fh.close() Gin=nx.read_graph6(fname) assert_equal(sorted(G.nodes()),sorted(Gin.nodes())) assert_equal(sorted(G.edges()),sorted(Gin.edges())) os.close(fd) os.unlink(fname)
def load_stdgraphs(size: int) -> List[nx.Graph]: """Load standard graph validation sets For each size (from 6 to 32 graph nodes) the dataset consists of 100 graphs drawn from the Erdős-Rényi ensemble with edge probability 50%. """ from pkg_resources import resource_stream if size < 6 or size > 32: raise ValueError('Size out of range.') filename = 'datasets/data/graph{}er100.g6'.format(size) fdata = resource_stream('quantumflow', filename) return nx.read_graph6(fdata)
def build_dataset(num_files, show): rows = num_files * 120052 # 120052 rows from each file, because # each opt_seq_n10_{idx}.g6.txt has 120052 optimal sequences #cols = 100 + 1 + 10 # 10x10 adj list + optimal_band + 10 optimal labels cols = 45 + 1 + 10 # reduced adj list + optimal_band + 10 optimal labels data = np.zeros((rows, cols)) row = 0 processed = 0 for idx in range(num_files): # get Y target_file_path = '{}opt_seq_n10_{}.g6.txt'.format( RESULT_DATA_PATH, idx) df = pd.read_csv(target_file_path, sep=';', dtype=int, header=None, skiprows=1, usecols=list(range(1, 11))) Y = df.values for i, permutation in enumerate(Y): p = get_cp_fixed(permutation) Y[i] = p.copy() # get x and store it in data data_file_path = '{}n10_{}.g6'.format(G6_GRAPH_PATH, idx) G = nx.read_graph6(data_file_path) for i, graph in enumerate(G): opt_band = get_bandwidth(graph, Y[i]) #x = nx.to_numpy_array(graph).ravel() x = nx.to_numpy_array(graph) x_ravel = np.zeros( 45) # matriz 10x10=100; 100-diagonal=90; sup=90/2=45 j = 0 k = 1 for u in range(9): for v in range(k, 10): x_ravel[j] = x[u][v] j += 1 k += 1 #data[row] = np.concatenate((x,np.array([opt_band]),Y[i])) data[row] = np.concatenate( (x_ravel.copy(), np.array([opt_band]), Y[i])) row += 1 if idx % show == 0: processed += show print('{} files processed.'.format(processed)) np.save(TARGET, data)
def load_g6_graphs(path, name): ### code used to load SR graphs obtained from here http://users.cecs.anu.edu.au/~bdm/data/graphs.html ### we don't split the data, because no training is performed (the network is used with random weights for the SR experiment) dataset = nx.read_graph6(os.path.join(path, name + '.g6')) Graph = namedtuple('Graph', ['node_features', 'edge_mat', 'label']) graph_list = list() for i, datum in enumerate(dataset): x = torch.ones(datum.number_of_nodes(), 1) edge_index = to_undirected( torch.tensor(list(datum.edges())).transpose(1, 0)) graph = Graph(x, edge_index, torch.tensor(i).long()) graph_list.append(graph) num_classes = len(dataset) return graph_list, num_classes
def find_graph_with_probability_in_file(file_path, target_probability, num_phases, infection_rate): graphs = nx.read_graph6(file_path) best_diff = 10000 best_graph = None for G in graphs: vertices = G.nodes() edges = G.edges() for v in vertices: edges_copied = [[e[0], e[1]] for e in edges] for index, edge in enumerate(edges_copied): if edge[0] == v: edge[0] = -1 if edge[1] == v: edge[1] = -1 if edge[0] == 0: edge[0] = v if edge[1] == 0: edge[1] = v if edge[0] == -1: edge[0] = 0 if edge[1] == -1: edge[1] = 0 edges_copied[index] = (edge[0], edge[1]) diff = abs( calculate_with_markov(vertices, edges_copied, num_phases, infection_rate) - target_probability) if diff < best_diff: best_diff = diff best_graph = edges_copied print(best_graph) for row in vertices: line = '' for column in vertices: line += '1' if (row, column) in best_graph or ( column, row) in best_graph else '0' print(line) print( calculate_with_markov(vertices, best_graph, num_phases, infection_rate))
def writeOptimalSequenceTextFileForBlock(block, numberNodes): # get a block of graphs to write the optimal sequences file for that block, under "opt_results" folder # the "optimal sequences" file contains all optimal sequences for each graph in that block Graphs = nx.read_graph6(f'{PATH_TO_GRAPHS_DATASETS}/n{numberNodes}_blocks/n{numberNodes}_{block}.g6') print(f"There are {len(Graphs)} non-isomorphic graphs of {numberNodes} nodes in the block {block} (.g6 file)") for i in range(len(Graphs)): writeGraphAsTextFile(Graphs[i], i) result_file = f'optimalSequences_n{numberNodes}_{block}.g6.txt' saveAllGraphsOptimalBandsInOneTextFile(len(Graphs), result_file, numberNodes, block) optimal_sequence_dict = load_opt_seq(result_file, numberNodes) larger,same,smaller = test_result(Graphs, optimal_sequence_dict) # Write tests results in the 150 blanks spaces that were reserved arr = [len(larger),same,smaller] s = ';'.join(list(map(str, arr))) path = f'./opt_results/n{numberNodes}_blocks/{result_file}' with open(path, 'r+') as file: file.seek(0) # move a cursor writer (or reader) to position 0 file.write(s)
def get_custom_edge_list(ks, substructure_type=None, filename=None): ''' Instantiates a list of `edge_list`s representing substructures of type `substructure_type` with sizes specified by `ks`. ''' if substructure_type is None and filename is None: raise ValueError( 'You must specify either a type or a filename where to read substructures from.' ) edge_lists = [] for k in ks: if substructure_type is not None: graphs_nx = getattr(nx, substructure_type)(k) else: graphs_nx = nx.read_graph6( os.path.join(filename, 'graph{}c.g6'.format(k))) if isinstance(graphs_nx, list) or isinstance(graphs_nx, types.GeneratorType): edge_lists += [list(graph_nx.edges) for graph_nx in graphs_nx] else: edge_lists.append(list(graphs_nx.edges)) return edge_lists
def load_graphs(mode, num): ''' Loads a random sample of graphs from the graphs file. Returns a mapping of the graph to its chromatic number. ''' log('loading graphs...') if 's' in mode: fname = str(GRAPH_DIR / SML_NAME) elif 'm' in mode: fname = str(GRAPH_DIR / MED_NAME) elif 'l' in mode: fname = str(GRAPH_DIR / LRG_NAME) else: raise Exception(f'Could not recognize mode: {mode}.') with open(fname, 'r', newline='\n', encoding='ISO-8859-1') as f: length = sum(1 for _ in f) if num >= length: num = length - 1 log(f'WARNING: Can only load up to {length} graphs from this file.') with open(fname, 'r') as f: lines = f.readlines() raw_graphs = random.sample(lines, num) # create temporary file so that nx can read it temp_path = 'temp' with open(temp_path, 'w', newline='\n') as f: f.writelines(raw_graphs) graphs = nx.read_graph6(temp_path) os.remove(temp_path) log(f'...{len(graphs)} graphs loaded.') return graphs
def build_dataset(*args): numberBlocks, numberNodes, numberTotalSequences, verbose = args rows = numberTotalSequences numberDigitsAdjcencyMatrix = (numberNodes * numberNodes - numberNodes) // 2 # cols = 45 + 1 + 10 # 10x10 upper triangle not optimal adjcency list + optimal_band (value) + 10 optimal labels (nodelist) # We are handling with symmetric adjcency lists (get the upper triangle from the main diagonal) cols = numberDigitsAdjcencyMatrix + 1 + numberNodes data = np.zeros((rows,cols)) row = 0 for block in range(numberBlocks): optimalSequence_i_file = f'./opt_results/n{numberNodes}_blocks/optimalSequences_n{numberNodes}_{block}.g6.txt' optimalSequences = pd.read_csv(optimalSequence_i_file, sep=';', dtype=int, header=None, skiprows=1, usecols=list(range(1, numberNodes + 1))).values optimalSequences = list(map(get_cp_fixed, optimalSequences)) # optimalSequences = np.array(optimalSequences) # optimalSequences is a matrix, idx 0 (row 0) is graph 0, # index 0 contains a list that represents its optimal sequence nodelist. # Data from the optimalSequence_n{NUMBER_NODES}_g6.txt # of course that another approach would be use load_opt_seq function, # but rather than returning a dict like load_opt_seq, this time we got an array # each row holds the upper triangle flattened, optimal bandwidth and optimal nodelist as columns # this will be the dataset to be passed into the neural network, stored as a ".csv" matrix Graphs = nx.read_graph6(f'{PATH_TO_GRAPHS_DATASETS}/n{numberNodes}_blocks/n{numberNodes}_{block}.g6') for i, graph in enumerate(Graphs): opt_band = get_optimal_bandwidth(graph, optimalSequences[i]) floatAdjMatrix = nx.to_numpy_array(graph) # "nx.to_numpy_array" is the same as "nx.adjacency matrix", but later we'll # use pytorch, a neural network works better with floats, since we have lot of 'wx + b' operations upperTriangleFlatten = np.array([floatAdjMatrix[row][column] for row in range(numberNodes - 1) for column in range(row + 1, numberNodes)]) data[row] = np.concatenate((np.array(upperTriangleFlatten), np.array([opt_band]), optimalSequences[i])) row += 1 if verbose and block % 4 == 0: print(f'{block + 1} blocks processed, total of {len(Graphs)} optimal sequences in the block just executed.') # np.save(target, data) buildCSVDataset(data, numberNodes)
def main(args): file_name = ' '.join(args.graph_file) # read graph file to networkx.DiGraph object ext = file_name.split('.')[-1] if ext == 'graphml': graph = nx.read_graphml(file_name) elif ext == 'gml': graph = nx.read_gml(file_name) elif ext == 'gexf': graph = nx.read_gexf(file_name) elif ext == 'g6': graph = nx.read_graph6(file_name) elif ext == 's6': graph = nx.read_sparse6(file_name) elif ext == 'gpickle' or ext == 'p': graph = nx.read_gpickle(file_name) elif ext == 'yaml': graph = nx.read_yaml(file_name) else: print "Graph file format not supported. Supported fileformats: graphml (recommended), gexf, gml, g6, s6, gpickle, yaml" for n in graph.nodes(): # from nicholas' tulip output if not 'x' in graph.node[n].keys(): if 'graphics' in graph.node[n].keys(): g = graph.node[n].pop('graphics') graph.node[n]['x'] = g['x'] graph.node[n]['y'] = g['y'] if 'h' in g.keys() and not 'node_type' in graph.node[n].keys(): if g['h'] == 1: graph.node[n]['node_type'] = 'reaction' elif g['h'] == 2.5: graph.node[n]['node_type'] = 'species' else: graph.node[n]['node_type'] = 'ignore' if not 'label' in graph.node[n].keys(): graph.node[n]['label'] = n if compatible_graph(graph): # get dictionary with layout info d = read_graph(graph) # get font font = ImageFont.truetype(args.font_file, 1000) # add cofactors if args.add_cofactors_from_sbml: sbml_file = ' '.join(args.add_cofactors_from_sbml) cofactors = get_cofactors_from_sbml(d, sbml_file) for r in cofactors: for s in cofactors[r]: d['edge_type'][(r,s)]=cofactors[r][s]['role'] else: cofactors = None # get the data to assemble the svg file (editable version) svg_data = get_svgdata( d= d, font=font, font_size= args.font_size, scale=args.scale, padding=args.padding, padding_labels= args.padding_labels, normalize=args.normalize, overlap=args.overlap, defdir = args.r_direction, cofactors = cofactors, reverse_cof = args.reverse_cof) # assemble svg file and save (editable version) doc = get_svgdoc(**svg_data) doc.save(args.svg_name) print 'output svg saved in', args.svg_name
import more_itertools as miter import itertools as iter import networkx as nx import string # import matplotlib.pyplot as plt G = nx.read_graph6('G.g6') H = nx.read_graph6('H.g6') # G = nx.petersen_graph() # H = nx.complete_graph(3) G_nodes = G.nodes() H_nodes = H.nodes() iterable = string.ascii_lowercase[0:len(G_nodes)] is_homomorphism_found = False for part in miter.set_partitions(iterable, len(H_nodes)): is_correct_homomorphism = True if is_homomorphism_found: break for p in part: if not is_correct_homomorphism: break if len(p) == 1: continue all_combs = iter.combinations(p, 2) for a_comb in all_combs: v1 = ord(a_comb[0]) - 97 v2 = ord(a_comb[1]) - 97 if G.has_edge(v1, v2): is_correct_homomorphism = False
def _cli(): parser = argparse.ArgumentParser( description=__description__) parser.add_argument('--version', action='version', version=__version__) parser.add_argument('-v', '--verbose', action='store_true') parser.add_argument('-i', '--fin', action='store', dest='fin', default='', metavar='FILE', help='Read model from file') parser.add_argument('-o', '--fout', action='store', dest='fout', default='', metavar='FILE', help='Write model to file') parser.add_argument('-N', '--nodes', type=int, dest='nodes', default=DEFAULT_NODES) parser.add_argument('-P', '--steps', type=int, dest='steps', default=DEFAULT_STEPS) parser.add_argument('--epochs', type=int, dest='epochs', default=EPOCHS) parser.add_argument('--lr', type=float, dest='learning_rate', default=LEARNING_RATE) parser.add_argument('-T', '--train', action='store', dest='ftrain', default='', metavar='FILE', help='Collection of graphs to train on') parser.add_argument('-V', '--validation', action='store', dest='fvalidation', default='', metavar='FILE', help='Validation graph dataset') opts = vars(parser.parse_args()) verbose = opts.pop('verbose') epochs = opts.pop('epochs') steps = opts.pop('steps') nodes = opts.pop('nodes') learning_rate = opts.pop('learning_rate') fin = opts.pop('fin') fout = opts.pop('fout') ftrain = opts.pop('ftrain') fvalidation = opts.pop('fvalidation') if ftrain: graphs = nx.read_graph6(ftrain) else: graphs = [nx.gnp_random_graph(nodes, 0.5) for _ in range(TRAINING_GRAPHS)] if fvalidation: validation = nx.read_graph6(fvalidation) else: validation = qf.datasets.load_stdgraphs(nodes) init_beta = None init_gamma = None if fin: with open(fin) as f: data = json.load(f) init_beta = np.asarray(data['beta']) init_gamma = np.asarray(data['gamma']) model = QAOAMaxcutModel(nodes, steps, init_beta, init_gamma) model.train(graphs, validation, epochs, learning_rate, verbose) if fout: with open(fout, 'w') as f: model.dump(f)
def read_one_graph(file_name, graph_number): return nx.read_graph6(file_name + '.g6') [graph_number]
"""okay so my idea is to create a new hashtable for all these subgraphs and generate corpus and then destroy them""" def create_partial_vocab(neigbourhood,hash_table,key_mid,d,vocab): """take 2*len(neigbourhood) such samples""" for i in range(1,2*len(neigbourhood)): choices = [np.random.choice(hash_table.values()) for i in range(1,d)] choices.insert(int(math.floor(d/2)),hash_table[key_mid]) choices = map(str,choices) vocab.append(" ".join(choices)) print vocab if __name__ == "__main__": i = 3 file_name = "/home/kris/Desktop/ML_DeppWalk/Data/all_graph10/graph4.g6" full_hash_table = [] print file_name file_list = nx.read_graph6(file_name) d = 5 #context window size vocab = [] #vocab """we migh have to save it to the disk and start again if size too big""" ret_start_val = 0 total_neigh = [] present_neighbourhood = gen_neigbourhood(i) start_val = max(0,ret_start_val) total_neigh.append(present_neighbourhood) ret_hash_table,key_mid = populate_table(i,start_val,present_neighbourhood)
from kuramoto import * from scipy.sparse import csr_matrix from math import floor from scipy.sparse.csgraph import reverse_cuthill_mckee #path = 'C:/Users/hbass/Desktop/fca/FCA-ML/adjacency-dynamics/' path = "/mnt/l/home/fca30/" path = "/mnt/l/home/kura30/" # read initial coloring, labels, indices and graph6 coloring = pd.read_csv(path + 'color.csv', header=None).to_numpy() # dataout = [i for i in np.load(path+'labels (4).npy', # allow_pickle=True)] dataout = [i for i in pd.read_csv(path + 'sync.csv', header=None).to_numpy()] indices = [i for i in pd.read_csv(path + 'ind.csv', header=None).to_numpy()] graphs = nx.read_graph6(path + 'tag.csv') count = True def width(colors, kappa): """ computes width from a color list """ ordered = list(set(colors)) lordered = len(ordered) threshold = floor(kappa / 2) if ordered == 0: assert ("Empty array or logic error.") elif lordered == 1: return 0
def create_isomorphism_database(db_out, pkls_out, boxes, sizes, path_geng=None, path_RI=None): conn = sqlite3.connect(db_out) cursor = conn.cursor() cursor.execute('''DROP TABLE IF EXISTS subgraphs''') cursor.execute('''CREATE TABLE subgraphs ( id_pkl INTEGER, n_graphs INTEGER, graph6 TEXT, k INTEGER, k_partite TEXT, k_valences TEXT, nodes_valences TEXT, n_nodes INTEGER, n_edges INTEGER, PRIMARY KEY (graph6, k_partite, nodes_valences) );''') conn.commit() id_pkl = 0 for G, p in calculate_complete_multipartite_graphs(sizes, boxes): print([path_geng, str(G.number_of_nodes()), "-d1", "-D2", "-q"]) proc = subprocess.Popen( [path_geng, str(len(G.nodes)), "-d1", "-D2", "-q"], stdout=subprocess.PIPE, stderr=subprocess.PIPE) geng_out, err = proc.communicate() proc.stdout.close() proc.stderr.close() for i, line_geng in enumerate(geng_out.split()): print(line_geng) sG = nx.read_graph6(BytesIO(line_geng)) k_gfu = tempfile.NamedTemporaryFile(mode="w", delete=False) k_gfu.write(graph_to_ri(G, "k_graph")) k_gfu.seek(0) s_gfu = tempfile.NamedTemporaryFile(mode="w", delete=False) s_gfu.write(graph_to_ri(sG, "subgraph")) s_gfu.seek(0) proc = subprocess.Popen( [path_RI, "mono", "geu", k_gfu.name, s_gfu.name], stdout=subprocess.PIPE, stderr=subprocess.PIPE) RI_out, err = proc.communicate() k_gfu.close() s_gfu.close() mappings = [] subgraphs = {} for line in RI_out.decode("utf-8").splitlines(): if line[0] == "{": mappings.append(eval(line)) if len(mappings) == 20000: gi = graph_info( p, sG, mappings, ) for vn in gi[0]: if vn not in subgraphs: subgraphs[vn] = gi[0][vn] # print vn, result[0][vn], result[1][0], result[1][1], len(result[1][1]) else: before = len(subgraphs[vn]) for es in gi[0][vn]: if es not in subgraphs[vn]: subgraphs[vn].append(es) # print vn, es, result[1][0], result[1][1], len(result[1][1]) after = len(subgraphs[vn]) print(before, after) mappings = [] if len(mappings) > 0: gi = graph_info( p, sG, mappings, ) # job = job_server.submit(graphInfo, (p, sG, mappings, ), (valences,), modules=(), globals=globals()) # jobs.append(job) for vn in gi[0]: if vn not in subgraphs: subgraphs[vn] = gi[0][vn] # print vn, result[0][vn], result[1][0], result[1][1], len(result[1][1]) else: before = len(subgraphs[vn]) for es in gi[0][vn]: if es not in subgraphs[vn]: subgraphs[vn].append(es) # print vn, es, result[1][0], result[1][1], len(result[1][1]) after = len(subgraphs[vn]) print(before, after) if len(subgraphs) > 0: for vn in subgraphs: root = {} for fr in subgraphs[vn]: parent = root for e in fr: parent = parent.setdefault(e, {}) vt = tuple([sum(v) for v in eval(vn)]) print("INSERT:", i, line_geng.decode("utf-8"), len(subgraphs[vn]), len(p), str(p), vt, vn, sG.number_of_nodes(), sG.number_of_edges()) id_pkl += 1 cursor.execute( '''INSERT INTO subgraphs (id_pkl, n_graphs, graph6, k, k_partite, k_valences, nodes_valences, n_nodes, n_edges) values (?, ?, ?, ?, ?, ?, ?, ?, ?)''', (id_pkl, len( subgraphs[vn]), line_geng, len(p), str(p), str(vt), str(vn), sG.number_of_nodes(), sG.number_of_edges())) pickle.dump( root, open(os.path.join(pkls_out, "{}.pkl".format(id_pkl)), "wb")) conn.commit() conn.close()