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

omdev/.omlish-manifests.json

@@ -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/__about__.py

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

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/pyproject/cli.py

@@ -22,7 +22,6 @@ See:
 import argparse
 import asyncio
 import concurrent.futures as cf
-import dataclasses as dc
 import functools
 import itertools
 import multiprocessing as mp
@@ -47,40 +46,7 @@ from .configs import PyprojectConfigPreparer
 from .pkg import BasePyprojectPackageGenerator
 from .pkg import PyprojectPackageGenerator
 from .venvs import Venv
-
-
-##
-
-
-@dc.dataclass(frozen=True)
-class VersionsFile:
-    name: ta.Optional[str] = '.versions'
-
-    @staticmethod
-    def parse(s: str) -> ta.Mapping[str, str]:
-        return {
-            k: v
-            for l in s.splitlines()
-            if (sl := l.split('#')[0].strip())
-            for k, _, v in (sl.partition('='),)
-        }
-
-    @cached_nullary
-    def contents(self) -> ta.Mapping[str, str]:
-        if not self.name or not os.path.exists(self.name):
-            return {}
-        with open(self.name) as f:
-            s = f.read()
-        return self.parse(s)
-
-    @staticmethod
-    def get_pythons(d: ta.Mapping[str, str]) -> ta.Mapping[str, str]:
-        pfx = 'PYTHON_'
-        return {k[len(pfx):].lower(): v for k, v in d.items() if k.startswith(pfx)}
-
-    @cached_nullary
-    def pythons(self) -> ta.Mapping[str, str]:
-        return self.get_pythons(self.contents())
+from .versions import VersionsFile
 
 
 ##

omdev/pyproject/configs.py

@@ -24,7 +24,7 @@ class PyprojectConfig:
     venvs: ta.Mapping[str, VenvConfig] = dc.field(default_factory=dict)
 
     venvs_dir: str = '.venvs'
-    versions_file: ta.Optional[str] = '.versions'
+    # versions_file: ta.Optional[str] = '.versions'  # FIXME:
 
 
 class PyprojectConfigPreparer:

omdev/pyproject/tools/pyversions.py

@@ -0,0 +1,47 @@
+# ruff: noqa: UP006 UP045
+import dataclasses as dc
+import json
+import typing as ta
+import urllib.request
+
+from ..versions import VersionsFile
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class PyVersion:
+    name: str  # "Python 3.13.11",
+    slug: str  # "python-31311"
+    version: int  # 3
+    is_published: bool
+    is_latest: bool
+    release_date: str  # "2025-12-05T19:24:49Z"
+    pre_release: bool
+    release_page: ta.Optional[str]
+    release_notes_url: str  # "https://docs.python.org/release/3.13.11/whatsnew/changelog.html"
+    show_on_download_page: bool
+    resource_uri: str  # "https://www.python.org/api/v2/downloads/release/1083/"
+
+
+PY_VERSIONS_URL = 'https://www.python.org/api/v2/downloads/release/?is_published=true'
+
+
+def get_py_versions() -> ta.List[PyVersion]:
+    with urllib.request.urlopen(PY_VERSIONS_URL) as r:  # noqa
+        data = json.load(r)
+
+    return [PyVersion(**dct) for dct in data]
+
+
+##
+
+
+def _main() -> None:
+    print(get_py_versions())
+    print(VersionsFile().pythons())
+
+
+if __name__ == '__main__':
+    _main()

omdev/pyproject/versions.py

@@ -0,0 +1,40 @@
+# ruff: noqa: UP045
+import dataclasses as dc
+import os.path
+import typing as ta
+
+from omlish.lite.cached import cached_nullary
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class VersionsFile:
+    name: ta.Optional[str] = '.versions'
+
+    @staticmethod
+    def parse(s: str) -> ta.Mapping[str, str]:
+        return {
+            k: v
+            for l in s.splitlines()
+            if (sl := l.split('#')[0].strip())
+            for k, _, v in (sl.partition('='),)
+        }
+
+    @cached_nullary
+    def contents(self) -> ta.Mapping[str, str]:
+        if not self.name or not os.path.exists(self.name):
+            return {}
+        with open(self.name) as f:
+            s = f.read()
+        return self.parse(s)
+
+    @staticmethod
+    def get_pythons(d: ta.Mapping[str, str]) -> ta.Mapping[str, str]:
+        pfx = 'PYTHON_'
+        return {k[len(pfx):].lower(): v for k, v in d.items() if k.startswith(pfx)}
+
+    @cached_nullary
+    def pythons(self) -> ta.Mapping[str, str]:
+        return self.get_pythons(self.contents())

