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

shinestacker/algorithms/stack_framework.py

@@ -1,3 +1,5 @@
+# pylint: disable=C0114, C0115, C0116, W0102, R0902, R0903
+# pylint: disable=R0917, R0913, R1702, R0912, E1111, E1121, W0613
 import logging
 import os
 from .. config.constants import constants
@@ -23,21 +25,34 @@ class StackJob(Job):
 
 
 class FramePaths:
-    def __init__(self, name, input_path='', output_path='', working_path='', plot_path=constants.DEFAULT_PLOTS_PATH,
-                 scratch_output_dir=True, resample=1, reverse_order=constants.DEFAULT_FILE_REVERSE_ORDER, **kwargs):
+    def __init__(self, name, input_path='', output_path='', working_path='',
+                 plot_path=constants.DEFAULT_PLOTS_PATH,
+                 scratch_output_dir=True, resample=1,
+                 reverse_order=constants.DEFAULT_FILE_REVERSE_ORDER, **_kwargs):
         self.name = name
         self.working_path = working_path
         self.plot_path = plot_path
         self.input_path = input_path
         self.output_path = output_path
+        self.output_dir = None
         self.resample = resample
         self.reverse_order = reverse_order
         self.scratch_output_dir = scratch_output_dir
+        self.input_full_path = None
+        self.enabled = None
+        self.filenames = None
+
+    def folder_filelist(self):
+        assert False, "this method should be overwritten"
+
+    def print_message(self, msg='', level=logging.INFO, end=None, begin='', tqdm=False):
+        assert False, "this method should be overwritten"
 
     def set_filelist(self):
-        self.filenames = self.folder_filelist(self.input_full_path)
+        self.filenames = self.folder_filelist()
         file_list = self.input_full_path.replace(self.working_path, '').lstrip('/')
-        self.print_message(color_str(": {} files ".format(len(self.filenames)) + "in folder: " + file_list, 'blue'))
+        self.print_message(color_str(f": {len(self.filenames)} files in folder: {file_list}",
+                                     'blue'))
         self.print_message(color_str("focus stacking", 'blue'))
 
     def init(self, job):
@@ -46,7 +61,9 @@ class FramePaths:
         check_path_exists(self.working_path)
         if self.output_path == '':
             self.output_path = self.name
-        self.output_dir = self.working_path + ('' if self.working_path[-1] == '/' else '/') + self.output_path
+        self.output_dir = self.working_path + \
+            ('' if self.working_path[-1] == '/' else '/') + \
+            self.output_path
         if not os.path.exists(self.output_dir):
             os.makedirs(self.output_dir)
         else:
@@ -58,19 +75,27 @@ class FramePaths:
                             file_path = os.path.join(self.output_dir, filename)
                             if os.path.isfile(file_path):
                                 os.remove(file_path)
-                        self.print_message(color_str(f": output directory {self.output_path} content erased", 'yellow'))
+                        self.print_message(
+                            color_str(f": output directory {self.output_path} content erased",
+                                      'yellow'))
                     else:
-                        self.print_message(color_str(f": module disabled, output directory {self.output_path} not scratched", 'yellow'))
+                        self.print_message(
+                            color_str(f": module disabled, output directory {self.output_path}"
+                                      " not scratched", 'yellow'))
                 else:
-                    self.print_message(color_str(f": output directory {self.output_path} not empty, "
-                        "files may be overwritten or merged with existing ones.", 'yellow'), level=logging.WARNING) # noqa
+                    self.print_message(
+                        color_str(
+                            f": output directory {self.output_path} not empty, "
+                            "files may be overwritten or merged with existing ones.", 'yellow'
+                        ), level=logging.WARNING)
         if self.plot_path == '':
-            self.plot_path = self.working_path + ('' if self.working_path[-1] == '/' else '/') + self.plot_path
+            self.plot_path = self.working_path + \
+                ('' if self.working_path[-1] == '/' else '/') + self.plot_path
             if not os.path.exists(self.plot_path):
                 os.makedirs(self.plot_path)
         if self.input_path == '':
             if len(job.paths) == 0:
