testsuite: apply fixes required for pre-commit

Problem: The pre-commit CI hooks were skipping the testsuite
directory `t/`, but that will soon be fixed. This uncovers many
formatting issues and other minor errors.

Fix the errors and formatting found by the various pre-commit hooks.

Author: grondo

t/python/subflux.py

@@ -1,5 +1,3 @@
-#!/usr/bin/env python3
-
 ###############################################################
 # Copyright 2014 Lawrence Livermore National Security, LLC
 # (c.f. AUTHORS, NOTICE.LLNS, COPYING)
@@ -10,10 +8,10 @@
 # SPDX-License-Identifier: LGPL-3.0
 ###############################################################
 
+import argparse
 import os
-import sys
 import subprocess
-import argparse
+import sys
 
 script_dir = os.path.dirname(os.path.abspath(__file__))
 

t/python/t0001-handle.py

@@ -10,11 +10,11 @@
 # SPDX-License-Identifier: LGPL-3.0
 ###############################################################
 
-import unittest
 import syslog
+import unittest
 
 import flux
-from subflux import rerun_under_flux, script_dir
+from subflux import rerun_under_flux
 
 
 def __flux_size():

t/python/t0002-wrapper.py

@@ -13,8 +13,8 @@
 import unittest
 
 import flux
-from flux.core.inner import ffi, raw
 import flux.wrapper
+from flux.core.inner import ffi, raw
 from subflux import rerun_under_flux
 
 
@@ -42,12 +42,12 @@ def test_null_handle_exception(self):
         f = flux.Flux()
         payload = {"seq": 1, "pad": "stuff"}
         future = f.rpc("broker.ping", payload)
-        resp = future.get()
+        future.get()
         future.pimpl.handle = None
         with self.assertRaisesRegex(
             ValueError, r"Attempting to call a cached, bound method.*NULL handle"
         ):
-            resp = future.get()
+            future.get()
 
     def test_automatic_unwrapping(self):
         flux.core.inner.raw.flux_log(flux.Flux("loop://"), 0, "stuff")

t/python/t0003-barrier.py

@@ -10,8 +10,8 @@
 # SPDX-License-Identifier: LGPL-3.0
 ###############################################################
 
-import unittest
 import multiprocessing as mp
+import unittest
 
 import flux
 from subflux import rerun_under_flux

t/python/t0005-kvs.py

@@ -14,7 +14,6 @@
 
 import flux
 import flux.kvs
-
 from subflux import rerun_under_flux
 
 
@@ -39,7 +38,7 @@ def set_and_check_context(self, key, value, type):
         kd2 = flux.kvs.KVSDir(self.f)
         nv = kd2[key]
         if isinstance(value, bytes) and type is str:
-            self.assertEqual(value.decode('utf-8'), nv)
+            self.assertEqual(value.decode("utf-8"), nv)
         else:
             self.assertEqual(value, nv)
         if type is not None:

t/python/t0006-request.py

@@ -10,9 +10,9 @@
 # SPDX-License-Identifier: LGPL-3.0
 ###############################################################
 
+import errno
 import unittest
 
-import errno
 import flux
 from subflux import rerun_under_flux
 

t/python/t0007-watchers.py

@@ -10,10 +10,11 @@
 # SPDX-License-Identifier: LGPL-3.0
 ###############################################################
 
-import unittest
-import os
 import gc
+import os
 import signal
+import unittest
+
 import flux
 from subflux import rerun_under_flux
 
@@ -67,8 +68,8 @@ def test_timer_callback_exception(self):
         def cb(x, y, z, w):
             raise RuntimeError("this is a test")
 
-        with self.f.timer_watcher_create(0.01, cb) as timer:
-            with self.assertRaises(RuntimeError) as cm:
+        with self.f.timer_watcher_create(0.01, cb):
+            with self.assertRaises(RuntimeError):
                 self.f.reactor_run()
 
     def test_msg_watcher_unicode(self):
@@ -155,7 +156,7 @@ def raise_signal(handle, watcher, revents, args):
         #  Create new Flux handle to avoid potential stale state in
         #  self.f handle. (makes test unreliable)
         h = flux.Flux()
-        with h.signal_watcher_create(signal.SIGUSR2, signal_cb) as watcher:
+        with h.signal_watcher_create(signal.SIGUSR2, signal_cb):
             h.timer_watcher_create(0.05, raise_signal).start()
             with self.assertRaises(RuntimeError):
                 rc = h.reactor_run()
@@ -231,7 +232,7 @@ def cb_abort(handle, watcher, revents, _args):
         self.f.timer_watcher_create(0.0, cb, repeat=0.05).start()
 
         #  Timeout/abort after 5s
-        tw = self.f.timer_watcher_create(5.0, cb_abort).start()
+        self.f.timer_watcher_create(5.0, cb_abort).start()
         self.f.reactor_run()
 
         #  callback should have been called 5 times, not less

t/python/t0009-security.py

@@ -17,7 +17,7 @@
 
 try:
     from flux.security import SecurityContext
-except:
+except ModuleNotFoundError:
     print("1..0 # skip flux.security module not available")
     sys.exit(0)
 

t/python/t0010-job.py

@@ -10,27 +10,24 @@
 # SPDX-License-Identifier: LGPL-3.0
 ###############################################################
 
-import os
+import datetime
 import errno
-import sys
 import json
-import unittest
-import datetime
-import signal
 import locale
+import os
 import pathlib
+import signal
 import subprocess