omdev/scripts/ci.py

@@ -125,7 +125,7 @@ def __omlish_amalg__():  # noqa
             dict(path='../../omlish/http/coro/io.py', sha1='2cdf6529c37a37cc0c1db2e02032157cf906d5d6'),
             dict(path='../../omlish/http/parsing.py', sha1='3fea28dc6341908ba7c8fad42bf7bbe711f21b82'),
             dict(path='../../omlish/lite/marshal.py', sha1='96348f5f2a26dc27d842d33cc3927e9da163436b'),
-            dict(path='../../omlish/lite/maybes.py', sha1='bdf5136654ccd14b6a072588cad228925bdfbabd'),
+            dict(path='../../omlish/lite/maybes.py', sha1='04d2fcbea17028a5e6b8e7a7fb742375495ed233'),
             dict(path='../../omlish/lite/runtime.py', sha1='2e752a27ae2bf89b1bb79b4a2da522a3ec360c70'),
             dict(path='../../omlish/lite/timeouts.py', sha1='a0f673033a6943f242e35848d78a41892b9c62a1'),
             dict(path='../../omlish/logs/infos.py', sha1='4dd104bd468a8c438601dd0bbda619b47d2f1620'),
@@ -5015,6 +5015,13 @@ class Maybe(ta.Generic[T]):
         else:
             return other
 
+    @ta.final
+    def or_none(self) -> ta.Optional[T]:
+        if self.present:
+            return self.must()
+        else:
+            return None
+
     @ta.final
     def or_else_get(self, supplier: ta.Callable[[], ta.Union[T, U]]) -> ta.Union[T, U]:
         if self.present:

omdev/scripts/interp.py

@@ -65,7 +65,7 @@ def __omlish_amalg__():  # noqa
             dict(path='../../omlish/logs/std/proxy.py', sha1='3e7301a2aa351127f9c85f61b2f85dcc3f15aafb'),
             dict(path='../packaging/specifiers.py', sha1='a56ab4e8c9b174adb523921f6280ac41e0fce749'),
             dict(path='../../omlish/argparse/cli.py', sha1='f4dc3cd353d14386b5da0306768700e396afd2b3'),
-            dict(path='../../omlish/lite/maybes.py', sha1='bdf5136654ccd14b6a072588cad228925bdfbabd'),
+            dict(path='../../omlish/lite/maybes.py', sha1='04d2fcbea17028a5e6b8e7a7fb742375495ed233'),
             dict(path='../../omlish/lite/runtime.py', sha1='2e752a27ae2bf89b1bb79b4a2da522a3ec360c70'),
             dict(path='../../omlish/lite/timeouts.py', sha1='a0f673033a6943f242e35848d78a41892b9c62a1'),
             dict(path='../../omlish/logs/protocols.py', sha1='05ca4d1d7feb50c4e3b9f22ee371aa7bf4b3dbd1'),
@@ -2668,6 +2668,13 @@ class Maybe(ta.Generic[T]):
         else:
             return other
 
+    @ta.final
+    def or_none(self) -> ta.Optional[T]:
+        if self.present:
+            return self.must()
+        else:
+            return None
+
     @ta.final
     def or_else_get(self, supplier: ta.Callable[[], ta.Union[T, U]]) -> ta.Union[T, U]:
         if self.present:

omdev/scripts/lib/inject.py

@@ -34,7 +34,7 @@ def __omlish_amalg__():  # noqa
             dict(path='abstract.py', sha1='a2fc3f3697fa8de5247761e9d554e70176f37aac'),
             dict(path='check.py', sha1='bb6b6b63333699b84462951a854d99ae83195b94'),
             dict(path='reflect.py', sha1='c4fec44bf144e9d93293c996af06f6c65fc5e63d'),
-            dict(path='maybes.py', sha1='bdf5136654ccd14b6a072588cad228925bdfbabd'),
+            dict(path='maybes.py', sha1='04d2fcbea17028a5e6b8e7a7fb742375495ed233'),
             dict(path='inject.py', sha1='6f097e3170019a34ff6834d36fcc9cbeed3a7ab4'),
         ],
     )
@@ -884,6 +884,13 @@ class Maybe(ta.Generic[T]):
         else:
             return other
 
+    @ta.final
+    def or_none(self) -> ta.Optional[T]:
+        if self.present:
+            return self.must()
+        else:
+            return None
+
     @ta.final
     def or_else_get(self, supplier: ta.Callable[[], ta.Union[T, U]]) -> ta.Union[T, U]:
         if self.present: