This returns a string for each status
512431
def _get_str(task_dict, extra_indent):
    
    summary_length = execution_summary().summary_length

    lines = []
    task_names = sorted(task_dict.keys())
    for task_family in task_names:
        tasks = task_dict[task_family]
        tasks = sorted(tasks, key=lambda x: str(x))
        prefix_size = 8 if extra_indent else 4
        prefix = ' ' * prefix_size

        line = None

        if summary_length > 0 and len(lines) >= summary_length:
            line = prefix + "..."
            lines.append(line)
            break
        if len(tasks[0].get_params()) == 0:
            line = prefix + '- {0} {1}()'.format(len(tasks), str(task_family))
        elif _get_len_of_params(tasks[0]) > 60 or len(str(tasks[0])) > 200 or \
                (len(tasks) == 2 and len(tasks[0].get_params()) > 1 and (_get_len_of_params(tasks[0]) > 40 or len(str(tasks[0])) > 100)):
            """
            This is to make sure that there is no really long task in the output
            """
            line = prefix + '- {0} {1}(...)'.format(len(tasks), task_family)
        elif len((tasks[0].get_params())) == 1:
            attributes = {getattr(task, tasks[0].get_params()[0][0]) for task in tasks}
            param_class = tasks[0].get_params()[0][1]
            first, last = _ranging_attributes(attributes, param_class)
            if first is not None and last is not None and len(attributes) > 3:
                param_str = '{0}...{1}'.format(param_class.serialize(first), param_class.serialize(last))
            else:
                param_str = '{0}'.format(_get_str_one_parameter(tasks))
            line = prefix + '- {0} {1}({2}={3})'.format(len(tasks), task_family, tasks[0].get_params()[0][0], param_str)
        else:
            ranging = False
            params = _get_set_of_params(tasks)
            unique_param_keys = list(_get_unique_param_keys(params))
            if len(unique_param_keys) == 1:
                unique_param, = unique_param_keys
                attributes = params[unique_param]
                param_class = unique_param[1]
                first, last = _ranging_attributes(attributes, param_class)
                if first is not None and last is not None and len(attributes) > 2:
                    ranging = True
                    line = prefix + '- {0} {1}({2}'.format(len(tasks), task_family, _get_str_ranging_multiple_parameters(first, last, tasks, unique_param))
            if not ranging:
                if len(tasks) == 1:
                    line = prefix + '- {0} {1}'.format(len(tasks), tasks[0])
                if len(tasks) == 2:
                    line = prefix + '- {0} {1} and {2}'.format(len(tasks), tasks[0], tasks[1])
                if len(tasks) > 2:
                    line = prefix + '- {0} {1} ...'.format(len(tasks), tasks[0])
        lines.append(line)
    return '\n'.join(lines)
1334787
def get_statuses(self, username, offset=0, limit=10):

        

        response = self._req('/user/statuses/', {
            "username" : username,
            'offset' : offset,
            'limit' : limit
        })

        statuses = []

        for item in response['results']:
            s = Status()
            s.from_dict(item)
            statuses.append(s)

        return {
            "results" : statuses,
            "has_more" : response['has_more'],
            "next_offset" : response['next_offset']
        }
979214
public String getStatusString()
	{
		switch (status) {
		case ErrorCodes.NO_ERROR:
			return "connection state is normal";
		case ErrorCodes.CONNECTION_ID:
			return "server could not find active data connection with specified ID";
		case ErrorCodes.DATA_CONNECTION:
			return "server detected error concerning the data connection";
		case ErrorCodes.KNX_CONNECTION:
			return "server detected error concerning the KNX bus/subsystem connection";
		default:
			return "unknown status";
		}
	}
922270
def statuscategories(self):
        
        r_json = self._get_json('statuscategory')
        statuscategories = [StatusCategory(self._options, self._session, raw_stat_json)
                            for raw_stat_json in r_json]
        return statuscategories
233029
def get_jobs_by_status(status)
      r = []
      @group.values.each do |group|
        v = group.get_jobs_by_status(status)
        if v != nil and v != []
          r += v
        end
      end

      return r
    end
