Remove and return the last ``size`` item of the list ``name``

        Like **Redis.RPOP**

        :param string name: the queue name
        :param int size: the length of result
        :return: the list of pop elements
        :rtype: list
435056
def qpop_back(self, name, size=1):
        
        size = get_positive_integer("size", size)
        return self.execute_command('qpop_back', name, size)
902208
def calculate_size(name, key):
    
    data_size = 0
    data_size += calculate_size_str(name)
    data_size += calculate_size_data(key)
    return data_size
1137289
def calculate_size(name, function):
    
    data_size = 0
    data_size += calculate_size_str(name)
    data_size += calculate_size_data(function)
    return data_size
1057597
def popitem(self, last=True):
		
		try:
			if last:
				key, value = self._list.pop()
				index = len(self._list)
			else:
				key, value = self._list.pop(0)
				index = 0
		except IndexError:
			raise KeyError("IndexedDict is empty")

		index2, value2 = self._dict.pop(key)
		assert index == index2
		assert value is value2

		if not last:
			self._fix_indices_after_delete()

		return key, value
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
1067984
public static int ensureOutputParameterInRange(String name, long size) {
    if (size > Integer.MAX_VALUE) {
      LOG.warn("cos: {} capped to ~2.14GB"
          + " (maximum allowed size with current output mechanism)", name);
      return Integer.MAX_VALUE;
    } else {
      return (int) size;
    }
  }
982253
def popitem(self):
        
        node = self._head[2]
        if node is self._tail:
            raise KeyError('list is empty')
        self._find_lt(node[0])
        self._remove(node)
        return (node[0], node[1])
68272
def ensure_size(
        self,
        size = None
        ):
        
        if size is None:
            size = self.size_constraint
        while sys.getsizeof(self) > size:
            element_frequencies = collections.Counter(self)
            infrequent_element = element_frequencies.most_common()[-1:][0][0]
            self.remove(infrequent_element)
585860
def calculate_size(name, value, timeout_millis):
    
    data_size = 0
    data_size += calculate_size_str(name)
    data_size += calculate_size_data(value)
    data_size += LONG_SIZE_IN_BYTES
    return data_size
1101767
def pop_momentum_by_name(self, name):
        
        momentum = self.get_momentum_by_name(name)
        self.remove_momentum(momentum)
        return momentum
1271271
def itemsize(self):
        
        return self._items[:self._count, 1] - self._items[:self._count, 0]
1358613
def dpop(self, **kwds):
        
        item = self.dget(**kwds)
        self.remove(item)
        return item
669125
def calculate_size(name, interceptor):
    
    data_size = 0
    data_size += calculate_size_str(name)
    data_size += calculate_size_data(interceptor)
    return data_size
340839
def size(self):
        

        if self.id.endswith("/"):
            return sum(Queue(q).size() for q in self.get_known_subqueues())

        # ZSET
        if self.is_sorted:
            return context.connections.redis.zcard(self.redis_key)
        # SET
        elif self.is_set:
            return context.connections.redis.scard(self.redis_key)
        # LIST
        else:
            return context.connections.redis.llen(self.redis_key)
826802
def pop(self, queue_name):
        
        self._only_watch_from(queue_name)
        job = self.conn.reserve(timeout=0)
        job.delete()
        return job.body
215270
def pop(self, name: str, default: Any=_sentinel) -> Any:
        """"""
        if default is _sentinel:
            return self.__dict__.pop(name)
        else:
            return self.__dict__.pop(name, default)
1328106
final Object pop() {
        int size = stack.size();
        return size == 0 ? null : stack.remove(size - 1);
    }