omlish 0.0.0.dev169__tar.gz → 0.0.0.dev171__tar.gz

{omlish-0.0.0.dev169/omlish.egg-info → omlish-0.0.0.dev171}/PKG-INFO

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

{omlish-0.0.0.dev169 → omlish-0.0.0.dev171}/omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev169'
-__revision__ = 'ad8bd22d9c1cd7a5a22af3b9d27906ce64fd8451'
+__version__ = '0.0.0.dev171'
+__revision__ = '6786ad234e8dbeece3f1696fe7170f730b9ab11e'
 
 
 #

{omlish-0.0.0.dev169 → omlish-0.0.0.dev171}/omlish/antlr/_runtime/atn/ParserATNSimulator.py

@@ -235,7 +235,7 @@
 # the input.</p>
 #
 import sys
-from .. import DFA
+from ..dfa.DFA import DFA
 from ..BufferedTokenStream import TokenStream
 from ..Parser import Parser
 from ..ParserRuleContext import ParserRuleContext

{omlish-0.0.0.dev169 → omlish-0.0.0.dev171}/omlish/antlr/_runtime/dfa/DFASerializer.py

@@ -9,7 +9,7 @@
 
 # A DFA walker that knows how to dump them to serialized strings.#/
 from io import StringIO
-from .. import DFA
+from ..dfa.DFA import DFA
 from ..Utils import str_list
 from .DFAState import DFAState
 

{omlish-0.0.0.dev169 → omlish-0.0.0.dev171}/omlish/antlr/_runtime/error/DiagnosticErrorListener.py

@@ -28,7 +28,8 @@
 # </ul>
 
 from io import StringIO
-from .. import Parser, DFA
+from ..Parser import Parser
+from ..dfa.DFA import DFA
 from ..atn.ATNConfigSet import ATNConfigSet
 from .ErrorListener import ErrorListener
 

omlish-0.0.0.dev171/omlish/antlr/_runtime/tree/__init__.py

@@ -0,0 +1,2 @@
+# ruff: noqa
+# flake8: noqa

{omlish-0.0.0.dev169 → omlish-0.0.0.dev171}/omlish/antlr/_runtime/xpath/XPath.py

@@ -50,7 +50,13 @@
 # <p>
 # Whitespace is not allowed.</p>
 #
-from .. import CommonTokenStream, DFA, PredictionContextCache, Lexer, LexerATNSimulator, ParserRuleContext, TerminalNode
+from ..CommonTokenStream import CommonTokenStream
+from ..dfa.DFA import DFA
+from ..PredictionContext import PredictionContextCache
+from ..Lexer import Lexer
+from ..atn.LexerATNSimulator import LexerATNSimulator
+from ..ParserRuleContext import ParserRuleContext
+from ..tree.Tree import TerminalNode
 from ..InputStream import InputStream
 from ..Parser import Parser
 from ..RuleContext import RuleContext

{omlish-0.0.0.dev169 → omlish-0.0.0.dev171}/omlish/antlr/_runtime/xpath/XPathLexer.py

@@ -2,7 +2,7 @@
 # ruff: noqa
 # flake8: noqa
 # Generated from XPathLexer.g4 by ANTLR 4.11.2-SNAPSHOT
-from .. import *
+from .._all import *
 from io import StringIO
 import sys
 if sys.version_info[1] > 5:

omlish-0.0.0.dev171/omlish/antlr/delimit.py

