[pitivi] Fix pylint unused-*

[Thibault Saunier <tsaunier src gnome org>]

commit e3d678b09f160ff3d3269be5f463023fb6629813
Author: Alexandru Băluț <alexandru balut gmail com>
Date:   Fri Nov 1 07:49:49 2019 +0100

    Fix pylint unused-*

 tests/common.py             |  8 ++++----
 tests/test_project.py       | 20 +++++++++---------
 tests/test_undo.py          | 50 ++++++++++++++++++++++-----------------------
 tests/test_undo_timeline.py | 18 ++++++++--------
 4 files changed, 48 insertions(+), 48 deletions(-)
---
diff --git a/tests/common.py b/tests/common.py
index 9f39ea15..9b383ef4 100644
--- a/tests/common.py
+++ b/tests/common.py
@@ -50,16 +50,16 @@ from pitivi.utils.timeline import Selected
 from pitivi.utils.timeline import Zoomable
 
 
-def handle_uncaught_exception(exctype, value, trace):
+def handle_uncaught_exception_func(exctype, value, trace):
     traceback.print_tb(trace)
     print(value, file=sys.stderr)
     sys.exit(1)
 
 
-sys.excepthook = handle_uncaught_exception
+sys.excepthook = handle_uncaught_exception_func
 
 
-def handle_glog(domain, level, message, udata):
+def handle_glog_func(domain, level, message, udata):
     Gst.debug_print_stack_trace()
     traceback.print_stack()
     print("%s - %s" % (domain, message), file=sys.stderr)
@@ -69,7 +69,7 @@ def handle_glog(domain, level, message, udata):
 # GStreamer Not enabled because of an assertion on caps on the CI server.
 # See https://gitlab.gnome.org/thiblahute/pitivi/-/jobs/66570
 for category in ["Gtk", "Gdk", "GLib-GObject", "GES"]:
-    GLib.log_set_handler(category, GLib.LogLevelFlags.LEVEL_CRITICAL, handle_glog, None)
+    GLib.log_set_handler(category, GLib.LogLevelFlags.LEVEL_CRITICAL, handle_glog_func, None)
 
 detect_leaks = os.environ.get("PITIVI_TEST_DETECT_LEAKS", "0") not in ("0", "")
 os.environ["PITIVI_USER_CACHE_DIR"] = tempfile.mkdtemp(suffix="pitiviTestsuite")
diff --git a/tests/test_project.py b/tests/test_project.py
index 2807dde6..f0af3ada 100644
--- a/tests/test_project.py
+++ b/tests/test_project.py
@@ -40,13 +40,13 @@ class ProjectManagerListener():
 
     def __init__(self, manager):
         self.manager = manager
-        self.connectToProjectManager(self.manager)
+        self.connectToProjectManager()
         self._reset()
 
     def _reset(self):
         self.signals = []
 
-    def connectToProjectManager(self, manager):
+    def connectToProjectManager(self):
         for signal in ("new-project-loading", "new-project-loaded",
                        "new-project-created", "new-project-failed", "missing-uri",
                        "closing-project", "project-closed"):
@@ -91,13 +91,13 @@ class TestProjectManager(common.TestCase):
     def test_new_blank_project_signals(self):
         self.manager.new_blank_project()
 
-        name, args = self.signals[0]
+        name, _args = self.signals[0]
         self.assertEqual("new-project-loading", name, self.signals)
 
-        name, args = self.signals[1]
+        name, _args = self.signals[1]
         self.assertEqual("new-project-created", name, self.signals)
 
-        name, args = self.signals[2]
+        name, _args = self.signals[2]
         self.assertEqual("new-project-loaded", name, self.signals)
 
     def testMissingUriForwarded(self):
@@ -265,13 +265,13 @@ class TestProjectLoading(common.TestCase):
     def test_loaded_callback(self):
         mainloop = common.create_main_loop()
 
-        def loaded(project, timeline):
+        def loaded_cb(project, timeline):
             # If not called, the timeout of the mainloop will fail the test.
             mainloop.quit()
 
         # Create a blank project and save it.
         project = common.create_project()
-        project.connect("loaded", loaded)
+        project.connect("loaded", loaded_cb)
         mainloop.run()
         # The blank project loading succeeded emitting signal "loaded".
 
@@ -286,7 +286,7 @@ class TestProjectLoading(common.TestCase):
             project.save(project.ges_timeline, uri, None, overwrite=True)
 
             project2 = common.create_project()
-            project2.connect("loaded", loaded)
+            project2.connect("loaded", loaded_cb)
             mainloop.run()
             # The blank project loading succeeded emitting signal "loaded".
 
