def test_graph_vertex_add(self):
g = Graph()
v1 = Vertex(Point(1, 2))
v2 = Vertex(Point(2, 1))
g.add_vertex(v1)
g.add_vertex(v2)
g.add_edge(v1, v2)
g.add_edge(v2, v1)
self.assertEqual(len(g.edges), 1)
def post(self):
if(self.request.get('action') == 'save'):
routename = self.request.get('name')
routes = Route.gql("WHERE name = :1", routename).fetch(1)
if len(routes) > 0:
self.response.out.write('Route %s already exists.' % routename)
return
json_route = simplejson.loads(self.request.get('route'))
logging.info('JSON route = %s', json_route)
vertices = [latLng.split(',') for latLng in json_route]
route = Route()
route.name = routename
route.put()
logging.info('Inserted route with name %s and id %s', route.name, route.key())
for index in range(0, len(vertices)):
vertex = Vertex()
vertex.lat = float(str(vertices[index][0]))
vertex.lng = float(str(vertices[index][1]))
vertex.route = route
vertex.put()
logging.info('Inserted vertex %s, %s on route %s with id %s', vertex.lat, vertex.lng, vertex.route.name, vertex.key())
self.response.out.write('Success')
def parse(self, data):
"""Convert CSV topics into vertices and topics"""
vertex = Vertex.get_or_create(
name=data['institution'],
graph_id=self.graph.id)
for topic, keywords in data['topics']:
topic = Topic.get_or_create(name=topic)
tv = TopicVertex.get_or_create(
topic_id=topic.id, vertex_id=vertex.id)
for keyword in keywords:
kw = Keyword.get_or_create(name=keyword)
kt = KeywordTopic.get_or_create(
keyword_id=kw.id, topic_id=topic.id)
self.vertices.append(vertex)
def load(self, args):
"""Load all domains from scraper into new graph"""
domains = set(h.domain for h in HTML.query().all())
for domain in domains:
Vertex.get_or_create(domain=domain).save()
self.graph.vertices = Vertex.query().all()
def newVertex(self, vertexId):
self.listVertex.append(Vertex(vertexId))
def test_chain_method(self):
graph = OrientedGraph()
point = Point(4, 5)
v1 = Vertex(Point(4, 2))
v2 = Vertex(Point(2, 4))
v3 = Vertex(Point(6, 5))
v4 = Vertex(Point(5, 7))
e1 = OrientedEdge(v1, v2, 1)
e2 = OrientedEdge(v1, v3, 1)
e3 = OrientedEdge(v2, v3, 1)
e4 = OrientedEdge(v2, v4, 1)
e5 = OrientedEdge(v3, v4, 1)
graph.add_vertex(v1)
graph.add_vertex(v2)
graph.add_vertex(v3)
graph.add_vertex(v4)
graph.add_edge(v1, v2, 1)
graph.add_edge(v1, v3, 1)
graph.add_edge(v2, v3, 1)
graph.add_edge(v2, v4, 1)
graph.add_edge(v3, v4, 1)
ordered = [v1, v2, v3, v4]
weight_table = OrderedDict({
v1: {
"vin": [],
"vout": [e1, e2],
"win": 0,
"wout": 2
},
v2: {
"vin": [e1],
"vout": [e4, e3],
"win": 1,
"wout": 2
},
v3: {
"vin": [e3, e2],
"vout": [e5],
"win": 2,
"wout": 1
},
v4: {
"vin": [e4, e5],
"vout": [],
"win": 2,
"wout": 0
},
})
e1_balanced = copy.deepcopy(e1)
e1_balanced.weight = 2
e5_balanced = copy.deepcopy(e5)
e5_balanced.weight = 2
weight_table_balanced = {
v1: {
"vin": [],
"vout": [e1_balanced, e2],
"win": 0,
"wout": 3
},
v2: {
"vin": [e1_balanced],
"vout": [e4, e3],
"win": 2,
"wout": 2
},
v3: {
"vin": [e3, e2],
"vout": [e5_balanced],
"win": 2,
"wout": 2
},
v4: {
"vin": [e4, e5_balanced],
"vout": [],
"win": 3,
"wout": 0
},
}
e1_new = copy.deepcopy(e1)
e1_new.weight = 0
e2_new = copy.deepcopy(e2)
e2_new.weight = 0
e3_new = copy.deepcopy(e3)
e3_new.weight = 0
e4_new = copy.deepcopy(e4)
e4_new.weight = 0
e5_new = copy.deepcopy(e5)
e5_new.weight = 0
chains = [[e1_new, e4_new], [e1_new, e3_new, e5_new], [e2_new, e5_new]]
root = NodeWithParent(data=chains[1])
tree = ChainsBinTree(root)
tree.root.left = NodeWithParent(data=chains[0], parent=root)
tree.root.right = NodeWithParent(data=chains[2], parent=root)
point_between = (chains[0], chains[1])
ans = chain_method(graph, point)
self.assertEqual(ordered, next(ans))
self.assertEqual(weight_table, next(ans))
self.assertEqual(weight_table_balanced, next(ans))
self.assertEqual(chains, next(ans))
self.assertEqual(tree, next(ans))
self.assertEqual(point_between, next(ans))
def test_stripe(self):
p1 = Vertex(Point(7, 0))
p2 = Vertex(Point(2, 2.5))
p3 = Vertex(Point(12, 3))
p4 = Vertex(Point(8, 5))
p5 = Vertex(Point(0, 7))
p6 = Vertex(Point(13, 8))
p7 = Vertex(Point(6, 11))
g = Graph()
g.add_vertex(p1)
g.add_vertex(p2)
g.add_vertex(p3)
g.add_vertex(p4)
g.add_vertex(p5)
g.add_vertex(p6)
g.add_vertex(p7)
g.add_edge(p1, p2)
g.add_edge(p1, p3)
g.add_edge(p2, p3)
g.add_edge(p7, p6)
g.add_edge(p3, p6)
g.add_edge(p4, p6)
g.add_edge(p4, p5)
g.add_edge(p4, p7)
g.add_edge(p5, p7)
g.add_edge(p2, p5)
dot = Point(11.5, 5.5)
ans = list(stripe(g, dot))
self.assertEqual(
ans[0],
[
(-math.inf, 0.0),
(0.0, 2.5),
(2.5, 3.0),
(3.0, 5.0),
(5.0, 7.0),
(7.0, 8.0),
(8.0, 11.0),
(11.0, math.inf),
],
)
self.assertTrue(
TestAlgorithms.fragmentation_eq(
ans[1],
{
(-math.inf, 0.0): [],
(0.0, 2.5): [Edge(p1, p2), Edge(p1, p3)],
(2.5, 3.0): [Edge(p1, p3),
Edge(p2, p3),
Edge(p2, p5)],
(3.0, 5.0): [Edge(p2, p5), Edge(p3, p6)],
(5.0, 7.0): [
Edge(p2, p5),
Edge(p4, p5),
Edge(p4, p7),
Edge(p4, p6),
Edge(p3, p6),
],
(7.0, 8.0): [
Edge(p5, p7),
Edge(p4, p7),
Edge(p4, p6),
Edge(p3, p6),
],
(8.0, 11.0): [Edge(p5, p7),
Edge(p4, p7),
Edge(p7, p6)],
(11.0, math.inf): [],
},
))
self.assertEqual(ans[2], (5.0, 7.0))
self.assertEqual(ans[3], [Edge(p4, p6), Edge(p3, p6)])
