cubicweb: comparison entity.py

equal deleted inserted replaced

-:00b1b6b906cf
+:97c55baefa0c
 # 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.compat import all
 from logilab.common.decorators import cached
+from logilab.common.deprecation import deprecated
 from logilab.mtconverter import TransformData, TransformError, xml_escape
 from rql.utils import rqlvar_maker
 from cubicweb import Unauthorized, typed_eid
 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
 mixins.append(mixin)
 for iface in getattr(mixin, '__implements__', ()):
 if not interface.implements(cls, iface):
 interface.extend(cls, iface)
 if role == 'subject':
-setattr(cls, rschema.type, SubjectRelation(rschema))
+attr = rschema.type
 else:
 attr = 'reverse_%s' % rschema.type
-setattr(cls, attr, ObjectRelation(rschema))
+setattr(cls, attr, Relation(rschema, role))
 if mixins:
 # see etype class instantation in cwvreg.ETypeRegistry.etype_class method:
 # due to class dumping, cls is the generated top level class with actual
 # user class as (only) parent. Since we want to be able to override mixins
 # method from this user class, we have to take care to insert mixins after that
 # with some cases of entity classes inheritance.
 mixins.insert(0, cls.__bases__[0])
 mixins += cls.__bases__[1:]
 cls.__bases__ = tuple(mixins)
 cls.info('plugged %s mixins on %s', mixins, cls)
