algorhino-anemone 0.1.1__py3-none-any.whl

anemone/node_selector/notations_and_statics.py

@@ -0,0 +1,88 @@
+"""
+This module contains functions for selecting elements based on Zipf distribution.
+
+Zipf distribution is a discrete probability distribution that models the occurrence of elements in a dataset.
+The functions in this module provide methods for selecting elements based on their rank and value.
+
+"""
+
+from math import e, log
+from random import Random
+
+
+def zipf_picks(
+    ranks_values: dict[int, int | float],
+    random_generator: Random,
+    shift: bool = False,
+    random_pick: bool = False,
+) -> int:
+    """
+    Selects an element based on its rank and value.
+
+    Args:
+        ranks_values (dict[int, int | float]): A dictionary containing the ranks and values of the elements.
+        random_generator (random.Random): A random number generator.
+        shift (bool, optional): Whether to shift the ranks. Defaults to False.
+        random_pick (bool, optional): Whether to perform a random pick. Defaults to False.
+
+    Returns:
+        int: The rank of the selected element.
+
+    Raises:
+        Exception: If random_pick is True (not implemented yet).
+
+    """
+    shift_rank: int
+
+    if shift:
+        shift_rank = min(ranks_values.keys())
+    else:
+        shift_rank = 0
+
+    best_weight: float | None = None
+    best_rank: int = shift_rank
+
+    weights: list[float] = []
+    for rank, value in ranks_values.items():
+        shifted_rank = rank - shift_rank + 1
+        log_term: float = (log(e * shifted_rank)) ** 2
+        weight: float = value * shifted_rank * log_term + 0.0001
+        weights.append(weight)
+
+        if best_weight is None or weight < best_weight:
+            best_weight = weight
+            best_rank = rank
+
+    if random_pick:
+        choices_ = random_generator.choices(
+            list(ranks_values.keys()), weights=weights, k=1
+        )
+        raise NotImplementedError("not coded yet", choices_)  # not codeed properly yet
+
+    return best_rank
+
+
+def zipf_picks_random[T](ordered_list_elements: list[T], random_generator: Random) -> T:
+    """
+    Selects a random element from an ordered list based on Zipf distribution.
+
+    Args:
+        ordered_list_elements (list[T]): A list of elements.
+        random_generator (random.Random): A random number generator.
+
+    Returns:
+        T: The selected element.
+
+    Raises:
+        AssertionError: If the length of the list is 0.
+
+    """
+    length_list = len(ordered_list_elements)
+    assert length_list > 0
+    weights = [
+        1 / (index + 1) / (log(e * (index + 1))) ** 0 for index in range(length_list)
+    ]
+    picked_element = random_generator.choices(
+        ordered_list_elements, weights=weights, k=1
+    )
+    return picked_element[0]

anemone/node_selector/opening_instructions.py

