diff --git a/examples/complex_model/network/compute.py b/examples/complex_model/network/compute.py
index 0c4c07c..fd9a743 100644
--- a/examples/complex_model/network/compute.py
+++ b/examples/complex_model/network/compute.py
@@ -15,9 +15,13 @@
 sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), "../..")))
 
 import nada_algebra.client as na_client
+
 # Import helper functions for creating nillion client and getting keys
-from nillion_python_helpers import (create_nillion_client, getNodeKeyFromFile,
-                                    getUserKeyFromFile)
+from nillion_python_helpers import (
+    create_nillion_client,
+    getNodeKeyFromFile,
+    getUserKeyFromFile,
+)
 
 # Load environment variables from a .env file
 load_dotenv()
diff --git a/examples/linear_regression/network/compute.py b/examples/linear_regression/network/compute.py
index be9eda8..cb50706 100644
--- a/examples/linear_regression/network/compute.py
+++ b/examples/linear_regression/network/compute.py
@@ -15,9 +15,13 @@
 sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), "../..")))
 
 import nada_algebra.client as na_client
+
 # Import helper functions for creating nillion client and getting keys
-from nillion_python_helpers import (create_nillion_client, getNodeKeyFromFile,
-                                    getUserKeyFromFile)
+from nillion_python_helpers import (
+    create_nillion_client,
+    getNodeKeyFromFile,
+    getUserKeyFromFile,
+)
 
 # Load environment variables from a .env file
 load_dotenv()
