def test_custom_mapping(self):
# extended mapping
class X(object):
pass
serdes = Mock()
writer = GraphSONWriter(serializer_map={X: serdes})
assert X in writer.serializers
# base dicts are not modified
assert X not in gremlin_python.structure.io.graphsonV2d0._serializers
obj = X()
d = writer.toDict(obj)
serdes.dictify.assert_called_once_with(obj, writer)
assert d is serdes.dictify()
# overridden mapping
serdes = Mock()
writer = GraphSONWriter(serializer_map={int: serdes})
assert gremlin_python.structure.io.graphsonV2d0._serializers[int] is not writer.serializers[int]
value = 3
d = writer.toDict(value)
serdes.dictify.assert_called_once_with(value, writer)
assert d is serdes.dictify()
def test_custom_mapping(self):
# extended mapping
class X(object):
pass
serdes = Mock()
writer = GraphSONWriter(serializer_map={X: serdes})
assert X in writer.serializers
# base dicts are not modified
assert X not in gremlin_python.structure.io.graphsonV2d0._serializers
obj = X()
d = writer.toDict(obj)
serdes.dictify.assert_called_once_with(obj, writer)
assert d is serdes.dictify()
# overridden mapping
serdes = Mock()
writer = GraphSONWriter(serializer_map={int: serdes})
assert gremlin_python.structure.io.graphsonV2d0._serializers[int] is not writer.serializers[int]
value = 3
d = writer.toDict(value)
serdes.dictify.assert_called_once_with(value, writer)
assert d is serdes.dictify()
class TestGraphSONWriter(object):
graphson_writer = GraphSONWriter()
graphson_reader = GraphSONReader()
def test_number_output(self):
assert {"@type": "g:Int64", "@value": 2} == json.loads(self.graphson_writer.writeObject(long(2)))
assert {"@type": "g:Int32", "@value": 1} == json.loads(self.graphson_writer.writeObject(1))
assert {"@type": "g:Double", "@value": 3.2} == json.loads(self.graphson_writer.writeObject(3.2))
assert """true""" == self.graphson_writer.writeObject(True)
def test_numbers(self):
assert {"@type": "gx:Byte", "@value": 1} == json.loads(self.graphson_writer.writeObject(int.__new__(SingleByte, 1)))
assert {"@type": "g:Int64", "@value": 2} == json.loads(self.graphson_writer.writeObject(long(2)))
assert {"@type": "g:Int32", "@value": 1} == json.loads(self.graphson_writer.writeObject(1))
assert {"@type": "g:Double", "@value": 3.2} == json.loads(self.graphson_writer.writeObject(3.2))
assert {"@type": "g:Double", "@value": "NaN"} == json.loads(self.graphson_writer.writeObject(float('nan')))
assert {"@type": "g:Double", "@value": "Infinity"} == json.loads(self.graphson_writer.writeObject(float('inf')))
assert {"@type": "g:Double", "@value": "-Infinity"} == json.loads(self.graphson_writer.writeObject(float('-inf')))
assert {"@type": "gx:BigDecimal", "@value": "123456789987654321123456789987654321"} == json.loads(self.graphson_writer.writeObject(Decimal('123456789987654321123456789987654321')))
assert {"@type": "gx:BigDecimal", "@value": "NaN"} == json.loads(self.graphson_writer.writeObject(Decimal('nan')))
assert {"@type": "gx:BigDecimal", "@value": "Infinity"} == json.loads(self.graphson_writer.writeObject(Decimal('inf')))
assert {"@type": "gx:BigDecimal", "@value": "-Infinity"} == json.loads(self.graphson_writer.writeObject(Decimal('-inf')))
assert {"@type": "gx:BigInteger", "@value": "123456789987654321123456789987654321"} == json.loads(self.graphson_writer.writeObject(long(123456789987654321123456789987654321)))
assert {"@type": "gx:BigInteger", "@value": "123456789987654321123456789987654321"} == json.loads(self.graphson_writer.writeObject(123456789987654321123456789987654321))
assert """true""" == self.graphson_writer.writeObject(True)
def test_P(self):
result = {'@type': 'g:P',
'@value': {
'predicate': 'and',
'value': [{
'@type': 'g:P',
'@value': {
'predicate': 'or',
'value': [{
'@type': 'g:P',
'@value': {'predicate': 'lt', 'value': 'b'}
},
{'@type': 'g:P', '@value': {'predicate': 'gt', 'value': 'c'}}
]
}
},
{'@type': 'g:P', '@value': {'predicate': 'neq', 'value': 'd'}}]}}
assert result == json.loads(
self.graphson_writer.writeObject(P.lt("b").or_(P.gt("c")).and_(P.neq("d"))))
result = {'@type': 'g:P', '@value': {'predicate':'within','value': [{"@type": "g:Int32", "@value": 1},{"@type": "g:Int32", "@value": 2}]}}
assert result == json.loads(self.graphson_writer.writeObject(P.within([1,2])))
def test_strategies(self):
# we have a proxy model for now given that we don't want to have to have g:XXX all registered on the Gremlin traversal machine (yet)
assert {"@type": "g:SubgraphStrategy", "@value": {}} == json.loads(
self.graphson_writer.writeObject(SubgraphStrategy))
assert {"@type": "g:SubgraphStrategy", "@value": {
"vertices": {"@type": "g:Bytecode", "@value": {"step": [["has", "name", "marko"]]}}}} == json.loads(
self.graphson_writer.writeObject(SubgraphStrategy(vertices=__.has("name", "marko"))))
def test_graph(self):
# TODO: this assert is not compatible with python 3 and now that we test with both 2 and 3 it fails
assert {"@type": "g:Vertex", "@value": {"id": {"@type": "g:Int64", "@value": 12}, "label": "person"}} == json.loads(self.graphson_writer.writeObject(Vertex(long(12), "person")))
assert {"@type": "g:Edge", "@value": {"id": {"@type": "g:Int32", "@value": 7},
"outV": {"@type": "g:Int32", "@value": 0},
"outVLabel": "person",
"label": "knows",
"inV": {"@type": "g:Int32", "@value": 1},
"inVLabel": "dog"}} == json.loads(
self.graphson_writer.writeObject(Edge(7, Vertex(0, "person"), "knows", Vertex(1, "dog"))))
assert {"@type": "g:VertexProperty", "@value": {"id": "blah", "label": "keyA", "value": True,
"vertex": "stephen"}} == json.loads(
self.graphson_writer.writeObject(VertexProperty("blah", "keyA", True, Vertex("stephen"))))
assert {"@type": "g:Property",
"@value": {"key": "name", "value": "marko", "element": {"@type": "g:VertexProperty",
"@value": {
"vertex": "vertexId",
"id": {"@type": "g:Int32", "@value": 1234},
"label": "aKey"}}}} == json.loads(
self.graphson_writer.writeObject(
Property("name", "marko", VertexProperty(1234, "aKey", 21345, Vertex("vertexId")))))
vertex = self.graphson_reader.readObject(self.graphson_writer.writeObject(Vertex(1, "person")))
assert 1 == vertex.id
assert "person" == vertex.label
edge = self.graphson_reader.readObject(
self.graphson_writer.writeObject(Edge(3, Vertex(1, "person"), "knows", Vertex(2, "dog"))))
assert "knows" == edge.label
assert 3 == edge.id
assert 1 == edge.outV.id
assert 2 == edge.inV.id
vertex_property = self.graphson_reader.readObject(
self.graphson_writer.writeObject(VertexProperty(1, "age", 32, Vertex(1))))
assert 1 == vertex_property.id
assert "age" == vertex_property.key
assert 32 == vertex_property.value
property = self.graphson_reader.readObject(self.graphson_writer.writeObject(Property("age", 32.2, Edge(1,Vertex(2),"knows",Vertex(3)))))
assert "age" == property.key
assert 32.2 == property.value
def test_custom_mapping(self):
# extended mapping
class X(object):
pass
serdes = Mock()
writer = GraphSONWriter(serializer_map={X: serdes})
assert X in writer.serializers
# base dicts are not modified
assert X not in gremlin_python.structure.io.graphsonV2d0._serializers
obj = X()
d = writer.toDict(obj)
serdes.dictify.assert_called_once_with(obj, writer)
assert d is serdes.dictify()
# overridden mapping
serdes = Mock()
writer = GraphSONWriter(serializer_map={int: serdes})
assert gremlin_python.structure.io.graphsonV2d0._serializers[int] is not writer.serializers[int]
value = 3
d = writer.toDict(value)
serdes.dictify.assert_called_once_with(value, writer)
assert d is serdes.dictify()
def test_write_long(self):
mapping = self.graphson_writer.toDict(1)
assert mapping['@type'] == 'g:Int32'
assert mapping['@value'] == 1
mapping = self.graphson_writer.toDict(long(1))
assert mapping['@type'] == 'g:Int64'
assert mapping['@value'] == 1
def test_datetime(self):
expected = json.dumps({"@type": "g:Date", "@value": 1481750076295}, separators=(',', ':'))
dt = datetime.datetime.fromtimestamp(1481750076295 / 1000.0)
output = self.graphson_writer.writeObject(dt)
assert expected == output
def test_timestamp(self):
expected = json.dumps({"@type": "g:Timestamp", "@value": 1481750076295}, separators=(',', ':'))
ts = timestamp(1481750076295 / 1000.0)
output = self.graphson_writer.writeObject(ts)
assert expected == output
def test_duration(self):
expected = json.dumps({"@type": "gx:Duration", "@value": "P5D"}, separators=(',', ':'))
d = datetime.timedelta(hours=120)
output = self.graphson_writer.writeObject(d)
assert expected == output
def test_uuid(self):
expected = json.dumps({'@type': 'g:UUID', '@value': "41d2e28a-20a4-4ab0-b379-d810dede3786"}, separators=(',', ':'))
prop = uuid.UUID("41d2e28a-20a4-4ab0-b379-d810dede3786")
output = self.graphson_writer.writeObject(prop)
assert expected == output
def test_bytebuffer(self):
expected = json.dumps({'@type': 'gx:ByteBuffer', '@value': 'c29tZSBieXRlcyBmb3IgeW91'}, separators=(',', ':'))
bb = ByteBufferType("c29tZSBieXRlcyBmb3IgeW91", "utf8")
output = self.graphson_writer.writeObject(bb)
assert expected == output
def test_char(self):
expected = json.dumps({'@type': 'gx:Char', '@value': 'L'}, separators=(',', ':'))
c = str.__new__(SingleChar, chr(76))
output = self.graphson_writer.writeObject(c)
assert expected == output
# See the License for the specific language governing permissions and
# limitations under the License.
import logging
from cassandra.graph import SimpleGraphStatement
from cassandra.cluster import EXEC_PROFILE_GRAPH_DEFAULT
from gremlin_python.process.graph_traversal import GraphTraversal
from gremlin_python.structure.io.graphsonV2d0 import GraphSONWriter
from cassandra.datastax.graph.fluent.serializers import serializers
log = logging.getLogger(__name__)
graphson_writer = GraphSONWriter(serializer_map=serializers)
__all__ = ['TraversalBatch', '_query_from_traversal', '_DefaultTraversalBatch']
def _query_from_traversal(traversal):
"""
From a GraphTraversal, return a query string.
:param traversal: The GraphTraversal object
"""
try:
query = graphson_writer.writeObject(traversal)
except Exception:
log.exception("Error preparing graphson traversal query:")
raise
class TestGraphSONWriter(object):
graphson_writer = GraphSONWriter()
def test_number_output(self):
assert {"@type": "g:Int64", "@value": 2} == json.loads(self.graphson_writer.writeObject(long(2)))
assert {"@type": "g:Int32", "@value": 1} == json.loads(self.graphson_writer.writeObject(1))
assert {"@type": "g:Double", "@value": 3.2} == json.loads(self.graphson_writer.writeObject(3.2))
assert """true""" == self.graphson_writer.writeObject(True)
def test_numbers(self):
assert {"@type": "g:Int64", "@value": 2} == json.loads(self.graphson_writer.writeObject(long(2)))
assert {"@type": "g:Int32", "@value": 1} == json.loads(self.graphson_writer.writeObject(1))
assert {"@type": "g:Double", "@value": 3.2} == json.loads(self.graphson_writer.writeObject(3.2))
assert """true""" == self.graphson_writer.writeObject(True)
def test_P(self):
result = {'@type': 'g:P',
'@value': {
'predicate': 'and',
'value': [{
'@type': 'g:P',
'@value': {
'predicate': 'or',
'value': [{
'@type': 'g:P',
'@value': {'predicate': 'lt', 'value': 'b'}
},
{'@type': 'g:P', '@value': {'predicate': 'gt', 'value': 'c'}}
]
}
},
{'@type': 'g:P', '@value': {'predicate': 'neq', 'value': 'd'}}]}}
assert result == json.loads(
self.graphson_writer.writeObject(P.lt("b").or_(P.gt("c")).and_(P.neq("d"))))
result = {'@type': 'g:P', '@value': {'predicate':'within','value': [{"@type": "g:Int32", "@value": 1},{"@type": "g:Int32", "@value": 2}]}}
assert result == json.loads(self.graphson_writer.writeObject(P.within([1,2])))
def test_strategies(self):
# we have a proxy model for now given that we don't want to have to have g:XXX all registered on the Gremlin traversal machine (yet)
assert {"@type": "g:SubgraphStrategy", "@value": {}} == json.loads(
self.graphson_writer.writeObject(SubgraphStrategy))
assert {"@type": "g:SubgraphStrategy", "@value": {
"vertices": {"@type": "g:Bytecode", "@value": {"step": [["has", "name", "marko"]]}}}} == json.loads(
self.graphson_writer.writeObject(SubgraphStrategy(vertices=__.has("name", "marko"))))
def test_graph(self):
# TODO: this assert is not compatible with python 3 and now that we test with both 2 and 3 it fails
assert {"@type": "g:Vertex", "@value": {"id": {"@type": "g:Int64", "@value": 12}, "label": "person"}} == json.loads(self.graphson_writer.writeObject(Vertex(long(12), "person")))
assert {"@type": "g:Edge", "@value": {"id": {"@type": "g:Int32", "@value": 7},
"outV": {"@type": "g:Int32", "@value": 0},
"outVLabel": "person",
"label": "knows",
"inV": {"@type": "g:Int32", "@value": 1},
"inVLabel": "dog"}} == json.loads(
self.graphson_writer.writeObject(Edge(7, Vertex(0, "person"), "knows", Vertex(1, "dog"))))
assert {"@type": "g:VertexProperty", "@value": {"id": "blah", "label": "keyA", "value": True,
"vertex": "stephen"}} == json.loads(
self.graphson_writer.writeObject(VertexProperty("blah", "keyA", True, Vertex("stephen"))))
assert {"@type": "g:Property",
"@value": {"key": "name", "value": "marko", "element": {"@type": "g:VertexProperty",
"@value": {
"vertex": "vertexId",
"id": {"@type": "g:Int32", "@value": 1234},
"label": "aKey"}}}} == json.loads(
self.graphson_writer.writeObject(
Property("name", "marko", VertexProperty(1234, "aKey", 21345, Vertex("vertexId")))))
def test_custom_mapping(self):
# extended mapping
class X(object):
pass
serdes = Mock()
writer = GraphSONWriter(serializer_map={X: serdes})
assert X in writer.serializers
# base dicts are not modified
assert X not in gremlin_python.structure.io.graphsonV2d0._serializers
obj = X()
d = writer.toDict(obj)
serdes.dictify.assert_called_once_with(obj, writer)
assert d is serdes.dictify()
# overridden mapping
serdes = Mock()
writer = GraphSONWriter(serializer_map={int: serdes})
assert gremlin_python.structure.io.graphsonV2d0._serializers[int] is not writer.serializers[int]
value = 3
d = writer.toDict(value)
serdes.dictify.assert_called_once_with(value, writer)
assert d is serdes.dictify()
def test_write_long(self):
mapping = self.graphson_writer.toDict(1)
assert mapping['@type'] == 'g:Int32'
assert mapping['@value'] == 1
mapping = self.graphson_writer.toDict(long(1))
assert mapping['@type'] == 'g:Int64'
assert mapping['@value'] == 1