Debian Codegraph @

Lib/_pyrepl/reader.py

raw
1 # Copyright 2000-2010 Michael Hudson-Doyle <[email protected]>
2 # Antonio Cuni
3 # Armin Rigo
4 #
5 # All Rights Reserved
6 #
7 #
8 # Permission to use, copy, modify, and distribute this software and
9 # its documentation for any purpose is hereby granted without fee,
10 # provided that the above copyright notice appear in all copies and
11 # that both that copyright notice and this permission notice appear in
12 # supporting documentation.
13 #
14 # THE AUTHOR MICHAEL HUDSON DISCLAIMS ALL WARRANTIES WITH REGARD TO
15 # THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
16 # AND FITNESS, IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL,
17 # INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
18 # RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
19 # CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
20 # CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
21
22 from __future__ import annotations
23
24 import sys
25
26 from contextlib import contextmanager
27 from dataclasses import dataclass, field, fields
28 from _colorize import can_colorize, ANSIColors
29
30
31 from . import commands, console, input
32 from .utils import wlen, unbracket, disp_str
33 from .trace import trace
34
35
36 # types
37 Command = commands.Command
38 from .types import Callback, SimpleContextManager, KeySpec, CommandName
39
40
41 # syntax classes:
42
43 SYNTAX_WHITESPACE, SYNTAX_WORD, SYNTAX_SYMBOL = range(3)
44
45
46 def make_default_syntax_table() -> dict[str, int]:
47 # XXX perhaps should use some unicodedata here?
48 st: dict[str, int] = {}
49 for c in map(chr, range(256)):
50 st[c] = SYNTAX_SYMBOL
51 for c in [a for a in map(chr, range(256)) if a.isalnum()]:
52 st[c] = SYNTAX_WORD
53 st["\n"] = st[" "] = SYNTAX_WHITESPACE
54 return st
55
56
57 def make_default_commands() -> dict[CommandName, type[Command]]:
58 result: dict[CommandName, type[Command]] = {}
59 for v in vars(commands).values():
60 if isinstance(v, type) and issubclass(v, Command) and v.__name__[0].islower():
61 result[v.__name__] = v
62 result[v.__name__.replace("_", "-")] = v
63 return result
64
65
66 default_keymap: tuple[tuple[KeySpec, CommandName], ...] = tuple(
67 [
68 (r"\C-a", "beginning-of-line"),
69 (r"\C-b", "left"),
70 (r"\C-c", "interrupt"),
71 (r"\C-d", "delete"),
72 (r"\C-e", "end-of-line"),
73 (r"\C-f", "right"),
74 (r"\C-g", "cancel"),
75 (r"\C-h", "backspace"),
76 (r"\C-j", "accept"),
77 (r"\<return>", "accept"),
78 (r"\C-k", "kill-line"),
79 (r"\C-l", "clear-screen"),
80 (r"\C-m", "accept"),
81 (r"\C-t", "transpose-characters"),
82 (r"\C-u", "unix-line-discard"),
83 (r"\C-w", "unix-word-rubout"),
84 (r"\C-x\C-u", "upcase-region"),
85 (r"\C-y", "yank"),
86 *(() if sys.platform == "win32" else ((r"\C-z", "suspend"), )),
87 (r"\M-b", "backward-word"),
88 (r"\M-c", "capitalize-word"),
89 (r"\M-d", "kill-word"),
90 (r"\M-f", "forward-word"),
91 (r"\M-l", "downcase-word"),
92 (r"\M-t", "transpose-words"),
93 (r"\M-u", "upcase-word"),
94 (r"\M-y", "yank-pop"),
95 (r"\M--", "digit-arg"),
96 (r"\M-0", "digit-arg"),
97 (r"\M-1", "digit-arg"),
98 (r"\M-2", "digit-arg"),
99 (r"\M-3", "digit-arg"),
100 (r"\M-4", "digit-arg"),
101 (r"\M-5", "digit-arg"),
102 (r"\M-6", "digit-arg"),
103 (r"\M-7", "digit-arg"),
104 (r"\M-8", "digit-arg"),
105 (r"\M-9", "digit-arg"),
106 (r"\M-\n", "accept"),
107 ("\\\\", "self-insert"),
108 (r"\x1b[200~", "enable_bracketed_paste"),
109 (r"\x1b[201~", "disable_bracketed_paste"),
110 (r"\x03", "ctrl-c"),
111 ]
112 + [(c, "self-insert") for c in map(chr, range(32, 127)) if c != "\\"]
113 + [(c, "self-insert") for c in map(chr, range(128, 256)) if c.isalpha()]
114 + [
115 (r"\<up>", "up"),
116 (r"\<down>", "down"),
117 (r"\<left>", "left"),
118 (r"\C-\<left>", "backward-word"),
119 (r"\<right>", "right"),
120 (r"\C-\<right>", "forward-word"),
121 (r"\<delete>", "delete"),
122 (r"\x1b[3~", "delete"),
123 (r"\<backspace>", "backspace"),
124 (r"\M-\<backspace>", "backward-kill-word"),
125 (r"\<end>", "end-of-line"), # was 'end'
126 (r"\<home>", "beginning-of-line"), # was 'home'
127 (r"\<f1>", "help"),
128 (r"\<f2>", "show-history"),
129 (r"\<f3>", "paste-mode"),
130 (r"\EOF", "end"), # the entries in the terminfo database for xterms
131 (r"\EOH", "home"), # seem to be wrong. this is a less than ideal
132 # workaround
133 ]
134 )
135
136
137 @dataclass(slots=True)
138 class Reader:
139 """The Reader class implements the bare bones of a command reader,
140 handling such details as editing and cursor motion. What it does
141 not support are such things as completion or history support -
142 these are implemented elsewhere.
143
144 Instance variables of note include:
145
146 * buffer:
147 A *list* (*not* a string at the moment :-) containing all the
148 characters that have been entered.
149 * console:
150 Hopefully encapsulates the OS dependent stuff.
151 * pos:
152 A 0-based index into `buffer' for where the insertion point
153 is.
154 * screeninfo:
155 Ahem. This list contains some info needed to move the
156 insertion point around reasonably efficiently.
157 * cxy, lxy:
158 the position of the insertion point in screen ...
159 * syntax_table:
160 Dictionary mapping characters to `syntax class'; read the
161 emacs docs to see what this means :-)
162 * commands:
163 Dictionary mapping command names to command classes.
164 * arg:
165 The emacs-style prefix argument. It will be None if no such
166 argument has been provided.
167 * dirty:
168 True if we need to refresh the display.
169 * kill_ring:
170 The emacs-style kill-ring; manipulated with yank & yank-pop
171 * ps1, ps2, ps3, ps4:
172 prompts. ps1 is the prompt for a one-line input; for a
173 multiline input it looks like:
174 ps2> first line of input goes here
175 ps3> second and further
176 ps3> lines get ps3
177 ...
178 ps4> and the last one gets ps4
179 As with the usual top-level, you can set these to instances if
180 you like; str() will be called on them (once) at the beginning
181 of each command. Don't put really long or newline containing
182 strings here, please!
183 This is just the default policy; you can change it freely by
184 overriding get_prompt() (and indeed some standard subclasses
185 do).
186 * finished:
187 handle1 will set this to a true value if a command signals
188 that we're done.
189 """
190
191 console: console.Console
192
193 ## state
194 buffer: list[str] = field(default_factory=list)
195 pos: int = 0
196 ps1: str = "->> "
197 ps2: str = "/>> "
198 ps3: str = "|.. "
199 ps4: str = R"\__ "
200 kill_ring: list[list[str]] = field(default_factory=list)
201 msg: str = ""
202 arg: int | None = None
203 dirty: bool = False
204 finished: bool = False
205 paste_mode: bool = False
206 in_bracketed_paste: bool = False
207 commands: dict[str, type[Command]] = field(default_factory=make_default_commands)
208 last_command: type[Command] | None = None
209 syntax_table: dict[str, int] = field(default_factory=make_default_syntax_table)
210 keymap: tuple[tuple[str, str], ...] = ()
211 input_trans: input.KeymapTranslator = field(init=False)
212 input_trans_stack: list[input.KeymapTranslator] = field(default_factory=list)
213 screen: list[str] = field(default_factory=list)
214 screeninfo: list[tuple[int, list[int]]] = field(init=False)
215 cxy: tuple[int, int] = field(init=False)
216 lxy: tuple[int, int] = field(init=False)
217 scheduled_commands: list[str] = field(default_factory=list)
218 can_colorize: bool = False
219 threading_hook: Callback | None = None
220
221 ## cached metadata to speed up screen refreshes
222 @dataclass
223 class RefreshCache:
224 in_bracketed_paste: bool = False
225 screen: list[str] = field(default_factory=list)
226 screeninfo: list[tuple[int, list[int]]] = field(init=False)
227 line_end_offsets: list[int] = field(default_factory=list)
228 pos: int = field(init=False)
229 cxy: tuple[int, int] = field(init=False)
230 dimensions: tuple[int, int] = field(init=False)
231 invalidated: bool = False
232
233 def update_cache(self,
234 reader: Reader,
235 screen: list[str],
236 screeninfo: list[tuple[int, list[int]]],
237 ) -> None:
238 self.in_bracketed_paste = reader.in_bracketed_paste
239 self.screen = screen.copy()
240 self.screeninfo = screeninfo.copy()
241 self.pos = reader.pos
242 self.cxy = reader.cxy
243 self.dimensions = reader.console.width, reader.console.height
244 self.invalidated = False
245
246 def valid(self, reader: Reader) -> bool:
247 if self.invalidated:
248 return False
249 dimensions = reader.console.width, reader.console.height
250 dimensions_changed = dimensions != self.dimensions
251 paste_changed = reader.in_bracketed_paste != self.in_bracketed_paste
252 return not (dimensions_changed or paste_changed)
253
254 def get_cached_location(self, reader: Reader) -> tuple[int, int]:
255 if self.invalidated:
256 raise ValueError("Cache is invalidated")
257 offset = 0
258 earliest_common_pos = min(reader.pos, self.pos)
259 num_common_lines = len(self.line_end_offsets)
260 while num_common_lines > 0:
261 offset = self.line_end_offsets[num_common_lines - 1]
262 if earliest_common_pos > offset:
263 break
264 num_common_lines -= 1
265 else:
266 offset = 0
267 return offset, num_common_lines
268
269 last_refresh_cache: RefreshCache = field(default_factory=RefreshCache)
270
271 def __post_init__(self) -> None:
272 # Enable the use of `insert` without a `prepare` call - necessary to
273 # facilitate the tab completion hack implemented for
274 # <https://bugs.python.org/issue25660>.
275 self.keymap = self.collect_keymap()
276 self.input_trans = input.KeymapTranslator(
277 self.keymap, invalid_cls="invalid-key", character_cls="self-insert"
278 )
279 self.screeninfo = [(0, [])]
280 self.cxy = self.pos2xy()
281 self.lxy = (self.pos, 0)
282 self.can_colorize = can_colorize()
283
284 self.last_refresh_cache.screeninfo = self.screeninfo
285 self.last_refresh_cache.pos = self.pos
286 self.last_refresh_cache.cxy = self.cxy
287 self.last_refresh_cache.dimensions = (0, 0)
288
289 def collect_keymap(self) -> tuple[tuple[KeySpec, CommandName], ...]:
290 return default_keymap
291
292 def calc_screen(self) -> list[str]:
293 """Translate changes in self.buffer into changes in self.console.screen."""
294 # Since the last call to calc_screen:
295 # screen and screeninfo may differ due to a completion menu being shown
296 # pos and cxy may differ due to edits, cursor movements, or completion menus
297
298 # Lines that are above both the old and new cursor position can't have changed,
299 # unless the terminal has been resized (which might cause reflowing) or we've
300 # entered or left paste mode (which changes prompts, causing reflowing).
301 num_common_lines = 0
302 offset = 0
303 if self.last_refresh_cache.valid(self):
304 offset, num_common_lines = self.last_refresh_cache.get_cached_location(self)
305
306 screen = self.last_refresh_cache.screen
307 del screen[num_common_lines:]
308
309 screeninfo = self.last_refresh_cache.screeninfo
310 del screeninfo[num_common_lines:]
311
312 last_refresh_line_end_offsets = self.last_refresh_cache.line_end_offsets
313 del last_refresh_line_end_offsets[num_common_lines:]
314
315 pos = self.pos
316 pos -= offset
317
318 prompt_from_cache = (offset and self.buffer[offset - 1] != "\n")
319 lines = "".join(self.buffer[offset:]).split("\n")
320 cursor_found = False
321 lines_beyond_cursor = 0
322 for ln, line in enumerate(lines, num_common_lines):
323 line_len = len(line)
324 if 0 <= pos <= line_len:
325 self.lxy = pos, ln
326 cursor_found = True
327 elif cursor_found:
328 lines_beyond_cursor += 1
329 if lines_beyond_cursor > self.console.height:
330 # No need to keep formatting lines.
331 # The console can't show them.
332 break
333 if prompt_from_cache:
334 # Only the first line's prompt can come from the cache
335 prompt_from_cache = False
336 prompt = ""
337 else:
338 prompt = self.get_prompt(ln, line_len >= pos >= 0)
339 while "\n" in prompt:
340 pre_prompt, _, prompt = prompt.partition("\n")
341 last_refresh_line_end_offsets.append(offset)
342 screen.append(pre_prompt)
343 screeninfo.append((0, []))
344 pos -= line_len + 1
345 prompt, prompt_len = self.process_prompt(prompt)
346 chars, char_widths = disp_str(line)
347 wrapcount = (sum(char_widths) + prompt_len) // self.console.width
348 trace("wrapcount = {wrapcount}", wrapcount=wrapcount)
349 if wrapcount == 0 or not char_widths:
350 offset += line_len + 1 # Takes all of the line plus the newline
351 last_refresh_line_end_offsets.append(offset)
352 screen.append(prompt + "".join(chars))
353 screeninfo.append((prompt_len, char_widths))
354 else:
355 pre = prompt
356 prelen = prompt_len
357 for wrap in range(wrapcount + 1):
358 index_to_wrap_before = 0
359 column = 0
360 for char_width in char_widths:
361 if column + char_width + prelen >= self.console.width:
362 break
363 index_to_wrap_before += 1
364 column += char_width
365 if len(chars) > index_to_wrap_before:
366 offset += index_to_wrap_before
367 post = "\\"
368 after = [1]
369 else:
370 offset += index_to_wrap_before + 1 # Takes the newline
371 post = ""
372 after = []
373 last_refresh_line_end_offsets.append(offset)
374 render = pre + "".join(chars[:index_to_wrap_before]) + post
375 render_widths = char_widths[:index_to_wrap_before] + after
376 screen.append(render)
377 screeninfo.append((prelen, render_widths))
378 chars = chars[index_to_wrap_before:]
379 char_widths = char_widths[index_to_wrap_before:]
380 pre = ""
381 prelen = 0
382 self.screeninfo = screeninfo
383 self.cxy = self.pos2xy()
384 if self.msg:
385 for mline in self.msg.split("\n"):
386 screen.append(mline)
387 screeninfo.append((0, []))
388
389 self.last_refresh_cache.update_cache(self, screen, screeninfo)
390 return screen
391
392 @staticmethod
393 def process_prompt(prompt: str) -> tuple[str, int]:
394 r"""Return a tuple with the prompt string and its visible length.
395
396 The prompt string has the zero-width brackets recognized by shells
397 (\x01 and \x02) removed. The length ignores anything between those
398 brackets as well as any ANSI escape sequences.
399 """
400 out_prompt = unbracket(prompt, including_content=False)
401 visible_prompt = unbracket(prompt, including_content=True)
402 return out_prompt, wlen(visible_prompt)
403
404 def bow(self, p: int | None = None) -> int:
405 """Return the 0-based index of the word break preceding p most
406 immediately.
407
408 p defaults to self.pos; word boundaries are determined using
409 self.syntax_table."""
410 if p is None:
411 p = self.pos
412 st = self.syntax_table
413 b = self.buffer
414 p -= 1
415 while p >= 0 and st.get(b[p], SYNTAX_WORD) != SYNTAX_WORD:
416 p -= 1
417 while p >= 0 and st.get(b[p], SYNTAX_WORD) == SYNTAX_WORD:
418 p -= 1
419 return p + 1
420
421 def eow(self, p: int | None = None) -> int:
422 """Return the 0-based index of the word break following p most
423 immediately.
424
425 p defaults to self.pos; word boundaries are determined using
426 self.syntax_table."""
427 if p is None:
428 p = self.pos
429 st = self.syntax_table
430 b = self.buffer
431 while p < len(b) and st.get(b[p], SYNTAX_WORD) != SYNTAX_WORD:
432 p += 1
433 while p < len(b) and st.get(b[p], SYNTAX_WORD) == SYNTAX_WORD:
434 p += 1
435 return p
436
437 def bol(self, p: int | None = None) -> int:
438 """Return the 0-based index of the line break preceding p most
439 immediately.
440
441 p defaults to self.pos."""
442 if p is None:
443 p = self.pos
444 b = self.buffer
445 p -= 1
446 while p >= 0 and b[p] != "\n":
447 p -= 1
448 return p + 1
449
450 def eol(self, p: int | None = None) -> int:
451 """Return the 0-based index of the line break following p most
452 immediately.
453
454 p defaults to self.pos."""
455 if p is None:
456 p = self.pos
457 b = self.buffer
458 while p < len(b) and b[p] != "\n":
459 p += 1
460 return p
461
462 def max_column(self, y: int) -> int:
463 """Return the last x-offset for line y"""
464 return self.screeninfo[y][0] + sum(self.screeninfo[y][1])
465
466 def max_row(self) -> int:
467 return len(self.screeninfo) - 1
468
469 def get_arg(self, default: int = 1) -> int:
470 """Return any prefix argument that the user has supplied,
471 returning `default' if there is None. Defaults to 1.
472 """
473 if self.arg is None:
474 return default
475 return self.arg
476
477 def get_prompt(self, lineno: int, cursor_on_line: bool) -> str:
478 """Return what should be in the left-hand margin for line
479 `lineno'."""
480 if self.arg is not None and cursor_on_line:
481 prompt = f"(arg: {self.arg}) "
482 elif self.paste_mode and not self.in_bracketed_paste:
483 prompt = "(paste) "
484 elif "\n" in self.buffer:
485 if lineno == 0:
486 prompt = self.ps2
487 elif self.ps4 and lineno == self.buffer.count("\n"):
488 prompt = self.ps4
489 else:
490 prompt = self.ps3
491 else:
492 prompt = self.ps1
493
494 if self.can_colorize:
495 prompt = f"{ANSIColors.BOLD_MAGENTA}{prompt}{ANSIColors.RESET}"
496 return prompt
497
498 def push_input_trans(self, itrans: input.KeymapTranslator) -> None:
499 self.input_trans_stack.append(self.input_trans)
500 self.input_trans = itrans
501
502 def pop_input_trans(self) -> None:
503 self.input_trans = self.input_trans_stack.pop()
504
505 def setpos_from_xy(self, x: int, y: int) -> None:
506 """Set pos according to coordinates x, y"""
507 pos = 0
508 i = 0
509 while i < y:
510 prompt_len, char_widths = self.screeninfo[i]
511 offset = len(char_widths)
512 in_wrapped_line = prompt_len + sum(char_widths) >= self.console.width
513 if in_wrapped_line:
514 pos += offset - 1 # -1 cause backslash is not in buffer
515 else:
516 pos += offset + 1 # +1 cause newline is in buffer
517 i += 1
518
519 j = 0
520 cur_x = self.screeninfo[i][0]
521 while cur_x < x:
522 if self.screeninfo[i][1][j] == 0:
523 j += 1 # prevent potential future infinite loop
524 continue
525 cur_x += self.screeninfo[i][1][j]
526 j += 1
527 pos += 1
528
529 self.pos = pos
530
531 def pos2xy(self) -> tuple[int, int]:
532 """Return the x, y coordinates of position 'pos'."""
533
534 prompt_len, y = 0, 0
535 char_widths: list[int] = []
536 pos = self.pos
537 assert 0 <= pos <= len(self.buffer)
538
539 # optimize for the common case: typing at the end of the buffer
540 if pos == len(self.buffer) and len(self.screeninfo) > 0:
541 y = len(self.screeninfo) - 1
542 prompt_len, char_widths = self.screeninfo[y]
543 return prompt_len + sum(char_widths), y
544
545 for prompt_len, char_widths in self.screeninfo:
546 offset = len(char_widths)
547 in_wrapped_line = prompt_len + sum(char_widths) >= self.console.width
548 if in_wrapped_line:
549 offset -= 1 # need to remove line-wrapping backslash
550
551 if offset >= pos:
552 break
553
554 if not in_wrapped_line:
555 offset += 1 # there's a newline in buffer
556
557 pos -= offset
558 y += 1
559 return prompt_len + sum(char_widths[:pos]), y
560
561 def insert(self, text: str | list[str]) -> None:
562 """Insert 'text' at the insertion point."""
563 self.buffer[self.pos : self.pos] = list(text)
564 self.pos += len(text)
565 self.dirty = True
566
567 def update_cursor(self) -> None:
568 """Move the cursor to reflect changes in self.pos"""
569 self.cxy = self.pos2xy()
570 self.console.move_cursor(*self.cxy)
571
572 def after_command(self, cmd: Command) -> None:
573 """This function is called to allow post command cleanup."""
574 if getattr(cmd, "kills_digit_arg", True):
575 if self.arg is not None:
576 self.dirty = True
577 self.arg = None
578
579 def prepare(self) -> None:
580 """Get ready to run. Call restore when finished. You must not
581 write to the console in between the calls to prepare and
582 restore."""
583 try:
584 self.console.prepare()
585 self.arg = None
586 self.finished = False
587 del self.buffer[:]
588 self.pos = 0
589 self.dirty = True
590 self.last_command = None
591 self.calc_screen()
592 except BaseException:
593 self.restore()
594 raise
595
596 while self.scheduled_commands:
597 cmd = self.scheduled_commands.pop()
598 self.do_cmd((cmd, []))
599
600 def last_command_is(self, cls: type) -> bool:
601 if not self.last_command:
602 return False
603 return issubclass(cls, self.last_command)
604
605 def restore(self) -> None:
606 """Clean up after a run."""
607 self.console.restore()
608
609 @contextmanager
610 def suspend(self) -> SimpleContextManager:
611 """A context manager to delegate to another reader."""
612 prev_state = {f.name: getattr(self, f.name) for f in fields(self)}
613 try:
614 self.restore()
615 yield
616 finally:
617 for arg in ("msg", "ps1", "ps2", "ps3", "ps4", "paste_mode"):
618 setattr(self, arg, prev_state[arg])
619 self.prepare()
620
621 def finish(self) -> None:
622 """Called when a command signals that we're finished."""
623 pass
624
625 def error(self, msg: str = "none") -> None:
626 self.msg = "! " + msg + " "
627 self.dirty = True
628 self.console.beep()
629
630 def update_screen(self) -> None:
631 if self.dirty:
632 self.refresh()
633
634 def refresh(self) -> None:
635 """Recalculate and refresh the screen."""
636 if self.in_bracketed_paste and self.buffer and not self.buffer[-1] == "\n":
637 return
638
639 # this call sets up self.cxy, so call it first.
640 self.screen = self.calc_screen()
641 self.console.refresh(self.screen, self.cxy)
642 self.dirty = False
643
644 def do_cmd(self, cmd: tuple[str, list[str]]) -> None:
645 """`cmd` is a tuple of "event_name" and "event", which in the current
646 implementation is always just the "buffer" which happens to be a list
647 of single-character strings."""
648
649 trace("received command {cmd}", cmd=cmd)
650 if isinstance(cmd[0], str):
651 command_type = self.commands.get(cmd[0], commands.invalid_command)
652 elif isinstance(cmd[0], type):
653 command_type = cmd[0]
654 else:
655 return # nothing to do
656
657 command = command_type(self, *cmd) # type: ignore[arg-type]
658 command.do()
659
660 self.after_command(command)
661
662 if self.dirty:
663 self.refresh()
664 else:
665 self.update_cursor()
666
667 if not isinstance(cmd, commands.digit_arg):
668 self.last_command = command_type
669
670 self.finished = bool(command.finish)
671 if self.finished:
672 self.console.finish()
673 self.finish()
674
675 def run_hooks(self) -> None:
676 threading_hook = self.threading_hook
677 if threading_hook is None and 'threading' in sys.modules:
678 from ._threading_handler import install_threading_hook
679 install_threading_hook(self)
680 if threading_hook is not None:
681 try:
682 threading_hook()
683 except Exception:
684 pass
685
686 input_hook = self.console.input_hook
687 if input_hook:
688 try:
689 input_hook()
690 except Exception:
691 pass
692
693 def handle1(self, block: bool = True) -> bool:
694 """Handle a single event. Wait as long as it takes if block
695 is true (the default), otherwise return False if no event is
696 pending."""
697
698 if self.msg:
699 self.msg = ""
700 self.dirty = True
701
702 while True:
703 # We use the same timeout as in readline.c: 100ms
704 self.run_hooks()
705 self.console.wait(100)
706 event = self.console.get_event(block=False)
707 if not event:
708 if block:
709 continue
710 return False
711
712 translate = True
713
714 if event.evt == "key":
715 self.input_trans.push(event)
716 elif event.evt == "scroll":
717 self.refresh()
718 elif event.evt == "resize":
719 self.refresh()
720 else:
721 translate = False
722
723 if translate:
724 cmd = self.input_trans.get()
725 else:
726 cmd = [event.evt, event.data]
727
728 if cmd is None:
729 if block:
730 continue
731 return False
732
733 self.do_cmd(cmd)
734 return True
735
736 def push_char(self, char: int | bytes) -> None:
737 self.console.push_char(char)
738 self.handle1(block=False)
739
740 def readline(self, startup_hook: Callback | None = None) -> str:
741 """Read a line. The implementation of this method also shows
742 how to drive Reader if you want more control over the event
743 loop."""
744 self.prepare()
745 try:
746 if startup_hook is not None:
747 startup_hook()
748 self.refresh()
749 while not self.finished:
750 self.handle1()
751 return self.get_unicode()
752
753 finally:
754 self.restore()
755
756 def bind(self, spec: KeySpec, command: CommandName) -> None:
757 self.keymap = self.keymap + ((spec, command),)
758 self.input_trans = input.KeymapTranslator(
759 self.keymap, invalid_cls="invalid-key", character_cls="self-insert"
760 )
761
762 def get_unicode(self) -> str:
763 """Return the current buffer as a unicode string."""
764 return "".join(self.buffer)