omlish 0.0.0.dev188__tar.gz → 0.0.0.dev189__tar.gz

{omlish-0.0.0.dev188/omlish.egg-info → omlish-0.0.0.dev189}/PKG-INFO

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

{omlish-0.0.0.dev188 → omlish-0.0.0.dev189}/omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev188'
-__revision__ = '5fdaec4377bb26043e0d2e86d311ce717e41ca0f'
+__version__ = '0.0.0.dev189'
+__revision__ = 'a07761c6eb75b56d0c159dd576f686dec5845963'
 
 
 #

{omlish-0.0.0.dev188 → omlish-0.0.0.dev189}/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-0.0.0.dev188 → omlish-0.0.0.dev189}/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-0.0.0.dev188 → omlish-0.0.0.dev189}/omlish/subprocesses.py

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

omlish-0.0.0.dev189/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-0.0.0.dev189/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-0.0.0.dev188 → omlish-0.0.0.dev189/omlish.egg-info}/PKG-INFO

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

{omlish-0.0.0.dev188 → omlish-0.0.0.dev189}/omlish.egg-info/SOURCES.txt

@@ -557,7 +557,10 @@ omlish/sql/tabledefs/tabledefs.py
 omlish/term/__init__.py
 omlish/term/codes.py
 omlish/term/progressbar.py
-omlish/term/vt100.py
+omlish/term/vt100/__init__.py
+omlish/term/vt100/c.py
+omlish/term/vt100/states.py
+omlish/term/vt100/terminal.py
 omlish/testing/__init__.py
 omlish/testing/testing.py
 omlish/testing/pytest/__init__.py

{omlish-0.0.0.dev188 → omlish-0.0.0.dev189}/pyproject.toml

@@ -12,7 +12,7 @@ authors = [
 urls = {source = 'https://github.com/wrmsr/omlish'}
 license = {text = 'BSD-3-Clause'}
 requires-python = '>=3.12'
-version = '0.0.0.dev188'
+version = '0.0.0.dev189'
 classifiers = [
     'License :: OSI Approved :: BSD License',
     'Development Status :: 2 - Pre-Alpha',