algorhino-anemone 0.1.1__py3-none-any.whl

anemone/updates/index_updater.py

@@ -0,0 +1,100 @@
+"""
+This module contains the IndexUpdater class, which is responsible for updating the indices of AlgorithmNode objects in a tree structure.
+"""
+
+from typing import TYPE_CHECKING
+
+from anemone.indices.node_indices.index_data import (
+    MaxDepthDescendants,
+)
+from anemone.nodes.algorithm_node.algorithm_node import (
+    AlgorithmNode,
+)
+
+from .index_block import (
+    IndexUpdateInstructionsFromOneNode,
+    IndexUpdateInstructionsTowardsOneParentNode,
+)
+from .updates_file import UpdateInstructionsTowardsOneParentNode
+
+if TYPE_CHECKING:
+    from valanga import BranchKey
+
+
+class IndexUpdater:
+    """
+    The IndexUpdater class is responsible for updating the indices of AlgorithmNode objects in a tree structure.
+    """
+
+    def __init__(self) -> None:
+        """Initialize the index updater."""
+        ...
+
+    def create_update_instructions_after_node_birth(
+        self, new_node: AlgorithmNode
+    ) -> IndexUpdateInstructionsFromOneNode:
+        """
+        Creates the update instructions block after a new node is added to the tree.
+
+        Args:
+            new_node (AlgorithmNode): The newly added node.
+
+        Returns:
+            IndexUpdateInstructionsBlock: The update instructions block.
+        """
+        base_update_instructions: IndexUpdateInstructionsFromOneNode = (
+            IndexUpdateInstructionsFromOneNode(
+                node_sending_update=new_node, updated_index=True
+            )
+        )
+        return base_update_instructions
+
+    def perform_updates(
+        self,
+        node_to_update: AlgorithmNode,
+        updates_instructions: UpdateInstructionsTowardsOneParentNode,
+    ) -> IndexUpdateInstructionsFromOneNode:
+        """
+        Performs the index updates based on the given update instructions.
+
+        Args:
+            node_to_update (AlgorithmNode): The node to update.
+            updates_instructions (UpdateInstructionsTowardsOneParentNode): The update instructions toward this node.
+
+        Returns:
+            IndexUpdateInstructionsFromOneNode: The update instructions coming from the updated node.
+        """
+        # get the base block
+        updates_instructions_index: IndexUpdateInstructionsTowardsOneParentNode | None
+        updates_instructions_index = (
+            updates_instructions.index_updates_toward_one_parent_node
+        )
+        assert updates_instructions_index is not None
+
+        # UPDATE index
+        has_index_changed: bool = False
+        branch: BranchKey
+        for branch in updates_instructions_index.branches_with_updated_index:
+            # hardcoded at some point it should be linked to updater coming from search factory i believe
+            assert isinstance(
+                node_to_update.exploration_index_data, MaxDepthDescendants
+            )
+            child = node_to_update.tree_node.branches_children[branch]
+            assert isinstance(child, AlgorithmNode)
+            assert isinstance(child.exploration_index_data, MaxDepthDescendants)
+            has_index_changed_child: bool = (
+                node_to_update.exploration_index_data.update_from_child(
+                    child.exploration_index_data.max_depth_descendants
+                )
+            )
+            has_index_changed = has_index_changed or has_index_changed_child
+
+        base_update_instructions: IndexUpdateInstructionsFromOneNode = (
+            IndexUpdateInstructionsFromOneNode(
+                node_sending_update=node_to_update, updated_index=has_index_changed
+            )
+        )
+
+        return base_update_instructions
+
+        # todo i dont understand anymore when the instructions stops beeing propagated back

anemone/updates/minmax_evaluation_updater.py

