Fixed general linting issues

Author: Michael Graves

can/notifier.py

@@ -10,11 +10,7 @@
 from collections.abc import Awaitable, Callable, Iterable
 from contextlib import AbstractContextManager
 from types import TracebackType
-from typing import (
-    Any,
-    Final,
-    NamedTuple,
-)
+from typing import Any, Final, NamedTuple
 
 from can.bus import BusABC
 from can.listener import Listener
@@ -101,7 +97,6 @@ def find_instances(self, bus: BusABC) -> tuple["Notifier", ...]:
 
 
 class Notifier(AbstractContextManager["Notifier"]):
-
     _registry: Final = _NotifierRegistry()
 
     def __init__(
@@ -316,20 +311,20 @@ def find_instances(bus: BusABC) -> tuple["Notifier", ...]:
 
     def restart(self) -> None:
         """Restarts the Notifier if it has been stopped.
-        
+
         :raises RuntimeWarning: If the notifier is already running.
         """
         with self._lock:
             if not self._stopped:
                 raise RuntimeWarning("Notifier is already running.")
-            
+
             self._stopped = False
             self.exception = None
             # Note: _bus_list is preserved from previous run
-            
+
             for bus in self._bus_list:
                 self._start_reader(bus)
-            
+
             # Re-trigger listeners if they have a start method
             for listener in self.listeners:
                 if hasattr(listener, "start"):

test/notifier_test.py

@@ -76,46 +76,46 @@ def test_restart(self):
         with can.Bus("test", interface="virtual", receive_own_messages=True) as bus:
             reader = can.BufferedReader()
             notifier = can.Notifier(bus, [reader], 0.1)
-            
+
             bus.send(can.Message(arbitration_id=0x123))
             self.assertIsNotNone(reader.get_message(1))
-            
+
             notifier.stop()
             self.assertTrue(notifier.stopped)
-            
+
             new_reader = can.BufferedReader()
             notifier.listeners = [new_reader]
-            
+
             notifier.restart()
             self.assertFalse(notifier.stopped)
-            
+
             # Small settling time for the thread to actually start
             time.sleep(0.2)
-            
+
             # Send and Verify
             msg = can.Message(arbitration_id=0xABC)
             bus.send(msg)
-            
+
             recv = new_reader.get_message(1)
             self.assertIsNotNone(recv, "Failed to receive message after restart")
             self.assertEqual(recv.arbitration_id, 0xABC)
-            
+
             notifier.stop()
 
     def test_restart_registry_lifecycle(self):
         with can.Bus("test", interface="virtual", receive_own_messages=True) as bus:
             notifier = can.Notifier(bus, [], 0.1)
             notifier.stop()
-            
+
             # Verify it is removed from registry
             self.assertEqual(can.Notifier.find_instances(bus), ())
-            
+
             notifier.restart()
-            
+
             # Verify it is back in the registry and blocking others
             self.assertEqual(can.Notifier.find_instances(bus), (notifier,))
             self.assertRaises(ValueError, can.Notifier, bus, [], 0.1)
-            
+
             notifier.stop()
 
     def test_double_restart_warning(self):
@@ -125,6 +125,7 @@ def test_double_restart_warning(self):
                 with self.assertRaises(RuntimeWarning):
                     notifier.restart()
 
+
 class AsyncNotifierTest(unittest.TestCase):
     def test_asyncio_notifier(self):
         async def run_it():
@@ -147,25 +148,25 @@ async def run_it():
                 notifier = can.Notifier(
                     bus, [reader], 0.1, loop=asyncio.get_running_loop()
                 )
-                
+
                 notifier.stop()
-                
+
                 # In some cases, creating a new listener is the safest path for a restart
                 new_reader = can.AsyncBufferedReader()
-                notifier.listeners = [new_reader] 
-                
+                notifier.listeners = [new_reader]
+
                 notifier.restart()
-                
+
                 # Small yield to let the selector register the FD
                 await asyncio.sleep(0.1)
-                
+
                 bus.send(can.Message(arbitration_id=0x123))
-                
+
                 recv_msg = await asyncio.wait_for(new_reader.get_message(), 1.5)
-                
+
                 self.assertIsNotNone(recv_msg)
                 self.assertEqual(recv_msg.arbitration_id, 0x123)
-                
+
                 notifier.stop()
 
         asyncio.run(run_it())