@@ -0,0 +1,249 @@
+"""
+This module contains classes and functions related to opening instructions in a chess game.
+"""
+
+from dataclasses import dataclass
+from enum import Enum
+from random import Random
+from typing import Any, ItemsView, Iterator, Self, ValuesView
+
+from valanga import BranchKey
+
+from anemone import nodes
+from anemone.nodes.utils import (
+    a_branch_str_sequence_from_root,
+    a_move_key_sequence_from_root,
+)
+
+type OpeningInstructionKey = tuple[int, BranchKey]
+
+
+@dataclass(slots=True)
+class OpeningInstruction[NodeT: nodes.ITreeNode[Any] = nodes.ITreeNode[Any]]:
+    """
+    Represents an opening instruction for a specific node in the game tree.
+    """
+
+    node_to_open: NodeT
+    branch: BranchKey
+
+    def print_info(self) -> None:
+        """
+        Prints information about the opening instruction.
+        """
+        print(
+            f"OpeningInstruction: node_to_open {self.node_to_open.id} at hm {self.node_to_open.tree_depth} {self.node_to_open.state}| "
+            f"a path from root to node_to_open is {a_move_key_sequence_from_root(self.node_to_open)} {a_branch_str_sequence_from_root(self.node_to_open)}| "
+            f"self.branch {self.branch} {self.node_to_open.state.branch_name_from_key(self.branch)}"
+        )
+
+
+class OpeningInstructions[NodeT: nodes.ITreeNode[Any] = nodes.ITreeNode[Any]]:
+    # todo do we need a dict? why not a set? verify
+
+    """
+    Represents a collection of opening instructions.
+    """
+
+    batch: dict[OpeningInstructionKey, OpeningInstruction[NodeT]]
+
+    def __init__(
+        self,
+        dictionary: dict[OpeningInstructionKey, OpeningInstruction[NodeT]]
+        | None = None,
+    ) -> None:
+        """
+        Initializes the OpeningInstructions object.
+
+        Args:
+            dictionary: A dictionary of opening instructions (optional).
+        """
+        # here i use a dictionary because they are insertion ordered until there is an ordered set in python
+        # order is important because some method give a batch where the last element in the batch are prioritary
+        self.batch = {}
+
+        if dictionary is not None:
+            for key in dictionary:
+                self[key] = dictionary[key]
+
+    def __setitem__(
+        self, key: OpeningInstructionKey, value: OpeningInstruction[NodeT]
+    ) -> None:
+        """
+        Sets an opening instruction in the collection.
+
+        Args:
+            key: The key for the opening instruction.
+            value: The opening instruction.
+        """
+        # key is supposed to be a tuple with (node_to_open,  move_to_play)
+        self.batch[key] = value
+
+    def __getitem__(self, key: OpeningInstructionKey) -> OpeningInstruction[NodeT]:
+        """
+        Retrieves an opening instruction from the collection.
+
+        Args:
+            key: The key for the opening instruction.
+
+        Returns:
+            The opening instruction.
+        """
+        # assert(0==1)
+        return self.batch[key]
+
+    def __iter__(self) -> Iterator[OpeningInstructionKey]:
+        """
+        Returns an iterator over the keys of the opening instructions.
+
+        Returns:
+            An iterator over the keys.
+        """
+        return iter(self.batch)
+
+    def __bool__(self) -> bool:
+        """
+        Checks if the collection is non-empty.
+
+        Returns:
+            True if the collection is non-empty, False otherwise.
+        """
+        return bool(self.batch)
+
+    def merge(self, another_opening_instructions_batch: Self) -> None:
+        """
+        Merges another batch of opening instructions into the current collection.
+
+        Args:
+            another_opening_instructions_batch: Another OpeningInstructions object.
+        """
+        for (
+            opening_instruction_key,
+            opening_instruction,
+        ) in another_opening_instructions_batch.items():
+            if opening_instruction_key not in self.batch:
+                self.batch[opening_instruction_key] = opening_instruction
+
+    def pop_items(self, how_many: int, popped: Self) -> None:
+        """
+        Pops a specified number of opening instructions from the collection.
+
+        Args:
+            how_many: The number of opening instructions to pop.
+            popped: An OpeningInstructions object to store the popped instructions.
+        """
+        how_many = min(how_many, len(self.batch))
+        for _ in range(how_many):
+            key, value = self.batch.popitem()
+            popped[key] = value
+
+    def values(self) -> ValuesView[OpeningInstruction[NodeT]]:
+        """
+        Returns a view of the values in the collection.
+
+        Returns:
+            A view of the values.
+        """
+        return self.batch.values()
+
+    def items(self) -> ItemsView[OpeningInstructionKey, OpeningInstruction[NodeT]]:
+        """
+        Returns a view of the items (key-value pairs) in the collection.
+
+        Returns:
+            A view of the items.
+        """
+        return self.batch.items()
+
+    def print_info(self) -> None:
+        """
+        Prints information about the opening instructions in the collection.
+        """
+        print("OpeningInstructionsBatch: batch contains", len(self.batch), "elements:")
+        for _key, opening_instructions in self.batch.items():
+            opening_instructions.print_info()
+
+    def __len__(self) -> int:
+        """
+        Returns the number of opening instructions in the collection.
+
+        Returns:
+            The number of opening instructions.
+        """
+        return len(self.batch)
+
+
+def create_instructions_to_open_all_branches[NodeT: nodes.ITreeNode[Any]](
+    branches_to_play: list[BranchKey], node_to_open: NodeT
+) -> OpeningInstructions[NodeT]:
+    """
+    Creates opening instructions for all possible moves to play from a given node.
+
+    Args:
+        moves_to_play: A list of chess moves.
+        node_to_open: The node to open.
+
+    Returns:
+        An OpeningInstructions object containing the opening instructions.
+    """
+    opening_instructions_batch: OpeningInstructions[NodeT] = OpeningInstructions()
+
+    for branch_to_play in branches_to_play:
+        # at the moment it looks redundant keys are almost the same as values but its clean
+        # the keys are here for fast and redundant proof insertion
+        # and the values are here for clean data processing
+        opening_instructions_batch[(node_to_open.id, branch_to_play)] = (
+            OpeningInstruction(node_to_open=node_to_open, branch=branch_to_play)
+        )
+    #  node_to_open.non_opened_legal_moves.add(move_to_play)
+    return opening_instructions_batch
+
+
+class OpeningType(Enum):
+    """
+    Represents the type of opening to use.
+    """
+
+    ALL_CHILDREN = "all_children"
+
+
+class OpeningInstructor:
+    """
+    Represents an opening instructor that provides opening instructions based on a specific opening type.
+    """
+
+    def __init__(self, opening_type: OpeningType, random_generator: Random) -> None:
+        """
+        Initializes the OpeningInstructor object.
+
+        Args:
+            opening_type: The type of opening to use.
+            random_generator: A random number generator.
+        """
+        self.opening_type = opening_type
+        self.random_generator = random_generator
+
+    def all_branches_to_open(
+        self, node_to_open: nodes.ITreeNode[Any]
+    ) -> list[BranchKey]:
+        """
+        Returns a list of all possible branches to open from a given node.
+
+        Args:
+            node_to_open: The node to open.
+
+        Returns:
+            A list of chess moves.
+        """
+        if self.opening_type == OpeningType.ALL_CHILDREN:
+            node_to_open.all_branches_generated = True
+            branches_to_play: list[BranchKey] = node_to_open.state.branch_keys.get_all()
+
+            # this shuffling add randomness to the playing style
+            # (it stills depends on the random seed, but if random seed varies then the behavior will be more random)
+            # DEACTIVATED ATM BECAUSE I DO NOT UNDERSTAND or FORGOT THE USE CASE: MAYBE DEAD SINCE SEED SYSTEM CHANGED
+            # self.random_generator.shuffle(moves_to_play)
+
+        else:
+            raise NotImplementedError("Hello-la")
+        return branches_to_play

