def traversal_note_result():
    vert = Vertex(id=7700, label='Note')
    result = [{'p': VertexProperty(id=7701, label='name', value='D3', vertex=None),
               'v': vert},
              {'p': VertexProperty(id=7702, label='length', value=16, vertex=None),
               'v': vert},
              {'p': VertexProperty(id=7703, label='dot', value=0, vertex=None),
               'v': vert}]
    return result
示例#2
0
    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
示例#3
0
 def test_graph_objects(self):
     vertex = Vertex(1)
     assert "v[1]" == str(vertex)
     assert "vertex" == vertex.label
     assert "person" == Vertex(1, "person").label
     assert vertex == Vertex(1)
     #
     edge = Edge(2, Vertex(1), "said", Vertex("hello", "phrase"))
     assert "e[2][1-said->hello]" == str(edge)
     assert Vertex(1) == edge.outV
     assert Vertex("hello") == edge.inV
     assert "said" == edge.label
     assert "phrase" == edge.inV.label
     assert edge.inV != edge.outV
     #
     vertex_property = VertexProperty(long(24), "name", "marko", Vertex(1))
     assert "vp[name->marko]" == str(vertex_property)
     assert "name" == vertex_property.label
     assert "name" == vertex_property.key
     assert "marko" == vertex_property.value
     assert long(24) == vertex_property.id
     assert Vertex(1) == vertex_property.vertex
     assert isinstance(vertex_property.id, long)
     assert vertex_property == VertexProperty(long(24), "name", "marko",
                                              Vertex(1))
     #
     property = Property("age", 29, Vertex(1))
     assert "p[age->29]" == str(property)
     assert "age" == property.key
     assert 29 == property.value
     assert Vertex(1) == property.element
     assert isinstance(property.value, int)
     assert property == Property("age", 29, Vertex(1))
     if not six.PY3:
         assert property != Property("age", long(29), Vertex(1))
     #
     for i in [vertex, edge, vertex_property, property]:
         for j in [vertex, edge, vertex_property, property]:
             if type(i) != type(j):
                 assert i != j
             else:
                 assert i == j
                 assert i.__hash__() == hash(i)
示例#4
0
    def test_graph(self):
        assert {"@type": "g:Vertex",
                "@value": {"id": {"@type": "g:Int64", "@value": 12}, "label": "person"}} == json.loads(
            self.graphson_writer.writeObject(Vertex(12l, "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": "anId",
                                                                            "label": "aKey"}}}} == json.loads(
            self.graphson_writer.writeObject(
                Property("name", "marko", VertexProperty("anId", "aKey", 21345, Vertex("vertexId")))))
示例#5
0
    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")))))
示例#6
0
def test_parse_gremlin_property_elements(gremlin_parser):
    # parse VertexProperty elements
    v = VertexProperty("foo", "name", "bar", "v1")
    input = [v]
    out = gremlin_parser.gremlin_results_to_dict(input)
    df = pd.DataFrame.from_records(out)
    row = df.iloc[0]
    assert df.shape == (1, 5)
    assert row["id"] == "foo"
    assert row["label"] == "name"
    assert row["value"] == "bar"
    assert row["key"] == "name"
    assert row["vertex"] == "v1"

    v = Property("foo", "name", "bar")
    input = [v]
    out = gremlin_parser.gremlin_results_to_dict(input)
    df = pd.DataFrame.from_records(out)
    row = df.iloc[0]
    assert df.shape == (1, 3)
    assert row["element"] == "bar"
    assert row["value"] == "name"
    assert row["key"] == "foo"
def traversal_mult_note_result():
    vert_0 = Vertex(id=7700, label='Note')
    vert_1 = Vertex(id=7800, label='Note')

    result = [{'p': VertexProperty(id=7701, label='name', value='D3', vertex=None),
               'v': vert_0},
              {'p': VertexProperty(id=7702, label='length', value=16, vertex=None),
               'v': vert_0},
              {'p': VertexProperty(id=7703, label='dot', value=0, vertex=None),
               'v': vert_0},
              {'p': VertexProperty(id=7710, label='name', value='F3', vertex=None),
               'v': vert_1},
              {'p': VertexProperty(id=7712, label='length', value=8, vertex=None),
               'v': vert_1},
              {'p': VertexProperty(id=7713, label='dot', value=1, vertex=None),
               'v': vert_1}]

    return result
示例#8
0
 def objectify(cls, d, reader):
     vertex = Vertex(reader.toObject(
         d.get("vertex"))) if "vertex" in d else None
     return VertexProperty(reader.toObject(d["id"]), d["label"],
                           reader.toObject(d["value"]), vertex)
示例#9
0
 def test_vertexproperty(self):
     x = VertexProperty(123, "name", "stephen", None)
     output = self.graphbinary_reader.readObject(
         self.graphbinary_writer.writeObject(x))
     assert x == output
示例#10
0
 def _objectify(self, dict):
     value = dict[_SymbolHelper._VALUE]
     return VertexProperty(GraphSONReader._objectify(value["id"]),
                           value["label"],
                           GraphSONReader._objectify(value["value"]))
示例#11
0
 def _read_vertexproperty(cls, b, r):
     vp = VertexProperty(r.readObject(b), r.toObject(b, DataType.string, False), r.readObject(b), None)
     b.read(4)
     return vp
示例#12
0
 def objectify(cls, d, reader):
     return VertexProperty(reader.toObject(d["id"]), d["label"],
                           reader.toObject(d["value"]))
def traversal_line_result():
    result = [{'p': VertexProperty(id=4603, label='name', value='bach_cello', vertex=None),
               'v': Vertex(id=4602, label='Line')}]
    return result