Commit 9a702f44 authored by Tiago Peixoto's avatar Tiago Peixoto
Browse files

Improve Graph.vertex/edge/graph_properties to avoid circular references

parent 9b659850
......@@ -1213,50 +1213,160 @@ def perfect_prop_hash(props, htype="int32_t"):
return hprops
class PropertyDict(dict):
class InternalPropertyDict(dict):
"""Internal dictionary of property maps. It only accepts string keys and
:class:`PropertyMap` instances as values."""
def __init__(self, g):
self.g = weakref.ref(g)
@_require("key", tuple)
@_require("val", PropertyMap)
def __setitem__(self, key, val):
t, k = key
self.__set_property(t, k, val)
@_limit_args({"t": ["v", "e", "g"]})
@_require("key", str)
def __set_property(self, t, key, v):
dict.__setitem__(self, (t, key), v)
@_require("key", tuple)
def __delitem__(self, key):
dict.__delitem__(self, key)
@_require("key", tuple)
def setdefault(self, key, default=None):
if not isinstance(default, PropertyMap):
raise ValueError("default parameter must be of type PropertyMap, not: %s" % type(default))
v = self.get(key, None)
if v is None:
self[key] = v = default
return v
if sys.version_info < (3,):
def update(self, *args, **kwargs):
temp = dict(*args, **kwargs)
for k, v in temp.iteritems():
self[k] = v
def update(self, *args, **kwargs):
temp = dict(*args, **kwargs)
for k, v in temp.items():
self[k] = v
class PropertyDict():
"""Wrapper for the dict of vertex, graph or edge properties, which sets the
value on the property map when changed in the dict.
For convenience, the dictionary entries are also available via attributes.
.. note::
The class is only an one-way proxy to the internally-kept properties. If
you modify this object, the change will be propagated to the internal
dictionary, but not vice-versa. Keep this in mind if you intend to keep
a copy of the class instance.
def __init__(self, g, old, get_func, set_func, del_func):
dict.update(self, old)
super(PropertyDict, self).__setattr__("g", g)
super(PropertyDict, self).__setattr__("get_func", get_func)
super(PropertyDict, self).__setattr__("set_func", set_func)
super(PropertyDict, self).__setattr__("del_func", del_func)
def __init__(self, properties, t):
super(PropertyDict, self).__setattr__("properties", properties)
super(PropertyDict, self).__setattr__("t", t)
def __contains__(self, key):
return (self.t, key) in
def __getitem__(self, key):
if self.get_func != None:
val = self.get_func(self.g, key)
dict.__setitem__(self, key, val)
return val
raise KeyError("Property dict cannot be gotten")
if self.t == "g":
p =[(self.t, key)]
return p[p.get_graph()]
return[(self.t, key)]
def get(self, key, default=None):
return self[key]
except KeyError:
return default
def __setitem__(self, key, val):
if self.set_func != None:
self.set_func(self.g, key, val)
k = (self.t, key)
if self.t == "g" and not isinstance(val, PropertyMap) and k in
p =[k]
p[p.get_graph()] = val
raise KeyError("Property dict cannot be set")
dict.__setitem__(self, key, val)[k] = val
def setdefault(self, key, default=None):, key), default)
if sys.version_info < (3,):
def update(self, *args, **kwargs):
temp = dict(*args, **kwargs)
for k, v in temp.iteritems():[(self.t, k)] = v
def update(self, *args, **kwargs):
temp = dict(*args, **kwargs)
for k, v in temp.items():[(self.t, k)] = v
def __delitem__(self, key):
self.del_func(self.g, key)
dict.__delitem__(self, key)
del[(self.t, key)]
def clear(self):
for k in self.keys():
self.del_func(self.g, k)
keys = []
for k in
if k[0] == self.t:
for k in keys:
del[(self.t, k)]
def __len__(self):
count = 0
for k in
if k[0] == self.t:
count += 1
return count
def __iter__(self):
return self.iterkeys()
def iterkeys(self):
for k in
if k[0] == self.t:
yield k[0]
def haskey(self, key):
def items(self):
for k, v in
if k[0] == self.t:
yield k[1], v
if sys.version_info < (3,):
def iteritems(self):
for k, v in
if k[0] == self.t:
yield k[1], v
def itervalues(self):
for k, v in
if k[0] == self.t:
yield v
def keys(self):
return [k[1] for k in if k[0] == self.t]
if sys.version_info < (3,):
def values(self):
return [v for k, v in if k[0] == self.t]
def __repr__(self):
temp = dict([(k[1], v) for k, v in if k[0] == self.t])
return repr(temp)
def values(self):
return [v for k, v in if k[0] == self.t]
def __repr__(self):
temp = dict([(k[1], v) for k, v in if k[0] == self.t])
return repr(temp)
def __getattr__(self, attr):
return self.__getitem__(attr)
......@@ -1264,6 +1374,7 @@ class PropertyDict(dict):
def __setattr__(self, attr, val):
return self.__setitem__(attr, val)
# Graph class
# The main graph interface
......@@ -1303,7 +1414,10 @@ class Graph(object):
def __init__(self, g=None, directed=True, prune=False, vorder=None):
self.__properties = {}
self.__properties = InternalPropertyDict(self)
self.__graph_properties = PropertyDict(self.__properties, "g")
self.__vertex_properties = PropertyDict(self.__properties, "v")
self.__edge_properties = PropertyDict(self.__properties, "e")
self.__known_properties = {}
self.__filter_state = {"reversed": False,
"edge_filter": (None, False),
......@@ -1751,29 +1865,7 @@ class Graph(object):
# Internal property maps
# ======================
# all properties
def __get_properties(self):
return PropertyDict(self, self.__properties,
lambda g, k: g.__properties[k],
lambda g, k, v: g.__set_property(k[0], k[1], v),
lambda g, k: g.__del_property(k[0], k[1]))
@_limit_args({"t": ["v", "e", "g"]})
@_require("k", str)
def __set_property(self, t, k, v):
if t == "g" and not isinstance(v, PropertyMap):
self.__properties[(t, k)][self] = v
if t != v.key_type():
raise ValueError("wrong key type for property map")
self.__properties[(t, k)] = v
@_limit_args({"t": ["v", "e", "g"]})
@_require("k", str)
def __del_property(self, t, k):
del self.__properties[(t, k)]
properties = property(__get_properties,
properties = property(lambda self: self.__properties,
"""Dictionary of internal properties. Keys must always be a tuple, where the
first element if a string from the set {'v', 'e', 'g'}, representing a
......@@ -1787,42 +1879,22 @@ class Graph(object):
>>> del[("e", "foo")]
def __get_specific_properties(self, t):
props = dict([(k[1], v) for k, v in self.__properties.items() \
if k[0] == t])
return props
# vertex properties
def __get_vertex_properties(self):
return PropertyDict(self, self.__get_specific_properties("v"),
lambda g, k: g.__properties[("v", k)],
lambda g, k, v: g.__set_property("v", k, v),
lambda g, k: g.__del_property("v", k))
vertex_properties = property(__get_vertex_properties,
vertex_properties = property(lambda self: self.__vertex_properties,
doc="Dictionary of internal vertex properties. The keys are the property names.")
vp = property(__get_vertex_properties,
vp = property(lambda self: self.__vertex_properties,
doc="Alias to :attr:`~Graph.vertex_properties`.")
# edge properties
def __get_edge_properties(self):
return PropertyDict(self, self.__get_specific_properties("e"),
lambda g, k: g.__properties[("e", k)],
lambda g, k, v: g.__set_property("e", k, v),
lambda g, k: g.__del_property("e", k))
edge_properties = property(__get_edge_properties,
edge_properties = property(lambda self: self.__edge_properties,
doc="Dictionary of internal edge properties. The keys are the property names.")
ep = property(__get_edge_properties,
ep = property(lambda self: self.__edge_properties,
doc="Alias to :attr:`~Graph.edge_properties`.")
# graph properties
def __get_graph_properties(self):
return PropertyDict(self, self.__get_specific_properties("g"),
lambda g, k: g.__properties[("g", k)][g],
lambda g, k, v: g.__set_property("g", k, v),
lambda g, k: g.__del_property("g", k))
graph_properties = property(__get_graph_properties,
graph_properties = property(lambda self: self.__graph_properties,
doc="Dictionary of internal graph properties. The keys are the property names.")
gp = property(__get_graph_properties,
gp = property(lambda self: self.__graph_properties,
doc="Alias to :attr:`~Graph.graph_properties`.")
def own_property(self, prop):
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment