Adopt more ruff rules (#924)

* more linting

* typing

* fix bug

* fix json util test

Author: blink1073

.pre-commit-config.yaml

@@ -35,7 +35,7 @@ repos:
       - id: black
 
   - repo: https://github.com/charliermarsh/ruff-pre-commit
-    rev: v0.0.221
+    rev: v0.0.236
     hooks:
       - id: ruff
         args: ["--fix"]

jupyter_client/channels.py

@@ -159,7 +159,7 @@ def unpause(self) -> None:
 
     def is_beating(self) -> bool:
         """Is the heartbeat running and responsive (and not paused)."""
-        if self.is_alive() and not self._pause and self._beating:
+        if self.is_alive() and not self._pause and self._beating:  # noqa
             return True
         else:
             return False
@@ -290,7 +290,8 @@ def __init__(self, socket: zmq.asyncio.Socket, session: Session, loop: t.Any = N
             Unused here, for other implementations
         """
         if not isinstance(socket, zmq.asyncio.Socket):
-            raise ValueError('Socket must be asyncio')
+            msg = 'Socket must be asyncio'
+            raise ValueError(msg)
         super().__init__(socket, session)
 
     async def _recv(self, **kwargs: t.Any) -> t.Dict[str, t.Any]:  # type:ignore[override]

jupyter_client/client.py

@@ -195,7 +195,8 @@ async def _async_wait_for_ready(self, timeout: t.Optional[float] = None) -> None
                         break
 
             if not await self._async_is_alive():
-                raise RuntimeError("Kernel died before replying to kernel_info")
+                msg = "Kernel died before replying to kernel_info"
+                raise RuntimeError(msg)
 
             # Check if current time is ready check time plus timeout
             if time.time() > abs_timeout:
@@ -223,7 +224,8 @@ async def _async_recv_reply(
                 else:
                     reply = await self._async_get_shell_msg(timeout=timeout)
             except Empty as e:
-                raise TimeoutError("Timeout waiting for reply") from e
+                msg = "Timeout waiting for reply"
+                raise TimeoutError(msg) from e
             if reply["parent_header"].get("msg_id") != msg_id:
                 # not my reply, someone may have forgotten to retrieve theirs
                 continue
@@ -232,13 +234,10 @@ async def _async_recv_reply(
     async def _stdin_hook_default(self, msg: t.Dict[str, t.Any]) -> None:
         """Handle an input request"""
         content = msg["content"]
-        if content.get("password", False):
-            prompt = getpass
-        else:
-            prompt = input  # type: ignore
+        prompt = getpass if content.get("password", False) else input
 
         try:
-            raw_data = prompt(content["prompt"])
+            raw_data = prompt(content["prompt"])  # type:ignore[operator]
         except EOFError:
             # turn EOFError into EOF character
             raw_data = "\x04"
@@ -475,11 +474,13 @@ async def _async_execute_interactive(
             The reply message for this request
         """
         if not self.iopub_channel.is_alive():
-            raise RuntimeError("IOPub channel must be running to receive output")
+            emsg = "IOPub channel must be running to receive output"
+            raise RuntimeError(emsg)
         if allow_stdin is None:
             allow_stdin = self.allow_stdin
         if allow_stdin and not self.stdin_channel.is_alive():
-            raise RuntimeError("stdin channel must be running to allow input")
+            emsg = "stdin channel must be running to allow input"
+            raise RuntimeError(emsg)
         msg_id = await ensure_async(
             self.execute(
                 code,
@@ -492,20 +493,19 @@ async def _async_execute_interactive(
         )
         if stdin_hook is None:
             stdin_hook = self._stdin_hook_default
-        if output_hook is None:
-            # detect IPython kernel
-            if "IPython" in sys.modules:
-                from IPython import get_ipython
-
-                ip = get_ipython()
-                in_kernel = getattr(ip, "kernel", False)
-                if in_kernel:
-                    output_hook = partial(
-                        self._output_hook_kernel,
-                        ip.display_pub.session,
-                        ip.display_pub.pub_socket,
-                        ip.display_pub.parent_header,
-                    )
+        # detect IPython kernel
+        if output_hook is None and "IPython" in sys.modules:
+            from IPython import get_ipython
+
+            ip = get_ipython()
+            in_kernel = getattr(ip, "kernel", False)
+            if in_kernel:
+                output_hook = partial(
+                    self._output_hook_kernel,
+                    ip.display_pub.session,
+                    ip.display_pub.pub_socket,
+                    ip.display_pub.parent_header,
+                )
         if output_hook is None:
             # default: redisplay plain-text outputs
             output_hook = self._output_hook_default
@@ -532,7 +532,8 @@ async def _async_execute_interactive(
                 timeout_ms = int(1000 * timeout)
             events = dict(poller.poll(timeout_ms))
             if not events:
-                raise TimeoutError("Timeout waiting for output")
+                emsg = "Timeout waiting for output"
+                raise TimeoutError(emsg)
             if stdin_socket in events:
                 req = await ensure_async(self.stdin_channel.get_msg(timeout=0))
                 res = stdin_hook(req)
@@ -747,10 +748,7 @@ def comm_info(self, target_name: t.Optional[str] = None) -> str:
         -------
         The msg_id of the message sent
         """
-        if target_name is None:
-            content = {}
-        else:
-            content = {"target_name": target_name}
+        content = {} if target_name is None else {"target_name": target_name}
         msg = self.session.msg("comm_info_request", content)
         self.shell_channel.send(msg)
         return msg["header"]["msg_id"]

jupyter_client/connect.py

@@ -218,7 +218,8 @@ def find_connection_file(
 
     matches = [os.path.abspath(m) for m in matches]
     if not matches:
-        raise OSError(f"Could not find {filename!r} in {path!r}")
+        msg = f"Could not find {filename!r} in {path!r}"
+        raise OSError(msg)
     elif len(matches) == 1:
         return matches[0]
     else:
@@ -592,10 +593,11 @@ def _reconcile_connection_info(self, info: KernelConnectionInfo) -> None:
         # Ensure what is in KernelManager is what we expect.
         km_info = self.get_connection_info()
         if not self._equal_connections(info, km_info):
-            raise ValueError(
+            msg = (
                 "KernelManager's connection information already exists and does not match "
                 "the expected values returned from provisioner!"
             )
+            raise ValueError(msg)
 
     @staticmethod
     def _equal_connections(conn1: KernelConnectionInfo, conn2: KernelConnectionInfo) -> bool:
@@ -613,10 +615,7 @@ def _equal_connections(conn1: KernelConnectionInfo, conn2: KernelConnectionInfo)
             "signature_scheme",
         ]
 
-        for key in pertinent_keys:
-            if conn1.get(key) != conn2.get(key):
-                return False
-        return True
+        return all(conn1.get(key) == conn2.get(key) for key in pertinent_keys)
 
     # --------------------------------------------------------------------------
     # Creating connected sockets

jupyter_client/ioloop/manager.py

@@ -63,9 +63,8 @@ def start_restarter(self):
 
     def stop_restarter(self):
         """Stop the restarter."""
-        if self.autorestart:
-            if self._restarter is not None:
-                self._restarter.stop()
+        if self.autorestart and self._restarter is not None:
+            self._restarter.stop()
 
     connect_shell = as_zmqstream(KernelManager.connect_shell)
     connect_control = as_zmqstream(KernelManager.connect_control)
@@ -107,9 +106,8 @@ def start_restarter(self):
 
     def stop_restarter(self):
         """Stop the restarter."""
-        if self.autorestart:
-            if self._restarter is not None:
-                self._restarter.stop()
+        if self.autorestart and self._restarter is not None:
+            self._restarter.stop()
 
     connect_shell = as_zmqstream(AsyncKernelManager.connect_shell)
     connect_control = as_zmqstream(AsyncKernelManager.connect_control)

jupyter_client/jsonutil.py

@@ -28,7 +28,7 @@
 
 # holy crap, strptime is not threadsafe.
 # Calling it once at import seems to help.
-datetime.strptime("1", "%d")
+datetime.strptime("1", "%d")  # noqa
 
 # -----------------------------------------------------------------------------
 # Classes and functions
@@ -174,10 +174,11 @@ def json_clean(obj):
         nkeys = len(obj)
         nkeys_collapsed = len(set(map(str, obj)))
         if nkeys != nkeys_collapsed:
-            raise ValueError(
+            msg = (
                 'dict cannot be safely converted to JSON: '
                 'key collision would lead to dropped values'
             )
+            raise ValueError(msg)
         # If all OK, proceed by making the new dict that will be json-safe
         out = {}
         for k, v in obj.items():

jupyter_client/kernelspec.py

@@ -368,10 +368,12 @@ def install_kernel_spec(
             kernel_name = os.path.basename(source_dir)
         kernel_name = kernel_name.lower()
         if not _is_valid_kernel_name(kernel_name):
-            raise ValueError(f"Invalid kernel name {kernel_name!r}.  {_kernel_name_description}")
+            msg = f"Invalid kernel name {kernel_name!r}.  {_kernel_name_description}"
+            raise ValueError(msg)
 
         if user and prefix:
-            raise ValueError("Can't specify both user and prefix. Please choose one or the other.")
+            msg = "Can't specify both user and prefix. Please choose one or the other."
+            raise ValueError(msg)
 
         if replace is not None:
             warnings.warn(

jupyter_client/launcher.py

@@ -66,7 +66,7 @@ def launch_kernel(
     # stderr are all invalid.
     redirect_out = sys.executable.endswith("pythonw.exe")
     if redirect_out:
-        blackhole = open(os.devnull, "w")
+        blackhole = open(os.devnull, "w")  # noqa
         _stdout = blackhole if stdout is None else stdout
         _stderr = blackhole if stderr is None else stderr
     else:
@@ -171,10 +171,9 @@ def launch_kernel(
         proc.win32_interrupt_event = interrupt_event
 
     # Clean up pipes created to work around Popen bug.
-    if redirect_in:
-        if stdin is None:
-            assert proc.stdin is not None
-            proc.stdin.close()
+    if redirect_in and stdin is None:
+        assert proc.stdin is not None
+        proc.stdin.close()
 
     return proc
 

jupyter_client/localinterfaces.py

@@ -39,7 +39,8 @@ def _get_output(cmd):
     p = Popen(cmd, stdout=PIPE, stderr=PIPE, startupinfo=startupinfo)
     stdout, stderr = p.communicate()
     if p.returncode:
-        raise OSError("Failed to run {}: {}".format(cmd, stderr.decode("utf8", "replace")))
+        msg = "Failed to run {}: {}".format(cmd, stderr.decode("utf8", "replace"))
+        raise OSError(msg)
     return stdout.decode("utf8", "replace")
 
 
@@ -127,7 +128,7 @@ def _load_ips_ip():
     addrs = []
     for line in lines:
         blocks = line.lower().split()
-        if (len(blocks) >= 2) and (blocks[0] == "inet"):
+        if (len(blocks) >= 2) and (blocks[0] == "inet"):  # noqa
             addrs.append(blocks[1].split("/")[0])
     _populate_from_list(addrs)
 

jupyter_client/manager.py

@@ -541,7 +541,8 @@ async def _async_restart_kernel(
             kernel.
         """
         if self._launch_args is None:
-            raise RuntimeError("Cannot restart the kernel. No previous call to 'start_kernel'.")
+            msg = "Cannot restart the kernel. No previous call to 'start_kernel'."
+            raise RuntimeError(msg)
 
         # Stop currently running kernel.
         await self._async_shutdown_kernel(now=now, restart=True)
@@ -597,17 +598,16 @@ async def _async_interrupt_kernel(self) -> None:
         Unlike ``signal_kernel``, this operation is well supported on all
         platforms.
         """
-        if not self.has_kernel:
-            if self._ready is not None:
-                if isinstance(self._ready, CFuture):
-                    ready = asyncio.ensure_future(t.cast(Future[t.Any], self._ready))
-                else:
-                    ready = self._ready
-                # Wait for a shutdown if one is in progress.
-                if self.shutting_down:
-                    await ready
-                # Wait for a startup.
+        if not self.has_kernel and self._ready is not None:
+            if isinstance(self._ready, CFuture):
+                ready = asyncio.ensure_future(t.cast(Future[t.Any], self._ready))
+            else:
+                ready = self._ready
+            # Wait for a shutdown if one is in progress.
+            if self.shutting_down:
                 await ready
+            # Wait for a startup.
+            await ready
 
         if self.has_kernel:
             assert self.kernel_spec is not None
@@ -620,7 +620,8 @@ async def _async_interrupt_kernel(self) -> None:
                 self._connect_control_socket()
                 self.session.send(self._control_socket, msg)
         else:
-            raise RuntimeError("Cannot interrupt kernel. No kernel is running!")
+            msg = "Cannot interrupt kernel. No kernel is running!"
+            raise RuntimeError(msg)
 
     interrupt_kernel = run_sync(_async_interrupt_kernel)
 
@@ -636,7 +637,8 @@ async def _async_signal_kernel(self, signum: int) -> None:
             assert self.provisioner is not None
             await self.provisioner.send_signal(signum)
         else:
-            raise RuntimeError("Cannot signal kernel. No kernel is running!")
+            msg = "Cannot signal kernel. No kernel is running!"
+            raise RuntimeError(msg)
 
     signal_kernel = run_sync(_async_signal_kernel)