btreeny 0.1.0__py3-none-any.whl

btreeny/__init__.py

@@ -0,0 +1,400 @@
+import contextlib
+from copy import deepcopy
+import functools
+import itertools
+from typing import (
+    Callable,
+    Generator,
+    Iterator,
+    Literal,
+    ParamSpec,
+    ContextManager,
+    TypeVar,
+    cast,
+)
+import uuid
+
+from ._get_name import get_name
+from ._tree_status import TreeStatus
+from ._ctx import (
+    call_stack as __ctx_call_stack,
+    tree_graph as __ctx_tree_graph,
+    id_map as __ctx_id_map,
+    tree_status as __ctx_tree_status,
+)
+
+BlackboardType = TypeVar("BlackboardType")
+TreeTickFunction = Callable[[BlackboardType], TreeStatus]
+TreeNode = ContextManager[TreeTickFunction[BlackboardType]]
+
+RUNNING = TreeStatus.RUNNING
+SUCCESS = TreeStatus.SUCCESS
+FAILURE = TreeStatus.FAILURE
+
+P = ParamSpec("P")
+T = TypeVar("T")
+
+
+@contextlib.contextmanager
+def _manage_call_stack(id: uuid.UUID, name: str):
+    _id_map = deepcopy(__ctx_id_map.get())
+    _id_map[id] = name
+    __ctx_id_map.set(_id_map)
+    # When we setup this action, set it on the call stack
+    stack = __ctx_call_stack.get()
+    parent = None if len(stack) == 0 else stack[-1]
+    __ctx_call_stack.set(stack + [id])
+    # Add this to the node graph
+    _tree_graph = deepcopy(__ctx_tree_graph.get())
+    if parent not in _tree_graph:
+        _tree_graph[parent] = []
+    if id not in _tree_graph[parent]:
+        _tree_graph[parent].append(id)
+    __ctx_tree_graph.set(_tree_graph)
+    yield
+    # Drain all values including and after this ID from the stack
+    # Raises ValueError if ID not in stack
+    stack = __ctx_call_stack.get()
+    id_in_stack = stack.index(id)
+    __ctx_call_stack.set(stack[:id_in_stack])
+
+
+def action(
+    func: Callable[P, Iterator[TreeTickFunction[BlackboardType]]],
+) -> Callable[P, TreeNode[BlackboardType]]:
+    self_name = get_name(func)
+
+    f = contextlib.contextmanager(func)
+
+    @contextlib.contextmanager
+    @functools.wraps(f)
+    def inner(*args: P.args, **kwargs: P.kwargs):
+        # Each invocation of the action function gets a new ID
+        self_id = uuid.uuid4()
+        with _manage_call_stack(self_id, self_name):
+            with f(*args, **kwargs) as action:
+
+                @functools.wraps(action)
+                def action_func(blackboard: BlackboardType):
+                    result = action(blackboard)
+                    _tree_status = deepcopy(__ctx_tree_status.get())
+                    _tree_status[self_id] = result
+                    __ctx_tree_status.set(_tree_status)
+                    return result
+
+                yield action_func
+
+    return inner
+
+
+def simple_action(f: TreeTickFunction[BlackboardType]):
+    @action
+    @functools.wraps(f)
+    def _inner():
+        yield f
+
+    return _inner
+
+
+# ------------------------------------------------------------------------------
+# Control flow
+# ------------------------------------------------------------------------------
+
+
+@action
+def sequential(*children: TreeNode[BlackboardType]):
+    def gen() -> Generator[TreeStatus, BlackboardType, TreeStatus]:
+        blackboard = yield TreeStatus.RUNNING
+        for child_context_manager in children:
+            with child_context_manager as child_action:
+                # TODO: Pyrefly is not happy with blackboard typing - why?
+                while (
+                    result := child_action(blackboard)  # pyrefly: ignore
+                ) == TreeStatus.RUNNING:
+                    blackboard = yield TreeStatus.RUNNING
+                if result == TreeStatus.FAILURE:
+                    return result
+        return TreeStatus.SUCCESS
+
+    stepper = gen()
+    next(stepper)
+
+    def inner(blackboard: BlackboardType) -> TreeStatus:
+        nonlocal stepper
+        try:
+            return stepper.send(blackboard)
+        except StopIteration as e:
+            # TODO: Raise an exception if we try to tick the tree when it's finished
+            return cast(TreeStatus, e.value)
+
+    try:
+        yield inner
+    finally:
+        stepper.close()
+
+
+@action
+def fallback(*children: TreeNode[BlackboardType]):
+    def gen() -> Generator[TreeStatus, BlackboardType, TreeStatus]:
+        blackboard = yield TreeStatus.RUNNING
+        for child_context_manager in children:
+            with child_context_manager as child_action:
+                # TODO: Pyrefly is not happy with blackboard typing - why?
+                while (
+                    result := child_action(blackboard)  # pyrefly: ignore
+                ) == TreeStatus.RUNNING:
+                    blackboard = yield TreeStatus.RUNNING
+                if result == TreeStatus.SUCCESS:
+                    return result
+        return TreeStatus.FAILURE
+
+    stepper = gen()
+    next(stepper)
+
+    def inner(blackboard: BlackboardType):
+        nonlocal stepper
+        try:
+            return stepper.send(blackboard)
+        except StopIteration as e:
+            # TODO: Raise an exception if we try to tick the tree when it's finished
+            return cast(TreeStatus, e.value)
+
+    try:
+        yield inner
+    finally:
+        stepper.close()
+
+
+@action
+def repeat(
+    action_factory: Callable[[], TreeNode[BlackboardType]],
+    continue_if: Literal[TreeStatus.SUCCESS, TreeStatus.FAILURE],
+    count: int | None = None,
+):
+    """Repeat an action while it returns a specific value (success or failure).
+
+    Parameters
+    ----------
+    action_factory: () -> TreeNode[BlackboardType]
+        A function used to generate the action node to repeat. This needs to be a
+        function as we perform action setup and teardown on each repeat.
+    count: int, default=None
+        The number of repeats to try. If `None` then repeat to failure.
+    continue_if: TreeStatus.SUCCESS | TreeStatus.FAILURE
+        The return value which should trigger a repeat
+    """
+    # Create children which is an inf
+    if count is None:
+        children = map(lambda factory: factory(), itertools.repeat(action_factory))
+    else:
+        children = map(
+            lambda factory: factory(), itertools.repeat(action_factory, count)
+        )
+
+    def gen() -> Generator[TreeStatus, BlackboardType, TreeStatus]:
+        blackboard = yield TreeStatus.RUNNING
+        result = TreeStatus.SUCCESS
+        for i, child_context_manager in enumerate(children):
+            with child_context_manager as child_action:
+                while (result := child_action(blackboard)) == TreeStatus.RUNNING:
+                    blackboard = yield TreeStatus.RUNNING
+                if result == continue_if:
+                    # If this is the last child then return
+                    if count is not None and i >= count - 1:
+                        return result
+                    blackboard = yield TreeStatus.RUNNING
+                else:
+                    return result
+        return result
+
+    stepper = gen()
+    next(stepper)
+
+    def inner(blackboard: BlackboardType):
+        nonlocal stepper
+        try:
+            return stepper.send(blackboard)
+        except StopIteration as e:
+            # TODO: Raise an exception if we try to tick the tree when it's finished
+            return cast(TreeStatus, e.value)
+
+    try:
+        yield inner
+    finally:
+        stepper.close()
+
+
+retry = functools.partial(repeat, continue_if=TreeStatus.FAILURE)
+redo = functools.partial(repeat, continue_if=TreeStatus.SUCCESS)
+
+
+@action
+def remap(
+    child: TreeNode[BlackboardType],
+    mapping: dict[TreeStatus, TreeStatus],
+):
+    with child as action:
+
+        def inner(blackboard: BlackboardType) -> TreeStatus:
+            result = action(blackboard)
+            return mapping.get(result, result)
+
+        yield inner
+
+
+@action
+def swap(
+    child: TreeNode[BlackboardType],
+    *,
+    from_: TreeStatus,
+    to: TreeStatus,
+):
+    if from_ == to:
+        raise ValueError(f"Cannot swap {from_} with itself")
+    with remap(child, {from_: to, to: from_}) as action:
+        yield action
+
+
+@action
+def always_return(
+    child: TreeNode[BlackboardType],
+    *,
+    always_return: TreeStatus,
+):
+    with child as action:
+
+        def inner(blackboard: BlackboardType) -> TreeStatus:
+            _ = action(blackboard)
+            return always_return
+
+        yield inner
+
+
+@action
+def react(
+    condition: Callable[[BlackboardType], bool],
+    nominal: TreeNode[BlackboardType],
+    failure: TreeNode[BlackboardType],
+):
+    """A react node allows highly reactive behavior, switching between multiple
+    actions depending on the currently evaluated state of the `condition` function.
+
+    Parameters
+    ----------
+    condition: (BlackboardType) -> bool
+        The function to call to determine if we are in the "nominal" or "failure" mode
+    nominal: Tree
+    """
+    # We need to carefully manage the call stack, inserting and removing children
+    # as we switch between modes
+    initial_call_stack = __ctx_call_stack.get()
+    initial_graph = __ctx_tree_graph.get()
+    # Get the failure call stack
+    failure_action = failure.__enter__()
+    failure_call_stack = __ctx_call_stack.get()
+    failure_graph = __ctx_tree_graph.get()
+    __ctx_call_stack.set(initial_call_stack)
+    __ctx_tree_graph.set(initial_graph)
+    # Get the nominal call stack
+    nominal_action = nominal.__enter__()
+    nominal_call_stack = __ctx_call_stack.get()
+    nominal_graph = __ctx_tree_graph.get()
+    # Intial mode is nominal
+    mode: Literal["nominal", "failure"] = "nominal"
+
+    def inner(blackboard: BlackboardType) -> TreeStatus:
+        nonlocal \
+            nominal_call_stack, \
+            failure_call_stack, \
+            nominal_graph, \
+            failure_graph, \
+            mode
+        match (mode, condition(blackboard)):
+            # Mode is nominal, condtion passes
+            case ("nominal", True):
+                # Run the nominal action
+                return nominal_action(blackboard)
+            # Mode is nominal, condtion failes - transition to fail
+            case ("nominal", False):
+                mode = "failure"
+                # Update the nominal call stack
+                nominal_call_stack = __ctx_call_stack.get()
+                nominal_graph = __ctx_tree_graph.get()
+                # Set the current call stack as the failure stack
+                __ctx_call_stack.set(failure_call_stack)
+                __ctx_tree_graph.set(failure_graph)
+                # Run the failure action
+                return failure_action(blackboard)
+            # Mode is failure, but the condition has started passing - transition to nominal
+            case ("failure", True):
+                mode = "nominal"
+                failure_call_stack = __ctx_call_stack.get()
+                failure_graph = __ctx_tree_graph.get()
+                __ctx_call_stack.set(nominal_call_stack)
+                __ctx_tree_graph.set(nominal_graph)
+                return nominal_action(blackboard)
+            # Mode is failure and the condition is failing
+            case ("failure", False):
+                return failure_action(blackboard)
+            case _:
+                raise RuntimeError("Impossible branch")
+
+    try:
+        yield inner
+    finally:
+        # Cleanup - being careful to reset stack as appropriate
+        match mode:
+            case "nominal":
+                nominal.__exit__(None, None, None)
+                __ctx_call_stack.set(failure_call_stack)
+                failure.__exit__(None, None, None)
+            case "failure":
+                failure.__exit__(None, None, None)
+                __ctx_call_stack.set(nominal_call_stack)
+                nominal.__exit__(None, None, None)
+
+
+@action
+def failsafe(
+    check: Callable[[BlackboardType], bool],
+    nominal: TreeNode[BlackboardType],
+    failure: TreeNode[BlackboardType],
+):
+    """Run a check on each tick, as soon as the check returns ``False`` move from a "nominal"
+    mode to an "error" mode.
+    """
+
+    def gen() -> Generator[TreeStatus, BlackboardType, TreeStatus]:
+        nonlocal nominal
+        blackboard = yield TreeStatus.RUNNING
+        result = TreeStatus.SUCCESS
+        with nominal as nominal_action:
+            while check(blackboard):
+                result = nominal_action(blackboard)
+                match result:
+                    case TreeStatus.RUNNING:
+                        yield result
+                    case _:
+                        return result
+        with failure as failure_action:
+            while (
+                result := failure_action(blackboard)  # pyrefly: ignore
+            ) == TreeStatus.RUNNING:
+                blackboard = yield TreeStatus.RUNNING
+            return result
+        return TreeStatus.SUCCESS
+
+    stepper = gen()
+    next(stepper)
+
+    def inner(blackboard: BlackboardType):
+        nonlocal stepper
+        try:
+            return stepper.send(blackboard)
+        except StopIteration as e:
+            return cast(TreeStatus, e.value)
+
+    try:
+        yield inner
+    finally:
+        stepper.close()