@@ -0,0 +1,108 @@
+"""
+This module contains the MinMaxEvaluationUpdater class, which is responsible for updating the min-max evaluation values of AlgorithmNode objects.
+"""
+
+from anemone.nodes.algorithm_node.algorithm_node import (
+    AlgorithmNode,
+)
+
+from .updates_file import UpdateInstructionsTowardsOneParentNode
+from .value_block import (
+    ValueUpdateInstructionsFromOneNode,
+    ValueUpdateInstructionsTowardsOneParentNode,
+)
+
+
+class MinMaxEvaluationUpdater:
+    """
+    The MinMaxEvaluationUpdater class is responsible for updating the min-max evaluation values of AlgorithmNode objects.
+    """
+
+    def __init__(self) -> None:
+        """Initializes a new instance of the MinMaxEvaluationUpdater class."""
+        ...
+
+    def create_update_instructions_after_node_birth(
+        self, new_node: AlgorithmNode
+    ) -> ValueUpdateInstructionsFromOneNode:
+        """
+        Creates the update instructions for a newly created AlgorithmNode.
+
+        Args:
+            new_node (AlgorithmNode): The newly created AlgorithmNode.
+
+        Returns:
+            ValueUpdateInstructionsBlock: The update instructions for the newly created node.
+        """
+        base_update_instructions: ValueUpdateInstructionsFromOneNode = (
+            ValueUpdateInstructionsFromOneNode(
+                node_sending_update=new_node,
+                is_node_newly_over=new_node.tree_evaluation.over_event.is_over(),
+                new_value_for_node=True,
+                new_best_move_for_node=False,
+            )
+        )
+        return base_update_instructions
+
+    def perform_updates(
+        self,
+        node_to_update: AlgorithmNode,
+        updates_instructions: UpdateInstructionsTowardsOneParentNode,
+    ) -> ValueUpdateInstructionsFromOneNode:
+        """
+        Performs the updates on an AlgorithmNode based on the given update instructions.
+
+        Args:
+            node_to_update (AlgorithmNode): The AlgorithmNode to update.
+            updates_instructions (UpdateInstructionsTowardsOneParentNode): The update instructions.
+
+        Returns:
+            ValueUpdateInstructionsFromOneNode: The update instructions for the parents of the updated node.
+        """
+        # get the base block
+        updates_instructions_block: ValueUpdateInstructionsTowardsOneParentNode | None
+        updates_instructions_block = (
+            updates_instructions.value_updates_toward_one_parent_node
+        )
+        assert updates_instructions_block is not None
+
+        # UPDATE VALUE
+        has_value_changed: bool
+        has_best_node_seq_changed_1: bool
+        has_value_changed, has_best_node_seq_changed_1 = (
+            node_to_update.tree_evaluation.minmax_value_update_from_children(
+                branches_with_updated_value=updates_instructions_block.branches_with_updated_value
+            )
+        )
+
+        # UPDATE BEST MOVE
+        has_best_node_seq_changed_2: bool
+        if updates_instructions_block.branches_with_updated_best_branch:
+            has_best_node_seq_changed_2 = (
+                node_to_update.tree_evaluation.update_best_branch_sequence(
+                    updates_instructions_block.branches_with_updated_best_branch
+                )
+            )
+        else:
+            has_best_node_seq_changed_2 = False
+        has_best_node_seq_changed: bool = (
+            has_best_node_seq_changed_1 or has_best_node_seq_changed_2
+        )
+
+        # UPDATE OVER
+        is_newly_over = node_to_update.tree_evaluation.update_over(
+            updates_instructions_block.branches_with_updated_over
+        )
+
+        assert is_newly_over is not None
+
+        # create the new instructions for the parents
+        base_update_instructions_block: ValueUpdateInstructionsFromOneNode
+        base_update_instructions_block = ValueUpdateInstructionsFromOneNode(
+            node_sending_update=node_to_update,
+            is_node_newly_over=is_newly_over,
+            new_value_for_node=has_value_changed,
+            new_best_move_for_node=has_best_node_seq_changed,
+        )
+
+        return base_update_instructions_block

anemone/updates/updates_file.py

