Get the AmCAT status page
519402
def get_status(self):
        """"""
        url = URL.status.format(**locals())
        return self.get_request(url)
957966
def status(cls):
        """"""
        return cls.json_get('%s/status' % cls.api_url, empty_key=True,
                            send_key=False)
645778
def get_system_status(self):
        
        try:
            api_server_status_link = self.api_server + '/status_msg?version=' +\
                version_number
            response = urllib2.urlopen(api_server_status_link, timeout=1)
            status_msg = json.load(response)['status']
        except urllib2.HTTPError:
            status_msg = "Sorry, can't connect to psiturk.org, please check\
                your internet connection.\nYou will not be able to create new\
                hits, but testing locally should work.\n"
        return status_msg
520455
function getOnlineStatus(serverUrlOrServerUrlOptions) {
    if (serverUrlOrServerUrlOptions === void 0) { serverUrlOrServerUrlOptions = init.initOptions.serverUrl; }
    var serverUrl;
    if (_.isString(serverUrlOrServerUrlOptions)) {
        serverUrl = serverUrlOrServerUrlOptions;
    }
    else if (serverUrlOrServerUrlOptions) {
        serverUrl = serverUrlOrServerUrlOptions.serverUrl;
    }
    return server.Server.getInstance(serverUrl).serverInfos;
}
630707
function getStats () {
        pc.getStats(function (res) {
            var items = [];
            var connectionType = {};

            res.result().forEach(function (result) {
                var item = {};
                result.names().forEach(function (name) {
                    item[name] = result.stat(name);
                });
                item.id = result.id;
                item.type = result.type;
                item.timestamp = result.timestamp;

                if (item.type === 'googCandidatePair' && item.googActiveConnection === 'true') {
                    connectionType = {
                        local: {
                            candidateType: item.googLocalCandidateType,
                            ipAddress: item.googLocalAddress
                        },
                        remote: {
                            candidateType: item.googRemoteCandidateType,
                            ipAddress: item.googRemoteAddress
                        },
                        transport: item.googTransportType
                    };

                    return;
                }

                items.push(item);
            });

            traceStats(items);
            window._webdriverrtcTimeout = setTimeout(getStats.bind(window, items), interval);

            if (typeof cb === 'function') {
                cb(connectionType);
                cb = undefined;
            }
        });
    }
1283274
function statusText()
    {
        if ( $this->Progress == 100 )
        {
            return self::STATUS_COMPLETE;
        }

        if ( $this->Progress < 0 )
        {
            return self::STATUS_NOT_STARTED;
        }

        $timeSinceLastReport = time() - $this->LastReportTimestamp;

        if ( $timeSinceLastReport <= self::STATUS_ACTIVE_TIMEOUT )
        {
            return self::STATUS_ACTIVE;
        }

        if ( $timeSinceLastReport <= self::STATUS_DELAYED_TIMEOUT )
        {
            return self::STATUS_DELAYED;
        }

        return self::STATUS_DEAD;
    }
259649
public static function getHTTPStatus() {
        return [
            self::HTTP_STATUS_CONTINUE,
            self::HTTP_STATUS_SWITCHING_PROTOCOLS,
            self::HTTP_STATUS_PROCESSING,
            self::HTTP_STATUS_OK,
            self::HTTP_STATUS_CREATED,
            self::HTTP_STATUS_ACCEPTED,
            self::HTTP_STATUS_NON_AUTHORITATIVE_INFORMATION,
            self::HTTP_STATUS_NO_CONTENT,
            self::HTTP_STATUS_RESET_CONTENT,
            self::HTTP_STATUS_PARTIAL_CONTENT,
            self::HTTP_STATUS_MULTI_STATUS,
            self::HTTP_STATUS_ALREADY_REPORTED,
            self::HTTP_STATUS_IM_USED,
            self::HTTP_STATUS_MULTIPLE_CHOICES,
            self::HTTP_STATUS_MOVED_PERMANENTLY,
            self::HTTP_STATUS_MOVED_TEMPORARILY,
            self::HTTP_STATUS_SEE_OTHER,
            self::HTTP_STATUS_NOT_MODIFIED,
            self::HTTP_STATUS_USE_PROXY,
            self::HTTP_STATUS_TEMPORARY_REDIRECT,
            self::HTTP_STATUS_PERMANENT_REDIRECT,
            self::HTTP_STATUS_BAD_REQUEST,
            self::HTTP_STATUS_UNAUTHORIZED,
            self::HTTP_STATUS_PAYMENT_REQUIRED,
            self::HTTP_STATUS_FORBIDDEN,
            self::HTTP_STATUS_NOT_FOUND,
            self::HTTP_STATUS_METHOD_NOT_ALLOWED,
            self::HTTP_STATUS_NOT_ACCEPTABLE,
            self::HTTP_STATUS_PROXY_AUTHENTICATION_REQUIRED,
            self::HTTP_STATUS_REQUEST_TIME_OUT,
            self::HTTP_STATUS_CONFLICT,
            self::HTTP_STATUS_GONE,
            self::HTTP_STATUS_LENGTH_REQUIRED,
            self::HTTP_STATUS_PRECONDITION_FAILED,
            self::HTTP_STATUS_REQUEST_ENTITY_TOO_LARGE,
            self::HTTP_STATUS_REQUEST_URI_TOO_LONG,
            self::HTTP_STATUS_UNSUPPORTED_MEDIA_TYPE,
            self::HTTP_STATUS_REQUESTED_RANGE_UNSATISFIABLE,
            self::HTTP_STATUS_EXPECTATION_FAILED,
            self::HTTP_STATUS_UNPROCESSABLE_ENTITY,
            self::HTTP_STATUS_LOCKED,
            self::HTTP_STATUS_METHOD_FAILURE,
            self::HTTP_STATUS_UPGRADE_REQUIRED,
            self::HTTP_STATUS_PRECONDITION_REQUIRED,
            self::HTTP_STATUS_TOO_MANY_REQUESTS,
            self::HTTP_STATUS_REQUEST_HEADER_FIELDS_TOO_LARGE,
            self::HTTP_STATUS_INTERNAL_SERVER_ERROR,
            self::HTTP_STATUS_NOT_IMPLEMENTED,
            self::HTTP_STATUS_BAD_GATEWAY_OU_PROXY_ERROR,
            self::HTTP_STATUS_SERVICE_UNAVAILABLE,
            self::HTTP_STATUS_GATEWAY_TIME_OUT,
            self::HTTP_STATUS_HTTP_VERSION_NOT_SUPPORTED,
            self::HTTP_STATUS_VARIANT_ALSO_NEGOTIATES,
            self::HTTP_STATUS_INSUFFICIENT_STORAGE,
            self::HTTP_STATUS_LOOP_DETECTED,
            self::HTTP_STATUS_NOT_EXTENDED,
            self::HTTP_STATUS_NETWORK_AUTHENTICATION_REQUIRED,
        ];
    }
