From 83ac08ce3870de4bb04834314c017735c5f7bb04 Mon Sep 17 00:00:00 2001
From: makseq-ubnt <makseq@gmail.com>
Date: Tue, 21 Mar 2023 15:57:45 +0000
Subject: [PATCH] fix: LSDV-4825: Apply black formatter to
 label-studio-converter

---
 label_studio_converter/audio.py               |  29 +-
 label_studio_converter/brush.py               | 155 +++--
 label_studio_converter/cli.py                 |  77 ++-
 label_studio_converter/converter.py           | 546 ++++++++++++------
 label_studio_converter/exports/csv.py         |   8 +-
 label_studio_converter/funsd.py               |  36 +-
 label_studio_converter/imports/coco.py        | 152 +++--
 label_studio_converter/imports/colors.py      |   3 +-
 .../imports/label_config.py                   |  20 +-
 label_studio_converter/imports/pathtrack.py   |  98 ++--
 label_studio_converter/imports/yolo.py        |  97 ++--
 label_studio_converter/main.py                | 115 +++-
 label_studio_converter/utils.py               | 151 +++--
 setup.py                                      |   2 +-
 tests/test_brush.py                           |  36 +-
 tests/test_converter.py                       |   8 +-
 tests/test_converter_conll.py                 |  93 ++-
 tests/test_export.py                          |   5 +-
 tests/test_import_yolo.py                     |  41 +-
 19 files changed, 1113 insertions(+), 559 deletions(-)

diff --git a/label_studio_converter/audio.py b/label_studio_converter/audio.py
index 1e25697d..3ace6b06 100644
--- a/label_studio_converter/audio.py
+++ b/label_studio_converter/audio.py
@@ -10,7 +10,9 @@
 logger = logging.getLogger(__name__)
 
 
-def convert_to_asr_json_manifest(input_data, output_dir, data_key, project_dir, upload_dir, download_resources):
+def convert_to_asr_json_manifest(
+    input_data, output_dir, data_key, project_dir, upload_dir, download_resources
+):
     audio_dir_rel = 'audio'
     output_audio_dir = os.path.join(output_dir, audio_dir_rel)
     ensure_dir(output_dir), ensure_dir(output_audio_dir)
@@ -19,13 +21,24 @@ def convert_to_asr_json_manifest(input_data, output_dir, data_key, project_dir,
         for item in input_data:
             audio_path = item['input'][data_key]
             try:
-                audio_path = download(audio_path, output_audio_dir, project_dir=project_dir, upload_dir=upload_dir,
-                                      return_relative_path=True, download_resources=download_resources)
-                duration = get_audio_duration(os.path.join(output_audio_dir, os.path.basename(audio_path)))
+                audio_path = download(
+                    audio_path,
+                    output_audio_dir,
+                    project_dir=project_dir,
+                    upload_dir=upload_dir,
+                    return_relative_path=True,
+                    download_resources=download_resources,
+                )
+                duration = get_audio_duration(
+                    os.path.join(output_audio_dir, os.path.basename(audio_path))
+                )
             except:
-                logger.info('Unable to download {image_path} or get audio duration. The item {item} will be skipped'.format(
-                    image_path=audio_path, item=item
-                ), exc_info=True)
+                logger.info(
+                    'Unable to download {image_path} or get audio duration. The item {item} will be skipped'.format(
+                        image_path=audio_path, item=item
+                    ),
+                    exc_info=True,
+                )
                 continue
 
             for texts in iter(item['output'].values()):
@@ -37,7 +50,7 @@ def convert_to_asr_json_manifest(input_data, output_dir, data_key, project_dir,
                 'audio_filepath': audio_path,
                 'duration': duration,
                 'text': transcript,
-                'annotator': _get_annotator(item, default='')
+                'annotator': _get_annotator(item, default=''),
             }
             json.dump(metadata, fout)
             fout.write('\n')
diff --git a/label_studio_converter/brush.py b/label_studio_converter/brush.py
index ce98b75f..ef097416 100644
--- a/label_studio_converter/brush.py
+++ b/label_studio_converter/brush.py
@@ -48,28 +48,26 @@ def __init__(self, data):
         self.i = 0
 
     def read(self, size):
-        out = self.data[self.i:self.i + size]
+        out = self.data[self.i : self.i + size]
         self.i += size
         return int(out, 2)
 
 
 def access_bit(data, num):
-    """ from bytes array to bits by num position
-    """
+    """from bytes array to bits by num position"""
     base = int(num // 8)
     shift = 7 - int(num % 8)
     return (data[base] & (1 << shift)) >> shift
 
 
 def bytes2bit(data):
-    """ get bit string from bytes data
-    """
+    """get bit string from bytes data"""
     return ''.join([str(access_bit(data, i)) for i in range(len(data) * 8)])
 
 
 def decode_rle(rle, print_params: bool = False):
-    """ from LS RLE to numpy uint8 3d image [width, height, channel]
-    
+    """from LS RLE to numpy uint8 3d image [width, height, channel]
+
     Args:
         print_params (bool, optional): If true, a RLE parameters print statement is suppressed
     """
@@ -77,10 +75,12 @@ def decode_rle(rle, print_params: bool = False):
     num = input.read(32)
     word_size = input.read(5) + 1
     rle_sizes = [input.read(4) + 1 for _ in range(4)]
-    
+
     if print_params:
-        print('RLE params:', num, 'values', word_size, 'word_size', rle_sizes, 'rle_sizes')
-        
+        print(
+            'RLE params:', num, 'values', word_size, 'word_size', rle_sizes, 'rle_sizes'
+        )
+
     i = 0
     out = np.zeros(num, dtype=np.uint8)
     while i < num:
@@ -99,13 +99,15 @@ def decode_rle(rle, print_params: bool = False):
 
 
 def decode_from_annotation(from_name, results):
-    """ from LS annotation to {"tag_name + label_name": [numpy uint8 image (width x height)]}
-    """
+    """from LS annotation to {"tag_name + label_name": [numpy uint8 image (width x height)]}"""
     layers = {}
     counters = defaultdict(int)
     for result in results:
-        key = 'brushlabels' if result['type'].lower() == 'brushlabels' else \
-            ('labels' if result['type'].lower() == 'labels' else None)
+        key = (
+            'brushlabels'
+            if result['type'].lower() == 'brushlabels'
+            else ('labels' if result['type'].lower() == 'labels' else None)
+        )
         if key is None or 'rle' not in result:
             continue
 
@@ -125,18 +127,36 @@ def decode_from_annotation(from_name, results):
     return layers
 
 
-def save_brush_images_from_annotation(task_id, annotation_id, completed_by,
-                                      from_name, results, out_dir, out_format='numpy'):
+def save_brush_images_from_annotation(
+    task_id,
+    annotation_id,
+    completed_by,
+    from_name,
+    results,
+    out_dir,
+    out_format='numpy',
+):
     layers = decode_from_annotation(from_name, results)
     if isinstance(completed_by, dict):
         email = completed_by.get('email', '')
     else:
         email = str(completed_by)
-    email = "".join(x for x in email if x.isalnum() or x == '@' or x == '.')  # sanitize filename
+    email = "".join(
+        x for x in email if x.isalnum() or x == '@' or x == '.'
+    )  # sanitize filename
 
     for name in layers:
-        filename = os.path.join(out_dir, 'task-' + str(task_id) + '-annotation-' + str(annotation_id)
-                                + '-by-' + email + '-' + name)
+        filename = os.path.join(
+            out_dir,
+            'task-'
+            + str(task_id)
+            + '-annotation-'
+            + str(annotation_id)
+            + '-by-'
+            + email
+            + '-'
+            + name,
+        )
         image = layers[name]
         logger.debug(f'Save image to {filename}')
         if out_format == 'numpy':
@@ -149,16 +169,21 @@ def save_brush_images_from_annotation(task_id, annotation_id, completed_by,
 
 
 def convert_task(item, out_dir, out_format='numpy'):
-    """ Task with multiple annotations to brush images, out_format = numpy | png
-    """
+    """Task with multiple annotations to brush images, out_format = numpy | png"""
     for from_name, results in item['output'].items():
-        save_brush_images_from_annotation(item['id'], item['annotation_id'], item['completed_by'],
-                                          from_name, results, out_dir, out_format)
+        save_brush_images_from_annotation(
+            item['id'],
+            item['annotation_id'],
+            item['completed_by'],
+            from_name,
+            results,
+            out_dir,
+            out_format,
+        )
 
 
 def convert_task_dir(items, out_dir, out_format='numpy'):
-    """ Directory with tasks and annotation to brush images, out_format = numpy | png
-    """
+    """Directory with tasks and annotation to brush images, out_format = numpy | png"""
     for item in items:
         convert_task(item, out_dir, out_format)
 
@@ -170,7 +195,7 @@ def convert_task_dir(items, out_dir, out_format='numpy'):
 
 
 def bits2byte(arr_str, n=8):
-    """ Convert bits back to byte
+    """Convert bits back to byte
 
     :param arr_str:  string with the bit array
     :type arr_str: str
@@ -180,7 +205,7 @@ def bits2byte(arr_str, n=8):
     :type rle: list
     """
     rle = []
-    numbers = [arr_str[i:i + n] for i in range(0, len(arr_str), n)]
+    numbers = [arr_str[i : i + n] for i in range(0, len(arr_str), n)]
     for i in numbers:
         rle.append(int(i, 2))
     return rle
@@ -188,23 +213,23 @@ def bits2byte(arr_str, n=8):
 
 # Shamelessly plagiarized from https://stackoverflow.com/a/32681075/6051733
 def base_rle_encode(inarray):
-    """ run length encoding. Partial credit to R rle function.
-        Multi datatype arrays catered for including non Numpy
-        returns: tuple (runlengths, startpositions, values) """
-    ia = np.asarray(inarray)                # force numpy
+    """run length encoding. Partial credit to R rle function.
+    Multi datatype arrays catered for including non Numpy
+    returns: tuple (runlengths, startpositions, values)"""
+    ia = np.asarray(inarray)  # force numpy
     n = len(ia)
     if n == 0:
         return None, None, None
     else:
-        y = ia[1:] != ia[:-1]               # pairwise unequal (string safe)
-        i = np.append(np.where(y), n - 1)   # must include last element posi
-        z = np.diff(np.append(-1, i))       # run lengths
-        p = np.cumsum(np.append(0, z))[:-1] # positions
+        y = ia[1:] != ia[:-1]  # pairwise unequal (string safe)
+        i = np.append(np.where(y), n - 1)  # must include last element posi
+        z = np.diff(np.append(-1, i))  # run lengths
+        p = np.cumsum(np.append(0, z))[:-1]  # positions
         return z, p, ia[i]
 
 
 def encode_rle(arr, wordsize=8, rle_sizes=[3, 4, 8, 16]):
-    """ Encode a 1d array to rle
+    """Encode a 1d array to rle
 
 
     :param arr: flattened np.array from a 4d image (R, G, B, alpha)
@@ -287,9 +312,8 @@ def encode_rle(arr, wordsize=8, rle_sizes=[3, 4, 8, 16]):
 
             # rle size = 16 or longer
             else:
-
                 length_temp = length_reeks
-                while length_temp > 2 ** 16:
+                while length_temp > 2**16:
                     # Starting with a 1 indicates that we have started a series
                     out_str += '1'
 
@@ -297,7 +321,7 @@ def encode_rle(arr, wordsize=8, rle_sizes=[3, 4, 8, 16]):
                     out_str += f'{2 ** 16 - 1:016b}'
 
                     out_str += f'{value:08b}'
-                    length_temp -= 2 ** 16
+                    length_temp -= 2**16
 
                 # Starting with a 1 indicates that we have started a series
                 out_str += '1'
@@ -328,40 +352,43 @@ def contour2rle(contours, contour_id, img_width, img_height):
     :type img_width: int
     :param img_height: image shape height
     :type img_height: int
-    :return: list of ints in RLE format 
+    :return: list of ints in RLE format
     """
     import cv2  # opencv
+
     mask_im = np.zeros((img_width, img_height, 4))
-    mask_contours = cv2.drawContours(mask_im, contours, contour_id, color=(0, 255, 0, 100), thickness=-1)
+    mask_contours = cv2.drawContours(
+        mask_im, contours, contour_id, color=(0, 255, 0, 100), thickness=-1
+    )
     rle_out = encode_rle(mask_contours.ravel().astype(int))
     return rle_out
 
 
 def mask2rle(mask):
-    """ Convert mask to RLE
-    
+    """Convert mask to RLE
+
     :param mask: uint8 or int np.array mask with len(shape) == 2 like grayscale image
-    :return: list of ints in RLE format 
+    :return: list of ints in RLE format
     """
     assert len(mask.shape) == 2, 'mask must be 2D np.array'
     assert mask.dtype == np.uint8 or mask.dtype == int, 'mask must be uint8 or int'
     array = mask.ravel()
-    array = np.repeat(array, 4)  # must be 4 channels 
+    array = np.repeat(array, 4)  # must be 4 channels
     rle = encode_rle(array)
     return rle
-    
-    
+
+
 def image2rle(path):
-    """ Convert mask image (jpg, png) to RLE
+    """Convert mask image (jpg, png) to RLE
 
     1. Read image as grayscale
     2. Flatten to 1d array
     3. Threshold > 128
     4. Encode
-    
-    :param path: path to image with mask (jpg, png), this image will be thresholded with values > 128 to obtain mask, 
+
+    :param path: path to image with mask (jpg, png), this image will be thresholded with values > 128 to obtain mask,
                  so you can mark background as black and foreground as white
-    :return: list of ints in RLE format 
+    :return: list of ints in RLE format
     """
     with Image.open(path).convert('L') as image:
         mask = np.array((np.array(image) > 128) * 255, dtype=np.uint8)
@@ -371,10 +398,18 @@ def image2rle(path):
         return rle, image.size[0], image.size[1]
 
 
-def image2annotation(path, label_name, from_name, to_name, ground_truth=False, model_version=None, score=None):
-    """ Convert image with mask to brush RLE annotation
+def image2annotation(
+    path,
+    label_name,
+    from_name,
+    to_name,
+    ground_truth=False,
+    model_version=None,
+    score=None,
+):
+    """Convert image with mask to brush RLE annotation
 
-    :param path: path to image with mask (jpg, png), this image will be thresholded with values > 128 to obtain mask, 
+    :param path: path to image with mask (jpg, png), this image will be thresholded with values > 128 to obtain mask,
                  so you can mark background as black and foreground as white
     :param label_name: label name from labeling config (<Label>)
     :param from_name: brush tag name (<BrushLabels>)
@@ -382,7 +417,7 @@ def image2annotation(path, label_name, from_name, to_name, ground_truth=False, m
     :param ground_truth: ground truth annotation true/false
     :param model_version: any string, only for predictions
     :param score: model score as float, only for predictions
-    
+
     :return: dict with Label Studio Annotation or Prediction (Pre-annotation)
     """
     rle, width, height = image2rle(path)
@@ -391,19 +426,13 @@ def image2annotation(path, label_name, from_name, to_name, ground_truth=False, m
             {
                 "id": str(uuid.uuid4())[0:8],
                 "type": "brushlabels",
-                "value": {
-                    "rle": rle,
-                    "format": "rle",
-                    "brushlabels": [
-                        label_name
-                    ]
-                },
+                "value": {"rle": rle, "format": "rle", "brushlabels": [label_name]},
                 "origin": "manual",
                 "to_name": to_name,
                 "from_name": from_name,
                 "image_rotation": 0,
                 "original_width": width,
-                "original_height": height
+                "original_height": height,
             }
         ],
     }
diff --git a/label_studio_converter/cli.py b/label_studio_converter/cli.py
index 5b40969a..f09bdc8a 100644
--- a/label_studio_converter/cli.py
+++ b/label_studio_converter/cli.py
@@ -16,54 +16,71 @@ def __call__(self, parser, namespace, values, option_string=None):
 def main():
     parser = argparse.ArgumentParser(
         description='Converter from Label Studio output completions to various formats',
-        formatter_class=argparse.ArgumentDefaultsHelpFormatter
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
     )
     parser.add_argument(
-        '-i', '--input', dest='input', required=True,
+        '-i',
+        '--input',
+        dest='input',
+        required=True,
         help='Directory or JSON file with completions (e.g. "/<project_path>/completions")',
-        action=ExpandFullPath
+        action=ExpandFullPath,
     )
     parser.add_argument(
-        '-c', '--config', dest='config', required=True,
+        '-c',
+        '--config',
+        dest='config',
+        required=True,
         help='Project config (e.g. "/<project_path>/config.xml")',
-        action=ExpandFullPath
+        action=ExpandFullPath,
     )
     parser.add_argument(
-        '-o', '--output', dest='output',
+        '-o',
+        '--output',
+        dest='output',
         help='Output file or directory (will be created if not exists)',
         default=os.path.join(os.path.dirname(__file__), 'output'),
-        action=ExpandFullPath
+        action=ExpandFullPath,
     )
     parser.add_argument(
-        '-f', '--format', dest='format',
+        '-f',
+        '--format',
+        dest='format',
         metavar='FORMAT',
         help='Output format: ' + ', '.join(f.name for f in Format),
         type=Format.from_string,
         choices=list(Format),
-        default=Format.JSON
+        default=Format.JSON,
     )
     parser.add_argument(
-        '--csv-separator', dest='csv_separator',
+        '--csv-separator',
+        dest='csv_separator',
         help='Separator used in CSV format',
-        default=','
+        default=',',
     )
     parser.add_argument(
-        '--csv-no-header', dest='csv_no_header',
+        '--csv-no-header',
+        dest='csv_no_header',
         help='Whether to omit header in CSV output file',
-        action='store_true'
+        action='store_true',
     )
     parser.add_argument(
-        '--image-dir', dest='image_dir',
+        '--image-dir',
+        dest='image_dir',
         help='In case of image outputs (COCO, VOC, ...), specifies output image directory where downloaded images will '
-             'be stored. (If not specified, local image paths left untouched)'
+        'be stored. (If not specified, local image paths left untouched)',
     )
     parser.add_argument(
-        '--project-dir', dest='project_dir', default=None,
-        help='Label Studio project directory path'
+        '--project-dir',
+        dest='project_dir',
+        default=None,
+        help='Label Studio project directory path',
     )
     parser.add_argument(
-        '--heartex-format', dest='heartex_format', action='store_true',
-        help='Set this flag if your completions are coming from Heartex platform instead of Label Studio'
+        '--heartex-format',
+        dest='heartex_format',
+        action='store_true',
+        help='Set this flag if your completions are coming from Heartex platform instead of Label Studio',
     )
     args = parser.parse_args()
 
@@ -76,13 +93,29 @@ def main():
     elif args.format == Format.CSV:
         header = not args.csv_no_header
         sep = args.csv_separator
-        c.convert_to_csv(args.input, args.output, sep=sep, header=header, is_dir=not args.heartex_format)
+        c.convert_to_csv(
+            args.input,
+            args.output,
+            sep=sep,
+            header=header,
+            is_dir=not args.heartex_format,
+        )
     elif args.format == Format.CONLL2003:
         c.convert_to_conll2003(args.input, args.output, is_dir=not args.heartex_format)
     elif args.format == Format.COCO:
-        c.convert_to_coco(args.input, args.output, output_image_dir=args.image_dir, is_dir=not args.heartex_format)
+        c.convert_to_coco(
+            args.input,
+            args.output,
+            output_image_dir=args.image_dir,
+            is_dir=not args.heartex_format,
+        )
     elif args.format == Format.VOC:
-        c.convert_to_voc(args.input, args.output, output_image_dir=args.image_dir, is_dir=not args.heartex_format)
+        c.convert_to_voc(
+            args.input,
+            args.output,
+            output_image_dir=args.image_dir,
+            is_dir=not args.heartex_format,
+        )
     elif args.format == Format.YOLO:
         c.convert_to_yolo(args.input, args.output, is_dir=not args.heartex_format)
 
diff --git a/label_studio_converter/converter.py b/label_studio_converter/converter.py
index 8ef0ea1e..ef519710 100644
--- a/label_studio_converter/converter.py
+++ b/label_studio_converter/converter.py
@@ -18,8 +18,15 @@
 from PIL import Image
 
 from label_studio_converter.utils import (
-    parse_config, create_tokens_and_tags, download, get_image_size, get_image_size_and_channels, ensure_dir,
-    get_polygon_area, get_polygon_bounding_box, _get_annotator
+    parse_config,
+    create_tokens_and_tags,
+    download,
+    get_image_size,
+    get_image_size_and_channels,
+    ensure_dir,
+    get_polygon_area,
+    get_polygon_bounding_box,
+    _get_annotator,
 )
 from label_studio_converter import brush
 from label_studio_converter.audio import convert_to_asr_json_manifest
@@ -57,84 +64,90 @@ def from_string(cls, s):
 
 
 class Converter(object):
-
     _FORMAT_INFO = {
         Format.JSON: {
             'title': 'JSON',
             'description': "List of items in raw JSON format stored in one JSON file. Use to export both the data "
-                           "and the annotations for a dataset. It's Label Studio Common Format",
-            'link': 'https://labelstud.io/guide/export.html#JSON'
+            "and the annotations for a dataset. It's Label Studio Common Format",
+            'link': 'https://labelstud.io/guide/export.html#JSON',
         },
         Format.JSON_MIN: {
             'title': 'JSON-MIN',
             'description': 'List of items where only "from_name", "to_name" values from the raw JSON format are '
-                           'exported. Use to export only the annotations for a dataset.',
+            'exported. Use to export only the annotations for a dataset.',
             'link': 'https://labelstud.io/guide/export.html#JSON-MIN',
         },
         Format.CSV: {
             'title': 'CSV',
             'description': 'Results are stored as comma-separated values with the column names specified by the '
-                           'values of the "from_name" and "to_name" fields.',
-            'link': 'https://labelstud.io/guide/export.html#CSV'
+            'values of the "from_name" and "to_name" fields.',
+            'link': 'https://labelstud.io/guide/export.html#CSV',
         },
         Format.TSV: {
             'title': 'TSV',
             'description': 'Results are stored in tab-separated tabular file with column names specified by '
-                           '"from_name" "to_name" values',
-            'link': 'https://labelstud.io/guide/export.html#TSV'
+            '"from_name" "to_name" values',
+            'link': 'https://labelstud.io/guide/export.html#TSV',
         },
         Format.CONLL2003: {
             'title': 'CONLL2003',
             'description': 'Popular format used for the CoNLL-2003 named entity recognition challenge.',
             'link': 'https://labelstud.io/guide/export.html#CONLL2003',
-            'tags': ['sequence labeling', 'text tagging', 'named entity recognition']
+            'tags': ['sequence labeling', 'text tagging', 'named entity recognition'],
         },
         Format.COCO: {
             'title': 'COCO',
             'description': 'Popular machine learning format used by the COCO dataset for object detection and image '
-                           'segmentation tasks with polygons and rectangles.',
+            'segmentation tasks with polygons and rectangles.',
             'link': 'https://labelstud.io/guide/export.html#COCO',
-            'tags': ['image segmentation', 'object detection']
+            'tags': ['image segmentation', 'object detection'],
         },
         Format.VOC: {
             'title': 'Pascal VOC XML',
             'description': 'Popular XML format used for object detection and polygon image segmentation tasks.',
             'link': 'https://labelstud.io/guide/export.html#Pascal-VOC-XML',
-            'tags': ['image segmentation', 'object detection']
+            'tags': ['image segmentation', 'object detection'],
         },
         Format.YOLO: {
             'title': 'YOLO',
             'description': 'Popular TXT format is created for each image file. Each txt file contains annotations for '
-                           'the corresponding image file, that is object class, object coordinates, height & width.',
+            'the corresponding image file, that is object class, object coordinates, height & width.',
             'link': 'https://labelstud.io/guide/export.html#YOLO',
-            'tags': ['image segmentation', 'object detection']
+            'tags': ['image segmentation', 'object detection'],
         },
         Format.BRUSH_TO_NUMPY: {
             'title': 'Brush labels to NumPy',
             'description': 'Export your brush labels as NumPy 2d arrays. Each label outputs as one image.',
             'link': 'https://labelstud.io/guide/export.html#Brush-labels-to-NumPy-amp-PNG',
-            'tags': ['image segmentation']
+            'tags': ['image segmentation'],
         },
         Format.BRUSH_TO_PNG: {
             'title': 'Brush labels to PNG',
             'description': 'Export your brush labels as PNG images. Each label outputs as one image.',
             'link': 'https://labelstud.io/guide/export.html#Brush-labels-to-NumPy-amp-PNG',
-            'tags': ['image segmentation']
+            'tags': ['image segmentation'],
         },
         Format.ASR_MANIFEST: {
             'title': 'ASR Manifest',
             'description': 'Export audio transcription labels for automatic speech recognition as the JSON manifest '
-                           'format expected by NVIDIA NeMo models.',
+            'format expected by NVIDIA NeMo models.',
             'link': 'https://labelstud.io/guide/export.html#ASR-MANIFEST',
-            'tags': ['speech recognition']
-        }
+            'tags': ['speech recognition'],
+        },
     }
 
     def all_formats(self):
         return self._FORMAT_INFO
 
