shinestacker 0.3.3__py3-none-any.whl → 0.3.5__py3-none-any.whl

shinestacker/gui/actions_window.py

@@ -1,13 +1,13 @@
+# pylint: disable=C0114, C0115, C0116, E0611, R0914, R0912, R0915, W0718
 import os.path
 import os
+import traceback
 import json
 import jsonpickle
-import traceback
 from PySide6.QtWidgets import QMessageBox, QFileDialog, QDialog
 from .. core.core_utils import get_app_base_path
 from .. config.constants import constants
 from .project_model import ActionConfig
-from .action_config import ActionConfigDialog
 from .project_editor import ProjectEditor
 from .new_project import NewProjectDialog
 from .project_model import Project
@@ -16,9 +16,6 @@ from .project_model import Project
 class ActionsWindow(ProjectEditor):
     def __init__(self):
         super().__init__()
-        self._current_file = None
-        self._current_file_wd = ''
-        self._modified_project = False
         self.update_title()
 
     def update_title(self):
@@ -31,7 +28,7 @@ class ActionsWindow(ProjectEditor):
 
     def mark_as_modified(self):
         self._modified_project = True
-        self._project_buffer.append(self.project.clone())
+        self.project_buffer.append(self.project.clone())
         self.update_title()
 
     def close_project(self):
@@ -123,19 +120,21 @@ class ActionsWindow(ProjectEditor):
         if not self._check_unsaved_changes():
             return
         if file_path is False:
-            file_path, _ = QFileDialog.getOpenFileName(self, "Open Project", "", "Project Files (*.fsp);;All Files (*)")
+            file_path, _ = QFileDialog.getOpenFileName(
+                self, "Open Project", "", "Project Files (*.fsp);;All Files (*)")
         if file_path:
             try:
                 self._current_file = file_path
-                self._current_file_wd = '' if os.path.isabs(file_path) else os.path.dirname(file_path)
+                self._current_file_wd = '' if os.path.isabs(file_path) \
+                    else os.path.dirname(file_path)
                 if not os.path.isabs(self._current_file_wd):
                     self._current_file_wd = os.path.abspath(self._current_file_wd)
                     self._current_file = os.path.basename(self._current_file)
-                file = open(file_path, 'r')
+                with open(file_path, 'r', encoding="utf-8") as file:
+                    json_obj = json.load(file)
                 pp = file_path.split('/')
                 if len(pp) > 1:
                     os.chdir('/'.join(pp[:-1]))
-                json_obj = json.load(file)
                 project = Project.from_dict(json_obj['project'])
                 if project is None:
                     raise RuntimeError(f"Project from file {file_path} produced a null project.")
@@ -155,21 +154,23 @@ class ActionsWindow(ProjectEditor):
                 if 'working_path' in job.params.keys():
                     working_path = job.params['working_path']
                     if not os.path.isdir(working_path):
-                        QMessageBox.warning(self, "Working path not found",
-                                            f'''The working path specified in the project file for the job:
-                                            "{job.params['name']}"
-                                            was not found.\n
-                                            Please, select a valid working path.''')
+                        QMessageBox.warning(
+                            self, "Working path not found",
+                            f'''The working path specified in the project file for the job:
+                                "{job.params['name']}"
+                                was not found.\n
+                                Please, select a valid working path.''')
                         self.edit_action(job)
                 for action in job.sub_actions:
                     if 'working_path' in job.params.keys():
                         working_path = job.params['working_path']
                         if working_path != '' and not os.path.isdir(working_path):
-                            QMessageBox.warning(self, "Working path not found",
-                                                f'''The working path specified in the project file for the job:
-                                                "{job.params['name']}"
-                                                was not found.\n
-                                                Please, select a valid working path.''')
+                            QMessageBox.warning(
+                                self, "Working path not found",
+                                f'''The working path specified in the project file for the job:
+                                "{job.params['name']}"
+                                was not found.\n
+                                Please, select a valid working path.''')
                             self.edit_action(action)
 
     def current_file_name(self):
