mirror of
https://github.com/kovidgoyal/kitty.git
synced 2026-11-16 13:08:25 +00:00
612 lines
21 KiB
Python
612 lines
21 KiB
Python
#!/usr/bin/env python
|
|
# License: GPL v3 Copyright: 2016, Kovid Goyal <kovid at kovidgoyal.net>
|
|
|
|
import fcntl
|
|
import io
|
|
import os
|
|
import select
|
|
import shlex
|
|
import shutil
|
|
import signal
|
|
import struct
|
|
import sys
|
|
import termios
|
|
import time
|
|
from contextlib import contextmanager, suppress
|
|
from functools import wraps
|
|
from unittest import TestCase
|
|
|
|
from kitty.config import finalize_keys, finalize_mouse_mappings
|
|
from kitty.fast_data_types import TEXT_SIZE_CODE, Cursor, HistoryBuf, LineBuf, Screen, get_options, monotonic, set_options
|
|
from kitty.options.parse import merge_result_dicts
|
|
from kitty.options.types import Options, defaults
|
|
from kitty.options.utils import mouse_wheel_buttons
|
|
from kitty.rgb import to_color
|
|
from kitty.types import MouseEvent
|
|
from kitty.window import da1, decode_cmdline, process_remote_print, process_title_from_child
|
|
|
|
from . import is_ci
|
|
|
|
|
|
def parse_bytes(screen, data, dump_callback=None):
|
|
data = memoryview(data)
|
|
while data:
|
|
dest = screen.test_create_write_buffer()
|
|
s = screen.test_commit_write_buffer(data, dest)
|
|
data = data[s:]
|
|
screen.test_parse_written_data(dump_callback)
|
|
|
|
|
|
def draw_multicell(
|
|
screen: Screen, text: str, width: int = 0, scale: int = 1, subscale_n: int = 0, subscale_d: int = 0, vertical_align: int = 0, horizontal_align: int = 0
|
|
) -> None:
|
|
cmd = f'\x1b]{TEXT_SIZE_CODE};w={width}:s={scale}:n={subscale_n}:d={subscale_d}:v={vertical_align}:h={horizontal_align};{text}\a'
|
|
parse_bytes(screen, cmd.encode())
|
|
|
|
|
|
class Callbacks:
|
|
def __init__(self, pty=None) -> None:
|
|
self.clear()
|
|
self.pty = pty
|
|
self.ftc = None
|
|
self.set_pointer_shape = lambda data: None
|
|
self.last_cmd_at = 0
|
|
self.last_cmd_cmdline = ''
|
|
self.last_cmd_exit_status = sys.maxsize
|
|
|
|
def write(self, data) -> None:
|
|
self.wtcbuf += bytes(data)
|
|
|
|
def notify_child_of_resize(self):
|
|
self.num_of_resize_events += 1
|
|
|
|
def on_reset(self, is_hard_reset: bool = True) -> None:
|
|
if self.pty is not None:
|
|
self.pty.reset_termios_state()
|
|
|
|
def color_control(self, code, data) -> None:
|
|
from kitty.fast_data_types import base64_decode
|
|
from kitty.window import color_control
|
|
|
|
response = color_control(self.color_profile, code, data)
|
|
if response:
|
|
|
|
def p(x):
|
|
if '@' in x:
|
|
return (to_color(x.partition('@')[0]), int(255 * float(x.partition('@')[2])))
|
|
ans = to_color(x)
|
|
if ans is None:
|
|
ans = x
|
|
return ans
|
|
|
|
parts = {}
|
|
for x in response.split(';')[1:]:
|
|
k, _, v = x.partition('=')
|
|
if k == 'unknown':
|
|
# unknown field names are base64 encoded, collect the decoded names in a list
|
|
parts.setdefault('unknown', []).append(base64_decode(v).decode('ascii'))
|
|
else:
|
|
parts[k] = p(v)
|
|
self.color_control_responses.append(parts)
|
|
|
|
def title_changed(self, data, is_base64=False) -> None:
|
|
self.titlebuf.append(process_title_from_child(data, is_base64, ''))
|
|
|
|
def on_cwd_change(self, raw_url) -> None:
|
|
self.cwd_changes.append(raw_url)
|
|
|
|
def osc_context(self, data):
|
|
pass
|
|
|
|
def program_status_report(self, data):
|
|
self.program_status_reports.append(str(data, 'utf-8'))
|
|
|
|
def icon_changed(self, data) -> None:
|
|
self.iconbuf += str(data, 'utf-8')
|
|
|
|
def set_dynamic_color(self, code, data='') -> None:
|
|
if code == 22:
|
|
self.set_pointer_shape(data)
|
|
else:
|
|
self.colorbuf += str(data or b'', 'utf-8')
|
|
|
|
def set_color_table_color(self, code, data='') -> None:
|
|
self.ctbuf += ''
|
|
|
|
def color_profile_popped(self, x) -> None:
|
|
pass
|
|
|
|
def cmd_output_marking(self, is_start: bool | None, data: str = '') -> None:
|
|
if is_start:
|
|
self.last_cmd_at = monotonic()
|
|
self.last_cmd_cmdline = decode_cmdline(data) if data else data
|
|
else:
|
|
if self.last_cmd_at != 0:
|
|
self.last_cmd_at = 0
|
|
with suppress(Exception):
|
|
self.last_cmd_exit_status = int(data)
|
|
|
|
def request_capabilities(self, q) -> None:
|
|
from kitty.terminfo import get_capabilities
|
|
|
|
for c in get_capabilities(q, None):
|
|
self.write(c.encode('ascii'))
|
|
|
|
def desktop_notify(self, osc_code: int, raw_data: memoryview) -> None:
|
|
self.notifications.append((osc_code, str(raw_data, 'utf-8')))
|
|
|
|
def open_url(self, url: str, hyperlink_id: int) -> None:
|
|
self.open_urls.append((url, hyperlink_id))
|
|
|
|
def clipboard_control(self, data: memoryview, is_partial: bool = False) -> None:
|
|
self.cc_buf.append((str(data, 'utf-8'), is_partial))
|
|
|
|
def clear(self) -> None:
|
|
self.wtcbuf = b''
|
|
self.iconbuf = self.colorbuf = self.ctbuf = ''
|
|
self.titlebuf = []
|
|
self.cwd_changes = []
|
|
self.printbuf = []
|
|
self.color_control_responses = []
|
|
self.notifications = []
|
|
self.program_status_reports = []
|
|
self.open_urls = []
|
|
self.cc_buf = []
|
|
self.bell_count = 0
|
|
self.clone_cmds = []
|
|
self.current_clone_data = ''
|
|
self.last_cmd_exit_status = sys.maxsize
|
|
self.last_cmd_cmdline = ''
|
|
self.last_cmd_at = 0
|
|
self.num_of_resize_events = 0
|
|
self.da1 = []
|
|
|
|
def on_bell(self) -> None:
|
|
self.bell_count += 1
|
|
|
|
def on_da1(self) -> None:
|
|
opts = None
|
|
with suppress(RuntimeError):
|
|
opts = get_options()
|
|
if opts is None:
|
|
opts = defaults
|
|
payload = da1(opts)
|
|
self.da1.append(payload)
|
|
if self.pty and self.pty.needs_da1:
|
|
self.pty.send_da1_response(payload)
|
|
|
|
def on_activity_since_last_focus(self) -> None:
|
|
pass
|
|
|
|
def finish_scroll_animation(self) -> None:
|
|
pass
|
|
|
|
def on_mouse_event(self, event):
|
|
steps = 1
|
|
if event['button'] in mouse_wheel_buttons: # repeat_count is the number of wheel steps
|
|
steps, event['repeat_count'] = event['repeat_count'], 1
|
|
ev = MouseEvent(**event)
|
|
opts = get_options()
|
|
action_def = opts.mousemap.get(ev)
|
|
if not action_def:
|
|
return False
|
|
self.current_mouse_button = ev.button
|
|
for _ in range(steps):
|
|
for action in opts.alias_map.resolve_aliases(action_def, 'mouse_map'):
|
|
getattr(self, action.func)(*action.args)
|
|
self.current_mouse_button = 0
|
|
return True
|
|
|
|
def handle_remote_print(self, msg):
|
|
text = process_remote_print(msg)
|
|
self.printbuf.append(text)
|
|
|
|
def handle_remote_cmd(self, msg):
|
|
pass
|
|
|
|
def handle_remote_clone(self, msg):
|
|
msg = str(msg, 'utf-8')
|
|
if not msg:
|
|
if self.current_clone_data:
|
|
cdata, self.current_clone_data = self.current_clone_data, ''
|
|
from kitty.launch import CloneCmd
|
|
|
|
self.clone_cmds.append(CloneCmd(cdata))
|
|
self.current_clone_data = ''
|
|
return
|
|
num, rest = msg.split(':', 1)
|
|
if num == '0' or len(self.current_clone_data) > 1024 * 1024:
|
|
self.current_clone_data = ''
|
|
self.current_clone_data += rest
|
|
|
|
def handle_remote_ssh(self, msg):
|
|
from kittens.ssh.utils import get_ssh_data
|
|
|
|
if self.pty:
|
|
for line in get_ssh_data(msg, 'testing'):
|
|
self.pty.write_to_child(line)
|
|
|
|
def handle_remote_echo(self, msg):
|
|
from base64 import standard_b64decode
|
|
|
|
if self.pty:
|
|
data = standard_b64decode(msg)
|
|
self.pty.write_to_child(data)
|
|
|
|
def file_transmission(self, data):
|
|
if self.ftc:
|
|
self.ftc.handle_serialized_command(data)
|
|
|
|
|
|
def filled_line_buf(ynum=5, xnum=5, cursor=Cursor()):
|
|
ans = LineBuf(ynum, xnum)
|
|
cursor.x = 0
|
|
for i in range(ynum):
|
|
t = (f'{i}') * xnum
|
|
ans.line(i).set_text(t, 0, xnum, cursor)
|
|
return ans
|
|
|
|
|
|
def filled_cursor():
|
|
ans = Cursor()
|
|
ans.bold = ans.italic = ans.reverse = ans.strikethrough = ans.dim = True
|
|
ans.fg = 0x101
|
|
ans.bg = 0x201
|
|
ans.decoration_fg = 0x301
|
|
return ans
|
|
|
|
|
|
def filled_history_buf(ynum=5, xnum=5, cursor=Cursor()):
|
|
lb = filled_line_buf(ynum, xnum, cursor)
|
|
ans = HistoryBuf(ynum, xnum)
|
|
for i in range(ynum):
|
|
ans.push(lb.line(i))
|
|
return ans
|
|
|
|
|
|
max_attempts = 4 if is_ci else 2
|
|
sleep_duration = 4 if is_ci else 2
|
|
|
|
|
|
def retry_on_failure(max_attempts=max_attempts, sleep_duration=sleep_duration):
|
|
def decorator(func):
|
|
@wraps(func)
|
|
def wrapper(*args, **kwargs):
|
|
for attempt in range(max_attempts):
|
|
try:
|
|
return func(*args, **kwargs)
|
|
except Exception:
|
|
if attempt < max_attempts - 1: # Don't sleep on the last attempt
|
|
time.sleep(sleep_duration)
|
|
print(f'{func.__name__} failed, retrying in {sleep_duration} seconds', file=sys.stderr)
|
|
else:
|
|
raise # Re-raise the last exception
|
|
|
|
return wrapper
|
|
|
|
return decorator
|
|
|
|
|
|
class BaseTest(TestCase):
|
|
ae = TestCase.assertEqual
|
|
maxDiff = 2048
|
|
is_ci = is_ci
|
|
|
|
def rmtree_ignoring_errors(self, tdir):
|
|
try:
|
|
shutil.rmtree(tdir)
|
|
except FileNotFoundError as err:
|
|
print('Failed to delete the directory:', tdir, 'with error:', err, file=sys.stderr)
|
|
|
|
def tearDown(self):
|
|
set_options(None)
|
|
|
|
def set_options(self, options=None):
|
|
final_options = {'scrollback_pager_history_size': 1024, 'click_interval': 0.5}
|
|
if options:
|
|
final_options.update(options)
|
|
options = Options(merge_result_dicts(defaults._asdict(), final_options))
|
|
finalize_keys(options, {})
|
|
finalize_mouse_mappings(options, {})
|
|
set_options(options)
|
|
return options
|
|
|
|
def cmd_to_run_python_code(self, code):
|
|
from kitty.constants import kitty_exe
|
|
|
|
return [kitty_exe(), '+runpy', code]
|
|
|
|
def create_screen(self, cols=5, lines=5, scrollback=5, cell_width=10, cell_height=20, options=None):
|
|
self.set_options(options)
|
|
c = Callbacks()
|
|
s = Screen(c, lines, cols, scrollback, cell_width, cell_height, 0, c)
|
|
c.color_profile = s.color_profile
|
|
return s
|
|
|
|
def create_pty(
|
|
self,
|
|
argv=None,
|
|
cols=80,
|
|
lines=100,
|
|
scrollback=100,
|
|
cell_width=10,
|
|
cell_height=20,
|
|
options=None,
|
|
cwd=None,
|
|
env=None,
|
|
stdin_fd=None,
|
|
needs_da1=False,
|
|
):
|
|
self.set_options(options)
|
|
return PTY(
|
|
argv,
|
|
lines,
|
|
cols,
|
|
scrollback,
|
|
cell_width,
|
|
cell_height,
|
|
cwd,
|
|
env,
|
|
stdin_fd=stdin_fd,
|
|
needs_da1=needs_da1,
|
|
)
|
|
|
|
def assertEqualAttributes(self, c1, c2):
|
|
x1, y1, c1.x, c1.y = c1.x, c1.y, 0, 0
|
|
x2, y2, c2.x, c2.y = c2.x, c2.y, 0, 0
|
|
try:
|
|
self.assertEqual(c1, c2)
|
|
finally:
|
|
c1.x, c1.y, c2.x, c2.y = x1, y1, x2, y2
|
|
|
|
|
|
debug_stdout = debug_stderr = -1
|
|
|
|
|
|
@contextmanager
|
|
def forwardable_stdio():
|
|
global debug_stderr, debug_stdout
|
|
debug_stdout = fd = os.dup(sys.stdout.fileno())
|
|
os.set_inheritable(fd, True)
|
|
debug_stderr = fd = os.dup(sys.stderr.fileno())
|
|
os.set_inheritable(fd, True)
|
|
try:
|
|
yield
|
|
finally:
|
|
os.close(debug_stderr)
|
|
os.close(debug_stdout)
|
|
debug_stderr = debug_stdout = -1
|
|
|
|
|
|
class PTY:
|
|
def __init__(
|
|
self,
|
|
argv=None,
|
|
rows=25,
|
|
columns=80,
|
|
scrollback=100,
|
|
cell_width=10,
|
|
cell_height=20,
|
|
cwd=None,
|
|
env=None,
|
|
stdin_fd=None,
|
|
needs_da1=True,
|
|
window_id=0,
|
|
log_data_flow=False,
|
|
):
|
|
self.log_data_flow = log_data_flow
|
|
if isinstance(argv, str):
|
|
argv = shlex.split(argv)
|
|
self.write_buf = b''
|
|
self.child_pid = 0
|
|
self.child_waited_for = False
|
|
self.cell_width = cell_width
|
|
self.cell_height = cell_height
|
|
if argv is None:
|
|
from kitty.child import openpty
|
|
|
|
self.master_fd, self.slave_fd = openpty()
|
|
self.initial_termios_state = termios.tcgetattr(self.master_fd)
|
|
else:
|
|
self.child_pid, self.master_fd = self.spawn_child(argv, rows, columns, cwd, env, stdin_fd)
|
|
if stdin_fd is not None:
|
|
os.close(stdin_fd)
|
|
os.set_blocking(self.master_fd, False)
|
|
self.set_window_size(rows=rows, columns=columns)
|
|
self.needs_da1 = needs_da1
|
|
self.callbacks = Callbacks(self)
|
|
self.screen = Screen(self.callbacks, rows, columns, scrollback, cell_width, cell_height, window_id, self.callbacks)
|
|
self.received_bytes = b''
|
|
|
|
def spawn_child(self, argv, rows, columns, cwd, env, stdin_fd):
|
|
# Do not use pty.fork() as that runs Python code in the forked child
|
|
# before exec(), and macOS (since Tahoe 26.2) sometimes kills processes
|
|
# that do anything non-trivial between fork() and exec() with SIGKILL.
|
|
# spawn() does all the child setup in C using only async-signal-safe
|
|
# functions. The window size is set before spawning so that the child
|
|
# sees the correct size from the start.
|
|
from kitty.child import openpty
|
|
from kitty.constants import kitten_exe
|
|
from kitty.fast_data_types import spawn
|
|
|
|
master, slave = openpty()
|
|
try:
|
|
s = struct.pack('HHHH', rows, columns, columns * self.cell_width, rows * self.cell_height)
|
|
fcntl.ioctl(master, termios.TIOCSWINSZ, s)
|
|
env = dict(os.environ if env is None else env)
|
|
pass_fds: tuple[int, ...] = ()
|
|
if debug_stdout > -1:
|
|
env['KITTY_STDIO_FORWARDED'] = str(debug_stdout)
|
|
pass_fds = (debug_stdout, debug_stderr)
|
|
ready_read_fd, ready_write_fd = os.pipe()
|
|
try:
|
|
pid = spawn(
|
|
argv[0],
|
|
cwd or os.getcwd(),
|
|
tuple(argv),
|
|
tuple(f'{k}={v}' for k, v in env.items()),
|
|
master,
|
|
slave,
|
|
-1 if stdin_fd is None else stdin_fd,
|
|
-1,
|
|
ready_read_fd,
|
|
ready_write_fd,
|
|
(),
|
|
kitten_exe(),
|
|
False,
|
|
pass_fds,
|
|
)
|
|
finally:
|
|
os.close(ready_read_fd)
|
|
# Closing the write end tells the child it can exec
|
|
os.close(ready_write_fd)
|
|
except BaseException:
|
|
os.close(master)
|
|
raise
|
|
finally:
|
|
os.close(slave)
|
|
return pid, master
|
|
|
|
def reset_termios_state(self):
|
|
if s := getattr(self, 'initial_termios_state', None):
|
|
termios.tcsetattr(self.master_fd, termios.TCSANOW, s)
|
|
|
|
def turn_off_echo(self):
|
|
s = termios.tcgetattr(self.master_fd)
|
|
s[3] &= ~termios.ECHO
|
|
termios.tcsetattr(self.master_fd, termios.TCSANOW, s)
|
|
|
|
def is_echo_on(self):
|
|
s = termios.tcgetattr(self.master_fd)
|
|
return True if s[3] & termios.ECHO else False
|
|
|
|
def __enter__(self):
|
|
return self
|
|
|
|
def __exit__(self, *a):
|
|
self.__del__()
|
|
|
|
def __del__(self):
|
|
if hasattr(self, 'master_fd'):
|
|
os.close(self.master_fd)
|
|
del self.master_fd
|
|
if hasattr(self, 'slave_fd'):
|
|
os.close(self.slave_fd)
|
|
del self.slave_fd
|
|
if getattr(self, 'child_pid', 0) > 0 and not self.child_waited_for:
|
|
st = time.monotonic()
|
|
while time.monotonic() - st < 2:
|
|
pid, ec = os.waitpid(self.child_pid, os.WNOHANG)
|
|
if pid == self.child_pid:
|
|
self.child_waited_for = True
|
|
break
|
|
time.sleep(0.1)
|
|
if not self.child_waited_for:
|
|
os.kill(self.child_pid, signal.SIGKILL)
|
|
os.waitpid(self.child_pid, 0)
|
|
self.child_waited_for = True
|
|
|
|
def write_to_child(self, data, flush=False):
|
|
if isinstance(data, str):
|
|
data = data.encode('utf-8')
|
|
if self.log_data_flow:
|
|
print('t -> c:', bytes(data))
|
|
self.write_buf += data
|
|
if flush:
|
|
self.process_input_from_child(0)
|
|
|
|
def send_da1_response(self, data: str) -> None:
|
|
self.write_to_child('\x1b[' + data, flush=False) # ]]]]]]
|
|
|
|
def send_cmd_to_child(self, cmd, flush=False):
|
|
self.callbacks.last_cmd_exit_status = sys.maxsize
|
|
self.last_cmd = cmd
|
|
self.write_to_child(cmd + '\r', flush=flush)
|
|
|
|
def process_input_from_child(self, timeout=10):
|
|
rd, wd, _ = select.select([self.master_fd], [self.master_fd] if self.write_buf else [], [], max(0, timeout))
|
|
if wd:
|
|
n = os.write(self.master_fd, self.write_buf)
|
|
self.write_buf = self.write_buf[n:]
|
|
|
|
bytes_read = 0
|
|
if rd:
|
|
data = os.read(self.master_fd, io.DEFAULT_BUFFER_SIZE)
|
|
bytes_read += len(data)
|
|
self.received_bytes += data
|
|
if self.log_data_flow:
|
|
print('c -> t:', data)
|
|
parse_bytes(self.screen, data)
|
|
return bytes_read
|
|
|
|
def wait_till(self, q, timeout=10, timeout_msg=None):
|
|
end_time = time.monotonic() + timeout
|
|
while not q() and time.monotonic() <= end_time:
|
|
try:
|
|
self.process_input_from_child(timeout=end_time - time.monotonic())
|
|
except OSError as e:
|
|
if not q():
|
|
raise Exception(f'Failed to read from pty with error: {e}. {self.screen_contents_for_error()}') from e
|
|
return
|
|
if not q():
|
|
msg = 'The condition was not met'
|
|
if timeout_msg is not None:
|
|
msg = timeout_msg()
|
|
if not msg.endswith('\n'):
|
|
msg += '. '
|
|
raise TimeoutError(f'Timed out after {timeout} seconds: {msg}{self.screen_contents_for_error()}')
|
|
|
|
def wait_till_child_exits(self, timeout=30 if BaseTest.is_ci else 10, require_exit_code=None):
|
|
end_time = time.monotonic() + timeout
|
|
while time.monotonic() <= end_time:
|
|
si_pid, status = os.waitpid(self.child_pid, os.WNOHANG)
|
|
if si_pid == self.child_pid:
|
|
# The child has been reaped, calling waitpid() on it again
|
|
# would fail with ECHILD, so handle every kind of termination
|
|
# here, not just a normal exit.
|
|
self.child_waited_for = True
|
|
with suppress(OSError):
|
|
while self.process_input_from_child(timeout=0):
|
|
pass
|
|
if os.WIFSIGNALED(status):
|
|
sig = os.WTERMSIG(status)
|
|
try:
|
|
signame = signal.Signals(sig).name
|
|
except ValueError:
|
|
signame = str(sig)
|
|
raise AssertionError(f'Child was killed by signal: {signame}. {self.screen_contents_for_error()}')
|
|
ec = os.waitstatus_to_exitcode(status)
|
|
if require_exit_code is not None and ec != require_exit_code:
|
|
raise AssertionError(f'Child exited with exit status: {status} code: {ec} != {require_exit_code}. {self.screen_contents_for_error()}')
|
|
return status
|
|
with suppress(OSError):
|
|
self.process_input_from_child(timeout=0.02)
|
|
raise AssertionError(f'Child did not exit in {timeout} seconds. {self.screen_contents_for_error()}')
|
|
|
|
def set_window_size(self, rows=25, columns=80, send_signal=True):
|
|
if hasattr(self, 'screen'):
|
|
self.screen.resize(rows, columns)
|
|
if send_signal:
|
|
x_pixels = columns * self.cell_width
|
|
y_pixels = rows * self.cell_height
|
|
s = struct.pack('HHHH', rows, columns, x_pixels, y_pixels)
|
|
fcntl.ioctl(self.master_fd, termios.TIOCSWINSZ, s)
|
|
|
|
def screen_contents_for_error(self):
|
|
from kitty.window import as_text
|
|
|
|
ans = as_text(self.screen, add_history=True, as_ansi=False)
|
|
return f'Screen contents as repr:\n{ans!r}\nScreen contents:\n{ans.rstrip()}'
|
|
|
|
def screen_contents(self):
|
|
lines = []
|
|
for i in range(self.screen.lines):
|
|
x = str(self.screen.line(i))
|
|
if x:
|
|
lines.append(x)
|
|
return '\n'.join(lines)
|
|
|
|
def last_cmd_output(self, as_ansi=False, add_wrap_markers=False):
|
|
from kitty.window import cmd_output
|
|
|
|
return cmd_output(self.screen, as_ansi=as_ansi, add_wrap_markers=add_wrap_markers)
|