-    def __init__(self, config, project_dir, output_tags=None, upload_dir=None, download_resources=True):
-        """ Initialize Label Studio Converter for Exports
+    def __init__(
+        self,
+        config,
+        project_dir,
+        output_tags=None,
+        upload_dir=None,
+        download_resources=True,
+    ):
+        """Initialize Label Studio Converter for Exports
 
         :param config: string or dict: XML string with Label studio labeling config or path to this file or parsed_config
         :param project_dir: upload root directory for images, audio and other labeling files
@@ -158,11 +171,15 @@ def __init__(self, config, project_dir, output_tags=None, upload_dir=None, downl
             self._schema = parse_config(config_string)
 
         if self._schema is None:
-            logger.warning('Label config or schema for Converter is not provided, '
-                           'it might be critical for some export formats, now set schema to empty dict')
+            logger.warning(
+                'Label config or schema for Converter is not provided, '
+                'it might be critical for some export formats, now set schema to empty dict'
+            )
             self._schema = {}
 
-        self._data_keys, self._output_tags = self._get_data_keys_and_output_tags(output_tags)
+        self._data_keys, self._output_tags = self._get_data_keys_and_output_tags(
+            output_tags
+        )
         self._supported_formats = self._get_supported_formats()
 
     def convert(self, input_data, output_data, format, is_dir=True, **kwargs):
@@ -176,35 +193,65 @@ def convert(self, input_data, output_data, format, is_dir=True, **kwargs):
         elif format == Format.CSV:
             header = kwargs.get('csv_header', True)
             sep = kwargs.get('csv_separator', ',')
-            self.convert_to_csv(input_data, output_data, sep=sep, header=header, is_dir=is_dir)
+            self.convert_to_csv(
+                input_data, output_data, sep=sep, header=header, is_dir=is_dir
+            )
         elif format == Format.TSV:
             header = kwargs.get('csv_header', True)
             sep = kwargs.get('csv_separator', '\t')
-            self.convert_to_csv(input_data, output_data, sep=sep, header=header, is_dir=is_dir)
+            self.convert_to_csv(
+                input_data, output_data, sep=sep, header=header, is_dir=is_dir
+            )
         elif format == Format.CONLL2003:
             self.convert_to_conll2003(input_data, output_data, is_dir=is_dir)
         elif format == Format.COCO:
             image_dir = kwargs.get('image_dir')
-            self.convert_to_coco(input_data, output_data, output_image_dir=image_dir, is_dir=is_dir)
+            self.convert_to_coco(
+                input_data, output_data, output_image_dir=image_dir, is_dir=is_dir
+            )
         elif format == Format.YOLO:
             image_dir = kwargs.get('image_dir')
             label_dir = kwargs.get('label_dir')
-            self.convert_to_yolo(input_data, output_data, output_image_dir=image_dir,
-                                 output_label_dir=label_dir, is_dir=is_dir)
+            self.convert_to_yolo(
+                input_data,
+                output_data,
+                output_image_dir=image_dir,
+                output_label_dir=label_dir,
+                is_dir=is_dir,
+            )
         elif format == Format.VOC:
             image_dir = kwargs.get('image_dir')
-            self.convert_to_voc(input_data, output_data, output_image_dir=image_dir, is_dir=is_dir)
+            self.convert_to_voc(
+                input_data, output_data, output_image_dir=image_dir, is_dir=is_dir
+            )
         elif format == Format.BRUSH_TO_NUMPY:
-            items = self.iter_from_dir(input_data) if is_dir else self.iter_from_json_file(input_data)
+            items = (
+                self.iter_from_dir(input_data)
+                if is_dir
+                else self.iter_from_json_file(input_data)
+            )
             brush.convert_task_dir(items, output_data, out_format='numpy')
         elif format == Format.BRUSH_TO_PNG:
-            items = self.iter_from_dir(input_data) if is_dir else self.iter_from_json_file(input_data)
+            items = (
+                self.iter_from_dir(input_data)
+                if is_dir
+                else self.iter_from_json_file(input_data)
+            )
             brush.convert_task_dir(items, output_data, out_format='png')
         elif format == Format.ASR_MANIFEST:
-            items = self.iter_from_dir(input_data) if is_dir else self.iter_from_json_file(input_data)
+            items = (
+                self.iter_from_dir(input_data)
+                if is_dir
+                else self.iter_from_json_file(input_data)
+            )
             convert_to_asr_json_manifest(
-                items, output_data, data_key=self._data_keys[0], project_dir=self.project_dir,
-                upload_dir=self.upload_dir, download_resources=self.download_resources)
+                items,
+                output_data,
+                data_key=self._data_keys[0],
+                project_dir=self.project_dir,
+                upload_dir=self.upload_dir,
+                download_resources=self.download_resources,
+            )
 
     def _get_data_keys_and_output_tags(self, output_tags=None):
         data_keys = set()
