shinestacker 0.3.2__py3-none-any.whl → 0.3.4__py3-none-any.whl

shinestacker/algorithms/base_stack_algo.py

@@ -0,0 +1,42 @@
+# pylint: disable=C0114, C0115, C0116, E0602, R0903
+import numpy as np
+from .. core.colors import color_str
+from .. core.exceptions import InvalidOptionError, ImageLoadError
+from .. config.constants import constants
+from .utils import read_img, get_img_metadata, validate_image
+
+
+class BaseStackAlgo:
+    def __init__(self, name, steps_per_frame, float_type=constants.DEFAULT_PY_FLOAT):
+        self._name = name
+        self._steps_per_frame = steps_per_frame
+        self.process = None
+        if float_type == constants.FLOAT_32:
+            self.float_type = np.float32
+        elif float_type == constants.FLOAT_64:
+            self.float_type = np.float64
+        else:
+            raise InvalidOptionError(
+                "float_type", float_type,
+                details=" valid values are FLOAT_32 and FLOAT_64"
+            )
+
+    def name(self):
+        return self._name
+
+    def steps_per_frame(self):
+        return self._steps_per_frame
+
+    def print_message(self, msg):
+        self.process.sub_message_r(color_str(msg, "light_blue"))
+
+    def read_image_and_update_metadata(self, img_path, metadata):
+        img = read_img(img_path)
+        if img is None:
+            raise ImageLoadError(img_path)
+        updated = metadata is None
+        if updated:
+            metadata = get_img_metadata(img)
+        else:
+            validate_image(img, *metadata)
+        return img, metadata, updated

shinestacker/algorithms/core_utils.py

@@ -1,3 +1,4 @@
+# pylint: disable=C0114, C0116
 import os
 from ..config.config import config
 
@@ -8,15 +9,14 @@ if not config.DISABLE_TQDM:
 
 def check_path_exists(path):
     if not os.path.exists(path):
-        raise Exception('Path does not exist: ' + path)
+        raise RuntimeError('Path does not exist: ' + path)
 
 
 def make_tqdm_bar(name, size, ncols=80):
     if not config.DISABLE_TQDM:
         if config.JUPYTER_NOTEBOOK:
-            bar = tqdm_notebook(desc=name, total=size)
+            tbar = tqdm_notebook(desc=name, total=size)
         else:
-            bar = tqdm(desc=name, total=size, ncols=ncols)
-        return bar
-    else:
-        return None
+            tbar = tqdm(desc=name, total=size, ncols=ncols)
+        return tbar
+    return None

shinestacker/algorithms/denoise.py

@@ -1,3 +1,4 @@
+# pylint: disable=C0114, C0116, E1101
 import cv2
 import numpy as np
 
@@ -6,4 +7,6 @@ def denoise(image, h_luminance, template_window_size=7, search_window_size=21):
     norm_type = cv2.NORM_L2 if image.dtype == np.uint8 else cv2.NORM_L1
     if image.dtype == np.uint16:
         h_luminance = h_luminance * 256
-    return cv2.fastNlMeansDenoising(image, [h_luminance], None, template_window_size, search_window_size, norm_type)
+    return cv2.fastNlMeansDenoising(
+        image, [h_luminance], None, template_window_size, search_window_size, norm_type
+    )

shinestacker/algorithms/depth_map.py

@@ -1,16 +1,22 @@
+# pylint: disable=C0114, C0115, C0116, E1101, R0902, R0913, R0917, R0914, R0912, R0915
 import numpy as np
 import cv2
 from .. config.constants import constants
-from .. core.colors import color_str
-from .. core.exceptions import ImageLoadError, InvalidOptionError, RunStopException
-from .utils import read_img, get_img_metadata, validate_image, img_bw
+from .. core.exceptions import InvalidOptionError, RunStopException
+from .utils import read_img, img_bw
+from .base_stack_algo import BaseStackAlgo
 
 
-class DepthMapStack:
-    def __init__(self, map_type=constants.DEFAULT_DM_MAP, energy=constants.DEFAULT_DM_ENERGY,
-                 kernel_size=constants.DEFAULT_DM_KERNEL_SIZE, blur_size=constants.DEFAULT_DM_BLUR_SIZE,
-                 smooth_size=constants.DEFAULT_DM_SMOOTH_SIZE, temperature=constants.DEFAULT_DM_TEMPERATURE,
-                 levels=constants.DEFAULT_DM_LEVELS, float_type=constants.DEFAULT_DM_FLOAT):
+class DepthMapStack(BaseStackAlgo):
+    def __init__(self, map_type=constants.DEFAULT_DM_MAP,
+                 energy=constants.DEFAULT_DM_ENERGY,
+                 kernel_size=constants.DEFAULT_DM_KERNEL_SIZE,
+                 blur_size=constants.DEFAULT_DM_BLUR_SIZE,
+                 smooth_size=constants.DEFAULT_DM_SMOOTH_SIZE,
+                 temperature=constants.DEFAULT_DM_TEMPERATURE,
+                 levels=constants.DEFAULT_DM_LEVELS,
+                 float_type=constants.DEFAULT_DM_FLOAT):
+        super().__init__("depth map", 2, float_type)
         self.map_type = map_type
         self.energy = energy
         self.kernel_size = kernel_size
@@ -18,21 +24,6 @@ class DepthMapStack:
         self.smooth_size = smooth_size
         self.temperature = temperature
         self.levels = levels
-        if float_type == constants.FLOAT_32:
-            self.float_type = np.float32
-        elif float_type == constants.FLOAT_64:
-            self.float_type = np.float64
-        else:
-            raise InvalidOptionError("float_type", float_type, details=" valid values are FLOAT_32 and FLOAT_64")
-
-    def name(self):
-        return "depth map"
-
-    def steps_per_frame(self):
-        return 2
-
-    def print_message(self, msg):
-        self.process.sub_message_r(color_str(msg, "light_blue"))
 
     def get_sobel_map(self, gray_images):
         energies = np.zeros(gray_images.shape, dtype=self.float_type)
@@ -63,13 +54,12 @@ class DepthMapStack:
         if self.map_type == constants.DM_MAP_AVERAGE:
             sum_energies = np.sum(energies, axis=0)
             return np.divide(energies, sum_energies, where=sum_energies != 0)
-        elif self.map_type == constants.DM_MAP_MAX:
+        if self.map_type == constants.DM_MAP_MAX:
             max_energy = np.max(energies, axis=0)
             relative = np.exp((energies - max_energy) / self.temperature)
             return relative / np.sum(relative, axis=0)
-        else:
-            raise InvalidOptionError("map_type", self.map_type, details=f" valid values are "
-                                     f"{constants.DM_MAP_AVERAGE} and {constants.DM_MAP_MAX}.")
+        raise InvalidOptionError("map_type", self.map_type, details=f" valid values are "
+                                 f"{constants.DM_MAP_AVERAGE} and {constants.DM_MAP_MAX}.")
 
     def pyramid_blend(self, images, weights):
         blended = None
@@ -105,14 +95,10 @@ class DepthMapStack:
         gray_images = []
         metadata = None
         for i, img_path in enumerate(filenames):
-            self.print_message(': reading file (1/2) {}'.format(img_path.split('/')[-1]))
-            img = read_img(img_path)
-            if img is None:
-                raise ImageLoadError(img_path)
-            if metadata is None:
-                metadata = get_img_metadata(img)
-            else:
-                validate_image(img, *metadata)
+            self.print_message(f": reading file (1/2) {img_path.split('/')[-1]}")
+
+            img, metadata, _updated = self.read_image_and_update_metadata(img_path, metadata)
+
             gray = img_bw(img)
             gray_images.append(gray)
             self.process.callback('after_step', self.process.id, self.process.name, i)
@@ -125,8 +111,10 @@ class DepthMapStack:
         elif self.energy == constants.DM_ENERGY_LAPLACIAN:
             energies = self.get_laplacian_map(gray_images)
         else:
-            raise InvalidOptionError('energy', self.energy, details=f" valid values are "
-                                     f"{constants.DM_ENERGY_SOBEL} and {constants.DM_ENERGY_LAPLACIAN}.")
+            raise InvalidOptionError(
+                'energy', self.energy, details=f" valid values are "
+                f"{constants.DM_ENERGY_SOBEL} and {constants.DM_ENERGY_LAPLACIAN}."
+            )
         max_energy = np.max(energies)
         if max_energy > 0:
             energies = energies / max_energy
@@ -135,7 +123,7 @@ class DepthMapStack:
         weights = self.get_focus_map(energies)
         blended_pyramid = None
         for i, img_path in enumerate(filenames):
-            self.print_message(': reading file (2/2) {}'.format(img_path.split('/')[-1]))
+            self.print_message(f": reading file (2/2) {img_path.split('/')[-1]}")
             img = read_img(img_path).astype(self.float_type)
             weight = weights[i]
             gp_img = [img]
@@ -152,7 +140,8 @@ class DepthMapStack:
                              for j in range(self.levels)]
             blended_pyramid = current_blend if blended_pyramid is None \
                 else [np.add(bp, cb) for bp, cb in zip(blended_pyramid, current_blend)]
-            self.process.callback('after_step', self.process.id, self.process.name, i + len(filenames))
+            self.process.callback('after_step', self.process.id,
+                                  self.process.name, i + len(filenames))
             if self.process.callback('check_running', self.process.id, self.process.name) is False:
                 raise RunStopException(self.name)
         result = blended_pyramid[0]

shinestacker/algorithms/exif.py

@@ -1,12 +1,13 @@
+# pylint: disable=C0114, C0116, W0718, R0911, R0912, E1101
 import os
 import re
 import io
+import logging
 import cv2
 import numpy as np
 from PIL import Image
 from PIL.TiffImagePlugin import IFDRational
 from PIL.ExifTags import TAGS
-import logging
 import tifffile
 from .. config.constants import constants
 from .utils import write_img
@@ -37,27 +38,28 @@ def extract_enclosed_data_for_jpg(data, head, foot):
     size = len(foot.decode('ascii'))
     xmp_start, xmp_end = data.find(head), data.find(foot)
     if xmp_start != -1 and xmp_end != -1:
-        return re.sub(b'[^\x20-\x7E]', b'', data[xmp_start:xmp_end + size]).decode().replace('\x00', '').encode()
-    else:
-        return None
+        return re.sub(
+            b'[^\x20-\x7E]', b'',
+            data[xmp_start:xmp_end + size]
+        ).decode().replace('\x00', '').encode()
+    return None
 
 
 def get_exif(exif_filename):
     if not os.path.isfile(exif_filename):
-        raise Exception("File does not exist: " + exif_filename)
+        raise RuntimeError(f"File does not exist: {exif_filename}")
     ext = exif_filename.split(".")[-1]
     image = Image.open(exif_filename)
-    if ext == 'tif' or ext == 'tiff':
+    if ext in ('tif', 'tiff'):
         return image.tag_v2 if hasattr(image, 'tag_v2') else image.getexif()
-    elif ext == 'jpeg' or ext == 'jpg':
-        exif_dict = image.getexif()
+    if ext in ('jpeg', 'jpg'):
+        exif_data = image.getexif()
         with open(exif_filename, 'rb') as f:
             data = extract_enclosed_data_for_jpg(f.read(), b'<?xpacket', b'<?xpacket end="w"?>')
             if data is not None:
-                exif_dict[XMLPACKET] = data
-        return exif_dict
-    else:
-        return image.getexif()
+                exif_data[XMLPACKET] = data
+        return exif_data
+    return image.getexif()
 
 
 def exif_extra_tags_for_tif(exif):
@@ -78,19 +80,19 @@ def exif_extra_tags_for_tif(exif):
         tag, data = TAGS.get(tag_id, tag_id), exif.get(tag_id)
         if isinstance(data, bytes):
             try:
-                if tag_id != IMAGERESOURCES and tag_id != INTERCOLORPROFILE:
+                if tag_id not in (IMAGERESOURCES, INTERCOLORPROFILE):
                     if tag_id == XMLPACKET:
                         data = re.sub(b'[^\x20-\x7E]', b'', data)
                     data = data.decode()
             except Exception:
-                logger.warning(f"Copy: can't decode EXIF tag {tag:25} [#{tag_id}]")
+                logger.warning(msg=f"Copy: can't decode EXIF tag {tag:25} [#{tag_id}]")
                 data = '<<< decode error >>>'
         if isinstance(data, IFDRational):
             data = (data.numerator, data.denominator)
         if tag not in NO_COPY_TIFF_TAGS and tag_id not in NO_COPY_TIFF_TAGS_ID:
             extra.append((tag_id, *get_tiff_dtype_count(data), data, False))
         else:
-            logger.debug(f"Skip tag {tag:25} [#{tag_id}]")
+            logger.debug(msg=f"Skip tag {tag:25} [#{tag_id}]")
     return extra, {'resolution': resolution, 'resolutionunit': resolutionunit,
                    'software': software, 'photometric': photometric}
 
@@ -98,29 +100,28 @@ def exif_extra_tags_for_tif(exif):
 def get_tiff_dtype_count(value):
     if isinstance(value, str):
         return 2, len(value) + 1  # ASCII string, (dtype=2), length + null terminator
-    elif isinstance(value, (bytes, bytearray)):
+    if isinstance(value, (bytes, bytearray)):
         return 1, len(value)  # Binary data (dtype=1)
-    elif isinstance(value, (list, tuple, np.ndarray)):
+    if isinstance(value, (list, tuple, np.ndarray)):
         if isinstance(value, np.ndarray):
             dtype = value.dtype  # Array or sequence
         else:
             dtype = np.array(value).dtype  # Map numpy dtype to TIFF dtype
         if dtype == np.uint8:
             return 1, len(value)
-        elif dtype == np.uint16:
+        if dtype == np.uint16:
             return 3, len(value)
-        elif dtype == np.uint32:
+        if dtype == np.uint32:
             return 4, len(value)
-        elif dtype == np.float32:
+        if dtype == np.float32:
             return 11, len(value)
-        elif dtype == np.float64:
+        if dtype == np.float64:
             return 12, len(value)
-    elif isinstance(value, int):
+    if isinstance(value, int):
         if 0 <= value <= 65535:
             return 3, 1  # uint16
-        else:
-            return 4, 1  # uint32
-    elif isinstance(value, float):
+        return 4, 1  # uint32
+    if isinstance(value, float):
         return 11, 1  # float64
     return 2, len(str(value)) + 1  # Default for othre cases (ASCII string)
 
@@ -128,7 +129,7 @@ def get_tiff_dtype_count(value):
 def add_exif_data_to_jpg_file(exif, in_filenama, out_filename, verbose=False):
     logger = logging.getLogger(__name__)
     if exif is None:
-        raise Exception('No exif data provided.')
+        raise RuntimeError('No exif data provided.')
     if verbose:
         print_exif(exif)
     xmp_data = extract_enclosed_data_for_jpg(exif[XMLPACKET], b'<x:xmpmeta', b'</x:xmpmeta>')
@@ -140,7 +141,11 @@ def add_exif_data_to_jpg_file(exif, in_filenama, out_filename, verbose=False):
                 app1_marker_pos = jpeg_data.find(b'\xFF\xE1')
                 if app1_marker_pos == -1:
                     app1_marker_pos = len(jpeg_data) - 2
-                updated_data = (jpeg_data[:app1_marker_pos] + b'\xFF\xE1' + len(xmp_data).to_bytes(2, 'big') + xmp_data + jpeg_data[app1_marker_pos:])
+                updated_data = (
+                    jpeg_data[:app1_marker_pos] +
+                    b'\xFF\xE1' + len(xmp_data).to_bytes(2, 'big') +
+                    xmp_data + jpeg_data[app1_marker_pos:]
+                )
             else:
                 logger.warning("Copy: can't find XMLPacket in JPG EXIF data")
                 updated_data = jpeg_data
@@ -156,10 +161,10 @@ def write_image_with_exif_data(exif, image, out_filename, verbose=False):
     ext = out_filename.split(".")[-1]
     if verbose:
         print_exif(exif)