@@ -0,0 +1,248 @@
+"""
+This module contains classes for managing update instructions in a batch.
+
+Classes:
+- UpdateInstructions: Represents update instructions for a single node.
+- UpdateInstructionsBatch: Represents a batch of update instructions for multiple nodes.
+"""
+
+from dataclasses import dataclass, field
+from typing import Self
+
+from valanga import BranchKey
+
+from anemone.nodes.algorithm_node.algorithm_node import AlgorithmNode
+from anemone.utils.dict_of_numbered_dict_with_pointer_on_max import (
+    DictOfNumberedDictWithPointerOnMax,
+)
+
+from .index_block import (
+    IndexUpdateInstructionsFromOneNode,
+    IndexUpdateInstructionsTowardsOneParentNode,
+)
+from .value_block import (
+    ValueUpdateInstructionsFromOneNode,
+    ValueUpdateInstructionsTowardsOneParentNode,
+)
+
+
+@dataclass(slots=True)
+class UpdateInstructionsFromOneNode:
+    """
+    Represents update instructions generated from a single node.
+
+    Attributes:
+    - value_block: The value update instructions generated from a single node.
+    - index_block: The index update instructions generated from a single node.
+    """
+
+    value_block: ValueUpdateInstructionsFromOneNode | None = None
+    index_block: IndexUpdateInstructionsFromOneNode | None = None
+
+
+@dataclass(slots=True)
+class UpdateInstructionsTowardsOneParentNode:
+    """
+    Represents update instructions for a single node.
+
+    Attributes:
+    - value_block: The value update instructions block.
+    - index_block: The index update instructions block.
+    """
+
+    value_updates_toward_one_parent_node: (
+        ValueUpdateInstructionsTowardsOneParentNode | None
+    ) = None
+    index_updates_toward_one_parent_node: (
+        IndexUpdateInstructionsTowardsOneParentNode | None
+    ) = None
+
+    def add_update_from_a_child_node(
+        self,
+        update_from_a_child_node: UpdateInstructionsFromOneNode,
+        branch_from_parent_to_child: BranchKey,
+    ) -> None:
+        """
+        Adds update instructions from a child node.
+
+        Args:
+        - update_from_a_child_node: The update instructions from the child node.
+        - branch_from_parent_to_child: The branch key from the parent to the child.
+        """
+        assert self.value_updates_toward_one_parent_node is not None
+        assert update_from_a_child_node.value_block is not None
+        self.value_updates_toward_one_parent_node.add_update_from_one_child_node(
+            branch_from_parent_to_child=branch_from_parent_to_child,
+            update_from_one_child_node=update_from_a_child_node.value_block,
+        )
+
+        if self.index_updates_toward_one_parent_node is None:
+            assert update_from_a_child_node.index_block is None
+        else:
+            if update_from_a_child_node.index_block is not None:
+                self.index_updates_toward_one_parent_node.add_update_from_one_child_node(
+                    branch_from_parent_to_child=branch_from_parent_to_child,
+                    update_from_one_child_node=update_from_a_child_node.index_block,
+                )
+
+    def add_updates_towards_one_parent_node(self, another_update: Self) -> None:
+        """
+        Adds update instructions from another UpdateInstructionsTowardsOneParentNode.
+        Args:
+        - another_update: The other update instructions to add.
+        """
+        assert self.value_updates_toward_one_parent_node is not None
+        assert another_update.value_updates_toward_one_parent_node is not None
+        self.value_updates_toward_one_parent_node.add_update_toward_one_parent_node(
+            another_update.value_updates_toward_one_parent_node
+        )
+
+        if self.index_updates_toward_one_parent_node is None:
+            assert another_update.index_updates_toward_one_parent_node is None
+        else:
+            if another_update.index_updates_toward_one_parent_node is not None:
+                self.index_updates_toward_one_parent_node.add_update_toward_one_parent_node(
+                    another_update.index_updates_toward_one_parent_node
+                )
+
+    def print_info(self) -> None:
+        """
+        Prints information about the update instructions.
+        """
+        print("printing info of update instructions")
+        assert (
+            self.index_updates_toward_one_parent_node is not None
+            and self.value_updates_toward_one_parent_node is not None
+        )
+        self.value_updates_toward_one_parent_node.print_info()
+        self.index_updates_toward_one_parent_node.print_info()
+
+    def empty(self) -> bool:
+        """
+        Checks if the update instructions are empty.
+
+        Returns:
+        - True if the update instructions are empty, False otherwise.
+        """
+        assert self.value_updates_toward_one_parent_node is not None
+        return self.value_updates_toward_one_parent_node.empty() and (
+            self.index_updates_toward_one_parent_node is None
+            or self.index_updates_toward_one_parent_node.empty()
+        )
+
+
+@dataclass
+class UpdateInstructionsTowardsMultipleNodes[NodeT: AlgorithmNode = AlgorithmNode]:
+    """Represents update instructions towards multiple parent nodes."""
+
+    @staticmethod
+    def _new_one_node_instructions() -> DictOfNumberedDictWithPointerOnMax[
+        NodeT, UpdateInstructionsTowardsOneParentNode
+    ]:
+        """Return a fresh mapping for per-node update instructions."""
+        return DictOfNumberedDictWithPointerOnMax()
+
+    one_node_instructions: DictOfNumberedDictWithPointerOnMax[
+        NodeT, UpdateInstructionsTowardsOneParentNode
+    ] = field(default_factory=_new_one_node_instructions)
+
+    def add_update_from_one_child_node(
+        self,
+        update_from_child_node: UpdateInstructionsFromOneNode,
+        parent_node: NodeT,
+        branch_from_parent: BranchKey,
+    ) -> None:
+        """
+        Adds update instructions from a child node to a parent node.
+        Args:
+            update_from_child_node: The update instructions from the child node.
+            parent_node: The parent node to which the updates are directed.
+            branch_from_parent: The branch key from the parent to the child.
+        """
+        if parent_node not in self.one_node_instructions:
+            # build the UpdateInstructionsTowardsOneParentNode
+            assert update_from_child_node.value_block is not None
+            value_updates_toward_one_parent_node: (
+                ValueUpdateInstructionsTowardsOneParentNode
+            )
+            value_updates_toward_one_parent_node = (
+                ValueUpdateInstructionsTowardsOneParentNode(
+                    branches_with_updated_value=(
+                        {branch_from_parent}
+                        if update_from_child_node.value_block.new_value_for_node
+                        else set()
+                    ),
+                    branches_with_updated_over=(
+                        {branch_from_parent}
+                        if update_from_child_node.value_block.is_node_newly_over
+                        else set()
+                    ),
+                    branches_with_updated_best_branch=(
+                        {branch_from_parent}
+                        if update_from_child_node.value_block.new_best_move_for_node
+                        else set()
+                    ),
+                )
+            )
+            index_updates_toward_one_parent_node: (
+                IndexUpdateInstructionsTowardsOneParentNode | None
+            )
+            if update_from_child_node.index_block is not None:
+                index_updates_toward_one_parent_node = (
+                    IndexUpdateInstructionsTowardsOneParentNode(
+                        branches_with_updated_index=(
+                            {branch_from_parent}
+                            if update_from_child_node.index_block.updated_index
+                            else set()
+                        ),
+                    )
+                )
+            else:
+                index_updates_toward_one_parent_node = None
+            update_instructions_towards_parent: UpdateInstructionsTowardsOneParentNode
+            update_instructions_towards_parent = UpdateInstructionsTowardsOneParentNode(
+                value_updates_toward_one_parent_node=value_updates_toward_one_parent_node,
+                index_updates_toward_one_parent_node=index_updates_toward_one_parent_node,
+            )
+            self.one_node_instructions[parent_node] = update_instructions_towards_parent
+        else:
+            # update the UpdateInstructionsTowardsOneParentNode
+            self.one_node_instructions[parent_node].add_update_from_a_child_node(
+                update_from_a_child_node=update_from_child_node,
+                branch_from_parent_to_child=branch_from_parent,
+            )
+
+    def add_updates_towards_one_parent_node(
+        self,
+        update_from_child_node: UpdateInstructionsTowardsOneParentNode,
+        parent_node: NodeT,
+    ) -> None:
+        """
+        Adds update instructions from another UpdateInstructionsTowardsOneParentNode to a parent node.
+        Args:
+            update_from_child_node: The update instructions from another UpdateInstructionsTowardsOneParentNode.
+            parent_node: The parent node to which the updates are directed.
+        """
+        if parent_node in self.one_node_instructions:
+            self.one_node_instructions[parent_node].add_updates_towards_one_parent_node(
+                another_update=update_from_child_node
+            )
+        else:
+            self.one_node_instructions[parent_node] = update_from_child_node
+
+    def pop_item(self) -> tuple[NodeT, UpdateInstructionsTowardsOneParentNode]:
+        """
+        Pops an item from the update instructions.
+        Returns:
+            A tuple containing the parent node and its corresponding update instructions.
+        """
+        return self.one_node_instructions.popitem()
+
+    def __bool__(self) -> bool:
+        """
+        Checks if the data structure is non-empty.
+
+        Returns:
+            bool: True if the data structure is non-empty, False otherwise.
+        """
+        return bool(self.one_node_instructions)

