Added possibility to call game based on given player_names

Author: Advueu963

shapiq/games/base.py

@@ -195,7 +195,11 @@ def _check_coalitions(
             if tuple_types[0] not in [set(), {int}, {str}]:
                 raise TypeError("Tuples must contain either integers or strings.")
 
-            # convert strings in tuples to integers
+            # check that string tuples are only used if player names are provided
+            if self.player_name_lookup is None and tuple_types[0] == {str}:
+                raise TypeError("Player names have to be provided to evaluate string tuples.")
+
+            # convert strings to integers
             if tuple_types[0] == {str}:
                 coalitions = [
                     tuple([self.player_name_lookup[name] for name in coal]) for coal in coalitions
@@ -211,9 +215,16 @@ def _check_coalitions(
                 raise TypeError("Elements of tuple must have the same type.")
             if tuple_types not in [set(), {int}, {str}]:
                 raise TypeError("Tuple must contain either integers or strings.")
+
+            # check that string tuples are only used if player names are provided
+            if self.player_name_lookup is None and tuple_types == {str}:
+                raise TypeError("Player names have to be provided to evaluate string tuples.")
+
+            # convert strings to integers
             if tuple_types == {str}:
                 coalitions = tuple([self.player_name_lookup[name] for name in coalitions])
 
+            # convert tuple to one-hot encoding
             coalitions = transform_coalitions_to_array([coalitions], self.n_players)
             return coalitions
         elif isinstance(coalitions, np.ndarray):
@@ -232,6 +243,18 @@ def _check_coalitions(
                     f"the number of players in the game ({self.n_players})."
                 )
             return coalitions
+        elif isinstance(coalitions, str):
+            if coalitions == "empty":
+                return self.empty_coalition.reshape((1, self.n_players))
+            elif coalitions == "grand":
+                return self.grand_coalition.reshape((1, self.n_players))
+            else:
+                if self.player_name_lookup is None:
+                    raise TypeError("Player names have to be provided to evaluate strings.")
+
+                tuple_coal = tuple([self.player_name_lookup[coalitions]])
+                return transform_coalitions_to_array([tuple_coal], self.n_players)
+
         else:
             raise TypeError("Coalitions have to be numpy arrays or lists of tuples or tuple.")
 

tests/tests_games/test_base_game.py

@@ -68,8 +68,6 @@ def value_function(self, coalition):
     # test wrong datatype in coalition call
     with pytest.raises(TypeError):
         assert test_game({0, 1, 2}) == 0.0
-
-    # test wrong datatype in coalition call
     with pytest.raises(TypeError):
         assert test_game([(None)]) == 0.0
 
@@ -78,6 +76,7 @@ def value_function(self, coalition):
     assert test_game(test_coalition) == 0.0
     assert test_game(()) == 0.0
     assert test_game([()]) == 0.0
+    assert test_game("empty") == 0.0
 
     # test with grand coalition all call variants
     test_coalition = test_game.grand_coalition
@@ -86,6 +85,7 @@ def value_function(self, coalition):
     assert test_game([tuple(range(0, test_game.n_players))]) == 1.0
     assert test_game(tuple(test_game.player_name_lookup.values())) == 1.0
     assert test_game([tuple(test_game.player_name_lookup.values())]) == 1.0
+    assert test_game("grand") == 1.0
 
     # test with single player coalition all call variants
     test_coalition = np.array([True] + [False for _ in range(test_game.n_players - 1)])
@@ -94,6 +94,18 @@ def value_function(self, coalition):
     assert test_game([tuple([0])]) - 1 / 6 < 10e-7
     assert test_game(tuple(("Alice",))) - 1 / 6 < 10e-7
     assert test_game([tuple(("Alice",))]) - 1 / 6 < 10e-7
+    assert test_game("Alice") - 1 / 6 < 10e-7
+
+    # test string calls with missing player names
+    test_game2 = TestGame(n=n_players)
+    assert test_game2("grand") == 1.0
+    assert test_game2("empty") == 0.0
+    with pytest.raises(TypeError):
+        assert test_game2("Alice") == 0.0
+    with pytest.raises(TypeError):
+        assert test_game2(("Bob",)) == 0.0
+    with pytest.raises(TypeError):
+        assert test_game2([("Charlie",)]) == 0.0
 
 
 def test_precompute():