def get_eattr(self, edges, name=None):
g = self.parent()
eid = g.edge_id
if nonstring_container(edges[0]):
# many edges
if name is None:
eprop = {}
for k in self.keys():
prop = self.prop[k]
dtype = super().__getitem__(k)
eprop[k] = _to_np_array(
[prop[eid(tuple(e))] for e in edges], dtype)
return eprop
prop = self.prop[name]
dtype = super().__getitem__(name)
return _to_np_array([prop[eid(tuple(e))] for e in edges], dtype)
# single edge
if name is None:
eprop = {}
for k in self.keys():
eprop[k] = self.prop[k][eid(tuple(edges))]
return eprop
return self.prop[name][eid(tuple(edges))]
def get_eattr(self, edges, name=None):
g = self.parent()._graph
if nonstring_container(edges[0]):
# many edges
eids = [g.get_eid(*e) for e in edges]
if name is None:
eprop = {}
if nonstring_container(name[0]):
for k in self.keys():
dtype = _np_dtype(super().__getitem__(k))
eprop[k] = _to_np_array(
[g.es[eid][k] for eid in eids], dtype=dtype)
dtype = _np_dtype(super().__getitem__(name))
return _to_np_array([g.es[eid][name] for eid in eids], dtype=dtype)
elif not nonstring_container(edges):
raise ValueError("Invalid `edges` entry: {}.".format(edges))
# single edge
eid = g.get_eid(*edges)
if name is None:
eprop = {}
for k in self.keys():
eprop[k] = g.es[eid][k]
return eprop
return g.es[eid][name]
def __getitem__(self, name):
'''
Return the attributes of an edge or a list of edges.
'''
eprop = {}
graph = self.parent()
if isinstance(name, slice):
for k in self.keys():
dtype = _np_dtype(super().__getitem__(k))
eprop[k] = _to_np_array(self.prop[k], dtype)[name]
return eprop
elif nonstring_container(name):
if nonstring_container(name[0]):
eids = [graph.edge_id(e) for e in name]
for k in self.keys():
dtype = _np_dtype(super().__getitem__(k))
eprop[k] = _to_np_array(self.prop[k], dtype=dtype)[eids]
else:
eid = graph.edge_id(name)
for k in self.keys():
eprop[k] = self.prop[k][eid]
return eprop
dtype = _np_dtype(super().__getitem__(name))
return _to_np_array(self.prop[name], dtype=dtype)
def __getitem__(self, name):
dtype = super(_GtNProperty, self).__getitem__(name)
g = self.parent()._graph
if dtype == "string":
return g.vertex_properties[name].get_2d_array([0])[0]
elif dtype == "object":
vprop = g.vertex_properties[name]
return _to_np_array([vprop[i] for i in range(g.num_vertices())],
dtype)
return _to_np_array(g.vertex_properties[name].a, dtype)
def new_attribute(self, name, value_type, values=None, val=None):
dtype = object
g = self.parent()._graph
if val is None:
if value_type in ("int", "integer"):
val = int(0)
dtype = int
elif value_type in ("double", "float"):
val = np.NaN
dtype = float
elif value_type == "string":
val = ""
else:
val = None
if values is None:
values = _to_np_array(
[deepcopy(val) for _ in range(g.num_vertices())], dtype)
if len(values) != g.num_vertices():
raise ValueError("A list or a np.array with one entry per "
"node in the graph is required, got "
"{} values vs {} nodes for '{}'.".format(
len(values), g.num_vertices(), name))
# store name and value type in the dict
super(_GtNProperty, self).__setitem__(name, value_type)
# store the real values in the attribute
nprop = g.new_vertex_property(value_type, vals=values)
g.vertex_properties[name] = nprop
self._num_values_set[name] = len(values)
def new_attribute(self, name, value_type, values=None, val=None):
g = self.parent()._graph
num_edges = g.num_edges()
if values is None and val is None:
self._num_values_set[name] = num_edges
if val is None:
if value_type in ("int", "integer"):
val = int(0)
elif value_type in ("double", "float"):
val = np.NaN
elif value_type == "string":
val = ""
else:
val = None
if values is None:
values = _to_np_array([deepcopy(val) for _ in range(num_edges)],
value_type)
if len(values) != num_edges:
self._num_values_set[name] = 0
raise ValueError("A list or a np.array with one entry per "
"edge in the graph is required")
# store name and value type in the dict
super(_GtEProperty, self).__setitem__(name, value_type)
# store the real values in the attribute
eprop = g.new_edge_property(value_type, vals=values)
g.edge_properties[name] = eprop
self._num_values_set[name] = len(values)
def new_attribute(self, name, value_type, values=None, val=None):
dtype = object
if val is None:
if value_type in ("int", "integer"):
val = int(0)
dtype = int
elif value_type in ("double", "float"):
val = np.NaN
dtype = float
elif value_type == "string":
val = ""
else:
val = None
value_type = "object"
if values is None:
values = _to_np_array(
[deepcopy(val) for _ in range(self.parent().node_nb())],
value_type)
if len(values) != self.parent().node_nb():
raise ValueError("A list or a np.array with one entry per "
"node in the graph is required")
# store name and value type in the dict
super().__setitem__(name, value_type)
# store the real values in the attribute
self.prop[name] = list(values)
self._num_values_set[name] = len(values)
def __getitem__(self, name):
g = self.parent()._graph
lst = [g.nodes[i][name] for i in range(g.number_of_nodes())]
dtype = _np_dtype(super(_NxNProperty, self).__getitem__(name))
return _to_np_array(lst, dtype=dtype)
def get_eattr(self, edges, name=None):
g = self.parent()._graph
Edge = g.edge
if nonstring_container(edges[0]):
# many edges
if name is None:
eprop = {}
for k in self.keys():
tmp = g.edge_properties[k]
dtype = super().__getitem__(k)
eprop[k] = _to_np_array([tmp[Edge(*e)] for e in edges],
dtype)
return eprop
tmp = g.edge_properties[name]
dtype = super().__getitem__(name)
return _to_np_array([tmp[Edge(*e)] for e in edges], dtype)
if name is None:
eprop = {}
for k in self.keys():
tmp = g.edge_properties[k]
eprop[k] = tmp[Edge(*edges)]
return eprop
tmp = g.edge_properties[name]
return tmp[Edge(*edges)]
def __getitem__(self, name):
'''
Return the attributes of an edge or a list of edges.
'''
g = self.parent()._graph
Edge = g.edge
dtype = super().__getitem__(name)
if self._edges_deleted:
eprop = g.edge_properties[name]
edges = self.parent().edges_array
return _to_np_array([eprop[Edge(*e)] for e in edges], dtype)
if dtype == "string":
return g.edge_properties[name].get_2d_array([0])[0]
elif dtype == "object":
tmp = g.edge_properties[name]
return _to_np_array([tmp[Edge(*e)] for e in g.get_edges()], dtype)
return _to_np_array(g.edge_properties[name].a, dtype)
def get_eattr(self, edges, name=None):
g = self.parent()._graph
if nonstring_container(edges[0]):
# many edges
name = self.keys() if name is None else [name]
eprop = {k: [] for k in self.keys()}
for edge in edges:
data = g.get_edge_data(*edge)
if data is None:
raise ValueError("Edge {} does not exist.".format(edge))
[eprop[k].append(data[k]) for k in name]
for k, v in eprop.items():
dtype = _np_dtype(super().__getitem__(k))
eprop[k] = _to_np_array(v, dtype)
if len(name) == 1:
return eprop[name[0]]
return eprop
# single edge
data = deepcopy(g.get_edge_data(*edges))
if not data:
raise ValueError("Edge {} does not exist.".format(edges))
if name is None:
del data["eid"]
return data
return data[name]
def __getitem__(self, name):
g = self.parent()._graph
dtype = _np_dtype(super(_IgNProperty, self).__getitem__(name))
return _to_np_array(g.vs[name], dtype=dtype)
def __getitem__(self, name):
dtype = _np_dtype(super().__getitem__(name))
return _to_np_array(self.prop[name], dtype=dtype)