anemone

anemone is a Python library for tree search over valanga game states. It separates structural tree storage, runtime search state, node evaluation, exploration indices, and selector/opening logic so different search policies can share one coherent runtime.

Overview

The main architectural split is:

• structure: TreeNode and ITreeNode
• runtime: AlgorithmNode and TreeExploration
• evaluation: direct evaluation plus backed-up tree evaluation
• exploration: per-node exploration-index payloads and tree-wide recomputation
• selection: selectors and opening instructions that decide what to expand next

Installation

Release 0.3.0 requires Python 3.14 or higher. CPU release validation uses standard CPython 3.14.10 (GIL enabled, PYTHON_JIT=0). Runtime dependencies use the published valanga==0.3.0; test extras use atomheart==0.3.0 and parsley-coco==0.2.0. The neural extra requires Coral 0.2.x.

Run tox --workdir /path/to/private/anemone-tox for complete validation. requirements/validation-py314.txt selects verified public foundation wheels by URL and SHA-256 for both local tox and CI.

Published distribution names:

pip install algorhino-anemone

Optional extras:

pip install algorhino-anemone[nn]
pip install algorhino-anemone[debug]

Debug snapshot export and the debug browser's SVG rendering also require the system Graphviz executable (dot).

Getting started

The canonical public entry point is anemone.factory.create_search.

• Use anemone.factory to build a runnable search runtime.
• Treat anemone._runtime_assembly and anemone.search_factory as internal wiring layers behind that API.
• Use TreeAndValueBranchSelector only when you want the higher-level one-shot recommendation wrapper instead of driving the runtime directly.

from random import Random

from anemone.factory import SearchArgs, create_search

# Domain-specific collaborators omitted for brevity:
# - YourStateType
# - your_dynamics
# - starting_state
# - your_evaluator
# - your_selector_args
# - your_opening_type
# - your_stopping_criterion
# - your_recommender_rule
args = SearchArgs(
    node_selector=your_selector_args,
    opening_type=your_opening_type,
    stopping_criterion=your_stopping_criterion,
    recommender_rule=your_recommender_rule,
)

runtime = create_search(
    state_type=YourStateType,
    dynamics=your_dynamics,
    starting_state=starting_state,
    args=args,
    random_generator=Random(0),
    master_state_value_evaluator=your_evaluator,
    state_representation_factory=None,
)

result = runtime.explore(Random(0))
print(result.branch_recommendation.recommended_name)

Core concepts

• TreeNode: the concrete structural node storing state, depth, and links.
• AlgorithmNode: the runtime wrapper that adds tree evaluation and exploration-index payloads.
• direct_value: the immediate evaluator output for one node.
• backed_up_value: the subtree-derived value propagated from children.
• exploration index: optional per-node search-priority data recomputed across the tree by a configured strategy.

How it works

• create_search(...) assembles the runtime, direct evaluator, selector factory, tree-evaluation factory, and tree manager.
• The initial tree is created with a directly evaluated root node.
• A selector chooses which node or branch to open next.
• The tree manager expands the structure and creates any new runtime nodes.
• Direct evaluation fills direct_value on newly created nodes.
• Upward propagation recomputes backed_up_value, branch ordering, and principal variation.
• Exploration-index payloads are refreshed for the next iteration.

Documentation

• Search iteration architecture
• Node evaluation README
• Exploration indices README
• Node selector README
• Nodes README
• Search factory README