Apply Chris Eibl suggestionы and use only int and bytes in eventqueue.push

Author: sergey-miryanov

Lib/_pyrepl/base_eventqueue.py

@@ -69,23 +69,14 @@ def insert(self, event: Event) -> None:
         trace('added event {event}', event=event)
         self.events.append(event)
 
-    def push(self, char: int | bytes | str) -> None:
+    def push(self, char: int | bytes) -> None:
         """
         Processes a character by updating the buffer and handling special key mappings.
         """
-
-        if isinstance(char, bytes):
-            self.buf.extend(char)
-        else:
-
-            ord_char = char if isinstance(char, int) else ord(char)
-            if ord_char > 255:
-                assert isinstance(char, str)
-                char = bytes(char.encode(self.encoding, "replace"))
-                self.buf.extend(char)
-            else:
-                char = bytes([ord_char])
-                self.buf.append(ord_char)
+        assert isinstance(char, (int, bytes))
+        ord_char = char if isinstance(char, int) else ord(char)
+        char = bytes((ord_char,))
+        self.buf.append(ord_char)
 
         if char in self.keymap:
             if self.keymap is self.compiled_keymap:
@@ -113,8 +104,7 @@ def push(self, char: int | bytes | str) -> None:
             try:
                 decoded = bytes(self.buf).decode(self.encoding)
             except UnicodeError:
-                self.flush_buf()
-                raise
+                return
             else:
                 self.insert(Event('key', decoded, self.flush_buf()))
             finally:

Lib/test/test_pyrepl/test_eventqueue.py

@@ -53,7 +53,7 @@ def test_push_with_key_in_keymap(self, mock_keymap):
         mock_keymap.compile_keymap.return_value = {"a": "b"}
         eq = self.make_eventqueue()
         eq.keymap = {b"a": "b"}
-        eq.push("a")
+        eq.push(b"a")
         mock_keymap.compile_keymap.assert_called()
         self.assertEqual(eq.events[0].evt, "key")
         self.assertEqual(eq.events[0].data, "b")
@@ -63,7 +63,7 @@ def test_push_without_key_in_keymap(self, mock_keymap):
         mock_keymap.compile_keymap.return_value = {"a": "b"}
         eq = self.make_eventqueue()
         eq.keymap = {b"c": "d"}
-        eq.push("a")
+        eq.push(b"a")
         mock_keymap.compile_keymap.assert_called()
         self.assertEqual(eq.events[0].evt, "key")
         self.assertEqual(eq.events[0].data, "a")
@@ -73,13 +73,13 @@ def test_push_with_keymap_in_keymap(self, mock_keymap):
         mock_keymap.compile_keymap.return_value = {"a": "b"}
         eq = self.make_eventqueue()
         eq.keymap = {b"a": {b"b": "c"}}
-        eq.push("a")
+        eq.push(b"a")
         mock_keymap.compile_keymap.assert_called()
         self.assertTrue(eq.empty())
-        eq.push("b")
+        eq.push(b"b")
         self.assertEqual(eq.events[0].evt, "key")
         self.assertEqual(eq.events[0].data, "c")
-        eq.push("d")
+        eq.push(b"d")
         self.assertEqual(eq.events[1].evt, "key")
         self.assertEqual(eq.events[1].data, "d")
 
@@ -88,32 +88,32 @@ def test_push_with_keymap_in_keymap_and_escape(self, mock_keymap):
         mock_keymap.compile_keymap.return_value = {"a": "b"}
         eq = self.make_eventqueue()
         eq.keymap = {b"a": {b"b": "c"}}
-        eq.push("a")
+        eq.push(b"a")
         mock_keymap.compile_keymap.assert_called()
         self.assertTrue(eq.empty())
         eq.flush_buf()
-        eq.push("\033")
+        eq.push(b"\033")
         self.assertEqual(eq.events[0].evt, "key")
         self.assertEqual(eq.events[0].data, "\033")
-        eq.push("b")
+        eq.push(b"b")
         self.assertEqual(eq.events[1].evt, "key")
         self.assertEqual(eq.events[1].data, "b")
 
     def test_push_special_key(self):
         eq = self.make_eventqueue()
         eq.keymap = {}
-        eq.push("\x1b")
-        eq.push("[")
-        eq.push("A")
+        eq.push(b"\x1b")
+        eq.push(b"[")
+        eq.push(b"A")
         self.assertEqual(eq.events[0].evt, "key")
         self.assertEqual(eq.events[0].data, "\x1b")
 
     def test_push_unrecognized_escape_sequence(self):
         eq = self.make_eventqueue()
         eq.keymap = {}
-        eq.push("\x1b")
-        eq.push("[")
-        eq.push("Z")
+        eq.push(b"\x1b")
+        eq.push(b"[")
+        eq.push(b"Z")
         self.assertEqual(len(eq.events), 3)
         self.assertEqual(eq.events[0].evt, "key")
         self.assertEqual(eq.events[0].data, "\x1b")
@@ -122,23 +122,31 @@ def test_push_unrecognized_escape_sequence(self):
         self.assertEqual(eq.events[2].evt, "key")
         self.assertEqual(eq.events[2].data, "Z")
 
-    def test_push_unicode_character(self):
+    def test_push_unicode_character_as_str(self):
         eq = self.make_eventqueue()
         eq.keymap = {}
-        eq.push("ч")
-        self.assertEqual(eq.events[0].evt, "key")
-        self.assertEqual(eq.events[0].data, "ч")
+        with self.assertRaises(AssertionError):
+            eq.push("ч")
+        with self.assertRaises(AssertionError):
+            eq.push("ñ")
 
     def test_push_unicode_character_as_bytes(self):
         eq = self.make_eventqueue()
         eq.keymap = {}
 
-        eq.push("ч".encode(eq.encoding, "replace"))
+        encoded = "ч".encode(eq.encoding, "replace")
+        self.assertEqual(len(encoded), 2)
+
+        eq.push(encoded[0])
+        e = eq.get()
+        self.assertIsNone(e)
+
+        eq.push(encoded[1])
         e = eq.get()
         self.assertEqual(e.evt, "key")
         self.assertEqual(e.data, "ч")
 
-    def test_push_long_unicode_character_as_bytes(self):
+    def test_push_unicode_character_as_bytes_in_paste_mode(self):
         eq = self.make_eventqueue()
         eq.keymap = {}
 
@@ -151,9 +159,9 @@ def _push(keys):
             for k in keys:
                 eq.push(k)
 
-        _push("\x1b[200")
-        eq.push("ñ".encode(eq.encoding, "replace"))
-        _push("\x1b[201")
+        _push(b"\x1b[200")
+        _push("ñ".encode(eq.encoding, "replace"))
+        _push(b"\x1b[201")
 
         self.assertEqual(eq.get(), _event("key", "\x1b"))
         self.assertEqual(eq.get(), _event("key", "["))
@@ -169,7 +177,7 @@ def _push(keys):
         self.assertEqual(eq.get(), _event("key", "0"))
         self.assertEqual(eq.get(), _event("key", "1"))
 
-    def test_push_long_unicode_character(self):
+    def test_push_unicode_character_as_str_in_paste_mode(self):
         eq = self.make_eventqueue()
         eq.keymap = {}
 
@@ -182,11 +190,12 @@ def _push(keys):
             for k in keys:
                 eq.push(k)
 
-        _push("\x1b[200")
-        msg = "'utf-8' codec can't decode byte 0xf1 in position 0: unexpected end of data"
-        with self.assertRaisesRegex(UnicodeDecodeError, msg):
-            eq.push("ñ")
-        _push("\x1b[201")
+        self.assertIsInstance("ñ", str)
+
+        _push(b"\x1b[200")
+        with self.assertRaises(AssertionError):
+            _push("ñ")
+        _push(b"\x1b[201")
 
         self.assertEqual(eq.get(), _event("key", "\x1b"))
         self.assertEqual(eq.get(), _event("key", "["))