diff --git a/examples/multi_layer_perceptron/01_model_provider.ipynb b/examples/multi_layer_perceptron/01_model_provider.ipynb
index 4b703b8..e5cd3ce 100644
--- a/examples/multi_layer_perceptron/01_model_provider.ipynb
+++ b/examples/multi_layer_perceptron/01_model_provider.ipynb
@@ -37,9 +37,19 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 25,
+   "execution_count": 2,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/vscode/.local/lib/python3.12/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
+      "  from .autonotebook import tqdm as notebook_tqdm\n",
+      "Importing plotly failed. Interactive plots will not work.\n"
+     ]
+    }
+   ],
    "source": [
     "import json\n",
     "import os\n",
@@ -50,7 +60,11 @@
     "from torch import nn\n",
     "from torchvision import transforms\n",
     "import py_nillion_client as nillion\n",
-    "from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay, precision_recall_fscore_support\n",
+    "from sklearn.metrics import (\n",
+    "    confusion_matrix,\n",
+    "    ConfusionMatrixDisplay,\n",
+    "    precision_recall_fscore_support,\n",
+    ")\n",
     "import matplotlib.pyplot as plt\n",
     "from PIL import Image\n",
     "import numpy as np\n",
@@ -83,7 +97,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# !kaggle datasets download mehradaria/covid19-lung-ct-scans -p data --unzip"
+    "!kaggle datasets download mehradaria/covid19-lung-ct-scans -p data --unzip"
    ]
   },
   {
@@ -96,8 +110,8 @@
     "    def __init__(self, root_dir: os.PathLike, transform) -> None:\n",
     "        self.root_dir = root_dir\n",
     "        self.transform = transform\n",
-    "    \n",
-    "        self.classes = ['Non-COVID-19', 'COVID-19']\n",
+    "\n",
+    "        self.classes = [\"Non-COVID-19\", \"COVID-19\"]\n",
     "\n",
     "        self.data = []\n",
     "        self.targets = []\n",
@@ -105,7 +119,7 @@
     "        for class_index, class_name in enumerate(self.classes):\n",
     "            class_dir = os.path.join(self.root_dir, class_name)\n",
     "            for filename in os.listdir(class_dir):\n",
-    "                if filename.endswith('.png'):\n",
+    "                if filename.endswith(\".png\"):\n",
     "                    img_path = os.path.join(class_dir, filename)\n",
     "                    self.data.append(img_path)\n",
     "                    self.targets.append(class_index)\n",
@@ -117,7 +131,7 @@
     "        img_path = self.data[index]\n",
     "        label = self.targets[index]\n",
     "\n",
-    "        img = Image.open(img_path).convert('RGB')\n",
+    "        img = Image.open(img_path).convert(\"RGB\")\n",
     "        img = self.transform(img)\n",
     "\n",
     "        return img, label"
@@ -136,11 +150,13 @@
     "    def __init__(self) -> None:\n",
     "        \"\"\"Model is a two layers and an activations\"\"\"\n",
     "        super(MyNN, self).__init__()\n",
-    "        self.conv1 = torch.nn.Conv2d(in_channels=1, out_channels=2, kernel_size=3, stride=4, padding=1)\n",
+    "        self.conv1 = torch.nn.Conv2d(\n",
+    "            in_channels=1, out_channels=2, kernel_size=3, stride=4, padding=1\n",
+    "        )\n",
     "        self.pool = torch.nn.AvgPool2d(kernel_size=2, stride=2)\n",
     "\n",
-    "        self.fc1 = torch.nn.Linear(in_features=8, out_features=2 )\n",
-    "        \n",
+    "        self.fc1 = torch.nn.Linear(in_features=8, out_features=2)\n",
+    "\n",
     "        self.relu = torch.nn.ReLU()\n",
     "        self.flatten = torch.nn.Flatten()\n",
     "\n",
@@ -167,7 +183,7 @@
     "    transform=transforms.Compose(\n",
     "        [\n",
     "            transforms.Grayscale(),\n",
-    "            transforms.Resize((16,16)),\n",
+    "            transforms.Resize((16, 16)),\n",
     "            transforms.ToTensor(),\n",
     "        ]\n",
     "    ),\n",
@@ -190,132 +206,132 @@
      "output_type": "stream",
      "text": [
       "Starting epoch 1...\n",
-      "Loss after mini-batch   100: 0.718\n",
-      "Accuracy after mini-batch   100: 11.250\n",
-      "Loss after mini-batch   200: 0.708\n",
-      "Accuracy after mini-batch   200: 11.312\n",
-      "Loss after mini-batch   300: 0.699\n",
-      "Accuracy after mini-batch   300: 11.000\n",
-      "Loss after mini-batch   400: 0.691\n",
-      "Accuracy after mini-batch   400: 74.875\n",
+      "Loss after mini-batch   100: 0.506\n",
+      "Accuracy after mini-batch   100: 87.312\n",
+      "Loss after mini-batch   200: 0.489\n",
+      "Accuracy after mini-batch   200: 87.812\n",
+      "Loss after mini-batch   300: 0.459\n",
+      "Accuracy after mini-batch   300: 89.875\n",
+      "Loss after mini-batch   400: 0.463\n",
+      "Accuracy after mini-batch   400: 87.688\n",
       "Starting epoch 2...\n",
-      "Loss after mini-batch   100: 0.681\n",
-      "Accuracy after mini-batch   100: 90.375\n",
-      "Loss after mini-batch   200: 0.674\n",
-      "Accuracy after mini-batch   200: 88.688\n",
-      "Loss after mini-batch   300: 0.666\n",
-      "Accuracy after mini-batch   300: 90.062\n",
-      "Loss after mini-batch   400: 0.661\n",
-      "Accuracy after mini-batch   400: 87.562\n",
-      "Starting epoch 3...\n",
-      "Loss after mini-batch   100: 0.651\n",
+      "Loss after mini-batch   100: 0.433\n",
       "Accuracy after mini-batch   100: 88.875\n",
-      "Loss after mini-batch   200: 0.645\n",
-      "Accuracy after mini-batch   200: 88.812\n",
-      "Loss after mini-batch   300: 0.637\n",
-      "Accuracy after mini-batch   300: 89.375\n",
-      "Loss after mini-batch   400: 0.631\n",
-      "Accuracy after mini-batch   400: 89.250\n",
+      "Loss after mini-batch   200: 0.424\n",
+      "Accuracy after mini-batch   200: 88.500\n",
+      "Loss after mini-batch   300: 0.418\n",
+      "Accuracy after mini-batch   300: 87.875\n",
+      "Loss after mini-batch   400: 0.411\n",
+      "Accuracy after mini-batch   400: 87.500\n",
+      "Starting epoch 3...\n",
+      "Loss after mini-batch   100: 0.384\n",
+      "Accuracy after mini-batch   100: 88.938\n",
+      "Loss after mini-batch   200: 0.373\n",
+      "Accuracy after mini-batch   200: 88.938\n",
+      "Loss after mini-batch   300: 0.382\n",
+      "Accuracy after mini-batch   300: 87.875\n",
+      "Loss after mini-batch   400: 0.386\n",
+      "Accuracy after mini-batch   400: 87.250\n",
       "Starting epoch 4...\n",
-      "Loss after mini-batch   100: 0.622\n",
-      "Accuracy after mini-batch   100: 89.562\n",
-      "Loss after mini-batch   200: 0.619\n",
-      "Accuracy after mini-batch   200: 88.000\n",
-      "Loss after mini-batch   300: 0.609\n",
-      "Accuracy after mini-batch   300: 89.750\n",
-      "Loss after mini-batch   400: 0.605\n",
-      "Accuracy after mini-batch   400: 89.000\n",
+      "Loss after mini-batch   100: 0.365\n",
+      "Accuracy after mini-batch   100: 88.250\n",
+      "Loss after mini-batch   200: 0.369\n",
+      "Accuracy after mini-batch   200: 88.188\n",
+      "Loss after mini-batch   300: 0.363\n",
+      "Accuracy after mini-batch   300: 88.250\n",
+      "Loss after mini-batch   400: 0.354\n",
+      "Accuracy after mini-batch   400: 88.375\n",
       "Starting epoch 5...\n",
-      "Loss after mini-batch   100: 0.601\n",
-      "Accuracy after mini-batch   100: 88.062\n",
-      "Loss after mini-batch   200: 0.587\n",
-      "Accuracy after mini-batch   200: 90.688\n",
-      "Loss after mini-batch   300: 0.587\n",
-      "Accuracy after mini-batch   300: 88.688\n",
-      "Loss after mini-batch   400: 0.581\n",
-      "Accuracy after mini-batch   400: 89.125\n",
+      "Loss after mini-batch   100: 0.345\n",
+      "Accuracy after mini-batch   100: 88.875\n",
+      "Loss after mini-batch   200: 0.369\n",
+      "Accuracy after mini-batch   200: 87.625\n",
+      "Loss after mini-batch   300: 0.353\n",
+      "Accuracy after mini-batch   300: 88.625\n",
+      "Loss after mini-batch   400: 0.365\n",
+      "Accuracy after mini-batch   400: 87.688\n",
       "Starting epoch 6...\n",
-      "Loss after mini-batch   100: 0.574\n",
-      "Accuracy after mini-batch   100: 89.188\n",
-      "Loss after mini-batch   200: 0.572\n",
-      "Accuracy after mini-batch   200: 88.312\n",
-      "Loss after mini-batch   300: 0.561\n",
-      "Accuracy after mini-batch   300: 89.750\n",
-      "Loss after mini-batch   400: 0.559\n",
-      "Accuracy after mini-batch   400: 89.000\n",
+      "Loss after mini-batch   100: 0.386\n",
+      "Accuracy after mini-batch   100: 86.312\n",
+      "Loss after mini-batch   200: 0.348\n",
+      "Accuracy after mini-batch   200: 88.812\n",
+      "Loss after mini-batch   300: 0.353\n",
+      "Accuracy after mini-batch   300: 88.375\n",
+      "Loss after mini-batch   400: 0.340\n",
+      "Accuracy after mini-batch   400: 89.125\n",
       "Starting epoch 7...\n",
-      "Loss after mini-batch   100: 0.553\n",
-      "Accuracy after mini-batch   100: 89.000\n",
-      "Loss after mini-batch   200: 0.549\n",
-      "Accuracy after mini-batch   200: 88.750\n",
-      "Loss after mini-batch   300: 0.543\n",
-      "Accuracy after mini-batch   300: 89.000\n",
-      "Loss after mini-batch   400: 0.536\n",
-      "Accuracy after mini-batch   400: 89.375\n",
+      "Loss after mini-batch   100: 0.378\n",
+      "Accuracy after mini-batch   100: 87.125\n",
+      "Loss after mini-batch   200: 0.337\n",
+      "Accuracy after mini-batch   200: 89.375\n",
+      "Loss after mini-batch   300: 0.353\n",
+      "Accuracy after mini-batch   300: 88.000\n",
+      "Loss after mini-batch   400: 0.356\n",
+      "Accuracy after mini-batch   400: 88.188\n",
       "Starting epoch 8...\n",
-      "Loss after mini-batch   100: 0.530\n",
-      "Accuracy after mini-batch   100: 89.562\n",
-      "Loss after mini-batch   200: 0.525\n",
-      "Accuracy after mini-batch   200: 89.500\n",
-      "Loss after mini-batch   300: 0.525\n",
-      "Accuracy after mini-batch   300: 88.688\n",
-      "Loss after mini-batch   400: 0.520\n",
-      "Accuracy after mini-batch   400: 88.750\n",
+      "Loss after mini-batch   100: 0.349\n",
+      "Accuracy after mini-batch   100: 88.312\n",
+      "Loss after mini-batch   200: 0.370\n",
+      "Accuracy after mini-batch   200: 87.375\n",
+      "Loss after mini-batch   300: 0.333\n",
+      "Accuracy after mini-batch   300: 89.312\n",
+      "Loss after mini-batch   400: 0.364\n",
+      "Accuracy after mini-batch   400: 88.062\n",
       "Starting epoch 9...\n",
-      "Loss after mini-batch   100: 0.509\n",
-      "Accuracy after mini-batch   100: 89.812\n",
-      "Loss after mini-batch   200: 0.506\n",
-      "Accuracy after mini-batch   200: 89.625\n",
-      "Loss after mini-batch   300: 0.511\n",
-      "Accuracy after mini-batch   300: 87.875\n",
-      "Loss after mini-batch   400: 0.498\n",
-      "Accuracy after mini-batch   400: 89.000\n",
+      "Loss after mini-batch   100: 0.340\n",
+      "Accuracy after mini-batch   100: 88.875\n",
+      "Loss after mini-batch   200: 0.346\n",
+      "Accuracy after mini-batch   200: 88.875\n",
+      "Loss after mini-batch   300: 0.356\n",
+      "Accuracy after mini-batch   300: 88.062\n",
+      "Loss after mini-batch   400: 0.375\n",
+      "Accuracy after mini-batch   400: 87.250\n",
       "Starting epoch 10...\n",
-      "Loss after mini-batch   100: 0.471\n",
-      "Accuracy after mini-batch   100: 88.500\n",
-      "Loss after mini-batch   200: 0.436\n",
-      "Accuracy after mini-batch   200: 88.125\n",
-      "Loss after mini-batch   300: 0.393\n",
-      "Accuracy after mini-batch   300: 89.438\n",
-      "Loss after mini-batch   400: 0.369\n",
-      "Accuracy after mini-batch   400: 89.688\n"
+      "Loss after mini-batch   100: 0.355\n",
+      "Accuracy after mini-batch   100: 88.250\n",
+      "Loss after mini-batch   200: 0.358\n",
+      "Accuracy after mini-batch   200: 88.062\n",
+      "Loss after mini-batch   300: 0.358\n",
+      "Accuracy after mini-batch   300: 88.000\n",
+      "Loss after mini-batch   400: 0.346\n",
+      "Accuracy after mini-batch   400: 88.625\n"
      ]
     }
    ],
    "source": [
     "accuracies, losses = [], []\n",
     "for epoch in range(10):\n",
-    "  print(f'Starting epoch {epoch+1}...')\n",
+    "    print(f\"Starting epoch {epoch+1}...\")\n",
     "\n",
-    "  incorrect, correct = 0, 0\n",
-    "  current_loss = 0\n",
-    "  for i, data in enumerate(trainloader):\n",
-    "    inputs, targets = data\n",
+    "    incorrect, correct = 0, 0\n",
+    "    current_loss = 0\n",
+    "    for i, data in enumerate(trainloader):\n",
+    "        inputs, targets = data\n",
     "\n",
-    "    optimizer.zero_grad()\n",
+    "        optimizer.zero_grad()\n",
     "\n",
-    "    outputs = my_model(inputs)\n",
-    "    loss = loss_function(outputs, targets)\n",
+    "        outputs = my_model(inputs)\n",
+    "        loss = loss_function(outputs, targets)\n",
     "\n",
-    "    preds = torch.argmax(outputs, axis=1)\n",
+    "        preds = torch.argmax(outputs, axis=1)\n",
     "\n",
-    "    correct += (preds == targets).float().sum()\n",
-    "    incorrect += (preds != targets).float().sum()\n",
+    "        correct += (preds == targets).float().sum()\n",
+    "        incorrect += (preds != targets).float().sum()\n",
     "\n",
-    "    loss.backward()\n",
-    "    optimizer.step()\n",
+    "        loss.backward()\n",
+    "        optimizer.step()\n",
     "\n",
-    "    current_loss += loss.item()\n",
-    "    if i % 100 == 99:\n",
-    "      accuracy = 100 * correct / (incorrect + correct)\n",
-    "      accuracies.append(accuracy)\n",
+    "        current_loss += loss.item()\n",
+    "        if i % 100 == 99:\n",
+    "            accuracy = 100 * correct / (incorrect + correct)\n",
+    "            accuracies.append(accuracy)\n",
     "\n",
-    "      print('Loss after mini-batch %5d: %.3f' % (i + 1, current_loss / 100))\n",
-    "      losses.append(current_loss/100)\n",
-    "      print('Accuracy after mini-batch %5d: %.3f' % (i + 1, accuracy))\n",
+    "            print(\"Loss after mini-batch %5d: %.3f\" % (i + 1, current_loss / 100))\n",
+    "            losses.append(current_loss / 100)\n",
+    "            print(\"Accuracy after mini-batch %5d: %.3f\" % (i + 1, accuracy))\n",
     "\n",
-    "      correct, incorrect = 0, 0\n",
-    "      current_loss = 0"
+    "            correct, incorrect = 0, 0\n",
+    "            current_loss = 0"
    ]
   },
   {
@@ -326,7 +342,7 @@
     {
      "data": {
       "text/plain": [
-       "[<matplotlib.lines.Line2D at 0xffff068ca660>]"
+       "[<matplotlib.lines.Line2D at 0xffff3b3164e0>]"
       ]
      },
      "execution_count": 8,
@@ -335,7 +351,7 @@
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -356,7 +372,7 @@
     {
      "data": {
       "text/plain": [
-       "[<matplotlib.lines.Line2D at 0xffff05d600e0>]"
+       "[<matplotlib.lines.Line2D at 0xffff3b38f830>]"
       ]
      },
      "execution_count": 9,
@@ -365,7 +381,7 @@
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -387,13 +403,13 @@
     "y_pred = []\n",
     "y_true = []\n",
     "for i, data in enumerate(testloader):\n",
-    "  inputs, targets = data\n",
+    "    inputs, targets = data\n",
     "\n",
-    "  outputs = my_model(inputs)\n",
-    "  preds = torch.argmax(outputs, axis=1)\n",
+    "    outputs = my_model(inputs)\n",
+    "    preds = torch.argmax(outputs, axis=1)\n",
     "\n",
-    "  y_pred.extend(preds.tolist())\n",
-    "  y_true.extend(targets.tolist())"
+    "    y_pred.extend(preds.tolist())\n",
+    "    y_true.extend(targets.tolist())"
    ]
   },
   {
@@ -405,10 +421,10 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "precision: 87.848%\n",
+      "precision: 91.286%\n",
       "recall: 100.000%\n",
-      "f1: 93.531%\n",
-      "support: 1482\n"
+      "f1: 95.445%\n",
+      "support: 1540\n"
      ]
     },
     {
@@ -422,9 +438,9 @@
    ],
    "source": [
     "precision, recall, f1, support = precision_recall_fscore_support(y_true, y_pred)\n",
-    "print(\"precision: {:.3f}%\".format(precision[1]*100))\n",
-    "print(\"recall: {:.3f}%\".format(recall[1]*100))\n",
-    "print(\"f1: {:.3f}%\".format(f1[1]*100))\n",
+    "print(\"precision: {:.3f}%\".format(precision[1] * 100))\n",
+    "print(\"recall: {:.3f}%\".format(recall[1] * 100))\n",
+    "print(\"f1: {:.3f}%\".format(f1[1] * 100))\n",
     "print(\"support: {}\".format(support[1]))"
    ]
   },
