cubicweb: comparison selectors.py

equal deleted inserted replaced

-:a3d3220669d6
+:f4c97d3c8b93
 specified
 When there are several classes to be evaluated, return the sum of scores for
 each entity class unless:
-- `once_is_enough` is False (the default) and some entity class is scored
+- `mode` == 'all' (the default) and some entity class is scored
 to 0, in which case 0 is returned
-- `once_is_enough` is True, in which case the first non-zero score is
+- `mode` == 'any', in which case the first non-zero score is
 returned
 - `accept_none` is False and some cell in the column has a None value
 (this may occurs with outer join)
 """
-def __init__(self, once_is_enough=False, accept_none=True):
+def __init__(self, once_is_enough=None, accept_none=True, mode='all'):
-self.once_is_enough = once_is_enough
+if once_is_enough is not None:
+warn("[3.14] once_is_enough is deprecated, use mode='any'",
+DeprecationWarning, stacklevel=2)
+if once_is_enough:
+mode = 'any'
+assert mode in ('any', 'all'), 'bad mode %s' % mode
+self.once_is_enough = mode == 'any'
 self.accept_none = accept_none
 @lltrace
 def __call__(self, cls, req, rset=None, row=None, col=0, entity=None,
 select=None, filtered_variable=None,
 * else return the sum of scores for each entity found in the column
 specified specified by the `col` argument or in column 0 if not specified,
 unless:
-- `once_is_enough` is False (the default) and some entity is scored
+- `mode` == 'all' (the default) and some entity class is scored
 to 0, in which case 0 is returned
-- `once_is_enough` is True, in which case the first non-zero score is
+- `mode` == 'any', in which case the first non-zero score is
 returned
 - `accept_none` is False and some cell in the column has a None value
 (this may occurs with outer join)
 class ExpectedValueSelector(Selector):
 """Take a list of expected values as initializer argument and store them
 into the :attr:`expected` set attribute. You may also give a set as single
 argument, which will be then be referenced as set of expected values,
-allowing modification to the given set to be considered.
+allowing modifications to the given set to be considered.
-You should implement the :meth:`_get_value(cls, req, **kwargs)` method
+You should implement one of :meth:`_values_set(cls, req, **kwargs)` or
-which should return the value for the given context. The selector will then
+:meth:`_get_value(cls, req, **kwargs)` method which should respectivly
-return 1 if the value is expected, else 0.
+return the set of values or the unique possible value for the given context.
-"""
-def __init__(self, *expected):
+You may also specify a `mode` behaviour as argument, as explained below.
+Returned score is:
+- 0 if `mode` == 'all' (the default) and at least one expected
+values isn't found
+- 0 if `mode` == 'any' and no expected values isn't found at all
+- else the number of matching values
+Notice `mode`='any' with a single expected value has no effect at all.
+"""
+def __init__(self, *expected, **kwargs):
 assert expected, self
 if len(expected) == 1 and isinstance(expected[0], set):
 self.expected = expected[0]
 else:
 self.expected = frozenset(expected)
+mode = kwargs.pop('mode', 'all')
+assert mode in ('any', 'all'), 'bad mode %s' % mode
+self.once_is_enough = mode == 'any'
+assert not kwargs, 'unexpected arguments %s' % kwargs
 def __str__(self):
 return '%s(%s)' % (self.__class__.__name__,
 ','.join(sorted(str(s) for s in self.expected)))
 @lltrace
 def __call__(self, cls, req, **kwargs):
-if self._get_value(cls, req, **kwargs) in self.expected:
+values = self._values_set(cls, req, **kwargs)
-return 1
+matching = len(values & self.expected)
+if self.once_is_enough:
+return matching
+if matching == len(self.expected):
+return matching
 return 0
