omlish 0.0.0.dev187__py3-none-any.whl → 0.0.0.dev189__py3-none-any.whl

omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev187'
-__revision__ = 'adae44733a5f69bcd3faa57f0ef2be7b47c9bb4d'
+__version__ = '0.0.0.dev189'
+__revision__ = 'a07761c6eb75b56d0c159dd576f686dec5845963'
 
 
 #

omlish/io/buffers.py

@@ -129,10 +129,15 @@ class DelimitingBuffer:
 
 
 class ReadableListBuffer:
+    # FIXME: merge with PrependableGeneratorReader
+
     def __init__(self) -> None:
         super().__init__()
         self._lst: list[bytes] = []
 
+    def __len__(self) -> int:
+        return sum(map(len, self._lst))
+
     def feed(self, d: bytes) -> None:
         if d:
             self._lst.append(d)
@@ -171,6 +176,12 @@ class ReadableListBuffer:
 
         return None
 
+    def read_exact(self, sz: int) -> bytes:
+        d = self.read(sz)
+        if d is None or len(d) != sz:
+            raise EOFError(f'ReadableListBuffer got {"no" if d is None else len(d)}, expected {sz}')
+        return d
+
     def read_until(self, delim: bytes = b'\n') -> ta.Optional[bytes]:
         if not (lst := self._lst):
             return None

omlish/io/generators/stepped.py

@@ -2,6 +2,7 @@ import typing as ta
 
 from ... import check
 from ... import lang
+from ..buffers import ReadableListBuffer
 from .consts import DEFAULT_BUFFER_SIZE
 from .direct import BytesDirectGenerator
 from .direct import StrDirectGenerator
@@ -149,33 +150,33 @@ def read_into_str_stepped_generator(
 
 @lang.autostart
 def buffer_bytes_stepped_reader_generator(g: BytesSteppedReaderGenerator) -> BytesSteppedGenerator:
+    i: bytes | None
     o = g.send(None)
-    buf: ta.Any = None
+    rlb = ReadableListBuffer()
     eof = False
 
     while True:
         if eof:
             raise EOFError
 
-        if not buf:
-            buf = check.isinstance((yield None), bytes)
-            if not buf:
+        if not len(rlb):
+            if (more := check.isinstance((yield None), bytes)):
+                rlb.feed(more)
+            else:
                 eof = True
 
         if o is None:
-            i = buf
-            buf = None
+            i = check.not_none(rlb.read())
 
         elif isinstance(o, int):
-            while len(buf) < o:
+            while len(rlb) < o:
                 more = check.isinstance((yield None), bytes)
                 if not more:
                     raise EOFError
                 # FIXME: lol - share guts with readers
-                buf += more
+                rlb.feed(more)
 
-            i = buf[:o]
-            buf = buf[o:]
+            i = check.not_none(rlb.read(o))
 
         else:
             raise TypeError(o)

omlish/logs/color.py

@@ -2,15 +2,15 @@
 import logging
 import typing as ta
 
-from .. import term
+from ..term import codes as tc
 from .standard import StandardLogFormatter
 
 
 class ColorLogFormatter(StandardLogFormatter):
-    LEVEL_COLORS: ta.Mapping[int, term.SGRs.FG] = {
-        logging.WARNING: term.SGRs.FG.BRIGHT_YELLOW,
-        logging.ERROR: term.SGRs.FG.BRIGHT_RED,
-        logging.CRITICAL: term.SGRs.FG.BRIGHT_RED,
+    LEVEL_COLORS: ta.Mapping[int, tc.SGRs.FG] = {
+        logging.WARNING: tc.SGRs.FG.BRIGHT_YELLOW,
+        logging.ERROR: tc.SGRs.FG.BRIGHT_RED,
+        logging.CRITICAL: tc.SGRs.FG.BRIGHT_RED,
     }
 
     def formatMessage(self, record):
@@ -20,5 +20,5 @@ class ColorLogFormatter(StandardLogFormatter):
         except KeyError:
             pass
         else:
-            buf = term.SGR(c) + buf + term.SGR(term.SGRs.RESET)
+            buf = tc.SGR(c) + buf + tc.SGR(tc.SGRs.RESET)
         return buf

omlish/subprocesses.py

@@ -1,4 +1,5 @@
 # ruff: noqa: UP006 UP007
+# @omlish-lite
 import abc
 import contextlib
 import logging

omlish/{term.py → term/codes.py}

@@ -1,13 +1,8 @@
 import enum
 import re
-import sys
-import time
 import typing as ta
 
-from . import lang
-
-
-T = ta.TypeVar('T')
+from .. import lang
 
 
 ##
@@ -233,139 +228,6 @@ BG24_RGB = ControlSequence(
 ##
 
 
-class ProgressBar:
-    """
-    TODO:
-     - ProgressBarRenderer
-     - right-justify
-     - ProgressBarGroup
-     - animate
-    """
-
-    def __init__(
-            self,
-            total: int | None = None,
-            *,
-            length: int = 40,
-            interval: float = .2,
-            start_time: float | None = None,
-            out: ta.TextIO | None = None,
-    ) -> None:
-        super().__init__()
-
-        self._total = total
-        self._length = length
-        self._interval = interval
-        if start_time is None:
-            start_time = time.time()
-        self._start_time = start_time
-        if out is None:
-            out = sys.stdout
-        self._out = out
-
-        self._i = 0
-        self._elapsed = 0.
-        self._last_print = 0.
-
-    def render(
-            self,
-            *,
-            complete: bool = False,
-    ) -> str:
-        iter_per_sec = self._i / self._elapsed if self._elapsed > 0 else 0
-
-        if self._total is not None:
-            remaining = (self._total - self._i) / iter_per_sec if iter_per_sec > 0 else 0
-            done = int(self._length * self._i / self._total)
-
-            bar = f'[{"█" * done}{"." * (self._length - done)}]'
-            info_parts = [
-                f'{self._i}/{self._total}',
-                f'{iter_per_sec:.2f} it/s',
-                f'{self._elapsed:.2f}s elapsed',
-                f'{remaining:.2f}s left',
-            ]
-
-        else:
-            bar = f'[{("█" if complete else "?") * self._length}]'
-            info_parts = [
-                f'{self._i}',
-                f'{iter_per_sec:.2f} it/s',
-                f'{self._elapsed:.2f}s elapsed',
-            ]
-
-        info = ' | '.join(info_parts)
-        return f'{bar} {info}'
-
-    def print(
-            self,
-            *,
-            now: float | None = None,
-            **kwargs: ta.Any,
-    ) -> None:
-        if now is None:
-            now = time.time()
-
-        line = self.render(**kwargs)
-        self._out.write(f'\033[2K\033[G{line}')
-        self._out.flush()
-
-        self._last_print = now
-
-    def update(
-            self,
-            n: int = 1,
-            *,
-            now: float | None = None,
-            silent: bool = False,
-    ) -> None:
-        if now is None:
-            now = time.time()
-
-        self._i += n
-        self._elapsed = now - self._start_time
-
-        if not silent:
-            if now - self._last_print >= self._interval:
-                self.print(now=now)
-
-
-def progress_bar(
-        seq: ta.Iterable[T],
-        *,
-        no_tty_check: bool = False,
-        total: int | None = None,
-        out: ta.TextIO | None = None,
-        **kwargs: ta.Any,
-) -> ta.Generator[T, None, None]:
-    if out is None:
-        out = sys.stdout
-
-    if not no_tty_check and not out.isatty():
-        yield from seq
-        return
-
-    if total is None:
-        if isinstance(seq, ta.Sized):
-            total = len(seq)
-
-    pb = ProgressBar(
-        total=total,
-        out=out,
-        **kwargs,
-    )
-
-    for item in seq:
-        pb.update()
-        yield item
-
-    pb.print(complete=True)
-    out.write('\n')
-
-
-##
-
-
 def main() -> None:
     import sys
 

omlish/term/progressbar.py

@@ -0,0 +1,139 @@
+import sys
+import time
+import typing as ta
+
+
+T = ta.TypeVar('T')
+
+
+##
+
+
+class ProgressBar:
+    """
+    TODO:
+     - ProgressBarRenderer
+     - right-justify
+     - ProgressBarGroup
+     - animate
+    """
+
+    def __init__(
+            self,
+            total: int | None = None,
+            *,
+            length: int = 40,
+            interval: float = .2,
+            start_time: float | None = None,
+            out: ta.TextIO | None = None,
+    ) -> None:
+        super().__init__()
+
+        self._total = total
+        self._length = length
+        self._interval = interval
+        if start_time is None:
+            start_time = time.time()
+        self._start_time = start_time
+        if out is None:
+            out = sys.stdout
+        self._out = out
+
+        self._i = 0
+        self._elapsed = 0.
+        self._last_print = 0.
+
+    def render(
+            self,
+            *,
+            complete: bool = False,
+    ) -> str:
+        iter_per_sec = self._i / self._elapsed if self._elapsed > 0 else 0
+
+        if self._total is not None:
+            remaining = (self._total - self._i) / iter_per_sec if iter_per_sec > 0 else 0
+            done = int(self._length * self._i / self._total)
+
+            bar = f'[{"█" * done}{"." * (self._length - done)}]'
+            info_parts = [
+                f'{self._i}/{self._total}',
+                f'{iter_per_sec:.2f} it/s',
+                f'{self._elapsed:.2f}s elapsed',
+                f'{remaining:.2f}s left',
+            ]
+
+        else:
+            bar = f'[{("█" if complete else "?") * self._length}]'
+            info_parts = [
+                f'{self._i}',
+                f'{iter_per_sec:.2f} it/s',
+                f'{self._elapsed:.2f}s elapsed',
+            ]
+
+        info = ' | '.join(info_parts)
+        return f'{bar} {info}'
+
+    def print(
+            self,
+            *,
+            now: float | None = None,
+            **kwargs: ta.Any,
+    ) -> None:
+        if now is None:
+            now = time.time()
+
+        line = self.render(**kwargs)
+        self._out.write(f'\033[2K\033[G{line}')
+        self._out.flush()
+
+        self._last_print = now
+
+    def update(
+            self,
+            n: int = 1,
+            *,
+            now: float | None = None,
+            silent: bool = False,
+    ) -> None:
+        if now is None:
+            now = time.time()
+
+        self._i += n
+        self._elapsed = now - self._start_time
+
+        if not silent:
+            if now - self._last_print >= self._interval:
+                self.print(now=now)
+
+
+def progress_bar(
+        seq: ta.Iterable[T],
+        *,
+        no_tty_check: bool = False,
+        total: int | None = None,
+        out: ta.TextIO | None = None,
+        **kwargs: ta.Any,
+) -> ta.Generator[T, None, None]:
+    if out is None:
+        out = sys.stdout
+
+    if not no_tty_check and not out.isatty():
+        yield from seq
+        return
+
+    if total is None:
+        if isinstance(seq, ta.Sized):
+            total = len(seq)
+
+    pb = ProgressBar(
+        total=total,
+        out=out,
+        **kwargs,
+    )
+
+    for item in seq:
+        pb.update()
+        yield item
+
+    pb.print(complete=True)
+    out.write('\n')

omlish/term/vt100/c.py

@@ -0,0 +1,106 @@
+import io
+
+from ... import check
+from .states import ACTIONS_IN_ORDER
+from .states import STATE_TABLES
+from .states import STATES
+from .states import STATES_IN_ORDER
+from .states import StateTransition
+from .states import check_state_tables
+
+
+def _pad(s: str, length: int) -> str:
+    return s + ' ' * (length - len(s))
+
+
+def _generate_c() -> dict[str, str]:
+    out = {}
+
+    #
+
+    f = io.StringIO()
+
+    f.write('typedef enum {\n')
+    for i, state in enumerate(STATES_IN_ORDER):
+        f.write(f'   VTPARSE_STATE_{state.upper()} = {i + 1},\n')
+    f.write('} vtparse_state_t;\n\n')
+
+    f.write('typedef enum {\n')
+    for i, action_str in enumerate(ACTIONS_IN_ORDER):
+        f.write(f'   VTPARSE_ACTION_{action_str.upper()} = {i + 1},\n')
+    f.write('} vtparse_action_t;\n\n')
+
+    f.write('typedef unsigned char state_change_t;\n')
+    f.write(f'extern state_change_t STATE_TABLE[{len(STATES_IN_ORDER)}][256];\n')
+    f.write(f'extern vtparse_action_t ENTRY_ACTIONS[{len(STATES_IN_ORDER)}];\n')
+    f.write(f'extern vtparse_action_t EXIT_ACTIONS[{len(STATES_IN_ORDER)}];\n')
+    f.write(f'extern char *ACTION_NAMES[{len(ACTIONS_IN_ORDER) + 1}];\n')
+    f.write(f'extern char *STATE_NAMES[{len(STATES_IN_ORDER) + 1}];\n\n')
+
+    out['vtparse_table.h'] = f.getvalue()
+
+    #
+
+    f = io.StringIO()
+
+    f.write('#include "vtparse_table.h"\n\n')
+
+    f.write('char *ACTION_NAMES[] = {\n')
+    f.write('   "<no action>",\n')
+    for action_str in ACTIONS_IN_ORDER:
+        f.write(f'   "{action_str.upper()}",\n')
+    f.write('};\n\n')
+
+    f.write('char *STATE_NAMES[] = {\n')
+    f.write('   "<no state>",\n')
+    for state in STATES_IN_ORDER:
+        f.write(f'   "{state}",\n')
+    f.write('};\n\n')
+
+    f.write(f'state_change_t STATE_TABLE[{len(STATES_IN_ORDER)}][256] = {{\n')
+    for i, state in enumerate(STATES_IN_ORDER):
+        f.write(f'  {{  /* VTPARSE_STATE_{state.upper()} = {i} */\n')
+        for j, state_change in enumerate(STATE_TABLES[state]):
+            if not state_change:
+                f.write('    0,\n')
+            else:
+                action = next((s for s in state_change if isinstance(s, str)), None)
+                state_trans = next((s for s in state_change if isinstance(s, StateTransition)), None)
+                action_str = f'VTPARSE_ACTION_{action.upper()}' if action else '0'
+                state_str = f'VTPARSE_STATE_{state_trans.to_state}' if state_trans else '0'
+                f.write(
+                    f'/*{str(j).rjust(3)}*/  {_pad(action_str, 33)} | ({_pad(state_str, 33)} << 4),\n')
+        f.write('  },\n')
+    f.write('};\n\n')
+
+    f.write('vtparse_action_t ENTRY_ACTIONS[] = {\n')
+    for state in STATES_IN_ORDER:
+        actions = STATES[state]
+        if 'on_entry' in actions:
+            f.write(f"   VTPARSE_ACTION_{check.isinstance(actions['on_entry'], str).upper()}, /* {state} */\n")
+        else:
+            f.write(f'   0  /* none for {state} */,\n')
+    f.write('};\n\n')
+
+    f.write('vtparse_action_t EXIT_ACTIONS[] = {\n')
+    for state in STATES_IN_ORDER:
+        actions = STATES[state]
+        if 'on_exit' in actions:
+            f.write(f"   VTPARSE_ACTION_{check.isinstance(actions['on_exit'], str).upper()}, /* {state} */\n")
+        else:
+            f.write(f'   0  /* none for {state} */,\n')
+    f.write('};\n\n')
+
+    out['vtparse_table.c'] = f.getvalue()
+
+    #
+
+    return out
+
+
+if __name__ == '__main__':
+    check_state_tables(STATE_TABLES)
+    for f, c in _generate_c().items():
+        print(f)
+        print(c)
+        print()

omlish/term/vt100/states.py

@@ -0,0 +1,271 @@
+"""
+Original author: Joshua Haberman
+https://github.com/haberman/vtparse/blob/198ea4382f824dbb3f0e5b5553a9eb3290764694/vtparse_tables.rb
+
+==
+
+https://vt100.net/emu/dec_ansi_parser
+https://github.com/haberman/vtparse
+"""
+import typing as ta
+
+
+##
+
+
+class StateTransition(ta.NamedTuple):
+    to_state: str
+
+
+TransitionMap: ta.TypeAlias = ta.Mapping[
+    int | range | str,
+    str | StateTransition | tuple[str | StateTransition, ...],
+]
+
+
+##
+
+
+# Define the anywhere transitions
+ANYWHERE_TRANSITIONS: TransitionMap = {
+    0x18: ('execute', StateTransition('ground')),
+    0x1a: ('execute', StateTransition('ground')),
+    range(0x80, 0x90): ('execute', StateTransition('ground')),
+    range(0x91, 0x98): ('execute', StateTransition('ground')),
+    0x99: ('execute', StateTransition('ground')),
+    0x9a: ('execute', StateTransition('ground')),
+    0x9c: StateTransition('ground'),
+    0x1b: StateTransition('escape'),
+    0x98: StateTransition('sos_pm_apc_string'),
+    0x9e: StateTransition('sos_pm_apc_string'),
+    0x9f: StateTransition('sos_pm_apc_string'),
+    0x90: StateTransition('dcs_entry'),
+    0x9d: StateTransition('osc_string'),
+    0x9b: StateTransition('csi_entry'),
+}
+
+
+# Global states dictionary
+STATES: ta.Mapping[str, TransitionMap] = {
+    # Define state transitions
+    'ground': {
+        range(0x18): 'execute',
+        0x19: 'execute',
+        range(0x1c, 0x20): 'execute',
+        range(0x20, 0x80): 'print',
+    },
+
+    'escape': {
+        'on_entry': 'clear',
+        range(0x18): 'execute',
+        0x19: 'execute',
+        range(0x1c, 0x20): 'execute',
+        0x7f: 'ignore',
+        range(0x20, 0x30): ('collect', StateTransition('escape_intermediate')),
+        range(0x30, 0x50): ('esc_dispatch', StateTransition('ground')),
+        range(0x51, 0x58): ('esc_dispatch', StateTransition('ground')),
+        0x59: ('esc_dispatch', StateTransition('ground')),
+        0x5a: ('esc_dispatch', StateTransition('ground')),
+        0x5c: ('esc_dispatch', StateTransition('ground')),
+        range(0x60, 0x7f): ('esc_dispatch', StateTransition('ground')),
+        0x5b: StateTransition('csi_entry'),
+        0x5d: StateTransition('osc_string'),
+        0x50: StateTransition('dcs_entry'),
+        0x58: StateTransition('sos_pm_apc_string'),
+        0x5e: StateTransition('sos_pm_apc_string'),
+        0x5f: StateTransition('sos_pm_apc_string'),
+    },
+
+    'escape_intermediate': {
+        range(0x18): 'execute',
+        0x19: 'execute',
+        range(0x1c, 0x20): 'execute',
+        range(0x20, 0x30): 'collect',
+        0x7f: 'ignore',
+        range(0x30, 0x7f): ('esc_dispatch', StateTransition('ground')),
+    },
+
+    'csi_entry': {
+        'on_entry': 'clear',
+        range(0x18): 'execute',
+        0x19: 'execute',
+        range(0x1c, 0x20): 'execute',
+        0x7f: 'ignore',
+        range(0x20, 0x30): ('collect', StateTransition('csi_intermediate')),
+        0x3a: StateTransition('csi_ignore'),
+        range(0x30, 0x3a): ('param', StateTransition('csi_param')),
+        0x3b: ('param', StateTransition('csi_param')),
+        range(0x3c, 0x40): ('collect', StateTransition('csi_param')),
+        range(0x40, 0x7f): ('csi_dispatch', StateTransition('ground')),
+    },
+
+    'csi_ignore': {
+        range(0x18): 'execute',
+        0x19: 'execute',
+        range(0x1c, 0x20): 'execute',
+        range(0x20, 0x40): 'ignore',
+        0x7f: 'ignore',
+        range(0x40, 0x7f): StateTransition('ground'),
+    },
+
+    'csi_param': {
+        range(0x18): 'execute',
+        0x19: 'execute',
+        range(0x1c, 0x20): 'execute',
+        range(0x30, 0x3a): 'param',
+        0x3b: 'param',
+        0x7f: 'ignore',
+        0x3a: StateTransition('csi_ignore'),
+        range(0x3c, 0x40): StateTransition('csi_ignore'),
+        range(0x20, 0x30): ('collect', StateTransition('csi_intermediate')),
+        range(0x40, 0x7f): ('csi_dispatch', StateTransition('ground')),
+    },
+
+    'csi_intermediate': {
+        range(0x18): 'execute',
+        0x19: 'execute',
+        range(0x1c, 0x20): 'execute',
+        range(0x20, 0x30): 'collect',
+        0x7f: 'ignore',
+        range(0x30, 0x40): StateTransition('csi_ignore'),
+        range(0x40, 0x7f): ('csi_dispatch', StateTransition('ground')),
+    },
+
+    'dcs_entry': {
+        'on_entry': 'clear',
+        range(0x18): 'ignore',
+        0x19: 'ignore',
+        range(0x1c, 0x20): 'ignore',
+        0x7f: 'ignore',
+        0x3a: StateTransition('dcs_ignore'),
+        range(0x20, 0x30): ('collect', StateTransition('dcs_intermediate')),
+        range(0x30, 0x3a): ('param', StateTransition('dcs_param')),
+        0x3b: ('param', StateTransition('dcs_param')),
+        range(0x3c, 0x40): ('collect', StateTransition('dcs_param')),
+        range(0x40, 0x7f): (StateTransition('dcs_passthrough')),
+    },
+
+    'dcs_intermediate': {
+        range(0x18): 'ignore',
+        0x19: 'ignore',
+        range(0x1c, 0x20): 'ignore',
+        range(0x20, 0x30): 'collect',
+        0x7f: 'ignore',
+        range(0x30, 0x40): StateTransition('dcs_ignore'),
+        range(0x40, 0x7f): StateTransition('dcs_passthrough'),
+    },
+
+    'dcs_ignore': {
+        range(0x18): 'ignore',
+        0x19: 'ignore',
+        range(0x1c, 0x80): 'ignore',
+    },
+
+    'dcs_param': {
+        range(0x18): 'ignore',
+        0x19: 'ignore',
+        range(0x1c, 0x20): 'ignore',
+        range(0x30, 0x3a): 'param',
+        0x3b: 'param',
+        0x7f: 'ignore',
+        0x3a: StateTransition('dcs_ignore'),
+        range(0x3c, 0x40): StateTransition('dcs_ignore'),
+        range(0x20, 0x30): ('collect', StateTransition('dcs_intermediate')),
+        range(0x40, 0x7f): StateTransition('dcs_passthrough'),
+    },
+
+    'dcs_passthrough': {
+        'on_entry': 'hook',
+        range(0x18): 'put',
+        0x19: 'put',
+        range(0x1c, 0x20): 'put',
+        range(0x20, 0x7f): 'put',
+        0x7f: 'ignore',
+        'on_exit': 'unhook',
+    },
+
+    'sos_pm_apc_string': {
+        range(0x18): 'ignore',
+        0x19: 'ignore',
+        range(0x1c, 0x80): 'ignore',
+    },
+
+    'osc_string': {
+        'on_entry': 'osc_start',
+        range(0x18): 'ignore',
+        0x19: 'ignore',
+        range(0x1c, 0x20): 'ignore',
+        range(0x20, 0x80): 'osc_put',
+        'on_exit': 'osc_end',
+    },
+}
+
+
+##
+
+
+ACTIONS_IN_ORDER = sorted(
+    action
+    for state, transitions in STATES.items()
+    for keys, actions in transitions.items()
+    for action in ([actions] if not isinstance(actions, tuple) else actions)
+    if isinstance(action, str)
+)
+
+STATES_IN_ORDER = sorted(STATES)
+
+
+##
+
+
+TransitionTable: ta.TypeAlias = tuple[tuple[str | StateTransition, ...], ...]
+
+
+def _build_state_tables() -> ta.Mapping[str, TransitionTable]:
+    # Expand the range-based data structures into fully expanded tables
+    state_tables: dict[str, list] = {}
+
+    def expand_ranges(dct):
+        array = [None] * 256
+        for k, v in dct.items():
+            if isinstance(k, range):
+                for i in k:
+                    array[i] = v
+            elif isinstance(k, int):
+                array[k] = v
+        return array
+
+    for s, t in STATES.items():
+        state_tables[s] = expand_ranges(t)
+
+    # Seed all the states with the anywhere transitions
+    anywhere_transitions_expanded = expand_ranges(ANYWHERE_TRANSITIONS)
+
+    for state, transitions in state_tables.items():
+        for i, transition in enumerate(anywhere_transitions_expanded):
+            if transition is not None:
+                if transitions[i] is not None:
+                    raise ValueError(
+                        f'State {state} already had a transition defined for 0x{i:02x}, but that transition is also an '
+                        f'anywhere transition!',
+                    )
+                transitions[i] = transition
+
+    # For consistency, make all transitions tuples of actions
+    return {
+        state: tuple(tuple(t if isinstance(t, (list, tuple)) else [t]) for t in transitions)
+        for state, transitions in state_tables.items()
+    }
+
+
+STATE_TABLES = _build_state_tables()
+
+
+##
+
+
+def check_state_tables(state_tables: ta.Mapping[str, TransitionTable]) -> None:
+    for state, transitions in state_tables.items():
+        for i, val in enumerate(transitions):
+            if not val:
+                raise ValueError(f'No transition defined from state {state}, char 0x{i:02x}!')

omlish/term/vt100/terminal.py

@@ -0,0 +1,271 @@
+import dataclasses as dc
+import string
+import typing as ta
+
+from omlish.lite.check import check
+
+
+T = ta.TypeVar('T')
+
+
+##
+
+
+@dc.dataclass()
+class Cell:
+    """Represents a single character cell in the terminal with attributes."""
+
+    char: str = ' '
+
+    fg: str = 'default'
+    bg: str = 'default'
+
+    bold: bool = False
+    underline: bool = False
+    reverse: bool = False
+
+    def __repr__(self):
+        return f'Cell({self.char!r}, bold={self.bold}, underline={self.underline})'
+
+
+class Vt100Terminal:
+    def __init__(
+            self,
+            rows: int = 24,
+            cols: int = 80,
+    ) -> None:
+        super().__init__()
+
+        self._rows = rows
+        self._cols = cols
+
+        # 2D array of Cell objects
+        self._screen = [
+            [Cell() for _ in range(cols)]
+            for _ in range(rows)
+        ]
+
+        # Current cursor position (row, col), 0-based internally
+        self._cursor_row = 0
+        self._cursor_col = 0
+
+        # Current text attributes
+        self._current_fg = 'default'
+        self._current_bg = 'default'
+        self._current_bold = False
+        self._current_underline = False
+        self._current_reverse = False
+
+        # Parser state
+        self._state: ta.Literal['normal', 'esc', 'csi'] = 'normal'
+        self._escape_buffer: list[str] = []
+
+    def parse_byte(self, byte: int | str) -> None:
+        """Parse a single byte of input (as an integer or a single-character string)."""
+
+        if isinstance(byte, int):
+            byte = chr(byte)
+
+        if self._state == 'normal':
+            if byte == '\x1b':
+                # Start of escape sequence
+                self._state = 'esc'
+                self._escape_buffer = [byte]
+            elif byte == '\r':
+                # Carriage return
+                self._cursor_col = 0
+            elif byte == '\n':
+                # Line feed
+                self._cursor_row = min(self._cursor_row + 1, self._rows - 1)
+            elif byte == '\b':
+                # Backspace
+                self._cursor_col = max(self._cursor_col - 1, 0)
+            elif byte in string.printable and byte not in ['\x0b', '\x0c']:
+                # Printable ASCII (excluding form feeds, vertical tabs, etc.)
+                self._put_char(byte)
+            else:
+                # Ignore other control characters
+                pass
+
+        elif self._state == 'esc':
+            self._escape_buffer.append(byte)
+            if byte == '[':
+                # Move to CSI state (Control Sequence Introducer)
+                self._state = 'csi'
+            # Some escape codes like ESCc, ESC7, etc. are possible but we'll ignore or handle them in a minimal way. If
+            # no further instructions, revert to normal
+            elif len(self._escape_buffer) == 2:
+                # We only support ESC + [ in this example, so revert
+                self._state = 'normal'
+
+        elif self._state == 'csi':
+            self._escape_buffer.append(byte)
+            # Check if this byte ends the sequence (typical final bytes are A-Z, @, etc.)
+            if byte.isalpha() or byte in '@`~':
+                # We have a complete CSI sequence: parse it
+                self._parse_csi(''.join(self._escape_buffer))
+                # Reset state
+                self._state = 'normal'
+                self._escape_buffer = []
+
+    def _put_char(self, ch: str) -> None:
+        """Write a character at the current cursor position, and advance the cursor."""
+
+        if 0 <= self._cursor_row < self._rows and 0 <= self._cursor_col < self._cols:
+            cell = self._screen[self._cursor_row][self._cursor_col]
+            cell.char = ch
+            cell.fg = self._current_fg
+            cell.bg = self._current_bg
+            cell.bold = self._current_bold
+            cell.underline = self._current_underline
+            cell.reverse = self._current_reverse
+
+        self._cursor_col += 1
+        if self._cursor_col >= self._cols:
+            self._cursor_col = 0
+            self._cursor_row = min(self._cursor_row + 1, self._rows - 1)
+
+    def _parse_csi(self, seq: str) -> None:
+        """
+        Parse a CSI (Control Sequence Introducer) escape sequence. Typically looks like: ESC [ parameters letter For
+        example: ESC [ 2 J, ESC [ 10 ; 20 H, etc.
+        """
+
+        # seq includes the initial ESC[. e.g. "\x1b[10;20H"
+        # We'll strip ESC[ and parse what remains.
+        check.state(seq.startswith('\x1b['))
+        body = seq[2:]  # everything after ESC[
+
+        # Find final character that determines the command (e.g. 'A', 'B', 'H', 'J', 'K', 'm', etc.)
+        final = body[-1]
+        params = body[:-1]
+
+        # Split params by semicolons, handle empty as '0'
+        if params.strip() == '':
+            numbers = [0]
+        else:
+            numbers = [int(x) if x.isdigit() else 0 for x in params.split(';')]
+
+        if final in 'ABCD':
+            # Cursor movement
+            n = numbers[0] if numbers else 1
+            if final == 'A':
+                # Up
+                self._cursor_row = max(self._cursor_row - n, 0)
+            elif final == 'B':
+                # Down
+                self._cursor_row = min(self._cursor_row + n, self._rows - 1)
+            elif final == 'C':
+                # Right
+                self._cursor_col = min(self._cursor_col + n, self._cols - 1)
+            elif final == 'D':
+                # Left
+                self._cursor_col = max(self._cursor_col - n, 0)
+
+        elif final in 'Hf':
+            # Cursor position
+            # CSI row;colH or CSI row;colf (1-based coords)
+            row = numbers[0] if len(numbers) > 0 else 1
+            col = numbers[1] if len(numbers) > 1 else 1
+            self._cursor_row = min(max(row - 1, 0), self._rows - 1)
+            self._cursor_col = min(max(col - 1, 0), self._cols - 1)
+
+        elif final == 'J':
+            # Erase display
+            # n=0 -> clear from cursor down,
+            # n=1 -> clear from cursor up,
+            # n=2 -> clear entire screen
+            n = numbers[0] if numbers else 0
+            if n == 2:
+                self._clear_screen()
+            elif n == 0:
+                self._clear_down()
+            elif n == 1:
+                self._clear_up()
+            # else: unsupported J mode, ignore
+
+        elif final == 'K':
+            # Erase line
+            # n=0 -> clear from cursor right
+            # n=1 -> clear from cursor left
+            # n=2 -> clear entire line
+            n = numbers[0] if numbers else 0
+            if n == 2:
+                self._clear_line(self._cursor_row)
+            elif n == 0:
+                self._clear_right(self._cursor_row, self._cursor_col)
+            elif n == 1:
+                self._clear_left(self._cursor_row, self._cursor_col)
+            # else: ignore
+
+        elif final == 'm':
+            # SGR - Select Graphic Rendition
+            # We handle a subset: 0 (reset), 1 (bold), 4 (underline), 7 (reverse)
+            # Colors could be extended, but here we keep it minimal
+            for code in numbers:
+                if code == 0:
+                    self._current_fg = 'default'
+                    self._current_bg = 'default'
+                    self._current_bold = False
+                    self._current_underline = False
+                    self._current_reverse = False
+                elif code == 1:
+                    self._current_bold = True
+                elif code == 4:
+                    self._current_underline = True
+                elif code == 7:
+                    self._current_reverse = True
+                # You can add more codes for color, etc.
+                else:
+                    # Unsupported SGR code - ignore gracefully
+                    pass
+
+        else:
+            # Unsupported final - ignore gracefully
+            pass
+
+    # hods for Erase Operations
+
+    def _clear_screen(self) -> None:
+        for r in range(self._rows):
+            for c in range(self._cols):
+                self._screen[r][c] = Cell()
+
+    def _clear_down(self) -> None:
+        """Clear from cursor to the end of the screen."""
+
+        # Clear current line from cursor forward
+        self._clear_right(self._cursor_row, self._cursor_col)
+
+        # Clear all lines below cursor
+        for r in range(self._cursor_row + 1, self._rows):
+            self._clear_line(r)
+
+    def _clear_up(self) -> None:
+        """Clear from the start of the screen up to the cursor."""
+
+        # Clear current line from start to cursor
+        self._clear_left(self._cursor_row, self._cursor_col)
+
+        # Clear all lines above cursor
+        for r in range(self._cursor_row):
+            self._clear_line(r)
+
+    def _clear_line(self, row: int) -> None:
+        for c in range(self._cols):
+            self._screen[row][c] = Cell()
+
+    def _clear_right(self, row: int, col: int) -> None:
+        for c in range(col, self._cols):
+            self._screen[row][c] = Cell()
+
+    def _clear_left(self, row: int, col: int) -> None:
+        for c in range(col + 1):
+            self._screen[row][c] = Cell()
+
+    # Debug/Utility Methods
+
+    def get_screen_as_strings(self) -> list[str]:
+        """Return a list of strings representing each row (ignoring attributes). Useful for debugging/testing."""
+
+        return [''.join(cell.char for cell in row) for row in self._screen]

{omlish-0.0.0.dev187.dist-info → omlish-0.0.0.dev189.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: omlish
-Version: 0.0.0.dev187
+Version: 0.0.0.dev189
 Summary: omlish
 Author: wrmsr
 License: BSD-3-Clause

{omlish-0.0.0.dev187.dist-info → omlish-0.0.0.dev189.dist-info}/RECORD

@@ -1,5 +1,5 @@
 omlish/.manifests.json,sha256=lRkBDFxlAbf6lN5upo3WSf-owW8YG1T21dfpbQL-XHM,7598
-omlish/__about__.py,sha256=uczpyoSCBa1D3dhUVJ18pnATINJxHB2nOI42fI9vOVg,3409
+omlish/__about__.py,sha256=Gs9hXW7PiNiRdGtxDHSxJf4Q0yutVUp9BalCHX8po30,3409
 omlish/__init__.py,sha256=SsyiITTuK0v74XpKV8dqNaCmjOlan1JZKrHQv5rWKPA,253
 omlish/c3.py,sha256=ubu7lHwss5V4UznbejAI0qXhXahrU01MysuHOZI9C4U,8116
 omlish/cached.py,sha256=UI-XTFBwA6YXWJJJeBn-WkwBkfzDjLBBaZf4nIJA9y0,510
@@ -11,9 +11,8 @@ omlish/libc.py,sha256=8r7Ejyhttk9ruCfBkxNTrlzir5WPbDE2vmY7VPlceMA,15362
 omlish/multiprocessing.py,sha256=QZT4C7I-uThCAjaEY3xgUYb-5GagUlnE4etN01LDyU4,5186
 omlish/runmodule.py,sha256=PWvuAaJ9wQQn6bx9ftEL3_d04DyotNn8dR_twm2pgw0,700
 omlish/shlex.py,sha256=bsW2XUD8GiMTUTDefJejZ5AyqT1pTgWMPD0BMoF02jE,248
-omlish/subprocesses.py,sha256=n6pk0nUaTFHzD_A6duyKNJ4ggncU7uNepfh_T90etHE,8671
+omlish/subprocesses.py,sha256=KOvt5gvpq2uisjYKyU_XUPZyM6yq8ywgbfWjz-lx9CQ,8686
 omlish/sync.py,sha256=QJ79kxmIqDP9SeHDoZAf--DpFIhDQe1jACy8H4N0yZI,2928
-omlish/term.py,sha256=EVHm3lEEIc9hT4f8BPmzbNUwlqZ8nrRpCwyQMN7LBm0,9313
 omlish/antlr/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omlish/antlr/delimit.py,sha256=3Byvh9_Ip8ftM_SeSEmMbnNo1jrxk-xm8HnHDp_nDaI,3466
 omlish/antlr/dot.py,sha256=uH2X7-8xNLYDQNJ30uW8ssv1MLkZSm07GsalcRuunYI,817
@@ -311,7 +310,7 @@ omlish/inject/impl/proxy.py,sha256=1ko0VaKqzu9UG8bIldp9xtUrAVUOFTKWKTjOCqIGr4s,1
 omlish/inject/impl/scopes.py,sha256=hKnzNieB-fJSFEXDP_QG1mCfIKoVFIfFlf9LiIt5tk4,5920
 omlish/io/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omlish/io/abc.py,sha256=Cxs8KB1B_69rxpUYxI-MTsilAmNooJJn3w07DKqYKkE,1255
-omlish/io/buffers.py,sha256=6wsFKHwL41IW-F0Zu-H7_ovQqvW7q0CwtQFu2wdhlEE,5286
+omlish/io/buffers.py,sha256=qo1hCqTfKvlbSmddneporqCtW0rZJ_Mv2GrQTI1Hbk0,5636
 omlish/io/pyio.py,sha256=q4RBFVpBE5PYjnGPGT-_4pcZb7dFJmLJ4LtI8OoDRQY,95433
 omlish/io/trampoline.py,sha256=oUKTQg1F5xQS1431Kt7MbK-NZpX509ubcXU-s86xJr8,7171
 omlish/io/compress/__init__.py,sha256=qV-aDfPWykTMYcoQmE8THZ4KFDRzqwN3QPPNEJVarXY,86
@@ -336,7 +335,7 @@ omlish/io/generators/__init__.py,sha256=YsSLJY9uw72eX3iXd_A0pM69g7EvEqMFdCdR_BBD
 omlish/io/generators/consts.py,sha256=4r6IMLBMic6MJHVn9UiORIkkPAuxsqtzFT3KV0fatC0,33
 omlish/io/generators/direct.py,sha256=A9VJB1rNKU3l-NatpYIwyCLI3R_ybGglmdx6sAtoTo4,324
 omlish/io/generators/readers.py,sha256=MolTFCzcnD5XoP0su0YUNHJ0xlHC3KTihvWAi75y8Bo,4336
-omlish/io/generators/stepped.py,sha256=sl-3-hNVYi7qGYZjwBPHs0hKxmz7XkfDMosCXbhIYlE,5025
+omlish/io/generators/stepped.py,sha256=WZnLpCzv5pA6jLdb1lplXoKRPbREw9wO586Dew5EzV4,5129
 omlish/iterators/__init__.py,sha256=yMavf5FofiS1EU4UFuWPXiFZ03W0H-y7MuMxW8FUaEE,358
 omlish/iterators/iterators.py,sha256=ghI4dO6WPyyFOLTIIMaHQ_IOy2xXaFpGPqveZ5YGIBU,3158
 omlish/iterators/recipes.py,sha256=53mkexitMhkwXQZbL6DrhpT0WePQ_56uXd5Jaw3DfzI,467
@@ -395,7 +394,7 @@ omlish/lite/typing.py,sha256=U3-JaEnkDSYxK4tsu_MzUn3RP6qALBe5FXQXpD-licE,1090
 omlish/logs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omlish/logs/abc.py,sha256=ho4ABKYMKX-V7g4sp1BByuOLzslYzLlQ0MESmjEpT-o,8005
 omlish/logs/all.py,sha256=4Z6cNB0E1xbX0IOQWZEWLA0Jw-yyjhXa3PD_Nvfewu8,556
-omlish/logs/color.py,sha256=02feYPZm4A7qHeBABpiar2J2E6tf-vtw1pOQAsJs_1c,668
+omlish/logs/color.py,sha256=CM-ceoPXs0j5_klnZDJkFCFRgHOToFzJyLjC6LsnPEk,665
 omlish/logs/configs.py,sha256=XOc8rWxfPpPMxJESVD2mLCUoLtbQnGnZwvYhhqe7DD8,772
 omlish/logs/filters.py,sha256=2noFRyBez3y519fpfsDSt1vo8wX-85b8sMXZi5o_xyE,208
 omlish/logs/handlers.py,sha256=zgSnKQA5q9Fu7T0Nkd7twog9H1Wg9-bDCzz4_F1TOBo,319
@@ -545,6 +544,13 @@ omlish/sql/tabledefs/elements.py,sha256=lP_Ch19hKmiGYPQVeC8HpFaKdTYnXi2FfpfwKMxZ
 omlish/sql/tabledefs/lower.py,sha256=YQf8gl1kxD5Fm-vOxV6G0Feh_D9PP1pYwz_vz6XjTPQ,1405
 omlish/sql/tabledefs/marshal.py,sha256=j-Rz1HsiXmABv39-2VoJdzSSB3kbxqaVevbdkZWMyG8,504
 omlish/sql/tabledefs/tabledefs.py,sha256=lIhvlt0pk6G7RZAtDFsFXm5j0l9BvRfnP7vNGeydHtE,816
+omlish/term/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+omlish/term/codes.py,sha256=gqouA7KDyGzyCmmu8ejGhT_8XJGsejdTQh2pSCMbWAQ,6150
+omlish/term/progressbar.py,sha256=TiwdmPSMa5jQj35i1NQURTWQGy4eWUNx_XiPM38JtvQ,3184
+omlish/term/vt100/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+omlish/term/vt100/c.py,sha256=cAhDKXI81PZRtFmTotfad3HZGREP1QnOlWYoAw6v-Fw,3532
+omlish/term/vt100/states.py,sha256=OxPUxfFTcfz56MhtDgIigEApChOtN6XO1g6R2H08mu4,8303
+omlish/term/vt100/terminal.py,sha256=sYLddUSrubCJPnI6f2t5Pzp0tFGLLBKyYdDfKmkwREM,9363
 omlish/testing/__init__.py,sha256=M_BQrcCHkoL-ZvE-UpQ8XxXNYRRawhjUz4rCJnAqM2A,152
 omlish/testing/testing.py,sha256=TT2wwSzPZ_KhIvKxpM1qc1yHKD-LHDNgGrcr_h8vs7c,2895
 omlish/testing/pytest/__init__.py,sha256=B2nyJrjIoNcEopbg0IZ5UUDs4OHmQ8qqElFJfGcDdas,257
@@ -573,9 +579,9 @@ omlish/text/indent.py,sha256=6Jj6TFY9unaPa4xPzrnZemJ-fHsV53IamP93XGjSUHs,1274
 omlish/text/minja.py,sha256=KAmZ2POcLcxwF4DPKxdWa16uWxXmVz1UnJXLSwt4oZo,5761
 omlish/text/parts.py,sha256=7vPF1aTZdvLVYJ4EwBZVzRSy8XB3YqPd7JwEnNGGAOo,6495
 omlish/text/random.py,sha256=jNWpqiaKjKyTdMXC-pWAsSC10AAP-cmRRPVhm59ZWLk,194
-omlish-0.0.0.dev187.dist-info/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
-omlish-0.0.0.dev187.dist-info/METADATA,sha256=ji6ytWK7_WKR3YDtI_fBXFAcEjfQ3huw6GPdX8h4wHs,4264
-omlish-0.0.0.dev187.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-omlish-0.0.0.dev187.dist-info/entry_points.txt,sha256=Lt84WvRZJskWCAS7xnQGZIeVWksprtUHj0llrvVmod8,35
-omlish-0.0.0.dev187.dist-info/top_level.txt,sha256=pePsKdLu7DvtUiecdYXJ78iO80uDNmBlqe-8hOzOmfs,7
-omlish-0.0.0.dev187.dist-info/RECORD,,
+omlish-0.0.0.dev189.dist-info/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
+omlish-0.0.0.dev189.dist-info/METADATA,sha256=JRj7SgIl1vGF733weElFasb6_IEBNT8cTHUdlW4Aq98,4264
+omlish-0.0.0.dev189.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+omlish-0.0.0.dev189.dist-info/entry_points.txt,sha256=Lt84WvRZJskWCAS7xnQGZIeVWksprtUHj0llrvVmod8,35
+omlish-0.0.0.dev189.dist-info/top_level.txt,sha256=pePsKdLu7DvtUiecdYXJ78iO80uDNmBlqe-8hOzOmfs,7
+omlish-0.0.0.dev189.dist-info/RECORD,,