Skip to main content

Async behavior tree

Project description


Async behavior tree for python

Alpha Status (project and code refactorisation)

This project was generated with cookiecutter using jacebrowning/template-python.

Unix Build Status Windows Build Status Coverage Status Scrutinizer Code Quality PyPI Version PyPI License

Versions following Semantic Versioning

What's a behavior tree ?

Unlike a Finite State Machine, a Behaviour Tree is a tree of hierarchical nodes that controls the flow of decision and the execution of "tasks" or, as we will call them further, "Actions". -- behaviortree

If your new (or not) about behavior tree, you could spend some time on this few links:

Few implementation libraries:

  • task_behavior_engine A behavior tree based task engine written in Python
  • pi_trees a Python/ROS library for implementing Behavior Trees
  • pr_behavior_tree A simple python behavior tree library based on coroutines
  • btsk Behavior Tree Starter Kit
  • behave A behavior tree implementation in Python

Why another library so ?

When you study behavior tree implementation, reactive node, dynamic change, runtime execution, etc ... at a moment you're build more or less something that mimic an evaluator 'eval/apply' or a compilator, with a complex hierachical set of class. All complexity came with internal state management, global variable, callback etc ... This break the simplicity of initial design.

What I find usefull with behavior tree:

  • clarity of expression
  • node tree representation
  • possibility to reuse behavior
  • add external measure to dynamicaly change a behavior, a first step on obervable pattern...

As I've used OOP for years (very long time), I will try to avoid class tree and prefer using the power of a single function to obtain what I want: add metadata on a sematic construction, deal with closure and function in parameters or in return value...

And a last reason, more personal, it that i would explore python expressivity.

So, in this module, I purpose you to use the concept of coroutines, and their mecanisms to manage the execution flow. By this way:

  • we reuse simple language idiom to manage state, parameter, etc
  • no design constraint on action implementation
  • most of language build block could be reused

You could build expression like this:

async def a_func():
    """A great function"""
    return "a"

async def b_decorator(child_value, other=""):
    """A great decorator..."""
    return f"b{child_value}{other}"

assert run(decorate(a_func, b_decorator)) == "ba"

This expression apply b_decorator on function a_func. Note that decorate(a_func, b_decorator) is not an async function, only action, or condition are async function.

Few guidelines of this implementation:

  • In order to mimic all NodeStatus (success, failure, running), I replace this by truthy/falsy meaning of evaluation value. A special dedicated exception decorate standard exception in order to give them a Falsy meaning.
  • Blackboard pattern, act as a manager of context variable for behavior tree. With python 3, please... simply use contextvars !
  • In order to be able to build a sematic tree, I've introduce a metadata tuple added on function implementation.

The rest is just implementation details..

A little note:

You should not use this until you're ready to think about what you're doing :)

a note on async framework

As we use async function as underlaying mechanism to manage the execution flow, the standard library asyncio is pretty fine. But, (always a but somewhere isn't it...), you should read this [amazing blog post}( by Nathaniel J. Smith. And next study curio framework in deep.

As curio said:

Don't Use Curio if You're Allergic to Curio

Personaly, after few time of testing and reading curio code, I'm pretty addict.

TODO List to go away of Alpha status

TODO Code:

  • module common definition (typing)
  • module of meta manipulation
  • define submodule for decorator, leaf etc
  • add more example in docs
  • ensure tests and coverage



  • Python 3.7+


Install this library directly into an activated virtual environment:

$ pip install async-btree

or add it to your Poetry project:

$ poetry add async-btree


After installation, the package can imported:

$ python
>>> import async_btree
>>> async_btree.__version__

Project details

Download files

Download the file for your platform. If you're not sure which to choose, learn more about installing packages.

Source Distribution

async_btree-0.0.1a0.tar.gz (16.1 kB view hashes)

Uploaded Source

Built Distribution

async_btree-0.0.1a0-py3-none-any.whl (18.7 kB view hashes)

Uploaded Python 3

Supported by

AWS AWS Cloud computing and Security Sponsor Datadog Datadog Monitoring Fastly Fastly CDN Google Google Download Analytics Microsoft Microsoft PSF Sponsor Pingdom Pingdom Monitoring Sentry Sentry Error logging StatusPage StatusPage Status page