latch 2.51.2.dev5__tar.gz → 2.51.2.dev6__tar.gz

{latch-2.51.2.dev5/latch.egg-info → latch-2.51.2.dev6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: latch
-Version: 2.51.2.dev5
+Version: 2.51.2.dev6
 Summary: The Latch SDK
 Author-email: kenny@latch.bio
 Classifier: Programming Language :: Python :: 3.8

{latch-2.51.2.dev5 → latch-2.51.2.dev6/latch.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: latch
-Version: 2.51.2.dev5
+Version: 2.51.2.dev6
 Summary: The Latch SDK
 Author-email: kenny@latch.bio
 Classifier: Programming Language :: Python :: 3.8

{latch-2.51.2.dev5 → latch-2.51.2.dev6}/latch.egg-info/SOURCES.txt

@@ -63,7 +63,6 @@ latch_cli/__init__.py
 latch_cli/click_utils.py
 latch_cli/constants.py
 latch_cli/main.py
-latch_cli/menus.py
 latch_cli/tinyrequests.py
 latch_cli/workflow_config.py
 latch_cli/auth/__init__.py
@@ -80,6 +79,11 @@ latch_cli/exceptions/cache.py
 latch_cli/exceptions/errors.py
 latch_cli/exceptions/handler.py
 latch_cli/exceptions/traceback.py
+latch_cli/menus/__init__.py
+latch_cli/menus/common.py
+latch_cli/menus/vt100.py
+latch_cli/menus/win32.py
+latch_cli/menus/win32_types.py
 latch_cli/nextflow/__init__.py
 latch_cli/nextflow/config.py
 latch_cli/nextflow/utils.py
@@ -172,7 +176,6 @@ latch_cli/snakemake/workflow.py
 latch_cli/snakemake/config/__init__.py
 latch_cli/snakemake/config/parser.py
 latch_cli/snakemake/config/utils.py
-latch_cli/tui/__init__.py
 latch_cli/utils/__init__.py
 latch_cli/utils/path.py
 tests/__init__.py

latch-2.51.2.dev6/latch_cli/menus/__init__.py

@@ -0,0 +1,8 @@
+import sys
+
+if sys.platform == "win32":
+    from .win32 import raw_input, select_tui
+else:
+    from .vt100 import raw_input, select_tui
+
+from .common import *

latch-2.51.2.dev6/latch_cli/menus/common.py

@@ -0,0 +1,181 @@
+import sys
+from typing import Callable, Generic, Tuple
+
+from git import Optional
+from typing_extensions import TypedDict, TypeVar
+
+old_print = print
+
+
+def buffered_print() -> Tuple[Callable, Callable]:
+    buffer = []
+
+    def __print(*args):
+        for arg in args:
+            buffer.append(arg)
+
+    def __show():
+        nonlocal buffer
+        old_print("".join(buffer), flush=True, end="")
+        buffer = []
+
+    return __print, __show
+
+
+# Allows for exactly one print per render, removing any weird flashing
+# behavior and also speeding things up considerably
+print, show = buffered_print()
+
+
+def clear(k: int):
+    """
+    Clear `k` lines below the cursor, returning the cursor to its original position
+    """
+    print(f"\x1b[2K\x1b[1E" * (k) + f"\x1b[{k}F")
+
+
+def draw_box(
+    ul_corner_pos: Tuple[int, int],
+    height: int,
+    width: int,
+    color: Optional[str] = None,
+):
+    if height <= 0 or width <= 0:
+        return
+    move_cursor(ul_corner_pos)
+    draw_horizontal_line(width, make_corner=True, color=color)
+    draw_vertical_line(height, make_corner=True, color=color)
+    draw_horizontal_line(width, left=True, make_corner=True, color=color)
+    draw_vertical_line(height, up=True, make_corner=True, color=color)
+
+
+def clear_screen():
+    print("\x1b[2J")
+
+
+def remove_cursor():
+    print("\x1b[?25l")
+
+
+def reveal_cursor():
+    print("\x1b[?25h")
+
+
+def move_cursor(pos: Tuple[int, int]):
+    """
+    Move the cursor to a given (x, y) coordinate
+    """
+    x, y = pos
+    if x < 0 or y < 0:
+        return
+    print(f"\x1b[{y};{x}H")
+
+
+def move_cursor_up(n: int):
+    if n <= 0:
+        return
+    print(f"\x1b[{n}A")
+
+
+def line_up(n: int):
+    """Moves to the start of the destination line"""
+    if n <= 0:
+        return
+    print(f"\x1b[{n}F")
+
+
+def move_cursor_down(n: int):
+    if n <= 0:
+        return
+    print(f"\x1b[{n}B")
+
+
+def line_down(n: int):
+    """Moves to the start of the destination line"""
+    if n <= 0:
+        return
+    print(f"\x1b[{n}E")
+
+
+def move_cursor_right(n: int):
+    if n <= 0:
+        return
+    print(f"\x1b[{n}C")
+
+
+def move_cursor_left(n: int):
+    if n <= 0:
+        return
+    print(f"\x1b[{n}D")
+
+
+def current_cursor_position() -> Tuple[int, int]:
+    res = b""
+    sys.stdout.write("\x1b[6n")
+    sys.stdout.flush()
+    while not res.endswith(b"R"):
+        res += sys.stdin.buffer.read(1)
+    y, x = res.strip(b"\x1b[R").split(b";")
+    return int(x), int(y)
+
+
+def draw_vertical_line(
+    height: int,
+    up: bool = False,
+    make_corner: bool = False,
+    color: Optional[str] = None,
+):
+    """
+    Draws a vertical line with given `height`, going upwards if `up` is True
+    and downwards otherwise.
+    """
+
+    if height <= 0:
+        return
+
+    if color is not None:
+        print(color)
+    sep = "\x1b[1A" if up else "\x1b[1B"
+    for i in range(height):
+        if i == 0 and make_corner:
+            corner = "\u2514" if up else "\u2510"
+            print(f"{corner}\x1b[1D{sep}")
+        else:
+            print(f"\u2502\x1b[1D{sep}")
+    if color is not None:
+        print("\x1b[0m")
+
+
+def draw_horizontal_line(
+    width: int,
+    left: bool = False,
+    make_corner: bool = False,
+    color: Optional[str] = None,
+):
+    """
+    Draws a horizontal line with given `width`, going to the left if `left` is True
+    and to the right otherwise.
+    """
+
+    if width <= 0:
+        return
+
+    if color is not None:
+        print(color)
+    sep = "\x1b[2D" if left else ""
+    for i in range(width):
+        if i == 0 and make_corner:
+            corner = "\u2518" if left else "\u250c"
+            print(f"{corner}{sep}")
+        else:
+            print(f"\u2500{sep}")
+    if color is not None:
+        print("\x1b[0m")
+
+
+T = TypeVar("T")
+
+
+class SelectOption(TypedDict, Generic[T]):
+    display_name: str
+    value: T

latch-2.51.2.dev6/latch_cli/menus/vt100.py

@@ -0,0 +1,165 @@
+import os
+import sys
+import termios
+import tty
+from functools import wraps
+from typing import Callable, List, Optional, TypeVar
+
+from typing_extensions import ParamSpec
+
+from latch_cli.click_utils import AnsiCodes
+
+from . import common
+
+P = ParamSpec("P")
+T = TypeVar("T")
+
+
+def raw_input(f: Callable[P, T]) -> Callable[P, T]:
+    @wraps(f)
+    def wrapper(*args: P.args, **kwargs: P.kwargs) -> T:
+        old_settings = termios.tcgetattr(sys.stdin.fileno())
+        tty.setraw(sys.stdin.fileno())
+
+        try:
+            return f(*args, **kwargs)
+        finally:
+            termios.tcsetattr(sys.stdin.fileno(), termios.TCSANOW, old_settings)
+
+    return wrapper
+
+
+def read_next_byte() -> bytes:
+    b = sys.stdin.buffer.read(1)
+    if b in (
+        b"\x03",  # CTRL C
+        b"\x04",  # CTRL D
+        b"q",
+        b"Q",
+    ):
+        raise KeyboardInterrupt
+    return b
+
+
+def read_bytes(num_bytes: int) -> bytes:
+    if num_bytes < 0:
+        raise ValueError(f"cannot read {num_bytes} bytes")
+    result = b""
+    for _ in range(num_bytes):
+        result += read_next_byte()
+    return result
+
+
+@raw_input
+def select_tui(
+    title: str, options: List[common.SelectOption[T]], clear_terminal: bool = True
+) -> Optional[T]:
+    """
+    Renders a terminal UI that allows users to select one of the options
+    listed in `options`
+
+    Args:
+        title: The title of the selection window.
+        options: A list of names for each of the options.
+        clear_terminal: Whether or not to clear the entire terminal window
+            before displaying - default False
+    """
+
+    if len(options) == 0:
+        raise ValueError("No options given")
+
+    def render(
+        curr_selected: int,
+        start_index: int = 0,
+        max_per_page: int = 10,
+        indent: str = "    ",
+    ) -> int:
+        if curr_selected < 0 or curr_selected >= len(options):
+            curr_selected = 0
+
+        print(title)
+        common.line_down(2)
+
+        num_lines_rendered = 4  # 4 "extra" lines for header + footer
+
+        for i in range(start_index, start_index + max_per_page):
+            if i >= len(options):
+                break
+            name = options[i]["display_name"]
+            if i == curr_selected:
+                color = AnsiCodes.color
+                bold = AnsiCodes.bold
+                reset = AnsiCodes.full_reset
+
+                prefix = indent[:-2] + "> "
+
+                print(f"{color}{bold}{prefix}{name}{reset}\x1b[1E")
+            else:
+                print(f"{indent}{name}\x1b[1E")
+            num_lines_rendered += 1
+
+        common.line_down(1)
+
+        control_str = "[ARROW-KEYS] Navigate\t[ENTER] Select\t[Q] Quit"
+        print(control_str)
+        common.line_up(num_lines_rendered - 1)
+
+        common.show()
+
+        return num_lines_rendered
+
+    curr_selected = 0
+    start_index = 0
+    _, term_height = os.get_terminal_size()
+    common.remove_cursor()
+
+    max_per_page = min(len(options), term_height - 4)
+
+    if clear_terminal:
+        common.clear_screen()
+        common.move_cursor((0, 0))
+    else:
+        print("\n" * (max_per_page + 3))
+        common.move_cursor_up(max_per_page + 4)
+
+    num_lines_rendered = render(
+        curr_selected,
+        start_index=start_index,
+        max_per_page=max_per_page,
+    )
+
+    try:
+        while True:
+            b = read_bytes(1)
+            if b == b"\r":
+                return options[curr_selected]["value"]
+            elif b == b"\x1b":
+                b = read_bytes(2)
+                if b == b"[A":  # Up Arrow
+                    curr_selected = max(curr_selected - 1, 0)
+                    if (
+                        curr_selected - start_index < max_per_page // 2
+                        and start_index > 0
+                    ):
+                        start_index -= 1
+                elif b == b"[B":  # Down Arrow
+                    curr_selected = min(curr_selected + 1, len(options) - 1)
+                    if (
+                        curr_selected - start_index > max_per_page // 2
+                        and start_index < len(options) - max_per_page
+                    ):
+                        start_index += 1
+                else:
+                    continue
+            common.clear(num_lines_rendered)
+            num_lines_rendered = render(
+                curr_selected,
+                start_index=start_index,
+                max_per_page=max_per_page,
+            )
+    except KeyboardInterrupt:
+        ...
+    finally:
+        common.clear(num_lines_rendered)
+        common.reveal_cursor()
+        common.show()

latch-2.51.2.dev6/latch_cli/menus/win32.py

@@ -0,0 +1,241 @@
+import msvcrt
+import os
+import sys
+from ctypes import c_ulong, pointer, windll
+from ctypes.wintypes import DWORD, HANDLE
+from dataclasses import dataclass
+from enum import Enum
+from functools import wraps
+from typing import TYPE_CHECKING, Callable, List, Optional, TypeVar
+
+from typing_extensions import ParamSpec
+
+from latch_cli.click_utils import AnsiCodes
+
+from . import common
+from .win32_types import (
+    INPUT_RECORD,
+    KEY_EVENT_RECORD,
+    MOUSE_EVENT_RECORD,
+    STD_INPUT_HANDLE,
+    EventTypes,
+)
+
+# assert sys.platform == "win32"
+
+P = ParamSpec("P")
+T = TypeVar("T")
+
+
+def raw_input(f: Callable[P, T]) -> Callable[P, T]:
+    # ayush: got most of this from
+    # https://github.com/prompt-toolkit/python-prompt-toolkit/blob/669541123c9a72da1fda662cbd0a18ffe9e6d113/src/prompt_toolkit/input/win32.py
+    @wraps(f)
+    def wrapper(*args: P.args, **kwargs: P.kwargs) -> T:
+
+        original_mode = DWORD()
+        handle = HANDLE(windll.kernel32.GetStdHandle(STD_INPUT_HANDLE))
+        windll.kernel32.GetConsoleMode(handle, pointer(original_mode))
+
+        enable_echo_input = 0x0004
+        enable_line_input = 0x0002
+        enable_processed_input = 0x0001
+
+        windll.kernel32.SetConsoleMode(
+            handle,
+            original_mode.value
+            & ~(enable_echo_input | enable_line_input | enable_processed_input),
+        )
+
+        try:
+            return f(*args, **kwargs)
+        finally:
+            windll.kernel32.SetConsoleMode(handle, original_mode)
+
+    return wrapper
+
+
+class Special(Enum):
+    left = "left"
+    right = "right"
+    up = "up"
+    down = "down"
+    enter = "enter"
+    ctrlc = "ctrlc"
+    ctrld = "ctrld"
+
+
+@dataclass
+class KeyInput:
+    special: Optional[Special]
+    value: str
+
+
+# ignoring most things except for arrow keys / enter
+def get_key_input() -> Optional[KeyInput]:
+    # ayush:
+    # https://github.com/prompt-toolkit/python-prompt-toolkit/blob/669541123c9a72da1fda662cbd0a18ffe9e6d113/src/prompt_toolkit/input/win32.py#L127
+    handle: HANDLE
+    if sys.stdin.isatty():
+        handle = HANDLE(windll.kernel32.GetStdHandle(STD_INPUT_HANDLE))
+    else:
+        _fdcon = os.open("CONIN$", os.O_RDWR | os.O_BINARY)
+        handle = HANDLE(msvcrt.get_osfhandle(_fdcon))
+
+    max_count = 2048  # Max events to read at the same time.
+
+    read = DWORD(0)
+    arrtype = INPUT_RECORD * max_count
+    input_records = arrtype()
+
+    windll.kernel32.ReadConsoleInputW(
+        handle, pointer(input_records), max_count, pointer(read)
+    )
+
+    for i in range(read.value):
+        ir = input_records[i]
+
+        if ir.EventType not in EventTypes:
+            continue
+
+        ev = getattr(ir.Event, EventTypes[ir.EventType])
+
+        if not (isinstance(ev, KEY_EVENT_RECORD) and ev.KeyDown):
+            continue
+
+        u_char = ev.uChar.UnicodeChar
+
+        special: Optional[Special] = None
+        if u_char == "\x00":  # special keys, e.g. arrow keys
+            if ev.VirtualKeyCode == 37:
+                special = Special.left
+            elif ev.VirtualKeyCode == 38:
+                special = Special.up
+            elif ev.VirtualKeyCode == 39:
+                special = Special.right
+            elif ev.VirtualKeyCode == 40:
+                special = Special.down
+        elif u_char == "\x0d":
+            special = Special.enter
+        elif u_char == "\x03":
+            special = Special.ctrlc
+        elif u_char == "\x04":
+            special = Special.ctrld
+
+        return KeyInput(special, u_char)
+
+
+@raw_input
+def select_tui(
+    title: str, options: List[common.SelectOption[T]], clear_terminal: bool = True
+) -> Optional[T]:
+    """
+    Renders a terminal UI that allows users to select one of the options
+    listed in `options`
+
+    Args:
+        title: The title of the selection window.
+        options: A list of names for each of the options.
+        clear_terminal: Whether or not to clear the entire terminal window
+            before displaying - default False
+    """
+
+    if len(options) == 0:
+        raise ValueError("No options given")
+
+    def render(
+        curr_selected: int,
+        start_index: int = 0,
+        max_per_page: int = 10,
+        indent: str = "    ",
+    ) -> int:
+        if curr_selected < 0 or curr_selected >= len(options):
+            curr_selected = 0
+
+        print(title)
+        common.line_down(2)
+
+        num_lines_rendered = 4  # 4 "extra" lines for header + footer
+
+        for i in range(start_index, start_index + max_per_page):
+            if i >= len(options):
+                break
+            name = options[i]["display_name"]
+            if i == curr_selected:
+                color = AnsiCodes.color
+                bold = AnsiCodes.bold
+                reset = AnsiCodes.full_reset
+
+                prefix = indent[:-2] + "> "
+
+                print(f"{color}{bold}{prefix}{name}{reset}\x1b[1E")
+            else:
+                print(f"{indent}{name}\x1b[1E")
+            num_lines_rendered += 1
+
+        common.line_down(1)
+
+        control_str = "[ARROW-KEYS] Navigate\t[ENTER] Select\t[Q] Quit"
+        print(control_str)
+        common.line_up(num_lines_rendered - 1)
+
+        common.show()
+
+        return num_lines_rendered
+
+    curr_selected = 0
+    start_index = 0
+    _, term_height = os.get_terminal_size()
+    common.remove_cursor()
+
+    max_per_page = min(len(options), term_height - 4)
+
+    if clear_terminal:
+        common.clear_screen()
+        common.move_cursor((0, 0))
+    else:
+        print("\n" * (max_per_page + 3))
+        common.move_cursor_up(max_per_page + 4)
+
+    num_lines_rendered = render(
+        curr_selected,
+        start_index=start_index,
+        max_per_page=max_per_page,
+    )
+
+    try:
+        while True:
+            k = get_key_input()
+            if k is None:
+                continue
+
+            if k.special == Special.enter:
+                return options[curr_selected]["value"]
+            elif k.special == Special.up:  # Up Arrow
+                curr_selected = max(curr_selected - 1, 0)
+                if curr_selected - start_index < max_per_page // 2 and start_index > 0:
+                    start_index -= 1
+            elif k.special == Special.down:  # Down Arrow
+                curr_selected = min(curr_selected + 1, len(options) - 1)
+                if (
+                    curr_selected - start_index > max_per_page // 2
+                    and start_index < len(options) - max_per_page
+                ):
+                    start_index += 1
+            elif k.special in {Special.ctrlc, Special.ctrld} or k.value in {"q", "Q"}:
+                return
+            else:
+                continue
+
+            common.clear(num_lines_rendered)
+            num_lines_rendered = render(
+                curr_selected,
+                start_index=start_index,
+                max_per_page=max_per_page,
+            )
+    except KeyboardInterrupt:
+        ...
+    finally:
+        common.clear(num_lines_rendered)
+        common.reveal_cursor()
+        common.show()