Remove a range of element between the rank ``start`` and
        ``stop`` both included.

        :param name: str     the name of the redis key
        :param min:
        :param max:
        :return: Future()
347224
def zremrangebyrank(self, name, min, max):
        
        with self.pipe as pipe:
            return pipe.zremrangebyrank(self.redis_key(name), min, max)
1207019
def zremrangebylex(self, key, min=b'-', max=b'+',
                       include_min=True, include_max=True):
        
        if not isinstance(min, bytes):  # FIXME
            raise TypeError("min argument must be bytes")
        if not isinstance(max, bytes):  # FIXME
            raise TypeError("max argument must be bytes")
        if not min == b'-':
            min = (b'[' if include_min else b'(') + min
        if not max == b'+':
            max = (b'[' if include_max else b'(') + max
        return self.execute(b'ZREMRANGEBYLEX', key, min, max)
569653
def delete(self, *names):
        
        names = [self.redis_key(n) for n in names]
        with self.pipe as pipe:
            return pipe.delete(*names)
714092
def remove_parameter(self, name):
		
		if name in self.__query:
			self.__query.pop(name)
955462
def intersect(self,range2):
    
    if not self.overlaps(range2): return None
    return type(self)(self.chr,max(self.start,range2.start)+self._start_offset,min(self.end,range2.end),self.payload,self.dir)
636876
def ltrim(self, name, start, end):
        
        with self.pipe as pipe:
            return pipe.ltrim(self.redis_key(name), start, end)
716031
def remove_from_set(set, item)
      Predictor.redis.multi do |redis|
        redis.srem(redis_key(:items, set), item)
        redis.srem(redis_key(:sets, item), set)
      end
    end
617417
def delete(self, name):
    '''
    
    '''
    # TODO: confirm that this does not use the combo index and determine
    # performance implications.
    num_deleted = 0
    for interval,config in self._intervals.items():
      # TODO: use write preference settings if we have them
      num_deleted += self._client[interval].remove( {'name':name} )['n']
    return num_deleted
517737
def remove_by_rank(self, low, high=None):
        
        if high is None:
            high = low
        return self.database.zremrangebyrank(self.key, low, high)
881540
def count_between(self, min_score=None, max_score=None):
        
        min_score = float('-inf') if min_score is None else float(min_score)
        max_score = float('inf') if max_score is None else float(max_score)

        return self.redis.zcount(self.key, min_score, max_score)
361616
def lrange(self, name, start, end):
        
        return self.execute_command('LRANGE', name, start, end)
1050383
public static void stop(String name) {
        Long start = PENDING.remove(name);
        if (start == null) {
            return;
        }
        long duration = System.currentTimeMillis() - start;
        Counter sum = CUMULATED.computeIfAbsent(name, k -> new Counter(k, "ms"));
        sum.increment(duration);
    }
243784
def remove_parameter(self, name):
		
		spec = self.__specs[name] if name in self.__specs else None
		if spec is not None and spec.optional() is False:
			raise ValueError('Unable to remove a required parameter "%s"' % name)

		WURIQuery.remove_parameter(self, name)
264615
def remove_members_in_score_range_in(
            self, leaderboard_name, min_score, max_score):
        '''
        
        '''
        pipeline = self.redis_connection.pipeline()
        pipeline.zremrangebyscore(
            leaderboard_name,
            min_score,
            max_score)
        pipeline.zremrangebyscore(
            self._ties_leaderboard_key(leaderboard_name),
            min_score,
            max_score)
        pipeline.execute()
133085
def delete_vector(self, hash_name, bucket_keys, data):
        
        with self.redis_object.pipeline() as pipeline:
            for key in bucket_keys:
                redis_key = self._format_redis_key(hash_name, key)
                rows = [(row, pickle.loads(row).get('data'))
                        for row in self._get_bucket_rows(hash_name, key)]
                for _, id_data in rows:
                    if id_data == data:
                        break
                else:
                    # Deleted data is not present in this bucket
                    continue
                pipeline.delete(redis_key)
                pipeline.rpush(redis_key, *(row for row, id_data in rows
                                            if id_data != data))
            pipeline.execute()
1243291
function lrange(start, stop) {
  if(start < 0) start = this._data.length + start;
  if(stop < 0) stop = this._data.length + stop;
  stop++;
  return this._data.slice(start, stop);
}
914875
def expire(self, name, time):
        
        with self.pipe as pipe:
            return pipe.expire(self.redis_key(name), time)