revert node traversal order back to the correct one

Author: d-kad

src/pygambit/game.pxi

@@ -186,9 +186,9 @@ class GameNodes:
 
     def __iter__(self) -> typing.Iterator[Node]:
         def dfs(node):
+            yield node
             for child in node.children:
                 yield from dfs(child)
-            yield node
         if not self.game.deref().IsTree():
             return
         yield from dfs(Node.wrap(self.game.deref().GetRoot()))
@@ -703,7 +703,14 @@ class Game:
 
     @property
     def nodes(self) -> GameNodes:
-        """The set of nodes in the game."""
+        """The set of nodes in the game.
+
+        Iteration over this property yields the nodes in the order of depth-first search.
+
+        .. versionchanged:: 16.4
+        Changed from a method ``nodes()`` to a property. Access as
+        ``game.nodes`` instead of ``game.nodes()``.
+        """
         return GameNodes.wrap(self.game)
 
     @property

tests/test_behav.py

@@ -641,7 +641,7 @@ def test_realiz_prob_nodes_reference(game: gbt.Game, node_idx: int,
                                      realiz_prob: typing.Union[str, float], rational_flag: bool):
     profile = game.mixed_behavior_profile(rational=rational_flag)
     realiz_prob = (gbt.Rational(realiz_prob) if rational_flag else realiz_prob)
-    node = game.nodes()[node_idx]
+    node = list(game.nodes)[node_idx]
     assert profile.realiz_prob(node) == realiz_prob
 
 
@@ -890,7 +890,7 @@ def test_martingale_property_of_node_value(game: gbt.Game, rational_flag: bool):
     realization probabilities of those children
     """
     profile = game.mixed_behavior_profile(rational=rational_flag)
-    for node in game.nodes():
+    for node in game.nodes:
         if node.is_terminal or node.player.is_chance:
             continue
         expected_val = 0
@@ -1080,23 +1080,23 @@ def _get_and_check_answers(game: gbt.Game, action_probs1: tuple, action_probs2:
      ######################################################################################
      # belief (at nodes)
      (games.create_mixed_behav_game_efg(), PROBS_1A_doub, PROBS_2A_doub, False,
-      lambda x, y: x.belief(y), lambda x: x.nodes()),
+      lambda x, y: x.belief(y), lambda x: x.nodes),
      (games.create_mixed_behav_game_efg(), PROBS_1A_rat, PROBS_2A_rat, True,
-      lambda x, y: x.belief(y), lambda x: x.nodes()),
+      lambda x, y: x.belief(y), lambda x: x.nodes),
      (games.create_myerson_2_card_poker_efg(), PROBS_1B_doub, PROBS_2B_doub, False,
-      lambda x, y: x.belief(y), lambda x: x.nodes()),
+      lambda x, y: x.belief(y), lambda x: x.nodes),
      (games.create_myerson_2_card_poker_efg(), PROBS_1A_rat, PROBS_2A_rat, True,
-      lambda x, y: x.belief(y), lambda x: x.nodes()),
+      lambda x, y: x.belief(y), lambda x: x.nodes),
      ######################################################################################
      # realiz_prob (at nodes)
      (games.create_mixed_behav_game_efg(), PROBS_1A_doub, PROBS_2A_doub, False,
-      lambda x, y: x.realiz_prob(y), lambda x: x.nodes()),
+      lambda x, y: x.realiz_prob(y), lambda x: x.nodes),
      (games.create_mixed_behav_game_efg(), PROBS_1A_rat, PROBS_2A_rat, True,
-      lambda x, y: x.realiz_prob(y), lambda x: x.nodes()),
+      lambda x, y: x.realiz_prob(y), lambda x: x.nodes),
      (games.create_myerson_2_card_poker_efg(), PROBS_1B_doub, PROBS_2B_doub, False,
-      lambda x, y: x.realiz_prob(y), lambda x: x.nodes()),
+      lambda x, y: x.realiz_prob(y), lambda x: x.nodes),
      (games.create_myerson_2_card_poker_efg(), PROBS_1A_rat, PROBS_2A_rat, True,
-      lambda x, y: x.realiz_prob(y), lambda x: x.nodes()),
+      lambda x, y: x.realiz_prob(y), lambda x: x.nodes),
      ######################################################################################
      # infoset_prob
      (games.create_mixed_behav_game_efg(), PROBS_1A_doub, PROBS_2A_doub, False,
@@ -1141,16 +1141,16 @@ def _get_and_check_answers(game: gbt.Game, action_probs1: tuple, action_probs2:
      # node_value
      (games.create_mixed_behav_game_efg(), PROBS_1A_doub, PROBS_2A_doub, False,
       lambda x, y: x.node_value(player=y[0], node=y[1]),
-      lambda x: list(product(x.players, x.nodes()))),
+      lambda x: list(product(x.players, x.nodes))),
      (games.create_mixed_behav_game_efg(), PROBS_1A_rat, PROBS_2A_rat, True,
       lambda x, y: x.node_value(player=y[0], node=y[1]),
-      lambda x: list(product(x.players, x.nodes()))),
+      lambda x: list(product(x.players, x.nodes))),
      (games.create_myerson_2_card_poker_efg(), PROBS_1B_doub, PROBS_2B_doub, False,
       lambda x, y: x.node_value(player=y[0], node=y[1]),
-      lambda x: list(product(x.players, x.nodes()))),
+      lambda x: list(product(x.players, x.nodes))),
      (games.create_myerson_2_card_poker_efg(), PROBS_1A_rat, PROBS_2A_rat, True,
       lambda x, y: x.node_value(player=y[0], node=y[1]),
-      lambda x: list(product(x.players, x.nodes()))),
+      lambda x: list(product(x.players, x.nodes))),
      ######################################################################################
      # liap_value (of profile, hence [1] for objects_to_test, any singleton collection would do)
      (games.create_mixed_behav_game_efg(), PROBS_1A_doub, PROBS_2A_doub, False,

tests/test_extensive.py

@@ -55,11 +55,6 @@ def test_game_add_players_nolabel():
     game.add_player()
 
 
-def test_game_num_nodes():
-    game = games.read_from_file("basic_extensive_game.efg")
-    assert len(game.nodes) == 15
-
-
 def test_game_is_perfect_recall():
     game = games.read_from_file("perfect_recall.efg")
     assert game.is_perfect_recall

tests/test_node.py

@@ -202,7 +202,7 @@ def test_copy_tree_onto_nondescendent_terminal_node():
     g = games.read_from_file("e01.efg")
     list_nodes = list(g.nodes)
     src_node = list_nodes[3]   # path=[1, 0]
-    dest_node = list_nodes[0]  # path=[0, 0]
+    dest_node = list_nodes[2]  # path=[0, 0]
 
     g.copy_tree(src_node, dest_node)
 
@@ -213,8 +213,8 @@ def test_copy_tree_onto_descendent_terminal_node():
     """Test copying a subtree to a node that's a descendent of the original."""
     g = games.read_from_file("e01.efg")
     list_nodes = list(g.nodes)
