diff --git a/.gitignore b/.gitignore
index 2dc53ca3..c67c29a0 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +1,5 @@
+.vscode/**
+
 # Byte-compiled / optimized / DLL files
 __pycache__/
 *.py[cod]
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 5d3180b6..610be0e7 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -21,4 +21,4 @@ repos:
         name: ruff
         language: python
         types: [python]
-        entry: ruff --no-cache --fix
+        entry: ruff check --no-cache --fix
diff --git a/docs/source/conf.py b/docs/source/conf.py
index a87ca1d5..b84204ef 100644
--- a/docs/source/conf.py
+++ b/docs/source/conf.py
@@ -3,22 +3,24 @@
 # For the full list of built-in configuration values, see the documentation:
 # https://www.sphinx-doc.org/en/master/usage/configuration.html
 
-from sphinx.builders.html import StandaloneHTMLBuilder
 import os
 import sys
+
+from sphinx.builders.html import StandaloneHTMLBuilder
+
 sys.path.insert(0, os.path.abspath("../.."))
 sys.path.insert(0, os.path.abspath("../../shapiq"))
 
 import shapiq
 
 # -- Read the Docs ---------------------------------------------------------------------------------
-master_doc = 'index'
+master_doc = "index"
 
 # -- Project information ---------------------------------------------------------------------------
 # https://www.sphinx-doc.org/en/master/usage/configuration.html#project-information
-project = 'shapiq'
-copyright = '2023, the shapiq developers'
-author = 'Maximilian Muschalik and Fabian Fumagalli'
+project = "shapiq"
+copyright = "2023, the shapiq developers"
+author = "Maximilian Muschalik and Fabian Fumagalli"
 release = shapiq.__version__
 version = shapiq.__version__
 
@@ -34,15 +36,15 @@
     "sphinx.ext.autodoc",
     "sphinx.ext.doctest",
     "sphinx.ext.autosummary",
-    'sphinx_copybutton',
+    "sphinx_copybutton",
     "sphinx.ext.viewcode",
     "sphinx.ext.autosectionlabel",
     "sphinx_autodoc_typehints",
     "sphinx_toolbox.more_autodoc.autoprotocol",
 ]
 
-templates_path = ['_templates']
-exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store']
+templates_path = ["_templates"]
+exclude_patterns = ["_build", "Thumbs.db", ".DS_Store"]
 
 source_suffix = {
     ".rst": "restructuredtext",
@@ -59,9 +61,9 @@
 
 # -- Options for HTML output -----------------------------------------------------------------------
 # https://www.sphinx-doc.org/en/master/usage/configuration.html#options-for-html-output
-html_theme = 'furo'
+html_theme = "furo"
 html_static_path = ["_static"]
-html_favicon = '_static/shapiq.ico'
+html_favicon = "_static/shapiq.ico"
 pygments_dark_style = "monokai"
 html_theme_options = {
     "sidebar_hide_name": True,
@@ -83,19 +85,22 @@
 # -- Autodoc ---------------------------------------------------------------------------------------
 autosummary_generate = True
 autodoc_default_options = {
-    'show-inheritance': True,
-    'members': True,
-    'member-order': 'groupwise',
-    'special-members': '__call__',
-    'undoc-members': True,
-    'exclude-members': '__weakref__'
+    "show-inheritance": True,
+    "members": True,
+    "member-order": "groupwise",
+    "special-members": "__call__",
+    "undoc-members": True,
+    "exclude-members": "__weakref__",
 }
-autoclass_content = 'class'
+autoclass_content = "class"
 autodoc_inherit_docstrings = False
 
 # -- Images ----------------------------------------------------------------------------------------
 StandaloneHTMLBuilder.supported_image_types = [
-    "image/svg+xml", "image/gif", "image/png", "image/jpeg"
+    "image/svg+xml",
+    "image/gif",
+    "image/png",
+    "image/jpeg",
 ]
 # -- Copy Paste Button -----------------------------------------------------------------------------
 # Ignore >>> when copying code
diff --git a/notebooks/bike.ipynb b/notebooks/bike.ipynb
index a8a0f8a2..b2d92eaa 100644
--- a/notebooks/bike.ipynb
+++ b/notebooks/bike.ipynb
@@ -2,25 +2,25 @@
  "cells": [
   {
    "cell_type": "markdown",
-   "source": [
-    "# Load and Prepare the Dataset\n",
-    "The dataset stems from a kaggle competition and is available at [https://www.kaggle.com/c/bike-sharing-demand](https://www.kaggle.com/c/bike-sharing-demand)."
-   ],
+   "id": "853488804411d5a7",
    "metadata": {
     "collapsed": false
    },
-   "id": "853488804411d5a7"
+   "source": [
+    "# Load and Prepare the Dataset\n",
+    "The dataset stems from a kaggle competition and is available at [https://www.kaggle.com/c/bike-sharing-demand](https://www.kaggle.com/c/bike-sharing-demand)."
+   ]
   },
   {
    "cell_type": "code",
-   "execution_count": 59,
+   "execution_count": 1,
    "id": "initial_id",
    "metadata": {
-    "collapsed": true,
     "ExecuteTime": {
      "end_time": "2024-01-04T13:18:53.806704200Z",
      "start_time": "2024-01-04T13:18:53.770362900Z"
-    }
+    },
+    "collapsed": true
    },
    "outputs": [],
    "source": [
@@ -30,25 +30,33 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 60,
-   "outputs": [],
-   "source": [
-    "data = shapiq.load_bike()\n",
-    "feature_names = data.columns.tolist()[:-3]\n",
-    "n_features = len(feature_names)"
-   ],
+   "execution_count": 2,
+   "id": "dafd7b49bb5aa04c",
    "metadata": {
-    "collapsed": false,
     "ExecuteTime": {
      "end_time": "2024-01-04T13:18:54.373604900Z",
      "start_time": "2024-01-04T13:18:53.776358700Z"
-    }
+    },
+    "collapsed": false
    },
-   "id": "dafd7b49bb5aa04c"
+   "outputs": [],
+   "source": [
+    "data = shapiq.load_bike()\n",
+    "feature_names = data.columns.tolist()[:-3]\n",
+    "n_features = len(feature_names)"
+   ]
   },
   {
    "cell_type": "code",
-   "execution_count": 61,
+   "execution_count": 3,
+   "id": "7294335c1b016c89",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2024-01-04T13:18:54.388950200Z",
+     "start_time": "2024-01-04T13:18:54.378953100Z"
+    },
+    "collapsed": false
+   },
    "outputs": [],
    "source": [
     "# Split data, with total count serving as regression target\n",
@@ -62,45 +70,45 @@
     "train = train[:, :-3].copy()\n",
     "val = val[:, :-3].copy()\n",
     "test = test[:, :-3].copy()"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "ExecuteTime": {
-     "end_time": "2024-01-04T13:18:54.388950200Z",
-     "start_time": "2024-01-04T13:18:54.378953100Z"
-    }
-   },
-   "id": "7294335c1b016c89"
+   ]
   },
   {
    "cell_type": "markdown",
-   "source": [
-    "# Train a Model"
-   ],
+   "id": "594f5cc5514315a6",
    "metadata": {
     "collapsed": false
    },
-   "id": "594f5cc5514315a6"
+   "source": [
+    "# Train a Model"
+   ]
   },
   {
    "cell_type": "code",
-   "execution_count": 62,
-   "outputs": [],
-   "source": [
-    "from sklearn.ensemble import RandomForestRegressor"
-   ],
+   "execution_count": 4,
+   "id": "3d283e7b6424cff5",
    "metadata": {
-    "collapsed": false,
     "ExecuteTime": {
      "end_time": "2024-01-04T13:18:54.409763800Z",
      "start_time": "2024-01-04T13:18:54.390955700Z"
-    }
+    },
+    "collapsed": false
    },
-   "id": "3d283e7b6424cff5"
+   "outputs": [],
+   "source": [
+    "from sklearn.ensemble import RandomForestRegressor"
+   ]
   },
   {
    "cell_type": "code",
-   "execution_count": 63,
+   "execution_count": 5,
+   "id": "f53094e4abc75a2e",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2024-01-04T13:18:57.664189Z",
+     "start_time": "2024-01-04T13:18:54.409763800Z"
+    },
+    "collapsed": false
+   },
    "outputs": [
     {
      "name": "stdout",
@@ -116,109 +124,176 @@
     "model.fit(train, Y_train)\n",
     "print('Train R2: {:.3f}'.format(model.score(train, Y_train)))\n",
     "print('Val R2: {:.3f}'.format(model.score(val, Y_val)))"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "ExecuteTime": {
-     "end_time": "2024-01-04T13:18:57.664189Z",
-     "start_time": "2024-01-04T13:18:54.409763800Z"
-    }
-   },
-   "id": "f53094e4abc75a2e"
+   ]
   },
   {
    "cell_type": "markdown",
-   "source": [
-    "# Explain the Model with Interactions"
-   ],
+   "id": "acb9b64d4f122679",
    "metadata": {
     "collapsed": false
    },
-   "id": "acb9b64d4f122679"
+   "source": [
+    "# Explain the Model with Interactions"
+   ]
   },
   {
    "cell_type": "code",
-   "execution_count": 64,
-   "outputs": [],
-   "source": [
-    "from shapiq import InteractionExplainer"
-   ],
+   "execution_count": 6,
+   "id": "81be2c2049c53b57",
    "metadata": {
-    "collapsed": false,
     "ExecuteTime": {
-     "end_time": "2024-01-04T13:18:57.677575200Z",
-     "start_time": "2024-01-04T13:18:57.663191200Z"
-    }
+     "end_time": "2024-01-04T13:18:58.059113600Z",
+     "start_time": "2024-01-04T13:18:57.679575800Z"
+    },
+    "collapsed": false
    },
-   "id": "3dbc40b7565166de"
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 65,
    "outputs": [
     {
      "data": {
-      "text/plain": "InteractionValues(\n    index=nSII, max_order=2, min_order=1, estimated=False, estimation_budget=4096,\n    values={\n        (0,): -91.0403,\n        (1,): 4.1264,\n        (2,): -0.4724,\n        (3,): -51.347,\n        (4,): 0.5578,\n        (5,): 0.0,\n        (6,): 0.0,\n        (7,): 0.0,\n        (8,): 10.6859,\n        (9,): 3.6103,\n        (10,): 0.786,\n        (11,): 3.7735,\n        (0, 1): -0.8073,\n        (0, 2): 2.469,\n        (0, 3): 9.901,\n        (0, 4): 0.621,\n        (0, 5): 0.0,\n        (0, 6): 0.0,\n        (0, 7): 0.0,\n        (0, 8): -5.2057,\n        (0, 9): 2.8267,\n        (0, 10): -1.9047,\n        (0, 11): 0.06,\n        (1, 2): -0.718,\n        (1, 3): -1.958,\n        (1, 4): 0.0,\n        (1, 5): 0.0,\n        (1, 6): 0.0,\n        (1, 7): 0.0,\n        (1, 8): 0.165,\n        (1, 9): -2.4673,\n        (1, 10): 0.0183,\n        (1, 11): 0.0073,\n        (2, 3): 6.7183,\n        (2, 4): -0.133,\n        (2, 5): 0.0,\n        (2, 6): 0.0,\n        (2, 7): 0.0,\n        (2, 8): 0.0177,\n        (2, 9): -6.111,\n        (2, 10): -0.282,\n        (2, 11): -1.6257,\n        (3, 4): -0.6367,\n        (3, 5): 0.0,\n        (3, 6): 0.0,\n        (3, 7): 0.0,\n        (3, 8): -2.1633,\n        (3, 9): -4.01,\n        (3, 10): 2.7537,\n        (3, 11): 2.175,\n        (4, 5): 0.0,\n        (4, 6): 0.0,\n        (4, 7): 0.0,\n        (4, 8): -0.3577,\n        (4, 9): -0.2347,\n        (4, 10): 0.523,\n        (4, 11): -0.282,\n        (5, 6): 0.0,\n        (5, 7): 0.0,\n        (5, 8): 0.0,\n        (5, 9): 0.0,\n        (5, 10): 0.0,\n        (5, 11): 0.0,\n        (6, 7): 0.0,\n        (6, 8): 0.0,\n        (6, 9): 0.0,\n        (6, 10): 0.0,\n        (6, 11): 0.0,\n        (7, 8): 0.0,\n        (7, 9): 0.0,\n        (7, 10): 0.0,\n        (7, 11): 0.0,\n        (8, 9): -7.775,\n        (8, 10): 0.6027,\n        (8, 11): -0.1683,\n        (9, 10): -2.9567,\n        (9, 11): 0.748,\n        (10, 11): 0.4057\n    }\n)"
+      "text/plain": [
+       "InteractionValues(\n",
+       "    index=SII, max_order=2, min_order=1, estimated=False, estimation_budget=4096,\n",
+       "    values={\n",
+       "        (0,): -87.1203,\n",
+       "        (1,): 1.2464,\n",
+       "        (2,): -0.3224,\n",
+       "        (3,): -44.957,\n",
+       "        (4,): 0.3078,\n",
+       "        (5,): -0.0,\n",
+       "        (6,): -0.0,\n",
+       "        (7,): -0.0,\n",
+       "        (8,): 3.2259,\n",
+       "        (9,): -6.3797,\n",
+       "        (10,): 0.366,\n",
+       "        (11,): 4.3735,\n",
+       "        (0, 1): -0.8073,\n",
+       "        (0, 2): 2.469,\n",
+       "        (0, 3): 9.901,\n",
+       "        (0, 4): 0.621,\n",
+       "        (0, 5): 0.0,\n",
+       "        (0, 6): -0.0,\n",
+       "        (0, 7): -0.0,\n",
+       "        (0, 8): -5.2057,\n",
+       "        (0, 9): 2.8267,\n",
+       "        (0, 10): -1.9047,\n",
+       "        (0, 11): -0.06,\n",
+       "        (1, 2): -0.718,\n",
+       "        (1, 3): -1.958,\n",
+       "        (1, 4): -0.0,\n",
+       "        (1, 5): -0.0,\n",
+       "        (1, 6): -0.0,\n",
+       "        (1, 7): -0.0,\n",
+       "        (1, 8): 0.165,\n",
+       "        (1, 9): -2.4673,\n",
+       "        (1, 10): 0.0183,\n",
+       "        (1, 11): 0.0073,\n",
+       "        (2, 3): 6.7183,\n",
+       "        (2, 4): -0.133,\n",
+       "        (2, 5): -0.0,\n",
+       "        (2, 6): -0.0,\n",
+       "        (2, 7): 0.0,\n",
+       "        (2, 8): -0.0177,\n",
+       "        (2, 9): -6.111,\n",
+       "        (2, 10): -0.282,\n",
+       "        (2, 11): -1.6257,\n",
+       "        (3, 4): -0.6367,\n",
+       "        (3, 5): -0.0,\n",
+       "        (3, 6): -0.0,\n",
+       "        (3, 7): -0.0,\n",
+       "        (3, 8): -2.1633,\n",
+       "        (3, 9): -4.01,\n",
+       "        (3, 10): 2.7537,\n",
+       "        (3, 11): 2.175,\n",
+       "        (4, 5): -0.0,\n",
+       "        (4, 6): -0.0,\n",
+       "        (4, 7): -0.0,\n",
+       "        (4, 8): -0.3577,\n",
+       "        (4, 9): -0.2347,\n",
+       "        (4, 10): 0.523,\n",
+       "        (4, 11): -0.282,\n",
+       "        (5, 6): -0.0,\n",
+       "        (5, 7): -0.0,\n",
+       "        (5, 8): -0.0,\n",
+       "        (5, 9): 0.0,\n",
+       "        (5, 10): -0.0,\n",
+       "        (5, 11): -0.0,\n",
+       "        (6, 7): -0.0,\n",
+       "        (6, 8): -0.0,\n",
+       "        (6, 9): 0.0,\n",
+       "        (6, 10): -0.0,\n",
+       "        (6, 11): -0.0,\n",
+       "        (7, 8): 0.0,\n",
+       "        (7, 9): 0.0,\n",
+       "        (7, 10): -0.0,\n",
+       "        (7, 11): -0.0,\n",
+       "        (8, 9): -7.775,\n",
+       "        (8, 10): 0.6027,\n",
+       "        (8, 11): -0.1683,\n",
+       "        (9, 10): -2.9567,\n",
+       "        (9, 11): 0.748,\n",
+       "        (10, 11): 0.4057\n",
+       "    }\n",
+       ")"
+      ]
      },
-     "execution_count": 65,
+     "execution_count": 6,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
     "model_function = model.predict\n",
-    "explainer = InteractionExplainer(\n",
+    "explainer = shapiq.TabularExplainer(\n",
     "    model=model_function,\n",
     "    background_data=train,\n",
     "    random_state=42,\n",
-    "    index=\"nSII\",\n",
+    "    index=\"SII\",\n",
     "    max_order=2,\n",
     "    approximator=\"auto\",\n",
     ")\n",
     "x_explain = test[0].reshape(1, -1)\n",
     "interaction_values = explainer.explain(x_explain, budget=2**x_explain.shape[1])\n",
     "interaction_values"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "ExecuteTime": {
-     "end_time": "2024-01-04T13:18:58.059113600Z",
-     "start_time": "2024-01-04T13:18:57.679575800Z"
-    }
-   },
-   "id": "81be2c2049c53b57"
+   ]
   },
   {
    "cell_type": "markdown",
-   "source": [
-    "# Visualize the Interactions"
-   ],
+   "id": "35ad0602713e1b85",
    "metadata": {
     "collapsed": false
    },
-   "id": "35ad0602713e1b85"
+   "source": [
+    "# Visualize the Interactions"
+   ]
   },
   {
    "cell_type": "code",
-   "execution_count": 66,
-   "outputs": [],
-   "source": [
-    "from shapiq import network_plot\n",
-    "import numpy as np\n",
-    "import matplotlib.pyplot as plt"
-   ],
+   "execution_count": 7,
+   "id": "c5df625546b750ec",
    "metadata": {
-    "collapsed": false,
     "ExecuteTime": {
      "end_time": "2024-01-04T13:18:58.102877200Z",
      "start_time": "2024-01-04T13:18:58.061115200Z"
-    }
+    },
+    "collapsed": false
    },
-   "id": "c5df625546b750ec"
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt"
+   ]
   },
   {
    "cell_type": "code",
-   "execution_count": 67,
+   "execution_count": 8,
+   "id": "dfc8ecdfc3f720",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2024-01-04T13:18:58.115862900Z",
+     "start_time": "2024-01-04T13:18:58.077337200Z"
+    },
+    "collapsed": false
+   },
    "outputs": [],
    "source": [
     "first_order_values = np.asarray([interaction_values[(i,)] for i in range(n_features)])\n",
@@ -228,46 +303,40 @@
     "        if i == j:\n",
     "            continue\n",
     "        second_order_values[i, j] = interaction_values[(i, j)]"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "ExecuteTime": {
-     "end_time": "2024-01-04T13:18:58.115862900Z",
-     "start_time": "2024-01-04T13:18:58.077337200Z"
-    }
-   },
-   "id": "dfc8ecdfc3f720"
+   ]
   },
   {
    "cell_type": "code",
-   "execution_count": 68,
+   "execution_count": 9,
+   "id": "db9caa01d8496958",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2024-01-04T13:18:58.274265100Z",
+     "start_time": "2024-01-04T13:18:58.091709Z"
+    },
+    "collapsed": false
+   },
    "outputs": [
     {
      "data": {
-      "text/plain": "<Figure size 600x600 with 1 Axes>",
-      "image/png": "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"
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 600x600 with 1 Axes>"
+      ]
      },
      "metadata": {},
      "output_type": "display_data"
     }
    ],
    "source": [
-    "fig, axes = network_plot(\n",
+    "fig, axes = shapiq.network_plot(\n",
     "    first_order_values=first_order_values,\n",
     "    second_order_values=second_order_values,\n",
     "    feature_names=feature_names,\n",
     ")\n",
     "plt.tight_layout()\n",
     "plt.show()"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "ExecuteTime": {
-     "end_time": "2024-01-04T13:18:58.274265100Z",
-     "start_time": "2024-01-04T13:18:58.091709Z"
-    }
-   },
-   "id": "db9caa01d8496958"
+   ]
   }
  ],
  "metadata": {
@@ -279,14 +348,14 @@
   "language_info": {
    "codemirror_mode": {
     "name": "ipython",
-    "version": 2
+    "version": 3
    },
    "file_extension": ".py",
    "mimetype": "text/x-python",
    "name": "python",
    "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython2",
-   "version": "2.7.6"
+   "pygments_lexer": "ipython3",
+   "version": "3.9.19"
   }
  },
  "nbformat": 4,
diff --git a/pyproject.toml b/pyproject.toml
index c9616e4b..c334951d 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -10,7 +10,7 @@ line-length = 100
 target-version = ['py39']
 
 [tool.ruff]
-select = ["E", "F", "I", "UP"]  # https://beta.ruff.rs/docs/rules/
+lint.select = ["E", "F", "I", "UP"]  # https://beta.ruff.rs/docs/rules/
+lint.ignore = ["E501"]
 line-length = 100
-target-version = 'py39'
-ignore = ["E501"]
+target-version = 'py39'
\ No newline at end of file
diff --git a/setup.py b/setup.py
index 84ef8937..6887fd69 100644
--- a/setup.py
+++ b/setup.py
@@ -1,7 +1,8 @@
-import setuptools
-import io
+import codecs
 import os
 
+import setuptools
+
 NAME = "shapiq"
 DESCRIPTION = "SHAPley Interaction Quantification (SHAP-IQ) for Explainable AI"
 LONG_DESCRIPTION_CONTENT_TYPE = "text/markdown"
@@ -11,11 +12,22 @@
 REQUIRES_PYTHON = ">=3.9.0"
 
 work_directory = os.path.abspath(os.path.dirname(__file__))
-version: dict = {}
-with open(os.path.join(work_directory, NAME, "__version__.py")) as f:
-    exec(f.read(), version)
 
-with io.open(os.path.join(work_directory, "README.md"), encoding="utf-8") as f:
+
+# https://packaging.python.org/guides/single-sourcing-package-version/
+def read(rel_path):
+    with codecs.open(os.path.join(work_directory, rel_path), "r") as fp:
+        return fp.read()
+
+
+def get_version(rel_path):
+    for line in read(rel_path).splitlines():
+        if line.startswith("__version__"):
+            delimiter = '"' if '"' in line else "'"
+            return line.split(delimiter)[1]
+
+
+with open(os.path.join(work_directory, "README.md"), encoding="utf-8") as f:
     long_description = "\n" + f.read()
 
 base_packages = ["numpy", "scipy", "pandas", "tqdm"]
@@ -45,7 +57,7 @@
 
 setuptools.setup(
     name=NAME,
-    version=version["__version__"],
+    version=get_version("shapiq/__init__.py"),
     description=DESCRIPTION,
     long_description=long_description,
     long_description_content_type=LONG_DESCRIPTION_CONTENT_TYPE,
@@ -57,7 +69,7 @@
         "Tracker": "https://github.com/mmschlk/shapiq/issues?q=is%3Aissue+label%3Abug",
         "Source": "https://github.com/mmschlk/shapiq",
     },
-    packages=setuptools.find_packages(exclude=("tests", "examples", "docs")),
+    packages=setuptools.find_packages(include=("shapiq", "shapiq.*")),
     install_requires=base_packages + plotting_packages,
     extras_require={
         "docs": base_packages + plotting_packages + doc_packages,
diff --git a/shapiq/__init__.py b/shapiq/__init__.py
index 2715aa2b..62a187eb 100644
--- a/shapiq/__init__.py
+++ b/shapiq/__init__.py
@@ -2,7 +2,7 @@
 the well established Shapley value and its generalization to interaction.
 """
 
-from .__version__ import __version__
+__version__ = "0.0.6"
 
 # approximator classes
 from .approximator import (
diff --git a/shapiq/__version__.py b/shapiq/__version__.py
deleted file mode 100644
index 034f46c3..00000000
--- a/shapiq/__version__.py
+++ /dev/null
@@ -1 +0,0 @@
-__version__ = "0.0.6"
diff --git a/shapiq/approximator/_base.py b/shapiq/approximator/_base.py
index 668ee954..6aa7aa2e 100644
--- a/shapiq/approximator/_base.py
+++ b/shapiq/approximator/_base.py
@@ -4,12 +4,11 @@
 from typing import Callable, Optional
 
 import numpy as np
-from interaction_values import InteractionValues
 
+from shapiq.approximator._config import AVAILABLE_INDICES
+from shapiq.interaction_values import InteractionValues
 from shapiq.utils.sets import generate_interaction_lookup
 
-from ._config import AVAILABLE_INDICES
-
 __all__ = [
     "Approximator",
 ]
diff --git a/shapiq/approximator/k_sii.py b/shapiq/approximator/k_sii.py
index 511cac52..6ac67e8e 100644
--- a/shapiq/approximator/k_sii.py
+++ b/shapiq/approximator/k_sii.py
@@ -3,10 +3,10 @@
 from typing import Optional, Union
 
 import numpy as np
-from interaction_values import InteractionValues
-from scipy.special import bernoulli
+import scipy as sp
 
 from shapiq.approximator._base import Approximator
+from shapiq.interaction_values import InteractionValues
 from shapiq.utils import generate_interaction_lookup, powerset
 
 
@@ -118,7 +118,7 @@ def _calculate_ksii_from_sii(
         interaction_lookup = generate_interaction_lookup(n, 1, max_order)
 
     # compute nSII values from SII values
-    bernoulli_numbers = bernoulli(max_order)
+    bernoulli_numbers = sp.special.bernoulli(max_order)
     nsii_values = np.zeros_like(sii_values)
     # all subsets S with 1 <= |S| <= max_order
     for subset in powerset(set(range(n)), min_size=1, max_size=max_order):
diff --git a/shapiq/approximator/permutation/sii.py b/shapiq/approximator/permutation/sii.py
index bcc98f32..a3a1028e 100644
--- a/shapiq/approximator/permutation/sii.py
+++ b/shapiq/approximator/permutation/sii.py
@@ -3,10 +3,11 @@
 from typing import Callable, Optional
 
 import numpy as np
-from approximator._base import Approximator
-from approximator.k_sii import KShapleyMixin
-from interaction_values import InteractionValues
-from utils import powerset
+
+from shapiq.approximator._base import Approximator
+from shapiq.approximator.k_sii import KShapleyMixin
+from shapiq.interaction_values import InteractionValues
+from shapiq.utils import powerset
 
 
 class PermutationSamplingSII(Approximator, KShapleyMixin):
diff --git a/shapiq/approximator/permutation/sti.py b/shapiq/approximator/permutation/sti.py
index 42aac3e2..218a3917 100644
--- a/shapiq/approximator/permutation/sti.py
+++ b/shapiq/approximator/permutation/sti.py
@@ -4,10 +4,11 @@
 from typing import Callable, Optional
 
 import numpy as np
-from approximator._base import Approximator
-from interaction_values import InteractionValues
-from scipy.special import binom
-from utils import get_explicit_subsets, powerset
+import scipy as sp
+
+from shapiq.approximator._base import Approximator
+from shapiq.interaction_values import InteractionValues
+from shapiq.utils import get_explicit_subsets, powerset
 
 
 class PermutationSamplingSTI(Approximator):
@@ -76,7 +77,9 @@ def approximate(
         counts: np.ndarray[int] = self._init_result(dtype=int)
 
         # compute all lower order interactions if budget allows it
-        lower_order_cost = sum(int(binom(self.n, s)) for s in range(self.min_order, self.max_order))
+        lower_order_cost = sum(
+            int(sp.special.binom(self.n, s)) for s in range(self.min_order, self.max_order)
+        )
         if self.max_order > 1 and budget >= lower_order_cost:
             budget -= lower_order_cost
             used_budget += lower_order_cost
@@ -161,7 +164,7 @@ def _compute_iteration_cost(self) -> int:
         Returns:
             int: The cost of a single iteration.
         """
-        iteration_cost = int(binom(self.n, self.max_order) * 2**self.max_order)
+        iteration_cost = int(sp.special.binom(self.n, self.max_order) * 2**self.max_order)
         return iteration_cost
 
     def _compute_lower_order_sti(
diff --git a/shapiq/approximator/regression/__init__.py b/shapiq/approximator/regression/__init__.py
index b03c5842..36e4d12f 100644
--- a/shapiq/approximator/regression/__init__.py
+++ b/shapiq/approximator/regression/__init__.py
@@ -1,5 +1,4 @@
-"""This module contains the regression-based approximators to estimate Shapley interaction values.
-"""
+"""This module contains the regression-based approximators to estimate Shapley interaction values."""
 
 from .fsi import RegressionFSI
 from .sii import RegressionSII
diff --git a/shapiq/approximator/regression/_base.py b/shapiq/approximator/regression/_base.py
index bdc8e5d7..0d1fa78c 100644
--- a/shapiq/approximator/regression/_base.py
+++ b/shapiq/approximator/regression/_base.py
@@ -3,11 +3,12 @@
 from typing import Callable, Optional
 
 import numpy as np
-from approximator._base import Approximator
-from approximator.sampling import ShapleySamplingMixin
-from interaction_values import InteractionValues
-from scipy.special import bernoulli, binom
-from utils import powerset
+import scipy as sp
+
+from shapiq.approximator._base import Approximator
+from shapiq.approximator.sampling import ShapleySamplingMixin
+from shapiq.interaction_values import InteractionValues
+from shapiq.utils import powerset
 
 AVAILABLE_INDICES_REGRESSION = ["FSI", "SII", "SV"]
 
@@ -71,7 +72,7 @@ def __init__(
             n, max_order=max_order, index=index, top_order=False, random_state=random_state
         )
         self.iteration_cost: int = 1
-        self._bernoulli_numbers = bernoulli(self.n)  # used for SII
+        self._bernoulli_numbers = sp.special.bernoulli(self.n)  # used for SII
 
     def approximate(
         self,
@@ -168,7 +169,9 @@ def _get_fsi_subset_representation(
             of players.
         """
         n_subsets = all_subsets.shape[0]
-        num_players = sum(int(binom(self.n, order)) for order in range(1, self.max_order + 1))
+        num_players = sum(
+            int(sp.special.binom(self.n, order)) for order in range(1, self.max_order + 1)
+        )
         regression_subsets = np.zeros(shape=(n_subsets, num_players), dtype=bool)
         for interaction_index, interaction in enumerate(
             powerset(self.N, min_size=1, max_size=self.max_order)
@@ -192,7 +195,9 @@ def _get_sii_subset_representation(
             of players.
         """
         n_subsets = all_subsets.shape[0]
-        num_players = sum(int(binom(self.n, order)) for order in range(1, self.max_order + 1))
+        num_players = sum(
+            int(sp.special.binom(self.n, order)) for order in range(1, self.max_order + 1)
+        )
         regression_subsets = np.zeros(shape=(n_subsets, num_players), dtype=float)
         for interaction_index, interaction in enumerate(
             powerset(self.N, min_size=1, max_size=self.max_order)
@@ -215,7 +220,9 @@ def _get_bernoulli_weight(self, intersection_size: int, r_prime: int) -> float:
         """
         weight = 0
         for size in range(1, intersection_size + 1):
-            weight += binom(intersection_size, size) * self._bernoulli_numbers[r_prime - size]
+            weight += (
+                sp.special.binom(intersection_size, size) * self._bernoulli_numbers[r_prime - size]
+            )
         return weight
 
     def _get_bernoulli_weights(
diff --git a/shapiq/approximator/sampling.py b/shapiq/approximator/sampling.py
index 1b961246..095ff540 100644
--- a/shapiq/approximator/sampling.py
+++ b/shapiq/approximator/sampling.py
@@ -3,9 +3,9 @@
 from typing import Union
 
 import numpy as np
-from approximator._base import Approximator
-from scipy.special import binom
+import scipy as sp
 
+from shapiq.approximator._base import Approximator
 from shapiq.utils import get_explicit_subsets, split_subsets_budget
 
 
@@ -18,7 +18,7 @@ class ShapleySamplingMixin(ABC):
     """
 
     def _init_ksh_sampling_weights(
-        self: Union[Approximator, "ShapleySamplingMixin"]
+        self: Union[Approximator, "ShapleySamplingMixin"],
     ) -> np.ndarray[float]:
         """Initializes the weights for sampling subsets.
 
@@ -54,7 +54,9 @@ def _get_ksh_subset_weights(
         ksh_weights = self._init_ksh_sampling_weights()  # indexed by subset size
         subset_sizes = np.sum(subsets, axis=1)
         weights = ksh_weights[subset_sizes]  # set the weights for each subset size
-        weights /= binom(self.n, subset_sizes)  # divide by the number of subsets of the same size
+        weights /= sp.special.binom(
+            self.n, subset_sizes
+        )  # divide by the number of subsets of the same size
 
         # set the weights for the empty and full sets to big M
         weights[np.logical_not(subsets).all(axis=1)] = float(1_000_000)
diff --git a/shapiq/approximator/shapiq/shapiq.py b/shapiq/approximator/shapiq/shapiq.py
index ade5006e..1a514196 100644
--- a/shapiq/approximator/shapiq/shapiq.py
+++ b/shapiq/approximator/shapiq/shapiq.py
@@ -4,11 +4,12 @@
 from typing import Callable, Optional
 
 import numpy as np
-from approximator._base import Approximator
-from approximator.k_sii import KShapleyMixin
-from approximator.sampling import ShapleySamplingMixin
-from interaction_values import InteractionValues
-from utils import powerset
+
+from shapiq.approximator._base import Approximator
+from shapiq.approximator.k_sii import KShapleyMixin
+from shapiq.approximator.sampling import ShapleySamplingMixin
+from shapiq.interaction_values import InteractionValues
+from shapiq.utils import powerset
 
 AVAILABLE_INDICES_SHAPIQ = {"SII", "STI", "FSI", "k-SII"}
 
diff --git a/shapiq/explainer/__init__.py b/shapiq/explainer/__init__.py
index 0ec86f70..9c2a3dc5 100644
--- a/shapiq/explainer/__init__.py
+++ b/shapiq/explainer/__init__.py
@@ -1,6 +1,5 @@
 """This module contains the explainer for the shapiq package."""
 
-
 from .tabular import TabularExplainer
 from .tree import TreeExplainer
 
diff --git a/shapiq/explainer/_base.py b/shapiq/explainer/_base.py
index 82d8e490..fd0983cf 100644
--- a/shapiq/explainer/_base.py
+++ b/shapiq/explainer/_base.py
@@ -3,7 +3,8 @@
 from abc import ABC, abstractmethod
 
 import numpy as np
-from interaction_values import InteractionValues
+
+from shapiq.interaction_values import InteractionValues
 
 
 class Explainer(ABC):
diff --git a/shapiq/explainer/imputer/marginal_imputer.py b/shapiq/explainer/imputer/marginal_imputer.py
index 69efd8a6..2c359235 100644
--- a/shapiq/explainer/imputer/marginal_imputer.py
+++ b/shapiq/explainer/imputer/marginal_imputer.py
@@ -3,7 +3,8 @@
 from typing import Callable, Optional
 
 import numpy as np
-from explainer.imputer._base import Imputer
+
+from shapiq.explainer.imputer._base import Imputer
 
 
 class MarginalImputer(Imputer):
diff --git a/shapiq/explainer/tabular.py b/shapiq/explainer/tabular.py
index 9cd5226c..e1e03e66 100644
--- a/shapiq/explainer/tabular.py
+++ b/shapiq/explainer/tabular.py
@@ -4,18 +4,18 @@
 from typing import Callable, Optional, Union
 
 import numpy as np
-from approximator import (
+
+from shapiq.approximator import (
     PermutationSamplingSII,
     PermutationSamplingSTI,
     RegressionFSI,
     RegressionSII,
     ShapIQ,
 )
-from approximator._base import Approximator
-from interaction_values import InteractionValues
-
-from ._base import Explainer
-from .imputer import MarginalImputer
+from shapiq.approximator._base import Approximator
+from shapiq.explainer._base import Explainer
+from shapiq.explainer.imputer import MarginalImputer
+from shapiq.interaction_values import InteractionValues
 
 __all__ = ["TabularExplainer"]
 
diff --git a/shapiq/explainer/tree/__init__.py b/shapiq/explainer/tree/__init__.py
index 43d65f18..124bef27 100644
--- a/shapiq/explainer/tree/__init__.py
+++ b/shapiq/explainer/tree/__init__.py
@@ -1,4 +1,5 @@
 """This module contains the tree explainer implementation."""
+
 from .base import TreeModel
 from .explainer import TreeExplainer
 from .treeshapiq import TreeSHAPIQ
diff --git a/shapiq/explainer/tree/base.py b/shapiq/explainer/tree/base.py
index 7fac1ca8..d2773162 100644
--- a/shapiq/explainer/tree/base.py
+++ b/shapiq/explainer/tree/base.py
@@ -1,4 +1,5 @@
 """This module contains the base class for tree model conversion."""
+
 from dataclasses import dataclass
 from typing import Any, Optional
 
diff --git a/shapiq/explainer/tree/conversion/edges.py b/shapiq/explainer/tree/conversion/edges.py
index c6bc953f..445be846 100644
--- a/shapiq/explainer/tree/conversion/edges.py
+++ b/shapiq/explainer/tree/conversion/edges.py
@@ -1,6 +1,7 @@
 """This module contains the conversion functions to parse a tree model into the edge representation.
 The edge representation is used by the TreeSHAP-IQ algorithm to compute the interaction values of a
 tree-based model."""
+
 import numpy as np
 from scipy.special import binom
 
diff --git a/shapiq/explainer/tree/conversion/sklearn.py b/shapiq/explainer/tree/conversion/sklearn.py
index 6c488b6e..8d0ece47 100644
--- a/shapiq/explainer/tree/conversion/sklearn.py
+++ b/shapiq/explainer/tree/conversion/sklearn.py
@@ -1,14 +1,15 @@
 """This module contains functions for converting scikit-learn decision trees to the format used by
- shapiq."""
+shapiq."""
 
 from typing import Optional
 
 import numpy as np
-from explainer.tree.base import TreeModel
 
 from shapiq.utils import safe_isinstance
 from shapiq.utils.types import Model
 
+from ..base import TreeModel
+
 
 def convert_sklearn_forest(
     tree_model: Model,
diff --git a/shapiq/explainer/tree/explainer.py b/shapiq/explainer/tree/explainer.py
index 2fb5f8d2..fb25d4fe 100644
--- a/shapiq/explainer/tree/explainer.py
+++ b/shapiq/explainer/tree/explainer.py
@@ -1,11 +1,13 @@
 """This module contains the TreeExplainer class making use of the TreeSHAPIQ algorithm for
 computing any-order Shapley Interactions for tree ensembles."""
+
 import copy
 from typing import Any, Optional, Union
 
 import numpy as np
-from explainer._base import Explainer
-from interaction_values import InteractionValues
+
+from shapiq.explainer._base import Explainer
+from shapiq.interaction_values import InteractionValues
 
 from .treeshapiq import TreeModel, TreeSHAPIQ
 from .validation import validate_tree_model
diff --git a/shapiq/explainer/tree/treeshapiq.py b/shapiq/explainer/tree/treeshapiq.py
index 49fdeb62..7fd6d60a 100644
--- a/shapiq/explainer/tree/treeshapiq.py
+++ b/shapiq/explainer/tree/treeshapiq.py
@@ -1,13 +1,14 @@
 """This module contains the tree explainer implementation."""
+
 import copy
 from math import factorial
 from typing import Any, Optional, Union
 
 import numpy as np
-from approximator import transforms_sii_to_ksii
-from interaction_values import InteractionValues
-from scipy.special import binom
+import scipy as sp
 
+from shapiq.approximator import transforms_sii_to_ksii
+from shapiq.interaction_values import InteractionValues
 from shapiq.utils import generate_interaction_lookup, powerset
 
 from .base import EdgeTree, TreeModel
@@ -139,7 +140,7 @@ def explain(self, x_explain: np.ndarray) -> InteractionValues:
         interactions = np.asarray([], dtype=float)
         for order in range(self._min_order, self._max_order + 1):
             self.shapley_interactions = np.zeros(
-                int(binom(self._n_features_in_tree, order)), dtype=float
+                int(sp.special.binom(self._n_features_in_tree, order)), dtype=float
             )
             self._prepare_variables_for_order(interaction_order=order)
             self._compute_shapley_interaction_values(x_explain_relevant, order=order, node_id=0)
@@ -417,7 +418,7 @@ def _get_polynomials(
             interaction_poly_down = np.zeros(
                 (
                     self._edge_tree.max_depth + 1,
-                    int(binom(self._n_features_in_tree, order)),
+                    int(sp.special.binom(self._n_features_in_tree, order)),
                     self.n_interpolation_size,
                 )
             )
@@ -426,7 +427,7 @@ def _get_polynomials(
             quotient_poly_down = np.zeros(
                 (
                     self._edge_tree.max_depth + 1,
-                    int(binom(self._n_features_in_tree, order)),
+                    int(sp.special.binom(self._n_features_in_tree, order)),
                     self.n_interpolation_size,
                 )
             )
@@ -489,7 +490,9 @@ def _precompute_subsets_with_feature(
 
         # prepare the interaction updates and positions
         for feature_i in range(n_features):
-            positions = np.zeros(int(binom(n_features - 1, interaction_order - 1)), dtype=int)
+            positions = np.zeros(
+                int(sp.special.binom(n_features - 1, interaction_order - 1)), dtype=int
+            )
             interaction_update_positions[feature_i] = positions.copy()
             interaction_updates[feature_i] = []
 
@@ -527,7 +530,7 @@ def _precalculate_interaction_ancestors(
 
         for node_id in self._tree.nodes[1:]:  # for all nodes except the root node
             subset_ancestors[node_id] = np.full(
-                int(binom(n_features, interaction_order)), -1, dtype=int
+                int(sp.special.binom(n_features, interaction_order)), -1, dtype=int
             )
         for S in powerset(range(n_features), interaction_order, interaction_order):
             # self.shapley_interactions_lookup[S] = counter_interaction
@@ -573,7 +576,7 @@ def _get_subset_weight_cii(self, t, order) -> Optional[float]:
         # TODO: add docstring
         if self._interaction_type == "STI":
             return self._max_order / (
-                self._n_features_in_tree * binom(self._n_features_in_tree - 1, t)
+                self._n_features_in_tree * sp.special.binom(self._n_features_in_tree - 1, t)
             )
         if self._interaction_type == "FSI":
             return (
@@ -598,7 +601,7 @@ def _get_N_id(D) -> np.ndarray[float]:
     @staticmethod
     def _get_norm_weight(M) -> np.ndarray[float]:
         # TODO: add docstring and rename variables
-        return np.array([binom(M, i) for i in range(M + 1)])
+        return np.array([sp.special.binom(M, i) for i in range(M + 1)])
 
     @staticmethod
     def _cache(interpolated_poly: np.ndarray[float]) -> np.ndarray[float]:
diff --git a/shapiq/explainer/tree/validation.py b/shapiq/explainer/tree/validation.py
index e12da4f3..a27462ed 100644
--- a/shapiq/explainer/tree/validation.py
+++ b/shapiq/explainer/tree/validation.py
@@ -1,4 +1,5 @@
 """This module contains conversion functions for the tree explainer implementation."""
+
 import warnings
 from typing import Any, Optional, Union
 
diff --git a/shapiq/games/__init__.py b/shapiq/games/__init__.py
index fd2143d8..c89f6a3d 100644
--- a/shapiq/games/__init__.py
+++ b/shapiq/games/__init__.py
@@ -1,6 +1,6 @@
 """This module contains sample game functions for the shapiq package."""
 
-from games.dummy import DummyGame
+from .dummy import DummyGame
 
 __all__ = [
     "DummyGame",
diff --git a/shapiq/interaction_values.py b/shapiq/interaction_values.py
index 3fe257e8..848a89bf 100644
--- a/shapiq/interaction_values.py
+++ b/shapiq/interaction_values.py
@@ -1,12 +1,14 @@
 """This module contains the InteractionValues Dataclass, which is used to store the interaction
 scores."""
+
 import copy
 import warnings
 from dataclasses import dataclass
 from typing import Optional, Union
 
 import numpy as np
-from utils import generate_interaction_lookup, powerset
+
+from shapiq.utils import generate_interaction_lookup, powerset
 
 AVAILABLE_INDICES = {"k-SII", "SII", "STI", "FSI", "SV", "BZF"}
 
diff --git a/shapiq/plot/network.py b/shapiq/plot/network.py
index 17399ed6..2400f0c3 100644
--- a/shapiq/plot/network.py
+++ b/shapiq/plot/network.py
@@ -4,18 +4,17 @@
 import math
 from typing import Any, Optional, Union
 
+import matplotlib.pyplot as plt
 import networkx as nx
 import numpy as np
-from interaction_values import InteractionValues
-from matplotlib import pyplot as plt
 from PIL import Image
-from utils import powerset
+
+from shapiq.interaction_values import InteractionValues
+from shapiq.utils import powerset
 
 from ._config import BLUE, LINES, NEUTRAL, RED
 
-__all__ = [
-    "network_plot",
-]
+__all__ = ["network_plot"]
 
 
 def network_plot(
diff --git a/shapiq/plot/stacked_bar.py b/shapiq/plot/stacked_bar.py
index 785ab15a..3b941412 100644
--- a/shapiq/plot/stacked_bar.py
+++ b/shapiq/plot/stacked_bar.py
@@ -1,16 +1,16 @@
 """This module contains functions to plot the n_sii stacked bar charts."""
 
-__all__ = ["stacked_bar_plot"]
-
 from copy import deepcopy
 from typing import Optional, Union
 
+import matplotlib.pyplot as plt
 import numpy as np
-from matplotlib import pyplot as plt
 from matplotlib.patches import Patch
 
 from ._config import COLORS_N_SII
 
+__all__ = ["stacked_bar_plot"]
+
 
 def stacked_bar_plot(
     feature_names: Union[list, np.ndarray],
diff --git a/shapiq/utils/types.py b/shapiq/utils/types.py
index b7773d05..acb90a0a 100644
--- a/shapiq/utils/types.py
+++ b/shapiq/utils/types.py
@@ -1,4 +1,5 @@
 """This module contains all custom types used in the shapiq package."""
+
 from typing import TypeVar
 
 # Model type for all machine learning models
diff --git a/tests/conftest.py b/tests/conftest.py
index 6e16e374..92ff9161 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -2,11 +2,12 @@
 If it becomes too large, it can be split into multiple files like here:
 https://gist.github.com/peterhurford/09f7dcda0ab04b95c026c60fa49c2a68
 """
+
 import numpy as np
 import pytest
-from sklearn.datasets import make_regression, make_classification
-from sklearn.tree import DecisionTreeRegressor, DecisionTreeClassifier
-from sklearn.ensemble import RandomForestRegressor, RandomForestClassifier
+from sklearn.datasets import make_classification, make_regression
+from sklearn.ensemble import RandomForestClassifier, RandomForestRegressor
+from sklearn.tree import DecisionTreeClassifier, DecisionTreeRegressor
 
 from shapiq.explainer.tree import TreeModel
 
diff --git a/tests/test_abstract_classes.py b/tests/test_abstract_classes.py
index 6f496796..380e1699 100644
--- a/tests/test_abstract_classes.py
+++ b/tests/test_abstract_classes.py
@@ -1,11 +1,12 @@
 """This test module contains all tests regarding the base approximator class."""
+
 import numpy as np
 import pytest
 
-from shapiq.games.base import Game
 from shapiq.approximator._base import Approximator
-from shapiq.explainer.imputer._base import Imputer
 from shapiq.explainer._base import Explainer
+from shapiq.explainer.imputer._base import Imputer
+from shapiq.games.base import Game
 
 
 def concreter(abclass):
diff --git a/tests/test_base_interaction_values.py b/tests/test_base_interaction_values.py
index 1db9a461..a52b9761 100644
--- a/tests/test_base_interaction_values.py
+++ b/tests/test_base_interaction_values.py
@@ -1,4 +1,5 @@
 """This test module contains all tests regarding the InteractionValues dataclass."""
+
 from copy import copy, deepcopy
 
 import numpy as np
diff --git a/tests/test_integration_import_all.py b/tests/test_integration_import_all.py
index 43439074..400a983b 100644
--- a/tests/test_integration_import_all.py
+++ b/tests/test_integration_import_all.py
@@ -4,15 +4,11 @@
 import importlib
 import pkgutil
 import sys
+
 import pytest
 
 import shapiq
-from shapiq import approximator
-from shapiq import explainer
-from shapiq import games
-from shapiq import utils
-from shapiq import plot
-from shapiq import datasets
+from shapiq import approximator, datasets, explainer, games, plot, utils
 
 
 @pytest.mark.parametrize(
diff --git a/tests/tests_approximators/test_approximator_ksii_estimation.py b/tests/tests_approximators/test_approximator_ksii_estimation.py
index e3cf0cd5..9cbe527d 100644
--- a/tests/tests_approximators/test_approximator_ksii_estimation.py
+++ b/tests/tests_approximators/test_approximator_ksii_estimation.py
@@ -1,14 +1,15 @@
 """Tests the approximiation of nSII values with PermutationSamplingSII and ShapIQ."""
+
 import numpy as np
 import pytest
 
-from approximator import (
-    convert_ksii_into_one_dimension,
-    transforms_sii_to_ksii,
+from shapiq.approximator import (
     PermutationSamplingSII,
     ShapIQ,
+    convert_ksii_into_one_dimension,
+    transforms_sii_to_ksii,
 )
-from games import DummyGame
+from shapiq.games import DummyGame
 
 
 @pytest.mark.parametrize(
diff --git a/tests/tests_approximators/test_approximator_permutation_sii.py b/tests/tests_approximators/test_approximator_permutation_sii.py
index 2f0c208c..adc7a2e4 100644
--- a/tests/tests_approximators/test_approximator_permutation_sii.py
+++ b/tests/tests_approximators/test_approximator_permutation_sii.py
@@ -1,12 +1,13 @@
 """This test module contains all tests regarding the SII permutation sampling approximator."""
+
 from copy import copy, deepcopy
 
 import numpy as np
 import pytest
 
-from interaction_values import InteractionValues
-from approximator.permutation import PermutationSamplingSII
-from games import DummyGame
+from shapiq.approximator.permutation import PermutationSamplingSII
+from shapiq.games import DummyGame
+from shapiq.interaction_values import InteractionValues
 
 
 @pytest.mark.parametrize(
diff --git a/tests/tests_approximators/test_approximator_permutation_sti.py b/tests/tests_approximators/test_approximator_permutation_sti.py
index 15a56566..bf6c0905 100644
--- a/tests/tests_approximators/test_approximator_permutation_sti.py
+++ b/tests/tests_approximators/test_approximator_permutation_sti.py
@@ -1,12 +1,13 @@
 """This test module contains all tests regarding the STI permutation sampling approximator."""
+
 from copy import copy, deepcopy
 
 import numpy as np
 import pytest
 
-from interaction_values import InteractionValues
-from approximator.permutation import PermutationSamplingSTI
-from games import DummyGame
+from shapiq.approximator.permutation import PermutationSamplingSTI
+from shapiq.games import DummyGame
+from shapiq.interaction_values import InteractionValues
 
 
 @pytest.mark.parametrize(
diff --git a/tests/tests_approximators/test_approximator_regression_fsi.py b/tests/tests_approximators/test_approximator_regression_fsi.py
index dc0c315b..389db30b 100644
--- a/tests/tests_approximators/test_approximator_regression_fsi.py
+++ b/tests/tests_approximators/test_approximator_regression_fsi.py
@@ -1,12 +1,13 @@
 """This test module contains all tests regarding the FSI regression approximator."""
-from copy import deepcopy, copy
+
+from copy import copy, deepcopy
 
 import numpy as np
 import pytest
 
-from interaction_values import InteractionValues
-from approximator.regression import RegressionFSI
-from games import DummyGame
+from shapiq.approximator.regression import RegressionFSI
+from shapiq.games import DummyGame
+from shapiq.interaction_values import InteractionValues
 
 
 @pytest.mark.parametrize(
diff --git a/tests/tests_approximators/test_approximator_regression_sii.py b/tests/tests_approximators/test_approximator_regression_sii.py
index 41e62c24..b36cee0a 100644
--- a/tests/tests_approximators/test_approximator_regression_sii.py
+++ b/tests/tests_approximators/test_approximator_regression_sii.py
@@ -1,13 +1,14 @@
 """This test module contains all tests regarding the SII regression approximator."""
-from copy import deepcopy, copy
+
+from copy import copy, deepcopy
 
 import numpy as np
 import pytest
 
-from interaction_values import InteractionValues
-from approximator.regression._base import Regression
-from approximator.regression import RegressionSII
-from games import DummyGame
+from shapiq.approximator.regression import RegressionSII
+from shapiq.approximator.regression._base import Regression
+from shapiq.games import DummyGame
+from shapiq.interaction_values import InteractionValues
 
 
 @pytest.mark.parametrize(
diff --git a/tests/tests_approximators/test_approximator_regression_sv.py b/tests/tests_approximators/test_approximator_regression_sv.py
index 99067ad5..c66daeb6 100644
--- a/tests/tests_approximators/test_approximator_regression_sv.py
+++ b/tests/tests_approximators/test_approximator_regression_sv.py
@@ -1,12 +1,13 @@
 """This test module contains all tests regarding the SV KernelSHAP regression approximator."""
-from copy import deepcopy, copy
+
+from copy import copy, deepcopy
 
 import numpy as np
 import pytest
 
-from interaction_values import InteractionValues
-from approximator.regression import KernelSHAP
-from games import DummyGame
+from shapiq.approximator.regression import KernelSHAP
+from shapiq.games import DummyGame
+from shapiq.interaction_values import InteractionValues
 
 
 @pytest.mark.parametrize(
diff --git a/tests/tests_approximators/test_approximator_shapiq.py b/tests/tests_approximators/test_approximator_shapiq.py
index 1503d183..7dccdd90 100644
--- a/tests/tests_approximators/test_approximator_shapiq.py
+++ b/tests/tests_approximators/test_approximator_shapiq.py
@@ -4,9 +4,10 @@
 
 import numpy as np
 import pytest
-from approximator.shapiq import ShapIQ
-from games import DummyGame
-from interaction_values import InteractionValues
+
+from shapiq.approximator.shapiq import ShapIQ
+from shapiq.games import DummyGame
+from shapiq.interaction_values import InteractionValues
 
 
 @pytest.mark.parametrize(
diff --git a/tests/tests_datasets/test_bike.py b/tests/tests_datasets/test_bike.py
index e973f3e6..c76a0a54 100644
--- a/tests/tests_datasets/test_bike.py
+++ b/tests/tests_datasets/test_bike.py
@@ -1,4 +1,5 @@
 """This test module contains the tests for the bike dataset."""
+
 from shapiq import load_bike
 
 
diff --git a/tests/tests_explainer/test_explainer_tabular.py b/tests/tests_explainer/test_explainer_tabular.py
index e3bcc6bc..ad840ec4 100644
--- a/tests/tests_explainer/test_explainer_tabular.py
+++ b/tests/tests_explainer/test_explainer_tabular.py
@@ -1,14 +1,12 @@
-"""This test module contains all tests regarding the interaciton explainer for the shapiq package.
-"""
+"""This test module contains all tests regarding the interaciton explainer for the shapiq package."""
 
 import pytest
-
-from sklearn.tree import DecisionTreeRegressor
-from sklearn.ensemble import RandomForestRegressor
 from sklearn.datasets import make_regression
+from sklearn.ensemble import RandomForestRegressor
+from sklearn.tree import DecisionTreeRegressor
 
-from shapiq.explainer import TabularExplainer
 from shapiq.approximator import RegressionFSI
+from shapiq.explainer import TabularExplainer
 
 
 @pytest.fixture
diff --git a/tests/tests_explainer/tests_imputer/test_marginal_imputer.py b/tests/tests_explainer/tests_imputer/test_marginal_imputer.py
index 0593629d..65a268d0 100644
--- a/tests/tests_explainer/tests_imputer/test_marginal_imputer.py
+++ b/tests/tests_explainer/tests_imputer/test_marginal_imputer.py
@@ -1,4 +1,5 @@
 """This test module contains all tests for the marginal imputer module of the shapiq package."""
+
 import numpy as np
 
 from shapiq.explainer.imputer import MarginalImputer
diff --git a/tests/tests_explainer/tests_tree_explainer/test_tree_explainer.py b/tests/tests_explainer/tests_tree_explainer/test_tree_explainer.py
index 49cd26b8..faef7d20 100644
--- a/tests/tests_explainer/tests_tree_explainer/test_tree_explainer.py
+++ b/tests/tests_explainer/tests_tree_explainer/test_tree_explainer.py
@@ -1,9 +1,9 @@
 """This test module contains all tests for the tree explainer module of the shapiq package."""
+
 import numpy as np
 import pytest
 
-from explainer.tree import TreeModel
-from shapiq.explainer.tree import TreeExplainer
+from shapiq.explainer.tree import TreeExplainer, TreeModel
 
 
 def test_decision_tree_classifier(dt_clf_model, background_clf_data):
diff --git a/tests/tests_explainer/tests_tree_explainer/test_tree_explainer_conversion.py b/tests/tests_explainer/tests_tree_explainer/test_tree_explainer_conversion.py
index 08a009be..a6b31d28 100644
--- a/tests/tests_explainer/tests_tree_explainer/test_tree_explainer_conversion.py
+++ b/tests/tests_explainer/tests_tree_explainer/test_tree_explainer_conversion.py
@@ -1,11 +1,12 @@
 """This test module collects all tests for the conversions of the supported tree models for the
 TreeExplainer class."""
-import numpy as np
 
+import numpy as np
 
-from shapiq.utils import safe_isinstance
 from shapiq.explainer.tree.base import TreeModel
-from shapiq.explainer.tree.conversion.sklearn import convert_sklearn_tree, convert_sklearn_forest
+from shapiq.explainer.tree.conversion.edges import create_edge_tree
+from shapiq.explainer.tree.conversion.sklearn import convert_sklearn_forest, convert_sklearn_tree
+from shapiq.utils import safe_isinstance
 
 
 def test_tree_model_init():
@@ -40,8 +41,6 @@ def test_tree_model_init():
 def test_edge_tree_init():
     """Tests the initialization of the EdgeTree class."""
 
-    from explainer.tree.conversion.edges import create_edge_tree
-
     # setup test data (same as in test_manual_tree of test_tree_treeshapiq.py)
     children_left = np.asarray([1, 2, 3, -1, -1, -1, 7, -1, -1])
     children_right = np.asarray([6, 5, 4, -1, -1, -1, 8, -1, -1])
@@ -79,7 +78,7 @@ def test_edge_tree_init():
         subset_updates_pos_store=interaction_update_positions,
     )
 
-    assert safe_isinstance(edge_tree, ["explainer.tree.base.EdgeTree"])
+    assert safe_isinstance(edge_tree, ["shapiq.explainer.tree.base.EdgeTree"])
 
     # check if edge_tree can be accessed via __getitem__
     assert edge_tree["parents"] is not None
@@ -88,7 +87,7 @@ def test_edge_tree_init():
 def test_sklean_dt_conversion(dt_reg_model, dt_clf_model):
     """Test the conversion of a scikit-learn decision tree model."""
     # test regression model
-    tree_model_class_path_str = ["explainer.tree.base.TreeModel"]
+    tree_model_class_path_str = ["shapiq.explainer.tree.base.TreeModel"]
     tree_model = convert_sklearn_tree(dt_reg_model)
     assert safe_isinstance(tree_model, tree_model_class_path_str)
     assert tree_model.empty_prediction is not None
@@ -111,7 +110,7 @@ def test_sklean_dt_conversion(dt_reg_model, dt_clf_model):
 
 def test_skleanr_rf_conversion(rf_clf_model, rf_reg_model):
     """Test the conversion of a scikit-learn random forest model."""
-    tree_model_class_path_str = ["explainer.tree.base.TreeModel"]
+    tree_model_class_path_str = ["shapiq.explainer.tree.base.TreeModel"]
 
     # test the regression model
     tree_model = convert_sklearn_forest(rf_reg_model)
diff --git a/tests/tests_explainer/tests_tree_explainer/test_tree_explainer_utils.py b/tests/tests_explainer/tests_tree_explainer/test_tree_explainer_utils.py
index c377099b..564478ce 100644
--- a/tests/tests_explainer/tests_tree_explainer/test_tree_explainer_utils.py
+++ b/tests/tests_explainer/tests_tree_explainer/test_tree_explainer_utils.py
@@ -1,4 +1,5 @@
 """This test module collects all tests for the utility functions of the tree explainer."""
+
 import numpy as np
 
 from shapiq.explainer.tree.utils import (
diff --git a/tests/tests_explainer/tests_tree_explainer/test_tree_explainer_validate.py b/tests/tests_explainer/tests_tree_explainer/test_tree_explainer_validate.py
index 2856ffdc..78ddce24 100644
--- a/tests/tests_explainer/tests_tree_explainer/test_tree_explainer_validate.py
+++ b/tests/tests_explainer/tests_tree_explainer/test_tree_explainer_validate.py
@@ -1,9 +1,10 @@
 """This test module contains all tests for the validation functions of the tree explainer
 implementation."""
+
 import copy
 
-import pytest
 import numpy as np
+import pytest
 
 from shapiq import safe_isinstance
 from shapiq.explainer.tree.validation import validate_tree_model
@@ -11,7 +12,7 @@
 
 def test_validate_model(dt_clf_model, dt_reg_model, rf_reg_model, rf_clf_model):
     """Test the validation of the model."""
-    class_path_str = ["explainer.tree.base.TreeModel"]
+    class_path_str = ["shapiq.explainer.tree.base.TreeModel"]
     # sklearn dt models are supported
     tree_model = validate_tree_model(dt_clf_model)
     assert safe_isinstance(tree_model, class_path_str)
@@ -37,7 +38,7 @@ def test_validate_output_types_parameters(dt_clf_model, dt_clf_model_tree_model)
     tested in the next test.
 
     """
-    class_path_str = ["explainer.tree.base.TreeModel"]
+    class_path_str = ["shapiq.explainer.tree.base.TreeModel"]
 
     # test with invalid output type
     with pytest.raises(ValueError):
diff --git a/tests/tests_explainer/tests_tree_explainer/test_tree_treeshapiq.py b/tests/tests_explainer/tests_tree_explainer/test_tree_treeshapiq.py
index 49e971df..e7a65715 100644
--- a/tests/tests_explainer/tests_tree_explainer/test_tree_treeshapiq.py
+++ b/tests/tests_explainer/tests_tree_explainer/test_tree_treeshapiq.py
@@ -1,4 +1,5 @@
 """This module contains all tests for the TreeExplainer class of the shapiq package."""
+
 import numpy as np
 import pytest
 
diff --git a/tests/tests_games/test_base_game.py b/tests/tests_games/test_base_game.py
index f526654a..3eaa9c9d 100644
--- a/tests/tests_games/test_base_game.py
+++ b/tests/tests_games/test_base_game.py
@@ -5,8 +5,6 @@
 import numpy as np
 import pytest
 
-
-from shapiq.games.base import Game
 from shapiq.games.dummy import DummyGame  # used to test the base class
 
 
diff --git a/tests/tests_games/test_games_dummy.py b/tests/tests_games/test_games_dummy.py
index d0f2d630..732c2986 100644
--- a/tests/tests_games/test_games_dummy.py
+++ b/tests/tests_games/test_games_dummy.py
@@ -1,8 +1,9 @@
 """This test module contains the tests for the DummyGame class."""
+
 import numpy as np
 import pytest
 
-from games import DummyGame
+from shapiq.games import DummyGame
 
 
 @pytest.mark.parametrize(
diff --git a/tests/tests_plots/test_network_plot.py b/tests/tests_plots/test_network_plot.py
index 3b70967b..4a9f67c6 100644
--- a/tests/tests_plots/test_network_plot.py
+++ b/tests/tests_plots/test_network_plot.py
@@ -1,12 +1,13 @@
 """This module contains all tests for the network plots."""
-import numpy as np
+
 import matplotlib.pyplot as plt
+import numpy as np
 import pytest
+import scipy as sp
 from PIL import Image
-from scipy.special import binom
 
+from shapiq.interaction_values import InteractionValues
 from shapiq.plot import network_plot
-from interaction_values import InteractionValues
 
 
 def test_network_plot():
@@ -34,7 +35,7 @@ def test_network_plot():
 
     # test with InteractionValues object
     n_players = 5
-    n_values = n_players + int(binom(n_players, 2))
+    n_values = n_players + int(sp.special.binom(n_players, 2))
     iv = InteractionValues(
         values=np.random.rand(n_values),
         index="k-SII",
diff --git a/tests/tests_plots/test_stacked_bar.py b/tests/tests_plots/test_stacked_bar.py
index 640b9fe8..b3815540 100644
--- a/tests/tests_plots/test_stacked_bar.py
+++ b/tests/tests_plots/test_stacked_bar.py
@@ -1,8 +1,7 @@
 """This module contains all tests for the stacked bar plots."""
-import numpy as np
 
 import matplotlib.pyplot as plt
-
+import numpy as np
 
 from shapiq.plot import stacked_bar_plot
 
diff --git a/tests/tests_utils/test_utils_modules.py b/tests/tests_utils/test_utils_modules.py
index 05e7116b..77032bab 100644
--- a/tests/tests_utils/test_utils_modules.py
+++ b/tests/tests_utils/test_utils_modules.py
@@ -1,8 +1,9 @@
 """This test module contains tests for utils.modules."""
+
 import pytest
+from sklearn.tree import DecisionTreeRegressor
 
 from shapiq.utils import safe_isinstance, try_import
-from sklearn.tree import DecisionTreeRegressor
 
 
 def test_safe_isinstance():
diff --git a/tests/tests_utils/test_utils_sets.py b/tests/tests_utils/test_utils_sets.py
index 63cb5757..9a2d095c 100644
--- a/tests/tests_utils/test_utils_sets.py
+++ b/tests/tests_utils/test_utils_sets.py
@@ -1,13 +1,14 @@
 """This test module contains the test cases for the utils sets module."""
+
 import numpy as np
 import pytest
 
 from shapiq.utils import (
-    powerset,
+    generate_interaction_lookup,
+    get_explicit_subsets,
     pair_subset_sizes,
+    powerset,
     split_subsets_budget,
-    get_explicit_subsets,
-    generate_interaction_lookup,
     transform_coalitions_to_array,
 )