Get the value to filter on

        :return: the value to filter on
162628
def value(self):
        
        if self.filter_.get('field') is not None:
            try:
                result = getattr(self.model, self.filter_['field'])
            except AttributeError:
                raise InvalidFilters("{} has no attribute {}".format(self.model.__name__, self.filter_['field']))
            else:
                return result
        else:
            if 'val' not in self.filter_:
                raise InvalidFilters("Can't find value or field in a filter")

            return self.filter_['val']
489511
def filter_params(self, value):
        
        if value is None:
            return {}
        target = ".".join(self.field.source_attrs)
        return { '__raw__': { target + ".$id": value } }
35415
def build_filter(self, filter):
        
        try:
            self.filter = Filter.from_string(filter, self.limit)
        except ValueError:
            raise

        return self
828186
def get_filter_value(self, column_name):
        
        for flt, value in zip(self.filters, self.values):
            if flt.column_name == column_name:
                return value
952887
def get_filter_item(name: str, operation: bytes, value: bytes) -> bytes:
    
    assert isinstance(name, str)
    assert isinstance(value, bytes)
    if operation is None:
        return filter_format(b"(%s=%s)", [name, value])
    elif operation == "contains":
        assert value != ""
        return filter_format(b"(%s=*%s*)", [name, value])
    else:
        raise ValueError("Unknown search operation %s" % operation)
71438
def filters(self):
        """"""
        if self._filters is None:
            self._filters, self._attributes = self._fetch_configuration()
        return self._filters
1374273
def querystring(self):
        
        return {key: value for (key, value) in self.qs.items()
                if key.startswith(self.MANAGED_KEYS) or self._get_key_values('filter[')}
571034
def _value_retriever(self, value):
        
        if self._use_as_callable(value):
            return value

        return lambda item: data_get(item, value)
844035
def filter(self, filter_id=""):
    
    params = join_params(self.parameters, {"filter_id": filter_id})

    return self.__class__(**params)
507849
def pre_filter(self):
        
        if self._name in self.PRE_FILTER_FIELDS:
            val = int(self._value * self.FIELD_SCALE.get(self._name, 1))
            return '"{}=value=${},value={}"'.format(
                   self._rt_cmp, self.PRE_FILTER_FIELDS[self._name], val)
        return ''
1121455
def filter_value(old: float, new: float, factor: float) -> float:
    
    r_factor: float = 1 - factor
    return old * r_factor + new * factor
1110955
def get_value(self, query):
        
        indices = self.get_dimension_indices(query)
        index = self.get_value_index(indices)
        value = self.get_value_by_index(index)
        return value
478228
def get_params(self):
        
        params = {}
        complex = False

        for name, opt in self.filter_options.items():
            if opt.ignored:
                continue
            if self.set_param(params, name):
                complex = True
        return params, complex
1219344
def filter_by_value(cls, value):
        
        constants = []
        for constant in cls.iterconstants():
            if constant.value == value:
                constants.append(constant)
        return constants
396497
def allow_filtering(self):
        
        clone = copy.deepcopy(self)
        clone._allow_filtering = True
        return clone
1294359
def filter(self, **kwargs):
        
        readFilter = ReadFilter(**kwargs)
        self._filters.append(readFilter.filter)
        return self
1189191
def value(self):
        
        val = {}
        for k in self.__allowed_keys:
            v = getattr(self, "_" + k)
            if v is not None:
                val[k] = v
        return val