@@ -182,7 +183,8 @@ class ActionsWindow(ProjectEditor):
             self.save_project_as()
 
     def save_project_as(self):
-        file_path, _ = QFileDialog.getSaveFileName(self, "Save Project As", "", "Project Files (*.fsp);;All Files (*)")
+        file_path, _ = QFileDialog.getSaveFileName(
+            self, "Save Project As", "", "Project Files (*.fsp);;All Files (*)")
         if file_path:
             if not file_path.endswith('.fsp'):
                 file_path += '.fsp'
@@ -191,6 +193,7 @@ class ActionsWindow(ProjectEditor):
             self._current_file = file_path
             self._modified_project = False
             self.update_title()
+            os.chdir(os.path.dirname(file_path))
 
     def do_save(self, file_path):
         try:
@@ -198,9 +201,10 @@ class ActionsWindow(ProjectEditor):
                 'project': self.project.to_dict(),
                 'version': 1
             })
-            path = f"{self._current_file_wd}/{file_path}" if self._current_file_wd != '' else file_path
-            f = open(path, 'w')
-            f.write(json_obj)
+            path = f"{self._current_file_wd}/{file_path}" \
+                if self._current_file_wd != '' else file_path
+            with open(path, 'w', encoding="utf-8") as f:
+                f.write(json_obj)
             self._modified_project = False
         except Exception as e:
             QMessageBox.critical(self, "Error", f"Cannot save file:\n{str(e)}")
@@ -215,18 +219,14 @@ class ActionsWindow(ProjectEditor):
             if reply == QMessageBox.Save:
                 self.save_project()
                 return True
-            elif reply == QMessageBox.Discard:
-                return True
-            else:
-                return False
-        else:
-            return True
+            return reply == QMessageBox.Discard
+        return True
 
     def on_job_edit(self, item):
         index = self.job_list.row(item)
         if 0 <= index < len(self.project.jobs):
             job = self.project.jobs[index]
-            dialog = ActionConfigDialog(job, self._current_file_wd, self)
+            dialog = self.action_config_dialog(job)
             if dialog.exec() == QDialog.Accepted:
                 current_row = self.job_list.currentRow()
                 if current_row >= 0:
@@ -257,8 +257,9 @@ class ActionsWindow(ProjectEditor):
                         break
             if current_action:
                 if not is_sub_action:
-                    self.set_enabled_sub_actions_gui(current_action.type_name == constants.ACTION_COMBO)
-                dialog = ActionConfigDialog(current_action, self._current_file_wd, self)
+                    self.set_enabled_sub_actions_gui(
+                        current_action.type_name == constants.ACTION_COMBO)
+                dialog = self.action_config_dialog(current_action)
                 if dialog.exec() == QDialog.Accepted:
                     self.on_job_selected(job_index)
                     self.refresh_ui()
@@ -273,14 +274,14 @@ class ActionsWindow(ProjectEditor):
             if self.job_list.hasFocus():
                 current_action = job
             elif self.action_list.hasFocus():
-                job_row, action_row, pos = self.get_current_action()
+                job_row, _action_row, pos = self.get_current_action()
                 if pos.actions is not None:
                     current_action = pos.action if not pos.is_sub_action else pos.sub_action
         if current_action is not None:
             self.edit_action(current_action)
 
     def edit_action(self, action):
-        dialog = ActionConfigDialog(action, self._current_file_wd, self)
+        dialog = self.action_config_dialog(action)
         if dialog.exec() == QDialog.Accepted:
             self.on_job_selected(self.job_list.currentRow())
             self.mark_as_modified()

shinestacker/gui/colors.py

@@ -1,3 +1,4 @@
+# pylint: disable=C0114, C0115, C0116, R0903, E0611
 from PySide6.QtGui import QColor
 
 

shinestacker/gui/gui_images.py

@@ -1,3 +1,4 @@
+# pylint: disable=C0114, C0115, C0116, E0611, W0718, E1101, C0103
 import webbrowser
 import subprocess
 import os