+import unittest
 from glob import glob
 
-import yaml
-
 import flux
-import flux.kvs
 import flux.constants
+import flux.kvs
+import yaml
 from flux import job
-from flux.job import Jobspec, JobspecV1, ffi, JobID, JobInfo
+from flux.job import JobInfo, Jobspec, JobspecV1, ffi
 from flux.job.stats import JobStats
-from flux.future import Future
 
 
 def __flux_size():
@@ -49,7 +46,7 @@ def setUpClass(self):
         self.fh = flux.Flux()
         self.use_ascii = False
         build_opts = subprocess.check_output(["flux", "version"]).decode()
-        if  locale.getlocale()[1] != "UTF-8" or "ascii-only" in build_opts:
+        if locale.getlocale()[1] != "UTF-8" or "ascii-only" in build_opts:
             self.use_ascii = True
 
         self.jobspec_dir = os.path.abspath(
@@ -90,7 +87,7 @@ def test_03_invalid_construction(self):
             ):
                 with self.assertRaises(
                     (ValueError, TypeError, yaml.scanner.ScannerError)
-                ) as cm:
+                ):
                     cls.from_yaml_file(invalid_jobspec_filepath)
 
     def test_04_valid_construction(self):
@@ -332,7 +329,7 @@ def cb(future, events):
             events.append(event.name)
 
         future.then(cb, events)
-        rc = self.fh.reactor_run()
+        self.fh.reactor_run()
 
         # Last event should be "start"
         self.assertEqual(events[-1], "start")
@@ -688,32 +685,34 @@ def test_33_get_job(self):
         jobid = job.submit(self.fh, self.sleep_jobspec)
         meta = job.get_job(self.fh, jobid)
         self.assertIsInstance(meta, dict)
-        for key in ['id',
-                    'userid',
-                    'urgency',
-                    'priority',
-                    't_submit',
-                    't_depend',
-                    'state',
-                    'name',
-                    'cwd',
-                    'ntasks',
-                    'ncores',
-                    'duration',
-                    'nnodes',
-                    'result',
-                    'runtime',
-                    'returncode',
-                    'waitstatus',
-                    'nodelist',
-                    'exception']:
+        for key in [
+            "id",
+            "userid",
+            "urgency",
+            "priority",
+            "t_submit",
+            "t_depend",
+            "state",
+            "name",
+            "cwd",
+            "ntasks",
+            "ncores",
+            "duration",
+            "nnodes",
+            "result",
+            "runtime",
+            "returncode",
+            "waitstatus",
+            "nodelist",
+            "exception",
+        ]:
             self.assertIn(key, meta)
 
-        self.assertEqual(meta['id'], jobid)
-        self.assertEqual(meta['name'], "sleep")
-        self.assertTrue(meta['state'] in ["SCHED", "DEPEND", "RUN"])
-        self.assertEqual(meta['ntasks'], 1)
-        self.assertEqual(meta['ncores'], 1)
+        self.assertEqual(meta["id"], jobid)
+        self.assertEqual(meta["name"], "sleep")
+        self.assertTrue(meta["state"] in ["SCHED", "DEPEND", "RUN"])
+        self.assertEqual(meta["ntasks"], 1)
+        self.assertEqual(meta["ncores"], 1)
 
         # Test a job that does not exist
         meta = job.get_job(self.fh, 123456)
@@ -727,11 +726,12 @@ def test_34_timeleft(self):
         jobid = job.submit(self.fh, spec, waitable=True)
         job.wait(self.fh, jobid=jobid)
         try:
-            dt = job.timeleft()
-            dt = job.timeleft(self.fh)
+            job.timeleft()
+            job.timeleft(self.fh)
         except OSError:
             pass
 
+
 if __name__ == "__main__":
     from subflux import rerun_under_flux
 

t/python/t0012-futures.py

@@ -10,8 +10,8 @@
 # SPDX-License-Identifier: LGPL-3.0
 ###############################################################
 
-import gc
 import errno
+import gc
 import unittest
 
 import flux
@@ -86,8 +86,8 @@ def then_cb(future):
             raise RuntimeError("this is a test")
 
         self.f.rpc("broker.ping", self.ping_payload).then(then_cb)
-        with self.assertRaises(RuntimeError) as cm:
-            rc = self.f.reactor_run()
+        with self.assertRaises(RuntimeError):
+            self.f.reactor_run()
 
     def test_03_future_then_varargs(self):
         cb_ran = [False]
@@ -212,7 +212,7 @@ def service_cb(fh, t, msg, arg):
             {"count": arg["target"]},
             flags=flux.constants.FLUX_RPC_STREAMING,
         ).then(continuation_cb, arg=arg)
-        ret = self.f.reactor_run()
+        self.f.reactor_run()
         self.assertEqual(arg["count"], arg["target"])
 
         watcher.stop()
@@ -230,15 +230,15 @@ def test_08_future_from_future(self):
         orig_fut = self.f.rpc("broker.ping", payload=self.ping_payload)
         new_fut = Future(orig_fut)
         del orig_fut
-        resp_payload = new_fut.get()
+        new_fut.get()
         # Future's `get` returns `None`, so just test that it is fulfilled
         self.assertTrue(new_fut.is_ready())
 
         orig_fut = self.f.rpc("foo.bar")
         new_fut = Future(orig_fut)
         del orig_fut
         with self.assertRaises(EnvironmentError):
-            resp_payload = new_fut.get()
+            new_fut.get()
 
 
 if __name__ == "__main__":