Return all the currently dependent jobs
497659
def depends(self, offset=0, count=25):
        ''''''
        return self.client('jobs', 'depends', self.name, offset, count)
383244
public function all() : array
    {
        $jobs = array();

        foreach ($this->jobs as $name => $jobBag) {
            $jobs[$name] = $this->getOrMake($name);
        }

        return $jobs;
    }
414879
def jobs(self):
        
        if self._jobs is None:
            self._jobs = JobTable(self.connection, self.database)
        return self._jobs
1145609
async def all_job_results(self) -> List[JobResult]:
        
        keys = await self.keys(result_key_prefix + '*')
        results = await asyncio.gather(*[self._get_job_result(k) for k in keys])
        return sorted(results, key=attrgetter('enqueue_time'))
1128942
def extract_submittable_jobs(waiting):
    
    submittable = set()            # Holds jobs that are able to be submitted
    # Loop over each job, and check all the subjobs in that job's dependency
    # list.  If there are any, and all of these have been submitted, then
    # append the job to the list of submittable jobs.
    for job in waiting:
        unsatisfied = sum([(subjob.submitted is False) for subjob in
                           job.dependencies])
        if unsatisfied == 0:
            submittable.add(job)
    return list(submittable)
943071
def get_jids():
    '''
    
    '''
    log.debug('sdstack_etcd returner <get_jids> called')
    ret = []
    client, path = _get_conn(__opts__)
    items = client.get('/'.join((path, 'jobs')))
    for item in items.children:
        if item.dir is True:
            jid = str(item.key).split('/')[-1]
            ret.append(jid)
    return ret
997066
def _jobs():
    '''
    
    '''
    response = salt.utils.http.query(
        "{0}/scheduler/jobs".format(_base_url()),
        decode_type='json',
        decode=True,
    )
    jobs = {}
    for job in response['dict']:
        jobs[job.pop('name')] = job
    return jobs
440502
private static List<String> getDependencies(Config config) {
    return config.hasPath(ConfigurationKeys.JOB_DEPENDENCIES) ? Arrays
        .asList(config.getString(ConfigurationKeys.JOB_DEPENDENCIES).split(",")) : new ArrayList<>();
  }
1129031
def get_jobs(self, full=None, limit=None, skip=None, start=None, end=None,
                 output_format=None):
        """"""
        method = 'GET'
        endpoint = '/rest/v1/{}/jobs'.format(self.client.sauce_username)
        data = {}
        if full is not None:
            data['full'] = full
        if limit is not None:
            data['limit'] = limit
        if skip is not None:
            data['skip'] = skip
        if start is not None:
            data['from'] = start
        if end is not None:
            data['to'] = end
        if output_format is not None:
            data['format'] = output_format
        if data:
            endpoint = '?'.join([endpoint, urlencode(data)])
        return self.client.request(method, endpoint)
31714
def jobs(opts={})

      opts = { opts => true } if opts.is_a?(Symbol)

      jobs = @jobs.to_a

      if opts[:running]
        jobs = jobs.select { |j| j.running? }
      elsif ! opts[:all]
        jobs = jobs.reject { |j| j.next_time.nil? || j.unscheduled_at }
      end

      tags = Array(opts[:tag] || opts[:tags]).collect(&:to_s)
      jobs = jobs.reject { |j| tags.find { |t| ! j.tags.include?(t) } }

      jobs
    end
1045842
public function getIncomingDependencies(Job $job)
    {
        $jobIds = $this->getJobIdsOfIncomingDependencies($job);
        if (empty($jobIds)) {
            return [];
        }

        return $this->_em->createQuery('SELECT j FROM JMSJobQueueBundle:Job j WHERE j.id IN (:ids)')
            ->setParameter('ids', $jobIds)
            ->getResult();
    }
822649
def get_jids():
    '''
    
    '''
    ret = {}
    for jid, job, _, _ in _walk_through(_job_dir()):
        ret[jid] = salt.utils.jid.format_jid_instance(jid, job)

        if __opts__.get('job_cache_store_endtime'):
            endtime = get_endtime(jid)
            if endtime:
                ret[jid]['EndTime'] = endtime

    return ret
199015
def getnjobs(self, key, **kwargs):
        

        return self.get(key, cast_func=parse_n_jobs, **kwargs)
444501
def get_running_jobs(opts):
    '''
    
    '''

    ret = []
    proc_dir = os.path.join(opts['cachedir'], 'proc')
    if not os.path.isdir(proc_dir):
        return ret
    for fn_ in os.listdir(proc_dir):
        path = os.path.join(proc_dir, fn_)
        data = read_proc_file(path, opts)
        if not data:
            continue
        if not is_pid_healthy(data['pid']):
            continue
        ret.append(data)
    return ret
896326
def get_dependants(self, run):
        
        if run in self._graph.nodes():
            return list(self._graph.successors(run))
        else:
            return []
1340694
def get_jobs(self, recursive=True):
        
        if recursive:
            ret_dict = self.jobs.copy()
            for link in self._links.values():
                ret_dict.update(link.get_jobs(recursive))
            return ret_dict
        return self.jobs
1335420
def getTopologicalOrderingOfJobs(self):
        
        ordering = []
        visited = set()
        def getRunOrder(job):
            #Do not add the job to the ordering until all its predecessors have been
            #added to the ordering
            for p in job._directPredecessors:
                if p not in visited:
                    return
            if job not in visited:
                visited.add(job)
                ordering.append(job)
                list(map(getRunOrder, job._children + job._followOns))
        getRunOrder(self)
        return ordering