+fetch_attrs = ('modification_date',)
+@classmethod
+def fetch_order(cls, attr, var):
+"""class method used to control sort order when multiple entities of
+this type are fetched
+"""
+return cls.fetch_unrelated_order(attr, var)
+@classmethod
+def fetch_unrelated_order(cls, attr, var):
+"""class method used to control sort order when multiple entities of
+this type are fetched to use in edition (eg propose them to create a
+new relation on an edited entity).
+"""
+if attr == 'modification_date':
+return '%s DESC' % var
+return None
 @classmethod
 def fetch_rql(cls, user, restriction=None, fetchattrs=None, mainvar='X',
 settype=True, ordermethod='fetch_order'):
 """return a rql to fetch all entities of the class type"""
 {'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 = {}
-self._related_cache = {}
 if rset is not None:
 self.eid = rset[row][col]
 else:
 self.eid = None
-self._is_saved = True
+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)
-self.skip_security_attributes.add(attr)
+self._cw_skip_security_attributes.add(attr)
 def __delitem__(self, attr):
 """override __delitem__ to update self.edited_attributes on cleanup of
 undesired changes introduced in the entity's dict. For example, see the
 code snippet below from the `forge` cube:
 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 clear(self):
+self.cw_attr_cache.clear()
+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)
+value = 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)
-self.skip_security_attributes.add(attr)
+self._cw_skip_security_attributes.add(attr)
+return value
 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):
 """override update to update self.edited_attributes. See `__setitem__`
 """
 for attr, value in values.items():
 self[attr] = value # use self.__setitem__ implementation
-def rql_set_value(self, attr, value):
+def cw_adapt_to(self, interface):
-"""call by rql execution plan when some attribute is modified
+"""return an adapter the entity to the given interface name.
-don't use dict api in such case since we don't want attribute to be
+return None if it can not be adapted.
-added to skip_security_attributes.
+"""
-"""
+try:
-super(Entity, self).__setitem__(attr, value)
+cache = self._cw_adapters_cache
+except AttributeError:
-def pre_add_hook(self):
+self._cw_adapters_cache = cache = {}
-"""hook called by the repository before doing anything to add the entity
+try:
-(before_add entity hooks have not been called yet). This give the
+return cache[interface]
-occasion to do weird stuff such as autocast (File -> Image for instance).
+except KeyError:
+adapter = self._cw.vreg['adapters'].select_or_none(
-This method must return the actual entity to be added.
+interface, self._cw, entity=self)
-"""
+cache[interface] = adapter
-return self
+return adapter
-def set_eid(self, eid):
+def has_eid(self): # XXX cw_has_eid
-self.eid = eid
-def has_eid(self):
 """return True if the entity has an attributed eid (False
 meaning that the entity has to be created
 """
 try:
 typed_eid(self.eid)
 return True
 except (ValueError, TypeError):
 return False
-def is_saved(self):
+def cw_is_saved(self):
 """during entity creation, there is some time during which the entity
-has an eid attributed though it's not saved (eg during before_add_entity
+has an eid attributed though it's not saved (eg during
-hooks). You can use this method to ensure the entity has an eid *and* is
+'before_add_entity' hooks). You can use this method to ensure the entity
-saved in its source.
+has an eid *and* is saved in its source.
 """
-return self.has_eid() and self._is_saved
+return self.has_eid() and self._cw_is_saved
 @cached
-def metainformation(self):
+def cw_metainformation(self):
 res = dict(zip(('type', 'source', 'extid'), self._cw.describe(self.eid)))
 res['source'] = self._cw.source_defs()[res['source']]
 return res
-def clear_local_perm_cache(self, action):
+def cw_check_perm(self, action):
-for rqlexpr in self.e_schema.get_rqlexprs(action):
-self._cw.local_perm_cache.pop((rqlexpr.eid, (('x', self.eid),)), None)
-def check_perm(self, action):
 self.e_schema.check_perm(self._cw, action, eid=self.eid)
-def has_perm(self, action):
+def cw_has_perm(self, action):
 return self.e_schema.has_perm(self._cw, action, eid=self.eid)
-def view(self, __vid, __registry='views', w=None, **kwargs):
+def view(self, __vid, __registry='views', w=None, **kwargs): # XXX cw_view
 """shortcut to apply a view on this entity"""
 view = self._cw.vreg[__registry].select(__vid, self._cw, rset=self.cw_rset,
 row=self.cw_row, col=self.cw_col,
 **kwargs)
 return view.render(row=self.cw_row, col=self.cw_col, w=w, **kwargs)
-def absolute_url(self, *args, **kwargs):
+def absolute_url(self, *args, **kwargs): # XXX cw_url
 """return an absolute url to view this entity"""
 # use *args since we don't want first argument to be "anonymous" to
 # avoid potential clash with kwargs
 if args:
 assert len(args) == 1, 'only 0 or 1 non-named-argument expected'
 method = None
 # in linksearch mode, we don't want external urls else selecting
 # the object for use in the relation is tricky
 # XXX search_state is web specific
 if getattr(self._cw, 'search_state', ('normal',))[0] == 'normal':
-kwargs['base_url'] = self.metainformation()['source'].get('base-url')
+kwargs['base_url'] = self.cw_metainformation()['source'].get('base-url')
 if method in (None, 'view'):
 try:
 kwargs['_restpath'] = self.rest_path(kwargs.get('base_url'))
 except TypeError:
 warn('[3.4] %s: rest_path() now take use_ext_eid argument, '
 kwargs['_restpath'] = self.rest_path()
 else:
 kwargs['rql'] = 'Any X WHERE X eid %s' % self.eid
 return self._cw.build_url(method, **kwargs)
-def rest_path(self, use_ext_eid=False):
+def rest_path(self, use_ext_eid=False): # XXX cw_rest_path
 """returns a REST-like (relative) path for this entity"""
 mainattr, needcheck = self._rest_attr_info()
 etype = str(self.e_schema)
 path = etype.lower()
 if mainattr != 'eid':
 if nbresults != 1: # ambiguity?
 mainattr = 'eid'
 path += '/eid'
 if mainattr == 'eid':
 if use_ext_eid:
-value = self.metainformation()['extid']
+value = self.cw_metainformation()['extid']
 else:
 value = self.eid
 return '%s/%s' % (path, self._cw.url_quote(value))
-def attr_metadata(self, attr, metadata):
+def cw_attr_metadata(self, attr, metadata):
 """return a metadata for an attribute (None if unspecified)"""
 value = getattr(self, '%s_%s' % (attr, metadata), None)
 if value is None and metadata == 'encoding':
 value = self._cw.vreg.property_value('ui.encoding')
 return value
 def printable_value(self, attr, value=_marker, attrtype=None,
-format='text/html', displaytime=True):
+format='text/html', displaytime=True): # XXX cw_printable_value
 """return a displayable value (i.e. unicode string) which may contains
 html tags
 """
 attr = str(attr)
 if value is _marker:
 if attrtype == 'String':
 # internalinalized *and* formatted string such as schema
 # description...
 if props.internationalizable:
 value = self._cw._(value)
-attrformat = self.attr_metadata(attr, 'format')
+attrformat = self.cw_attr_metadata(attr, 'format')
 if attrformat:
-return self.mtc_transform(value, attrformat, format,
+return self._cw_mtc_transform(value, attrformat, format,
 self._cw.encoding)
 elif attrtype == 'Bytes':
-attrformat = self.attr_metadata(attr, 'format')
+attrformat = self.cw_attr_metadata(attr, 'format')
 if attrformat:
-encoding = self.attr_metadata(attr, 'encoding')
+encoding = self.cw_attr_metadata(attr, 'encoding')
-return self.mtc_transform(value.getvalue(), attrformat, format,
+return self._cw_mtc_transform(value.getvalue(), attrformat, format,
 encoding)
 return u''
 value = printable_value(self._cw, attrtype, value, props,
 displaytime=displaytime)
 if format == 'text/html':
 value = xml_escape(value)
 return value
-def mtc_transform(self, data, format, target_format, encoding,
+def _cw_mtc_transform(self, data, format, target_format, encoding,
 _engine=ENGINE):
 trdata = TransformData(data, format, encoding, appobject=self)
 data = _engine.convert(trdata, target_format).decode()
 if format == 'text/html':
 data = soup2xhtml(data, self._cw.encoding)
 return data
 # entity cloning ##########################################################
-def copy_relations(self, ceid):
+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).
 By default meta and composite relations are skipped.
 if rdef.cardinality[1] in '?1':
 continue
 rql = 'SET X %s V WHERE X eid %%(x)s, Y eid %%(y)s, Y %s V' % (
 rschema.type, rschema.type)
 execute(rql, {'x': self.eid, 'y': ceid})
-self.clear_related_cache(rschema.type, 'subject')
+self.cw_clear_relation_cache(rschema.type, 'subject')
 for rschema in self.e_schema.object_relations():
 if rschema.meta:
 continue
 # skip already defined relations
 if self.related(rschema.type, 'object'):
 if rdef.cardinality[0] in '?1':
 continue
 rql = 'SET V %s X WHERE X eid %%(x)s, Y eid %%(y)s, V %s Y' % (
 rschema.type, rschema.type)
 execute(rql, {'x': self.eid, 'y': ceid})
-self.clear_related_cache(rschema.type, 'object')
+self.cw_clear_relation_cache(rschema.type, 'object')
 # data fetching methods ###################################################
 @cached
-def as_rset(self):
+def as_rset(self): # XXX .cw_as_rset
 """returns a resultset containing `self` information"""
 rset = ResultSet([(self.eid,)], 'Any X WHERE X eid %(x)s',
 {'x': self.eid}, [(self.__regid__,)])
 rset.req = self._cw
 return rset
-def to_complete_relations(self):
+def _cw_to_complete_relations(self):
 """by default complete final relations to when calling .complete()"""
 for rschema in self.e_schema.subject_relations():
 if rschema.final:
 continue
 targets = rschema.objects(self.e_schema)
-if len(targets) > 1:
-# ambigous relations, the querier doesn't handle
-# outer join correctly in this case
-continue
 if rschema.inlined:
 matching_groups = self._cw.user.matching_groups
-rdef = rschema.rdef(self.e_schema, targets[0])
+if all(matching_groups(e.get_groups('read')) and
-if matching_groups(rdef.get_groups('read')) and \
+rschema.rdef(self.e_schema, e).get_groups('read')
-all(matching_groups(e.get_groups('read')) for e in targets):
+for e in targets):
 yield rschema, 'subject'
-def to_complete_attributes(self, skip_bytes=True, skip_pwd=True):
+def _cw_to_complete_attributes(self, skip_bytes=True, skip_pwd=True):
 for rschema, attrschema in self.e_schema.attribute_definitions():
 # skip binary data by default
 if skip_bytes and attrschema.type == 'Bytes':
 continue
 attr = rschema.type
 self[attr] = None
 continue
 yield attr
 _cw_completed = False
-def complete(self, attributes=None, skip_bytes=True, skip_pwd=True):
+def complete(self, attributes=None, skip_bytes=True, skip_pwd=True): # XXX cw_complete
 """complete this entity by adding missing attributes (i.e. query the
 repository to fill the entity)
 :type skip_bytes: bool
 :param skip_bytes:
 self._cw_completed = True
 varmaker = rqlvar_maker()
 V = varmaker.next()
 rql = ['WHERE %s eid %%(x)s' % V]
 selected = []