@@ -377,7 +377,7 @@ class TestProjectLoading(common.TestCase):
     def test_load_project_with_missing_proxy(self):
         """Checks loading a project with missing proxies."""
         with common.cloned_sample("1sec_simpsons_trailer.mp4"):
-            mainloop, app, medialib, proxy_uri = self.load_project_with_missing_proxy()
+            mainloop, _app, medialib, proxy_uri = self.load_project_with_missing_proxy()
             mainloop.run()
 
         self.assertEqual(len(medialib.storemodel), 1)
@@ -395,7 +395,7 @@ class TestProjectLoading(common.TestCase):
             # This way we are sure it will not finish before we test
             # the state while it is being rebuilt.
             with mock.patch.object(GstTranscoder.Transcoder, "run_async"):
-                mainloop, app, medialib, proxy_uri = self.load_project_with_missing_proxy()
+                mainloop, app, medialib, _proxy_uri = self.load_project_with_missing_proxy()
                 uri = common.get_sample_uri("1sec_simpsons_trailer.mp4")
 
                 app.project_manager.connect("new-project-loaded", lambda x, y: mainloop.quit())
diff --git a/tests/test_undo.py b/tests/test_undo.py
index 1b879dc2..7df991bb 100644
--- a/tests/test_undo.py
+++ b/tests/test_undo.py
@@ -87,19 +87,19 @@ class TestUndoableActionLog(common.TestCase):
         self.signals = []
 
     def tearDown(self):
-        self._disconnectFromUndoableActionLog(self.log)
+        self._disconnect_from_undoable_action_log()
 
-    def _undoActionLogSignalCb(self, log, *args):
+    def _undo_action_log_signal_cb(self, log, *args):
         args = list(args)
         signal_name = args.pop(-1)
         self.signals.append((signal_name, args))
 
     def _connectToUndoableActionLog(self, log):
         for signal_name in ("begin", "push", "rollback", "commit", "move"):
-            log.connect(signal_name, self._undoActionLogSignalCb, signal_name)
+            log.connect(signal_name, self._undo_action_log_signal_cb, signal_name)
 
-    def _disconnectFromUndoableActionLog(self, log):
-        self.log.disconnect_by_func(self._undoActionLogSignalCb)
+    def _disconnect_from_undoable_action_log(self):
+        self.log.disconnect_by_func(self._undo_action_log_signal_cb)
 
     def testRollbackWrongState(self):
         self.assertRaises(UndoWrongStateError, self.log.rollback)
@@ -144,7 +144,7 @@ class TestUndoableActionLog(common.TestCase):
         self.assertEqual(len(self.log.redo_stacks), 0)
         self.log.begin("meh")
         self.assertEqual(len(self.signals), 1)
-        name, (stack,) = self.signals[0]
+        name, (_stack,) = self.signals[0]
         self.assertEqual(name, "begin")
         self.assertTrue(self.log.is_in_transaction())
 
@@ -152,9 +152,9 @@ class TestUndoableActionLog(common.TestCase):
         self.log.push(mock.Mock(spec=UndoableAction))
         self.log.commit("meh")
         self.assertEqual(len(self.signals), 3)
-        name, (stack, action) = self.signals[1]
+        name, (_stack, _action) = self.signals[1]
         self.assertEqual(name, "push")
-        name, (stack,) = self.signals[2]
+        name, (_stack,) = self.signals[2]
         self.assertEqual(name, "commit")
         self.assertFalse(self.log.is_in_transaction())
         self.assertEqual(len(self.log.undo_stacks), 1)
@@ -170,7 +170,7 @@ class TestUndoableActionLog(common.TestCase):
         self.assertEqual(len(self.log.redo_stacks), 0)
         self.log.begin("meh")
         self.assertEqual(len(self.signals), 1)
-        name, (stack,) = self.signals[0]
+        name, (_stack,) = self.signals[0]
         self.assertEqual(name, "begin")
         self.assertTrue(self.log.is_in_transaction())
 
@@ -178,7 +178,7 @@ class TestUndoableActionLog(common.TestCase):
         self.assertEqual(len(self.log.redo_stacks), 0)
         self.log.begin("nested")
         self.assertEqual(len(self.signals), 2)
-        name, (stack,) = self.signals[1]
+        name, (_stack,) = self.signals[1]
         self.assertEqual(name, "begin")
         self.assertTrue(self.log.is_in_transaction())
 
@@ -186,9 +186,9 @@ class TestUndoableActionLog(common.TestCase):
         self.log.push(mock.Mock(spec=UndoableAction))
         self.log.commit("nested")
         self.assertEqual(len(self.signals), 4)