@@ -436,7 +452,7 @@
     {
      "data": {
       "text/plain": [
-       "<sklearn.metrics._plot.confusion_matrix.ConfusionMatrixDisplay at 0xffff05dc9970>"
+       "<sklearn.metrics._plot.confusion_matrix.ConfusionMatrixDisplay at 0xffff3c01dd30>"
       ]
      },
      "execution_count": 12,
@@ -445,7 +461,7 @@
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 2 Axes>"
       ]
@@ -517,7 +533,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "/tmp/tmpr0ektdn9\n"
+      "/tmp/tmpsl1rnkrg\n"
      ]
     }
    ],
@@ -564,7 +580,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": 16,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -597,7 +613,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": 17,
    "metadata": {},
    "outputs": [
     {
@@ -605,8 +621,8 @@
      "output_type": "stream",
      "text": [
       "✅ Program saved successfully!\n",
-      "action_id: 17da6b3d-16ff-401d-8223-f84001e87065\n",
-      "program_id: NhjEBNWqnAVfYvsp4atCjstZPtSKnjx1nQF9Z95zw8vocEztByKoGZbyhY4Fs6F38RWJuLgFniQkzZTqN4vimXr/main\n"
+      "action_id: 880b4727-3763-4435-90ce-d5a66c5693f4\n",
+      "program_id: 5GnDBJ4brQtS7U3YsUdweoKUfbN7t9CNDaZ7AnVLarwWcRNfQUwr1Ct2aTQsMhhvjb1xeYPfiKAahMz7i5D85ZUd/main\n"
      ]
     }
    ],
