boris-behav-obs 8.27.9__py2.py3-none-any.whl → 9.0.1__py2.py3-none-any.whl

boris/export_events.py

@@ -38,7 +38,7 @@ from . import project_functions
 from . import dialog
 from . import db_functions
 
-from PyQt5.QtWidgets import QApplication, QFileDialog, QMessageBox, QInputDialog
+from PySide6.QtWidgets import QApplication, QFileDialog, QMessageBox, QInputDialog
 
 
 def export_events_as_behavioral_sequences(self, separated_subjects=False, timed=False):
@@ -93,28 +93,28 @@ def export_events_as_behavioral_sequences(self, separated_subjects=False, timed=
         QMessageBox.warning(None, cfg.programName, "Select subject(s) and behavior(s) to analyze")
         return
 
-    fn = QFileDialog().getSaveFileName(self, "Export events as behavioral sequences", "", "Text files (*.txt);;All files (*)")
-    file_name = fn[0] if type(fn) is tuple else fn
-
-    if file_name:
-        r, msg = export_observation.observation_to_behavioral_sequences(
-            pj=self.pj,
-            selected_observations=selected_observations,
-            parameters=parameters,
-            behaviors_separator=self.behav_seq_separator,
-            separated_subjects=separated_subjects,
-            timed=timed,
-            file_name=file_name,
+    file_name, _ = QFileDialog.getSaveFileName(self, "Export events as behavioral sequences", "", "Text files (*.txt);;All files (*)")
+
+    if not file_name:
+        return
+    r, msg = export_observation.observation_to_behavioral_sequences(
+        pj=self.pj,
+        selected_observations=selected_observations,
+        parameters=parameters,
+        behaviors_separator=self.behav_seq_separator,
+        separated_subjects=separated_subjects,
+        timed=timed,
+        file_name=file_name,
+    )
+    if not r:
+        logging.critical(f"Error while exporting events as behavioral sequences: {msg}")
+        QMessageBox.critical(
+            None,
+            cfg.programName,
+            f"Error while exporting events as behavioral sequences:<br>{msg}",
+            QMessageBox.Ok | QMessageBox.Default,
+            QMessageBox.NoButton,
         )
-        if not r:
-            logging.critical(f"Error while exporting events as behavioral sequences: {msg}")
-            QMessageBox.critical(
-                None,
-                cfg.programName,
-                f"Error while exporting events as behavioral sequences:<br>{msg}",
-                QMessageBox.Ok | QMessageBox.Default,
-                QMessageBox.NoButton,
-            )
 
 
 def export_tabular_events(self, mode: str = "tabular") -> None:
@@ -215,7 +215,12 @@ def export_tabular_events(self, mode: str = "tabular") -> None:
                 return
 
         if len(selected_observations) == 1:
-            file_name, filter_ = QFileDialog().getSaveFileName(self, "Export events", "", ";;".join(available_formats))
+            file_dialog_options = QFileDialog.Options()
+            file_dialog_options |= QFileDialog.DontConfirmOverwrite
+
+            file_name, filter_ = QFileDialog().getSaveFileName(
+                self, "Export events", "", ";;".join(available_formats), options=file_dialog_options
+            )
             if not file_name:
                 return
 
@@ -223,7 +228,7 @@ def export_tabular_events(self, mode: str = "tabular") -> None:
             if pl.Path(file_name).suffix != "." + output_format:
                 file_name = str(pl.Path(file_name)) + "." + output_format
                 # check if file with new extension already exists
-                if pl.Path(file_name).is_file():
+                if pl.Path(file_name).exists():
                     if (
                         dialog.MessageDialog(cfg.programName, f"The file {file_name} already exists.", [cfg.CANCEL, cfg.OVERWRITE])
                         == cfg.CANCEL
@@ -398,7 +403,12 @@ def export_aggregated_events(self):
             cfg.RDS,
         )
 
-        fileName, filter_ = QFileDialog().getSaveFileName(self, "Export aggregated events", "", ";;".join(file_formats))
+        file_dialog_options = QFileDialog.Options()
+        file_dialog_options |= QFileDialog.DontConfirmOverwrite
+
+        fileName, filter_ = QFileDialog().getSaveFileName(
+            self, "Export aggregated events", "", ";;".join(file_formats), options=file_dialog_options
+        )
 
         if not fileName:
             return
@@ -407,7 +417,7 @@ def export_aggregated_events(self):
         if pl.Path(fileName).suffix != "." + outputFormat:
             # check if file with new extension already exists
             fileName = str(pl.Path(fileName)) + "." + outputFormat
-            if pl.Path(fileName).is_file():
+            if pl.Path(fileName).exists():
                 if dialog.MessageDialog(cfg.programName, f"The file {fileName} already exists.", [cfg.CANCEL, cfg.OVERWRITE]) == cfg.CANCEL:
                     return
 
@@ -671,8 +681,8 @@ def export_events_as_textgrid(self) -> None:
         QMessageBox.warning(None, cfg.programName, "Select subject(s) and behavior(s) to export")
         return
 
-    export_dir = QFileDialog(self).getExistingDirectory(
-        self, "Export events as Praat TextGrid", os.path.expanduser("~"), options=QFileDialog(self).ShowDirsOnly
+    export_dir = QFileDialog.getExistingDirectory(
+        self, "Export events as Praat TextGrid", os.path.expanduser("~"), options=QFileDialog.ShowDirsOnly
     )
     if not export_dir:
         return

boris/export_observation.py

@@ -601,7 +601,7 @@ def dataset_write(dataset: tablib.Dataset, file_name: str, output_format: str, d
             if output_format == cfg.PANDAS_DF_EXT:
                 df.to_pickle(file_name)
 
-            if flag_pyreadr_loaded and output_format == cfg.RDS_EXT:
+            if output_format == cfg.RDS_EXT and flag_pyreadr_loaded:
                 pyreadr.write_rds(file_name, df)
 
             return True, ""

boris/external_processes.py

@@ -20,14 +20,13 @@ This file is part of BORIS.
 
 """
 
-
 import os
 import tempfile
 import pathlib as pl
 import logging
 
-from PyQt5.QtWidgets import QFileDialog, QMessageBox, QInputDialog
-from PyQt5.QtCore import (
+from PySide6.QtWidgets import QFileDialog, QMessageBox, QInputDialog
+from PySide6.QtCore import (
     Qt,
     QProcess,
 )
@@ -101,8 +100,7 @@ def ffmpeg_process(self, action: str):
     else:
         msg = f"Select one or more video files to {action.replace('_', ' and ')}"
         file_type = "Video files (*)"
-    fn = QFileDialog().getOpenFileNames(self, msg, "", file_type)
-    file_names = fn[0] if type(fn) is tuple else fn
+    file_names, _ = QFileDialog().getOpenFileNames(self, msg, "", file_type)
 
     if not file_names:
         return

boris/geometric_measurement.py

@@ -33,9 +33,9 @@ except ModuleNotFoundError:
     flag_pyreadr_loaded = False
 
 
-from PyQt5.QtCore import QPoint, Qt, pyqtSignal, QEvent
-from PyQt5.QtGui import QColor, QPainter, QPolygon, QPixmap
-from PyQt5.QtWidgets import (
+from PySide6.QtCore import QPoint, Qt, Signal, QEvent
+from PySide6.QtGui import QColor, QPainter, QPolygon, QPixmap, QAction, QPen
+from PySide6.QtWidgets import (
     QApplication,
     QCheckBox,
     QFileDialog,
@@ -51,7 +51,6 @@ from PyQt5.QtWidgets import (
     QColorDialog,
     QSpacerItem,
     QSizePolicy,
-    QAction,
     QDialog,
 )
 
@@ -67,10 +66,10 @@ class wgMeasurement(QDialog):
     widget for geometric measurements
     """
 
-    closeSignal = pyqtSignal()
-    send_event_signal = pyqtSignal(QEvent)
-    reload_image_signal = pyqtSignal()
-    save_picture_signal = pyqtSignal(str)
+    closeSignal = Signal()
+    send_event_signal = Signal(QEvent)
+    reload_image_signal = Signal()
+    save_picture_signal = Signal(str)
     mark_color: str = cfg.ACTIVE_MEASUREMENTS_COLOR
     flag_saved = True  # store if measurements are saved
     draw_mem: dict = {}
@@ -452,15 +451,24 @@ def draw_point(self, x: int, y: int, color: str, n_player: int = 0) -> None:
     """
     draw point on frame-by-frame image
     """
+
+    logging.debug("draw_point function")
+
     RADIUS = 6
-    painter = QPainter()
-    painter.begin(self.dw_player[n_player].frame_viewer.pixmap())
-    painter.setPen(QColor(color))
-    painter.drawEllipse(QPoint(x, y), RADIUS, RADIUS)
-    # cross inside circle
-    painter.drawLine(x - RADIUS, y, x + RADIUS, y)
-    painter.drawLine(x, y - RADIUS, x, y + RADIUS)
-    painter.end()
+
+    pixmap_copy = self.dw_player[n_player].frame_viewer.pixmap().copy()
+
+    painter = QPainter(pixmap_copy)
+    try:
+        painter.setPen(QPen(QColor(color), 1))
+        painter.drawEllipse(QPoint(x, y), RADIUS, RADIUS)
+        # cross inside circle
+        painter.drawLine(x - RADIUS, y, x + RADIUS, y)
+        painter.drawLine(x, y - RADIUS, x, y + RADIUS)
+    finally:
+        painter.end()
+
+    self.dw_player[n_player].frame_viewer.setPixmap(pixmap_copy)
     self.dw_player[n_player].frame_viewer.update()
 
 
@@ -468,11 +476,17 @@ def draw_line(self, x1: int, y1: int, x2: int, y2: int, color: str, n_player: in
     """
     draw line on frame-by-frame image
     """
-    painter = QPainter()
-    painter.begin(self.dw_player[n_player].frame_viewer.pixmap())
-    painter.setPen(QColor(color))
-    painter.drawLine(x1, y1, x2, y2)
-    painter.end()
+
+    pixmap_copy = self.dw_player[n_player].frame_viewer.pixmap().copy()
+    painter = QPainter(pixmap_copy)
+
+    try:
+        painter.setPen(QColor(color))
+        painter.drawLine(x1, y1, x2, y2)
+    finally:
+        painter.end()
+
+    self.dw_player[n_player].frame_viewer.setPixmap(pixmap_copy)
     self.dw_player[n_player].frame_viewer.update()
 
 
@@ -520,6 +534,8 @@ def image_clicked(self, n_player: int, event) -> None:
 
     x, y = event.pos().x(), event.pos().y()
 
+    logging.debug(f"clicked on {x} {y}")
+
     # convert label coordinates in pixmap coordinates
     pixmap_x = int(x - (self.dw_player[n_player].frame_viewer.width() - self.dw_player[n_player].frame_viewer.pixmap().width()) / 2)
     pixmap_y = int(y - (self.dw_player[n_player].frame_viewer.height() - self.dw_player[n_player].frame_viewer.pixmap().height()) / 2)
@@ -892,11 +908,18 @@ def redraw_measurements(self):
                         for x, y in element["coordinates"]:
                             x, y = scale_coord([x, y])
                             polygon.append(QPoint(x, y))
-                        painter = QPainter()
-                        painter.begin(self.dw_player[idx].frame_viewer.pixmap())
-                        painter.setPen(QColor(elements_color))
-                        painter.drawPolygon(polygon)
-                        painter.end()
+
+                        pixmap_copy = self.dw_player[idx].frame_viewer.pixmap().copy()
+                        painter = QPainter(pixmap_copy)
+
+                        try:
+                            painter.setPen(QColor(elements_color))
+                            painter.drawPolygon(polygon)
+                        finally:
+                            painter.end()
+
+                        self.dw_player[idx].frame_viewer.setPixmap(pixmap_copy)
+
                         dw.frame_viewer.update()
 
                     if element["object_type"] == cfg.POLYLINE_OBJECT:

boris/gui_utilities.py

@@ -21,9 +21,9 @@ Copyright 2012-2024 Olivier Friard
 
 import pathlib as pl
 import logging
-from PyQt5.QtCore import QSettings
-from PyQt5.QtWidgets import QWidget
-from PyQt5.QtGui import QIcon
+from PySide6.QtCore import QSettings
+from PySide6.QtWidgets import QWidget
+from PySide6.QtGui import QIcon
 
 
 def save_geometry(widget: QWidget, widget_name: str):
@@ -59,43 +59,44 @@ def restore_geometry(widget: QWidget, widget_name: str, default_geometry):
                 logging.warning("Error during restoring default")
 
 
-def set_icons(self):
+def set_icons(self, theme_mode: str) -> None:
     """
     set icons of actions
     """
 
     # menu
-    self.actionTime_budget.setIcon(QIcon(":/time_budget"))
-    self.actionPlot_events2.setIcon(QIcon(":/plot_events"))
-    self.action_advanced_event_filtering.setIcon(QIcon(":/filter"))
-    self.actionPreferences.setIcon(QIcon(":/preferences"))
+    self.action_obs_list.setIcon(QIcon(f":/observations_list_{theme_mode}"))
 
-    self.action_obs_list.setIcon(QIcon(":/observations_list"))
+    self.actionTime_budget.setIcon(QIcon(f":/time_budget_{theme_mode}"))
+    self.actionPlot_events2.setIcon(QIcon(f":/plot_events_{theme_mode}"))
+    self.action_advanced_event_filtering.setIcon(QIcon(f":/filter_{theme_mode}"))
 
-    self.actionPlay.setIcon(QIcon(":/play"))
-    self.actionReset.setIcon(QIcon(":/reset"))
-    self.actionJumpBackward.setIcon(QIcon(":/jump_backward"))
-    self.actionJumpForward.setIcon(QIcon(":/jump_forward"))
+    self.actionPreferences.setIcon(QIcon(f":/preferences_{theme_mode}"))
 
-    self.actionFaster.setIcon(QIcon(":/faster"))
-    self.actionSlower.setIcon(QIcon(":/slower"))
-    self.actionNormalSpeed.setIcon(QIcon(":/normal_speed"))
+    self.actionPlay.setIcon(QIcon(f":/play_{theme_mode}"))
+    self.actionReset.setIcon(QIcon(f":/reset_{theme_mode}"))
+    self.actionJumpBackward.setIcon(QIcon(f":/jump_backward_{theme_mode}"))
+    self.actionJumpForward.setIcon(QIcon(f":/jump_forward_{theme_mode}"))
 
-    self.actionPrevious.setIcon(QIcon(":/previous"))
-    self.actionNext.setIcon(QIcon(":/next"))
+    self.actionFaster.setIcon(QIcon(f":/faster_{theme_mode}"))
+    self.actionSlower.setIcon(QIcon(f":/slower_{theme_mode}"))
+    self.actionNormalSpeed.setIcon(QIcon(f":/normal_speed_{theme_mode}"))
 
-    self.actionSnapshot.setIcon(QIcon(":/snapshot"))
+    self.actionPrevious.setIcon(QIcon(f":/previous_{theme_mode}"))
+    self.actionNext.setIcon(QIcon(f":/next_{theme_mode}"))
 
-    self.actionFrame_backward.setIcon(QIcon(":/frame_backward"))
-    self.actionFrame_forward.setIcon(QIcon(":/frame_forward"))
-    self.actionCloseObs.setIcon(QIcon(":/close_observation"))
-    self.actionCurrent_Time_Budget.setIcon(QIcon(":/time_budget"))
-    self.actionPlot_current_observation.setIcon(QIcon(":/plot_events"))
+    self.actionSnapshot.setIcon(QIcon(f":/snapshot_{theme_mode}"))
 
-    self.actionPlot_events_in_real_time.setIcon(QIcon(":/plot_real_time"))
+    self.actionFrame_backward.setIcon(QIcon(f":/frame_backward_{theme_mode}"))
+    self.actionFrame_forward.setIcon(QIcon(f":/frame_forward_{theme_mode}"))
+    self.actionCloseObs.setIcon(QIcon(f":/close_observation_{theme_mode}"))
+    self.actionCurrent_Time_Budget.setIcon(QIcon(f":/time_budget_{theme_mode}"))
+    self.actionPlot_current_observation.setIcon(QIcon(f":/plot_events_{theme_mode}"))
 
-    self.actionBehavior_bar_plot.setIcon(QIcon(":/plot_time_budget"))
-    self.actionPlot_current_time_budget.setIcon(QIcon(":/plot_time_budget"))
-    self.action_geometric_measurements.setIcon(QIcon(":/measurement"))
-    self.actionFind_in_current_obs.setIcon(QIcon(":/find"))
-    self.actionExplore_project.setIcon(QIcon(":/explore"))
+    self.actionPlot_events_in_real_time.setIcon(QIcon(f":/plot_real_time_{theme_mode}"))
+
+    self.actionBehavior_bar_plot.setIcon(QIcon(f":/plot_time_budget_{theme_mode}"))
+    self.actionPlot_current_time_budget.setIcon(QIcon(f":/plot_time_budget_{theme_mode}"))
+    self.action_geometric_measurements.setIcon(QIcon(f":/measurement_{theme_mode}"))
+    self.actionFind_in_current_obs.setIcon(QIcon(f":/find_{theme_mode}"))
+    self.actionExplore_project.setIcon(QIcon(f":/explore_{theme_mode}"))

boris/import_observations.py

@@ -19,13 +19,12 @@ Copyright 2012-2024 Olivier Friard
   MA 02110-1301, USA.
 """
 
-
 import json
 import datetime
 from pathlib import Path
 import pandas as pd
 
-from PyQt5.QtWidgets import (
+from PySide6.QtWidgets import (
     QMessageBox,
     QFileDialog,
 )
@@ -210,10 +209,9 @@ def import_observations(self):
     import observations from project file
     """
 
-    fn = QFileDialog().getOpenFileName(
+    file_name, _ = QFileDialog().getOpenFileName(
         None, "Choose a file", "", "BORIS project files (*.boris);;Spreadsheet files (*.ods *.xlsx *);;All files (*)"
     )
-    file_name = fn[0] if type(fn) is tuple else fn
 
     if not file_name:
         return

boris/irr.py

@@ -25,7 +25,7 @@ import logging
 from decimal import Decimal as dec
 
 import numpy as np
-from PyQt5.QtWidgets import QInputDialog, QMessageBox
+from PySide6.QtWidgets import QInputDialog, QMessageBox
 
 from . import config as cfg
 from . import db_functions, dialog, project_functions, select_subj_behav

boris/latency.py

@@ -29,7 +29,7 @@ from . import dialog
 from . import select_observations
 from . import project_functions, observation_operations
 
-from PyQt5.QtWidgets import QMessageBox
+from PySide6.QtWidgets import QMessageBox
 
 
 def get_latency(self):

boris/map_creator.py

@@ -24,32 +24,22 @@ import binascii
 import json
 import os
 
-from PyQt5.QtCore import (
+from PySide6.QtCore import (
     Qt,
-    pyqtSignal,
+    Signal,
     QPoint,
     QByteArray,
     QBuffer,
     QIODevice,
     QLineF,
 )
-from PyQt5.QtGui import (
-    QColor,
-    QBrush,
-    QMouseEvent,
-    QPixmap,
-    QIcon,
-    QPen,
-    QPolygon,
-    QPolygonF,
-)
+from PySide6.QtGui import QColor, QBrush, QMouseEvent, QPixmap, QIcon, QPen, QPolygon, QPolygonF, QAction
 
-from PyQt5.QtWidgets import (
+from PySide6.QtWidgets import (
     QGraphicsPolygonItem,
     QGraphicsEllipseItem,
     QGraphicsPixmapItem,
     QGraphicsLineItem,
-    QAction,
     QMainWindow,
     QGraphicsView,
     QPushButton,
@@ -80,14 +70,14 @@ selectedBrush.setColor(QColor(255, 255, 0, 255))
 
 
 class ModifiersMapCreatorWindow(QMainWindow):
-    closed = pyqtSignal()
+    closed = Signal()
 
     class View(QGraphicsView):
         """
         class for handling mousepress event in QGraphicsView
         """
 
-        mousePress = pyqtSignal(QMouseEvent)
+        mousePress = Signal(QMouseEvent)
 
         def mousePressEvent(self, event):
             self.mousePress.emit(event)
@@ -527,79 +517,77 @@ class ModifiersMapCreatorWindow(QMainWindow):
             if response == "Cancel":
                 return
 
-        fn = QFileDialog().getOpenFileName(
+        fileName, _ = QFileDialog().getOpenFileName(
             self,
             "Open a coding map",
             "",
             "BORIS coding map (*.boris_map);;All files (*)",
         )
-        fileName = fn[0] if type(fn) is tuple else fn
 
-        if fileName:
-            try:
-                self.codingMap = json.loads(open(fileName, "r").read())
-            except Exception:
-                QMessageBox.critical(
-                    self,
-                    cfg.programName,
-                    "The file {} seems not a behaviors coding map...".format(fileName),
-                )
-                return
+        if not fileName:
+            self.statusBar().showMessage("No file", 5000)
+        try:
+            self.codingMap = json.loads(open(fileName, "r").read())
+        except Exception:
+            QMessageBox.critical(
+                self,
+                cfg.programName,
+                "The file {} seems not a behaviors coding map...".format(fileName),
+            )
+            return
 
-            self.cancelMap()
+        self.cancelMap()
 
-            self.mapName = self.codingMap["name"]
+        self.mapName = self.codingMap["name"]
 
-            self.setWindowTitle(cfg.programName + " - Map creator tool - " + self.mapName)
+        self.setWindowTitle(cfg.programName + " - Map creator tool - " + self.mapName)
 
-            self.bitmapFileName = True
+        self.bitmapFileName = True
 
-            self.fileName = fileName
+        self.fileName = fileName
 
-            self.areasList = self.codingMap["areas"]  # dictionary of dictionaries
-            bitmapContent = binascii.a2b_base64(self.codingMap["bitmap"])
+        self.areasList = self.codingMap["areas"]  # dictionary of dictionaries
+        bitmapContent = binascii.a2b_base64(self.codingMap["bitmap"])
 
-            self.pixmap.loadFromData(bitmapContent)
+        self.pixmap.loadFromData(bitmapContent)
 
-            self.btDeleteArea.setEnabled(False)
+        self.btDeleteArea.setEnabled(False)
 
-            self.view.setSceneRect(0, 0, self.pixmap.size().width(), self.pixmap.size().height())
-            pixItem = QGraphicsPixmapItem(self.pixmap)
-            pixItem.setPos(0, 0)
-            self.view.scene().addItem(pixItem)
+        self.view.setSceneRect(0, 0, self.pixmap.size().width(), self.pixmap.size().height())
+        pixItem = QGraphicsPixmapItem(self.pixmap)
+        pixItem.setPos(0, 0)
+        self.view.scene().addItem(pixItem)
 
-            for areaCode in self.areasList:
-                points = self.areasList[areaCode]["geometry"]
+        for areaCode in self.areasList:
+            points = self.areasList[areaCode]["geometry"]
 
-                newPolygon = QPolygonF()
-                for p in points:
-                    newPolygon.append(QPoint(p[0], p[1]))
+            newPolygon = QPolygonF()
+            for p in points:
+                newPolygon.append(QPoint(p[0], p[1]))
 
-                clr = QColor()
-                clr.setRgba(self.areasList[areaCode]["color"])
+            clr = QColor()
+            clr.setRgba(self.areasList[areaCode]["color"])
 
-                # draw polygon
-                polygon = QGraphicsPolygonItem()
+            # draw polygon
+            polygon = QGraphicsPolygonItem()
 
-                polygon.setPolygon(newPolygon)
+            polygon.setPolygon(newPolygon)
 
-                polygon.setPen(QPen(clr, penWidth, penStyle, Qt.RoundCap, Qt.RoundJoin))
+            polygon.setPen(QPen(clr, penWidth, penStyle, Qt.RoundCap, Qt.RoundJoin))
 
-                polygon.setBrush(QBrush(clr, Qt.SolidPattern))
+            polygon.setBrush(QBrush(clr, Qt.SolidPattern))
 
-                self.view.scene().addItem(polygon)
-                self.polygonsList2[areaCode] = polygon
+            self.view.scene().addItem(polygon)
+            self.polygonsList2[areaCode] = polygon
 
-            self.btNewArea.setVisible(True)
+        self.btNewArea.setVisible(True)
 
-            self.btLoad.setVisible(False)
+        self.btLoad.setVisible(False)
 
-            self.saveMapAction.setEnabled(True)
-            self.saveAsMapAction.setEnabled(True)
-            self.mapNameAction.setEnabled(True)
-            self.statusBar().showMessage('Click "New area" to create a new area')
-        else:
-            self.statusBar().showMessage("No file", 5000)
+        self.saveMapAction.setEnabled(True)
+        self.saveAsMapAction.setEnabled(True)
+        self.mapNameAction.setEnabled(True)
+        self.statusBar().showMessage('Click "New area" to create a new area')
 
     def saveMap(self):
         if self.fileName:
@@ -843,41 +831,41 @@ class ModifiersMapCreatorWindow(QMainWindow):
 
         maxSize = 512
 
-        fn = QFileDialog().getOpenFileName(self, "Load bitmap", "", "bitmap files (*.png *.jpg);;All files (*)")
-        fileName = fn[0] if type(fn) is tuple else fn
+        fileName, _ = QFileDialog().getOpenFileName(self, "Load bitmap", "", "bitmap files (*.png *.jpg);;All files (*)")
 
-        if fileName:
-            self.bitmapFileName = fileName
+        if not fileName:
+            return
+        self.bitmapFileName = fileName
 
-            self.pixmap.load(self.bitmapFileName)
+        self.pixmap.load(self.bitmapFileName)
 
-            if self.pixmap.size().width() > maxSize or self.pixmap.size().height() > maxSize:
-                self.pixmap = self.pixmap.scaled(maxSize, maxSize, Qt.KeepAspectRatio)
-                QMessageBox.information(
-                    self,
-                    cfg.programName,
-                    "The bitmap was resized to %d x %d pixels\nThe original file was not modified"
-                    % (self.pixmap.size().width(), self.pixmap.size().height()),
-                )
+        if self.pixmap.size().width() > maxSize or self.pixmap.size().height() > maxSize:
+            self.pixmap = self.pixmap.scaled(maxSize, maxSize, Qt.KeepAspectRatio)
+            QMessageBox.information(
+                self,
+                cfg.programName,
+                "The bitmap was resized to %d x %d pixels\nThe original file was not modified"
+                % (self.pixmap.size().width(), self.pixmap.size().height()),
+            )
 
-            # scale image
-            # pixmap = pixmap.scaled (256, 256, Qt.KeepAspectRatio)
+        # scale image
+        # pixmap = pixmap.scaled (256, 256, Qt.KeepAspectRatio)
 
-            self.view.setSceneRect(0, 0, self.pixmap.size().width(), self.pixmap.size().height())
-            pixitem = QGraphicsPixmapItem(self.pixmap)
-            pixitem.setPos(0, 0)
-            self.view.scene().addItem(pixitem)
+        self.view.setSceneRect(0, 0, self.pixmap.size().width(), self.pixmap.size().height())
+        pixitem = QGraphicsPixmapItem(self.pixmap)
+        pixitem.setPos(0, 0)
+        self.view.scene().addItem(pixitem)
 
-            self.btNewArea.setVisible(True)
+        self.btNewArea.setVisible(True)
 
-            self.btLoad.setVisible(False)
-            self.saveMapAction.setEnabled(True)
-            self.saveAsMapAction.setEnabled(True)
-            self.mapNameAction.setEnabled(True)
+        self.btLoad.setVisible(False)
+        self.saveMapAction.setEnabled(True)
+        self.saveAsMapAction.setEnabled(True)
+        self.mapNameAction.setEnabled(True)
 
-            self.statusBar().showMessage("""Click "New modifier" to create a new modifier""")
+        self.statusBar().showMessage("""Click "New modifier" to create a new modifier""")
 
-            self.flagMapChanged = True
+        self.flagMapChanged = True
 
 
 if __name__ == "__main__":