Return the results
557384
public function get($toObject = false)
	{
        if(!env('GOOGLE_KEY')) {
            throw new Exception("Need an env key for geo request", 401);
        }

		$this->response = null;
		$this->error = null;

		if($this->c2a()) {
			$response = $this->template($toObject);
		}
		elseif($this->a2c()) {
			$response = $this->template($toObject);
		}
		elseif($this->i2c()) {
			$response = $this->template($toObject);
		}
		elseif($this->p2c()) {
			$response = $this->template($toObject);
		}

		if($response) {
			$this->reset();
			return $response;
		}

		throw new Exception(trans('location::errors.not_enough_data'));
	}
1119845
function getResults () {
  return getHtmls(URLS).then(htmls => {
    return getScrapersResults(SCRAPERS, URLS, htmls).then(results => results)
  })
}
714542
def submit_all(self):
        
        for args in self.task_args:
            self.submit(*args)
        return self.get_results()
504302
def dump(self):
        
        results = []
        for data in self.data():
            results.append(data)
        return results
1017518
def results( self ):
        """"""
        rs = []
        for k in self._results.keys():
            # filter out pending job ids, which can be anything except dicts
            ars = [ res for res in self._results[k] if isinstance(res, dict) ]
            rs.extend(ars)
        return rs
738376
def results(self):
        ""
        cur = self._conn.cursor()
        rows = cur.execute("SELECT * FROM results")
        for row in rows:
            yield (row['job_id'], _row_to_work_result(row))
394754
def __parse_results(self,results):
        
        reslist = []
        cursor = 0
        match  = RE_RESULTS.search(results,cursor)
        while match:
            doc = {}
            doc['bibcode'] = match.group('bibcode')
            doc['confidence'] = self.__get_confidence_level(match.group('confidence'))
            doc['refstring'] = match.group('refstring')
            reslist.append(doc)
            cursor = match.end()
            match  = RE_RESULTS.search(results,cursor)
        return reslist
599996
def get_results(self, client):
        
        data = self._request('GET', '/results/{}'.format(client))
        return data.json()
758811
def results(self, request):
        ""
        results = {}
        form = self.form(request.GET)
        if form.is_valid():
            options = form.cleaned_data
            term = options.get('term', '')
            raw_data = self.get_query(request, term)
            results = self.format_results(raw_data, options)
        return self.response(results)
134867
def model_results(self) -> str:
        
        with open(os.path.join(self.directory, "model.results")) as f:
            return f.read()
1224512
def collect_results(self) -> Optional[Tuple[int, Dict[str, float]]]:
        
        self.wait_to_finish()
        if self.decoder_metric_queue.empty():
            if self._results_pending:
                self._any_process_died = True
            self._results_pending = False
            return None
        decoded_checkpoint, decoder_metrics = self.decoder_metric_queue.get()
        assert self.decoder_metric_queue.empty()
        self._results_pending = False
        logger.info("Decoder-%d finished: %s", decoded_checkpoint, decoder_metrics)
        return decoded_checkpoint, decoder_metrics
627635
def get_results(self):
        
        try:
            stdout, stderr = self._lint()
            # Can't return a generator from a subprocess
            return list(stdout), stderr or []
        except FileNotFoundError as exception:
            # Error if the linter was not found but was chosen by the user
            if self._linter.name in self.config.user_linters:
                error_msg = 'Could not find {}. Did you install it? ' \
                    'Got exception: {}'.format(self._linter.name, exception)
                return [[], [error_msg]]
            # If the linter was not chosen by the user, do nothing
            return [[], []]
1180925
public function fetchResults()
    {
        if (count($this->results) == 0) {
            while ($result = $this->fetchResult()) {
                $this->results[] = $result;
            }
        }

        return $this->results;
    }
337867
def GetResults(self):
    
    results = []
    for hasher in self._hashers:
      logger.debug('Processing results for hasher {0:s}'.format(hasher.NAME))
      result = analyzer_result.AnalyzerResult()
      result.analyzer_name = self.NAME
      result.attribute_name = '{0:s}_hash'.format(hasher.NAME)
      result.attribute_value = hasher.GetStringDigest()
      results.append(result)
    return results
392820
def results(self, *args, **kwargs):
        
        def worker():
            kwargs['page'] = 1
            while True:
                response = self.client(*args, **kwargs)
                if isinstance(response, list):
                    yield response
                    break
                elif _is_page(response):
                    yield response['results']
                    if response['next']:
                        kwargs['page'] += 1
                    else:
                        break
                else:
                    raise NoResultsError(response)

        return itertools.chain.from_iterable(worker())
194189
def get_results():
    """"""
    # store info in a dictionary {name -> shortname}
    res = {}
    session = requests.Session()
    handle_url('http://www.creators.com/comics/cat-seeall.html', session, res)
    save_result(res, json_file)
240397
private function returnOutput()
    {
        $collection = new Collection($this->results);

        switch ($this->output) {
            case 'db':
                return $this->saveToDatabase($collection);
                break;
            case 'collection':
                return $collection;
                break;
            case 'json':
                return $collection->toJson();
                break;
            case 'array':
            default:
                return $collection->toArray();
        }
    }