btreeny/_ctx.py

@@ -0,0 +1,14 @@
+import contextvars
+import uuid
+from ._tree_status import TreeStatus
+
+id_map = contextvars.ContextVar[dict[uuid.UUID, str]]("call_stack")
+id_map.set({})
+call_stack = contextvars.ContextVar[list[uuid.UUID]]("call_stack")
+call_stack.set([])
+tree_graph = contextvars.ContextVar[dict[uuid.UUID | None, list[uuid.UUID]]](
+    "tree_graph"
+)
+tree_graph.set({})
+tree_status = contextvars.ContextVar[dict[uuid.UUID, TreeStatus]]("tree_status")
+tree_status.set({})

btreeny/_get_name.py

@@ -0,0 +1,10 @@
+from typing import Any
+
+
+def get_name(obj: Any) -> str:
+    """Attempt to fetch a human readable name for an object"""
+    if (name := getattr(obj, "__name__", None)) is not None:
+        return name
+    elif (cls := getattr(obj, "__class__", None)) is not None:
+        return getattr(cls, "__name__", str(obj))
+    return str(obj)

btreeny/_tree_status.py

@@ -0,0 +1,7 @@
+from enum import Enum
+
+
+class TreeStatus(str, Enum):
+    RUNNING = "RUNNING"
+    SUCCESS = "SUCCESS"
+    FAILURE = "FAILURE"

