Generates a list of all Tasks.
761614
def tasks(self):
        ''''''
        tasks_response = self.get_request('tasks/')
        return [Task(self, tjson['task']) for tjson in tasks_response]
2897
def do_running_tasks(self, arg):
        
        for task in asyncio.Task.all_tasks(loop=self.loop):
            _LOGGING.info(task)
1358424
def setup_tasks(self, tasks):
        
        task_classes = []
        for task in tasks:
            category, namespace, name = task.split(".")
            try:
                cls = find_in_registry(category=category, namespace=namespace, name=name)[0]
            except TypeError:
                log.error("Could not find the task with category.namespace.name {0}".format(task))
                raise TypeError
            task_classes.append(cls)
        self.tasks = task_classes
459581
function getAllTasks(directories, options) {
	const allTasks = getAllAliases(options);
	for (const dir of directories) {
		const tasks = glob.sync(`${dir}/*/index.js`);
		tasks.forEach(filename => {
			const taskName = path.basename(path.dirname(filename));
			if (!allTasks[taskName]) {
				const module = require(filename);
				allTasks[taskName] = module.description || '';
			}
		});
	}
	return allTasks;
}
460856
def get_all_tasks(self, course):
        
        tasks = self.get_readable_tasks(course)
        output = {}
        for task in tasks:
            try:
                output[task] = self.get_task(course, task)
            except:
                pass
        return output
1019221
def tasks(self, task_cls=None):
		
		result = []
		for tasks in self.__registry.values():
			result.extend(tasks)

		if task_cls is not None:
			result = filter(lambda x: issubclass(x, task_cls), result)
		return tuple(result)
152307
def tasks(self):
        """"""
        tasks = set()
        for ctrl in self.controllers.values():
            tasks.update(ctrl.tasks)
        return tasks
866833
def done_tasks(self):
        """"""
        tasks = [task for task in self.all_tasks if task._state != NewTask._PENDING]
        return tasks
1332515
public List<RemoteTask> getAllTasks()
    {
        return tasks.values().stream()
                .flatMap(Set::stream)
                .collect(toImmutableList());
    }
1019490
def list_tasks(collector):
    """"""
    print("Usage: dashmat <task>")
    print("")
    print("Available tasks to choose from are:")
    print("-----------------------------------")
    print("")
    keygetter = lambda item: item[1].label
    tasks = sorted(available_actions.items(), key=keygetter)
    sorted_tasks = sorted(list(tasks), key=lambda item: len(item[0]))
    max_length = max(len(name) for name, _ in sorted_tasks)
    for key, task in sorted_tasks:
        desc = dedent(task.__doc__ or "").strip().split('\n')[0]
        print("\t{0}{1} :-: {2}".format(" " * (max_length-len(key)), key, desc))
    print("")
335138
function generateTaskList (user) {
		
		var text = '';
		
		for (var t = 0; t < user.tasks.length; t++) {
			text = text + '> `' + (t + 1) + '`) ' + user.tasks[t] + '\n';
		}
		
		return text;
		
	}
892907
def list_task_definitions(self):
        
        task_arns = []
        for task_definition_list in self.task_definitions.values():
            task_arns.extend(
                [task_definition.arn for task_definition in task_definition_list])
        return task_arns
887596
def tasks(self):
        
        if self._tasks is None:
            self._tasks = TaskList(self._version, assistant_sid=self._solution['sid'], )
        return self._tasks
1027218
private void writeTasks() throws IOException
   {
      writeAttributeTypes("task_types", TaskField.values());

      m_writer.writeStartList("tasks");
      for (Task task : m_projectFile.getChildTasks())
      {
         writeTask(task);
      }
      m_writer.writeEndList();
   }
162755
def task(name, deps = None, fn = None):
	""""""
	if callable(deps):
		fn = deps
		deps = None

	if not deps and not fn:
		logger.log(logger.red("The task '%s' is empty" % name))
	else:
		tasks[name] = [fn, deps]
902023
def generate_all_deps(self, target: Target):
        """"""
        yield from (self.targets[dep_name]
                    for dep_name in self.generate_dep_names(target))
1183100
function() {
        self.tasksCount = 0;
        var list = [], i = 0;
        for(var t in self) {
            if( typeof(self[t]) == 'function') {
                list[i] = {
                    func: self[t],
                    cb: hasCallback(self[t])
                }
                ++i
            }
        }
        run(list)
    }