anemone/node_selector/recurzipf/recur_zipf_base.py

@@ -0,0 +1,141 @@
+"""
+This module contains the implementation of the RecurZipfBase class, which is a node selector for a move selector tree.
+
+The RecurZipfBase class is responsible for selecting the next node to explore in a move selector tree based on the RecurZipf algorithm.
+
+Classes:
+- RecurZipfBase: The RecurZipfBase Node selector.
+
+"""
+
+from dataclasses import dataclass
+from random import Random
+from typing import TYPE_CHECKING, Any, Literal
+
+from anemone import trees
+from anemone.node_selector.branch_explorer import SamplingPriorities, ZipfBranchExplorer
+from anemone.node_selector.node_selector_types import NodeSelectorType
+from anemone.node_selector.opening_instructions import (
+    OpeningInstructions,
+    OpeningInstructor,
+    create_instructions_to_open_all_branches,
+)
+from anemone.nodes.algorithm_node.algorithm_node import AlgorithmNode
+
+if TYPE_CHECKING:
+    from anemone import tree_manager as tree_man
+
+
+@dataclass
+class RecurZipfBaseArgs:
+    """
+    Arguments for the RecurZipfBase node selector.
+
+    Attributes:
+        move_explorer_priority (SamplingPriorities): The priority for move exploration.
+    """
+
+    type: Literal[NodeSelectorType.RECUR_ZIPF_BASE]
+    branch_explorer_priority: SamplingPriorities
+
+
+class RecurZipfBase[NodeT: AlgorithmNode[Any] = AlgorithmNode[Any]]:
+    """The RecurZipfBase Node selector"""
+
+    opening_instructor: OpeningInstructor
+
+    def __init__(
+        self,
+        args: RecurZipfBaseArgs,
+        random_generator: Random,
+        opening_instructor: OpeningInstructor,
+    ) -> None:
+        """
+        Initializes a new instance of the RecurZipfBase class.
+
+        Args:
+        - args (RecurZipfBaseArgs): The arguments for the RecurZipfBase node selector.
+        - random_generator (random.Random): The random number generator.
+        - opening_instructor (OpeningInstructor): The opening instructor.
+
+        """
+        self.opening_instructor = opening_instructor
+        self.branch_explorer = ZipfBranchExplorer(
+            args.branch_explorer_priority, random_generator
+        )
+        self.random_generator = random_generator
+
+    def choose_node_and_branch_to_open(
+        self,
+        tree: trees.Tree[NodeT],
+        latest_tree_expansions: "tree_man.TreeExpansions[NodeT]",
+    ) -> OpeningInstructions[NodeT]:
+        """
+        Chooses the next node to explore and the move to open.
+
+        Args:
+        - tree (trees.Tree[AlgorithmNode]): The move selector tree.
+        - latest_tree_expansions (tree_man.TreeExpansions): The latest tree expansions.
+
+        Returns:
+        - OpeningInstructions: The instructions for opening the selected move.
+
+        """
+        # todo maybe proportions and proportions can be valuesorted dict with smart updates
+
+        _ = latest_tree_expansions  # not used here
+        opening_instructions: OpeningInstructions[NodeT]
+        # TODO make sure this block is put in chipiron now with a wrapper
+        # best_node_sequence = best_node_sequence_from_node(tree.root_node)
+        # if best_node_sequence:
+        #     last_node_in_best_line = best_node_sequence[-1]
+        #     assert isinstance(last_node_in_best_line, AlgorithmNode)
+        #     if (
+        #         last_node_in_best_line.state.is_attacked(
+        #             not last_node_in_best_line.tree_node.player_to_move
+        #         )
+        #         and not last_node_in_best_line.minmax_evaluation.is_over()
+        #     ):
+        #         # print('best line is underattacked')
+        #         if self.random_generator.random() > 0.5:
+        #             # print('best line is underattacked and i do')
+        #             all_moves_to_open: list[BranchKey] = (
+        #                 self.opening_instructor.all_branches_to_open(
+        #                     node_to_open=last_node_in_best_line.tree_node
+        #                 )
+        #             )
+        #             opening_instructions = create_instructions_to_open_all_branches(
+        #                 branches_to_play=all_moves_to_open,
+        #                 node_to_open=last_node_in_best_line,
+        #             )
+        #             return opening_instructions
+
+        wandering_node: NodeT = tree.root_node
+
+        while wandering_node.tree_evaluation.branches_not_over:
+            assert not wandering_node.is_over()
+            branch = self.branch_explorer.sample_branch_to_explore(
+                tree_node_to_sample_from=wandering_node
+            )
+            next_node = wandering_node.branches_children[branch]
+            assert next_node is not None
+            wandering_node = next_node
+
+        all_branches_to_open = self.opening_instructor.all_branches_to_open(
+            node_to_open=wandering_node
+        )
+        opening_instructions = create_instructions_to_open_all_branches(
+            branches_to_play=all_branches_to_open, node_to_open=wandering_node
+        )
+
+        return opening_instructions
+
+    def __str__(self) -> str:
+        """
+        Returns a string representation of the RecurZipfBase node selector.
+
+        Returns:
+        - str: The string representation of the RecurZipfBase node selector.
+
+        """
+        return "RecurZipfBase"