@@ -635,7 +651,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 26,
+   "execution_count": 18,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -645,7 +661,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 30,
+   "execution_count": 19,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -674,12 +690,11 @@
     "    Returns:\n",
     "        Dict[str, str]: Resulting `provider_party_id` and `model_store_id`.\n",
     "    \"\"\"\n",
-    "    \n",
+    "\n",
     "    model_secrets = nillion.Secrets(\n",
     "        model_client.export_state_as_secrets(\"my_nn\", na.SecretRational)\n",
     "    )\n",
     "\n",
-    "\n",
     "    secret_bindings = nillion.ProgramBindings(program_id)\n",
     "    secret_bindings.add_input_party(\"Party0\", party_id)\n",
     "\n",
@@ -702,7 +717,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 31,
+   "execution_count": 20,
    "metadata": {},
    "outputs": [
     {
@@ -710,8 +725,8 @@
      "output_type": "stream",
      "text": [
       "✅ Model params uploaded successfully!\n",
-      "provider_party_id: 12D3KooWGzPps56nqg5VxtsKjfiGMBR4gPoPybjKJ5fjoNZgNqgQ\n",
-      "model_store_id: a301b88a-5bf5-43fc-b2cd-3ce3c63bab2c\n"
+      "provider_party_id: 12D3KooWQLbKxRFoa3rcA8do1R2o96yhgxGnJS5RbTr3ZJwQiQay\n",
+      "model_store_id: d6002305-15f9-4e76-b5aa-510560f89e75\n"
      ]
     }
    ],