-        name, (stack, action) = self.signals[2]
+        name, (_stack, _action) = self.signals[2]
         self.assertEqual(name, "push")
-        name, (stack,) = self.signals[3]
+        name, (_stack,) = self.signals[3]
         self.assertEqual(name, "commit")
         self.assertTrue(self.log.is_in_transaction())
         self.assertEqual(len(self.log.undo_stacks), 0)
@@ -197,7 +197,7 @@ class TestUndoableActionLog(common.TestCase):
         self.assertEqual(self.log.undo_stacks, [])
         self.log.commit("meh")
         self.assertEqual(len(self.signals), 5)
-        name, (stack,) = self.signals[4]
+        name, (_stack,) = self.signals[4]
         self.assertEqual(name, "commit")
         self.assertFalse(self.log.is_in_transaction())
         self.assertEqual(len(self.log.undo_stacks), 1)
@@ -220,13 +220,13 @@ class TestUndoableActionLog(common.TestCase):
         self.assertEqual(len(self.log.redo_stacks), 0)
         self.log.begin("meh")
         self.assertEqual(len(self.signals), 1)
-        name, (stack,) = self.signals[0]
+        name, (_stack,) = self.signals[0]
         self.assertEqual(name, "begin")
         self.assertTrue(self.log.is_in_transaction())
 
         self.log.rollback()
         self.assertEqual(len(self.signals), 2)
-        name, (stack,) = self.signals[1]
+        name, (_stack,) = self.signals[1]
         self.assertEqual(name, "rollback")
         self.assertFalse(self.log.is_in_transaction())
         self.assertEqual(len(self.log.undo_stacks), 0)
@@ -238,7 +238,7 @@ class TestUndoableActionLog(common.TestCase):
         self.assertEqual(len(self.log.redo_stacks), 0)
         self.log.begin("meh")
         self.assertEqual(len(self.signals), 1)
-        name, (stack,) = self.signals[0]
+        name, (_stack,) = self.signals[0]
         self.assertEqual(name, "begin")
         self.assertTrue(self.log.is_in_transaction())
 
@@ -246,13 +246,13 @@ class TestUndoableActionLog(common.TestCase):
         self.assertEqual(len(self.log.redo_stacks), 0)
         self.log.begin("nested")
         self.assertEqual(len(self.signals), 2)
-        name, (stack,) = self.signals[1]
+        name, (_stack,) = self.signals[1]
         self.assertEqual(name, "begin")
         self.assertTrue(self.log.is_in_transaction())
 
         self.log.rollback()
         self.assertEqual(len(self.signals), 3)
-        name, (stack,) = self.signals[2]
+        name, (_stack,) = self.signals[2]
         self.assertEqual(name, "rollback")
         self.assertTrue(self.log.is_in_transaction())
         self.assertEqual(len(self.log.undo_stacks), 0)
@@ -260,7 +260,7 @@ class TestUndoableActionLog(common.TestCase):
 
         self.log.rollback()
         self.assertEqual(len(self.signals), 4)
-        name, (stack,) = self.signals[3]
+        name, (_stack,) = self.signals[3]
         self.assertEqual(name, "rollback")
         self.assertFalse(self.log.is_in_transaction())
         self.assertEqual(len(self.log.undo_stacks), 0)
@@ -271,7 +271,7 @@ class TestUndoableActionLog(common.TestCase):
         # begin
         self.log.begin("meh")
         self.assertEqual(len(self.signals), 1)
-        name, (stack,) = self.signals[0]
+        name, (_stack,) = self.signals[0]
         self.assertEqual(name, "begin")
         self.assertTrue(self.log.is_in_transaction())
 
@@ -280,14 +280,14 @@ class TestUndoableActionLog(common.TestCase):
         action1.expand.return_value = False
         self.log.push(action1)
         self.assertEqual(len(self.signals), 2)
-        name, (stack, signal_action) = self.signals[1]
+        name, (_stack, signal_action) = self.signals[1]
         self.assertEqual(name, "push")
         self.assertTrue(action1 is signal_action)
 
         action2 = mock.Mock(spec=UndoableAction)
         self.log.push(action2)
         self.assertEqual(len(self.signals), 3)
-        name, (stack, signal_action) = self.signals[2]
+        name, (_stack, signal_action) = self.signals[2]
         self.assertEqual(name, "push")
         self.assertTrue(action2 is signal_action)
 
@@ -296,7 +296,7 @@ class TestUndoableActionLog(common.TestCase):
         self.assertEqual(len(self.log.redo_stacks), 0)
         self.log.commit("meh")
         self.assertEqual(len(self.signals), 4)
