omdev 0.0.0.dev486__py3-none-any.whl → 0.0.0.dev506__py3-none-any.whl

omdev/.omlish-manifests.json

@@ -39,7 +39,7 @@
     "module": ".cli.clicli",
     "attr": "_CLI_MODULE",
     "file": "omdev/cli/clicli.py",
-    "line": 233,
+    "line": 263,
     "value": {
       "!.cli.types.CliModule": {
         "name": "cli",
@@ -527,7 +527,7 @@
     "module": ".tools.sqlrepl",
     "attr": "_CLI_MODULE",
     "file": "omdev/tools/sqlrepl.py",
-    "line": 196,
+    "line": 307,
     "value": {
       "!.cli.types.CliModule": {
         "name": "sqlrepl",

omdev/README.md

@@ -0,0 +1,51 @@
+# Overview
+
+Development utilities and support code.
+
+# Notable packages
+
+- **[cli](https://github.com/wrmsr/omlish/blob/master/omdev/cli)** - The codebase's all-in-one CLI. This is not
+  installed as an entrypoint / command when this package is itself installed - that is separated into the `omdev-cli`
+  installable package so as to not pollute users' bin/ directories when depping this lib for its utility code.
+
+- **[amalg](https://github.com/wrmsr/omlish/blob/master/omdev/amalg)** - The [amalgamator](#amalgamation).
+
+- **[pyproject](https://github.com/wrmsr/omlish/blob/master/omdev/pyproject)**
+  ([amalg](https://github.com/wrmsr/omlish/blob/master/omdev/scripts/pyproject.py)) - python project management tool.
+  wrangles but does not replace tools like venv, pip, setuptools, and uv. does things like sets up venvs, generates
+  [`.pkg`](https://github.com/wrmsr/omlish/blob/master/.pkg) directories and their `pyproject.toml`'s (from their
+  `__about__.py`'s), and packages them. this should grow to eat more and more of the Makefile. as it is amalgamated it
+  requires no installation and can just be dropped into other projects / repos.
+
+- **[ci](https://github.com/wrmsr/omlish/blob/master/omdev/ci)**
+  ([amalg](https://github.com/wrmsr/omlish/blob/master/omdev/scripts/ci.py)) - ci runner. given a
+  [`compose.yml`](https://github.com/wrmsr/omlish/blob/master/docker/compose.yml)
+  and requirements.txt files, takes care of building and caching of containers and venvs and execution of required ci
+  commands. detects and [natively uses](https://github.com/wrmsr/omlish/blob/master/omdev/ci/github/api/v2)
+  github-action's caching system. unifies ci execution between local dev and github runners.
+
+- **[tools.json](https://github.com/wrmsr/omlish/blob/master/omdev/tools/json)** (cli: `om j`) - a tool for json-like
+  data, obviously in the vein of [jq](https://github.com/jqlang/jq) but using the internal
+  [jmespath](https://github.com/wrmsr/omlish/blob/master/omlish/specs/jmespath) engine. supports
+  [true streaming](https://github.com/wrmsr/omlish/blob/master/omlish/formats/json/stream) json input and output, as
+  well as [various other](https://github.com/wrmsr/omlish/blob/master/omdev/tools/json/formats.py) non-streaming input
+  formats.
+
+- **[tools.git](https://github.com/wrmsr/omlish/blob/master/omdev/tools/git)** (cli: `om git`) - a tool for various lazy
+  git operations, including the one that (poorly) writes all of these commit messages.
+
+# Amalgamation
+
+Amalgamation is the process of stitching together multiple python source files into a single self-contained python
+script. ['lite'](https://github.com/wrmsr/omlish/blob/master/omlish#lite-code) code is written in a style conducive to
+this.
+
+# Local storage
+
+Some of this code, when asked, will store things on the local filesystem. The only directories used (outside of ones
+explicitly specified as command or function arguments) are managed in
+[home.paths](https://github.com/wrmsr/omlish/blob/master/omdev/home/paths.py), and are the following:
+
+- `$OMLISH_HOME`, default of `~/.omlish` - persistent things like config and state.
+- `$OMLISH_CACHE`, default of `~/.cache/omlish` - used for things like the local ci cache and
+  [various other](https://github.com/search?q=repo%3Awrmsr%2Fomlish+%22dcache.%22&type=code) cached data.

omdev/__about__.py

@@ -13,7 +13,7 @@ class Project(ProjectBase):
 
     optional_dependencies = {
         'black': [
-            'black ~= 25.11',
+            'black ~= 26.1',
         ],
 
         'c': [
@@ -44,7 +44,9 @@ class Project(ProjectBase):
 
         'tui': [
             'rich ~= 14.2',
-            'textual ~= 6.8',
+            'textual ~= 7.3',  # [syntax]
+            'textual-dev ~= 1.8',
+            'textual-speedups ~= 0.2',
         ],
     }
 

omdev/ci/cli.py

@@ -22,7 +22,7 @@ from omlish.argparse.cli import argparse_cmd
 from omlish.lite.check import check
 from omlish.lite.inject import inj
 from omlish.logs.modules import get_module_logger
-from omlish.logs.standard import configure_standard_logging
+from omlish.logs.std.standard import configure_standard_logging
 
 from .cache import DirectoryFileCache
 from .ci import Ci

omdev/cli/clicli.py

@@ -1,9 +1,11 @@
+import dataclasses as dc
 import inspect
 import os
 import re
 import shlex
 import subprocess
 import sys
+import time
 import typing as ta
 import urllib.parse
 import urllib.request
@@ -13,6 +15,7 @@ from omlish import lang
 from omlish.argparse import all as ap
 from omlish.os.temp import temp_dir_context
 
+from ..packaging.versions import Version
 from ..pip import get_root_dists
 from ..pip import lookup_latest_package_version
 from . import install
@@ -87,22 +90,49 @@ class CliCli(ap.Cli):
 
     #
 
+    @dc.dataclass()
+    class ReinstallWouldNotUpgradeError(Exception):
+        current_version: str
+        target_version: str
+
+        def __str__(self) -> str:
+            return f'Current version {self.current_version} is not older than target version {self.target_version} '
+
     @ap.cmd(
         ap.arg('--url', default=DEFAULT_REINSTALL_URL),
         ap.arg('--local', action='store_true'),
         ap.arg('--no-deps', action='store_true'),
         ap.arg('--no-uv', action='store_true'),
         ap.arg('--dry-run', action='store_true'),
+        ap.arg('--must-upgrade', action='store_true'),
+        ap.arg('--must-upgrade-loop', action='store_true'),
         ap.arg('--version'),
         ap.arg('extra_deps', nargs='*'),
     )
     def reinstall(self) -> None:
-        latest_version = _parse_latest_version_str(lookup_latest_package_version(__package__.split('.')[0]))
-
-        if self.args.version is not None:
-            target_version: str = self.args.version
-        else:
-            target_version = latest_version
+        current_version = __about__.__version__
+
+        while True:
+            latest_version = _parse_latest_version_str(lookup_latest_package_version(__package__.split('.')[0]))
+
+            if self.args.version is not None:
+                target_version: str = self.args.version
+            else:
+                target_version = latest_version
+
+            if self.args.must_upgrade or self.args.must_upgrade_loop:
+                current_vo = Version(current_version)
+                target_vo = Version(target_version)
+                if not (target_vo > current_vo):
+                    ex = CliCli.ReinstallWouldNotUpgradeError(current_version, target_version)
+                    if self.args.must_upgrade_loop:
+                        print(ex)
+                        time.sleep(1)
+                        continue
+                    else:
+                        raise ex
+
+            break
 
         #
 
@@ -186,7 +216,7 @@ class CliCli(ap.Cli):
 
         #
 
-        print(f'Current version: {__about__.__version__}')
+        print(f'Current version: {current_version}')
         print(f'Latest version: {latest_version}')
         print(f'Target version: {target_version}')
         print()

omdev/dataclasses/cli.py

@@ -1,5 +1,5 @@
 from omlish.argparse import all as ap
-from omlish.logs.standard import configure_standard_logging
+from omlish.logs.std.standard import configure_standard_logging
 
 from .codegen import DataclassCodeGen
 

omdev/interp/cli.py

@@ -17,7 +17,7 @@ from omlish.lite.check import check
 from omlish.lite.inject import Injector
 from omlish.lite.inject import inj
 from omlish.lite.runtime import check_lite_runtime_version
-from omlish.logs.standard import configure_standard_logging
+from omlish.logs.std.standard import configure_standard_logging
 
 from .inject import bind_interp
 from .resolvers import InterpResolver

omdev/interp/types.py

@@ -85,9 +85,10 @@ class InterpSpecifier:
     def parse(cls, s: str) -> 'InterpSpecifier':
         s, o = InterpOpts.parse_suffix(s)
         if not any(s.startswith(o) for o in Specifier.OPERATORS):
-            s = '~=' + s
             if s.count('.') < 2:
-                s += '.0'
+                s = '~=' + s + '.0'
+            else:
+                s = '==' + s
         return cls(
             specifier=Specifier(s),
             opts=o,

omdev/interp/uv/provider.py

@@ -5,7 +5,9 @@ uv run --python 3.11.6 pip
 uv venv --python 3.11.6 --seed barf
 python3 -m venv barf && barf/bin/pip install uv && barf/bin/uv venv --python 3.11.6 --seed barf2
 uv python find '3.13.10'
+uv python list --output-format=json
 """
+import dataclasses as dc
 import typing as ta
 
 from omlish.logs.protocols import LoggerLike
@@ -21,6 +23,34 @@ from .uv import Uv
 ##
 
 
+@dc.dataclass(frozen=True)
+class UvPythonListOutput:
+    key: str
+    version: str
+
+    @dc.dataclass(frozen=True)
+    class VersionParts:
+        major: int
+        minor: int
+        patch: int
+
+    version_parts: VersionParts
+
+    path: ta.Optional[str]
+    symlink: ta.Optional[str]
+
+    url: str
+
+    os: str  # emscripten linux macos
+    variant: str  # default freethreaded
+    implementation: str  # cpython graalpy pyodide pypy
+    arch: str  # aarch64 wasm32 x86_64
+    libc: str  # gnu musl none
+
+
+##
+
+
 class UvInterpProvider(InterpProvider):
     def __init__(
             self,
@@ -40,3 +70,9 @@ class UvInterpProvider(InterpProvider):
 
     async def get_installed_version(self, version: InterpVersion) -> Interp:
         raise NotImplementedError
+
+    # async def get_installable_versions(self, spec: InterpSpecifier) -> ta.Sequence[InterpVersion]:
+    #     return []
+
+    # async def install_version(self, version: InterpVersion) -> Interp:
+    #     raise TypeError

omdev/manifests/main.py

@@ -5,7 +5,7 @@ import multiprocessing as mp
 import os.path
 
 from omlish.lite.json import json_dumps_pretty
-from omlish.logs.standard import configure_standard_logging
+from omlish.logs.std.standard import configure_standard_logging
 
 from .building import ManifestBuilder
 from .building import check_package_manifests

omdev/markdown/incparse.py

@@ -114,3 +114,395 @@ class IncrementalMarkdownParser:
             adjusted.append(token)
 
         return adjusted
+
+
+##
+
+
+class ClaudeIncrementalMarkdownParser:
+    # @omlish-llm-author "claude-opus-4-5"
+
+    def __init__(
+            self,
+            *,
+            parser: ta.Optional['md.MarkdownIt'] = None,
+    ) -> None:
+        super().__init__()
+
+        if parser is None:
+            parser = md.MarkdownIt()
+        self._parser = parser
+
+        self._stable_tokens: list[md.token.Token] = []
+        self._buffer = ''
+        self._num_stable_lines = 0
+
+    class FeedOutput(ta.NamedTuple):
+        stable: ta.Sequence['md.token.Token']
+        new_stable: ta.Sequence['md.token.Token']
+        unstable: ta.Sequence['md.token.Token']
+
+    def feed2(self, chunk: str) -> FeedOutput:
+        self._buffer += chunk
+
+        new_tokens = self._parser.parse(self._buffer)
+
+        adjusted_tokens = self._adjust_token_line_numbers(new_tokens, self._num_stable_lines)
+
+        stable_count = self._find_stable_token_count(adjusted_tokens, self._buffer)
+
+        newly_stable: ta.Sequence[md.token.Token]
+        if stable_count > 0:
+            newly_stable = adjusted_tokens[:stable_count]
+
+            max_line = 0
+            for token in newly_stable:
+                if token.map:
+                    max_line = max(max_line, token.map[1])
+
+            if max_line > self._num_stable_lines:
+                lines_to_remove = max_line - self._num_stable_lines
+                lines = self._buffer.split('\n')
+                self._buffer = '\n'.join(lines[lines_to_remove:])
+
+                self._stable_tokens.extend(newly_stable)
+                self._num_stable_lines = max_line
+
+        else:
+            newly_stable = ()
+
+        return ClaudeIncrementalMarkdownParser.FeedOutput(
+            stable=self._stable_tokens,
+            new_stable=newly_stable,
+            unstable=adjusted_tokens[stable_count:],
+        )
+
+    def feed(self, chunk: str) -> list['md.token.Token']:
+        out = self.feed2(chunk)
+        return [*out.stable, *out.unstable]
+
+    def _find_stable_token_count(
+            self,
+            tokens: list['md.token.Token'],
+            buffer: str,
+    ) -> int:
+        if not tokens:
+            return 0
+
+        parent_indices = []
+        for i, token in enumerate(tokens):
+            if token.nesting in (1, 0) and token.level == 0:
+                parent_indices.append(i)
+
+        if len(parent_indices) < 2:
+            return 0
+
+        # Find the last parent index that is fully terminated. We need at least one more parent after it to consider it
+        # stable.
+        buffer_lines = buffer.split('\n')
+
+        for candidate_idx in range(len(parent_indices) - 2, -1, -1):
+            token_list_idx = parent_indices[candidate_idx]
+
+            # Find the end of this block (either the token itself or its closing tag)
+            block_end_idx = token_list_idx
+            if tokens[token_list_idx].nesting == 1:
+                # Opening tag - find corresponding close
+                depth = 1
+                for j in range(token_list_idx + 1, len(tokens)):
+                    if tokens[j].level == 0:
+                        if tokens[j].nesting == 1:
+                            depth += 1
+                        elif tokens[j].nesting == -1:
+                            depth -= 1
+                            if depth == 0:
+                                block_end_idx = j
+                                break
+
+            # Get the line range for this block
+            end_line = 0
+            for t in tokens[:block_end_idx + 1]:
+                if t.map:
+                    end_line = max(end_line, t.map[1])
+
+            # Check if followed by blank line or another clear block boundary end_line is exclusive (points to line
+            # after the block). Relative to current buffer (not absolute).
+            relative_end = end_line - self._num_stable_lines
+
+            if relative_end < 0:
+                continue
+
+            if relative_end < len(buffer_lines):
+                # Check for blank line or clear termination
+                if relative_end < len(buffer_lines):
+                    following_content = '\n'.join(buffer_lines[relative_end:])
+                    # Stable if: blank line follows, or significant content after
+                    if (
+                        following_content.startswith('\n') or
+                        (following_content.strip() and len(following_content.strip()) > 0)
+                    ):
+                        # Check the next parent token exists and has been parsed
+                        if candidate_idx + 1 < len(parent_indices):
+                            next_parent_idx = parent_indices[candidate_idx + 1]
+                            next_token = tokens[next_parent_idx]
+                            # The next block should start after our block ends
+                            if next_token.map and next_token.map[0] >= end_line - self._num_stable_lines:
+                                return parent_indices[candidate_idx + 1]
+
+        return 0
+
+    def _adjust_token_line_numbers(
+            self,
+            tokens: list['md.token.Token'],
+            line_offset: int,
+    ) -> list['md.token.Token']:
+        adjusted = []
+        for token in tokens:
+            if token.map:
+                token = dc.replace(
+                    token,
+                    map=[token.map[0] + line_offset, token.map[1] + line_offset],
+                )
+
+            adjusted.append(token)
+
+        return adjusted
+
+
+class GptIncrementalMarkdownParser:
+    # @omlish-llm-author "gpt-5.2"
+
+    def __init__(
+            self,
+            *,
+            parser: ta.Optional['md.MarkdownIt'] = None,
+    ) -> None:
+        super().__init__()
+
+        if parser is None:
+            parser = md.MarkdownIt()
+        self._parser = parser
+
+        self._stable_tokens: list[md.token.Token] = []
+        self._buffer = ''
+        self._num_stable_lines = 0  # Number of *source* lines removed from the buffer and committed.
+
+    class FeedOutput(ta.NamedTuple):
+        stable: ta.Sequence['md.token.Token']
+        new_stable: ta.Sequence['md.token.Token']
+        unstable: ta.Sequence['md.token.Token']
+
+    def feed2(self, chunk: str) -> FeedOutput:
+        self._buffer += chunk
+
+        # Parse the current buffer (line numbers are relative to the buffer's start).
+        new_tokens = self._parser.parse(self._buffer)
+
+        # Adjust ALL tokens to account for stable lines from previous parses.
+        adjusted_tokens = self._adjust_token_line_numbers(new_tokens, self._num_stable_lines)
+
+        # Decide how many *source lines* from the front of the buffer are safe to commit permanently.
+        stable_line_cut = self._find_stable_line_cut(self._buffer)
+        stable_abs_line = self._num_stable_lines + stable_line_cut
+
+        newly_stable: ta.Sequence[md.token.Token]
+        if stable_line_cut > 0:
+            # Commit tokens that are wholly before the stable cut.
+            newly_stable_list: list[md.token.Token] = []
+            remaining_list: list[md.token.Token] = []
+
+            for t in adjusted_tokens:
+                # Tokens without maps are treated conservatively as unstable unless we've already committed
+                # all remaining source.
+                if not t.map:
+                    remaining_list.append(t)
+                    continue
+
+                # t.map is [start_line, end_line) in absolute source lines (after adjustment).
+                if t.map[1] <= stable_abs_line:
+                    newly_stable_list.append(t)
+                else:
+                    remaining_list.append(t)
+
+            newly_stable = newly_stable_list
+
+            # Remove committed source lines from the buffer.
+            lines = self._buffer.split('\n')
+            self._buffer = '\n'.join(lines[stable_line_cut:])
+
+            # Persist committed state.
+            self._stable_tokens.extend(newly_stable)
+            self._num_stable_lines = stable_abs_line
+
+            unstable = remaining_list
+
+        else:
+            newly_stable = ()
+            unstable = adjusted_tokens
+
+        return GptIncrementalMarkdownParser.FeedOutput(
+            stable=self._stable_tokens,
+            new_stable=newly_stable,
+            unstable=unstable,
+        )
+
+    def feed(self, chunk: str) -> list['md.token.Token']:
+        out = self.feed2(chunk)
+        return [*out.stable, *out.unstable]
+
+    ##
+    # Stability boundary
+
+    def _find_stable_line_cut(self, buf: str) -> int:
+        """
+        Return a conservative number of *source lines* from the buffer start that can be treated as permanently stable
+        (i.e. future suffixes of the markdown source will not change their parse/render).
+
+        This intentionally errs on the side of keeping more in the unstable tail.
+        """
+
+        if not buf:
+            return 0
+
+        lines = buf.split('\n')
+
+        # Track whether we're inside a fenced code block. This is the biggest retroactive-parse hazard.
+        in_fence = False
+        fence_marker: str | None = None
+
+        # Track whether we're inside a blockquote region (heuristic).
+        in_quote = False
+
+        # Track whether we're inside a list region (heuristic).
+        in_list = False
+
+        # We only commit up to a "hard" boundary: a blank line that is outside fence/quote/list context. Additionally,
+        # we require that the boundary line itself is blank (so setext headings can't reach back).
+        last_safe_cut: int = 0
+
+        def is_blank(s: str) -> bool:
+            return not s.strip()
+
+        def is_fence_line(s: str) -> str | None:
+            st = s.lstrip()
+            if st.startswith('```'):
+                return '```'
+            if st.startswith('~~~'):
+                return '~~~'
+            return None
+
+        def is_quote_line(s: str) -> bool:
+            return s.lstrip().startswith('>')
+
+        def is_list_line(s: str) -> bool:
+            st = s.lstrip()
+            if not st:
+                return False
+            # Very conservative list marker detection.
+            if st[0] in ('-', '*', '+') and len(st) > 1 and st[1].isspace():
+                return True
+            # "1. " / "1) "
+            i = 0
+            while i < len(st) and st[i].isdigit():
+                i += 1
+            if i > 0 and i < len(st) and st[i] in ('.', ')'):
+                j = i + 1
+                return j < len(st) and st[j].isspace()
+            return False
+
+        def is_indented_code(s: str) -> bool:
+            # Indented code blocks (4 spaces / 1 tab) can be sensitive to context; treat as "unstable context" for
+            # committing boundaries.
+            return s.startswith(('    ', '\t'))
+
+        for i, line in enumerate(lines):
+            # Fence tracking.
+            fm = is_fence_line(line)
+            if fm is not None:
+                if not in_fence:
+                    in_fence = True
+                    fence_marker = fm
+                else:
+                    # Only close on the matching marker (conservative).
+                    if fence_marker == fm:
+                        in_fence = False
+                        fence_marker = None
+
+            # Quote tracking (heuristic: treat contiguous quote lines as quote context).
+            if is_quote_line(line):
+                in_quote = True
+            elif is_blank(line):
+                # A blank line is a potential place to end a quote, but only if we are not in a fence.
+                if not in_fence:
+                    in_quote = False
+
+            # List tracking (heuristic: any list marker enters list context; blank lines end list context only if the
+            # following non-blank line is not indented / not list / not quote).
+            if is_list_line(line):
+                in_list = True
+            if is_blank(line) and not in_fence:
+                # Peek ahead to see if the list plausibly continues.
+                j = i + 1
+                while j < len(lines) and is_blank(lines[j]):
+                    j += 1
+                if j >= len(lines):
+                    # End of buffer: keep tail unstable.
+                    pass
+                else:
+                    nxt = lines[j]
+                    if (
+                            not is_indented_code(nxt) and
+                            not is_list_line(nxt) and
+                            not is_quote_line(nxt)
+                    ):
+                        in_list = False
+
+            # Commit boundary selection.
+            if is_blank(line) and not in_fence and not in_quote and not in_list:
+                # Safe to commit through this blank line (i.e. cut after it).
+                last_safe_cut = i + 1
+
+        # Never cut the entire buffer; leave at least one line in the tail so incremental feeds keep working.
+        if last_safe_cut >= len(lines):
+            return 0
+
+        return last_safe_cut
+
+    def _adjust_token_line_numbers(
+            self,
+            tokens: list['md.token.Token'],
+            line_offset: int,
+    ) -> list['md.token.Token']:
+        adjusted: list[md.token.Token] = []
+
+        def adj_tok(t: 'md.token.Token') -> 'md.token.Token':
+            nt = t
+            if nt.map:
+                nt = dc.replace(
+                    nt,
+                    map=[nt.map[0] + line_offset, nt.map[1] + line_offset],
+                )
+
+            # Adjust children maps too (markdown-it uses children for inline tokens).
+            ch = getattr(nt, 'children', None)
+            if ch:
+                new_children: list[md.token.Token] = []
+                changed = False
+                for c in ch:
+                    nc = c
+                    if nc.map:
+                        nc = dc.replace(
+                            nc,
+                            map=[nc.map[0] + line_offset, nc.map[1] + line_offset],
+                        )
+                        changed = True
+                    new_children.append(nc)
+                if changed:
+                    nt = dc.replace(nt, children=new_children)
+
+            return nt
+
+        for token in tokens:
+            adjusted.append(adj_tok(token))
+
+        return adjusted

omdev/packaging/revisions.py

@@ -15,7 +15,7 @@ import zipfile
 from omlish.lite.cached import cached_nullary
 from omlish.lite.check import check
 from omlish.logs.modules import get_module_logger
-from omlish.logs.standard import configure_standard_logging
+from omlish.logs.std.standard import configure_standard_logging
 
 from ..git.revisions import get_git_revision
 from .wheelfile import WheelFile