def tearDown(self): """Get rid of the database again after each test.""" if self.rpc_client: self.rpc_client.transport.close() self.http_server.stop() self.http_server = None caliope_server.app = Flask('caliope_server') #:Delete database neo4j.GraphDatabaseService().clear()
def test_can_set_properties_on_node_in_same_batch(): graph_db = neo4j.GraphDatabaseService() batch = neo4j.WriteBatch(graph_db) alice = batch.create({}) batch.set_properties(alice, {"name": "Alice", "age": 34}) results = batch.submit() alice = results[batch.find(alice)] assert alice["name"] == "Alice" assert alice["age"] == 34
def test_can_cast_rel(): graph_db = neo4j.GraphDatabaseService() a, b, ab = graph_db.create({}, {}, (0, "KNOWS", 1)) casted = rel(ab) assert isinstance(casted, neo4j.Relationship) assert not casted.is_abstract assert casted.start_node == a assert casted.type == "KNOWS" assert casted.end_node == b
def test_can_delete_properties_on_node_in_same_batch(): graph_db = neo4j.GraphDatabaseService() batch = neo4j.WriteBatch(graph_db) alice = batch.create({"name": "Alice", "age": 34}) batch.delete_properties(alice) results = batch.submit() alice = results[batch.find(alice)] props = alice.get_properties() assert props == {}
def dbsetup(readonly=False): 'Set up our connection to Neo4j' ourstore = Store(neo4j.GraphDatabaseService(), uniqueindexmap={}, classkeymap={}) CMAinit(None, readonly=readonly, use_network=False) for classname in GraphNode.classmap: GraphNode.initclasstypeobj(ourstore, classname) return ourstore
def test_can_insert_subgraph_from_geoff_file(): graph_db = neo4j.GraphDatabaseService() planets = geoff.Subgraph.load(PLANETS_GEOFF) assert len(planets.nodes) == 25 assert len(planets.relationships) == 24 assert len(planets.index_entries) == 0 out = planets.insert_into(graph_db) assert len(out) == 25 assert all(isinstance(node, neo4j.Node) for node in out.values())
def test_can_insert_single_node(): graph_db = neo4j.GraphDatabaseService() source = '(a {"name": "Alice"})' subgraph = geoff.Subgraph(source) out = subgraph.insert_into(graph_db) assert isinstance(out["a"], neo4j.Node) assert out["a"].get_properties() == {"name": "Alice"} matches = list(out["a"].match_outgoing()) assert len(matches) == 0
def test_can_set_labels_on_preexisting_node(): graph_db = neo4j.GraphDatabaseService() if not graph_db.supports_node_labels: return alice, = graph_db.create({"name": "Alice"}) alice.add_labels("human", "female") batch = neo4j.WriteBatch(graph_db) batch.set_labels(alice, "mystery", "badger") batch.run() assert alice.get_labels() == {"mystery", "badger"}
def update_info(user, path): tag = genId() id1 = genId() id2 = genId() id3 = genId() g = neo4j.GraphDatabaseService() s = "CREATE (p:Photo {path:" "'" + path + "'" ",tag:" "'" + tag + "'" ",id1:" "'" + id1 + "'" ",id2:" "'" + id2 + "'" ",id3:" "'" + id3 + "'" "})" cypher.execute(g, s) t = "MATCH (n),(p) WHERE n.name= " "'" + user + "'" " AND p.path= " "'" + path + "'" " CREATE (n)-[:UPLOADS]->(p)" cypher.execute(g, t)
def test_can_use_return_values_as_references(): batch = neo4j.WriteBatch(neo4j.GraphDatabaseService()) a = batch.create(node(name="Alice")) b = batch.create(node(name="Bob")) batch.create(rel(a, "KNOWS", b)) results = batch.submit() ab = results[2] assert isinstance(ab, neo4j.Relationship) assert ab.start_node["name"] == "Alice" assert ab.end_node["name"] == "Bob"
def test_can_create_path_with_new_nodes(): graph_db = neo4j.GraphDatabaseService() batch = neo4j.WriteBatch(graph_db) batch.create_path({"name": "Alice"}, "KNOWS", {"name": "Bob"}) results = batch.submit() path = results[0] assert len(path) == 1 assert path.nodes[0]["name"] == "Alice" assert path.relationships[0].type == "KNOWS" assert path.nodes[1]["name"] == "Bob"
def test_many_queries(): graph_db = neo4j.GraphDatabaseService() node, = graph_db.create({}) query = "START z=node({0}) RETURN z".format(node._id) for i in range(40): with neo4j.CypherQuery(graph_db, query).execute() as records: for record in records: assert record.columns == ("z", ) assert record.values == (node, ) graph_db.delete(node)
def get_all_relationships(): # returns ALL of the possible relationship types in the graph graph_db = neo4j.GraphDatabaseService(NEO4J_SERVER_ADDRESS) # get the relationship types from the database s = [str(x) for x in graph_db.relationship_types] # sort them alphabetically s.sort() # maybe not necessary? graph_db = None return s
def test_cannot_add_labels_to_abstract_nodes(): graph_db = neo4j.GraphDatabaseService() if not graph_db.supports_node_labels: return alice = node(name="Alice") try: alice.add_labels("human", "female") except TypeError: assert True else: assert False
def test_can_insert_subgraph_from_xml_file(): graph_db = neo4j.GraphDatabaseService() planets = geoff.Subgraph.load_xml(PLANETS_XML) if sys.version_info >= (2, 7): assert planets.source == PLANETS_GEOFF.getvalue() assert len(planets.nodes) == 25 assert len(planets.relationships) == 24 assert len(planets.index_entries) == 0 out = planets.insert_into(graph_db) assert len(out) == 25 assert all(isinstance(node, neo4j.Node) for node in out.values())
def hello_cypher(): graph_db = neo4j.GraphDatabaseService() query_str = """\ match (n:User)-[:FOLLOWS]->(m:User) where n.screenName = {screenName} return m.screenName as friend order by friend """ query = neo4j.CypherQuery(graph_db, query_str) results = query.execute(screenName="wefreema") return [result.friend for result in results]
def login(): form = LoginForm() global db_client app.graph_db = neo4j.GraphDatabaseService("http://localhost:7474/db/data/") user_data, user_metadata = cypher.execute(app.graph_db, "MATCH (n:USER {{ id : {0}}}) RETURN (n)".format(int(form.id.data))) if user_data[0][0]['id']: session['user'] = int(form.id.data) return redirect('/') else: return redirect('/')
def like_connection(id, user, remove=False): """ Find the restaurant node from 'id' and find user node from 'user' and create the new relationship """ graph_db = neo4j.GraphDatabaseService() restaurant = graph_db.find("Restaurant", "_id", id).next() user_node = get_current_user_node(user, graph_db) path = user_node.get_or_create_path("LIKES", restaurant) if remove: path.relationships[0].delete()
def test_can_get_or_create_path_with_existing_nodes(): graph_db = neo4j.GraphDatabaseService() alice, bob = graph_db.create({"name": "Alice"}, {"name": "Bob"}) batch = neo4j.WriteBatch(graph_db) batch.get_or_create_path(alice, "KNOWS", bob) results = batch.submit() path = results[0] assert len(path) == 1 assert path.nodes[0] == alice assert path.relationships[0].type == "KNOWS" assert path.nodes[1] == bob
def new_session(self): try: self.session = neo4j.GraphDatabaseService(self.url) except SocketError as e: raise SocketError("Error connecting to {0} - {1}".format(self.url, e)) if self.session.neo4j_version < (2, 0): raise Exception("Support for neo4j versions prior to 2.0 are " + "supported by the 0.x.x series releases of neomodel") if hasattr(self, 'tx_session'): delattr(self, 'tx_session')
def test_can_merge_simple_graph(): graph_db = neo4j.GraphDatabaseService() source = '(a {"name": "Alice"}) (b {"name": "Bob"}) (a)-[:KNOWS]->(b)' subgraph = geoff.Subgraph(source) out = subgraph.merge_into(graph_db) assert isinstance(out["a"], neo4j.Node) assert isinstance(out["b"], neo4j.Node) assert out["a"].get_properties() == {"name": "Alice"} assert out["b"].get_properties() == {"name": "Bob"} matches = list(out["a"].match_outgoing(end_node=out["b"])) assert len(matches) == 1 assert matches[0].type == "KNOWS"
def createMatrix(): g = neo4j.GraphDatabaseService() s = "MATCH (a)-[k:KNOWS]-(b) RETURN a.name,k.heavy,b.name" gr = nx.Graph() b = cypher.execute(g, s)[0] for i in b: if i[1] == None: gr.add_edge(str(i[0]), str(i[2]), weight=0) else: gr.add_edge(str(i[0]), str(i[2]), weight=float(i[1])) a = nx.to_numpy_matrix(gr) return a
def test_can_set_labels_on_node(): graph_db = neo4j.GraphDatabaseService() if not graph_db.supports_node_labels: return alice, = graph_db.create(node(name="Alice")) alice.add_labels("human", "female") labels = alice.get_labels() assert len(labels) == 2 assert labels == set(["human", "female"]) alice.set_labels("mystery", "badger") labels = alice.get_labels() assert labels == set(["mystery", "badger"]) assert labels != set(["human", "female"])
def test_can_query_node_index(): graph_db = neo4j.GraphDatabaseService() graph_db.clear() people = graph_db.get_or_create_index(neo4j.Node, "people") a = people.create("name", "Alice", {"name": "Alice"}) b = people.create("name", "Bob", {"name": "Bob"}) c = people.create("name", "Carol", {"name": "Carol"}) d = people.create("name", "Dave", {"name": "Dave"}) e = people.create("name", "Eve", {"name": "Eve"}) f = people.create("name", "Frank", {"name": "Frank"}) for person in people.query("name:*a*"): print(person) assert person in (c, d, f)
def func(tag, user, rate): g = neo4j.GraphDatabaseService() a = check_rate.func(tag) if user in a: print "Already Rated" exit() s = "MATCH (n),(b:People) WHERE n.tag= " "'" + tag + "'" " AND b.name= " "'" + user + "'" " CREATE (b)-[:RATES {rate:" + str( rate) + "}]->(n)" if (cypher.execute(g, s)): a = check_rate.func(tag) print str(len(a)) else: print "No"
def main(graph_db): ''' spouštím funkci main() ''' graph_db = neo4j.GraphDatabaseService(neo4j.DEFAULT_URI) print(graph_db.neo4j_version) graph_db.clear() # create a single node alice, = graph_db.create({"name": "Alice"}) print(alice)
def test_can_create_path(self): graph_db = neo4j.GraphDatabaseService() path = neo4j.Path({"name": "Alice"}, "KNOWS", {"name": "Bob"}) assert path.nodes[0] == {"name": "Alice"} assert path._relationships[0]._type == "KNOWS" assert path.nodes[1] == {"name": "Bob"} path = path.create(graph_db) assert isinstance(path.nodes[0], neo4j.Node) assert path.nodes[0]["name"] == "Alice" assert isinstance(path.relationships[0], neo4j.Relationship) assert path._relationships[0]._type == "KNOWS" assert isinstance(path.nodes[1], neo4j.Node) assert path.nodes[1]["name"] == "Bob"
def _send_big_batch(self, node_count): graph_db = neo4j.GraphDatabaseService() graph_db.clear() print("creating batch of " + str(node_count)) batch = neo4j.WriteBatch(graph_db) for i in range(node_count): batch.create_node({"number": i}) print("submitting batch") nodes = batch.submit() print("checking batch") for node in nodes: assert isinstance(node, neo4j.Node) print("done")
def numberOfEdges(a): g = neo4j.GraphDatabaseService() for i in a: s = "MATCH (a)<-[w:WRITES|UPLOADS]-(n)-[k:KNOWS]-(b) WHERE a.tag= " "'" + i + "'" " RETURN n.name,k.bond,b.name" b = cypher.execute(g, s)[0] for j in b: l = len(b) h = j[1] / float(l) t = "MATCH (a)-[k:KNOWS]-(b) WHERE a.name= " "'" + j[ 0] + "'" " AND b.name= " "'" + j[ 2] + "'" " SET k.heavy=" "'" + str(h) + "'" cypher.execute(g, t) print j
def returnCommitInformation(project, commit): try: gdb = neo4j.GraphDatabaseService(settings.NEO4J_SERVER) except socket.error: print "Unable to connect to Neo4j: ", settings.NEO4J_SERVER return None q = "START a=node(*) where has(a.hash) return max(a.total_delta) as maximum;" result = neo4j.CypherQuery(gdb, q) #TODO: switch this so it's only a single return (so we don't have to go through the for loop) for r in result.stream(): maximum = r['maximum'] commit_info = None q = "START a=node(*) match a-[:impact]->() where a.hash = '"+commit+"' return distinct a;" result = neo4j.CypherQuery(gdb, q) for r in result.stream(): #TODO: switch this so it's only a single return (so we don't have to go through the for loop) converted_date = time.strftime('%Y/%m/%d', time.localtime(int(r.a['date']))) if r.a['total_delta'] == 0: impact_msg = "No technical change" elif r.a['total_delta'] < (maximum * 0.25): impact_msg = "Minimal technical change" elif r.a['total_delta'] < (maximum * 0.5): impact_msg = "Low technical change" elif r.a['total_delta'] < (maximum * 0.75): impact_msg = "Moderate technical change" else: impact_msg = "Substantial technical change." commit_info = CodeImpact(commit_hash=r.a['hash'], date=converted_date, delta_impact=round(r.a['total_delta'], 3), delta_impact_msg=impact_msg, logmsg=r.a['logmsg'], author_developer=r.a['author_developer'], author_email=r.a['author_email']) #if we don't have an :impact edge, we still need to populate the commit_info variable if not commit_info: q = "START a=node(*) where a.hash = '"+commit+"' return a;" result = neo4j.CypherQuery(gdb, q) for res in result.stream(): #TODO: switch this so it's only a single return (so we don't have to go through the for loop) converted_date = time.strftime('%Y/%m/%d', time.localtime(int(res.a['date']))) commit_info = CodeImpact(commit_hash=res.a['hash'], date=converted_date, delta_impact=0, delta_impact_msg="No technical change", logmsg=res.a['logmsg'], author_developer=res.a['author_developer'], author_email=res.a['author_email']) code_impact = [] q = "START a=node(*) match a-[r:impact]->b where a.hash = '"+commit+"' optional match b<-[:has]-c return r, b, c order by r.impactvalue desc limit 10;" result = neo4j.CypherQuery(gdb, q) for r in result.stream(): if r.c is not None: code_impact.append(CodeImpactFiles(code_impact=round(r.r['impactvalue'], 3), filename=r.b['filename'], function=r.b['function'], functionfilename=r.c['filename'])) else: code_impact.append(CodeImpactFiles(code_impact=round(r.r['impactvalue'], 3), filename=r.b['filename'], function=r.b['function'], functionfilename=None)) return commit_info, code_impact