def fork_prewarm_process(opts: Options,
use_exec: bool = False) -> Optional[PrewarmProcess]:
stdin_read, stdin_write = safe_pipe()
stdout_read, stdout_write = safe_pipe()
death_notify_read, death_notify_write = safe_pipe()
if use_exec:
import subprocess
tp = subprocess.Popen([
kitty_exe(), '+runpy',
f'from kitty.prewarm import exec_main; exec_main({stdin_read}, {stdout_write}, {death_notify_write})'
],
pass_fds=(stdin_read, stdout_write,
death_notify_write))
child_pid = tp.pid
tp.returncode = 0 # prevent a warning when the popen object is deleted with the process still running
else:
child_pid = os.fork()
if child_pid:
# master
os.close(stdin_read)
os.close(stdout_write)
os.close(death_notify_write)
p = PrewarmProcess(child_pid, stdin_write, stdout_read,
death_notify_read)
if use_exec:
p.reload_kitty_config()
return p
# child
os.close(stdin_write)
os.close(stdout_read)
os.close(death_notify_read)
set_options(opts)
exec_main(stdin_read, stdout_write, death_notify_write)
raise SystemExit(0)
def run_kitten(kitten: str, run_name: str = '__main__') -> None:
import runpy
original_kitten_name = kitten
kitten = resolved_kitten(kitten)
set_debug(kitten)
if kitten in all_kitten_names():
runpy.run_module(f'kittens.{kitten}.main', run_name=run_name)
return
# Look for a custom kitten
if not kitten.endswith('.py'):
kitten += '.py'
from kitty.constants import config_dir
path = path_to_custom_kitten(config_dir, kitten)
if not os.path.exists(path):
print('Available builtin kittens:', file=sys.stderr)
for kitten in all_kitten_names():
print(kitten, file=sys.stderr)
raise SystemExit(f'No kitten named {original_kitten_name}')
m = runpy.run_path(path,
init_globals={
'sys': sys,
'os': os
},
run_name='__run_kitten__')
from kitty.fast_data_types import set_options
try:
m['main'](sys.argv)
finally:
set_options(None)
def create_screen(self, cols=5, lines=5, scrollback=5, cell_width=10, cell_height=20, options=None):
final_options = {'scrollback_pager_history_size': 1024, 'click_interval': 0.5}
if options:
final_options.update(options)
options = Options(merge_configs(defaults._asdict(), final_options))
set_options(options)
c = Callbacks()
return Screen(c, lines, cols, scrollback, cell_width, cell_height, 0, c)
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_configs(defaults._asdict(), final_options))
finalize_keys(options)
finalize_mouse_mappings(options)
set_options(options)
return options
def set_kitty_opts(
paths: Sequence[str], overrides: Sequence[str] = ()) -> 'Options':
from kitty.config import load_config
from kitty.fast_data_types import set_options
from kitty.utils import suppress_error_logging
with suppress_error_logging():
opts = load_config(*paths, overrides=overrides or None)
set_options(opts)
return opts
def create_screen(self,
cols=5,
lines=5,
scrollback=5,
cell_width=10,
cell_height=20,
options={}):
options = Options(merge_configs(defaults._asdict(), options))
set_options(options)
c = Callbacks()
return Screen(c, lines, cols, scrollback, cell_width, cell_height, 0,
c)
def kitty_opts() -> 'Options':
from kitty.fast_data_types import get_options, set_options
try:
ans = cast(Optional['Options'], get_options())
except RuntimeError:
ans = None
if ans is None:
from kitty.cli import create_default_opts
from kitty.utils import suppress_error_logging
with suppress_error_logging():
ans = create_default_opts()
set_options(ans)
return ans
def create_screen(self,
cols=5,
lines=5,
scrollback=5,
cell_width=10,
cell_height=20,
options=None):
if options is None:
options = {'scrollback_pager_history_size': 1024}
options = Options(merge_configs(defaults._asdict(), options))
set_options(options)
c = Callbacks()
return Screen(c, lines, cols, scrollback, cell_width, cell_height, 0,
c)
def setup_for_testing(family='monospace', size=11.0, dpi=96.0):
opts = defaults._replace(font_family=family)
set_options(opts)
sprites = {}
def send_to_gpu(x, y, z, data):
sprites[(x, y, z)] = data
sprite_map_set_limits(100000, 100)
set_send_sprite_to_gpu(send_to_gpu)
set_logical_dpi(dpi, dpi)
cell_width, cell_height = set_font_family(opts, override_font_size=size)
prerender()
return sprites, cell_width, cell_height
def exec_main(stdin_read: int, stdout_write: int,
death_notify_write: int) -> None:
os.setsid()
# SIGUSR1 is used for reloading kitty config, we rely on the parent process
# to inform us of that
signal.signal(signal.SIGUSR1, signal.SIG_IGN)
signal.siginterrupt(signal.SIGUSR1, False)
os.set_inheritable(stdin_read, False)
os.set_inheritable(stdout_write, False)
os.set_inheritable(death_notify_write, False)
running_in_kitty(False)
try:
main(stdin_read, stdout_write, death_notify_write)
finally:
set_options(None)
def __enter__(self) -> Tuple[Dict[Tuple[int, int, int], bytes], int, int]:
opts = defaults._replace(font_family=self.family, font_size=self.size)
set_options(opts)
sprites = {}
def send_to_gpu(x: int, y: int, z: int, data: bytes) -> None:
sprites[(x, y, z)] = data
sprite_map_set_limits(100000, 100)
set_send_sprite_to_gpu(send_to_gpu)
try:
set_font_family(opts)
cell_width, cell_height = create_test_font_group(self.size, self.dpi, self.dpi)
return sprites, cell_width, cell_height
except Exception:
set_send_sprite_to_gpu(None)
raise
def __enter__(self):
from collections import OrderedDict
opts = defaults._replace(font_family=self.family, font_size=self.size)
set_options(opts)
sprites = OrderedDict()
def send_to_gpu(x, y, z, data):
sprites[(x, y, z)] = data
sprite_map_set_limits(100000, 100)
set_send_sprite_to_gpu(send_to_gpu)
try:
set_font_family(opts)
cell_width, cell_height = create_test_font_group(
self.size, self.dpi, self.dpi)
return sprites, cell_width, cell_height
except Exception:
set_send_sprite_to_gpu(None)
raise
def edit_config_file(args: List[str]) -> None:
from kitty.cli import create_default_opts
from kitty.fast_data_types import set_options
from kitty.utils import edit_config_file as f
set_options(create_default_opts())
f()
def tearDown(self):
set_options(None)
def handle_result(kargs, answer, target_window_id, boss):
args, rest = cli.parse_args([])
opts = cli.create_opts(args)
boss.keymap = opts.keymap.copy()
fast_data_types.set_options(opts, constants.is_wayland(), args.debug_rendering,
args.debug_font_fallback)