@@ -215,7 +262,9 @@ def _get_data_keys_and_output_tags(self, output_tags=None):
                     logger.debug(
                         'Specified tag "{tag}" not found in config schema: '
                         'available options are {schema_keys}'.format(
-                            tag=tag, schema_keys=str(list(self._schema.keys()))))
+                            tag=tag, schema_keys=str(list(self._schema.keys()))
+                        )
+                    )
         for name, info in self._schema.items():
             if output_tags is not None and name not in output_tags:
                 continue
@@ -226,7 +275,12 @@ def _get_data_keys_and_output_tags(self, output_tags=None):
 
     def _get_supported_formats(self):
         if len(self._data_keys) > 1:
-            return [Format.JSON.name, Format.JSON_MIN.name, Format.CSV.name, Format.TSV.name]
+            return [
+                Format.JSON.name,
+                Format.JSON_MIN.name,
+                Format.CSV.name,
+                Format.TSV.name,
+            ]
         output_tag_types = set()
         input_tag_types = set()
         for info in self._schema.values():
@@ -237,21 +291,43 @@ def _get_supported_formats(self):
         all_formats = [f.name for f in Format]
         if not ('Text' in input_tag_types and 'Labels' in output_tag_types):
             all_formats.remove(Format.CONLL2003.name)
-        if not ('Image' in input_tag_types and ('RectangleLabels' in output_tag_types or
-                                                'Rectangle' in output_tag_types and 'Labels' in output_tag_types)):
+        if not (
+            'Image' in input_tag_types
+            and (
+                'RectangleLabels' in output_tag_types
+                or 'Rectangle' in output_tag_types
+                and 'Labels' in output_tag_types
+            )
+        ):
             all_formats.remove(Format.VOC.name)
-        if not ('Image' in input_tag_types and ('RectangleLabels' in output_tag_types or
-                                                'PolygonLabels' in output_tag_types) or
-                                                'Rectangle' in output_tag_types and 'Labels' in output_tag_types or
-                                                'PolygonLabels' in output_tag_types and 'Labels' in output_tag_types):
-
+        if not (
+            'Image' in input_tag_types
+            and (
+                'RectangleLabels' in output_tag_types
+                or 'PolygonLabels' in output_tag_types
+            )
+            or 'Rectangle' in output_tag_types
+            and 'Labels' in output_tag_types
+            or 'PolygonLabels' in output_tag_types
+            and 'Labels' in output_tag_types
+        ):
             all_formats.remove(Format.COCO.name)
             all_formats.remove(Format.YOLO.name)
-        if not ('Image' in input_tag_types and ('BrushLabels' in output_tag_types or 'brushlabels' in output_tag_types or
-                                                'Brush' in output_tag_types and 'Labels' in output_tag_types)):
+        if not (
+            'Image' in input_tag_types
+            and (
+                'BrushLabels' in output_tag_types
+                or 'brushlabels' in output_tag_types
+                or 'Brush' in output_tag_types
+                and 'Labels' in output_tag_types
+            )
+        ):
             all_formats.remove(Format.BRUSH_TO_NUMPY.name)
             all_formats.remove(Format.BRUSH_TO_PNG.name)
-        if not (('Audio' in input_tag_types or 'AudioPlus' in input_tag_types) and 'TextArea' in output_tag_types):
+        if not (
+            ('Audio' in input_tag_types or 'AudioPlus' in input_tag_types)
+            and 'TextArea' in output_tag_types
+        ):
             all_formats.remove(Format.ASR_MANIFEST.name)
 
         return all_formats
@@ -262,14 +338,16 @@ def supported_formats(self):
 
     def iter_from_dir(self, input_dir):
         if not os.path.exists(input_dir):
-            raise FileNotFoundError('{input_dir} doesn\'t exist'.format(input_dir=input_dir))
+            raise FileNotFoundError(
+                '{input_dir} doesn\'t exist'.format(input_dir=input_dir)
+            )
         for json_file in glob(os.path.join(input_dir, '*.json')):
             for item in self.iter_from_json_file(json_file):
                 if item:
                     yield item
 
     def iter_from_json_file(self, json_file):
-        """ Extract annotation results from json file
+        """Extract annotation results from json file
 
         param json_file: path to task list or dict with annotations
         """
@@ -290,12 +368,16 @@ def iter_from_json_file(self, json_file):
     def annotation_result_from_task(self, task):
         has_annotations = 'completions' in task or 'annotations' in task
         if not has_annotations:
-            logger.warning('Each task dict item should contain "annotations" or "completions" [deprecated], '
-                           'where value is list of dicts')
+            logger.warning(
+                'Each task dict item should contain "annotations" or "completions" [deprecated], '
+                'where value is list of dicts'
+            )
             return None
 
         # get last not skipped completion and make result from it
-        annotations = task['annotations'] if 'annotations' in task else task['completions']
+        annotations = (
+            task['annotations'] if 'annotations' in task else task['completions']
+        )
 
         # return task with empty annotations
         if not annotations:
@@ -303,13 +385,17 @@ def annotation_result_from_task(self, task):
             yield data
 
         # skip cancelled annotations
-        cancelled = lambda x: not (x.get('skipped', False) or x.get('was_cancelled', False))
+        cancelled = lambda x: not (
+            x.get('skipped', False) or x.get('was_cancelled', False)
+        )
         annotations = list(filter(cancelled, annotations))
         if not annotations:
             return None
 
         # sort by creation time
-        annotations = sorted(annotations, key=lambda x: x.get('created_at', 0), reverse=True)
+        annotations = sorted(
+            annotations, key=lambda x: x.get('created_at', 0), reverse=True
+        )
 
         for annotation in annotations:
             result = annotation['result']
@@ -341,7 +427,7 @@ def get_data(task, outputs, annotation):
             'annotation_id': annotation.get('id'),
             'created_at': annotation.get('created_at'),
             'updated_at': annotation.get('updated_at'),
-            'lead_time': annotation.get('lead_time')
+            'lead_time': annotation.get('lead_time'),
         }
 
     def _check_format(self, fmt):
@@ -417,7 +503,11 @@ def convert_to_csv(self, input_data, output_dir, is_dir=True, **kwargs):
                 record['id'] = item['id']
             for name, value in item['output'].items():
                 pretty_value = self._prettify(value)
-                record[name] = pretty_value if isinstance(pretty_value, str) else json.dumps(pretty_value, ensure_ascii=False)
+                record[name] = (
+                    pretty_value
+                    if isinstance(pretty_value, str)
+                    else json.dumps(pretty_value, ensure_ascii=False)
+                )
             for name, value in item['input'].items():
                 if isinstance(value, dict) or isinstance(value, list):
                     record[name] = json.dumps(value, ensure_ascii=False)
@@ -462,24 +552,32 @@ def convert_to_conll2003(self, input_data, output_dir, is_dir=True):
             item_iterator = self.iter_from_dir if is_dir else self.iter_from_json_file
 
             for item in item_iterator(input_data):
-                filtered_output = list(filter(lambda x: x[0]['type'].lower() == 'labels', item['output'].values()))
+                filtered_output = list(
+                    filter(
+                        lambda x: x[0]['type'].lower() == 'labels',
+                        item['output'].values(),
+                    )
+                )
                 tokens, tags = create_tokens_and_tags(
                     text=item['input'][data_key],
-                    spans=next(iter(filtered_output), None)
+                    spans=next(iter(filtered_output), None),
                 )
                 for token, tag in zip(tokens, tags):
                     fout.write('{token} -X- _ {tag}\n'.format(token=token, tag=tag))
                 fout.write('\n')
 
-    def convert_to_coco(self, input_data, output_dir, output_image_dir=None, is_dir=True):
-
+    def convert_to_coco(
+        self, input_data, output_dir, output_image_dir=None, is_dir=True
+    ):
         def add_image(images, width, height, image_id, image_path):
-            images.append({
-                'width': width,
-                'height': height,
-                'id': image_id,
-                'file_name': image_path
-            })
+            images.append(
+                {
+                    'width': width,
+                    'height': height,
+                    'id': image_id,
+                    'file_name': image_path,
+                }
+            )
             return images
 
         self._check_format(Format.COCO)
@@ -493,7 +591,11 @@ def add_image(images, width, height, image_id, image_path):
         images, categories, annotations = [], [], []
         categories, category_name_to_id = self._get_labels()
         data_key = self._data_keys[0]
-        item_iterator = self.iter_from_dir(input_data) if is_dir else self.iter_from_json_file(input_data)
+        item_iterator = (
+            self.iter_from_dir(input_data)
+            if is_dir
+            else self.iter_from_json_file(input_data)
+        )
         for item_idx, item in enumerate(item_iterator):
             image_path = item['input'][data_key]
             image_id = len(images)
@@ -502,22 +604,33 @@ def add_image(images, width, height, image_id, image_path):
             # download all images of the dataset, including the ones without annotations
             if not os.path.exists(image_path):
                 try:
-                    image_path = download(image_path, output_image_dir, project_dir=self.project_dir,
-                                          return_relative_path=True, upload_dir=self.upload_dir,
-                                          download_resources=self.download_resources)
+                    image_path = download(
+                        image_path,
+                        output_image_dir,
+                        project_dir=self.project_dir,
+                        return_relative_path=True,
+                        upload_dir=self.upload_dir,
+                        download_resources=self.download_resources,
+                    )
                 except:
-                    logger.info('Unable to download {image_path}. The image of {item} will be skipped'.format(
-                        image_path=image_path, item=item
-                    ), exc_info=True)
+                    logger.info(
+                        'Unable to download {image_path}. The image of {item} will be skipped'.format(
+                            image_path=image_path, item=item
+                        ),
+                        exc_info=True,
+                    )
             # add image to final images list
             try:
                 with Image.open(os.path.join(output_dir, image_path)) as img:
                     width, height = img.size
                 images = add_image(images, width, height, image_id, image_path)
             except:
-                logger.info("Unable to open {image_path}, can't extract width and height for COCO export".format(
-                    image_path=image_path, item=item
-                ), exc_info=True)
+                logger.info(
+                    "Unable to open {image_path}, can't extract width and height for COCO export".format(
+                        image_path=image_path, item=item
+                    ),
+                    exc_info=True,
+                )
 
             # skip tasks without annotations
             if not item['output']:
@@ -527,7 +640,7 @@ def add_image(images, width, height, image_id, image_path):
 
                 logger.warning('No annotations found for item #' + str(item_idx))
                 continue
-          
+
             # concatenate results over all tag names
             labels = []
             for key in item['output']:
@@ -538,7 +651,6 @@ def add_image(images, width, height, image_id, image_path):
                 continue
 
             for label in labels:
-
                 category_name = None
                 for key in ['rectanglelabels', 'polygonlabels', 'labels']:
                     if key in label and len(label[key]) > 0:
@@ -551,7 +663,9 @@ def add_image(images, width, height, image_id, image_path):
 
                 if not height or not width:
                     if 'original_width' not in label or 'original_height' not in label:
-                        logger.debug(f'original_width or original_height not found in {image_path}')
+                        logger.debug(
+                            f'original_width or original_height not found in {image_path}'
+                        )
                         continue
 
                     width, height = label['original_width'], label['original_height']
@@ -563,36 +677,44 @@ def add_image(images, width, height, image_id, image_path):
 
                 if 'rectanglelabels' in label or 'labels' in label:
                     x, y, w, h = self.rotated_rectangle(label)
-                    
+
                     x = x * label["original_width"] / 100
                     y = y * label["original_height"] / 100
                     w = w * label["original_width"] / 100
                     h = h * label["original_height"] / 100
 
-                    annotations.append({
-                        'id': annotation_id,
-                        'image_id': image_id,
-                        'category_id': category_id,
-                        'segmentation': [],
-                        'bbox': [x, y, w, h],
-                        'ignore': 0,
-                        'iscrowd': 0,
-                        'area': w * h,
-                    })
+                    annotations.append(
+                        {
+                            'id': annotation_id,
+                            'image_id': image_id,
+                            'category_id': category_id,
+                            'segmentation': [],
+                            'bbox': [x, y, w, h],
+                            'ignore': 0,
+                            'iscrowd': 0,
+                            'area': w * h,
+                        }
+                    )
                 elif "polygonlabels" in label:
-                    points_abs = [(x / 100 * width, y / 100 * height) for x, y in label["points"]]
+                    points_abs = [
+                        (x / 100 * width, y / 100 * height) for x, y in label["points"]
+                    ]
                     x, y = zip(*points_abs)
 
-                    annotations.append({
-                        'id': annotation_id,
-                        'image_id': image_id,
-                        'category_id': category_id,
-                        'segmentation': [[coord for point in points_abs for coord in point]],
-                        'bbox': get_polygon_bounding_box(x, y),
-                        'ignore': 0,
-                        'iscrowd': 0,
-                        'area': get_polygon_area(x, y)
-                    })
+                    annotations.append(
+                        {
+                            'id': annotation_id,
+                            'image_id': image_id,
+                            'category_id': category_id,
+                            'segmentation': [
+                                [coord for point in points_abs for coord in point]
+                            ],
+                            'bbox': get_polygon_bounding_box(x, y),
+                            'ignore': 0,
+                            'iscrowd': 0,
+                            'area': get_polygon_area(x, y),
+                        }
+                    )
                 else:
                     raise ValueError("Unknown label type")
 
@@ -600,21 +722,33 @@ def add_image(images, width, height, image_id, image_path):
                     annotations[-1].update({'annotator': _get_annotator(item)})
 
         with io.open(output_file, mode='w', encoding='utf8') as fout:
-            json.dump({
-                'images': images,
-                'categories': categories,
-                'annotations': annotations,
-                'info': {
-                    'year': datetime.now().year,
-                    'version': '1.0',
-                    'description': '',
-                    'contributor': 'Label Studio',
-                    'url': '',
-                    'date_created': str(datetime.now())
-                }
-            }, fout, indent=2)
-
-    def convert_to_yolo(self, input_data, output_dir, output_image_dir=None, output_label_dir=None, is_dir=True, split_labelers=False):
+            json.dump(
+                {
+                    'images': images,
+                    'categories': categories,
+                    'annotations': annotations,
+                    'info': {
+                        'year': datetime.now().year,
+                        'version': '1.0',
+                        'description': '',
+                        'contributor': 'Label Studio',
+                        'url': '',
+                        'date_created': str(datetime.now()),
+                    },
+                },
+                fout,
+                indent=2,
+            )
+
+    def convert_to_yolo(
+        self,
+        input_data,
+        output_dir,
+        output_image_dir=None,
+        output_label_dir=None,
+        is_dir=True,
+        split_labelers=False,
+    ):
         """Convert data in a specific format to the YOLO format.
 
         Parameters
