Refresh the data used by get_value.

        Only needed if you're not using subscriptions.
507852
def refresh(self):
        
        j = self.vera_request(id='sdata', output_format='json').json()
        scenes = j.get('scenes')
        for scene_data in scenes:
            if scene_data.get('id') == self.scene_id:
                self.update(scene_data)
317841
def refresh(self, key, ttl, prev_value=None, prev_index=None,
                timeout=None):
        
        return self.adapter.set(key, ttl=ttl, refresh=True,
                                prev_value=prev_value, prev_index=prev_index,
                                timeout=timeout)
384220
def update(self, value=None):
        ''

        if value is not None and value is not UnknownLength:
            if (self.maxval is not UnknownLength
                and not 0 <= value <= self.maxval):

                raise ValueError('Value out of range')

            self.currval = value


        if not self._need_update(): return
        if self.start_time is None:
            raise RuntimeError('You must call "start" before calling "update"')

        now = time.time()
        self.seconds_elapsed = now - self.start_time
        self.next_update = self.currval + self.update_interval
        self.fd.write(self._format_line() + '\r')
        self.last_update_time = now
1295202
async def refresh_data(self):
        """"""
        queue = await self.get_queue()
        history = await self.get_history()
        totals = {}
        for k in history:
            if k[-4:] == 'size':
                totals[k] = self._convert_size(history.get(k))
        self.queue = {**totals, **queue}
303298
def updateCurrentValue(self, value):
        
        try:
            method = getattr(self._targetObject, self._setter)
        except AttributeError:
            return
        
        try:
            method(unwrapVariant(value))
        except:
            return
731733
public function refresh()
    {
        $this->_response = $this->getIndex()->requestEndpoint(new \Elasticsearch\Endpoints\Indices\Stats());
        $this->_data = $this->getResponse()->getData();
    }
976954
def refresh_interval(self, refresh_interval):
        
        if isinstance(refresh_interval, int) and refresh_interval > 0:
            self._refresh_interval = refresh_interval
        else:
            self._refresh_interval = None
210944
public function RefreshDataFromDatabase()
    {
        $this->ClearInternalCache();
        $sActiveLanguageId = self::getLanguageService()->getActiveLanguageId();
        if (null !== $sActiveLanguageId) {
            $this->SetLanguage($sActiveLanguageId);
        }
        $bEnableObjectCaching = $this->GetEnableObjectCaching();
        $this->SetEnableObjectCaching(false);
        $this->Load($this->id);
        $this->SetEnableObjectCaching($bEnableObjectCaching);
    }
636988
def refresh(self, fields=None, **kwargs):
        
        cond = self.c[self._primary_field]==self._key
        query = self.filter(cond, **kwargs)
        if not fields:
            fields = list(self.table.c)
        
        v = query.values_one(*fields)
        if not v:
            raise NotFound('Instance <{0}:{1}> can not be found'.format(self.tablename, self._key))
        
        d = self._data_prepare(v.items())
        self.update(**d)
        self.set_saved()
125692
def refresh(self, using=None, **kwargs):
        
        return self._get_connection(using).indices.refresh(index=self._name, **kwargs)
965343
protected function refresh()
    {
        if (Session::get()->exists(App::get()->shortName . $this->sessionKey)) {
            $state = Session::get()->value(App::get()->shortName . $this->sessionKey);
            $this->_userData = $state['vars'];
            $this->_rights = $state['rights'];
            $this->connected = (count($this->_userData) > 0);
        }
    }
1006908
function queryRefresh(queryList) {
    var queryListImpl = queryList;
    if (queryList.dirty) {
        queryList.reset(queryListImpl._valuesTree);
        queryList.notifyOnChanges();
        return true;
    }
    return false;
}
764127
def reload(self):
        
        self.load(self.api.get(self.objName, self.key))
1261265
def refresh(self, include_fields=None, exclude_fields=None,
        extra_fields=None):
        
        # pylint: disable=protected-access
        r = self.bugzilla._getbug(self.bug_id,
            include_fields=include_fields, exclude_fields=exclude_fields,
            extra_fields=self._bug_fields + (extra_fields or []))
        # pylint: enable=protected-access
        self._update_dict(r)
1114199
public function refresh()
    {
        $keyName = $this->keyName;

        //If we don't have a key we cant refresh
        if (! isset($this->$keyName))
        {
            return;
        }

        $dbItem = self::getOneByKey($this->getKey());

        //Check if we are already the same
        if ($dbItem == $this)
        {
            return;
        }

        //Get values from DB & check if they match. Update if needed
        foreach (get_object_vars($dbItem) as $var => $val)
        {
            if ($this->$var !== $val)
            {
                $this->$var = $val;
            }
        }
    }
966101
def refresh(self, *args, **kwargs):
        
        self.prjbrws.set_model(self.create_prj_model())
        if self.get_current_file():
            self.set_to_current()
        else:
            self.init_selection()
155081
def refresh(self):
        
        data = self.machine.raw_snapshot_data(self.name)
        self._save(data)