Set global timeout value, in seconds, for all DDE calls
9882
def setTimeout(self, time):
        """"""
        self.conversation.SetDDETimeout(round(time))
        return self.conversation.GetDDETimeout()
802913
def settimeout(self, timeout):
        
        self.sock_opt.timeout = timeout
        if self.sock:
            self.sock.settimeout(timeout)
1300253
function setIntervalContext(fn, ctx, timeout) {
  var id;

  var cancel = function() {
    clearInterval(id);
  };

  id = setInterval(function() { fn(); }, timeout);

  ctx.once('cancel', cancel);
}
1154122
def _set_slave_timeout(self, dpid, port, timeout):
        """"""
        slave = self._get_slave(dpid, port)
        if slave:
            slave['timeout'] = timeout
1204451
void setDataSourceLoginTimeout(int seconds) throws SQLException {
      for(ConnectionPoolSegment segment : segments) {
         if(segment.dbConnection.datasource != null) {
            segment.dbConnection.datasource.setLoginTimeout(seconds);
         }
      }
   }
910047
public final void setGuaranteedRemoteGetWaitTime(long value) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(this, tc, "setGuaranteedRemoteGetWaitTime", Long.valueOf(value));
        getHdr2().setLongField(JsHdr2Access.GUARANTEEDREMOTEGET_SET_WAITTIME, value);
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(this, tc, "setGuaranteedRemoteGetWaitTime");
    }
492241
def set_timeout(timeout)
      new_action = { 'SessionTimeoutMinutes' => timeout }
      response = rest_patch('/redfish/v1/Managers/1/NetworkService/', body: new_action)
      response_handler(response)
      true
    end
51404
function createTimeout(timer, i, callback) {
    return setTimeout(function() {
        callback(timer, i);
    }, timer.seconds * 1000);
}
964979
function TimeoutModule(Component){

  Component.implement({
    /**
     * just like setTimeout, but will enter digest automately
     * @param  {Function} fn    
     * @param  {Number}   delay 
     * @return {Number}   timeoutid
     */
    $timeout: function(fn, delay){
      delay = delay || 0;
      return setTimeout(function(){
        fn.call(this);
        this.$update(); //enter digest
      }.bind(this), delay);
    },
    /**
     * just like setInterval, but will enter digest automately
     * @param  {Function} fn    
     * @param  {Number}   interval 
     * @return {Number}   intervalid
     */
    $interval: function(fn, interval){
      interval = interval || 1000/60;
      return setInterval(function(){
        fn.call(this);
        this.$update(); //enter digest
      }.bind(this), interval);
    }
  });
}
418434
def setex(self, name, time, value):
        
        if isinstance(time, datetime.timedelta):
            time = int(time.total_seconds())
        return self.execute_command('SETEX', name, time, value)
451298
function(callback, timeInMs) {
    var timeout = makeTimeout(callback);
    setTriggerTime(timeout, timeInMs);
    s_timeoutsToInsert.push(timeout);
    return timeout.id;
  }
1239497
public void setProxyBranchTimeout(int seconds) {
		if(logger.isDebugEnabled()) {
			logger.debug("setProxyBranchTimeout");
		}
		if(seconds<=0) 
			throw new IllegalArgumentException("Negative or zero timeout not allowed");
		
		if(isCanceled() || isTimedOut()) {
			logger.error("Cancelled or timed out proxy branch should not be updated with new timeout values");
			return;
		}
		
		this.proxyBranchTimeout = seconds;
		if(this.started) updateTimer(false, originalRequest.getSipApplicationSession(false));
	}
1338345
public void setProxyTimeout(int seconds) {
		if(seconds<=0) throw new IllegalArgumentException("Negative or zero timeout not allowed");
		
		proxyTimeout = seconds;
		for(ProxyBranchImpl proxyBranch : proxyBranches.values()) {	
			final boolean inactive = proxyBranch.isCanceled() || proxyBranch.isTimedOut();
			
			if(!inactive) {
				proxyBranch.setProxyBranchTimeout(seconds);
			}
		}

	}
932776
public boolean setDoNotDisturb(VacuumDoNotDisturb dnd) throws CommandExecutionException {
        if (dnd == null) throw new CommandExecutionException(CommandExecutionException.Error.INVALID_PARAMETERS);
        return sendOk("set_dnd_timer", dnd.construct());
    }
1038556
def timeout(self, value):
        '''
        
        '''
        if not self.params:
            self.params = dict(timeout=value)
            return self
        self.params['timeout'] = value
        return self
368927
def timeout(self, timeout):
        """"""
        self._proxy_json._timeout = timeout
        self._proxy_http._timeout = timeout
798250
def _onMethodTimeout(self, serial, d):
        
        del self._pendingCalls[serial]
        d.errback(error.TimeOut('Method call timed out'))