-    if ext == 'jpeg' or ext == 'jpg':
+    if ext in ('jpeg', 'jpg'):
         cv2.imwrite(out_filename, image, [int(cv2.IMWRITE_JPEG_QUALITY), 100])
         add_exif_data_to_jpg_file(exif, out_filename, out_filename, verbose)
-    elif ext == 'tiff' or ext == 'tif':
+    elif ext in ('tiff', 'tif'):
         metadata = {"description": f"image generated with {constants.APP_STRING} package"}
         extra_tags, exif_tags = exif_extra_tags_for_tif(exif)
         tifffile.imwrite(out_filename, image, metadata=metadata, compression='adobe_deflate',
@@ -174,16 +179,16 @@ def save_exif_data(exif, in_filename, out_filename=None, verbose=False):
     if out_filename is None:
         out_filename = in_filename
     if exif is None:
-        raise Exception('No exif data provided.')
+        raise RuntimeError('No exif data provided.')
     if verbose:
         print_exif(exif)
-    if ext == 'tiff' or ext == 'tif':
+    if ext in ('tiff', 'tif'):
         image_new = tifffile.imread(in_filename)
     else:
         image_new = Image.open(in_filename)
-    if ext == 'jpeg' or ext == 'jpg':
+    if ext in ('jpeg', 'jpg'):
         add_exif_data_to_jpg_file(exif, in_filename, out_filename, verbose)
-    elif ext == 'tiff' or ext == 'tif':
+    elif ext in ('tiff', 'tif'):
         metadata = {"description": f"image generated with {constants.APP_STRING} package"}
         extra_tags, exif_tags = exif_extra_tags_for_tif(exif)
         tifffile.imwrite(out_filename, image_new, metadata=metadata, compression='adobe_deflate',
@@ -195,9 +200,9 @@ def save_exif_data(exif, in_filename, out_filename=None, verbose=False):
 
 def copy_exif_from_file_to_file(exif_filename, in_filename, out_filename=None, verbose=False):
     if not os.path.isfile(exif_filename):
-        raise Exception("File does not exist: " + exif_filename)
+        raise RuntimeError(f"File does not exist: {exif_filename}")
     if not os.path.isfile(in_filename):
-        raise Exception("File does not exist: " + in_filename)
+        raise RuntimeError(f"File does not exist: {in_filename}")
     exif = get_exif(exif_filename)
     return save_exif_data(exif, in_filename, out_filename, verbose)
 
@@ -210,7 +215,7 @@ def exif_dict(exif, hide_xml=True):
         tag = TAGS.get(tag_id, tag_id)
         if tag_id == XMLPACKET and hide_xml:
             data = "<<< XML data >>>"
-        elif tag_id == IMAGERESOURCES or tag_id == INTERCOLORPROFILE:
+        elif tag_id in (IMAGERESOURCES, INTERCOLORPROFILE):
             data = "<<< Photoshop data >>>"
         elif tag_id == STRIPOFFSETS:
             data = "<<< Strip offsets >>>"
@@ -230,9 +235,9 @@ def exif_dict(exif, hide_xml=True):
 def print_exif(exif, hide_xml=True):
     exif_data = exif_dict(exif, hide_xml)
     if exif_data is None:
-        raise Exception('Image has no exif data.')
+        raise RuntimeError('Image has no exif data.')
     logger = logging.getLogger(__name__)
     for tag, (tag_id, data) in exif_data.items():
         if isinstance(data, IFDRational):
             data = f"{data.numerator}/{data.denominator}"
-        logger.info(f"{tag:25} [#{tag_id:5d}]: {data}")
+        logger.info(msg=f"{tag:25} [#{tag_id:5d}]: {data}")

shinestacker/algorithms/multilayer.py

@@ -1,3 +1,4 @@
+# pylint: disable=C0114, C0115, C0116, E1101, R0914, E0606
 import os
 import logging
 import cv2
@@ -21,39 +22,43 @@ def read_multilayer_tiff(input_file):
 
 
 def write_multilayer_tiff(input_files, output_file, labels=None, exif_path='', callbacks=None):
-    extensions = list(set([file.split(".")[-1] for file in input_files]))
+    extensions = list({file.split(".")[-1] for file in input_files})
     if len(extensions) > 1:
         msg = ", ".join(extensions)
-        raise Exception(f"All input files must have the same extension. Input list has the following extensions: {msg}.")
+        raise RuntimeError("All input files must have the same extension. "
+                           f"Input list has the following extensions: {msg}.")
     extension = extensions[0]
-    if extension == 'tif' or extension == 'tiff':
+    if extension in ('tif', 'tiff'):
         images = [tifffile.imread(p) for p in input_files]
-    elif extension == 'jpg' or extension == 'jpeg':
+    elif extension in ('jpg', 'jpeg'):
         images = [cv2.imread(p) for p in input_files]
         images = [cv2.cvtColor(i, cv2.COLOR_BGR2RGB) for i in images]
     elif extension == 'png':
         images = [cv2.imread(p, cv2.IMREAD_UNCHANGED) for p in input_files]
         images = [cv2.cvtColor(i, cv2.COLOR_BGR2RGB) for i in images]
     if labels is None:
-        image_dict = {file.split('/')[-1].split('.')[0]: image for file, image in zip(input_files, images)}
+        image_dict = {file.split('/')[-1].split('.')[0]: image
+                      for file, image in zip(input_files, images)}
     else:
         if len(labels) != len(input_files):
-            raise Exception("input_files and labels must have the same length if labels are provided.")
-        image_dict = {label: image for label, image in zip(labels, images)}
-    write_multilayer_tiff_from_images(image_dict, output_file, exif_path=exif_path, callbacks=callbacks)
+            raise RuntimeError("input_files and labels "
+                               "must have the same length if labels are provided.")
+        image_dict = dict(zip(labels, images))
+    write_multilayer_tiff_from_images(image_dict, output_file,
+                                      exif_path=exif_path, callbacks=callbacks)
 
 
 def write_multilayer_tiff_from_images(image_dict, output_file, exif_path='', callbacks=None):
     if isinstance(image_dict, (list, tuple, np.ndarray)):
         fmt = 'Layer {:03d}'
         image_dict = {fmt.format(i + 1): img for i, img in enumerate(image_dict)}
-    shapes = list(set([image.shape[:2] for image in image_dict.values()]))
+    shapes = list({image.shape[:2] for image in image_dict.values()})
     if len(shapes) > 1:
-        raise Exception("All input files must have the same dimensions.")
+        raise RuntimeError("All input files must have the same dimensions.")
     shape = shapes[0]
-    dtypes = list(set([image.dtype for image in image_dict.values()]))
+    dtypes = list({image.dtype for image in image_dict.values()})
     if len(dtypes) > 1:
-        raise Exception("All input files must all have 8 bit or 16 bit depth.")
+        raise RuntimeError("All input files must all have 8 bit or 16 bit depth.")
     dtype = dtypes[0]
     max_pixel_value = constants.MAX_UINT16 if dtype == np.uint16 else constants.MAX_UINT8
     transp = np.full_like(list(image_dict.values())[0][..., 0], max_pixel_value)
@@ -127,8 +132,9 @@ def write_multilayer_tiff_from_images(image_dict, output_file, exif_path='', cal
         if os.path.isfile(exif_path):
             extra_tags, exif_tags = exif_extra_tags_for_tif(get_exif(exif_path))
         elif os.path.isdir(exif_path):
-            dirpath, _, fnames = next(os.walk(exif_path))
-            fnames = [name for name in fnames if os.path.splitext(name)[-1][1:].lower() in constants.EXTENSIONS]
+            _dirpath, _, fnames = next(os.walk(exif_path))
+            fnames = [name for name in fnames
+                      if os.path.splitext(name)[-1][1:].lower() in constants.EXTENSIONS]
             extra_tags, exif_tags = exif_extra_tags_for_tif(get_exif(exif_path + '/' + fnames[0]))
         tiff_tags['extratags'] += extra_tags
         tiff_tags = {**tiff_tags, **exif_tags}
@@ -137,16 +143,23 @@ def write_multilayer_tiff_from_images(image_dict, output_file, exif_path='', cal
         if callback:
             callback(output_file.split('/')[-1])
     compression = 'adobe_deflate'
-    overlayed_images = overlay(*((np.concatenate((image, np.expand_dims(transp, axis=-1)), axis=-1), (0, 0)) for image in image_dict.values()), shape=shape)
-    tifffile.imwrite(output_file, overlayed_images, compression=compression, metadata=None, **tiff_tags)
+    overlayed_images = overlay(
+        *((np.concatenate((image, np.expand_dims(transp, axis=-1)),
+          axis=-1), (0, 0)) for image in image_dict.values()), shape=shape
+    )
+    tifffile.imwrite(output_file, overlayed_images,
+                     compression=compression, metadata=None, **tiff_tags)
 
 
-class MultiLayer(FrameMultiDirectory, JobBase):
+class MultiLayer(JobBase, FrameMultiDirectory):
     def __init__(self, name, enabled=True, **kwargs):
         FrameMultiDirectory.__init__(self, name, **kwargs)
         JobBase.__init__(self, name, enabled)
         self.exif_path = kwargs.get('exif_path', '')
-        self.reverse_order = kwargs.get('reverse_order', constants.DEFAULT_MULTILAYER_FILE_REVERSE_ORDER)
+        self.reverse_order = kwargs.get(
+            'reverse_order',
+            constants.DEFAULT_MULTILAYER_FILE_REVERSE_ORDER
+        )
 
     def init(self, job):
         FrameMultiDirectory.init(self, job)
@@ -161,27 +174,34 @@ class MultiLayer(FrameMultiDirectory, JobBase):
         elif hasattr(self.input_full_path, "__len__"):
             paths = self.input_path
         else:
-            raise Exception("input_path option must contain a path or an array of paths")
+            raise RuntimeError("input_path option must contain a path or an array of paths")
         if len(paths) == 0:
             self.print_message(color_str("no input paths specified", "red"), level=logging.WARNING)
             return
         files = self.folder_filelist()
         if len(files) == 0:
-            self.print_message(color_str("no input in {} specified path{}:"
-                                         " ".format(len(paths),
-                                                    's' if len(paths) > 1 else '') + ", ".join([f"'{p}'" for p in paths]), "red"),
-                               level=logging.WARNING)
+            self.print_message(
+                color_str(f"no input in {len(paths)} specified path" +
+                          ('s' if len(paths) > 1 else '') + ": "
+                          ", ".join([f"'{p}'" for p in paths]),
+                          "red"),
+                level=logging.WARNING)
             return
         self.print_message(color_str("merging frames in " + self.folder_list_str(), "blue"))
         input_files = [f"{self.working_path}/{f}" for f in files]
-        self.print_message(color_str("frames: " + ", ".join([i.split("/")[-1] for i in files]), "blue"))
-        self.print_message(color_str("reading files", "blue"))
+        self.print_message(
+            color_str("frames: " + ", ".join([i.split("/")[-1] for i in files]), "blue"))
+        self.print_message(
+            color_str("reading files", "blue"))
         filename = ".".join(files[0].split("/")[-1].split(".")[:-1])
         output_file = f"{self.working_path}/{self.output_path}/{filename}.tif"
         callbacks = {
-            'exif_msg': lambda path: self.print_message(color_str(f"copying exif data from path: {path}", "blue")),
-            'write_msg': lambda path: self.print_message(color_str(f"writing multilayer tiff file: {path}", "blue"))
+            'exif_msg': lambda path: self.print_message(
+                color_str(f"copying exif data from path: {path}", "blue")),
+            'write_msg': lambda path: self.print_message(
+                color_str(f"writing multilayer tiff file: {path}", "blue"))
         }
-        write_multilayer_tiff(input_files, output_file, labels=None, exif_path=self.exif_path, callbacks=callbacks)
+        write_multilayer_tiff(input_files, output_file, labels=None, exif_path=self.exif_path,
+                              callbacks=callbacks)
         app = 'internal_retouch_app' if config.COMBINED_APP else f'{constants.RETOUCH_APP}'
         self.callback('open_app', self.id, self.name, app, output_file)