-                raise Exception(f"Job {job.name} does not have any configured path")
+                raise RuntimeError(f"Job {job.name} does not have any configured path")
             self.input_path = job.paths[-1]
         job.paths.append(self.output_path)
 
@@ -81,15 +106,16 @@ class FrameDirectory(FramePaths):
 
     def folder_list_str(self):
         if isinstance(self.input_full_path, list):
-            file_list = ", ".join([i for i in self.input_full_path.replace(self.working_path, '').lstrip('/')])
-            return "folder{}: ".format('s' if len(self.input_full_path) > 1 else '') + file_list
-        else:
-            return "folder: " + self.input_full_path.replace(self.working_path, '').lstrip('/')
+            file_list = ", ".join(
+                list(self.input_full_path.replace(self.working_path, '').lstrip('/')))
+            return "folder" + ('s' if len(self.input_full_path) > 1 else '') + f": {file_list}"
+        return "folder: " + self.input_full_path.replace(self.working_path, '').lstrip('/')
 
-    def folder_filelist(self, path):
+    def folder_filelist(self):
         src_contents = os.walk(self.input_full_path)
-        dirpath, _, filenames = next(src_contents)
-        filelist = [name for name in filenames if os.path.splitext(name)[-1][1:].lower() in constants.EXTENSIONS]
+        _dirpath, _, filenames = next(src_contents)
+        filelist = [name for name in filenames
+                    if os.path.splitext(name)[-1][1:].lower() in constants.EXTENSIONS]
         filelist.sort()
         if self.reverse_order:
             filelist.reverse()
@@ -97,24 +123,29 @@ class FrameDirectory(FramePaths):
             filelist = filelist[0::self.resample]
         return filelist
 
-    def init(self, job):
+    def init(self, job, _working_path=''):
         FramePaths.init(self, job)
-        self.input_full_path = self.working_path + ('' if self.working_path[-1] == '/' else '/') + self.input_path
+        self.input_full_path = self.working_path + \
+            ('' if self.working_path[-1] == '/' else '/') + self.input_path
         check_path_exists(self.input_full_path)
         job.paths.append(self.output_path)
 
 
-class FrameMultiDirectory:
-    def __init__(self, name, input_path='', output_path='', working_path='', plot_path=constants.DEFAULT_PLOTS_PATH,
-                 scratch_output_dir=True, resample=1, reverse_order=constants.DEFAULT_FILE_REVERSE_ORDER, **kwargs):
-        FramePaths.__init__(self, name, input_path, output_path, working_path, plot_path, scratch_output_dir, resample, reverse_order, **kwargs)
+class FrameMultiDirectory(FramePaths):
+    def __init__(self, name, input_path='', output_path='', working_path='',
+                 plot_path=constants.DEFAULT_PLOTS_PATH,
+                 scratch_output_dir=True, resample=1,
+                 reverse_order=constants.DEFAULT_FILE_REVERSE_ORDER, **_kwargs):
+        FramePaths.__init__(self, name, input_path, output_path, working_path, plot_path,
+                            scratch_output_dir, resample, reverse_order)
+        self.input_full_path = None
 
     def folder_list_str(self):
         if isinstance(self.input_full_path, list):
-            file_list = ", ".join([d.replace(self.working_path, '').lstrip('/') for d in self.input_full_path])
-            return "folder{}: ".format('s' if len(self.input_full_path) > 1 else '') + file_list
-        else:
-            return "folder: " + self.input_full_path.replace(self.working_path, '').lstrip('/')
+            file_list = ", ".join([d.replace(self.working_path, '').lstrip('/')
+                                   for d in self.input_full_path])
+            return "folder" + ('s' if len(self.input_full_path) > 1 else '') + f": {file_list}"
+        return "folder: " + self.input_full_path.replace(self.working_path, '').lstrip('/')
 
     def folder_filelist(self):
         if isinstance(self.input_full_path, str):
@@ -124,39 +155,49 @@ class FrameMultiDirectory:
             dirs = self.input_full_path
             paths = self.input_path
         else:
-            raise Exception("input_full_path option must contain a path or an array of paths")
+            raise RuntimeError("input_full_path option must contain a path or an array of paths")
         files = []
         for d, p in zip(dirs, paths):
             filelist = []