@@ -75,7 +76,8 @@ class GuiImageView(QWidget):
         self.setLayout(self.layout)
         pixmap = QPixmap(file_path)
         if pixmap:
-            scaled_pixmap = pixmap.scaledToWidth(gui_constants.GUI_IMG_WIDTH, Qt.SmoothTransformation)
+            scaled_pixmap = pixmap.scaledToWidth(
+                gui_constants.GUI_IMG_WIDTH, Qt.SmoothTransformation)
             self.image_label.setPixmap(scaled_pixmap)
         else:
             raise RuntimeError(f"Can't load file: {file_path}.")
@@ -112,7 +114,8 @@ class GuiOpenApp(QWidget):
         self.setLayout(self.layout)
         pixmap = QPixmap(file_path)
         if pixmap:
-            scaled_pixmap = pixmap.scaledToWidth(gui_constants.GUI_IMG_WIDTH, Qt.SmoothTransformation)
+            scaled_pixmap = pixmap.scaledToWidth(
+                gui_constants.GUI_IMG_WIDTH, Qt.SmoothTransformation)
             self.image_label.setPixmap(scaled_pixmap)
         else:
             raise RuntimeError(f"Can't load file: {file_path}.")
@@ -134,7 +137,8 @@ class GuiOpenApp(QWidget):
                 try:
                     os.system(f"{self.app} -f {self.file_path} &")
                 except Exception as e:
-                    raise RuntimeError(f"Can't open file {self.file_path} with app: {self.app}.\n{str(e)}")
+                    raise RuntimeError(
+                        f"Can't open file {self.file_path} with app: {self.app}.\n{str(e)}") from e
             else:
                 app = None
                 stacked_widget = self.parent().window().findChild(QStackedWidget)

shinestacker/gui/gui_logging.py

@@ -1,3 +1,4 @@
+# pylint: disable=C0114, C0115, C0116, E0611, W0212, R0903
 import logging
 from PySide6.QtWidgets import QWidget, QTextEdit, QMessageBox, QStatusBar
 from PySide6.QtGui import QTextCursor, QTextOption, QFont
@@ -87,8 +88,8 @@ class SimpleHtmlHandler(QObject, logging.Handler):
         try:
             msg = self.format(record)
             self.html_signal.emit(msg)
-        except Exception as e:
-            logging.error(f"Logging error: {e}")
+        except RuntimeError as e:
+            logging.error(msg=f"Logging error: {e}")
 
 
 class GuiLogger(QWidget):

shinestacker/gui/gui_run.py

@@ -1,3 +1,4 @@
+# pylint: disable=C0114, C0115, C0116, E0611, R0903, R0915, R0914, R0917, R0913, R0902
 import time
 from PySide6.QtWidgets import (QWidget, QPushButton, QVBoxLayout, QHBoxLayout, QProgressBar,
                                QMessageBox, QScrollArea, QSizePolicy, QFrame, QLabel, QComboBox)
@@ -50,6 +51,7 @@ class TimerProgressBar(QProgressBar):
         super().setValue(0)
         self.set_running_style()
         self._start_time = -1
+        self._current_time = -1
 
     def set_style(self, bar_color=None):
         if bar_color is None:
@@ -77,11 +79,11 @@ class TimerProgressBar(QProgressBar):
         m = (ss % 3600) // 60
         s = (ss % 3600) % 60
         x = secs - ss
-        t_str = "{:02d}".format(s) + "{:.1f}s".format(x).lstrip('0')
+        t_str = f"{s:02d}" + f"{x:.1f}s".lstrip('0')
         if m > 0:
-            t_str = "{:02d}:{}".format(m, t_str)
+            t_str = f"{m:02d}:{t_str}"
         if h > 0:
-            t_str = "{:02d}:{}".format(h, t_str)
+            t_str = f"{h:02d}:{t_str}"
         if m > 0 or h > 0:
             t_str = t_str.lstrip('0')
         elif 0 < s < 10:
@@ -114,9 +116,11 @@ class TimerProgressBar(QProgressBar):
         self.check_time(self.maximum())
         self.setValue(self.maximum())
 
