Refresh the model

        :returns: None
        :rtype: None
        :raises: None
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()
1369607
def refresh(self) -> None:
        
        logger.info('refreshing sources')
        for source in list(self):
            self.unload(source)

        if not os.path.exists(self.__registry_fn):
            return

        # TODO add version
        with open(self.__registry_fn, 'r') as f:
            registry = yaml.load(f)
        assert isinstance(registry, list)

        for source_description in registry:
            source = Source.from_dict(source_description)
            self.load(source)

        logger.info('refreshed sources')
223316
def refresh(self):
        
        if not self._client:
            return
        current_volumes = self._client.volumes()['Volumes']
        self.clear()
        if current_volumes:
            self.update(vol['Name'] for vol in current_volumes)
531953
def refresh(self):
        
        strawpoll_response = requests.get('{api_url}/{poll_id}'.format(api_url=api_url, poll_id=self.id))
        raise_status(strawpoll_response)
        self.status_code = strawpoll_response.status_code
        self.response_json = strawpoll_response.json()
        self.id = self.response_json['id']
        self.title = self.response_json['title']
        self.options = self.response_json['options']
        self.votes = self.response_json['votes']
        self.captcha = self.response_json['captcha']
        self.dupcheck = self.response_json['dupcheck']
        self.url = 'https://www.strawpoll.me/{id}'.format(id=self.id)
        self.results_url = 'https://www.strawpoll.me/{id}/r'.format(id=self.id)
1192059
def refresh(self):
        """"""
        d = self.request('get', self.instance_url())
        return d.addCallback(self.refresh_from).addCallback(lambda _: self)
555176
def refresh(header = self.class::DEFAULT_REQUEST_HEADER)
      ensure_client && ensure_uri
      response = @client.rest_get(@data['uri'], header, @api_version)
      body = @client.response_handler(response)
      set_all(body)
      self
    end
85889
def refresh(self, scope_list=None):
        
        request_data = self.get_refresh_token_params(scope_list)
        res = self._session.post(**request_data)
        if res.status_code != 200:
            raise APIException(
                request_data['url'],
                res.status_code,
                response=res.content,
                request_param=request_data,
                response_header=res.headers
            )
        json_res = res.json()
        self.update_token(json_res)
        return json_res
1147353
def _refresh_state(self):
    
    if self._is_complete:
      return

    if not self._future:
      raise Exception('Please implement this in the derived class')

    if self._future.done():
      self._is_complete = True
      self._end_time = datetime.datetime.utcnow()
      try:
        self._result = self._future.result()
      except Exception as e:
        message = str(e)
        self._fatal_error = JobError(location=traceback.format_exc(), message=message,
                                     reason=str(type(e)))
426642
def refresh(self):
        

        if self.object_id is None:
            url = self.build_url(self._endpoints.get('default_drive'))
        else:
            url = self.build_url(
                self._endpoints.get('get_drive').format(id=self.object_id))

        response = self.con.get(url)
        if not response:
            return False

        drive = response.json()

        self._update_data({self._cloud_data_key: drive})
        return True
1095950
def refresh(self):
        
        r = fapi.get_workspace(self.namespace, self.name, self.api_url)
        fapi._check_response_code(r, 200)
        self.data = r.json()
        return self
1289541
def refresh(self):
        
        data = {
            'grant_type': 'refresh_token',
            'refresh_token': self._token.refresh_token
        }

        response = self.http_client.post(self.URL, data=data, auth=(self.client_id, self.client_secret))
        response.raise_for_status()
        self._token = Token.from_json(response.json())
592689
def refresh(self):
        # type: () -> None
        """"""
        from pykechain.client import API_EXTRA_PARAMS
        src = self._client.reload(self, extra_params=API_EXTRA_PARAMS['activity'])
        self.__dict__.update(src.__dict__)
1122058
public void refresh() {
        this.getRefreshLock().writeLock().lock();

        try {
            this.authenticate();
        } catch (BoxAPIException e) {
            this.notifyError(e);
            this.getRefreshLock().writeLock().unlock();
            throw e;
        }

        this.notifyRefresh();
        this.getRefreshLock().writeLock().unlock();
    }
393778
def refresh(self):
        
        self.log.info('starting the ``refresh`` method')

        astorbgz = self._download_astorb()
        astorbDictList = self._parse_astorb_database_file(astorbgz)
        self._import_astorb_to_database(astorbDictList)

        self.log.info('completed the ``refresh`` method')
        return None
231552
def refresh(self):
        
        resp = self._imgur._send_request(self._INFO_URL)
        self._populate(resp)
        self._has_fetched = True
357474
def refresh(self):
      '''
      '''
      # There's no GET endpoint for steps, so get the parent guide and loop
      # through its steps until we find the right one.
      response = requests.get('%s/guides/%s' % (API_BASE_URL, self.guideid))
      attributes = response.json()
      
      for step in attributes['steps']:
         if step['stepid'] == self.stepid:
            self._update(step)
            return
      raise Exception('Step with id %s not found in guide %s.' \
                      % (self.stepid, self.guideid))
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)