@@ -736,12 +751,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 32,
+   "execution_count": 21,
    "metadata": {},
    "outputs": [],
    "source": [
     "# This information is needed by the model user\n",
-    "with open(\"tmp.json\", \"w\") as provider_variables_file:\n",
+    "with open(\"data/tmp.json\", \"w\") as provider_variables_file:\n",
     "    provider_variables = {\n",
     "        \"program_id\": program_id,\n",
     "        \"model_store_id\": model_store_id,\n",
@@ -752,7 +767,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 33,
+   "execution_count": 22,
    "metadata": {},
    "outputs": [],
    "source": [
diff --git a/examples/multi_layer_perceptron/02_model_inference.ipynb b/examples/multi_layer_perceptron/02_model_inference.ipynb
index 59acf1d..f9f5e38 100644
--- a/examples/multi_layer_perceptron/02_model_inference.ipynb
+++ b/examples/multi_layer_perceptron/02_model_inference.ipynb
@@ -30,7 +30,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -74,7 +74,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 3,
    "metadata": {},
    "outputs": [
     {
@@ -83,7 +83,7 @@
        "True"
       ]
      },
-     "execution_count": 5,
+     "execution_count": 3,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -98,7 +98,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 4,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -112,24 +112,24 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 5,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Program ID:  NhjEBNWqnAVfYvsp4atCjstZPtSKnjx1nQF9Z95zw8vocEztByKoGZbyhY4Fs6F38RWJuLgFniQkzZTqN4vimXr/main\n",
-      "Model Store ID:  a301b88a-5bf5-43fc-b2cd-3ce3c63bab2c\n",
-      "Model Provider Party ID:  12D3KooWGzPps56nqg5VxtsKjfiGMBR4gPoPybjKJ5fjoNZgNqgQ\n"
+      "Program ID:  5GnDBJ4brQtS7U3YsUdweoKUfbN7t9CNDaZ7AnVLarwWcRNfQUwr1Ct2aTQsMhhvjb1xeYPfiKAahMz7i5D85ZUd/main\n",
+      "Model Store ID:  d6002305-15f9-4e76-b5aa-510560f89e75\n",
+      "Model Provider Party ID:  12D3KooWQLbKxRFoa3rcA8do1R2o96yhgxGnJS5RbTr3ZJwQiQay\n"
      ]
     }
    ],
    "source": [
     "# This information was provided by the model provider\n",
-    "with open(\"tmp.json\", \"r\") as provider_variables_file:\n",
+    "with open(\"data/tmp.json\", \"r\") as provider_variables_file:\n",
     "    provider_variables = json.load(provider_variables_file)\n",
-    "    \n",
+    "\n",
     "program_id = provider_variables[\"program_id\"]\n",
     "model_store_id = provider_variables[\"model_store_id\"]\n",
     "model_provider_party_id = provider_variables[\"model_provider_party_id\"]\n",
@@ -155,14 +155,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 6,
    "metadata": {},
    "outputs": [],
    "source": [
     "test_image = transforms.Compose(\n",
     "    [\n",
     "        transforms.Grayscale(),\n",
-    "        transforms.Resize((16,16)),\n",
+    "        transforms.Resize((16, 16)),\n",
     "        transforms.ToTensor(),\n",
     "    ]\n",
     ")(Image.open(\"data/COVID-19_Lung_CT_Scans/COVID-19/COVID-19_0001.png\"))"
@@ -170,7 +170,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": 7,
    "metadata": {},
    "outputs": [
     {
@@ -179,7 +179,7 @@
        "(1, 1, 16, 16)"
       ]
      },
-     "execution_count": 14,
+     "execution_count": 7,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -198,7 +198,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 23,
+   "execution_count": 8,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -225,7 +225,9 @@
     "    Returns:\n",
     "        Dict[str, str]: Resulting `model_user_party_id` and `images_store_id`.\n",
     "    \"\"\"\n",
-    "    secrets = nillion.Secrets(na_client.array(images, \"my_input\", nada_type=na.SecretRational))\n",
+    "    secrets = nillion.Secrets(\n",
+    "        na_client.array(images, \"my_input\", nada_type=na.SecretRational)\n",
+    "    )\n",
     "\n",
     "    secret_bindings = nillion.ProgramBindings(program_id)\n",
     "    secret_bindings.add_input_party(\"Party1\", party_id)\n",
@@ -242,7 +244,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 24,
+   "execution_count": 9,
    "metadata": {},
    "outputs": [
     {
@@ -250,8 +252,8 @@
      "output_type": "stream",
      "text": [
       "✅ Images uploaded successfully!\n",
-      "model_user_user_id: 37Qew8NyqKYEjVCeDNMohPKKj4VSMxZMxRCYV6Snm8wvs1nJxRkynyUKMrXVk8Vkz2eoKpz8BaA58nGdA1SLyJAq\n",
-      "images_store_id: 00ecd070-3878-4bfa-a4b8-92b11975221a\n"
+      "model_user_user_id: unDxCapdG2Dp7w2FwajbBWEF6wrinZp1ArKPvqeMxGt32WbkoXcZGQcSJHwDUMvKr4AG6zQnW4GGDaBcCFqtsu3\n",
+      "images_store_id: 3465b7fe-062e-4528-9fc3-e20bdff86008\n"
      ]
     }
    ],
@@ -282,7 +284,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 31,
+   "execution_count": 10,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -332,25 +334,25 @@
     "\n",
     "    return {\n",
     "        \"compute_id\": compute_event.uuid,\n",
-    "        \"output_0\": inference_result[\"my_output_0_0\"]  / (2 ** na.get_log_scale()),\n",
-    "        \"output_1\": inference_result[\"my_output_0_1\"]  / (2 ** na.get_log_scale()),\n",
+    "        \"output_0\": inference_result[\"my_output_0_0\"] / (2 ** na.get_log_scale()),\n",
+    "        \"output_1\": inference_result[\"my_output_0_1\"] / (2 ** na.get_log_scale()),\n",
     "    }"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 32,
+   "execution_count": 11,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "{'compute_id': 'e814f72b-55e8-49dd-b68c-4060516357f3',\n",
-       " 'output_0': -1.10308837890625,\n",
-       " 'output_1': 0.5345001220703125}"
+       "{'compute_id': '42b1bcc4-fa08-4260-aa2e-213fb9702f10',\n",
+       " 'output_0': -1.40350341796875,\n",
+       " 'output_1': 0.935302734375}"
       ]
      },
