Get the status of the report and its sub-reports.

        :rtype: str
        :return: report status ('passed', 'failed' or 'error')
551202
def get_status(self):
        '''
        
        '''
        status = self.get('status')
        if status == Report.PASSED:
            for sr_name in self._sub_reports:
                sr = self._sub_reports[sr_name]
                sr_status = sr.get_status()
                reason = sr.get('reason')
                if sr_status == Report.ERROR:
                    self.error(reason)
                    break
                if sr_status == Report.FAILED:
                    self.failed(reason)
                    break
            status = self.get('status')
        return status
728439
def get_status(self):
        
        url = self.base_url + '/status'
        try:
            r = requests.get(url, timeout=10)
            return r.json()
        except RequestException as err:
            raise Client.ClientError(err)
745533
def status(self):
        
        if 'sandbox_type' in self.engine.data:
            if self.engine.sandbox_type == 'none':
                return False
            return True
        return False
174477
def _request_status(self):
        
        if self.item_id:
            return True

        response = self.con.get(self.monitor_url)
        if not response:
            return False

        data = response.json()

        self.status = data.get('status', 'inProgress')
        self.completion_percentage = data.get(self._cc('percentageComplete'),
                                              0)
        self.item_id = data.get(self._cc('resourceId'), None)

        return self.item_id is not None
1223440
def get_status(self):
        
        entries = self.__query('/samlp:LogoutResponse/samlp:Status/samlp:StatusCode')
        if len(entries) == 0:
            return None
        status = entries[0].attrib['Value']
        return status
256662
def status():
    
    import pdb; pdb.set_trace()
    branch = git.branch
    issue = jira.get_issue(branch)
    if not issue:
        return

    # Print the title
    title = issue.fields.summary
    print "(%s) %s" % (branch, title)

    # Print the status
    status = issue.fields.status.name
    assignee = issue.fields.assignee.name
    in_progress = jira.get_datetime_issue_in_progress(issue)

    if in_progress:
        in_progress_string = in_progress.strftime("%a %x %I:%M %p")
        print '  Status: %s as of %s' % (status, in_progress_string)
    else:
        print '  Status: %s' % status

    print '  Assignee: %s' % assignee

    # Print the worklogs

    # Get the timespent and return 0m if it does not exist
    time_spent = '0m'
    try:
        time_spent = issue.fields.timetracking.timeSpent
    except:
        pass

    worklogs = jira.get_worklog(issue)
    print "\nTime logged (%s):" % time_spent
    if worklogs:
        for worklog in worklogs:
            worklog_hash = worklog.raw

            author = worklog_hash['author']['name']

            time_spent = worklog_hash.get('timeSpent', '0m')

            created = dateutil.parser.parse(worklog_hash['started'])
            created_pattern = '%a %x         '  # Adding extra space for formatting
            if not created.hour == created.minute == created.second == 0:
                created = created.astimezone(tzlocal())
                created_pattern = '%a %x %I:%M %p'
            comment = worklog_hash.get('comment', '<no comment>')

            updated_string = created.strftime(created_pattern)
            print "  %s - %s (%s): %s" % (updated_string, author, time_spent, comment)
    else:
        print "  No worklogs"

    cycle_time = jira.get_cycle_time(issue)
    if cycle_time:
        print '\nCycle Time: %.1f days' % cycle_time

    # Print the time elapsed since the last mark
    elapsed_time = jira.get_elapsed_time(issue)
    if elapsed_time:
        print '\n\033[0;32m%s elapsed\033[00m (use "jtime log ." to log elapsed time or "jtime log <duration> (ex. 30m, 1h etc.)" to log a specific amount of time)' % (elapsed_time)
    else:
        print '\n\033[0;32m0m elapsed\033[00m'
950992
def get_status(self):
        '''
        
        '''
        jobs = Job.objects.filter(push=self).filter(
            Q(failure_classification__isnull=True) |
            Q(failure_classification__name='not classified')).exclude(tier=3)

        status_dict = {}
        for (state, result, total) in jobs.values_list(
                'state', 'result').annotate(
                    total=Count('result')):
            if state == 'completed':
                status_dict[result] = total
            else:
                status_dict[state] = total
        if 'superseded' in status_dict:
            # backward compatability for API consumers
            status_dict['coalesced'] = status_dict['superseded']

        return status_dict
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
435807
def status(self, indices=None):
        
        path = self.conn._make_path(indices, (), '_status', allow_all_indices=False)
        return self.conn._send_request('GET', path)
1371071
async def get_status(self, filters=None, utc=False):
        
        client_facade = client.ClientFacade.from_connection(self.connection())
        return await client_facade.FullStatus(filters)
864520
def passed(self):
        '''
        
        '''
        self.set_status(Report.PASSED)
        if 'reason' in self._data_fields:
            del self._data_fields['reason']
661628
def get_results(self):
        

        return {'status': self.status,
                'error_msg': self.error_msg,
                'k': self.k,
                'x': self.x,
                'lam': self.lam*self.obj_sca,
                'nu': self.nu*self.obj_sca,
                'mu': self.mu*self.obj_sca,
                'pi': self.pi*self.obj_sca}
134932
def GetStatusInformation(self):
    
    status = processing_status.TasksStatus()

    with self._lock:
      status.number_of_abandoned_tasks = len(self._tasks_abandoned)
      status.number_of_queued_tasks = len(self._tasks_queued)
      status.number_of_tasks_pending_merge = (
          len(self._tasks_pending_merge) + len(self._tasks_merging))
      status.number_of_tasks_processing = len(self._tasks_processing)
      status.total_number_of_tasks = self._total_number_of_tasks

    return status
383072
def show_status(self, status):
        
        statuses = self.get_statuses()
        statuses = [x for x in statuses if x['value'] == status]
        if len(statuses) == 0:
            raise Exception("Unknown status value")
        else:
            return statuses[0]
1172074
def status(self):
        
        response = self._get(url.status)
        self._check_response(response, 200)
        return self._create_response(response)
180407
async def getStats(self):
        
        merged = RTCStatsReport()
        coros = [x.getStats() for x in (self.getSenders() + self.getReceivers())]
        for report in await asyncio.gather(*coros):
            merged.update(report)
        return merged
900754
def status_get():
    
    cmd = ['status-get', "--format=json", "--include-data"]
    try:
        raw_status = subprocess.check_output(cmd)
    except OSError as e:
        if e.errno == errno.ENOENT:
            return ('unknown', "")
        else:
            raise
    else:
        status = json.loads(raw_status.decode("UTF-8"))
        return (status["status"], status["message"])