omdev 0.0.0.dev500__py3-none-any.whl → 0.0.0.dev509__py3-none-any.whl

omdev/tools/sqlrepl.py

@@ -1,3 +1,10 @@
+"""
+TODO:
+ - sqlite
+ - unify-ish with omlish.sql
+"""
+import abc
+import configparser
 import dataclasses as dc
 import os.path
 import shutil
@@ -76,104 +83,197 @@ def spec_from_cfg(cfg: ta.Mapping[str, ta.Any], prefix: str) -> ServerSpec:
     )
 
 
-@lang.cached_function
-def _maybe_warn_pgcli_keyring() -> None:
-    import pgcli.config
+##
+
+
+@dc.dataclass(frozen=True)
+class ReplArgs:
+    spec: ServerSpec
+    extra_args: ta.Sequence[str] | None = None  # noqa
+
+    _: dc.KW_ONLY
+
+    exe: ta.Sequence[str] | None = None
+
+    no_dbcli: bool = False
+    no_import: bool = False
+    no_uv: bool = False
+    dbcli_version: str | None = None
+
+
+class ReplRunner(lang.Abstract):
+    def __init__(self, args: ReplArgs) -> None:
+        super().__init__()
+
+        self._args = args
+
+    exe_name: ta.ClassVar[str]
+    dbcli_name: ta.ClassVar[str | None] = None
+
+    #
+
+    class Exe(ta.NamedTuple):
+        args: ta.Sequence[str]
+        is_dbcli: bool
+
+    @lang.cached_function
+    def exe(self) -> Exe:
+        if self._args.exe is not None:
+            if isinstance(self._args.exe, str):
+                return ReplRunner.Exe([self._args.exe], False)
+            else:
+                return ReplRunner.Exe(list(self._args.exe), False)
+
+        def default():
+            return ReplRunner.Exe([check.not_none(shutil.which(self.exe_name))], False)
+
+        if self._args.no_dbcli or self.dbcli_name is None:
+            return default()
+
+        if not self._args.no_import:
+            main_mod = self.dbcli_name + '.main'
+
+            try:
+                __import__(main_mod)
+            except ImportError:
+                pass
+            else:
+                return ReplRunner.Exe([sys.executable, '-m', main_mod], True)
+
+        if not self._args.no_uv and (uv_exe := shutil.which('uv')) is not None:
+            uv_arg = self.dbcli_name
+            if self._args.dbcli_version is not None:
+                uv_arg += f'@{self._args.dbcli_version}'
+
+            return ReplRunner.Exe([uv_exe, 'tool', 'run', uv_arg], True)
+
+        return default()
+
+    #
+
+    @abc.abstractmethod
+    def build_args(self) -> ta.Sequence[str]:
+        raise NotImplementedError
+
+    def pre_exec(self) -> None:
+        pass
+
+    #
+
+    def run(self) -> ta.NoReturn:
+        lst: list[str] = [
+            *self.exe().args,
+            *self.build_args(),
+        ]
+
+        self.pre_exec()
+
+        os.execvp(lst[0], lst)
+
+
+class MysqlReplRunner(ReplRunner):
+    dbcli_name = 'mycli'
+    exe_name = 'mysql'
+
+    def build_args(self) -> ta.Sequence[str]:
+        lst: list[str] = []
+
+        if self._args.spec.username:
+            lst.extend(['--user', self._args.spec.username])
+
+        lst.extend(['--host', self._args.spec.host])
+        if not self.exe().is_dbcli:
+            lst.append('--protocol=TCP')
+        if self._args.spec.port:
+            lst.extend(['--port', str(self._args.spec.port)])
+
+        if self._args.spec.db:
+            lst.append(self._args.spec.db)
+
+        lst.extend(self._args.extra_args or [])
+
+        return lst
+
+    def pre_exec(self) -> None:
+        super().pre_exec()
+
+        if self._args.spec.password:
+            os.environ['MYSQL_PWD'] = self._args.spec.password
+
+
+class PostgresReplRunner(ReplRunner):
+    dbcli_name = 'pgcli'
+    exe_name = 'psql'
+
+    def build_args(self) -> ta.Sequence[str]:
+        lst: list[str] = []
+
+        if self._args.spec.username:
+            lst.extend(['--username', self._args.spec.username])
+
+        if self._args.spec.host:
+            lst.extend(['--host', self._args.spec.host])
+        if self._args.spec.port:
+            lst.extend(['--port', str(self._args.spec.port)])
+
+        if self._args.spec.db:
+            lst.append(self._args.spec.db)
+
+        lst.extend(self._args.extra_args or [])
+
+        return lst
+
+    def _maybe_warn_keyring(self) -> None:
+        if 'XDG_CONFIG_HOME' in os.environ:
+            cfg_dir = f'{os.path.expanduser(os.environ["XDG_CONFIG_HOME"])}/pgcli/'
+        else:
+            cfg_dir = os.path.expanduser('~/.config/pgcli/')
+        cfg_path = os.path.join(cfg_dir, 'config')
+
+        if os.path.exists(cfg_path):
+            cfg = configparser.ConfigParser()
+            cfg.read(cfg_path)
+
+            if cfg.has_section('main') and not cfg.getboolean('main', 'keyring', fallback=True):
+                return
 
