def build_prod_tree(config, key): if '.MKT' in key: return [GraphNode(config, key, 0, [])] if key in TREE_CACHE: return TREE_CACHE[key] trees = [] sources = config['sources'] template = config['templates'][key] if len(template['inputs']) == 0: trees.append(GraphNode(config, key, 0, [])) else: # identify all input combinations and production trees input_options = [] for input in template['inputs']: input_trees = [] for source in sources[input['id']]: source_chain = build_prod_tree(config, source) input_trees.extend(source_chain) input_options.append(input_trees) input_combos = combine_options(input_options) # create a production tree root for each variation variant = 0 for combo in input_combos: combo_node = GraphNode(config, key, variant, combo) trees.append(combo_node) variant = variant + 1 TREE_CACHE[key] = trees return trees
def toggle_user_updownvote_graph(self, login, gid, direction): direction in ('up', 'down') user = User.get_by_login(self.db, login) graph = GraphNode.get_by_name(self.db, gid) vote = user.get_vote_graph(gid) if direction == 'up': if vote['upvote']: user.rm_upvote_graph(gid) vote['upvote'] = False else: user.upvote_graph(gid) vote['upvote'] = True vote['downvote'] = False if direction == 'down': if vote['downvote']: user.rm_downvote_graph(gid) vote['downvote'] = False else: user.downvote_graph(gid) vote['upvote'] = False vote['downvote'] = True vote.update({ 'username': login, 'graph': gid, 'action': '%svote' % direction, 'time': datetime.datetime.now().isoformat() }) return vote
def get_edge_types(self, gid): """ returns node types that belongs to a graph gid : param gid : graph name """ graph = GraphNode.get_by_name(self.db, gid) return graph.get_edge_types()
def read_adj_file(fname): nodes = {} with open(fname) as f: row = 0 for line in f: col = 0 for bit in line.split(): if bit == '1': if col not in nodes.keys(): nodes[col] = GraphNode(col) if row not in nodes.keys(): nodes[row] = GraphNode(row) nodes[col].add_connections(nodes[row]) col = col + 1 row = row + 1 return nodes
def createNode(self, instance): global node_matrix self.total_nodes = self.total_nodes + 1 var = self.total_nodes '''Creating a GraphNode Class.''' node = GraphNode(pos=(400, 400), node_id=var) '''Creating a Node Matrix. Will use this matrix in APP Class for future calculations''' node_matrix.append(node) '''Adding the Widget to the drawing screen''' self.add_widget(node_matrix[-1])
def create_graph(self, login, name, properties): """ :param login: user login :param name: graph name :param description: graph description """ user = User.get_by_login(self.db, login) g = GraphNode(user, name) self.db.create(g.node, g.own_rel) self.update_graph(user, name, properties) return name
def find_edges(self, graph_name, edgetype_name, properties, start=0, size=100): graph = GraphNode.get_by_name(self.db, graph_name) edgetype = EdgeType.get_by_name(self.db, graph, edgetype_name) return [ x.as_dict() for x in UEdge.find_in_graph(self.db, graph, edgetype, properties, start, size) ]
def find_nodes(self, graph_name, nodetype_uuid, properties, start=0, size=100): graph = GraphNode.get_by_name(self.db, graph_name) nodetype = NodeType.get_by_uuid(self.db, nodetype_uuid) return [ x.as_dict() for x in UNode.find_in_graph( self.db, graph_name, nodetype.uuid, properties, start, size) ]
def create_edge_type(self, username, graph_name, name, properties, description=""): graph = GraphNode.get_by_name(self.db, graph_name) edgetype = EdgeType(graph, name, properties, description) self.db.create(edgetype.node, edgetype.belongs_rel) #TODO: log user action return edgetype.as_dict()
def proxemie(self, graph_name, p0, weights=None, filter_edges=None, filter_nodes=None, limit=50, n_step=3): graph = GraphNode.get_by_name(self.db, graph_name) return graph.proxemieMC(p0, weights=weights, filter_edges=filter_edges, filter_nodes=filter_nodes, limit=limit, n_step=n_step, n_walk=10000)
def get_graphs_count(self): return GraphNode.get_count(self.db)
def get_user_updownvote_graph(self, login, gid): user = User.get_by_login(self.db, login) graph = GraphNode.get_by_name(self.db, gid) return user.get_vote_graph(gid)
def get_edges(self, graph_name, edges_uuids): return GraphNode.get_by_name(self.db, graph_name).get_edge_list(edges_uuids)
def get_edge_list(self, graph_name, nodes_uuids): return GraphNode.get_by_name(self.db, graph_name).get_subgraph(nodes_uuids)
def get_graph_infos(self, name): return GraphNode.get_by_name(self.db, name).as_dict()
def find_edge_type(self, graph_name, type_name): graph = GraphNode.get_by_name(self.db, graph_name) return EdgeType.get_by_name(self.db, graph, type_name).as_dict()
def get_graph_metadata(self, name): return GraphNode.get_by_name(self.db, name).get_metadata()
def update_graph(self, user, graph_name, properties): graph = GraphNode.get_by_name(self.db, graph_name) graph.set_properties(properties) graph.node.push() return graph
def get_graphs(self): graphs = GraphNode.get_all(self.db) return graphs
def set_nodes_starred(self, gid, nodes_uuids, starred): graph = GraphNode.get_by_name(self.db, gid) if starred: graph.star(nodes_uuids) else: graph.unstar(nodes_uuids)
def rm_upvote_graph(self, login, graphname): user = self.get_user(login) graph = GraphNode.get_by_name(self.db, graphname) pass
def get_starred_node_uuids(self, graphname): return [ node for node in GraphNode.get_by_name( self.db, graphname).get_starred_node_uuids() ]
def complete_label(self, graph_name, what, prefix, start=0, size=100): graph = GraphNode.get_by_name(self.db, graph_name) return graph.complete_label(what, prefix, start, size)
def get_starred_node_count(self, graphname): return GraphNode.get_by_name(self.db, graphname).get_starred_node_count()
def destroy_graph(self, graph_name): return GraphNode.get_by_name(self.db, graph_name).destroy()