Return the list of checked items that do not have any child.
967320
def get_checked(self):
        """"""
        checked = []

        def get_checked_children(item):
            if not self.tag_has("unchecked", item):
                ch = self.get_children(item)
                if not ch and self.tag_has("checked", item):
                    checked.append(item)
                else:
                    for c in ch:
                        get_checked_children(c)

        ch = self.get_children("")
        for c in ch:
            get_checked_children(c)
        return checked
520872
def get_checks(self):
        """"""
        return [
            self.is_date,
            self.is_datetime,
            self.is_integer,
            self.is_float,
            self.default]
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()]
325550
def include_none?(*items)
      items = items.first if items.length == 1 && items.first.kind_of?(Array)
      (self & items).empty?
    end
565445
def has_children(self):
        ""
        return bool([x for x in self.children if not isinstance(x, EmptyLine)])
1117872
def _check_jp2h_child_boxes(self, boxes, parent_box_name):
        """"""
        JP2H_CHILDREN = set(['bpcc', 'cdef', 'cmap', 'ihdr', 'pclr'])

        box_ids = set([box.box_id for box in boxes])
        intersection = box_ids.intersection(JP2H_CHILDREN)
        if len(intersection) > 0 and parent_box_name not in ['jp2h', 'jpch']:
            msg = "A {0} box can only be nested in a JP2 header box."
            raise IOError(msg.format(list(intersection)[0]))

        # Recursively check any contained superboxes.
        for box in boxes:
            if hasattr(box, 'box'):
                self._check_jp2h_child_boxes(box.box, box.box_id)
483223
def _validate_list_data(self, expected, actual):
        """"""
        for e in expected:
            if e not in actual:
                return "expected item {} not found in actual list".format(e)
        return None
920631
function getCheckedList() {
    const checked = [];
    this.state.items.forEach((item, i) => {
        if (item.checked) {
            checked.push(i);
        }
    });
    return checked;
}
731551
def hasChildren(self, parentIndex=QtCore.QModelIndex()):
        
        parentItem = self.getItem(parentIndex, altItem=self.invisibleRootItem)
        return parentItem.hasChildren()
197455
def checkedRecords(self, column=0, parent=None, recurse=True):
        
        output = []
        for item in self.checkedItems(column, parent, recurse):
            try:
                record = item.record()
                if record is not None:
                    output.append(record)
            except AttributeError:
                continue
        return output
841515
def filtered_entries(self):
        """"""
        return [
            e for e in self.entries if not any(fnmatch.fnmatch(e.name.lower(), p.lower()) for p in self.exclude_list)
        ]
543662
def issuperset(self, items):
        
        return all(_compat.map(self._seen.__contains__, items))
1173755
def hidden_item_tags(self):
        
        hidden_item_tags = self.cp.get('ls', 'hidden_item_tags')
        # pylint: disable=no-member
        return [] if hidden_item_tags == '' else [tag.strip() for tag in
                                                  hidden_item_tags.split(',')]
1178104
function without(list, test, removedFn) {
 
   return withoutInner(list, removedFn || noop);
 
   function withoutInner(subList, removedFn) {
      return subList  
         ?  ( test(head(subList)) 
                  ? (removedFn(head(subList)), tail(subList)) 
                  : cons(head(subList), withoutInner(tail(subList), removedFn))
            )
         : emptyList
         ;
   }               
}
12911
@SuppressWarnings("unchecked")
    public static <E> List<E> without(final List<E> list, E ... values) {
        final List<E> valuesList = Arrays.asList(values);
        return filter(list, new Predicate<E>() {
            @Override
            public boolean test(E elem) {
                return !contains(valuesList, elem);
            }
        });
    }
1343410
def get_without_invoice(self):
        
        qs = Transaction.objects.filter(
            children__isnull=True, invoice__isnull=True)
        return qs
440374
public List<?> getNotSelected() {
		List options = getOptions();
		if (options == null || options.isEmpty()) {
			return Collections.EMPTY_LIST;
		}

		List notSelected = new ArrayList(options);
		notSelected.removeAll(getSelected());
		return Collections.unmodifiableList(notSelected);
	}