-    c = pgcli.config.get_config()
-    if c['main'].as_bool('keyring'):
         warnings.warn(
             'pgcli keyring is not disabled, it will try to store credentials. '
-            'set `keyring = False` in ~/.config/pgcli/config',
+            'set `[main] keyring = False` in ~/.config/pgcli/config',
         )
 
+    def pre_exec(self) -> None:
+        super().pre_exec()
 
-def _dbcli_or_fallback_exe(dbcli_mod: str | None, default_exe: str) -> tuple[ta.Sequence[str], bool]:
-    if dbcli_mod is not None:
-        main_mod = dbcli_mod + '.main'
-        try:
-            __import__(main_mod)
-        except ImportError:
-            pass
-        else:
-            if dbcli_mod == 'pgcli':
-                _maybe_warn_pgcli_keyring()
-            return [sys.executable, '-m', main_mod], True
-    return [check.not_none(shutil.which(default_exe))], False
-
-
-def exec_mysql_cli(
-        spec: ServerSpec,
-        *extra_args: str,
-        exe: ta.Iterable[str] | None = None,
-        no_dbcli: bool = False,
-) -> ta.NoReturn:
-    if exe is not None:
-        args, is_dbcli = list(exe), False
-    else:
-        argsx, is_dbcli = _dbcli_or_fallback_exe(
-            'mycli' if not no_dbcli else None,
-            'mysql',
-        )
-        args = list(argsx)
-    if spec.username:
-        args.extend(['--user', spec.username])
-    if spec.password:
-        os.environ['MYSQL_PWD'] = spec.password
-    args.extend(['--host', spec.host])
-    if not is_dbcli:
-        args.append('--protocol=TCP')
-    if spec.port:
-        args.extend(['--port', str(spec.port)])
-    if spec.db:
-        args.append(spec.db)
-    args.extend(extra_args)
-    os.execvp(args[0], args)
-
-
-def exec_postgres_cli(
-        spec: ServerSpec,
-        *extra_args: str,
-        exe: ta.Iterable[str] | None = None,
-        no_dbcli: bool = False,
-) -> ta.NoReturn:
-    if exe is not None:
-        args, is_dbcli = list(exe), False
-    else:
-        argsx, is_dbcli = _dbcli_or_fallback_exe(
-            'pgcli' if not no_dbcli else None,
-            'psql',
-        )
-        args = list(argsx)
-    if spec.username:
-        args.extend(['--username', spec.username])
-    if spec.password:
-        os.environ['PGPASSWORD'] = spec.password
-    if spec.host:
-        args.extend(['--host', spec.host])
-    if spec.port:
-        args.extend(['--port', str(spec.port)])
-    if spec.db:
-        args.append(spec.db)
-    args.extend(extra_args)
-    os.execvp(args[0], args)
+        self._maybe_warn_keyring()
+
+        if self._args.spec.password:
+            os.environ['PGPASSWORD'] = self._args.spec.password
+
+
+##
 
 
 class Cli(ap.Cli):
     @ap.cmd(
-        ap.arg('--no-dbcli', action='store_true'),
         ap.arg('dialect'),
         ap.arg('target'),
         ap.arg('args', nargs='*'),
+        ap.arg('--no-dbcli', action='store_true'),
+        ap.arg('--no-import', action='store_true'),
+        ap.arg('--no-uv', action='store_true'),
     )
     def repl(self) -> None:
         l, _, r = (target := self.args.target).partition(':')
         _, lf = os.path.dirname(l), os.path.basename(l)
         if not lf.endswith('.yml'):
             raise Exception(f'unhandled target: {target=}')
