Get the result of this transfer.
481184
def get_result(self):
        
        while self._result is None:
            if len(self.daplink._commands_to_read) > 0:
                self.daplink._read_packet()
            else:
                assert not self.daplink._crnt_cmd.get_empty()
                self.daplink.flush()

        if self._error is not None:
            # Pylint is confused and thinks self._error is None
            # since that is what it is initialized to.
            # Supress warnings for this.
            # pylint: disable=raising-bad-type
            raise self._error

        assert self._result is not None
        return self._result
186080
def result(self):
        """"""
        # Module(body=[Expr(value=...)])
        return self.eval_(ast.parse(self.expr).body[0].value)
79124
def get_transaction(self, clear=False):
        
        transaction = getattr(self.thread_local, "transaction", None)
        if clear:
            self.thread_local.transaction = None
        return transaction
39252
def result(self, value):
        """"""
        if self._process_result:
            self._result = self._process_result(value)

        self._raw_result = value
1330750
def get(self, timeout=None):
        """"""
        self.wait(timeout)
        if self._state==self.FULFILLED:
            return self.value
        else:
            raise ValueError("Calculation didn't yield a value")
1011037
function() {
    return new Promise(function(onResolve, onReject) {

      const getBalance = async function(){

        const getSTPBalanceResponse = await fundManager.getSTPrimeBalanceOf(utilityChainOwnerAddr);

        if(getSTPBalanceResponse.isSuccess() && (new BigNumber(getSTPBalanceResponse.data.balance)).greaterThan(0)){
          logger.info('* ST\' credited to utility chain owner');
          return onResolve(getSTPBalanceResponse);
        } else {
          logger.info('* Waiting for credit of ST\' to utility chain owner');
          setTimeout(getBalance, 60000);
        }
      };

      getBalance();
    });
  }
110010
def do_GET(self):
        """"""
        f = self.send_head()
        if f:
            self.copyfile(f, self.wfile)
            f.close()
559247
def get_results(self):
        
        return IterResult(self._loop(), self.name, self.argnames,
                          self.sent, self.monitor.hdf5)
599996
def get_results(self, client):
        
        data = self._request('GET', '/results/{}'.format(client))
        return data.json()
604555
def get_result(self, commit, default=MemoteResult()):
        """"""
        assert self._results is not None, \
            "Please call the method `load_history` first."
        return self._results.get(commit, default)
1050336
def get_results(self, request):
        
        super(HierarchicalChangeList, self).get_results(request)

        self._hierarchy.hook_get_results(self)
315406
def transfer(cls, field_mappings, source, destination_factory):
    """"""
    data = dict()
    for index, field_mapping in enumerate(field_mappings):
      try:
        data[field_mapping.destination_name] = field_mapping.get_value(source)
      except Exception as ex:
        raise Exception(
          "Error with mapping #{0} '{1}'->'{2}': {3}".format(
            index,
            field_mapping.source_name,
            field_mapping.destination_name, ex)) from ex
    return destination_factory(data)
895397
public function getResult () : Result
    {
        // Cache
        if ( $this->_Result === null ) :
            $this->calcPossibleRanking();
            $this->calcRankingScore();
            $this->makeRanking();
            $this->conflictInfos();
        endif;

        // Return
        return $this->_Result;
    }
1296710
def get(self, timeout=None):
        
        if timeout is None:
            self._lock.acquire()
        else:
            self._wait(timeout)
        
        res = self.result
        if res[0]:
            return res[1]
        else:
            raise res[1]
239628
def sendResult(self, future):
        """"""
        future = copy.copy(future)

        # Remove the (now) extraneous elements from future class
        future.callable = future.args = future.kargs = future.greenlet = None

        if not future.sendResultBack:
            # Don't reply back the result if it isn't asked
            future.resultValue = None

        self._sendReply(
            future.id.worker,
            pickle.dumps(
                future,
                pickle.HIGHEST_PROTOCOL,
            ),
        )
327341
def result(self):
    
    self.wait()
    if self._fatal_error:
      raise self._fatal_error
    return self._result
1111783
def _process_results():
    """"""
    async = get_current_async()
    callbacks = async.get_callbacks()

    if not isinstance(async.result.payload, AsyncException):
        callback = callbacks.get('success')
    else:
        callback = callbacks.get('error')

        if not callback:
            raise async.result.payload.exception, None, \
                async.result.payload.traceback[2]

    return _execute_callback(async, callback)