algorhino-anemone 0.1.1__py3-none-any.whl

anemone/search_factory/search_factory.py

@@ -0,0 +1,192 @@
+"""
+This module contains the implementation of the SearchFactory class, which is an abstract factory that creates
+dependent factories for selecting nodes to open, creating indices, and updating indices. These factories need to
+operate on the same data, so they are created in a coherent way.
+
+The SearchFactory class provides methods to create the node selector factory, the index updater, and to create
+node indices for a given tree node.
+
+Classes:
+- SearchFactory: An abstract factory for creating dependent factories for selecting nodes to open, creating indices,
+and updating indices.
+
+Protocols:
+- SearchFactoryP: A protocol that defines the abstract methods for the SearchFactory class.
+
+Functions:
+- create_node_selector_factory: A function that creates the node selector factory.
+- create_node_index_updater: A function that creates the index updater.
+- node_index_create: A function that creates node indices for a given tree node.
+"""
+
+from dataclasses import dataclass
+from functools import partial
+from random import Random
+from typing import Callable, Protocol
+
+from valanga import State
+
+from anemone import node_selector as node_selectors
+from anemone import nodes
+from anemone.indices import node_indices
+from anemone.indices.node_indices.factory import (
+    create_exploration_index_data,
+)
+from anemone.node_selector.opening_instructions import (
+    OpeningInstructor,
+    OpeningType,
+)
+from anemone.node_selector.sequool.factory import (
+    SequoolArgs,
+)
+from anemone.nodes.algorithm_node.algorithm_node import AlgorithmNode
+from anemone.updates.index_updater import IndexUpdater
+
+NodeSelectorFactory = Callable[[], node_selectors.NodeSelector]
+
+
+class SearchFactoryP(Protocol):
+    """
+    The abstract Factory that creates the following dependent factories in charge of selecting nodes to open
+    - the node selector
+    - the index creator
+    - the index updater
+    These three classes needs to operate on the same data, so they need to be created in a coherent way
+    """
+
+    def create_node_selector_factory(self) -> NodeSelectorFactory:
+        """
+        Creates a NodeSelectorFactory object.
+
+        Returns:
+            NodeSelectorFactory: The created NodeSelectorFactory object.
+        """
+        ...
+
+    def create_node_index_updater(self) -> IndexUpdater | None:
+        """
+        Creates and returns an instance of the IndexUpdater class, which is responsible for updating the node index.
+
+        Returns:
+            IndexUpdater | None: An instance of the IndexUpdater class if successful, None otherwise.
+        """
+        ...
+
+    def node_index_create[StateT: State](
+        self,
+        tree_node: nodes.TreeNode[AlgorithmNode[StateT], StateT],
+    ) -> node_indices.NodeExplorationData[AlgorithmNode[StateT], StateT] | None:
+        """
+        Creates a node index for the given tree node.
+
+        Args:
+            tree_node (nodes.TreeNode): The tree node for which to create the index.
+
+        Returns:
+            node_indices.NodeExplorationData | None: The created node index, or None if the index could not be created.
+        """
+        ...
+
+
+@dataclass
+class SearchFactory:
+    """
+    The abstract Factory that creates the following dependent factories in charge of selecting nodes to open
+    - the node selector
+    - the index creator
+    - the index updater
+    These three classes needs to operate on the same data, so they need to be created in a coherent way
+    """
+
+    node_selector_args: node_selectors.AllNodeSelectorArgs | None
+    opening_type: OpeningType | None
+    random_generator: Random | None
+    index_computation: node_indices.IndexComputationType | None
+    depth_index: bool = False
+
+    def __post_init__(self) -> None:
+        """
+        Initializes the object after it has been created.
+
+        This method is automatically called after the object has been initialized.
+        It sets the value of `depth_index` based on the type of `node_selector_args`.
+
+        If `node_selector_args` is an instance of `SequoolArgs`, then `depth_index`
+        is set to the value of `recursive_selection_on_all_nodes` attribute of `node_selector_args`.
+        Otherwise, `depth_index` is set to False.
+        """
+        if isinstance(self.node_selector_args, SequoolArgs):
+            a: SequoolArgs = self.node_selector_args
+            self.depth_index: bool = a.recursive_selection_on_all_nodes
+        else:
+            self.depth_index: bool = False
+
+    def create_node_selector_factory(self) -> NodeSelectorFactory:
+        """
+        Creates the node selector factory .
+
+        Returns:
+            A callable object that creates the node selector.
+
+        Raises:
+            AssertionError: If the random generator is not provided.
+        """
+        # creates the opening instructor
+
+        assert self.random_generator is not None
+        opening_instructor: OpeningInstructor | None = (
+            OpeningInstructor(
+                opening_type=self.opening_type, random_generator=self.random_generator
+            )
+            if self.opening_type is not None
+            else None
+        )
+
+        assert self.node_selector_args is not None
+        assert opening_instructor is not None
+
+        node_selector_create: NodeSelectorFactory = partial(
+            node_selectors.create,
+            args=self.node_selector_args,
+            opening_instructor=opening_instructor,
+            random_generator=self.random_generator,
+        )
+        return node_selector_create
+
+    def create_node_index_updater(self) -> IndexUpdater | None:
+        """
+        Creates the index updater.
+
+        Returns:
+            An instance of the IndexUpdater class if depth indexing is enabled, otherwise None.
+        """
+        index_updater: IndexUpdater | None
+        if self.depth_index:
+            index_updater = IndexUpdater()
+        else:
+            index_updater = None
+        return index_updater
+
+    def node_index_create[StateT: State](
+        self,
+        tree_node: nodes.TreeNode[AlgorithmNode[StateT], StateT],
+    ) -> node_indices.NodeExplorationData[AlgorithmNode[StateT], StateT] | None:
+        """
+        Creates node indices for a given tree node.
+
+        Args:
+            tree_node: The tree node for which to create the node indices.
+
+        Returns:
+            An instance of the NodeExplorationData class if depth indexing is enabled, otherwise None.
+        """
+
+        exploration_index_data: (
+            node_indices.NodeExplorationData[AlgorithmNode[StateT], StateT] | None
+        ) = create_exploration_index_data(
+            tree_node=tree_node,
+            index_computation=self.index_computation,
+            depth_index=self.depth_index,
+        )
+
+        return exploration_index_data

