async def _add_edge(self, edge): """Convenience function for generating crud traversals.""" props = mapper.map_props_to_db(edge, edge.__mapping__) traversal = self._g.V(Binding('sid', edge.source.id)) traversal = traversal.addE(edge.__mapping__._label) traversal = traversal.to(__.V(Binding('tid', edge.target.id))) return await self._add_properties(traversal, props, edge)
async def test_unregistered_edge_desialization(self, app): session = await app.session() p1 = await session.g.addV('person').oneOrNone() p2 = await session.g.addV('person').oneOrNone() e1 = await session.g.V(Binding('p1_id', p1.id)).addE('unregistered').to( session.g.V(Binding('p2_id', p2.id))).property('how_long', 1).oneOrNone() assert isinstance(e1, element.GenericEdge) assert e1.how_long == 1 assert e1.__label__ == 'unregistered' await app.close()
async def test_edge_desialization(self, app, knows_class): session = await app.session() p1 = await session.g.addV('person').next() p2 = await session.g.addV('person').next() e1 = await session.g.V(Binding('p1_id', p1.id)).addE('knows').to( session.g.V(Binding('p2_id', p2.id))).property( knows_class.notes, 'somehow').property('how_long', 1).next() assert isinstance(e1, knows_class) assert e1.notes == 'somehow' assert e1.how_long == 1 await app.close()
async def test_remove_vertex(self, app, person): session = await app.session() person.name = 'dave' person.age = 35 await session.save(person) result = await session.g.V(Binding('vid', person.id)).oneOrNone() assert result is person rid = result.id await session.remove_vertex(person) result = await session.g.V(Binding('rid', rid)).oneOrNone() assert not result await app.close()
async def _update_vertex_properties(self, vertex, traversal, props): traversal, removals, metaprops = self._add_properties(traversal, props) for k in removals: await self._g.V(Binding('vid', vertex.id)).properties(k).drop().oneOrNone() result = await self._simple_traversal(traversal, vertex) if metaprops: removals = await self._add_metaprops(result, metaprops) for db_name, key, value in removals: await self._g.V(Binding('vid', vertex.id)).properties( db_name).has(key, value).drop().oneOrNone() traversal = self._g.V(Binding('vid', vertex.id)) result = await self._simple_traversal(traversal, vertex) return result
async def test_non_element_deserialization(self, app): session = await app.session() p1 = await session.g.addV('person').property( 'name', 'leif').oneOrNone() one = await session.g.V(Binding('p1_id', p1.id)).count().oneOrNone() assert one == 1 await app.close()
async def _update_edge_properties(self, edge, traversal, props): traversal, removals, _ = self._add_properties(traversal, props) eid = edge.id if isinstance(eid, dict): eid = Binding('eid', edge.id) for k in removals: await self._g.E(eid).properties(k).drop().oneOrNone() return await self._simple_traversal(traversal, edge)
async def test_property_deserialization(self, app): # In a future version this should deserialize to a goblin vert prop??? session = await app.session() p1 = await session.g.addV('person').property('name', 'leif').next() traversal = session.g.V(Binding('p1_id', p1.id)).properties('name') name = await traversal.next() assert name.value == 'leif' assert name.label == 'name' await app.close()
async def test_remove_edge(self, app, person_class, place_class, lives_in_class): session = await app.session() jon = person_class() jon.name = 'jonathan' jon.age = 38 montreal = place_class() montreal.name = 'Montreal' lives_in = lives_in_class(jon, montreal) session.add(jon, montreal, lives_in) await session.flush() result = await session.g.E(Binding('eid', lives_in.id)).next() assert result is lives_in rid = result.id await session.remove_edge(lives_in) result = await session.g.E(Binding('rid', rid)).next() assert not result await app.close()
async def test_remove_vertex_foreign_session(self, app, person): session1 = await app.session() session2 = await app.session() person.name = 'dave' person.age = 35 await session1.save(person) result = await session1.g.V(Binding('vid', person.id)).next() assert result is person rid = result.id await session2.remove_vertex(person) result = await session2.g.V(Binding('rid', rid)).next() assert not result result = await session1.g.V(Binding('vid', person.id)).next() assert result is None # This is why we warn assert rid in session1.current assert person is session1.current[rid] await app.close()
async def get_vertex(self, vertex): """ Get a vertex from the db. Vertex must have id. :param goblin.element.Vertex element: Vertex to be retrieved :returns: :py:class:`Vertex<goblin.element.Vertex>` | None """ return await self.g.V(Binding('vid', vertex.id)).next()
async def test_property_deserialization(self, app): session = await app.session() p1 = await session.g.addV('person').property( 'name', 'leif').oneOrNone() traversal = session.g.V(Binding('p1_id', p1.id)).properties('name') name = await traversal.oneOrNone() assert name['value'] == 'leif' assert name['label'] == 'name' await app.close()
async def _update_vertex(self, vertex): """ Update a vertex, generally to change/remove property values. :param goblin.element.Vertex vertex: Vertex to be updated :returns: :py:class:`Vertex<goblin.element.Vertex>` object """ props = mapper.map_props_to_db(vertex, vertex.__mapping__) traversal = self._g.V(Binding('vid', vertex.id)) return await self._update_vertex_properties(vertex, traversal, props)
async def _add_vertex(self, vertex): """Convenience function for generating crud traversals.""" props = mapper.map_props_to_db(vertex, vertex.__mapping__) traversal = self._g.addV(vertex.__mapping__.label) traversal, _, metaprops = self._add_properties(traversal, props) result = await self._simple_traversal(traversal, vertex) if metaprops: await self._add_metaprops(result, metaprops) traversal = self._g.V(Binding('vid', vertex.id)) result = await self._simple_traversal(traversal, vertex) return result
async def test_submit_traversal(remote_graph, remote_connection): g = remote_graph.traversal().withRemote(remote_connection) resp = g.addV('person').property('name', 'leifur').valueMap(True) leif = await resp.next() assert leif['name'][0] == 'leifur' assert leif[T.label] == 'person' resp = g.V(Binding('vid', leif[T.id])).drop() none = await resp.next() assert none is None await remote_connection.close()
async def remove_vertex(self, vertex): """ Remove a vertex from the db. :param goblin.element.Vertex vertex: Vertex to be removed """ traversal = self._g.V(Binding('vid', vertex.id)).drop() result = await self._simple_traversal(traversal, vertex) hashable_id = self._get_hashable_id(vertex.id) vertex = self.current.pop(hashable_id) del vertex return result
async def get_edge(self, edge): """ Get a edge from the db. Edge must have id. :param goblin.element.Edge element: Edge to be retrieved :returns: :py:class:`Edge<goblin.element.Edge>` | None """ eid = edge.id if isinstance(eid, dict): eid = Binding('eid', edge.id) return await self.g.E(eid).next()
async def _add_metaprops(self, result, metaprops): potential_removals = [] for metaprop in metaprops: db_name, (binding, value), metaprops = metaprop for key, val in metaprops.items(): if val: traversal = self._g.V(Binding('vid', result.id)).properties( db_name).hasValue(value).property(key, val) await traversal.oneOrNone() else: potential_removals.append((db_name, key, value)) return potential_removals
async def test_remove_edge_foreign_session(self, app, person_class, place_class, lives_in_class): session1 = await app.session() session2 = await app.session() jon = person_class() jon.name = 'jonathan' jon.age = 38 montreal = place_class() montreal.name = 'Montreal' lives_in = lives_in_class(jon, montreal) session1.add(jon, montreal, lives_in) await session1.flush() result = await session1.g.E(Binding('eid', lives_in.id)).next() assert result is lives_in rid = result.id await session2.remove_edge(lives_in) result = await session1.g.E(Binding('rid', rid)).next() assert not result # This is why whe warm assert rid in session1.current assert lives_in is session1.current[rid] await app.close()
async def _update_edge(self, edge): """ Update an edge, generally to change/remove property values. :param goblin.element.Edge edge: Edge to be updated :returns: :py:class:`Edge<goblin.element.Edge>` object """ props = mapper.map_props_to_db(edge, edge.__mapping__) eid = edge.id if isinstance(eid, dict): eid = Binding('eid', edge.id) traversal = self._g.E(eid) return await self._update_edge_properties(edge, traversal, props)
async def remove_edge(self, edge): """ Remove an edge from the db. :param goblin.element.Edge edge: Element to be removed """ eid = edge.id if isinstance(eid, dict): eid = Binding('eid', edge.id) traversal = self._g.E(eid).drop() result = await self._simple_traversal(traversal, edge) hashable_id = self._get_hashable_id(edge.id) edge = self.current.pop(hashable_id) del edge return result
async def test_submit_traversal(event_loop, remote_graph, aliases, gremlin_host, gremlin_port): cluster = await driver.Cluster.open( event_loop, aliases=aliases, hosts=[gremlin_host], port=gremlin_port, message_serializer=serializer.GraphSONMessageSerializer) client = await cluster.connect() g = remote_graph.traversal().withRemote(client) resp = g.addV('person').property('name', 'leifur') leif = await resp.next() resp.traversers.close() assert leif['properties']['name'][0]['value'] == 'leifur' assert leif['label'] == 'person' resp = g.V(Binding('vid', leif['id'])).drop() none = await resp.next() assert none is None await cluster.close()
async def remove_vertex(self, vertex): """ Remove a vertex from the db. :param goblin.element.Vertex vertex: Vertex to be removed """ traversal = self._g.V(Binding('vid', vertex.id)).drop() result = await self._simple_traversal(traversal, vertex) hashable_id = self._get_hashable_id(vertex.id) if hashable_id in self.current: vertex = self.current.pop(hashable_id) else: msg = 'Vertex {} does not belong to this session obj {}'.format( vertex, self) logger.warning(msg) del vertex return result
async def remove_edge(self, edge): """ Remove an edge from the db. :param goblin.element.Edge edge: Element to be removed """ eid = edge.id if isinstance(eid, dict): eid = Binding('eid', edge.id) traversal = self._g.E(eid).drop() result = await self._simple_traversal(traversal, edge) hashable_id = self._get_hashable_id(edge.id) if hashable_id in self.current: edge = self.current.pop(hashable_id) else: msg = 'Edge {} does not belong to this session obj {}'.format( edge, self) logger.warning(msg) del edge return result
def test_bytecode(self): g = traversal().withGraph(Graph()) bytecode = g.V().out("created").bytecode assert 0 == len(bytecode.bindings.keys()) assert 0 == len(bytecode.source_instructions) assert 2 == len(bytecode.step_instructions) assert "V" == bytecode.step_instructions[0][0] assert "out" == bytecode.step_instructions[1][0] assert "created" == bytecode.step_instructions[1][1] assert 1 == len(bytecode.step_instructions[0]) assert 2 == len(bytecode.step_instructions[1]) ## bytecode = g.withSack(1).E().groupCount().by("weight").bytecode assert 0 == len(bytecode.bindings.keys()) assert 1 == len(bytecode.source_instructions) assert "withSack" == bytecode.source_instructions[0][0] assert 1 == bytecode.source_instructions[0][1] assert 3 == len(bytecode.step_instructions) assert "E" == bytecode.step_instructions[0][0] assert "groupCount" == bytecode.step_instructions[1][0] assert "by" == bytecode.step_instructions[2][0] assert "weight" == bytecode.step_instructions[2][1] assert 1 == len(bytecode.step_instructions[0]) assert 1 == len(bytecode.step_instructions[1]) assert 2 == len(bytecode.step_instructions[2]) ## bytecode = g.V(Bindings.of('a', [1, 2, 3])) \ .out(Bindings.of('b', 'created')) \ .where(__.in_(Bindings.of('c', 'created'), Bindings.of('d', 'knows')) \ .count().is_(Bindings.of('e', P.gt(2)))).bytecode assert 5 == len(bytecode.bindings.keys()) assert [1, 2, 3] == bytecode.bindings['a'] assert 'created' == bytecode.bindings['b'] assert 'created' == bytecode.bindings['c'] assert 'knows' == bytecode.bindings['d'] assert P.gt(2) == bytecode.bindings['e'] assert Binding('b', 'created') == bytecode.step_instructions[1][1] assert 'binding[b=created]' == str(bytecode.step_instructions[1][1]) assert isinstance(hash(bytecode.step_instructions[1][1]), int)
def test_binding(self): x = Binding("name", "marko") output = self.graphbinary_reader.readObject( self.graphbinary_writer.writeObject(x)) assert x == output
async def _check_edge(self, edge): """Used to check for existence, does not update session edge""" eid = edge.id if isinstance(eid, dict): eid = Binding('eid', edge.id) return await self._g.E(eid).next()
async def _check_vertex(self, vertex): """Used to check for existence, does not update session vertex""" msg = await self._g.V(Binding('vid', vertex.id)).next() return msg
def objectify(cls, buff, reader, nullable=True): return cls.is_null(buff, reader, lambda b, r: Binding(r.toObject(b, DataType.string, False), reader.readObject(b)), nullable)