+    # pylint: disable=C0103
     def setValue(self, val):
         self.check_time(val)
         super().setValue(val)
+    # pylint: enable=C0103
 
     def set_running_style(self):
         self.set_style(action_running_color)
@@ -192,7 +196,9 @@ class RunWindow(QTextEditLogger):
             self.retouch_widget.setStyleSheet(BLUE_COMBO_STYLE)
             self.retouch_widget.addItems(options)
             self.retouch_widget.setEnabled(False)
-            self.retouch_widget.currentIndexChanged.connect(lambda: self.retouch(self.retouch_paths[self.retouch_widget.currentIndex() - 1]))
+            self.retouch_widget.currentIndexChanged.connect(
+                lambda: self.retouch(
+                    self.retouch_paths[self.retouch_widget.currentIndex() - 1]))
             self.status_bar.addPermanentWidget(self.retouch_widget)
 
         self.stop_button = QPushButton("Stop")
@@ -238,40 +244,40 @@ class RunWindow(QTextEditLogger):
             self.close_window_callback(self.id_str())
 
     @Slot(int, str)
-    def handle_before_action(self, id, name):
-        if 0 <= id < len(self.color_widgets[self.row_widget_id]):
-            self.color_widgets[self.row_widget_id][id].set_color(*action_running_color.tuple())
+    def handle_before_action(self, run_id, _name):
+        if 0 <= run_id < len(self.color_widgets[self.row_widget_id]):
+            self.color_widgets[self.row_widget_id][run_id].set_color(*action_running_color.tuple())
             self.progress_bar.start(1)
-        if id == -1:
+        if run_id == -1:
             self.progress_bar.set_running_style()
 
     @Slot(int, str)
-    def handle_after_action(self, id, name):
-        if 0 <= id < len(self.color_widgets[self.row_widget_id]):
-            self.color_widgets[self.row_widget_id][id].set_color(*action_done_color.tuple())
+    def handle_after_action(self, run_id, _name):
+        if 0 <= run_id < len(self.color_widgets[self.row_widget_id]):
+            self.color_widgets[self.row_widget_id][run_id].set_color(*action_done_color.tuple())
             self.progress_bar.stop()
-        if id == -1:
+        if run_id == -1:
             self.row_widget_id += 1
             self.progress_bar.set_done_style()
 
     @Slot(int, str, str)
-    def handle_step_counts(self, id, name, steps):
+    def handle_step_counts(self, _run_id, _name, steps):
         self.progress_bar.start(steps)
 
     @Slot(int, str)
-    def handle_begin_steps(self, id, name):
+    def handle_begin_steps(self, _run_id, _name):
         self.progress_bar.start(1)
 
     @Slot(int, str)
-    def handle_end_steps(self, id, name):
+    def handle_end_steps(self, _run_id, _name):
         self.progress_bar.stop()
 
     @Slot(int, str, str)
-    def handle_after_step(self, id, name, step):
+    def handle_after_step(self, _run_id, _name, step):
         self.progress_bar.setValue(step)
 
     @Slot(int, str, str)
-    def handle_save_plot(self, id, name, path):
+    def handle_save_plot(self, _run_id, name, path):
         label = QLabel(name, self)
         label.setStyleSheet("QLabel {margin-top: 5px; font-weight: bold;}")
         self.image_layout.addWidget(label)
@@ -290,10 +296,12 @@ class RunWindow(QTextEditLogger):
         self.image_area_widget.setFixedWidth(needed_width)
         self.right_area.updateGeometry()
         self.image_area_widget.updateGeometry()
-        QTimer.singleShot(0, lambda: self.right_area.verticalScrollBar().setValue(self.right_area.verticalScrollBar().maximum()))
+        QTimer.singleShot(
+            0, lambda: self.right_area.verticalScrollBar().setValue(
+                self.right_area.verticalScrollBar().maximum()))
 
     @Slot(int, str, str, str)