-            for dirpath, _, filenames in os.walk(d):
-                filelist = [p + "/" + name for name in filenames if os.path.splitext(name)[-1][1:].lower() in constants.EXTENSIONS]
+            for _dirpath, _, filenames in os.walk(d):
+                filelist = [p + "/" + name
+                            for name in filenames
+                            if os.path.splitext(name)[-1][1:].lower() in constants.EXTENSIONS]
                 if self.reverse_order:
                     filelist.reverse()
                 if self.resample > 1:
                     filelist = filelist[0::self.resample]
                 files += filelist
             if len(files) == 0:
-                self.print_message(color_str(f"input folder {p} does not contain any image", "red"), level=logging.WARNING)
+                self.print_message(color_str(f"input folder {p} does not contain any image", "red"),
+                                   level=logging.WARNING)
         return files
 
     def init(self, job):
         FramePaths.init(self, job)
         if isinstance(self.input_path, str):
-            self.input_full_path = self.working_path + ('' if self.working_path[-1] == '/' else '/') + self.input_path
+            self.input_full_path = self.working_path + \
+                ('' if self.working_path[-1] == '/' else '/') + \
+                self.input_path
             check_path_exists(self.input_full_path)
         elif hasattr(self.input_path, "__len__"):
             self.input_full_path = []
             for path in self.input_path:
-                self.input_full_path.append(self.working_path + ('' if self.working_path[-1] == '/' else '/') + path)
+                self.input_full_path.append(self.working_path +
+                                            ('' if self.working_path[-1] == '/' else '/') +
+                                            path)
         job.paths.append(self.output_path)
 
 
-class FramesRefActions(FrameDirectory, ActionList):
+class FramesRefActions(ActionList, FrameDirectory):
     def __init__(self, name, enabled=True, ref_idx=-1, step_process=False, **kwargs):
         FrameDirectory.__init__(self, name, **kwargs)
         ActionList.__init__(self, name, enabled)
         self.ref_idx = ref_idx
         self.step_process = step_process
+        self._idx = None
+        self._ref_idx = None
+        self._idx_step = None
 
     def begin(self):
         ActionList.begin(self)
@@ -168,28 +209,28 @@ class FramesRefActions(FrameDirectory, ActionList):
     def end(self):
         ActionList.end(self)
 
-    def run_frame(self, idx, ref_idx):
-        assert False, 'abstract method'
+    def run_frame(self, _idx, _ref_idx):
+        pass
 
     def run_step(self):
         if self.count == 1:
-            self.__idx = self.ref_idx if self.step_process else 0
-            self.__ref_idx = self.ref_idx
-            self.__idx_step = +1
+            self._idx = self.ref_idx if self.step_process else 0
+            self._ref_idx = self.ref_idx
+            self._idx_step = +1
         ll = len(self.filenames)
         self.print_message_r(
-            color_str("step {}/{}: process file: {}, reference: {}".format(self.count, ll, self.filenames[self.__idx],
-                                                                           self.filenames[self.__ref_idx]), "blue"))
-        self.run_frame(self.__idx, self.__ref_idx)
-        if self.__idx < ll:
+            color_str(f"step {self.count}/{ll}: process file: {self.filenames[self._idx]}, "
+                      f"reference: {self.filenames[self._ref_idx]}", "blue"))
+        self.run_frame(self._idx, self._ref_idx)
+        if self._idx < ll:
             if self.step_process:
-                self.__ref_idx = self.__idx
-            self.__idx += self.__idx_step
-        if self.__idx == ll:
-            self.__idx = self.ref_idx - 1
+                self._ref_idx = self._idx
+            self._idx += self._idx_step
+        if self._idx == ll:
+            self._idx = self.ref_idx - 1
             if self.step_process:
-                self.__ref_idx = self.ref_idx
-            self.__idx_step = -1
+                self._ref_idx = self.ref_idx
+            self._idx_step = -1
 
 
 class SubAction:
@@ -200,38 +241,42 @@ class SubAction:
 class CombinedActions(FramesRefActions):
     def __init__(self, name, actions=[], enabled=True, **kwargs):
         FramesRefActions.__init__(self, name, enabled, **kwargs)