@@ -0,0 +1,106 @@
+# ruff: noqa: N802 N815
+import io
+import typing as ta
+
+from .. import check
+from . import runtime as antlr4
+
+
+class DelimitingLexer(antlr4.Lexer):
+    def __init__(
+            self,
+            *args: ta.Any,
+            delimiter_token: ta.Any,
+            delimiters: ta.Iterable[str],
+            no_skip: bool = False,
+            **kwargs,
+    ) -> None:
+        super().__init__(*args, **kwargs)
+
+        self._delimiter_token = delimiter_token
+        self._delimiters = set(check.not_isinstance(delimiters, str))
+        self._no_skip = no_skip
+
+    _hitEOF: bool
+
+    def nextToken(self) -> antlr4.Token:
+        if self._input is None:
+            raise antlr4.IllegalStateException('nextToken requires a non-null input stream.')
+
+        token_start_marker = self._input.mark()
+        try:
+            while True:
+                if self._hitEOF:
+                    self.emitEOF()
+                    return self._token
+
+                self._token: antlr4.Token | None = None
+                self._channel = antlr4.Token.DEFAULT_CHANNEL
+                self._tokenStartCharIndex = self._input.index
+                self._tokenStartColumn = self._interp.column
+                self._tokenStartLine = self._interp.line
+                self._text = None
+
+                continue_outer = False
+                while True:
+                    self._type = antlr4.Token.INVALID_TYPE
+                    ttype = self.SKIP
+
+                    for delimiter in self._delimiters:
+                        if self._match_delimiter(delimiter):
+                            ttype = self._delimiter_token
+                            break
+                    else:
+                        try:
+                            ttype = self._interp.match(self._input, self._mode)
+                        except antlr4.LexerNoViableAltException as e:
+                            self.notifyListeners(e)  # report error
+                            self.recover(e)
+
+                    if self._input.LA(1) == antlr4.Token.EOF:
+                        self._hitEOF = True
+
+                    if self._type == antlr4.Token.INVALID_TYPE:
+                        self._type = ttype
+
+                    if not self._no_skip and self._type == self.SKIP:
+                        continue_outer = True
+                        break
+
+                    if self._type != self.MORE:
+                        break
+
+                if continue_outer:
+                    continue
+
+                if self._token is None:
+                    self.emit()
+
+                return self._token
+
+        finally:
+            self._input.release(token_start_marker)
+
+    def _match_delimiter(self, delimiter: str) -> bool:
+        for i, c in enumerate(delimiter):
+            if chr(self._input.LA(i + 1)) != c:
+                return False
+        self._input.seek(self._input.index + len(delimiter))
+        return True
+
+    def split(self) -> tuple[list[tuple[str, str]], str]:
+        lst = []
+        sb = io.StringIO()
+        while True:
+            token = self.nextToken()
+            if token.type == antlr4.Token.EOF:
+                break
+            if token.type == self._delimiter_token:
+                statement = sb.getvalue().strip()
+                if statement:
+                    lst.append((statement, token.text))
+                sb = io.StringIO()
+            else:
+                sb.write(token.text)
+        partial = sb.getvalue()
+        return lst, partial

omlish-0.0.0.dev171/omlish/antlr/dot.py

@@ -0,0 +1,31 @@
+from ..graphs import dot
+from . import runtime as antlr4
+from .utils import yield_contexts
+
+
+def dot_ctx(root: antlr4.ParserRuleContext) -> dot.Graph:
+    stmts: list[dot.Stmt] = [
+        dot.RawStmt('rankdir=LR;'),
+    ]
+
+    for c in yield_contexts(root):
+        if isinstance(c, antlr4.TerminalNode):
+            continue
+
+        lbl = [
+            [type(c).__name__],
+            [str(id(c))],
+            [f'{c.start} {c.stop}'],
+        ]
+
+        stmts.append(dot.Node(f'_{id(c)}', {'label': lbl, 'shape': 'box'}))
+
+        for n in (c.children or []):
+            if not isinstance(n, antlr4.TerminalNode):
+                stmts.append(dot.Edge(f'_{id(c)}', f'_{id(n)}'))
+
+    return dot.Graph(stmts)
+
+
+def open_dot_ctx(root: antlr4.ParserRuleContext) -> None:
+    dot.open_dot(dot.render(dot_ctx(root)))

omlish-0.0.0.dev171/omlish/antlr/errors.py

@@ -0,0 +1,11 @@
+# ruff: noqa: N802 N803
+from . import runtime as antlr4
+
+
+class ParseError(Exception):
+    pass
+
+
+class SilentRaisingErrorListener(antlr4.ErrorListener):
+    def syntaxError(self, recognizer, offendingSymbol, line, column, msg, e):
+        raise ParseError(recognizer, offendingSymbol, line, column, msg, e)

omlish-0.0.0.dev171/omlish/antlr/input.py

