Returns the status of the invoice

        STATUSES: pending, completed, cancelled
963118
def confirm(self, token=None):
        
        _token = token if token else self._response.get("token")
        return self._process('checkout-invoice/confirm/' + str(_token))
619084
def deps_status(self):
        """"""
        if not self.deps:
            return [self.S_OK]

        return [d.status for d in self.deps]
725774
async def pendings(self, tasks=None):
        
        tasks = tasks or self.todo_tasks
        await asyncio.gather(*tasks, loop=self.loop)
1313587
def show_status(self):
        
        txt = 'Agent Status:\n'
        print(txt)
        txt += "start_x  = " + str(self.start_x) + "\n"
        txt += "start_y  = " + str(self.start_y) + "\n"
        txt += "target_x = " + str(self.target_x) + "\n"
        txt += "target_y = " + str(self.target_y) + "\n"
        txt += "current_x = " + str(self.current_x) + "\n"
        txt += "current_y = " + str(self.current_y) + "\n"
       
        
        print(self.grd)
        return txt
1253970
def is_finished(self):
        
        self.get_info()

        if 'status' not in self.info:
            return False
        if 'isFinished' not in self.info['status']:
            return False

        return self.info['status']['isFinished']
1049084
def pendingResultsFor( self, ps ):
        """"""
        k = self._parametersAsIndex(ps)
        if k in self._results.keys():
            # filter out pending job ids, which can be anything except dicts
            return [ j for j in self._results[k] if not isinstance(j, dict) ]
        else:
            return []
634193
public STATUS getStatus() {
		if (featureContent.isLoaded()) {
			return STATUS.LOADED;
		}
		if (deferred == null) {
			return STATUS.EMPTY;
		}
		return STATUS.LOADING;
	}
1154831
public function getPaymentStatus()
    {
        $state = $this->getValue('oepaypal_paymentstatus');
        if (empty($state)) {
            $state = self::PAYPAL_ORDER_STATE_COMPLETED;
        }

        return $state;
    }
1941
def status(self):
		

		if self.paid:
			return self.STATUS_PAID
		if self.forgiven:
			return self.STATUS_FORGIVEN
		if self.closed:
			return self.STATUS_CLOSED
		return self.STATUS_OPEN
666375
def num_pending_tasks(self):
        
        return len(self._status_tasks[PENDING]) + len(self._status_tasks[RUNNING])
203166
def _get_calculated_status(self):
        """"""
        if settings.PAGE_SHOW_START_DATE and self.publication_date:
            if self.publication_date > get_now():
                return self.DRAFT

        if settings.PAGE_SHOW_END_DATE and self.publication_end_date:
            if self.publication_end_date < get_now():
                return self.EXPIRED

        return self.status
355489
def get_cancellation_status(brain_or_object, default="active"):
    
    if is_brain(brain_or_object):
        return getattr(brain_or_object, "cancellation_state", default)
    workflows = get_workflows_for(brain_or_object)
    if 'bika_cancellation_workflow' not in workflows:
        return default
    return get_workflow_status_of(brain_or_object, 'cancellation_state')
464798
def pending_work_items(self):
        ""
        pending = self._conn.execute(
            "SELECT * FROM work_items WHERE job_id NOT IN (SELECT job_id FROM results)"
        )
        return (_row_to_work_item(p) for p in pending)
1099755
def status():
    '''
    
    '''
    ret = {}
    apcaccess = _check_apcaccess()
    res = __salt__['cmd.run_all'](apcaccess)
    retcode = res['retcode']
    if retcode != 0:
        ret['Error'] = 'Something with wrong executing apcaccess, is apcupsd running?'
        return ret

    for line in res['stdout'].splitlines():
        line = line.split(':')
        ret[line[0].strip()] = line[1].strip()

    return ret
28097
def get_statuses(self):
        
        return github.PaginatedList.PaginatedList(
            github.CommitStatus.CommitStatus,
            self._requester,
            self._parentUrl(self._parentUrl(self.url)) + "/statuses/" + self.sha,
            None
        )
222922
def checkForFinishedThreads(self):
        ''
        for t in self.unfinishedThreads:
            if not t.is_alive():
                t.endTime = time.process_time()
                if getattr(t, 'status', None) is None:
                    t.status = 'ended'
676449
def get_status(
        status):
    
    if status == SUCCESS:
        return 'SUCCESS'
    elif status == FAILED:
        return 'FAILED'
    elif status == ERR:
        return 'ERR'
    elif status == EX:
        return 'EX'
    elif status == NOT_RUN:
        return 'NOT_RUN'
    elif status == INVALID:
        return 'INVALID'
    elif status == NOT_DONE:
        return 'NOT_DONE'
    else:
        return 'unsupported status={}'.format(
            status)