-     "execution_count": 32,
+     "execution_count": 11,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -377,7 +379,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 33,
+   "execution_count": 12,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -388,11 +390,13 @@
     "    def __init__(self) -> None:\n",
     "        \"\"\"Model is a two layers and an activations\"\"\"\n",
     "        super(MyNN, self).__init__()\n",
-    "        self.conv1 = torch.nn.Conv2d(in_channels=1, out_channels=2, kernel_size=3, stride=4, padding=1)\n",
+    "        self.conv1 = torch.nn.Conv2d(\n",
+    "            in_channels=1, out_channels=2, kernel_size=3, stride=4, padding=1\n",
+    "        )\n",
     "        self.pool = torch.nn.AvgPool2d(kernel_size=2, stride=2)\n",
     "\n",
-    "        self.fc1 = torch.nn.Linear(in_features=8, out_features=2 )\n",
-    "        \n",
+    "        self.fc1 = torch.nn.Linear(in_features=8, out_features=2)\n",
+    "\n",
     "        self.relu = torch.nn.ReLU()\n",
     "        self.flatten = torch.nn.Flatten()\n",
     "\n",
@@ -407,7 +411,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 35,
+   "execution_count": 13,
    "metadata": {},
    "outputs": [
     {
@@ -416,7 +420,7 @@
        "<All keys matched successfully>"
       ]
      },