+
         with open(l) as f:
             cfg = yaml.safe_load(f.read())
+
         dialect = self.args.dialect
+
         if lf == 'compose.yml':
             svc = cfg['services'][r]
             if dialect == 'mysql':
@@ -185,13 +285,24 @@ class Cli(ap.Cli):
         else:
             spec = spec_from_cfg(cfg, r)
 
+        repl_args = ReplArgs(
+            spec,
+            self.args.args,
+            no_dbcli=self.args.no_dbcli,
+            no_import=self.args.no_import,
+            no_uv=self.args.no_uv,
+        )
+
+        repl_run: ReplRunner
         if dialect == 'mysql':
-            exec_mysql_cli(spec, *self.args.args, no_dbcli=self.args.no_dbcli)
+            repl_run = MysqlReplRunner(repl_args)
         elif dialect == 'postgres':
-            exec_postgres_cli(spec, *self.args.args, no_dbcli=self.args.no_dbcli)
+            repl_run = PostgresReplRunner(repl_args)
         else:
             raise Exception(f'unhandled dialect: {dialect=}')
 
+        repl_run.run()
+
 
 # @omlish-manifest
 _CLI_MODULE = CliModule('sqlrepl', __name__)

omdev/tui/rich/markdown2.py

@@ -130,6 +130,8 @@ class NaiveMarkdownLiveStream(MarkdownLiveStream):
 
 
 class IncrementalMarkdownLiveStream(MarkdownLiveStream):
