A list of all `EPSFStar` objects stored in this object that have
        not been excluded from fitting, including those that comprise
        linked stars (i.e. `LinkedEPSFStar`), as a flat list.
184313
def all_good_stars(self):
        

        stars = []
        for star in self.all_stars:
            if star._excluded_from_fit:
                continue
            else:
                stars.append(star)

        return stars
1144118
public static DescriptorExtensionList<View,ViewDescriptor> all() {
        return Jenkins.getInstance().<View,ViewDescriptor>getDescriptorList(View.class);
    }
430758
def ensure_dtraj_list(dtrajs):
    

    """
    if isinstance(dtrajs, list):
        # elements are ints? then wrap into a list
        if is_list_of_int(dtrajs):
            return [np.array(dtrajs, dtype=int)]
        else:
            for i, dtraj in enumerate(dtrajs):
                dtrajs[i] = ensure_dtraj(dtraj)
            return dtrajs
    else:
        return [ensure_dtraj(dtrajs)]
759096
private List<UnitFactor> list(UnitFactor factor) {
    List<UnitFactor> list = new ArrayList<>();
    list.add(factor);
    return list;
  }
558284
def ensure_list(obj):
        
        if not obj:
            return []
        elif isinstance(obj, (str, unicode, bytes, bytearray)):
            return [obj]
        elif hasattr(obj, '__iter__') or hasattr(obj, '__getitem__'):
            return list(obj)
        else:
            return [obj]
1337369
def _flatten(self, iterator, **filter_options):
        '''
        
        '''
        resp = list()
        for entry in iterator:
            for tup in entry:
                if self._matches_filter(tup, **filter_options):
                    resp.append(tup)
        return resp
102811
def pairs(self):
        
        keys = self._clean.keys()
        pairs = []
        for key in keys:
            pairs.append([key, self.obj[key]])

        return self._wrap(pairs)
645840
def getPartitions(self):
        
        partitions = []
        for analysis in self.getAnalyses(full_objects=True):
            if analysis.getSamplePartition() not in partitions:
                partitions.append(analysis.getSamplePartition())
        return partitions
894167
def flatten_list(lobj):
    
    ret = []
    for item in lobj:
        if isinstance(item, list):
            for sub_item in flatten_list(item):
                ret.append(sub_item)
        else:
            ret.append(item)
    return ret
1023773
public static <T> List<T> list(boolean isLinked, Iterator<T> iter) {
		final List<T> list = list(isLinked);
		if (null != iter) {
			while (iter.hasNext()) {
				list.add(iter.next());
			}
		}
		return list;
	}
250661
def ensure_dtraj_list(dtrajs):
    

    """
    if isinstance(dtrajs, list):
        # elements are ints? then wrap into a list
        if is_list_of_int(dtrajs):
            return [np.array(dtrajs, dtype=int)]
        else:
            for i in range(len(dtrajs)):
                dtrajs[i] = ensure_dtraj(dtrajs[i])
            return dtrajs
    else:
        return [ensure_dtraj(dtrajs)]
19954
def flatten_items(items, recurse=False):
    

    if not items:
        return items
    elif not hasattr(items, '__iter__'):
        return items
    elif isinstance(items, _flattened_types):
        return items

    flattened = []
    for item in items:
        if item and hasattr(item, '__iter__') and not isinstance(item, _flattened_types):
            flattened.extend(flatten_items(item, True) if recurse else item)
        else:
            flattened.append(item)

    return type(items)(flattened) if isinstance(items, _flatten_types) else flattened
880293
def _to_list(sc, cols, converter=None):
    
    if converter:
        cols = [converter(c) for c in cols]
    return sc._jvm.PythonUtils.toList(cols)
1099506
def _collapse_list_of_sets(self, sets):
        ''''''
        found = True
        while found:
            found = False
            to_intersect = None
            for i in range(len(sets)):
                for j in range(len(sets)):
                    if i == j:
                        continue
                    elif sets[i].intersection(sets[j]):
                        to_intersect = i, j
                        break

                if to_intersect is not None:
                    break

            if to_intersect is not None:
                found = True
                sets[i].update(sets[j])
                sets.pop(j)

        return sets
1339406
def object_results(self, object_results):
        
        if _is_iterable_non_string(object_results):
            self._object_results = list(object_results)
        elif object_results is None:
            self._object_results = []
        else:
            self._object_results = [object_results]
716285
def as_list(self, fs_type=None):
        """"""
        entries = self._entries
        if fs_type:
            entries = filter(lambda a: a.fs_type == fs_type, entries)
        return entries
400548
protected final List<?> list(Object... datas) {
    List<Object> items = CollectUtils.newArrayList(datas.length);
    for (Object obj : datas) {
      if (obj instanceof Class<?>) {
        items.add(buildInnerReference((Class<?>) obj));
      } else {
        items.add(obj);
      }
    }
    return items;
  }