remove all ignored types comments

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)  # type:ignore[arg-type]
+    context = Instance(zmq.asyncio.Context)
 
     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)  # type:ignore[arg-type]
-    iopub_channel_class = Type(AsyncZMQSocketChannel)  # type:ignore[arg-type]
-    stdin_channel_class = Type(AsyncZMQSocketChannel)  # type:ignore[arg-type]
-    hb_channel_class = Type(HBChannel)  # type:ignore[arg-type]
-    control_channel_class = Type(AsyncZMQSocketChannel)  # type:ignore[arg-type]
+    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)
 
     _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)  # type:ignore[arg-type]
-    iopub_channel_class = Type(ZMQSocketChannel)  # type:ignore[arg-type]
-    stdin_channel_class = Type(ZMQSocketChannel)  # type:ignore[arg-type]
-    hb_channel_class = Type(HBChannel)  # type:ignore[arg-type]
-    control_channel_class = Type(ZMQSocketChannel)  # type:ignore[arg-type]
+    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)
 
     _recv_reply = run_sync(KernelClient._async_recv_reply)
 

jupyter_client/localinterfaces.py

@@ -181,7 +181,7 @@ def _load_ips_psutil() -> None:
 
 def _load_ips_netifaces() -> None:
     """load ip addresses with netifaces"""
-    import netifaces  # type: ignore[import-not-found]
+    import netifaces
 
     addr_dict: dict[str, list[str]] = {}
 

jupyter_client/manager.py

@@ -391,7 +391,7 @@ async def _async_pre_start_kernel(
         self.kernel_id = self.kernel_id or kw.pop("kernel_id", str(uuid.uuid4()))
         # save kwargs for use in restart
         # assigning Traitlets Dicts to Dict make mypy unhappy but is ok
-        self._launch_args = kw.copy()  # type:ignore [assignment]
+        self._launch_args = kw.copy()
         if self.provisioner is None:  # will not be None on restarts
             self.provisioner = KPF.instance(parent=self.parent).create_provisioner_instance(
                 self.kernel_id,

jupyter_client/provisioning/local_provisioner.py

@@ -14,7 +14,7 @@
 from .provisioner_base import KernelProvisionerBase
 
 
-class LocalProvisioner(KernelProvisionerBase):  # type:ignore[misc]
+class LocalProvisioner(KernelProvisionerBase):
     """
     :class:`LocalProvisioner` is a concrete class of ABC :py:class:`KernelProvisionerBase`
     and is the out-of-box default implementation used when no kernel provisioner is

jupyter_client/provisioning/provisioner_base.py

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

jupyter_client/runapp.py

@@ -38,7 +38,7 @@
 frontend_flags = set(frontend_flags_dict.keys())
 
 
-class RunApp(JupyterApp, JupyterConsoleApp):  # type:ignore[misc]
+class RunApp(JupyterApp, JupyterConsoleApp):
     """An Jupyter Console app to run files."""
 
     version = __version__

jupyter_client/session.py

@@ -812,7 +812,7 @@ def send(
             track = False
 
         if isinstance(stream, zmq.asyncio.Socket):
-            assert stream is not None  # type:ignore[unreachable]
+            assert stream is not None
             stream = zmq.Socket.shadow(stream.underlying)
 
         if isinstance(msg_or_type, Message | dict):

jupyter_client/ssh/tunnel.py

@@ -35,7 +35,7 @@ class SSHException(Exception):  # type:ignore[no-redef]  # noqa
     from .forward import forward_tunnel
 
 try:
-    import pexpect  # type: ignore[import-untyped]
+    import pexpect
 except ImportError:
     pexpect = None
 

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)  # type:ignore[arg-type]
-    shell_channel_class = Type(ThreadedZMQSocketChannel)  # type:ignore[arg-type]
-    stdin_channel_class = Type(ThreadedZMQSocketChannel)  # type:ignore[arg-type]
-    hb_channel_class = Type(HBChannel)  # type:ignore[arg-type]
-    control_channel_class = Type(ThreadedZMQSocketChannel)  # type:ignore[arg-type]
+    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)
 
     def is_alive(self) -> bool:
         """Is the kernel process still running?"""