Retrieves the (parsed) status from the connection
14292
def status
      logger.info "Retrieving Vagrant status for #{description}"
      output = connection.execute!(:status).stdout
      Derelict::Parser::Status.new(output)
    end
334971
async def get_status_info(self) -> Tuple[str, str, int]:
        """"""
        return await self.gateway.commands.GetStatusInfo()
171428
def status_code(self):
        
        try:
            return self._status_code
        except AttributeError:
            self._status_code = self._response.getcode()
        return self._status_code
94434
def _get_async_status(self, response):
        
        if self._is_empty(response):
            return None
        body = self._as_json(response)
        return body.get('status')
758426
public String getStatusString()
	{
		switch (status) {
		case ErrorCodes.NO_ERROR:
			return "the connection was established successfully";
		case ErrorCodes.CONNECTION_TYPE:
			return "the requested connection type is not supported";
		case ErrorCodes.CONNECTION_OPTION:
			return "one or more connection options are not supported";
		case ErrorCodes.NO_MORE_CONNECTIONS:
			return "could not accept new connection (maximum reached)";
		case ErrorCodes.TUNNELING_LAYER:
			return "the requested tunneling layer is not supported";
		default:
			return "unknown status";
		}
	}
254283
def status()
            joinThread()
            lastconnerror = getCString()
            status = getCString()
            uptime = 0
            begin
                uptime_uint = MiniUPnP.new_uintp()
                r = MiniUPnP.UPNP_GetStatusInfo(@urls.controlURL,
                           @data.servicetype, status, uptime_uint,
                           lastconnerror)
                if r != 0 then
                    raise UPnPException.new, "Error while retriving status info. #{code2error(r)}."
                end
                uptime = MiniUPnP.uintp_value(uptime_uint)
            rescue
                raise
            ensure
                MiniUPnP.delete_uintp(uptime_uint)
            end
            return status.rstrip,lastconnerror.rstrip,uptime
        end
649164
def get_status(address=None):
    
    address = address or (config.dbserver.host, DBSERVER_PORT)
    return 'running' if socket_ready(address) else 'not-running'
1321163
def status(self):
        """"""

        hw_type, name, major, minor, patch, status = self.rpc(0x00, 0x04, result_format="H6sBBBB")

        status = {
            'hw_type': hw_type,
            'name': name.decode('utf-8'),
            'version': (major, minor, patch),
            'status': status
        }

        return status
432645
public int getHTTPStatus() throws InterruptedException, BOSHException {
        if (toThrow != null) {
            throw(toThrow);
        }
        lock.lock();
        try {
            if (!sent) {
                awaitResponse();
            }
        } finally {
            lock.unlock();
        }
        return statusCode;
    }
447995
def status(self, status_id, raise_exception_on_failure=False):
        """"""
        query = {"output": "json", "user_credentials": self.api_key}

        resp = requests.get(
            "%sstatus/%s" % (self._url, status_id), params=query, timeout=self._timeout
        )

        if raise_exception_on_failure and resp.status_code != 200:
            raise DocumentStatusFailure(resp.content, resp.status_code)

        if resp.status_code == 200:
            as_json = json.loads(resp.content)
            if as_json["status"] == "completed":
                as_json["download_key"] = _get_download_key(as_json["download_url"])
            return as_json
        return resp
803413
def status(self):
        
        if not self.created:
            return None
        self.inner().reload()
        return self.inner().status
937073
def get_status(self):
        """"""

        result = ''
        if self._data_struct is not None:
            result = self._data_struct[KEY_STATUS]
        return result
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]
1090637
def get_status(with_version=False):
    """"""
    client = get_status_api()

    with catch_raise_api_exception():
        data, _, headers = client.status_check_basic_with_http_info()

    ratelimits.maybe_rate_limit(client, headers)

    if with_version:
        return data.detail, data.version

    return data.detail
885842
def status(self):
        
        message = self.end_message if self.end_message else self.start_message
        if message:
            return message.contents[ACTION_STATUS_FIELD]
        else:
            return None
1180760
def get_status(self):
        
        status = ctypes.c_int32()
        result = self.library.Par_GetStatus(self.pointer, ctypes.byref(status))
        check_error(result, "partner")
        return status
983801
private void checkStatus(MtasSolrStatus status) throws IOException {
		if (!status.finished()) {
			if (status.error()) {
				status.setFinished();
				if (requestHandler != null) {
					requestHandler.finishStatus(status);
				}
				throw new IOException(status.errorMessage());
			} else if (status.abort()) {
				status.setFinished();
				if (requestHandler != null) {
					requestHandler.finishStatus(status);
				}
				throw new IOException(status.abortMessage());
			}
		}
	}