-for attr in (attributes or self.to_complete_attributes(skip_bytes, skip_pwd)):
+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))
 # +1 since this doen't include the main variable
 lastattr = len(selected) + 1
 if attributes is None:
 # fetch additional relations (restricted to 0..1 relations)
-for rschema, role in self.to_complete_relations():
+for rschema, role in self._cw_to_complete_relations():
 rtype = rschema.type
-if self.relation_cached(rtype, role):
+if self.cw_relation_cached(rtype, role):
 continue
+# at this point we suppose that:
+# * this is a inlined relation
+# * entity (self) is the subject
+# * user has read perm on the relation and on the target entity
+assert rschema.inlined
+assert role == 'subject'
 var = varmaker.next()
-targettype = rschema.targets(self.e_schema, role)[0]
+# keep outer join anyway, we don't want .complete to crash on
-rdef = rschema.role_rdef(self.e_schema, targettype, role)
+# missing mandatory relation (see #1058267)
-card = rdef.role_cardinality(role)
+rql.append('%s %s %s?' % (V, rtype, var))
-assert card in '1?', '%s %s %s %s' % (self.e_schema, rtype,
-role, card)
-if role == 'subject':
-if card == '1':
-rql.append('%s %s %s' % (V, rtype, var))
-else:
-rql.append('%s %s %s?' % (V, rtype, var))
-else:
-if card == '1':
-rql.append('%s %s %s' % (var, rtype, V))
-else:
-rql.append('%s? %s %s' % (var, rtype, V))
 selected.append(((rtype, role), var))
 if selected:
 # select V, we need it as the left most selected variable
 # if some outer join are included to fetch inlined relations
 rql = 'Any %s,%s %s' % (V, ','.join(var for attr, var in selected),
 if value is None:
 rrset = ResultSet([], rql, {'x': self.eid})
 rrset.req = self._cw
 else:
 rrset = self._cw.eid_rset(value)
-self.set_related_cache(rtype, role, rrset)
+self.cw_set_relation_cache(rtype, role, rrset)
-def get_value(self, name):
+def cw_attr_value(self, name):
 """get value for the attribute relation <name>, query the repository
 to get the value if necessary.
 :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.is_saved():
+if not self.cw_is_saved():
 return None
 rql = "Any A WHERE X eid %%(x)s, X %s A" % name
 try:
 rset = self._cw.execute(rql, {'x': self.eid})
 except Unauthorized:
 self[name] = value = self._cw._('unaccessible')
 else:
 self[name] = value = None
 return value
-def related(self, rtype, role='subject', limit=None, entities=False):
+def related(self, rtype, role='subject', limit=None, entities=False): # XXX .cw_related
 """returns a resultset of related entities
 :param role: is the role played by 'self' in the relation ('subject' or 'object')
 :param limit: resultset's maximum size
 :param entities: if True, the entites are returned; if False, a result set is returned
 """
 try:
-return self.related_cache(rtype, role, entities, limit)
+return self._cw_relation_cache(rtype, role, entities, limit)
 except KeyError:
 pass
 if not self.has_eid():
 if entities:
 return []
 return self.empty_rset()
-rql = self.related_rql(rtype, role)
+rql = self.cw_related_rql(rtype, role)
 rset = self._cw.execute(rql, {'x': self.eid})
-self.set_related_cache(rtype, role, rset)
+self.cw_set_relation_cache(rtype, role, rset)
 return self.related(rtype, role, limit, entities)
-def related_rql(self, rtype, role='subject', targettypes=None):
+def cw_related_rql(self, rtype, role='subject', targettypes=None):
 rschema = self._cw.vreg.schema[rtype]
 if role == 'subject':
 restriction = 'E eid %%(x)s, E %s X' % rtype
 if targettypes is None:
 targettypes = rschema.objects(self.e_schema)
 tuple(args)
 return rql
 # generic vocabulary methods ##############################################
-def unrelated_rql(self, rtype, targettype, role, ordermethod=None,
+def cw_unrelated_rql(self, rtype, targettype, role, ordermethod=None,
 vocabconstraints=True):
 """build a rql to fetch `targettype` entities unrelated to this entity
 using (rtype, role) relation.
 Consider relation permissions so that returned entities may be actually
 select.solutions, args, existant)
 rql = rqlst.as_string()
 return rql, args
 def unrelated(self, rtype, targettype, role='subject', limit=None,
-ordermethod=None):
+ordermethod=None): # XXX .cw_unrelated
 """return a result set of target type objects that may be related
 by a given relation, with self as subject or object
 """
 try:
-rql, args = self.unrelated_rql(rtype, targettype, role, ordermethod)
+rql, args = self.cw_unrelated_rql(rtype, targettype, role, ordermethod)
 except Unauthorized:
 return self._cw.empty_rset()
 if limit is not None:
 before, after = rql.split(' WHERE ', 1)
 rql = '%s LIMIT %s WHERE %s' % (before, limit, after)
 return self._cw.execute(rql, args)
-# relations cache handling ################################################
+# relations cache handling #################################################
-def relation_cached(self, rtype, role):
+def cw_relation_cached(self, rtype, role):
-"""return true if the given relation is already cached on the instance
+"""return None if the given relation isn't already cached on the
-"""
+instance, else the content of the cache (a 2-uple (rset, entities)).
-return self._related_cache.get('%s_%s' % (rtype, role))
+"""
+return self._cw_related_cache.get('%s_%s' % (rtype, role))
-def related_cache(self, rtype, role, entities=True, limit=None):
+def _cw_relation_cache(self, rtype, role, entities=True, limit=None):
 """return values for the given relation if it's cached on the instance,
 else raise `KeyError`
 """
-res = self._related_cache['%s_%s' % (rtype, role)][entities]
+res = self._cw_related_cache['%s_%s' % (rtype, role)][entities]
 if limit is not None and limit < len(res):
 if entities:
 res = res[:limit]
 else:
 res = res.limit(limit)
 return res
