Increment the value of ``key`` in hash ``name`` by ``amount``
355057
async def hincrby(self, name, key, amount=1):
        ""
        return await self.execute_command('HINCRBY', name, key, amount)
1253801
public function increment($key, $value = 1)
    {
        return $this->redisServer->getHashClient($key)->incrBy($key, $value);
    }
796055
def increment(d, key, val=1):
    
    if key in d:
        d[key] += val
    else:
        d[key] = val
89090
def set(self, key, value):
        """"""
        key = "{0}{1}".format(self.prefix, key)

        value = json.dumps(value, cls=NumpyEncoder)
        self.redis.set(key, value)
1020475
def increment(field, amount = 1)
      # value = (self[field] || 0) + amount
      # self[field] = value
      # if !@parse_object_id
      #  # TODO - warn that the object must be stored first
      #  return nil
      # end

      body = { field => Parse::Increment.new(amount) }.to_json
      data = @client.request(uri, :put, body)
      parse data
      self
    end
70550
def put(key, value)
    value = value.to_f
    @input_values[key] = value
    @smallest_seen_values[key] ||= 0.0
    if @largest_seen_values[key] == nil or @smallest_seen_values[key] > @largest_seen_values[key]
      @largest_seen_values[key] = @smallest_seen_values[key] + 1.0
    end
    @smallest_seen_values[key] = value if value < @smallest_seen_values[key]
    @largest_seen_values[key] = value if value > @largest_seen_values[key]
  end
1211052
def inc(self, key, key_length=0):
        
        if key_length < 1:
            key_length = len(key)
        val = self.add_method(self, key, key_length, 1)
        if self.k:
            self._update(key, val)
        return val
1321131
def smartSum(x,key,value):
    
    if key not in list(x.keys()):
        x[key] = value
    else:   x[key]+=value
761551
private void refillEntry(int baseHash)
  {
    K key = _keys[baseHash];
    V value = _values[baseHash];

    _keys[baseHash] = null;
    _values[baseHash] = null;

    int hash = key.hashCode() & _mask;

    for (int count = _size; count >= 0; count--) {
      if (_values[hash] == null) {
        _keys[hash] = key;
        _values[hash] = value;
        return;
      }

      hash = (hash + 1) & _mask;
    }
  }
83585
function increment(redisClient, amount, keyPrepend, key, callback) {

    if (typeof amount !== 'number') {
        callback("increment amount is not number");
        return;
    }

    var multi = redisClient.multi();

    // Chain each redis command.
    incrementMinute(multi, amount, keyPrepend, key);
    incrementHour(multi, amount, keyPrepend, key);
    incrementDays(multi, amount, keyPrepend, key);
    incrementWeeks(multi, amount, keyPrepend, key);

    // Do it
    multi.exec(callback);

}
456733
def add(self, value):
        """"""
        # Raise TypeError if value is not hashable
        hash(value)

        self.redis.sadd(self.key, self._pickle(value))
161262
def update(other_hash)
      if other_hash.is_a? Hash
        super(other_hash)
      else
        other_hash.to_hash.each_pair do |key, value|
          if block_given?
            value = yield(key, value)
          end
          self[key] = value
        end
        self
      end
    end
1282034
def set(key, value = nil)
      if key.is_a?(Hash)
        properties.merge!(key)
      else
        properties[key] = value
      end
    end
124488
def new_item(self, hash_key, range_key=None, attrs=None):
        
        return Item(self, hash_key, range_key, attrs)
458288
def increment(self, key, value=1):
        
        self._store.increment(self.tagged_item_key(key), value)
805196
def increment(self, key, value=1):
        
        raw = self._get_payload(key)

        integer = int(raw['data']) + value

        self.put(key, integer, int(raw['time']))

        return integer
610941
def increment(self, key: Any, by: int = 1) -> None:
        
        if key is not None:
            self[key] = self.get(key, 0) + by