-     "execution_count": 35,
+     "execution_count": 13,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -428,16 +432,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 42,
+   "execution_count": 14,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "tensor([0.1628, 0.8372], grad_fn=<SoftmaxBackward0>)"
+       "tensor([0.0880, 0.9120], grad_fn=<SoftmaxBackward0>)"
       ]
      },
-     "execution_count": 42,
+     "execution_count": 14,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -448,22 +452,24 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 43,
+   "execution_count": 15,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "tensor([0.1628, 0.8372])"
+       "tensor([0.0880, 0.9120])"
       ]
      },
-     "execution_count": 43,
+     "execution_count": 15,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "torch.softmax(torch.Tensor([result_inference[\"output_0\"], result_inference[\"output_1\"]]), dim=0)"
+    "torch.softmax(\n",
+    "    torch.Tensor([result_inference[\"output_0\"], result_inference[\"output_1\"]]), dim=0\n",
+    ")"
    ]
   }
  ],
diff --git a/examples/multi_layer_perceptron/helpers.py b/examples/multi_layer_perceptron/helpers.py
deleted file mode 100644
index b7f714a..0000000
--- a/examples/multi_layer_perceptron/helpers.py
+++ /dev/null
@@ -1,74 +0,0 @@
-"""Helper functions and classes"""
-
-from typing import Dict
-import torch
-import py_nillion_client as nillion
-
-from torch import nn
-
-
-class MyModel(nn.Module):
-    """Fully customizable model"""
-
-    def __init__(self, model_name: str) -> None:
-        """Initialization
-
-        Args:
-            model_name (str): Model name to be used as prefix for secret names.
-        """
-        super().__init__()
-        self.model_name = model_name
-        self.conv1 = nn.Conv2d(in_channels=1, out_channels=2, kernel_size=3, padding=1, stride=4)
-        self.pool = nn.AvgPool2d(kernel_size=2, stride=2)
-        self.fc1 = nn.Linear(8, 2)
-        self.relu = nn.ReLU()
-        self.flatten = nn.Flatten()
-
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
-        """Forward pass.
-
-        Args:
-            x (torch.Tensor): Input array.
-
-        Returns:
-            torch.Tensor: Output array.
-        """
-        x = self.relu(self.conv1(x))
-        x = self.pool(x)
-        x = self.flatten(x)
-        x = self.fc1(x)
-        return x
-
-    def export_weights_as_secrets(self, precision: int) -> Dict:
-        """Exports all current model weights as quantized Nillion secrets.
-
-        Args:
-            precision (int): Desired precision for quantization.
-
-        Raises:
-            ValueError: Raised when unexpected layer is encountered
-
-        Returns:
-            Dict: Model weight secrets.
-        """
-        weight_secrets = {}
-        def return_data(result: dict, name: str, array: torch.Tensor):
-            if len(array.shape) == 1:
-                result.update(
-                    {
-                        f"{name}_{i}": nillion.SecretInteger(round(value.item() * precision))
-                        if round(value.item() * precision) != 0
-                        else nillion.SecretInteger(round(value.item() * precision)+1)
-                        for i, value in enumerate(array)
-                    }
-                )
-                return
-            [return_data(result, f"{name}_{i}", array[i]) for i in range(array.shape[0])]
-            return result
-
-        for weight_name, weight_tensor in self.state_dict().items():
-            result = {}
-            return_data(result, f"{self.model_name}_{weight_name}", weight_tensor)
-            weight_secrets.update(result)
-
-        return weight_secrets
diff --git a/examples/multi_layer_perceptron/src/my_nn.py b/examples/multi_layer_perceptron/src/my_nn.py
index be277f6..4e9b730 100644
--- a/examples/multi_layer_perceptron/src/my_nn.py
+++ b/examples/multi_layer_perceptron/src/my_nn.py
@@ -1,4 +1,5 @@
 import nada_algebra as na
+
 from nada_ai import nn
 
 
@@ -8,7 +9,9 @@ class MyNN(nn.Module):
     def __init__(self) -> None:
         """Model is a two layers and an activations"""
         # Input size (1, 1, 16, 16) --> Output size (1, 2)
