Get the status of a KPL button.
19440
def kpl_status(self, address, group):
        """"""
        addr = Address(address)
        device = self.plm.devices[addr.id]
        device.states[group].async_refresh_state()
800455
def status(self, column=None, value=None, **kwargs):
        
        return self._resolve_call('GIC_STATUS', column, value, **kwargs)
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
364236
def status(context):
    """"""
    context.obj.find_repo_type()
    context.obj.call([context.obj.vc_name, 'status'])
676449
def get_status(
        status):
    
    if status == SUCCESS:
        return 'SUCCESS'
    elif status == FAILED:
        return 'FAILED'
    elif status == ERR:
        return 'ERR'
    elif status == EX:
        return 'EX'
    elif status == NOT_RUN:
        return 'NOT_RUN'
    elif status == INVALID:
        return 'INVALID'
    elif status == NOT_DONE:
        return 'NOT_DONE'
    else:
        return 'unsupported status={}'.format(
            status)
737763
def check_status(self, **kwargs):
        
        for work in self:
            work.check_status()

        if kwargs.pop("show", False):
            self.show_status(**kwargs)
177553
def status(self, message, *args, **kwargs):
    """"""
    if self.isEnabledFor(GNUPG_STATUS_LEVEL):
        self._log(GNUPG_STATUS_LEVEL, message, args, **kwargs)
440059
def status(self, status_in):
        """"""
        if isinstance(status_in, PIDStatus):
            status_in = [status_in, ]
        return self.filter(
            self._filtered_pid_class.status.in_(status_in)
        )
1343866
def get_status(self, response, finished=False):
        """"""
        status_pos = 0
        for line in response.split("\n"):
            if line.startswith('JOBID'):
                try:
                    status_pos = line.find('STAT')
                except ValueError:
                    return None
            else:
                status = line[status_pos:].split()[0]
                if status in self.status_mapping:
                    return self.status_mapping[status]
        return None
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()
1118019
def getStatus(self) :
        """"""
        if self.status == CONST.COLLECTION_LOADING_STATUS :
            return "loading"
        elif self.status == CONST.COLLECTION_LOADED_STATUS :
            return "loaded"
        elif self.status == CONST.COLLECTION_DELETED_STATUS :
            return "deleted"
        elif self.status == CONST.COLLECTION_UNLOADED_STATUS :
            return "unloaded"
        elif self.status == CONST.COLLECTION_NEWBORN_STATUS :
            return "newborn"
        else :
            raise ValueError("The collection has an Unknown status %s" % self.status)
1064801
def status(self):
        """"""
        status_request = etcdrpc.StatusRequest()
        status_response = self.maintenancestub.Status(
            status_request,
            self.timeout,
            credentials=self.call_credentials,
            metadata=self.metadata
        )

        for m in self.members:
            if m.id == status_response.leader:
                leader = m
                break
        else:
            # raise exception?
            leader = None

        return Status(status_response.version,
                      status_response.dbSize,
                      leader,
                      status_response.raftIndex,
                      status_response.raftTerm)
888834
def status
      {
        :extended   => get_if_handleable(raw[:extended_status_message]),
        :code       => raw[:status_code].to_i,
        :message    => get_if_handleable(raw[:status_message]),
        :updated_at => get_if_handleable(raw[:status_update_date])
      }.reject { |k, v| v.nil? }
    end
1259944
def widget_status(self):
        """"""
        widget_status_list = []
        for i in self.widgetlist:
            widget_status_list += [[i.name, i.status]]
        return widget_status_list
85355
def status(self, *args, priority=0):
        ''
        k = (priority, args)
        self.statuses[k] = self.statuses.get(k, 0) + 1

        if self.statusHistory:
            prevpri, prevargs, prevn = self.statusHistory[-1]
            if prevpri == priority and prevargs == args:
                self.statusHistory[-1][2] += 1
                return True

        self.statusHistory.append([priority, args, 1])
        return True
57228
def update_button_status(self):
        
        # enable/disable ok button
        if len(self.displaced.currentField()) > 0:
            self.button_box.button(
                QtWidgets.QDialogButtonBox.Ok).setEnabled(True)
        else:
            self.button_box.button(
                QtWidgets.QDialogButtonBox.Ok).setEnabled(False)
190302
def _get_state(pkg):
    '''
    
    '''
    cmd = ['opkg', 'status']
    cmd.append(pkg)
    out = __salt__['cmd.run'](cmd, python_shell=False)
    state_flag = ''
    for line in salt.utils.itertools.split(out, '\n'):
        if line.startswith('Status'):
            _status, _state_want, state_flag, _state_status = line.split()

    return state_flag