-        name, (stack,) = self.signals[3]
+        name, (_stack,) = self.signals[3]
         self.assertEqual(name, "commit")
         self.assertFalse(self.log.is_in_transaction())
         self.assertEqual(len(self.log.undo_stacks), 1)
@@ -309,7 +309,7 @@ class TestUndoableActionLog(common.TestCase):
         # undo what we just committed
         self.log.undo()
         self.assertEqual(len(self.signals), 5)
-        name, stack = self.signals[4]
+        name, _args = self.signals[4]
         self.assertEqual(name, "move")
         self.assertEqual(len(self.log.undo_stacks), 0)
         self.assertEqual(len(self.log.redo_stacks), 1)
@@ -321,7 +321,7 @@ class TestUndoableActionLog(common.TestCase):
         # redo
         self.log.redo()
         self.assertEqual(len(self.signals), 6)
-        name, stack = self.signals[5]
+        name, _args = self.signals[5]
         self.assertEqual(name, "move")
         self.assertEqual(len(self.log.undo_stacks), 1)
         self.assertEqual(len(self.log.redo_stacks), 0)
diff --git a/tests/test_undo_timeline.py b/tests/test_undo_timeline.py
index 3a2e9b0e..230ef5ad 100644
--- a/tests/test_undo_timeline.py
+++ b/tests/test_undo_timeline.py
@@ -162,7 +162,7 @@ class TestTimelineObserver(BaseTestUndoTimeline):
         self.assertIsNone(clip1.get_parent())
         self.assertIsNone(clip2.get_parent())
 
-        for i in range(4):
+        for _ in range(4):
             # Undo ungrouping.
             self.action_log.undo()
             self.assertTrue(isinstance(clip1.get_parent(), GES.Group))
@@ -208,7 +208,7 @@ class TestTimelineObserver(BaseTestUndoTimeline):
         self.assertEqual(len(clips), 1, clips)
         self.assertEqual(len(clips[0].get_children(False)), 2)
 
-        for i in range(2):
+        for _ in range(2):
             # Undo grouping.
             self.action_log.undo()
             clips = list(self.getTimelineClips())
@@ -447,7 +447,7 @@ class TestLayerObserver(BaseTestUndoTimeline):
             self.assertEqual(2, len(self.layer.get_clips()))
 
         with self.action_log.started("split clip"):
-            clip2 = clip1.split(15 * Gst.SECOND)
+            _clip2 = clip1.split(15 * Gst.SECOND)
             self.assertEqual(3, len(self.layer.get_clips()))
 
         self.action_log.undo()
@@ -1040,9 +1040,9 @@ class TestDragDropUndo(BaseTestUndoTimeline):
             event.get_button.return_value = True, 1
             timeline_ui._button_press_event_cb(None, event)
 
-            def translate_coordinates(widget, x, y):
+            def translate_coordinates_func(widget, x, y):
                 return x, y
-            clip.ui.translate_coordinates = translate_coordinates
+            clip.ui.translate_coordinates = translate_coordinates_func
             event = mock.Mock()
             event.get_state.return_value = Gdk.ModifierType.BUTTON1_MASK
             event.x = 1
@@ -1157,8 +1157,8 @@ class TestDragDropUndo(BaseTestUndoTimeline):
 
         # Events emitted while dragging an asset on a separator in the timeline:
         # motion, receive, motion, leave, drop.
-        with mock.patch.object(Gdk, "drag_status") as drag_status_mock:
-            with mock.patch.object(Gtk, "drag_finish") as drag_finish_mock:
+        with mock.patch.object(Gdk, "drag_status") as _drag_status_mock:
+            with mock.patch.object(Gtk, "drag_finish") as _drag_finish_mock:
                 target = mock.Mock()
                 target.name.return_value = URI_TARGET_ENTRY.target
                 timeline_ui.drag_dest_find_target = mock.Mock(return_value=target)
@@ -1180,9 +1180,9 @@ class TestDragDropUndo(BaseTestUndoTimeline):
                 self.assertIsNone(timeline_ui.dragging_element)
                 self.assertFalse(timeline_ui.dropping_clips)
 
-                def translate_coordinates(widget, x, y):
+                def translate_coordinates_func(widget, x, y):
                     return x, y
-                timeline_ui.translate_coordinates = translate_coordinates
+                timeline_ui.translate_coordinates = translate_coordinates_func
                 timeline_ui._drag_motion_cb(timeline_ui, None, 0, LAYER_HEIGHT * 2, 0)
                 self.assertFalse(timeline_ui.drag_get_data.called)
                 self.assertIsNotNone(timeline_ui.dragging_element)