anemone/updates/value_block.py

@@ -0,0 +1,133 @@
+"""
+This module defines the ValueUpdateInstructionsBlock class and a helper function to create instances of it.
+
+The ValueUpdateInstructionsBlock class represents a block of update instructions for a tree value node in
+ a move selector algorithm. It contains sets of moves that have been updated with new values,
+  best moves, or are newly over.
+
+The create_value_update_instructions_block function is a helper function that creates an instance of
+ the ValueUpdateInstructionsBlock class with the specified update instructions.
+
+"""
+
+from dataclasses import dataclass, field
+from typing import Self
+
+from valanga import BranchKey
+
+from anemone.nodes.algorithm_node.algorithm_node import (
+    AlgorithmNode,
+)
+
+
+@dataclass(slots=True)
+class ValueUpdateInstructionsFromOneNode:
+    """Represents update instructions generated from a single node."""
+
+    node_sending_update: AlgorithmNode
+    is_node_newly_over: bool
+    new_value_for_node: bool
+    new_best_move_for_node: bool
+
+
+def _new_branchkey_set() -> set[BranchKey]:
+    """Return a new empty set of branch keys."""
+    return set()
+
+
+@dataclass(slots=True)
+class ValueUpdateInstructionsTowardsOneParentNode:
+    """Represents a block of value-update instructions intended to a specific node in the algorithm tree."""
+
+    branches_with_updated_over: set[BranchKey] = field(
+        default_factory=_new_branchkey_set
+    )
+    branches_with_updated_value: set[BranchKey] = field(
+        default_factory=_new_branchkey_set
+    )
+    branches_with_updated_best_branch: set[BranchKey] = field(
+        default_factory=_new_branchkey_set
+    )
+
+    def add_update_from_one_child_node(
+        self,
+        update_from_one_child_node: ValueUpdateInstructionsFromOneNode,
+        branch_from_parent_to_child: BranchKey,
+    ) -> None:
+        """Adds an update from a child node to the parent node.
+
+        Args:
+            update_from_one_child_node (ValueUpdateInstructionsFromOneNode): The update instructions from the child node.
+            move_from_parent_to_child (moveKey): The move key representing the move from the parent to the child.
+        """
+        if update_from_one_child_node.is_node_newly_over:
+            self.branches_with_updated_over.add(branch_from_parent_to_child)
+        if update_from_one_child_node.new_value_for_node:
+            self.branches_with_updated_value.add(branch_from_parent_to_child)
+        if update_from_one_child_node.new_best_move_for_node:
+            self.branches_with_updated_best_branch.add(branch_from_parent_to_child)
+
+    def add_update_toward_one_parent_node(self, another_update: Self) -> None:
+        """Adds an update towards one parent node.
+
+        Args:
+            another_update (Self): The update instructions from another child node.
+        """
+        self.branches_with_updated_value = (
+            self.branches_with_updated_value
+            | another_update.branches_with_updated_value
+        )
+        self.branches_with_updated_over = (
+            self.branches_with_updated_over | another_update.branches_with_updated_over
+        )
+        self.branches_with_updated_best_branch = (
+            self.branches_with_updated_best_branch
+            | another_update.branches_with_updated_best_branch
+        )
+
+    def print_info(self) -> None:
+        """
+        Print information about the update instructions block.
+
+        Returns:
+            None
+        """
+        print("upInstructions printing")
+        print(
+            len(self.branches_with_updated_value),
+            "branches_with_updated_value",
+            end=" ",
+        )
+        for branch in self.branches_with_updated_value:
+            print(branch, end=" ")
+        print(
+            "\n",
+            len(self.branches_with_updated_best_branch),
+            "branches_with_updated_best_branch:",
+            end=" ",
+        )
+        for branch in self.branches_with_updated_best_branch:
+            print(branch, end=" ")
+        print(
+            "\n",
+            len(self.branches_with_updated_over),
+            "branches_with_updated_over",
+            end=" ",
+        )
+        for branch in self.branches_with_updated_over:
+            print(branch, end=" ")
+        print()
+
+    def empty(self) -> bool:
+        """
+        Check if all the components of the update instructions block are empty.
+
+        Returns:
+            bool: True if all components are empty, False otherwise.
+        """
+        empty_bool = (
+            not bool(self.branches_with_updated_value)
+            and not bool(self.branches_with_updated_best_branch)
+            and not bool(self.branches_with_updated_over)
+        )
+        return empty_bool