-    def handle_open_app(self, id, name, app, path):
+    def handle_open_app(self, _run_id, name, app, path):
         label = QLabel(name, self)
         label.setStyleSheet("QLabel {margin-top: 5px; font-weight: bold;}")
         self.image_layout.addWidget(label)
@@ -306,7 +314,9 @@ class RunWindow(QTextEditLogger):
         self.image_area_widget.setFixedWidth(needed_width)
         self.right_area.updateGeometry()
         self.image_area_widget.updateGeometry()
-        QTimer.singleShot(0, lambda: self.right_area.verticalScrollBar().setValue(self.right_area.verticalScrollBar().maximum()))
+        QTimer.singleShot(
+            0, lambda: self.right_area.verticalScrollBar().setValue(
+                self.right_area.verticalScrollBar().maximum()))
 
 
 class RunWorker(LogWorker):
@@ -336,40 +346,41 @@ class RunWorker(LogWorker):
         }
         self.tag = ""
 
-    def before_action(self, id, name):
-        self.before_action_signal.emit(id, name)
+    def before_action(self, run_id, name):
+        self.before_action_signal.emit(run_id, name)
 
-    def after_action(self, id, name):
-        self.after_action_signal.emit(id, name)
+    def after_action(self, run_id, name):
+        self.after_action_signal.emit(run_id, name)
 
-    def step_counts(self, id, name, steps):
-        self.step_counts_signal.emit(id, name, steps)
+    def step_counts(self, run_id, name, steps):
+        self.step_counts_signal.emit(run_id, name, steps)
 
-    def begin_steps(self, id, name):
-        self.begin_steps_signal.emit(id, name)
+    def begin_steps(self, run_id, name):
+        self.begin_steps_signal.emit(run_id, name)
 
-    def end_steps(self, id, name):
-        self.end_steps_signal.emit(id, name)
+    def end_steps(self, run_id, name):
+        self.end_steps_signal.emit(run_id, name)
 
-    def after_step(self, id, name, step):
-        self.after_step_signal.emit(id, name, step)
+    def after_step(self, run_id, name, step):
+        self.after_step_signal.emit(run_id, name, step)
 
-    def save_plot(self, id, name, path):
-        self.save_plot_signal.emit(id, name, path)
+    def save_plot(self, run_id, name, path):
+        self.save_plot_signal.emit(run_id, name, path)
 
-    def open_app(self, id, name, app, path):
-        self.open_app_signal.emit(id, name, app, path)
+    def open_app(self, run_id, name, app, path):
+        self.open_app_signal.emit(run_id, name, app, path)
 
-    def check_running(self, id, name):
+    def check_running(self, _run_id, _name):
         return self.status == constants.STATUS_RUNNING
 
     def run(self):