-def set_related_cache(self, rtype, role, rset, col=0):
+def cw_set_relation_cache(self, rtype, role, rset):
 """set cached values for the given relation"""
 if rset:
-related = list(rset.entities(col))
+related = list(rset.entities(0))
 rschema = self._cw.vreg.schema.rschema(rtype)
 if role == 'subject':
 rcard = rschema.rdef(self.e_schema, related[0].e_schema).cardinality[1]
 target = 'object'
 else:
 rcard = rschema.rdef(related[0].e_schema, self.e_schema).cardinality[0]
 target = 'subject'
 if rcard in '?1':
 for rentity in related:
-rentity._related_cache['%s_%s' % (rtype, target)] = (
+rentity._cw_related_cache['%s_%s' % (rtype, target)] = (
 self.as_rset(), (self,))
 else:
 related = ()
-self._related_cache['%s_%s' % (rtype, role)] = (rset, related)
+self._cw_related_cache['%s_%s' % (rtype, role)] = (rset, related)
-def clear_related_cache(self, rtype=None, role=None):
+def cw_clear_relation_cache(self, rtype=None, role=None):
 """clear cached values for the given relation or the entire cache if
 no relation is given
 """
 if rtype is None:
-self._related_cache = {}
+self._cw_related_cache = {}
+self._cw_adapters_cache = {}
 else:
 assert role
-self._related_cache.pop('%s_%s' % (rtype, role), None)
+self._cw_related_cache.pop('%s_%s' % (rtype, role), None)
-def clear_all_caches(self):
+def clear_all_caches(self): # XXX cw_clear_all_caches
 """flush all caches on this entity. Further attributes/relations access
 will triggers new database queries to get back values.
 If you use custom caches on your entity class (take care to @cached!),
 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
-for rschema, _, role in self.e_schema.relation_definitions():
+self.cw_clear_relation_cache()
-self.clear_related_cache(rschema.type, role)
 # rest path unique cache
 try:
 del self.__unique
 except AttributeError:
 pass
 # raw edition utilities ###################################################
-def set_attributes(self, **kwargs):
+def set_attributes(self, **kwargs): # XXX cw_set_attributes
 _check_cw_unsafe(kwargs)
 assert kwargs
-assert self._is_saved, "should not call set_attributes while entity "\
+assert self.cw_is_saved(), "should not call set_attributes while entity "\
 "hasn't been saved yet"
 relations = []
 for key in kwargs:
 relations.append('X %s %%(%s)s' % (key, key))
 # and now update the database
 # update current local object _after_ the rql query to avoid
 # interferences between the query execution itself and the
 # edited_attributes / skip_security_attributes machinery
 self.update(kwargs)
-def set_relations(self, **kwargs):
+def set_relations(self, **kwargs): # XXX cw_set_relations
 """add relations to the given object. To set a relation where this entity
 is the object of the relation, use 'reverse_'<relation> as argument name.
 Values may be an entity, a list of entities, or None (meaning that all
 relations of the given type from or to this object should be deleted).
 values = (values,)
 self._cw.execute('SET %s WHERE X eid %%(x)s, Y eid IN (%s)' % (
 restr, ','.join(str(r.eid) for r in values)),
 {'x': self.eid})
-def delete(self, **kwargs):
+def cw_delete(self, **kwargs):
 assert self.has_eid(), self.eid
 self._cw.execute('DELETE %s X WHERE X eid %%(x)s' % self.e_schema,
 {'x': self.eid}, **kwargs)
 # server side utilities ###################################################
+def _cw_rql_set_value(self, attr, value):
+"""call by rql execution plan when some attribute is modified
+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.
+"""
+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)
 @property