@@ -648,29 +782,47 @@ def convert_to_yolo(self, input_data, output_dir, output_image_dir=None, output_
             os.makedirs(output_label_dir, exist_ok=True)
         categories, category_name_to_id = self._get_labels()
         data_key = self._data_keys[0]
-        item_iterator = self.iter_from_dir(input_data) if is_dir else self.iter_from_json_file(input_data)
+        item_iterator = (
+            self.iter_from_dir(input_data)
+            if is_dir
+            else self.iter_from_json_file(input_data)
+        )
         for item_idx, item in enumerate(item_iterator):
             # get image path and label file path
             image_path = item['input'][data_key]
             # download image
             if not os.path.exists(image_path):
                 try:
-                    image_path = download(image_path, output_image_dir, project_dir=self.project_dir,
-                                          return_relative_path=True, upload_dir=self.upload_dir,
-                                          download_resources=self.download_resources)
+                    image_path = download(
+                        image_path,
+                        output_image_dir,
+                        project_dir=self.project_dir,
+                        return_relative_path=True,
+                        upload_dir=self.upload_dir,
+                        download_resources=self.download_resources,
+                    )
                 except:
-                    logger.info('Unable to download {image_path}. The item {item} will be skipped'.format(
-                        image_path=image_path, item=item
-                    ), exc_info=True)
+                    logger.info(
+                        'Unable to download {image_path}. The item {item} will be skipped'.format(
+                            image_path=image_path, item=item
+                        ),
+                        exc_info=True,
+                    )
 
             # create dedicated subfolder for each labeler if split_labelers=True
             labeler_subfolder = str(item['completed_by']) if split_labelers else ''
-            os.makedirs(os.path.join(output_label_dir, labeler_subfolder), exist_ok=True)
+            os.makedirs(
+                os.path.join(output_label_dir, labeler_subfolder), exist_ok=True
+            )
 
             # identify label file path
             filename = os.path.splitext(os.path.basename(image_path))[0]
-            filename = filename[0:255 - 4]  # urls might be too long, use 255 bytes (-4 for .txt) limit for filenames
-            label_path = os.path.join(output_label_dir, labeler_subfolder, filename + '.txt')
+            filename = filename[
+                0 : 255 - 4
+            ]  # urls might be too long, use 255 bytes (-4 for .txt) limit for filenames
+            label_path = os.path.join(
+                output_label_dir, labeler_subfolder, filename + '.txt'
+            )
 
             # Skip tasks without annotations
             if not item['output']:
@@ -695,7 +847,7 @@ def convert_to_yolo(self, input_data, output_dir, output_image_dir=None, output_
             annotations = []
             for label in labels:
                 category_name = None
-                category_names = []     # considering multi-label
+                category_names = []  # considering multi-label
                 for key in ['rectanglelabels', 'polygonlabels', 'labels']:
                     if key in label and len(label[key]) > 0:
                         # change to save multi-label
@@ -703,46 +855,60 @@ def convert_to_yolo(self, input_data, output_dir, output_image_dir=None, output_
                             category_names.append(category_name)
 
                 if len(category_names) == 0:
-                    logger.debug("Unknown label type or labels are empty: " + str(label))
+                    logger.debug(
+                        "Unknown label type or labels are empty: " + str(label)
+                    )
                     continue
 
                 for category_name in category_names:
                     if category_name not in category_name_to_id:
                         category_id = len(categories)
                         category_name_to_id[category_name] = category_id
-                        categories.append({
-                            'id': category_id,
-                            'name': category_name
-                        })
+                        categories.append({'id': category_id, 'name': category_name})
                     category_id = category_name_to_id[category_name]
 
                     if "rectanglelabels" in label or 'labels' in label:
                         x, y, w, h = self.rotated_rectangle(label)
-                        annotations.append([category_id, (x + w / 2) / 100, (y + h / 2) / 100, w / 100, h / 100])
+                        annotations.append(
+                            [
+                                category_id,
+                                (x + w / 2) / 100,
+                                (y + h / 2) / 100,
+                                w / 100,
+                                h / 100,
+                            ]
+                        )
                     elif "polygonlabels" in label:
                         points_abs = [(x / 100, y / 100) for x, y in label["points"]]
-                        annotations.append([category_id] + [coord for point in points_abs for coord in point])
+                        annotations.append(
+                            [category_id]
+                            + [coord for point in points_abs for coord in point]
+                        )
                     else:
                         raise ValueError(f"Unknown label type {label}")
             with open(label_path, 'w') as f:
                 for annotation in annotations:
                     for idx, l in enumerate(annotation):
-                        if idx == len(annotation) -1:
+                        if idx == len(annotation) - 1:
                             f.write(f"{l}\n")
                         else:
                             f.write(f"{l} ")
         with open(class_file, 'w', encoding='utf8') as f:
             for c in categories:
-                f.write(c['name']+'\n')
+                f.write(c['name'] + '\n')
         with io.open(notes_file, mode='w', encoding='utf8') as fout:
-            json.dump({
-                'categories': categories,
-                'info': {
-                    'year': datetime.now().year,
-                    'version': '1.0',
-                    'contributor': 'Label Studio'
-                }
-            }, fout, indent=2)
+            json.dump(
+                {
+                    'categories': categories,
+                    'info': {
+                        'year': datetime.now().year,
+                        'version': '1.0',
+                        'contributor': 'Label Studio',
+                    },
+                },
+                fout,
+                indent=2,
+            )
 
     @staticmethod
     def rotated_rectangle(label):
@@ -753,17 +919,29 @@ def rotated_rectangle(label):
             label["height"],
             label["rotation"] if "rotation" in label else 0.0,
         )
-        
+
         if abs(label_r) > 0:
             alpha = math.atan(label_h / label_w)
-            beta = math.pi * (label_r / 180)  # Label studio defines the angle towards the vertical axis
-            
-            radius = math.sqrt((label_w/2) ** 2 + (label_h/2) ** 2)
-            
+            beta = math.pi * (
+                label_r / 180
+            )  # Label studio defines the angle towards the vertical axis
+
+            radius = math.sqrt((label_w / 2) ** 2 + (label_h / 2) ** 2)
+
             # Label studio saves the position of top left corner after rotation
-            x_0 = label_x - radius * (math.cos(math.pi - alpha - beta) - math.cos(math.pi - alpha)) + label_w / 2
-            y_0 = label_y + radius * (math.sin(math.pi - alpha - beta) - math.sin(math.pi - alpha)) + label_h / 2
-            
+            x_0 = (
+                label_x
+                - radius
+                * (math.cos(math.pi - alpha - beta) - math.cos(math.pi - alpha))
+                + label_w / 2
+            )
+            y_0 = (
+                label_y
+                + radius
+                * (math.sin(math.pi - alpha - beta) - math.sin(math.pi - alpha))
+                + label_h / 2
+            )
+
             theta_1 = alpha + beta
             theta_2 = math.pi - alpha + beta
             theta_3 = math.pi + alpha + beta
@@ -781,16 +959,17 @@ def rotated_rectangle(label):
                 y_0 + radius * math.sin(theta_3),
                 y_0 + radius * math.sin(theta_4),
             ]
-            
+
             label_x = min(x_coord)
             label_y = min(y_coord)
             label_w = max(x_coord) - label_x
-            label_h = max(y_coord) - label_y 
-        
-        return label_x, label_y, label_w, label_h
+            label_h = max(y_coord) - label_y
 
-    def convert_to_voc(self, input_data, output_dir, output_image_dir=None, is_dir=True):
+        return label_x, label_y, label_w, label_h
 
+    def convert_to_voc(
+        self, input_data, output_dir, output_image_dir=None, is_dir=True
+    ):
         ensure_dir(output_dir)
         if output_image_dir is not None:
             ensure_dir(output_image_dir)
@@ -807,7 +986,11 @@ def create_child_node(doc, tag, attr, parent_node):
             parent_node.appendChild(child_node)
 
         data_key = self._data_keys[0]
-        item_iterator = self.iter_from_dir(input_data) if is_dir else self.iter_from_json_file(input_data)
+        item_iterator = (
+            self.iter_from_dir(input_data)
+            if is_dir
+            else self.iter_from_json_file(input_data)
+        )
         for item_idx, item in enumerate(item_iterator):
             image_path = item['input'][data_key]
             annotations_dir = os.path.join(output_dir, 'Annotations')
@@ -818,13 +1001,24 @@ def create_child_node(doc, tag, attr, parent_node):
             if not os.path.exists(image_path):
                 try:
                     image_path = download(
-                        image_path, output_image_dir, project_dir=self.project_dir,
-                        upload_dir=self.upload_dir, return_relative_path=True, download_resources=self.download_resources)
+                        image_path,
+                        output_image_dir,
+                        project_dir=self.project_dir,
+                        upload_dir=self.upload_dir,
+                        return_relative_path=True,
+                        download_resources=self.download_resources,
+                    )
                 except:
-                    logger.info('Unable to download {image_path}. The item {item} will be skipped'.format(
-                        image_path=image_path, item=item), exc_info=True)
+                    logger.info(
+                        'Unable to download {image_path}. The item {item} will be skipped'.format(
+                            image_path=image_path, item=item
+                        ),
+                        exc_info=True,
+                    )
                 else:
-                    full_image_path = os.path.join(output_image_dir, os.path.basename(image_path))
+                    full_image_path = os.path.join(
+                        output_image_dir, os.path.basename(image_path)
+                    )
                     # retrieve number of channels from downloaded image
                     try:
                         _, _, channels = get_image_size_and_channels(full_image_path)
@@ -849,7 +1043,9 @@ def create_child_node(doc, tag, attr, parent_node):
                 continue
 
             if 'original_width' not in bboxes[0] or 'original_height' not in bboxes[0]:
-                logger.debug(f'original_width or original_height not found in {image_name}')
+                logger.debug(
+                    f'original_width or original_height not found in {image_name}'
+                )
                 continue
 
             width, height = bboxes[0]['original_width'], bboxes[0]['original_height']
@@ -881,7 +1077,11 @@ def create_child_node(doc, tag, attr, parent_node):
             create_child_node(doc, 'segmented', '0', root_node)
 
             for bbox in bboxes:
-                key = 'rectanglelabels' if 'rectanglelabels' in bbox else ('labels' if 'labels' in bbox else None)
+                key = (
+                    'rectanglelabels'
+                    if 'rectanglelabels' in bbox
+                    else ('labels' if 'labels' in bbox else None)
+                )
                 if key is None or len(bbox[key]) == 0:
                     continue
 
@@ -918,10 +1118,9 @@ def _get_labels(self):
             attrs = info['labels_attrs']
             for label in attrs:
                 if attrs[label].get('category'):
-                    categories.append({
-                        'id': attrs[label].get('category'),
-                        'name': label
-                    })
+                    categories.append(
+                        {'id': attrs[label].get('category'), 'name': label}
+                    )
                     category_name_to_id[label] = attrs[label].get('category')
         labels_to_add = set(labels) - set(list(category_name_to_id.keys()))
         labels_to_add = sorted(list(labels_to_add))
@@ -929,10 +1128,7 @@ def _get_labels(self):
         while idx in list(category_name_to_id.values()):
             idx += 1
         for label in labels_to_add:
-            categories.append({
-                'id': idx,
-                'name': label
-            })
+            categories.append({'id': idx, 'name': label})
             category_name_to_id[label] = idx
             idx += 1
             while idx in list(category_name_to_id.values()):
diff --git a/label_studio_converter/exports/csv.py b/label_studio_converter/exports/csv.py
index 9424d8a2..1e7c3591 100644
--- a/label_studio_converter/exports/csv.py
+++ b/label_studio_converter/exports/csv.py
@@ -7,7 +7,6 @@
 
 
 class ExportToCSV(object):
-
     def __init__(self, tasks):
         if isinstance(tasks, str) and tasks.endswith('.json'):
             if not os.path.exists(tasks):
@@ -37,7 +36,6 @@ def _minify_result(self, result):
             return value
 
     def _get_annotation_results(self, annotation, minify, flat_regions):
-
         results = annotation['result']
         if not flat_regions:
             yield {'result': results}
@@ -66,10 +64,12 @@ def to_records(self, minify=True, flat_regions=True):
                 record = {
                     'id': task['id'],
                     'annotation_id': annotation.get('id'),
-                    'annotator': self._get_annotator_id(annotation)
+                    'annotator': self._get_annotator_id(annotation),
                 }
                 record.update(task['data'])
-                for result in self._get_annotation_results(annotation, minify, flat_regions):
+                for result in self._get_annotation_results(
+                    annotation, minify, flat_regions
+                ):
                     rec = deepcopy(record)
                     rec.update(result)
                     records.append(rec)
diff --git a/label_studio_converter/funsd.py b/label_studio_converter/funsd.py
index 5c100003..a050e5df 100644
--- a/label_studio_converter/funsd.py
+++ b/label_studio_converter/funsd.py
@@ -39,24 +39,23 @@ def convert_annotation_to_fund(result):
     counter = 0
     for key in pre:
         counter += 1
-        output.append({
-            "id": counter,
-            "box": pre[key]['box'],
-            "text": pre[key]['text'],
-            "label": pre[key]['label'],
-            "words": [
-                {
-                    "box": pre[key]['box'],
-                    "text": pre[key]['text']
-                }
-            ],
-            "linking": []
-        })
+        output.append(
+            {
+                "id": counter,
+                "box": pre[key]['box'],
+                "text": pre[key]['text'],
+                "label": pre[key]['label'],
+                "words": [{"box": pre[key]['box'], "text": pre[key]['text']}],
+                "linking": [],
+            }
+        )
 
     return {'form': output}
 
 
-def ls_to_funsd_converter(ls_export_path='export.json', funsd_dir='funsd', data_key='ocr'):
+def ls_to_funsd_converter(
+    ls_export_path='export.json', funsd_dir='funsd', data_key='ocr'
+):
     with open(ls_export_path) as f:
         tasks = json.load(f)
 
