fix mypy lints

Author: Carreau

jupyter_client/asynchronous/client.py

@@ -34,7 +34,7 @@ class AsyncKernelClient(KernelClient):
     raising :exc:`queue.Empty` if no message arrives within ``timeout`` seconds.
     """
 
-    context = Instance(zmq.asyncio.Context)
+    context = Instance(zmq.asyncio.Context)  # type:ignore[assignment]
 
     def _context_default(self) -> zmq.asyncio.Context:
         self._created_context = True
@@ -52,11 +52,11 @@ def _context_default(self) -> zmq.asyncio.Context:
     wait_for_ready = KernelClient._async_wait_for_ready
 
     # The classes to use for the various channels
-    shell_channel_class = Type(AsyncZMQSocketChannel)
-    iopub_channel_class = Type(AsyncZMQSocketChannel)
-    stdin_channel_class = Type(AsyncZMQSocketChannel)
-    hb_channel_class = Type(HBChannel)
-    control_channel_class = Type(AsyncZMQSocketChannel)
+    shell_channel_class = Type(AsyncZMQSocketChannel)  # type:ignore[assignment]
+    iopub_channel_class = Type(AsyncZMQSocketChannel)  # type:ignore[assignment]
+    stdin_channel_class = Type(AsyncZMQSocketChannel)  # type:ignore[assignment]
+    hb_channel_class = Type(HBChannel)  # type:ignore[assignment]
+    control_channel_class = Type(AsyncZMQSocketChannel)  # type:ignore[assignment]
 
     _recv_reply = KernelClient._async_recv_reply
 

jupyter_client/blocking/client.py

@@ -49,11 +49,11 @@ class BlockingKernelClient(KernelClient):
     wait_for_ready = run_sync(KernelClient._async_wait_for_ready)
 
     # The classes to use for the various channels
-    shell_channel_class = Type(ZMQSocketChannel)
-    iopub_channel_class = Type(ZMQSocketChannel)
-    stdin_channel_class = Type(ZMQSocketChannel)
-    hb_channel_class = Type(HBChannel)
-    control_channel_class = Type(ZMQSocketChannel)
+    shell_channel_class = Type(ZMQSocketChannel)  # type:ignore[assignment]
+    iopub_channel_class = Type(ZMQSocketChannel)  # type:ignore[assignment]
+    stdin_channel_class = Type(ZMQSocketChannel)  # type:ignore[assignment]
+    hb_channel_class = Type(HBChannel)  # type:ignore[assignment]
+    control_channel_class = Type(ZMQSocketChannel)  # type:ignore[assignment]
 
     _recv_reply = run_sync(KernelClient._async_recv_reply)
 

jupyter_client/provisioning/provisioner_base.py

@@ -15,7 +15,7 @@ class KernelProvisionerMeta(ABCMeta, type(LoggingConfigurable)):  # type: ignore
     pass
 
 
-class KernelProvisionerBase(ABC, LoggingConfigurable, metaclass=KernelProvisionerMeta):
+class KernelProvisionerBase(ABC, LoggingConfigurable, metaclass=KernelProvisionerMeta):  # type: ignore[metaclass]
     """
     Abstract base class defining methods for KernelProvisioner classes.
 

jupyter_client/session.py

@@ -759,7 +759,7 @@ def send(
         content: dict[str, t.Any] | None = None,
         parent: dict[str, t.Any] | None = None,
         ident: bytes | list[bytes] | None = None,
-        buffers: list[bytes] | None = None,
+        buffers: list[bytes | memoryview[bytes]] | None = None,
         track: bool = False,
         header: dict[str, t.Any] | None = None,
         metadata: dict[str, t.Any] | None = None,
@@ -844,14 +844,15 @@ def send(
                     raise TypeError(emsg) from e
             # memoryview.contiguous is new in 3.3,
             # just skip the check on Python 2
+            assert hasattr(view, "contiguous"), "We should only be on python 3.9+ now"
             if hasattr(view, "contiguous") and not view.contiguous:
                 # zmq requires memoryviews to be contiguous
                 raise ValueError("Buffer %i (%r) is not contiguous" % (idx, buf))
 
         if self.adapt_version:
             msg = adapt(msg, self.adapt_version)
         to_send = self.serialize(msg, ident)
-        to_send.extend(buffers)
+        to_send.extend(buffers)  # type: ignore[arg-type]
         longest = max([len(s) for s in to_send])
         copy = longest < self.copy_threshold
 

jupyter_client/ssh/tunnel.py

@@ -17,6 +17,7 @@
 import warnings
 from getpass import getpass, getuser
 from multiprocessing import Process
+from types import ModuleType
 from typing import Any, cast
 
 try:
@@ -34,6 +35,7 @@ class SSHException(Exception):  # type:ignore[no-redef]  # noqa
 else:
     from .forward import forward_tunnel
 
+pexpect: ModuleType | None
 try:
     import pexpect
 except ImportError:
@@ -303,6 +305,7 @@ def openssh_tunnel(
 
 
 def _stop_tunnel(cmd: Any) -> None:
+    assert pexpect is not None
     pexpect.run(cmd)
 
 

jupyter_client/threaded.py

@@ -335,11 +335,11 @@ def stop_channels(self) -> None:
         if self.ioloop_thread and self.ioloop_thread.is_alive():
             self.ioloop_thread.stop()
 
-    iopub_channel_class = Type(ThreadedZMQSocketChannel)
-    shell_channel_class = Type(ThreadedZMQSocketChannel)
-    stdin_channel_class = Type(ThreadedZMQSocketChannel)
-    hb_channel_class = Type(HBChannel)
-    control_channel_class = Type(ThreadedZMQSocketChannel)
+    iopub_channel_class = Type(ThreadedZMQSocketChannel)  # type:ignore[assignment]
+    shell_channel_class = Type(ThreadedZMQSocketChannel)  # type:ignore[assignment]
+    stdin_channel_class = Type(ThreadedZMQSocketChannel)  # type:ignore[assignment]
+    hb_channel_class = Type(HBChannel)  # type:ignore[assignment]
+    control_channel_class = Type(ThreadedZMQSocketChannel)  # type:ignore[assignment]
 
     def is_alive(self) -> bool:
         """Is the kernel process still running?"""