+def _values_set(self, cls, req, **kwargs):
+return frozenset( (self._get_value(cls, req, **kwargs),) )
 def _get_value(self, cls, req, **kwargs):
 raise NotImplementedError()
 # bare selectors ##############################################################
 class match_kwargs(ExpectedValueSelector):
 """Return non-zero score if parameter names specified as initializer
-arguments are specified in the input context. When multiple parameters are
+arguments are specified in the input context.
-specified, all of them should be specified in the input context. Return a
-score corresponding to the number of expected parameters.
-"""
+Return a score corresponding to the number of expected parameters.
-@lltrace
+When multiple parameters are expected, all of them should be found in
-def __call__(self, cls, req, **kwargs):
+the input context unless `mode` keyword argument is given to 'any',
-for arg in self.expected:
+in which case a single matching parameter is enough.
-if not arg in kwargs:
+"""
-return 0
-return len(self.expected)
+def _values_set(self, cls, req, **kwargs):
+return frozenset(kwargs)
 class appobject_selectable(Selector):
 """Return 1 if another appobject is selectable using the same input context.
 value at the end.
 See :class:`~cubicweb.selectors.EntitySelector` documentation for entity
 lookup / score rules according to the input context.
 """
-def __init__(self, scorefunc, once_is_enough=False):
+def __init__(self, scorefunc, once_is_enough=None, mode='all'):
-super(score_entity, self).__init__(once_is_enough)
+super(score_entity, self).__init__(mode=mode, once_is_enough=once_is_enough)
 def intscore(*args, **kwargs):
 score = scorefunc(*args, **kwargs)
 if not score:
 return 0
 if isinstance(score, (int, long)):
 """Return 1 if the entity adapt to IDownloadable and has the given MIME type.
 You can give 'image/' to match any image for instance, or 'image/png' to match
 only PNG images.
 """
-def __init__(self, mimetype, once_is_enough=False):
+def __init__(self, mimetype, once_is_enough=None, mode='all'):
-super(has_mimetype, self).__init__(once_is_enough)
+super(has_mimetype, self).__init__(mode=mode, once_is_enough=once_is_enough)
 self.mimetype = mimetype
 def score_entity(self, entity):
 idownloadable = entity.cw_adapt_to('IDownloadable')
 if idownloadable is None:
 benefit from the ORM's request entities cache.
 See :class:`~cubicweb.selectors.EntitySelector` documentation for entity
 lookup / score rules according to the input context.
 """
-def __init__(self, expression, once_is_enough=False, user_condition=False):
+def __init__(self, expression, once_is_enough=None, mode='all', user_condition=False):
-super(rql_condition, self).__init__(once_is_enough)
+super(rql_condition, self).__init__(mode=mode, once_is_enough=once_is_enough)
 self.user_condition = user_condition
 if user_condition:
 rql = 'Any COUNT(U) WHERE U eid %%(u)s, %s' % expression
 elif 'U' in frozenset(split_expression(expression)):
 rql = 'Any COUNT(X) WHERE X eid %%(x)s, U eid %%(u)s, %s' % expression
 class match_context(ExpectedValueSelector):
 @lltrace
 def __call__(self, cls, req, context=None, **kwargs):
-try:
+if not context in self.expected:
-if not context in self.expected:
+return 0
-return 0
-except AttributeError:
-return 1 # class doesn't care about search state, accept it
 return 1
 # XXX deprecate
 @objectify_selector
 return 1
 class match_form_params(ExpectedValueSelector):
 """Return non-zero score if parameter names specified as initializer
-arguments are specified in request's form parameters. When multiple
+arguments are specified in request's form parameters.
-parameters are specified, all of them should be found in req.form. Return a
-score corresponding to the number of expected parameters.
+Return a score corresponding to the number of expected parameters.
-"""
+When multiple parameters are expected, all of them should be found in
-@lltrace
+the input context unless `mode` keyword argument is given to 'any',
-def __call__(self, cls, req, **kwargs):
+in which case a single matching parameter is enough.
-for param in self.expected:
+"""
-if not param in req.form:
-return 0
+def _values_set(self, cls, req, **kwargs):
-return len(self.expected)
+return frozenset(req.form)
 class specified_etype_implements(is_instance):
 """Return non-zero score if the entity type specified by an 'etype' key
 searched in (by priority) input context kwargs and request form parameters
 which will not score at edit time::
 is_instance('Version') & (match_transition('ready') |
 attribute_edited('publication_date'))
 """
-def __init__(self, attribute, once_is_enough=False):
+def __init__(self, attribute, once_is_enough=None, mode='all'):
-super(attribute_edited, self).__init__(once_is_enough)
+super(attribute_edited, self).__init__(mode=mode, once_is_enough=once_is_enough)
 self._attribute = attribute
 def score_entity(self, entity):
 return eid_param(role_name(self._attribute, 'subject'), entity.eid) in entity._cw.form
 # Other selectors ##############################################################
 class match_exception(ExpectedValueSelector):
-"""Return 1 if a view is specified an as its registry id is in one of the
+"""Return 1 if exception given as `exc` in the input context is an instance
-expected view id given to the initializer.
+of one of the class given on instanciation of this predicate.
 """
 def __init__(self, *expected):
 assert expected, self
+# we want a tuple, not a set as done in the parent class
 self.expected = expected
 @lltrace
 def __call__(self, cls, req, exc=None, **kwargs):
 if exc is not None and isinstance(exc, self.expected):
 @objectify_selector
 def debug_mode(cls, req, rset=None, **kwargs):
 """Return 1 if running in debug mode."""
 return req.vreg.config.debugmode and 1 or 0
 ## deprecated stuff ############################################################
 class on_transition(is_in_state):

changeset 7955	f4c97d3c8b93
parent 7879	9aae456abab5
child 7986	552d41237156