anemone/state_transition.py

@@ -0,0 +1,47 @@
+"""Defines state transition protocols and implementations for Anemone."""
+
+from dataclasses import dataclass
+from typing import Protocol
+
+from valanga import BranchKey, State, StateModifications
+
+
+class StateTransition[StateT](Protocol):
+    """Protocol for state transitions in Anemone."""
+
+    def copy_for_expansion(self, state: StateT, *, copy_stack: bool) -> StateT:
+        """Return a copy of state suitable for expansion."""
+        ...
+
+    def step(
+        self,
+        state: StateT,
+        *,
+        branch_key: BranchKey,
+    ) -> tuple[StateT, StateModifications | None]:
+        """Apply a branch key to advance the state."""
+        ...
+
+
+@dataclass(frozen=True)
+class ValangaStateTransition(StateTransition[State]):
+    """State transition implementation using Valanga's State."""
+
+    deep_copy_legal_moves: bool = False
+
+    def copy_for_expansion(self, state: State, *, copy_stack: bool) -> State:
+        """Copy the state, optionally copying its stack."""
+        return state.copy(
+            stack=copy_stack,
+            deep_copy_legal_moves=self.deep_copy_legal_moves,
+        )
+
+    def step(
+        self,
+        state: State,
+        *,
+        branch_key: BranchKey,
+    ) -> tuple[State, StateModifications | None]:
+        """Advance state by a branch key and return modifications."""
+        modifications = state.step(branch_key=branch_key)
+        return state, modifications

