Running with Results

This example assumes we have a task registered on a running worker.

One method for running a task in Hatchet is to run it and wait for its result. Some example use cases for this type of task trigger include:

Fanout patterns, where a parent fans out work to a number of children, and wants to receive the results of those child tasks and make some decision based on them. For example, if each child run fips a coin, and the parent wants to count up how many heads there were and do something with that information.
Waiting for long-running API calls to complete, such as if calling an LLM. For instance, if you had a part of your product that writes a poem for a user, your backend might run a write_poem task, which in turn calls an LLM, and then your backend would wait for that task to complete and return its result (the poem).

You can use your Task object to run a task and wait for it to complete by calling the run method. This method will block until the task completes and return the result.

examples/child/trigger.py

from examples.child.worker import SimpleInput, child_task

child_task.run(SimpleInput(message="Hello, World!"))

You can also await the result of aio_run:

examples/child/trigger.py

result = await child_task.aio_run(SimpleInput(message="Hello, World!"))

Note that the type of input here is a Pydantic model that matches the input schema of your workflow.

You can use your Task object to run a task and wait for it to complete by calling the run method. This method will return a promise that resolves when the task completes and returns the result.

src/v1/examples/simple/run.ts

const res = await simple.run({
  Message: 'HeLlO WoRlD',
});

console.log(res.TransformedMessage);

You can use your Task object to run a task and wait for it to complete by calling the Run method. This method will block until the task completes and return the result.

examples/v1/run/simple.go

simple := v1_workflows.Simple(hatchet)
result, err := simple.Run(ctx, v1_workflows.SimpleInput{
	Message: "Hello, World!",
})

if err != nil {
	panic(err)
}

fmt.Println(result.TransformedMessage)

Spawning Tasks from within a Task

You can also spawn tasks from within a task. This is useful for composing tasks together to create more complex workflows, fanning out batched tasks, or creating conditional workflows.

You can run a task from within a task by calling the aio_run method on the task object from within a task function. This will associate the runs in the dashboard for easier debugging.

examples/child/simple-fanout.py

@hatchet.task(name="SpawnTask")
async def spawn(input: EmptyModel, ctx: Context) -> dict[str, Any]:
    # Simply run the task with the input we received
    result = await child_task.aio_run(
        input=SimpleInput(message="Hello, World!"),
    )

    return {"results": result}

And that’s it! The parent task will run and spawn the child task, and then will collect the results from its tasks.

You can run a task from within a task by calling the runChild method on the ctx parameter of the task function. This will associate the runs in the dashboard for easier debugging.

src/v1/examples/simple/run.ts

const parent = hatchet.task({
  name: 'parent',
  fn: async (input, ctx) => {
    // Simply call ctx.runChild with the task you want to run
    const child = await ctx.runChild(simple, {
      Message: 'HeLlO WoRlD',
    });

    return {
      result: child.TransformedMessage,
    };
  },
});

You can run a task from within a task by calling the Run method on the task object from within a task function. This will associate the runs in the dashboard for easier debugging.

examples/v1/workflows/simple.go

simple := Simple(hatchet)

parent := factory.NewTask(
	create.StandaloneTask{
		Name: "parent-task",
	}, func(ctx worker.HatchetContext, input SimpleInput) (*SimpleResult, error) {

		// Run the child task
		child, err := workflow.RunChildWorkflow(ctx, simple, SimpleInput{Message: input.Message})
		if err != nil {
			return nil, err
		}

		// Transform the input message to lowercase
		return &SimpleResult{
			TransformedMessage: child.TransformedMessage,
		}, nil
	},
	hatchet,
)

Running Tasks in Parallel

Sometimes you may want to run multiple tasks concurrently. Here’s how to do that in each language:

Since the aio_run method returns a coroutine, you can spawn multiple tasks in parallel and await using asyncio.gather.

examples/child/trigger.py

result1 = child_task.aio_run(SimpleInput(message="Hello, World!"))
result2 = child_task.aio_run(SimpleInput(message="Hello, Moon!"))

#  gather the results of the two tasks
results = await asyncio.gather(result1, result2)

#  print the results of the two tasks
print(results[0]["transformed_message"])
print(results[1]["transformed_message"])

Since the run method returns a promise, you can spawn multiple tasks in parallel and await using Promise.all.

src/v1/examples/simple/run.ts

const res1 = simple.run({
  Message: 'HeLlO WoRlD',
});

const res2 = simple.run({
  Message: 'Hello MoOn',
});

const results = await Promise.all([res1, res2]);

console.log(results[0].TransformedMessage);
console.log(results[1].TransformedMessage);

You can run multiple tasks in parallel by calling Run multiple times in goroutines and using a sync.WaitGroup to wait for them to complete.

examples/v1/run/simple.go

var results []string
var resultsMutex sync.Mutex
var errs []error
var errsMutex sync.Mutex

wg := sync.WaitGroup{}
wg.Add(2)

go func() {
	defer wg.Done()
	result, err := simple.Run(ctx, v1_workflows.SimpleInput{
		Message: "Hello, World!",
	})

	if err != nil {
		errsMutex.Lock()
		errs = append(errs, err)
		errsMutex.Unlock()
		return
	}

	resultsMutex.Lock()
	results = append(results, result.TransformedMessage)
	resultsMutex.Unlock()
}()

go func() {
	defer wg.Done()
	result, err := simple.Run(ctx, v1_workflows.SimpleInput{
		Message: "Hello, Moon!",
	})

	if err != nil {
		errsMutex.Lock()
		errs = append(errs, err)
		errsMutex.Unlock()
		return
	}

	resultsMutex.Lock()
	results = append(results, result.TransformedMessage)
	resultsMutex.Unlock()
}()

wg.Wait()

While you can run multiple tasks in parallel using the Run method, this is not recommended for large numbers of tasks. Instead, we recommend using bulk run methods for large parallel task execution.

Introduction Run Without Wait Trigger

We use cookies

Running with Results

Spawning Tasks from within a Task

Running Tasks in Parallel