@@ -0,0 +1,96 @@
+# ruff: noqa: N802
+import typing as ta
+
+
+##
+
+
+# class InputStream(ta.Protocol):
+#
+#   @property
+#   def index(self) -> int: ...
+#
+#   @property
+#   def size(self) -> int: ...
+#
+#   # Reset the stream so that it's in the same state it was when the object was created *except* the data array is not
+#   # touched.
+#   def reset(self) -> None: ...
+#
+#   def consume(self) -> None: ...
+#
+#   def LA(self, offset: int) -> int: ...
+#
+#   def LT(self, offset: int) -> int: ...
+#
+#   def mark(self) -> int: ...
+#
+#   def release(self, marker: int) -> None: ...
+#
+#   # consume() ahead until p==_index; can't just set p=_index as we must update line and column. If we seek backwards,
+#   # just set p
+#   def seek(self, _index: int) -> None: ...
+#
+#   def getText(self, start: int, stop: int) -> str: ...
+#
+#   def __str__(self) -> str: ...
+
+
+InputStream: ta.TypeAlias = ta.Any
+
+
+##
+
+
+# @lang.protocol_check(InputStream)
+class ProxyInputStream:
+    def __init__(self, target: InputStream) -> None:
+        super().__init__()
+
+        self._target = target
+
+    @property
+    def index(self) -> int:
+        return self._target.index
+
+    @property
+    def size(self) -> int:
+        return self._target.size
+
+    def reset(self) -> None:
+        self._target.reset()
+
+    def consume(self) -> None:
+        self._target.consume()
+
+    def LA(self, offset: int) -> int:
+        return self._target.LA(offset)
+
+    def LT(self, offset: int) -> int:
+        return self._target.LT(offset)
+
+    def mark(self) -> int:
+        return self._target.mark()
+
+    def release(self, marker: int) -> None:
+        return self._target.release(marker)
+
+    def seek(self, _index: int) -> None:
+        return self._target.seek(_index)
+
+    def getText(self, start: int, stop: int) -> str:
+        return self._target.getText(start, stop)
+
+    def __str__(self) -> str:
+        return str(self._target)
+
+
+##
+
+
+class CaseInsensitiveInputStream(ProxyInputStream):
+    def LA(self, offset: int) -> int:
+        ret = super().LA(offset)
+        if ret != -1:
+            ret = ord(chr(ret).upper())
+        return ret

omlish-0.0.0.dev171/omlish/antlr/parsing.py

@@ -0,0 +1,19 @@
+# ruff: noqa: N802 N803
+import typing as ta
+
+from . import runtime as antlr4
+
+
+LexerT = ta.TypeVar('LexerT', bound=antlr4.Lexer)
+ParserT = ta.TypeVar('ParserT', bound=antlr4.Parser)
+
+
+def parse(
+        buf: str,
+        lexer_cls: type[LexerT],
+        parser_cls: type[ParserT],
+) -> ParserT:
+    lexer = lexer_cls(antlr4.InputStream(buf))
+    stream = antlr4.CommonTokenStream(lexer)
+    stream.fill()
+    return parser_cls(stream)

omlish-0.0.0.dev171/omlish/antlr/runtime.py

@@ -0,0 +1,102 @@
+# ruff: noqa: I001
+# flake8: noqa: F401
+
+from ._runtime.BufferedTokenStream import (  # type: ignore
+    TokenStream,
+)
+
+from ._runtime.CommonTokenStream import (  # type: ignore
+    CommonTokenStream,
+)
+
+from ._runtime.FileStream import (  # type: ignore
+    FileStream,
+)
+
+from ._runtime.InputStream import (  # type: ignore
+    InputStream,
+)
+
+from ._runtime.Lexer import (  # type: ignore
+    Lexer,
+)
+
+from ._runtime.Parser import (  # type: ignore
+    Parser,
+)
+
+from ._runtime.ParserRuleContext import (  # type: ignore
+    ParserRuleContext,
+    RuleContext,
+)
+
+from ._runtime.PredictionContext import (  # type: ignore
+    PredictionContextCache,
+)
+
+from ._runtime.StdinStream import (  # type: ignore
+    StdinStream,
+)
+
+from ._runtime.Token import (  # type: ignore
+    Token,
+)
+
+from ._runtime.Utils import (  # type: ignore
+    str_list,
+)
+
+from ._runtime.atn.ATN import (  # type: ignore
+    ATN,
+)
+
+from ._runtime.atn.ATNDeserializer import (  # type: ignore
+    ATNDeserializer,
+)
+
+from ._runtime.atn.LexerATNSimulator import (  # type: ignore
+    LexerATNSimulator,
+)
+
+from ._runtime.atn.ParserATNSimulator import (  # type: ignore
+    ParserATNSimulator,
+)
+
+from ._runtime.atn.PredictionMode import (  # type: ignore
+    PredictionMode,
+)
+
+from ._runtime.dfa.DFA import (  # type: ignore
+    DFA,
+)
+
+from ._runtime.error.DiagnosticErrorListener import (  # type: ignore
+    DiagnosticErrorListener,
+)
+
+from ._runtime.error.ErrorListener import (  # type: ignore
+    ErrorListener,
+)
+
+from ._runtime.error.ErrorStrategy import (  # type: ignore
+    BailErrorStrategy,
+)
+
+from ._runtime.error.Errors import (  # type: ignore
+    LexerNoViableAltException,
+)
+
+from ._runtime.error.Errors import (  # type: ignore
+    IllegalStateException,
+    NoViableAltException,
+    RecognitionException,
+)
+
+from ._runtime.tree.Tree import (  # type: ignore
+    ErrorNode,
+    ParseTreeListener,
+    ParseTreeVisitor,
+    ParseTreeWalker,
+    RuleNode,
+    TerminalNode,
+)

