def index(req, session, postgres_handle):
root_user = None
if 'user_id' in req.params:
root_user = TwitterUser.get_by_id(req.params['user_id'],
postgres_handle)
if not root_user:
root_user = TwitterUser.by_screen_name('SmartTypes', postgres_handle)
reduction = TwitterReduction.get_latest_reduction(root_user.id,
postgres_handle)
if not reduction:
root_user = TwitterUser.by_screen_name('SmartTypes', postgres_handle)
reduction = TwitterReduction.get_latest_reduction(
root_user.id, postgres_handle)
return {
'active_tab':
'social_map',
'template_path':
'social_map/index.html',
'root_user':
root_user,
'reduction':
reduction,
'num_groups':
len(TwitterGroup.all_groups(reduction.id, postgres_handle)),
'users_with_a_reduction':
TwitterReduction.get_users_with_a_reduction(postgres_handle),
}
def next_or_previous_reduction_id(req, session, postgres_handle):
reduction = None
if 'reduction_id' in req.params:
try:
reduction_id = int(req.params['reduction_id'])
except ValueError:
reduction_id = -1
reduction = TwitterReduction.get_by_id(reduction_id, postgres_handle)
#prev / next reduction
new_reduction_id = -1
if reduction and 'next_or_previous' in req.params:
if req.params['next_or_previous'] in ['prev_reduction', 'next_reduction']:
ordered_reduction_list = TwitterReduction.get_ordered_id_list(
reduction.root_user_id, postgres_handle)
for i in range(len(ordered_reduction_list)):
if reduction.id == ordered_reduction_list[i]:
current_idx = i
break
if req.params['next_or_previous'] == 'prev_reduction':
idx = current_idx - 1
if req.params['next_or_previous'] == 'next_reduction':
idx = current_idx + 1
new_reduction_id = ordered_reduction_list[idx]
return {
'content_type': 'application/json',
'json': {
'reduction_id': new_reduction_id,
'num_groups': len(TwitterGroup.all_groups(new_reduction_id, postgres_handle))
}
}
def index(req, session, postgres_handle):
#if it's not a valid request keep reduction_id None
#don't do work for bots that don't know what they're
#looking for
reduction = None
user_reduction_counts = TwitterReduction.get_user_reduction_counts(
postgres_handle)
random.shuffle(user_reduction_counts)
if req.path.split('/') > 1 and req.path.split(
'/')[1]: # path looks like '/something'
root_user = TwitterUser.by_screen_name(
req.path.split('/')[1], postgres_handle)
if root_user:
reduction = TwitterReduction.get_latest_reduction(
root_user.id, postgres_handle)
if not reduction and is_int(req.path.split('/')[1]):
reduction = TwitterReduction.get_by_id(
req.path.split('/')[1], postgres_handle)
else:
reduction = TwitterReduction.get_latest_reduction(
user_reduction_counts[0][0].id, postgres_handle)
return {
'reduction_id':
reduction.id
if reduction and reduction.tiles_are_written_to_disk else None,
'reduction':
reduction
if reduction and reduction.tiles_are_written_to_disk else None,
'user_reduction_counts':
user_reduction_counts
}
def community_features(req, session, postgres_handle):
reduction = None
if req.path.split('/') > 3 and req.path.split('/')[3]: # path looks like '/social_map/community_features/something'
root_user = TwitterUser.by_screen_name(req.path.split('/')[3], postgres_handle)
if root_user:
reduction = TwitterReduction.get_latest_reduction(root_user.id, postgres_handle)
if not reduction and is_int(req.path.split('/')[3]):
reduction = TwitterReduction.get_by_id(req.path.split('/')[3], postgres_handle)
return {
'content_type': 'application/json',
'json':reduction.get_geojson_community_features() if reduction else [],
}
def index(req, session, postgres_handle):
root_user = None
if 'user_id' in req.params:
root_user = TwitterUser.get_by_id(req.params['user_id'], postgres_handle)
if not root_user:
root_user = TwitterUser.by_screen_name('SmartTypes', postgres_handle)
reduction = TwitterReduction.get_latest_reduction(root_user.id, postgres_handle)
if not reduction:
root_user = TwitterUser.by_screen_name('SmartTypes', postgres_handle)
reduction = TwitterReduction.get_latest_reduction(root_user.id, postgres_handle)
return {
'active_tab': 'social_map',
'template_path': 'social_map/index.html',
'root_user': root_user,
'reduction': reduction,
'num_groups': len(TwitterGroup.all_groups(reduction.id, postgres_handle)),
'users_with_a_reduction': TwitterReduction.get_users_with_a_reduction(postgres_handle),
}
def group_details(req, session, postgres_handle):
if 'group_index' in req.params and 'reduction_id' in req.params:
reduction = TwitterReduction.get_by_id(req.params['reduction_id'], postgres_handle)
group_index = int(req.params['group_index'])
twitter_group = TwitterGroup.get_by_index(reduction.id, group_index, postgres_handle)
else:
twitter_group = None
return {
'template_path': 'social_map/group_details.html',
'twitter_group': twitter_group,
}
def group_details(req, session, postgres_handle):
if 'group_index' in req.params and 'reduction_id' in req.params:
reduction = TwitterReduction.get_by_id(req.params['reduction_id'],
postgres_handle)
group_index = int(req.params['group_index'])
twitter_group = TwitterGroup.get_by_index(reduction.id, group_index,
postgres_handle)
else:
twitter_group = None
return {
'template_path': 'social_map/group_details.html',
'twitter_group': twitter_group,
}
def node_details(req, session, postgres_handle):
twitter_user, in_links, out_links = None, [], []
if 'node_id' in req.params and 'reduction_id' in req.params:
reduction = TwitterReduction.get_by_id(req.params['reduction_id'], postgres_handle)
twitter_user = TwitterUser.get_by_id(req.params['node_id'], postgres_handle)
if twitter_user:
in_links, out_links = reduction.get_in_and_out_links_for_user(req.params['node_id'])
return {
'template_path': 'social_map/node_details.html',
'twitter_user': twitter_user,
'in_links':in_links,
'out_links':out_links,
}
def index(req, session, postgres_handle):
#if it's not a valid request keep reduction_id None
#don't do work for bots that don't know what they're
#looking for
reduction = None
user_reduction_counts = TwitterReduction.get_user_reduction_counts(postgres_handle)
random.shuffle(user_reduction_counts)
if req.path.split('/') > 1 and req.path.split('/')[1]: # path looks like '/something'
root_user = TwitterUser.by_screen_name(req.path.split('/')[1], postgres_handle)
if root_user:
reduction = TwitterReduction.get_latest_reduction(root_user.id, postgres_handle)
if not reduction and is_int(req.path.split('/')[1]):
reduction = TwitterReduction.get_by_id(req.path.split('/')[1], postgres_handle)
else:
reduction = TwitterReduction.get_latest_reduction(user_reduction_counts[0][0].id, postgres_handle)
return {
'reduction_id': reduction.id if reduction and reduction.tiles_are_written_to_disk else None,
'reduction': reduction if reduction and reduction.tiles_are_written_to_disk else None,
'user_reduction_counts': user_reduction_counts
}
def next_or_previous_reduction_id(req, session, postgres_handle):
reduction = None
if 'reduction_id' in req.params:
try:
reduction_id = int(req.params['reduction_id'])
except ValueError:
reduction_id = -1
reduction = TwitterReduction.get_by_id(reduction_id, postgres_handle)
#prev / next reduction
new_reduction_id = -1
if reduction and 'next_or_previous' in req.params:
if req.params['next_or_previous'] in [
'prev_reduction', 'next_reduction'
]:
ordered_reduction_list = TwitterReduction.get_ordered_id_list(
reduction.root_user_id, postgres_handle)
for i in range(len(ordered_reduction_list)):
if reduction.id == ordered_reduction_list[i]:
current_idx = i
break
if req.params['next_or_previous'] == 'prev_reduction':
idx = current_idx - 1
if req.params['next_or_previous'] == 'next_reduction':
idx = current_idx + 1
new_reduction_id = ordered_reduction_list[idx]
return {
'content_type': 'application/json',
'json': {
'reduction_id':
new_reduction_id,
'num_groups':
len(TwitterGroup.all_groups(new_reduction_id, postgres_handle))
}
}
def map_data(req, session, postgres_handle):
reduction = None
if 'reduction_id' in req.params:
try:
reduction_id = int(req.params['reduction_id'])
except ValueError:
reduction_id = -1
reduction = TwitterReduction.get_by_id(reduction_id, postgres_handle)
#details
reduction_details = []
if reduction:
return_all = not smarttypes.config.IS_PROD # for debugging
#return_all = False
reduction_details = reduction.get_details(return_all=return_all)
return {'content_type': 'application/json', 'json': reduction_details}
def node_details(req, session, postgres_handle):
twitter_user, in_links, out_links = None, [], []
if 'node_id' in req.params and 'reduction_id' in req.params:
reduction = TwitterReduction.get_by_id(req.params['reduction_id'],
postgres_handle)
twitter_user = TwitterUser.get_by_id(req.params['node_id'],
postgres_handle)
if twitter_user:
in_links, out_links = reduction.get_in_and_out_links_for_user(
req.params['node_id'])
return {
'template_path': 'social_map/node_details.html',
'twitter_user': twitter_user,
'in_links': in_links,
'out_links': out_links,
}
def map_data(req, session, postgres_handle):
reduction = None
if 'reduction_id' in req.params:
try:
reduction_id = int(req.params['reduction_id'])
except ValueError:
reduction_id = -1
reduction = TwitterReduction.get_by_id(reduction_id, postgres_handle)
#details
reduction_details = []
if reduction:
return_all = not smarttypes.config.IS_PROD # for debugging
#return_all = False
reduction_details = reduction.get_details(return_all=return_all)
return {
'content_type': 'application/json',
'json': reduction_details
}
def map_data(req, session, postgres_handle):
reduction = None
if 'reduction_id' in req.params:
try:
reduction_id = int(req.params['reduction_id'])
except ValueError:
reduction_id = -1
reduction = TwitterReduction.get_by_id(reduction_id, postgres_handle)
reduction_info = {
'coordinates':[],
'min_coord':0,
'max_coord':1,
}
if reduction:
return_all = not smarttypes.config.IS_PROD # for debugging
#return_all = False
reduction_info = reduction.get_reduction_info(return_all=return_all)
return {
'content_type': 'application/json',
'json': reduction_info
}
from datetime import datetime
import smarttypes, sys, string
from smarttypes.config import *
from smarttypes.model.twitter_credentials import TwitterCredentials
from smarttypes.model.twitter_user import TwitterUser
from smarttypes.model.twitter_reduction import TwitterReduction
from smarttypes.utils.postgres_handle import PostgresHandle
postgres_handle = PostgresHandle(smarttypes.connection_string)
if __name__ == "__main__":
user_count_list = TwitterReduction.get_user_reduction_counts(
postgres_handle)
for user, count in user_count_list:
if count == 1:
creds = TwitterCredentials.get_by_twitter_id(
user.id, postgres_handle)
creds.maybe_send_initial_map_email()
queue.put(None)
# wait for pending rendering jobs to complete
queue.join()
for i in range(num_threads):
renderers[i].join()
if __name__ == "__main__":
postgres_handle = PostgresHandle(smarttypes.connection_string)
#get reduction_id
qry = """
select tr.id
from twitter_reduction tr
where tr.tiles_are_written_to_disk = False
order by tr.id desc limit 1;
"""
reduction_id = postgres_handle.execute_query(qry, {})[0]['id']
tile_dir = '../static/tiles/%s/' % reduction_id
if not os.path.isdir(tile_dir):
os.mkdir(tile_dir)
style_file = 'mapnik.xml'
min_zoom = 0
max_zoom = 5
bbox = (-180, -85.0511, 180, 85.0511)
render_tiles(bbox, style_file, tile_dir, min_zoom, max_zoom)
reduction = TwitterReduction.get_by_id(reduction_id, postgres_handle)
reduction.tiles_are_written_to_disk = True
reduction.save()
postgres_handle.connection.commit()
g.vs['size'] = 1
#plot to file
layout = Layout(layout_list)
filepath = 'io/%s.png' % root_user.screen_name
thumb_filepath = 'io/%s_thumb.png' % root_user.screen_name
plot_graph(g, layout, filepath, size_tup=(600, 600))
#need to adjust vs['size'] if i want to do this
#plot_graph(g, layout, thumb_filepath, size_tup=(50, 50))
if not smarttypes.config.IS_PROD:
os.system('cp io/%s*.png /home/timmyt/projects/smarttypes/smarttypes/static/images/maps/.' % root_user.screen_name)
else:
os.system('scp io/%s*.png cottie:/home/timmyt/projects/smarttypes/smarttypes/static/images/maps/.' % root_user.screen_name)
print 'save to disk'
twitter_reduction = TwitterReduction.create_reduction(root_user.id, postgres_handle)
postgres_handle.connection.commit()
for community_idx, values_dict in community_stats.items():
#params:
#reduction_id, index, center_coordinate, member_ids,
#global_pagerank, community_pagerank, hybrid_pagerank
if community_idx > 0:
TwitterCommunity.create_community(twitter_reduction.id, community_idx,
values_dict['center_coordinate'], values_dict['member_ids'], values_dict['global_pagerank'],
values_dict['community_pagerank'], values_dict['hybrid_pagerank'], postgres_handle)
postgres_handle.connection.commit()
TwitterCommunity.mk_tag_clouds(twitter_reduction.id, postgres_handle)
postgres_handle.connection.commit()
#how long
print datetime.now() - start_time
def reduce_graph(screen_name, distance=20, min_followers=60):
postgres_handle = PostgresHandle(smarttypes.connection_string)
###########################################
##reduce
###########################################
root_user = TwitterUser.by_screen_name(screen_name, postgres_handle)
follower_followies_map = root_user.get_graph_info(distance=distance,
min_followers=min_followers)
gr = GraphReduce(screen_name, follower_followies_map)
gr.reduce_with_linloglayout()
###########################################
##save reduction in db
###########################################
root_user_id = root_user.id
user_ids = []
x_coordinates = []
y_coordinates = []
in_links = []
out_links = []
for i in range(len(gr.layout_ids)):
user_id = gr.layout_ids[i]
user_ids.append(user_id)
x_coordinates.append(gr.reduction[i][0])
y_coordinates.append(gr.reduction[i][1])
itr_in_links = PostgresHandle.spliter.join(gr.G.predecessors(user_id))
itr_out_links = PostgresHandle.spliter.join(gr.G.successors(user_id))
in_links.append(itr_in_links)
out_links.append(itr_out_links)
twitter_reduction = TwitterReduction.create_reduction(root_user_id, user_ids,
x_coordinates, y_coordinates, in_links, out_links, postgres_handle)
postgres_handle.connection.commit()
###########################################
##save groups in db
###########################################
groups = []
for i in range(gr.n_groups):
user_ids = []
for j in range(len(gr.layout_ids)):
if i == gr.groups[j]:
user_ids.append(gr.layout_ids[j])
#run pagerank to get the scores
group_graph = networkx.DiGraph()
group_edges = []
for user_id in user_ids:
for following_id in set(user_ids).intersection(follower_followies_map[user_id]):
group_edges.append((user_id, following_id))
print len(user_ids), len(group_edges)
if not group_edges:
continue
group_graph.add_edges_from(group_edges)
pagerank = networkx.pagerank(group_graph, max_iter=500)
scores = []
for user_id in user_ids:
scores.append(pagerank.get(user_id, 0))
groups.append(TwitterGroup.create_group(twitter_reduction.id, i, user_ids, scores,
postgres_handle))
postgres_handle.connection.commit()
###########################################
##makes for quicker queries in some cases
###########################################
twitter_reduction.save_group_info(postgres_handle)
postgres_handle.connection.commit()
###########################################
##mk_tag_clouds
###########################################
TwitterGroup.mk_tag_clouds(twitter_reduction.id, postgres_handle)
postgres_handle.connection.commit()
#coordinates = reduce_with_linloglayout(g, root_user)
coordinates = reduce_with_semi_intelligent_agents(g)
#id_communities
vertex_clustering = id_communities(g, coordinates)
#do this after community detection because it causes distortion
coordinates = reproject_to_spherical_mercator(coordinates)
#network_stats
network_stats = get_network_stats(network, g, vertex_clustering)
global_pagerank, community_pagerank, community_score = network_stats
hybrid_pagerank = calculate_hybrid_pagerank(global_pagerank, community_pagerank, community_score)
print "save reduction"
reduction = TwitterReduction.create_reduction(root_user.id, [0, 0, 0], False, postgres_handle)
postgres_handle.connection.commit()
print "save reduction users"
reduction_users = []
for i in range(len(member_ids)):
tru = TwitterReductionUser(postgres_handle=postgres_handle)
tru.reduction_id = reduction.id
tru.user_id = member_ids[i]
tru.coordinates = Point(coordinates[i][0], coordinates[i][1])
tru.pagerank = global_pagerank[i]
tru.hybrid_pagerank = hybrid_pagerank[i]
reduction_users.append(tru.save())
postgres_handle.connection.commit()
print "save communities"
from datetime import datetime
import smarttypes, sys, string
from smarttypes.config import *
from smarttypes.model.twitter_credentials import TwitterCredentials
from smarttypes.model.twitter_user import TwitterUser
from smarttypes.model.twitter_reduction import TwitterReduction
from smarttypes.utils.postgres_handle import PostgresHandle
postgres_handle = PostgresHandle(smarttypes.connection_string)
if __name__ == "__main__":
user_count_list = TwitterReduction.get_user_reduction_counts(postgres_handle)
for user, count in user_count_list:
if count == 1:
creds = TwitterCredentials.get_by_twitter_id(user.id, postgres_handle)
creds.maybe_send_initial_map_email()
def reduce_graph(screen_name, distance=20, min_followers=60):
postgres_handle = PostgresHandle(smarttypes.connection_string)
###########################################
##reduce
###########################################
root_user = TwitterUser.by_screen_name(screen_name, postgres_handle)
follower_followies_map = root_user.get_graph_info(
distance=distance, min_followers=min_followers)
gr = GraphReduce(screen_name, follower_followies_map)
gr.reduce_with_linloglayout()
###########################################
##save reduction in db
###########################################
root_user_id = root_user.id
user_ids = []
x_coordinates = []
y_coordinates = []
in_links = []
out_links = []
for i in range(len(gr.layout_ids)):
user_id = gr.layout_ids[i]
user_ids.append(user_id)
x_coordinates.append(gr.reduction[i][0])
y_coordinates.append(gr.reduction[i][1])
itr_in_links = PostgresHandle.spliter.join(gr.G.predecessors(user_id))
itr_out_links = PostgresHandle.spliter.join(gr.G.successors(user_id))
in_links.append(itr_in_links)
out_links.append(itr_out_links)
twitter_reduction = TwitterReduction.create_reduction(
root_user_id, user_ids, x_coordinates, y_coordinates, in_links,
out_links, postgres_handle)
postgres_handle.connection.commit()
###########################################
##save groups in db
###########################################
groups = []
for i in range(gr.n_groups):
user_ids = []
for j in range(len(gr.layout_ids)):
if i == gr.groups[j]:
user_ids.append(gr.layout_ids[j])
#run pagerank to get the scores
group_graph = networkx.DiGraph()
group_edges = []
for user_id in user_ids:
for following_id in set(user_ids).intersection(
follower_followies_map[user_id]):
group_edges.append((user_id, following_id))
print len(user_ids), len(group_edges)
if not group_edges:
continue
group_graph.add_edges_from(group_edges)
pagerank = networkx.pagerank(group_graph, max_iter=500)
scores = []
for user_id in user_ids:
scores.append(pagerank.get(user_id, 0))
groups.append(
TwitterGroup.create_group(twitter_reduction.id, i, user_ids,
scores, postgres_handle))
postgres_handle.connection.commit()
###########################################
##makes for quicker queries in some cases
###########################################
twitter_reduction.save_group_info(postgres_handle)
postgres_handle.connection.commit()
###########################################
##mk_tag_clouds
###########################################
TwitterGroup.mk_tag_clouds(twitter_reduction.id, postgres_handle)
postgres_handle.connection.commit()
if __name__ == "__main__":
postgres_handle = PostgresHandle(smarttypes.connection_string)
#get reduction_id
qry = """
select tr.id
from twitter_reduction tr
where tr.tiles_are_written_to_disk = False
order by tr.id desc limit 1;
"""
reduction_id = postgres_handle.execute_query(qry, {})[0]['id']
tile_dir = '../static/tiles/%s/' % reduction_id
if not os.path.isdir(tile_dir):
os.mkdir(tile_dir)
style_file = 'mapnik.xml'
min_zoom = 0
max_zoom = 5
bbox = (-180, -85.0511, 180, 85.0511)
render_tiles(bbox, style_file, tile_dir, min_zoom, max_zoom)
reduction = TwitterReduction.get_by_id(reduction_id, postgres_handle)
reduction.tiles_are_written_to_disk = True
reduction.save()
postgres_handle.connection.commit()
def get_latest_reduction(self):
from smarttypes.model.twitter_reduction import TwitterReduction
return TwitterReduction.get_latest_reduction(self.id,
self.postgres_handle)
def reduce_graph(screen_name,
distance=20,
min_followers=60,
pickle_it=True,
just_load_from_file=False):
postgres_handle = PostgresHandle(smarttypes.connection_string)
# if just_load_from_file:
# print "Loading data from a pickle."
# gr = GraphReduce(screen_name, {})
# f = open(gr.pickle_file_path)
# twitter_reduction, groups = pickle.load(f)
# twitter_reduction.id = None
# twitter_reduction.postgres_handle = postgres_handle
# twitter_reduction.save()
# postgres_handle.connection.commit()
# for group in groups:
# group.id = None
# group.reduction_id = twitter_reduction.id
# group.postgres_handle = postgres_handle
# group.save()
# postgres_handle.connection.commit()
# TwitterGroup.mk_tag_clouds(twitter_reduction.id, postgres_handle)
# postgres_handle.connection.commit()
# print "All done!"
# return 0
########################
##reduce
########################
root_user = TwitterUser.by_screen_name(screen_name, postgres_handle)
follower_followies_map = root_user.get_graph_info(
distance=distance, min_followers=min_followers)
gr = GraphReduce(screen_name, follower_followies_map)
#gr.reduce_with_exafmm()
gr.reduce_with_linloglayout()
########################
##save reduction in db
########################
root_user_id = root_user.id
user_ids = []
x_coordinates = []
y_coordinates = []
in_links = []
out_links = []
for i in range(len(gr.layout_ids)):
user_id = gr.layout_ids[i]
user_ids.append(user_id)
x_coordinates.append(gr.reduction[i][0])
y_coordinates.append(gr.reduction[i][1])
itr_in_links = PostgresHandle.spliter.join(gr.G.predecessors(user_id))
itr_out_links = PostgresHandle.spliter.join(gr.G.successors(user_id))
in_links.append(itr_in_links)
out_links.append(itr_out_links)
twitter_reduction = TwitterReduction.create_reduction(
root_user_id, user_ids, x_coordinates, y_coordinates, in_links,
out_links, postgres_handle)
postgres_handle.connection.commit()
########################
##save groups in db
########################
groups = []
for i in range(gr.n_clusters):
user_ids = []
for j in range(len(gr.layout_ids)):
if gr.layout_clusters[j][i] > 0:
user_ids.append(gr.layout_ids[j])
#run pagerank to get the scores
group_graph = networkx.DiGraph()
group_edges = []
for user_id in user_ids:
if user_id in follower_followies_map:
for following_id in set(user_ids).intersection(
follower_followies_map[user_id]):
group_edges.append((user_id, following_id))
print len(user_ids), len(group_edges)
if not group_edges:
continue
group_graph.add_edges_from(group_edges)
pagerank = networkx.pagerank(group_graph, max_iter=500)
scores = []
for user_id in user_ids:
scores.append(pagerank.get(user_id, 0))
groups.append(
TwitterGroup.create_group(twitter_reduction.id, i, user_ids,
scores, postgres_handle))
postgres_handle.connection.commit()
twitter_reduction.save_group_info(postgres_handle)
postgres_handle.connection.commit()
########################
##mk_tag_clouds
########################
TwitterGroup.mk_tag_clouds(twitter_reduction.id, postgres_handle)
postgres_handle.connection.commit()
#id_communities
vertex_clustering = id_communities(g, coordinates)
#do this after community detection because it causes distortion
coordinates = reproject_to_spherical_mercator(coordinates)
#network_stats
network_stats = get_network_stats(network, g, vertex_clustering)
global_pagerank, community_pagerank, community_score = network_stats
hybrid_pagerank = calculate_hybrid_pagerank(global_pagerank,
community_pagerank,
community_score)
print "save reduction"
reduction = TwitterReduction.create_reduction(root_user.id, [0, 0, 0],
False, postgres_handle)
postgres_handle.connection.commit()
print "save reduction users"
reduction_users = []
for i in range(len(member_ids)):
tru = TwitterReductionUser(postgres_handle=postgres_handle)
tru.reduction_id = reduction.id
tru.user_id = member_ids[i]
tru.coordinates = Point(coordinates[i][0], coordinates[i][1])
tru.pagerank = global_pagerank[i]
tru.hybrid_pagerank = hybrid_pagerank[i]
reduction_users.append(tru.save())
postgres_handle.connection.commit()
print "save communities"
def get_latest_reduction(self):
from smarttypes.model.twitter_reduction import TwitterReduction
return TwitterReduction.get_latest_reduction(self.id, self.postgres_handle)