-        self.__actions = actions
+        self._actions = actions
+        self.dtype = None
+        self.shape = None
 
     def begin(self):
         FramesRefActions.begin(self)
-        for a in self.__actions:
+        for a in self._actions:
             if a.enabled:
                 a.begin(self)
 
     def img_ref(self, idx):
         filename = self.filenames[idx]
-        img = read_img((self.output_dir if self.step_process else self.input_full_path) + "/" + filename)
+        img = read_img((self.output_dir
+                        if self.step_process else self.input_full_path) + f"/{filename}")
         self.dtype = img.dtype
         self.shape = img.shape
         if img is None:
-            raise Exception("Invalid file: " + self.input_full_path + "/" + filename)
+            raise RuntimeError(f"Invalid file: {self.input_full_path}/{filename}")
         return img
 
     def run_frame(self, idx, ref_idx):
         filename = self.filenames[idx]
         self.sub_message_r(': read input image')
-        img = read_img(self.input_full_path + "/" + filename)
-        if hasattr(self, 'dtype') and img.dtype != self.dtype:
-            raise BitDepthError(img.dtype, self.dtype)
-        if hasattr(self, 'shape') and img.shape != self.shape:
-            raise ShapeError(img.shape, self.shape)
+        img = read_img(f"{self.input_full_path}/{filename}")
+        if self.dtype is not None and img.dtype != self.dtype:
+            raise BitDepthError(self.dtype, img.dtype, )
+        if self.shape is not None and img.shape != self.shape:
+            raise ShapeError(self.shape, img.shape)
         if img is None:
-            raise Exception("Invalid file: " + self.input_full_path + "/" + filename)
-        if len(self.__actions) == 0:
+            raise RuntimeError(f"Invalid file: {self.input_full_path}/{filename}")
+        if len(self._actions) == 0:
             self.sub_message(color_str(": no actions specified.", "red"), level=logging.WARNING)
-        for a in self.__actions:
+        for a in self._actions:
             if not a.enabled:
-                self.get_logger().warning(color_str(self.base_message + ": sub-action disabled", 'red'))
+                self.get_logger().warning(color_str(f"{self.base_message}: sub-action disabled",
+                                                    'red'))
             else:
                 if self.callback('check_running', self.id, self.name) is False:
                     raise RunStopException(self.name)
@@ -240,9 +285,10 @@ class CombinedActions(FramesRefActions):
         if img is not None:
             write_img(self.output_dir + "/" + filename, img)
         else:
-            self.print_message("No output file resulted from processing input file: " + self.input_full_path + "/" + filename, level=logging.WARNING)
+            self.print_message("No output file resulted from processing input file: "
+                               f"{self.input_full_path}/{filename}", level=logging.WARNING)
 
     def end(self):
-        for a in self.__actions:
+        for a in self._actions:
             if a.enabled:
                 a.end()

shinestacker/algorithms/utils.py

@@ -1,7 +1,8 @@
-import cv2
+# pylint: disable=C0114, C0116, E1101
 import os
-import numpy as np
 import logging
+import numpy as np
+import cv2
 import matplotlib.pyplot as plt
 from .. config.config import config
 from .. core.exceptions import ShapeError, BitDepthError
@@ -9,20 +10,21 @@ from .. core.exceptions import ShapeError, BitDepthError
 
 def read_img(file_path):
     if not os.path.isfile(file_path):
-        raise Exception("File does not exist: " + file_path)
+        raise RuntimeError("File does not exist: " + file_path)
     ext = file_path.split(".")[-1]
-    if ext == 'jpeg' or ext == 'jpg':
+    img = None
+    if ext in ['jpeg', 'jpg']:
         img = cv2.imread(file_path)
-    elif ext == 'tiff' or ext == 'tif' or ext == 'png':
+    elif ext in ['tiff', 'tif', 'png']:
         img = cv2.imread(file_path, cv2.IMREAD_UNCHANGED)
     return img
 
 
 def write_img(file_path, img):
     ext = file_path.split(".")[-1]
-    if ext == 'jpeg' or ext == 'jpg':
+    if ext in ['jpeg', 'jpg']:
         cv2.imwrite(file_path, img, [int(cv2.IMWRITE_JPEG_QUALITY), 100])
