Return the list of action check list dictionary.

        :return: The list of action check list dictionary.
        :rtype: list
343367
def action_checklist(self):
        
        actions = []
        exposure = definition(self.exposure.keywords.get('exposure'))
        actions.extend(exposure.get('actions'))

        hazard = definition(self.hazard.keywords.get('hazard'))
        actions.extend(hazard.get('actions'))

        actions.extend(specific_actions(hazard, exposure))
        return actions
977578
def _get_sorted_actions_list(self, raw_set):
        
        keys_list = raw_set.keys()
        # actions_dicts_l is the final list which will contain the the
        # dictionaries with the actions.
        # The dictionaries will be sorted by the index obtained in the
        # template.
        actions_dicts_l = []
        # a_count is a counter which is incremented every time a new action is
        # added to the list, so we can give it a index.
        a_count = 0
        # actions_list will contain the keys starting with 'action-' but sorted
        # by their index
        actions_list = self._get_sorted_action_keys(keys_list)
        for key in actions_list:
            # Getting the key for otherWS element
            otherWS_key = 'otherWS-'+str(a_count)
            # Getting the value for otherWS selector
            otherWS = raw_set.get(otherWS_key, '')
            # Getting the key for analyst element
            analyst_key = 'analyst-'+str(a_count)
            # Getting the value for analyst
            analyst = raw_set.get(analyst_key, '')
            # Getting which analysis should has its result set
            setresulton_key = 'setresulton-'+str(a_count)
            setresulton = raw_set.get(setresulton_key, '')
            # Getting the discrete result to set
            setresultdiscrete_key = 'setresultdiscrete-'+str(a_count)
            setresultdiscrete = raw_set.get(setresultdiscrete_key, '')
            # Getting the numeric result to set
            setresultvalue_key = 'setresultvalue-'+str(a_count)
            setresultvalue = raw_set.get(setresultvalue_key, '')
            # Getting the local analysis id
            local_id_key = 'an_result_id-'+str(a_count)
            local_id = raw_set.get(local_id_key, '')
            # Getting the local analysis id
            worksheettemplate_key = 'worksheettemplate-'+str(a_count)
            worksheettemplate = raw_set.get(worksheettemplate_key, '')
            # Getting the visibility in report
            showinreport_key = 'showinreport-'+str(a_count)
            showinreport = raw_set.get(showinreport_key, '')
            # Getting the analysis to show or hide in report
            setvisibilityof_key = 'setvisibilityof-'+str(a_count)
            setvisibilityof = raw_set.get(setvisibilityof_key, '')
            # Building the action dict
            action_dict = {
                'action': raw_set[key],
                'act_row_idx': a_count,
                'otherWS': otherWS,
                'worksheettemplate': worksheettemplate,
                'analyst': analyst,
                'setresulton': setresulton,
                'setresultdiscrete': setresultdiscrete,
                'setresultvalue': setresultvalue,
                'an_result_id': local_id,
                'showinreport': showinreport,
                'setvisibilityof': setvisibilityof,
                }
            # Saves the action as a new dict inside the actions list
            actions_dicts_l.append(action_dict)
            a_count += 1
        return actions_dicts_l
732608
def checks_list():
    '''
    
    '''
    application_url = _get_application_url()
    log.debug('[uptime] get checks')
    jcontent = requests.get('{0}/api/checks'.format(application_url)).json()
    return [x['url'] for x in jcontent]
317027
def profiles(self):
        
        output = []
        for act in self.actions():
            if ( isinstance(act, XViewProfileAction) ):
                output.append(act.profile())
        return output
1150411
def all_actions(self):
        
        count = self.get_count_action()
        page = 1
        while True:  # не цикл for, потому как не уверен, что всё норм будет с API
            actions = self.get_action_list(page=page)
            for action in actions:
                yield action
            page += 1
            if len(actions) < options.ACTIONS_ON_PAGE or page > math.ceil(count / options.ACTIONS_ON_PAGE):
                break
1169951
def get_actions(self):
        """"""
        self._read_state_variables()
        actions = []
        nodes = self.root.iterfind(
            './/ns:action', namespaces={'ns': self.namespace})
        for node in nodes:
            action = FritzAction(self.service.service_type,
                                 self.service.control_url)
            action.name = node.find(self.nodename('name')).text
            action.arguments = self._get_arguments(node)
            actions.append(action)
        return actions
