Returns the index key for the given args "value" (`args`)

        Parameters
        ----------
        kwargs: dict
            use_lua: bool
                Default to ``True``, if scripting is supported.
                If ``True``, the process of reading from the sorted-set, extracting
                the primary keys, excluding some values if needed, and putting the
                primary keys in a set or zset, is done in lua at the redis level.
                Else, data is fetched, manipulated here, then returned to redis.

        For the other parameters, see ``BaseIndex.get_filtered_keys``

def get_filtered_keys(self, suffix, *args, **kwargs):
        """Returns the index key for the given args "value" (`args`)

        Parameters
        ----------
        kwargs: dict
            use_lua: bool
                Default to ``True``, if scripting is supported.
                If ``True``, the process of reading from the sorted-set, extracting
                the primary keys, excluding some values if needed, and putting the
                primary keys in a set or zset, is done in lua at the redis level.
                Else, data is fetched, manipulated here, then returned to redis.

        For the other parameters, see ``BaseIndex.get_filtered_keys``

        """

        accepted_key_types = kwargs.get('accepted_key_types', None)

        if accepted_key_types\
                and 'set' not in accepted_key_types and 'zset' not in accepted_key_types:
            raise ImplementationError(
                '%s can only return keys of type "set" or "zset"' % self.__class__.__name__
            )

        key_type = 'set' if not accepted_key_types or 'set' in accepted_key_types else 'zset'
        tmp_key = unique_key(self.connection)
        args = list(args)

        # special "in" case: we get n keys and make an unionstore with them then return this key
        if suffix == 'in':

            values = set(args.pop())

            if not values:
                return []  # no keys

            in_keys = [
                self.get_filtered_keys('eq', *(args+[value]), **kwargs)[0][0]
                for value in values
            ]

            if key_type == 'set':
                self.connection.sunionstore(tmp_key, *in_keys)
            else:
                self.connection.zunionstore(tmp_key, *in_keys)

            # we can delete the temporary keys
            for in_key in in_keys:
                self.connection.delete(in_key)

            return [(tmp_key, key_type, True)]

        use_lua = self.model.database.support_scripting() and kwargs.get('use_lua', True)

        key = self.get_storage_key(*args)
        value = self.normalize_value(args[-1], transform=False)

        real_suffix = self.remove_prefix(suffix)

        if use_lua:
            start, end, exclude = self.get_boundaries(real_suffix, value)
            self.call_script(key, tmp_key, key_type, start, end, exclude)
        else:
            pks = self.get_pks_for_filter(key, real_suffix, value)
            if pks:
                if key_type == 'set':
                    self.connection.sadd(tmp_key, *pks)
                else:
                    self.connection.zadd(tmp_key, **{pk: idx for idx, pk in enumerate(pks)})

        return [(tmp_key, key_type, True)]