-    src_node = list_nodes[4]   # path=[0]
-    dest_node = list_nodes[1]  # path=[0, 1, 0]
+    src_node = list_nodes[1]   # path=[0]
+    dest_node = list_nodes[4]  # path=[0, 1, 0]
 
     g.copy_tree(src_node, dest_node)
 
@@ -478,7 +478,7 @@ def test_len_after_append_move():
     initial_number_of_nodes = len(game.nodes)
     list_nodes = list(game.nodes)
 
-    terminal_node = list_nodes[1]
+    terminal_node = list_nodes[5]         # path=[1, 1, 0]
     player = game.players[0]
     actions_to_add = ["T", "M", "B"]
 
@@ -494,10 +494,10 @@ def test_len_after_append_infoset():
     initial_number_of_nodes = len(game.nodes)
     list_nodes = list(game.nodes)
 
-    member_node = list_nodes[5]           # path=[1]
+    member_node = list_nodes[2]           # path=[1]
     infoset_to_modify = member_node.infoset
     number_of_infoset_actions = len(infoset_to_modify.actions)
-    terminal_node_to_add = list_nodes[3]  # path=[1, 1, 1]
+    terminal_node_to_add = list_nodes[6]  # path=[1, 1, 1]
 
     game.append_infoset(terminal_node_to_add, infoset_to_modify)
 
@@ -564,9 +564,9 @@ def test_len_after_insert_infoset():
     initial_number_of_nodes = len(game.nodes)
     list_nodes = list(game.nodes)
 
-    member_node = list_nodes[4]           # path=[1, 1]
+    member_node = list_nodes[6]           # path=[1]
     infoset_to_modify = member_node.infoset
-    node_to_insert_above = list_nodes[1]  # path=[0, 1]
+    node_to_insert_above = list_nodes[7]  # path=[0, 1]
     number_of_infoset_actions = len(infoset_to_modify.actions)
 
     game.insert_infoset(node_to_insert_above, infoset_to_modify)
@@ -581,7 +581,7 @@ def test_len_after_copy_tree():
     initial_number_of_nodes = len(game.nodes)
     list_nodes = list(game.nodes)
     src_node = list_nodes[3]   # path=[1, 0]
-    dest_node = list_nodes[0]  # path=[0, 0]
+    dest_node = list_nodes[2]  # path=[0, 0]
     number_of_src_ancestors = _count_subtree_nodes(src_node)
 
     game.copy_tree(src_node, dest_node)