omlish 0.0.0.dev187__tar.gz → 0.0.0.dev189__tar.gz

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

@@ -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 → omlish-0.0.0.dev189}/omlish/__about__.py

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

{omlish-0.0.0.dev187 → 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.dev187 → 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.dev187 → omlish-0.0.0.dev189}/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-0.0.0.dev187 → 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.dev187/omlish/term.py → omlish-0.0.0.dev189/omlish/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-0.0.0.dev189/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-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()