algorhino-anemone 0.1.9__py3-none-any.whl → 0.1.11__py3-none-any.whl

{algorhino_anemone-0.1.9.dist-info → algorhino_anemone-0.1.11.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: algorhino-anemone
-Version: 0.1.9
+Version: 0.1.11
 Summary: anemone searches trees
 Author-email: Victor Gabillon <victorgabillon@gmail.com>
 License-Expression: GPL-3.0-only
@@ -12,18 +12,18 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.13
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: valanga>=0.1.10
-Requires-Dist: atomheart>=0.1.2
+Requires-Dist: valanga>=0.1.14
+Requires-Dist: atomheart>=0.1.7
 Requires-Dist: rich
 Requires-Dist: sortedcollections>=2.1.0
 Requires-Dist: graphviz
 Provides-Extra: test
-Requires-Dist: pytest>=8.4.1; extra == "test"
+Requires-Dist: pytest>=9.0.2; extra == "test"
 Requires-Dist: coverage; extra == "test"
 Requires-Dist: pytest-cov>=6.0.0; extra == "test"
 Provides-Extra: lint
-Requires-Dist: ruff>=0.14.1; extra == "lint"
-Requires-Dist: pylint>=3.3.8; extra == "lint"
+Requires-Dist: ruff>=0.15.0; extra == "lint"
+Requires-Dist: pylint>=4.0.4; extra == "lint"
 Provides-Extra: typecheck
 Requires-Dist: mypy>=1.18.2; extra == "typecheck"
 Requires-Dist: pyright[nodejs]>=1.1.408; extra == "typecheck"

algorhino_anemone-0.1.11.dist-info/RECORD

@@ -0,0 +1,82 @@
+algorhino_anemone-0.1.11.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+anemone/__init__.py,sha256=15XN-GemLe35vDc4CBT9DE0IVap1g1jP2IVI8X_2Tqo,928
+anemone/basics.py,sha256=wKagPFuxXhDQbjTuM1Qjh37HcJt0m39NBMDg2dc2M6M,188
+anemone/factory.py,sha256=IHtTjR2S92sqeRY2KBNagui3oDPCOEj5IDR3yF5DL0I,6075
+anemone/state_transition.py,sha256=fxvHZOYRtWV5ExXRIoehdRg9qV6zhgiE5uiCeOc80Dc,1418
+anemone/tree_and_value_branch_selector.py,sha256=-Jehxi328Q-rUvU7gZorRVWRDijyBlwrRbaFBvaNiOY,3655
+anemone/tree_exploration.py,sha256=a-uOaPp41K2vCjl9yYQHmVKjZH8Lrpmtbsohpl80Ik0,10242
+anemone/indices/__init__.py,sha256=s1_3fzDPi-L7VQcee0GCpuhza2Exljee-LVuxPu3ht0,65
+anemone/indices/index_manager/__init__.py,sha256=JWYMhOT-XX3cZ36OEy-veZvA8Dbjm_TCwBeyUgEFMr8,501
+anemone/indices/index_manager/factory.py,sha256=15t-olh8mGSP739j0ZYm2uqfWCb9zz1wilkfdC1Dtvg,2014
+anemone/indices/index_manager/node_exploration_manager.py,sha256=WG72bKkKsZbCZ2PKMG8RU0BLb4tvIOF0amEelcb_wTA,23273
+anemone/indices/node_indices/__init__.py,sha256=UcrRQDEs8HybHVkFbUZl9beS3N8EcuGYq7YzOLOxKwk,760
+anemone/indices/node_indices/factory.py,sha256=suPUsjjK3o_fBrjLhab9ELXM8eeXQd5_feWgERTNYaM,4345
+anemone/indices/node_indices/index_data.py,sha256=TH30Rs-meexyFjdIOyGBjgCLTPc1nF4WtbDzlDi-RUs,5345
+anemone/indices/node_indices/index_types.py,sha256=9qwZxv7OBgytwcWGZ-1G6RYDBvQD5rOFxMuBd6vfJAg,551
+anemone/nn/torch_evaluator.py,sha256=lALUV8rm4c80wFxiWHI_-00BMenqAaivqz29GbqPXHY,3611
+anemone/node_evaluation/__init__.py,sha256=FIeCBTB3QsNsIJ22inDJNf3vVsIBdFUuqJJ0L8Q8d9Y,58
+anemone/node_evaluation/node_direct_evaluation/__init__.py,sha256=FB_WFfdy0oTsz1sRF2Rd7-sXoI5Iu1Rdyolj0HF0Uis,884
+anemone/node_evaluation/node_direct_evaluation/factory.py,sha256=z-AywVoud87mL_NLXY3DjbfPhTPBMZmuVdLLGlrQTjE,457
+anemone/node_evaluation/node_direct_evaluation/node_direct_evaluator.py,sha256=HjWVFJy4UDA6VB-6tCkS3iWcFEzYTFa_363GIdwdNzA,5367
+anemone/node_evaluation/node_tree_evaluation/node_minmax_evaluation.py,sha256=aLQFTR_3uqpAF3QxLHdl9U4X4993_-BFOSAWVRoWzOY,34615
+anemone/node_evaluation/node_tree_evaluation/node_tree_evaluation.py,sha256=Ej8h5FNnarEHNbNA68wfu2abXWfRW2PLWDqMYaUN5mo,4282
+anemone/node_evaluation/node_tree_evaluation/node_tree_evaluation_factory.py,sha256=3BEXa080hgb4bE4r-130_ANM4LGl4vzwPJbEhsbpzw0,1328
+anemone/node_factory/__init__.py,sha256=4HMQ9MBID2odRrkR-t8BX89vTdmN2xybTL0mW5WnXUY,535
+anemone/node_factory/algorithm_node_factory.py,sha256=XDaWaTY552uJ90ECC2lqyWreSc0cc04DLuvXIhd8dSI,4098
+anemone/node_factory/base.py,sha256=jcj5Tagvgu6ZYllpvxxLhsApUROxEz3iMdaXbuasTfA,2106
+anemone/node_selector/__init__.py,sha256=fi_BlhEuBh29CWhTpBuSPa9PLrfoPyiCVXGXIyEn8uo,1306
+anemone/node_selector/branch_explorer.py,sha256=Oh0cOtys2s--nZsTDataR3IjZIN6SFs-Q0uu5eVrxxU,2556
+anemone/node_selector/factory.py,sha256=WHSTqsaOf-P3LWo-b97fr_uBUxdkdzqzC25eR8Hi5Nw,2111
+anemone/node_selector/node_selector.py,sha256=DJ1w6mRso-LKD8tRLESdlC4yYyf5T1-RcULfo2s4EBk,1096
+anemone/node_selector/node_selector_args.py,sha256=m4fFMswcHaNQyHSiV0OaoF2gQUWe4_7V5dmO4_nTqQE,531
+anemone/node_selector/node_selector_types.py,sha256=D7CSGcqWFQAyiQfTiunq2i6JxyiIbL_Y3Ru17ujP_CQ,305
+anemone/node_selector/notations_and_statics.py,sha256=XuzHQJmqsuuZnR9pDq8uUO_kyeioqfbJKDyVodhadVY,2592
+anemone/node_selector/opening_instructions.py,sha256=gtu1wO0s5FNu0vH9ZF7ItlZQujQLHy6ArJ1CyHGwTIg,7553
+anemone/node_selector/recurzipf/__init__.py,sha256=nGrweb6xLrknVOO3DqQzSiGxSLso9uPcOR12PLEJRPk,56
+anemone/node_selector/recurzipf/recur_zipf_base.py,sha256=8GNfiFdNZZrxNP7k2HlSyO_T2m1PhX953hVXoD9hiso,3795
+anemone/node_selector/sequool/__init__.py,sha256=3A-yFgnQookFcDHPaSBaJsF97Ia0jsT_g9yY8OEm1Xw,471
+anemone/node_selector/sequool/factory.py,sha256=wmNOf3uYJ0eerjFvx1jdyORtneCtzDuGW9oRHjD-KRo,3056
+anemone/node_selector/sequool/sequool.py,sha256=z3FsoJYs1URpRMOFoZGDCaGRg9inHcj32ZcmFEjbL_E,11350
+anemone/node_selector/uniform/__init__.py,sha256=Y28PZn5mvO7nm9aY9LRxPB-_UUmRnW-Yc8Yc97lBY7o,352
+anemone/node_selector/uniform/uniform.py,sha256=Rdvt0tmWfK8FTxE4ql7xLT2vgIWPnq5iu_QPlzWa_XY,3630
+anemone/nodes/__init__.py,sha256=QiMFfcRefUaP8OtRweuTqjSZ-43TPjIx-P790_v13RU,379
+anemone/nodes/itree_node.py,sha256=akniqYyUdBk63h0zIBrrGHBJ_HDf3jfuA9_18AliQvw,3442
+anemone/nodes/tree_node.py,sha256=O_C9dqWZ_8F-TGmXChtu5jnvmIFl213KyIKWqiGPIQw,7660
+anemone/nodes/tree_traversal.py,sha256=pqtEKdG-NUwrHPu0OnvWTsoBxFDSxKlwBdFTum5jJS8,3926
+anemone/nodes/utils.py,sha256=WHES9GaJuaF5gVP8knzG1iZGnOKEDKtDKwkv2KjItLo,4472
+anemone/nodes/algorithm_node/__init__.py,sha256=AYJ2KAm9xXL42inS6lkypQPHt9sYtWdBPmK9ShgCYYE,115
+anemone/nodes/algorithm_node/algorithm_node.py,sha256=HAqL9iL4Mo7J8N2cxX4ofsjdBRivWW_Ywi4lHB3Kq_A,6533
+anemone/progress_monitor/__init__.py,sha256=zwsFet62FUlbonLTtDOye2VmLFEl8XWAJQJ6NdKu0pY,64
+anemone/progress_monitor/progress_monitor.py,sha256=mFR24b4qtp8bV7ZWbCTb7U-6L4KQOcLKCgvMmfLeRWE,11105
+anemone/recommender_rule/__init__.py,sha256=ia_KPE4CsDgt8qEtKMLHS3vOZcv6aaAqHAbchjBNHEM,333
+anemone/recommender_rule/recommender_rule.py,sha256=pt3HUbH1V_pZC-sKo1Ged6vm_wvmVrea9s2YqipPv44,4374
+anemone/search_factory/__init__.py,sha256=wjaaLMJUlQfn2y6a74AApX01RgmYo50xF63x7z0AWfY,605
+anemone/search_factory/search_factory.py,sha256=jPdjQfhrwwT_EF3asACtAu_FLfCQ0NaX2ODGbuSHMzw,6512
+anemone/tree_manager/__init__.py,sha256=1kRsT7_UQ_YI8NEvpZqV13RETEfgw9mrzjKZcl4w_hY,948
+anemone/tree_manager/algorithm_node_tree_manager.py,sha256=GK6heOTHGNeGrVPq3EYaEOrMbN8FsTjmNay0BkpNJDM,8478
+anemone/tree_manager/factory.py,sha256=76o9DoOpK_rin1caKsHPk7PkmNwvLChWvPYlHdJvb6o,2666
+anemone/tree_manager/tree_expander.py,sha256=AzpwI4hVLNRpphirWX5fruSIiWL6bV-9yv-XPAzzdoY,4033
+anemone/tree_manager/tree_manager.py,sha256=16zlg4OjiLMua0wGIPoFCD4RqVQkAthNE7GtxGnYkGg,7926
+anemone/trees/__init__.py,sha256=3ujCsvrveUCBUWHtklD_jcUzVhYycBphZCaIcDJcXbE,268
+anemone/trees/descendants.py,sha256=CNRjwuPW3UA-B9fDG3XRQigzgYgwUIrhzYxPtO4kGeQ,25889
+anemone/trees/factory.py,sha256=ZXe22pLF0mq41eThFSVhOX6nOeBI2Cq9Y7bwPY9vAJM,2290
+anemone/trees/tree.py,sha256=HqoPjB9HcIrWYV0iv8eoBn6d2OGIlJ6GfcjdxjgEhSQ,1964
+anemone/trees/tree_visualization.py,sha256=IOBnwuykk4rKW0HyeyiohOs27mas7-P60_gnEGl9OBY,4634
+anemone/updates/__init__.py,sha256=0PzroMHow_viONeaUeEH_Oc0KS-bwHp9PYvm4ekdido,1099
+anemone/updates/algorithm_node_updater.py,sha256=96VcRxvMHRmuvZw8mdMz2QTcI4jnqGQmje_3I_mbSjE,5786
+anemone/updates/factory.py,sha256=MoAtf2o9BuljpHr-HcE6Up5NdEfSed5IQO1hyMF7ssc,1187
+anemone/updates/index_block.py,sha256=YvLQXsEHxe_sU2Am8LwxQSXbgjC598o7gCZ3MiId7KA,3003
+anemone/updates/index_updater.py,sha256=KmE3RazrfWOH_rSQ1VbSbYDgUzwFaeTRSI6AfAkYdw4,3531
+anemone/updates/minmax_evaluation_updater.py,sha256=dFqPhsXErk_R39Z2V6oGzE8oLiBsI2flq1dxU3XEIeI,3958
+anemone/updates/updates_file.py,sha256=NGDf1l3At4ufeoQ_wpURIPEvx9oS1dndEqvWwydlAak,10011
+anemone/updates/value_block.py,sha256=Z5J4BZzkUCMaqAfcA061bxO00iwGKMqH5UOYDNVG5zI,4598
+anemone/utils/comparable.py,sha256=-A7uqdIHHfokivT-rWVOGueKBMGxetscUR2QkLzuop0,898
+anemone/utils/dataclass.py,sha256=KtOViWQF33DfJkhIq0WX_TFNTfDjsMQZdEyX4pZrKw4,1758
+anemone/utils/dict_of_numbered_dict_with_pointer_on_max.py,sha256=f-VcVP_UpzW8TayJydnXWHpw30UC04MLbjeEvEO-z9Y,3877
+anemone/utils/logger.py,sha256=DqV0C8l9PxA6a72RG4HX0G_YaSjSlidwdnJLdyIvxGI,3009
+anemone/utils/my_value_sorted_dict.py,sha256=DiL0Ds_TkE88jZB_NJ8fE98Ksaskf3qIyocc5TyoD3M,586
+anemone/utils/small_tools.py,sha256=KtFzO9GYZch-pLdO83IFFXA-s3HpjU38lA832u3JTQU,2800
+algorhino_anemone-0.1.11.dist-info/METADATA,sha256=DmG7BfcmgreqQ-5E5os6DztCaR_C5whOZIbFiLXG2F0,5693
+algorhino_anemone-0.1.11.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+algorhino_anemone-0.1.11.dist-info/top_level.txt,sha256=G1vbB-vAevQVde3UZ5X1_Ysy1_6sJDEueHRi2qcDgrY,8
+algorhino_anemone-0.1.11.dist-info/RECORD,,

{algorhino_anemone-0.1.9.dist-info → algorhino_anemone-0.1.11.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.10.1)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

anemone/__init__.py

@@ -1,5 +1,4 @@
-"""
-This module provides functionality for creating tree and value builders for the TreeAndValuePlayer.
+"""Provide functionality for creating tree and value builders for the TreeAndValuePlayer.
 
 The TreeAndValuePlayerArgs class represents the arguments for configuring the TreeAndValuePlayer.
 The create_tree_and_value_builders function is used to create the tree and value builders.

anemone/factory.py

@@ -1,17 +1,10 @@
-"""
-Module for creating Tree and Value Branch Selector objects.
-"""
+"""Module for creating Tree and Value Branch Selector objects."""
 
 from dataclasses import dataclass
-from queue import Queue
 from random import Random
-from typing import Literal, Type
+from typing import Literal
 
-from valanga import (
-    RepresentationFactory,
-    StateModifications,
-    TurnState,
-)
+from valanga import RepresentationFactory, StateModifications, TurnState
 from valanga.evaluator_types import EvaluatorInput
 
 from anemone import node_factory
@@ -30,7 +23,6 @@ from anemone.nodes.algorithm_node.algorithm_node import AlgorithmNode
 from anemone.progress_monitor.progress_monitor import (
     AllStoppingCriterionArgs,
 )
-from anemone.utils.dataclass import IsDataclass
 
 from . import node_selector as node_selector_m
 from . import recommender_rule
@@ -44,9 +36,7 @@ TREE_AND_VALUE_LITERAL_STRING: Literal["TreeAndValue"] = "TreeAndValue"
 
 @dataclass
 class TreeAndValuePlayerArgs:
-    """
-    Dataclass for Tree and Value Player Arguments.
-    """
+    """Dataclass for Tree and Value Player Arguments."""
 
     node_selector: node_selector_m.AllNodeSelectorArgs
     opening_type: node_selector_m.OpeningType
@@ -57,23 +47,21 @@ class TreeAndValuePlayerArgs:
 
 
 def create_tree_and_value_branch_selector[StateT: TurnState](
-    state_type: Type[StateT],
+    state_type: type[StateT],
     args: TreeAndValuePlayerArgs,
     random_generator: Random,
     master_state_evaluator: MasterStateEvaluator,
     state_representation_factory: RepresentationFactory[
-        StateT, StateModifications, EvaluatorInput
+        StateT, EvaluatorInput, StateModifications
     ]
     | None,
-    queue_progress_player: Queue[IsDataclass] | None,
 ) -> TreeAndValueBranchSelector[StateT]:
-    """Convenience constructor using the default minmax tree evaluation.
+    """Create a branch selector using the default minmax tree evaluation.
 
     This keeps the existing API stable, while allowing advanced users to inject a
     different tree-evaluation strategy via
     `create_tree_and_value_branch_selector_with_tree_eval_factory`.
     """
-
     node_tree_evaluation_factory: NodeTreeEvaluationFactory[StateT]
     node_tree_evaluation_factory = NodeTreeMinmaxEvaluationFactory[StateT]()
 
@@ -84,35 +72,34 @@ def create_tree_and_value_branch_selector[StateT: TurnState](
         master_state_evaluator=master_state_evaluator,
         state_representation_factory=state_representation_factory,
         node_tree_evaluation_factory=node_tree_evaluation_factory,
-        queue_progress_player=queue_progress_player,
     )
 
 
 def create_tree_and_value_branch_selector_with_tree_eval_factory[StateT: TurnState](
-    state_type: Type[StateT],
+    state_type: type[StateT],
     args: TreeAndValuePlayerArgs,
     random_generator: Random,
     master_state_evaluator: MasterStateEvaluator,
     state_representation_factory: RepresentationFactory[
-        StateT, StateModifications, EvaluatorInput
+        StateT, EvaluatorInput, StateModifications
     ]
     | None,
     node_tree_evaluation_factory: NodeTreeEvaluationFactory[StateT],
-    queue_progress_player: Queue[IsDataclass] | None,
 ) -> TreeAndValueBranchSelector[StateT]:
-    """
-    Create a TreeAndValueBranchSelector object with the given arguments.
+    """Create a TreeAndValueBranchSelector object with the given arguments.
 
     Args:
-        args (TreeAndValuePlayerArgs): The arguments for creating the TreeAndValueBranchSelector.
-        syzygy (SyzygyTable | None): The SyzygyTable object for tablebase endgame evaluation.
-        random_generator (random.Random): The random number generator.
+        state_type (type[StateT]): The state type for the search.
+        args (TreeAndValuePlayerArgs): Arguments for creating the selector.
+        random_generator (Random): The random number generator.
+        master_state_evaluator (MasterStateEvaluator): Evaluator for state values.
+        state_representation_factory (RepresentationFactory | None): Optional state representation factory.
+        node_tree_evaluation_factory (NodeTreeEvaluationFactory[StateT]): Factory for node tree evaluations.
 
     Returns:
         TreeAndValueBranchSelector: The created TreeAndValueBranchSelector object.
 
     """
-
     _ = state_type  # not used here
 
     node_evaluator: NodeDirectEvaluator[StateT] = create_node_evaluator(
@@ -159,7 +146,6 @@ def create_tree_and_value_branch_selector_with_tree_eval_factory[StateT: TurnSta
             node_selector_create=search_factory.create_node_selector_factory(),
             stopping_criterion_args=args.stopping_criterion,
             recommend_branch_after_exploration=args.recommender_rule,
-            queue_progress_player=queue_progress_player,
         )
     )
     return tree_branch_selector

anemone/indices/__init__.py

@@ -0,0 +1 @@
+"""Index utilities for node exploration and index management."""

anemone/indices/index_manager/__init__.py

@@ -1,5 +1,4 @@
-"""
-This module provides functionality for managing exploration index managers.
+"""Provide functionality for managing exploration index managers.
 
 The module includes the following functions and classes:
 - create_exploration_index_manager: A function to create an exploration index manager.
@@ -9,4 +8,4 @@ The module includes the following functions and classes:
 from .factory import create_exploration_index_manager
 from .node_exploration_manager import NodeExplorationIndexManager
 
-__all__ = ["create_exploration_index_manager", "NodeExplorationIndexManager"]
+__all__ = ["NodeExplorationIndexManager", "create_exploration_index_manager"]

anemone/indices/index_manager/factory.py

@@ -1,6 +1,4 @@
-"""
-This module contains the factory function to create a node exploration index manager based on the given index computation
-"""
+"""Provide a factory for node exploration index managers."""
 
 from anemone.indices.index_manager.node_exploration_manager import (
     NodeExplorationIndexManager,
@@ -14,11 +12,20 @@ from anemone.indices.node_indices.index_types import (
 )
 
 
+class UnknownIndexComputationError(ValueError):
+    """Raised when an index computation type is not recognized."""
+
+    def __init__(self, index_computation: IndexComputationType) -> None:
+        """Initialize the error with the unsupported computation type."""
+        super().__init__(
+            f"player creator: can not find {index_computation} in {__name__}"
+        )
+
+
 def create_exploration_index_manager(
     index_computation: IndexComputationType | None = None,
 ) -> NodeExplorationIndexManager:
-    """
-    Creates a node exploration index manager based on the given index computation type.
+    """Create a node exploration index manager for the given index computation type.
 
     Args:
         index_computation (IndexComputationType | None): The type of index computation to be used.
@@ -43,8 +50,6 @@ def create_exploration_index_manager(
             case IndexComputationType.MIN_LOCAL_CHANGE:
                 node_exploration_manager = UpdateIndexLocalMinChange()
             case _:
-                raise ValueError(
-                    f"player creator: can not find {index_computation} in {__name__}"
-                )
+                raise UnknownIndexComputationError(index_computation)
 
     return node_exploration_manager

anemone/indices/index_manager/node_exploration_manager.py

@@ -31,13 +31,13 @@ class _StateWithTurn(State, Protocol):
 
 
 class NodeExplorationIndexManager(Protocol):
-    """
-    A protocol for managing the exploration indices of nodes in a tree.
+    """A protocol for managing the exploration indices of nodes in a tree.
 
     This protocol defines methods for updating the exploration indices of nodes in a tree.
 
     Args:
         Protocol (type): The base protocol type.
+
     """
 
     needs_parent_state: bool
@@ -47,11 +47,12 @@ class NodeExplorationIndexManager(Protocol):
         root_node: NodeT,
         root_node_exploration_index_data: NodeExplorationData[NodeT, Any] | None,
     ) -> None:
-        """
-        Updates the exploration index of the root node in the tree.
+        """Update the exploration index of the root node in the tree.
 
         Args:
             root_node (AlgorithmNode): The root node of the tree.
+            root_node_exploration_index_data (NodeExplorationData | None): Exploration index data for the root node.
+
         """
         ...
 
@@ -65,21 +66,23 @@ class NodeExplorationIndexManager(Protocol):
         tree: Tree[NodeT],
         child_rank: int,
     ) -> None:
-        """
-        Updates the exploration index of a child node in the tree.
+        """Update the exploration index of a child node in the tree.
 
         Args:
             child_node (AlgorithmNode): The child node to update.
             parent_node (AlgorithmNode): The parent node of the child node.
+            parent_node_exploration_index_data (NodeExplorationData | None): Exploration index data for the parent.
+            child_node_exploration_index_data (NodeExplorationData | None): Exploration index data for the child.
+            parent_node_state (_StateWithTurn | None): Parent node state with turn information, if needed.
             tree (Tree): The tree containing the nodes.
             child_rank (int): The rank of the child node among its siblings.
+
         """
         ...
 
 
 class NullNodeExplorationIndexManager(NodeExplorationIndexManager):
-    """
-    A class representing a null node exploration index manager.
+    """A class representing a null node exploration index manager.
 
     This class is used when there is no need to update the exploration index of nodes in a tree.
     It inherits from the NodeExplorationIndexManager class.
@@ -92,13 +95,13 @@ class NullNodeExplorationIndexManager(NodeExplorationIndexManager):
         root_node: NodeT,
         root_node_exploration_index_data: NodeExplorationData[NodeT, Any] | None,
     ) -> None:
-        """
-        Updates the exploration index of the root node in the tree.
+        """Update the exploration index of the root node in the tree.
 
         Args:
             root_node (AlgorithmNode): The root node of the tree.
+            root_node_exploration_index_data (NodeExplorationData | None): Exploration index data for the root node.
+
         """
-        ...
 
     def update_node_indices[NodeT: AlgorithmNode[Any]](
         self,
@@ -110,22 +113,23 @@ class NullNodeExplorationIndexManager(NodeExplorationIndexManager):
         tree: Tree[NodeT],
         child_rank: int,
     ) -> None:
-        """
-        Updates the exploration index of a child node in the tree.
+        """Update the exploration index of a child node in the tree.
 
         Args:
             child_node (AlgorithmNode): The child node to update.
             parent_node (AlgorithmNode): The parent node of the child node.
+            parent_node_exploration_index_data (NodeExplorationData | None): Exploration index data for the parent.
+            child_node_exploration_index_data (NodeExplorationData | None): Exploration index data for the child.
+            parent_node_state (_StateWithTurn | None): Parent node state with turn information, if needed.
             tree (Tree): The tree containing the nodes.
             child_rank (int): The rank of the child node among its siblings.
+
         """
         raise NotImplementedError("should not be raised")
 
 
 class UpdateIndexGlobalMinChange:
-    """
-    A class that updates the exploration index of nodes in a tree using the global minimum change strategy.
-    """
+    """A class that updates the exploration index of nodes in a tree using the global minimum change strategy."""
 
     needs_parent_state = False
 
@@ -134,11 +138,12 @@ class UpdateIndexGlobalMinChange:
         root_node: NodeT,
         root_node_exploration_index_data: NodeExplorationData[NodeT, Any] | None,
     ) -> None:
-        """
-        Updates the exploration index of the root node in the tree using the global minimum change strategy.
+        """Update the exploration index of the root node using the global minimum change strategy.
 
         Args:
             root_node (AlgorithmNode): The root node of the tree.
+            root_node_exploration_index_data (NodeExplorationData | None): Exploration index data for the root node.
+
         """
         root_value: float = root_node.tree_evaluation.get_value_white()
 
@@ -158,16 +163,18 @@ class UpdateIndexGlobalMinChange:
         tree: Tree[NodeT],
         child_rank: int,
     ) -> None:
-        """
-        Updates the exploration index of a child node in the tree using the global minimum change strategy.
+        """Update the exploration index of a child node using the global minimum change strategy.
 
         Args:
             child_node (AlgorithmNode): The child node to update.
             parent_node (AlgorithmNode): The parent node of the child node.
+            parent_node_exploration_index_data (NodeExplorationData | None): Exploration index data for the parent.
+            child_node_exploration_index_data (NodeExplorationData | None): Exploration index data for the child.
+            parent_node_state (_StateWithTurn | None): Parent node state with turn information, if needed.
             tree (Tree): The tree containing the nodes.
             child_rank (int): The rank of the child node among its siblings.
-        """
 
+        """
         _ = child_rank
         _ = parent_node
         _ = tree
@@ -193,10 +200,6 @@ class UpdateIndexGlobalMinChange:
             abs(child_node_max_path_value - child_node_min_path_value) / 2
         )
 
