diff --git a/.circleci/config.yml b/.circleci/config.yml
deleted file mode 100644
index a841c1584..000000000
--- a/.circleci/config.yml
+++ /dev/null
@@ -1,81 +0,0 @@
-version: 2.1
-
-orbs:
-  python: circleci/python@1.4.0
-
-jobs:
-  linting:
-    executor: python/default
-    steps:
-      - checkout
-      - restore_cache:
-          key: deps1-{{ .Branch }}-{{ checksum "requirements.txt" }}
-      - run:
-          command: |
-            sudo apt update && sudo apt install libcurl4-openssl-dev
-          name: Install curl-config from Ubuntu APT
-      - run:
-          command: |
-            python3 install.py --aws --azure --gcp --no-local
-          name: Install pip dependencies
-      - run:
-          command: |
-            . python-venv/bin/activate
-            black sebs --check --config .black.toml
-          name: Python code formatting with black
-      - run:
-          command: |
-            . python-venv/bin/activate
-            flake8 sebs --config=.flake8.cfg --tee --output-file flake-reports
-          name: Python code lint with flake8
-      - run:
-          command: |
-            . python-venv/bin/activate
-            mypy sebs --config-file=.mypy.ini
-          name: Python static code verification with mypy
-      - store_artifacts:
-          path: flake-reports
-          destination: flake-reports
-  test-aws:
-    executor: python/default
-    steps:
-      - checkout
-      - setup_remote_docker
-      - restore_cache:
-          key: deps1-{{ .Branch }}-{{ checksum "requirements.txt" }}
-      - run:
-          command: |
-            if [[ -d $HOME/docker ]];
-            then
-              ls $HOME/docker/*.tar.gz | xargs -I {file} sh -c "zcat {file} | docker load";
-            else
-              docker pull mcopik/serverless-benchmarks:build.aws.python.3.7
-              docker pull mcopik/serverless-benchmarks:build.aws.nodejs.12.x
-            fi
-          name: Load Docker images
-      - run:
-          command: |
-            python3 install.py --aws
-          name: Install pip dependencies
-      - run:
-          command: |
-            mkdir -p $HOME/docker
-            docker images mcopik/serverless-benchmarks --filter='dangling=false' --format '{{.Repository}}:{{.Tag}} {{.ID}}' |\
-            xargs -n 2 -t sh -c 'test -e $HOME/docker/$1.tar.gz || docker save $0 | gzip -2 > $HOME/docker/$1.tar.gz'
-          name: Save Docker images
-      - save_cache:
-          key: deps1-{{ .Branch }}-{{ checksum "requirements.txt" }}
-          paths:
-            - "sebs-virtualenv"
-            - $HOME/docker
-      - run:
-          command: |
-            . sebs-virtualenv/bin/activate
-            tests/test_runner.py --deployment aws
-          name: Execute AWS tests
-
-workflows:
-  main:
-    jobs:
-      - linting
-
diff --git a/.github/workflows/lint.yml b/.github/workflows/lint.yml
new file mode 100644
index 000000000..1043be62e
--- /dev/null
+++ b/.github/workflows/lint.yml
@@ -0,0 +1,55 @@
+name: Lint
+
+on:
+  push:
+  pull_request:
+
+jobs:
+  linting:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Check out code
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        id: setup-python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.x'
+
+      - name: Cache virtualenv
+        uses: actions/cache@v4
+        with:
+          path: python-venv
+          key: venv-${{ runner.os }}-${{ steps.setup-python.outputs.python-version }}-${{ hashFiles('requirements.txt') }}-${{ github.ref_name }}
+          restore-keys: |
+            venv-${{ runner.os }}-${{ steps.setup-python.outputs.python-version }}-${{ hashFiles('requirements.txt') }}-
+            venv-${{ runner.os }}-${{ steps.setup-python.outputs.python-version }}-
+
+      - name: Install system packages
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y libcurl4-openssl-dev
+
+      - name: Install Python dependencies (via install.py)
+        run: |
+          python3 install.py --no-aws --no-azure --no-gcp --no-openwhisk --no-local
+
+      - name: Black (check)
+        run: |
+          . python-venv/bin/activate
+          black benchmarks --check --config .black.toml
+
+      - name: Flake8 (lint)
+        run: |
+          . python-venv/bin/activate
+          # write to file and echo to stdout (requires flake8 with --tee support)
+          flake8 benchmarks --config=.flake8.cfg --tee --output-file flake-reports
+
+      - name: Upload flake report
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: flake-reports
+          path: flake-reports
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 22e59d275..58f8adb8d 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -9,7 +9,7 @@ repos:
         entry: flake8
         args: ["--config=.flake8.cfg"]
         types: [python]
-        files: ^sebs/
+        files: ^(sebs/|benchmarks/)
   - repo: local
     hooks:
       - id: black-check-local
@@ -19,5 +19,12 @@ repos:
         entry: black
         args: ["--config=.black.toml", "--check", "--diff"]
         types: [python]
-        files: ^sebs/
+        files: ^(sebs/|benchmarks/)
+  # - repo: local
+  #   hooks:
+  #     - id: mypy-local
+  #       name: mypy (project venv)
+  #       language: system
+  #       entry: bash -lc 'python -m mypy --config-file=.mypy.ini sebs'
+  #       types: [python]
 
diff --git a/benchmarks/000.microbenchmarks/010.sleep/input.py b/benchmarks/000.microbenchmarks/010.sleep/input.py
index 041d2ba7f..af0427a6c 100644
--- a/benchmarks/000.microbenchmarks/010.sleep/input.py
+++ b/benchmarks/000.microbenchmarks/010.sleep/input.py
@@ -1,12 +1,11 @@
+size_generators = {"test": 1, "small": 100, "large": 1000}
 
-size_generators = {
-    'test' : 1,
-    'small' : 100,
-    'large': 1000
-}
 
 def buckets_count():
     return (0, 0)
 
-def generate_input(data_dir, size, benchmarks_bucket, input_paths, output_paths, upload_func, nosql_func):
-    return { 'sleep': size_generators[size] }
+
+def generate_input(
+    data_dir, size, benchmarks_bucket, input_paths, output_paths, upload_func, nosql_func
+):
+    return {"sleep": size_generators[size]}
diff --git a/benchmarks/000.microbenchmarks/010.sleep/python/function.py b/benchmarks/000.microbenchmarks/010.sleep/python/function.py
index 7dda59a57..64be15557 100644
--- a/benchmarks/000.microbenchmarks/010.sleep/python/function.py
+++ b/benchmarks/000.microbenchmarks/010.sleep/python/function.py
@@ -1,9 +1,9 @@
-
 from time import sleep
 
+
 def handler(event):
 
     # start timing
-    sleep_time = event.get('sleep')
+    sleep_time = event.get("sleep")
     sleep(sleep_time)
-    return { 'result': sleep_time }
+    return {"result": sleep_time}
diff --git a/benchmarks/000.microbenchmarks/020.network-benchmark/input.py b/benchmarks/000.microbenchmarks/020.network-benchmark/input.py
index 0d969bc74..8f43ffc5a 100644
--- a/benchmarks/000.microbenchmarks/020.network-benchmark/input.py
+++ b/benchmarks/000.microbenchmarks/020.network-benchmark/input.py
@@ -2,10 +2,12 @@ def buckets_count():
     return 0, 1
 
 
-def generate_input(data_dir, size, benchmarks_bucket, input_paths, output_paths, upload_func, nosql_func):
+def generate_input(
+    data_dir, size, benchmarks_bucket, input_paths, output_paths, upload_func, nosql_func
+):
     return {
-        'bucket': {
-            'bucket': benchmarks_bucket,
-            'output': output_paths[0],
+        "bucket": {
+            "bucket": benchmarks_bucket,
+            "output": output_paths[0],
         },
     }
diff --git a/benchmarks/000.microbenchmarks/020.network-benchmark/python/function.py b/benchmarks/000.microbenchmarks/020.network-benchmark/python/function.py
index eb8ccdcf2..58c376a2d 100644
--- a/benchmarks/000.microbenchmarks/020.network-benchmark/python/function.py
+++ b/benchmarks/000.microbenchmarks/020.network-benchmark/python/function.py
@@ -1,27 +1,26 @@
 import csv
-import json
 import os.path
 import socket
 from datetime import datetime
-from time import sleep
 
 from . import storage
 
+
 def handler(event):
 
-    request_id = event['request-id']
-    address = event['server-address']
-    port = event['server-port']
-    repetitions = event['repetitions']
-    output_bucket = event.get('bucket').get('bucket')
-    output_prefix = event.get('bucket').get('output')
+    request_id = event["request-id"]
+    address = event["server-address"]
+    port = event["server-port"]
+    repetitions = event["repetitions"]
+    output_bucket = event.get("bucket").get("bucket")
+    output_prefix = event.get("bucket").get("output")
     times = []
     i = 0
     socket.setdefaulttimeout(3)
     server_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
     server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
-    server_socket.bind(('', 0))
-    message = request_id.encode('utf-8')
+    server_socket.bind(("", 0))
+    message = request_id.encode("utf-8")
     adr = (address, port)
     consecutive_failures = 0
     while i < repetitions + 1:
@@ -43,16 +42,16 @@ def handler(event):
         consecutive_failures = 0
         server_socket.settimeout(2)
     server_socket.close()
-   
+
     if consecutive_failures != 5:
-        with open('/tmp/data.csv', 'w', newline='') as csvfile:
-            writer = csv.writer(csvfile, delimiter=',')
-            writer.writerow(["id", "client_send", "client_rcv"]) 
+        with open("/tmp/data.csv", "w", newline="") as csvfile:
+            writer = csv.writer(csvfile, delimiter=",")
+            writer.writerow(["id", "client_send", "client_rcv"])
             for row in times:
                 writer.writerow(row)
-      
+
         client = storage.storage.get_instance()
-        filename = 'results-{}.csv'.format(request_id)
-        key = client.upload(output_bucket, os.path.join(output_prefix, filename), '/tmp/data.csv')
+        filename = "results-{}.csv".format(request_id)
+        key = client.upload(output_bucket, os.path.join(output_prefix, filename), "/tmp/data.csv")
 
-    return { 'result': key }
+    return {"result": key}
diff --git a/benchmarks/000.microbenchmarks/030.clock-synchronization/input.py b/benchmarks/000.microbenchmarks/030.clock-synchronization/input.py
index 427215380..8f43ffc5a 100644
--- a/benchmarks/000.microbenchmarks/030.clock-synchronization/input.py
+++ b/benchmarks/000.microbenchmarks/030.clock-synchronization/input.py
@@ -1,12 +1,13 @@
-
-
 def buckets_count():
     return 0, 1
 
-def generate_input(data_dir, size, benchmarks_bucket, input_paths, output_paths, upload_func, nosql_func):
+
+def generate_input(
+    data_dir, size, benchmarks_bucket, input_paths, output_paths, upload_func, nosql_func
+):
     return {
-        'bucket': {
-            'bucket': benchmarks_bucket,
-            'output': output_paths[0],
+        "bucket": {
+            "bucket": benchmarks_bucket,
+            "output": output_paths[0],
         },
     }
diff --git a/benchmarks/000.microbenchmarks/030.clock-synchronization/python/function.py b/benchmarks/000.microbenchmarks/030.clock-synchronization/python/function.py
index 9ffd978ae..9cf93eccf 100644
--- a/benchmarks/000.microbenchmarks/030.clock-synchronization/python/function.py
+++ b/benchmarks/000.microbenchmarks/030.clock-synchronization/python/function.py
@@ -1,28 +1,27 @@
 import csv
-import json
 import os
 import socket
 from datetime import datetime
-from time import sleep
 
 from . import storage
 
+
 def handler(event):
 
-    request_id = event['request-id']
-    address = event['server-address']
-    port = event['server-port']
-    repetitions = event['repetitions']
-    output_bucket = event.get('bucket').get('bucket')
-    output_prefix = event.get('bucket').get('output')
+    request_id = event["request-id"]
+    address = event["server-address"]
+    port = event["server-port"]
+    repetitions = event["repetitions"]
+    output_bucket = event.get("bucket").get("bucket")
+    output_prefix = event.get("bucket").get("output")
     times = []
     print("Starting communication with {}:{}".format(address, port))
     i = 0
     socket.setdefaulttimeout(4)
     server_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
     server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
-    server_socket.bind(('', 0))
-    message = request_id.encode('utf-8')
+    server_socket.bind(("", 0))
+    message = request_id.encode("utf-8")
     adr = (address, port)
     consecutive_failures = 0
     measurements_not_smaller = 0
@@ -43,11 +42,13 @@ def handler(event):
         if i > 0:
             times.append([i, send_begin, recv_end])
         cur_time = recv_end - send_begin
-        print("Time {} Min Time {} NotSmaller {}".format(cur_time, cur_min, measurements_not_smaller))
+        print(
+            "Time {} Min Time {} NotSmaller {}".format(cur_time, cur_min, measurements_not_smaller)
+        )
         if cur_time > cur_min and cur_min > 0:
             measurements_not_smaller += 1
             if measurements_not_smaller == repetitions:
-                message = "stop".encode('utf-8')
+                message = "stop".encode("utf-8")
                 server_socket.sendto(message, adr)
                 break
         else:
@@ -57,18 +58,18 @@ def handler(event):
         consecutive_failures = 0
         server_socket.settimeout(4)
     server_socket.close()
-   
+
     if consecutive_failures != 5:
-        with open('/tmp/data.csv', 'w', newline='') as csvfile:
-            writer = csv.writer(csvfile, delimiter=',')
-            writer.writerow(["id", "client_send", "client_rcv"]) 
+        with open("/tmp/data.csv", "w", newline="") as csvfile:
+            writer = csv.writer(csvfile, delimiter=",")
+            writer.writerow(["id", "client_send", "client_rcv"])
             for row in times:
                 writer.writerow(row)
-      
+
         client = storage.storage.get_instance()
-        filename = 'results-{}.csv'.format(request_id)
-        key = client.upload(output_bucket, os.path.join(output_prefix, filename), '/tmp/data.csv')
+        filename = "results-{}.csv".format(request_id)
+        key = client.upload(output_bucket, os.path.join(output_prefix, filename), "/tmp/data.csv")
     else:
         key = None
 
-    return { 'result': {'bucket-key': key, 'timestamp':  event['income-timestamp']} }
+    return {"result": {"bucket-key": key, "timestamp": event["income-timestamp"]}}
diff --git a/benchmarks/000.microbenchmarks/040.server-reply/input.py b/benchmarks/000.microbenchmarks/040.server-reply/input.py
index 041d2ba7f..af0427a6c 100644
--- a/benchmarks/000.microbenchmarks/040.server-reply/input.py
+++ b/benchmarks/000.microbenchmarks/040.server-reply/input.py
@@ -1,12 +1,11 @@
+size_generators = {"test": 1, "small": 100, "large": 1000}
 
-size_generators = {
-    'test' : 1,
-    'small' : 100,
-    'large': 1000
-}
 
 def buckets_count():
     return (0, 0)
 
-def generate_input(data_dir, size, benchmarks_bucket, input_paths, output_paths, upload_func, nosql_func):
-    return { 'sleep': size_generators[size] }
+
+def generate_input(
+    data_dir, size, benchmarks_bucket, input_paths, output_paths, upload_func, nosql_func
+):
+    return {"sleep": size_generators[size]}
diff --git a/benchmarks/000.microbenchmarks/040.server-reply/python/function.py b/benchmarks/000.microbenchmarks/040.server-reply/python/function.py
index fb5b57aa3..4c2a294ba 100644
--- a/benchmarks/000.microbenchmarks/040.server-reply/python/function.py
+++ b/benchmarks/000.microbenchmarks/040.server-reply/python/function.py
@@ -1,11 +1,10 @@
-
 import socket
-from time import sleep
+
 
 def handler(event):
 
     # start timing
-    addr = (event.get('ip-address'), event.get('port'))
+    addr = (event.get("ip-address"), event.get("port"))
     socket.setdefaulttimeout(20)
     s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
     s.connect(addr)
diff --git a/benchmarks/100.webapps/110.dynamic-html/input.py b/benchmarks/100.webapps/110.dynamic-html/input.py
index 98dac88b2..c20154ec3 100644
--- a/benchmarks/100.webapps/110.dynamic-html/input.py
+++ b/benchmarks/100.webapps/110.dynamic-html/input.py
@@ -1,11 +1,9 @@
+size_generators = {"test": 10, "small": 1000, "large": 100000}
 
-size_generators = {
-    'test' : 10,
-    'small' : 1000,
-    'large': 100000
-}
 
-def generate_input(data_dir, size, benchmarks_bucket, input_paths, output_paths, upload_func, nosql_func):
-    input_config = {'username': 'testname'} 
-    input_config['random_len'] = size_generators[size]
+def generate_input(
+    data_dir, size, benchmarks_bucket, input_paths, output_paths, upload_func, nosql_func
+):
+    input_config = {"username": "testname"}
+    input_config["random_len"] = size_generators[size]
     return input_config
diff --git a/benchmarks/100.webapps/110.dynamic-html/python/function.py b/benchmarks/100.webapps/110.dynamic-html/python/function.py
index 7c990f4eb..6f7b42bc5 100644
--- a/benchmarks/100.webapps/110.dynamic-html/python/function.py
+++ b/benchmarks/100.webapps/110.dynamic-html/python/function.py
@@ -1,22 +1,21 @@
-from datetime import datetime                                                   
-from random import sample  
+from datetime import datetime
+from random import sample
 from os import path
-from time import time                                                           
-import os
 
 from jinja2 import Template
 
 SCRIPT_DIR = path.abspath(path.join(path.dirname(__file__)))
 
+
 def handler(event):
 
     # start timing
-    name = event.get('username')
-    size = event.get('random_len')
+    name = event.get("username")
+    size = event.get("random_len")
     cur_time = datetime.now()
     random_numbers = sample(range(0, 1000000), size)
-    template = Template( open(path.join(SCRIPT_DIR, 'templates', 'template.html'), 'r').read())
-    html = template.render(username = name, cur_time = cur_time, random_numbers = random_numbers)
+    template = Template(open(path.join(SCRIPT_DIR, "templates", "template.html"), "r").read())
+    html = template.render(username=name, cur_time=cur_time, random_numbers=random_numbers)
     # end timing
-    # dump stats 
-    return {'result': html}
+    # dump stats
+    return {"result": html}
diff --git a/benchmarks/100.webapps/120.uploader/input.py b/benchmarks/100.webapps/120.uploader/input.py
index ce6169ccb..7aafb2b22 100644
--- a/benchmarks/100.webapps/120.uploader/input.py
+++ b/benchmarks/100.webapps/120.uploader/input.py
@@ -1,19 +1,25 @@
-
 url_generators = {
     # source: mlperf fake_imagenet.sh. 230 kB
-    'test' : 'https://upload.wikimedia.org/wikipedia/commons/thumb/e/e7/Jammlich_crop.jpg/800px-Jammlich_crop.jpg',
+    "test": (
+        "https://upload.wikimedia.org/wikipedia/commons/thumb/e/e7/"
+        "Jammlich_crop.jpg/800px-Jammlich_crop.jpg"
+    ),
     # video: HPX source code, 6.7 MB
-    'small': 'https://github.com/STEllAR-GROUP/hpx/archive/refs/tags/1.4.0.zip',
+    "small": "https://github.com/STEllAR-GROUP/hpx/archive/refs/tags/1.4.0.zip",
     # resnet model from pytorch. 98M
-    'large':  'https://download.pytorch.org/models/resnet50-19c8e357.pth'
+    "large": "https://download.pytorch.org/models/resnet50-19c8e357.pth",
 }
 
+
 def buckets_count():
     return (0, 1)
 
-def generate_input(data_dir, size, benchmarks_bucket, input_buckets, output_buckets, upload_func, nosql_func):
-    input_config = {'object': {}, 'bucket': {}}
-    input_config['object']['url'] = url_generators[size]
-    input_config['bucket']['bucket'] = benchmarks_bucket
-    input_config['bucket']['output'] = output_buckets[0]
+
+def generate_input(
+    data_dir, size, benchmarks_bucket, input_buckets, output_buckets, upload_func, nosql_func
+):
+    input_config = {"object": {}, "bucket": {}}
+    input_config["object"]["url"] = url_generators[size]
+    input_config["bucket"]["bucket"] = benchmarks_bucket
+    input_config["bucket"]["output"] = output_buckets[0]
     return input_config
diff --git a/benchmarks/100.webapps/120.uploader/python/function.py b/benchmarks/100.webapps/120.uploader/python/function.py
index d032bbdb6..cb17131f1 100755
--- a/benchmarks/100.webapps/120.uploader/python/function.py
+++ b/benchmarks/100.webapps/120.uploader/python/function.py
@@ -1,26 +1,29 @@
-
 import datetime
 import os
 
 import urllib.request
 
 from . import storage
+
 client = storage.storage.get_instance()
 
-SEBS_USER_AGENT = "SeBS/1.2 (https://github.com/spcl/serverless-benchmarks) SeBS Benchmark Suite/1.2"
+SEBS_USER_AGENT = (
+    "SeBS/1.2 (https://github.com/spcl/serverless-benchmarks) SeBS Benchmark Suite/1.2"
+)
+
 
 def handler(event):
 
-    bucket = event.get('bucket').get('bucket')
-    output_prefix = event.get('bucket').get('output')
-    url = event.get('object').get('url')
+    bucket = event.get("bucket").get("bucket")
+    output_prefix = event.get("bucket").get("output")
+    url = event.get("object").get("url")
     name = os.path.basename(url)
-    download_path = '/tmp/{}'.format(name)
+    download_path = "/tmp/{}".format(name)
 
     process_begin = datetime.datetime.now()
     req = urllib.request.Request(url)
-    req.add_header('User-Agent', SEBS_USER_AGENT)
-    with open(download_path, 'wb') as f:
+    req.add_header("User-Agent", SEBS_USER_AGENT)
+    with open(download_path, "wb") as f:
         with urllib.request.urlopen(req) as response:
             f.write(response.read())
     size = os.path.getsize(download_path)
@@ -33,16 +36,12 @@ def handler(event):
     process_time = (process_end - process_begin) / datetime.timedelta(microseconds=1)
     upload_time = (upload_end - upload_begin) / datetime.timedelta(microseconds=1)
     return {
-            'result': {
-                'bucket': bucket,
-                'url': url,
-                'key': key_name
-            },
-            'measurement': {
-                'download_time': 0,
-                'download_size': 0,
-                'upload_time': upload_time,
-                'upload_size': size,
-                'compute_time': process_time
-            }
+        "result": {"bucket": bucket, "url": url, "key": key_name},
+        "measurement": {
+            "download_time": 0,
+            "download_size": 0,
+            "upload_time": upload_time,
+            "upload_size": size,
+            "compute_time": process_time,
+        },
     }
diff --git a/benchmarks/200.multimedia/210.thumbnailer/input.py b/benchmarks/200.multimedia/210.thumbnailer/input.py
index 8943effed..6f04bfafb 100644
--- a/benchmarks/200.multimedia/210.thumbnailer/input.py
+++ b/benchmarks/200.multimedia/210.thumbnailer/input.py
@@ -1,9 +1,12 @@
-import glob, os
+import glob
+import os
+
 
 def buckets_count():
     return (1, 1)
 
-'''
+
+"""
     Generate test, small and large workload for thumbnailer.
 
     :param data_dir: directory where benchmark data is placed
@@ -11,19 +14,23 @@ def buckets_count():
     :param input_buckets: input storage containers for this benchmark
     :param output_buckets:
     :param upload_func: upload function taking three params(bucket_idx, key, filepath)
-'''
-def generate_input(data_dir, size, benchmarks_bucket, input_paths, output_paths, upload_func, nosql_func):
+"""
+
+
+def generate_input(
+    data_dir, size, benchmarks_bucket, input_paths, output_paths, upload_func, nosql_func
+):
 
-    for file in glob.glob(os.path.join(data_dir, '*.jpg')):
+    for file in glob.glob(os.path.join(data_dir, "*.jpg")):
         img = os.path.relpath(file, data_dir)
         upload_func(0, img, file)
 
-    #TODO: multiple datasets
-    input_config = {'object': {}, 'bucket': {}}
-    input_config['object']['key'] = img
-    input_config['object']['width'] = 200
-    input_config['object']['height'] = 200
-    input_config['bucket']['bucket'] = benchmarks_bucket
-    input_config['bucket']['input'] = input_paths[0]
-    input_config['bucket']['output'] = output_paths[0]
+    # TODO: multiple datasets
+    input_config = {"object": {}, "bucket": {}}
+    input_config["object"]["key"] = img
+    input_config["object"]["width"] = 200
+    input_config["object"]["height"] = 200
+    input_config["bucket"]["bucket"] = benchmarks_bucket
+    input_config["bucket"]["input"] = input_paths[0]
+    input_config["bucket"]["output"] = output_paths[0]
     return input_config
diff --git a/benchmarks/200.multimedia/210.thumbnailer/python/function.py b/benchmarks/200.multimedia/210.thumbnailer/python/function.py
index 20527067b..2df0a7bfb 100755
--- a/benchmarks/200.multimedia/210.thumbnailer/python/function.py
+++ b/benchmarks/200.multimedia/210.thumbnailer/python/function.py
@@ -1,44 +1,45 @@
 import datetime
 import io
 import os
-import sys
-import uuid
 from urllib.parse import unquote_plus
 from PIL import Image
 
 from . import storage
+
 client = storage.storage.get_instance()
 
 # Disk-based solution
-#def resize_image(image_path, resized_path, w, h):
+# def resize_image(image_path, resized_path, w, h):
 #    with Image.open(image_path) as image:
 #        image.thumbnail((w,h))
 #        image.save(resized_path)
 
+
 # Memory-based solution
 def resize_image(image_bytes, w, h):
     with Image.open(io.BytesIO(image_bytes)) as image:
-        image.thumbnail((w,h))
+        image.thumbnail((w, h))
         out = io.BytesIO()
-        image.save(out, format='jpeg')
+        image.save(out, format="jpeg")
         # necessary to rewind to the beginning of the buffer
         out.seek(0)
         return out
 
+
 def handler(event):
-  
-    bucket = event.get('bucket').get('bucket')
-    input_prefix = event.get('bucket').get('input')
-    output_prefix = event.get('bucket').get('output')
-    key = unquote_plus(event.get('object').get('key'))
-    width = event.get('object').get('width')
-    height = event.get('object').get('height')
+
+    bucket = event.get("bucket").get("bucket")
+    input_prefix = event.get("bucket").get("input")
+    output_prefix = event.get("bucket").get("output")
+    key = unquote_plus(event.get("object").get("key"))
+    width = event.get("object").get("width")
+    height = event.get("object").get("height")
     # UUID to handle multiple calls
-    #download_path = '/tmp/{}-{}'.format(uuid.uuid4(), key)
-    #upload_path = '/tmp/resized-{}'.format(key)
-    #client.download(input_bucket, key, download_path)
-    #resize_image(download_path, upload_path, width, height)
-    #client.upload(output_bucket, key, upload_path)
+    # download_path = '/tmp/{}-{}'.format(uuid.uuid4(), key)
+    # upload_path = '/tmp/resized-{}'.format(key)
+    # client.download(input_bucket, key, download_path)
+    # resize_image(download_path, upload_path, width, height)
+    # client.upload(output_bucket, key, upload_path)
     download_begin = datetime.datetime.now()
     img = client.download_stream(bucket, os.path.join(input_prefix, key))
     download_end = datetime.datetime.now()
@@ -56,15 +57,12 @@ def handler(event):
     upload_time = (upload_end - upload_begin) / datetime.timedelta(microseconds=1)
     process_time = (process_end - process_begin) / datetime.timedelta(microseconds=1)
     return {
-            'result': {
-                'bucket': bucket,
-                'key': key_name
-            },
-            'measurement': {
-                'download_time': download_time,
-                'download_size': len(img),
-                'upload_time': upload_time,
-                'upload_size': resized_size,
-                'compute_time': process_time
-            }
+        "result": {"bucket": bucket, "key": key_name},
+        "measurement": {
+            "download_time": download_time,
+            "download_size": len(img),
+            "upload_time": upload_time,
+            "upload_size": resized_size,
+            "compute_time": process_time,
+        },
     }
diff --git a/benchmarks/200.multimedia/220.video-processing/input.py b/benchmarks/200.multimedia/220.video-processing/input.py
index 6da31647f..86c7191cb 100644
--- a/benchmarks/200.multimedia/220.video-processing/input.py
+++ b/benchmarks/200.multimedia/220.video-processing/input.py
@@ -1,9 +1,12 @@
-import glob, os
+import glob
+import os
+
 
 def buckets_count():
     return (1, 1)
 
-'''
+
+"""
     Generate test, small and large workload for thumbnailer.
 
     :param data_dir: directory where benchmark data is placed
@@ -11,17 +14,21 @@ def buckets_count():
     :param input_buckets: input storage containers for this benchmark
     :param output_buckets:
     :param upload_func: upload function taking three params(bucket_idx, key, filepath)
-'''
-def generate_input(data_dir, size, benchmarks_bucket, input_paths, output_paths, upload_func, nosql_func):
-    for file in glob.glob(os.path.join(data_dir, '*.mp4')):
+"""
+
+
+def generate_input(
+    data_dir, size, benchmarks_bucket, input_paths, output_paths, upload_func, nosql_func
+):
+    for file in glob.glob(os.path.join(data_dir, "*.mp4")):
         img = os.path.relpath(file, data_dir)
         upload_func(0, img, file)
-    #TODO: multiple datasets
-    input_config = {'object': {}, 'bucket': {}}
-    input_config['object']['key'] = img
-    input_config['object']['op'] = 'watermark'
-    input_config['object']['duration'] = 1
-    input_config['bucket']['bucket'] = benchmarks_bucket
-    input_config['bucket']['input'] = input_paths[0]
-    input_config['bucket']['output'] = output_paths[0]
+    # TODO: multiple datasets
+    input_config = {"object": {}, "bucket": {}}
+    input_config["object"]["key"] = img
+    input_config["object"]["op"] = "watermark"
+    input_config["object"]["duration"] = 1
+    input_config["bucket"]["bucket"] = benchmarks_bucket
+    input_config["bucket"]["input"] = input_paths[0]
+    input_config["bucket"]["output"] = output_paths[0]
     return input_config
diff --git a/benchmarks/200.multimedia/220.video-processing/python/function.py b/benchmarks/200.multimedia/220.video-processing/python/function.py
index 9f8a869aa..ab132ba2e 100755
--- a/benchmarks/200.multimedia/220.video-processing/python/function.py
+++ b/benchmarks/200.multimedia/220.video-processing/python/function.py
@@ -7,62 +7,84 @@
 
 
 from . import storage
+
 client = storage.storage.get_instance()
 
 SCRIPT_DIR = os.path.abspath(os.path.join(os.path.dirname(__file__)))
 
+
 def call_ffmpeg(args):
-    ret = subprocess.run([os.path.join(SCRIPT_DIR, 'ffmpeg', 'ffmpeg'), '-y'] + args,
-            #subprocess might inherit Lambda's input for some reason
-            stdin=subprocess.DEVNULL,
-            stdout=subprocess.PIPE, stderr=subprocess.STDOUT
+    ret = subprocess.run(
+        [os.path.join(SCRIPT_DIR, "ffmpeg", "ffmpeg"), "-y"] + args,
+        # subprocess might inherit Lambda's input for some reason
+        stdin=subprocess.DEVNULL,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
     )
     if ret.returncode != 0:
-        print('Invocation of ffmpeg failed!')
-        print('Out: ', ret.stdout.decode('utf-8'))
+        print("Invocation of ffmpeg failed!")
+        print("Out: ", ret.stdout.decode("utf-8"))
         raise RuntimeError()
 
+
 # https://superuser.com/questions/556029/how-do-i-convert-a-video-to-gif-using-ffmpeg-with-reasonable-quality
 def to_gif(video, duration, event):
-    output = '/tmp/processed-{}.gif'.format(os.path.basename(video))
-    call_ffmpeg(["-i", video,
-        "-t",
-        "{0}".format(duration),
-        "-vf",
-        "fps=10,scale=320:-1:flags=lanczos,split[s0][s1];[s0]palettegen[p];[s1][p]paletteuse",
-        "-loop", "0",
-        output])
+    output = "/tmp/processed-{}.gif".format(os.path.basename(video))
+    call_ffmpeg(
+        [
+            "-i",
+            video,
+            "-t",
+            "{0}".format(duration),
+            "-vf",
+            "fps=10,scale=320:-1:flags=lanczos,split[s0][s1];[s0]palettegen[p];[s1][p]paletteuse",
+            "-loop",
+            "0",
+            output,
+        ]
+    )
     return output
 
+
 # https://devopstar.com/2019/01/28/serverless-watermark-using-aws-lambda-layers-ffmpeg/
 def watermark(video, duration, event):
-    output = '/tmp/processed-{}'.format(os.path.basename(video))
+    output = "/tmp/processed-{}".format(os.path.basename(video))
     watermark_file = os.path.dirname(os.path.realpath(__file__))
-    call_ffmpeg([
-        "-i", video,
-        "-i", os.path.join(watermark_file, os.path.join('resources', 'watermark.png')),
-        "-t", "{0}".format(duration),
-        "-filter_complex", "overlay=main_w/2-overlay_w/2:main_h/2-overlay_h/2",
-        output])
+    call_ffmpeg(
+        [
+            "-i",
+            video,
+            "-i",
+            os.path.join(watermark_file, os.path.join("resources", "watermark.png")),
+            "-t",
+            "{0}".format(duration),
+            "-filter_complex",
+            "overlay=main_w/2-overlay_w/2:main_h/2-overlay_h/2",
+            output,
+        ]
+    )
     return output
 
+
 def transcode_mp3(video, duration, event):
     pass
 
-operations = { 'transcode' : transcode_mp3, 'extract-gif' : to_gif, 'watermark' : watermark }
+
+operations = {"transcode": transcode_mp3, "extract-gif": to_gif, "watermark": watermark}
+
 
 def handler(event):
 
-    bucket = event.get('bucket').get('bucket')
-    input_prefix = event.get('bucket').get('input')
-    output_prefix = event.get('bucket').get('output')
-    key = event.get('object').get('key')
-    duration = event.get('object').get('duration')
-    op = event.get('object').get('op')
-    download_path = '/tmp/{}'.format(key)
+    bucket = event.get("bucket").get("bucket")
+    input_prefix = event.get("bucket").get("input")
+    output_prefix = event.get("bucket").get("output")
+    key = event.get("object").get("key")
+    duration = event.get("object").get("duration")
+    op = event.get("object").get("op")
+    download_path = "/tmp/{}".format(key)
 
     # Restore executable permission
-    ffmpeg_binary = os.path.join(SCRIPT_DIR, 'ffmpeg', 'ffmpeg')
+    ffmpeg_binary = os.path.join(SCRIPT_DIR, "ffmpeg", "ffmpeg")
     # needed on Azure but read-only filesystem on AWS
     try:
         st = os.stat(ffmpeg_binary)
@@ -89,16 +111,12 @@ def handler(event):
     upload_time = (upload_stop - upload_begin) / datetime.timedelta(microseconds=1)
     process_time = (process_end - process_begin) / datetime.timedelta(microseconds=1)
     return {
-            'result': {
-                'bucket': bucket,
-                'key': upload_key
-            },
-            'measurement': {
-                'download_time': download_time,
-                'download_size': download_size,
-                'upload_time': upload_time,
-                'upload_size': upload_size,
-                'compute_time': process_time
-            }
-        }
-
+        "result": {"bucket": bucket, "key": upload_key},
+        "measurement": {
+            "download_time": download_time,
+            "download_size": download_size,
+            "upload_time": upload_time,
+            "upload_size": upload_size,
+            "compute_time": process_time,
+        },
+    }
diff --git a/benchmarks/300.utilities/311.compression/input.py b/benchmarks/300.utilities/311.compression/input.py
index 5f88bc91a..e9e706bd5 100644
--- a/benchmarks/300.utilities/311.compression/input.py
+++ b/benchmarks/300.utilities/311.compression/input.py
@@ -1,4 +1,5 @@
-import glob, os
+import os
+
 
 def buckets_count():
     return (1, 1)
@@ -9,11 +10,12 @@ def upload_files(data_root, data_dir, upload_func):
     for root, dirs, files in os.walk(data_dir):
         prefix = os.path.relpath(root, data_root)
         for file in files:
-            file_name = prefix + '/' + file
+            file_name = prefix + "/" + file
             filepath = os.path.join(root, file)
             upload_func(0, file_name, filepath)
 
-'''
+
+"""
     Generate test, small and large workload for compression test.
 
     :param data_dir: directory where benchmark data is placed
@@ -21,8 +23,12 @@ def upload_files(data_root, data_dir, upload_func):
     :param input_buckets: input storage containers for this benchmark
     :param output_buckets:
     :param upload_func: upload function taking three params(bucket_idx, key, filepath)
-'''
-def generate_input(data_dir, size, benchmarks_bucket, input_paths, output_paths, upload_func, nosql_func):
+"""
+
+
+def generate_input(
+    data_dir, size, benchmarks_bucket, input_paths, output_paths, upload_func, nosql_func
+):
 
     # upload different datasets
     datasets = []
@@ -30,9 +36,9 @@ def generate_input(data_dir, size, benchmarks_bucket, input_paths, output_paths,
         datasets.append(dir)
         upload_files(data_dir, os.path.join(data_dir, dir), upload_func)
 
-    input_config = {'object': {}, 'bucket': {}}
-    input_config['object']['key'] = datasets[0]
-    input_config['bucket']['bucket'] = benchmarks_bucket
-    input_config['bucket']['input'] = input_paths[0]
-    input_config['bucket']['output'] = output_paths[0]
+    input_config = {"object": {}, "bucket": {}}
+    input_config["object"]["key"] = datasets[0]
+    input_config["bucket"]["bucket"] = benchmarks_bucket
+    input_config["bucket"]["input"] = input_paths[0]
+    input_config["bucket"]["output"] = output_paths[0]
     return input_config
diff --git a/benchmarks/300.utilities/311.compression/python/function.py b/benchmarks/300.utilities/311.compression/python/function.py
index f758e14e4..8ceb52d2f 100755
--- a/benchmarks/300.utilities/311.compression/python/function.py
+++ b/benchmarks/300.utilities/311.compression/python/function.py
@@ -1,13 +1,13 @@
 import datetime
-import io
 import os
 import shutil
 import uuid
-import zlib
 
 from . import storage
+
 client = storage.storage.get_instance()
 
+
 def parse_directory(directory):
 
     size = 0
@@ -16,13 +16,14 @@ def parse_directory(directory):
             size += os.path.getsize(os.path.join(root, file))
     return size
 
+
 def handler(event):
-  
-    bucket = event.get('bucket').get('bucket')
-    input_prefix = event.get('bucket').get('input')
-    output_prefix = event.get('bucket').get('output')
-    key = event.get('object').get('key')
-    download_path = '/tmp/{}-{}'.format(key, uuid.uuid4())
+
+    bucket = event.get("bucket").get("bucket")
+    input_prefix = event.get("bucket").get("input")
+    output_prefix = event.get("bucket").get("output")
+    key = event.get("object").get("key")
+    download_path = "/tmp/{}-{}".format(key, uuid.uuid4())
     os.makedirs(download_path)
 
     s3_download_begin = datetime.datetime.now()
@@ -31,29 +32,27 @@ def handler(event):
     size = parse_directory(download_path)
 
     compress_begin = datetime.datetime.now()
-    shutil.make_archive(os.path.join(download_path, key), 'zip', root_dir=download_path)
+    shutil.make_archive(os.path.join(download_path, key), "zip", root_dir=download_path)
     compress_end = datetime.datetime.now()
 
     s3_upload_begin = datetime.datetime.now()
-    archive_name = '{}.zip'.format(key)
+    archive_name = "{}.zip".format(key)
     archive_size = os.path.getsize(os.path.join(download_path, archive_name))
-    key_name = client.upload(bucket, os.path.join(output_prefix, archive_name), os.path.join(download_path, archive_name))
+    key_name = client.upload(
+        bucket, os.path.join(output_prefix, archive_name), os.path.join(download_path, archive_name)
+    )
     s3_upload_stop = datetime.datetime.now()
 
     download_time = (s3_download_stop - s3_download_begin) / datetime.timedelta(microseconds=1)
     upload_time = (s3_upload_stop - s3_upload_begin) / datetime.timedelta(microseconds=1)
     process_time = (compress_end - compress_begin) / datetime.timedelta(microseconds=1)
     return {
-            'result': {
-                'bucket': bucket,
-                'key': key_name
-            },
-            'measurement': {
-                'download_time': download_time,
-                'download_size': size,
-                'upload_time': upload_time,
-                'upload_size': archive_size,
-                'compute_time': process_time
-            }
-        }
-
+        "result": {"bucket": bucket, "key": key_name},
+        "measurement": {
+            "download_time": download_time,
+            "download_size": size,
+            "upload_time": upload_time,
+            "upload_size": archive_size,
+            "compute_time": process_time,
+        },
+    }
diff --git a/benchmarks/400.inference/411.image-recognition/input.py b/benchmarks/400.inference/411.image-recognition/input.py
index 45d7215a6..c5ce190d0 100644
--- a/benchmarks/400.inference/411.image-recognition/input.py
+++ b/benchmarks/400.inference/411.image-recognition/input.py
@@ -1,18 +1,21 @@
-import glob, os
+import os
+
 
 def buckets_count():
     return (2, 0)
 
+
 def upload_files(data_root, data_dir, upload_func):
 
     for root, dirs, files in os.walk(data_dir):
         prefix = os.path.relpath(root, data_root)
         for file in files:
-            file_name = prefix + '/' + file
+            file_name = prefix + "/" + file
             filepath = os.path.join(root, file)
             upload_func(0, file_name, filepath)
 
-'''
+
+"""
     Generate test, small and large workload for compression test.
 
     :param data_dir: directory where benchmark data is placed
@@ -20,25 +23,29 @@ def upload_files(data_root, data_dir, upload_func):
     :param input_buckets: input storage containers for this benchmark
     :param output_buckets:
     :param upload_func: upload function taking three params(bucket_idx, key, filepath)
-'''
-def generate_input(data_dir, size, benchmarks_bucket, input_paths, output_paths, upload_func, nosql_func):
+"""
+
+
+def generate_input(
+    data_dir, size, benchmarks_bucket, input_paths, output_paths, upload_func, nosql_func
+):
 
     # upload model
-    model_name = 'resnet50-19c8e357.pth'
-    upload_func(0, model_name, os.path.join(data_dir, 'model', model_name))
+    model_name = "resnet50-19c8e357.pth"
+    upload_func(0, model_name, os.path.join(data_dir, "model", model_name))
 
     input_images = []
-    resnet_path = os.path.join(data_dir, 'fake-resnet')
-    with open(os.path.join(resnet_path, 'val_map.txt'), 'r') as f:
+    resnet_path = os.path.join(data_dir, "fake-resnet")
+    with open(os.path.join(resnet_path, "val_map.txt"), "r") as f:
         for line in f:
             img, img_class = line.split()
             input_images.append((img, img_class))
             upload_func(1, img, os.path.join(resnet_path, img))
-    
-    input_config = {'object': {}, 'bucket': {}}
-    input_config['object']['model'] = model_name
-    input_config['object']['input'] = input_images[0][0]
-    input_config['bucket']['bucket'] = benchmarks_bucket
-    input_config['bucket']['input'] = input_paths[1]
-    input_config['bucket']['model'] = input_paths[0]
+
+    input_config = {"object": {}, "bucket": {}}
+    input_config["object"]["model"] = model_name
+    input_config["object"]["input"] = input_images[0][0]
+    input_config["bucket"]["bucket"] = benchmarks_bucket
+    input_config["bucket"]["input"] = input_paths[1]
+    input_config["bucket"]["model"] = input_paths[0]
     return input_config
diff --git a/benchmarks/400.inference/411.image-recognition/python/function.py b/benchmarks/400.inference/411.image-recognition/python/function.py
index 411386419..0cfa1c57f 100644
--- a/benchmarks/400.inference/411.image-recognition/python/function.py
+++ b/benchmarks/400.inference/411.image-recognition/python/function.py
@@ -1,14 +1,20 @@
-
-import datetime, json, os, uuid
+import datetime
+import json
+import os
+import uuid
 
 # Extract zipped torch model - used in Python 3.8 and 3.9
 # The reason is that torch versions supported for these Python
 # versions are too large for Lambda packages.
-if os.path.exists('function/torch.zip'):
-    import zipfile, sys
+if os.path.exists("function/torch.zip"):
+    import sys
+    import zipfile
+
     # we cannot write to the read-only filesystem
-    zipfile.ZipFile('function/torch.zip').extractall('/tmp/')
-    sys.path.append(os.path.join(os.path.dirname(__file__), '/tmp/.python_packages/lib/site-packages'))
+    zipfile.ZipFile("function/torch.zip").extractall("/tmp/")
+    sys.path.append(
+        os.path.join(os.path.dirname(__file__), "/tmp/.python_packages/lib/site-packages")
+    )
 
 from PIL import Image
 import torch
@@ -16,21 +22,23 @@
 from torchvision.models import resnet50
 
 from . import storage
+
 client = storage.storage.get_instance()
 
 SCRIPT_DIR = os.path.abspath(os.path.join(os.path.dirname(__file__)))
-class_idx = json.load(open(os.path.join(SCRIPT_DIR, "imagenet_class_index.json"), 'r'))
+class_idx = json.load(open(os.path.join(SCRIPT_DIR, "imagenet_class_index.json"), "r"))
 idx2label = [class_idx[str(k)][1] for k in range(len(class_idx))]
 model = None
 
+
 def handler(event):
-  
-    bucket = event.get('bucket').get('bucket')
-    input_prefix = event.get('bucket').get('input')
-    model_prefix = event.get('bucket').get('model')
-    key = event.get('object').get('input')
-    model_key = event.get('object').get('model')
-    download_path = '/tmp/{}-{}'.format(key, uuid.uuid4())
+
+    bucket = event.get("bucket").get("bucket")
+    input_prefix = event.get("bucket").get("input")
+    model_prefix = event.get("bucket").get("model")
+    key = event.get("object").get("input")
+    model_key = event.get("object").get("model")
+    download_path = "/tmp/{}-{}".format(key, uuid.uuid4())
 
     image_download_begin = datetime.datetime.now()
     image_path = download_path
@@ -40,7 +48,7 @@ def handler(event):
     global model
     if not model:
         model_download_begin = datetime.datetime.now()
-        model_path = os.path.join('/tmp', model_key)
+        model_path = os.path.join("/tmp", model_key)
         client.download(bucket, os.path.join(model_prefix, model_key), model_path)
         model_download_end = datetime.datetime.now()
         model_process_begin = datetime.datetime.now()
@@ -53,36 +61,38 @@ def handler(event):
         model_download_end = model_download_begin
         model_process_begin = datetime.datetime.now()
         model_process_end = model_process_begin
-   
+
     process_begin = datetime.datetime.now()
     input_image = Image.open(image_path)
-    preprocess = transforms.Compose([
-        transforms.Resize(256),
-        transforms.CenterCrop(224),
-        transforms.ToTensor(),
-        transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
-    ])
+    preprocess = transforms.Compose(
+        [
+            transforms.Resize(256),
+            transforms.CenterCrop(224),
+            transforms.ToTensor(),
+            transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
+        ]
+    )
     input_tensor = preprocess(input_image)
-    input_batch = input_tensor.unsqueeze(0) # create a mini-batch as expected by the model 
+    input_batch = input_tensor.unsqueeze(0)  # create a mini-batch as expected by the model
     output = model(input_batch)
     _, index = torch.max(output, 1)
-    # The output has unnormalized scores. To get probabilities, you can run a softmax on it.
-    prob = torch.nn.functional.softmax(output[0], dim=0)
-    _, indices = torch.sort(output, descending = True)
     ret = idx2label[index]
     process_end = datetime.datetime.now()
 
-    download_time = (image_download_end- image_download_begin) / datetime.timedelta(microseconds=1)
-    model_download_time = (model_download_end - model_download_begin) / datetime.timedelta(microseconds=1)
-    model_process_time = (model_process_end - model_process_begin) / datetime.timedelta(microseconds=1)
+    download_time = (image_download_end - image_download_begin) / datetime.timedelta(microseconds=1)
+    model_download_time = (model_download_end - model_download_begin) / datetime.timedelta(
+        microseconds=1
+    )
+    model_process_time = (model_process_end - model_process_begin) / datetime.timedelta(
+        microseconds=1
+    )
     process_time = (process_end - process_begin) / datetime.timedelta(microseconds=1)
     return {
-            'result': {'idx': index.item(), 'class': ret},
-            'measurement': {
-                'download_time': download_time + model_download_time,
-                'compute_time': process_time + model_process_time,
-                'model_time': model_process_time,
-                'model_download_time': model_download_time
-            }
-        }
-
+        "result": {"idx": index.item(), "class": ret},
+        "measurement": {
+            "download_time": download_time + model_download_time,
+            "compute_time": process_time + model_process_time,
+            "model_time": model_process_time,
+            "model_download_time": model_download_time,
+        },
+    }
diff --git a/benchmarks/500.scientific/501.graph-pagerank/input.py b/benchmarks/500.scientific/501.graph-pagerank/input.py
index e20a6dcd1..a4ab10fb8 100644
--- a/benchmarks/500.scientific/501.graph-pagerank/input.py
+++ b/benchmarks/500.scientific/501.graph-pagerank/input.py
@@ -1,8 +1,7 @@
-size_generators = {
-    'test' : 10,
-    'small' : 10000,
-    'large': 100000
-}
+size_generators = {"test": 10, "small": 10000, "large": 100000}
 
-def generate_input(data_dir, size, benchmarks_bucket, input_paths, output_paths, upload_func, nosql_func):
-    return { 'size': size_generators[size], 'seed': 42}
+
+def generate_input(
+    data_dir, size, benchmarks_bucket, input_paths, output_paths, upload_func, nosql_func
+):
+    return {"size": size_generators[size], "seed": 42}
diff --git a/benchmarks/500.scientific/501.graph-pagerank/python/function.py b/benchmarks/500.scientific/501.graph-pagerank/python/function.py
index 0e462e9b4..461fc14a9 100755
--- a/benchmarks/500.scientific/501.graph-pagerank/python/function.py
+++ b/benchmarks/500.scientific/501.graph-pagerank/python/function.py
@@ -1,9 +1,10 @@
 import datetime
 import igraph
 
+
 def handler(event):
 
-    size = event.get('size')
+    size = event.get("size")
     if "seed" in event:
         import random
 
@@ -17,13 +18,15 @@ def handler(event):
     result = graph.pagerank()
     process_end = datetime.datetime.now()
 
-    graph_generating_time = (graph_generating_end - graph_generating_begin) / datetime.timedelta(microseconds=1)
+    graph_generating_time = (graph_generating_end - graph_generating_begin) / datetime.timedelta(
+        microseconds=1
+    )
     process_time = (process_end - process_begin) / datetime.timedelta(microseconds=1)
 
     return {
-            'result': result[0],
-            'measurement': {
-                'graph_generating_time': graph_generating_time,
-                'compute_time': process_time
-            }
+        "result": result[0],
+        "measurement": {
+            "graph_generating_time": graph_generating_time,
+            "compute_time": process_time,
+        },
     }
diff --git a/benchmarks/500.scientific/502.graph-mst/input.py b/benchmarks/500.scientific/502.graph-mst/input.py
index e20a6dcd1..a4ab10fb8 100644
--- a/benchmarks/500.scientific/502.graph-mst/input.py
+++ b/benchmarks/500.scientific/502.graph-mst/input.py
@@ -1,8 +1,7 @@
-size_generators = {
-    'test' : 10,
-    'small' : 10000,
-    'large': 100000
-}
+size_generators = {"test": 10, "small": 10000, "large": 100000}
 
-def generate_input(data_dir, size, benchmarks_bucket, input_paths, output_paths, upload_func, nosql_func):
-    return { 'size': size_generators[size], 'seed': 42}
+
+def generate_input(
+    data_dir, size, benchmarks_bucket, input_paths, output_paths, upload_func, nosql_func
+):
+    return {"size": size_generators[size], "seed": 42}
diff --git a/benchmarks/500.scientific/502.graph-mst/python/function.py b/benchmarks/500.scientific/502.graph-mst/python/function.py
index b63fbdce2..69ad77678 100755
--- a/benchmarks/500.scientific/502.graph-mst/python/function.py
+++ b/benchmarks/500.scientific/502.graph-mst/python/function.py
@@ -1,9 +1,10 @@
 import datetime
 import igraph
 
+
 def handler(event):
 
-    size = event.get('size')
+    size = event.get("size")
     if "seed" in event:
         import random
 
@@ -17,13 +18,15 @@ def handler(event):
     result = graph.spanning_tree(None, False)
     process_end = datetime.datetime.now()
 
-    graph_generating_time = (graph_generating_end - graph_generating_begin) / datetime.timedelta(microseconds=1)
+    graph_generating_time = (graph_generating_end - graph_generating_begin) / datetime.timedelta(
+        microseconds=1
+    )
     process_time = (process_end - process_begin) / datetime.timedelta(microseconds=1)
 
     return {
-            'result': result[0],
-            'measurement': {
-                'graph_generating_time': graph_generating_time,
-                'compute_time': process_time
-            }
+        "result": result[0],
+        "measurement": {
+            "graph_generating_time": graph_generating_time,
+            "compute_time": process_time,
+        },
     }
diff --git a/benchmarks/500.scientific/503.graph-bfs/input.py b/benchmarks/500.scientific/503.graph-bfs/input.py
index e20a6dcd1..a4ab10fb8 100644
--- a/benchmarks/500.scientific/503.graph-bfs/input.py
+++ b/benchmarks/500.scientific/503.graph-bfs/input.py
@@ -1,8 +1,7 @@
-size_generators = {
-    'test' : 10,
-    'small' : 10000,
-    'large': 100000
-}
+size_generators = {"test": 10, "small": 10000, "large": 100000}
 
-def generate_input(data_dir, size, benchmarks_bucket, input_paths, output_paths, upload_func, nosql_func):
-    return { 'size': size_generators[size], 'seed': 42}
+
+def generate_input(
+    data_dir, size, benchmarks_bucket, input_paths, output_paths, upload_func, nosql_func
+):
+    return {"size": size_generators[size], "seed": 42}
diff --git a/benchmarks/500.scientific/503.graph-bfs/python/function.py b/benchmarks/500.scientific/503.graph-bfs/python/function.py
index 18423ae1a..51a37346b 100755
--- a/benchmarks/500.scientific/503.graph-bfs/python/function.py
+++ b/benchmarks/500.scientific/503.graph-bfs/python/function.py
@@ -1,9 +1,10 @@
 import datetime
 import igraph
 
+
 def handler(event):
 
-    size = event.get('size')
+    size = event.get("size")
     if "seed" in event:
         import random
 
@@ -17,13 +18,15 @@ def handler(event):
     result = graph.bfs(0)
     process_end = datetime.datetime.now()
 
-    graph_generating_time = (graph_generating_end - graph_generating_begin) / datetime.timedelta(microseconds=1)
+    graph_generating_time = (graph_generating_end - graph_generating_begin) / datetime.timedelta(
+        microseconds=1
+    )
     process_time = (process_end - process_begin) / datetime.timedelta(microseconds=1)
 
     return {
-            'result': result,
-            'measurement': {
-                'graph_generating_time': graph_generating_time,
-                'compute_time': process_time
-            }
+        "result": result,
+        "measurement": {
+            "graph_generating_time": graph_generating_time,
+            "compute_time": process_time,
+        },
     }
diff --git a/benchmarks/500.scientific/504.dna-visualisation/input.py b/benchmarks/500.scientific/504.dna-visualisation/input.py
index a9f376ea2..ea26f48c0 100644
--- a/benchmarks/500.scientific/504.dna-visualisation/input.py
+++ b/benchmarks/500.scientific/504.dna-visualisation/input.py
@@ -1,16 +1,21 @@
-import glob, os
+import glob
+import os
+
 
 def buckets_count():
     return (1, 1)
 
-def generate_input(data_dir, size, benchmarks_bucket, input_paths, output_paths, upload_func, nosql_func):
 
-    for file in glob.glob(os.path.join(data_dir, '*.fasta')):
+def generate_input(
+    data_dir, size, benchmarks_bucket, input_paths, output_paths, upload_func, nosql_func
+):
+
+    for file in glob.glob(os.path.join(data_dir, "*.fasta")):
         data = os.path.relpath(file, data_dir)
         upload_func(0, data, file)
-    input_config = {'object': {}, 'bucket': {}}
-    input_config['object']['key'] = data
-    input_config['bucket']['bucket'] = benchmarks_bucket
-    input_config['bucket']['input'] = input_paths[0]
-    input_config['bucket']['output'] = output_paths[0]
+    input_config = {"object": {}, "bucket": {}}
+    input_config["object"]["key"] = data
+    input_config["bucket"]["bucket"] = benchmarks_bucket
+    input_config["bucket"]["input"] = input_paths[0]
+    input_config["bucket"]["output"] = output_paths[0]
     return input_config
diff --git a/benchmarks/500.scientific/504.dna-visualisation/python/function.py b/benchmarks/500.scientific/504.dna-visualisation/python/function.py
index 8362a73a1..ca9f5975e 100755
--- a/benchmarks/500.scientific/504.dna-visualisation/python/function.py
+++ b/benchmarks/500.scientific/504.dna-visualisation/python/function.py
@@ -1,17 +1,23 @@
-import datetime, io, json, os
+import datetime
+import io
+import json
+import os
+
 # using https://squiggle.readthedocs.io/en/latest/
 from squiggle import transform
 
 from . import storage
+
 client = storage.storage.get_instance()
 
+
 def handler(event):
 
-    bucket = event.get('bucket').get('bucket')
-    input_prefix = event.get('bucket').get('input')
-    output_prefix = event.get('bucket').get('output')
-    key = event.get('object').get('key')
-    download_path = '/tmp/{}'.format(key)
+    bucket = event.get("bucket").get("bucket")
+    input_prefix = event.get("bucket").get("input")
+    output_prefix = event.get("bucket").get("output")
+    key = event.get("object").get("key")
+    download_path = "/tmp/{}".format(key)
 
     download_begin = datetime.datetime.now()
     client.download(bucket, os.path.join(input_prefix, key), download_path)
@@ -34,13 +40,10 @@ def handler(event):
     process_time = (process_end - process_begin) / datetime.timedelta(microseconds=1)
 
     return {
-            'result': {
-                'bucket': bucket,
-                'key': key_name
-            },
-            'measurement': {
-                'download_time': download_time,
-                'compute_time': process_time,
-                'upload_time': process_time
-            }
+        "result": {"bucket": bucket, "key": key_name},
+        "measurement": {
+            "download_time": download_time,
+            "compute_time": process_time,
+            "upload_time": upload_time,
+        },
     }
diff --git a/benchmarks/wrappers/aws/python/handler.py b/benchmarks/wrappers/aws/python/handler.py
index 907b2c612..f5a1d4195 100644
--- a/benchmarks/wrappers/aws/python/handler.py
+++ b/benchmarks/wrappers/aws/python/handler.py
@@ -1,39 +1,46 @@
-
-import datetime, io, json, os, sys, uuid
+import datetime
+import io
+import json
+import os
+import sys
+import uuid
 
 # Add current directory to allow location of packages
-sys.path.append(os.path.join(os.path.dirname(__file__), '.python_packages/lib/site-packages'))
+sys.path.append(os.path.join(os.path.dirname(__file__), ".python_packages/lib/site-packages"))
 
 # TODO: usual trigger
 # implement support for S3 and others
+
+
 def handler(event, context):
 
     income_timestamp = datetime.datetime.now().timestamp()
 
     # HTTP trigger with API Gateaway
-    if 'body' in event:
-        event = json.loads(event['body'])
+    if "body" in event:
+        event = json.loads(event["body"])
     req_id = context.aws_request_id
-    event['request-id'] = req_id
-    event['income-timestamp'] = income_timestamp
+    event["request-id"] = req_id
+    event["income-timestamp"] = income_timestamp
     begin = datetime.datetime.now()
     from function import function
+
     ret = function.handler(event)
     end = datetime.datetime.now()
 
-    log_data = {
-        'output': ret['result']
-    }
-    if 'measurement' in ret:
-        log_data['measurement'] = ret['measurement']
-    if 'logs' in event:
-        log_data['time'] = (end - begin) / datetime.timedelta(microseconds=1)
+    log_data = {"output": ret["result"]}
+    if "measurement" in ret:
+        log_data["measurement"] = ret["measurement"]
+    if "logs" in event:
+        log_data["time"] = (end - begin) / datetime.timedelta(microseconds=1)
         results_begin = datetime.datetime.now()
         from function import storage
+
         storage_inst = storage.storage.get_instance()
-        b = event.get('logs').get('bucket')
-        storage_inst.upload_stream(b, '{}.json'.format(req_id),
-                io.BytesIO(json.dumps(log_data).encode('utf-8')))
+        b = event.get("logs").get("bucket")
+        storage_inst.upload_stream(
+            b, "{}.json".format(req_id), io.BytesIO(json.dumps(log_data).encode("utf-8"))
+        )
         results_end = datetime.datetime.now()
         results_time = (results_end - results_begin) / datetime.timedelta(microseconds=1)
     else:
@@ -41,14 +48,14 @@ def handler(event, context):
 
     # cold test
     is_cold = False
-    fname = os.path.join('/tmp', 'cold_run')
+    fname = os.path.join("/tmp", "cold_run")
     if not os.path.exists(fname):
         is_cold = True
         container_id = str(uuid.uuid4())[0:8]
-        with open(fname, 'a') as f:
+        with open(fname, "a") as f:
             f.write(container_id)
     else:
-        with open(fname, 'r') as f:
+        with open(fname, "r") as f:
             container_id = f.read()
 
     cold_start_var = ""
@@ -56,16 +63,17 @@ def handler(event, context):
         cold_start_var = os.environ["cold_start"]
 
     return {
-        'statusCode': 200,
-        'body': json.dumps({
-            'begin': begin.strftime('%s.%f'),
-            'end': end.strftime('%s.%f'),
-            'results_time': results_time,
-            'is_cold': is_cold,
-            'result': log_data,
-            'request_id': context.aws_request_id,
-            'cold_start_var': cold_start_var,
-            'container_id': container_id,
-        })
+        "statusCode": 200,
+        "body": json.dumps(
+            {
+                "begin": begin.strftime("%s.%f"),
+                "end": end.strftime("%s.%f"),
+                "results_time": results_time,
+                "is_cold": is_cold,
+                "result": log_data,
+                "request_id": context.aws_request_id,
+                "cold_start_var": cold_start_var,
+                "container_id": container_id,
+            }
+        ),
     }
-
diff --git a/benchmarks/wrappers/aws/python/setup.py b/benchmarks/wrappers/aws/python/setup.py
index b3d878351..016974465 100644
--- a/benchmarks/wrappers/aws/python/setup.py
+++ b/benchmarks/wrappers/aws/python/setup.py
@@ -2,14 +2,13 @@
 from glob import glob
 from pkg_resources import parse_requirements
 
-with open('requirements.txt') as f:
+with open("requirements.txt") as f:
     requirements = [str(r) for r in parse_requirements(f)]
 
 setup(
-    name='function',
+    name="function",
     install_requires=requirements,
-    packages=['function'],
-    package_dir={'function': '.'},
-    package_data={'function': glob('**', recursive=True)},
+    packages=["function"],
+    package_dir={"function": "."},
+    package_data={"function": glob("**", recursive=True)},
 )
-
diff --git a/benchmarks/wrappers/aws/python/storage.py b/benchmarks/wrappers/aws/python/storage.py
index 4be0025e8..50875fbfc 100644
--- a/benchmarks/wrappers/aws/python/storage.py
+++ b/benchmarks/wrappers/aws/python/storage.py
@@ -10,16 +10,14 @@ class storage:
     client = None
 
     def __init__(self):
-        self.client = boto3.client('s3')
+        self.client = boto3.client("s3")
 
     @staticmethod
     def unique_name(name):
         name, extension = os.path.splitext(name)
-        return '{name}.{random}{extension}'.format(
-                    name=name,
-                    extension=extension,
-                    random=str(uuid.uuid4()).split('-')[0]
-                )
+        return "{name}.{random}{extension}".format(
+            name=name, extension=extension, random=str(uuid.uuid4()).split("-")[0]
+        )
 
     def upload(self, bucket, file, filepath):
         key_name = storage.unique_name(file)
@@ -31,8 +29,8 @@ def download(self, bucket, file, filepath):
 
     def download_directory(self, bucket, prefix, path):
         objects = self.client.list_objects_v2(Bucket=bucket, Prefix=prefix)
-        for obj in objects['Contents']:
-            file_name = obj['Key']
+        for obj in objects["Contents"]:
+            file_name = obj["Key"]
             path_to_file = os.path.dirname(file_name)
             os.makedirs(os.path.join(path, path_to_file), exist_ok=True)
             self.download(bucket, file_name, os.path.join(path, file_name))
@@ -46,7 +44,7 @@ def download_stream(self, bucket, file):
         data = io.BytesIO()
         self.client.download_fileobj(bucket, file, data)
         return data.getbuffer()
-    
+
     def get_instance():
         if storage.instance is None:
             storage.instance = storage()
diff --git a/benchmarks/wrappers/azure/python/handler.py b/benchmarks/wrappers/azure/python/handler.py
index 88e44baf6..964fc2fde 100644
--- a/benchmarks/wrappers/azure/python/handler.py
+++ b/benchmarks/wrappers/azure/python/handler.py
@@ -1,52 +1,60 @@
-
-import datetime, io, json, os, uuid
+import datetime
+import io
+import json
+import os
+import uuid
 
 import azure.functions as func
 
 
-if 'NOSQL_STORAGE_DATABASE' in os.environ:
+if "NOSQL_STORAGE_DATABASE" in os.environ:
 
     from . import nosql
 
     nosql.nosql.get_instance(
-        os.environ['NOSQL_STORAGE_DATABASE'],
-        os.environ['NOSQL_STORAGE_URL'],
-        os.environ['NOSQL_STORAGE_CREDS']
+        os.environ["NOSQL_STORAGE_DATABASE"],
+        os.environ["NOSQL_STORAGE_URL"],
+        os.environ["NOSQL_STORAGE_CREDS"],
     )
 
-if 'STORAGE_CONNECTION_STRING' in os.environ:
+if "STORAGE_CONNECTION_STRING" in os.environ:
 
     from . import storage
-    client = storage.storage.get_instance(os.environ['STORAGE_CONNECTION_STRING'])
+
+    client = storage.storage.get_instance(os.environ["STORAGE_CONNECTION_STRING"])
+
 
 # TODO: usual trigger
 # implement support for blob and others
+
+
 def main(req: func.HttpRequest, context: func.Context) -> func.HttpResponse:
     income_timestamp = datetime.datetime.now().timestamp()
     req_json = req.get_json()
 
-    req_json['request-id'] = context.invocation_id
-    req_json['income-timestamp'] = income_timestamp
+    req_json["request-id"] = context.invocation_id
+    req_json["income-timestamp"] = income_timestamp
     begin = datetime.datetime.now()
     # We are deployed in the same directory
     from . import function
+
     ret = function.handler(req_json)
     end = datetime.datetime.now()
 
-    log_data = {
-        'output': ret['result']
-    }
-    if 'measurement' in ret:
-        log_data['measurement'] = ret['measurement']
-    if 'logs' in req_json:
-        log_data['time'] = (end - begin) / datetime.timedelta(microseconds=1)
+    log_data = {"output": ret["result"]}
+    if "measurement" in ret:
+        log_data["measurement"] = ret["measurement"]
+    if "logs" in req_json:
+        log_data["time"] = (end - begin) / datetime.timedelta(microseconds=1)
         results_begin = datetime.datetime.now()
         from . import storage
+
         storage_inst = storage.storage.get_instance()
-        b = req_json.get('logs').get('bucket')
+        b = req_json.get("logs").get("bucket")
         req_id = context.invocation_id
-        storage_inst.upload_stream(b, '{}.json'.format(req_id),
-                io.BytesIO(json.dumps(log_data).encode('utf-8')))
+        storage_inst.upload_stream(
+            b, "{}.json".format(req_id), io.BytesIO(json.dumps(log_data).encode("utf-8"))
+        )
         results_end = datetime.datetime.now()
         results_time = (results_end - results_begin) / datetime.timedelta(microseconds=1)
     else:
@@ -54,14 +62,14 @@ def main(req: func.HttpRequest, context: func.Context) -> func.HttpResponse:
 
     # cold test
     is_cold = False
-    fname = os.path.join('/tmp','cold_run')
+    fname = os.path.join("/tmp", "cold_run")
     if not os.path.exists(fname):
         is_cold = True
         container_id = str(uuid.uuid4())[0:8]
-        with open(fname, 'a') as f:
+        with open(fname, "a") as f:
             f.write(container_id)
     else:
-        with open(fname, 'r') as f:
+        with open(fname, "r") as f:
             container_id = f.read()
 
     is_cold_worker = False
@@ -73,17 +81,18 @@ def main(req: func.HttpRequest, context: func.Context) -> func.HttpResponse:
         is_cold_worker = True
 
     return func.HttpResponse(
-        json.dumps({
-            'begin': begin.strftime('%s.%f'),
-            'end': end.strftime('%s.%f'),
-            'results_time': results_time,
-            'result': log_data,
-            'is_cold': is_cold,
-            'is_cold_worker': is_cold_worker,
-            'container_id': container_id,
-            'environ_container_id': os.environ['CONTAINER_NAME'],
-            'request_id': context.invocation_id
-        }),
-        mimetype="application/json"
+        json.dumps(
+            {
+                "begin": begin.strftime("%s.%f"),
+                "end": end.strftime("%s.%f"),
+                "results_time": results_time,
+                "result": log_data,
+                "is_cold": is_cold,
+                "is_cold_worker": is_cold_worker,
+                "container_id": container_id,
+                "environ_container_id": os.environ["CONTAINER_NAME"],
+                "request_id": context.invocation_id,
+            }
+        ),
+        mimetype="application/json",
     )
-
diff --git a/benchmarks/wrappers/azure/python/storage.py b/benchmarks/wrappers/azure/python/storage.py
index 42b129c89..fabd8e6a1 100644
--- a/benchmarks/wrappers/azure/python/storage.py
+++ b/benchmarks/wrappers/azure/python/storage.py
@@ -1,10 +1,10 @@
-
 import os
 import uuid
 from typing import Optional
 
 from azure.storage.blob import BlobServiceClient
 
+
 class storage:
     instance = None
     client = None
@@ -15,20 +15,18 @@ def __init__(self, connection_string: str):
     @staticmethod
     def unique_name(name):
         name, extension = os.path.splitext(name)
-        return '{name}.{random}{extension}'.format(
-                    name=name,
-                    extension=extension,
-                    random=str(uuid.uuid4()).split('-')[0]
-                )
+        return "{name}.{random}{extension}".format(
+            name=name, extension=extension, random=str(uuid.uuid4()).split("-")[0]
+        )
 
     def upload(self, container, file, filepath):
-        with open(filepath, 'rb') as data:
+        with open(filepath, "rb") as data:
             return self.upload_stream(container, file, data)
 
     def download(self, container, file, filepath):
-        with open(filepath, 'wb') as download_file:
-            download_file.write( self.download_stream(container, file) )
-    
+        with open(filepath, "wb") as download_file:
+            download_file.write(self.download_stream(container, file))
+
     def download_directory(self, container, prefix, path):
         client = self.client.get_container_client(container=container)
         objects = client.list_blobs(name_starts_with=prefix)
@@ -37,20 +35,17 @@ def download_directory(self, container, prefix, path):
             path_to_file = os.path.dirname(file_name)
             os.makedirs(os.path.join(path, path_to_file), exist_ok=True)
             self.download(container, file_name, os.path.join(path, file_name))
-    
+
     def upload_stream(self, container, file, data):
         key_name = storage.unique_name(file)
-        client = self.client.get_blob_client(
-                container=container,
-                blob=key_name
-        )
+        client = self.client.get_blob_client(container=container, blob=key_name)
         client.upload_blob(data)
         return key_name
 
     def download_stream(self, container, file):
         client = self.client.get_blob_client(container=container, blob=file)
         return client.download_blob().readall()
-    
+
     @staticmethod
     def get_instance(connection_string: Optional[str] = None):
         if storage.instance is None:
diff --git a/benchmarks/wrappers/gcp/python/handler.py b/benchmarks/wrappers/gcp/python/handler.py
index 9b6989611..57e1d000b 100644
--- a/benchmarks/wrappers/gcp/python/handler.py
+++ b/benchmarks/wrappers/gcp/python/handler.py
@@ -1,44 +1,46 @@
-import datetime, io, json, os, uuid, sys
+import datetime
+import io
+import json
+import os
+import sys
+import uuid
 
-sys.path.append(os.path.join(os.path.dirname(__file__), '.python_packages/lib/site-packages'))
+sys.path.append(os.path.join(os.path.dirname(__file__), ".python_packages/lib/site-packages"))
 
 # This variable is defined by SeBS during function creation.
-if 'NOSQL_STORAGE_DATABASE' in os.environ:
+if "NOSQL_STORAGE_DATABASE" in os.environ:
     from function import nosql
 
-    nosql.nosql.get_instance(
-        os.environ['NOSQL_STORAGE_DATABASE']
-    )
+    nosql.nosql.get_instance(os.environ["NOSQL_STORAGE_DATABASE"])
 
 
 def handler(req):
     income_timestamp = datetime.datetime.now().timestamp()
-    req_id = req.headers.get('Function-Execution-Id')
-
+    req_id = req.headers.get("Function-Execution-Id")
 
     req_json = req.get_json()
-    req_json['request-id'] = req_id
-    req_json['income-timestamp'] = income_timestamp
+    req_json["request-id"] = req_id
+    req_json["income-timestamp"] = income_timestamp
     begin = datetime.datetime.now()
     # We are deployed in the same directorygit status
     from function import function
+
     ret = function.handler(req_json)
     end = datetime.datetime.now()
 
-
-    log_data = {
-        'output': ret['result']
-    }
-    if 'measurement' in ret:
-        log_data['measurement'] = ret['measurement']
-    if 'logs' in req_json:
-        log_data['time'] = (end - begin) / datetime.timedelta(microseconds=1)
+    log_data = {"output": ret["result"]}
+    if "measurement" in ret:
+        log_data["measurement"] = ret["measurement"]
+    if "logs" in req_json:
+        log_data["time"] = (end - begin) / datetime.timedelta(microseconds=1)
         results_begin = datetime.datetime.now()
         from function import storage
+
         storage_inst = storage.storage.get_instance()
-        b = req_json.get('logs').get('bucket')
-        storage_inst.upload_stream(b, '{}.json'.format(req_id),
-                                   io.BytesIO(json.dumps(log_data).encode('utf-8')))
+        b = req_json.get("logs").get("bucket")
+        storage_inst.upload_stream(
+            b, "{}.json".format(req_id), io.BytesIO(json.dumps(log_data).encode("utf-8"))
+        )
         results_end = datetime.datetime.now()
         results_time = (results_end - results_begin) / datetime.timedelta(microseconds=1)
     else:
@@ -46,27 +48,33 @@ def handler(req):
 
     # cold test
     is_cold = False
-    fname = os.path.join('/tmp', 'cold_run')
+    fname = os.path.join("/tmp", "cold_run")
     if not os.path.exists(fname):
         is_cold = True
         container_id = str(uuid.uuid4())[0:8]
-        with open(fname, 'a') as f:
+        with open(fname, "a") as f:
             f.write(container_id)
     else:
-        with open(fname, 'r') as f:
+        with open(fname, "r") as f:
             container_id = f.read()
 
     cold_start_var = ""
     if "cold_start" in os.environ:
         cold_start_var = os.environ["cold_start"]
 
-    return json.dumps({
-            'begin': begin.strftime('%s.%f'),
-            'end': end.strftime('%s.%f'),
-            'results_time': results_time,
-            'is_cold': is_cold,
-            'result': log_data,
-            'request_id': req_id,
-            'cold_start_var': cold_start_var,
-            'container_id': container_id,
-        }), 200, {'ContentType': 'application/json'}
+    return (
+        json.dumps(
+            {
+                "begin": begin.strftime("%s.%f"),
+                "end": end.strftime("%s.%f"),
+                "results_time": results_time,
+                "is_cold": is_cold,
+                "result": log_data,
+                "request_id": req_id,
+                "cold_start_var": cold_start_var,
+                "container_id": container_id,
+            }
+        ),
+        200,
+        {"ContentType": "application/json"},
+    )
diff --git a/benchmarks/wrappers/gcp/python/storage.py b/benchmarks/wrappers/gcp/python/storage.py
index 81163cb34..70f182618 100644
--- a/benchmarks/wrappers/gcp/python/storage.py
+++ b/benchmarks/wrappers/gcp/python/storage.py
@@ -15,11 +15,9 @@ def __init__(self):
     @staticmethod
     def unique_name(name):
         name, extension = os.path.splitext(name)
-        return '{name}.{random}{extension}'.format(
-                    name=name,
-                    extension=extension,
-                    random=str(uuid.uuid4()).split('-')[0]
-                )
+        return "{name}.{random}{extension}".format(
+            name=name, extension=extension, random=str(uuid.uuid4()).split("-")[0]
+        )
 
     def upload(self, bucket, file, filepath):
         key_name = storage.unique_name(file)
diff --git a/benchmarks/wrappers/local/python/storage.py b/benchmarks/wrappers/local/python/storage.py
index b44968408..d25583a13 100644
--- a/benchmarks/wrappers/local/python/storage.py
+++ b/benchmarks/wrappers/local/python/storage.py
@@ -1,32 +1,28 @@
-import io
 import os
 import uuid
 
 import minio
 
+
 class storage:
     instance = None
     client = None
 
     def __init__(self):
-        if 'MINIO_ADDRESS' in os.environ:
-            address = os.environ['MINIO_ADDRESS']
-            access_key = os.environ['MINIO_ACCESS_KEY']
-            secret_key = os.environ['MINIO_SECRET_KEY']
+        if "MINIO_ADDRESS" in os.environ:
+            address = os.environ["MINIO_ADDRESS"]
+            access_key = os.environ["MINIO_ACCESS_KEY"]
+            secret_key = os.environ["MINIO_SECRET_KEY"]
             self.client = minio.Minio(
-                    address,
-                    access_key=access_key,
-                    secret_key=secret_key,
-                    secure=False)
+                address, access_key=access_key, secret_key=secret_key, secure=False
+            )
 
     @staticmethod
     def unique_name(name):
         name, extension = os.path.splitext(name)
-        return '{name}.{random}{extension}'.format(
-                    name=name,
-                    extension=extension,
-                    random=str(uuid.uuid4()).split('-')[0]
-                )
+        return "{name}.{random}{extension}".format(
+            name=name, extension=extension, random=str(uuid.uuid4()).split("-")[0]
+        )
 
     def upload(self, bucket, file, filepath):
         key_name = storage.unique_name(file)
@@ -55,4 +51,3 @@ def get_instance():
         if storage.instance is None:
             storage.instance = storage()
         return storage.instance
-
diff --git a/benchmarks/wrappers/openwhisk/python/__main__.py b/benchmarks/wrappers/openwhisk/python/__main__.py
index 3ae44f9c2..3833bff8c 100644
--- a/benchmarks/wrappers/openwhisk/python/__main__.py
+++ b/benchmarks/wrappers/openwhisk/python/__main__.py
@@ -2,24 +2,30 @@
 import datetime
 import os
 
+
 def main(args):
     logging.getLogger().setLevel(logging.INFO)
     begin = datetime.datetime.now()
-    args['request-id'] = os.getenv('__OW_ACTIVATION_ID')
-    args['income-timestamp'] = begin.timestamp()
+    args["request-id"] = os.getenv("__OW_ACTIVATION_ID")
+    args["income-timestamp"] = begin.timestamp()
 
-    for arg in ["MINIO_STORAGE_CONNECTION_URL", "MINIO_STORAGE_ACCESS_KEY", "MINIO_STORAGE_SECRET_KEY"]:
+    for arg in [
+        "MINIO_STORAGE_CONNECTION_URL",
+        "MINIO_STORAGE_ACCESS_KEY",
+        "MINIO_STORAGE_SECRET_KEY",
+    ]:
         os.environ[arg] = args[arg]
         del args[arg]
 
     key_list = list(args.keys())
     for arg in key_list:
-        if 'NOSQL_STORAGE_' in arg:
+        if "NOSQL_STORAGE_" in arg:
             os.environ[arg] = args[arg]
             del args[arg]
 
     try:
         from function import function
+
         ret = function.handler(args)
         end = datetime.datetime.now()
         logging.info("Function result: {}".format(ret))
@@ -38,7 +44,7 @@ def main(args):
         return {
             "begin": begin.strftime("%s.%f"),
             "end": end.strftime("%s.%f"),
-            "request_id": os.getenv('__OW_ACTIVATION_ID'),
+            "request_id": os.getenv("__OW_ACTIVATION_ID"),
             "results_time": results_time,
             "is_cold": is_cold,
             "result": log_data,
@@ -49,7 +55,7 @@ def main(args):
         return {
             "begin": begin.strftime("%s.%f"),
             "end": end.strftime("%s.%f"),
-            "request_id": os.getenv('__OW_ACTIVATION_ID'),
+            "request_id": os.getenv("__OW_ACTIVATION_ID"),
             "results_time": results_time,
-            "result": f"Error - invocation failed! Reason: {e}"
+            "result": f"Error - invocation failed! Reason: {e}",
         }
diff --git a/benchmarks/wrappers/openwhisk/python/nosql.py b/benchmarks/wrappers/openwhisk/python/nosql.py
index da8245009..4a8676d36 100644
--- a/benchmarks/wrappers/openwhisk/python/nosql.py
+++ b/benchmarks/wrappers/openwhisk/python/nosql.py
@@ -5,6 +5,7 @@
 import boto3
 from botocore.client import Config
 
+
 class nosql:
 
     instance: Optional["nosql"] = None
@@ -14,14 +15,14 @@ def __init__(self):
         if environ["NOSQL_STORAGE_TYPE"] != "scylladb":
             raise RuntimeError(f"Unsupported NoSQL storage type: {environ['NOSQL_STORAGE_TYPE']}!")
 
-        config = Config(connect_timeout=5, retries={'max_attempts': 0})
+        config = Config(connect_timeout=5, retries={"max_attempts": 0})
         self.client = boto3.resource(
             "dynamodb",
             region_name="None",
             aws_access_key_id="None",
             aws_secret_access_key="None",
             endpoint_url=f"http://{environ['NOSQL_STORAGE_ENDPOINT']}",
-            config=config
+            config=config,
         )
         self._tables = {}
 
diff --git a/benchmarks/wrappers/openwhisk/python/setup.py b/benchmarks/wrappers/openwhisk/python/setup.py
index b942d059b..016974465 100644
--- a/benchmarks/wrappers/openwhisk/python/setup.py
+++ b/benchmarks/wrappers/openwhisk/python/setup.py
@@ -2,13 +2,13 @@
 from glob import glob
 from pkg_resources import parse_requirements
 
-with open('requirements.txt') as f:
+with open("requirements.txt") as f:
     requirements = [str(r) for r in parse_requirements(f)]
 
 setup(
-    name='function',
+    name="function",
     install_requires=requirements,
-    packages=['function'],
-    package_dir={'function': '.'},
-    package_data={'function': glob('**', recursive=True)},
-)
\ No newline at end of file
+    packages=["function"],
+    package_dir={"function": "."},
+    package_data={"function": glob("**", recursive=True)},
+)
diff --git a/benchmarks/wrappers/openwhisk/python/storage.py b/benchmarks/wrappers/openwhisk/python/storage.py
index 76c7e3e8e..09b9e78a7 100644
--- a/benchmarks/wrappers/openwhisk/python/storage.py
+++ b/benchmarks/wrappers/openwhisk/python/storage.py
@@ -1,8 +1,8 @@
+import logging
 import os
 import uuid
-import json
+
 import minio
-import logging
 
 
 class storage:
@@ -25,14 +25,14 @@ def __init__(self):
                 maxsize=10,
                 retries=urllib3.Retry(
                     total=5, backoff_factor=0.2, status_forcelist=[500, 502, 503, 504]
-                )
+                ),
             )
             self.client = minio.Minio(
                 os.getenv("MINIO_STORAGE_CONNECTION_URL"),
                 access_key=os.getenv("MINIO_STORAGE_ACCESS_KEY"),
                 secret_key=os.getenv("MINIO_STORAGE_SECRET_KEY"),
                 secure=False,
-                http_client=mgr
+                http_client=mgr,
             )
         except Exception as e:
             logging.info(e)
@@ -41,12 +41,9 @@ def __init__(self):
     @staticmethod
     def unique_name(name):
         name, extension = os.path.splitext(name)
-        return '{name}.{random}{extension}'.format(
-                    name=name,
-                    extension=extension,
-                    random=str(uuid.uuid4()).split('-')[0]
-                )
-
+        return "{name}.{random}{extension}".format(
+            name=name, extension=extension, random=str(uuid.uuid4()).split("-")[0]
+        )
 
     def upload(self, bucket, file, filepath):
         key_name = storage.unique_name(file)
@@ -64,9 +61,7 @@ def download_directory(self, bucket, prefix, path):
 
     def upload_stream(self, bucket, file, bytes_data):
         key_name = storage.unique_name(file)
-        self.client.put_object(
-            bucket, key_name, bytes_data, bytes_data.getbuffer().nbytes
-        )
+        self.client.put_object(bucket, key_name, bytes_data, bytes_data.getbuffer().nbytes)
         return key_name
 
     def download_stream(self, bucket, file):