Removed deprecated behaviour from shapiq. (#496)

mmschlk · web-flow · commit c45923cdbae6 · 2026-03-11T18:11:21.000+01:00
* Removed deprecated behaviour from shapiq:
 - removed `path_to_values` from `Game`
 - made json the only viable file format for `InteractionValues`

* updated CHANGELOG.md
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -1,5 +1,11 @@
 # Changelog
 
+## v1.5.0 (unreleased)
+
+### Removed Deprecated Features
+- removes `path_to_values` parameter from `shapiq.Game`, which was previously deprecated. Use `shapiq.Game.load()` instead.
+- removes pickle support from `shapiq.InteractionValues`. JSON is now the only supported file format. Use `InteractionValues.save()` and `InteractionValues.load()` with JSON files.
+
 ## v1.4.1 (2025-11-10)
 
 ### Bugfix
diff --git a/src/shapiq/game.py b/src/shapiq/game.py
@@ -3,7 +3,6 @@
 from __future__ import annotations
 
 import json
-import os
 import warnings
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, TypedDict, cast
@@ -13,7 +12,6 @@
 
 from shapiq.utils import (
     powerset,
-    raise_deprecation_warning,
     transform_array_to_coalitions,
     transform_coalitions_to_array,
 )
@@ -99,10 +97,6 @@ class Game:
         >>> new_game.load_values("dummy_game.npz")
         >>> game.precomputed, game.n_values_stored
         True, 2
-        >>> # you can also load a game of any class with the Game class
-        >>> new_game = Game(path_to_values="dummy_game.npz")
-        >>> new_game.precomputed, new_game.n_values_stored
-        True, 2
         >>> # save and load the game
         >>> game.save("game.pkl")
         >>> new_game = DummyGame.load("game.pkl")
@@ -130,7 +124,6 @@ def __init__(
         *,
         normalize: bool = True,
         normalization_value: float | None = None,
-        path_to_values: Path | str | None = None,
         verbose: bool = False,
         player_names: list[str] | None = None,
         **kwargs: Any,  # noqa: ARG002
@@ -151,9 +144,6 @@ def __init__(
                 to ``False`` this value is not required. Otherwise, the value is needed to normalize and
                 center the game. If no value is provided, the game raises a warning.
 
-            path_to_values: The path to load the game values from. If the path is provided, the game
-                values are loaded from the given path. Defaults to ``None``.
-
             verbose: Whether to show a progress bar for the evaluation. Defaults to ``False``. Note
                 that this only has an effect if the game is not precomputed and may slow down the
                 evaluation.
@@ -164,14 +154,7 @@ def __init__(
             kwargs: Additional keyword arguments (not used).
 
         """
-        if path_to_values is not None:
-            msg = (
-                "Initializing a Game with `path_to_values` is deprecated and will be removed in a"
-                " future version. Use `Game.load` or `Game().load_values()` instead."
-            )
-            raise_deprecation_warning(message=msg, deprecated_in="1.3.1", removed_in="1.4.0")
-
-        if n_players is None and path_to_values is None:
+        if n_players is None:
             msg = "The number of players has to be provided if game is not loaded from values."
             raise ValueError(msg)
 
@@ -180,11 +163,10 @@ def __init__(
 
         # define storage variables
         self.game_values = {}
-        # TODO(mmschlk): Remove None Assignment below and drop the pyright ignore when we remove path_to_values # noqa: TD003
-        self.n_players = n_players  # type: ignore[assignment]
+        self.n_players = n_players
         # setup normalization of the game
         self.normalization_value = 0.0
-        if normalize and path_to_values is None:
+        if normalize:
             if normalization_value is None:
                 # this is desired behavior, as in some cases normalization is set by the subclasses
                 # after init of the base Game class. For example, in the imputer classes.
@@ -201,12 +183,6 @@ def __init__(
 
         game_id = str(hash(self))[:8]
         self.game_id = f"{self.get_game_name()}_{game_id}"
-        if path_to_values is not None:
-            self.load_values(path_to_values, precomputed=True)
-            self.game_id = str(path_to_values).split(os.path.sep)[-1].split(".")[0]
-            # if game should not be normalized, reset normalization value to 0
-            if not normalize and self.normalization_value != 0:
-                self.normalization_value = 0.0
 
         # define some handy coalition variables
         self.empty_coalition = np.zeros(self.n_players, dtype=bool)
diff --git a/src/shapiq/interaction_values.py b/src/shapiq/interaction_values.py
@@ -5,7 +5,6 @@
 import contextlib
 import copy
 import json
-import pickle
 from pathlib import Path
 from typing import TYPE_CHECKING
 from warnings import warn
@@ -19,8 +18,6 @@
     is_index_aggregated,
     is_index_valid,
 )
-from .utils.errors import raise_deprecation_warning
-from .utils.saving import safe_str_to_tuple, safe_tuple_to_str
 from .utils.sets import generate_interaction_lookup
 
 if TYPE_CHECKING:
@@ -32,11 +29,6 @@
 
     from shapiq.typing import InteractionScores, JSONType
 
-SAVE_JSON_DEPRECATION_MSG = (
-    "Saving InteractionValues not as a JSON file is deprecated. "
-    "The parameters `as_pickle` and `as_npz` will be removed in the future. "
-)
-
 
 class InteractionValues:
     """This class contains the interaction values as estimated by an approximator.
@@ -773,61 +765,18 @@ def get_subset(self, players: list[int]) -> InteractionValues:
             baseline_value=self.baseline_value,
         )
 
-    def save(self, path: Path, *, as_pickle: bool = False, as_npz: bool = False) -> None:
-        """Save the InteractionValues object to a file.
-
-        By default, the InteractionValues object is saved as a JSON file.
+    def save(self, path: Path) -> None:
+        """Save the InteractionValues object to a JSON file.
 
         Args:
             path: The path to save the InteractionValues object to.
-            as_pickle: Whether to save the InteractionValues object as a pickle file (``True``).
-            as_npz: Whether to save the InteractionValues object as a ``npz`` file (``True``).
-
-        Raises:
-            DeprecationWarning: If `as_pickle` or `as_npz` is set to ``True``, a deprecation
-                warning is raised
         """
         # check if the directory exists
         directory = Path(path).parent
         if not Path(directory).exists():
             with contextlib.suppress(FileNotFoundError):
                 Path(directory).mkdir(parents=True, exist_ok=True)
-        if as_pickle:
-            raise_deprecation_warning(
-                message=SAVE_JSON_DEPRECATION_MSG,
-                deprecated_in="1.3.1",
-                removed_in="1.4.0",
-            )
-            with Path(path).open("wb") as file:
-                pickle.dump(self, file)
-        elif as_npz:
-            raise_deprecation_warning(
-                message=SAVE_JSON_DEPRECATION_MSG,
-                deprecated_in="1.3.1",
-                removed_in="1.4.0",
-            )
-            # save object as npz file
-            interaction_keys = np.array(
-                list(map(safe_tuple_to_str, self.interaction_lookup.keys()))
-            )
-            interaction_indices = np.array(list(self.interaction_lookup.values()))
-            estimation_budget = self.estimation_budget if self.estimation_budget is not None else -1
-
-            np.savez(
-                path,
-                values=self.values,
-                index=self.index,
-                max_order=self.max_order,
-                n_players=self.n_players,
-                min_order=self.min_order,
-                interaction_lookup_keys=interaction_keys,
-                interaction_lookup_indices=interaction_indices,
-                estimated=self.estimated,
-                estimation_budget=estimation_budget,
-                baseline_value=self.baseline_value,
-            )
-        else:
-            self.to_json_file(path)
+        self.to_json_file(path)
 
     @classmethod
     def load(cls, path: Path | str) -> InteractionValues:
@@ -841,46 +790,10 @@ def load(cls, path: Path | str) -> InteractionValues:
 
         """
         path = Path(path)
-        # check if path ends with .json
-        if path.name.endswith(".json"):
-            return cls.from_json_file(path)
-
-        raise_deprecation_warning(
-            SAVE_JSON_DEPRECATION_MSG, deprecated_in="1.3.1", removed_in="1.4.0"
-        )
-
-        # try loading as npz file
-        if path.name.endswith(".npz"):
-            data = np.load(path, allow_pickle=True)
-            try:
-                # try to load Pyright save format
-                interaction_lookup = {
-                    safe_str_to_tuple(key): int(value)
-                    for key, value in zip(
-                        data["interaction_lookup_keys"],
-                        data["interaction_lookup_indices"],
-                        strict=False,
-                    )
-                }
-            except KeyError:
-                # fallback to old format
-                interaction_lookup = data["interaction_lookup"].item()
-            estimation_budget = data["estimation_budget"].item()
-            if estimation_budget == -1:
-                estimation_budget = None
-            return InteractionValues(
-                values=data["values"],
-                index=str(data["index"]),
-                max_order=int(data["max_order"]),
-                n_players=int(data["n_players"]),
-                min_order=int(data["min_order"]),
-                interaction_lookup=interaction_lookup,
-                estimated=bool(data["estimated"]),
-                estimation_budget=estimation_budget,
-                baseline_value=float(data["baseline_value"]),
-            )
-        msg = f"Path {path} does not end with .json or .npz. Cannot load InteractionValues."
-        raise ValueError(msg)
+        if not path.name.endswith(".json"):
+            msg = f"Path {path} does not end with .json. Cannot load InteractionValues."
+            raise ValueError(msg)
+        return cls.from_json_file(path)
 
     @classmethod
     def from_dict(cls, data: dict[str, Any]) -> InteractionValues:
diff --git a/tests/shapiq/tests_deprecation/deprecated_behaviour.py b/tests/shapiq/tests_deprecation/deprecated_behaviour.py
@@ -1,71 +1,23 @@
-"""Collects all deprecated behaviour tests."""
+"""Collects all deprecated behavior tests.
 
-from __future__ import annotations
-
-import warnings
-from typing import TYPE_CHECKING
-
-if TYPE_CHECKING:
-    import pytest
-
-from .features import register_deprecated
-
-
-@register_deprecated(name="Game(path_to_values=...)", deprecated_in="1.3.1", removed_in="1.4.0")
-def deprecated_game_init_with_path(request: pytest.FixtureRequest) -> None:
-    from shapiq.game import Game
-
-    tmp_path = request.getfixturevalue("tmp_path")
-    game = request.getfixturevalue("cooking_game_pre_computed")
-    path = tmp_path / "dummy_game.json"
-    game.save(path)
-    Game(path_to_values=path)
-
-
-@register_deprecated(
-    name="InteractionValues.save(..., as_pickle=True)", deprecated_in="1.3.1", removed_in="1.4.0"
-)
-def save_interaction_values_as_pickle(request: pytest.FixtureRequest) -> None:
-    """Tests that old methods work but also warn with deprecation."""
-    import pathlib
+Test functions in this module are registered as deprecated features using the `register_deprecated`
+decorator from `features.py`. Each test function should be decorated with `register_deprecated`,
+which takes the name of the deprecated feature, the version in which it was deprecated, and the
+version in which it will be removed as arguments.
 
-    tmp_path = request.getfixturevalue("tmp_path")
-    iv = request.getfixturevalue("iv_7_all")
+Example:
+    >>> from .features import register_deprecated
 
-    path = tmp_path / pathlib.Path("test_interaction_values")
-    iv.save(path, as_pickle=True)
+    >>> @register_deprecated(name="Game(path_to_values=...)", deprecated_in="1.3.1", removed_in="1.4.0")
+    >>> def deprecated_game_init_with_path(request: pytest.FixtureRequest) -> None:
+    >>> from shapiq.game import Game
+    >>>
+    >>> tmp_path = request.getfixturevalue("tmp_path")
+    >>> game = request.getfixturevalue("cooking_game_pre_computed")
+    >>> path = tmp_path / "dummy_game.json"
+    >>> game.save(path)
+    >>> Game(path_to_values=path)
 
+"""
 
-@register_deprecated(
-    name="InteractionValues.save(..., as_npz=True)", deprecated_in="1.3.1", removed_in="1.4.0"
-)
-def save_interaction_values_as_npz(request: pytest.FixtureRequest) -> None:
-    """Tests that old methods work but also warn with deprecation."""
-    import pathlib
-
-    tmp_path = request.getfixturevalue("tmp_path")
-    iv = request.getfixturevalue("iv_7_all")
-
-    path = tmp_path / pathlib.Path("test_interaction_values")
-    iv.save(path, as_npz=True)
-
-
-@register_deprecated(
-    name="InteractionValues.load() from non-json file", deprecated_in="1.3.1", removed_in="1.4.0"
-)
-def load_interaction_values_from_non_json(request: pytest.FixtureRequest) -> None:
-    """Tests that old methods work but also warn with deprecation."""
-    import pathlib
-
-    from shapiq.interaction_values import InteractionValues
-
-    tmp_path = request.getfixturevalue("tmp_path")
-    iv: InteractionValues = request.getfixturevalue("iv_7_all")
-    path = tmp_path / pathlib.Path("test_interaction_values.npz")
-
-    # supress the warning for saving as .npz
-    with warnings.catch_warnings():
-        warnings.simplefilter("ignore", DeprecationWarning)
-        iv.save(path, as_npz=True)
-
-    InteractionValues.load(path)
+from __future__ import annotations
diff --git a/tests/shapiq/tests_unit/tests_games/test_base_game.py b/tests/shapiq/tests_unit/tests_games/test_base_game.py
@@ -246,11 +246,12 @@ class TestSavingGames:
 
     @pytest.mark.parametrize("suffix", [".json", ".npz"])
     def test_init_from_saved_game(self, suffix, cooking_game_pre_computed: Game, tmp_path: Path):
-        """Test initializing a game from a saved file."""
+        """Test loading a game from a saved file using load_values."""
         path = tmp_path / "dummy_game"
         path = path.with_suffix(suffix)
         cooking_game_pre_computed.save_values(path)
-        loaded_game = Game(path_to_values=path)
+        loaded_game = Game(n_players=cooking_game_pre_computed.n_players)
+        loaded_game.load_values(path, precomputed=True)
         check_game_equality(cooking_game_pre_computed, loaded_game)
 
     @pytest.mark.parametrize("suffix", [".json", ".npz"])
@@ -262,10 +263,11 @@ def test_save_adds_suffix(self, cooking_game_pre_computed: Game, tmp_path: Path,
         assert path_with_suffix.exists()
 
     def test_save_game_npz(self, cooking_game_pre_computed: Game, tmp_path: Path):
-        """Test initializing a game from a saved file."""
+        """Test loading a game from a saved npz file using load_values."""
         path = tmp_path / "dummy_game.npz"
         cooking_game_pre_computed.save_values(path, as_npz=True)
-        loaded_game = Game(path_to_values=path)
+        loaded_game = Game(n_players=cooking_game_pre_computed.n_players)
+        loaded_game.load_values(path, precomputed=True)
         check_game_equality(cooking_game_pre_computed, loaded_game)
 
     def test_save_and_load_json(self, cooking_game_pre_computed: Game, tmp_path: Path):
@@ -295,15 +297,18 @@ def test_save_and_load_with_normalization(self, suffix, tmp_path: Path):
         path = tmp_path / f"dummy_game.{suffix}"
         game.save_values(path)
 
-        game_loaded = Game(path_to_values=path)
+        game_loaded = Game(n_players=4)
+        game_loaded.load_values(path, precomputed=True)
         assert game_loaded.normalize  # should be normalized
         assert game_loaded.normalization_value == normalization_value
         empty_value = game_loaded(game_loaded.empty_coalition)
         # the output should be the same as the original game with normalization (-0.25)
         assert empty_value == dummy_game_empty_output - normalization_value
 
-        # load with normalization set to False
-        game_loaded = Game(path_to_values=path, normalize=False)
+        # load without normalization by resetting normalization_value after loading
+        game_loaded = Game(n_players=4)
+        game_loaded.load_values(path, precomputed=True)
+        game_loaded.normalization_value = 0.0
         assert not game_loaded.normalize  # should not be normalized
         assert game_loaded.normalization_value == 0.0
         empty_value = game_loaded(game_loaded.empty_coalition)