anemone/utils/comparable.py

@@ -0,0 +1,32 @@
+"""
+This module defines the Comparable class, which is an abstract base class for objects that can be compared.
+
+Classes that inherit from Comparable must implement the __lt__ method, which defines the less-than comparison operation.
+
+"""
+
+from abc import ABCMeta, abstractmethod
+from typing import Any, TypeVar
+
+
+class Comparable(metaclass=ABCMeta):
+    """
+    An abstract base class for objects that can be compared.
+
+    Subclasses of `Comparable` must implement the `__lt__` method to define the less-than comparison.
+
+    Attributes:
+        None
+
+    Methods:
+        __lt__(self, other: Any) -> bool: Abstract method that compares the object with another object and
+         returns True if the object is less than the other object, False otherwise.
+    """
+
+    @abstractmethod
+    def __lt__(self, other: Any) -> bool:
+        """Return True if this object is less than the other."""
+        ...
+
+
+CT = TypeVar("CT", bound=Comparable)

anemone/utils/dataclass.py

@@ -0,0 +1,64 @@
+"""
+Module to check if an object is a dataclass
+"""
+
+from collections.abc import Iterable
+from enum import Enum
+from typing import Any, ClassVar, Protocol, no_type_check
+
+
+class DataClass(Protocol):
+    """
+    Protocol to represent a dataclass.
+
+    This protocol is used to check if an object is a dataclass by checking
+    for the presence of the `__dataclass_fields__` attribute.
+    """
+
+    __dataclass_fields__: dict[str, Any]
+
+
+class IsDataclass(Protocol):
+    """
+    Protocol to represent a dataclass.
+
+    This protocol is used to check if an object is a dataclass by checking
+    for the presence of the `__dataclass_fields__` attribute.
+    """
+
+    __dataclass_fields__: ClassVar[dict[Any, Any]]
+
+
+# used as factory function in one of the option of as_dict in order to make the enum be replaced by str (useful for yamlization)
+# pyright: ignore
+def custom_asdict_factory(data: Iterable[tuple[Any, Any]]) -> dict[Any, Any]:
+    """Custom asdict factory function.
+
+    Args:
+        data (Iterable[tuple[Any, Any]]): The input data to be converted.
+
+    Returns:
+        dict[Any, Any]: The converted dictionary.
+    """
+
+    @no_type_check
+    def convert_value(obj: Any) -> Any:
+        """Converts a value to a serializable format.
+
+        Args:
+            obj (Any): The input value to be converted.
+
+        Returns:
+            Any: The converted value.
+        """
+        if isinstance(obj, Enum):
+            return obj.value
+        elif isinstance(obj, list):
+            return [convert_value(item) for item in obj]
+        elif isinstance(obj, dict):
+            result: dict[Any, Any] = {k: convert_value(v) for k, v in obj.items()}
+            return result
+        else:
+            return obj
+
+    return dict((k, convert_value(v)) for k, v in data)