+    # @omlish-llm-author "gemini-3-pro"
+
     def __init__(
             self,
             *,
@@ -147,40 +149,239 @@ class IncrementalMarkdownLiveStream(MarkdownLiveStream):
         ip_out = self._inc_parser.feed2(s)
 
         if ip_out.new_stable:
-            # try:
-            #     srs = getattr(self, '_srs')
-            # except AttributeError:
-            #     setattr(self, '_srs', srs := [])
-            # from ...markdown.tokens import token_repr, flatten_tokens
-            # srs.extend(map(token_repr, flatten_tokens(ip_out.new_stable)))
-
+            # Render the stable lines
             stable_lines = self._console_render(markdown_from_tokens(ip_out.new_stable))
-            stable_lines.append(' ')  # FIXME: lame hack
-            self._live.console.print(rich.text.Text.from_ansi('\n'.join(stable_lines), no_wrap=True))
+
+            # Overlap Detection
+            already_printed_count = min(self._lines_printed_to_scrollback, len(stable_lines))
+
+            if already_printed_count < len(stable_lines):
+                new_stable_lines = stable_lines[already_printed_count:]
+                # Ensure no_wrap=True is used here to match strict line counting
+                self._live.console.print(rich.text.Text.from_ansi('\n'.join(new_stable_lines), no_wrap=True))
+
+            # Adjust counter
             self._lines_printed_to_scrollback = max(0, self._lines_printed_to_scrollback - len(stable_lines))
 
         unstable_lines = self._console_render(markdown_from_tokens(ip_out.unstable))
 
-        # Calculate how many lines fit in the live window
         available_height = self._console.height - 2
-
-        # Determine which lines overflow and need to be printed to scrollback
         total_lines = len(unstable_lines)
+
         if total_lines > available_height:
-            # Lines that should be in scrollback
-            lines_for_scrollback = total_lines - available_height
+            # We calculate lines allowed in scrollback, but we subtract 1. This ensures the very bottom line (often a
+            # transient border) stays in the Live window and is not committed to history until more content pushes it
+            # up.
+            lines_for_scrollback = max(0, total_lines - available_height - 1)
 
-            # Print any new lines that weren't already printed
             if lines_for_scrollback > self._lines_printed_to_scrollback:
                 new_lines_to_print = unstable_lines[self._lines_printed_to_scrollback:lines_for_scrollback]
-                self._live.console.print(rich.text.Text.from_ansi('\n'.join(new_lines_to_print)))
+
+                # Ensure no_wrap=True is used here to prevent auto-wrap from creating "phantom" lines that desync our
+                # line counts.
+                self._live.console.print(rich.text.Text.from_ansi('\n'.join(new_lines_to_print), no_wrap=True))
+
                 self._lines_printed_to_scrollback = lines_for_scrollback
 
-            # Show only the bottom portion in the live window
             visible_lines = unstable_lines[-available_height:]
 
         else:
             visible_lines = unstable_lines
 
-        # Update the live display
         self._live.update(rich.text.Text.from_ansi('\n'.join(visible_lines)))
+
+
+class SteppedIncrementalMarkdownLiveStream(MarkdownLiveStream):
+    # @omlish-llm-author "gemini-3-pro"
+
+    def __init__(
+            self,
+            *,
+            parser: ta.Optional['md.MarkdownIt'] = None,
+            console: ta.Optional['rich.console.Console'] = None,
+            scroll_step: int | None = None,
+    ) -> None:
+        super().__init__(
+            parser=parser,
+            console=console,
+        )
+
+        self._inc_parser = IncrementalMarkdownParser(parser=self._parser)
+        self._scroll_step = scroll_step
+
+    def feed(self, s: str) -> None:
+        ip_out = self._inc_parser.feed2(s)
+
+        ##
+        # Handle stable content
+
+        if ip_out.new_stable:
+            stable_lines = self._console_render(markdown_from_tokens(ip_out.new_stable))
+
+            # Overlap Detection: Determine how many lines of this now-stable block were already pushed to scrollback
+            # while they were in the "unstable" phase.
+            already_printed_count = min(self._lines_printed_to_scrollback, len(stable_lines))
+
+            if already_printed_count < len(stable_lines):
+                new_stable_lines = stable_lines[already_printed_count:]
+                # Force no_wrap=True to ensure 1:1 line counting
+                self._live.console.print(rich.text.Text.from_ansi('\n'.join(new_stable_lines), no_wrap=True))
+
+            # Adjust the global scrollback counter. We effectively shift the "start" of the unstable window down by the
+            # size of the stable block.
+            self._lines_printed_to_scrollback = max(0, self._lines_printed_to_scrollback - len(stable_lines))
+
+        ##
+        # Handle unstable content
+
+        unstable_lines = self._console_render(markdown_from_tokens(ip_out.unstable))
+        total_lines = len(unstable_lines)
+        available_height = self._console.height - 2
+
+        # Calculate the absolute minimum lines that MUST be in scrollback to fit the current content. We subtract 1 to
+        # hold back the bottom-most line (e.g., table borders) from history until it is pushed up by further content.
+        min_needed_scrollback = max(0, total_lines - available_height - 1)
+
+        if min_needed_scrollback > self._lines_printed_to_scrollback:
+            # We need to scroll. Calculate how much.
+            diff = min_needed_scrollback - self._lines_printed_to_scrollback
+
+            # Use the step size if configured, otherwise just satisfy the immediate difference. If the difference is
+            # larger than the step (e.g., big paste), we jump the full difference.
+            step = self._scroll_step if self._scroll_step is not None else 1
+            jump_size = max(diff, step)
+
+            # Calculate the new target scrollback index. We must clamp this to 'total_lines - 1' to ensure we never push
+            # the strictly held-back last line into history.
+            max_pushable_index = max(0, total_lines - 1)
+            target_scrollback = min(self._lines_printed_to_scrollback + jump_size, max_pushable_index)
+
+            if target_scrollback > self._lines_printed_to_scrollback:
+                new_lines_to_print = unstable_lines[self._lines_printed_to_scrollback:target_scrollback]
+                self._live.console.print(rich.text.Text.from_ansi('\n'.join(new_lines_to_print), no_wrap=True))
+                self._lines_printed_to_scrollback = target_scrollback
+
+        # Update the live display. We slice from '_lines_printed_to_scrollback' to the end. If we just performed a large
+        # 'jump', this will naturally result in fewer lines than 'available_height', creating the desired visual "void"
+        # at the bottom.
+        visible_lines = unstable_lines[self._lines_printed_to_scrollback:]
+        self._live.update(rich.text.Text.from_ansi('\n'.join(visible_lines)))
+
+
+##
+
+
+class ClaudeIncrementalMarkdownLiveStream(MarkdownLiveStream):
+    # @omlish-llm-author "claude-opus-4-5"
+
+    def __init__(
+            self,
+            *,
+            parser: ta.Optional['md.MarkdownIt'] = None,
+            console: ta.Optional['rich.console.Console'] = None,
+    ) -> None:
+        super().__init__(
+            parser=parser,
+            console=console,
+        )
+
+        from ...markdown.incparse import ClaudeIncrementalMarkdownParser  # noqa
+        self._inc_parser = ClaudeIncrementalMarkdownParser(parser=self._parser)
+        self._last_unstable_line_count = 0
+
+    def _enter_contexts(self) -> None:
+        super()._enter_contexts()
+
+        # Override to configure Live with explicit vertical overflow handling
+        self._live = self._enter_context(rich.live.Live(
+            rich.text.Text(''),
+            console=self._console,
+            refresh_per_second=10,
+            vertical_overflow='crop',
+        ))
+
+    def feed(self, s: str) -> None:
+        ip_out = self._inc_parser.feed2(s)
+
+        if ip_out.new_stable:
+            # Stop live display to commit stable content cleanly
+            self._live.stop()
+
+            # Render and print stable content to true scrollback
+            stable_lines = self._console_render(markdown_from_tokens(ip_out.new_stable))
+            for line in stable_lines:
+                self._console.print(rich.text.Text.from_ansi(line), highlight=False)
+
+            # Reset tracking state since we're starting fresh with new unstable content
+            self._last_unstable_line_count = 0
+            self._lines_printed_to_scrollback = 0
+
+            # Restart live display
+            self._live.start()
+
+        # Render current unstable content
+        unstable_lines = self._console_render(markdown_from_tokens(ip_out.unstable))
+        current_line_count = len(unstable_lines)
+
+        # Calculate available display height
+        available_height = self._console.height - 2
+
+        # Handle content that exceeds available height. Key insight: never commit unstable content to scrollback since
+        # it may change.
+        if current_line_count > available_height:
+            # Only show the bottom portion that fits
+            visible_lines = unstable_lines[-available_height:]
+        else:
+            visible_lines = unstable_lines
+
+        # Handle shrinking content: if we had more lines before and now have fewer, we need to ensure the live region is
+        # properly cleared.
+        if current_line_count < self._last_unstable_line_count:
+            # Pad with empty lines to prevent artifacts from previous longer content. This ensures the live region fully
+            # overwrites its previous state.
+            lines_to_clear = min(
+                self._last_unstable_line_count - current_line_count,
+                available_height - len(visible_lines),
+            )
+            if lines_to_clear > 0:
+                visible_lines = visible_lines + [''] * lines_to_clear
+
+        self._last_unstable_line_count = current_line_count
+
+        # Update the live display
+        display_text = '\n'.join(visible_lines)
+        self._live.update(rich.text.Text.from_ansi(display_text))
+
+
+class GptIncrementalMarkdownLiveStream(MarkdownLiveStream):
+    # @omlish-llm-author "gpt-5.2"
+
+    def __init__(
+            self,
+            *,
+            parser: ta.Optional['md.MarkdownIt'] = None,
+            console: ta.Optional['rich.console.Console'] = None,
+    ) -> None:
+        super().__init__(
+            parser=parser,
+            console=console,
+        )
+
+        from ...markdown.incparse import GptIncrementalMarkdownParser  # noqa
+        self._inc_parser = GptIncrementalMarkdownParser(parser=self._parser)
+
+    def feed(self, s: str) -> None:
+        ip_out = self._inc_parser.feed2(s)
+
+        # Permanently commit only content the parser marked as stable. This avoids *all* "scrollback delta accounting"
+        # and the associated duplication/gap bugs when the rendered tail shrinks / reflows / reinterprets (streaming
+        # markdown is non-monotonic).
+        if ip_out.new_stable:
+            # Print stable renderables directly through Rich (avoid ANSI round-tripping / splitlines). Use end="" so we
+            # don't inject extra blank lines beyond what the markdown renderable produces.
+            self._live.console.print(markdown_from_tokens(ip_out.new_stable), end='')
+
+        # Show the remaining (unstable) tail in the live region. We intentionally do *not* try to "spill overflow of
+        # unstable to scrollback", since those lines are not provably stable and may retroactively change; printing them
+        # would violate correctness.
+        self._live.update(markdown_from_tokens(ip_out.unstable))

{omdev-0.0.0.dev500.dist-info → omdev-0.0.0.dev509.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omdev
-Version: 0.0.0.dev500
+Version: 0.0.0.dev509
 Summary: omdev
 Author: wrmsr
 License-Expression: BSD-3-Clause
@@ -14,9 +14,9 @@ Classifier: Programming Language :: Python :: 3.13
 Requires-Python: >=3.13
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: omlish==0.0.0.dev500
+Requires-Dist: omlish==0.0.0.dev509
 Provides-Extra: all
-Requires-Dist: black~=25.12; extra == "all"
+Requires-Dist: black~=26.1; extra == "all"
 Requires-Dist: pycparser~=2.23; extra == "all"
 Requires-Dist: pcpp~=1.30; extra == "all"
 Requires-Dist: docutils~=0.22; extra == "all"
@@ -27,11 +27,11 @@ Requires-Dist: mypy~=1.19; extra == "all"
 Requires-Dist: gprof2dot~=2025.4; extra == "all"
 Requires-Dist: segno~=1.6; extra == "all"
 Requires-Dist: rich~=14.2; extra == "all"
-Requires-Dist: textual~=7.0; extra == "all"
+Requires-Dist: textual~=7.3; extra == "all"
 Requires-Dist: textual-dev~=1.8; extra == "all"
 Requires-Dist: textual-speedups~=0.2; extra == "all"
 Provides-Extra: black
-Requires-Dist: black~=25.12; extra == "black"
+Requires-Dist: black~=26.1; extra == "black"
 Provides-Extra: c
 Requires-Dist: pycparser~=2.23; extra == "c"
 Requires-Dist: pcpp~=1.30; extra == "c"
@@ -48,7 +48,7 @@ Provides-Extra: qr
 Requires-Dist: segno~=1.6; extra == "qr"
 Provides-Extra: tui
 Requires-Dist: rich~=14.2; extra == "tui"
-Requires-Dist: textual~=7.0; extra == "tui"
+Requires-Dist: textual~=7.3; extra == "tui"
 Requires-Dist: textual-dev~=1.8; extra == "tui"
 Requires-Dist: textual-speedups~=0.2; extra == "tui"
 Dynamic: license-file