btreeny/viz.py

@@ -0,0 +1,176 @@
+from collections import deque
+from dataclasses import asdict, dataclass
+from typing import Callable
+
+try:
+    from rich.pretty import pprint
+    from rich.tree import Tree
+
+    __has_rich = True
+except ImportError:
+    from pprint import pprint
+
+    __has_rich = False
+import uuid
+
+try:
+    import rerun as rr
+
+    __has_rerun = True
+except ImportError:
+    __has_rerun = False
+
+from ._ctx import (
+    tree_graph as __ctx_tree_graph,
+    id_map as __ctx_id_map,
+    tree_status as __ctx_tree_status,
+)
+from ._tree_status import TreeStatus
+
+
+def print_trace(print_func: Callable[[str], None] = print):
+    """Print the current state of the tree using a specified function.
+
+    Parameters
+    ----------
+    print_func: (str) -> None
+        The printing function to use, defaults to the builtin `print` function.
+    """
+    _id_map = __ctx_id_map.get()
+    _tree_graph = __ctx_tree_graph.get()
+    _tree_status = __ctx_tree_status.get()
+    root_actions = _tree_graph[None]
+    q = deque()
+    print_func(f"\n{' Trace ':-^50}")
+    for action_id in root_actions:
+        q.append((action_id, 0))
+    while len(q) > 0:
+        action_id, indent_count = q.popleft()
+        indent = " " * indent_count * 4
+        action_name = _id_map[action_id]
+        action_status = _tree_status.get(action_id, None)
+        if action_status is not None:
+            action_status = action_status.value
+        print_func(f"{indent}{action_id} {action_name} - {action_status}")
+        for child in _tree_graph.get(action_id, [])[::-1]:
+            q.appendleft((child, indent_count + 1))
+    print_func("-" * 50 + "\n")
+
+
+@dataclass
+class TreeStatusGraph:
+    node: str
+    status: TreeStatus
+    children: "list[TreeStatusGraph]"
+
+    def pprint(self):
+        pprint(asdict(self))
+
+
+def get_tree_status() -> "TreeStatusGraph":
+    """Fetch the current state of the tree as a tree datastructure.
+
+    Returns
+    -------
+    TreeStatus:
+        The root of the behavior tree.
+    """
+    _id_map = __ctx_id_map.get()
+    _tree_graph = __ctx_tree_graph.get()
+    _tree_status = __ctx_tree_status.get()
+
+    root_actions = _tree_graph[None]
+    assert len(root_actions) == 1
+    root_action = root_actions[0]
+    node_map: dict[uuid.UUID, TreeStatusGraph] = {}
+    node_map[root_action] = TreeStatusGraph(
+        node=_id_map[root_action], status=_tree_status[root_action], children=[]
+    )
+    q = deque[uuid.UUID]([])
+    q.append(root_action)
+    while len(q) > 0:
+        action = q.popleft()
+        try:
+            children = _tree_graph[action]
+        except KeyError:
+            continue
+        for child in children:
+            child_name = _id_map[child]
+            child_status = _tree_status[child]
+            node_map[child] = TreeStatusGraph(
+                node=child_name, status=child_status, children=[]
+            )
+            node_map[action].children.append(node_map[child])
+            q.append(child)
+    return node_map[root_action]
+
+
+if __has_rerun:
+
+    @dataclass
+    class RerunGraph:
+        nodes: rr.GraphNodes
+        edges: rr.GraphEdges
+
+    def rerun_tree_graph() -> RerunGraph:
+        _id_map = __ctx_id_map.get()
+        _tree_graph = __ctx_tree_graph.get()
+        _tree_status = __ctx_tree_status.get()
+        keys = list(_tree_status.keys())
+
+        def _color_from_status(s: TreeStatus) -> int:
+            match s:
+                case TreeStatus.SUCCESS:
+                    return 0x119911FF
+                case TreeStatus.FAILURE:
+                    return 0x991111FF
+                case TreeStatus.RUNNING:
+                    return 0xBB6633FF
+                case _:
+                    raise RuntimeError(f"Not a valid status {s}")
+
+        return RerunGraph(
+            nodes=rr.GraphNodes(
+                node_ids=list(map(str, keys)),
+                labels=[f"{_id_map[k]}\n{_tree_status[k]}" for k in keys],
+                colors=[_color_from_status(_tree_status[k]) for k in keys],
+                show_labels=True,
+            ),
+            edges=rr.GraphEdges(
+                edges=[
+                    (str(parent), str(child))
+                    for parent in keys
+                    for child in _tree_graph.get(parent, [])
+                ],
+                graph_type="directed",
+            ),
+        )
+
+
+if __has_rich:
+
+    def get_rich_tree() -> Tree:
+        _id_map = __ctx_id_map.get()
+        _tree_graph = __ctx_tree_graph.get()
+        _tree_status = __ctx_tree_status.get()
+        try:
+            root_actions = _tree_graph[None]
+        except KeyError:
+            return Tree("root")
+        assert len(root_actions) == 1, "Expected one root action"
+        root = root_actions[0]
+        q = deque[tuple[uuid.UUID, Tree]]()
+        tree = Tree(f"{_id_map[root]} - {_tree_status[root].value}")
+        q.append((root, tree))
+        while len(q) > 0:
+            action_id, parent_tree = q.popleft()
+            action_name = _id_map[action_id]
+            action_status = _tree_status.get(action_id, None)
+            if action_status is not None:
+                action_status = action_status.value
+            else:
+                action_status = "Not Run"
+            child_tree = parent_tree.add(f"{action_name} - {action_status}")
+            for child in _tree_graph.get(action_id, [])[::-1]:
+                q.appendleft((child, child_tree))
+        return tree

