def _from_mutable_graph(self, graph_def):
     graph_info = graph_def_pb2.MutableGraphInfoPb()
     graph_def.extension.Unpack(graph_info)
     # simple graph schema
     if graph_info.vdata_type:
         self._vdata_type = unify_type(graph_info.vdata_type)
     if graph_info.edata_type:
         self._edata_type = unify_type(graph_info.edata_type)
 def add_property(self, name, data_type, primary_key=False):
     self._prop_index[name] = len(self._props)
     if isinstance(data_type, str):
         data_type = unify_type(data_type)
     self._props.append(
         Property(name, data_type, primary_key, len(self._props)))
     self._valid_props.append(1)
     return self
    def _from_vineyard(self, graph_def):
        vy_info = graph_def_pb2.VineyardInfoPb()
        graph_def.extension.Unpack(vy_info)
        self._oid_type = vy_info.oid_type
        self._vid_type = vy_info.vid_type
        # simple graph schema.
        if vy_info.vdata_type:
            self._vdata_type = unify_type(vy_info.vdata_type)
        if vy_info.edata_type:
            self._edata_type = unify_type(vy_info.edata_type)

        # property graph schema
        if vy_info.property_schema_json:
            try:
                schema = json.loads(vy_info.property_schema_json)
                if schema:
                    for item in schema["types"]:

                        def add_common_attributes(entry, item):
                            for prop in item["propertyDefList"]:
                                entry.add_property(
                                    prop["name"],
                                    unify_type(prop["data_type"]))
                            entry._valid_props = item["valid_properties"]

                        if item["type"] == "VERTEX":
                            entry = VertexLabel(item["label"], item["id"])
                            assert entry.id == len(self._vertex_labels)
                            add_common_attributes(entry, item)
                            self._vertex_labels.append(entry)
                            self._v_label_index[entry.label] = entry.id
                        elif item["type"] == "EDGE":
                            entry = EdgeLabel(item["label"], item["id"])
                            assert entry.id == len(self._edge_labels)
                            for rel in item["rawRelationShips"]:
                                entry.source(
                                    rel["srcVertexLabel"]).destination(
                                        rel["dstVertexLabel"])
                            add_common_attributes(entry, item)
                            self._edge_labels.append(entry)
                            self._e_label_index[entry.label] = entry.id
                    self._valid_vertices = schema["valid_vertices"]
                    self._valid_edges = schema["valid_edges"]
            except Exception as e:
                raise ValueError("Invalid property graph schema") from e
        return self
Exemple #4
0
    def get_schema_from_def(self, schema_def):
        """Decode informations from proto message, generated by engine.

        Args:
            schema_def (`GraphSchemaDef`): Proto message defined in `proto/graph_def.proto`.

        Raises:
            ValueError: If the schema is not valid.
        """
        self._oid_type = schema_def.oid_type
        self._vid_type = schema_def.vid_type

        # simple graph schema.
        if schema_def.vdata_type:
            self._vdata_type = unify_type(schema_def.vdata_type)
        if schema_def.edata_type:
            self._edata_type = unify_type(schema_def.edata_type)

        # property graph schema
        if schema_def.property_schema_json:
            try:
                self._schema = json.loads(schema_def.property_schema_json)
                if self._schema:
                    for item in self._schema["types"]:
                        if item["type"] == "VERTEX":
                            self._vertex_labels.append(item["label"])
                            self._vertex_properties.append({
                                prop["name"]: unify_type(prop["data_type"])
                                for prop in item["propertyDefList"]
                            })
                        elif item["type"] == "EDGE":
                            self._edge_labels.append(item["label"])
                            self._edge_properties.append({
                                prop["name"]: unify_type(prop["data_type"])
                                for prop in item["propertyDefList"]
                            })
                            relation = [(rel["srcVertexLabel"],
                                         rel["dstVertexLabel"])
                                        for rel in item["rawRelationShips"]]
                            self._edge_relationships.append(relation)
            except Exception as e:
                raise ValueError("Invalid property graph schema") from e
Exemple #5
0
 def add_edge_properties(self, properties) -> bool:
     for key, value in properties.items():
         try:
             prop_type = unify_type(type(value))
             if key in self._edge_properties[0]:
                 if prop_type != self._edge_properties[0][key]:
                     return False
             else:
                 self._edge_properties[0][key] = prop_type
         except TypeError:
             return False
     return True
 def add_nx_edge_properties(self, properties) -> bool:
     for key, value in properties.items():
         try:
             prop_type = unify_type(type(value))
             for prop in self._edge_labels[0].properties:
                 if key == prop.name:
                     if prop_type != prop.type:
                         return False
                     break
             else:
                 self._edge_labels[0].add_property(key, prop_type)
         except TypeError:
             return False
     return True
Exemple #7
0
 def add_property(self, prop: str, dtype=None) -> None:
     """prop is a str, representing name. It can optionally have a type."""
     self.properties.append((prop, utils.unify_type(dtype)))
 def add_common_attributes(entry, item):
     for prop in item["propertyDefList"]:
         entry.add_property(
             prop["name"],
             unify_type(prop["data_type"]))
     entry._valid_props = item["valid_properties"]