-        # the amount of change for the child to become better than any of its ancestor
-        # and become the overall best bode, the max is computed with the parent index
-        # child_index: float = max(local_child_index, parent_index)
-
         # the index of the child node is updated now
         # as a child node can have multiple parents we take the min if an index was previously computed
         if child_node_exploration_index_data.index is None:
@@ -220,9 +223,7 @@ class UpdateIndexGlobalMinChange:
 
 
 class UpdateIndexZipfFactoredProba:
-    """
-    A class that updates the exploration index of nodes in a tree using the Zipf factored probability strategy.
-    """
+    """A class that updates the exploration index of nodes in a tree using the Zipf factored probability strategy."""
 
     needs_parent_state = False
 
@@ -231,13 +232,13 @@ class UpdateIndexZipfFactoredProba:
         root_node: NodeT,
         root_node_exploration_index_data: NodeExplorationData[NodeT, Any] | None,
     ) -> None:
-        """
-        Updates the exploration index of the root node in the tree using the Zipf factored probability strategy.
+        """Update the exploration index of the root node using the Zipf factored probability strategy.
 
         Args:
             root_node (AlgorithmNode): The root node of the tree.
-        """
+            root_node_exploration_index_data (NodeExplorationData | None): Exploration index data for the root node.
 
+        """
         _ = root_node
         assert isinstance(
             root_node_exploration_index_data, RecurZipfQuoolExplorationData
@@ -255,14 +256,17 @@ class UpdateIndexZipfFactoredProba:
         tree: Tree[NodeT],
         child_rank: int,
     ) -> None:
-        """
-        Updates the exploration index of a child node in the tree using the Zipf factored probability strategy.
+        """Update the exploration index of a child node using the Zipf factored probability strategy.
 
         Args:
             child_node (AlgorithmNode): The child node to update.
             parent_node (AlgorithmNode): The parent node of the child node.
+            parent_node_exploration_index_data (NodeExplorationData | None): Exploration index data for the parent.
+            child_node_exploration_index_data (NodeExplorationData | None): Exploration index data for the child.
+            parent_node_state (_StateWithTurn | None): Parent node state with turn information, if needed.
             tree (Tree): The tree containing the nodes.
             child_rank (int): The rank of the child node among its siblings.
+
         """
         _ = parent_node
 
@@ -306,9 +310,7 @@ class UpdateIndexZipfFactoredProba:
 
 
 class UpdateIndexLocalMinChange:
-    """
-    A class that updates the exploration index of nodes in a tree using the local minimum change strategy.
-    """
+    """A class that updates the exploration index of nodes in a tree using the local minimum change strategy."""
 
     needs_parent_state = True
 
@@ -317,11 +319,12 @@ class UpdateIndexLocalMinChange:
         root_node: NodeT,
         root_node_exploration_index_data: NodeExplorationData[NodeT, Any] | None,
     ) -> None:
-        """
-        Updates the exploration index of the root node in the tree using the local minimum change strategy.
+        """Update the exploration index of the root node using the local minimum change strategy.
 
         Args:
             root_node (AlgorithmNode): The root node of the tree.
+            root_node_exploration_index_data (NodeExplorationData | None): Exploration index data for the root node.
+
         """
         _ = root_node
         assert isinstance(root_node_exploration_index_data, IntervalExplo)
