From b8490456d7b51a78fefd1796573c5c25d4d0b03b Mon Sep 17 00:00:00 2001
From: Henrik Koski <98282892+PiispaH@users.noreply.github.com>
Date: Wed, 24 Jul 2024 13:51:04 +0300
Subject: [PATCH] Conforming to pylint (#2901)

* Ran pylint and fixed some things.

* Continue to conform to the desires of pylint

* Remove old pylintrc

* Convert lambdas to def due to pylint
---
 bin/append_license.py                         |    2 +-
 bin/build_ui.py                               |   12 +-
 pylintrc                                      | 1180 ++++++++++-------
 spinetoolbox/execution_managers.py            |   10 +-
 spinetoolbox/fetch_parent.py                  |    2 -
 spinetoolbox/headless.py                      |   21 +-
 spinetoolbox/helpers.py                       |   63 +-
 spinetoolbox/kernel_fetcher.py                |    2 +-
 spinetoolbox/main.py                          |    2 +-
 spinetoolbox/mvcmodels/array_model.py         |    9 +-
 .../mvcmodels/compound_table_model.py         |    3 +-
 spinetoolbox/mvcmodels/empty_row_model.py     |    2 +-
 spinetoolbox/mvcmodels/file_list_models.py    |    9 +-
 .../mvcmodels/filter_checkbox_list_model.py   |    1 +
 .../mvcmodels/filter_execution_model.py       |    2 +-
 spinetoolbox/mvcmodels/map_model.py           |   14 +-
 spinetoolbox/mvcmodels/minimal_table_model.py |    4 +-
 spinetoolbox/mvcmodels/minimal_tree_model.py  |    2 -
 .../project_item_specification_models.py      |    4 +-
 spinetoolbox/mvcmodels/time_pattern_model.py  |    4 +-
 .../time_series_model_variable_resolution.py  |    6 +-
 spinetoolbox/plotting.py                      |   24 +-
 spinetoolbox/plugin_manager.py                |    6 +-
 spinetoolbox/project.py                       |   60 +-
 spinetoolbox/project_item/project_item.py     |   12 +-
 spinetoolbox/project_item_icon.py             |   16 +-
 spinetoolbox/project_upgrader.py              |   38 +-
 spinetoolbox/server/engine_client.py          |   31 +-
 .../spine_db_editor/graphics_items.py         |   12 +-
 .../spine_db_editor/mvcmodels/empty_models.py |    6 +-
 .../mvcmodels/entity_tree_item.py             |   12 +-
 .../mvcmodels/frozen_table_model.py           |    2 +
 .../mvcmodels/multi_db_tree_item.py           |    6 +-
 .../mvcmodels/parameter_value_list_item.py    |    7 +-
 .../mvcmodels/pivot_table_models.py           |   40 +-
 .../single_and_empty_model_mixins.py          |    1 -
 .../mvcmodels/single_models.py                |    2 +-
 .../mvcmodels/tree_item_utility.py            |    2 +-
 .../widgets/add_items_dialogs.py              |   14 +-
 .../spine_db_editor/widgets/commit_viewer.py  |    2 +-
 .../spine_db_editor/widgets/custom_editors.py |    1 -
 .../spine_db_editor/widgets/custom_menus.py   |   29 +-
 .../widgets/custom_qgraphicsviews.py          |    3 +-
 .../widgets/custom_qtableview.py              |   10 +-
 .../widgets/custom_qtreeview.py               |    6 +-
 .../widgets/custom_qwidgets.py                |    5 +-
 .../widgets/edit_or_remove_items_dialogs.py   |   26 +-
 .../widgets/multi_spine_db_editor.py          |    2 +-
 .../widgets/scenario_generator.py             |    5 +-
 .../widgets/spine_db_editor.py                |    8 +-
 .../widgets/stacked_view_mixin.py             |    4 +-
 .../widgets/tabular_view_header_widget.py     |    1 +
 .../widgets/tabular_view_mixin.py             |   13 +-
 spinetoolbox/spine_db_icon_manager.py         |    2 +-
 spinetoolbox/spine_db_manager.py              |   31 +-
 spinetoolbox/spine_db_worker.py               |    7 +-
 spinetoolbox/spine_engine_manager.py          |   15 +-
 spinetoolbox/spine_engine_worker.py           |    2 +-
 spinetoolbox/ui_main.py                       |   57 +-
 spinetoolbox/widgets/about_widget.py          |   12 -
 spinetoolbox/widgets/array_value_editor.py    |    2 +-
 spinetoolbox/widgets/commit_dialog.py         |    2 +-
 spinetoolbox/widgets/custom_menus.py          |    2 +-
 spinetoolbox/widgets/custom_qgraphicsscene.py |    2 +-
 spinetoolbox/widgets/custom_qtableview.py     |   41 +-
 spinetoolbox/widgets/custom_qwidgets.py       |   12 +-
 .../widgets/jupyter_console_widget.py         |    8 +-
 spinetoolbox/widgets/kernel_editor.py         |    8 +-
 spinetoolbox/widgets/multi_tab_spec_editor.py |    9 +-
 spinetoolbox/widgets/multi_tab_window.py      |    7 +-
 .../widgets/persistent_console_widget.py      |    5 +-
 spinetoolbox/widgets/plot_widget.py           |    4 +-
 spinetoolbox/widgets/project_item_drag.py     |    3 +
 spinetoolbox/widgets/settings_widget.py       |   24 +-
 tests/mock_helpers.py                         |   13 +-
 tests/mvcmodels/test_MinimalTableModel.py     |    2 +-
 .../test_TimeSeriesModelFixedResolution.py    |    2 +-
 .../test_TimeSeriesModelVariableResolution.py |    1 +
 tests/project_item/test_logging_connection.py |    1 -
 tests/server/test_RemoteSpineEngineManager.py |   12 +-
 tests/spine_db_editor/helpers.py              |    2 +-
 .../mvcmodels/test_PivotModel.py              |   12 +-
 .../mvcmodels/test_PivotTableModel.py         |  171 +--
 .../mvcmodels/test_alternative_model.py       |    2 +-
 .../widgets/spine_db_editor_test_base.py      |    2 +-
 .../widgets/test_add_items_dialog.py          |    2 +-
 .../widgets/test_custom_editors.py            |    2 +-
 .../widgets/test_custom_qtableview.py         |   16 +-
 .../widgets/test_custom_qtreeview.py          |    8 +-
 tests/test_ProjectUpgrader.py                 |   46 +-
 tests/test_SpineDBManager.py                  |    2 +-
 tests/test_SpineToolboxProject.py             |    8 +-
 tests/test_ToolboxUI.py                       |    9 +-
 tests/test_helpers.py                         |   14 +-
 tests/test_plotting.py                        |    9 +-
 tests/test_spine_db_fetcher.py                |    2 +-
 tests/widgets/test_ArrayTableView.py          |    6 +-
 tests/widgets/test_CopyPasteTableView.py      |    6 +-
 tests/widgets/test_IndexedValueTableView.py   |    6 +-
 tests/widgets/test_JupyterConsoleWidget.py    |   12 +-
 tests/widgets/test_MapTableView.py            |    5 +-
 tests/widgets/test_ParameterValueEditor.py    |    3 +-
 tests/widgets/test_custom_combobox.py         |   12 +-
 tests/widgets/test_custom_qgraphicsscene.py   |    2 +-
 tests/widgets/test_custom_qlineedits.py       |    6 +-
 tests/widgets/test_kernel_editor.py           |   14 +-
 tests/widgets/test_open_project_dialog.py     |   12 +-
 tests/widgets/test_plugin_manager_widgets.py  |   12 +-
 108 files changed, 1285 insertions(+), 1164 deletions(-)

diff --git a/bin/append_license.py b/bin/append_license.py
index 9d68e7b94..96da7479c 100755
--- a/bin/append_license.py
+++ b/bin/append_license.py
@@ -45,7 +45,7 @@ def _append_license_py(path):
 
 def _append_license_xml(path):
     """Appends a license header to given .py, .ui or .xml file."""
-    xml_license = list()
+    xml_license = []
     xml_license.append("<!--\n")
     for line in license_text:
         xml_license.append(line.replace("/", "\\/"))
diff --git a/bin/build_ui.py b/bin/build_ui.py
index 63de70b51..0841ddd94 100755
--- a/bin/build_ui.py
+++ b/bin/build_ui.py
@@ -8,7 +8,7 @@
 def find_ui_dirs(path, found_dirs=None):
     """Recursively searches for 'ui' directories and returns their paths as a list."""
     if found_dirs is None:
-        found_dirs = list()
+        found_dirs = []
     for entry in os.scandir(path):
         if entry.is_dir():
             if entry.name == 'ui':
@@ -20,7 +20,7 @@ def find_ui_dirs(path, found_dirs=None):
 
 def fix_resources_imports(path):
     """Fixes resources imports in a given automatically generated Python ui file."""
-    lines = list()
+    lines = []
     with open(path, 'r') as in_file:
         for line in in_file:
             if line == "from . import resources_icons_rc\n":
@@ -71,8 +71,8 @@ def build_qrc(input_path, output_path, force):
 ui_dirs = find_ui_dirs(project_source_dir)
 for ui_dir in ui_dirs:
     print(f"--- Entering {os.path.abspath(ui_dir)} ---")
-    ui_entries = list()
-    py_entries = dict()
+    ui_entries = []
+    py_entries = {}
     for entry in os.scandir(ui_dir):
         if entry.is_file():
             base, extension = os.path.splitext(entry.name)
@@ -93,8 +93,8 @@ def build_qrc(input_path, output_path, force):
         if ui_modification_time > py_modification_time:
             build_ui(ui_entry.path, py_entry.path, args.force)
 resources_dir = os.path.join(project_source_dir, "ui", "resources")
-qrc_entries = list()
-py_paths = dict()
+qrc_entries = []
+py_paths = {}
 for entry in os.scandir(resources_dir):
     if entry.is_file():
         base, extension = os.path.splitext(entry.name)
diff --git a/pylintrc b/pylintrc
index 4b56508f3..0ad719f24 100644
--- a/pylintrc
+++ b/pylintrc
@@ -1,512 +1,668 @@
-[MASTER]
-
-# A comma-separated list of package or module names from where C extensions may
-# be loaded. Extensions are loading into the active Python interpreter and may
-# run arbitrary code.
-extension-pkg-whitelist=PySide6
-
-# Add files or directories to the blacklist. They should be base names, not
-# paths.
-ignore=ui,.git,resources_icons.py,resources_logos.py
-
-# Add files or directories matching the regex patterns to the blacklist. The
-# regex matches against base names, not paths.
-ignore-patterns=
-
-# Python code to execute, usually for sys.path manipulation such as
-# pygtk.require().
-init-hook='import sys; sys.path.append("spinetoolbox")'
-
-# Use multiple processes to speed up Pylint. Specifying 0 will auto-detect the
-# number of processors available to use.
-jobs=1
-
-# Control the amount of potential inferred values when inferring a single
-# object. This can help the performance when dealing with large functions or
-# complex, nested conditions.
-limit-inference-results=100
-
-# List of plugins (as comma separated values of python modules names) to load,
-# usually to register additional checkers.
-load-plugins=
-
-# Pickle collected data for later comparisons.
-persistent=yes
-
-# When enabled, pylint would attempt to guess common misconfiguration and emit
-# user-friendly hints instead of false-positive error messages.
-suggestion-mode=yes
-
-# Allow loading of arbitrary C extensions. Extensions are imported into the
-# active Python interpreter and may run arbitrary code.
-unsafe-load-any-extension=yes
-
-
-[MESSAGES CONTROL]
-
-# Only show warnings with the listed confidence levels. Leave empty to show
-# all. Valid levels: HIGH, INFERENCE, INFERENCE_FAILURE, UNDEFINED.
-confidence=
-
-# Disable the message, report, category or checker with the given id(s). You
-# can either give multiple identifiers separated by comma (,) or put this
-# option multiple times (only on the command line, not in the configuration
-# file where it should appear only once). You can also use "--disable=all" to
-# disable everything first and then reenable specific checks. For example, if
-# you want to run only the similarities checker, you can use "--disable=all
-# --enable=similarities". If you want to run only the classes checker, but have
-# no Warning level messages displayed, use "--disable=all --enable=classes
-# --disable=W".
-disable=bad-continuation,
-    duplicate-code,
-    fixme,
-    inconsistent-return-statements,
-    invalid-name,
-    line-too-long,
-    missing-docstring,
-    no-member,  # Workaround for a bug in pylint, see https://github.com/PyCQA/pylint/issues/2585
-    protected-access,
-    too-few-public-methods,
-    too-many-ancestors,
-    too-many-arguments,
-    too-many-branches,
-    too-many-instance-attributes,
-    too-many-nested-blocks,
-    too-many-public-methods,
-    too-many-lines,
-    too-many-locals,
-    too-many-return-statements,
-    too-many-statements,
-    unused-argument
-
-# Enable the message, report, category or checker with the given id(s). You can
-# either give multiple identifier separated by comma (,) or put this option
-# multiple time (only on the command line, not in the configuration file where
-# it should appear only once). See also the "--disable" option for examples.
-enable=
-
-
-[REPORTS]
-
-# Python expression which should return a note less than 10 (10 is the highest
-# note). You have access to the variables errors warning, statement which
-# respectively contain the number of errors / warnings messages and the total
-# number of statements analyzed. This is used by the global evaluation report
-# (RP0004).
-evaluation=10.0 - ((float(5 * error + warning + refactor + convention) / statement) * 10)
-
-# Template used to display messages. This is a python new-style format string
-# used to format the message information. See doc for all details.
-#msg-template=
-
-# Set the output format. Available formats are text, parseable, colorized, json
-# and msvs (visual studio). You can also give a reporter class, e.g.
-# mypackage.mymodule.MyReporterClass.
-output-format=text
-
-# Tells whether to display a full report or only the messages.
-reports=no
-
-# Activate the evaluation score.
-score=yes
-
-
-[REFACTORING]
-
-# Maximum number of nested blocks for function / method body
-max-nested-blocks=5
-
-# Complete name of functions that never returns. When checking for
-# inconsistent-return-statements if a never returning function is called then
-# it will be considered as an explicit return statement and no message will be
-# printed.
-never-returning-functions=sys.exit
-
-
-[BASIC]
-
-# Naming style matching correct argument names.
-argument-naming-style=snake_case
-
-# Regular expression matching correct argument names. Overrides argument-
-# naming-style.
-#argument-rgx=
-
-# Naming style matching correct attribute names.
-attr-naming-style=snake_case
-
-# Regular expression matching correct attribute names. Overrides attr-naming-
-# style.
-#attr-rgx=
-
-# Bad variable names which should always be refused, separated by a comma.
-bad-names=foo,
-          bar,
-          baz,
-          toto,
-          tutu,
-          tata
-
-# Naming style matching correct class attribute names.
-class-attribute-naming-style=any
-
-# Regular expression matching correct class attribute names. Overrides class-
-# attribute-naming-style.
-#class-attribute-rgx=
-
-# Naming style matching correct class names.
-class-naming-style=PascalCase
-
-# Regular expression matching correct class names. Overrides class-naming-
-# style.
-#class-rgx=
-
-# Naming style matching correct constant names.
-const-naming-style=UPPER_CASE
-
-# Regular expression matching correct constant names. Overrides const-naming-
-# style.
-#const-rgx=
-
-# Minimum line length for functions/classes that require docstrings, shorter
-# ones are exempt.
-docstring-min-length=-1
-
-# Naming style matching correct function names.
-function-naming-style=snake_case
-
-# Regular expression matching correct function names. Overrides function-
-# naming-style.
-#function-rgx=
-
-# Good variable names which should always be accepted, separated by a comma.
-good-names=i,
-           j,
-           k,
-           ex,
-           Run,
-           ui,
-           x,
-           y,
-           _
-
-# Include a hint for the correct naming format with invalid-name.
-include-naming-hint=no
-
-# Naming style matching correct inline iteration names.
-inlinevar-naming-style=any
-
-# Regular expression matching correct inline iteration names. Overrides
-# inlinevar-naming-style.
-#inlinevar-rgx=
-
-# Naming style matching correct method names.
-method-naming-style=snake_case
-
-# Regular expression matching correct method names. Overrides method-naming-
-# style.
-#method-rgx=
-
-# Naming style matching correct module names.
-module-naming-style=snake_case
-
-# Regular expression matching correct module names. Overrides module-naming-
-# style.
-#module-rgx=
-
-# Colon-delimited sets of names that determine each other's naming style when
-# the name regexes allow several styles.
-name-group=
-
-# Regular expression which should only match function or class names that do
-# not require a docstring.
-no-docstring-rgx=^_
-
-# List of decorators that produce properties, such as abc.abstractproperty. Add
-# to this list to register other decorators that produce valid properties.
-# These decorators are taken in consideration only for invalid-name.
-property-classes=abc.abstractproperty
-
-# Naming style matching correct variable names.
-variable-naming-style=snake_case
-
-# Regular expression matching correct variable names. Overrides variable-
-# naming-style.
-#variable-rgx=
-
-
-[FORMAT]
-
-# Expected format of line ending, e.g. empty (any line ending), LF or CRLF.
-expected-line-ending-format=
-
-# Regexp for a line that is allowed to be longer than the limit.
-ignore-long-lines=^\s*(# )?<?https?://\S+>?$
-
-# Number of spaces of indent required inside a hanging or continued line.
-indent-after-paren=4
-
-# String used as indentation unit. This is usually "    " (4 spaces) or "\t" (1
-# tab).
-indent-string='    '
-
-# Maximum number of characters on a single line.
-max-line-length=100
-
-# Maximum number of lines in a module.
-max-module-lines=1000
-
-# List of optional constructs for which whitespace checking is disabled. `dict-
-# separator` is used to allow tabulation in dicts, etc.: {1  : 1,\n222: 2}.
-# `trailing-comma` allows a space between comma and closing bracket: (a, ).
-# `empty-line` allows space-only lines.
-no-space-check=trailing-comma,
-               dict-separator
-
-# Allow the body of a class to be on the same line as the declaration if body
-# contains single statement.
-single-line-class-stmt=no
-
-# Allow the body of an if to be on the same line as the test if there is no
-# else.
-single-line-if-stmt=no
-
-
-[LOGGING]
-
-# Format style used to check logging format string. `old` means using %
-# formatting, while `new` is for `{}` formatting.
-logging-format-style=old
-
-# Logging modules to check that the string format arguments are in logging
-# function parameter format.
-logging-modules=logging
-
-
-[MISCELLANEOUS]
-
-# List of note tags to take in consideration, separated by a comma.
-notes=FIXME,
-      XXX,
-      TODO
-
-
-[SIMILARITIES]
-
-# Ignore comments when computing similarities.
-ignore-comments=yes
-
-# Ignore docstrings when computing similarities.
-ignore-docstrings=yes
-
-# Ignore imports when computing similarities.
-ignore-imports=no
-
-# Minimum lines number of a similarity.
-min-similarity-lines=6
-
-
-[SPELLING]
-
-# Limits count of emitted suggestions for spelling mistakes.
-max-spelling-suggestions=4
-
-# Spelling dictionary name. Available dictionaries: none. To make it working
-# install python-enchant package..
-spelling-dict=
-
-# List of comma separated words that should not be checked.
-spelling-ignore-words=
-
-# A path to a file that contains private dictionary; one word per line.
-spelling-private-dict-file=
-
-# Tells whether to store unknown words to indicated private dictionary in
-# --spelling-private-dict-file option instead of raising a message.
-spelling-store-unknown-words=no
-
-
-[STRING]
-
-# This flag controls whether the implicit-str-concat-in-sequence should
-# generate a warning on implicit string concatenation in sequences defined over
-# several lines.
-check-str-concat-over-line-jumps=no
-
-
-[TYPECHECK]
-
-# List of decorators that produce context managers, such as
-# contextlib.contextmanager. Add to this list to register other decorators that
-# produce valid context managers.
-contextmanager-decorators=contextlib.contextmanager
-
-# List of members which are set dynamically and missed by pylint inference
-# system, and so shouldn't trigger E1101 when accessed. Python regular
-# expressions are accepted.
-generated-members=
-
-# Tells whether missing members accessed in mixin class should be ignored. A
-# mixin class is detected if its name ends with "mixin" (case insensitive).
-ignore-mixin-members=yes
-
-# Tells whether to warn about missing members when the owner of the attribute
-# is inferred to be None.
-ignore-none=yes
-
-# This flag controls whether pylint should warn about no-member and similar
-# checks whenever an opaque object is returned when inferring. The inference
-# can return multiple potential results while evaluating a Python object, but
-# some branches might not be evaluated, which results in partial inference. In
-# that case, it might be useful to still emit no-member and other checks for
-# the rest of the inferred objects.
-ignore-on-opaque-inference=yes
-
-# List of class names for which member attributes should not be checked (useful
-# for classes with dynamically set attributes). This supports the use of
-# qualified names.
-ignored-classes=optparse.Values,thread._local,_thread._local
-
-# List of module names for which member attributes should not be checked
-# (useful for modules/projects where namespaces are manipulated during runtime
-# and thus existing member attributes cannot be deduced by static analysis. It
-# supports qualified module names, as well as Unix pattern matching.
-ignored-modules=
-
-# Show a hint with possible names when a member name was not found. The aspect
-# of finding the hint is based on edit distance.
-missing-member-hint=yes
-
-# The minimum edit distance a name should have in order to be considered a
-# similar match for a missing member name.
-missing-member-hint-distance=1
-
-# The total number of similar names that should be taken in consideration when
-# showing a hint for a missing member.
-missing-member-max-choices=1
-
-
-[VARIABLES]
-
-# List of additional names supposed to be defined in builtins. Remember that
-# you should avoid defining new builtins when possible.
-additional-builtins=
-
-# Tells whether unused global variables should be treated as a violation.
-allow-global-unused-variables=yes
-
-# List of strings which can identify a callback function by name. A callback
-# name must start or end with one of those strings.
-callbacks=cb_,
-          _cb
-
-# A regular expression matching the name of dummy variables (i.e. expected to
-# not be used).
-dummy-variables-rgx=_+$|(_[a-zA-Z0-9_]*[a-zA-Z0-9]+?$)|dummy|^ignored_|^unused_
-
-# Argument names that match this expression will be ignored. Default to name
-# with leading underscore.
-ignored-argument-names=_.*|^ignored_|^unused_
-
-# Tells whether we should check for unused import in __init__ files.
-init-import=no
-
-# List of qualified module names which can have objects that can redefine
-# builtins.
-redefining-builtins-modules=six.moves,past.builtins,future.builtins,builtins,io
-
-
-[CLASSES]
-
-# List of method names used to declare (i.e. assign) instance attributes.
-defining-attr-methods=__init__,
-                      __new__,
-                      setUp
-
-# List of member names, which should be excluded from the protected access
-# warning.
-exclude-protected=_asdict,
-                  _fields,
-                  _replace,
-                  _source,
-                  _make
-
-# List of valid names for the first argument in a class method.
-valid-classmethod-first-arg=cls
-
-# List of valid names for the first argument in a metaclass class method.
-valid-metaclass-classmethod-first-arg=cls
-
-
-[DESIGN]
-
-# Maximum number of arguments for function / method.
-max-args=5
-
-# Maximum number of attributes for a class (see R0902).
-max-attributes=7
-
-# Maximum number of boolean expressions in an if statement.
-max-bool-expr=5
-
-# Maximum number of branch for function / method body.
-max-branches=12
-
-# Maximum number of locals for function / method body.
-max-locals=15
-
-# Maximum number of parents for a class (see R0901).
-max-parents=7
-
-# Maximum number of public methods for a class (see R0904).
-max-public-methods=20
-
-# Maximum number of return / yield for function / method body.
-max-returns=6
-
-# Maximum number of statements in function / method body.
-max-statements=50
-
-# Minimum number of public methods for a class (see R0903).
-min-public-methods=2
-
-
-[IMPORTS]
-
-# Allow wildcard imports from modules that define __all__.
-allow-wildcard-with-all=no
-
-# Analyse import fallback blocks. This can be used to support both Python 2 and
-# 3 compatible code, which means that the block might have code that exists
-# only in one or another interpreter, leading to false positives when analysed.
-analyse-fallback-blocks=no
-
-# Deprecated modules which should not be used, separated by a comma.
-deprecated-modules=optparse,tkinter.tix
-
-# Create a graph of external dependencies in the given file (report RP0402 must
-# not be disabled).
-ext-import-graph=
-
-# Create a graph of every (i.e. internal and external) dependencies in the
-# given file (report RP0402 must not be disabled).
-import-graph=
-
-# Create a graph of internal dependencies in the given file (report RP0402 must
-# not be disabled).
-int-import-graph=
-
-# Force import order to recognize a module as part of the standard
-# compatibility libraries.
-known-standard-library=
-
-# Force import order to recognize a module as part of a third party library.
-known-third-party=enchant
-
-
-[EXCEPTIONS]
-
-# Exceptions that will emit a warning when being caught. Defaults to
-# "BaseException, Exception".
-overgeneral-exceptions=BaseException,
-                       Exception
+[MAIN]
+
+# Analyse import fallback blocks. This can be used to support both Python 2 and
+# 3 compatible code, which means that the block might have code that exists
+# only in one or another interpreter, leading to false positives when analysed.
+analyse-fallback-blocks=no
+
+# Clear in-memory caches upon conclusion of linting. Useful if running pylint
+# in a server-like mode.
+clear-cache-post-run=no
+
+# Load and enable all available extensions. Use --list-extensions to see a list
+# all available extensions.
+#enable-all-extensions=
+
+# In error mode, messages with a category besides ERROR or FATAL are
+# suppressed, and no reports are done by default. Error mode is compatible with
+# disabling specific errors.
+#errors-only=
+
+# Always return a 0 (non-error) status code, even if lint errors are found.
+# This is primarily useful in continuous integration scripts.
+#exit-zero=
+
+# A comma-separated list of package or module names from where C extensions may
+# be loaded. Extensions are loading into the active Python interpreter and may
+# run arbitrary code.
+extension-pkg-allow-list=
+
+# A comma-separated list of package or module names from where C extensions may
+# be loaded. Extensions are loading into the active Python interpreter and may
+# run arbitrary code. (This is an alternative name to extension-pkg-allow-list
+# for backward compatibility.)
+extension-pkg-whitelist=
+
+# Return non-zero exit code if any of these messages/categories are detected,
+# even if score is above --fail-under value. Syntax same as enable. Messages
+# specified are enabled, while categories only check already-enabled messages.
+fail-on=
+
+# Specify a score threshold under which the program will exit with error.
+fail-under=10
+
+# Interpret the stdin as a python script, whose filename needs to be passed as
+# the module_or_package argument.
+#from-stdin=
+
+# Files or directories to be skipped. They should be base names, not paths.
+ignore=ui,.git,resources_icons.py,resources_logos.py
+
+# Add files or directories matching the regular expressions patterns to the
+# ignore-list. The regex matches against paths and can be in Posix or Windows
+# format. Because '\\' represents the directory delimiter on Windows systems,
+# it can't be used as an escape character.
+ignore-paths=
+
+# Files or directories matching the regular expression patterns are skipped.
+# The regex matches against base names, not paths. The default value ignores
+# Emacs file locks
+ignore-patterns=
+
+# List of module names for which member attributes should not be checked and
+# will not be imported (useful for modules/projects where namespaces are
+# manipulated during runtime and thus existing member attributes cannot be
+# deduced by static analysis). It supports qualified module names, as well as
+# Unix pattern matching.
+ignored-modules=
+
+# Python code to execute, usually for sys.path manipulation such as
+# pygtk.require().
+init-hook='import sys; sys.path.append("spinetoolbox")'
+
+# Use multiple processes to speed up Pylint. Specifying 0 will auto-detect the
+# number of processors available to use, and will cap the count on Windows to
+# avoid hangs.
+jobs=1
+
+# Control the amount of potential inferred values when inferring a single
+# object. This can help the performance when dealing with large functions or
+# complex, nested conditions.
+limit-inference-results=100
+
+# List of plugins (as comma separated values of python module names) to load,
+# usually to register additional checkers.
+load-plugins=
+
+# Pickle collected data for later comparisons.
+persistent=yes
+
+# Resolve imports to .pyi stubs if available. May reduce no-member messages and
+# increase not-an-iterable messages.
+prefer-stubs=no
+
+# Minimum Python version to use for version dependent checks. Will default to
+# the version used to run pylint.
+py-version=3.9
+
+# Discover python modules and packages in the file system subtree.
+recursive=no
+
+# Add paths to the list of the source roots. Supports globbing patterns. The
+# source root is an absolute path or a path relative to the current working
+# directory used to determine a package namespace for modules located under the
+# source root.
+source-roots=
+
+# When enabled, pylint would attempt to guess common misconfiguration and emit
+# user-friendly hints instead of false-positive error messages.
+suggestion-mode=yes
+
+# Allow loading of arbitrary C extensions. Extensions are imported into the
+# active Python interpreter and may run arbitrary code.
+unsafe-load-any-extension=yes
+
+# In verbose mode, extra non-checker-related info will be displayed.
+#verbose=
+
+
+[BASIC]
+
+# Naming style matching correct argument names.
+argument-naming-style=snake_case
+
+# Regular expression matching correct argument names. Overrides argument-
+# naming-style. If left empty, argument names will be checked with the set
+# naming style.
+#argument-rgx=
+
+# Naming style matching correct attribute names.
+attr-naming-style=snake_case
+
+# Regular expression matching correct attribute names. Overrides attr-naming-
+# style. If left empty, attribute names will be checked with the set naming
+# style.
+#attr-rgx=
+
+# Bad variable names which should always be refused, separated by a comma.
+bad-names=foo,
+          bar,
+          baz,
+          toto,
+          tutu,
+          tata
+
+# Bad variable names regexes, separated by a comma. If names match any regex,
+# they will always be refused
+bad-names-rgxs=
+
+# Naming style matching correct class attribute names.
+class-attribute-naming-style=any
+
+# Regular expression matching correct class attribute names. Overrides class-
+# attribute-naming-style. If left empty, class attribute names will be checked
+# with the set naming style.
+#class-attribute-rgx=
+
+# Naming style matching correct class constant names.
+class-const-naming-style=UPPER_CASE
+
+# Regular expression matching correct class constant names. Overrides class-
+# const-naming-style. If left empty, class constant names will be checked with
+# the set naming style.
+#class-const-rgx=
+
+# Naming style matching correct class names.
+class-naming-style=PascalCase
+
+# Regular expression matching correct class names. Overrides class-naming-
+# style. If left empty, class names will be checked with the set naming style.
+#class-rgx=
+
+# Naming style matching correct constant names.
+const-naming-style=UPPER_CASE
+
+# Regular expression matching correct constant names. Overrides const-naming-
+# style. If left empty, constant names will be checked with the set naming
+# style.
+#const-rgx=
+
+# Minimum line length for functions/classes that require docstrings, shorter
+# ones are exempt.
+docstring-min-length=-1
+
+# Naming style matching correct function names.
+function-naming-style=snake_case
+
+# Regular expression matching correct function names. Overrides function-
+# naming-style. If left empty, function names will be checked with the set
+# naming style.
+#function-rgx=
+
+# Good variable names which should always be accepted, separated by a comma.
+good-names=i,
+           j,
+           k,
+           ex,
+           Run,
+           ui,
+           x,
+           y,
+           _
+
+# Good variable names regexes, separated by a comma. If names match any regex,
+# they will always be accepted
+good-names-rgxs=
+
+# Include a hint for the correct naming format with invalid-name.
+include-naming-hint=no
+
+# Naming style matching correct inline iteration names.
+inlinevar-naming-style=any
+
+# Regular expression matching correct inline iteration names. Overrides
+# inlinevar-naming-style. If left empty, inline iteration names will be checked
+# with the set naming style.
+#inlinevar-rgx=
+
+# Naming style matching correct method names.
+method-naming-style=snake_case
+
+# Regular expression matching correct method names. Overrides method-naming-
+# style. If left empty, method names will be checked with the set naming style.
+#method-rgx=
+
+# Naming style matching correct module names.
+module-naming-style=snake_case
+
+# Regular expression matching correct module names. Overrides module-naming-
+# style. If left empty, module names will be checked with the set naming style.
+#module-rgx=
+
+# Colon-delimited sets of names that determine each other's naming style when
+# the name regexes allow several styles.
+name-group=
+
+# Regular expression which should only match function or class names that do
+# not require a docstring.
+no-docstring-rgx=^_
+
+# List of decorators that produce properties, such as abc.abstractproperty. Add
+# to this list to register other decorators that produce valid properties.
+# These decorators are taken in consideration only for invalid-name.
+property-classes=abc.abstractproperty
+
+# Regular expression matching correct type alias names. If left empty, type
+# alias names will be checked with the set naming style.
+#typealias-rgx=
+
+# Regular expression matching correct type variable names. If left empty, type
+# variable names will be checked with the set naming style.
+#typevar-rgx=
+
+# Naming style matching correct variable names.
+variable-naming-style=snake_case
+
+# Regular expression matching correct variable names. Overrides variable-
+# naming-style. If left empty, variable names will be checked with the set
+# naming style.
+#variable-rgx=
+
+
+[CLASSES]
+
+# Warn about protected attribute access inside special methods
+check-protected-access-in-special-methods=no
+
+# List of method names used to declare (i.e. assign) instance attributes.
+defining-attr-methods=__init__,
+                      __new__,
+                      setUp
+
+# List of member names, which should be excluded from the protected access
+# warning.
+exclude-protected=_asdict,
+                  _fields,
+                  _replace,
+                  _source,
+                  _make
+
+# List of valid names for the first argument in a class method.
+valid-classmethod-first-arg=cls
+
+# List of valid names for the first argument in a metaclass class method.
+valid-metaclass-classmethod-first-arg=cls
+
+
+[DESIGN]
+
+# List of regular expressions of class ancestor names to ignore when counting
+# public methods (see R0903)
+exclude-too-few-public-methods=
+
+# List of qualified class names to ignore when counting class parents (see
+# R0901)
+ignored-parents=
+
+# Maximum number of arguments for function / method.
+max-args=5
+
+# Maximum number of attributes for a class (see R0902).
+max-attributes=7
+
+# Maximum number of boolean expressions in an if statement (see R0916).
+max-bool-expr=5
+
+# Maximum number of branch for function / method body.
+max-branches=12
+
+# Maximum number of locals for function / method body.
+max-locals=15
+
+# Maximum number of parents for a class (see R0901).
+max-parents=7
+
+# Maximum number of public methods for a class (see R0904).
+max-public-methods=20
+
+# Maximum number of return / yield for function / method body.
+max-returns=6
+
+# Maximum number of statements in function / method body.
+max-statements=50
+
+# Minimum number of public methods for a class (see R0903).
+min-public-methods=2
+
+
+[EXCEPTIONS]
+
+# Exceptions that will emit a warning when caught.
+overgeneral-exceptions=builtins.BaseException,builtins.Exception
+
+
+[FORMAT]
+
+# Expected format of line ending, e.g. empty (any line ending), LF or CRLF.
+expected-line-ending-format=
+
+# Regexp for a line that is allowed to be longer than the limit.
+ignore-long-lines=^\s*(# )?<?https?://\S+>?$
+
+# Number of spaces of indent required inside a hanging or continued line.
+indent-after-paren=4
+
+# String used as indentation unit. This is usually "    " (4 spaces) or "\t" (1
+# tab).
+indent-string='    '
+
+# Maximum number of characters on a single line.
+max-line-length=100
+
+# Maximum number of lines in a module.
+max-module-lines=1000
+
+# Allow the body of a class to be on the same line as the declaration if body
+# contains single statement.
+single-line-class-stmt=no
+
+# Allow the body of an if to be on the same line as the test if there is no
+# else.
+single-line-if-stmt=no
+
+
+[IMPORTS]
+
+# List of modules that can be imported at any level, not just the top level
+# one.
+allow-any-import-level=
+
+# Allow explicit reexports by alias from a package __init__.
+allow-reexport-from-package=no
+
+# Allow wildcard imports from modules that define __all__.
+allow-wildcard-with-all=no
+
+# Deprecated modules which should not be used, separated by a comma.
+deprecated-modules=optparse,tkinter.tix
+
+# Output a graph (.gv or any supported image format) of external dependencies
+# to the given file (report RP0402 must not be disabled).
+ext-import-graph=
+
+# Output a graph (.gv or any supported image format) of all (i.e. internal and
+# external) dependencies to the given file (report RP0402 must not be
+# disabled).
+import-graph=
+
+# Output a graph (.gv or any supported image format) of internal dependencies
+# to the given file (report RP0402 must not be disabled).
+int-import-graph=
+
+# Force import order to recognize a module as part of the standard
+# compatibility libraries.
+known-standard-library=
+
+# Force import order to recognize a module as part of a third party library.
+known-third-party=enchant
+
+# Couples of modules and preferred modules, separated by a comma.
+preferred-modules=
+
+
+[LOGGING]
+
+# The type of string formatting that logging methods do. `old` means using %
+# formatting, `new` is for `{}` formatting.
+logging-format-style=old
+
+# Logging modules to check that the string format arguments are in logging
+# function parameter format.
+logging-modules=logging
+
+
+[MESSAGES CONTROL]
+
+# Only show warnings with the listed confidence levels. Leave empty to show
+# all. Valid levels: HIGH, CONTROL_FLOW, INFERENCE, INFERENCE_FAILURE,
+# UNDEFINED.
+confidence=
+
+# Disable the message, report, category or checker with the given id(s). You
+# can either give multiple identifiers separated by comma (,) or put this
+# option multiple times (only on the command line, not in the configuration
+# file where it should appear only once). You can also use "--disable=all" to
+# disable everything first and then re-enable specific checks. For example, if
+# you want to run only the similarities checker, you can use "--disable=all
+# --enable=similarities". If you want to run only the classes checker, but have
+# no Warning level messages displayed, use "--disable=all --enable=classes
+# --disable=W".
+disable=abstract-method,
+        raw-checker-failed,
+        bad-inline-option,
+        locally-disabled,
+        file-ignored,
+        suppressed-message,
+        useless-suppression,
+        deprecated-pragma,
+        use-symbolic-message-instead,
+        use-implicit-booleaness-not-comparison-to-string,
+        use-implicit-booleaness-not-comparison-to-zero,
+        duplicate-code,
+        fixme,
+        inconsistent-return-statements,
+        invalid-name,
+        line-too-long,
+        missing-module-docstring,
+        missing-class-docstring,
+        missing-function-docstring,
+        no-member,
+        protected-access,
+        too-few-public-methods,
+        too-many-ancestors,
+        too-many-arguments,
+        too-many-branches,
+        too-many-instance-attributes,
+        too-many-nested-blocks,
+        too-many-public-methods,
+        too-many-lines,
+        too-many-locals,
+        too-many-return-statements,
+        too-many-statements,
+        unused-argument
+
+# Enable the message, report, category or checker with the given id(s). You can
+# either give multiple identifier separated by comma (,) or put this option
+# multiple time (only on the command line, not in the configuration file where
+# it should appear only once). See also the "--disable" option for examples.
+enable=
+
+
+[METHOD_ARGS]
+
+# List of qualified names (i.e., library.method) which require a timeout
+# parameter e.g. 'requests.api.get,requests.api.post'
+timeout-methods=requests.api.delete,requests.api.get,requests.api.head,requests.api.options,requests.api.patch,requests.api.post,requests.api.put,requests.api.request
+
+
+[MISCELLANEOUS]
+
+# List of note tags to take in consideration, separated by a comma.
+notes=FIXME,
+      XXX,
+      TODO
+
+# Regular expression of note tags to take in consideration.
+notes-rgx=
+
+
+[REFACTORING]
+
+# Maximum number of nested blocks for function / method body
+max-nested-blocks=5
+
+# Complete name of functions that never returns. When checking for
+# inconsistent-return-statements if a never returning function is called then
+# it will be considered as an explicit return statement and no message will be
+# printed.
+never-returning-functions=sys.exit
+
+# Let 'consider-using-join' be raised when the separator to join on would be
+# non-empty (resulting in expected fixes of the type: ``"- " + " -
+# ".join(items)``)
+suggest-join-with-non-empty-separator=yes
+
+
+[REPORTS]
+
+# Python expression which should return a score less than or equal to 10. You
+# have access to the variables 'fatal', 'error', 'warning', 'refactor',
+# 'convention', and 'info' which contain the number of messages in each
+# category, as well as 'statement' which is the total number of statements
+# analyzed. This score is used by the global evaluation report (RP0004).
+evaluation=10.0 - ((float(5 * error + warning + refactor + convention) / statement) * 10)
+
+# Template used to display messages. This is a python new-style format string
+# used to format the message information. See doc for all details.
+msg-template=
+
+# Set the output format. Available formats are: text, parseable, colorized,
+# json2 (improved json format), json (old json format) and msvs (visual
+# studio). You can also give a reporter class, e.g.
+# mypackage.mymodule.MyReporterClass.
+#output-format=text
+
+# Tells whether to display a full report or only the messages.
+reports=no
+
+# Activate the evaluation score.
+score=yes
+
+
+[SIMILARITIES]
+
+# Comments are removed from the similarity computation
+ignore-comments=yes
+
+# Docstrings are removed from the similarity computation
+ignore-docstrings=yes
+
+# Imports are removed from the similarity computation
+ignore-imports=no
+
+# Signatures are removed from the similarity computation
+ignore-signatures=yes
+
+# Minimum lines number of a similarity.
+min-similarity-lines=6
+
+
+[SPELLING]
+
+# Limits count of emitted suggestions for spelling mistakes.
+max-spelling-suggestions=4
+
+# Spelling dictionary name. No available dictionaries : You need to install
+# both the python package and the system dependency for enchant to work.
+spelling-dict=
+
+# List of comma separated words that should be considered directives if they
+# appear at the beginning of a comment and should not be checked.
+spelling-ignore-comment-directives=fmt: on,fmt: off,noqa:,noqa,nosec,isort:skip,mypy:
+
+# List of comma separated words that should not be checked.
+spelling-ignore-words=
+
+# A path to a file that contains the private dictionary; one word per line.
+spelling-private-dict-file=
+
+# Tells whether to store unknown words to the private dictionary (see the
+# --spelling-private-dict-file option) instead of raising a message.
+spelling-store-unknown-words=no
+
+
+[STRING]
+
+# This flag controls whether inconsistent-quotes generates a warning when the
+# character used as a quote delimiter is used inconsistently within a module.
+check-quote-consistency=no
+
+# This flag controls whether the implicit-str-concat should generate a warning
+# on implicit string concatenation in sequences defined over several lines.
+check-str-concat-over-line-jumps=no
+
+
+[TYPECHECK]
+
+# List of decorators that produce context managers, such as
+# contextlib.contextmanager. Add to this list to register other decorators that
+# produce valid context managers.
+contextmanager-decorators=contextlib.contextmanager
+
+# List of members which are set dynamically and missed by pylint inference
+# system, and so shouldn't trigger E1101 when accessed. Python regular
+# expressions are accepted.
+generated-members=
+
+# Tells whether to warn about missing members when the owner of the attribute
+# is inferred to be None.
+ignore-none=yes
+
+# This flag controls whether pylint should warn about no-member and similar
+# checks whenever an opaque object is returned when inferring. The inference
+# can return multiple potential results while evaluating a Python object, but
+# some branches might not be evaluated, which results in partial inference. In
+# that case, it might be useful to still emit no-member and other checks for
+# the rest of the inferred objects.
+ignore-on-opaque-inference=yes
+
+# List of symbolic message names to ignore for Mixin members.
+ignored-checks-for-mixins=no-member,
+                          not-async-context-manager,
+                          not-context-manager,
+                          attribute-defined-outside-init
+
+# List of class names for which member attributes should not be checked (useful
+# for classes with dynamically set attributes). This supports the use of
+# qualified names.
+ignored-classes=optparse.Values,thread._local,_thread._local
+
+# Show a hint with possible names when a member name was not found. The aspect
+# of finding the hint is based on edit distance.
+missing-member-hint=yes
+
+# The minimum edit distance a name should have in order to be considered a
+# similar match for a missing member name.
+missing-member-hint-distance=1
+
+# The total number of similar names that should be taken in consideration when
+# showing a hint for a missing member.
+missing-member-max-choices=1
+
+# Regex pattern to define which classes are considered mixins.
+mixin-class-rgx=.*[Mm]ixin
+
+# List of decorators that change the signature of a decorated function.
+signature-mutators=
+
+
+[VARIABLES]
+
+# List of additional names supposed to be defined in builtins. Remember that
+# you should avoid defining new builtins when possible.
+additional-builtins=
+
+# Tells whether unused global variables should be treated as a violation.
+allow-global-unused-variables=yes
+
+# List of names allowed to shadow builtins
+allowed-redefined-builtins=
+
+# List of strings which can identify a callback function by name. A callback
+# name must start or end with one of those strings.
+callbacks=cb_,
+          _cb
+
+# A regular expression matching the name of dummy variables (i.e. expected to
+# not be used).
+dummy-variables-rgx=_+$|(_[a-zA-Z0-9_]*[a-zA-Z0-9]+?$)|dummy|^ignored_|^unused_
+
+# Argument names that match this expression will be ignored.
+ignored-argument-names=_.*|^ignored_|^unused_
+
+# Tells whether we should check for unused import in __init__ files.
+init-import=no
+
+# List of qualified module names which can have objects that can redefine
+# builtins.
+redefining-builtins-modules=six.moves,past.builtins,future.builtins,builtins,io
\ No newline at end of file
diff --git a/spinetoolbox/execution_managers.py b/spinetoolbox/execution_managers.py
index 29e07863f..7d9df5abc 100644
--- a/spinetoolbox/execution_managers.py
+++ b/spinetoolbox/execution_managers.py
@@ -137,9 +137,9 @@ def on_state_changed(self, new_state):
             new_state (int): Process state number (``QProcess::ProcessState``)
         """
         if new_state == QProcess.Starting:
-            self._logger.msg.emit("\tStarting program <b>{0}</b>".format(self._program))
+            self._logger.msg.emit(f"\tStarting program <b>{self._program}</b>")
             arg_str = " ".join(self._args)
-            self._logger.msg.emit("\tArguments: <b>{0}</b>".format(arg_str))
+            self._logger.msg.emit(f"\tArguments: <b>{arg_str}</b>")
         elif new_state == QProcess.Running:
             self._logger.msg_warning.emit("\tExecution in progress...")
         elif new_state == QProcess.NotRunning:
@@ -174,7 +174,7 @@ def on_process_error(self, process_error):
         elif process_error == QProcess.UnknownError:
             self._logger.msg_error.emit("Unknown error in process")
         else:
-            self._logger.msg_error.emit("Unspecified error in process: {0}".format(process_error))
+            self._logger.msg_error.emit(f"Unspecified error in process: {process_error}")
         self.teardown_process()
 
     def teardown_process(self):
@@ -205,7 +205,7 @@ def stop_execution(self):
                 self._process.finished.emit(-1, -1)
                 self._process.deleteLater()
         except Exception as ex:  # pylint: disable=broad-except
-            self._logger.msg_error.emit("[{0}] exception when terminating process".format(ex))
+            self._logger.msg_error.emit(f"[{ex}] exception when terminating process")
             logging.exception("Exception in closing QProcess: %s", ex)
         finally:
             self._process = None
@@ -228,7 +228,7 @@ def on_process_finished(self, exit_code, exit_status):
             pass
         else:
             if not self._silent:
-                self._logger.msg_error.emit("Unknown QProcess exit status [{0}]".format(exit_status))
+                self._logger.msg_error.emit(f"Unknown QProcess exit status [{exit_status}]")
             exit_code = -1
         if exit_code != 0:
             self.process_failed = True
diff --git a/spinetoolbox/fetch_parent.py b/spinetoolbox/fetch_parent.py
index 791831ac8..ad4c5f888 100644
--- a/spinetoolbox/fetch_parent.py
+++ b/spinetoolbox/fetch_parent.py
@@ -161,7 +161,6 @@ def key_for_index(self, db_map):
         """
         return None
 
-    # pylint: disable=no-self-use
     def accepts_item(self, item, db_map):
         """Called by the associated SpineDBWorker whenever items are fetched and also added/updated/removed.
         Returns whether this parent accepts that item as a children.
@@ -178,7 +177,6 @@ def accepts_item(self, item, db_map):
         """
         return True
 
-    # pylint: disable=no-self-use
     def shows_item(self, item, db_map):
         """Called by the associated SpineDBWorker whenever items are fetched and accepted.
         Returns whether this parent will show this item to the user.
diff --git a/spinetoolbox/headless.py b/spinetoolbox/headless.py
index 45d76a8c3..ee98b3f50 100644
--- a/spinetoolbox/headless.py
+++ b/spinetoolbox/headless.py
@@ -187,7 +187,7 @@ def __init__(self, args, startup_event_type, parent):
         self._logger = HeadlessLogger()
         self._startup_event_type = startup_event_type
         self._start.connect(self._execute)
-        self._node_messages = dict()
+        self._node_messages = {}
         self._project_dir = None
         self._app_settings = None
         self._item_dicts = None
@@ -250,7 +250,7 @@ def _open_project(self):
         """
         self._app_settings = QSettings("SpineProject", "Spine Toolbox", self)
         spec_factories = load_item_specification_factories("spine_items")
-        self._plugin_specifications = dict()
+        self._plugin_specifications = {}
         self._project_dir = pathlib.Path(self._args.project).resolve()
         config_dir = self._project_dir / ".spinetoolbox"
         specification_local_data = load_specification_local_data(config_dir)
@@ -370,7 +370,7 @@ def _execute_project(self):
                 "settings": settings,
                 "project_dir": solve_project_dir(self._project_dir),
             }
-            exec_remotely = True if self._server_config else False
+            exec_remotely = bool(self._server_config)
             engine_manager = make_engine_manager(exec_remotely, job_id=job_id)
             try:
                 engine_manager.run_engine(engine_data)
@@ -427,7 +427,7 @@ def _handle_node_execution_started(self, data):
         if data["direction"] == ExecutionDirection.BACKWARD:
             # Currently there are no interesting messages when executing backwards.
             return
-        self._node_messages[data["item_name"]] = dict()
+        self._node_messages[data["item_name"]] = {}
 
     def _handle_node_execution_finished(self, data):
         """Prints messages for finished nodes.
@@ -532,9 +532,8 @@ def _read_server_config(self):
                 sec_folder = ""
             cfg_dict = {"host": host, "port": port, "security_model": sec_model, "security_folder": sec_folder}
             return cfg_dict
-        else:
-            self._logger.msg_error.emit(f"cfg file '{cfg_fp}' missing.")
-            return None
+        self._logger.msg_error.emit(f"cfg file '{cfg_fp}' missing.")
+        return None
 
     def _insert_remote_engine_settings(self, settings):
         """Inserts remote engine client settings into the settings dictionary that is delivered to the engine.
@@ -564,7 +563,7 @@ def _prepare_remote_execution(self):
         if not self._server_config:
             return "1"
         host, port = self._server_config["host"], self._server_config["port"]
-        security_on = False if self._server_config["security_model"].lower() == "" else True
+        security_on = self._server_config["security_model"].lower() != ""
         sec_model = ClientSecurityModel.STONEHOUSE if security_on else ClientSecurityModel.NONE
         try:
             engine_client = EngineClient(host, port, sec_model, self._server_config["security_folder"])
@@ -643,8 +642,8 @@ def _specification_dicts(project_dict, project_dir, logger):
     Returns:
         dict: a mapping from item type to a list of specification dicts
     """
-    specification_dicts = dict()
-    specification_file_paths = dict()
+    specification_dicts = {}
+    specification_file_paths = {}
     for item_type, serialized_paths in project_dict["project"].get("specifications", {}).items():
         specification_file_paths[item_type] = [deserialize_path(path, project_dir) for path in serialized_paths]
     for item_type, paths in specification_file_paths.items():
@@ -660,7 +659,7 @@ def _specification_dicts(project_dict, project_dir, logger):
                 logger.msg_error.emit(f"Specification file <b>{path}</b> does not exist")
                 continue
             specification_dict["definition_file_path"] = path
-            specification_dicts.setdefault(item_type, list()).append(specification_dict)
+            specification_dicts.setdefault(item_type, []).append(specification_dict)
     return specification_dicts
 
 
diff --git a/spinetoolbox/helpers.py b/spinetoolbox/helpers.py
index fc2eca470..8cb946fcc 100644
--- a/spinetoolbox/helpers.py
+++ b/spinetoolbox/helpers.py
@@ -174,7 +174,7 @@ def rename_dir(old_dir, new_dir, toolbox, box_title):
         bool: True if operation was successful, False otherwise
     """
     if os.path.exists(new_dir):
-        msg = "Directory <b>{0}</b> already exists.<br/><br/>Would you like to overwrite its contents?".format(new_dir)
+        msg = f"Directory <b>{new_dir}</b> already exists.<br/><br/>Would you like to overwrite its contents?"
         box = QMessageBox(
             QMessageBox.Icon.Question,
             box_title,
@@ -192,32 +192,32 @@ def rename_dir(old_dir, new_dir, toolbox, box_title):
     except FileExistsError:
         # This is unlikely because of the above `if`, but still possible since another concurrent process
         # might have done things in between
-        msg = "Directory<br/><b>{0}</b><br/>already exists".format(new_dir)
+        msg = f"Directory<br/><b>{new_dir}</b><br/>already exists"
         toolbox.information_box.emit(box_title, msg)
         return False
     except PermissionError as pe_e:
         logging.error(pe_e)
         msg = (
-            "Access to directory <br/><b>{0}</b><br/>denied."
-            "<br/><br/>Possible reasons:"
-            "<br/>1. You don't have a permission to edit the directory"
-            "<br/>2. Windows Explorer is open in the directory"
-            "<br/><br/>Check these and try again.".format(old_dir)
+            f"Access to directory <br/><b>{old_dir}</b><br/>denied."
+            f"<br/><br/>Possible reasons:"
+            f"<br/>1. You don't have a permission to edit the directory"
+            f"<br/>2. Windows Explorer is open in the directory"
+            f"<br/><br/>Check these and try again."
         )
         toolbox.information_box.emit(box_title, msg)
         return False
     except OSError as os_e:
         logging.error(os_e)
         msg = (
-            "Renaming directory "
-            "<br/><b>{0}</b> "
-            "<br/>to "
-            "<br/><b>{1}</b> "
-            "<br/>failed."
-            "<br/><br/>Possibly reasons:"
-            "<br/>1. Windows Explorer is open in the directory."
-            "<br/>2. A file in the directory is open in another program. "
-            "<br/><br/>Check these and try again.".format(old_dir, new_dir)
+            f"Renaming directory "
+            f"<br/><b>{old_dir}</b> "
+            f"<br/>to "
+            f"<br/><b>{new_dir}</b> "
+            f"<br/>failed."
+            f"<br/><br/>Possibly reasons:"
+            f"<br/>1. Windows Explorer is open in the directory."
+            f"<br/>2. A file in the directory is open in another program. "
+            f"<br/><br/>Check these and try again."
         )
         toolbox.information_box.emit(box_title, msg)
         return False
@@ -294,11 +294,11 @@ def get_datetime(show, date=True):
     if not show:
         return ""
     t = datetime.datetime.now()
-    time_str = "{:02d}:{:02d}:{:02d}".format(t.hour, t.minute, t.second)
+    time_str = f"{t.hour:02d}:{t.minute:02d}:{t.second:02d}"
     if not date:
-        return "[{}] ".format(time_str)
-    date_str = "{:02d}-{:02d}-{:02d}".format(t.day, t.month, t.year)
-    return "[{} {}] ".format(date_str, time_str)
+        return f"[{time_str}] "
+    date_str = f"{t.day:02d}-{t.month:02d}-{t.year:02d}"
+    return f"[{date_str} {time_str}] "
 
 
 @busy_effect
@@ -370,7 +370,7 @@ def recursive_overwrite(logger, src, dst, ignore=None, silent=True):
     if os.path.isdir(src):
         if not os.path.isdir(dst):
             if not silent:
-                logger.msg.emit("Creating directory <b>{0}</b>".format(dst))
+                logger.msg.emit(f"Creating directory <b>{dst}</b>")
             os.makedirs(dst)
         files = os.listdir(src)
         for file_name in list(files):
@@ -390,7 +390,7 @@ def recursive_overwrite(logger, src, dst, ignore=None, silent=True):
         if not silent:
             _, src_filename = os.path.split(src)
             dst_dir, _ = os.path.split(dst)
-            logger.msg.emit("Copying <b>{0}</b> -> <b>{1}</b>".format(src_filename, dst_dir))
+            logger.msg.emit(f"Copying <b>{src_filename}</b> -> <b>{dst_dir}</b>")
         shutil.copyfile(src, dst)
 
 
@@ -831,7 +831,7 @@ def select_gams_executable(parent, line_edit):
     # Check that selected file at least starts with string 'gams'
     _, selected_file = os.path.split(answer[0])
     if not selected_file.lower().startswith("gams"):
-        msg = "Selected file <b>{0}</b> may not be a valid GAMS program".format(selected_file)
+        msg = f"Selected file <b>{selected_file}</b> may not be a valid GAMS program"
         # noinspection PyCallByClass, PyArgumentList
         QMessageBox.warning(parent, "Invalid GAMS Program", msg)
         return
@@ -858,7 +858,7 @@ def select_julia_executable(parent, line_edit):
     # Check that the selected file starts with "julia"
     _, selected_file = os.path.split(answer[0])
     if not selected_file.lower().startswith("julia"):
-        msg = "Selected file <b>{0}</b> is not a valid Julia Executable".format(selected_file)
+        msg = f"Selected file <b>{selected_file}</b> is not a valid Julia Executable"
         # noinspection PyCallByClass, PyArgumentList
         QMessageBox.warning(parent, "Invalid Julia Executable", msg)
         return
@@ -900,7 +900,7 @@ def select_python_interpreter(parent, line_edit):
     # Check that selected file at least starts with string 'python'
     _, selected_file = os.path.split(answer[0])
     if not selected_file.lower().startswith("python"):
-        msg = "Selected file <b>{0}</b> is not a valid Python interpreter".format(selected_file)
+        msg = f"Selected file <b>{selected_file}</b> is not a valid Python interpreter"
         # noinspection PyCallByClass, PyArgumentList
         QMessageBox.warning(parent, "Invalid Python Interpreter", msg)
         return
@@ -930,7 +930,7 @@ def select_conda_executable(parent, line_edit):
     # Check that selected file at least starts with string 'conda'
     if not is_valid_conda_executable(answer[0]):
         _, selected_file = os.path.split(answer[0])
-        msg = "Selected file <b>{0}</b> is not a valid Conda executable".format(selected_file)
+        msg = f"Selected file <b>{selected_file}</b> is not a valid Conda executable"
         # noinspection PyCallByClass, PyArgumentList
         QMessageBox.warning(parent, "Invalid Conda selected", msg)
         return
@@ -979,10 +979,12 @@ def get_path_from_native_open_file_dialog(parent, current_path, title, initial_p
         tuple: [0] is the selected path, [1] is the calling function, [2] is the error message
     """
     init_path = initial_path if initial_path is not None else home_dir()
+    # pylint: disable= possibly-used-before-assignment
     hwnd = win32gui.FindWindow(None, parent.windowTitle())
     pyhandle = pywintypes.HANDLE(hwnd)
     try:
         # NOTE: Paths must use Windows path separators (\) !
+        # pylint: disable= possibly-used-before-assignment
         r = win32gui.GetOpenFileNameW(
             hwndOwner=pyhandle,
             File=current_path,
@@ -1568,7 +1570,11 @@ def bisect_chunks(current_data, new_data, key=None):
     if key is not None:
         current_data = [key(x) for x in current_data]
     else:
-        key = lambda x: x
+
+        def key(x):
+            # pylint: disable=function-redefined
+            return x
+
     new_data = sorted(new_data, key=key)
     if not new_data:
         return ()
@@ -1695,6 +1701,9 @@ def handle_starttag(self, tag, attrs):
         if tag == "br":
             self._text += "\n"
 
+    def error(self, message):
+        """To stop pylint whining"""
+
 
 def same_path(path1, path2):
     """Checks if two paths are equal.
diff --git a/spinetoolbox/kernel_fetcher.py b/spinetoolbox/kernel_fetcher.py
index 462d9e673..65eb19907 100644
--- a/spinetoolbox/kernel_fetcher.py
+++ b/spinetoolbox/kernel_fetcher.py
@@ -82,7 +82,7 @@ def run(self):
             d = self.get_kernel_deats(resource_dir)
             icon = self.get_icon(resource_dir)
             if d["language"].lower().strip() == "python":  # Regular Python kernel found
-                if self.fetch_mode == 2 or self.fetch_mode == 3:
+                if self.fetch_mode in {2, 3}:
                     self.kernel_found.emit(kernel_name, resource_dir, False, icon, d)
             elif d["language"].lower().strip() == "julia":  # Regular Julia kernel found
                 if self.fetch_mode == 4:
diff --git a/spinetoolbox/main.py b/spinetoolbox/main.py
index 788165c88..72ee58db1 100644
--- a/spinetoolbox/main.py
+++ b/spinetoolbox/main.py
@@ -103,7 +103,7 @@ def _make_argument_parser():
 def _add_pywin32_system32_to_path():
     """Adds a directory to PATH on Windows that is required to make pywin32 work
     on (Conda) Python 3.8. See https://github.com/spine-tools/Spine-Toolbox/issues/1230."""
-    if not sys.platform == "win32":
+    if sys.platform != "win32":
         return
     if sys.version_info[0:2] == (3, 8):
         p = os.path.join(sys.exec_prefix, "Lib", "site-packages", "pywin32_system32")
diff --git a/spinetoolbox/mvcmodels/array_model.py b/spinetoolbox/mvcmodels/array_model.py
index 9d00aed8f..73b33bea2 100644
--- a/spinetoolbox/mvcmodels/array_model.py
+++ b/spinetoolbox/mvcmodels/array_model.py
@@ -34,7 +34,7 @@ def __init__(self, parent):
             parent (QObject): parent object
         """
         super().__init__(parent)
-        self._data = list()
+        self._data = []
         self._data_type = float
         self._index_name = Array.DEFAULT_INDEX_NAME
 
@@ -86,8 +86,8 @@ def _convert_to_data_type(self, indexes, values):
         Returns:
             tuple: indexes and converted values
         """
-        filtered = list()
-        converted = list()
+        filtered = []
+        converted = []
         if self._data_type == float:
             for index, value in zip(indexes, values):
                 if value is None:
@@ -131,8 +131,7 @@ def data(self, index, role=Qt.ItemDataRole.DisplayRole):
         if column == 0:
             if role in (Qt.ItemDataRole.DisplayRole, Qt.ItemDataRole.EditRole):
                 return row
-            else:
-                return None
+            return None
         if role == Qt.ItemDataRole.DisplayRole:
             if row == len(self._data):
                 return None
diff --git a/spinetoolbox/mvcmodels/compound_table_model.py b/spinetoolbox/mvcmodels/compound_table_model.py
index 3a5280493..cd00d794a 100644
--- a/spinetoolbox/mvcmodels/compound_table_model.py
+++ b/spinetoolbox/mvcmodels/compound_table_model.py
@@ -194,7 +194,7 @@ def batch_set_data(self, indexes, data):
             columns.append(index.column())
             sub_model, _ = self._row_map[index.row()]
             sub_index = self.map_to_sub(index)
-            d.setdefault(sub_model, list()).append((sub_index, value))
+            d.setdefault(sub_model, []).append((sub_index, value))
         for model, index_value_tuples in d.items():
             indexes, values = zip(*index_value_tuples)
             if not model.batch_set_data(list(indexes), list(values)):
@@ -249,6 +249,7 @@ def removeRows(self, row, count, parent=QModelIndex()):
                 sub_count = min(sub_model.rowCount(), count)
                 break
             finally:
+                # pylint: disable=used-before-assignment
                 sub_model.removeRows(sub_row, sub_count, self.map_to_sub(parent))
         self.endRemoveRows()
         self.refresh()
diff --git a/spinetoolbox/mvcmodels/empty_row_model.py b/spinetoolbox/mvcmodels/empty_row_model.py
index 8224f8056..ac22787db 100644
--- a/spinetoolbox/mvcmodels/empty_row_model.py
+++ b/spinetoolbox/mvcmodels/empty_row_model.py
@@ -62,7 +62,7 @@ def _handle_data_changed(self, top_left, bottom_right, roles=None):
         """Insert a new last empty row in case the previous one has been filled
         with any data other than the defaults."""
         if roles is None:
-            roles = list()
+            roles = []
         if roles and Qt.ItemDataRole.EditRole not in roles:
             return
         last_row = self.rowCount() - 1
diff --git a/spinetoolbox/mvcmodels/file_list_models.py b/spinetoolbox/mvcmodels/file_list_models.py
index a7abaf132..95dc1394d 100644
--- a/spinetoolbox/mvcmodels/file_list_models.py
+++ b/spinetoolbox/mvcmodels/file_list_models.py
@@ -37,8 +37,8 @@ def __init__(self, header_label="", draggable=False):
         super().__init__()
         self._header_label = header_label
         self._draggable = draggable
-        self._single_resources = list()
-        self._pack_resources = list()
+        self._single_resources = []
+        self._pack_resources = []
 
     def rowCount(self, parent=QModelIndex()):
         if not parent.isValid():
@@ -313,7 +313,10 @@ def __init__(self, parent=None):
     def reset_model(self, args):
         self._args = args
         self._reset_root(
-            self.invisibleRootItem(), args, dict(editable=True, selectable=True, drag_enabled=True), has_empty_row=True
+            self.invisibleRootItem(),
+            args,
+            {"editable": True, "selectable": True, "drag_enabled": True},
+            has_empty_row=True,
         )
 
     def canDropMimeData(self, data, drop_action, row, column, parent):
diff --git a/spinetoolbox/mvcmodels/filter_checkbox_list_model.py b/spinetoolbox/mvcmodels/filter_checkbox_list_model.py
index 01012e833..7068305f5 100644
--- a/spinetoolbox/mvcmodels/filter_checkbox_list_model.py
+++ b/spinetoolbox/mvcmodels/filter_checkbox_list_model.py
@@ -90,6 +90,7 @@ def data(self, index, role=Qt.ItemDataRole.DisplayRole):
             return None
         row = index.row()
         action_state = [self._all_selected]
+        data_row = None
         if self._show_empty:
             action_state.append(self._empty_selected)
         if self._show_add_to_selection:
diff --git a/spinetoolbox/mvcmodels/filter_execution_model.py b/spinetoolbox/mvcmodels/filter_execution_model.py
index 1df6431f6..1a0d6b6ba 100644
--- a/spinetoolbox/mvcmodels/filter_execution_model.py
+++ b/spinetoolbox/mvcmodels/filter_execution_model.py
@@ -15,7 +15,7 @@
 
 
 class FilterExecutionModel(QAbstractListModel):
-    _filter_consoles = dict()
+    _filter_consoles = {}
 
     def reset_model(self, filter_consoles):
         self.beginResetModel()
diff --git a/spinetoolbox/mvcmodels/map_model.py b/spinetoolbox/mvcmodels/map_model.py
index b4020252a..1c4b340eb 100644
--- a/spinetoolbox/mvcmodels/map_model.py
+++ b/spinetoolbox/mvcmodels/map_model.py
@@ -229,7 +229,7 @@ def insertRows(self, row, count, parent=QModelIndex()):
                 row_before = len(self._rows[0]) * [empty]
         else:
             row_before = (len(self._index_names) + 1) * [empty]
-        inserted = list()
+        inserted = []
         for _ in range(count):
             inserted.append([deepcopy(x) if x is not empty else x for x in row_before])
         self._rows = self._rows[:row] + inserted + self._rows[row:]
@@ -467,7 +467,7 @@ def _rows_to_dict(rows):
     Returns:
         dict: a nested dictionary
     """
-    tree = dict()
+    tree = {}
     for row in rows:
         current = tree
         for i, column in enumerate(row):
@@ -476,7 +476,7 @@ def _rows_to_dict(rows):
             if i < len(row) - 2 and row[i + 2] is not empty:
                 if not isinstance(column, (str, int, float, DateTime, Duration)):
                     raise ParameterValueFormatError(f"Index on row {rows.index(row) + 1} column {i + 1} is not scalar.")
-                current = current.setdefault(column, dict())
+                current = current.setdefault(column, {})
                 if not isinstance(current, dict):
                     raise ParameterValueFormatError(f"Indexing broken on row {rows.index(row) + 1} column {i + 1}.")
             else:
@@ -498,8 +498,8 @@ def _reconstruct_map(tree):
     Returns:
         Map: reconstructed Map
     """
-    indexes = list()
-    values = list()
+    indexes = []
+    values = []
     for key, value in tree.items():
         if isinstance(value, dict):
             value = _reconstruct_map(value)
@@ -510,7 +510,7 @@ def _reconstruct_map(tree):
         if first_type == numpy.float64:
             first_type = float
         if any(not isinstance(i, first_type) for i in indexes[1:]):
-            raise ParameterValueFormatError(f"Index type mismatch.")
+            raise ParameterValueFormatError("Index type mismatch.")
     map_ = Map(indexes, values)
     return map_
 
@@ -539,7 +539,7 @@ def _gather_index_names(map_value):
     Returns:
         list of str: index names
     """
-    nested_names = list()
+    nested_names = []
     for v in map_value.values:
         if isinstance(v, Map):
             new_nested_names = _gather_index_names(v)
diff --git a/spinetoolbox/mvcmodels/minimal_table_model.py b/spinetoolbox/mvcmodels/minimal_table_model.py
index ed02e2903..345b00547 100644
--- a/spinetoolbox/mvcmodels/minimal_table_model.py
+++ b/spinetoolbox/mvcmodels/minimal_table_model.py
@@ -29,7 +29,7 @@ def __init__(self, parent=None, header=None, lazy=True):
             header = []
         self._parent = parent
         self.header = header
-        self._main_data = list()
+        self._main_data = []
         self._fetched = not lazy
         self._paste = False
 
@@ -274,7 +274,7 @@ def removeColumns(self, column, count, parent=QModelIndex()):
     def reset_model(self, main_data=None):
         """Reset model."""
         if main_data is None:
-            main_data = list()
+            main_data = []
         self.beginResetModel()
         self._main_data = main_data
         self.endResetModel()
diff --git a/spinetoolbox/mvcmodels/minimal_tree_model.py b/spinetoolbox/mvcmodels/minimal_tree_model.py
index ced8a67dc..29be56f5a 100644
--- a/spinetoolbox/mvcmodels/minimal_tree_model.py
+++ b/spinetoolbox/mvcmodels/minimal_tree_model.py
@@ -196,12 +196,10 @@ def remove_children(self, position, count):
         self._has_children_initially = False
         return True
 
-    # pylint: disable=no-self-use
     def flags(self, column):
         """Enables the item and makes it selectable."""
         return Qt.ItemIsSelectable | Qt.ItemIsEnabled
 
-    # pylint: disable=no-self-use
     def data(self, column, role=Qt.ItemDataRole.DisplayRole):
         """Returns data for given column and role."""
         return None
diff --git a/spinetoolbox/mvcmodels/project_item_specification_models.py b/spinetoolbox/mvcmodels/project_item_specification_models.py
index 84f5be627..28bbd1c47 100644
--- a/spinetoolbox/mvcmodels/project_item_specification_models.py
+++ b/spinetoolbox/mvcmodels/project_item_specification_models.py
@@ -22,7 +22,7 @@ class ProjectItemSpecificationModel(QAbstractListModel):
 
     def __init__(self, icons):
         super().__init__()
-        self._spec_names = list()
+        self._spec_names = []
         self._icons = icons
         self._project = None
 
@@ -76,7 +76,7 @@ def connect_to_project(self, project):
 
     def clear(self):
         self.beginResetModel()
-        self._spec_names = list()
+        self._spec_names = []
         self.endResetModel()
 
     def rowCount(self, parent=None):
diff --git a/spinetoolbox/mvcmodels/time_pattern_model.py b/spinetoolbox/mvcmodels/time_pattern_model.py
index 2fa851a61..b389609fd 100644
--- a/spinetoolbox/mvcmodels/time_pattern_model.py
+++ b/spinetoolbox/mvcmodels/time_pattern_model.py
@@ -119,8 +119,8 @@ def batch_set_data(self, indexes, values):
             indexes (Sequence): a sequence of model indexes
             values (Sequence): a sequence of time periods/floats corresponding to the indexes
         """
-        modified_rows = list()
-        modified_columns = list()
+        modified_rows = []
+        modified_columns = []
         for index, value in zip(indexes, values):
             row = index.row()
             modified_rows.append(row)
diff --git a/spinetoolbox/mvcmodels/time_series_model_variable_resolution.py b/spinetoolbox/mvcmodels/time_series_model_variable_resolution.py
index 683aeb799..57b54cbbe 100644
--- a/spinetoolbox/mvcmodels/time_series_model_variable_resolution.py
+++ b/spinetoolbox/mvcmodels/time_series_model_variable_resolution.py
@@ -147,7 +147,7 @@ def setData(self, index, value, role=Qt.ItemDataRole.EditRole):
             try:
                 self._value.indexes[row] = value
             except ValueError:
-                self._value.indexes[row] = np.datetime64()
+                self._value.indexes[row] = np.datetime64()  # pylint: disable=no-value-for-parameter
         else:
             try:
                 self._value.values[row] = value
@@ -164,8 +164,8 @@ def batch_set_data(self, indexes, values):
             indexes (Sequence): a sequence of model indexes
             values (Sequence): a sequence of datetimes/floats corresponding to the indexes
         """
-        modified_rows = list()
-        modified_columns = list()
+        modified_rows = []
+        modified_columns = []
         for index, value in zip(indexes, values):
             row = index.row()
             modified_rows.append(row)
diff --git a/spinetoolbox/plotting.py b/spinetoolbox/plotting.py
index aeb4369a2..1c5f3cd90 100644
--- a/spinetoolbox/plotting.py
+++ b/spinetoolbox/plotting.py
@@ -105,8 +105,8 @@ def convert_indexed_value_to_tree(value):
         else:
             try:
                 x = float(x)
-            except TypeError:
-                raise ValueError("cannot plot null values")
+            except TypeError as error:
+                raise ValueError("cannot plot null values") from error
         d.content[index] = x
     return d
 
@@ -177,7 +177,7 @@ def raise_if_incompatible_x(data_list):
     if not data.x:
         return
     first_type = type(data.x[0])
-    if any(type(x) is not first_type for data in data_list for x in data.x):
+    if any(not isinstance(x, first_type) for data in data_list for x in data.x):
         raise PlottingError("Incompatible x axes.")
 
 
@@ -226,7 +226,7 @@ def combine_data_with_same_indexes(data_list):
             continue
         combined_xy = []
         for i in list_is:
-            combined_xy += [(x, y) for x, y in zip(data_list[i].x, data_list[i].y)]
+            combined_xy += list(zip(data_list[i].x, data_list[i].y))
         combined_xy.sort(key=itemgetter(0))
         x, y = zip(*combined_xy)
         model_data = data_list[list_is[0]]
@@ -318,7 +318,7 @@ def _plot_single_y_axis(data_list, y_label, axes, plot_type):
     """
     if plot_type == PlotType.STACKED_LINE:
         return _plot_stacked_line(data_list, y_label, axes)
-    elif plot_type == PlotType.BAR:
+    if plot_type == PlotType.BAR:
         return _plot_bar(data_list, y_label, axes)
     legend_handles = []
     plot = _make_plot_function(plot_type, type(data_list[0].x[0]), axes)
@@ -364,7 +364,7 @@ def _plot_bar(data_list, y_label, axes):
         list: legend handles
     """
     legend_handles = []
-    plot_kwargs = dict(axes=axes, **_BASE_SETTINGS)
+    plot_kwargs = {"axes": axes, **_BASE_SETTINGS}
     data_list, bar_width, x_ticks = _group_bars(data_list)
     if bar_width is not None:
         plot_kwargs["width"] = bar_width
@@ -712,7 +712,7 @@ def plot_db_mngr_items(items, db_maps, plot_widget=None):
         try:
             leaf_content = _convert_to_leaf(value)
         except PlottingError as error:
-            raise PlottingError(f"Failed to plot value in {db_map.codename}: {error}")
+            raise PlottingError(f"Failed to plot value in {db_map.codename}: {error}") from error
         db_name = db_map.codename
         parameter_name = item["parameter_definition_name"]
         entity_byname = item["entity_byname"]
@@ -826,15 +826,13 @@ def _convert_to_leaf(y):
     try:
         if isinstance(y, IndexedValue):
             return convert_indexed_value_to_tree(y)
-        else:
-            return float(y)
+        return float(y)
     except ValueError as error:
-        raise PlottingError(str(error))
-    except TypeError:
+        raise PlottingError(str(error)) from error
+    except TypeError as error:
         if isinstance(y, DateTime):
             return y.value
-        else:
-            raise PlottingError(f"couldn't convert {type(y).__name__} to float.")
+        raise PlottingError(f"couldn't convert {type(y).__name__} to float.") from error
 
 
 @contextmanager
diff --git a/spinetoolbox/plugin_manager.py b/spinetoolbox/plugin_manager.py
index a8c1f949c..f0e41bb04 100644
--- a/spinetoolbox/plugin_manager.py
+++ b/spinetoolbox/plugin_manager.py
@@ -37,7 +37,7 @@ def _download_file(remote, local):
     try:
         urllib.request.urlretrieve(remote, local)
     except urllib.error.HTTPError as e:
-        raise PluginWorkFailed(f"Failed to download {remote}: {str(e)}")
+        raise PluginWorkFailed(f"Failed to download {remote}: {str(e)}") from e
 
 
 def _download_plugin(plugin, plugin_local_dir):
@@ -166,8 +166,8 @@ def _load_registry(self):
         try:
             with urllib.request.urlopen(PLUGIN_REGISTRY_URL) as url:
                 registry = json.loads(url.read().decode())
-        except urllib.error.URLError:
-            raise PluginWorkFailed("Failed to load plugin registry. Are you connected to a network?")
+        except urllib.error.URLError as error:
+            raise PluginWorkFailed("Failed to load plugin registry. Are you connected to a network?") from error
         self._registry_plugins = {plugin_dict["name"]: plugin_dict for plugin_dict in registry["plugins"]}
 
     @Slot(bool)
diff --git a/spinetoolbox/project.py b/spinetoolbox/project.py
index a06fbcbf3..268bf0f27 100644
--- a/spinetoolbox/project.py
+++ b/spinetoolbox/project.py
@@ -123,10 +123,10 @@ def __init__(self, toolbox, p_dir, plugin_specs, app_settings, settings, logger)
         _, name = os.path.split(p_dir)
         super().__init__(name, "")
         self._toolbox = toolbox
-        self._project_items = dict()
+        self._project_items = {}
         self._specifications = dict(enumerate(plugin_specs))
-        self._connections = list()
-        self._jumps = list()
+        self._connections = []
+        self._jumps = []
         self._logger = logger
         self._app_settings = app_settings
         self._settings = settings
@@ -251,11 +251,11 @@ def save(self):
         }
         items_dict = {name: item.item_dict() for name, item in self._project_items.items()}
         local_items_data = self._pop_local_data_from_items_dict(items_dict)
-        saved_dict = dict(project=project_dict, items=items_dict)
+        saved_dict = {"project": project_dict, "items": items_dict}
         with open(self.config_file, "w") as fp:
             self._dump(saved_dict, fp)
         with (local_path / PROJECT_LOCAL_DATA_FILENAME).open("w") as fp:
-            self._dump(dict(items=local_items_data), fp)
+            self._dump({"items": local_items_data}, fp)
 
     def _save_all_specifications(self, local_path):
         """Writes all specifications except plugins to disk.
@@ -268,7 +268,7 @@ def _save_all_specifications(self, local_path):
         Returns:
             dict: specification local data that is supposed to be stored in a project specific place
         """
-        serialized_spec_paths = dict()
+        serialized_spec_paths = {}
         specifications_local_data = {}
         for spec in self._specifications.values():
             if spec.plugin is not None:
@@ -297,7 +297,7 @@ def _pop_local_data_from_items_dict(self, items_dict):
         Returns:
             dict: local project item data
         """
-        local_data_dict = dict()
+        local_data_dict = {}
         for name, item_dict in items_dict.items():
             local_entries = self._project_items[name].item_dict_local_entries()
             if not local_entries:
@@ -761,7 +761,7 @@ def add_connection(self, *args, silent=False, notify_resource_changes=True):
         if not self._is_dag_valid(dag):
             self.remove_connection(connection)
             msg = "This connection creates a cycle into the DAG.\n\nWould you like to add a Loop connection?"
-            title = f"Add Loop?"
+            title = "Add Loop?"
             message_box = QMessageBox(
                 QMessageBox.Icon.Question,
                 title,
@@ -910,7 +910,7 @@ def jump_issues(self, jump):
         Returns:
             list of str: list of issues, if any
         """
-        issues = list()
+        issues = []
         dag = self.dag_with_node(jump.source)
         if not dag.has_node(jump.destination):
             issues.append("Loop cannot span over separate DAGs.")
@@ -1030,13 +1030,16 @@ def _execute_dags(self, dags, execution_permits_list):
             return
         settings = make_settings_dict_for_engine(self._app_settings)
         darker_fg_color = QColor(FG_COLOR).darker().name()
-        darker = lambda x: f'<span style="color: {darker_fg_color}">{x}</span>'
+
+        def darker(x):
+            return f'<span style="color: {darker_fg_color}">{x}</span>'
+
         for k, (dag, execution_permits) in enumerate(zip(dags, execution_permits_list)):
             dag_identifier = f"{k + 1}/{len(dags)}"
             worker = self.create_engine_worker(dag, execution_permits, dag_identifier, settings, job_id)
             if worker is None:
                 continue
-            self._logger.msg.emit("<b>Starting DAG {0}</b>".format(dag_identifier))
+            self._logger.msg.emit(f"<b>Starting DAG {dag_identifier}</b>")
             item_names = (darker(name) if not execution_permits[name] else name for name in nx.topological_sort(dag))
             self._logger.msg.emit(darker(" -> ").join(item_names))
             worker.finished.connect(lambda worker=worker: self._handle_engine_worker_finished(worker))
@@ -1073,11 +1076,11 @@ def create_engine_worker(self, dag, execution_permits, dag_identifier, settings,
         for project_item in items.values():
             spec = project_item.specification()
             if spec is not None:
-                specs_by_type.setdefault(project_item.item_type(), list()).append(spec)
+                specs_by_type.setdefault(project_item.item_type(), []).append(spec)
         for jump in jumps.values():
             if jump.condition["type"] == "tool-specification":
                 spec = self.get_specification(jump.condition["specification"])
-                specs_by_type.setdefault("Tool", list()).append(spec)
+                specs_by_type.setdefault("Tool", []).append(spec)
         specification_dicts = {
             type_: [{**spec.to_dict(), "definition_file_path": spec.definition_file_path} for spec in specs]
             for type_, specs in specs_by_type.items()
@@ -1131,12 +1134,12 @@ def execute_selected(self, names):
         if not names:
             self._logger.msg_warning.emit("Please select a project item and try again.")
             return
-        dags = list()
+        dags = []
         for dag in [dag for dag in self._dag_iterator() if set(names) & dag.nodes]:
             more_dags = self._split_to_subdags(dag, names)
             dags += more_dags
         valid_dags = self._validate_dags(dags)
-        execution_permit_list = list()
+        execution_permit_list = []
         for dag in valid_dags:
             execution_permits = {name: name in names for name in dag.nodes}
             execution_permit_list.append(execution_permits)
@@ -1157,7 +1160,7 @@ def _split_to_subdags(self, dag, selected_items):
         if len(dag.nodes) == 1:
             return [dag]
         # Get selected items that are in current dag
-        selected_items_in_this_dag = list()
+        selected_items_in_this_dag = []
         for selected_item in list(selected_items):
             if selected_item in list(dag.nodes()):
                 selected_items_in_this_dag.append(selected_item)
@@ -1175,7 +1178,7 @@ def execute_project(self):
             self._logger.msg_warning.emit("Project has no items to execute")
             return
         dags = self._validate_dags(self._dag_iterator())
-        execution_permit_list = list()
+        execution_permit_list = []
         for dag in dags:
             execution_permit_list.append({item_name: True for item_name in dag.nodes})
         self.execute_dags(dags, execution_permit_list, "Executing All Directed Acyclic Graphs")
@@ -1420,7 +1423,7 @@ def _incoming_connections_and_jumps(self, name):
         return self.incoming_connections(name) + self._incoming_jumps(name)
 
     def _update_successor(self, successor, incoming_connections, resource_cache):
-        combined_resources = list()
+        combined_resources = []
         for conn in incoming_connections:
             item_name = conn.source
             predecessor = self._project_items[item_name]
@@ -1433,7 +1436,7 @@ def _update_successor(self, successor, incoming_connections, resource_cache):
         successor.upstream_resources_updated(combined_resources)
 
     def _update_predecessor(self, predecessor, outgoing_connections, resource_cache):
-        combined_resources = list()
+        combined_resources = []
         for conn in outgoing_connections:
             item_name = conn.destination
             successor = self._project_items[item_name]
@@ -1473,13 +1476,12 @@ def prepare_remote_execution(self):
         host, port, sec_model, sec_folder = self._toolbox.engine_server_settings()
         if not host:
             self._logger.msg_error.emit(
-                "Spine Engine Server <b>host address</b> missing. "
-                "Please enter host in <b>File->Settings->Engine</b>."
+                "Spine Engine Server <b>host address</b> missing. Please enter host in <b>File->Settings->Engine</b>."
             )
             return ""
-        elif not port:
+        if not port:
             self._logger.msg_error.emit(
-                "Spine Engine Server <b>port</b> missing. " "Please select port in <b>File->Settings->Engine</b>."
+                "Spine Engine Server <b>port</b> missing. Please select port in <b>File->Settings->Engine</b>."
             )
             return ""
         self._logger.msg.emit(f"Connecting to Spine Engine Server at <b>{host}:{port}</b>")
@@ -1569,20 +1571,20 @@ def node_successors(g):
     return {n: list(g.successors(n)) for n in nx.topological_sort(g)}
 
 
-def _ranks(node_successors):
+def _ranks(node_successors_):
     """Calculates node ranks.
 
     Args:
-        node_successors (dict): a mapping from successor name to a list of predecessor names
+        node_successors_ (dict): a mapping from successor name to a list of predecessor names
 
     Returns:
         dict: a mapping from node name to rank
     """
-    node_predecessors = dict()
-    for predecessor, successors in node_successors.items():
-        node_predecessors.setdefault(predecessor, list())
+    node_predecessors = {}
+    for predecessor, successors in node_successors_.items():
+        node_predecessors.setdefault(predecessor, [])
         for successor in successors:
-            node_predecessors.setdefault(successor, list()).append(predecessor)
+            node_predecessors.setdefault(successor, []).append(predecessor)
     ranking = []
     while node_predecessors:
         same_ranks = [node for node, predecessor in node_predecessors.items() if not predecessor]
diff --git a/spinetoolbox/project_item/project_item.py b/spinetoolbox/project_item/project_item.py
index 940b060db..0d1c87f11 100644
--- a/spinetoolbox/project_item/project_item.py
+++ b/spinetoolbox/project_item/project_item.py
@@ -46,9 +46,9 @@ def __init__(self, name, description, x, y, project):
         self._logger = project.toolbox()
         self._properties_ui = None
         self._icon = None
-        self._sigs = dict()
+        self._sigs = {}
         self._active = False
-        self._actions = list()
+        self._actions = []
         # Make project directory for this Item
         self.data_dir = os.path.join(self._project.items_dir, self.short_name)
         self._specification = None
@@ -83,13 +83,12 @@ def project(self):
     def logger(self):
         return self._logger
 
-    # pylint: disable=no-self-use
     def make_signal_handler_dict(self):
         """Returns a dictionary of all shared signals and their handlers.
         This is to enable simpler connecting and disconnecting.
         Must be implemented in subclasses.
         """
-        return dict()
+        return {}
 
     def activate(self):
         """Restore selections and connect signals."""
@@ -224,7 +223,6 @@ def handle_execution_successful(self, execution_direction, engine_state):
             engine_state: engine state after item's execution
         """
 
-    # pylint: disable=no-self-use
     def resources_for_direct_successors(self):
         """
         Returns resources for direct successors.
@@ -235,7 +233,7 @@ def resources_for_direct_successors(self):
         Returns:
             list: a list of ProjectItemResources
         """
-        return list()
+        return []
 
     def resources_for_direct_predecessors(self):
         """
@@ -247,7 +245,7 @@ def resources_for_direct_predecessors(self):
         Returns:
             list: a list of ProjectItemResources
         """
-        return list()
+        return []
 
     def _resources_to_predecessors_changed(self):
         """Notifies direct predecessors that item's resources have changed."""
diff --git a/spinetoolbox/project_item_icon.py b/spinetoolbox/project_item_icon.py
index 37d378e13..f14280a49 100644
--- a/spinetoolbox/project_item_icon.py
+++ b/spinetoolbox/project_item_icon.py
@@ -73,11 +73,11 @@ def __init__(self, toolbox, icon_file, icon_color):
         self.spec_item = None  # For displaying Tool Spec icon
         self.spec_item_renderer = None
         # Make connector buttons
-        self.connectors = dict(
-            bottom=ConnectorButton(toolbox, self, position="bottom"),
-            left=ConnectorButton(toolbox, self, position="left"),
-            right=ConnectorButton(toolbox, self, position="right"),
-        )
+        self.connectors = {
+            "bottom": ConnectorButton(toolbox, self, position="bottom"),
+            "left": ConnectorButton(toolbox, self, position="left"),
+            "right": ConnectorButton(toolbox, self, position="right"),
+        }
         self._setup()
         shadow_effect = QGraphicsDropShadowEffect()
         shadow_effect.setOffset(1)
@@ -166,7 +166,7 @@ def _setup(self):
         # Load SVG
         loading_ok = self.renderer.load(self.icon_file)
         if not loading_ok:
-            self._toolbox.msg_error.emit("Loading SVG icon from resource:{0} failed".format(self.icon_file))
+            self._toolbox.msg_error.emit(f"Loading SVG icon from resource:{self.icon_file} failed")
             return
         size = self.renderer.defaultSize()
         self.svg_item.setSharedRenderer(self.renderer)
@@ -459,7 +459,7 @@ def __init__(self, toolbox, parent, position="left"):
         self._parent = parent
         self._toolbox = toolbox
         self.position = position
-        self.links = list()
+        self.links = []
         self.setBrush(self.brush)
         parent_rect = parent.rect()
         extent = 0.2 * parent_rect.width()
@@ -658,7 +658,7 @@ def __init__(self, parent):
         """
         super().__init__(parent)
         self._parent = parent
-        self._notifications = list()
+        self._notifications = []
         font = QFont("Font Awesome 5 Free Solid")
         font.setPixelSize(self.FONT_SIZE_PIXELS)
         self.setFont(font)
diff --git a/spinetoolbox/project_upgrader.py b/spinetoolbox/project_upgrader.py
index e862afcef..956fa7086 100644
--- a/spinetoolbox/project_upgrader.py
+++ b/spinetoolbox/project_upgrader.py
@@ -141,16 +141,16 @@ def upgrade_v1_to_v2(old, factories):
         Returns:
             dict: Version 2 project dictionary
         """
-        new = dict()
+        new = {}
         new["version"] = 2
         new["name"] = old["project"]["name"]
         new["description"] = old["project"]["description"]
-        new["specifications"] = dict()
+        new["specifications"] = {}
         new["specifications"]["Tool"] = old["project"]["tool_specifications"]
         new["connections"] = old["project"]["connections"]
         # Change 'objects' to 'items' and remove all 'short name' entries
         # Also stores item_dict under their name and not under category
-        items = dict()
+        items = {}
         for category in old["objects"].keys():
             for item_name in old["objects"][category].keys():
                 old["objects"][category][item_name].pop("short name", "")  # Remove 'short name'
@@ -165,7 +165,7 @@ def upgrade_v1_to_v2(old, factories):
                     item_type = "GdxExporter"
                 v2_item_dict = factories[item_type].item_class().upgrade_v1_to_v2(item_name, v1_item_dict)
                 items[item_name] = v2_item_dict  # Store items using their name as key
-        return dict(project=new, items=items)
+        return {"project": new, "items": items}
 
     def upgrade_v2_to_v3(self, old, project_dir, factories):
         """Upgrades version 2 project dictionary to version 3.
@@ -219,7 +219,7 @@ def upgrade_v2_to_v3(self, old, project_dir, factories):
                 mappings = old_item_dict.get("mappings")
                 # Sanitize old mappings, as we used to do in Importer.from_dict
                 if mappings is None:
-                    mappings = list()
+                    mappings = []
                 # Convert table_types and table_row_types keys to int since json always has strings as keys.
                 for _, mapping in mappings:
                     table_types = mapping.get("table_types", {})
@@ -237,7 +237,7 @@ def upgrade_v2_to_v3(self, old, project_dir, factories):
                 # Make item specs from sanitized mappings
                 for k, (label, mapping) in enumerate(mappings):
                     spec_name = self.make_unique_importer_specification_name(item_name, label, k)
-                    spec = dict(name=spec_name, item_type="Importer", mapping=mapping)
+                    spec = {"name": spec_name, "item_type": "Importer", "mapping": mapping}
                     spec_path = os.path.join(project_dir, spec_name + ".json")
                     # FIXME: Let's try and handle write errors here...
                     with open(spec_path, "w") as fp:
@@ -349,8 +349,8 @@ def upgrade_v5_to_v6(old, project_dir):
         """
 
         def fix_file_selection(item_dict):
-            old_selection = item_dict.get("file_selection", list())
-            new_selection = list()
+            old_selection = item_dict.get("file_selection", [])
+            new_selection = []
             for path, selected in old_selection:
                 deserialized = deserialize_path(path, project_dir)
                 if deserialized.startswith("{") and deserialized.endswith("}"):
@@ -360,8 +360,8 @@ def fix_file_selection(item_dict):
             item_dict["file_selection"] = new_selection
 
         def fix_cmd_line_args(item_dict):
-            old_args = item_dict.get("cmd_line_args", list())
-            new_args = list()
+            old_args = item_dict.get("cmd_line_args", [])
+            new_args = []
             for arg in old_args:
                 deserialized = deserialize_path(arg, project_dir)
                 if deserialized.startswith("{") and deserialized.endswith("}"):
@@ -379,7 +379,7 @@ def fix_cmd_line_args(item_dict):
             fix_file_selection(import_dict)
         gimlet_dicts = [item_dict for item_dict in new["items"].values() if item_dict["type"] == "Gimlet"]
         for gimlet_dict in gimlet_dicts:
-            gimlet_dict["file_selection"] = gimlet_dict.pop("selections", list())
+            gimlet_dict["file_selection"] = gimlet_dict.pop("selections", [])
             fix_file_selection(gimlet_dict)
             fix_cmd_line_args(gimlet_dict)
         tool_dicts = [item_dict for item_dict in new["items"].values() if item_dict["type"] == "Tool"]
@@ -503,13 +503,13 @@ def upgrade_v9_to_v10(old):
         """
         new = copy.deepcopy(old)
         new["project"]["version"] = 10
-        names_to_remove = list()  # Gimlet and GdxExporter item names
+        names_to_remove = []  # Gimlet and GdxExporter item names
         # Get Gimlet and GdxExporter names and remove connections
         for name, item_dict in new["items"].items():
             if item_dict["type"] in ["Gimlet", "GdxExporter"]:
                 names_to_remove.append(name)
         # Get list of connections to remove
-        connections_to_remove = list()
+        connections_to_remove = []
         for conn in new["project"]["connections"]:
             for name_to_remove in names_to_remove:
                 if name_to_remove in conn["from"] or name_to_remove in conn["to"]:
@@ -601,8 +601,8 @@ def get_project_directory(self):
         # Check if the selected directory is already a project directory and ask if overwrite is ok
         if os.path.isdir(os.path.join(answer, ".spinetoolbox")):
             msg = (
-                "Directory \n\n{0}\n\nalready contains a Spine Toolbox project."
-                "\n\nWould you like to overwrite it?".format(answer)
+                f"Directory \n\n{answer}\n\nalready contains a Spine Toolbox project."
+                f"\n\nWould you like to overwrite it?"
             )
             message_box = QMessageBox(
                 QMessageBox.Icon.Question,
@@ -666,7 +666,7 @@ def is_valid_v1(self, p):
             return False
         for req_key in required_project_keys:
             if req_key not in project:
-                self._toolbox.msg_error.emit("Invalid project.json file. Key {0} not found.".format(req_key))
+                self._toolbox.msg_error.emit(f"Invalid project.json file. Key {req_key} not found.")
                 return False
         # Check types in project dict
         if not project["version"] == 1:
@@ -713,11 +713,11 @@ def is_valid_v2_to_v8(self, p, v):
             return False
         for req_key in required_project_keys:
             if req_key not in project:
-                self._toolbox.msg_error.emit("Invalid project.json file. Key {0} not found.".format(req_key))
+                self._toolbox.msg_error.emit(f"Invalid project.json file. Key {req_key} not found.")
                 return False
         # Check types in project dict
         if not project["version"] == v:
-            self._toolbox.msg_error.emit("Invalid project version:'{0}'".format(project["version"]))
+            self._toolbox.msg_error.emit(f"Invalid project version:'{project['version']}'")
             return False
         if not isinstance(project["name"], str) or not isinstance(project["description"], str):
             self._toolbox.msg_error.emit("Invalid project.json file. 'name' and 'description' must be strings.")
@@ -759,7 +759,7 @@ def is_valid_v9_to_v10(self, p):
             return False
         for req_key in required_project_keys:
             if req_key not in project:
-                self._toolbox.msg_error.emit("Invalid project.json file. Key {0} not found.".format(req_key))
+                self._toolbox.msg_error.emit(f"Invalid project.json file. Key {req_key} not found.")
                 return False
         return True
 
diff --git a/spinetoolbox/server/engine_client.py b/spinetoolbox/server/engine_client.py
index a51d16fdf..4835dcefd 100644
--- a/spinetoolbox/server/engine_client.py
+++ b/spinetoolbox/server/engine_client.py
@@ -55,7 +55,6 @@ def __init__(self, host, port, sec_model, sec_folder, ping=True):
             # prepare folders
             base_dir = sec_folder
             secret_keys_dir = os.path.join(base_dir, "private_keys")
-            keys_dir = os.path.join(base_dir, "certificates")
             public_keys_dir = os.path.join(base_dir, "public_keys")
             # We need two certificates, one for the client and one for
             # the server. The client must know the server's public key
@@ -120,16 +119,13 @@ def _check_connectivity(self, timeout):
         event = self.dealer_socket.poll(timeout=timeout)
         if event == 0:
             raise RemoteEngineInitFailed("Timeout expired. Pinging the server failed.")
-        else:
-            msg = self.dealer_socket.recv_multipart()
-            response = ServerMessage.parse(msg[1])
-            response_id = int(response.getId())  # Check that request ID matches the response ID
-            if not response_id == random_id:
-                raise RemoteEngineInitFailed(
-                    f"Ping failed. Request Id '{random_id}' does not " f"match reply Id '{response_id}'"
-                )
-            stop_time_ms = round(time.time() * 1000.0)  # debugging
-        return
+        msg = self.dealer_socket.recv_multipart()
+        response = ServerMessage.parse(msg[1])
+        response_id = int(response.getId())  # Check that request ID matches the response ID
+        if not response_id == random_id:
+            raise RemoteEngineInitFailed(
+                f"Ping failed. Request Id '{random_id}' does not " f"match reply Id '{response_id}'"
+            )
 
     def set_start_time(self):
         """Sets a start time for an operation. Call get_elapsed_time() after
@@ -208,7 +204,7 @@ def download_files(self, q):
                 if i > 0:
                     q.put(("server_status_msg", {"msg_type": "neutral", "text": f"Downloaded {i} files"}))
                 break
-            elif rcv[0] == b"incoming_file":
+            if rcv[0] == b"incoming_file":
                 q.put(
                     ("server_status_msg", {"msg_type": "warning", "text": "Downloading file " + rcv[1].decode("utf-8")})
                 )
@@ -334,7 +330,7 @@ def send_request_to_persistent_generator(self, data):
                 break
             yield json.loads(rcv[0].decode("utf-8"))
         pull_socket.close()
-        completed_msg = self.dealer_socket.recv_multipart()  # Get the final 'completed' msg
+        _ = self.dealer_socket.recv_multipart()  # Get the final 'completed' msg
 
     def get_elapsed_time(self):
         """Returns the elapsed time between now and when self.start_time was set.
@@ -345,12 +341,11 @@ def get_elapsed_time(self):
         t = round(time.time() * 1000.0) - self.start_time  # ms
         if t <= 1000:
             return str(t) + " ms"
-        elif 1000 < t < 60000:  # 1 < t < 60 s
+        if 1000 < t < 60000:  # 1 < t < 60 s
             return str(t / 1000) + " s"
-        else:
-            m = (t / 1000) / 60
-            s = (t / 1000) % 60
-            return str(m) + " min " + str(s) + " s"
+        m = (t / 1000) / 60
+        s = (t / 1000) % 60
+        return str(m) + " min " + str(s) + " s"
 
     def close(self):
         """Closes client sockets, context and thread."""
diff --git a/spinetoolbox/spine_db_editor/graphics_items.py b/spinetoolbox/spine_db_editor/graphics_items.py
index 8dae0d96c..a37da029f 100644
--- a/spinetoolbox/spine_db_editor/graphics_items.py
+++ b/spinetoolbox/spine_db_editor/graphics_items.py
@@ -186,7 +186,7 @@ def db_map_id(self, db_map):
     def db_items(self, db_map):
         for db_map_, id_ in self.db_map_ids:
             if db_map_ == db_map:
-                yield dict(class_id=self.entity_class_id(db_map), id=id_)
+                yield {"class_id": self.entity_class_id(db_map), "id": id_}
 
     def boundingRect(self):
         return super().boundingRect() | self.childrenBoundingRect()
@@ -367,11 +367,11 @@ def default_parameter_data(self):
         """Return data to put as default in a parameter table when this item is selected."""
         if not self.db_map_ids:
             return {}
-        return dict(
-            entity_class_name=self.entity_class_name,
-            entity_byname=DB_ITEM_SEPARATOR.join(self.byname),
-            database=self.first_db_map.codename,
-        )
+        return {
+            "entity_class_name": self.entity_class_name,
+            "entity_byname": DB_ITEM_SEPARATOR.join(self.byname),
+            "database": self.first_db_map.codename,
+        }
 
     def shape(self):
         """Returns a shape containing the entire bounding rect, to work better with icon transparency."""
diff --git a/spinetoolbox/spine_db_editor/mvcmodels/empty_models.py b/spinetoolbox/spine_db_editor/mvcmodels/empty_models.py
index d61497af7..02504dbc3 100644
--- a/spinetoolbox/spine_db_editor/mvcmodels/empty_models.py
+++ b/spinetoolbox/spine_db_editor/mvcmodels/empty_models.py
@@ -98,10 +98,10 @@ def can_be_filtered(self):
     def accepted_rows(self):
         return range(self.rowCount())
 
-    def db_item(self, _index):  # pylint: disable=no-self-use
+    def db_item(self, _index):
         return None
 
-    def item_id(self, _row):  # pylint: disable=no-self-use
+    def item_id(self, _row):
         return None
 
     def handle_items_added(self, db_map_data):
@@ -374,5 +374,5 @@ def setData(self, index, value, role=Qt.ItemDataRole.EditRole):
                 return False
             role = Qt.ItemDataRole.EditRole
         else:
-            self._entity_name_user_defined = True if value else False
+            self._entity_name_user_defined = bool(value)
         return super().setData(index, value, role)
diff --git a/spinetoolbox/spine_db_editor/mvcmodels/entity_tree_item.py b/spinetoolbox/spine_db_editor/mvcmodels/entity_tree_item.py
index f4d16a8c2..9886a48cf 100644
--- a/spinetoolbox/spine_db_editor/mvcmodels/entity_tree_item.py
+++ b/spinetoolbox/spine_db_editor/mvcmodels/entity_tree_item.py
@@ -116,7 +116,7 @@ def _children_sort_key(self):
 
     def default_parameter_data(self):
         """Return data to put as default in a parameter table when this item is selected."""
-        return dict(entity_class_name=self.name, database=self.first_db_map.codename)
+        return {"entity_class_name": self.name, "database": self.first_db_map.codename}
 
     @property
     def display_data(self):
@@ -262,11 +262,11 @@ def default_parameter_data(self):
         item = self.db_map_data(self.first_db_map)
         if not item:
             return {"database": self.first_db_map.codename}
-        return dict(
-            entity_class_name=item["entity_class_name"],
-            entity_byname=DB_ITEM_SEPARATOR.join(item["entity_byname"]),
-            database=self.first_db_map.codename,
-        )
+        return {
+            "entity_class_name": item["entity_class_name"],
+            "entity_byname": DB_ITEM_SEPARATOR.join(item["entity_byname"]),
+            "database": self.first_db_map.codename,
+        }
 
     def is_valid(self):
         """See base class.
diff --git a/spinetoolbox/spine_db_editor/mvcmodels/frozen_table_model.py b/spinetoolbox/spine_db_editor/mvcmodels/frozen_table_model.py
index 092d93d8d..f439ae0e5 100644
--- a/spinetoolbox/spine_db_editor/mvcmodels/frozen_table_model.py
+++ b/spinetoolbox/spine_db_editor/mvcmodels/frozen_table_model.py
@@ -233,6 +233,7 @@ def _keep_sorted(self, update_selected_row=True):
         if len(self._data) < 3:
             return
         frozen_value = self.get_frozen_value() if self._selected_row is not None else None
+        # pylint: disable=unsubscriptable-object
         self.layoutAboutToBeChanged["QList<QPersistentModelIndex>", "QAbstractItemModel::LayoutChangeHint"].emit(
             [], QAbstractTableModel.LayoutChangeHint.VerticalSortHint
         )
@@ -253,6 +254,7 @@ def _keep_sorted(self, update_selected_row=True):
             elif frozen_value != self.get_frozen_value():
                 # The row did not change but the frozen value did.
                 selected_row_changed = True
+        # pylint: disable=unsubscriptable-object
         self.layoutChanged["QList<QPersistentModelIndex>", "QAbstractItemModel::LayoutChangeHint"].emit(
             [], QAbstractTableModel.LayoutChangeHint.VerticalSortHint
         )
diff --git a/spinetoolbox/spine_db_editor/mvcmodels/multi_db_tree_item.py b/spinetoolbox/spine_db_editor/mvcmodels/multi_db_tree_item.py
index 8931ccf56..5c8a329be 100644
--- a/spinetoolbox/spine_db_editor/mvcmodels/multi_db_tree_item.py
+++ b/spinetoolbox/spine_db_editor/mvcmodels/multi_db_tree_item.py
@@ -185,7 +185,7 @@ def deep_take_db_map(self, db_map):
         id_ = self.take_db_map(db_map)
         if id_ is None:
             return None
-        other = self.parent_item.make_or_restore_child({db_map: id_})
+        other = self.parent_item.make_or_restore_child(db_map, id_)
         other_children = []
         for child in self.children:
             other_child = child.deep_take_db_map(db_map)
@@ -236,7 +236,7 @@ def make_or_restore_child(self, db_map, id_, **kwargs):
 
         Args:
             db_map (DatabaseMapping)
-            id (int)
+            id_ (int)
 
         Returns:
             MultiDBTreemItem
@@ -376,7 +376,7 @@ def update_children_by_id(self, db_map_ids, **kwargs):
         """
         # Find rows to update and db_map ids to add
         rows_to_update = set()
-        db_map_ids_to_add = dict()
+        db_map_ids_to_add = {}
         for db_map, ids in db_map_ids.items():
             for id_ in ids:
                 row = self.find_row(db_map, id_)
diff --git a/spinetoolbox/spine_db_editor/mvcmodels/parameter_value_list_item.py b/spinetoolbox/spine_db_editor/mvcmodels/parameter_value_list_item.py
index 926eb41af..2e7af66b5 100644
--- a/spinetoolbox/spine_db_editor/mvcmodels/parameter_value_list_item.py
+++ b/spinetoolbox/spine_db_editor/mvcmodels/parameter_value_list_item.py
@@ -66,7 +66,6 @@ def _do_set_up(self):
             return
         super()._do_set_up()
 
-    # pylint: disable=no-self-use
     def empty_child(self):
         return ValueItem(self._model)
 
@@ -86,7 +85,7 @@ def data(self, column, role=Qt.ItemDataRole.DisplayRole):
         return super().data(column, role)
 
     def _make_item_to_add(self, value):
-        return dict(name=value)
+        return {"name": value}
 
     def add_item_to_db(self, db_item):
         self.db_mngr.add_parameter_value_lists({self.db_map: [db_item]})
@@ -114,11 +113,11 @@ def list_index(self):
     def _make_item_to_add(self, value):
         db_value, db_type = value
         index = 0 if self.child_number() == 0 else self.parent_item.child(self.child_number() - 1).list_index() + 1
-        return dict(value=db_value, type=db_type, parameter_value_list_id=self.parent_item.id, index=index)
+        return {"value": db_value, "type": db_type, "parameter_value_list_id": self.parent_item.id, "index": index}
 
     def _make_item_to_update(self, _column, value):
         db_value, db_type = value
-        return dict(id=self.id, value=db_value, type=db_type)
+        return {"id": self.id, "value": db_value, "type": db_type}
 
     def add_item_to_db(self, db_item):
         self.db_mngr.add_list_values({self.db_map: [db_item]})
diff --git a/spinetoolbox/spine_db_editor/mvcmodels/pivot_table_models.py b/spinetoolbox/spine_db_editor/mvcmodels/pivot_table_models.py
index 9164d9170..5802ceb67 100644
--- a/spinetoolbox/spine_db_editor/mvcmodels/pivot_table_models.py
+++ b/spinetoolbox/spine_db_editor/mvcmodels/pivot_table_models.py
@@ -195,18 +195,18 @@ def header_type(self):
     def name(self):
         return "index"
 
-    def header_data(self, header_id, role=Qt.ItemDataRole.DisplayRole):  # pylint: disable=no-self-use
+    def header_data(self, header_id, role=Qt.ItemDataRole.DisplayRole):
         """See base class."""
         _, index = header_id
         if role == PARSED_ROLE:
             return index
         return str(index)
 
-    def update_data(self, db_map_data):  # pylint: disable=no-self-use
+    def update_data(self, db_map_data):
         """See base class."""
         return False
 
-    def add_data(self, names, db_map):  # pylint: disable=no-self-use
+    def add_data(self, names, db_map):
         """See base class."""
         return False
 
@@ -222,7 +222,7 @@ def header_type(self):
     def name(self):
         return "alternative"
 
-    def header_data(self, header_id, role=Qt.ItemDataRole.DisplayRole):  # pylint: disable=no-self-use
+    def header_data(self, header_id, role=Qt.ItemDataRole.DisplayRole):
         """See base class."""
         return self._get_header_data_from_db("alternative", header_id, "name", role)
 
@@ -253,7 +253,7 @@ def header_type(self):
     def name(self):
         return "scenario"
 
-    def header_data(self, header_id, role=Qt.ItemDataRole.DisplayRole):  # pylint: disable=no-self-use
+    def header_data(self, header_id, role=Qt.ItemDataRole.DisplayRole):
         """See base class."""
         return self._get_header_data_from_db("scenario", header_id, "name", role)
 
@@ -288,7 +288,7 @@ def header_type(self):
     def name(self):
         return "database"
 
-    def header_data(self, header_id, role=Qt.ItemDataRole.DisplayRole):  # pylint: disable=no-self-use
+    def header_data(self, header_id, role=Qt.ItemDataRole.DisplayRole):
         """See base class."""
         return header_id.codename
 
@@ -703,7 +703,7 @@ def index_in_data(self, index):
             and self.headerColumnCount() <= index.column() < self.columnCount() - self.emptyColumnCount()
         )
 
-    def column_is_index_column(self, column):  # pylint: disable=no-self-use
+    def column_is_index_column(self, column):
         """Returns True if column is the column containing expanded parameter_value indexes."""
         return False
 
@@ -797,7 +797,7 @@ def _color_data(self, index):
                 return FIXED_FIELD_COLOR
         return None
 
-    def _text_alignment_data(self, index):  # pylint: disable=no-self-use
+    def _text_alignment_data(self, index):
         return None
 
     def _header_data(self, index):
@@ -917,7 +917,7 @@ def _batch_set_header_data(self, header_data):
             header_id = self._header_id(index)
             if isinstance(header_id, tuple):
                 top_left_id = self.top_left_id(index)
-                item = dict(id=header_id[1], name=value)
+                item = {"id": header_id[1], "name": value}
                 data_by_top_left_id[top_left_id][header_id[0]].append(item)
         success = False
         for id_, data in data_by_top_left_id.items():
@@ -1281,14 +1281,14 @@ def _entity_parameter_value_to_add(self, db_map, header_ids, value_and_type, ent
             header_ids[0] if ent_id_lookup is None else ent_id_lookup[db_map, tuple(id_ for id_ in header_ids[:-2])]
         )
         value, value_type = split_value_and_type(value_and_type)
-        return dict(
-            entity_class_id=self._parent.current_class_id[db_map],
-            entity_id=entity_id,
-            parameter_definition_id=header_ids[-2],
-            value=value,
-            type=value_type,
-            alternative_id=header_ids[-1],
-        )
+        return {
+            "entity_class_id": self._parent.current_class_id[db_map],
+            "entity_id": entity_id,
+            "parameter_definition_id": header_ids[-2],
+            "value": value,
+            "type": value_type,
+            "alternative_id": header_ids[-1],
+        }
 
     def _make_parameter_value_to_add(self):
         if not self._parent.first_current_entity_class["dimension_id_list"]:
@@ -1693,7 +1693,11 @@ def _batch_set_entity_data(self, row_map, column_map, data, values):
         def entity_to_add(db_map, header_ids):
             element_names = [self.db_mngr.get_item(db_map, "entity", id_)["name"] for id_ in header_ids]
             name = name_from_elements(element_names)
-            return dict(element_id_list=list(header_ids), class_id=self._parent.current_class_id.get(db_map), name=name)
+            return {
+                "element_id_list": list(header_ids),
+                "class_id": self._parent.current_class_id.get(db_map),
+                "name": name,
+            }
 
         to_add = {}
         to_remove = {}
diff --git a/spinetoolbox/spine_db_editor/mvcmodels/single_and_empty_model_mixins.py b/spinetoolbox/spine_db_editor/mvcmodels/single_and_empty_model_mixins.py
index b033e0516..488ce2601 100644
--- a/spinetoolbox/spine_db_editor/mvcmodels/single_and_empty_model_mixins.py
+++ b/spinetoolbox/spine_db_editor/mvcmodels/single_and_empty_model_mixins.py
@@ -18,7 +18,6 @@
 class ConvertToDBMixin:
     """Base class for all mixins that convert model items (name-based) into database items (id-based)."""
 
-    # pylint: disable=no-self-use
     def _convert_to_db(self, item):
         """Returns a db item (id-based) from the given model item (name-based).
 
diff --git a/spinetoolbox/spine_db_editor/mvcmodels/single_models.py b/spinetoolbox/spine_db_editor/mvcmodels/single_models.py
index 6d4ffc726..a1df522cf 100644
--- a/spinetoolbox/spine_db_editor/mvcmodels/single_models.py
+++ b/spinetoolbox/spine_db_editor/mvcmodels/single_models.py
@@ -239,7 +239,7 @@ def split_value(value, column):
         row_data = {}
         for index, value in zip(indexes, data):
             row_data.setdefault(index.row(), {})[self.header[index.column()]] = split_value(value, index.column())
-        items = [dict(id=self._main_data[row], **data) for row, data in row_data.items()]
+        items = [{"id": self._main_data[row], **data} for row, data in row_data.items()]
         self.update_items_in_db(items)
         return True
 
diff --git a/spinetoolbox/spine_db_editor/mvcmodels/tree_item_utility.py b/spinetoolbox/spine_db_editor/mvcmodels/tree_item_utility.py
index 2f6e292d3..cb05c4eba 100644
--- a/spinetoolbox/spine_db_editor/mvcmodels/tree_item_utility.py
+++ b/spinetoolbox/spine_db_editor/mvcmodels/tree_item_utility.py
@@ -317,7 +317,7 @@ def set_data(self, column, value, role=Qt.ItemDataRole.EditRole):
         return True
 
     def _make_item_to_add(self, value):
-        return dict(name=value, description=self.item_data["description"])
+        return {"name": value, "description": self.item_data["description"]}
 
     def _make_item_to_update(self, column, value):
         field = self.header_data(column)
diff --git a/spinetoolbox/spine_db_editor/widgets/add_items_dialogs.py b/spinetoolbox/spine_db_editor/widgets/add_items_dialogs.py
index 2ae9cf169..a7764234b 100644
--- a/spinetoolbox/spine_db_editor/widgets/add_items_dialogs.py
+++ b/spinetoolbox/spine_db_editor/widgets/add_items_dialogs.py
@@ -67,7 +67,7 @@ def __init__(self, parent, entity_class, entities, db_mngr, *db_maps, commit_dat
         self.entities = entities
         self.db_maps = db_maps
         self.table_view.horizontalHeader().setMinimumSectionSize(0)
-        self.setWindowTitle("Add '{0}' entities".format(self.entity_class["name"]))
+        self.setWindowTitle(f"Add '{self.entity_class['name']}' entities")
         self.populate_table_view()
         self.connect_signals()
 
@@ -251,7 +251,7 @@ def _handle_spin_box_value_changed(self, i):
     def insert_column(self):
         column = self.number_of_dimensions
         self.number_of_dimensions += 1
-        column_name = "dimension name ({0})".format(self.number_of_dimensions)
+        column_name = f"dimension name ({self.number_of_dimensions})"
         self.model.insertColumns(column, 1)
         self.model.insert_horizontal_header_labels(column, [column_name])
         self.table_view.resizeColumnToContents(column)
@@ -283,7 +283,7 @@ def _handle_model_data_changed(self, top_left, bottom_right, roles):
     @Slot()
     def accept(self):
         """Collect info from dialog and try to add items."""
-        db_map_data = dict()
+        db_map_data = {}
         header_labels = self.model.horizontal_header_labels()
         name_column = header_labels.index("entity class name")
         description_column = header_labels.index("description")
@@ -294,7 +294,7 @@ def accept(self):
             row_data = self.model.row_data(i)
             entity_class_name = row_data[name_column]
             if not entity_class_name:
-                self.parent().msg_error.emit("Entity class missing at row {}".format(i + 1))
+                self.parent().msg_error.emit(f"Entity class missing at row {i + 1}")
                 return
             description = row_data[description_column]
             display_icon = row_data[display_icon_column]
@@ -312,16 +312,16 @@ def accept(self):
                 db_names = ""
             for db_name in db_names.split(","):
                 if db_name not in self.keyed_db_maps:
-                    self.parent().msg_error.emit("Invalid database {0} at row {1}".format(db_name, i + 1))
+                    self.parent().msg_error.emit(f"Invalid database {db_name} at row {i + 1}")
                     return
                 db_map = self.keyed_db_maps[db_name]
                 entity_classes = self.db_map_ent_cls_lookup_by_name[db_map]
-                dimension_id_list = list()
+                dimension_id_list = []
                 for column in range(name_column):  # Leave 'name' column outside
                     dimension_name = row_data[column]
                     if dimension_name not in entity_classes:
                         self.parent().msg_error.emit(
-                            "Invalid dimension '{}' for db '{}' at row {}".format(dimension_name, db_name, i + 1)
+                            f"Invalid dimension '{dimension_name}' for db '{db_name}' at row {i + 1}"
                         )
                         return
                     dimension_id = entity_classes[dimension_name]["id"]
diff --git a/spinetoolbox/spine_db_editor/widgets/commit_viewer.py b/spinetoolbox/spine_db_editor/widgets/commit_viewer.py
index e1ce5973a..94510aecc 100644
--- a/spinetoolbox/spine_db_editor/widgets/commit_viewer.py
+++ b/spinetoolbox/spine_db_editor/widgets/commit_viewer.py
@@ -157,7 +157,7 @@ def _all_affected_items_fetched(self, item_type):
         Args:
             item_type (str): item type
         """
-        label = self._affected_item_widgets[item_type].label.setVisible(False)
+        self._affected_item_widgets[item_type].label.setVisible(False)
 
     @Slot()
     def _finish_work(self):
diff --git a/spinetoolbox/spine_db_editor/widgets/custom_editors.py b/spinetoolbox/spine_db_editor/widgets/custom_editors.py
index 5e68804cc..2c62e9476 100644
--- a/spinetoolbox/spine_db_editor/widgets/custom_editors.py
+++ b/spinetoolbox/spine_db_editor/widgets/custom_editors.py
@@ -384,7 +384,6 @@ def toggle_selected(self, index):
         item = self._model.itemFromIndex(index).text()
         qitem = self._items[item]
         if item not in self._selected:
-            rank = len(self._selected)
             qitem.setCheckState(Qt.CheckState.Checked)
             self._selected.append(item)
         else:
diff --git a/spinetoolbox/spine_db_editor/widgets/custom_menus.py b/spinetoolbox/spine_db_editor/widgets/custom_menus.py
index e940a1b70..68e24c210 100644
--- a/spinetoolbox/spine_db_editor/widgets/custom_menus.py
+++ b/spinetoolbox/spine_db_editor/widgets/custom_menus.py
@@ -11,9 +11,9 @@
 ######################################################################################################################
 
 """Classes for custom context menus and pop-up menus."""
-from PySide6.QtCore import QEvent, QPoint, Qt, Signal, Slot
-from PySide6.QtGui import QAction, QIcon, QKeyEvent, QKeySequence
-from PySide6.QtWidgets import QMenu, QWidget
+from PySide6.QtCore import QPoint, Qt, Signal, Slot
+from PySide6.QtGui import QAction, QIcon
+from PySide6.QtWidgets import QMenu
 from spinedb_api import IndexedValue
 from spinedb_api.db_mapping_base import PublicItem
 from ...fetch_parent import FlexibleFetchParent
@@ -22,29 +22,6 @@
 from ...widgets.custom_menus import FilterMenuBase
 
 
-class MainMenu(QMenu):
-    def event(self, ev):
-        """Intercepts shortcuts and instead sends an equivalent event with the 'Alt' modifier,
-        so that mnemonics works with just the key.
-        Also sends a key press event with the 'Alt' key when this menu shows,
-        so that mnemonics are underlined on Windows.
-        """
-        if ev.type() == QEvent.KeyPress and ev.key() == Qt.Key_Alt:
-            return True
-        if ev.type() == QEvent.ShortcutOverride and ev.modifiers() == Qt.NoModifier:
-            actions = self.actions() + [a for child in self.findChildren(QWidget) for a in child.actions()]
-            mnemonics = [QKeySequence.mnemonic(a.text()) for a in actions]
-            key_seq = QKeySequence(Qt.Modifier.ALT.value | Qt.Key(ev.key()))
-            if key_seq in mnemonics:
-                ev = QKeyEvent(QEvent.KeyPress, ev.key(), Qt.AltModifier)
-                qApp.postEvent(self, ev)  # pylint: disable=undefined-variable
-                return True
-        if ev.type() == QEvent.Show:
-            pev = QKeyEvent(QEvent.KeyPress, Qt.Key_Alt, Qt.NoModifier)
-            qApp.postEvent(self, pev)  # pylint: disable=undefined-variable
-        return super().event(ev)
-
-
 class AutoFilterMenu(FilterMenuBase):
     filterChanged = Signal(str, object)
 
diff --git a/spinetoolbox/spine_db_editor/widgets/custom_qgraphicsviews.py b/spinetoolbox/spine_db_editor/widgets/custom_qgraphicsviews.py
index 8aa4bf4f5..66d781512 100644
--- a/spinetoolbox/spine_db_editor/widgets/custom_qgraphicsviews.py
+++ b/spinetoolbox/spine_db_editor/widgets/custom_qgraphicsviews.py
@@ -131,7 +131,7 @@ def __init__(self, parent=None):
             "<p>Whether to build the graph when the tree selections change (Ctrl+F5).</p>"
         )
         self._auto_rebuild_shortcut = QShortcut(QKeySequence(Qt.Modifier.CTRL | Qt.Key.Key_F5), self)
-        self._auto_rebuild_shortcut.activated.connect(lambda: self._auto_build_button.toggle())
+        self._auto_rebuild_shortcut.activated.connect(self._auto_build_button.toggle)
         self._rebuild_button = QPushButton("Rebuild (F5)")
         layout.addWidget(self._auto_build_button)
         layout.addWidget(self._rebuild_button)
@@ -149,6 +149,7 @@ def _connect_button_signals(self):
             lambda x: self.parent()._properties.get("auto_build").set_value(x, save=True)
         )
         self._auto_build_button.toggled.connect(lambda x: self.parent()._spine_db_editor.build_graph() if x else None)
+        # pylint: disable=unnecessary-lambda
         self.parent()._properties.get("auto_build")._action.triggered.connect(
             lambda x: self._auto_build_button.setChecked(x)
         )
diff --git a/spinetoolbox/spine_db_editor/widgets/custom_qtableview.py b/spinetoolbox/spine_db_editor/widgets/custom_qtableview.py
index 3cf7519ff..0d919dd5d 100644
--- a/spinetoolbox/spine_db_editor/widgets/custom_qtableview.py
+++ b/spinetoolbox/spine_db_editor/widgets/custom_qtableview.py
@@ -548,8 +548,8 @@ def __init__(self, view, db_editor):
                 view (PivotTableView): parent view
                 db_editor (SpineDBEditor): database editor
             """
-            self._selected_parameter_indexes = list()
-            self._selected_value_indexes = list()
+            self._selected_parameter_indexes = []
+            self._selected_value_indexes = []
             self._open_in_editor_action = None
             self._remove_values_action = None
             self._remove_parameters_action = None
@@ -710,8 +710,8 @@ def __init__(self, view, db_editor):
                 view (PivotTableView): parent view
                 db_editor (SpineDBEditor): database editor
             """
-            self._selected_scenario_indexes = list()
-            self._selected_scenario_alternative_indexes = list()
+            self._selected_scenario_indexes = []
+            self._selected_scenario_alternative_indexes = []
             self._generate_scenarios_action = None
             self._toggle_alternatives_checked = QAction("Check/uncheck selected")
             self._toggle_alternatives_checked.triggered.connect(self._toggle_checked_state)
@@ -780,7 +780,7 @@ def _open_scenario_generator(self):
             source_model = self._view.source_model
             db_mngr = self._db_editor.db_mngr
             chosen_db_map = None
-            alternatives = list()
+            alternatives = []
             for index in self._selected_alternative_indexes:
                 header_id = source_model._header_id(index)
                 db_map, id_ = header_id
diff --git a/spinetoolbox/spine_db_editor/widgets/custom_qtreeview.py b/spinetoolbox/spine_db_editor/widgets/custom_qtreeview.py
index 7a09a8d55..538fd6819 100644
--- a/spinetoolbox/spine_db_editor/widgets/custom_qtreeview.py
+++ b/spinetoolbox/spine_db_editor/widgets/custom_qtreeview.py
@@ -419,7 +419,7 @@ def __init__(self, parent):
             parent (QWidget): parent widget
         """
         super().__init__(parent=parent)
-        self._selected_alternative_ids = dict()
+        self._selected_alternative_ids = {}
         self._generate_scenarios_action = None
 
     @property
@@ -506,7 +506,7 @@ def _open_scenario_generator(self):
         if not isinstance(item, AlternativeItem):
             return
         included_ids = set()
-        alternatives = list()
+        alternatives = []
         db_map = item.db_map
         for id_ in self._selected_alternative_ids.get(db_map, ()):
             if id_ not in included_ids:
@@ -582,7 +582,7 @@ def __init__(self, parent):
             parent (QWidget): parent widget
         """
         super().__init__(parent=parent)
-        self._selected_scenario_ids = dict()
+        self._selected_scenario_ids = {}
         self._duplicate_scenario_action = None
 
     def reset(self):
diff --git a/spinetoolbox/spine_db_editor/widgets/custom_qwidgets.py b/spinetoolbox/spine_db_editor/widgets/custom_qwidgets.py
index ce4d78e6d..4358c8b6e 100644
--- a/spinetoolbox/spine_db_editor/widgets/custom_qwidgets.py
+++ b/spinetoolbox/spine_db_editor/widgets/custom_qwidgets.py
@@ -357,6 +357,7 @@ def _paint_volume_bar(painter, cell):
         path.moveTo(cell.bottomLeft())
         path.lineTo(cell.topRight())
         path.lineTo(cell.bottomRight())
+        # pylint: disable=undefined-variable
         painter.fillPath(path, qApp.palette().color(QPalette.Normal, QPalette.WindowText))
 
     def paintEvent(self, ev):
@@ -496,8 +497,8 @@ def _create_text(self):
 
     def _create_entity_names(self, entities):
         entity_names = {}
-        for db_map, entities in entities.items():
-            for entity in entities:
+        for db_map, entities_ in entities.items():
+            for entity in entities_:
                 entity_names.setdefault(db_map, {}).setdefault(entity["entity_class_name"], []).append(
                     str(entity["entity_byname"])
                 )
diff --git a/spinetoolbox/spine_db_editor/widgets/edit_or_remove_items_dialogs.py b/spinetoolbox/spine_db_editor/widgets/edit_or_remove_items_dialogs.py
index 14686dc6f..4bd3ffde6 100644
--- a/spinetoolbox/spine_db_editor/widgets/edit_or_remove_items_dialogs.py
+++ b/spinetoolbox/spine_db_editor/widgets/edit_or_remove_items_dialogs.py
@@ -29,7 +29,7 @@
 class EditOrRemoveItemsDialog(ManageItemsDialog):
     def __init__(self, parent, db_mngr):
         super().__init__(parent, db_mngr)
-        self.items = list()
+        self.items = []
 
     def all_databases(self, row):
         """Returns a list of db names available for a given row.
@@ -60,9 +60,9 @@ def __init__(self, parent, db_mngr, selected):
         self.model.set_horizontal_header_labels(
             ["entity class name", "description", "display icon", "active by default", "databases"]
         )
-        self.orig_data = list()
+        self.orig_data = []
         self.default_display_icon = default_icon_id()
-        model_data = list()
+        model_data = []
         for item in selected:
             data = item.db_map_data(item.first_db_map)
             row_data = [item.name, data["description"], data["display_icon"], data["active_by_default"]]
@@ -82,7 +82,7 @@ def connect_signals(self):
     @Slot()
     def accept(self):
         """Collect info from dialog and try to update items."""
-        db_map_data = dict()
+        db_map_data = {}
         for i in range(self.model.rowCount()):
             name, description, display_icon, active_by_default, db_names = self.model.row_data(i)
             if db_names is None:
@@ -92,11 +92,11 @@ def accept(self):
             for database in db_names.split(","):
                 db_map = next((db_map for db_map in item.db_maps if db_map.codename == database), None)
                 if db_map is None:
-                    self.parent().msg_error.emit("Invalid database {0} at row {1}".format(database, i + 1))
+                    self.parent().msg_error.emit(f"Invalid database {database} at row {i + 1}")
                     return
                 db_maps.append(db_map)
             if not name:
-                self.parent().msg_error.emit("Entity class name missing at row {}".format(i + 1))
+                self.parent().msg_error.emit(f"Entity class name missing at row {i + 1}")
                 return
             orig_row = self.orig_data[i]
             if [name, description] == orig_row:
@@ -156,7 +156,7 @@ def __init__(self, parent, db_mngr, selected, class_key):
     @Slot()
     def accept(self):
         """Collect info from dialog and try to update items."""
-        db_map_data = dict()
+        db_map_data = {}
         name_column = self.model.horizontal_header_labels().index("entity name")
         db_column = self.model.horizontal_header_labels().index("databases")
         for i in range(self.model.rowCount()):
@@ -165,7 +165,7 @@ def accept(self):
             element_name_list = [row_data[column] for column in range(name_column)]
             name = row_data[name_column]
             if not name:
-                self.parent().msg_error.emit("Entity name missing at row {}".format(i + 1))
+                self.parent().msg_error.emit(f"Entity name missing at row {i + 1}")
                 return
             orig_row = self.orig_data[i]
             if [*element_name_list, name] == orig_row:
@@ -177,7 +177,7 @@ def accept(self):
             for database in db_names.split(","):
                 db_map = next((db_map for db_map in item.db_maps if db_map.codename == database), None)
                 if db_map is None:
-                    self.parent().msg_error.emit("Invalid database {0} at row {1}".format(database, i + 1))
+                    self.parent().msg_error.emit(f"Invalid database {database} at row {i + 1}")
                     return
                 db_maps.append(db_map)
             pre_db_item = {"name": name}
@@ -194,7 +194,7 @@ def accept(self):
                 dimension_id_list = ent_cls["dimension_id_list"]
                 entities = self.db_map_ent_lookup[db_map]
                 # Find element_id_list
-                element_id_list = list()
+                element_id_list = []
                 for dimension_id, element_name in zip(dimension_id_list, element_name_list):
                     if (dimension_id, element_name) not in entities:
                         self.parent().msg_error.emit(
@@ -230,7 +230,7 @@ def __init__(self, parent, db_mngr, selected):
         self.table_view.setItemDelegate(RemoveEntitiesDelegate(self))
         self.connect_signals()
         self.model.set_horizontal_header_labels(["type", "name", "databases"])
-        model_data = list()
+        model_data = []
         for item_type, items in selected.items():
             for item in items:
                 row_data = [item_type, item.name, item.display_database]
@@ -241,7 +241,7 @@ def __init__(self, parent, db_mngr, selected):
     @Slot()
     def accept(self):
         """Collect info from dialog and try to remove items."""
-        db_map_typed_data = dict()
+        db_map_typed_data = {}
         for i in range(self.model.rowCount()):
             item_type, _, db_names = self.model.row_data(i)
             if db_names is None:
@@ -251,7 +251,7 @@ def accept(self):
             for database in db_names.split(","):
                 db_map = next((db_map for db_map in item.db_maps if db_map.codename == database), None)
                 if db_map is None:
-                    self.parent().msg_error.emit("Invalid database {0} at row {1}".format(database, i + 1))
+                    self.parent().msg_error.emit(f"Invalid database {database} at row {i + 1}")
                     return
                 db_maps.append(db_map)
             for db_map in db_maps:
diff --git a/spinetoolbox/spine_db_editor/widgets/multi_spine_db_editor.py b/spinetoolbox/spine_db_editor/widgets/multi_spine_db_editor.py
index d68958aae..c2feec59e 100644
--- a/spinetoolbox/spine_db_editor/widgets/multi_spine_db_editor.py
+++ b/spinetoolbox/spine_db_editor/widgets/multi_spine_db_editor.py
@@ -169,7 +169,7 @@ def show_user_guide(self, checked=False):
         """Opens Spine db editor documentation page in browser."""
         doc_url = f"{ONLINE_DOCUMENTATION_URL}/spine_db_editor/index.html"
         if not open_url(doc_url):
-            self.msg_error.emit("Unable to open url <b>{0}</b>".format(doc_url))
+            self.msg_error.emit(f"Unable to open url <b>{doc_url}</b>")
 
 
 class _CustomStatusBar(QStatusBar):
diff --git a/spinetoolbox/spine_db_editor/widgets/scenario_generator.py b/spinetoolbox/spine_db_editor/widgets/scenario_generator.py
index 281f4c5b6..ce40d298d 100644
--- a/spinetoolbox/spine_db_editor/widgets/scenario_generator.py
+++ b/spinetoolbox/spine_db_editor/widgets/scenario_generator.py
@@ -121,7 +121,7 @@ def _generate_scenarios(self, new_scenarios, scenarios_to_modify, scenario_alter
                 self._db_editor.db_mngr.add_scenarios({self._db_map: [{"name": name} for name in new_scenarios]})
                 waiter.wait()
         searchable_scenario_names = set(scenarios_to_modify)
-        scenario_definitions_by_id = dict()
+        scenario_definitions_by_id = {}
         alternative_iter = iter(scenario_alternatives)
         scenario_items = self._db_editor.db_mngr.get_items(self._db_map, "scenario")
         for item in scenario_items:
@@ -230,8 +230,7 @@ def _find_base_alternative(names):
         base_index = [n.lower() for n in names].index("base")
     except ValueError:
         return names[0] if names else ""
-    else:
-        return names[base_index]
+    return names[base_index]
 
 
 def _suffix(item_count):
diff --git a/spinetoolbox/spine_db_editor/widgets/spine_db_editor.py b/spinetoolbox/spine_db_editor/widgets/spine_db_editor.py
index 52da7a0a6..bbe5150c3 100644
--- a/spinetoolbox/spine_db_editor/widgets/spine_db_editor.py
+++ b/spinetoolbox/spine_db_editor/widgets/spine_db_editor.py
@@ -98,7 +98,7 @@ def __init__(self, db_mngr):
         self.err_msg.setWindowTitle("Error")
         self.err_msg.setWindowFlag(Qt.WindowType.WindowContextHelpButtonHint, False)
         self.silenced = False
-        max_screen_height = max([s.availableSize().height() for s in QGuiApplication.screens()])
+        max_screen_height = max(s.availableSize().height() for s in QGuiApplication.screens())
         self.visible_rows = int(max_screen_height / preferred_row_height(self))
         self.settings_group = "spineDBEditor"
         self.undo_action = None
@@ -112,6 +112,7 @@ def __init__(self, db_mngr):
         self._export_items_dialog = None
         self._export_items_dialog_state = None
         self.update_commit_enabled()
+        self.last_view = None
 
     @property
     def toolbox(self):
@@ -185,7 +186,7 @@ def load_db_urls(self, db_url_codenames, create=False, update_history=True, wind
         self.update_last_view()
         self.restore_ui(self.last_view, fresh=True)
         self.update_commit_enabled()
-        db_column_visible = True if len(self.db_maps) > 1 else False
+        db_column_visible = len(self.db_maps) > 1
         self.set_db_column_visibility(db_column_visible)
         return True
 
@@ -391,7 +392,7 @@ def import_file(self, checked=False):
 
         It supports SQLite, JSON, and Excel."""
         self.qsettings.beginGroup(self.settings_group)
-        file_path, selected_filter = get_open_file_name_in_last_dir(
+        file_path, _ = get_open_file_name_in_last_dir(
             self.qsettings,
             "importFileIntoDB",
             self,
@@ -921,7 +922,6 @@ def __init__(self, db_mngr, db_url_codenames=None):
         self._timer_refresh_tab_order.setSingleShot(True)
         self._add_docks_menu()
         self.connect_signals()
-        self.last_view = None
         self.apply_stacked_style()
         self.set_db_column_visibility(False)
         if db_url_codenames is not None:
diff --git a/spinetoolbox/spine_db_editor/widgets/stacked_view_mixin.py b/spinetoolbox/spine_db_editor/widgets/stacked_view_mixin.py
index 9bfa275cb..9197dd936 100644
--- a/spinetoolbox/spine_db_editor/widgets/stacked_view_mixin.py
+++ b/spinetoolbox/spine_db_editor/widgets/stacked_view_mixin.py
@@ -102,7 +102,7 @@ def _set_default_parameter_data(self, index=None):
         """
         if index is None or not index.isValid():
             default_db_map = next(iter(self.db_maps))
-            default_data = dict(database=default_db_map.codename)
+            default_data = {"database": default_db_map.codename}
         else:
             item = index.model().item_from_index(index)
             default_db_map = item.first_db_map
@@ -157,7 +157,7 @@ def get_all_alternatives(self):
         """Combines alternative ids from Scenario and Alternative tree selections."""
         all_alternatives = self._filter_alternative_ids.copy()
         for db_map, scenarios in self._filter_scenario_ids.get("scenario", {}).items():
-            for scenario, alternatives in scenarios.items():
+            for _, alternatives in scenarios.items():
                 all_alternatives.setdefault(db_map, set()).update(alternatives)
         for db_map, alternatives in self._filter_scenario_ids.get("scenario_alternative", {}).items():
             all_alternatives.setdefault(db_map, set()).update(alternatives)
diff --git a/spinetoolbox/spine_db_editor/widgets/tabular_view_header_widget.py b/spinetoolbox/spine_db_editor/widgets/tabular_view_header_widget.py
index e7aeceec8..47504b0ca 100644
--- a/spinetoolbox/spine_db_editor/widgets/tabular_view_header_widget.py
+++ b/spinetoolbox/spine_db_editor/widgets/tabular_view_header_widget.py
@@ -50,6 +50,7 @@ def __init__(self, identifier, area, menu=None, parent=None):
         layout.addWidget(label)
         layout.addWidget(button)
         layout.setContentsMargins(self._H_MARGIN, 0, self._H_MARGIN, 0)
+        h_alignment = None
         if area == "rows":
             h_alignment = Qt.AlignLeft
             layout.insertSpacing(1, self._SPACING)
diff --git a/spinetoolbox/spine_db_editor/widgets/tabular_view_mixin.py b/spinetoolbox/spine_db_editor/widgets/tabular_view_mixin.py
index b41d24dba..06ff27058 100644
--- a/spinetoolbox/spine_db_editor/widgets/tabular_view_mixin.py
+++ b/spinetoolbox/spine_db_editor/widgets/tabular_view_mixin.py
@@ -412,11 +412,7 @@ def create_filter_menu(self, identifier):
                 else:
                     item_type = header.header_type
                 if header.header_type == "entity":
-                    accepts_item = lambda item, db_map: (
-                        self.accepts_ith_element_item(header.rank, item, db_map)
-                        if self.first_current_entity_class["dimension_id_list"]
-                        else self.accepts_entity_item
-                    )
+                    accepts_item = self.accepts_item(header)
                 elif header.header_type == "parameter":
                     accepts_item = self.accepts_parameter_item
                 else:
@@ -618,6 +614,13 @@ def accepts_element_item(self, item, db_map):
     def accepts_ith_element_item(self, i, item, db_map):
         return item["class_id"] == self.current_dimension_id_list[i][db_map]
 
+    def accepts_item(self, header):
+        return lambda item, db_map: (
+            self.accepts_ith_element_item(header.rank, item, db_map)
+            if self.first_current_entity_class["dimension_id_list"]
+            else self.accepts_entity_item
+        )
+
     @contextmanager
     def _frozen_table_reload_disabled(self):
         self._disable_frozen_table_reload = True
diff --git a/spinetoolbox/spine_db_icon_manager.py b/spinetoolbox/spine_db_icon_manager.py
index e99cd3004..ab72cfb5d 100644
--- a/spinetoolbox/spine_db_icon_manager.py
+++ b/spinetoolbox/spine_db_icon_manager.py
@@ -171,7 +171,7 @@ def update_multi_classes(self, name, dimension_name_list, id_):
             if dimension_name_list in {x[1] for x in self._multi_class_renderers} and id_ in {
                 x[2] for x in self._multi_class_renderers
             }:  # In this case the class has been renamed and the renderer will be updated accordingly.
-                new_key = None
+                key, value, new_key = None, None, None
                 for key, value in self._multi_class_renderers.items():
                     if key[1] == dimension_name_list:
                         new_key = (
diff --git a/spinetoolbox/spine_db_manager.py b/spinetoolbox/spine_db_manager.py
index 665dd5329..2ed2c8db8 100644
--- a/spinetoolbox/spine_db_manager.py
+++ b/spinetoolbox/spine_db_manager.py
@@ -106,7 +106,7 @@ def __init__(self, settings, parent, synchronous=False):
         self.qsettings = settings
         self._db_maps = {}
         self._workers = {}
-        self.listeners = dict()
+        self.listeners = {}
         self.undo_stack = {}
         self.undo_action = {}
         self.redo_action = {}
@@ -114,7 +114,7 @@ def __init__(self, settings, parent, synchronous=False):
         self._connect_signals()
         self._cmd_id = 0
         self._synchronous = synchronous
-        self.data_stores = dict()
+        self.data_stores = {}
 
     def _connect_signals(self):
         self.error_msg.connect(self.receive_error_msg)
@@ -448,7 +448,7 @@ def unregister_listener(self, listener, *db_maps, dirty_db_maps=None, commit_dir
         Returns:
             failed_db_maps (list): All the db maps that failed to commit
         """
-        failed_db_maps = list()
+        failed_db_maps = []
         for db_map in db_maps:
             self.remove_db_map_listener(db_map, listener)
             try:
@@ -735,8 +735,7 @@ def get_item(db_map, item_type, id_):
         item = mapped_table.find_item_by_id(id_)
         if hasattr(item, "public_item"):
             return item.public_item
-        else:
-            return item
+        return item
 
     def get_field(self, db_map, item_type, id_, field):
         return self.get_item(db_map, item_type, id_).get(field)
@@ -808,13 +807,9 @@ def tool_tip_data_from_parsed(parsed_data):
         if isinstance(parsed_data, TimeSeriesFixedResolution):
             resolution = [relativedelta_to_duration(r) for r in parsed_data.resolution]
             resolution = ", ".join(resolution)
-            tool_tip_data = "Start: {}<br>resolution: [{}]<br>length: {}".format(
-                parsed_data.start, resolution, len(parsed_data)
-            )
+            tool_tip_data = f"Start: {parsed_data.start}<br>resolution: [{resolution}]<br>length: {len(parsed_data)}"
         elif isinstance(parsed_data, TimeSeriesVariableResolution):
-            tool_tip_data = "Start: {}<br>resolution: variable<br>length: {}".format(
-                parsed_data.indexes[0], len(parsed_data)
-            )
+            tool_tip_data = f"Start: {parsed_data.indexes[0]}<br>resolution: variable<br>length: {len(parsed_data)}"
         elif isinstance(parsed_data, ParameterValueFormatError):
             tool_tip_data = str(parsed_data)
         else:
@@ -1466,7 +1461,7 @@ def db_map_class_ids(db_map_data):
 
     def find_cascading_entity_classes(self, db_map_ids):
         """Finds and returns cascading entity classes for the given dimension ids."""
-        db_map_cascading_data = dict()
+        db_map_cascading_data = {}
         for db_map, dimension_ids in db_map_ids.items():
             for item in self.get_items(db_map, "entity_class"):
                 if set(item["dimension_id_list"]) & set(dimension_ids):
@@ -1475,7 +1470,7 @@ def find_cascading_entity_classes(self, db_map_ids):
 
     def find_cascading_entities(self, db_map_ids):
         """Finds and returns cascading entities for the given element ids."""
-        db_map_cascading_data = dict()
+        db_map_cascading_data = {}
         for db_map, element_ids in db_map_ids.items():
             for item in self.get_items(db_map, "entity"):
                 if set(item["element_id_list"]) & set(element_ids):
@@ -1484,7 +1479,7 @@ def find_cascading_entities(self, db_map_ids):
 
     def find_cascading_parameter_data(self, db_map_ids, item_type):
         """Finds and returns cascading parameter definitions or values for the given entity_class ids."""
-        db_map_cascading_data = dict()
+        db_map_cascading_data = {}
         for db_map, entity_class_ids in db_map_ids.items():
             for item in self.get_items(db_map, item_type):
                 if item["entity_class_id"] in entity_class_ids:
@@ -1493,7 +1488,7 @@ def find_cascading_parameter_data(self, db_map_ids, item_type):
 
     def find_cascading_parameter_values_by_entity(self, db_map_ids):
         """Finds and returns cascading parameter values for the given entity ids."""
-        db_map_cascading_data = dict()
+        db_map_cascading_data = {}
         for db_map, entity_ids in db_map_ids.items():
             for item in self.get_items(db_map, "parameter_value"):
                 if item["entity_id"] in entity_ids:
@@ -1502,7 +1497,7 @@ def find_cascading_parameter_values_by_entity(self, db_map_ids):
 
     def find_cascading_parameter_values_by_definition(self, db_map_ids):
         """Finds and returns cascading parameter values for the given parameter_definition ids."""
-        db_map_cascading_data = dict()
+        db_map_cascading_data = {}
         for db_map, param_def_ids in db_map_ids.items():
             for item in self.get_items(db_map, "parameter_value"):
                 if item["parameter_id"] in param_def_ids:
@@ -1511,7 +1506,7 @@ def find_cascading_parameter_values_by_definition(self, db_map_ids):
 
     def find_cascading_scenario_alternatives_by_scenario(self, db_map_ids):
         """Finds and returns cascading scenario alternatives for the given scenario ids."""
-        db_map_cascading_data = dict()
+        db_map_cascading_data = {}
         for db_map, ids in db_map_ids.items():
             for item in self.get_items(db_map, "scenario_alternative"):
                 if item["scenario_id"] in ids:
@@ -1520,7 +1515,7 @@ def find_cascading_scenario_alternatives_by_scenario(self, db_map_ids):
 
     def find_groups_by_entity(self, db_map_ids):
         """Finds and returns groups for the given entity ids."""
-        db_map_group_data = dict()
+        db_map_group_data = {}
         for db_map, entity_ids in db_map_ids.items():
             for item in self.get_items(db_map, "entity_group"):
                 if item["entity_id"] in entity_ids:
diff --git a/spinetoolbox/spine_db_worker.py b/spinetoolbox/spine_db_worker.py
index ba35f1985..1acd27eda 100644
--- a/spinetoolbox/spine_db_worker.py
+++ b/spinetoolbox/spine_db_worker.py
@@ -132,7 +132,7 @@ def fetch_more(self, parent):
             parent.set_busy(True)
             self._do_fetch_more(parent)
 
-    def _do_fetch_more(self, parent):
+    def _do_fetch_more(self, parent):  # pylint: disable=method-hidden
         item_type = parent.fetch_item_type
         if parent in self._parents_fetching.get(item_type, set()):
             return
@@ -151,7 +151,10 @@ def _do_fetch_more(self, parent):
             self._parents_fetching[item_type].add(parent)
             return
         self._parents_fetching[item_type] = {parent}
-        callback = lambda future: self._handle_query_advanced(item_type, future.result())
+
+        def callback(future):
+            self._handle_query_advanced(item_type, future.result())
+
         self._executor.submit(self._busy_db_map_fetch_more, item_type).add_done_callback(callback)
 
     @Slot(object)
diff --git a/spinetoolbox/spine_engine_manager.py b/spinetoolbox/spine_engine_manager.py
index 95a099c5d..9b118618c 100644
--- a/spinetoolbox/spine_engine_manager.py
+++ b/spinetoolbox/spine_engine_manager.py
@@ -14,7 +14,6 @@
 import json
 import queue
 import threading
-from spine_engine.exception import RemoteEngineInitFailed
 from spine_engine.server.util.event_data_converter import EventDataConverter
 from spinetoolbox.server.engine_client import ClientSecurityModel, EngineClient
 
@@ -236,12 +235,7 @@ def __init__(self, job_id=""):
 
     def make_engine_client(self, host, port, security, sec_folder, ping=True):
         """Creates a client for connecting to Spine Engine Server."""
-        try:
-            self.engine_client = EngineClient(host, port, security, sec_folder, ping)
-        except RemoteEngineInitFailed:
-            raise
-        except Exception:
-            raise
+        self.engine_client = EngineClient(host, port, security, sec_folder, ping)
 
     def run_engine(self, engine_data):
         """Makes an engine client for communicating with the engine server.
@@ -317,12 +311,11 @@ def _run(self):
                 self.q.put(("server_status_msg", {"msg_type": "success", "text": f"Execution time: {t}"}))
                 self.q.put(event)
                 break
-            elif event[0] == "server_execution_error":
+            if event[0] == "server_execution_error":
                 # spine engine raised an exception during execution
                 self.q.put(("server_status_msg", {"msg_type": "fail", "text": f"{event[0]: {event[1]}}"}))
                 break
-            else:
-                self.q.put(event)
+            self.q.put(event)
         self.engine_client.close()
 
     def answer_prompt(self, prompter_id, answer):
@@ -332,11 +325,9 @@ def answer_prompt(self, prompter_id, answer):
     def restart_kernel(self, connection_file):
         """See base class."""
         # TODO: This does not restart the kernel, only replaces the client. Do kernel_manager.restart_kernel() on server
-        pass
 
     def shutdown_kernel(self, connection_file):
         """See base class."""
-        pass
 
     def is_persistent_command_complete(self, persistent_key, command):
         return self.engine_client.send_is_complete(persistent_key, command)
diff --git a/spinetoolbox/spine_engine_worker.py b/spinetoolbox/spine_engine_worker.py
index c14054cee..850c4617b 100644
--- a/spinetoolbox/spine_engine_worker.py
+++ b/spinetoolbox/spine_engine_worker.py
@@ -336,7 +336,7 @@ def _handle_kernel_execution_msg(self, msg):
                 msg["filter_id"],
                 msg["kernel_name"],
                 msg["connection_file"],
-                msg.get("connection_file_dict", dict()),
+                msg.get("connection_file_dict", {}),
             )
         elif msg["type"] == "kernel_spec_not_found":
             msg_text = (
diff --git a/spinetoolbox/ui_main.py b/spinetoolbox/ui_main.py
index 86da06dfa..e0dd5d114 100644
--- a/spinetoolbox/ui_main.py
+++ b/spinetoolbox/ui_main.py
@@ -150,9 +150,9 @@ def __init__(self):
         self.setStyleSheet(MAINWINDOW_SS)
         # Class variables
         self.undo_stack = QUndoStack(self)
-        self._item_properties_uis = dict()
-        self.item_factories = dict()  # maps item types to `ProjectItemFactory` objects
-        self._item_specification_factories = dict()  # maps item types to `ProjectItemSpecificationFactory` objects
+        self._item_properties_uis = {}
+        self.item_factories = {}  # maps item types to `ProjectItemFactory` objects
+        self._item_specification_factories = {}  # maps item types to `ProjectItemSpecificationFactory` objects
         self._project = None
         self.specification_model = None
         self.filtered_spec_factory_models = {}
@@ -417,7 +417,7 @@ def update_window_title(self):
         if not self._project:
             self.setWindowTitle("Spine Toolbox")
             return
-        self.setWindowTitle("{0} [{1}][*] - Spine Toolbox".format(self._project.name, self._project.project_dir))
+        self.setWindowTitle(f"{self._project.name} [{self._project.project_dir}][*] - Spine Toolbox")
 
     @Slot()
     def init_project(self, project_dir):
@@ -435,9 +435,7 @@ def init_project(self, project_dir):
             + p
             + f"' href='{ONLINE_DOCUMENTATION_URL}/getting_started.html'>Getting Started</a>"
         )
-        welcome_msg = "Welcome to Spine Toolbox! If you need help, please read the {0} guide.".format(
-            getting_started_anchor
-        )
+        welcome_msg = f"Welcome to Spine Toolbox! If you need help, please read the {getting_started_anchor} guide."
         if not project_dir:
             open_previous_project = int(self._qsettings.value("appSettings/openPreviousProject", defaultValue="0"))
             if (
@@ -454,9 +452,7 @@ def init_project(self, project_dir):
             self.msg.emit(welcome_msg)
             return
         if not os.path.isdir(project_dir):
-            self.msg_error.emit(
-                "Cannot open previous project. Directory <b>{0}</b> may have been moved.".format(project_dir)
-            )
+            self.msg_error.emit(f"Cannot open previous project. Directory <b>{project_dir}</b> may have been moved.")
             self.remove_path_from_recent_projects(project_dir)
             return
         self.open_project(project_dir)
@@ -548,7 +544,7 @@ def open_project(self, load_dir=None):
                 if not recents:
                     start_dir = os.path.abspath(os.path.join(str(pathlib.Path.home())))
                 else:
-                    start_dir = str(recents).split("\n")[0]
+                    start_dir = str(recents).split("\n", maxsplit=1)[0]
                 load_dir = QFileDialog.getExistingDirectory(self, caption="Open Spine Toolbox Project", dir=start_dir)
                 if not load_dir:
                     return False  # Cancelled
@@ -741,7 +737,7 @@ def close_project(self, ask_confirmation=True, clear_event_log=True):
             save_at_exit = self._qsettings.value("appSettings/saveAtExit", defaultValue="prompt")
             if save_at_exit == "prompt" and not self._confirm_project_close():
                 return False
-            elif save_at_exit == "automatic" and not self.save_project():
+            if save_at_exit == "automatic" and not self.save_project():
                 return False
         if not self.undo_critical_commands():
             return False
@@ -892,8 +888,8 @@ def overwrite_check(self, project_dir):
         if not empty:
             if is_project_dir:
                 msg1 = (
-                    "Directory <b>{0}</b> already contains a Spine Toolbox project.<br/><br/>"
-                    "Would you like to overwrite the existing project?".format(project_dir)
+                    f"Directory <b>{project_dir}</b> already contains a Spine Toolbox project.<br/><br/>"
+                    f"Would you like to overwrite the existing project?"
                 )
                 box1 = QMessageBox(
                     QMessageBox.Icon.Question,
@@ -908,8 +904,8 @@ def overwrite_check(self, project_dir):
                     return False
             else:
                 msg2 = (
-                    "Directory <b>{0}</b> is not empty.<br/><br/>"
-                    "Would you like to make this directory into a Spine Toolbox project?".format(project_dir)
+                    f"Directory <b>{project_dir}</b> is not empty.<br/><br/>"
+                    f"Would you like to make this directory into a Spine Toolbox project?"
                 )
                 box2 = QMessageBox(
                     QMessageBox.Icon.Question,
@@ -954,9 +950,7 @@ def _set_active_project_item(self, active_project_item):
         if self.active_project_item:
             # Deactivate old active project item
             if not self.active_project_item.deactivate():
-                self.msg_error.emit(
-                    "Something went wrong in disconnecting {0} signals".format(self.active_project_item.name)
-                )
+                self.msg_error.emit(f"Something went wrong in disconnecting {self.active_project_item.name} signals")
             self._item_properties_uis[self.active_project_item.item_type()].unset_item()
         self.active_project_item = active_project_item
         if self.active_project_item:
@@ -1281,7 +1275,7 @@ def open_specification_file(self, index):
         # Check if file exists first. openUrl may return True if file doesn't exist
         if not os.path.isfile(file_path):
             logging.error("Failed to open editor for %s", file_path)
-            self.msg_error.emit("Specification file <b>{0}</b> not found.".format(file_path))
+            self.msg_error.emit(f"Specification file <b>{file_path}</b> not found.")
             return
         tool_specification_url = "file:///" + file_path
         # Open Tool specification file in editor
@@ -1289,9 +1283,9 @@ def open_specification_file(self, index):
         res = open_url(tool_specification_url)
         if not res:
             self.msg_error.emit(
-                "Unable to open specification file {0}. Make sure that <b>.json</b> "
-                "files are associated with a text editor. For example on Windows "
-                "10, go to Control Panel -> Default Programs to do this.".format(file_path)
+                f"Unable to open specification file {file_path}. Make sure that <b>.json</b> "
+                f"files are associated with a text editor. For example on Windows "
+                f"10, go to Control Panel -> Default Programs to do this."
             )
 
     @Slot(bool)
@@ -1607,7 +1601,6 @@ def show_about(self):
         form = AboutWidget(self)
         form.show()
 
-    # pylint: disable=no-self-use
     @Slot()
     def show_user_guide(self):
         """Opens Spine Toolbox documentation index page in browser."""
@@ -1615,7 +1608,6 @@ def show_user_guide(self):
         # noinspection PyTypeChecker, PyCallByClass, PyArgumentList
         open_url(index_url)
 
-    # pylint: disable=no-self-use
     @Slot()
     def show_getting_started_guide(self):
         """Opens Spine Toolbox Getting Started HTML page in browser."""
@@ -1644,9 +1636,10 @@ def retrieve_project(self):
                 "Please enter host in <b>File->Settings->Engine</b>."
             )
             return
-        elif not port:
+        if not port:
             self.msg_error.emit(
-                "Spine Engine Server <b>port</b> missing. " "Please select port in <b>File->Settings->Engine</b>."
+                "Spine Engine Server <b>port</b> missing. "
+                "Please select port in <b>File->Settings->Engine</b>."
             )
             return
         self.msg.emit(f"Connecting to Spine Engine Server at <b>{host}:{port}</b>")
@@ -1995,7 +1988,7 @@ def _serialize_selected_items(self):
              dict: a dict containing serialized version of selected project items
         """
         selected_project_items = self.ui.graphicsView.scene().selectedItems()
-        items_dict = dict()
+        items_dict = {}
         for item_icon in selected_project_items:
             if not isinstance(item_icon, ProjectItemIcon):
                 continue
@@ -2056,7 +2049,7 @@ def _deserialize_items(self, items_dict, duplicate_files=False):
         scene.clearSelection()
         shift_x, shift_y = self._deserialized_item_position_shifts(items_dict)
         scene_rect = scene.sceneRect()
-        final_items_dict = dict()
+        final_items_dict = {}
         for name, item_dict in items_dict.items():
             item_dict["duplicate_files"] = duplicate_files
             if name in self.project().all_item_names:
@@ -2356,7 +2349,7 @@ def _setup_jupyter_console(self, item, filter_id, kernel_name, connection_file,
         if not filter_id:
             self._item_consoles[item] = self._make_jupyter_console(item, kernel_name, connection_file)
         else:
-            d = self._filter_item_consoles.setdefault(item, dict())
+            d = self._filter_item_consoles.setdefault(item, {})
             d[filter_id] = self._make_jupyter_console(item, kernel_name, connection_file)
         self.override_console_and_execution_list()
 
@@ -2388,7 +2381,7 @@ def _setup_persistent_console(self, item, filter_id, key, language):
         if not filter_id:
             self._item_consoles[item] = self._make_persistent_console(item, key, language)
         else:
-            d = self._filter_item_consoles.setdefault(item, dict())
+            d = self._filter_item_consoles.setdefault(item, {})
             d[filter_id] = self._make_persistent_console(item, key, language)
         self.override_console_and_execution_list()
 
@@ -2461,7 +2454,7 @@ def _shutdown_engine_kernels(self):
         """Shuts down all persistent and Jupyter kernels managed by Spine Engine."""
         exec_remotely = self.qsettings().value("engineSettings/remoteExecutionEnabled", "false") == "true"
         engine_mngr = make_engine_manager(exec_remotely)
-        for key in self._persistent_consoles.keys():
+        for key in self._persistent_consoles:
             engine_mngr.kill_persistent(key)
         for connection_file in self._jupyter_consoles:
             engine_mngr.shutdown_kernel(connection_file)
diff --git a/spinetoolbox/widgets/about_widget.py b/spinetoolbox/widgets/about_widget.py
index af10dc748..d8a1165f6 100644
--- a/spinetoolbox/widgets/about_widget.py
+++ b/spinetoolbox/widgets/about_widget.py
@@ -43,17 +43,6 @@ def __init__(self, toolbox):
         self.setWindowFlags(Qt.WindowType.Popup)
         # Ensure this window gets garbage-collected when closed
         self.setAttribute(Qt.WA_DeleteOnClose)
-        full_version = (
-            str(spinetoolbox.__version_info__.major)
-            + "."
-            + str(spinetoolbox.__version_info__.minor)
-            + "."
-            + str(spinetoolbox.__version_info__.micro)
-            + "-"
-            + spinetoolbox.__version_info__.releaselevel
-            + "."
-            + str(spinetoolbox.__version_info__.serial)
-        )
         self.v_spinetoolbox = spinetoolbox.__version__
         self.v_spinedb_api = spinedb_api.__version__
         self.v_spine_engine = spine_engine.__version__
@@ -161,7 +150,6 @@ def mouseReleaseEvent(self, e):
             moved = self._mouseReleasePos - self._mousePressPos
             if moved.manhattanLength() > 3:
                 e.ignore()
-                return
 
     def mouseMoveEvent(self, e):
         """Moves the window when mouse button is pressed and mouse cursor is moved.
diff --git a/spinetoolbox/widgets/array_value_editor.py b/spinetoolbox/widgets/array_value_editor.py
index 215b86678..48cec0a17 100644
--- a/spinetoolbox/widgets/array_value_editor.py
+++ b/spinetoolbox/widgets/array_value_editor.py
@@ -27,7 +27,7 @@ def __init__(self, index, value_type, parent=None):
             index (QModelIndex): an index to a parameter_value in parent_model
             parent (QWidget, optional): a parent widget
         """
-        editors = dict()
+        editors = {}
         if value_type == ValueType.PLAIN_VALUE:
             editors[ValueType.PLAIN_VALUE] = PlainParameterValueEditor()
         elif value_type == ValueType.DATETIME:
diff --git a/spinetoolbox/widgets/commit_dialog.py b/spinetoolbox/widgets/commit_dialog.py
index 1707b6194..2b17cf45d 100644
--- a/spinetoolbox/widgets/commit_dialog.py
+++ b/spinetoolbox/widgets/commit_dialog.py
@@ -28,7 +28,7 @@ def __init__(self, parent, *db_names):
         super().__init__(parent)
         self.setWindowFlag(Qt.WindowType.WindowContextHelpButtonHint, False)
         self.setWindowModality(Qt.ApplicationModal)
-        self.setWindowTitle("Commit changes to {}".format(",".join(db_names)))
+        self.setWindowTitle(f"Commit changes to {','.join(db_names)}")
         form = QVBoxLayout(self)
         form.setContentsMargins(4, 4, 4, 4)
         self.action_accept = QAction(self)
diff --git a/spinetoolbox/widgets/custom_menus.py b/spinetoolbox/widgets/custom_menus.py
index 1ecbefd25..9bbe7c8ad 100644
--- a/spinetoolbox/widgets/custom_menus.py
+++ b/spinetoolbox/widgets/custom_menus.py
@@ -148,7 +148,7 @@ def call_open_project(self, checked, p):
             # Project has been removed, remove it from recent projects list
             self._parent.remove_path_from_recent_projects(p)
             self._parent.msg_error.emit(
-                "Opening selected project failed. Project file <b>{0}</b> may have been removed.".format(p)
+                f"Opening selected project failed. Project file <b>{p}</b> may have been removed."
             )
             return
         # Check if the same project is already open
diff --git a/spinetoolbox/widgets/custom_qgraphicsscene.py b/spinetoolbox/widgets/custom_qgraphicsscene.py
index 362a3bd99..9e4c91063 100644
--- a/spinetoolbox/widgets/custom_qgraphicsscene.py
+++ b/spinetoolbox/widgets/custom_qgraphicsscene.py
@@ -284,7 +284,7 @@ def _draw_tree_bg(self, painter, rect):
         y_start = round(top_left.y() / radius)
         x_stop = x_start + round(rect.width() / dx) + 1
         y_stop = y_start + round(rect.height() / radius) + 1
-        centers = list()
+        centers = []
         centers_append = centers.append
         for i in range(x_start, x_stop):
             ref = QPointF(i * dx, (i & 1) * dy)
diff --git a/spinetoolbox/widgets/custom_qtableview.py b/spinetoolbox/widgets/custom_qtableview.py
index a6f772f76..c300e16e8 100644
--- a/spinetoolbox/widgets/custom_qtableview.py
+++ b/spinetoolbox/widgets/custom_qtableview.py
@@ -203,8 +203,8 @@ def paste_on_selection(self):
         selection = self.selectionModel().selection()
         if selection.isEmpty():
             return False
-        indexes = list()
-        values = list()
+        indexes = []
+        values = []
         is_row_hidden = self.verticalHeader().isSectionHidden
         rows = [x for r in selection for x in range(r.top(), r.bottom() + 1) if not is_row_hidden(x)]
         is_column_hidden = self.horizontalHeader().isSectionHidden
@@ -230,6 +230,10 @@ def paste_on_selection(self):
 
     def paste_normal(self):
         """Pastes clipboard data, overwriting cells if needed."""
+
+        def is_visual_column_hidden(x):
+            return h.isSectionHidden(h.logicalIndex(x))
+
         text = QApplication.clipboard().text().strip()
         if not text:
             return False
@@ -239,8 +243,8 @@ def paste_normal(self):
         current = self.currentIndex()
         if not current.isValid():
             return False
-        indexes = list()
-        values = list()
+        indexes = []
+        values = []
         row = current.row()
         rows = []
         rows_append = rows.append
@@ -255,7 +259,6 @@ def paste_normal(self):
         columns = []
         columns_append = columns.append
         h = self.horizontalHeader()
-        is_visual_column_hidden = lambda x: h.isSectionHidden(h.logicalIndex(x))
         for _ in range(len(data[0])):
             while is_visual_column_hidden(visual_column):
                 visual_column += 1
@@ -487,8 +490,8 @@ def _paste_to_values_column(self, values, first_row, paste_length):
         Returns:
             tuple: A tuple (list(pasted indexes), list(pasted values))
         """
-        values_to_set = list()
-        indexes_to_set = list()
+        values_to_set = []
+        indexes_to_set = []
         create_model_index = self.model().index
         # Always paste to the Values column.
         for row in range(first_row, first_row + paste_length):
@@ -563,8 +566,8 @@ def _paste_two_columns(self, data_indexes, data_values, first_row, paste_length)
         Returns:
             tuple: a tuple (modified model indexes, modified model values)
         """
-        values_to_set = list()
-        indexes_to_set = list()
+        values_to_set = []
+        indexes_to_set = []
         create_model_index = self.model().index
         for row in range(first_row, first_row + paste_length):
             i = row - first_row
@@ -585,8 +588,8 @@ def _paste_single_column(self, values, first_row, first_column, paste_length):
         Returns:
             tuple: a tuple (modified model indexes, modified model values)
         """
-        values_to_set = list()
-        indexes_to_set = list()
+        values_to_set = []
+        indexes_to_set = []
         create_model_index = self.model().index
         # Always paste numbers to the Values column.
         target_column = first_column if not isinstance(values[0], float) else 1
@@ -607,9 +610,9 @@ def _read_pasted_text(text):
         """
         with io.StringIO(text) as input_stream:
             reader = csv.reader(input_stream, delimiter="\t")
-            single_column = list()
-            data_indexes = list()
-            data_values = list()
+            single_column = []
+            data_indexes = []
+            data_values = []
             with system_lc_numeric():
                 for row in reader:
                     column_count = len(row)
@@ -703,8 +706,8 @@ def paste(self, _=False):
             # If multiple row are selected, we paste what fits the selection.
             paste_length = selection_length
             pasted_table = pasted_table[0:selection_length]
-        values_to_set = list()
-        indexes_to_set = list()
+        values_to_set = []
+        indexes_to_set = []
         create_model_index = self.model().index
         for row in range(first_row, first_row + paste_length):
             values_to_set.append(pasted_table[row - first_row])
@@ -753,7 +756,7 @@ def copy(self, _=False):
         if left > right or top > bottom:
             QApplication.clipboard().setText("")
             return True
-        out_table = list()
+        out_table = []
         with system_lc_numeric():
             for y in range(top, bottom + 1):
                 row = (right - left + 1) * [None]
@@ -844,12 +847,12 @@ def _read_pasted_text(text):
         Returns:
             list of list: a list of table rows
         """
-        data = list()
+        data = []
         with io.StringIO(text) as input_stream:
             reader = csv.reader(input_stream, delimiter="\t")
             with system_lc_numeric():
                 for row in reader:
-                    data_row = list()
+                    data_row = []
                     for cell in row:
                         try:
                             number = locale.atof(cell)
diff --git a/spinetoolbox/widgets/custom_qwidgets.py b/spinetoolbox/widgets/custom_qwidgets.py
index e2bdb7c65..2a9c6ea07 100644
--- a/spinetoolbox/widgets/custom_qwidgets.py
+++ b/spinetoolbox/widgets/custom_qwidgets.py
@@ -280,9 +280,8 @@ def __init__(self, text, parent=None, io_files=None):
         self.tool_bar = _MenuToolBar(self)
         layout.addStretch()
         layout.addWidget(self.tool_bar)
-        icon_extent = qApp.style().pixelMetric(
-            QStyle.PixelMetric.PM_SmallIconSize
-        )  # pylint: disable=undefined-variable
+        # pylint: disable=undefined-variable
+        icon_extent = qApp.style().pixelMetric(QStyle.PixelMetric.PM_SmallIconSize)
         self.tool_bar.setIconSize(QSize(icon_extent, icon_extent))
         self.tool_bar.setToolButtonStyle(Qt.ToolButtonStyle.ToolButtonTextUnderIcon)
 
@@ -312,9 +311,8 @@ def __init__(self, text, parent=None, compact=False):
         if compact:
             self.tool_bar.setFixedHeight(self.option.rect.height())
         text_width = self.option.fontMetrics.horizontalAdvance(self._text)
-        icon_width = qApp.style().pixelMetric(
-            QStyle.PixelMetric.PM_ToolBarIconSize
-        )  # pylint: disable=undefined-variable
+        # pylint: disable=undefined-variable
+        icon_width = qApp.style().pixelMetric(QStyle.PixelMetric.PM_ToolBarIconSize)
         spacing = text_width + 3 * icon_width
         self.option.rect.setWidth(spacing)
         self.layout().insertSpacing(0, spacing)
@@ -507,7 +505,7 @@ def _add_line(widget, layout):
         line.setFrameShadow(QFrame.Sunken)
         layout.addWidget(line)
 
-    def isSeparator(self):  # pylint: disable=no-self-use
+    def isSeparator(self):
         return True
 
 
diff --git a/spinetoolbox/widgets/jupyter_console_widget.py b/spinetoolbox/widgets/jupyter_console_widget.py
index 0230b8105..54d2aa823 100644
--- a/spinetoolbox/widgets/jupyter_console_widget.py
+++ b/spinetoolbox/widgets/jupyter_console_widget.py
@@ -60,7 +60,7 @@ def __init__(self, toolbox, kernel_name, owner=None):
         exec_remotely = self._toolbox.qsettings().value("engineSettings/remoteExecutionEnabled", "false") == "true"
         self._engine_manager = make_engine_manager(exec_remotely)
         self._q = multiprocessing.Queue()
-        self._logger = QueueLogger(self._q, "DetachedPythonConsole", None, dict())
+        self._logger = QueueLogger(self._q, "DetachedPythonConsole", None, {})
         self.normal_cursor = self._control.viewport().cursor()
         self._copy_input_action = QAction("Copy (Only Input)", self)
         self._copy_input_action.triggered.connect(lambda checked: self.copy_input())
@@ -124,11 +124,9 @@ def _handle_kernel_started_msg(self, msg):
             manager successfully, None otherwise.
         """
         if msg["type"] == "kernel_started":
-            self._connection_file = solve_connection_file(
-                msg["connection_file"], msg.get("connection_file_dict", dict())
-            )
+            self._connection_file = solve_connection_file(msg["connection_file"], msg.get("connection_file_dict", {}))
             return self._connection_file
-        elif msg["type"] == "kernel_spec_not_found":
+        if msg["type"] == "kernel_spec_not_found":
             self._toolbox.msg_error.emit(
                 f"Kernel failed to start:<br/>"
                 f"Unable to find kernel spec <b>{msg['kernel_name']}</b>.<br/>"
diff --git a/spinetoolbox/widgets/kernel_editor.py b/spinetoolbox/widgets/kernel_editor.py
index 9d96b0718..7c2309268 100644
--- a/spinetoolbox/widgets/kernel_editor.py
+++ b/spinetoolbox/widgets/kernel_editor.py
@@ -327,8 +327,8 @@ def make_julia_kernel(self, checked=False):
             self.start_ijulia_install_process(julia, project)
         return True
 
-    # pylint: disable=no-self-use
-    def _is_rebuild_ijulia_needed(self):
+    @staticmethod
+    def _is_rebuild_ijulia_needed():
         return True
 
     @busy_effect
@@ -354,8 +354,8 @@ def is_ijulia_installed(self, program, project):
         exec_mngr.start_execution()
         if not exec_mngr.wait_for_process_finished(msecs=8000):
             self._logger.msg_error.emit(
-                "Couldn't start Julia to check IJulia status. "
-                "Please make sure that Julia {0} is correctly installed and try again.".format(program)
+                f"Couldn't start Julia to check IJulia status. "
+                f"Please make sure that Julia {program} is correctly installed and try again."
             )
             self._logger.msg_error.emit("Failed")
             return 0
diff --git a/spinetoolbox/widgets/multi_tab_spec_editor.py b/spinetoolbox/widgets/multi_tab_spec_editor.py
index e72ccbd9d..0a862f08f 100644
--- a/spinetoolbox/widgets/multi_tab_spec_editor.py
+++ b/spinetoolbox/widgets/multi_tab_spec_editor.py
@@ -82,11 +82,16 @@ def show_plus_button_context_menu(self, global_pos):
             other_index = other_index_by_spec.get(spec)
             if other_index is None:
                 # Spec is not open on another multi tab editor, so open it here
-                slot = lambda spec=spec: self.add_new_tab(spec)
+                def slot(spec_=spec):
+                    return self.add_new_tab(spec_)
+
             else:
                 # Spec is open on another multi tab editor, so bring it here
                 other, index = other_index
-                slot = lambda other=other, index=index: other.move_tab(index, self)
+
+                def slot(other_=other, index_=index):
+                    other_.move_tab(index_, self)
+
             menu.addAction(spec.name, slot)
         menu.popup(global_pos)
         menu.aboutToHide.connect(menu.deleteLater)
diff --git a/spinetoolbox/widgets/multi_tab_window.py b/spinetoolbox/widgets/multi_tab_window.py
index 22ff7814b..dd4baa7eb 100644
--- a/spinetoolbox/widgets/multi_tab_window.py
+++ b/spinetoolbox/widgets/multi_tab_window.py
@@ -202,7 +202,10 @@ def _connect_tab_signals(self, tab):
         """
         if tab in self._tab_slots:
             return False
-        slot = lambda title, tab=tab: self._handle_tab_window_title_changed(tab, title)
+
+        def slot(title, tab_=tab):
+            self._handle_tab_window_title_changed(tab_, title)
+
         self._tab_slots[tab] = slot
         tab.windowTitleChanged.connect(slot)
         self._handle_tab_window_title_changed(tab, tab.windowTitle())
@@ -502,7 +505,7 @@ def tabLayoutChange(self):
 
     def _move_plus_button(self):
         """Places the plus button at the right of the last tab."""
-        left = sum([self.tabRect(i).width() for i in range(self.count())])
+        left = sum(self.tabRect(i).width() for i in range(self.count()))
         top = self.geometry().top() + 1
         self._plus_button.move(left, top)
 
diff --git a/spinetoolbox/widgets/persistent_console_widget.py b/spinetoolbox/widgets/persistent_console_widget.py
index 4993ae575..3c5b35827 100644
--- a/spinetoolbox/widgets/persistent_console_widget.py
+++ b/spinetoolbox/widgets/persistent_console_widget.py
@@ -576,9 +576,8 @@ def create_engine_manager(self):
                 self._toolbox.msg_error.emit(f"Connecting to Spine Engine Server failed. {e}")
                 return None
             return self.engine_mngr
-        else:
-            engine_mngr = make_engine_manager(exec_remotely)
-            return engine_mngr
+        engine_mngr = make_engine_manager(exec_remotely)
+        return engine_mngr
 
     def _issue_command(self, text):
         """Issues command.
diff --git a/spinetoolbox/widgets/plot_widget.py b/spinetoolbox/widgets/plot_widget.py
index 5a70884d9..a2096dd53 100644
--- a/spinetoolbox/widgets/plot_widget.py
+++ b/spinetoolbox/widgets/plot_widget.py
@@ -33,7 +33,7 @@ class PlotWidget(QWidget):
         original_xy_data (list of XYData): unmodified data on which the plots are based
     """
 
-    plot_windows = dict()
+    plot_windows = {}
     """A global list of plot windows."""
 
     def __init__(self, parent=None, legend_axes_position=LegendPosition.BOTTOM):
@@ -48,7 +48,7 @@ def __init__(self, parent=None, legend_axes_position=LegendPosition.BOTTOM):
         self._toolbar = NavigationToolBar(self.canvas, self)
         self._layout.addWidget(self._toolbar)
         self._layout.addWidget(self.canvas)
-        self.original_xy_data = list()
+        self.original_xy_data = []
         QMetaObject.connectSlotsByName(self)
 
     def closeEvent(self, event):
diff --git a/spinetoolbox/widgets/project_item_drag.py b/spinetoolbox/widgets/project_item_drag.py
index 031e2e9cb..5991a386a 100644
--- a/spinetoolbox/widgets/project_item_drag.py
+++ b/spinetoolbox/widgets/project_item_drag.py
@@ -94,6 +94,9 @@ def __init__(self, toolbox, item_type, icon, parent=None):
         self.setMouseTracking(True)
         self.drag_about_to_start.connect(self._handle_drag_about_to_start)
         self.clicked.connect(self._show_tool_tip)
+        self.drag_start_pos = None
+        self.pixmap = None
+        self.mime_data = None
 
     @Slot(bool)
     def _show_tool_tip(self, _=False):
diff --git a/spinetoolbox/widgets/settings_widget.py b/spinetoolbox/widgets/settings_widget.py
index 2273a2957..416992135 100644
--- a/spinetoolbox/widgets/settings_widget.py
+++ b/spinetoolbox/widgets/settings_widget.py
@@ -105,7 +105,6 @@ def mouseReleaseEvent(self, e):
             moved = self._mouse_release_pos - self._mouse_press_pos
             if moved.manhattanLength() > 3:
                 e.ignore()
-                return
 
     def mouseMoveEvent(self, e):
         """Moves the window when mouse button is pressed and mouse cursor is moved.
@@ -127,7 +126,6 @@ def update_ui(self):
         """Updates UI to reflect current settings. Called when the user choses to cancel their changes.
         Undoes all temporary UI changes that resulted from the user playing with certain settings."""
 
-    # pylint: disable=no-self-use
     def save_settings(self):
         """Gets selections and saves them to persistent memory."""
         return True
@@ -520,7 +518,7 @@ def make_julia_kernel(self, _=False):
         """Makes a Julia kernel for Jupyter Console based on selected Julia executable and Julia project.
         If a kernel using the selected Julia executable and project already exists, sets that kernel
         selected in the comboBox."""
-        use_julia_jupyter_console, julia_exe, julia_project, julia_kernel = self._get_julia_settings()
+        _, julia_exe, julia_project, julia_kernel = self._get_julia_settings()
         if not julia_exe:
             julia_exe = resolve_default_julia_executable()
         julia_kernel = _get_kernel_name_by_exe(julia_exe, self._julia_kernel_model)
@@ -880,11 +878,11 @@ def save_settings(self):
         use_julia_jupyter_console, julia_exe, julia_project, julia_kernel = self._get_julia_settings()
         if use_julia_jupyter_console == "2" and not julia_kernel:
             msg = (
-                f"You have selected <b>Jupyter Console</b> for Julia Tools "
-                f"but you did not select a kernel, please"
-                f"<br><br>1. Select one from the dropdown menu"
-                f"<br>2. Click <b>Make Julia Kernel</b> button to create one, or"
-                f"<br>3. Select <b>Basic Console</b>"
+                "You have selected <b>Jupyter Console</b> for Julia Tools "
+                "but you did not select a kernel, please"
+                "<br><br>1. Select one from the dropdown menu"
+                "<br>2. Click <b>Make Julia Kernel</b> button to create one, or"
+                "<br>3. Select <b>Basic Console</b>"
             )
             box = QMessageBox(QMessageBox.Icon.Warning, "No Julia kernel selected", msg, parent=self)
             box.setWindowIcon(QIcon(":/symbols/app.ico"))
@@ -909,11 +907,11 @@ def save_settings(self):
             python_kernel = self.ui.comboBox_python_kernel.currentText()
         if use_python_jupyter_console == "2" and not python_kernel:
             msg = (
-                f"You have selected <b>Jupyter Console</b> for Python Tools "
-                f"but you did not select a kernel, please"
-                f"<br><br>1. Select one from the dropdown menu"
-                f"<br>2. Click <b>Make Python Kernel</b> button to create one, or"
-                f"<br>3. Select <b>Basic Console</b>"
+                "You have selected <b>Jupyter Console</b> for Python Tools "
+                "but you did not select a kernel, please"
+                "<br><br>1. Select one from the dropdown menu"
+                "<br>2. Click <b>Make Python Kernel</b> button to create one, or"
+                "<br>3. Select <b>Basic Console</b>"
             )
             box = QMessageBox(QMessageBox.Icon.Warning, "No Python kernel selected", msg, parent=self)
             box.setWindowIcon(QIcon(":/symbols/app.ico"))
diff --git a/tests/mock_helpers.py b/tests/mock_helpers.py
index c921ac4e4..c7c991487 100644
--- a/tests/mock_helpers.py
+++ b/tests/mock_helpers.py
@@ -85,7 +85,7 @@ def qsettings_value_side_effect(key, defaultValue="0"):
     """
     if key == "appSettings/openPreviousProject":
         return "0"  # Do not open previous project when instantiating ToolboxUI
-    elif key == "engineSettings/remoteExecutionEnabled":
+    if key == "engineSettings/remoteExecutionEnabled":
         return "false"
     return defaultValue
 
@@ -103,7 +103,7 @@ def add_ds(project, item_factories, name, x=0.0, y=0.0):
     Returns:
         DataStore: added project item
     """
-    item_dict = {name: {"type": "Data Store", "description": "", "url": dict(), "x": x, "y": y}}
+    item_dict = {name: {"type": "Data Store", "description": "", "url": {}, "x": x, "y": y}}
     project.restore_project_items(item_dict, item_factories)
     return project.get_item(name)
 
@@ -121,7 +121,7 @@ def add_dc_trough_undo_stack(toolbox, name, x=0, y=0, file_refs=None):
     Returns:
         DataConnection: added project item
     """
-    frefs = list() if not file_refs else file_refs
+    frefs = [] if not file_refs else file_refs
     item_dict = {name: {"type": "Data Connection", "description": "", "references": frefs, "x": x, "y": y}}
     if toolbox:  # This way the changes are pushed to the undo stack of ToolboxUI
         toolbox.add_project_items(item_dict)
@@ -144,7 +144,7 @@ def add_dc(project, item_factories, name, x=0, y=0, file_refs=None):
     Returns:
         DataConnection: added project item
     """
-    frefs = list() if not file_refs else file_refs
+    frefs = [] if not file_refs else file_refs
     item_dict = {name: {"type": "Data Connection", "description": "", "references": frefs, "x": x, "y": y}}
     project.restore_project_items(item_dict, item_factories)
     return project.get_item(name)
@@ -330,8 +330,7 @@ def q_object(o):
 
 
 def model_data_to_dict(model, parent=QModelIndex()):
-    """"""
-    rows = list()
+    rows = []
     for row in range(model.rowCount(parent)):
         row_data = []
         for column in range(model.columnCount()):
@@ -362,7 +361,7 @@ def model_data_to_table(model, parent=QModelIndex(), role=Qt.ItemDataRole.Displa
 def fetch_model(model):
     while model.canFetchMore(QModelIndex()):
         model.fetchMore(QModelIndex())
-        qApp.processEvents()
+        qApp.processEvents()  # pylint: disable=undefined-variable
 
 
 class FakeDataStore:
diff --git a/tests/mvcmodels/test_MinimalTableModel.py b/tests/mvcmodels/test_MinimalTableModel.py
index a50e89326..d84dcdec7 100644
--- a/tests/mvcmodels/test_MinimalTableModel.py
+++ b/tests/mvcmodels/test_MinimalTableModel.py
@@ -141,7 +141,7 @@ def test_batch_set_data(self):
         n_columns = 3
         model.insertColumns(0, n_columns)
         background = n_rows * n_columns * ["0xdeadbeef"]
-        indices = list()
+        indices = []
         for row in range(n_rows):
             for column in range(n_columns):
                 indices.append(model.index(row, column))
diff --git a/tests/mvcmodels/test_TimeSeriesModelFixedResolution.py b/tests/mvcmodels/test_TimeSeriesModelFixedResolution.py
index cb938c1ce..7936c1fac 100644
--- a/tests/mvcmodels/test_TimeSeriesModelFixedResolution.py
+++ b/tests/mvcmodels/test_TimeSeriesModelFixedResolution.py
@@ -50,7 +50,7 @@ def test_flags(self):
         self.assertEqual(model.flags(model_index), Qt.ItemIsSelectable | Qt.ItemIsEnabled | Qt.ItemIsEditable)
         model.deleteLater()
 
-    def test_indexes(self):  # pylint: disable=no-self-use
+    def test_indexes(self):
         model = TimeSeriesModelFixedResolution(
             TimeSeriesFixedResolution("2019-07-05T12:00", "2 hours", [-5.0, 7.0], True, False), None
         )
diff --git a/tests/mvcmodels/test_TimeSeriesModelVariableResolution.py b/tests/mvcmodels/test_TimeSeriesModelVariableResolution.py
index fa0ade13c..00f1324cc 100644
--- a/tests/mvcmodels/test_TimeSeriesModelVariableResolution.py
+++ b/tests/mvcmodels/test_TimeSeriesModelVariableResolution.py
@@ -224,6 +224,7 @@ def test_setData_sets_timestamp_to_nan_if_conversion_to_datetime_fails(self):
         )
         model_index = model.index(0, 0)
         model.setData(model_index, "what happened to Tuesday")
+        # pylint: disable=no-value-for-parameter
         expected = TimeSeriesVariableResolution([numpy.datetime64(), "1992-01-01T13:30"], [2.3, -5.0], True, False)
         self.assertEqual([str(x) for x in model.value.indexes], [str(x) for x in expected.indexes])
         self.assertTrue(numpy.array_equal(model.value.values, expected.values))
diff --git a/tests/project_item/test_logging_connection.py b/tests/project_item/test_logging_connection.py
index 58a0522a4..099af4db3 100644
--- a/tests/project_item/test_logging_connection.py
+++ b/tests/project_item/test_logging_connection.py
@@ -181,7 +181,6 @@ def __init__(self, name, project):
     def item_type():
         return "Mock Data Store"
 
-    # pylint: disable=no-self-use
     def resources_for_direct_successors(self):
         return [
             database_resource(
diff --git a/tests/server/test_RemoteSpineEngineManager.py b/tests/server/test_RemoteSpineEngineManager.py
index 030f4d0f9..934cd31fa 100644
--- a/tests/server/test_RemoteSpineEngineManager.py
+++ b/tests/server/test_RemoteSpineEngineManager.py
@@ -49,7 +49,7 @@ def test_remote_engine_manager(self):
 
     def _run_engine(self, attribs):
         remote_engine_mngr = RemoteSpineEngineManager()
-        engine_data = {"settings": dict(), "project_dir": ""}
+        engine_data = {"settings": {}, "project_dir": ""}
         # NOTE: This patch does not work without spec=True
         with mock.patch("spinetoolbox.spine_engine_manager.EngineClient", **attribs, spec=True) as mock_client:
             remote_engine_mngr.run_engine(engine_data)
@@ -94,12 +94,11 @@ def yield_events_dag_succeeds():
             ),
             ("dag_exec_finished", "COMPLETED"),
         ]
-        rcv_events_list = list()
+        rcv_events_list = []
         for event_type, data in engine_events:
             json_event = EventDataConverter.convert(event_type, data)
             rcv_events_list.append([json_event.encode("utf-8")])
-        for event in rcv_events_list:
-            yield event
+        yield from rcv_events_list
 
     @staticmethod
     def yield_events_dag_fails():
@@ -136,12 +135,11 @@ def yield_events_dag_fails():
             ),
             ("dag_exec_finished", "FAILED"),
         ]
-        rcv_events_list = list()
+        rcv_events_list = []
         for event_type, data in engine_events:
             json_event = EventDataConverter.convert(event_type, data)
             rcv_events_list.append([json_event.encode("utf-8")])
-        for event in rcv_events_list:
-            yield event
+        yield from rcv_events_list
 
 
 if __name__ == "__main__":
diff --git a/tests/spine_db_editor/helpers.py b/tests/spine_db_editor/helpers.py
index e2ce2d0e6..a17ae66cf 100644
--- a/tests/spine_db_editor/helpers.py
+++ b/tests/spine_db_editor/helpers.py
@@ -55,7 +55,7 @@ def _common_tear_down(self):
             QApplication.processEvents()
         self._db_mngr.clean_up()
         self._db_editor.deleteLater()
-        self._db_editor = None
+        self._db_editor = None  # pylint: disable=attribute-defined-outside-init
 
     def _commit_changes_to_database(self, commit_message):
         with mock.patch.object(self._db_editor, "_get_commit_msg") as commit_msg:
diff --git a/tests/spine_db_editor/mvcmodels/test_PivotModel.py b/tests/spine_db_editor/mvcmodels/test_PivotModel.py
index 1a8bdc630..54eddfaa7 100644
--- a/tests/spine_db_editor/mvcmodels/test_PivotModel.py
+++ b/tests/spine_db_editor/mvcmodels/test_PivotModel.py
@@ -111,7 +111,7 @@ def test_set_pivot_with_frozen(self):
         row_headers = [("aa",), ("bb",)]
         data = [["value_a_aa_1", None], [None, "value_a_bb_2"]]
         column_headers = [(1,), (2,)]
-        data_model = [[d for d in inner] for inner in model.get_pivoted_data(range(2), range(2))]
+        data_model = [list(inner) for inner in model.get_pivoted_data(range(2), range(2))]
         self.assertEqual(model._row_data_header, row_headers)
         self.assertEqual(model._column_data_header, column_headers)
         self.assertEqual(data_model, data)
@@ -122,7 +122,7 @@ def test_get_pivoted_data1(self):
         model.reset_model(DATA, INDEX_IDS)
         model.set_pivot(["test2"], ["test3"], ["test1"], ("a",))
         data = [["value_a_aa_1", None], [None, "value_a_bb_2"]]
-        data_model = [[d for d in inner] for inner in model.get_pivoted_data(range(2), range(2))]
+        data_model = [list(inner) for inner in model.get_pivoted_data(range(2), range(2))]
         self.assertEqual(data_model, data)
 
     def test_get_pivoted_data2(self):
@@ -138,7 +138,7 @@ def test_get_pivoted_data2(self):
             [None, None, None, None, "value_d_dd_5"],
             [None, None, None, None, "value_e_ee_5"],
         ]
-        data_model = [[d for d in inner] for inner in model.get_pivoted_data(range(6), range(5))]
+        data_model = [list(inner) for inner in model.get_pivoted_data(range(6), range(5))]
         self.assertEqual(data_model, data)
 
     def test_get_pivoted_data3(self):
@@ -154,7 +154,7 @@ def test_get_pivoted_data3(self):
             [None, None, None, None, "value_d_dd_5"],
             [None, None, None, None, "value_e_ee_5"],
         ]
-        data_model = [[d for d in inner] for inner in model.get_pivoted_data(range(6), range(5))]
+        data_model = [list(inner) for inner in model.get_pivoted_data(range(6), range(5))]
         self.assertEqual(data_model, data)
 
     def test_get_unique_index_values1(self):
@@ -226,7 +226,7 @@ def test_remove_single_point_of_data(self):
         expected_model_data = [
             [23.0],
         ]
-        data_model = [[d for d in inner] for inner in model.get_pivoted_data(range(1), range(1))]
+        data_model = [list(inner) for inner in model.get_pivoted_data(range(1), range(1))]
         self.assertEqual(data_model, expected_model_data)
         model.remove_from_model({("a", "aa", 1): None})
         self.assertEqual(model._data, {})
@@ -261,7 +261,7 @@ def test_remove_data_when_entire_column_vanishes(self):
             [None, 2.3, None],
             [None, None, None],
         ]
-        data_model = [[d for d in inner] for inner in model.get_pivoted_data(range(3), range(3))]
+        data_model = [list(inner) for inner in model.get_pivoted_data(range(3), range(3))]
         self.assertEqual(data_model, expected_model_data)
         column_header.data["bb"] = None
         model.remove_from_model({("a", "bb", 1): None})
diff --git a/tests/spine_db_editor/mvcmodels/test_PivotTableModel.py b/tests/spine_db_editor/mvcmodels/test_PivotTableModel.py
index 04e25aae6..cb3d747c3 100644
--- a/tests/spine_db_editor/mvcmodels/test_PivotTableModel.py
+++ b/tests/spine_db_editor/mvcmodels/test_PivotTableModel.py
@@ -54,72 +54,73 @@ def guarded_get_item(db_map, item_type, id_):
         with patch.object(self._db_editor.ui.dockWidget_pivot_table, "isVisible") as mock_is_visible:
             mock_is_visible.return_value = True
             self._db_editor.do_reload_pivot_table()
-        self._model = self._db_editor.pivot_table_model
+        model = self._db_editor.pivot_table_model
         with patch.object(self._db_mngr, "get_item") as get_item:
             get_item.side_effect = guarded_get_item
-            self._model.beginResetModel()
-            self._model.endResetModel()
-            qApp.processEvents()
+            model.beginResetModel()
+            model.endResetModel()
+            qApp.processEvents()  # pylint: disable=undefined-variable
             self.assertEqual(get_item_exceptions, [])
+        return model
 
-    def _model_data(self):
+    def _model_data(self, model):
         data = []
-        for row in range(self._model.rowCount()):
+        for row in range(model.rowCount()):
             row_data = []
-            for column in range(self._model.columnCount()):
-                row_data.append(self._model.index(row, column).data())
+            for column in range(model.columnCount()):
+                row_data.append(model.index(row, column).data())
             data.append(row_data)
         return data
 
     def test_x_flag(self):
         self._fill_model_with_data()
-        self._start()
-        self.assertIsNone(self._model.plot_x_column)
-        self._model.set_plot_x_column(1, True)
-        self.assertEqual(self._model.plot_x_column, 1)
-        self._model.set_plot_x_column(1, False)
-        self.assertIsNone(self._model.plot_x_column)
+        model = self._start()
+        self.assertIsNone(model.plot_x_column)
+        model.set_plot_x_column(1, True)
+        self.assertEqual(model.plot_x_column, 1)
+        model.set_plot_x_column(1, False)
+        self.assertIsNone(model.plot_x_column)
 
     def test_header_name(self):
         self._fill_model_with_data()
-        self._start()
-        self.assertEqual(self._model.rowCount(), 5)
-        self.assertEqual(self._model.columnCount(), 4)
-        self.assertEqual(self._model.header_name(self._model.index(2, 0)), "object1")
-        self.assertEqual(self._model.header_name(self._model.index(0, 1)), "parameter1")
-        self.assertEqual(self._model.header_name(self._model.index(3, 0)), "object2")
-        self.assertEqual(self._model.header_name(self._model.index(0, 2)), "parameter2")
+        model = self._start()
+        self.assertEqual(model.rowCount(), 5)
+        self.assertEqual(model.columnCount(), 4)
+        self.assertEqual(model.header_name(model.index(2, 0)), "object1")
+        self.assertEqual(model.header_name(model.index(0, 1)), "parameter1")
+        self.assertEqual(model.header_name(model.index(3, 0)), "object2")
+        self.assertEqual(model.header_name(model.index(0, 2)), "parameter2")
 
     def test_data(self):
         self._fill_model_with_data()
-        self._start()
-        self.assertEqual(self._model.rowCount(), 5)
-        self.assertEqual(self._model.columnCount(), 4)
-        self.assertEqual(self._model.index(0, 0).data(), "parameter")
-        self.assertEqual(self._model.index(1, 0).data(), "class1")
-        self.assertEqual(self._model.index(2, 0).data(), "object1")
-        self.assertEqual(self._model.index(3, 0).data(), "object2")
-        self.assertIsNone(self._model.index(4, 0).data())
-        self.assertEqual(self._model.index(0, 1).data(), "parameter1")
-        self.assertIsNone(self._model.index(1, 1).data())
-        self.assertEqual(self._model.index(2, 1).data(), str(1.0))
-        self.assertEqual(self._model.index(3, 1).data(), str(3.0))
-        self.assertIsNone(self._model.index(4, 1).data())
-        self.assertEqual(self._model.index(0, 2).data(), "parameter2")
-        self.assertIsNone(self._model.index(1, 2).data())
-        self.assertEqual(self._model.index(2, 2).data(), str(5.0))
-        self.assertEqual(self._model.index(3, 2).data(), str(7.0))
-        self.assertIsNone(self._model.index(4, 2).data())
-        self.assertIsNone(self._model.index(0, 3).data())
-        self.assertIsNone(self._model.index(1, 3).data())
-        self.assertIsNone(self._model.index(2, 3).data())
-        self.assertIsNone(self._model.index(3, 3).data())
-        self.assertIsNone(self._model.index(4, 3).data())
+        model = self._start()
+        self.assertEqual(model.rowCount(), 5)
+        self.assertEqual(model.columnCount(), 4)
+        self.assertEqual(model.index(0, 0).data(), "parameter")
+        self.assertEqual(model.index(1, 0).data(), "class1")
+        self.assertEqual(model.index(2, 0).data(), "object1")
+        self.assertEqual(model.index(3, 0).data(), "object2")
+        self.assertIsNone(model.index(4, 0).data())
+        self.assertEqual(model.index(0, 1).data(), "parameter1")
+        self.assertIsNone(model.index(1, 1).data())
+        self.assertEqual(model.index(2, 1).data(), str(1.0))
+        self.assertEqual(model.index(3, 1).data(), str(3.0))
+        self.assertIsNone(model.index(4, 1).data())
+        self.assertEqual(model.index(0, 2).data(), "parameter2")
+        self.assertIsNone(model.index(1, 2).data())
+        self.assertEqual(model.index(2, 2).data(), str(5.0))
+        self.assertEqual(model.index(3, 2).data(), str(7.0))
+        self.assertIsNone(model.index(4, 2).data())
+        self.assertIsNone(model.index(0, 3).data())
+        self.assertIsNone(model.index(1, 3).data())
+        self.assertIsNone(model.index(2, 3).data())
+        self.assertIsNone(model.index(3, 3).data())
+        self.assertIsNone(model.index(4, 3).data())
 
     def test_header_row_count(self):
         self._fill_model_with_data()
-        self._start()
-        self.assertEqual(self._model.headerRowCount(), 2)
+        model = self._start()
+        self.assertEqual(model.headerRowCount(), 2)
 
     def test_model_works_even_without_entities(self):
         data = {
@@ -128,15 +129,15 @@ def test_model_works_even_without_entities(self):
         self._db_mngr.import_data({self._db_map: data})
         while self._db_editor.entity_tree_model._root_item.row_count() == 0:
             QApplication.processEvents()
-        self._start()
-        self.assertEqual(self._model.rowCount(), 3)
-        self.assertEqual(self._model.columnCount(), 2)
-        self.assertEqual(self._model.index(0, 0).data(), "parameter")
-        self.assertEqual(self._model.index(1, 0).data(), "class1")
-        self.assertIsNone(self._model.index(2, 0).data())
-        self.assertIsNone(self._model.index(0, 1).data())
-        self.assertIsNone(self._model.index(1, 1).data())
-        self.assertIsNone(self._model.index(2, 1).data())
+        model = self._start()
+        self.assertEqual(model.rowCount(), 3)
+        self.assertEqual(model.columnCount(), 2)
+        self.assertEqual(model.index(0, 0).data(), "parameter")
+        self.assertEqual(model.index(1, 0).data(), "class1")
+        self.assertIsNone(model.index(2, 0).data())
+        self.assertIsNone(model.index(0, 1).data())
+        self.assertIsNone(model.index(1, 1).data())
+        self.assertIsNone(model.index(2, 1).data())
 
     def test_single_entity_creates_half_finished_pivot(self):
         initial_data = {
@@ -146,9 +147,9 @@ def test_single_entity_creates_half_finished_pivot(self):
         self._db_mngr.import_data({self._db_map: initial_data})
         while self._db_editor.entity_tree_model._root_item.row_count() == 0:
             QApplication.processEvents()
-        self._start()
+        model = self._start()
         expected = [["parameter", None], ["Object", None], ["spatula", None], [None, None]]
-        data = self._model_data()
+        data = self._model_data(model)
         self.assertEqual(data, expected)
 
     def test_single_entity_and_parameter_definition_create_empty_value_cell(self):
@@ -160,9 +161,9 @@ def test_single_entity_and_parameter_definition_create_empty_value_cell(self):
         self._db_mngr.import_data({self._db_map: initial_data})
         while self._db_editor.entity_tree_model._root_item.row_count() == 0:
             QApplication.processEvents()
-        self._start()
+        model = self._start()
         expected = [["parameter", "x", None], ["Object", None, None], ["spatula", None, None], [None, None, None]]
-        data = self._model_data()
+        data = self._model_data(model)
         self.assertEqual(data, expected)
 
     def test_removing_value_from_model_sets_value_cell_to_none(self):
@@ -175,9 +176,9 @@ def test_removing_value_from_model_sets_value_cell_to_none(self):
         self._db_mngr.import_data({self._db_map: initial_data})
         while self._db_editor.entity_tree_model._root_item.row_count() == 0:
             QApplication.processEvents()
-        self._start()
+        model = self._start()
         expected = [["parameter", "x", None], ["Object", None, None], ["spatula", str(2.3), None], [None, None, None]]
-        data = self._model_data()
+        data = self._model_data(model)
         self.assertEqual(data, expected)
         value_item = self._db_map.get_parameter_value_item(
             entity_class_name="Object",
@@ -187,12 +188,12 @@ def test_removing_value_from_model_sets_value_cell_to_none(self):
         )
         value_item.remove()
         expected = [["parameter", "x", None], ["Object", None, None], ["spatula", None, None], [None, None, None]]
-        data = self._model_data()
+        data = self._model_data(model)
         self.assertEqual(data, expected)
 
     def test_drag_and_drop_database_from_frozen_table(self):
         self._fill_model_with_data()
-        self._start()
+        model = self._start()
         for frozen_column in range(self._db_editor.frozen_table_model.columnCount()):
             frozen_index = self._db_editor.frozen_table_model.index(0, frozen_column)
             if frozen_index.data() == "database":
@@ -212,8 +213,8 @@ def test_drag_and_drop_database_from_frozen_table(self):
             raise RuntimeError("No 'parameter' header found")
         self._db_editor.handle_header_dropped(frozen_table_header_widget, index_widget)
         QApplication.processEvents()
-        self.assertEqual(self._model.rowCount(), 6)
-        self.assertEqual(self._model.columnCount(), 4)
+        self.assertEqual(model.rowCount(), 6)
+        self.assertEqual(model.columnCount(), 4)
         expected = [
             ["database", self.db_codename, self.db_codename, self.db_codename, None],
             ["parameter", "parameter1", "parameter2", None],
@@ -222,9 +223,9 @@ def test_drag_and_drop_database_from_frozen_table(self):
             ["object2", "3.0", "7.0", None],
             [None, None, None, None],
         ]
-        for row, column in itertools.product(range(self._model.rowCount()), range(self._model.columnCount())):
+        for row, column in itertools.product(range(model.rowCount()), range(model.columnCount())):
             with self.subTest(row=row, column=column):
-                self.assertEqual(self._model.index(row, column).data(), expected[row][column])
+                self.assertEqual(model.index(row, column).data(), expected[row][column])
 
 
 class TestIndexExpansionPivotTableModel(TestBase):
@@ -241,17 +242,19 @@ def _start(self, initial_data):
         with patch.object(self._db_editor.ui.dockWidget_pivot_table, "isVisible") as mock_is_visible:
             mock_is_visible.return_value = True
             self._db_editor.do_reload_pivot_table()
-        self._model = self._db_editor.pivot_table_model
-        self._model.beginResetModel()
-        self._model.endResetModel()
-        qApp.processEvents()
+        model = self._db_editor.pivot_table_model
+        model.beginResetModel()
+        model.endResetModel()
+        qApp.processEvents()  # pylint: disable=undefined-variable
+        return model
 
-    def _model_data(self):
+    @staticmethod
+    def _model_data(model):
         data = []
-        for row in range(self._model.rowCount()):
+        for row in range(model.rowCount()):
             row_data = []
-            for column in range(self._model.columnCount()):
-                row_data.append(self._model.index(row, column).data())
+            for column in range(model.columnCount()):
+                row_data.append(model.index(row, column).data())
             data.append(row_data)
         return data
 
@@ -267,10 +270,10 @@ def test_data(self):
                 ("class1", "object2", "parameter2", Map(["A", "B"], [-1.2, -2.2])),
             ),
         }
-        self._start(initial_data)
-        self.assertEqual(self._model.rowCount(), 10)
-        self.assertEqual(self._model.columnCount(), 4)
-        model_data = self._model_data()
+        model = self._start(initial_data)
+        self.assertEqual(model.rowCount(), 10)
+        self.assertEqual(model.columnCount(), 4)
+        model_data = self._model_data(model)
         expected = [
             [None, "parameter", "parameter1", "parameter2"],
             ["class1", "index", None, None],
@@ -291,12 +294,12 @@ def test_entity_without_parameter_values_does_not_show(self):
             "parameter_definitions": (("Object", "x"),),
             "entities": (("Object", "spatula"),),
         }
-        self._start(initial_data)
+        model = self._start(initial_data)
         expected = [
             [None, "parameter"],
             ["Object", "index"],
         ]
-        data = self._model_data()
+        data = self._model_data(model)
         self.assertEqual(data, expected)
 
     def test_removing_value_from_model_removes_it_from_model(self):
@@ -306,13 +309,13 @@ def test_removing_value_from_model_removes_it_from_model(self):
             "parameter_definitions": (("Object", "x"),),
             "parameter_values": (("Object", "spatula", "x", 2.3),),
         }
-        self._start(initial_data)
+        model = self._start(initial_data)
         expected = [
             [None, "parameter", "x"],
             ["Object", "index", None],
             ["spatula", "", str(2.3)],
         ]
-        data = self._model_data()
+        data = self._model_data(model)
         self.assertEqual(data, expected)
         value_item = self._db_map.get_parameter_value_item(
             entity_class_name="Object",
@@ -322,7 +325,7 @@ def test_removing_value_from_model_removes_it_from_model(self):
         )
         value_item.remove()
         expected = [[None, "parameter"], ["Object", "index"]]
-        data = self._model_data()
+        data = self._model_data(model)
         self.assertEqual(data, expected)
 
 
diff --git a/tests/spine_db_editor/mvcmodels/test_alternative_model.py b/tests/spine_db_editor/mvcmodels/test_alternative_model.py
index 2e1e89cb1..8b214fce6 100644
--- a/tests/spine_db_editor/mvcmodels/test_alternative_model.py
+++ b/tests/spine_db_editor/mvcmodels/test_alternative_model.py
@@ -202,7 +202,7 @@ def _fetch_all_recursively(model):
     for item in model.visit_all():
         while item.can_fetch_more():
             item.fetch_more()
-            qApp.processEvents()
+            qApp.processEvents()  # pylint: disable=undefined-variable
 
 
 if __name__ == "__main__":
diff --git a/tests/spine_db_editor/widgets/spine_db_editor_test_base.py b/tests/spine_db_editor/widgets/spine_db_editor_test_base.py
index caaf57303..b7cb1cd6f 100644
--- a/tests/spine_db_editor/widgets/spine_db_editor_test_base.py
+++ b/tests/spine_db_editor/widgets/spine_db_editor_test_base.py
@@ -217,4 +217,4 @@ def fetch_entity_tree_model(self):
         for item in self.spine_db_editor.entity_tree_model.visit_all():
             while item.can_fetch_more():
                 item.fetch_more()
-                qApp.processEvents()
+                qApp.processEvents()  # pylint: disable=undefined-variable
diff --git a/tests/spine_db_editor/widgets/test_add_items_dialog.py b/tests/spine_db_editor/widgets/test_add_items_dialog.py
index 80525e51e..3dc154c08 100644
--- a/tests/spine_db_editor/widgets/test_add_items_dialog.py
+++ b/tests/spine_db_editor/widgets/test_add_items_dialog.py
@@ -219,7 +219,7 @@ def test_add_entities_dialog_autofill(self):
         for item in self._db_editor.entity_tree_model.visit_all():
             while item.can_fetch_more():
                 item.fetch_more()
-                qApp.processEvents()
+                qApp.processEvents()  # pylint: disable=undefined-variable
         entity_classes = self._db_editor.entity_tree_model.root_item.children
         dialog = AddEntitiesDialog(self._db_editor, entity_classes[2], self._db_mngr, self._db_map)
         model = dialog.model
diff --git a/tests/spine_db_editor/widgets/test_custom_editors.py b/tests/spine_db_editor/widgets/test_custom_editors.py
index c74a0949b..621087dd0 100644
--- a/tests/spine_db_editor/widgets/test_custom_editors.py
+++ b/tests/spine_db_editor/widgets/test_custom_editors.py
@@ -62,7 +62,7 @@ def test_custom_line_editor(self):
 
     def test_custom_combobox_editor(self):
         with q_object(QWidget()) as parent:
-            editor = CustomComboBoxEditor(parent)
+            CustomComboBoxEditor(parent)
 
     def test_parameter_value_line_editor(self):
         with q_object(QWidget()) as parent:
diff --git a/tests/spine_db_editor/widgets/test_custom_qtableview.py b/tests/spine_db_editor/widgets/test_custom_qtableview.py
index 502abd952..c643cf80d 100644
--- a/tests/spine_db_editor/widgets/test_custom_qtableview.py
+++ b/tests/spine_db_editor/widgets/test_custom_qtableview.py
@@ -455,15 +455,15 @@ def test_sorting(self):
         url = "sqlite:///" + os.path.join(self._temp_dir.name, "test_database.sqlite")
         with DatabaseMapping(url) as db_map:
             parameter_definition_data = (
-                ("object_class", f"0parameter_"),
-                ("object_class", f"1parameter_"),
+                ("object_class", "0parameter_"),
+                ("object_class", "1parameter_"),
             )
             import_functions.import_object_parameters(db_map, parameter_definition_data)
             parameter_value_data = (
-                ("object_class", f"object_0", f"0parameter_", "a_value"),
-                ("object_class", f"object_0", f"1parameter_", "a_value"),
-                ("object_class", f"object_1", f"0parameter_", "a_value"),
-                ("object_class", f"object_1", f"1parameter_", "a_value"),
+                ("object_class", "object_0", "0parameter_", "a_value"),
+                ("object_class", "object_0", "1parameter_", "a_value"),
+                ("object_class", "object_1", "0parameter_", "a_value"),
+                ("object_class", "object_1", "1parameter_", "a_value"),
             )
             import_functions.import_object_parameter_values(db_map, parameter_value_data)
             db_map.commit_session("Add test data.")
@@ -489,8 +489,8 @@ def test_sorting(self):
             if object_n < 2:
                 expected.extend(
                     [
-                        ["object_class", f"object_{object_n}", f"0parameter_", "Base", "a_value", self.db_codename],
-                        ["object_class", f"object_{object_n}", f"1parameter_", "Base", "a_value", self.db_codename],
+                        ["object_class", f"object_{object_n}", "0parameter_", "Base", "a_value", self.db_codename],
+                        ["object_class", f"object_{object_n}", "1parameter_", "Base", "a_value", self.db_codename],
                     ]
                 )
         nd_entity_names = [f"object_{i} ǀ object_{j}" for i, j in itertools.permutations(range(self._n_ND_entities), 2)]
diff --git a/tests/spine_db_editor/widgets/test_custom_qtreeview.py b/tests/spine_db_editor/widgets/test_custom_qtreeview.py
index 89d77218b..a628a6cf7 100644
--- a/tests/spine_db_editor/widgets/test_custom_qtreeview.py
+++ b/tests/spine_db_editor/widgets/test_custom_qtreeview.py
@@ -337,7 +337,7 @@ def test_add_entity_class_with_another_class_as_preselected_first_dimension(self
         self.assertEqual(data[1].dimension_name_list, "an_entity_class")
 
     def _add_multidimensional_class(self, class_name, dimension_names):
-        item_names = {i: name for i, name in enumerate(dimension_names)}
+        item_names = dict(enumerate(dimension_names))
         item_names[len(dimension_names)] = class_name
         add_entity_tree_item(
             item_names,
@@ -347,7 +347,7 @@ def _add_multidimensional_class(self, class_name, dimension_names):
         )
 
     def _add_multidimensional_entity(self, element_name, entity_names):
-        item_names = {i: name for i, name in enumerate(entity_names)}
+        item_names = dict(enumerate(entity_names))
         item_names[len(entity_names)] = element_name
         add_entity_tree_item(item_names, self._db_editor.ui.treeView_entity, "Add entities", AddEntitiesDialog)
 
@@ -810,7 +810,7 @@ def setUp(self):
         for item in model.visit_all():
             while item.can_fetch_more():
                 item.fetch_more()
-                qApp.processEvents()
+                qApp.processEvents()  # pylint: disable=undefined-variable
 
     def tearDown(self):
         self._common_tear_down()
@@ -940,7 +940,7 @@ def test_remove_value(self):
         value_index = model.index(0, 0, list_name_index)
         view.selectionModel().setCurrentIndex(value_index, QItemSelectionModel.ClearAndSelect)
         view.remove_selected()
-        qApp.processEvents()
+        qApp.processEvents()  # pylint: disable=undefined-variable
         root_index = model.index(0, 0)
         self.assertEqual(model.rowCount(root_index), 2)
         list_name_index = model.index(0, 0, root_index)
diff --git a/tests/test_ProjectUpgrader.py b/tests/test_ProjectUpgrader.py
index 17eddde55..a2cdfda9f 100644
--- a/tests/test_ProjectUpgrader.py
+++ b/tests/test_ProjectUpgrader.py
@@ -57,9 +57,9 @@ def test_is_valid_v1(self):
         project_upgrader = ProjectUpgrader(self.toolbox)
         self.assertTrue(project_upgrader.is_valid(1, p))
         # Test that an invalid v1 project dict is not valid
-        p = dict()
-        p["project"] = dict()
-        p["objects"] = dict()
+        p = {}
+        p["project"] = {}
+        p["objects"] = {}
         self.assertFalse(project_upgrader.is_valid(1, p))
 
     def test_is_valid_v2(self):
@@ -68,9 +68,9 @@ def test_is_valid_v2(self):
         project_upgrader = ProjectUpgrader(self.toolbox)
         self.assertTrue(project_upgrader.is_valid(2, p))
         # Test that an invalid v2 project dict is not valid
-        p = dict()
-        p["project"] = dict()
-        p["items"] = dict()
+        p = {}
+        p["project"] = {}
+        p["items"] = {}
         self.assertFalse(project_upgrader.is_valid(2, p))
 
     def test_is_valid_v3(self):
@@ -79,9 +79,9 @@ def test_is_valid_v3(self):
         project_upgrader = ProjectUpgrader(self.toolbox)
         self.assertTrue(project_upgrader.is_valid(3, p))
         # Test that an invalid v3 project dict is not valid
-        p = dict()
-        p["project"] = dict()
-        p["items"] = dict()
+        p = {}
+        p["project"] = {}
+        p["items"] = {}
         self.assertFalse(project_upgrader.is_valid(3, p))
 
     def test_is_valid_v4(self):
@@ -90,9 +90,9 @@ def test_is_valid_v4(self):
         project_upgrader = ProjectUpgrader(self.toolbox)
         self.assertTrue(project_upgrader.is_valid(4, p))
         # Test that an invalid v4 project dict is not valid
-        p = dict()
-        p["project"] = dict()
-        p["items"] = dict()
+        p = {}
+        p["project"] = {}
+        p["items"] = {}
         self.assertFalse(project_upgrader.is_valid(4, p))
 
     def test_is_valid_v5(self):
@@ -101,9 +101,9 @@ def test_is_valid_v5(self):
         project_upgrader = ProjectUpgrader(self.toolbox)
         self.assertTrue(project_upgrader.is_valid(5, p))
         # Test that an invalid v5 project dict is not valid
-        p = dict()
-        p["project"] = dict()
-        p["items"] = dict()
+        p = {}
+        p["project"] = {}
+        p["items"] = {}
         self.assertFalse(project_upgrader.is_valid(5, p))
 
     def test_is_valid_v9(self):
@@ -111,9 +111,9 @@ def test_is_valid_v9(self):
         project_upgrader = ProjectUpgrader(self.toolbox)
         self.assertTrue(project_upgrader.is_valid(9, p))
         # Test that an invalid v9 project dict is not valid
-        p = dict()
-        p["project"] = dict()
-        p["items"] = dict()
+        p = {}
+        p["project"] = {}
+        p["items"] = {}
         self.assertFalse(project_upgrader.is_valid(9, p))
 
     def test_is_valid_v10(self):
@@ -121,9 +121,9 @@ def test_is_valid_v10(self):
         project_upgrader = ProjectUpgrader(self.toolbox)
         self.assertTrue(project_upgrader.is_valid(10, p))
         # Test that an invalid v10 project dict is not valid
-        p = dict()
-        p["project"] = dict()
-        p["items"] = dict()
+        p = {}
+        p["project"] = {}
+        p["items"] = {}
         self.assertFalse(project_upgrader.is_valid(10, p))
 
     def test_upgrade_v1_to_v2(self):
@@ -255,7 +255,7 @@ def test_upgrade_v4_to_v5(self):
                 # 'items' dict and that they contain a dict. Combiners should be gone in v5
                 v4_items = proj_v4["items"]
                 # Make a list of Combiner names
-                combiners = list()
+                combiners = []
                 for name, d in v4_items.items():
                     if d["type"] == "Combiner":
                         combiners.append(name)
@@ -296,7 +296,7 @@ def test_upgrade_v9_to_v10(self):
                 self.assertTrue(pu.is_valid(10, proj_v10))
                 v10_items = proj_v10["items"]
                 # Make a list of Gimlet and GdxExporter names in v9
-                names = list()
+                names = []
                 for name, d in proj_v9["items"].items():
                     if d["type"] in ["Gimlet", "GdxExporter"]:
                         names.append(name)
diff --git a/tests/test_SpineDBManager.py b/tests/test_SpineDBManager.py
index 24df4a134..1935922fd 100644
--- a/tests/test_SpineDBManager.py
+++ b/tests/test_SpineDBManager.py
@@ -623,7 +623,7 @@ def test_removing_scenario_alternative_and_committing(self):
         scenario = self._assert_success(self._db_map.add_scenario_item(name="scenario"))
         base = self._db_map.get_alternative_item(name="Base")
         next_level = self._assert_success(self._db_map.add_alternative_item(name="Next level"))
-        scen_alt_1 = self._assert_success(
+        _ = self._assert_success(
             self._db_map.add_scenario_alternative_item(scenario_id=scenario["id"], alternative_id=base["id"], rank=1)
         )
         scen_alt_2 = self._assert_success(
diff --git a/tests/test_SpineToolboxProject.py b/tests/test_SpineToolboxProject.py
index 47e569289..87ef630a5 100644
--- a/tests/test_SpineToolboxProject.py
+++ b/tests/test_SpineToolboxProject.py
@@ -93,7 +93,7 @@ def check_dag_handler(self, name):
         """Checks that project dag handler contains only one
         graph, which has one node and its name matches the
         given argument."""
-        dags = [dag for dag in self.toolbox.project()._dag_iterator()]
+        dags = list(self.toolbox.project()._dag_iterator())
         self.assertTrue(len(dags) == 1)
         g = self.toolbox.project().dag_with_node(name)
         self.assertTrue(len(g.nodes()) == 1)
@@ -178,7 +178,7 @@ def test_add_all_available_items(self):
         self.assertTrue(p.has_items())
         self.assertEqual(8, len(p.get_items()))
         # DAG handler should now have eight graphs, each with one item
-        dags = [dag for dag in self.toolbox.project()._dag_iterator()]
+        dags = list(self.toolbox.project()._dag_iterator())
         self.assertEqual(8, len(dags))
         # Check that all created items are in graphs
         ds_graph = self.toolbox.project().dag_with_node(ds_name)
@@ -261,7 +261,7 @@ def _execute_project(self, names=None):
             # This mocks the check for engineSettings/remoteEngineEnabled in SpineToolboxProject.execute_dags()
             mock_qsettings_value.side_effect = qsettings_value_side_effect
             # This mocks the call to make_settings_dict_for_engine in SpineToolboxProject._execute_dags()
-            mock_settings_dict.return_value = dict()
+            mock_settings_dict.return_value = {}
             if not names:
                 self.toolbox.project().execute_project()
             else:
@@ -434,7 +434,7 @@ def test_rename_item(self):
             project.connections,
             [LoggingConnection("renamed source", "left", destination_name, "right", toolbox=self.toolbox)],
         )
-        dags = [dag for dag in project._dag_iterator()]
+        dags = list(project._dag_iterator())
         self.assertEqual(len(dags), 1)
         self.assertEqual(node_successors(dags[0]), {"destination": [], "renamed source": ["destination"]})
         self.assertEqual(source_item.get_icon().name(), "renamed source")
diff --git a/tests/test_ToolboxUI.py b/tests/test_ToolboxUI.py
index d787c6e6a..57c1c5b1b 100644
--- a/tests/test_ToolboxUI.py
+++ b/tests/test_ToolboxUI.py
@@ -142,7 +142,7 @@ def test_open_project(self):
         self.assertEqual(len(links_d), 1)
         self.assertEqual(links_c[0], links_d[0])
         # Check that DAG graph is correct
-        dags = [dag for dag in self.toolbox.project()._dag_iterator()]
+        dags = list(self.toolbox.project()._dag_iterator())
         self.assertTrue(len(dags) == 1)  # Only one graph
         g = dags[0]
         self.assertTrue(len(g.nodes()) == 4)  # graph has four nodes
@@ -526,7 +526,7 @@ def test_remove_item(self):
         n_items = self.toolbox.project().n_items
         self.assertEqual(n_items, 1)
         # Check DAG handler
-        dags = [dag for dag in self.toolbox.project()._dag_iterator()]
+        dags = list(self.toolbox.project()._dag_iterator())
         self.assertEqual(1, len(dags))  # Number of DAGs (DiGraph objects) in project
         self.assertEqual(1, len(dags[0].nodes()))  # Number of nodes in the DiGraph
         # Check number of items in Design View
@@ -538,7 +538,7 @@ def test_remove_item(self):
             mock_message_box_exec.return_value = QMessageBox.StandardButton.Ok
             self.toolbox.ui.actionRemove.trigger()
         self.assertEqual(self.toolbox.project().n_items, 0)  # Check the number of project items
-        dags = [dag for dag in self.toolbox.project()._dag_iterator()]
+        dags = list(self.toolbox.project()._dag_iterator())
         self.assertEqual(0, len(dags))  # Number of DAGs (DiGraph) objects in project
         item_icons = self.toolbox.ui.graphicsView.scene().project_item_icons()
         self.assertEqual(len(item_icons), 0)
@@ -832,8 +832,7 @@ def _tasks_before_exit_scenario_6(key, defaultValue="2"):
 
 
 class MockDraggableButton(ProjectItemDragMixin, NiceButton):
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
+    """Mocked draggable button"""
 
 
 class TestToolboxUIWithTestSettings(unittest.TestCase):
diff --git a/tests/test_helpers.py b/tests/test_helpers.py
index af9dade00..7c4157a26 100644
--- a/tests/test_helpers.py
+++ b/tests/test_helpers.py
@@ -63,7 +63,7 @@ def setUpClass(cls):
             QApplication()
 
     def test_format_log_message(self):
-        stamp_pattern = re.compile("\[\d\d-\d\d-\d\d\d\d \d\d:\d\d:\d\d]")
+        stamp_pattern = re.compile(r"\[\d\d-\d\d-\d\d\d\d \d\d:\d\d:\d\d]")
         message = "test msg"
 
         def test_correctness(message_type, expected_color):
@@ -134,8 +134,8 @@ def test_rename_dir_prompts_user_if_target_exists(self):
 
     def test_get_datetime(self):
         self.assertEqual(get_datetime(False), "")
-        self.assertIsNotNone(re.match("\[\d\d-\d\d-\d\d\d\d \d\d:\d\d:\d\d]", get_datetime(True)))
-        self.assertIsNotNone(re.match("\[\d\d:\d\d:\d\d]", get_datetime(True, False)))
+        self.assertIsNotNone(re.match(r"\[\d\d-\d\d-\d\d\d\d \d\d:\d\d:\d\d]", get_datetime(True)))
+        self.assertIsNotNone(re.match(r"\[\d\d:\d\d:\d\d]", get_datetime(True, False)))
 
     def test_copy_files(self):
         with TemporaryDirectory() as temp_dir:
@@ -206,8 +206,8 @@ def test_recursive_overwrite(self):
             overwritten_file.touch()
             logger = MagicMock()
             recursive_overwrite(logger, str(source_dir), str(destination_dir))
-            with open(overwritten_file) as input:
-                self.assertEqual(input.readline(), "source")
+            with open(overwritten_file) as input_:
+                self.assertEqual(input_.readline(), "source")
 
     def test_tuple_itemgetter(self):
         def first(t):
@@ -339,12 +339,12 @@ def test_file_is_valid(self):
         with TemporaryDirectory() as temp_dir:
             file_path = Path(temp_dir, "file")
             file_path.touch()
-            with patch("spinetoolbox.helpers.QMessageBox") as message_box:
+            with patch("spinetoolbox.helpers.QMessageBox"):
                 self.assertTrue(file_is_valid(None, str(file_path), "Message title"))
 
     def test_dir_is_valid(self):
         with TemporaryDirectory() as temp_dir:
-            with patch("spinetoolbox.helpers.QMessageBox") as message_box:
+            with patch("spinetoolbox.helpers.QMessageBox"):
                 self.assertTrue(dir_is_valid(None, temp_dir, "Message title"))
 
     def test_unique_name(self):
diff --git a/tests/test_plotting.py b/tests/test_plotting.py
index cb8878707..be984b5d0 100644
--- a/tests/test_plotting.py
+++ b/tests/test_plotting.py
@@ -55,10 +55,7 @@ def _add_object_parameter_values(self, values):
         self._db_mngr.add_entities(
             {self._db_map: [{"class_id": 1, "name": f"o{i + 1}", "id": i + 1} for i in range(object_count)]}
         )
-        db_values = {
-            name: [(value, type_) for value, type_ in map(to_database, value_list)]
-            for name, value_list in values.items()
-        }
+        db_values = {name: list(map(to_database, value_list)) for name, value_list in values.items()}
         value_items = [
             {
                 "entity_class_id": 1,
@@ -257,14 +254,14 @@ def test_multiple_columns_selected_plots_on_two_y_axes(self):
             )
             lines = plot_widget.canvas.axes.get_lines()
             self.assertEqual(len(lines), 3)
-            for i in range(3):
+            for _ in range(3):
                 self.assertEqual(list(lines[0].get_xdata(orig=True)), ["Base"])
             self.assertEqual(list(lines[0].get_ydata(orig=True)), [1.1])
             self.assertEqual(list(lines[1].get_ydata(orig=True)), [1.2])
             self.assertEqual(list(lines[2].get_ydata(orig=True)), [1.3])
             lines = twinned[0].get_lines()
             self.assertEqual(len(lines), 3)
-            for i in range(3):
+            for _ in range(3):
                 self.assertEqual(list(lines[0].get_xdata(orig=True)), ["Base"])
             self.assertEqual(list(lines[0].get_ydata(orig=True)), [-3.0])
             self.assertEqual(list(lines[1].get_ydata(orig=True)), [-1.0])
diff --git a/tests/test_spine_db_fetcher.py b/tests/test_spine_db_fetcher.py
index 0aeb561d3..55a928067 100644
--- a/tests/test_spine_db_fetcher.py
+++ b/tests/test_spine_db_fetcher.py
@@ -48,7 +48,7 @@ def test_fetch_empty_database(self):
             fetcher = TestItemTypeFetchParent(item_type)
             while self._db_mngr.can_fetch_more(self._db_map, fetcher):
                 self._db_mngr.fetch_more(self._db_map, fetcher)
-                qApp.processEvents()
+                qApp.processEvents()  # pylint: disable=undefined-variable
             if item_type in ("alternative", "commit"):
                 fetcher.handle_items_added.assert_called_once()
             else:
diff --git a/tests/widgets/test_ArrayTableView.py b/tests/widgets/test_ArrayTableView.py
index e14b871d6..18a7db8ba 100644
--- a/tests/widgets/test_ArrayTableView.py
+++ b/tests/widgets/test_ArrayTableView.py
@@ -52,7 +52,7 @@ def test_copy_single_non_numeric_cell(self):
         table_view.selectionModel().select(index, QItemSelectionModel.Select)
         self.assertTrue(table_view.copy())
         clip = StringIO(QApplication.clipboard().text())
-        array = [row for row in csv.reader(clip)]
+        array = list(csv.reader(clip))
         self.assertEqual(array, [["a"]])
         table_view.deleteLater()
 
@@ -65,7 +65,7 @@ def test_copy_single_numeric_cell(self):
         table_view.selectionModel().select(index, QItemSelectionModel.Select)
         self.assertTrue(table_view.copy())
         clip = StringIO(QApplication.clipboard().text())
-        array = [row for row in csv.reader(clip, delimiter="\t")]
+        array = list(csv.reader(clip, delimiter="\t"))
         with system_lc_numeric():
             self.assertEqual(array, [[locale.str(5.5)]])
         table_view.deleteLater()
@@ -80,7 +80,7 @@ def test_copy_does_not_copy_expansion_row(self):
                 table_view.selectionModel().select(model.index(row, column), QItemSelectionModel.Select)
         self.assertTrue(table_view.copy())
         clip = StringIO(QApplication.clipboard().text())
-        array = [row for row in csv.reader(clip, delimiter="\t")]
+        array = list(csv.reader(clip, delimiter="\t"))
         with system_lc_numeric():
             self.assertEqual(array, [["0", locale.str(5.5)]])
         table_view.deleteLater()
diff --git a/tests/widgets/test_CopyPasteTableView.py b/tests/widgets/test_CopyPasteTableView.py
index 6ebe19c0f..185b01b3c 100644
--- a/tests/widgets/test_CopyPasteTableView.py
+++ b/tests/widgets/test_CopyPasteTableView.py
@@ -44,8 +44,8 @@ def headerData(self, section, orientation, role=Qt.ItemDataRole.DisplayRole):
         if role not in (Qt.ItemDataRole.DisplayRole, Qt.ItemDataRole.EditRole):
             return None
         if orientation == Qt.Orientation.Horizontal:
-            return "Column {}".format(section)
-        return "Row {}".format(section)
+            return f"Column {section}"
+        return f"Row {section}"
 
     def insertColumns(self, column, count, parent=QModelIndex()):
         self.beginInsertColumns(parent, column, column + count)
@@ -137,7 +137,7 @@ def test_paste_single_localized_row(self):
         view.setModel(model)
         selection_model = view.selectionModel()
         selection_model.select(model.index(0, 0), QItemSelectionModel.Rows | QItemSelectionModel.Select)
-        QApplication.clipboard().setText("A\tB\t{}".format(locale.str(-1.1)))
+        QApplication.clipboard().setText(f"A\tB\t{locale.str(-1.1)}")
         self.assertTrue(view.paste())
         self.assertEqual(model.index(0, 0).data(), "A")
         self.assertEqual(model.index(0, 1).data(), "B")
diff --git a/tests/widgets/test_IndexedValueTableView.py b/tests/widgets/test_IndexedValueTableView.py
index f821b33e3..8750924dc 100644
--- a/tests/widgets/test_IndexedValueTableView.py
+++ b/tests/widgets/test_IndexedValueTableView.py
@@ -102,7 +102,7 @@ def test_pasting_multiple_columns_to_last_row_expands_model(self):
         selection_model = self._table_view.selectionModel()
         model = self._table_view.model()
         selection_model.select(model.index(3, 1), QItemSelectionModel.Select)
-        copied_data = "2019-08-08T17:00\t{:n}\n2019-08-08T18:00\t{:n}".format(-4.4, -5.5)
+        copied_data = f"2019-08-08T17:00\t{-4.4}\n2019-08-08T18:00\t{-5.5}"
         QApplication.clipboard().setText(copied_data)
         self._table_view.paste()
         series = TimeSeriesVariableResolution(
@@ -135,7 +135,7 @@ def test_paste_to_multirow_selection_limits_pasted_data(self):
         selection_model.select(model.index(1, 1), QItemSelectionModel.Select)
         selection_model.select(model.index(2, 0), QItemSelectionModel.Select)
         selection_model.select(model.index(2, 1), QItemSelectionModel.Select)
-        copied_data = "2019-08-08T12:30\t{:n}\n2019-08-08T13:30\t{:n}\n2019-08-08T14:30\t{:n}".format(-2.2, -3.3, -4.4)
+        copied_data = f"2019-08-08T12:30\t{-2.2}\n2019-08-08T13:30\t{-3.3}\n2019-08-08T14:30\t{-4.4}"
         QApplication.clipboard().setText(copied_data)
         self._table_view.paste()
         series = TimeSeriesVariableResolution(
@@ -155,7 +155,7 @@ def test_paste_to_larger_selection_overrides_first_rows_only(self):
         selection_model.select(model.index(1, 1), QItemSelectionModel.Select)
         selection_model.select(model.index(2, 0), QItemSelectionModel.Select)
         selection_model.select(model.index(2, 1), QItemSelectionModel.Select)
-        copied_data = "2019-08-08T12:30\t{:n}\n2019-08-08T13:30\t{:n}".format(-1.1, -2.2)
+        copied_data = f"2019-08-08T12:30\t{-1.1}\n2019-08-08T13:30\t{-2.2}"
         QApplication.clipboard().setText(copied_data)
         self._table_view.paste()
         series = TimeSeriesVariableResolution(
diff --git a/tests/widgets/test_JupyterConsoleWidget.py b/tests/widgets/test_JupyterConsoleWidget.py
index 5b977cf1b..49dbe1835 100644
--- a/tests/widgets/test_JupyterConsoleWidget.py
+++ b/tests/widgets/test_JupyterConsoleWidget.py
@@ -100,7 +100,7 @@ def test_connect_jcw_to_kernel_manager_on_engine(self):
         self.assertEqual(1, _kernel_manager_factory.n_kernel_managers())
         # Replace QtKernelClient class with a custom one
         # Inspired by jupyter_client/tests/test_client.py
-        with mock.patch("spinetoolbox.widgets.jupyter_console_widget.QtKernelClient", new=CustomQtKernelClient) as mtkc:
+        with mock.patch("spinetoolbox.widgets.jupyter_console_widget.QtKernelClient", new=CustomQtKernelClient):
             jcw.connect_to_kernel()
         jcw.kernel_client.shell_channel.kernel_info_event.wait(timeout=10)  # Wait until we get a kernel_info_reply
         kernel_info_reply = jcw.kernel_client.shell_channel.last_msg
@@ -137,7 +137,7 @@ def test_restart_when_kernel_manager_is_running(self):
         self.assertEqual(1, _kernel_manager_factory.n_kernel_managers())
         # Replace QtKernelClient class with a custom one
         # Inspired by jupyter_client/tests/test_client.py
-        with mock.patch("spinetoolbox.widgets.jupyter_console_widget.QtKernelClient", new=CustomQtKernelClient) as mtkc:
+        with mock.patch("spinetoolbox.widgets.jupyter_console_widget.QtKernelClient", new=CustomQtKernelClient):
             jcw.connect_to_kernel()
         jcw.kernel_client.shell_channel.kernel_info_event.wait(timeout=10)  # Wait until we get a kernel_info_reply
         kernel_info_reply = jcw.kernel_client.shell_channel.last_msg
@@ -153,7 +153,7 @@ def test_restart_when_kernel_manager_is_running(self):
         )
         # Restart kernel manager
         jcw.kernel_client.shell_channel.kernel_info_event.clear()
-        with mock.patch("spinetoolbox.widgets.jupyter_console_widget.QtKernelClient", new=CustomQtKernelClient) as mtkc:
+        with mock.patch("spinetoolbox.widgets.jupyter_console_widget.QtKernelClient", new=CustomQtKernelClient):
             jcw.request_restart_kernel_manager()
         jcw.kernel_client.shell_channel.kernel_info_event.wait(timeout=10)
         kernel_info_reply = jcw.kernel_client.shell_channel.last_msg
@@ -175,7 +175,7 @@ def test_restart_when_kernel_manager_is_not_running(self):
         self.assertEqual(1, _kernel_manager_factory.n_kernel_managers())
         # Replace QtKernelClient class with a custom one
         # Inspired by jupyter_client/tests/test_client.py
-        with mock.patch("spinetoolbox.widgets.jupyter_console_widget.QtKernelClient", new=CustomQtKernelClient) as mtkc:
+        with mock.patch("spinetoolbox.widgets.jupyter_console_widget.QtKernelClient", new=CustomQtKernelClient):
             jcw.connect_to_kernel()
         jcw.kernel_client.shell_channel.kernel_info_event.wait(timeout=10)  # Wait until we get a kernel_info_reply
         kernel_info_reply = jcw.kernel_client.shell_channel.last_msg
@@ -198,7 +198,7 @@ def test_restart_when_kernel_manager_is_not_running(self):
         self.assertIsNone(jcw.kernel_client)
         # Restart kernel manager
         # jcw.kernel_client.shell_channel.kernel_info_event.clear()
-        with mock.patch("spinetoolbox.widgets.jupyter_console_widget.QtKernelClient", new=CustomQtKernelClient) as mtkc:
+        with mock.patch("spinetoolbox.widgets.jupyter_console_widget.QtKernelClient", new=CustomQtKernelClient):
             jcw.request_restart_kernel_manager()
         jcw.kernel_client.shell_channel.kernel_info_event.wait(timeout=10)
         kernel_info_reply = jcw.kernel_client.shell_channel.last_msg
@@ -220,7 +220,7 @@ def test_close_console_by_typing_exit(self):
         self.assertEqual(1, _kernel_manager_factory.n_kernel_managers())
         # Replace QtKernelClient class with a custom one
         # Inspired by jupyter_client/tests/test_client.py
-        with mock.patch("spinetoolbox.widgets.jupyter_console_widget.QtKernelClient", new=CustomQtKernelClient) as mtkc:
+        with mock.patch("spinetoolbox.widgets.jupyter_console_widget.QtKernelClient", new=CustomQtKernelClient):
             jcw.connect_to_kernel()
         jcw.kernel_client.shell_channel.kernel_info_event.wait(timeout=10)  # Wait until we get a kernel_info_reply
         kernel_info_reply = jcw.kernel_client.shell_channel.last_msg
diff --git a/tests/widgets/test_MapTableView.py b/tests/widgets/test_MapTableView.py
index 004a7db32..21f40fb0e 100644
--- a/tests/widgets/test_MapTableView.py
+++ b/tests/widgets/test_MapTableView.py
@@ -49,7 +49,7 @@ def test_copy_selection(self):
             table_view.selectionModel().select(model.index(0, column), QItemSelectionModel.Select)
         self.assertTrue(table_view.copy())
         clip = StringIO(QApplication.clipboard().text())
-        table = [row for row in csv.reader(clip, delimiter="\t")]
+        table = list(csv.reader(clip, delimiter="\t"))
         with system_lc_numeric():
             self.assertEqual(table, [["A", locale.str(2.3)]])
         table_view.deleteLater()
@@ -63,7 +63,7 @@ def test_copy_selection_does_not_copy_expanse_row_or_column(self):
                 table_view.selectionModel().select(model.index(row, column), QItemSelectionModel.Select)
         self.assertTrue(table_view.copy())
         clip = StringIO(QApplication.clipboard().text())
-        table = [row for row in csv.reader(clip, delimiter="\t")]
+        table = list(csv.reader(clip, delimiter="\t"))
         with system_lc_numeric():
             self.assertEqual(table, [["A", locale.str(2.3)]])
         table_view.deleteLater()
@@ -109,7 +109,6 @@ def test_paste_large_data_to_small_selection_cuts_data(self):
         self.assertTrue(table_view.paste())
         self.assertEqual(model.rowCount(), 4)
         self.assertEqual(model.columnCount(), 3)
-        m = model.value()
         self.assertEqual(model.value(), Map(["Q", "V", "C"], [2.3, 3.2, 4.3]))
         table_view.deleteLater()
 
diff --git a/tests/widgets/test_ParameterValueEditor.py b/tests/widgets/test_ParameterValueEditor.py
index 887ddcf17..fa9deb3b9 100644
--- a/tests/widgets/test_ParameterValueEditor.py
+++ b/tests/widgets/test_ParameterValueEditor.py
@@ -55,7 +55,8 @@ def setData(self, index, value, role=Qt.ItemDataRole.EditRole):
     def get_set_data_delayed(self, index):
         return lambda value, index=index: self.setData(index, value)
 
-    def index_name(self, index):  # pylint: disable=no-self-use
+    @staticmethod
+    def index_name(index):
         return "index_name"
 
 
diff --git a/tests/widgets/test_custom_combobox.py b/tests/widgets/test_custom_combobox.py
index 7ed6cd842..8dd83b90d 100644
--- a/tests/widgets/test_custom_combobox.py
+++ b/tests/widgets/test_custom_combobox.py
@@ -25,14 +25,14 @@ def setUpClass(cls):
             QApplication()
 
     def test_custom_combobox(self):
-        self.parent = QWidget()
-        cb = CustomQComboBox(self.parent)
+        parent = QWidget()
+        cb = CustomQComboBox(parent)
         cb.addItems(["a", "b", "c"])
         self.assertEqual("a", cb.itemText(0))
-        self.parent.deleteLater()
+        parent.deleteLater()
 
     def test_elided_combobox(self):
-        self.parent = QWidget()
-        cb = ElidedCombobox(self.parent)
+        parent = QWidget()
+        cb = ElidedCombobox(parent)
         cb.paintEvent(QPaintEvent(cb.rect()))
-        self.parent.deleteLater()
+        parent.deleteLater()
diff --git a/tests/widgets/test_custom_qgraphicsscene.py b/tests/widgets/test_custom_qgraphicsscene.py
index 4719e360f..b6e3aab68 100644
--- a/tests/widgets/test_custom_qgraphicsscene.py
+++ b/tests/widgets/test_custom_qgraphicsscene.py
@@ -27,7 +27,7 @@ def setUpClass(cls):
     def test_center_items(self):
         scene = CustomGraphicsScene()
         rect = scene.addRect(-120.0, 66.0, 1.0, 1.0)
-        child_rect = QGraphicsRectItem(23.3, -5.5, 0.3, 0.3, rect)
+        child_rect = QGraphicsRectItem(23.3, -5.5, 0.3, 0.3, rect)  # pylint: disable=unused-variable
         scene.center_items()
         self.assertEqual(scene.itemsBoundingRect(), scene.sceneRect())
         scene.deleteLater()
diff --git a/tests/widgets/test_custom_qlineedits.py b/tests/widgets/test_custom_qlineedits.py
index 10c860433..3ecc09dad 100644
--- a/tests/widgets/test_custom_qlineedits.py
+++ b/tests/widgets/test_custom_qlineedits.py
@@ -23,8 +23,8 @@ def setUpClass(cls):
             QApplication()
 
     def test_property_qlineedit(self):
-        self.parent = QWidget()
-        le = PropertyQLineEdit(self.parent)
+        parent = QWidget()
+        le = PropertyQLineEdit(parent)
         le.setText("abc")
         self.assertEqual("abc", le.text())
-        self.parent.deleteLater()
+        parent.deleteLater()
diff --git a/tests/widgets/test_kernel_editor.py b/tests/widgets/test_kernel_editor.py
index 6047318be..bf0e8c146 100644
--- a/tests/widgets/test_kernel_editor.py
+++ b/tests/widgets/test_kernel_editor.py
@@ -72,7 +72,9 @@ def test_make_python_kernel(self):
                     QApplication.processEvents()
                 editor.close()
             completion = subprocess.run(
-                [str(python_path), "-m", "jupyter", "kernelspec", "remove", "-f", kernel_name], capture_output=True
+                [str(python_path), "-m", "jupyter", "kernelspec", "remove", "-f", kernel_name],
+                capture_output=True,
+                check=False,
             )
             self.assertEqual(completion.returncode, 0)
 
@@ -104,7 +106,9 @@ def test_make_julia_kernel(self):
                 QApplication.processEvents()
             editor.close()
         completion = subprocess.run(
-            [sys.executable, "-m", "jupyter", "kernelspec", "list", "--json", kernel_name], capture_output=True
+            [sys.executable, "-m", "jupyter", "kernelspec", "list", "--json", kernel_name],
+            capture_output=True,
+            check=False,
         )
         real_kernel_name = None
         kernel_info = json.loads(completion.stdout)
@@ -118,8 +122,10 @@ def test_make_julia_kernel(self):
             # on Windows platforms preventing removal.
             # This removes the read only flag.
             kernelspec_dir = kernel_info["kernelspecs"][real_kernel_name]["resource_dir"]
-            subprocess.run(["attrib", "-r", str(pathlib.Path(kernelspec_dir, "*.*"))])
+            subprocess.run(["attrib", "-r", str(pathlib.Path(kernelspec_dir, "*.*"))], check=False)
         completion = subprocess.run(
-            [sys.executable, "-m", "jupyter", "kernelspec", "remove", "-f", real_kernel_name], capture_output=True
+            [sys.executable, "-m", "jupyter", "kernelspec", "remove", "-f", real_kernel_name],
+            capture_output=True,
+            check=False,
         )
         self.assertEqual(completion.returncode, 0)
diff --git a/tests/widgets/test_open_project_dialog.py b/tests/widgets/test_open_project_dialog.py
index e8f89a22e..8a94ebdcf 100644
--- a/tests/widgets/test_open_project_dialog.py
+++ b/tests/widgets/test_open_project_dialog.py
@@ -26,8 +26,8 @@ def setUpClass(cls):
             QApplication()
 
     def test_open_project_dialog(self):
-        self._widget = QWidget()
-        opw = OpenProjectDialog(DummyToolbox(self._widget))
+        widget = QWidget()
+        opw = OpenProjectDialog(DummyToolbox(widget))
         opw.go_root_action.trigger()
         opw.go_home_action.trigger()
         opw.go_documents_action.trigger()
@@ -41,10 +41,10 @@ def test_open_project_dialog(self):
         opw.close()
 
     def test_update_recents_remove_recents(self):
-        self._widget = QWidget()
+        widget = QWidget()
         with TemporaryDirectory() as temp_dir1:
             with TemporaryDirectory() as temp_dir2:
-                opw = OpenProjectDialog(DummyToolbox(self._widget))
+                opw = OpenProjectDialog(DummyToolbox(widget))
                 opw.expand_and_resize(temp_dir1)
                 # Add path
                 opw.update_recents(temp_dir1, opw._qsettings)
@@ -92,7 +92,7 @@ def setValue(self, key, value):
         """Returns without modifying anything."""
         if key == "appSettings/recentProjectStorages":
             self.recent_storages = value
-        return
 
-    def sync(self):
+    @staticmethod
+    def sync():
         return True
diff --git a/tests/widgets/test_plugin_manager_widgets.py b/tests/widgets/test_plugin_manager_widgets.py
index 73a92a7a9..953af925a 100644
--- a/tests/widgets/test_plugin_manager_widgets.py
+++ b/tests/widgets/test_plugin_manager_widgets.py
@@ -23,16 +23,16 @@ def setUpClass(cls):
             QApplication()
 
     def test_install_plugins_dialog(self):
-        self._parent = QWidget()
-        d = InstallPluginDialog(self._parent)
+        parent = QWidget()
+        d = InstallPluginDialog(parent)
         d.populate_list(["Plugin1", "Plugin2"])
         d.close()
-        self._parent.deleteLater()
+        parent.deleteLater()
 
     def test_manage_plugins_dialog(self):
-        self._parent = QWidget()
-        d = ManagePluginsDialog(self._parent)
+        parent = QWidget()
+        d = ManagePluginsDialog(parent)
         d.populate_list([("Plugin", True)])
         d._emit_item_removed("Plugin")
         d.close()
-        self._parent.deleteLater()
+        parent.deleteLater()