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()