-    elif ext == 'tiff' or ext == 'tif':
+    elif ext in ['tiff', 'tif']:
         cv2.imwrite(file_path, img, [int(cv2.IMWRITE_TIFF_COMPRESSION), 1])
     elif ext == 'png':
         cv2.imwrite(file_path, img)
@@ -36,10 +38,9 @@ def img_bw_8bit(img):
     img = img_8bit(img)
     if len(img.shape) == 3:
         return cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
-    elif len(img.shape) == 2:
+    if len(img.shape) == 2:
         return img
-    else:
-        raise ValueError(f"Unsupported image format: {img.shape}")
+    raise ValueError(f"Unsupported image format: {img.shape}")
 
 
 def img_bw(img):
@@ -63,7 +64,7 @@ def validate_image(img, expected_shape=None, expected_dtype=None):
 
 
 def save_plot(filename):
-    logging.getLogger(__name__).debug("save plot file: " + filename)
+    logging.getLogger(__name__).debug(msg=f"save plot file: {filename}")
     dir_path = os.path.dirname(filename)
     if not dir_path:
         dir_path = '.'

shinestacker/algorithms/vignetting.py

@@ -1,8 +1,9 @@
-import cv2
+# pylint: disable=C0114, C0115, C0116, R0902, E1101, W0718, W0640
 import logging
 import numpy as np
 import matplotlib.pyplot as plt
 from scipy.optimize import curve_fit, fsolve
+import cv2
 from .. core.colors import color_str
 from .. config.constants import constants
 from .utils import img_8bit, save_plot
@@ -21,6 +22,12 @@ class Vignetting(SubAction):
         self.plot_summary = kwargs.get('plot_summary', False)
         self.max_correction = kwargs.get('max_correction', constants.DEFAULT_MAX_CORRECTION)
         self.percentiles = np.sort(percentiles)
+        self.w_2 = None
+        self.h_2 = None
+        self.v0 = None
+        self.r_max = None
+        self.process = None
+        self.corrections = None
 
     def radial_mean_intensity(self, image):
         if len(image.shape) > 2:
@@ -40,8 +47,12 @@ class Vignetting(SubAction):
                 mean_intensities[i] = np.nan
         return (radii[1:] + radii[:-1]) / 2, mean_intensities
 
+    @staticmethod
     def sigmoid(r, i0, k, r0):
-        return i0 / (1.0 + np.exp(np.minimum(CLIP_EXP, np.exp(np.clip(k * (r - r0), -CLIP_EXP, CLIP_EXP)))))
+        return i0 / (1.0 +
+                     np.exp(np.minimum(CLIP_EXP,
+                                       np.exp(np.clip(k * (r - r0),
+                                              -CLIP_EXP, CLIP_EXP)))))
 
     def fit_sigmoid(self, radii, intensities):
         valid_mask = ~np.isnan(intensities)
@@ -50,7 +61,9 @@ class Vignetting(SubAction):
             res = curve_fit(Vignetting.sigmoid, r_valid, i_valid,
                             p0=[np.max(i_valid), 0.01, np.median(r_valid)])[0]
         except Exception:
-            self.process.sub_message(color_str(": could not find vignetting model", "red"), level=logging.WARNING)
+            self.process.sub_message(
+                color_str(": could not find vignetting model", "red"),
+                level=logging.WARNING)
             res = None
         return res
 
@@ -66,9 +79,10 @@ class Vignetting(SubAction):
             vignette[np.min(image, axis=2) < self.black_threshold, :] = 1
         else:
             vignette[image < self.black_threshold] = 1
-        return np.clip(image / vignette, 0, 255 if image.dtype == np.uint8 else 65535).astype(image.dtype)
+        return np.clip(image / vignette, 0, 255
+                       if image.dtype == np.uint8 else 65535).astype(image.dtype)
 
-    def run_frame(self, idx, ref_idx, img_0):
+    def run_frame(self, idx, _ref_idx, img_0):
         self.process.sub_message_r(color_str(": compute vignetting", "light_blue"))
         img = cv2.cvtColor(img_8bit(img_0), cv2.COLOR_BGR2GRAY)
         radii, intensities = self.radial_mean_intensity(img)
@@ -77,8 +91,9 @@ class Vignetting(SubAction):
             return img_0
         self.v0 = Vignetting.sigmoid(0, *pars)
         i0_fit, k_fit, r0_fit = pars
-        self.process.sub_message(f": fit parameters: i0={i0_fit:.4f}, k={k_fit:.4f}, r0={r0_fit:.4f}",
-                                 level=logging.DEBUG)
+        self.process.sub_message(
+            f": fit parameters: i0={i0_fit:.4f}, k={k_fit:.4f}, r0={r0_fit:.4f}",
+            level=logging.DEBUG)
         if self.plot_correction:
             plt.figure(figsize=(10, 5))
             plt.plot(radii, intensities, label="image mean intensity")
@@ -88,22 +103,27 @@ class Vignetting(SubAction):
             plt.legend()
             plt.xlim(radii[0], radii[-1])
             plt.ylim(0)
-            idx_str = "{:04d}".format(idx)
-            plot_path = f"{self.process.working_path}/{self.process.plot_path}/{self.process.name}-radial-intensity-{idx_str}.pdf"
+            idx_str = f"{idx:04d}"
+            plot_path = f"{self.process.working_path}/" \
+                f"{self.process.plot_path}/{self.process.name}-" \
+                f"radial-intensity-{idx_str}.pdf"
             save_plot(plot_path)
             plt.close('all')
-            self.process.callback('save_plot', self.process.id, f"{self.process.name}: intensity\nframe {idx_str}", plot_path)
+            self.process.callback(
+                'save_plot', self.process.id,
+                f"{self.process.name}: intensity\nframe {idx_str}", plot_path)
         for i, p in enumerate(self.percentiles):
-            self.corrections[i][idx] = fsolve(lambda x: Vignetting.sigmoid(x, *pars) / self.v0 - p, r0_fit)[0]
+            self.corrections[i][idx] = fsolve(lambda x: Vignetting.sigmoid(x, *pars) /
+                                              self.v0 - p, r0_fit)[0]
         if self.apply_correction:
             self.process.sub_message_r(color_str(": correct vignetting", "light_blue"))
             return self.correct_vignetting(img_0, pars)
-        else:
-            return img_0
+        return img_0
 
     def begin(self, process):
         self.process = process
-        self.corrections = [np.full(self.process.counts, None, dtype=float) for p in self.percentiles]
+        self.corrections = [np.full(self.process.counts, None, dtype=float)
+                            for p in self.percentiles]
 
     def end(self):
         if self.plot_summary:
@@ -113,7 +133,7 @@ class Vignetting(SubAction):
                 linestyle = 'solid'
                 if p == 0.5:
                     linestyle = '-.'
-                elif i == 0 or i == len(self.percentiles) - 1:
+                elif i in (0, len(self.percentiles) - 1):
                     linestyle = 'dotted'
                 plt.plot(xs, self.corrections[i], label=f"{p:.0%} correction",
                          linestyle=linestyle, color="blue")
@@ -121,17 +141,23 @@ class Vignetting(SubAction):
             iis = np.where(self.percentiles == 0.5)
             if len(iis) > 0:
                 i = iis[0][0]
-                if i >= 1 and i < len(self.percentiles) - 1:
-                    plt.fill_between(xs, self.corrections[i - 1], self.corrections[i + 1], color="#0000ff20")
-            plt.plot(xs[[0, -1]], [self.r_max] * 2, linestyle="--", label="max. radius", color="darkred")
-            plt.plot(xs[[0, -1]], [self.w_2] * 2, linestyle="--", label="half width", color="limegreen")
-            plt.plot(xs[[0, -1]], [self.h_2] * 2, linestyle="--", label="half height", color="darkgreen")
+                if 1 <= i < len(self.percentiles) - 1:
+                    plt.fill_between(xs, self.corrections[i - 1], self.corrections[i + 1],
+                                     color="#0000ff20")
+            plt.plot(xs[[0, -1]], [self.r_max] * 2,
+                     linestyle="--", label="max. radius", color="darkred")
+            plt.plot(xs[[0, -1]], [self.w_2] * 2,
+                     linestyle="--", label="half width", color="limegreen")
+            plt.plot(xs[[0, -1]], [self.h_2] * 2,
+                     linestyle="--", label="half height", color="darkgreen")
             plt.xlabel('frame')
             plt.ylabel('distance from center (pixels)')
             plt.legend(ncols=2)
             plt.xlim(xs[0], xs[-1])
             plt.ylim(0, self.r_max * 1.05)
-            plot_path = self.process.working_path + "/" + self.process.plot_path + "/" + self.process.name + "-r0.pdf"
+            plot_path = f"{self.process.working_path}/{self.process.plot_path}/" \
+                        f"{self.process.name}-r0.pdf"
             save_plot(plot_path)
             plt.close('all')
-            self.process.callback('save_plot', self.process.id, f"{self.process.name}: vignetting", plot_path)
+            self.process.callback('save_plot', self.process.id,
+                                  f"{self.process.name}: vignetting", plot_path)

shinestacker/algorithms/white_balance.py

@@ -1,3 +1,4 @@
+# pylint: disable=C0114, C0116
 import numpy as np
 
 

shinestacker/app/about_dialog.py

@@ -1,3 +1,4 @@
+# pylint: disable=C0114, C0116, E0611
 from PySide6.QtWidgets import QMessageBox
 from PySide6.QtCore import Qt
 from .. import __version__
@@ -5,7 +6,7 @@ from .. config.constants import constants
 
 
 def show_about_dialog():
-    version_clean = __version__.split("+")[0]
+    version_clean = __version__.split("+", maxsplit=1)[0]
     about_text = f"""
     <h3>{constants.APP_TITLE}</h3>
     <h4>version: v{version_clean}</h4>
@@ -13,7 +14,10 @@ def show_about_dialog():
     into a single focused image.</p>
     <p>Author: Luca Lista<br/>
     Email: <a href="mailto:luka.lista@gmail.com">luka.lista@gmail.com</a></p>
-    <p><a href="https://github.com/lucalista/shinestacker">GitHub homepage</a></p>
+    <ul>
+    <li><a href="https://shinestacker.wordpress.com/">Website on Wordpress</a></li>
+    <li><a href="https://github.com/lucalista/shinestacker">GitHub project repository</a></li>
+    </ul>
     """
     msg = QMessageBox()
     msg.setWindowTitle(f"About {constants.APP_STRING}")

shinestacker/app/app_config.py

@@ -1,3 +1,4 @@
+# pylint: disable=C0114, C0115, C0116, C0103, W0201
 class _AppConfig:
     _initialized = False
     _instance = None

shinestacker/app/gui_utils.py

@@ -1,6 +1,11 @@
+# pylint: disable=C0114, C0116, E0611
 import os
 import sys
 from PySide6.QtCore import QCoreApplication, QProcess
+from PySide6.QtGui import QAction
+from shinestacker.config.constants import constants
+from shinestacker.config.config import config
+from shinestacker.app.about_dialog import show_about_dialog
 
 
 def disable_macos_special_menu_items():
@@ -33,3 +38,18 @@ def disable_macos_special_menu_items():
     if user:
         QProcess.startDetached("pkill", ["-u", user, "-f", "cfprefsd"])
         QProcess.startDetached("pkill", ["-u", user, "-f", "SystemUIServer"])
+
+
+def fill_app_menu(app, app_menu):
+    about_action = QAction(f"About {constants.APP_STRING}", app)
+    about_action.triggered.connect(show_about_dialog)
+    app_menu.addAction(about_action)
+    app_menu.addSeparator()
+    if config.DONT_USE_NATIVE_MENU:
+        quit_txt, quit_short = "&Quit", "Ctrl+Q"
+    else:
+        quit_txt, quit_short = "Shut dw&wn", "Ctrl+Q"
+    exit_action = QAction(quit_txt, app)
+    exit_action.setShortcut(quit_short)
+    exit_action.triggered.connect(app.quit)
+    app_menu.addAction(exit_action)

shinestacker/app/help_menu.py

@@ -1,3 +1,4 @@
+# pylint: disable=C0114, C0116, E0611
 import webbrowser
 from PySide6.QtWidgets import QMenu
 from PySide6.QtGui import QAction