def show_edge_weights(self, raw_input: str): # show0 weights1 on/off2 list = raw_input.split(' ') if len(list) == 3: if list[2] == 'on': s.show_weight_labels = True else: s.show_weight_labels = False else: s.cust_print(self, ('Improper command caught in add node: ' + raw_input))
def swap_colors(self, raw_input: str): # swap0 colors1 colorone2 colortwo3 list = raw_input.split(' ') if len(list) == 4: for g in s.graph.nodes: if s.graph.nodes[g]['color'] == str(list[2]): s.graph.nodes[g]['color'] = str(list[3]) s.successfulCommand = True else: s.cust_print(self, ('Improper command caught in swap colors: ' + raw_input))
def choose_import(self, raw_input: str): if '.json' in raw_input: dm.import_json(self, raw_input) elif '.gexf' in raw_input: dm.import_gexf(self, raw_input) elif '.png' in raw_input: dm.import_png(self, raw_input) else: s.cust_print(self, ( 'What is the file format from command? I accept .png, .gexf and .json: ' + str(raw_input)))
def set_node_pos(self, raw_input: str): list = raw_input.split(' ') if len(list) == 5: try: s.graph.nodes[list[2]]['pos'] = str(list[3]) + ';' + str(list[4]) s.successfulCommand = True except Exception as e: s.cust_print(self, ('Something went wrong while setting node position')) else: s.cust_print(self, ('Improper command caught in set node pos: ' + raw_input))
def define_draw_style(self, raw_input): list = raw_input.split(' ') if len(list) == 2: if list[1] == 'none': s.cust_print(self, ( 'Selected none drawstyle. Make sure to set up all node positions!' )) s.draw_style = list[1] s.successfulCommand = True else: s.cust_print(self, ('Improper command caught in drawstyle: ' + raw_input))
def save_gexf(self, raw_input): list = raw_input.split(' ') if len(list) == 3: s.filename = list[2] s.successfulCommand = True now = s.datetime.datetime.now() file_name = s.filename + now.strftime("-%m-%d-%Y--%H-%M-%S") + '.gexf' file_plus_path = str(s.getcwd()) + '\\' + file_name s.nx.write_gexf(s.graph, file_plus_path) s.cust_print(self, (str(file_plus_path) + ' was saved.')) else: s.cust_print(self, ('Improper command caught in save gexf: ' + raw_input))
def fullscreen(self, raw_input: str): # remove edge x1 x2 list = raw_input.split(' ') if len(list) == 2: if 'on' == list[1]: s.fullscreen = True elif 'off' == list[1]: s.fullscreen = False else: s.cust_print( self, ('Improper command caught in fullscreen: ' + raw_input)) else: s.cust_print(self, ('Improper command caught in fullscreen: ' + raw_input))
def change_node_color(self, raw_input): # change0 node1 color2 [nodename]3 [color]4 list = raw_input.split(' ') if len(list) == 5: try: s.graph.nodes[list[3]]['color'] = list[4] s.successfulCommand = True except Exception as e: s.cust_print(self, ( 'Something went wrong while assigning node color, please make sure such node or color exists' )) else: s.cust_print( self, ('Improper command caught in change node color: ' + raw_input))
def save_json(self, raw_input): list = raw_input.split(' ') if len(list) == 3: s.filename = list[2] s.successfulCommand = True now = s.datetime.datetime.now() file_name = s.filename + now.strftime("-%m-%d-%Y--%H-%M-%S") + '.json' file_plus_path = str(s.getcwd()) + '\\' + file_name f = open(file_plus_path, 'a') f.write(s.json.dumps(s.json_graph.node_link_data(s.graph))) f.close() s.cust_print(self, (str(file_plus_path) + ' was saved.')) else: s.cust_print(self, ('Improper command caught in save json: ' + raw_input))
def remove_node(self, raw_input: str): # remove node x1 list = raw_input.split(' ') if len(list) == 3: try: s.graph.remove_node(list[2]) s.successfulCommand = True except Exception as e: s.cust_print( self, ('something went wrong when removing node, make sure it exists' )) else: s.cust_print(self, ('Improper command caught in remove node: ' + raw_input))
def set_edge_weight(self, raw_input: str): # set0 edge1 weight2 u3 v4 weight5 list = raw_input.split( ' ' ) # edge = ('n0', 'n1') [round(float(loc_arr[0]), 4), round(float(loc_arr[1]), 4)] if len(list) == 6: try: s.graph[str(list[3])][str(list[4])]['weight'] = round( float(list[5]), 4) s.successfulCommand = True except Exception as e: s.cust_print(self, ('Something went wrong while setting edge weight')) else: s.cust_print(self, ('Improper command caught in set weight: ' + raw_input))
def get_dist_between_two_points(self, x1, y1, x2, y2): pos1x = float(str(x1)) pos1y = float(str(y1)) pos2x = float(str(x2)) pos2y = float(str(y2)) x = pos1x - pos2x y = pos1y - pos2y dist = round(s.math.sqrt(x * x + y * y), 4) metrics = float(float(s.prop_m) * float(dist) / float(s.prop_d)) if s.distance_out_loud: s.cust_print(self, ('Distance between 2 points: ' + str(dist) + '; or ' + str(metrics) + ' ' + str(s.prop_m_suffix))) s.distance_out_loud = False return dist
def add_node(self, raw_input: str): list = raw_input.split(' ') if len(list) == 4: s.graph.add_node(list[2], weight=list[3], color=s.default_node_color, name=list[2], pos='None') s.successfulCommand = True elif len(list) == 3: s.graph.add_node(list[2], color=s.default_node_color, name=list[2], pos='None') s.successfulCommand = True else: s.cust_print(self, ('Improper command caught in add node: ' + raw_input))
def get_node_dist(self, raw_input: str): list = raw_input.split(' ') # get0 node1 dist3 u4 v5 if len(list) == 5: try: pos1 = s.graph.nodes[str(list[3])]['pos'] pos1x = float(str(pos1).split(';')[0]) pos1y = float(str(pos1).split(';')[1]) pos2 = s.graph.nodes[str(list[4])]['pos'] pos2x = float(str(pos2).split(';')[0]) pos2y = float(str(pos2).split(';')[1]) s.distance_out_loud = True get_dist_between_two_points(self, pos1x, pos1y, pos2x, pos2y) except Exception as e: s.cust_print(self, ('Something went wrong while getting node positions')) else: s.cust_print( self, ('Improper command caught in get node dist: ' + raw_input))
def add_b_edge(self, raw_input: str): list = raw_input.split(' ') if '.DiGraph' in str(type(s.graph)): if len(list) == 7: # first, add nodes with corresponding parameters add_node('add node ' + list[3]) add_node('add node ' + list[4]) s.graph.add_edge(list[3], list[4], weight=list[5]) s.graph.add_edge(list[4], list[3], weight=list[6]) s.successfulCommand = True elif len(list) == 6: # first, add nodes with corresponding parameters add_node('add node ' + list[3]) add_node('add node ' + list[4]) s.graph.add_edge(list[3], list[4], weight=list[5]) s.graph.add_edge(list[4], list[3], weight=list[5]) s.successfulCommand = True elif len(list) == 5: # first, add nodes with corresponding parameters add_node('add node ' + list[3]) add_node('add node ' + list[4]) s.graph.add_edge(list[3], list[4], weight=0) s.graph.add_edge(list[4], list[3], weight=0) else: s.cust_print( self, ('Improper command caught in add bidirectional edge: ' + raw_input)) if '.Graph' in str(type(s.graph)): if len(list) == 6: # first, add nodes with corresponding parameters add_node('add node ' + list[3]) add_node('add node ' + list[4]) s.graph.add_edge(list[3], list[4], weight=list[5]) s.successfulCommand = True elif len(list) == 5: # first, add nodes with corresponding parameters add_node('add node ' + list[3]) add_node('add node ' + list[4]) s.graph.add_edge(list[3], list[4], weight=0) s.successfulCommand = True else: s.cust_print( self, ('Improper command caught in add bidirectional edge: ' + raw_input))
def set_weight_proportion( self, raw_input: str): # set0 weight1 proportion2 u3 v4 xxxKm5 list = raw_input.split(' ') # edge = ('n0', 'n1') if len(list) == 6: try: # w = s.graph[str(list[3])][str(list[4])]['weight'] pos1 = s.graph.nodes[str(list[3])]['pos'] pos1x = float(str(pos1).split(';')[0]) pos1y = float(str(pos1).split(';')[1]) pos2 = s.graph.nodes[str(list[4])]['pos'] pos2x = float(str(pos2).split(';')[0]) pos2y = float(str(pos2).split(';')[1]) dist = get_dist_between_two_points(self, pos1x, pos1y, pos2x, pos2y) s.prop_d = float(dist) # s.prop_m = ''.join(re.findall(r"[-+]?\d*\.\d+|\d+", str(list[5]))) if str(list[5])[-2].isdigit(): s.prop_m = str(list[5][:-1]) s.prop_m_suffix = str(list[5][-1]) else: s.prop_m = str(list[5][:-2]) s.prop_m_suffix = str(list[5][-2]) + str(list[5][-1]) s.cust_print(self, ('new distance proportion: ' + str(s.prop_d) + ' = ' + str(s.prop_m) + ' ' + str(s.prop_m_suffix))) except Exception as e: s.cust_print( self, ('Something went wrong while setting weight proportion')) else: s.cust_print( self, ('Improper command caught in set weight proportion: ' + raw_input))
def generate_custom_pos(self): emptyDict = {} # s.cust_print(self, 'custom pos generation started') for n in s.graph.nodes: try: if s.graph.nodes[n][ 'pos'] == 'None' or s.graph.nodes[n]['pos'] is None: s.cust_print( self, (str(n) + ' _node has no pos, set it up properly')) s.cust_print( self, (str(n) + ' has invalid position, using default layout')) s.draw_style = 'default' emptyDict = s.nx.planar_layout(s.graph) return emptyDict else: loc_arr = str(s.graph.nodes[n]['pos']).split(';') emptyDict[n] = [ round(float(loc_arr[0]), 4), round(float(loc_arr[1]), 4) ] except Exception as e: s.cust_print( self, (str(n) + ' has invalid position, using default layout(exception)')) s.draw_style = 'default' emptyDict = s.nx.planar_layout(s.graph) return emptyDict # s.cust_print(self, 'result of custom generation:') # s.cust_print(self, emptyDict) return emptyDict
def dum_dum_shmoys_cycled(self, wh_max_number, init_radius, f_node, cycles): global local_results for i in range(int(cycles)): dum_dum_shmoys_cycled_small(self, wh_max_number, init_radius, f_node) local_best_rad = 99999999999999999999999999999999999 for result in local_results: if local_best_rad > float(result['rad']): local_best_rad = float(result['rad']) for nd in s.graph.nodes: s.graph.nodes[nd]['color'] = s.default_node_color for el in local_results: if float(el['rad']) <= float(local_best_rad): s.cust_print(self, ('cycled shmoys: With radius of ' + str(el['rad']))) s.cust_print( self, ('cycled shmoys: These nodes will work: ' + str(el['wh']))) for e in el['wh']: try: s.graph.nodes[e]['color'] = s.default_wh_color except Exception as e: s.cust_print(self, ( 'cycled shmoys: something went wrong while changing wh color' )) break dm.draw_graph(self) local_results.clear()
def dum_dum_floyd_alg(self): distance_matrix = s.nx.floyd_warshall_numpy(s.graph, s.graph.nodes) ind = 0 sums = ({}) for nd in s.graph.nodes: sums[nd] = str(distance_matrix[ind]) ind += 1 newlist = [] for i in sums.values(): newlist.append(str(i).strip(" ")) two_d_array = [] for i in newlist: x = i.strip().split(" ") one_d_arr = [] for xi in x: xi = re.findall(r"[-+]?\d*\.\d+|\d+", str(xi)) if len(xi) > 0: one_d_arr.append(float(xi[0])) two_d_array.append(one_d_arr) overall_sums = ({}) index2 = 0 for nd in s.graph.nodes: overall_sums[str(nd)] = max(two_d_array[index2]) index2 += 1 s.cust_print(self, ('and the winner is:')) minimal_sum = min(overall_sums.values()) min_sum_name = '' for name, summ in overall_sums.items(): if summ == minimal_sum: min_sum_name = name s.cust_print( self, (min_sum_name + ' with a longest dist of ' + str(minimal_sum))) for nd in s.graph.nodes: s.graph.nodes[nd]['color'] = s.default_node_color s.graph.nodes[min_sum_name]['color'] = s.default_wh_color dm.draw_graph(self) s.successfulCommand = True
def draw_graph(self): self.figure.clf() colors = [ s.graph.nodes[a].get('color', s.default_node_color) for a in s.graph.nodes ] if s.draw_style == 'default' or s.draw_style == 'planar': pos = s.nx.planar_layout(s.graph) elif s.draw_style == 'shell': pos = s.nx.shell_layout(s.graph) elif s.draw_style == 'spring': pos = s.nx.spring_layout(s.graph) elif s.draw_style == 'spectral': pos = s.nx.spectral_layout(s.graph) elif s.draw_style == 'none': pos = generate_custom_pos(self) elif s.draw_style == 'random': pos = s.nx.random_layout(s.graph) elif s.draw_style == 'circular': pos = s.nx.circular_layout(s.graph) else: s.cust_print( self, ('Hard switch to planar. What is this draw style? ' + s.draw_style + '; Please define a valid one (see help).')) pos = s.nx.planar_layout(s.graph) if s.background_is_image: implot = s.plt.imshow(s.background_img) s.nx.draw(s.graph, pos, node_color=colors) labels = s.nx.get_edge_attributes(s.graph, 'weight') nd_labels = s.nx.get_node_attributes(s.graph, 'name') if s.show_weight_labels: s.nx.draw_networkx_edge_labels(s.graph, pos, edge_labels=labels) s.nx.draw_networkx_labels(s.graph, pos, labels=nd_labels) self.canvas.draw_idle()
def on_click(self, event): if event.dblclick: pass if event.button: if event.button == 3: round(float(event.xdata), 4) add_posed_node( self, 'add pnode ' + s.generic_node_name + str(s.generic_node_name_counter) + ' ' + str(round(float(event.xdata), 4)) + ' ' + str(round(float(event.ydata), 4))) s.generic_node_name_counter += 1 draw_graph(self) if event.button == 2: try: for n in s.graph.nodes: npos = s.graph.nodes[n]['pos'] nx = float(str(npos).split(';')[0]) ny = float(str(npos).split(';')[1]) if get_dist_between_two_points( self, round(float(event.xdata), 4), round(float(event.ydata), 4), nx, ny) <= 15: s.mouse_clicked_nodes.append(n) break if len(s.mouse_clicked_nodes) >= 2: n1x = str(s.graph.nodes[str( s.mouse_clicked_nodes[0])]['pos']).split(';')[0] n1y = str(s.graph.nodes[str( s.mouse_clicked_nodes[0])]['pos']).split(';')[1] n2x = str(s.graph.nodes[str( s.mouse_clicked_nodes[1])]['pos']).split(';')[0] n2y = str(s.graph.nodes[str( s.mouse_clicked_nodes[1])]['pos']).split(';')[1] dist = get_dist_between_two_points(self, n1x, n1y, n2x, n2y) weight = float( (float(s.prop_m) * float(dist)) / float(s.prop_d)) add_edge( self, 'add edge ' + str(s.mouse_clicked_nodes[0]) + ' ' + str(s.mouse_clicked_nodes[1]) + ' ' + str(weight)) s.mouse_clicked_nodes.clear() draw_graph(self) except Exception as e: s.cust_print( self, ('something went wrong while creating edge with mouse')) s.cust_print(self, (e)) if event.button == 1: if event.xdata: s.cust_print( self, ('mouse pos: ' + str(round(float(event.xdata), 4)) + ' ' + str(round(float(event.xdata), 4))))
def remove_edge(self, raw_input: str): # remove0 edge1 u2 v3 # remove node x1 list = raw_input.split(' ') if len(list) == 4: try: s.graph.remove_edge(str(list[2]), str(list[3])) s.successfulCommand = True except Exception as e: s.cust_print(self, (e)) s.cust_print(self, ('Failed to remove edge')) else: s.cust_print(self, ('Improper command caught in remove edge: ' + raw_input))
def import_png(self, raw_input): list = raw_input.split(' ') if len(list) == 2: try: s.background_img = s.plt.imread(raw_input.split(' ')[1]) s.successfulCommand = True s.background_is_image = True except Exception as e: s.cust_print(self, ('something went wrong while importing file ' + str(raw_input.split(' ')[1]))) s.cust_print(self, (e)) else: s.cust_print(self, ('Improper command caught in import png: ' + raw_input))
def convert(self, raw_input: str): # convert0 dist/metr1 500_2 list = raw_input.split(' ') # (prop_m * edge dist) / prop_d if len(list) == 3: if 'dist' in raw_input: metrics = float(float(s.prop_m) * float(list[2]) / float(s.prop_d)) s.cust_print(self, ('it corresponds to ' + str(metrics) + ' ' + str(s.prop_m_suffix))) else: dist = float(float(s.prop_d) * float(list[2]) / float(s.prop_m)) s.cust_print(self, ('it corresponds to ' + str(dist))) else: s.cust_print( self, ('Improper command caught in converting values: ' + raw_input))
def import_gexf(self, raw_input): list = raw_input.split(' ') if len(list) == 2: filename = list[1] try: s.graph = s.nx.read_gexf(filename) s.generic_node_name_counter = find_next_generica_node_name_counter( ) s.successfulCommand = True except Exception as e: s.cust_print( self, ('something went wrong while importing file ' + str(filename))) s.cust_print(self, (e)) else: s.cust_print(self, ('Improper command caught in import gexf: ' + raw_input))
def import_json(self, raw_input): list = raw_input.split(' ') if len(list) == 2: filename = list[1] try: f = open(filename) s.graph = s.json_graph.node_link_graph(s.json.load(f)) f.close() s.generic_node_name_counter = find_next_generica_node_name_counter( ) s.successfulCommand = True except Exception as e: s.cust_print( self, ('something went wrong while importing file ' + str(filename))) s.cust_print(self, e) else: s.cust_print(self, ('Improper command caught in import json: ' + raw_input))
def add_edge(self, raw_input: str): list = raw_input.split(' ') if len(list) == 5: if list[2] in s.graph.nodes and list[3] in s.graph.nodes: s.graph.add_edge(list[2], list[3], weight=round(float(list[4]), 4)) # list[4] s.successfulCommand = True else: s.cust_print(self, ( 'abort adding edge, one of nodes is missing. (hint: command print nodes)' )) elif len(list) == 4: if list[2] in s.graph.nodes and list[3] in s.graph.nodes: s.graph.add_edge(list[2], list[3], weight=0) s.successfulCommand = True else: s.cust_print(self, ( 'abort adding edge, one of nodes is missing. (hint: command print nodes)' )) else: s.cust_print(self, ('Improper command caught in add edge: ' + raw_input))
def dum_dum_shmoys_cycled_small(self, wh_max_number, init_radius, f_node): global last_working_result global last_working_radius global local_results warehouse_current_number = 0 warehouse_max_number = wh_max_number all_nodes = list(s.graph.nodes) all_warehouses = [] first_node = None amount_of_cycles = int(warehouse_max_number) if f_node is not None and f_node != 'None': if '(' not in f_node or ')' not in f_node: s.cust_print(self, ( 'cycled shmoys: nodes should be passed inside brackets without spaces, separated by \',\'' )) return raw_given_nodes = str(f_node).split('(')[1].split(')')[0].split(',') given_nodes = [n for n in raw_given_nodes if n in s.graph.nodes] given_nodes = list(set(given_nodes)) if int(wh_max_number) < len(given_nodes): s.cust_print(self, ( 'cycled shmoys: there are more given nodes than max number of warehouses, aborting' )) return amount_of_cycles = amount_of_cycles - len(given_nodes) for n in given_nodes: all_warehouses.append(n) warehouse_current_number += 1 nodes_in_radius.append(first_node) recursive_search(n, 0, init_radius) for n in nodes_in_radius: try: all_nodes.remove(n) except ValueError: pass # do nothing! nodes_in_radius.clear() if len(all_nodes) <= 0: break for k in range(amount_of_cycles): first_node = random.choice(all_nodes) all_warehouses.append(first_node) warehouse_current_number += 1 nodes_in_radius.append(first_node) recursive_search(first_node, 0, init_radius) for n in nodes_in_radius: try: all_nodes.remove(n) except ValueError: pass nodes_in_radius.clear() if len(all_nodes) <= 0: break if len(all_nodes) > 0: new_radius = int(init_radius) + int(int(init_radius)) / 4 if new_radius < last_working_radius: dum_dum_shmoys_cycled_small(self, wh_max_number, new_radius, f_node) else: temp_dict = { 'rad': last_working_radius, 'wh': list(last_working_result) } local_results.append(temp_dict) last_working_radius = 99999999999999999999999999999999999 last_working_result.clear() s.successfulCommand = True else: last_working_result = all_warehouses last_working_radius = int(init_radius) new_radius = int(init_radius) - int(int(init_radius) / 32) dum_dum_shmoys_cycled_small(self, wh_max_number, new_radius, f_node)
def dum_dum_shmoys(self, wh_max_number, init_radius, f_node): # from now on f_node will be a list of nodes or None. list ex.: (1,2,3) global last_working_result global last_working_radius warehouse_current_number = 0 warehouse_max_number = wh_max_number all_nodes = list(s.graph.nodes) all_warehouses = [] first_node = None amount_of_cycles = int(warehouse_max_number) if f_node is not None and f_node != 'None': if '(' not in f_node or ')' not in f_node: s.cust_print(self, ( 'dum_dum_shmoys: nodes should be passed inside brackets without spaces, separated by \',\'' )) return raw_given_nodes = str(f_node).split('(')[1].split(')')[0].split(',') given_nodes = [n for n in raw_given_nodes if n in s.graph.nodes] given_nodes = list(set(given_nodes)) if int(wh_max_number) < len(given_nodes): s.cust_print(self, ( 'dum_dum_shmoys: there are more given nodes than max number of warehouses, aborting' )) return amount_of_cycles = amount_of_cycles - len(given_nodes) for n in given_nodes: all_warehouses.append(n) warehouse_current_number += 1 nodes_in_radius.append(first_node) recursive_search(n, 0, init_radius) for n in nodes_in_radius: try: all_nodes.remove(n) except ValueError: pass # do nothing! nodes_in_radius.clear() if len(all_nodes) <= 0: break for k in range(amount_of_cycles): first_node = random.choice(all_nodes) all_warehouses.append(first_node) warehouse_current_number += 1 nodes_in_radius.append(first_node) recursive_search(first_node, 0, init_radius) for n in nodes_in_radius: try: all_nodes.remove(n) except ValueError: pass nodes_in_radius.clear() if len(all_nodes) <= 0: break if len(all_nodes) > 0: s.cust_print(self, ( 'dum_dum_shmoys: there are still nodes that are not covered by warehouses, incrementing radius (' + str(init_radius) + ') by quarter and starting again')) new_radius = int(init_radius) + int(int(init_radius)) / 4 if new_radius < last_working_radius: dum_dum_shmoys(self, wh_max_number, new_radius, f_node) else: s.cust_print(self, ( 'dum_dum_shmoys: extended function execution failed, last successful radius = ' + str(last_working_radius))) s.cust_print( self, ('dum_dum_shmoys: last successful placed warehouses: ' + str(last_working_result))) for nd in s.graph.nodes: s.graph.nodes[nd]['color'] = s.default_node_color for nd in last_working_result: s.graph.nodes[nd]['color'] = s.default_wh_color last_working_radius = 99999999999999999999999999999999999 last_working_result.clear() s.successfulCommand = True else: s.cust_print( self, ('dum_dum_shmoys: function execution completed with radius = ' + str(init_radius))) s.cust_print( self, ('dum_dum_shmoys: placed warehouses: ' + str(all_warehouses))) last_working_result = all_warehouses last_working_radius = int(init_radius) new_radius = int(init_radius) - int(int(init_radius) / 32) s.cust_print( self, ('dum_dum_shmoys: starting recursion with lesser radius = ' + str(new_radius))) dum_dum_shmoys(self, wh_max_number, new_radius, f_node)
def print_list(self, raw_input): if 'edges' in raw_input: s.cust_print(self, (s.graph.edges)) for e in s.graph.edges: s.cust_print(self, (str(e) + ' : ' + str(s.graph.edges[e]['weight']))) # # labels = s.nx.get_edge_attributes(s.graph, 'weight') # s.cust_print(self, labels) # colors = [s.graph.nodes[a].get('weight', 0) for a in s.graph.nodes] # s.cust_print(self, colors) elif 'nodes' in raw_input: s.cust_print(self, (s.graph.nodes)) elif 'style' in raw_input: s.cust_print(self, ('current drawstyle is: ' + str(s.draw_style))) elif 'one' in raw_input: try: s.cust_print(self, (s.graph.nodes[str(raw_input).split(' ')[-1]])) except Exception as e: s.cust_print( self, ('Failed to print info about node: ' + str(raw_input))) else: s.cust_print(self, (s.graph.nodes.keys())) s.cust_print(self, (s.graph.nodes.values())) s.cust_print(self, ('What is this option?(caught in print): ' + raw_input))