btreeny-0.1.0.dist-info/METADATA

@@ -0,0 +1,163 @@
+Metadata-Version: 2.3
+Name: btreeny
+Version: 0.1.0
+Summary: Add your description here
+Author: Tim Lingard
+Author-email: Tim Lingard <tklingard@gmail.com>
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# Welcome to BTreeny!
+
+This package is a minimal(ish) implementation of [Behavior Trees](https://en.wikipedia.org/wiki/Behavior_tree_(artificial_intelligence,_robotics_and_control)) in Python.
+
+
+```python
+import btreeny
+
+# Generic over blackboards - use dataclasses to get nice type hints!
+MyBlackboardType = dict[str, str]
+
+# For the most simple case - define your actions as a function which takes a blackbaord
+# and returns a tree
+@btreeny.simple_action
+def my_failing_action(blackboard: MyBlackboardType):
+    # You could modify the blackboard, or take actions here
+    return btreeny.TreeStatus.FAILURE
+
+# For more complex actions
+@btreeny.action
+def my_running_action():
+    # Setup
+    # ...
+
+    # Yield a tick function
+    def _inner(blackboard: MyBlackboardType):
+        return btreeny.TreeStatus.RUNNING
+    try:
+        yield inner
+    finally:
+        # Teardown
+        # ...
+
+# We support many standard control flow nodes - see below for options
+root = btreeny.fallback(
+    my_failing_action(),
+    my_running_action(),
+)
+
+# Running the tree can be done manually
+blackboard = {}
+result = btreeny.TreeStatus.RUNNING
+with root as tick_function:
+    while result == btreeny.TreeStatus.RUNNING:
+        # We expect trees to modify the blackboard in-place
+        result = tick_function(blackboard)
+```
+
+
+## Writing an action
+
+In `btreeny`, an action is specified as a context which returns a callable function to "tick" the action. This allows you to manage the setup and teardown of resources required by that action.
+
+For example, an action which polls a URL until it gets a 200 status code, and will fail after some number of retries, might look like:
+
+```python
+@btreeny.action
+def poll_url(url: str, retries: int=10):
+    # setup a client to allow connection pooling
+    client = httpx.Client()
+    retry_count = 0
+    def tick(blackboard: Any):
+        # Since we're assigning to retry_count, we should declare it as nonlocal
+        # to this function's scope
+        nonlocal retry_count
+        if retry_count > retries:
+            return btreeny.TreeStatus.FAILURE
+        response = client.get(url)
+        retry_count += 1
+        if response.status_code == 200:
+            return btreeny.TreeStatus.SUCCESS
+        return btreeny.TreeStatus.RUNNING
+    # Use a try... finally block to ensure cleanup is run
+    try:
+        # yield the tick function
+        yield tick
+    finally:
+        # We can finish the function with our cleanup
+        client.close()
+```
+
+Note that in this case it'd have been more ergonomic to use 
+
+```python
+with httpx.Client() as client:
+    def tick(...):
+        ...
+    yield tick
+```
+
+As the client would have been closed for us!
+
+
+## Controlling flow
+
+### Sequential
+Accepts multiple children to cycle through. When each child succeeds, move to the next action. If any child fails then the node fails.
+
+### Fallback
+Accepts multiple children to cycle through. If a child fails, move to the next action. If any child suceeds then the node fails.
+
+### Repeat / Retry / Redo
+Accepts a factory function and an optional number of retries. If the resulting action matches the specified `continue_if` value, recreate the action using the factory function and carry on.
+
+- Retry wraps `repeat` with `continue_if=TreeStatus.FAILURE`
+- Redo wraps `repeat` with `continue_if=TreeStatus.SUCCESS`
+
+### Remap
+Map output states to different values - e.g. convert all `SUCCESS` outputs into `FAILURE`. Note that this is not reciprocal! You could, for example, use this to convert all outputs to `RUNNING`.
+
+`remap` has some utilities
+- `swap`: Reciprocally map between two states (e.g. Failure <-> Success)
+- `remap_to_always`: Convert the output of the action to always be this value.
+
+### React
+Given some condition check which runs on each tick with current blackboard, alternate between two different sub-trees.
+
+Note that this function resumes a sub-tree where it has left off, rather than trying to restart it. This can create undesirable behavior without careful planning.
+
+### Failsafe
+Given some condition check which runs on each tick with the current blackboard, if the check ever fails move to a failure tree.
+
+Useful when combined with `redo` to allow failsafe behaviour which can recover to continue normal operations.
+
+This action allows fallback to a charging state on low battery in the `waypoint_navigation` example script.
+
+
+## Logging and Visualization
+
+Understanding what's going on in your behavior tree is crucial for debugging and triaging issues - btreeny has an (opinionated) set of logging utilities, but lets you access the underlying data to write your own.
+
+The simplest way to log the current tree state is simply to use the 
+
+### Rich 
+
+Rich is a great library for pretty printing in the terminal, to get the current tree state as a [rich.Tree](https://rich.readthedocs.io/en/stable/tree.html) renderable, use `btree.viz.get_rich_tree()`.
+
+```python
+from rich.print import print
+tree = btree.viz.get_rich_tree()
+print(tree)
+```
+
+### Rerun
+
+Rerun is a great tool for visualizing robotics applications - and we want to make it easy for you to add your `btreeny` state to each timestep.
+
+```python
+import rerun as rr
+# fetch the current tree state as a dataclass with Rerun `rr.GraphNodes` and `rr.GraphEdges`
+graph = btreeny.viz.rerun_tree_graph()
+# Log to Rerun
+rr.log("tree", graph.nodes, graph.edges)
+```

btreeny-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+btreeny/__init__.py,sha256=042d5eebd6f7d654f7eddb87ffe3dc0b5846d4c7cce13fd9c86b919c239ec709,12823
+btreeny/_ctx.py,sha256=3c6f6a5e50c0965b5119adbc7980fc04727de56ed8148aee20a6fd5c010c58df,455
+btreeny/_get_name.py,sha256=baeeb9f6fa771ab010c0961208544f4a54d8045c40a09c19f7fbfac52c8f2725,333
+btreeny/_tree_status.py,sha256=496505ff7506a51ac47062795ad0e44d07ebdf4190f6dd2c22628a1422db400e,125
+btreeny/py.typed,sha256=e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855,0
+btreeny/viz.py,sha256=5149bf1ee07198886b93c5a9bdb724d61cca7d1adf5ae52005f71355c4855604,5363
+btreeny-0.1.0.dist-info/WHEEL,sha256=b70116f4076fa664af162441d2ba3754dbb4ec63e09d563bdc1e9ab023cce400,78
+btreeny-0.1.0.dist-info/METADATA,sha256=004c3c101b2acd5c6b155bb3ffa243e6180f098bf89c1429d9cf5268b98c874e,5602
+btreeny-0.1.0.dist-info/RECORD,,

btreeny-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.8.3
+Root-Is-Purelib: true
+Tag: py3-none-any