-def skip_security_attributes(self):
+def _cw_skip_security_attributes(self):
 try:
-return self._skip_security_attributes
+return self.__cw_skip_security_attributes
 except:
-self._skip_security_attributes = set()
+self.__cw_skip_security_attributes = set()
-return self._skip_security_attributes
+return self.__cw_skip_security_attributes
-def set_defaults(self):
+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 check(self, creation=False):
+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
 """
 # necessary since eid is handled specifically and yams require it to be
 # in the dictionary
 else:
 relations = None
 self.e_schema.check(self, creation=creation, _=_,
 relations=relations)
-def fti_containers(self, _done=None):
+@deprecated('[3.9] use entity.cw_attr_value(attr)')
-if _done is None:
+def get_value(self, name):
-_done = set()
+return self.cw_attr_value(name)
-_done.add(self.eid)
-containers = tuple(self.e_schema.fulltext_containers())
+@deprecated('[3.9] use entity.cw_delete()')
-if containers:
+def delete(self, **kwargs):
-for rschema, target in containers:
+return self.cw_delete(**kwargs)
-if target == 'object':
-targets = getattr(self, rschema.type)
+@deprecated('[3.9] use entity.cw_attr_metadata(attr, metadata)')
-else:
+def attr_metadata(self, attr, metadata):
-targets = getattr(self, 'reverse_%s' % rschema)
+return self.cw_attr_metadata(attr, metadata)
-for entity in targets:
-if entity.eid in _done:
+@deprecated('[3.9] use entity.cw_has_perm(action)')
-continue
+def has_perm(self, action):
-for container in entity.fti_containers(_done):
+return self.cw_has_perm(action)
-yield container
-yielded = True
+@deprecated('[3.9] use entity.cw_set_relation_cache(rtype, role, rset)')
-else:
+def set_related_cache(self, rtype, role, rset):
-yield self
+self.cw_set_relation_cache(rtype, role, rset)
-def get_words(self):
+@deprecated('[3.9] use entity.cw_clear_relation_cache(rtype, role, rset)')
-"""used by the full text indexer to get words to index
+def clear_related_cache(self, rtype=None, role=None):
+self.cw_clear_relation_cache(rtype, role)
-this method should only be used on the repository side since it depends
-on the logilab.database package
+@deprecated('[3.9] use entity.cw_related_rql(rtype, [role, [targettypes]])')
+def related_rql(self, rtype, role='subject', targettypes=None):
-:rtype: list
+return self.cw_related_rql(rtype, role, targettypes)
-:return: the list of indexable word of this entity
-"""
-from logilab.database.fti import tokenize
-# take care to cases where we're modyfying the schema
-pending = self._cw.transaction_data.setdefault('pendingrdefs', set())
-words = []
-for rschema in self.e_schema.indexable_attributes():
-if (self.e_schema, rschema) in pending:
-continue
-try:
-value = self.printable_value(rschema, format='text/plain')
-except TransformError:
-continue
-except:
-self.exception("can't add value of %s to text index for entity %s",
-rschema, self.eid)
-continue
-if value:
-words += tokenize(value)
-for rschema, role in self.e_schema.fulltext_relations():
-if role == 'subject':
-for entity in getattr(self, rschema.type):
-words += entity.get_words()
-else: # if role == 'object':
-for entity in getattr(self, 'reverse_%s' % rschema.type):
-words += entity.get_words()
-return words
 # attribute and relation descriptors ##########################################
 class Attribute(object):
 self._attrname = attrname
 def __get__(self, eobj, eclass):
 if eobj is None:
 return self
-return eobj.get_value(self._attrname)
+return eobj.cw_attr_value(self._attrname)
 def __set__(self, eobj, value):
 eobj[self._attrname] = value
 class Relation(object):
 """descriptor that controls schema relation access"""
-_role = None # for pylint
+def __init__(self, rschema, role):
-def __init__(self, rschema):
-self._rschema = rschema
 self._rtype = rschema.type
+self._role = role
 def __get__(self, eobj, eclass):
 if eobj is None:
 raise AttributeError('%s cannot be only be accessed from instances'
 % self._rtype)
 def __set__(self, eobj, value):
 raise NotImplementedError
-class SubjectRelation(Relation):
-"""descriptor that controls schema relation access"""
-_role = 'subject'
-class ObjectRelation(Relation):
-"""descriptor that controls schema relation access"""
-_role = 'object'
 from logging import getLogger
 from cubicweb import set_log_methods
 set_log_methods(Entity, getLogger('cubicweb.entity'))

branch	stable
changeset 5994	97c55baefa0c
parent 5980	6dc04e75c8e1
child 6085	8a059eefac75