@@ -341,16 +344,18 @@ class UpdateIndexLocalMinChange:
         tree: Tree[NodeT],
         child_rank: int,
     ) -> None:
-        """
-        Updates the exploration index of a child node in the tree using the local minimum change strategy.
+        """Update the exploration index of a child node using the local minimum change strategy.
 
         Args:
             child_node (AlgorithmNode): The child node to update.
             parent_node (AlgorithmNode): The parent node of the child node.
+            parent_node_exploration_index_data (NodeExplorationData | None): Exploration index data for the parent.
+            child_node_exploration_index_data (NodeExplorationData | None): Exploration index data for the child.
+            parent_node_state (_StateWithTurn | None): Parent node state with turn information, if needed.
             tree (Tree): The tree containing the nodes.
             child_rank (int): The rank of the child node among its siblings.
-        """
 
+        """
         _ = tree
         _ = child_rank
 
@@ -405,7 +410,6 @@ class UpdateIndexLocalMinChange:
                             value=child_white_value, interval=inter_level_interval
                         )
                     else:
-                        ...
                         local_index = None
                 if parent_node_state.turn == Color.BLACK:
                     best_branch_black: BranchKey | None = (
@@ -459,22 +463,23 @@ class UpdateIndexLocalMinChange:
                 )
 
 
