find another task's entries
962305
function ( taskName ) {
			var task = grunt.config.get( "bundles" )[taskName];
			var retVal = [];
			if ( task ) {
				var sources = task.modules;
				if ( !sys.isEmpty( sources ) && !sys.isEmpty( sources.src ) ) {
					grunt.log.writeln( "Adding sources for " + taskName );
					retVal = sys.map( grunt.file.expand( sources, sources.src ), function ( item ) {
						return resolvePath( item );
					} );
				}
			}
			return retVal;
		}
1305710
def count(self):
		
		result = 0
		for tasks in self.__registry.values():
			result += len(tasks)
		return result
767586
private long getTaskCumulativeRssmem(TaskAttemptID tid) {
	    ProcessTreeInfo ptInfo = processTreeInfoMap.get(tid);
	    ProcfsBasedProcessTree pTree = ptInfo.getProcessTree();
	    return pTree == null ? 0 : pTree.getCumulativeVmem();
  }
319155
def find_by_id(self, task, params={}, **options): 
        
        path = "/tasks/%s" % (task)
        return self.client.get(path, params, **options)
11209
def [](task_name, scopes=nil)
      task_name = task_name.to_s
      self.lookup(task_name, scopes) or
        enhance_with_matching_rule(task_name) or
        synthesize_file_task(task_name) or
        fail "Don't know how to build task '#{task_name}'"
    end
554203
def extract_followups(task):
    
    callbacks = task.request.callbacks
    errbacks = task.request.errbacks
    task.request.callbacks = None
    return {'link': callbacks, 'link_error': errbacks}
1329137
def check(self):
		
		if self.__next_start is not None:
			utc_now = utc_datetime()
			if utc_now >= self.__next_start:
				result = []

				for task_source in self.__next_sources:
					records = task_source.has_records()
					if records is not None:
						result.extend(records)

				self.__update_all()

				if len(result) > 0:
					return tuple(result)
1320420
def lookup_task(self, task):
        
        if isinstance(task, str):
            try:
                return self[task]
            except KeyError:
                pass
        raise TaskError('Unknown task %s' % task)
755695
def task_search(self, task_str, **kwargs):
        
        self.prune()
        result = collections.defaultdict(dict)
        for task in self._state.get_active_tasks():
            if task.id.find(task_str) != -1:
                serialized = self._serialize_task(task.id, include_deps=False)
                result[task.status][task.id] = serialized
        return result
540617
def tasks(self, name):
        ''''''
        found = self[name]
        if isinstance(found, Shovel):
            return [v for _, v in found.items()]
        return [found]
417565
def tasks(self):
        """"""
        return [StartActionItem(
            self._task,
            i,
            self.state,
            self.path,
            self.raw) for i in range(len(self.raw))]
1144368
def tasks(self):
        
        task_input = {'taskName': 'QueryTaskCatalog'}
        output = taskengine.execute(task_input, self._engine_name, cwd=self._cwd)
        return output['outputParameters']['TASKS']
1318639
def find_all_runs(self, session=None):
        
        with self._session(session) as session:
            return session.query(TaskRecord).all()
14693
def find_task_by_id(self, id, session=None):
        
        with self._session(session) as session:
            return session.query(TaskRecord).get(id)
801960
private List<TaskDef> findAllTaskDefs(Connection tx) {
        final String READ_ALL_TASKDEF_QUERY = "SELECT json_data FROM meta_task_def";

        return query(tx, READ_ALL_TASKDEF_QUERY, q -> q.executeAndFetch(TaskDef.class));
    }
1215781
def list_matching_entries(program, arguments):
    """"""
    output("\n".join(entry.name for entry in program.smart_search(*arguments)))
1028220
function(name, description, action) {
      if (!action) {
        [action, description] = [description, action];
      }
      return tasks[name] = {name, description, action};
    }