def deserialize_message(cls, message):
if isinstance(message, dict):
if message.get('@type', '') == 'g:Traverser':
obj = GraphSONReader._objectify(message)
else:
obj = Traverser(message.get('@value', message))
else:
obj = Traverser(message)
return obj
async def _deserialize_result(self, result):
if isinstance(result, Traverser):
bulk = result.bulk
obj = result.object
if isinstance(obj, (Vertex, Edge)):
hashable_id = self._get_hashable_id(obj.id)
current = self.current.get(hashable_id, None)
if isinstance(obj, Vertex):
# why doesn't this come in on the vertex?
label = await self._g.V(obj.id).label().next()
if not current:
current = self.app.vertices.get(label, GenericVertex)()
props = await self._get_vertex_properties(obj.id, label)
if isinstance(obj, Edge):
props = await self._g.E(obj.id).valueMap(True).next()
if not current:
current = self.app.edges.get(
props.get(T.label), GenericEdge)()
current.source = GenericVertex()
current.target = GenericVertex()
element = current.__mapping__.mapper_func(obj, props, current)
self.current[hashable_id] = element
return Traverser(element, bulk)
else:
return result
# Recursive serialization is broken in goblin
elif isinstance(result, dict):
for key in result:
result[key] = self._deserialize_result(result[key])
return result
elif isinstance(result, list):
return [self._deserialize_result(item) for item in result]
else:
return result
def test_traversals(self):
statics.load_statics(globals())
connection = DriverRemoteConnection('ws://localhost:8182/gremlin', 'g')
assert "remoteconnection[ws://localhost:8182/gremlin,g]" == str(
connection)
#
g = Graph().traversal().withRemote(connection)
#
assert 6L == g.V().count().toList()[0]
#
assert Vertex(1) == g.V(1).next()
assert 1 == g.V(1).id().next()
assert Traverser(Vertex(1)) == g.V(1).nextTraverser()
assert 1 == len(g.V(1).toList())
assert isinstance(g.V(1).toList(), list)
#
results = g.V().repeat(out()).times(2).name.toList()
assert 2 == len(results)
assert "lop" in results
assert "ripple" in results
#
assert 10 == g.V().repeat(both()).times(5)[0:10].count().next()
assert 1 == g.V().repeat(both()).times(5)[0].count().next()
assert 0 == g.V().repeat(both()).times(5)[0:0].count().next()
assert 4 == g.V()[2:].count().next()
assert 2 == g.V()[:2].count().next()
# todo: need a traversal metrics deserializer
g.V().out().profile().next()
connection.close()
async def test_traversals(self, remote_connection):
statics.load_statics(globals())
g = Graph().traversal().withRemote(remote_connection)
result = await g.V().count().toList()
assert long(6) == result[0]
# #
assert Vertex(1) == await g.V(1).next()
assert 1 == await g.V(1).id().next()
assert Traverser(Vertex(1)) == await g.V(1).nextTraverser()
result = await g.V(1).toList()
assert 1 == len(result)
result = await g.V(1).toList()
assert isinstance(result, list)
results = g.V().repeat(out()).times(2).name
results = await results.toList()
assert 2 == len(results)
assert "lop" in results # FIXME : Test fails here.
assert "ripple" in results
# # #
assert 10 == await g.V().repeat(both()).times(5)[0:10].count().next()
assert 1 == await g.V().repeat(both()).times(5)[0:1].count().next()
assert 0 == await g.V().repeat(both()).times(5)[0:0].count().next()
assert 4 == await g.V()[2:].count().next()
assert 2 == await g.V()[:2].count().next()
# # #
results = await g.withSideEffect('a', [
'josh', 'peter'
]).V(1).out('created').in_('created').values('name').where(within('a')
).toList()
assert 2 == len(results)
assert 'josh' in results
assert 'peter' in results
# # # todo: need a traversal metrics deserializer
# g.V().out().profile().next()
await remote_connection.close()
def _handle_query_results(result_set, gremlin_future):
try:
traversers = [Traverser(t) for t in result_set]
gremlin_future.set_result(
RemoteTraversal(iter(traversers), TraversalSideEffects()))
except Exception as e:
gremlin_future.set_exception(e)
def test_traversals(self, remote_connection):
statics.load_statics(globals())
assert "remoteconnection[ws://localhost:45940/gremlin,g]" == str(
remote_connection)
g = Graph().traversal().withRemote(remote_connection)
assert long(6) == g.V().count().toList()[0]
# #
assert Vertex(1) == g.V(1).next()
assert 1 == g.V(1).id().next()
assert Traverser(Vertex(1)) == g.V(1).nextTraverser()
assert 1 == len(g.V(1).toList())
assert isinstance(g.V(1).toList(), list)
results = g.V().repeat(out()).times(2).name
results = results.toList()
assert 2 == len(results)
assert "lop" in results
assert "ripple" in results
# #
assert 10 == g.V().repeat(both()).times(5)[0:10].count().next()
assert 1 == g.V().repeat(both()).times(5)[0:1].count().next()
assert 0 == g.V().repeat(both()).times(5)[0:0].count().next()
assert 4 == g.V()[2:].count().next()
assert 2 == g.V()[:2].count().next()
# #
results = g.withSideEffect(
'a', ['josh', 'peter'
]).V(1).out('created').in_('created').values('name').where(
within('a')).toList()
assert 2 == len(results)
assert 'josh' in results
assert 'peter' in results
# # todo: need a traversal metrics deserializer
g.V().out().profile().next()
def test_traversals(self, remote_connection):
statics.load_statics(globals())
g = traversal().withRemote(remote_connection)
assert long(6) == g.V().count().toList()[0]
# #
assert Vertex(1) == g.V(1).next()
assert 1 == g.V(1).id().next()
assert Traverser(Vertex(1)) == g.V(1).nextTraverser()
assert 1 == len(g.V(1).toList())
assert isinstance(g.V(1).toList(), list)
results = g.V().repeat(out()).times(2).name
results = results.toList()
assert 2 == len(results)
assert "lop" in results
assert "ripple" in results
# #
assert 10 == g.V().repeat(both()).times(5)[0:10].count().next()
assert 1 == g.V().repeat(both()).times(5)[0:1].count().next()
assert 0 == g.V().repeat(both()).times(5)[0:0].count().next()
assert 4 == g.V()[2:].count().next()
assert 2 == g.V()[:2].count().next()
# #
results = g.withSideEffect('a', ['josh', 'peter']).V(1).out('created').in_('created').values('name').where(P.within('a')).toList()
assert 2 == len(results)
assert 'josh' in results
assert 'peter' in results
# #
results = g.V().out().profile().toList()
assert 1 == len(results)
assert 'metrics' in results[0]
assert 'dur' in results[0]
# #
results = g.V().has('name', 'peter').as_('a').out('created').as_('b').select('a', 'b').by(
__.valueMap()).toList()
assert 1 == len(results)
assert 'peter' == results[0]['a']['name'][0]
assert 35 == results[0]['a']['age'][0]
assert 'lop' == results[0]['b']['name'][0]
assert 'java' == results[0]['b']['lang'][0]
assert 2 == len(results[0]['a'])
assert 2 == len(results[0]['b'])
# #
results = g.V(1).inject(g.V(2).next()).values('name').toList()
assert 2 == len(results)
assert 'marko' in results
assert 'vadas' in results
# #
results = g.V().has('person', 'name', 'marko').map(lambda: ("it.get().value('name')", "gremlin-groovy")).toList()
assert 1 == len(results)
assert 'marko' in results
# #
# this test just validates that the underscored versions of steps conflicting with Gremlin work
# properly and can be removed when the old steps are removed - TINKERPOP-2272
results = g.V().filter_(__.values('age').sum_().and_(
__.max_().is_(gt(0)), __.min_().is_(gt(0)))).range_(0, 1).id_().next()
assert 1 == results
def submit(self, bytecode):
# the only reason I don't use submitAsync here
# is to avoid an unuseful future wrap
query, ep = self._prepare_query(bytecode)
traversers = self.session.execute_graph(query,
execution_profile=ep)
traversers = [Traverser(t) for t in traversers]
return RemoteTraversal(iter(traversers), TraversalSideEffects())
def test_traversals(self, remote_connection):
statics.load_statics(globals())
assert "remoteconnection[ws://localhost:45940/gremlin,gmodern]" == str(remote_connection)
g = traversal().withRemote(remote_connection)
assert long(6) == g.V().count().toList()[0]
# #
assert Vertex(1) == g.V(1).next()
assert 1 == g.V(1).id().next()
assert Traverser(Vertex(1)) == g.V(1).nextTraverser()
assert 1 == len(g.V(1).toList())
assert isinstance(g.V(1).toList(), list)
results = g.V().repeat(out()).times(2).name
results = results.toList()
assert 2 == len(results)
assert "lop" in results
assert "ripple" in results
# #
assert 10 == g.V().repeat(both()).times(5)[0:10].count().next()
assert 1 == g.V().repeat(both()).times(5)[0:1].count().next()
assert 0 == g.V().repeat(both()).times(5)[0:0].count().next()
assert 4 == g.V()[2:].count().next()
assert 2 == g.V()[:2].count().next()
# #
results = g.withSideEffect('a', ['josh', 'peter']).V(1).out('created').in_('created').values('name').where(
within('a')).toList()
assert 2 == len(results)
assert 'josh' in results
assert 'peter' in results
# #
results = g.V().out().profile().toList()
assert 1 == len(results)
assert 'metrics' in results[0]
assert 'dur' in results[0]
# #
results = g.V().has('name', 'peter').as_('a').out('created').as_('b').select('a', 'b').by(
__.valueMap()).toList()
assert 1 == len(results)
assert 'peter' == results[0]['a']['name'][0]
assert 35 == results[0]['a']['age'][0]
assert 'lop' == results[0]['b']['name'][0]
assert 'java' == results[0]['b']['lang'][0]
assert 2 == len(results[0]['a'])
assert 2 == len(results[0]['b'])
# #
results = g.V(1).inject(g.V(2).next()).values('name').toList()
assert 2 == len(results)
assert 'marko' in results
assert 'vadas' in results
def submit(self, bytecode):
query = DseGraph.query_from_traversal(bytecode)
ep = self.session.execution_profile_clone_update(
self.execution_profile, row_factory=graph_traversal_row_factory)
graph_options = ep.graph_options.copy()
graph_options.graph_language = DseGraph.DSE_GRAPH_QUERY_LANGUAGE
if self.graph_name:
graph_options.graph_name = self.graph_name
ep.graph_options = graph_options
traversers = self.session.execute_graph(query, execution_profile=ep)
traversers = [Traverser(t) for t in traversers]
return RemoteTraversal(iter(traversers), TraversalSideEffects())
def test_traversals(self, remote_connection):
statics.load_statics(globals())
g = traversal().withRemote(remote_connection)
assert long(6) == g.V().count().toList()[0]
# #
assert Vertex(1) == g.V(1).next()
assert 1 == g.V(1).id().next()
assert Traverser(Vertex(1)) == g.V(1).nextTraverser()
assert 1 == len(g.V(1).toList())
assert isinstance(g.V(1).toList(), list)
results = g.V().repeat(out()).times(2).name
results = results.toList()
assert 2 == len(results)
assert "lop" in results
assert "ripple" in results
# #
assert 10 == g.V().repeat(both()).times(5)[0:10].count().next()
assert 1 == g.V().repeat(both()).times(5)[0:1].count().next()
assert 0 == g.V().repeat(both()).times(5)[0:0].count().next()
assert 4 == g.V()[2:].count().next()
assert 2 == g.V()[:2].count().next()
# #
results = g.withSideEffect(
'a', ['josh', 'peter'
]).V(1).out('created').in_('created').values('name').where(
P.within('a')).toList()
assert 2 == len(results)
assert 'josh' in results
assert 'peter' in results
# #
results = g.V().out().profile().toList()
assert 1 == len(results)
assert 'metrics' in results[0]
assert 'dur' in results[0]
# #
results = g.V().has('name',
'peter').as_('a').out('created').as_('b').select(
'a', 'b').by(__.valueMap()).toList()
assert 1 == len(results)
assert 'peter' == results[0]['a']['name'][0]
assert 35 == results[0]['a']['age'][0]
assert 'lop' == results[0]['b']['name'][0]
assert 'java' == results[0]['b']['lang'][0]
assert 2 == len(results[0]['a'])
assert 2 == len(results[0]['b'])
# #
results = g.V(1).inject(g.V(2).next()).values('name').toList()
assert 2 == len(results)
assert 'marko' in results
assert 'vadas' in results
# #
results = g.V().has('person', 'name', 'marko').map(
lambda: ("it.get().value('name')", "gremlin-groovy")).toList()
assert 1 == len(results)
assert 'marko' in results
# #
# this test just validates that the underscored versions of steps conflicting with Gremlin work
# properly and can be removed when the old steps are removed - TINKERPOP-2272
results = g.V().filter_(
__.values('age').sum_().and_(__.max_().is_(gt(0)),
__.min_().is_(gt(0)))).range_(
0, 1).id_().next()
assert 1 == results
# #
# test binding in P
results = g.V().has('person', 'age',
Bindings.of('x', lt(30))).count().next()
assert 2 == results
# #
# test dict keys which can only work on GraphBinary and GraphSON3 which include specific serialization
# types for dict
if not isinstance(remote_connection._client._message_serializer,
GraphSONSerializersV2d0):
results = g.V().has(
'person', 'name',
'marko').elementMap("name").groupCount().next()
assert {
HashableDict.of({
T.id: 1,
T.label: 'person',
'name': 'marko'
}): 1
} == results
def _objectify(self, dict):
return Traverser(
GraphSONReader._objectify(dict[_SymbolHelper._VALUE]["value"]),
GraphSONReader._objectify(dict[_SymbolHelper._VALUE]["bulk"]))
def _read_traverser(cls, b, r):
bulk = int64_unpack(b.read(8))
obj = r.readObject(b)
return Traverser(obj, bulk=bulk)
def _traversers_generator(traversers):
for t in traversers:
yield Traverser(t)
def deserialize_message(cls, message):
return Traverser(message)
def objectify(cls, d, reader):
return Traverser(reader.toObject(d["value"]),
reader.toObject(d["bulk"]))
async def _receive(self, async_iter, response_queue):
async for result in async_iter:
traverser = Traverser(self._deserialize_result(result), 1)
response_queue.put_nowait(traverser)
response_queue.put_nowait(None)
