app = FastAPI()

tasks = {"foo": "Listen to the Bar Fighters"}


@app.put("/get-or-create-task/{task_id}", status_code=200)
def get_or_create_task(task_id: str, response: Response):
    if task_id not in tasks:
        tasks[task_id] = "This didn't exist before"
        response.status_code = status.HTTP_201_CREATED

  auto* task_iter = static_cast<const tensorflow::CoordinatedTask*>(tasks.data);
  for (size_t i = 0; i < tasks.length; ++i) {
    task_vec[i].set_job_name(task_iter->job_name());
    task_vec[i].set_task_id(task_iter->task_id());
    ++task_iter;
  }
  auto results = coord_agent->GetTaskState(task_vec);
  if (!results.ok()) {
    status->status = results.status();
    return;
  }

				return
			}
			opts.setTask(parsed, task)
		} else if taskids := r.FormValue("taskid"); taskids != "" {
			taskid, err := strconv.ParseUint(taskids, 10, 64)
			if err != nil {
				log.Printf("failed to parse taskid parameter %q: %v", taskids, err)
				return
			}
			task, ok := parsed.summary.Tasks[trace.TaskID(taskid)]
			if !ok {
				log.Printf("failed to find task with id %d", taskid)
				return
			}

	Name string

	// Value is the value of the attribute.
	Value Value
}

// TaskID is the internal ID of a task used to disambiguate tasks (even if they
// are of the same type).
type TaskID uint64

const (
	// NoTask indicates the lack of a task.
	NoTask = TaskID(^uint64(0))

	// BackgroundTask is the global task that events are attached to if there was

        def task1 = taskDetails('task_A')
        def task2 = taskDetails('a:task_A')
        def task3 = taskDetails('a:a:task_A')
        def task4 = taskDetails('B:task_A')
        def task5 = taskDetails('c:task_A')
        def task6 = taskDetails('b:task_a')
        def task7 = taskDetails('a:task_Abc')
        def task8 = taskDetails('task_b')
        _ * target.groups >> ['group']

	type task struct {
		name       string
		parent     *trace.TaskID
		children   []trace.TaskID
		logs       []trace.Log
		goroutines []trace.GoID
	}
	parent := func(id trace.TaskID) *trace.TaskID {
		p := new(trace.TaskID)
		*p = id
		return p
	}
	wantTasks := map[trace.TaskID]task{
		trace.BackgroundTask: {
			// The background task (0) is never any task's parent.

	b1 := g1.Batch(trace.ThreadID(0), 0)
	b1.Event("ProcStatus", trace.ProcID(0), go122.ProcRunning)
	b1.Event("GoStatus", trace.GoID(1), trace.ThreadID(0), go122.GoRunning)
	b1.Event("UserTaskBegin", trace.TaskID(2), trace.TaskID(0) /* 0 means no parent, not background */, "my task", testgen.NoStack)

	g2 := t.Generation(2)

	// That same goroutine emits a task end in the following generation.
	b2 := g2.Batch(trace.ThreadID(0), 5)

			kind trace.EventKind
			task trace.TaskID
			args []string
		}
		want := []evDesc{
			{trace.EventTaskBegin, trace.TaskID(1), []string{"task0"}},
			{trace.EventRegionBegin, trace.TaskID(1), []string{"region0"}},
			{trace.EventRegionBegin, trace.TaskID(1), []string{"region1"}},
			{trace.EventLog, trace.TaskID(1), []string{"key0", "0123456789abcdef"}},
			{trace.EventRegionEnd, trace.TaskID(1), []string{"region1"}},

        def uniqueId = Iterables.getOnlyElement(realizeOps*.details*.taskId as Set)

        when:
        configurationCacheRun(":foo")
        then:
        def realizeOp = buildOperations.only(RealizeTaskBuildOperationType)
        with(realizeOp.details) {
            taskPath == ":foo"
            taskId == uniqueId
            eager == true
        }
    }

		endStack = region.End.Stack()
		endTime = region.End.Time()
		goroutine = region.End.Goroutine()
	}
	if goroutine == trace.NoGoroutine {
		return
	}
	arg := struct {
		TaskID uint64 `json:"taskid"`
	}{
		TaskID: uint64(region.TaskID),
	}
	ctx.AsyncSlice(traceviewer.AsyncSliceEvent{
		SliceEvent: traceviewer.SliceEvent{
			Name:     region.Name,
			Ts:       ctx.elapsed(startTime),