def setUp(self):
g = Graph()
n1 = Node()
n2 = Node()
n3 = Node()
n4 = Node()
g.add_edge(n1, n2)
g.add_edge(n2, n3)
g.add_edge(n3, n1)
g.add_edge(n3, n4)
self.g = g
def visitTwitterNode(self, node, *args):
print 'Visitando nodo twitter: id = %s, user = %s' % (node.num_id,
node.screen_name)
tw_local_graph = Graph()
friends = self.twitter_browser.friends(node)
for f in friends:
tw_local_graph.add_edge(node, f)
return tw_local_graph
def visitFacebookNode(self, node, *args):
print 'Visitando nodo facebook: id = %s, name = %s' % (node.id,
node.name)
fb_local_graph = Graph()
friends = self.facebook_browser.friends(node)
for f in friends:
print node, f
fb_local_graph.add_edge(node, f)
return fb_local_graph
def testTotalTrianglesWeight(self):
g = Graph()
g.add_edge(1, 2)
g.add_edge(2, 3)
g.add_edge(3, 1)
g.add_edge(5, 6)
g.add_edge(6, 7)
g.add_edge(7, 5)
g.create_index_triangles()
g.index_parameter_from_parameter('triangles', 'unseen_triangles')
self.assertEqual(g.total_triangles_weight(1), 2)
self.assertEqual(g.total_triangles_weight(2), 0)
self.assertEqual(g.total_unseen_triangles(), 2)
g.update_edge_weight(1, 2, 2)
self.assertEqual(g.total_triangles_weight(1), 1)
self.assertEqual(g.total_triangles_weight(2), 0)
g.update_edge_weight(2, 3, 2)
g.update_edge_weight(3, 1, 2)
self.assertEqual(g.total_triangles_weight(1), 1)
self.assertEqual(g.total_triangles_weight(2), 1)
class GraphTest(unittest.TestCase):
def setUp(self):
self.graph = Graph()
self.graph.debug = False
self.graph.input_debug_links = 1
self.graph.output_debug_nodes = 1
self.graph.load_edgelist(StringIO(example_txt), num=False)
def tearDown(self):
pass
# def testNodes(self):
# nodes = list(self.graph.nodes_iter())
# self.assertEqual( nodes, ['666', '1', '3', '2', '5', '4', '7', '6', '9', '8'])
#
#
# def testEdges(self):
# edges = list(self.graph.edges_iter())
# self.assertEqual( len(edges), 8)
#
#
# def testEdgesBunch(self):
# edges = list(self.graph.edges_iter(['1','4']))
# self.assertEqual( len(edges), 2)
#
#
# def testDegrees(self):
# self.assertEqual(list(self.graph.degrees()), [1, 1, 1, 1, 2, 1, 3, 1, 3, 2])
#
#
# def testDegreesPartial(self):
# self.assertEqual(list(self.graph.degrees(['2','3','4'])), [1, 1, 1])
#
#
# def testDegreesIter(self):
# self.assertEqual(list(self.graph.degrees_iter()), [1, 1, 1, 1, 2, 1, 3, 1, 3, 2])
#
#
# def testClustering(self):
# self.assertEqual(list(self.graph.clustering_indices()), [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.33333333333333331, 0.0, 0.33333333333333331, 1.0])
#
#
# def testKnn(self):
# self.assertEqual(list(self.graph.average_neighbor_degrees()), [3.0, 1.0, 2.0, 1.0, 1.0, 2.0, 2.0, 3.0, 2.0, 3.0])
#
#
# def testExcentricity(self):
# self.assertEqual(list(self.graph.eccentricities()), [3, 1, 2, 1, 1, 2, 2, 3, 2, 2])
#
#
# def testAveragePathLengths(self):
# self.assertEqual(list(self.graph.average_path_lengths()), [1.6000000000000001, 0.5, 1.0, 0.5, 0.66666666666666663, 1.0, 1.0, 1.6000000000000001, 1.0, 1.2])
#
#
# def testKcoreness(self):
# self.assertEqual(list(self.graph.kcoreness()), [1, 1, 1, 1, 1, 1, 2, 1, 2, 2])
#
#
# def testKcorenessPartial(self):
# self.assertEqual(list(self.graph.kcoreness(['3', '4', '5'])), [1, 1, 1])
#
#
# def testKcorenessIterPartial(self):
# self.assertEqual(list(self.graph.kcoreness_iter(['3', '4', '5'])), [1, 1, 1])
#
#
# def testRandomEdges(self):
# random.seed(666)
# self.assertEqual(self.graph.random_edges(2, False), [('666', '9'), ('3', '5')])
#
#
# def testRandomNodes(self):
# random.seed(666)
# self.assertEqual(self.graph.random_nodes(3, False), ['4', '2', '666'])
#
#
# def testShow(self):
## self.graph = Graph()
## self.graph.debug = False
## self.graph.input_debug_links = 1
## self.graph.output_debug_nodes = 1
## self.graph.load_edgelist(StringIO(top_edges), num=False)
## self.graph.show()
# pass
#
# def testDegreeEncodedGraph(self):
#
# self.assertEqual(self.graph.compressed_by_degree_graph().nodes(), ['!', '"', '%', '$', "'", '&', ')', '(', '+', '*'])
# self.assertEqual(self.graph.compressed_by_degree_graph().degrees(), [3, 3, 2, 2, 1, 1, 1, 1, 1, 1])
#
#
# def testSaveEncoded1(self):
# enc_g = self.graph.compressed_by_degree_graph(False)
# io = StringIO()
# enc_g.save_edgelist(io)
# self.assertEqual( io.getvalue().split('\n')[2:], ['# ', '0 9', '0 2', '0 1', '1 2', '1 4', '3 5', '3 7', '6 8', ''])
#
#
# def testSaveEncoded2(self):
# enc_g = self.graph.compressed_by_degree_graph()
# io = StringIO()
# enc_g.save_edgelist(io)
# self.assertEqual( io.getvalue().split('\n')[2:], ['# ', '! +', '! "', '! $', '" $', '" &', '% )', "% '", '( *', ''])
# def testTotalTriangles(self):
#
# self.assertEqual(self.graph.total_triangles(), 1)
# self.assertEqual(self.graph.total_triangles_weight(1), 1)
# self.assertEqual(self.graph.total_triangles_weight(2), 0)
#
# self.graph.add_edge(1234000, 1234001)
# self.graph.add_edge(1234001, 1234002)
# self.graph.add_edge(1234002, 1234000)
#
# self.graph.add_edge(1234000, 1234001)
# self.graph.add_edge(1234001, 1234003)
# self.graph.add_edge(1234003, 1234000)
#
# self.assertEqual(self.graph.total_triangles(), 3)
# self.assertEqual(self.graph.total_triangles_weight(1), 3)
# self.assertEqual(self.graph.total_triangles_weight(2), 0)
#
# self.assertEqual(self.graph.triangles_weight(1234000, 1), 2)
# self.assertEqual(self.graph.triangles_weight(1234000, 2), 0)
# self.assertEqual(self.graph.triangles_weight(6756443, 1), 0)
# self.assertEqual(self.graph.triangles_weight(6756443, 2), 0)
#
# self.graph.update_edge_weight(1234000, 1234001, 2)
# self.graph.update_edge_weight(1234001, 1234003, 2)
# self.graph.update_edge_weight(1234003, 1234000, 2)
#
# self.assertEqual(self.graph.total_triangles(), 3)
# self.assertEqual(self.graph.total_triangles_weight(1), 1)
# self.assertEqual(self.graph.total_triangles_weight(2), 1)
#
# self.assertEqual(self.graph.triangles_weight(1234000, 1), 0)
# self.assertEqual(self.graph.triangles_weight(1234000, 2), 1)
# self.assertEqual(self.graph.triangles_weight(6756443, 1), 0)
# self.assertEqual(self.graph.triangles_weight(6756443, 2), 0)
#
# self.graph.update_edge_weight(1234000, 1234001, 2)
# self.graph.update_edge_weight(1234001, 1234002, 2)
# self.graph.update_edge_weight(1234002, 1234000, 2)
#
# self.assertEqual(self.graph.total_triangles(), 3)
# self.assertEqual(self.graph.total_triangles_weight(1), 1)
# self.assertEqual(self.graph.total_triangles_weight(2), 2)
#
# self.assertEqual(self.graph.triangles_weight(1234000, 1), 0)
# self.assertEqual(self.graph.triangles_weight(1234000, 2), 2)
# self.assertEqual(self.graph.triangles_weight(6756443, 1), 0)
# self.assertEqual(self.graph.triangles_weight(6756443, 2), 0)
def testTotalTriangles(self):
self.graph = Graph()
self.graph.add_edge(1234000, 1234001)
self.graph.add_edge(1234001, 1234002)
self.graph.add_edge(1234002, 1234000)
self.graph.add_edge(1234000, 1234001)
self.graph.add_edge(1234001, 1234003)
self.graph.add_edge(1234003, 1234000)
self.graph.create_index_triangles()
self.assertEqual(self.graph.get_parameter_cache('triangles', 1234000),
2)
self.assertEqual(self.graph.get_parameter_cache('triangles', 1234001),
2)
self.assertEqual(self.graph.get_parameter_cache('triangles', 1234002),
1)
self.assertEqual(self.graph.get_parameter_cache('triangles', 1234003),
1)
print
for node, value in self.graph.get_parameter_cache_iter('triangles'):
print node, value
self.assertEqual(self.graph.total_triangles(), 2)
self.assertEqual(self.graph.total_triangles_weight(1), 2)
self.assertEqual(self.graph.total_triangles_weight(2), 0)
self.assertEqual(self.graph.triangles_weight(1234000, 1), 2)
self.assertEqual(self.graph.triangles_weight(1234000, 2), 0)
self.assertEqual(self.graph.triangles_weight(6756443, 1), 0)
self.assertEqual(self.graph.triangles_weight(6756443, 2), 0)
def testTotalTrianglesWeight(self):
g = Graph()
g.add_edge(1, 2)
g.add_edge(2, 3)
g.add_edge(3, 1)
g.add_edge(5, 6)
g.add_edge(6, 7)
g.add_edge(7, 5)
g.create_index_triangles()
g.index_parameter_from_parameter('triangles', 'unseen_triangles')
self.assertEqual(g.total_triangles_weight(1), 2)
self.assertEqual(g.total_triangles_weight(2), 0)
self.assertEqual(g.total_unseen_triangles(), 2)
g.update_edge_weight(1, 2, 2)
self.assertEqual(g.total_triangles_weight(1), 1)
self.assertEqual(g.total_triangles_weight(2), 0)
g.update_edge_weight(2, 3, 2)
g.update_edge_weight(3, 1, 2)
self.assertEqual(g.total_triangles_weight(1), 1)
self.assertEqual(g.total_triangles_weight(2), 1)
class LinkPrivacyModel(object):
'''
A class to simulate link privacy attacks on network with limited node visibility.
'''
def __init__(self, graph, lookahead, debug=False):
'''
graph: graph where the attack is made.
lookahead: visibility of the nodes in the graph.
'''
self.debug = debug
self.graph = graph
self.lookahead = lookahead + 1
if self.debug:
print 'INFO: Initializing LinkPrivacyModel...'
self.rogues = set([]) # remember extra rogues nodes added
self.false_links_graph = Graph() # remember false links added
self.visible_graph = Graph() # infiltrated subgraph
self.unseen_graph = copy.deepcopy(graph) # uninfiltrated subgraph
self.rogue_effort = 0 # cost in new nodes created
self.bribe_effort = 0 # cost in existing nodes bribed
self.false_link_effort = 0 # cost in new links created
self.cache_korolova_coverage = set([])
self.cached_sorted_degrees_dec = None
def add_rogue_node(self, r_node):
if self.debug:
print 'INFO: add_rogue_node --> %s ...' % str(r_node)
if r_node in self.graph.nodes():
raise LinkPrivacyModelException(
'new rogue node "%s" already in friend graph!' % str(r_node))
if r_node in self.rogues:
raise LinkPrivacyModelException(
'new node "%s" already in rogue node set!' % str(r_node))
self.rogues.add(r_node)
self.graph.add_node(r_node)
self.visible_graph.add_node(r_node)
self.rogue_effort += 1
def add_bribed_node(self, r_node):
if self.debug:
print 'INFO: add_bribed_node --> %s ...' % str(r_node)
if not r_node in self.graph.nodes():
raise LinkPrivacyModelException(
'new bribed node "%s" NOT in friend graph!' % str(r_node))
self.visible_graph.add_node(r_node)
edges = self.graph.lookahead_edges([r_node], self.lookahead)
self.visible_graph.add_edges_from(edges)
self.unseen_graph.remove_edges_from(edges)
nodes_in_new_visible_edges = list(
set([n for n, _ in edges] + [n2 for _, n2 in edges]))
for node in nodes_in_new_visible_edges:
# if self.unseen_graph.has_node(node) and self.unseen_graph.degree(node) == 0:
# self.unseen_graph.remove_node(node)
if self.visible_graph.degree(node) == self.graph.degree(node):
self.cache_korolova_coverage.add(node)
self.bribe_effort += 1
# self.cache_korolova_coverage.add( r_node )
# for neigh in self.graph.neighbors(r_node):
# if self.visible_graph.degree(neigh) == self.graph.degree(neigh):
# self.cache_korolova_coverage.add( neigh )
def add_false_link(self, src, dst):
if not src in self.graph.nodes():
raise LinkPrivacyModelException(
'new false link source node "%s" NOT in rogues or friend graph!'
% str(src))
if not dst in self.graph.nodes():
raise LinkPrivacyModelException(
'new false link destination node "%s" NOT in rogues or friend graph!'
% str(dst))
self.false_links_graph.add_edge(src, dst)
self.graph.add_edge(src, dst)
if self.visible_graph.has_node(src):
self.visible_graph.add_edges_from(
self.graph.lookahead_edges([src], self.lookahead))
if self.visible_graph.has_node(dst):
self.visible_graph.add_edges_from(
self.graph.lookahead_edges([dst], self.lookahead))
self.false_link_effort += 1
def link_coverage(self):
numerator = float(self.visible_graph.number_of_edges() -
self.false_links_graph.number_of_edges())
denominator = float(self.graph.number_of_edges() -
self.false_links_graph.number_of_edges())
return numerator / denominator
def node_coverage(self):
numerator = float(self.visible_graph.number_of_nodes() -
len(self.rogues))
denominator = float(self.graph.number_of_nodes() - len(self.rogues))
return numerator / denominator
def korolova_node_coverage(self):
#numerator = 0
#for node in self.visible_graph.nodes_iter():
# if self.graph.degree(node) == self.visible_graph.degree(node):
# numerator += 1
numerator = len(self.cache_korolova_coverage)
denominator = float(self.graph.number_of_nodes() - len(self.rogues))
return numerator / denominator
def total_effort(self):
return self.rogue_effort + self.bribe_effort + self.false_link_effort
def max_unseen_degree_node(self):
unseen_nodes_degrees = zip(self.unseen_graph.nodes(),
self.unseen_graph.degrees())
# in reverse order
unseen_nodes_degrees.sort(lambda x, y: -cmp(x[1], y[1]))
return unseen_nodes_degrees[0][0]
def max_unseen_degree_crawler_node(self):
if self.debug:
print 'INFO: max_unseen_degree_crawler_node ...'
unseen_nodes_degrees = zip(self.unseen_graph.nodes(),
self.unseen_graph.degrees())
# in reverse order
unseen_nodes_degrees.sort(lambda x, y: -cmp(x[1], y[1]))
visible_node_with_max_unseen_degree = None
for node, _ in unseen_nodes_degrees:
if node in self.visible_graph.nodes():
visible_node_with_max_unseen_degree = node
break
return visible_node_with_max_unseen_degree
def sorted_degrees_dec(self):
if self.debug:
print 'INFO: sorted_degrees_dec ...'
if not self.cached_sorted_degrees_dec:
degrees = zip(self.graph.nodes(), self.graph.degree())
degrees.sort(lambda x, y: cmp(x[1], y[1]))
degrees.reverse()
self.cached_sorted_degrees_dec = [x for x, _ in degrees]
return self.cached_sorted_degrees_dec
def sorted_degrees_dec_iter(self):
return iter(self.sorted_degrees_dec())
def random_node_order(self):
if self.debug:
print 'INFO: random_node_order ...'
return self.graph.random_nodes(self.graph.number_of_nodes())
def random_node_order_iter(self):
return iter(self.random_node_order())
def random_node(self):
return self.graph.random_nodes(1)[0]
class GraphTest3(unittest.TestCase):
def setUp(self):
self.graph = Graph()
self.graph.debug = False
self.graph.max_links_input = 50000
self.graph.input_debug_links = 200000
self.graph.output_debug_nodes = 10000
use_big_alphabet = False
has_num = False
self.graph.load_compressed_graph(cloudlight.tests.data_enc1, use_big_alphabet, has_num)
def tearDown(self):
pass
def testNodes(self):
self.assertEqual( self.graph.number_of_nodes(), 43948 )
def testEdges(self):
self.assertEqual( self.graph.number_of_edges(), 50000 )
def testDegreesPartial(self):
self.assertEqual(list(self.graph.degrees_iter(['2','3','4'])), [606, 595, 551])
def testClustering(self):
self.assertEqual(list(self.graph.clustering_indices_iter(['2','274','1174','278'])), [0.0, 0.025062656641604009, 0.33333333333333331, 0.024025974025974027])
def testKnn(self):
self.assertEqual(list(self.graph.average_neighbor_degrees_iter(['2','274','1174','278'])), [1.2854785478547854, 4.5087719298245617, 329.33333333333331, 6.3214285714285712])
def testKcorenessIterPartial1(self):
self.assertEqual(list(self.graph.kcoreness_iter(['2','274','1174','278'])), [4, 3, 3, 3])
def testKcorenessIterPartial2(self):
self.assertEqual(list(self.graph.kcoreness_iter(['3', '4', '5'])), [5, 4, 4])
def testTriangles(self):
self.graph.add_edge('2','1234000')
self.graph.add_edge('1234000', '1234001')
self.graph.add_edge('1234001', '2')
self.graph.add_edge('2','1')
self.graph.add_edge('1', '1234001')
self.graph.add_edge('1234001', '2')
self.graph.add_edge('2','1234003')
self.graph.add_edge('1234003', '1234004')
self.graph.add_edge('1234004', '2')
self.assertEqual(list(self.graph.triangles_iter(['2','3', '4'])), [3, 0, 25])