88569
def check_presses(self):
        
        pressed = []
        for button, state in self.buttons.items():
            if state.was_pressed_since_last_check:
                pressed.append(button)
                state.was_pressed_since_last_check = False
        self.__presses = ButtonPresses(pressed)
        return self.__presses
784573
def _list_checkers(self):
        
        classes = set()
        for checker_group in checkers.checkers.itervalues():
            for checker in checker_group:
                classes.add(checker)

        max_width = 0
        for clazz in classes:
            max_width = max(max_width, len(clazz.tool), len(clazz.__name__))

        for clazz in sorted(classes):
            status, _ = commands.getstatusoutput('which %s' % clazz.tool)
            result = 'missing' if status else 'installed'
            version = '' if status else clazz.get_version()
            print '%s%s%s%s' % (
                clazz.__name__.ljust(max_width + 1),
                clazz.tool.ljust(max_width + 1),
                result.ljust(max_width + 1),
                version,
            )
1347106
def update(self, action: torch.Tensor) -> 'ChecklistStatelet':
        
        checklist_addition = (self.terminal_actions == action).float()
        new_checklist = self.checklist + checklist_addition
        new_checklist_state = ChecklistStatelet(terminal_actions=self.terminal_actions,
                                                checklist_target=self.checklist_target,
                                                checklist_mask=self.checklist_mask,
                                                checklist=new_checklist,
                                                terminal_indices_dict=self.terminal_indices_dict)
        return new_checklist_state
253469
def getChecked(self):
        
        attrs = []
        layout = self.layout()
        for i in range(layout.count()):
            w = layout.itemAt(i).widget()
            if w.isChecked():
                attrs.append(str(w.text()))
        return attrs
1059875
def verification_checks(self):
        
        if self._verification_checks is None:
            self._verification_checks = VerificationCheckList(self._version, service_sid=self._solution['sid'], )
        return self._verification_checks
855076
def getDict(self):
        
        # We are going to have to return the dict so let's
        # first make sure all of our models are up to date with the values in
        # the GUI right now.
        badList = self.checkSetSaveEntries(doSave=False)
        if badList:
            self.processBadEntries(badList, self.taskName, canCancel=False)
        return self._taskParsObj.dict()
40493
def list(self):
        
        response = self.client._make_request('/accounts')
        response = response.json()
        return self.client._list_response(response)
369087
def _get_action_strings(cls,
                            possible_actions: List[List[ProductionRule]],
                            action_indices: Dict[int, List[List[int]]]) -> List[List[List[str]]]:
        
        all_action_strings: List[List[List[str]]] = []
        batch_size = len(possible_actions)
        for i in range(batch_size):
            batch_actions = possible_actions[i]
            batch_best_sequences = action_indices[i] if i in action_indices else []
            # This will append an empty list to ``all_action_strings`` if ``batch_best_sequences``
            # is empty.
            action_strings = [[batch_actions[rule_id][0] for rule_id in sequence]
                              for sequence in batch_best_sequences]
            all_action_strings.append(action_strings)
        return all_action_strings
1238984
def _list(self):
        
        if get_order_args().get(self.__class__.__name__):
            order_column, order_direction = get_order_args().get(
                self.__class__.__name__
            )
        else:
            order_column, order_direction = "", ""
        page = get_page_args().get(self.__class__.__name__)
        page_size = get_page_size_args().get(self.__class__.__name__)
        get_filter_args(self._filters)
        widgets = self._get_list_widget(
            filters=self._filters,
            order_column=order_column,
            order_direction=order_direction,
            page=page,
            page_size=page_size,
        )
        form = self.search_form.refresh()
        self.update_redirect()
        return self._get_search_widget(form=form, widgets=widgets)
1272094
def list_():
    '''
    
    '''
    ret = {}
    cmd = 'cpan -l'
    out = __salt__['cmd.run'](cmd).splitlines()
    for line in out:
        comps = line.split()
        ret[comps[0]] = comps[1]
    return ret
399499
def checkedIndexes( self ):
        
        if ( not self.isCheckable() ):
            return []
        
        model  = self.model()
        return [i for i in range(self.count()) if model.item(i).checkState()]