Gets the task assignees
545507
def assignees(self):
        
        if not self.can_update():
            self._tcex.handle_error(910, [self.type])

        for a in self.tc_requests.assignees(self.api_type, self.api_sub_type, self.unique_id):
            yield a
562769
@Nullable
	private TaskSlot getTaskSlot(AllocationID allocationId) {
		Preconditions.checkNotNull(allocationId);

		return allocationIDTaskSlotMap.get(allocationId);
	}
379641
@Service
    public List<Task> getTasks(String taskType, String startKey, Integer count) {
        return executionService.getTasks(taskType, startKey, count);
    }
730512
def get_tasks(self):
        
        tasks = collections.OrderedDict()
        for dep in self.ordered_dependencies:
            tasks[dep.name] = dep.task

        return tasks
99129
@Override
  public Map<JobId, Task> getTasks() {
    final Map<JobId, Task> tasks = Maps.newHashMap();
    for (final Map.Entry<String, Task> entry : this.tasks.getNodes().entrySet()) {
      final JobId id = jobIdFromTaskPath(entry.getKey());
      tasks.put(id, entry.getValue());
    }
    return tasks;
  }
357450
def get_task_workers(self, task_name=None, json_obj=None):
        
        if task_name is None and json_obj is None:
            raise ValueError('Either task_name or json_obj should be provided')

        if json_obj is None:
            json_obj = self.get_task_detail2(task_name)
        return WorkerDetail2.extract_from_json(json_obj, client=self._client, parent=self)
507705
public Iterator<JobTaskVertex> getTaskVertices() {

		final Collection<JobTaskVertex> coll = this.taskVertices.values();

		return coll.iterator();
	}
934692
def items(self):
        
        return {dep.task: value for dep, value in self._result.items()}.items()
408851
def _get_tasks_by_queue(self):
        """"""
        task_map = {}
        _checker = None

        # Ask the persistence engine for an Async to use for checking if the
        # context is complete.
        if self._persistence_engine:
            _checker = self._persistence_engine.context_completion_checker

        for async in self._tasks:
            queue = async.get_queue()
            if _checker:
                async.update_options(_context_checker=_checker)

            task = async.to_task()
            task_map.setdefault(queue, []).append(task)

        return task_map
499617
public int getAvailableSlots(TaskType taskType) {
    int availableSlots = 0;
    if (taskType == TaskType.MAP) {
      if (LOG.isDebugEnabled()) {
        LOG.debug(trackerName + " getAvailSlots:" +
        		     " max(m)=" + status.getMaxMapSlots() + 
        		     " occupied(m)=" + status.countOccupiedMapSlots());
      }
      availableSlots = status.getAvailableMapSlots();
    } else {
      if (LOG.isDebugEnabled()) {
        LOG.debug(trackerName + " getAvailSlots:" +
                  " max(r)=" + status.getMaxReduceSlots() + 
                  " occupied(r)=" + status.countOccupiedReduceSlots());
      }
      availableSlots = status.getAvailableReduceSlots();
    }
    return availableSlots;
  }
972369
def list_tasks(collector, tasks, **kwargs):
    """"""
    print("Available tasks to choose from are:")
    print("Use the --task option to choose one")
    print("")
    keygetter = lambda item: item[1].label
    tasks = sorted(tasks.items(), key=keygetter)
    for label, items in itertools.groupby(tasks, keygetter):
        print("--- {0}".format(label))
        print("----{0}".format("-" * len(label)))
        sorted_tasks = sorted(list(items), 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.description or "").strip().split('\n')[0]
            print("\t{0}{1} :-: {2}".format(" " * (max_length-len(key)), key, desc))
        print("")
762161
function getComponentsTasks(baseTask) {
	var components = getComponents();
	var tasks = [];

	for (index = 0; index < components.length; ++index) {
	    tasks.push(baseTask + '.' + components[index]);
	}

	return tasks;
}
1139636
def _get_task_priority(tasks, task_priority):
    
    if task_priority is None:
        return None
    if is_integer(task_priority):
        return task_priority
    if isinstance(task_priority, basestring):
        if task_priority in tasks:
            return tasks[task_priority].priority

    raise ValueError("Unrecognized task priority '{}'".format(task_priority))
1285777
def gather_candidates(self):
        
        async def slave_task(addr):
            r_manager = await self.env.connect(addr)
            return await r_manager.get_candidates()

        if self._single_env:
            self._candidates = self.env.candidates
        else:
            mgrs = self.get_managers()
            tasks = create_tasks(slave_task, mgrs)
            self._candidates = run(tasks)
142062
def task_queues(self):
        
        if self._task_queues is None:
            self._task_queues = TaskQueueList(self._version, workspace_sid=self._solution['sid'], )
        return self._task_queues
53979
def get_task_subtasks(client, task_id, completed=False):
    '''  '''
    params = {
            'task_id' : int(task_id),
            'completed' : completed,
            }
    response = client.authenticated_request(client.api.Endpoints.SUBTASKS, params=params)
    return response.json()
785125
private static void listAssignmentsByTask(ProjectFile file)
   {
      for (Task task : file.getTasks())
      {
         System.out.println("Assignments for task " + task.getName() + ":");

         for (ResourceAssignment assignment : task.getResourceAssignments())
         {
            Resource resource = assignment.getResource();
            String resourceName;

            if (resource == null)
            {
               resourceName = "(null resource)";
            }
            else
            {
               resourceName = resource.getName();
            }

            System.out.println("   " + resourceName);
         }
      }

      System.out.println();
   }