-# TODO their might be ways to optimize the computation such as not recomptuing for the whole tree
+# TODO: their might be ways to optimize the computation such as not recomptuing for the whole tree
 def update_all_indices[NodeT: AlgorithmNode[Any]](
     tree: Tree[NodeT], index_manager: NodeExplorationIndexManager
 ) -> None:
-    """
-    The idea is to compute an index $ind(n)$ for a node $n$ that measures the minimum amount of change
-     in the value of all the nodes such that this node $n$ becomes the best.
+    """Compute exploration indices for nodes in the tree.
 
-    This can be computed recursively as :
-    ind(n) = max( ind(parent(n),.5*abs(value(n)-value(parent(n))))
+    This computes an index $ind(n)$ for a node $n$ that measures the minimum amount
+    of change in the value of all the nodes such that this node $n$ becomes the best.
+    It can be computed recursively as:
+    ind(n) = max(ind(parent(n), 0.5 * abs(value(n) - value(parent(n)))))
 
     Args:
-        index_manager:
-        tree: a tree
+        tree: The tree to update.
+        index_manager: The index manager that defines the update logic.
 
     Returns:
+        None
 
     """
     if isinstance(index_manager, NullNodeExplorationIndexManager):
@@ -489,7 +494,7 @@ def update_all_indices[NodeT: AlgorithmNode[Any]](
 
     tree_depth: TreeDepth
     for tree_depth in tree_nodes:
-        # todo how are we sure that the hm comes in order?
+        # TODO: how are we sure that the hm comes in order?
         parent_node: NodeT
         for parent_node in tree_nodes[tree_depth].values():
             branch_rank: int
@@ -518,26 +523,26 @@ def update_all_indices[NodeT: AlgorithmNode[Any]](
                 )
 
 
-# TODO their might be ways to optimize the computation such as not recomptuing for the whole tree
+# TODO: their might be ways to optimize the computation such as not recomptuing for the whole tree
 
 
 def print_all_indices[NodeT: AlgorithmNode[Any]](
     tree: Tree[NodeT],
 ) -> None:
-    """
-    Prints the exploration indices of all nodes in the given tree.
+    """Print the exploration indices of all nodes in the given tree.
 
     Args:
         tree (Tree): The tree containing the nodes.
 
     Returns:
         None
+
     """
     tree_nodes: RangedDescendants[NodeT] = tree.descendants
 
     tree_depth: TreeDepth
     for tree_depth in tree_nodes:
-        # todo how are we sure that the hm comes in order?
+        # TODO: how are we sure that the hm comes in order?
         for parent_node in tree_nodes[tree_depth].values():
             assert isinstance(parent_node, AlgorithmNode)
             if parent_node.exploration_index_data is not None:

anemone/indices/node_indices/__init__.py

@@ -1,5 +1,4 @@
-"""
-This module provides functionality for managing node indices in the tree value package.
+"""Provide functionality for managing node indices in the tree value package.
 
 The following classes and functions are available:
 
@@ -15,8 +14,8 @@ from .index_data import NodeExplorationData
 from .index_types import IndexComputationType
 
 __all__ = [
-    "NodeExplorationData",
     "ExplorationIndexDataFactory",
     "IndexComputationType",
+    "NodeExplorationData",
     "create_exploration_index_data",
 ]