omlish-0.0.0.dev171/omlish/antlr/utils.py

@@ -0,0 +1,38 @@
+# ruff: noqa: N802 N803
+import io
+import typing as ta
+
+from . import runtime as antlr4
+
+
+##
+
+
+def pformat(
+        node: ta.Any,
+        *,
+        buf: ta.IO | None = None,
+        indent: str = '',
+        child_indent: str = '  ',
+) -> ta.IO:
+    if buf is None:
+        buf = io.StringIO()
+    buf.write(indent)
+    buf.write(node.__class__.__name__)
+    if hasattr(node, 'start') and hasattr(node, 'stop'):
+        buf.write(f' ({node.start} -> {node.stop})')
+    buf.write('\n')
+    for child in getattr(node, 'children', []) or []:
+        pformat(child, buf=buf, indent=indent + child_indent, child_indent=child_indent)
+    return buf
+
+
+def yield_contexts(
+        root: antlr4.ParserRuleContext,
+) -> ta.Iterator[antlr4.ParserRuleContext]:
+    q = [root]
+    while q:
+        c = q.pop()
+        yield c
+        if not isinstance(c, antlr4.TerminalNode) and c.children:
+            q.extend(c.children)

{omlish-0.0.0.dev169 → omlish-0.0.0.dev171}/omlish/lite/dataclasses.py

@@ -2,7 +2,7 @@
 import dataclasses as dc
 
 
-def cache_dataclass_hash(
+def dataclass_cache_hash(
         *,
         cached_hash_attr: str = '__dataclass_hash__',
 ):

omlish-0.0.0.dev171/omlish/lite/shlex.py

@@ -0,0 +1,12 @@
+import shlex
+
+
+def shlex_needs_quote(s: str) -> bool:
+    return bool(s) and len(list(shlex.shlex(s))) > 1
+
+
+def shlex_maybe_quote(s: str) -> str:
+    if shlex_needs_quote(s):
+        return shlex.quote(s)
+    else:
+        return s

{omlish-0.0.0.dev169 → omlish-0.0.0.dev171/omlish.egg-info}/PKG-INFO

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

{omlish-0.0.0.dev169 → omlish-0.0.0.dev171}/omlish.egg-info/SOURCES.txt

@@ -24,6 +24,13 @@ omlish.egg-info/entry_points.txt
 omlish.egg-info/requires.txt
 omlish.egg-info/top_level.txt
 omlish/antlr/__init__.py
+omlish/antlr/delimit.py
+omlish/antlr/dot.py
+omlish/antlr/errors.py
+omlish/antlr/input.py
+omlish/antlr/parsing.py
+omlish/antlr/runtime.py
+omlish/antlr/utils.py
 omlish/antlr/_runtime/BufferedTokenStream.py
 omlish/antlr/_runtime/CommonTokenFactory.py
 omlish/antlr/_runtime/CommonTokenStream.py
@@ -45,6 +52,7 @@ omlish/antlr/_runtime/Token.py
 omlish/antlr/_runtime/TokenStreamRewriter.py
 omlish/antlr/_runtime/Utils.py
 omlish/antlr/_runtime/__init__.py
+omlish/antlr/_runtime/_all.py
 omlish/antlr/_runtime/_pygrun.py
 omlish/antlr/_runtime/atn/ATN.py
 omlish/antlr/_runtime/atn/ATNConfig.py
@@ -390,6 +398,7 @@ omlish/lite/reflect.py
 omlish/lite/resources.py
 omlish/lite/runtime.py
 omlish/lite/secrets.py
+omlish/lite/shlex.py
 omlish/lite/socket.py
 omlish/lite/socketserver.py
 omlish/lite/strings.py

{omlish-0.0.0.dev169 → omlish-0.0.0.dev171}/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.dev169'
+version = '0.0.0.dev171'
 classifiers = [
     'License :: OSI Approved :: BSD License',
     'Development Status :: 2 - Pre-Alpha',

omlish-0.0.0.dev169/omlish/antlr/_runtime/__init__.py → omlish-0.0.0.dev171/omlish/antlr/_runtime/_all.py

@@ -1,6 +1,6 @@
-# type: ignore
 # ruff: noqa
 # flake8: noqa
+# type: ignore
 from .Token import Token
 from .InputStream import InputStream
 from .FileStream import FileStream