192892
def getStatuses(self, repo_user, repo_name, sha):
        
        return self.api.makeRequest(
            ['repos', repo_user, repo_name, 'statuses', sha],
            method='GET')
63307
def do_status(self, arg):
        '''  '''
        info = self.arm.get_info()
        max_len = len(max(info.keys(), key=len))

        print(self.style.theme('\nArm Status'))
        for key, value in info.items():
            print(self.style.help(key.ljust(max_len + 2), str(value)))
        print()
133659
def _parse_status(self, output):
        '''
        
        '''
        parsed = self._parse_machine_readable_output(output)
        statuses = []
        # group tuples by target name
        # assuming tuples are sorted by target name, this should group all
        # the tuples with info for each target.
        for target, tuples in itertools.groupby(parsed, lambda tup: tup[1]):
            # transform tuples into a dict mapping "type" to "data"
            info = {kind: data for timestamp, _, kind, data in tuples}
            status = Status(name=target, state=info.get('state'),
                            provider=info.get('provider-name'))
            statuses.append(status)

        return statuses
213541
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 NoMoreUniqueConnections:
			return "KNXnet/IP tunneling address for connection is not unique";
		case ErrorCodes.KNX_CONNECTION:
			return "server detected error concerning KNX subsystem connection";
		case ErrorCodes.TUNNELING_LAYER:
			return "the requested tunneling layer is not supported";
		case AuthError:
			return "authorization error";
		case NoTunnelingAddress:
			return "requested address is not a tunneling address";
		case ConnectionInUse:
			return "requested address is in use";
		case Error:
			return "undefined error";
		default:
			return "unknown status";
		}
	}
1000332
def status():
    '''
    
    '''
    ret = {}

    cmd = __execute_cmd('riak-admin', 'status')

    for i in cmd['stdout'].splitlines():
        if ':' in i:
            (name, val) = i.split(':', 1)
            ret[name.strip()] = val.strip()

    return ret
714478
function statusToText(status) {
          var words = [];

          if (status.index=='A') {
            words.push({
              code: 'A',
              color: '#00b111',
              title: 'Added'
            });
          }

          if (status.index=='M') {
            words.push({
              code: 'M',
              color: '#9000b1',
              title: 'Modified'
            });
          }

          if (status.index=='R') {
            words.push({
              code: 'R',
              color: '#0065b1',
              title: 'Renamed'
            });
          }

          if (status.index=='!') {
            words.push({
              code: 'I',
              color: '#b16d00',
              title: 'Ignored'
            });
          }

          if (status.index=='C') {
            words.push({
              code: 'C',
              color: '#b16d00',
              title: 'Copied'
            });
          }

          if (status.index==' ') {
            words.push({
              code: ' ',
              color: '#b16d00',
              title: 'Unmodified'
            });
          }

          if (status.index=='D') {
            words.push({
              code: 'D',
              color: '#de2d00',
              title: 'Deleted'
            });
          }

          return words;
        }
481733
def status(self, obj):
        """"""

        data_size = DWORD()
        data = PDWORD()
        opcode_value_type = DWORD()
        self._wlan_query_interface(self._handle, obj['guid'], 6,
                                   byref(data_size), byref(data),
                                   byref(opcode_value_type))

        return status_dict[data.contents.value]
1180191
@Transient
    public String getStatus()
    {
        if(hasFailed()) return FAILED; 
        if(hasSucceeded()) return SUCCESS; 
        if(ignored != 0) return IGNORED; 
        return NOT_RUNNED; 
    }
937073
def get_status(self):
        """"""

        result = ''
        if self._data_struct is not None:
            result = self._data_struct[KEY_STATUS]
        return result
13183
def statuses(self):
        
        r_json = self._get_json('status')
        statuses = [Status(self._options, self._session, raw_stat_json)
                    for raw_stat_json in r_json]
        return statuses
1062097
def status(self):
        """"""
        return {self._acronym_status(l): l for l in self.resp_text.split('\n')
                if l.startswith(self.prefix_status)}
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