cubicweb: comparison entity.py

equal deleted inserted replaced

-:b5d595b66c35
+:c3b99606644d
 # with CubicWeb.  If not, see <http://www.gnu.org/licenses/>.
 """Base class for entity objects manipulated in clients"""
 __docformat__ = "restructuredtext en"
+from copy import copy
 from warnings import warn
 from logilab.common import interface
 from logilab.common.decorators import cached
 from logilab.common.deprecation import deprecated
 if card in '+*':
 return card
 return '1'
-class Entity(AppObject, dict):
+class Entity(AppObject):
 """an entity instance has e_schema automagically set on
 the class and instances has access to their issuing cursor.
 A property is set for each attribute and relation on each entity's type
 class. Becare that among attributes, 'eid' is *NEITHER* stored in the
 {'x': created.eid}, build_descr=False)
 return created
 def __init__(self, req, rset=None, row=None, col=0):
 AppObject.__init__(self, req, rset=rset, row=row, col=col)
-dict.__init__(self)
 self._cw_related_cache = {}
 if rset is not None:
 self.eid = rset[row][col]
 else:
 self.eid = None
 self._cw_is_saved = True
+self.cw_attr_cache = {}
 def __repr__(self):
 return '<Entity %s %s %s at %s>' % (
-self.e_schema, self.eid, self.keys(), id(self))
+self.e_schema, self.eid, self.cw_attr_cache.keys(), id(self))
 def __json_encode__(self):
 """custom json dumps hook to dump the entity's eid
 which is not part of dict structure itself
 """
 def __hash__(self):
 return id(self)
 def __cmp__(self, other):
 raise NotImplementedError('comparison not implemented for %s' % self.__class__)
+def __contains__(self, key):
+return key in self.cw_attr_cache
+def __iter__(self):
+return iter(self.cw_attr_cache)
 def __getitem__(self, key):
 if key == 'eid':
 warn('[3.7] entity["eid"] is deprecated, use entity.eid instead',
 DeprecationWarning, stacklevel=2)
 return self.eid
-return super(Entity, self).__getitem__(key)
+return self.cw_attr_cache[key]
 def __setitem__(self, attr, value):
 """override __setitem__ to update self.edited_attributes.
 Typically, a before_[update|add]_hook could do::
 if attr == 'eid':
 warn('[3.7] entity["eid"] = value is deprecated, use entity.eid = value instead',
 DeprecationWarning, stacklevel=2)
 self.eid = value
 else:
-super(Entity, self).__setitem__(attr, value)
+self.cw_attr_cache[attr] = value
 # don't add attribute into skip_security if already in edited
 # attributes, else we may accidentaly skip a desired security check
 if hasattr(self, 'edited_attributes') and \
 attr not in self.edited_attributes:
 self.edited_attributes.add(attr)
 elif not has_load_left and edited:
 # cleanup, this may cause undesired changes
 del self.entity['load_left']
 """
-super(Entity, self).__delitem__(attr)
+del self.cw_attr_cache[attr]
 if hasattr(self, 'edited_attributes'):
 self.edited_attributes.remove(attr)
+def get(self, key, default=None):
+return self.cw_attr_cache.get(key, default)
 def setdefault(self, attr, default):
 """override setdefault to update self.edited_attributes"""
-super(Entity, self).setdefault(attr, default)
+self.cw_attr_cache.setdefault(attr, default)
 # don't add attribute into skip_security if already in edited
 # attributes, else we may accidentaly skip a desired security check
 if hasattr(self, 'edited_attributes') and \
 attr not in self.edited_attributes:
 self.edited_attributes.add(attr)
 def pop(self, attr, default=_marker):
 """override pop to update self.edited_attributes on cleanup of
 undesired changes introduced in the entity's dict. See `__delitem__`
 """
 if default is _marker:
-value = super(Entity, self).pop(attr)
+value = self.cw_attr_cache.pop(attr)
 else:
-value = super(Entity, self).pop(attr, default)
+value = self.cw_attr_cache.pop(attr, default)
 if hasattr(self, 'edited_attributes') and attr in self.edited_attributes:
 self.edited_attributes.remove(attr)
 return value
 def update(self, values):
 data = soup2xhtml(data, self._cw.encoding)
 return data
 # entity cloning ##########################################################
+def cw_copy(self):
+thecopy = copy(self)
+thecopy.cw_attr_cache = copy(self.cw_attr_cache)
+thecopy._cw_related_cache = {}
+return thecopy
 def copy_relations(self, ceid): # XXX cw_copy_relations
 """copy relations of the object with the given eid on this
 object (this method is called on the newly created copy, and
 ceid designates the original entity).
 V = varmaker.next()
 rql = ['WHERE %s eid %%(x)s' % V]
 selected = []
 for attr in (attributes or self._cw_to_complete_attributes(skip_bytes, skip_pwd)):
 # if attribute already in entity, nothing to do
-if self.has_key(attr):
+if self.cw_attr_cache.has_key(attr):
 continue
 # case where attribute must be completed, but is not yet in entity
 var = varmaker.next()
 rql.append('%s %s %s' % (V, attr, var))
 selected.append((attr, var))
 :type name: str
 :param name: name of the attribute to get
 """
 try:
-value = self[name]
+value = self.cw_attr_cache[name]
 except KeyError:
 if not self.cw_is_saved():
 return None
 rql = "Any A WHERE X eid %%(x)s, X %s A" % name
 try:
 you should override this method to clear them as well.
 """
 # clear attributes cache
 haseid = 'eid' in self
 self._cw_completed = False
-self.clear()
+self.cw_attr_cache.clear()
 # clear relations cache
 self.cw_clear_relation_cache()
 # rest path unique cache
 try:
 del self.__unique
 don't use dict api in such case since we don't want attribute to be
 added to skip_security_attributes.
 This method is for internal use, you should not use it.
 """
-super(Entity, self).__setitem__(attr, value)
+self.cw_attr_cache[attr] = value
 def _cw_clear_local_perm_cache(self, action):
 for rqlexpr in self.e_schema.get_rqlexprs(action):
 self._cw.local_perm_cache.pop((rqlexpr.eid, (('x', self.eid),)), None)
 return self.__cw_skip_security_attributes
 def _cw_set_defaults(self):
 """set default values according to the schema"""
 for attr, value in self.e_schema.defaults():
-if not self.has_key(attr):
+if not self.cw_attr_cache.has_key(attr):
 self[str(attr)] = value
 def _cw_check(self, creation=False):
 """check this entity against its schema. Only final relation
 are checked here, constraint on actual relations are checked in hooks

changeset 5726	c3b99606644d
parent 5573	8dfb1726526b
child 5728	12d3da7b3bcf