anemone/tree_and_value_branch_selector.py

@@ -0,0 +1,99 @@
+"""
+This module contains the implementation of the TreeAndValueMoveSelector class, which is responsible for selecting moves
+based on a tree and value strategy.
+
+The TreeAndValueMoveSelector class uses a tree-based approach to explore possible moves and select the best move based on
+a value function. It utilizes a tree manager, a tree factory, stopping criterion arguments, a node selector factory, a
+random generator, and recommendation functions to guide the move selection process.
+
+The TreeAndValueMoveSelector class provides the following methods:
+- select_move: Selects the best move based on the tree and value strategy.
+- print_info: Prints information about the move selector type.
+"""
+
+from dataclasses import dataclass
+from queue import Queue
+from random import Random
+
+from valanga import TurnState
+
+from anemone.basics import BranchRecommendation, Seed
+from anemone.progress_monitor.progress_monitor import (
+    AllStoppingCriterionArgs,
+)
+from anemone.search_factory import NodeSelectorFactory
+from anemone.utils.dataclass import IsDataclass
+
+from . import recommender_rule
+from . import tree_manager as tree_man
+from .tree_exploration import TreeExploration, create_tree_exploration
+from .trees.factory import ValueTreeFactory
+
+
+@dataclass
+class TreeAndValueBranchSelector[StateT: TurnState = TurnState]:
+    """
+    The TreeAndValueBranchSelector class is responsible for selecting moves based on a tree and value strategy.
+
+    Attributes:
+    - tree_manager: The tree manager responsible for managing the algorithm nodes.
+    - tree_factory: The tree factory responsible for creating move and value trees.
+    - stopping_criterion_args: The stopping criterion arguments used to determine when to stop the tree exploration.
+    - node_selector_create: The node selector factory used to create node selectors for tree exploration.
+    - random_generator: The random generator used for randomization during tree exploration.
+    - recommend_move_after_exploration: The recommendation functions used to recommend a move after tree exploration.
+    """
+
+    # pretty empty class but might be useful when dealing with multi round and time , no?
+
+    tree_manager: tree_man.AlgorithmNodeTreeManager
+    tree_factory: ValueTreeFactory[StateT]
+    stopping_criterion_args: AllStoppingCriterionArgs
+    node_selector_create: NodeSelectorFactory
+    random_generator: Random
+    recommend_move_after_exploration: recommender_rule.AllRecommendFunctionsArgs
+    queue_progress_player: Queue[IsDataclass] | None
+
+    def select_branch(
+        self, state: StateT, selection_seed: Seed
+    ) -> BranchRecommendation:
+        """
+        Selects the best move based on the tree and value strategy.
+
+        Args:
+        - board: The current board state.
+        - move_seed: The seed used for randomization during move selection.
+
+        Returns:
+        - The recommended move based on the tree and value strategy.
+        """
+        tree_exploration: TreeExploration = self.create_tree_exploration(state=state)
+        self.random_generator.seed(selection_seed)
+
+        branch_recommendation: BranchRecommendation = tree_exploration.explore(
+            random_generator=self.random_generator
+        ).branch_recommendation
+
+        return branch_recommendation
+
+    def create_tree_exploration(
+        self,
+        state: StateT,
+    ) -> TreeExploration:
+        """Create a TreeExploration instance for the given state."""
+        tree_exploration: TreeExploration = create_tree_exploration(
+            tree_manager=self.tree_manager,
+            node_selector_create=self.node_selector_create,
+            starting_state=state,
+            tree_factory=self.tree_factory,
+            stopping_criterion_args=self.stopping_criterion_args,
+            recommend_move_after_exploration=self.recommend_move_after_exploration,
+            queue_progress_player=self.queue_progress_player,
+        )
+        return tree_exploration
+
+    def print_info(self) -> None:
+        """
+        Prints information about the move selector type.
+        """
+        print("type: Tree and Value")

anemone/tree_exploration.py

