Returns a list of jobs that are stored in the database.
492203
def get_jobs(self, job_ids = None):
    """"""
    if job_ids is not None and len(job_ids) == 0:
      return []
    q = self.session.query(Job)
    if job_ids is not None:
      q = q.filter(Job.unique.in_(job_ids))
    return sorted(list(q), key=lambda job: job.unique)
827501
def jobs(self):
        
        if self._job_manager is None:
            self._job_manager = JobManager(session=self._session)
        return self._job_manager
789894
def list(self, allJobs=False):
        

        jobs = self.server.call('get', '/job')

        return [Job(job['id'], self.server) for job in jobs if allJobs or self._job_owned(job)]
899121
def get_jobs_by_status(status)
      r = []
      @jobs_by_id.values.each do |i|
        r << i if i.status == status.to_sym || status.to_sym == :all
      end
      return r
    end
1154932
def get_jobs_from_queue(self, queue: str, max_jobs: int) -> List[Job]:
        """"""
        rv = list()
        while len(rv) < max_jobs:
            try:
                job_json_string = self._get_queue(queue).get(block=False)
            except Empty:
                break

            job = Job.deserialize(job_json_string)
            job.status = JobStatus.RUNNING
            rv.append(job)

        return rv
1345316
protected void listJobConfProperties()
  {
    msg("==== JobConf properties:");
    Iterator it = jobConf_.iterator();
    TreeMap sorted = new TreeMap();
    while(it.hasNext()) {
      Map.Entry en = (Map.Entry)it.next();
      sorted.put(en.getKey(), en.getValue());
    }
    it = sorted.entrySet().iterator();
    while(it.hasNext()) {
      Map.Entry en = (Map.Entry)it.next();
      msg(en.getKey() + "=" + en.getValue());
    }
    msg("====");
  }
936978
public List<CarbonJobInfo> getJobList()
	{
		Element statusList = element.getChild("JobStatusList");

		if (statusList != null)
		{
			List<CarbonJobInfo> jobs = new ArrayList<CarbonJobInfo>();

			for (Element job : statusList.getChildren())
			{
				jobs.add(new CarbonJobInfo(job));
			}

			return jobs;
		}
		else if (getJobInfo() != null)
		{
			return Collections.singletonList(getJobInfo());
		}
		else
		{
			return Collections.emptyList();
		}
	}
527584
public Collection<JobEntryInfo> getJobEntryStates()
   {
      HashMap<Integer, JobEntryInfo> infos = new HashMap<Integer, JobEntryInfo>();
      for (JobEntryInfo jobEntry : jobEntries)
      {
         infos.put(jobEntry.getID(), jobEntry);
      }
      return infos.values();
   }
722376
def search(self, jobs: List[Dict[str, str]]) -> None:
        """"""
        if not isinstance(jobs, list):
            raise Exception("Jobs must be of type list.")
        self._log.info("Project: %s" % self.project)
        self._log.info("Processing jobs: %d", len(jobs))
        for _, job in enumerate(jobs):
            self._unfullfilled.put(job)

        for _ in range(self.PROCESSES):
            proc: Process = Process(target=self._job_handler)
            self._processes.append(proc)
            proc.start()

        for proc in self._processes:
            proc.join()

        while not self._fulfilled.empty():
            output: Dict = self._fulfilled.get()
            output.update({'project': self.project})
            self._processed.append(output['domain'])
            self.results.append(output)

            if output['greedy']:
                bonus_jobs: List = list()
                observed: List = list()
                for item in output['results']['emails']:
                    found: str = item.split('@')[1]
                    if found in self._processed or found in observed:
                        continue
                    observed.append(found)
                    base: Dict = dict()
                    base['limit'] = output['limit']
                    base['modifier'] = output['modifier']
                    base['engine'] = output['engine']
                    base['greedy'] = False
                    base['domain'] = found
                    bonus_jobs.append(base)

                if len(bonus_jobs) > 0:
                    self.search(bonus_jobs)

        self._log.info("All jobs processed")
        if self.output:
            self._save()
206433
def ListJobs(self, token=None):
    """"""
    del token
    return [job.cron_job_id for job in data_store.REL_DB.ReadCronJobs()]
1207366
def list_job_ids(self, skip=0, limit=20):
        

        return [str(x["_id"]) for x in self.collection.find(
            {"status": "queued"},
            sort=[("_id", -1 if self.is_reverse else 1)],
            projection={"_id": 1})
        ]
199015
def getnjobs(self, key, **kwargs):
        

        return self.get(key, cast_func=parse_n_jobs, **kwargs)
827220
List<Job> getRemainingJobs() {
    if (mThread.isAlive()) {
      LOG.warn("Internal error: Polling running monitor for jobs");
    }
    synchronized (mJobs) {
      return new ArrayList<Job>(mJobs);
    }
  }
1005883
def list(self):
        '''
        
        '''
        databases = []
        for dbname in os.listdir(self.path):
            databases.append(dbname)
        return list(reversed(sorted(databases)))
383244
public function all() : array
    {
        $jobs = array();

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

        return $jobs;
    }
171985
def job_data(cls, job_id=dummy_job_id, branches=None, **kwargs):
        
        return dict(job_id=job_id, branches=branches or [])
6493
def collection_for_job(cls, job):
        
        return cls.collection(job_model_repr=job.get_model_repr(), identifier=getattr(job, '_cached_identifier', job.identifier.hget()))