@@ -67,8 +66,10 @@ def ls_to_funsd_converter(ls_export_path='export.json', funsd_dir='funsd', data_
             output = convert_annotation_to_fund(annotation['result'])
             filename = task["data"][data_key]
             filename = os.path.basename(filename)
-            filename = f'{funsd_dir}/task-{task["id"]}-annotation-{annotation["id"]}-' \
-                       f'{filename}.json'
+            filename = (
+                f'{funsd_dir}/task-{task["id"]}-annotation-{annotation["id"]}-'
+                f'{filename}.json'
+            )
 
             with open(filename, 'w') as f:
                 json.dump(output, f)
@@ -76,7 +77,8 @@ def ls_to_funsd_converter(ls_export_path='export.json', funsd_dir='funsd', data_
 
 if __name__ == '__main__':
     import sys
+
     print('Usage:', sys.argv[0], 'export.json')
     print('This command will export your LS OCR annotations to "./funsd/" directory')
-	
+
     ls_to_funsd_converter(sys.argv[1])
diff --git a/label_studio_converter/imports/coco.py b/label_studio_converter/imports/coco.py
index 4a93dd98..57a6deb3 100644
--- a/label_studio_converter/imports/coco.py
+++ b/label_studio_converter/imports/coco.py
@@ -12,16 +12,14 @@
 
 def new_task(out_type, root_url, file_name):
     return {
-        "data": {
-            "image": os.path.join(root_url, file_name)
-        },
+        "data": {"image": os.path.join(root_url, file_name)},
         # 'annotations' or 'predictions'
         out_type: [
             {
                 "result": [],
                 "ground_truth": False,
             }
-        ]
+        ],
     }
 
 
@@ -38,22 +36,23 @@ def create_bbox(annotation, categories, from_name, image_height, image_width, to
             "width": width / image_width * 100.0,
             "height": height / image_height * 100.0,
             "rotation": 0,
-            "rectanglelabels": [
-                label
-            ]
+            "rectanglelabels": [label],
         },
         "to_name": to_name,
         "from_name": from_name,
         "image_rotation": 0,
         "original_width": image_width,
-        "original_height": image_height
+        "original_height": image_height,
     }
     return item
 
-def create_segmentation(annotation, categories, from_name, image_height, image_width, to_name):
+
+def create_segmentation(
+    annotation, categories, from_name, image_height, image_width, to_name
+):
     label = categories[int(annotation['category_id'])]
     segmentation = annotation['segmentation'][0]
-    points = [list(x) for x in zip(*[iter(segmentation)]*2)]
+    points = [list(x) for x in zip(*[iter(segmentation)] * 2)]
 
     for i in range(len(points)):
         points[i][0] = points[i][0] / image_width * 100.0
