Set the explicit unix expiry time of a key.
502508
def expire_at(self, key, expiry, **opts):
        """"""
        key, store = self._expand_opts(key, opts)
        data = store.get(key)
        if data is not None:
            data = list(data)
            data[EXPIRY_INDEX] = expiry
            store[key] = tuple(data)
        else:
            raise KeyError(key)
1079394
@Override
    public byte[] set(byte[] key, byte[] value, int expireTime) {
        if (key == null) {
            return null;
        }
        Jedis jedis = getJedis();
        try {
            jedis.set(key, value);
            // -1 and 0 is not a valid expire time in Jedis
            if (expireTime > 0) {
                jedis.expire(key, expireTime);
            }
         } finally {
            jedis.close();
        }
        return value;
    }
452005
void expireAfterWrite(String key, @Nullable String value) {
    requireArgument(expireAfterWriteDuration == UNSET_INT, "expireAfterWrite was already set");
    expireAfterWriteDuration = parseDuration(key, value);
    expireAfterWriteTimeUnit = parseTimeUnit(key, value);
  }
718448
def expire(self, key, max_age, **opts):
        """"""
        self.expire_at(key, time() + max_age, **opts)
709424
public void setExpiryTime(long pExpiryTime) {
        long oldEexpiryTime = expiryTime;

        expiryTime = pExpiryTime;

        if (expiryTime < oldEexpiryTime) {
            // Expire now
            nextExpiryTime = 0;
            removeExpiredEntries();
        }
    }
737184
async def set(self, key, value, param=None, expire_time=None, herd_timeout=None):
        
        identity = self._gen_identity(key, param)
        expected_expired_ts = int(time.time())
        if expire_time:
            expected_expired_ts += expire_time
        expected_expired_ts += herd_timeout or self.default_herd_timeout
        value = self._pack([value, expected_expired_ts])
        return await self.client.set(identity, value, ex=expire_time)
1136856
public Long pexpireAt(Object key, long millisecondsTimestamp) {
		Jedis jedis = getJedis();
		try {
			return jedis.pexpireAt(keyToBytes(key), millisecondsTimestamp);
		}
		finally {close(jedis);}
	}
175263
def set_session_value(self, name, value):
        """"""

        self.redis().hset(self._session_key, name, value)
        self._update_session_expiration()
721905
def set_ttl(self, key, ttl):
        
        return self._client.expire(self.get_key(key), ttl)
413901
function set($key, $value, $expire = 0)
    {
        if ($expire <= 0)
        {
            $expire = 0x7fffffff;
        }
        return $this->redis->setex($key, $expire, serialize($value));
    }
230697
def set_key(self, key='C'):
        """"""
        if isinstance(key, Key):
            key = key.name[0]
        self.track_data += self.key_signature_event(key)
840366
def set_time(self, key_name, new_time):
        """"""
        self.unbake()
        kf = self.dct[key_name]
        kf['time'] = new_time
        self.bake()
387211
def set_pttl(self, key, ttl):
        
        return self._client.pexpire(self.get_key(key), ttl)
822204
function setKey(key, val, flag, expiry, xflag, req) {
  var exists = this._data[key] !== undefined;
  var o = {v: val, t: Date.now()};
  if((xflag === Constants.NX && exists)
    || (xflag === Constants.XX && !exists)) {
    return undefined;
  }
  this._data[key] = o;
  if(!exists) {
    this._keys.push(key);
  }
  if((flag === Constants.EX || flag === Constants.PX)
    && expiry !== undefined) {
    expiry = flag === Constants.EX
      ? Date.now() + (expiry * 1000)
      : Date.now() + expiry;
    this.setExpiry(key, expiry, req);
  }
  return Constants.OK;
}
463505
def set_cas(key, value, cas, ttl=nil, options=nil)
      ttl ||= @options[:expires_in].to_i
      perform(:set, key, value, ttl, cas, options)
    end
1202885
def expire_key(self, key):
        '''
        
        '''
        value = self.base_dict[key]
        del self[key]
        if self.callback is not None:
            self.callback(
                key, value, *self.callback_args, **self.callback_kwargs)
361083
public Long expire(Object key, int seconds) {
		Jedis jedis = getJedis();
		try {
			return jedis.expire(keyToBytes(key), seconds);
		}
		finally {close(jedis);}
	}