anemone/node_selector/sequool/__init__.py

@@ -0,0 +1,19 @@
+"""
+This module provides functionality for creating and managing Sequool objects.
+
+A Sequool object represents a sequence of operations that can be applied to a dataset.
+
+Example usage:
+    from .factory import create_sequool, SequoolArgs
+
+    # Create a Sequool object
+    sequool = create_sequool()
+
+    # Define the arguments for the Sequool object
+    sequool_args = SequoolArgs()
+
+"""
+
+from .factory import SequoolArgs, create_sequool
+
+__all__ = ["create_sequool", "SequoolArgs"]

anemone/node_selector/sequool/factory.py

@@ -0,0 +1,102 @@
+"""
+factory for sequool node selector
+"""
+
+from dataclasses import dataclass
+from functools import partial
+from random import Random
+from typing import Literal
+
+from anemone import trees
+from anemone.node_selector.node_selector_types import (
+    NodeSelectorType,
+)
+from anemone.node_selector.opening_instructions import (
+    OpeningInstructor,
+)
+from anemone.nodes.algorithm_node.algorithm_node import AlgorithmNode
+
+from .sequool import (
+    ConsiderNodesFromTreeDepths,
+    RandomAllSelector,
+    Sequool,
+    StaticNotOpenedSelector,
+    TreeDepthSelector,
+    consider_nodes_from_all_lesser_tree_depths_in_descendants,
+    consider_nodes_from_all_lesser_tree_depths_in_sub_stree,
+    consider_nodes_only_from_tree_depths_in_descendants,
+)
+
+
+@dataclass
+class SequoolArgs:
+    """
+    Arguments for the Sequool node selector.
+
+    Attributes:
+        recursive_selection_on_all_nodes (bool): Flag indicating whether to perform recursive selection on all nodes.
+        random_depth_pick (bool): Flag indicating whether to randomly pick a depth for selection.
+        consider_all_lesser_half_move (bool): Flag indicating whether to consider all lesser half moves.
+    """
+
+    type: Literal[NodeSelectorType.SEQUOOL]
+    recursive_selection_on_all_nodes: bool
+    random_depth_pick: bool
+    consider_all_lesser_half_move: bool
+
+
+def create_sequool(
+    opening_instructor: OpeningInstructor,
+    args: SequoolArgs,
+    random_generator: Random,
+) -> Sequool[AlgorithmNode]:
+    """
+    Create a sequool node selector object.
+
+    Args:
+        opening_instructor: An opening instructor object.
+        args: Dictionary of arguments.
+        random_generator: Random generator object.
+
+    Returns:
+        A sequool node selector object.
+
+    """
+    all_nodes_not_opened = trees.Descendants[AlgorithmNode]()
+    tree_depth_selector: TreeDepthSelector
+    if args.recursive_selection_on_all_nodes:
+        tree_depth_selector = RandomAllSelector()
+    else:
+        tree_depth_selector = StaticNotOpenedSelector(
+            all_nodes_not_opened=all_nodes_not_opened
+        )
+
+    consider_nodes_from_tree_depths: ConsiderNodesFromTreeDepths[AlgorithmNode]
+    if args.recursive_selection_on_all_nodes:
+        consider_nodes_from_tree_depths = (
+            consider_nodes_from_all_lesser_tree_depths_in_sub_stree
+        )
+    else:
+        if args.consider_all_lesser_half_move:
+            consider_nodes_from_all_lesser_tree_depths = partial(
+                consider_nodes_from_all_lesser_tree_depths_in_descendants,
+                descendants=all_nodes_not_opened,
+            )
+            consider_nodes_from_tree_depths = consider_nodes_from_all_lesser_tree_depths
+        else:
+            consider_nodes_only_from_tree_depths = partial(
+                consider_nodes_only_from_tree_depths_in_descendants,
+                descendants=all_nodes_not_opened,
+            )
+            consider_nodes_from_tree_depths = consider_nodes_only_from_tree_depths
+    sequool: Sequool[AlgorithmNode] = Sequool(
+        opening_instructor=opening_instructor,
+        all_nodes_not_opened=all_nodes_not_opened,
+        recursif=args.recursive_selection_on_all_nodes,
+        tree_depth_selector=tree_depth_selector,
+        random_depth_pick=args.random_depth_pick,
+        random_generator=random_generator,
+        consider_nodes_from_tree_depths=consider_nodes_from_tree_depths,
+    )
+
+    return sequool