@@ -0,0 +1,274 @@
+"""
+This module contains the implementation of the TreeExploration class, which is responsible for managing a search
+ for the best move in a given chess position using a tree-based approach.
+
+The TreeExploration class is used to create and manage a tree structure that represents the possible moves and
+ their evaluations in a chess position. It provides methods for exploring the tree, selecting the best move,
+  and printing information during the move computation.
+
+The module also includes helper functions for creating a TreeExploration object and its dependencies.
+
+Classes:
+- TreeExploration: Manages the search for the best move using a tree-based approach.
+
+Functions:
+- create_tree_exploration: Creates a TreeExploration object with the specified dependencies.
+"""
+
+from dataclasses import dataclass
+from queue import Queue
+from random import Random
+from typing import TYPE_CHECKING, Any, Callable
+
+from valanga import BoardEvaluation, BranchKey, PlayerProgressMessage, State, TurnState
+
+from anemone.basics import BranchRecommendation
+from anemone.nodes.algorithm_node.algorithm_node import AlgorithmNode
+from anemone.progress_monitor.progress_monitor import (
+    AllStoppingCriterionArgs,
+    ProgressMonitor,
+    create_stopping_criterion,
+)
+from anemone.search_factory import NodeSelectorFactory
+from anemone.utils.dataclass import IsDataclass
+from anemone.utils.logger import anemone_logger
+
+from . import node_selector as node_sel
+from . import recommender_rule, trees
+from . import tree_manager as tree_man
+from .trees.factory import ValueTreeFactory
+
+if TYPE_CHECKING:
+    from anemone.recommender_rule.recommender_rule import BranchPolicy
+
+
+@dataclass
+class TreeExplorationResult[NodeT: AlgorithmNode[Any] = AlgorithmNode[Any]]:
+    """
+    Tree Exploration Result holds the result of a tree exploration.
+    """
+
+    branch_recommendation: BranchRecommendation
+    tree: trees.Tree[NodeT]
+
+
+def compute_child_evals[StateT: State](
+    root: AlgorithmNode[StateT],
+) -> dict[BranchKey, BoardEvaluation]:
+    """Compute evaluations for each existing child branch."""
+    evals: dict[BranchKey, BoardEvaluation] = {}
+    for bk, child in root.branches_children.items():
+        if child is None:
+            continue
+
+        # Use whatever your canonical per-node evaluation is:
+        evals[bk] = child.tree_evaluation.evaluate()
+    return evals
+
+
+@dataclass
+class TreeExploration[NodeT: AlgorithmNode[Any] = AlgorithmNode[Any]]:
+    """
+    Tree Exploration is an object to manage one best move search.
+
+    Attributes:
+    - tree: The tree structure representing the possible moves and their evaluations.
+    - tree_manager: The manager for the tree structure.
+    - node_selector: The selector for choosing nodes and moves to open in the tree.
+    - recommend_move_after_exploration: The recommender rule for selecting the best move after the tree exploration.
+    - stopping_criterion: The stopping criterion for determining when to stop the tree exploration.
+
+    Methods:
+    - print_info_during_move_computation: Prints information during the move computation.
+    - explore: Explores the tree to find the best move.
+    """
+
+    # TODO Not sure why this class is not simply the TreeAndValuePlayer Class
+    #  but might be useful when dealing with multi round and time , no?
+
+    tree: trees.Tree[NodeT]
+    tree_manager: tree_man.AlgorithmNodeTreeManager[NodeT]
+    node_selector: node_sel.NodeSelector[NodeT]
+    recommend_move_after_exploration: recommender_rule.AllRecommendFunctionsArgs
+    stopping_criterion: ProgressMonitor[NodeT]
+    notify_percent_function: Callable[[int], None] | None
+
+    def print_info_during_move_computation(self, random_generator: Random) -> None:
+        """
+        Prints information during the move computation.
+
+        Args:
+        - random_generator: The random number generator.
+
+        Returns:
+        - None
+        """
+        current_best_move: str
+        if self.tree.root_node.tree_evaluation.best_branch_sequence:
+            current_best_move = str(
+                self.tree.root_node.tree_evaluation.best_branch_sequence[0]
+            )
+        else:
+            current_best_move = "?"
+        if random_generator.random() < 0.11:
+            anemone_logger.info(
+                "state: %s",
+                self.tree.root_node.state,
+            )
+
+            str_progress = self.stopping_criterion.get_string_of_progress(self.tree)
+            anemone_logger.info(
+                "%s | current best move: %s | current white value: %s",
+                str_progress,
+                current_best_move,
+                self.tree.root_node.tree_evaluation.value_white_minmax,
+            )
+
+            # ,end='\r')
+            self.tree.root_node.tree_evaluation.print_branches_sorted_by_value_and_exploration()
+            self.tree_manager.print_best_line(tree=self.tree)
+
+    def explore(self, random_generator: Random) -> TreeExplorationResult[NodeT]:
+        """
+        Explores the tree to find the best move.
+
+        Args:
+        - random_generator: The random number generator.
+
+        Returns:
+        - MoveRecommendation: The recommended move and its evaluation.
+        """
+        # by default the first tree expansion is the creation of the tree node
+        tree_expansions: tree_man.TreeExpansions[NodeT] = tree_man.TreeExpansions()
+
+        tree_expansion: tree_man.TreeExpansion[NodeT] = tree_man.TreeExpansion(
+            child_node=self.tree.root_node,
+            parent_node=None,
+            state_modifications=None,
+            creation_child_node=True,
+            branch_key=None,
+        )
+        tree_expansions.add_creation(tree_expansion=tree_expansion)
+
+        loop: int = 0
+        while self.stopping_criterion.should_we_continue(tree=self.tree):
+            loop = loop + 1
+            assert not self.tree.root_node.is_over()
+            # print info
+            self.print_info_during_move_computation(random_generator=random_generator)
+
+            # choose the moves and nodes to open
+            opening_instructions: node_sel.OpeningInstructions[NodeT]
+            opening_instructions = self.node_selector.choose_node_and_branch_to_open(
+                tree=self.tree, latest_tree_expansions=tree_expansions
+            )
+
+            # make sure we do not break the stopping criterion
+            opening_instructions_subset: node_sel.OpeningInstructions[NodeT]
+            opening_instructions_subset = (
+                self.stopping_criterion.respectful_opening_instructions(
+                    opening_instructions=opening_instructions, tree=self.tree
+                )
+            )
+
+            # open the nodes
+            tree_expansions = self.tree_manager.open_instructions(
+                tree=self.tree, opening_instructions=opening_instructions_subset
+            )
+
+            # self.node_selector.communicate_expansions()
+            self.tree_manager.update_backward(tree_expansions=tree_expansions)
+            self.tree_manager.update_indices(tree=self.tree)
+
+            if loop % 10 == 0:
+                self.stopping_criterion.notify_percent_progress(
+                    tree=self.tree, notify_percent_function=self.notify_percent_function
+                )
+
+        # trees.save_raw_data_to_file(tree=self.tree)
+        # self.tree_manager.print_some_stats(tree=self.tree)
+        # for move, child in self.tree.root_node.moves_children.items():
+        #    chipiron_logger.info(f'{move} {self.tree.root_node.moves_children[move].minmax_evaluation.get_value_white()}'
+        #          f' {child.minmax_evaluation.over_event.get_over_tag()}')
+        # chipiron_logger.info(f'evaluation for white: {self.tree.root_node.minmax_evaluation.get_value_white()}')
+
+        policy: BranchPolicy = self.recommend_move_after_exploration.policy(
+            self.tree.root_node
+        )
+
+        best_branch: BranchKey = self.recommend_move_after_exploration.sample(
+            policy, random_generator
+        )
+
+        self.tree_manager.print_best_line(
+            tree=self.tree
+        )  # todo maybe almost best chosen line no?
+
+        move_recommendation = BranchRecommendation(
+            branch_key=best_branch,
+            evaluation=self.tree.root_node.tree_evaluation.evaluate(),
+            policy=policy,
+            child_evals=compute_child_evals(self.tree.root_node),
+        )
+
+        tree_exploration_result: TreeExplorationResult[NodeT] = TreeExplorationResult(
+            branch_recommendation=move_recommendation, tree=self.tree
+        )
+
+        return tree_exploration_result
+
+
+def create_tree_exploration[StateT: TurnState](
+    node_selector_create: NodeSelectorFactory,
+    starting_state: StateT,
+    tree_manager: tree_man.AlgorithmNodeTreeManager[AlgorithmNode[StateT]],
+    tree_factory: ValueTreeFactory[StateT],
+    stopping_criterion_args: AllStoppingCriterionArgs,
+    recommend_move_after_exploration: recommender_rule.AllRecommendFunctionsArgs,
+    queue_progress_player: Queue[IsDataclass] | None,
+) -> TreeExploration[AlgorithmNode[StateT]]:
+    """
+    Creates a TreeExploration object with the specified dependencies.
+
+    Args:
+    - node_selector_create: The factory function for creating the node selector.
+    - starting_board: The starting chess board position.
+    - tree_manager: The manager for the tree structure.
+    - tree_factory: The factory for creating the tree structure.
+    - stopping_criterion_args: The arguments for creating the stopping criterion.
+    - recommend_move_after_exploration: The recommender rule for selecting the best move after the tree exploration.
+
+    Returns:
+    - TreeExploration: The created TreeExploration object.
+    """
+    # creates the tree
+    tree: trees.Tree[AlgorithmNode[StateT]] = tree_factory.create(
+        starting_state=starting_state
+    )
+    # creates the node selector
+    node_selector: node_sel.NodeSelector[AlgorithmNode[StateT]] = node_selector_create()
+    stopping_criterion: ProgressMonitor[AlgorithmNode[StateT]] = (
+        create_stopping_criterion(
+            args=stopping_criterion_args, node_selector=node_selector
+        )
+    )
+
+    def notify_percent_function(progress_percent: int) -> None:
+        """Send progress updates to the queue if configured."""
+        if queue_progress_player is not None:
+            queue_progress_player.put(
+                PlayerProgressMessage(
+                    progress_percent=progress_percent, player_color=starting_state.turn
+                )
+            )
+
+    tree_exploration: TreeExploration[AlgorithmNode[StateT]] = TreeExploration(
+        tree=tree,
+        tree_manager=tree_manager,
+        stopping_criterion=stopping_criterion,
+        node_selector=node_selector,
+        recommend_move_after_exploration=recommend_move_after_exploration,
+        notify_percent_function=notify_percent_function,
+    )
+
+    return tree_exploration

anemone/tree_manager/__init__.py

@@ -0,0 +1,29 @@
+"""
+This module provides functionality for managing algorithm node trees.
+
+The module includes classes for creating and managing algorithm node tree managers,
+expanding tree structures, and managing tree expansions.
+
+Classes:
+- AlgorithmNodeTreeManager: A class for managing algorithm node trees.
+- TreeManager: A class for managing tree structures.
+- TreeExpansion: A class for representing a single tree expansion.
+- TreeExpansions: A class for managing multiple tree expansions.
+
+Functions:
+- create_algorithm_node_tree_manager: A function for creating an algorithm node tree manager.
+
+"""
+
+from .algorithm_node_tree_manager import AlgorithmNodeTreeManager
+from .factory import create_algorithm_node_tree_manager
+from .tree_expander import TreeExpansion, TreeExpansions
+from .tree_manager import TreeManager
+
+__all__ = [
+    "create_algorithm_node_tree_manager",
+    "TreeManager",
+    "AlgorithmNodeTreeManager",
+    "TreeExpansion",
+    "TreeExpansions",
+]