Send a command to server flush|delete all keys.

        :param time: Time to wait until flush in seconds.
        :type time: int
        :return: True in case of success, False in case of failure
        :rtype: bool
965072
def flush_all(self, time=0):
        
        returns = []
        for server in self.servers:
            returns.append(server.flush_all(time))

        return any(returns)
620177
def pexpire(self, name, time):
        
        with self.pipe as pipe:
            return pipe.pexpire(self.redis_key(name), time)
910375
def flush(self, batch_size=1000):
        
        keys = self.database.keys(self.namespace + ':*')
        for i in range(0, len(keys), batch_size):
            self.database.delete(*keys[i:i + batch_size])
1141617
def flush_and_refresh(self, index):
        
        self.client.indices.flush(wait_if_ongoing=True, index=index)
        self.client.indices.refresh(index=index)
        self.client.cluster.health(
            wait_for_status='yellow', request_timeout=30)
        return True
255963
def flushInput(self):
                ''''''
                self.buf = ''
                saved_timeout = self.timeout
                self.timeout = 0.5
                self._recv()
                self.timeout = saved_timeout
                self.buf = ''
                self.debug("flushInput")
1038676
def flush(key):
    
    flush_list = []
    for item in cache:
        if key in item:
            flush_list.append(item)
    for item in flush_list:
        del cache[item]
568859
def flush(self):
        
        local_sender = self.sender
        if not local_sender:
            return
        while True:
            # get at most send_buffer_size items and send them
            data = []
            while len(data) < local_sender.send_buffer_size:
                item = self.get()
                if not item:
                    break
                data.append(item)
            if len(data) == 0:
                break
            local_sender.send(data)
1337251
def _clear(self, wait):
        
        i = 0
        t1 = time.time()
        for k in self.bucket.get_keys():
            i += 1
            self.bucket.get(k).delete()
        print("\nDELETION TOOK: %s" % round(time.time() - t1, 2))
        if wait:
            while self._model_class.objects.count():
                time.sleep(0.3)
        return i
296430
def settime(self, time):
        
        if isinstance(time, datetime) or isinstance(time,
                                                             datetime.date):
            seconds = int(time.strftime("%s"))
        elif isinstance(time, int):
            seconds = time
        else:
            raise TypeError("datetime.date, datetime.datetime or integer " +
                            "is required as time argument")
        raise NotImplementedError
1180842
def __flush(self):
        
        def on_md5(md5):
            self._file["md5"] = md5
            self._file["length"] = self._position
            self._file["uploadDate"] = datetime.datetime.utcnow()
            return self._coll.files.insert(self._file)

        return self.__flush_buffer()\
            .addCallback(lambda _: self._coll.filemd5(self._id))\
            .addCallback(on_md5)
235396
def delete(self, n=1, interval=0, pre_dl=None, post_dl=None):
        
        self.delay(pre_dl)
        self.k.tap_key(self.k.delete_key, n, interval)
        self.delay(post_dl)
1089114
def time(host=None, port=None, db=None, password=None):
    '''
    
    '''
    server = _connect(host, port, db, password)
    return server.time()[0]
210549
def sethello(self, time):
        
        _runshell([brctlexe, 'sethello', self.name, str(time)],
            "Could not set hello time in %s." % self.name)
936617
def flush(self):
        

        self.clear()
        self.delete(self.session_key)
        self.create()
1113331
def cmd_time(self, args):
        ''''''
        tusec = self.master.field('SYSTEM_TIME', 'time_unix_usec', 0)
        if tusec == 0:
            print("No SYSTEM_TIME time available")
            return
        print("%s (%s)\n" % (time.ctime(tusec * 1.0e-6), time.ctime()))
1067236
def flush(self, error=False, prompt=False):
        """"""
        PythonShellWidget.flush(self, error=error, prompt=prompt)
        if self.interrupted:
            self.interrupted = False
            raise KeyboardInterrupt
227614
def timeit(metric, func, *args, **kwargs):
    
    return _client.timeit(metric, func, *args, **kwargs)