@@ -62,27 +61,25 @@ def create_segmentation(annotation, categories, from_name, image_height, image_w
     item = {
         "id": uuid.uuid4().hex[0:10],
         "type": "polygonlabels",
-        "value": {
-            "points": points,
-            "polygonlabels": [
-                label
-            ]
-        },
+        "value": {"points": points, "polygonlabels": [label]},
         "to_name": to_name,
         "from_name": from_name,
         "image_rotation": 0,
         "original_width": image_width,
-        "original_height": image_height
+        "original_height": image_height,
     }
     return item
 
-def create_keypoints(annotation, categories, from_name, to_name, image_height, image_width, point_width):
+
+def create_keypoints(
+    annotation, categories, from_name, to_name, image_height, image_width, point_width
+):
     label = categories[int(annotation['category_id'])]
     points = annotation['keypoints']
     items = []
 
     for i in range(0, len(points), 3):
-        x, y, v = points[i:i+3]  # x, y, visibility
+        x, y, v = points[i : i + 3]  # x, y, visibility
         x, y, v = float(x), float(y), int(v)
         item = {
             "id": uuid.uuid4().hex[0:10],
@@ -91,15 +88,13 @@ def create_keypoints(annotation, categories, from_name, to_name, image_height, i
                 "x": x / image_width * 100.0,
                 "y": y / image_height * 100.0,
                 "width": point_width,
-                "keypointlabels": [
-                    label
-                ]
+                "keypointlabels": [label],
             },
             "to_name": to_name,
             "from_name": from_name,
             "image_rotation": 0,
             "original_width": image_width,
-            "original_height": image_height
+            "original_height": image_height,
         }
 
         # visibility
@@ -110,13 +105,17 @@ def create_keypoints(annotation, categories, from_name, to_name, image_height, i
     return items
 
 
-def convert_coco_to_ls(input_file, out_file,
-                       to_name='image', from_name='label', out_type="annotations",
-                       image_root_url='/data/local-files/?d=',
-                       use_super_categories=False,
-                       point_width=1.0):
-
-    """ Convert COCO labeling to Label Studio JSON
+def convert_coco_to_ls(
+    input_file,
+    out_file,
+    to_name='image',
+    from_name='label',
+    out_type="annotations",
+    image_root_url='/data/local-files/?d=',
+    use_super_categories=False,
+    point_width=1.0,
+):
+    """Convert COCO labeling to Label Studio JSON
 
     :param input_file: file with COCO json
     :param out_file: output file with Label Studio JSON tasks
@@ -152,12 +151,17 @@ def convert_coco_to_ls(input_file, out_file,
     # mapping: image id => image
     images = {item['id']: item for item in coco['images']}
 
-    logger.info(f'Found {len(categories)} categories, {len(images)} images and {len(coco["annotations"])} annotations')
+    logger.info(
+        f'Found {len(categories)} categories, {len(images)} images and {len(coco["annotations"])} annotations'
+    )
 
     # flags for labeling config composing
     segmentation = bbox = keypoints = rle = False
     segmentation_once = bbox_once = keypoints_once = rle_once = False
-    rectangles_from_name, keypoints_from_name = from_name + '_rectangles', from_name + '_keypoints'
+    rectangles_from_name, keypoints_from_name = (
+        from_name + '_rectangles',
+        from_name + '_keypoints',
+    )
     segmentation_from_name = from_name + 'polygons'
     tags = {}
 
@@ -170,7 +174,9 @@ def convert_coco_to_ls(input_file, out_file,
         segmentation |= 'segmentation' in annotation
         bbox |= 'bbox' in annotation
         keypoints |= 'keypoints' in annotation
-        rle |= annotation.get('iscrowd') == 1  # 0 - polygons are in segmentation, otherwise rle
+        rle |= (
+            annotation.get('iscrowd') == 1
+        )  # 0 - polygons are in segmentation, otherwise rle
 
         if rle and not rle_once:  # not supported
             logger.error('RLE in segmentation is not yet supported in COCO')
@@ -190,21 +196,46 @@ def convert_coco_to_ls(input_file, out_file,
         # read image sizes
         image_id = annotation['image_id']
         image = images[image_id]
-        image_file_name, image_width, image_height = image['file_name'], image['width'], image['height']
+        image_file_name, image_width, image_height = (
+            image['file_name'],
+            image['width'],
+            image['height'],
+        )
 
         task = tasks[image_id]
 
         if 'bbox' in annotation:
-            item = create_bbox(annotation, categories, rectangles_from_name, image_height, image_width, to_name)
+            item = create_bbox(
+                annotation,
+                categories,
+                rectangles_from_name,
+                image_height,
+                image_width,
+                to_name,
+            )
             task[out_type][0]['result'].append(item)
 
         if 'segmentation' in annotation:
-            item = create_segmentation(annotation, categories, segmentation_from_name, image_height, image_width, to_name)
+            item = create_segmentation(
+                annotation,
+                categories,
+                segmentation_from_name,
+                image_height,
+                image_width,
+                to_name,
+            )
             task[out_type][0]['result'].append(item)
 
         if 'keypoints' in annotation:
-            items = create_keypoints(annotation, categories, keypoints_from_name, to_name,
-                                     image_height, image_width, point_width)
+            items = create_keypoints(
+                annotation,
+                categories,
+                keypoints_from_name,
+                to_name,
+                image_height,
+                image_width,
+                point_width,
+            )
             task[out_type][0]['result'] += items
 
         tasks[image_id] = task
@@ -219,12 +250,14 @@ def convert_coco_to_ls(input_file, out_file,
         with open(out_file, 'w') as out:
             json.dump(tasks, out)
 
-        print('\n'
-              f'  1. Create a new project in Label Studio\n'
-              f'  2. Use Labeling Config from "{label_config_file}"\n'
-              f'  3. Setup serving for images [e.g. you can use Local Storage (or others):\n'
-              f'     https://labelstud.io/guide/storage.html#Local-storage]\n'
-              f'  4. Import "{out_file}" to the project\n')
+        print(
+            '\n'
+            f'  1. Create a new project in Label Studio\n'
+            f'  2. Use Labeling Config from "{label_config_file}"\n'
+            f'  3. Setup serving for images [e.g. you can use Local Storage (or others):\n'
+            f'     https://labelstud.io/guide/storage.html#Local-storage]\n'
+            f'  4. Import "{out_file}" to the project\n'
+        )
     else:
         logger.error('No labels converted')
 
@@ -233,40 +266,49 @@ def add_parser(subparsers):
     coco = subparsers.add_parser('coco')
 
     coco.add_argument(
-        '-i', '--input', dest='input', required=True,
+        '-i',
+        '--input',
+        dest='input',
+        required=True,
         help='directory with COCO where images, labels, notes.json are located',
-        action=ExpandFullPath
+        action=ExpandFullPath,
     )
     coco.add_argument(
-        '-o', '--output', dest='output',
+        '-o',
+        '--output',
+        dest='output',
         help='output file with Label Studio JSON tasks',
         default='output.json',
-        action=ExpandFullPath
+        action=ExpandFullPath,
     )
     coco.add_argument(
-        '--to-name', dest='to_name',
+        '--to-name',
+        dest='to_name',
         help='object name from Label Studio labeling config',
         default='image',
     )
     coco.add_argument(
-        '--from-name', dest='from_name',
+        '--from-name',
+        dest='from_name',
         help='control tag name from Label Studio labeling config',
         default='label',
     )
     coco.add_argument(
-        '--out-type', dest='out_type',
+        '--out-type',
+        dest='out_type',
         help='annotation type - "annotations" or "predictions"',
         default='annotations',
     )
     coco.add_argument(
-        '--image-root-url', dest='image_root_url',
+        '--image-root-url',
+        dest='image_root_url',
         help='root URL path where images will be hosted, e.g.: http://example.com/images',
         default='/data/local-files/?d=',
     )
     coco.add_argument(
-        '--point-width', dest='point_width',
+        '--point-width',
+        dest='point_width',
         help='key point width (size)',
         default=1.0,
-        type=float
+        type=float,
     )
-
diff --git a/label_studio_converter/imports/colors.py b/label_studio_converter/imports/colors.py
index f5096483..708aafb5 100644
--- a/label_studio_converter/imports/colors.py
+++ b/label_studio_converter/imports/colors.py
@@ -194,4 +194,5 @@
     (6, 124, 142),
     (80, 97, 157),
     (216, 113, 201),
-    (24, 109, 67)]
+    (24, 109, 67),
+]
diff --git a/label_studio_converter/imports/label_config.py b/label_studio_converter/imports/label_config.py
index 42750b00..96794ad4 100644
--- a/label_studio_converter/imports/label_config.py
+++ b/label_studio_converter/imports/label_config.py
@@ -12,7 +12,9 @@
 """
 
 
-def generate_label_config(categories, tags, to_name='image', from_name='label', filename=None):
+def generate_label_config(
+    categories, tags, to_name='image', from_name='label', filename=None
+):
     labels = ''
     for key in sorted(categories.keys()):
         color = COLORS[int(key) % len(COLORS)]
@@ -21,14 +23,20 @@ def generate_label_config(categories, tags, to_name='image', from_name='label',
 
     body = ''
     for from_name in tags:
-        tag_body = str(LABELS) \
-            .replace('{# TAG_NAME #}', tags[from_name]) \
-            .replace('{# LABELS #}', labels) \
-            .replace('{# TO_NAME #}', to_name) \
+        tag_body = (
+            str(LABELS)
+            .replace('{# TAG_NAME #}', tags[from_name])
+            .replace('{# LABELS #}', labels)
+            .replace('{# TO_NAME #}', to_name)
             .replace('{# FROM_NAME #}', from_name)
+        )
         body += f'\n  <Header value="{tags[from_name]}"/>' + tag_body
 
-    config = str(LABELING_CONFIG).replace('{# BODY #}', body).replace('{# TO_NAME #}', to_name)
+    config = (
+        str(LABELING_CONFIG)
+        .replace('{# BODY #}', body)
+        .replace('{# TO_NAME #}', to_name)
+    )
 
     if filename:
         with open(filename, 'w') as f:
diff --git a/label_studio_converter/imports/pathtrack.py b/label_studio_converter/imports/pathtrack.py
index 4c925453..3e06be0b 100644
--- a/label_studio_converter/imports/pathtrack.py
+++ b/label_studio_converter/imports/pathtrack.py
@@ -35,7 +35,7 @@ def get_info(path):
             fps=float(b.root.doc.fps.get_text()),
             original_width=int(b.root.doc.imw.get_text()),
             original_height=int(b.root.doc.imh.get_text()),
-            frame_count=int(b.root.doc.num_frames.get_text())
+            frame_count=int(b.root.doc.num_frames.get_text()),
         )
 
 
@@ -47,22 +47,15 @@ def new_task(data, result, ground_truth=False, model_version=None, score=None):
     :param model_version: if not None, there will be prediction
     :param score: prediction score, used only if model_version is not None
     """
-    task = {
-        "data": data
-    }
+    task = {"data": data}
 
     # add predictions or annotations
     if model_version:
-        task["predictions"] = [{
-            "result": result,
-            "model_version": model_version,
-            "score": score
-        }]
+        task["predictions"] = [
+            {"result": result, "model_version": model_version, "score": score}
+        ]
     else:
-        task["annotations"] = [{
-            "result": result,
-            "ground_truth": ground_truth
-        }]
+        task["annotations"] = [{"result": result, "ground_truth": ground_truth}]
 
     return task
 
@@ -71,15 +64,10 @@ def new_region(labels, info, from_name, to_name):
     region = {
         "id": uuid.uuid4().hex[0:10],
         "type": "videorectangle",
-        "value": {
-            "sequence": [
-
-            ],
-            "framesCount": info.frame_count
-        },
+        "value": {"sequence": [], "framesCount": info.frame_count},
         "origin": "manual",
         "to_name": to_name,
-        "from_name": from_name
+        "from_name": from_name,
     }
 
     if labels is not None:
@@ -98,7 +86,7 @@ def new_keyframe(region, bbox, info):
             "time": bbox.frame / info.fps,
             "frame": bbox.frame,
             "enabled": False,
-            "rotation": 0
+            "rotation": 0,
         }
     )
     return region
@@ -114,13 +102,16 @@ def generator(path):
             frame=int(v[0]),
             bbox_id=int(v[1]),
             label_id=int(v[1]),
-
-            x=int(v[2]), y=int(v[3]),
-            width=int(v[4]), height=int(v[5])
+            x=int(v[2]),
+            y=int(v[3]),
+            width=int(v[4]),
+            height=int(v[5]),
         )
 
 
-def create_config(from_name='box', to_name='video', source_value='video', target_fps=None):
+def create_config(
+    from_name='box', to_name='video', source_value='video', target_fps=None
+):
     return f"""<View>
    <Header>Label the video:</Header>
    <Video name="{to_name}" value="${source_value}" framerate="{target_fps}"/>
@@ -134,10 +125,17 @@ def create_config(from_name='box', to_name='video', source_value='video', target
     """
 
 
-def convert_shot(input_url, label_file, info_file,
-                 from_name='box', to_name='video', source_value='video',
-                 target_fps=None, hop_keyframes=0):
-    """ Convert bounding boxes from PathTrack to Label Studio video format
+def convert_shot(
+    input_url,
+    label_file,
+    info_file,
+    from_name='box',
+    to_name='video',
+    source_value='video',
+    target_fps=None,
+    hop_keyframes=0,
+):
+    """Convert bounding boxes from PathTrack to Label Studio video format
 
     :param input_url: video file
     :param label_file: text file with annotations line by line
@@ -180,18 +178,29 @@ def convert_shot(input_url, label_file, info_file,
     if hop_keyframes > 1:
         for r in regions:
             last = regions[r]['value']['sequence'][-1]
-            regions[r]['value']['sequence'] = regions[r]['value']['sequence'][0:-1:hop_keyframes]
+            regions[r]['value']['sequence'] = regions[r]['value']['sequence'][
+                0:-1:hop_keyframes
+            ]
             if regions[r]['value']['sequence'][-1] != last:
                 regions[r]['value']['sequence'].append(last)
 
-    logger.info('Shot with %i regions and %i keyframes created', len(regions), keyframe_count)
+    logger.info(
+        'Shot with %i regions and %i keyframes created', len(regions), keyframe_count
+    )
     data = {source_value: input_url}
     return new_task(data, result=list(regions.values()))
 
 
-def convert_dataset(root_dir, root_url, from_name='box', to_name='video', source_value='video',
-                    target_fps=None, hop_keyframes=0):
-    """ Convert PathTrack dataset to Label Studio video labeling format
+def convert_dataset(
+    root_dir,
+    root_url,
+    from_name='box',
+    to_name='video',
+    source_value='video',
+    target_fps=None,
+    hop_keyframes=0,
+):
+    """Convert PathTrack dataset to Label Studio video labeling format
 
     :param root_dir: root dir with video folders, e.g.: 'pathtrack/train' or 'pathtrack/test'
     :param root_url: where the dataset is served by http/https
@@ -216,9 +225,16 @@ def convert_dataset(root_dir, root_url, from_name='box', to_name='video', source
         label_file = os.path.join(shot_dir, 'gt/gt.txt')
         info_file = os.path.join(shot_dir, 'info.xml')
 
-        task = convert_shot(input_url, label_file, info_file,
-                            from_name, to_name, source_value,
-                            target_fps, hop_keyframes)
+        task = convert_shot(
+            input_url,
+            label_file,
+            info_file,
+            from_name,
+            to_name,
+            source_value,
+            target_fps,
+            hop_keyframes,
+        )
         if task is None:
             continue
 
@@ -242,9 +258,11 @@ def convert_dataset(root_dir, root_url, from_name='box', to_name='video', source
     # exit()
     print(f'Usage: {sys.argv[0]} root_url target_fps\n')
 
-    url = sys.argv[1] if len(sys.argv) > 1 else 'https://data.heartex.net/pathtrack/train/'
+    url = (
+        sys.argv[1]
+        if len(sys.argv) > 1
+        else 'https://data.heartex.net/pathtrack/train/'
+    )
     fps = float(sys.argv[2]) if len(sys.argv) > 2 else None
     hop = int(sys.argv[3]) if len(sys.argv) > 3 else 0
     convert_dataset('./', url, target_fps=fps, hop_keyframes=hop)
-
-
diff --git a/label_studio_converter/imports/yolo.py b/label_studio_converter/imports/yolo.py
index d12617fe..4982a1fd 100644
--- a/label_studio_converter/imports/yolo.py
+++ b/label_studio_converter/imports/yolo.py
@@ -1,6 +1,8 @@
 import os
 import json  # better to use "imports ujson as json" for the best performance
-from urllib.request import pathname2url # for converting "+","*", etc. in file paths to appropriate urls
+from urllib.request import (
+    pathname2url,
+)  # for converting "+","*", etc. in file paths to appropriate urls
 import uuid
 import logging
 from PIL import Image
@@ -11,11 +13,16 @@
 logger = logging.getLogger('root')
 
 
-def convert_yolo_to_ls(input_dir, out_file,
-                       to_name='image', from_name='label', out_type="annotations",
-                       image_root_url='/data/local-files/?d=', image_ext='.jpg,.jpeg,.png'):
-
-    """ Convert YOLO labeling to Label Studio JSON
+def convert_yolo_to_ls(
+    input_dir,
+    out_file,
+    to_name='image',
+    from_name='label',
+    out_type="annotations",
+    image_root_url='/data/local-files/?d=',
+    image_ext='.jpg,.jpeg,.png',
+):
+    """Convert YOLO labeling to Label Studio JSON
     :param input_dir: directory with YOLO where images, labels, notes.json are located
     :param out_file: output file with Label Studio JSON tasks
     :param to_name: object name from Label Studio labeling config
@@ -27,7 +34,7 @@ def convert_yolo_to_ls(input_dir, out_file,
 
     tasks = []
     logger.info('Reading YOLO notes and categories from %s', input_dir)
-        
+
     # build categories=>labels dict
     notes_file = os.path.join(input_dir, 'classes.txt')
     with open(notes_file) as f:
@@ -37,13 +44,19 @@ def convert_yolo_to_ls(input_dir, out_file,
 
     # generate and save labeling config
     label_config_file = out_file.replace('.json', '') + '.label_config.xml'
-    generate_label_config(categories, {from_name: 'RectangleLabels'}, to_name, from_name, label_config_file)
+    generate_label_config(
+        categories,
+        {from_name: 'RectangleLabels'},
+        to_name,
+        from_name,
+        label_config_file,
+    )
 
     # define directories
     labels_dir = os.path.join(input_dir, 'labels')
     images_dir = os.path.join(input_dir, 'images')
     logger.info('Converting labels from %s', labels_dir)
-    
+
     # build array out of provided comma separated image_extns (str -> array)
     image_ext = [x.strip() for x in image_ext.split(",")]
     logger.info(f'image extensions->, {image_ext}')
@@ -54,17 +67,18 @@ def convert_yolo_to_ls(input_dir, out_file,
         for ext in image_ext:
             if f.endswith(ext):
                 image_file = f
-                image_file_base = f[0:-len(ext)]
+                image_file_base = f[0 : -len(ext)]
                 image_file_found_flag = True
                 break
         if not image_file_found_flag:
             continue
-        
+
         image_root_url += '' if image_root_url.endswith('/') else '/'
         task = {
             "data": {
                 # eg. '../../foo+you.py' -> '../../foo%2Byou.py'
-                "image": image_root_url + str(pathname2url(image_file))
+                "image": image_root_url
+                + str(pathname2url(image_file))
             }
         }
 
@@ -88,25 +102,28 @@ def convert_yolo_to_ls(input_dir, out_file,
                 lines = file.readlines()
                 for line in lines:
                     label_id, x, y, width, height = line.split()
-                    x, y, width, height = float(x), float(y), float(width), float(height)
+                    x, y, width, height = (
+                        float(x),
+                        float(y),
+                        float(width),
+                        float(height),
+                    )
                     item = {
                         "id": uuid.uuid4().hex[0:10],
                         "type": "rectanglelabels",
                         "value": {
-                            "x": (x-width/2) * 100,
-                            "y": (y-height/2) * 100,
+                            "x": (x - width / 2) * 100,
+                            "y": (y - height / 2) * 100,
                             "width": width * 100,
                             "height": height * 100,
                             "rotation": 0,
-                            "rectanglelabels": [
-                                categories[int(label_id)]
-                            ]
+                            "rectanglelabels": [categories[int(label_id)]],
                         },
                         "to_name": to_name,
                         "from_name": from_name,
                         "image_rotation": 0,
                         "original_width": image_width,
-                        "original_height": image_height
+                        "original_height": image_height,
                     }
                     task[out_type][0]['result'].append(item)
 
@@ -117,12 +134,14 @@ def convert_yolo_to_ls(input_dir, out_file,
         with open(out_file, 'w') as out:
             json.dump(tasks, out)
 
-        print('\n'
-              f'  1. Create a new project in Label Studio\n'
-              f'  2. Use Labeling Config from "{label_config_file}"\n'
-              f'  3. Setup serving for images [e.g. you can use Local Storage (or others):\n'
-              f'     https://labelstud.io/guide/storage.html#Local-storage]\n'
-              f'  4. Import "{out_file}" to the project\n')
+        print(
+            '\n'
+            f'  1. Create a new project in Label Studio\n'
+            f'  2. Use Labeling Config from "{label_config_file}"\n'
+            f'  3. Setup serving for images [e.g. you can use Local Storage (or others):\n'
+            f'     https://labelstud.io/guide/storage.html#Local-storage]\n'
+            f'  4. Import "{out_file}" to the project\n'
+        )
     else:
         logger.error('No labels converted')
 
@@ -131,38 +150,48 @@ def add_parser(subparsers):
     yolo = subparsers.add_parser('yolo')
 
     yolo.add_argument(
-        '-i', '--input', dest='input', required=True,
+        '-i',
+        '--input',
+        dest='input',
+        required=True,
         help='directory with YOLO where images, labels, notes.json are located',
-        action=ExpandFullPath
+        action=ExpandFullPath,
     )
     yolo.add_argument(
-        '-o', '--output', dest='output',
+        '-o',
+        '--output',
+        dest='output',
         help='output file with Label Studio JSON tasks',
         default='output.json',
-        action=ExpandFullPath
+        action=ExpandFullPath,
     )
     yolo.add_argument(
-        '--to-name', dest='to_name',
+        '--to-name',
+        dest='to_name',
         help='object name from Label Studio labeling config',
         default='image',
     )
     yolo.add_argument(
-        '--from-name', dest='from_name',
+        '--from-name',
+        dest='from_name',
         help='control tag name from Label Studio labeling config',
         default='label',
     )
     yolo.add_argument(
-        '--out-type', dest='out_type',
+        '--out-type',
+        dest='out_type',
         help='annotation type - "annotations" or "predictions"',
         default='annotations',
     )
     yolo.add_argument(
-        '--image-root-url', dest='image_root_url',
+        '--image-root-url',
+        dest='image_root_url',
         help='root URL path where images will be hosted, e.g.: http://example.com/images',
         default='/data/local-files/?d=',
     )
     yolo.add_argument(
-        '--image-ext', dest='image_ext',
+        '--image-ext',
+        dest='image_ext',
         help='image extension to search: .jpeg or .jpg, .png',
         default='.jpg',
     )
diff --git a/label_studio_converter/main.py b/label_studio_converter/main.py
index a21d9ef5..2eba0678 100644
--- a/label_studio_converter/main.py
+++ b/label_studio_converter/main.py
@@ -13,51 +13,68 @@
 
 def get_export_args(parser):
     parser.add_argument(
-        '-i', '--input', dest='input', required=True,
+        '-i',
+        '--input',
+        dest='input',
+        required=True,
         help='Directory or JSON file with annotations (e.g. "/<project_path>/annotations")',
-        action=ExpandFullPath
+        action=ExpandFullPath,
     )
     parser.add_argument(
-        '-c', '--config', dest='config',
+        '-c',
+        '--config',
+        dest='config',
         help='Project config (e.g. "/<project_path>/config.xml")',
-        action=ExpandFullPath
+        action=ExpandFullPath,
     )
     parser.add_argument(
-        '-o', '--output', dest='output',
+        '-o',
+        '--output',
+        dest='output',
         help='Output file or directory (will be created if not exists)',
         default=os.path.join(os.path.dirname(__file__), 'output'),
-        action=ExpandFullPath
+        action=ExpandFullPath,
     )
     parser.add_argument(
-        '-f', '--format', dest='format',
+        '-f',
+        '--format',
+        dest='format',
         metavar='FORMAT',
         help='Output format: ' + ', '.join(f.name for f in Format),
         type=Format.from_string,
         choices=list(Format),
-        default=Format.JSON
+        default=Format.JSON,
     )
     parser.add_argument(
-        '--csv-separator', dest='csv_separator',
+        '--csv-separator',
+        dest='csv_separator',
         help='Separator used in CSV format',
-        default=','
+        default=',',
     )
     parser.add_argument(
-        '--csv-no-header', dest='csv_no_header',
+        '--csv-no-header',
+        dest='csv_no_header',
         help='Whether to omit header in CSV output file',
-        action='store_true'
+        action='store_true',
     )
     parser.add_argument(
-        '--image-dir', dest='image_dir',
+        '--image-dir',
+        dest='image_dir',
         help='In case of image outputs (COCO, VOC, ...), specifies output image directory where downloaded images will '
-             'be stored. (If not specified, local image paths left untouched)'
+        'be stored. (If not specified, local image paths left untouched)',
     )
     parser.add_argument(
-        '--project-dir', dest='project_dir', default=None,
-        help='Label Studio project directory path'
+        '--project-dir',
+        dest='project_dir',
+        default=None,
+        help='Label Studio project directory path',
     )
     parser.add_argument(
-        '--heartex-format', dest='heartex_format', action='store_true', default=True,
-        help='Set this flag if your annotations are in one JSON file instead of multiple JSON files from directory'
+        '--heartex-format',
+        dest='heartex_format',
+        action='store_true',
+        default=True,
+        help='Set this flag if your annotations are in one JSON file instead of multiple JSON files from directory',
     )
 
 
@@ -69,14 +86,14 @@ def get_all_args():
     # Export
     parser_export = subparsers.add_parser(
         'export',
-        help='Converter from Label Studio JSON annotations to external formats'
+        help='Converter from Label Studio JSON annotations to external formats',
     )
     get_export_args(parser_export)
 
     # Import
     parser_import = subparsers.add_parser(
         'import',
-        help="Converter from external formats to Label Studio JSON annotations"
+        help="Converter from external formats to Label Studio JSON annotations",
     )
     import_format = parser_import.add_subparsers(dest='import_format')
     import_yolo.add_parser(import_format)
@@ -93,21 +110,45 @@ def export(args):
     elif args.format == Format.CSV:
         header = not args.csv_no_header
         sep = args.csv_separator
-        c.convert_to_csv(args.input, args.output, sep=sep, header=header, is_dir=not args.heartex_format)
+        c.convert_to_csv(
+            args.input,
+            args.output,
+            sep=sep,
+            header=header,
+            is_dir=not args.heartex_format,
+        )
     elif args.format == Format.CSV_OLD:
         header = not args.csv_no_header
         sep = args.csv_separator
-        ExportToCSV(args.input).to_file(args.output, sep=sep, header=header, index=False)
+        ExportToCSV(args.input).to_file(
+            args.output, sep=sep, header=header, index=False
+        )
     elif args.format == Format.TSV:
         header = not args.csv_no_header
         sep = '\t'
-        c.convert_to_csv(args.input, args.output, sep=sep, header=header, is_dir=not args.heartex_format)
+        c.convert_to_csv(
+            args.input,
+            args.output,
+            sep=sep,
+            header=header,
+            is_dir=not args.heartex_format,
+        )
     elif args.format == Format.CONLL2003:
         c.convert_to_conll2003(args.input, args.output, is_dir=not args.heartex_format)
     elif args.format == Format.COCO:
-        c.convert_to_coco(args.input, args.output, output_image_dir=args.image_dir, is_dir=not args.heartex_format)
+        c.convert_to_coco(
+            args.input,
+            args.output,
+            output_image_dir=args.image_dir,
+            is_dir=not args.heartex_format,
+        )
     elif args.format == Format.VOC:
-        c.convert_to_voc(args.input, args.output, output_image_dir=args.image_dir, is_dir=not args.heartex_format)
+        c.convert_to_voc(
+            args.input,
+            args.output,
+            output_image_dir=args.image_dir,
+            is_dir=not args.heartex_format,
+        )
     elif args.format == Format.YOLO:
         c.convert_to_yolo(args.input, args.output, is_dir=not args.heartex_format)
     else:
@@ -116,14 +157,26 @@ def export(args):
 
 def imports(args):
     if args.import_format == 'yolo':
-        import_yolo.convert_yolo_to_ls(input_dir=args.input, out_file=args.output,
-                                       to_name=args.to_name, from_name=args.from_name, out_type=args.out_type,
-                                       image_root_url=args.image_root_url, image_ext=args.image_ext)
+        import_yolo.convert_yolo_to_ls(
+            input_dir=args.input,
+            out_file=args.output,
+            to_name=args.to_name,
+            from_name=args.from_name,
+            out_type=args.out_type,
+            image_root_url=args.image_root_url,
+            image_ext=args.image_ext,
+        )
 
     elif args.import_format == 'coco':
-        import_coco.convert_coco_to_ls(input_file=args.input, out_file=args.output,
-                                       to_name=args.to_name, from_name=args.from_name, out_type=args.out_type,
-                                       image_root_url=args.image_root_url, point_width=args.point_width)
+        import_coco.convert_coco_to_ls(
+            input_file=args.input,
+            out_file=args.output,
+            to_name=args.to_name,
+            from_name=args.from_name,
+            out_type=args.out_type,
+            image_root_url=args.image_root_url,
+            point_width=args.point_width,
+        )
     else:
         raise FormatNotSupportedError()
 
diff --git a/label_studio_converter/utils.py b/label_studio_converter/utils.py
index 4e451441..2f180ede 100644
--- a/label_studio_converter/utils.py
+++ b/label_studio_converter/utils.py
@@ -22,21 +22,26 @@
 logger = logging.getLogger(__name__)
 
 _LABEL_TAGS = {'Label', 'Choice'}
-_NOT_CONTROL_TAGS = {'Filter',}
-LOCAL_FILES_DOCUMENT_ROOT = get_env('LOCAL_FILES_DOCUMENT_ROOT', default=os.path.abspath(os.sep))
+_NOT_CONTROL_TAGS = {
+    'Filter',
+}
+LOCAL_FILES_DOCUMENT_ROOT = get_env(
+    'LOCAL_FILES_DOCUMENT_ROOT', default=os.path.abspath(os.sep)
+)
 
 TreebankWordTokenizer.PUNCTUATION = [
-        (re.compile(r"([:,])([^\d])"), r" \1 \2"),
-        (re.compile(r"([:,])$"), r" \1 "),
-        (re.compile(r"\.\.\."), r" ... "),
-        (re.compile(r"[;@#$/%&]"), r" \g<0> "),
-        (
-            re.compile(r'([^\.])(\.)([\]\)}>"\']*)\s*$'),
-            r"\1 \2\3 ",
-        ),  # Handles the final period.
-        (re.compile(r"[?!]"), r" \g<0> "),
-        (re.compile(r"([^'])' "), r"\1 ' "),
-    ]
+    (re.compile(r"([:,])([^\d])"), r" \1 \2"),
+    (re.compile(r"([:,])$"), r" \1 "),
+    (re.compile(r"\.\.\."), r" ... "),
+    (re.compile(r"[;@#$/%&]"), r" \g<0> "),
+    (
+        re.compile(r'([^\.])(\.)([\]\)}>"\']*)\s*$'),
+        r"\1 \2\3 ",
+    ),  # Handles the final period.
+    (re.compile(r"[?!]"), r" \g<0> "),
+    (re.compile(r"([^'])' "), r"\1 ' "),
+]
+
 
 class ExpandFullPath(argparse.Action):
     def __call__(self, parser, namespace, values, option_string=None):
@@ -56,24 +61,33 @@ def tokenize(text):
 
 
 def create_tokens_and_tags(text, spans):
-    #tokens_and_idx = tokenize(text) # This function doesn't work properly if text contains multiple whitespaces...
-    token_index_tuples = [token for token in TreebankWordTokenizer().span_tokenize(text)]
+    # tokens_and_idx = tokenize(text) # This function doesn't work properly if text contains multiple whitespaces...
+    token_index_tuples = [
+        token for token in TreebankWordTokenizer().span_tokenize(text)
+    ]
     tokens_and_idx = [(text[start:end], start) for start, end in token_index_tuples]
-    if spans and all([span.get('start') is not None and span.get('end') is not None for span in spans]):
+    if spans and all(
+        [
+            span.get('start') is not None and span.get('end') is not None
+            for span in spans
+        ]
+    ):
         spans = list(sorted(spans, key=itemgetter('start')))
         span = spans.pop(0)
         span_start = span['start']
-        span_end = span['end']-1
+        span_end = span['end'] - 1
         prefix = 'B-'
         tokens, tags = [], []
         for token, token_start in tokens_and_idx:
             tokens.append(token)
-            token_end = token_start + len(token) - 1#"- 1" - This substraction is wrong. token already uses the index E.g. "Hello" is 0-4
-            token_start_ind = token_start  #It seems like the token start is too early.. for whichever reason
-
-            #if for some reason end of span is missed.. pop the new span (Which is quite probable due to this method)
-            #Attention it seems like span['end'] is the index of first char afterwards. In case the whitespace is part of the
-            #labell we need to subtract one. Otherwise next token won't trigger the span update.. only the token after next..
+            token_end = (
+                token_start + len(token) - 1
+            )  # "- 1" - This substraction is wrong. token already uses the index E.g. "Hello" is 0-4
+            token_start_ind = token_start  # It seems like the token start is too early.. for whichever reason
+
+            # if for some reason end of span is missed.. pop the new span (Which is quite probable due to this method)
+            # Attention it seems like span['end'] is the index of first char afterwards. In case the whitespace is part of the
+            # labell we need to subtract one. Otherwise next token won't trigger the span update.. only the token after next..
             if token_start_ind > span_end:
                 while spans:
                     span = spans.pop(0)
@@ -110,12 +124,21 @@ def _get_upload_dir(project_dir=None, upload_dir=None):
         if not os.path.exists(upload_dir):
             upload_dir = None
     if not upload_dir:
-        raise FileNotFoundError("Can't find upload dir: either LS_UPLOAD_DIR or project should be passed to converter")
+        raise FileNotFoundError(
+            "Can't find upload dir: either LS_UPLOAD_DIR or project should be passed to converter"
+        )
     return upload_dir
 
 
-def download(url, output_dir, filename=None, project_dir=None, return_relative_path=False, upload_dir=None,
-             download_resources=True):
+def download(
+    url,
+    output_dir,
+    filename=None,
+    project_dir=None,
+    return_relative_path=False,
+    upload_dir=None,
+    download_resources=True,
+):
     is_local_file = url.startswith('/data/') and '?d=' in url
     is_uploaded_file = url.startswith('/data/upload')
 
@@ -123,11 +146,17 @@ def download(url, output_dir, filename=None, project_dir=None, return_relative_p
         upload_dir = _get_upload_dir(project_dir, upload_dir)
         filename = urllib.parse.unquote(url.replace('/data/upload/', ''))
         filepath = os.path.join(upload_dir, filename)
-        logger.debug(f'Copy {filepath} to {output_dir}'.format(filepath=filepath, output_dir=output_dir))
+        logger.debug(
+            f'Copy {filepath} to {output_dir}'.format(
+                filepath=filepath, output_dir=output_dir
+            )
+        )
         if download_resources:
             shutil.copy(filepath, output_dir)
         if return_relative_path:
-            return os.path.join(os.path.basename(output_dir), os.path.basename(filename))
+            return os.path.join(
+                os.path.basename(output_dir), os.path.basename(filename)
+            )
         return filepath
 
     if is_local_file:
@@ -145,7 +174,14 @@ def download(url, output_dir, filename=None, project_dir=None, return_relative_p
         filename = f'{basename}{ext}'
         filepath = os.path.join(output_dir, filename)
         if os.path.exists(filepath):
-            filename = basename + '_' + hashlib.md5(url.encode() + str(datetime.datetime.now().timestamp()).encode()).hexdigest()[:4] + ext
+            filename = (
+                basename
+                + '_'
+                + hashlib.md5(
+                    url.encode() + str(datetime.datetime.now().timestamp()).encode()
+                ).hexdigest()[:4]
+                + ext
+            )
 
     filepath = os.path.join(output_dir, filename)
     if not os.path.exists(filepath):
@@ -183,19 +219,19 @@ def ensure_dir(dir_path):
 
 def parse_config(config_string):
     """
-        :param config_string: Label config string
-        :return: structured config of the form:
-        {
-            "<ControlTag>.name": {
-                "type": "ControlTag",
-                "to_name": ["<ObjectTag1>.name", "<ObjectTag2>.name"],
-                "inputs: [
-                    {"type": "ObjectTag1", "value": "<ObjectTag1>.value"},
-                    {"type": "ObjectTag2", "value": "<ObjectTag2>.value"}
-                ],
-                "labels": ["Label1", "Label2", "Label3"] // taken from "alias" if exists or "value"
-        }
-        """
+    :param config_string: Label config string
+    :return: structured config of the form:
+    {
+        "<ControlTag>.name": {
+            "type": "ControlTag",
+            "to_name": ["<ObjectTag1>.name", "<ObjectTag2>.name"],
+            "inputs: [
+                {"type": "ObjectTag1", "value": "<ObjectTag1>.value"},
+                {"type": "ObjectTag2", "value": "<ObjectTag2>.value"}
+            ],
+            "labels": ["Label1", "Label2", "Label3"] // taken from "alias" if exists or "value"
+    }
+    """
     if not config_string:
         return {}
 
@@ -203,7 +239,11 @@ def _is_input_tag(tag):
         return tag.attrib.get('name') and tag.attrib.get('value')
 
     def _is_output_tag(tag):
-        return tag.attrib.get('name') and tag.attrib.get('toName') and tag.tag not in _NOT_CONTROL_TAGS
+        return (
+            tag.attrib.get('name')
+            and tag.attrib.get('toName')
+            and tag.tag not in _NOT_CONTROL_TAGS
+        )
 
     def _get_parent_output_tag_name(tag, outputs):
         # Find parental <Choices> tag for nested tags like <Choices><View><View><Choice>...
@@ -231,14 +271,23 @@ def _get_parent_output_tag_name(tag, outputs):
                 if tag.attrib.get('whenTagName'):
                     conditionals = {'type': 'tag', 'name': tag.attrib['whenTagName']}
                 elif tag.attrib.get('whenLabelValue'):
-                    conditionals = {'type': 'label', 'name': tag.attrib['whenLabelValue']}
+                    conditionals = {
+                        'type': 'label',
+                        'name': tag.attrib['whenLabelValue'],
+                    }
                 elif tag.attrib.get('whenChoiceValue'):
-                    conditionals = {'type': 'choice', 'name': tag.attrib['whenChoiceValue']}
+                    conditionals = {
+                        'type': 'choice',
+                        'name': tag.attrib['whenChoiceValue'],
+                    }
             if conditionals:
                 tag_info['conditionals'] = conditionals
             outputs[tag.attrib['name']] = tag_info
         elif _is_input_tag(tag):
-            inputs[tag.attrib['name']] = {'type': tag.tag, 'value': tag.attrib['value'].lstrip('$')}
+            inputs[tag.attrib['name']] = {
+                'type': tag.tag,
+                'value': tag.attrib['value'].lstrip('$'),
+            }
         if tag.tag not in _LABEL_TAGS:
             continue
         parent_name = _get_parent_output_tag_name(tag, outputs)
@@ -247,7 +296,9 @@ def _get_parent_output_tag_name(tag, outputs):
             if not actual_value:
                 logger.debug(
                     'Inspecting tag {tag_name}... found no "value" or "alias" attributes.'.format(
-                        tag_name=etree.tostring(tag, encoding='unicode').strip()[:50]))
+                        tag_name=etree.tostring(tag, encoding='unicode').strip()[:50]
+                    )
+                )
             else:
                 labels[parent_name][actual_value] = dict(tag.attrib)
     for output_tag, tag_info in outputs.items():
@@ -256,7 +307,8 @@ def _get_parent_output_tag_name(tag, outputs):
             if input_tag_name not in inputs:
                 logger.debug(
                     f'to_name={input_tag_name} is specified for output tag name={output_tag}, '
-                    'but we can\'t find it among input tags')
+                    'but we can\'t find it among input tags'
+                )
                 continue
             tag_info['inputs'].append(inputs[input_tag_name])
         tag_info['labels'] = list(labels[output_tag])
@@ -280,8 +332,7 @@ def get_polygon_bounding_box(x, y):
 
 
 def _get_annotator(item, default=None, int_id=False):
-    """ Get annotator id or email from annotation
-    """
+    """Get annotator id or email from annotation"""
     annotator = item['completed_by']
     if isinstance(annotator, dict):
         annotator = annotator.get('email', default)
diff --git a/setup.py b/setup.py
index f64c06c4..12bd8ab9 100644
--- a/setup.py
+++ b/setup.py
@@ -34,5 +34,5 @@
         'console_scripts': [
             'label-studio-converter=label_studio_converter.main:main',
         ],
-    }
+    },
 )
diff --git a/tests/test_brush.py b/tests/test_brush.py
index 0432f8a1..d3e89808 100644
--- a/tests/test_brush.py
+++ b/tests/test_brush.py
@@ -11,16 +11,17 @@
 def test_image2annotation():
     annotation = image2annotation(
         'tests/test.png',
-        label_name='Airplane', from_name='tag', to_name='image',
-        model_version='v1', score=0.5
+        label_name='Airplane',
+        from_name='tag',
+        to_name='image',
+        model_version='v1',
+        score=0.5,
     )
 
     # prepare Label Studio Task
     task = {
         'data': {'image': 'https://labelstud.io/images/test.jpg'},
-        'predictions': [
-            annotation
-        ]
+        'predictions': [annotation],
     }
 
     """ You can import this `task.json` to the Label Studio project with this labeling config:
@@ -42,5 +43,26 @@ def test_rle_encoding():
     """testing rle encoding with simple example"""
     test_arr = [1, 1, 1, 1, 2, 3, 5, 6, 7, 8, 4, 4, 4, 4, 4, 4, 4, 4]
     rle_test = encode_rle(test_arr)
-    assert rle_test == [0, 0, 0, 18, 57, 27, 252, 96, 32, 1, 0, 6, 0, 40, 0,
-                        192, 3, 128, 17, 56, 32]
+    assert rle_test == [
+        0,
+        0,
+        0,
+        18,
+        57,
+        27,
+        252,
+        96,
+        32,
+        1,
+        0,
+        6,
+        0,
+        40,
+        0,
+        192,
+        3,
+        128,
+        17,
+        56,
+        32,
+    ]
diff --git a/tests/test_converter.py b/tests/test_converter.py
index bf82f6ab..034598f2 100644
--- a/tests/test_converter.py
+++ b/tests/test_converter.py
@@ -9,7 +9,9 @@
 INPUT_JSON_PATH = os.path.join(BASE_DIR, TEST_DATA_PATH, "data.json")
 LABEL_CONFIG_PATH = os.path.join(BASE_DIR, TEST_DATA_PATH, "label_config.xml")
 INPUT_JSON_PATH_POLYGONS = os.path.join(BASE_DIR, TEST_DATA_PATH, "data_polygons.json")
-LABEL_CONFIG_PATH_POLYGONS = os.path.join(BASE_DIR, TEST_DATA_PATH, "label_config_polygons.xml")
+LABEL_CONFIG_PATH_POLYGONS = os.path.join(
+    BASE_DIR, TEST_DATA_PATH, "label_config_polygons.xml"
+)
 
 
 def check_equal_list_of_strings(list1, list2):
@@ -119,9 +121,7 @@ def test_convert_polygons_to_yolo(create_temp_folder):
     )
 
     abs_path_label_dir = os.path.abspath(output_label_dir)
-    expected_paths = [
-        os.path.join(abs_path_label_dir, "image2.txt")
-    ]
+    expected_paths = [os.path.join(abs_path_label_dir, "image2.txt")]
     generated_paths = get_os_walk(abs_path_label_dir)
     # Check all files and subfolders have been generated.
     assert check_equal_list_of_strings(
diff --git a/tests/test_converter_conll.py b/tests/test_converter_conll.py
index 827bfab8..6a02269a 100644
--- a/tests/test_converter_conll.py
+++ b/tests/test_converter_conll.py
@@ -4,13 +4,16 @@
 
 class TestUtils(unittest.TestCase):
     def test_create_tokens_and_tags_with_eol_tag(self):
-
         s = 'I need a break\nplease'
-        spans = [{'end': 14,
-                  'labels': ['Person'],
-                  'start': 9,
-                  'text': 'break',
-                  'type': 'Labels'}]
+        spans = [
+            {
+                'end': 14,
+                'labels': ['Person'],
+                'start': 9,
+                'text': 'break',
+                'type': 'Labels',
+            }
+        ]
         tokens, tags = utils.create_tokens_and_tags(s, spans)
         self.assertEqual(tokens[0], "I")
         self.assertEqual(tags[0], "O")
@@ -24,13 +27,16 @@ def test_create_tokens_and_tags_with_eol_tag(self):
         self.assertEqual(tags[4], "O")
 
     def test_create_tokens_and_tags_with_tab_tag(self):
-
         s = 'I need a tab\tplease'
-        spans = [{'end': 12,
-                  'labels': ['Person'],
-                  'start': 9,
-                  'text': 'tab',
-                  'type': 'Labels'}]
+        spans = [
+            {
+                'end': 12,
+                'labels': ['Person'],
+                'start': 9,
+                'text': 'tab',
+                'type': 'Labels',
+            }
+        ]
         tokens, tags = utils.create_tokens_and_tags(s, spans)
         self.assertEqual(tokens[0], "I")
         self.assertEqual(tags[0], "O")
@@ -73,29 +79,70 @@ def test_create_tokens_and_tags_for_token_with_dollar_sign(self):
 
     def test_create_tokens_and_tags_for_token_with_slash_sign(self):
         text = 'A meal from Google/Facebook'
-        spans = [{'end': 17, 'labels': ['ORG'], 'start': 12, 'text': 'Google'},
-                 {'end': 22, 'labels': ['ORG'], 'start': 19, 'text': 'Face'}]
+        spans = [
+            {'end': 17, 'labels': ['ORG'], 'start': 12, 'text': 'Google'},
+            {'end': 22, 'labels': ['ORG'], 'start': 19, 'text': 'Face'},
+        ]
         tokens, tags = utils.create_tokens_and_tags(text, spans)
         self.assertEqual(tokens, ['A', 'meal', 'from', 'Google', '/', 'Facebook'])
         self.assertEqual(tags, ['O', 'O', 'O', 'B-ORG', 'O', 'B-ORG'])
 
-
     def test_create_tokens_and_tags_for_token_with_ampersand_sign(self):
         text = "They're the world's most fear;some fighting team,Teenage Mut;ant Ninja Turtles (We're really hip!).They're heroes in the half-shell and they're green,Teenage Mutant Ninja Turtles (Hey, get a grip!),When the evil Shre&dder attacks These Turtle boys don't cut him no slack! Spli\/nter taught them to be ninja teens.. Teen#age Mutant Ninja Turtles (He's a radi@cal rat!), Leonardo leads, Donat#ello does machines, Teenage Mutant Ninja Turt;les (That's a fact, Jack!),Raphael is cool but rude (Gimme a break!), Michel;angelo is a party dude (Party!)"
-        spans = [{"start":0,"end":4,"text":"They","labels":["PER"]},{"start":12,"end":17,"text":"world","labels":["PER"]},{"start":57,"end":60,"text":"Mut","labels":["PER"]},{"start":212,"end":216,"text":"Shre","labels":["PER"]},{"start":314,"end":318,"text":"Teen","labels":["PER"]},{"start":272,"end":276,"text":"Spli","labels":["PER"]}]
+        spans = [
+            {"start": 0, "end": 4, "text": "They", "labels": ["PER"]},
+            {"start": 12, "end": 17, "text": "world", "labels": ["PER"]},
+            {"start": 57, "end": 60, "text": "Mut", "labels": ["PER"]},
+            {"start": 212, "end": 216, "text": "Shre", "labels": ["PER"]},
+            {"start": 314, "end": 318, "text": "Teen", "labels": ["PER"]},
+            {"start": 272, "end": 276, "text": "Spli", "labels": ["PER"]},
+        ]
         tokens, tags = utils.create_tokens_and_tags(text, spans)
         self.assertEqual(tokens[52], 'Shre')
         self.assertEqual(tags[52], 'B-PER')
         self.assertEqual(tags[51], 'O')
         self.assertEqual(tags[53], 'O')
 
-
     def test_create_tokens_and_tags_for_token_with_hash_sign(self):
         text = "Mut;ant Ninja Turtles. Teen#age Mutant Ninja Turtles."
-        spans = [{"start":0,"end":3,"text":"Mut","labels":["PER"]},
-                 {"start":5,"end":7,"text":"ant","labels":["ORG"]},
-                 {"start":24,"end":27,"text":"Teen","labels":["PER"]},
-                 {"start":29,"end":30,"text":"Shre","labels":["ORG"]}]
+        spans = [
+            {"start": 0, "end": 3, "text": "Mut", "labels": ["PER"]},
+            {"start": 5, "end": 7, "text": "ant", "labels": ["ORG"]},
+            {"start": 24, "end": 27, "text": "Teen", "labels": ["PER"]},
+            {"start": 29, "end": 30, "text": "Shre", "labels": ["ORG"]},
+        ]
         tokens, tags = utils.create_tokens_and_tags(text, spans)
-        self.assertEqual(tokens, ['Mut', ';', 'ant', 'Ninja', 'Turtles.', 'Teen', '#', 'age', 'Mutant', 'Ninja', 'Turtles', '.'])
-        self.assertEqual(tags, ['B-PER', 'O', 'B-ORG', 'O', 'O', 'B-PER', 'O', 'B-ORG', 'O', 'O', 'O', 'O'])
\ No newline at end of file
+        self.assertEqual(
+            tokens,
+            [
+                'Mut',
+                ';',
+                'ant',
+                'Ninja',
+                'Turtles.',
+                'Teen',
+                '#',
+                'age',
+                'Mutant',
+                'Ninja',
+                'Turtles',
+                '.',
+            ],
+        )
+        self.assertEqual(
+            tags,
+            [
+                'B-PER',
+                'O',
+                'B-ORG',
+                'O',
+                'O',
+                'B-PER',
+                'O',
+                'B-ORG',
+                'O',
+                'O',
+                'O',
+                'O',
+            ],
+        )
diff --git a/tests/test_export.py b/tests/test_export.py
index 81c77a4f..7c132cf1 100644
--- a/tests/test_export.py
+++ b/tests/test_export.py
@@ -14,7 +14,7 @@ def test_csv_export():
     sep = ','
     converter.convert_to_csv(input_data, output_dir, sep=sep, header=True, is_dir=False)
 
-    df = read_csv(result_csv, sep=sep) 
+    df = read_csv(result_csv, sep=sep)
     nulls = df.isnull().sum()
     if nulls.any() > 0:
         assert False, "There should be no empty values in result CSV"
@@ -23,7 +23,7 @@ def test_csv_export():
     input_data = os.path.abspath(os.path.dirname(__file__)) + '/data/csv_test2.json'
     sep = '\t'
     converter.convert_to_csv(input_data, output_dir, sep=sep, header=True, is_dir=False)
-    df = read_csv(result_csv, sep=sep) 
+    df = read_csv(result_csv, sep=sep)
     nulls = df.isnull().sum()
     assert sum(nulls) == 2, "There should be exactly two empty values in result CSV"
 
@@ -31,5 +31,6 @@ def test_csv_export():
     json.loads(df.iloc[0].writers)
     json.loads(df.iloc[0].iswcs_1)
 
+
 if __name__ == '__main__':
     test_csv_export()
diff --git a/tests/test_import_yolo.py b/tests/test_import_yolo.py
index 487f51ad..723d5110 100644
--- a/tests/test_import_yolo.py
+++ b/tests/test_import_yolo.py
@@ -8,38 +8,47 @@
 
 def test_import_yolo():
     """Tests generated config and json files for yolo imports
-    test_import_yolo_data folder assumes only images in the 'images' folder 
+    test_import_yolo_data folder assumes only images in the 'images' folder
     with corresponding labels existing in the 'labes' dir and a 'classes.txt' present.
     (currently 7 images -> 3 png, 2 jpg and 2 jpeg files)
     """
-    input_data_dir = os.path.join(os.path.abspath(os.path.dirname(__file__)),'data','test_import_yolo_data')
-    out_json_file = os.path.join('/tmp','lsc-pytest','yolo_exp_test.json')
-    image_ext = '.jpg,.jpeg,.png' #comma seperated string of extns.
+    input_data_dir = os.path.join(
+        os.path.abspath(os.path.dirname(__file__)), 'data', 'test_import_yolo_data'
+    )
+    out_json_file = os.path.join('/tmp', 'lsc-pytest', 'yolo_exp_test.json')
+    image_ext = '.jpg,.jpeg,.png'  # comma seperated string of extns.
 
     import_yolo.convert_yolo_to_ls(
-        input_dir=input_data_dir, 
-        out_file=out_json_file,
-        image_ext=image_ext
+        input_dir=input_data_dir, out_file=out_json_file, image_ext=image_ext
     )
     #'yolo_exp_test.label_config.xml' and 'yolo_exp_test.json' must be generated.
-    out_config_file = os.path.join('/tmp','lsc-pytest','yolo_exp_test.label_config.xml')
-    assert os.path.exists(out_config_file) and os.path.exists(out_json_file), "> import failed! files not generated." 
+    out_config_file = os.path.join(
+        '/tmp', 'lsc-pytest', 'yolo_exp_test.label_config.xml'
+    )
+    assert os.path.exists(out_config_file) and os.path.exists(
+        out_json_file
+    ), "> import failed! files not generated."
 
-    #provided labels from classes.txt
-    with open(os.path.join(input_data_dir,'classes.txt'), 'r') as f:
-        labels = f.read()[:-1].split('\n') #[:-1] since last line in classes.txt is empty by convention
+    # provided labels from classes.txt
+    with open(os.path.join(input_data_dir, 'classes.txt'), 'r') as f:
+        labels = f.read()[:-1].split(
+            '\n'
+        )  # [:-1] since last line in classes.txt is empty by convention
 
-    #generated labels from config xml
+    # generated labels from config xml
     label_element = ET.parse(out_config_file).getroot()[2]
     lables_generated = [x.attrib['value'] for x in label_element.getchildren()]
-    assert set(labels) == set(lables_generated), "> generated class labels do not match original labels"
+    assert set(labels) == set(
+        lables_generated
+    ), "> generated class labels do not match original labels"
 
-    #total image files in the input folder 
-    img_files = glob.glob(os.path.join(input_data_dir,'images','*'))
+    # total image files in the input folder
+    img_files = glob.glob(os.path.join(input_data_dir, 'images', '*'))
 
     with open(out_json_file, 'r') as f:
         ls_data = json.loads(f.read())
     assert len(ls_data) == len(img_files), "some file imports did not succeed!"
 
+
 if __name__ == '__main__':
     test_import_yolo()