Retrieves the current status of the message.

See https://developer.telesign.com/docs/messaging-api for detailed API documentation.
358596
function status ($reference_id, array $params = []) {
    return $this->get(sprintf(self::MESSAGING_STATUS_RESOURCE, $reference_id), $params);
  }
622296
public function getStatus()
    {
        switch (strtolower($this->request->status)) {
            case 'success':
                return self::STATUS_COMPLETED;

            case 'pending':
                return self::STATUS_PENDING;

            case 'failure':
                return self::STATUS_FAILED;

            default:
                return self::STATUS_FAILED;
        }
    }
456578
def _status_message_received(self, msg):
        
        if not self._status_received:
            asyncio.ensure_future(self._confirm_status_received(),
                                  loop=self._loop)
898594
public alluxio.grpc.Status getStatus() {
    alluxio.grpc.Status result = alluxio.grpc.Status.valueOf(status_);
    return result == null ? alluxio.grpc.Status.UNKNOWN : result;
  }
160205
@Override
    public String status() {
        MDC.setContextMap(contextMap);
        xlogger.entry();
        try {
            status = getStatus();
        } catch (final DevFailed e) {
            try {
                stateImpl.stateMachine(DeviceState.UNKNOWN);
                statusImpl.statusMachine(DevFailedUtils.toString(e), DeviceState.UNKNOWN);
                status = DevFailedUtils.toString(e);
            } catch (final DevFailed e1) {
                logger.debug(NOT_IMPORTANT_ERROR, e1);
            }
            logger.debug(NOT_IMPORTANT_ERROR, e);
        }
        return status;
    }
777086
def status(self):
        
        if self.request_list.conflict:
            return SolverStatus.failed

        if self.callback_return == SolverCallbackReturn.fail:
            # the solve has failed because a callback has nominated the most
            # recent failure as the reason.
            return SolverStatus.failed

        st = self.phase_stack[-1].status
        if st == SolverStatus.cyclic:
            return SolverStatus.failed
        elif len(self.phase_stack) > 1:
            if st == SolverStatus.solved:
                return SolverStatus.solved
            else:
                return SolverStatus.unsolved
        elif st in (SolverStatus.pending, SolverStatus.exhausted):
            return SolverStatus.unsolved
        else:
            return st
1226105
public static Response getStatusResponse(Response.Status status, String... messages) {
		if (status == null) {
			return Response.status(Response.Status.BAD_REQUEST).build();
		}
		String msg = StringUtils.join(messages, ". ");
		if (StringUtils.isBlank(msg)) {
			msg = status.getReasonPhrase();
		}
		try {
			return GenericExceptionMapper.getExceptionResponse(status.getStatusCode(), msg);
		} catch (Exception ex) {
			logger.error(null, ex);
			return Response.status(Response.Status.BAD_REQUEST).build();
		}
	}
1250332
def status(self):
        
        data = self._read()
        self._status = YubiKeyUSBHIDStatus(data)
        return self._status
15208
def _get_event_status(self, message):
        
        status = None

        if message.event_status == LRR_EVENT_STATUS.TRIGGER:
            status = True
        elif message.event_status == LRR_EVENT_STATUS.RESTORE:
            status = False

        return status
992289
def get_status(self):
        """"""
        try:
            request = requests.get(
                '{}/{}/'.format(self.resource, URI), timeout=self.timeout)
            raw_data = request.json()
            # Doesn't always work !!!!!
            #self._mac = next(iter(self.raw_data))
            self.data = raw_data[self._mac]
            return self.data
        except (requests.exceptions.ConnectionError, ValueError):
            raise exceptions.MyStromConnectionError()
958185
public function getStatusString()
    {
        if (array_key_exists($this->status, TicketMessageInterface::STATUSES)) {
            return TicketMessageInterface::STATUSES[$this->status];
        }

        return TicketMessageInterface::STATUSES[0];
    }
759758
def request_status(self):
        ''''''
        self.sendcommand(Vendapin.REQUEST_STATUS)
        # wait for the reply
        time.sleep(1)
        response = self.receivepacket()
        if self.was_packet_accepted(response):
            return Vendapin.READY
        else:
            return self.parsedata(response)[0]
206147
def get_status(id)
			
			if id == nil || id == ""
				return nil
			end			
			
			result = get(@protocol + WebServicesBaseURLGet + "getstatus.ashx?id=" + GrabzIt::Utility.nil_check(id))

			doc = REXML::Document.new(result)

			processing = doc.root.elements["Processing"].text()
			cached = doc.root.elements["Cached"].text()
			expired = doc.root.elements["Expired"].text()
			message = doc.root.elements["Message"].text()

			return ScreenShotStatus.new((processing == TrueString), (cached == TrueString), (expired == TrueString), message)
		end
192634
def status(self):
        
        if isinstance(self.attrs['State'], dict):
            return self.attrs['State']['Status']
        return self.attrs['State']
971561
def status(self):
        ''''''
        self.status_callcount += 1
        self.last_bored = time.time() # status entertains us
        return("status called %(status_callcount)d times.  My target positions=%(packets_mytarget)u  Other target positions=%(packets_mytarget)u" %
               {"status_callcount": self.status_callcount,
                "packets_mytarget": self.packets_mytarget,
                "packets_othertarget": self.packets_othertarget,
               })
382811
def get_status(self, response, finished=False):
        """"""
        for line in response.split("\n"):
            if line.strip() in self.status_mapping:
                return self.status_mapping[line.strip()]
        return None
559970
def status_message(self):
        

        msg = None
        if self.last_ddns_response in response_messages.keys():
            return response_messages.get(self.last_ddns_response)

        if 'good' in self.last_ddns_response:
            ip = re.search(r'(\d{1,3}\.?){4}', self.last_ddns_response).group()
            msg = "SUCCESS: DNS hostname IP (%s) successfully updated." % ip
        elif 'nochg' in self.last_ddns_response:
            ip = re.search(r'(\d{1,3}\.?){4}', self.last_ddns_response).group()
            msg = "SUCCESS: IP address (%s) is up to date, nothing was changed. " \
                  "Additional 'nochg' updates may be considered abusive." % ip
        else:
            msg = "ERROR: Ooops! Something went wrong !!!"

        return msg