+        # pylint: disable=line-too-long
         self.status_signal.emit(f"{self.tag} running...", constants.RUN_ONGOING, "", 0)
         self.html_signal.emit(f'''
         <div style="margin: 2px 0; font-family: {constants.LOG_FONTS_STR};">
         <span style="color: #{ColorPalette.DARK_BLUE.hex()}; font-style: italic; font-weigt: bold;">{self.tag} begins</span>
         </div>
-        ''')
+        ''') # noqa
         status, error_message = self.do_run()
         if status == constants.RUN_FAILED:
             message = f"{self.tag} failed"
@@ -380,11 +391,15 @@ class RunWorker(LogWorker):
         elif status == constants.RUN_STOPPED:
             message = f"{self.tag} stopped"
             color = "#" + ColorPalette.DARK_RED.hex()
+        else:
+            message = ''
+            color = "#000000"
         self.html_signal.emit(f'''
         <div style="margin: 2px 0; font-family: {constants.LOG_FONTS_STR};">
         <span style="color: {color}; font-style: italic; font-weight: bold;">{message}</span>
         </div>
         ''')
+        # pylint: enable=line-too-long
         self.end_signal.emit(status, self.id_str, message)
         self.status_signal.emit(message, status, error_message, 0)
 

shinestacker/gui/main_window.py

@@ -1,3 +1,4 @@
+# pylint: disable=C0114, C0115, C0116, E0611, R0902, R0915, R0904, R0914, R0912, E1101, W0201
 import os
 import subprocess
 from PySide6.QtWidgets import (QWidget, QVBoxLayout, QHBoxLayout, QTabWidget, QLabel, QMessageBox,
@@ -90,6 +91,7 @@ class TabWidgetWithPlaceholder(QWidget):
         else:
             self.stacked_widget.setCurrentIndex(0)
 
+    # pylint: disable=C0103
     def addTab(self, widget, label):
         result = self.tab_widget.addTab(widget, label)
         self.update_placeholder_visibility()
@@ -117,6 +119,7 @@ class TabWidgetWithPlaceholder(QWidget):
 
     def indexOf(self, widget):
         return self.tab_widget.indexOf(widget)
+    # pylint: enable=C0103
 
 
 class MainWindow(ActionsWindow, LogManager):
@@ -289,17 +292,44 @@ class MainWindow(ActionsWindow, LogManager):
         self.run_all_jobs_action.triggered.connect(self.run_all_jobs)
         menu.addAction(self.run_all_jobs_action)
 
+    def add_action_combined_actions(self):
+        self.add_action(constants.ACTION_COMBO)
+
+    def add_action_noise_detection(self):
+        self.add_action(constants.ACTION_NOISEDETECTION)
+
+    def add_action_focus_stack(self):
+        self.add_action(constants.ACTION_FOCUSSTACK)
+
+    def add_action_focus_stack_bunch(self):
+        self.add_action(constants.ACTION_FOCUSSTACKBUNCH)
+
+    def add_action_multilayer(self):
+        self.add_action(constants.ACTION_MULTILAYER)
+
+    def add_sub_action_make_noise(self):
+        self.add_sub_action(constants.ACTION_MASKNOISE)
+
+    def add_sub_action_vignetting(self):
+        self.add_sub_action(constants.ACTION_VIGNETTING)
+
+    def add_sub_action_align_frames(self):
+        self.add_sub_action(constants.ACTION_ALIGNFRAMES)
+
+    def add_sub_action_balance_frames(self):
+        self.add_sub_action(constants.ACTION_BALANCEFRAMES)
+
     def add_actions_menu(self, menubar):
         menu = menubar.addMenu("&Actions")
         add_action_menu = QMenu("Add Action", self)
         for action in constants.ACTION_TYPES:
             entry_action = QAction(action, self)
             entry_action.triggered.connect({
-                constants.ACTION_COMBO: self.add_action_CombinedActions,
-                constants.ACTION_NOISEDETECTION: self.add_action_NoiseDetection,
-                constants.ACTION_FOCUSSTACK: self.add_action_FocusStack,
-                constants.ACTION_FOCUSSTACKBUNCH: self.add_action_FocusStackBunch,
-                constants.ACTION_MULTILAYER: self.add_action_MultiLayer
+                constants.ACTION_COMBO: self.add_action_combined_actions,
+                constants.ACTION_NOISEDETECTION: self.add_action_noise_detection,
+                constants.ACTION_FOCUSSTACK: self.add_action_focus_stack,
+                constants.ACTION_FOCUSSTACKBUNCH: self.add_action_focus_stack_bunch,
+                constants.ACTION_MULTILAYER: self.add_action_multilayer
             }[action])
             add_action_menu.addAction(entry_action)
         menu.addMenu(add_action_menu)
@@ -308,10 +338,10 @@ class MainWindow(ActionsWindow, LogManager):
         for action in constants.SUB_ACTION_TYPES:
             entry_action = QAction(action, self)
             entry_action.triggered.connect({
-                constants.ACTION_MASKNOISE: self.add_sub_action_MakeNoise,
-                constants.ACTION_VIGNETTING: self.add_sub_action_Vignetting,
-                constants.ACTION_ALIGNFRAMES: self.add_sub_action_AlignFrames,
-                constants.ACTION_BALANCEFRAMES: self.add_sub_action_BalanceFrames
+                constants.ACTION_MASKNOISE: self.add_sub_action_make_noise,
+                constants.ACTION_VIGNETTING: self.add_sub_action_vignetting,
+                constants.ACTION_ALIGNFRAMES: self.add_sub_action_align_frames,
+                constants.ACTION_BALANCEFRAMES: self.add_sub_action_balance_frames
             }[action])
             entry_action.setEnabled(False)
             self.sub_action_menu_entries.append(entry_action)
@@ -330,7 +360,8 @@ class MainWindow(ActionsWindow, LogManager):
         self.action_selector.setEnabled(False)
         toolbar.addWidget(self.action_selector)
         self.add_action_entry_action = QAction("Add Action", self)
-        self.add_action_entry_action.setIcon(QIcon(os.path.join(self.script_dir, "img/plus-round-line-icon.png")))
+        self.add_action_entry_action.setIcon(
+            QIcon(os.path.join(self.script_dir, "img/plus-round-line-icon.png")))
         self.add_action_entry_action.setToolTip("Add action")
         self.add_action_entry_action.triggered.connect(self.add_action)
         self.add_action_entry_action.setEnabled(False)
@@ -340,7 +371,8 @@ class MainWindow(ActionsWindow, LogManager):
         self.sub_action_selector.setEnabled(False)
         toolbar.addWidget(self.sub_action_selector)
         self.add_sub_action_entry_action = QAction("Add Sub Action", self)
-        self.add_sub_action_entry_action.setIcon(QIcon(os.path.join(self.script_dir, "img/plus-round-line-icon.png")))
+        self.add_sub_action_entry_action.setIcon(
+            QIcon(os.path.join(self.script_dir, "img/plus-round-line-icon.png")))
         self.add_sub_action_entry_action.setToolTip("Add sub action")
         self.add_sub_action_entry_action.triggered.connect(self.add_sub_action)
         self.add_sub_action_entry_action.setEnabled(False)
@@ -351,6 +383,7 @@ class MainWindow(ActionsWindow, LogManager):
         toolbar.addAction(self.run_job_action)
         toolbar.addAction(self.run_all_jobs_action)
 
+    # pylint: disable=C0103
     def contextMenuEvent(self, event):
         item = self.job_list.itemAt(self.job_list.viewport().mapFrom(self, event.pos()))
         current_action = None
@@ -362,7 +395,7 @@ class MainWindow(ActionsWindow, LogManager):
         if item:
             index = self.action_list.row(item)
             self.action_list.setCurrentRow(index)
-            job_row, action_row, pos = self.get_action_at(index)
+            _job_row, _action_row, pos = self.get_action_at(index)
             current_action = pos.action if not pos.is_sub_action else pos.sub_action
         if current_action:
             menu = QMenu(self)
@@ -375,7 +408,8 @@ class MainWindow(ActionsWindow, LogManager):
             menu.addAction(edit_config_action)
             menu.addSeparator()
             self.current_action_working_path, name = get_action_working_path(current_action)
-            if self.current_action_working_path != '' and os.path.exists(self.current_action_working_path):
+            if self.current_action_working_path != '' and \
+                    os.path.exists(self.current_action_working_path):
                 action_name = "Browse Working Path" + (f" > {name}" if name != '' else '')
                 self.browse_working_path_action = QAction(action_name)
                 self.browse_working_path_action.triggered.connect(self.browse_working_path_path)
@@ -383,7 +417,8 @@ class MainWindow(ActionsWindow, LogManager):
             ip, name = get_action_input_path(current_action)
             if ip != '':
                 ips = ip.split(constants.PATH_SEPARATOR)
-                self.current_action_input_path = constants.PATH_SEPARATOR.join([f"{self.current_action_working_path}/{ip}" for ip in ips])
+                self.current_action_input_path = constants.PATH_SEPARATOR.join(
+                    [f"{self.current_action_working_path}/{ip}" for ip in ips])
                 p_exists = False
                 for p in self.current_action_input_path.split(constants.PATH_SEPARATOR):
                     if os.path.exists(p):
@@ -410,20 +445,25 @@ class MainWindow(ActionsWindow, LogManager):
                 if len(retouch_path) > 0:
                     menu.addSeparator()
                     self.job_retouch_path_action = QAction("Retouch path")
-                    self.job_retouch_path_action.triggered.connect(lambda job: self.run_retouch_path(current_action, retouch_path))
+                    self.job_retouch_path_action.triggered.connect(
+                        lambda job: self.run_retouch_path(current_action, retouch_path))
                     menu.addAction(self.job_retouch_path_action)
             menu.exec(event.globalPos())
+    # pylint: enable=C0103
 
     def get_icon(self, icon):
         return QIcon(os.path.join(self.script_dir, f"img/{icon}.png"))
 
     def get_retouch_path(self, job):
         frames_path = [get_action_output_path(action)[0]
-                       for action in job.sub_actions if action.type_name == constants.ACTION_COMBO]
+                       for action in job.sub_actions
+                       if action.type_name == constants.ACTION_COMBO]
         bunches_path = [get_action_output_path(action)[0]
-                        for action in job.sub_actions if action.type_name == constants.ACTION_FOCUSSTACKBUNCH]
+                        for action in job.sub_actions
+                        if action.type_name == constants.ACTION_FOCUSSTACKBUNCH]
         stack_path = [get_action_output_path(action)[0]
-                      for action in job.sub_actions if action.type_name == constants.ACTION_FOCUSSTACK]
+                      for action in job.sub_actions
+                      if action.type_name == constants.ACTION_FOCUSSTACK]
         if len(bunches_path) > 0:
             stack_path += [bunches_path[0]]
         elif len(frames_path) > 0:
@@ -434,7 +474,7 @@ class MainWindow(ActionsWindow, LogManager):
         stack_path = [f"{wp}/{s}" for s in stack_path]
         return stack_path
 
-    def run_retouch_path(self, job, retouch_path):
+    def run_retouch_path(self, _job, retouch_path):
         self.retouch_callback(retouch_path)
 
     def browse_path(self, path):
@@ -444,9 +484,9 @@ class MainWindow(ActionsWindow, LogManager):
                 if running_under_windows():
                     os.startfile(os.path.normpath(p))
                 elif running_under_macos():
-                    subprocess.run(['open', p])
+                    subprocess.run(['open', p], check=True)
                 else:
-                    subprocess.run(['xdg-open', p])
+                    subprocess.run(['xdg-open', p], check=True)
 
     def browse_working_path_path(self):
         self.browse_path(self.current_action_working_path)
@@ -501,13 +541,14 @@ class MainWindow(ActionsWindow, LogManager):
             w = self.tab_widget.widget(i)
             if w.id_str() == id_str:
                 return i, w
+        return None, None
 
     def get_tab_at_position(self, id_str):
-        i, w = self.get_tab_and_position(id_str)
+        _i, w = self.get_tab_and_position(id_str)
         return w
 
     def get_tab_position(self, id_str):
-        i, w = self.get_tab_and_position(id_str)
+        i, _w = self.get_tab_and_position(id_str)
         return i
 
     def do_handle_end_message(self, status, id_str, message):
@@ -581,11 +622,14 @@ class MainWindow(ActionsWindow, LogManager):
                 self.start_thread(worker)
                 self._workers.append(worker)
             else:
-                QMessageBox.warning(self, "Can't run Job", "Job " + job.params["name"] + " is disabled.")
+                QMessageBox.warning(
+                    self, "Can't run Job",
+                    "Job " + job.params["name"] + " is disabled.")
                 return
 
     def run_all_jobs(self):
-        labels = [[(self.action_text(a), a.enabled() and job.enabled()) for a in job.sub_actions] for job in self.project.jobs]
+        labels = [[(self.action_text(a), a.enabled() and
+                    job.enabled()) for a in job.sub_actions] for job in self.project.jobs]
         project_name = ".".join(self.current_file_name().split(".")[:-1])
         if project_name == '':
             project_name = '[new]'