MAINT: use f-strings everywhere (larray-project/larray#854)

Author: gdementen

doc/source/conf.py

@@ -17,7 +17,7 @@
 # sys.path.insert(0, os.path.abspath('../../'))
 
 import larray_editor
-print("larray-editor: {}, {}".format(larray_editor.__version__, larray_editor.__file__))
+print(f"larray-editor: {larray_editor.__version__}, {larray_editor.__file__}")
 
 # -- Project information -----------------------------------------------------
 

larray_editor/api.py

@@ -287,7 +287,7 @@ def compare(*args, **kwargs):
     if names is None:
         def get_name(i, obj, depth=0):
             obj_names = find_names(obj, depth=depth + 1)
-            return obj_names[0] if obj_names else '%s %d' % (default_name, i)
+            return obj_names[0] if obj_names else f'{default_name} {i:d}'
 
         # depth + 2 because of the list comprehension
         names = [get_name(i, a, depth=depth + 2) for i, a in enumerate(args)]

larray_editor/arrayadapter.py

@@ -27,7 +27,7 @@ def get_adapter(data, bg_value):
         return None
     data_type = type(data)
     if data_type not in REGISTERED_ADAPTERS:
-        raise TypeError("No Adapter implemented for data with type {}".format(data_type))
+        raise TypeError(f"No Adapter implemented for data with type {data_type}")
     adapter_cls = REGISTERED_ADAPTERS[data_type]
     return adapter_cls(data, bg_value)
 
@@ -52,7 +52,7 @@ def data(self):
 
     @data.setter
     def data(self, original_data):
-        assert original_data is not None, "{} does not accept None as input data".format(self.__class__)
+        assert original_data is not None, f"{self.__class__} does not accept None as input data"
         self._original_data = self.prepare_data(original_data)
 
     @property

larray_editor/arraymodel.py

@@ -111,8 +111,8 @@ def reset(self):
         self.endResetModel()
         if logger.isEnabledFor(logging.DEBUG):
             caller = stack()[1]
-            logger.debug("model {} has been reset after call of {} from module {} at line {}".format(self.__class__,
-                            caller.function, basename(caller.filename), caller.lineno))
+            logger.debug(f"model {self.__class__} has been reset after call of {caller.function} from module "
+                         f"{basename(caller.filename)} at line {caller.lineno}")
 
 
 class AxesArrayModel(AbstractArrayModel):
@@ -303,7 +303,7 @@ def _set_data(self, data):
             dtn = dtype.name
             if dtn not in SUPPORTED_FORMATS and not dtn.startswith('str') \
                     and not dtn.startswith('unicode'):
-                QMessageBox.critical(self.dialog, "Error", "{} arrays are currently not supported".format(dtn))
+                QMessageBox.critical(self.dialog, "Error", f"{dtn} arrays are currently not supported")
                 return
         # for complex numbers, shading will be based on absolute value
         # but for all other types it will be the real part
@@ -356,8 +356,7 @@ def set_bg_gradient(self, bg_gradient, reset=True):
 
     def set_bg_value(self, bg_value, reset=True):
         if bg_value is not None and not (isinstance(bg_value, np.ndarray) and bg_value.shape == self._data.shape):
-            raise ValueError("Expected None or 2D Numpy ndarray with shape {} for `bg_value` argument"
-                             .format(self._data.shape))
+            raise ValueError(f"Expected None or 2D Numpy ndarray with shape {self._data.shape} for `bg_value` argument")
         self.bg_value = bg_value
         if reset:
             self.reset()
@@ -428,7 +427,7 @@ def data(self, index, role=Qt.DisplayRole):
                     v = self.bg_value[i, j]
                 return self.bg_gradient[v]
         # elif role == Qt.ToolTipRole:
-        #     return "{}\n{}".format(repr(value),self.get_labels(index))
+        #     return f"{repr(value)}\n{self.get_labels(index)}"
         return None
 
     def get_values(self, left=0, top=0, right=None, bottom=None, sample=False):
@@ -478,10 +477,10 @@ def convert_values(self, values):
             for i, v in enumerate(values.flat):
                 res.flat[i] = self.convert_value(v)
         except ValueError as e:
-            QMessageBox.critical(self.dialog, "Error", "Value error: %s" % str(e))
+            QMessageBox.critical(self.dialog, "Error", f"Value error: {str(e)}")
             return None
         except OverflowError as e:
-            QMessageBox.critical(self.dialog, "Error", "Overflow error: %s" % e.message)
+            QMessageBox.critical(self.dialog, "Error", f"Overflow error: {e.message}")
             return None
         return res
 

larray_editor/arraywidget.py

@@ -99,10 +99,10 @@ def __init__(self, parent, model, hpos, vpos):
 
         # set position
         if not (hpos == LEFT or hpos == RIGHT):
-            raise TypeError("Value of hpos must be {} or {}".format(LEFT, RIGHT))
+            raise TypeError(f"Value of hpos must be {LEFT} or {RIGHT}")
         self.hpos = hpos
         if not (vpos == TOP or vpos == BOTTOM):
-            raise TypeError("Value of vpos must be {} or {}".format(TOP, BOTTOM))
+            raise TypeError(f"Value of vpos must be {TOP} or {BOTTOM}")
         self.vpos = vpos
 
         # set selection mode
@@ -187,8 +187,8 @@ class AxesView(AbstractView):
     def __init__(self, parent, model):
         # check model
         if not isinstance(model, AxesArrayModel):
-            raise TypeError("Expected model of type {}. Received {} instead"
-                            .format(AxesArrayModel.__name__, type(model).__name__))
+            raise TypeError(f"Expected model of type {AxesArrayModel.__name__}. "
+                            f"Received {type(model).__name__} instead")
         AbstractView.__init__(self, parent, model, LEFT, TOP)
 
     def selectAll(self):
@@ -201,8 +201,8 @@ class LabelsView(AbstractView):
     def __init__(self, parent, model, hpos, vpos):
         # check model
         if not isinstance(model, LabelsArrayModel):
-            raise TypeError("Expected model of type {}. Received {} instead"
-                            .format(LabelsArrayModel.__name__, type(model).__name__))
+            raise TypeError(f"Expected model of type {LabelsArrayModel.__name__}. "
+                            f"Received {type(model).__name__} instead")
         AbstractView.__init__(self, parent, model, hpos, vpos)
 
 
@@ -236,11 +236,11 @@ def createEditor(self, parent, option, index):
         elif value is not np.ma.masked:
             minvalue, maxvalue = self.minvalue, self.maxvalue
             if minvalue is not None and maxvalue is not None:
-                msg = "value must be between %s and %s" % (minvalue, maxvalue)
+                msg = f"value must be between {minvalue} and {maxvalue}"
             elif minvalue is not None:
-                msg = "value must be >= %s" % minvalue
+                msg = f"value must be >= {minvalue}"
             elif maxvalue is not None:
-                msg = "value must be <= %s" % maxvalue
+                msg = f"value must be <= {maxvalue}"
             else:
                 msg = None
 
@@ -293,8 +293,8 @@ class DataView(AbstractView):
     def __init__(self, parent, model):
         # check model
         if not isinstance(model, DataArrayModel):
-            raise TypeError("Expected model of type {}. Received {} instead"
-                            .format(DataArrayModel.__name__, type(model).__name__))
+            raise TypeError(f"Expected model of type {DataArrayModel.__name__}. "
+                            f"Received {type(model).__name__} instead")
         AbstractView.__init__(self, parent, model, RIGHT, BOTTOM)
 
         self.context_menu = self.setup_context_menu()

larray_editor/combo.py

@@ -36,7 +36,7 @@ def __getitem__(self, key):
             return [self.item(i) for i in range(start, stop, step)]
         else:
             if key >= self.rowCount():
-                raise IndexError("index %d is out of range" % key)
+                raise IndexError(f"index {key} is out of range")
             return self.item(key)
 
     def __len__(self):
@@ -261,7 +261,7 @@ def __init__(self):
 
             combo = FilterComboBox(self)
             for i in range(20):
-                combo.addItem('Item %s' % i)
+                combo.addItem(f'Item {i}')
             layout.addWidget(combo)
 
     app = QtWidgets.QApplication(sys.argv)

larray_editor/commands.py

@@ -49,7 +49,7 @@ def __init__(self, editor, target, changes):
         text_command = self.get_description(target, changes)
         self.setText(text_command)
         if logger.isEnabledFor(logging.DEBUG):
-            logger.debug("Edit command pushed: {}".format(text_command))
+            logger.debug(f"Edit command pushed: {text_command}")
 
     def undo(self):
         for change in self.changes:
@@ -83,12 +83,12 @@ class EditSessionArrayCommand(EditArrayCommand):
     """
     def get_description(self, target, changes):
         if len(changes) == 1:
-            return "Editing Cell {} of {}".format(changes[0].key, target)
+            return f"Editing Cell {changes[0].key} of {target}"
         else:
-            return "Pasting {} Cells in {}".format(len(changes), target)
+            return f"Pasting {len(changes)} Cells in {target}"
 
     def apply_change(self, key, new_value):
-        self.editor.kernel.shell.run_cell("{}[{}] = {}".format(self.target, key, new_value))
+        self.editor.kernel.shell.run_cell(f"{self.target}[{key}] = {new_value}")
 
 
 class EditCurrentArrayCommand(EditArrayCommand):
@@ -106,9 +106,9 @@ class EditCurrentArrayCommand(EditArrayCommand):
     """
     def get_description(self, target, changes):
         if len(changes) == 1:
-            return "Editing Cell {}".format(changes[0].key)
+            return f"Editing Cell {changes[0].key}"
         else:
-            return "Pasting {} Cells".format(len(changes))
+            return f"Pasting {len(changes)} Cells"
 
     def apply_change(self, key, new_value):
         self.target[key] = new_value

larray_editor/comparator.py

@@ -193,7 +193,7 @@ def _setup_and_check(self, widget, data, title, readonly, **kwargs):
           * names: list of str
         """
         arrays = [la.asarray(array) for array in data if isinstance(array, DISPLAY_IN_GRID)]
-        names = kwargs.get('names', ["Array{}".format(i) for i in range(len(arrays))])
+        names = kwargs.get('names', [f"Array{i}" for i in range(len(arrays))])
 
         layout = QVBoxLayout()
         widget.setLayout(layout)
@@ -239,7 +239,7 @@ def _setup_and_check(self, widget, data, title, readonly, **kwargs):
           * colors: str
         """
         sessions = data
-        names = kwargs.get('names', ["Session{}".format(i) for i in range(len(sessions))])
+        names = kwargs.get('names', [f"Session{i}" for i in range(len(sessions))])
 
         assert all(isinstance(s, la.Session) for s in sessions)
         self.sessions = sessions

larray_editor/editor.py

@@ -116,10 +116,10 @@ def setup_and_check(self, data, title='', readonly=False, caller_info=None, **kw
 
         # permanently display caller info in the status bar
         if caller_info is not None:
-            caller_info = 'launched from file {} at line {}'.format(caller_info.filename, caller_info.lineno)
+            caller_info = f'launched from file {caller_info.filename} at line {caller_info.lineno}'
             self.statusBar().addPermanentWidget(QLabel(caller_info))
         # display welcome message
-        self.statusBar().showMessage("Welcome to the {}".format(self.name), 4000)
+        self.statusBar().showMessage(f"Welcome to the {self.name}", 4000)
 
         # set central widget
         widget = QWidget()
@@ -224,12 +224,12 @@ def _report_issue(*args, **kwargs):
 ## Version and main components
 * Python {python} on {system} {bitness:d}bits
 """
-            issue_template += "* {package} {{{package}}}\n".format(package=package)
+            issue_template += f"* {package} {{{package}}}\n"
             for dep in dependencies[package]:
-                issue_template += "* {dep} {{{dep}}}\n".format(dep=dep)
+                issue_template += f"* {dep} {{{dep}}}\n"
             issue_template = issue_template.format(**versions)
 
-            url = QUrl(urls['new_issue_{}'.format(package)])
+            url = QUrl(urls[f'new_issue_{package}'])
             if PYQT5:
                 from qtpy.QtCore import QUrlQuery
                 query = QUrlQuery()
@@ -263,7 +263,7 @@ def about(self):
 """
         for dep in dependencies['editor']:
             if kwargs[dep] != 'N/A':
-                message += "<li>{dep} {{{dep}}}</li>\n".format(dep=dep)
+                message += f"<li>{dep} {{{dep}}}</li>\n"
         message += "</ul>"
         QMessageBox.about(self, _("About LArray Editor"), message.format(**kwargs))
 
@@ -276,14 +276,14 @@ def _update_title(self, title, array, name):
             # current file (if not None)
             if isinstance(array, la.Array):
                 # array info
-                shape = ['{} ({})'.format(display_name, len(axis))
+                shape = [f'{display_name} ({len(axis)})'
                          for display_name, axis in zip(array.axes.display_names, array.axes)]
             else:
                 # if it's not an Array, it must be a Numpy ndarray
                 assert isinstance(array, np.ndarray)
                 shape = [str(length) for length in array.shape]
             # name + shape + dtype
-            array_info = ' x '.join(shape) + ' [{}]'.format(dtype)
+            array_info = ' x '.join(shape) + f' [{dtype}]'
             if name:
                 title += [name + ': ' + array_info]
             else:
@@ -306,7 +306,7 @@ def save_widgets_state_and_geometry(self):
         settings.setValue('geometry', self.saveGeometry())
         settings.setValue('state', self.saveState())
         for widget_name, widget in self.widget_state_settings.items():
-            settings.setValue('state/{}'.format(widget_name), widget.saveState())
+            settings.setValue(f'state/{widget_name}', widget.saveState())
         settings.endGroup()
 
     def restore_widgets_state_and_geometry(self):
@@ -319,7 +319,7 @@ def restore_widgets_state_and_geometry(self):
         if state:
             self.restoreState(state)
         for widget_name, widget in self.widget_state_settings.items():
-            state = settings.value('state/{}'.format(widget_name))
+            state = settings.value(f'state/{widget_name}')
             if state:
                 widget.restoreState(state)
         settings.endGroup()
@@ -440,7 +440,7 @@ def void_formatter(array, *args, **kwargs):
                 funcname = frame_summary.name
                 filename = os.path.basename(frame_summary.filename)
                 listitem = QListWidgetItem(stack_frame_widget)
-                listitem.setText("{}, {}:{}".format(funcname, filename, frame_summary.lineno))
+                listitem.setText(f"{funcname}, {filename}:{frame_summary.lineno}")
                 # we store the frame summary object in the user data of the list
                 listitem.setData(Qt.UserRole, frame_summary)
                 listitem.setToolTip(frame_summary.line)
@@ -474,7 +474,7 @@ def void_formatter(array, *args, **kwargs):
             if os.path.isfile(data):
                 self._open_file(data)
             else:
-                QMessageBox.critical(self, "Error", "File {} could not be found".format(data))
+                QMessageBox.critical(self, "Error", f"File {data} could not be found")
                 self.new()
         elif not debug:
             self._push_data(data)
@@ -757,15 +757,15 @@ def update_title(self):
             basename = os.path.basename(self.current_file)
             if os.path.isdir(self.current_file):
                 assert not name.endswith('.csv')
-                fname = os.path.join(basename, '{}.csv'.format(name))
+                fname = os.path.join(basename, f'{name}.csv')
                 name = ''
             else:
                 fname = basename
         else:
             fname = '<new>'
 
         array = self.current_array
-        title = ['{}{}'.format(unsaved_marker, fname)]
+        title = [f'{unsaved_marker}{fname}']
         self._update_title(title, array, name)
 
     def set_current_array(self, array, name):
@@ -838,8 +838,7 @@ def _load_script(self, filepath):
             self.ipython_cell_executed()
             self.recent_loaded_scripts.add(filepath)
         except Exception as e:
-            QMessageBox.critical(self, "Error", "Cannot load script file {}:\n{}"
-                                 .format(os.path.basename(filepath), e))
+            QMessageBox.critical(self, "Error", f"Cannot load script file {os.path.basename(filepath)}:\n{e}")
 
     def load_script(self, filepath=None):
         # %load add automatically the extension .py if not present in passed filename
@@ -923,12 +922,11 @@ def _save_script(self, filepath, lines, overwrite):
             if lines:
                 lines = lines.replace('..', '-')
             else:
-                lines = '1-{}'.format(self.kernel.shell.execution_count)
-            self.kernel.shell.run_line_magic('save', '{} {} {}'.format(overwrite, filepath, lines))
+                lines = f'1-{self.kernel.shell.execution_count}'
+            self.kernel.shell.run_line_magic('save', f'{overwrite} {filepath} {lines}')
             self.recent_saved_scripts.add(filepath)
         except Exception as e:
-            QMessageBox.critical(self, "Error", "Cannot save history as {}:\n{}"
-                                 .format(os.path.basename(filepath), e))
+            QMessageBox.critical(self, "Error", f"Cannot save history as {os.path.basename(filepath)}:\n{e}")
 
     # See http://ipython.readthedocs.io/en/stable/interactive/magics.html#magic-save
     # for more details
@@ -1007,7 +1005,7 @@ def save_script(self):
                 overwrite = radio_button_overwrite.isChecked()
                 if overwrite and os.path.isfile(filepath):
                     ret = QMessageBox.warning(self, "Warning",
-                                              "File `{}` exists. Are you sure to overwrite it?".format(filepath),
+                                              f"File `{filepath}` exists. Are you sure to overwrite it?",
                                               QMessageBox.Save | QMessageBox.Discard | QMessageBox.Cancel)
                     if ret == QMessageBox.Save:
                         self._save_script(filepath, lines, overwrite)
@@ -1043,10 +1041,9 @@ def _open_file(self, filepath: Union[str, Path]):
             self._push_data(session)
             self.set_current_file(current_file_name)
             self.unsaved_modifications = False
-            self.statusBar().showMessage("Loaded: {}".format(display_name), 4000)
+            self.statusBar().showMessage(f"Loaded: {display_name}", 4000)
         except Exception as e:
-            QMessageBox.critical(self, "Error", "Something went wrong during load of file(s) {}:\n{}"
-                                 .format(display_name, e))
+            QMessageBox.critical(self, "Error", f"Something went wrong during load of file(s) {display_name}:\n{e}")
 
     def open_data(self):
         if self._ask_to_save_if_unsaved_modifications():
@@ -1073,7 +1070,7 @@ def open_recent_file(self):
                 if os.path.exists(filepath):
                     self._open_file(filepath)
                 else:
-                    QMessageBox.warning(self, "Warning", "File {} could not be found".format(filepath))
+                    QMessageBox.warning(self, "Warning", f"File {filepath} could not be found")
 
     def _save_data(self, filepath):
         try:
@@ -1082,9 +1079,9 @@ def _save_data(self, filepath):
             self.set_current_file(filepath)
             self.edit_undo_stack.clear()
             self.unsaved_modifications = False
-            self.statusBar().showMessage("Arrays saved in file {}".format(filepath), 4000)
+            self.statusBar().showMessage(f"Arrays saved in file {filepath}", 4000)
         except Exception as e:
-            QMessageBox.critical(self, "Error", "Something went wrong during save in file {}:\n{}".format(filepath, e))
+            QMessageBox.critical(self, "Error", f"Something went wrong during save in file {filepath}:\n{e}")
 
     def save_data(self):
         """