636306
function getState(cm, pos) {
	pos = pos || cm.getCursor("start");
	var stat = cm.getTokenAt(pos);
	if(!stat.type) return {};

	var types = stat.type.split(" ");

	var ret = {},
		data, text;
	for(var i = 0; i < types.length; i++) {
		data = types[i];
		if(data === "strong") {
			ret.bold = true;
		} else if(data === "variable-2") {
			text = cm.getLine(pos.line);
			if(/^\s*\d+\.\s/.test(text)) {
				ret["ordered-list"] = true;
			} else {
				ret["unordered-list"] = true;
			}
		} else if(data === "atom") {
			ret.quote = true;
		} else if(data === "em") {
			ret.italic = true;
		} else if(data === "quote") {
			ret.quote = true;
		} else if(data === "strikethrough") {
			ret.strikethrough = true;
		} else if(data === "comment") {
			ret.code = true;
		} else if(data === "link") {
			ret.link = true;
		} else if(data === "tag") {
			ret.image = true;
		} else if(data.match(/^header(\-[1-6])?$/)) {
			ret[data.replace("header", "heading")] = true;
		}
	}
	return ret;
}
1356038
function reportStatus(status) {
        if (DEBUG && status !== "success") inspectArgs("reportStatus: ", status);

        if (status === "fail") {
            var err = `capturejs: cannot access ${option.uri}: failed to open page`;
            console.error(err);
            phInstance.exit();
            process.nextTick(callback, err);
        } else {
            return phPage;
        }
    }
1053999
def gmmStatus():
    """"""
    a = TpPd(pd=0x3)
    b = MessageType(mesType=0x20)  # 00100000
    c = GmmCause()
    packet = a / b / c
    return packet
995262
function getPreviewStatus(statuses, config) {
  const previewContext = config.getIn(['backend', 'preview_context']);
  return statuses.find(({ context }) => {
    return isPreviewContext(context, previewContext);
  });
}
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()
849471
def tile_status(self):
        """"""
        stat = self.status()

        flags = stat['status']

        # FIXME: This needs to stay in sync with lib_common: cdb_status.h
        status = {}
        status['debug_mode'] = bool(flags & (1 << 3))
        status['configured'] = bool(flags & (1 << 1))
        status['app_running'] = bool(flags & (1 << 0))
        status['trapped'] = bool(flags & (1 << 2))

        return status
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
700796
def query_status(self):
        ''''''
        try:
            data = self.api_iface._api_get(self.link)
            self._update_details(data)
        except APIError as e:
            print("API error: ")
            for key,value in e.data.iteritems:
                print(str(key) + ": " + str(value))
650081
function getStatsAdapter() {

    ///
  // Get Stats using the older API. Used by all current versions
  // of Chrome.
  //
    function getStatsOldAPI(peerConnection, completion) {

      peerConnection.getStats(function(rtcStatsReport) {

        var stats = [];
        rtcStatsReport.result().forEach(function(rtcStat) {

          var stat = {};

          rtcStat.names().forEach(function(name) {
            stat[name] = rtcStat.stat(name);
          });

          // fake the structure of the "new" RTC stat object
          stat.id = rtcStat.id;
          stat.type = rtcStat.type;
          stat.timestamp = rtcStat.timestamp;
          stats.push(stat);
        });

        completion(null, stats);
      });
    }

  ///
  // Get Stats using the newer API.
  //
    function getStatsNewAPI(peerConnection, completion) {

      peerConnection.getStats(null, function(rtcStatsReport) {

        var stats = [];
        rtcStatsReport.forEach(function(rtcStats) {
          stats.push(rtcStats);
        });

        completion(null, stats);
      }, completion);
    }

    if (OT.$.browserVersion().name === 'Firefox' || OTPlugin.isInstalled()) {
      return getStatsNewAPI;
    } else {
      return getStatsOldAPI;
    }
  }
1039711
def get_status(self, mxit_id, scope='profile/public'):
        
        status = _get(
            token=self.oauth.get_app_token(scope),
            uri='/user/public/statusmessage/' + urllib.quote(mxit_id)
        )

        if status.startswith('"') and status.endswith('"'):
            status = status[1:-1]

        return status