function to find active (not marked as finished) iterations 

		Returns
		-------
			list: all active iteration objects (empty if there are none)
351945
def active_iterations(self):
		

		l = list(filter(lambda idx: not self.iterations[idx].is_finished, range(len(self.iterations))))
		return(l)
264878
def getActiveAxes(self):
        """"""
        active = []
        for i in range(len(self._axisId)):
            if self._menu.IsChecked(self._axisId[i]):
                active.append(i)
        return active
185336
def get_all_active(self):
        
        now = timezone.now()
        return self.select_related().filter(active_datetime__lte=now,
                                              inactive_datetime__gte=now).order_by('active_datetime')
866367
@Transactional
	public List<ProcessInstance> getActiveProcesses() {
		if (log.isDebugEnabled()) {
			getAllProcesses();
		}
		Query query = m_entityManager.createNamedQuery("ActiveProcesses");
		@SuppressWarnings("unchecked")
		List<ProcessInstance> result = query.getResultList();
		if (log.isDebugEnabled()) {
			for (ProcessInstance processInstance:result) {
				log.debug("processInstanceId={} processName={} taskId={} status={}",processInstance.getId(),processInstance.getProcessDefinitionName(),processInstance.getTaskId(), processInstance.getStatus());
			}
			log.debug("found {} active processes",result.size());
		}
		return result;
	}
1098096
def is_active(self):
        """"""
        if self._queue.exhausted:
            return False
        return any(ch.is_active for ch in self._refs.values())
43909
def getActiveAxes(self):
        
        names = sorted(k for k in self.keys() if self[k]!=0)
        return names
836241
def get_active_window(self):
        
        window_ret = window_t(0)
        _libxdo.xdo_get_active_window(self._xdo, ctypes.byref(window_ret))
        return window_ret.value
312486
def has_active_condition(self, condition, instances):
        
        return_value = None
        for instance in instances + [None]:
            if not self.can_execute(instance):
                continue
            result = self.is_active(instance, condition)
            if result is False:
                return False
            elif result is True:
                return_value = True
        return return_value
422525
def get_active_ajax_datatable(self):
        
        data = getattr(self.request, self.request.method)
        datatables_dict = self.get_datatables(only=data['datatable'])
        return list(datatables_dict.values())[0]
1307847
def get_active_sessions(self):
        
        for last_timestamp, i, events in self.recently_active:
            yield Session(events[-1].user, unpack_events(events))
870283
def get_records(self):
        
        # Won't be able to find new records.
        if self.exhausted:
            return []

        # Already caught up, just the one call please.
        if self.empty_responses >= CALLS_TO_REACH_HEAD:
            return self._apply_get_records_response(self.session.get_stream_records(self.iterator_id))

        # Up to 5 calls to try and find a result
        while self.empty_responses < CALLS_TO_REACH_HEAD and not self.exhausted:
            records = self._apply_get_records_response(self.session.get_stream_records(self.iterator_id))
            if records:
                return records

        return []
994800
def active(self):
        
        projects = []
        r = requests.get(self.api,
                         params={'action': 'query', 'list': 'categorymembers', 'cmpageid': self.active_id,
                                 'cmtype': 'page', 'cmlimit': '500', 'format': 'json'},
                         headers=self.header)
        if r.status_code == 200:
            jsd = r.json()
            projects.append([(x['title'], x['pageid']) for x in jsd['query']['categorymembers']])
            if 'query-continue' in jsd:
                while True:
                    r = requests.get(self.api,
                                     params={'action': 'query', 'list': 'categorymembers',
                                             'cmpageid': self.active_id, 'cmtype': 'page', 'cmlimit': '500',
                                             'cmcontinue': jsd['query-continue']['categorymembers']['cmcontinue'],
                                             'format': 'json'},
                                     headers=self.header)
                    if r.status_code == 200:
                        jsd = r.json()
                        projects.append([(x['title'], x['pageid']) for x in jsd['query']['categorymembers']])
                        if 'query-continue' not in jsd:
                            break
                    else:
                        break
        return projects[0]
616998
def _get_current_output(self):
        
        output = []
        for item in self.items:
            out = self.py3.get_output(item)
            if out and "separator" not in out[-1]:
                out[-1]["separator"] = True
            output += out
        return output
1308373
def last_active(self):
        
        result = None
        for actor in reversed(self.actors):
            if not actor.skip:
                result = actor
                break
        return result
495158
def active(self):
        

        context = self._get_context()
        if not context:
            return super(TornadoScopeManager, self).active

        return context.active
772695
def list(self, limit=None, marker=None, end_marker=None, prefix=None):
        
        return self._manager.list(limit=limit, marker=marker,
                end_marker=end_marker, prefix=prefix)
224243
def get_only_active_packages(packages):
        

        active_packages = []

        for package in packages:
            if package['isActive']:
                active_packages.append(package)

        return active_packages