-        self.conv1 = nn.Conv2d(in_channels=1, out_channels=2, kernel_size=3, padding=1, stride=4)
+        self.conv1 = nn.Conv2d(
+            in_channels=1, out_channels=2, kernel_size=3, padding=1, stride=4
+        )
         # Input size (1, 2) --> Output size (1, 2)
         self.pool = nn.AvgPool2d(kernel_size=2, stride=2)
         self.fc1 = nn.Linear(in_features=8, out_features=2)
@@ -16,7 +19,6 @@ def __init__(self) -> None:
         self.relu = nn.ReLU()
         self.flatten = nn.Flatten()
 
-
     def forward(self, x: na.NadaArray) -> na.NadaArray:
         """My forward pass logic"""
         x = self.relu(self.conv1(x))
diff --git a/examples/multi_layer_perceptron/tmp.json b/examples/multi_layer_perceptron/tmp.json
deleted file mode 100644
index fe56b96..0000000
--- a/examples/multi_layer_perceptron/tmp.json
+++ /dev/null
@@ -1 +0,0 @@
-{"program_id": "NhjEBNWqnAVfYvsp4atCjstZPtSKnjx1nQF9Z95zw8vocEztByKoGZbyhY4Fs6F38RWJuLgFniQkzZTqN4vimXr/main", "model_store_id": "a301b88a-5bf5-43fc-b2cd-3ce3c63bab2c", "model_provider_party_id": "12D3KooWGzPps56nqg5VxtsKjfiGMBR4gPoPybjKJ5fjoNZgNqgQ"}
\ No newline at end of file
diff --git a/examples/neural_net/network/compute.py b/examples/neural_net/network/compute.py
index f4997d8..7353e11 100644
--- a/examples/neural_net/network/compute.py
+++ b/examples/neural_net/network/compute.py
@@ -15,9 +15,13 @@
 sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), "../..")))
 
 import nada_algebra.client as na_client
+
 # Import helper functions for creating nillion client and getting keys
-from nillion_python_helpers import (create_nillion_client, getNodeKeyFromFile,
-                                    getUserKeyFromFile)
+from nillion_python_helpers import (
+    create_nillion_client,
+    getNodeKeyFromFile,
+    getUserKeyFromFile,
+)
 
 # Load environment variables from a .env file
 load_dotenv()
diff --git a/examples/time_series/network/compute.py b/examples/time_series/network/compute.py
index 6f0febd..4606547 100644
--- a/examples/time_series/network/compute.py
+++ b/examples/time_series/network/compute.py
@@ -16,9 +16,13 @@
 sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), "../..")))
 
 import nada_algebra.client as na_client
+
 # Import helper functions for creating nillion client and getting keys
-from nillion_python_helpers import (create_nillion_client, getNodeKeyFromFile,
-                                    getUserKeyFromFile)
+from nillion_python_helpers import (
+    create_nillion_client,
+    getNodeKeyFromFile,
+    getUserKeyFromFile,
+)
 
 # Load environment variables from a .env file
 load_dotenv()
diff --git a/nada_ai/nada_typing.py b/nada_ai/nada_typing.py
index f3133b3..e389f37 100644
--- a/nada_ai/nada_typing.py
+++ b/nada_ai/nada_typing.py
@@ -4,12 +4,19 @@
 
 import nada_algebra as na
 import nada_dsl as dsl
+
 # pylint:disable=no-name-in-module
-from py_nillion_client import (PublicVariableInteger,
-                               PublicVariableUnsignedInteger, SecretInteger,
-                               SecretUnsignedInteger)
-from sklearn.linear_model import (LinearRegression, LogisticRegression,
-                                  LogisticRegressionCV)
+from py_nillion_client import (
+    PublicVariableInteger,
+    PublicVariableUnsignedInteger,
+    SecretInteger,
+    SecretUnsignedInteger,
+)
+from sklearn.linear_model import (
+    LinearRegression,
+    LogisticRegression,
+    LogisticRegressionCV,
+)
 
 __all__ = ["NillionType", "LinearModel", "ShapeLike", "NadaInteger"]
 
diff --git a/nada_ai/nn/modules/relu.py b/nada_ai/nn/modules/relu.py
index ddd634d..b4e1f27 100644
--- a/nada_ai/nn/modules/relu.py
+++ b/nada_ai/nn/modules/relu.py
@@ -3,8 +3,14 @@
 from typing import Union
 
 import nada_algebra as na
-from nada_dsl import (Integer, NadaType, PublicBoolean, PublicInteger,
-                      SecretBoolean, SecretInteger)
+from nada_dsl import (
+    Integer,
+    NadaType,
+    PublicBoolean,
+    PublicInteger,
+    SecretBoolean,
+    SecretInteger,
+)
 
 from nada_ai.nn.module import Module
 
diff --git a/tests/python-tests/test_model_client.py b/tests/python-tests/test_model_client.py
index 4621c5c..73d6563 100644
--- a/tests/python-tests/test_model_client.py
+++ b/tests/python-tests/test_model_client.py
@@ -10,8 +10,7 @@
 from sklearn.linear_model import LinearRegression, LogisticRegression
 from torch import nn
 
-from nada_ai.client import (ModelClient, ProphetClient, SklearnClient,
-                            TorchClient)
+from nada_ai.client import ModelClient, ProphetClient, SklearnClient, TorchClient
 
 
 class TestModelClient: