omextra 0.0.0.dev437__py3-none-any.whl → 0.0.0.dev439__py3-none-any.whl

omextra/text/antlr/_runtime/tree/Trees.py

@@ -0,0 +1,114 @@
+# type: ignore
+# ruff: noqa
+# flake8: noqa
+#
+# Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
+# Use of this file is governed by the BSD 3-clause license that
+# can be found in the LICENSE.txt file in the project root.
+#
+
+
+# A set of utility routines useful for all kinds of ANTLR trees.#
+from io import StringIO
+from ..Token import Token
+from ..Utils import escapeWhitespace
+from .Tree import RuleNode, ErrorNode, TerminalNode, Tree, ParseTree
+
+# need forward declaration
+Parser  = None
+
+class Trees(object):
+
+     # Print out a whole tree in LISP form. {@link #getNodeText} is used on the
+    #  node payloads to get the text for the nodes.  Detect
+    #  parse trees and extract data appropriately.
+    @classmethod
+    def toStringTree(cls, t:Tree, ruleNames:list=None, recog:Parser=None):
+        if recog is not None:
+            ruleNames = recog.ruleNames
+        s = escapeWhitespace(cls.getNodeText(t, ruleNames), False)
+        if t.getChildCount()==0:
+            return s
+        with StringIO() as buf:
+            buf.write("(")
+            buf.write(s)
+            buf.write(' ')
+            for i in range(0, t.getChildCount()):
+                if i > 0:
+                    buf.write(' ')
+                buf.write(cls.toStringTree(t.getChild(i), ruleNames))
+            buf.write(")")
+            return buf.getvalue()
+
+    @classmethod
+    def getNodeText(cls, t:Tree, ruleNames:list=None, recog:Parser=None):
+        if recog is not None:
+            ruleNames = recog.ruleNames
+        if ruleNames is not None:
+            if isinstance(t, RuleNode):
+                if t.getAltNumber()!=0: # should use ATN.INVALID_ALT_NUMBER but won't compile
+                    return ruleNames[t.getRuleIndex()]+":"+str(t.getAltNumber())
+                return ruleNames[t.getRuleIndex()]
+            elif isinstance( t, ErrorNode):
+                return str(t)
+            elif isinstance(t, TerminalNode):
+                if t.symbol is not None:
+                    return t.symbol.text
+        # no recog for rule names
+        payload = t.getPayload()
+        if isinstance(payload, Token ):
+            return payload.text
+        return str(t.getPayload())
+
+
+    # Return ordered list of all children of this node
+    @classmethod
+    def getChildren(cls, t:Tree):
+        return [ t.getChild(i) for i in range(0, t.getChildCount()) ]
+
+    # Return a list of all ancestors of this node.  The first node of
+    #  list is the root and the last is the parent of this node.
+    #
+    @classmethod
+    def getAncestors(cls, t:Tree):
+        ancestors = []
+        t = t.getParent()
+        while t is not None:
+            ancestors.insert(0, t) # insert at start
+            t = t.getParent()
+        return ancestors
+
+    @classmethod
+    def findAllTokenNodes(cls, t:ParseTree, ttype:int):
+        return cls.findAllNodes(t, ttype, True)
+
+    @classmethod
+    def findAllRuleNodes(cls, t:ParseTree, ruleIndex:int):
+        return cls.findAllNodes(t, ruleIndex, False)
+
+    @classmethod
+    def findAllNodes(cls, t:ParseTree, index:int, findTokens:bool):
+        nodes = []
+        cls._findAllNodes(t, index, findTokens, nodes)
+        return nodes
+
+    @classmethod
+    def _findAllNodes(cls, t:ParseTree, index:int, findTokens:bool, nodes:list):
+        from ..ParserRuleContext import ParserRuleContext
+        # check this node (the root) first
+        if findTokens and isinstance(t, TerminalNode):
+            if t.symbol.type==index:
+                nodes.append(t)
+        elif not findTokens and isinstance(t, ParserRuleContext):
+            if t.ruleIndex == index:
+                nodes.append(t)
+        # check children
+        for i in range(0, t.getChildCount()):
+            cls._findAllNodes(t.getChild(i), index, findTokens, nodes)
+
+    @classmethod
+    def descendants(cls, t:ParseTree):
+        nodes = [t]
+        for i in range(0, t.getChildCount()):
+            nodes.extend(cls.descendants(t.getChild(i)))
+        return nodes

omextra/text/antlr/_runtime/tree/__init__.py

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

omextra/text/antlr/_runtime/xpath/XPath.py

@@ -0,0 +1,278 @@
+# type: ignore
+# ruff: noqa
+# flake8: noqa
+#
+# Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
+# Use of this file is governed by the BSD 3-clause license that
+# can be found in the LICENSE.txt file in the project root.
+#
+
+#
+# Represent a subset of XPath XML path syntax for use in identifying nodes in
+# parse trees.
+#
+# <p>
+# Split path into words and separators {@code /} and {@code //} via ANTLR
+# itself then walk path elements from left to right. At each separator-word
+# pair, find set of nodes. Next stage uses those as work list.</p>
+#
+# <p>
+# The basic interface is
+# {@link XPath#findAll ParseTree.findAll}{@code (tree, pathString, parser)}.
+# But that is just shorthand for:</p>
+#
+# <pre>
+# {@link XPath} p = new {@link XPath#XPath XPath}(parser, pathString);
+# return p.{@link #evaluate evaluate}(tree);
+# </pre>
+#
+# <p>
+# See {@code org.antlr.v4.test.TestXPath} for descriptions. In short, this
+# allows operators:</p>
+#
+# <dl>
+# <dt>/</dt> <dd>root</dd>
+# <dt>//</dt> <dd>anywhere</dd>
+# <dt>!</dt> <dd>invert; this must appear directly after root or anywhere
+# operator</dd>
+# </dl>
+#
+# <p>
+# and path elements:</p>
+#
+# <dl>
+# <dt>ID</dt> <dd>token name</dd>
+# <dt>'string'</dt> <dd>any string literal token from the grammar</dd>
+# <dt>expr</dt> <dd>rule name</dd>
+# <dt>*</dt> <dd>wildcard matching any node</dd>
+# </dl>
+#
+# <p>
+# Whitespace is not allowed.</p>
+#
+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
+from ..Token import Token
+from ..atn.ATNDeserializer import ATNDeserializer
+from ..error.ErrorListener import ErrorListener
+from ..error.Errors import LexerNoViableAltException
+from ..tree.Tree import ParseTree
+from ..tree.Trees import Trees
+from io import StringIO
+from .XPathLexer import XPathLexer
+
+
+class XPath(object):
+
+    WILDCARD = "*" # word not operator/separator
+    NOT = "!" # word for invert operator
+
+    def __init__(self, parser:Parser, path:str):
+        self.parser = parser
+        self.path = path
+        self.elements = self.split(path)
+
+    def split(self, path:str):
+        input = InputStream(path)
+        lexer = XPathLexer(input)
+        def recover(self, e):
+            raise e
+        lexer.recover = recover
+        lexer.removeErrorListeners()
+        lexer.addErrorListener(ErrorListener()) # XPathErrorListener does no more
+        tokenStream = CommonTokenStream(lexer)
+        try:
+            tokenStream.fill()
+        except LexerNoViableAltException as e:
+            pos = lexer.column
+            msg = "Invalid tokens or characters at index %d in path '%s'" % (pos, path)
+            raise Exception(msg, e)
+
+        tokens = iter(tokenStream.tokens)
+        elements = list()
+        for el in tokens:
+            invert = False
+            anywhere = False
+            # Check for path separators, if none assume root
+            if el.type in [XPathLexer.ROOT, XPathLexer.ANYWHERE]:
+                anywhere = el.type == XPathLexer.ANYWHERE
+                next_el = next(tokens, None)
+                if not next_el:
+                    raise Exception('Missing element after %s' % el.getText())
+                else:
+                    el = next_el
+            # Check for bangs
+            if el.type == XPathLexer.BANG:
+                invert = True
+                next_el = next(tokens, None)
+                if not next_el:
+                    raise Exception('Missing element after %s' % el.getText())
+                else:
+                    el = next_el
+            # Add searched element
+            if el.type in [XPathLexer.TOKEN_REF, XPathLexer.RULE_REF, XPathLexer.WILDCARD, XPathLexer.STRING]:
+                element = self.getXPathElement(el, anywhere)
+                element.invert = invert
+                elements.append(element)
+            elif el.type==Token.EOF:
+                break
+            else:
+                raise Exception("Unknown path element %s" % lexer.symbolicNames[el.type])
+        return elements
+
+    #
+    # Convert word like {@code#} or {@code ID} or {@code expr} to a path
+    # element. {@code anywhere} is {@code true} if {@code //} precedes the
+    # word.
+    #
+    def getXPathElement(self, wordToken:Token, anywhere:bool):
+        if wordToken.type==Token.EOF:
+            raise Exception("Missing path element at end of path")
+
+        word = wordToken.text
+        if wordToken.type==XPathLexer.WILDCARD :
+            return XPathWildcardAnywhereElement() if anywhere else XPathWildcardElement()
+
+        elif wordToken.type in [XPathLexer.TOKEN_REF, XPathLexer.STRING]:
+            tsource = self.parser.getTokenStream().tokenSource
+
+            ttype = Token.INVALID_TYPE
+            if wordToken.type == XPathLexer.TOKEN_REF:
+                if word in tsource.ruleNames:
+                    ttype = tsource.ruleNames.index(word) + 1
+            else:
+                if word in tsource.literalNames:
+                    ttype = tsource.literalNames.index(word)
+
+            if ttype == Token.INVALID_TYPE:
+                raise Exception("%s at index %d isn't a valid token name" % (word, wordToken.tokenIndex))
+            return XPathTokenAnywhereElement(word, ttype) if anywhere else XPathTokenElement(word, ttype)
+
+        else:
+            ruleIndex = self.parser.ruleNames.index(word) if word in self.parser.ruleNames else -1
+
+            if ruleIndex == -1:
+                raise Exception("%s at index %d isn't a valid rule name" % (word, wordToken.tokenIndex))
+            return XPathRuleAnywhereElement(word, ruleIndex) if anywhere else XPathRuleElement(word, ruleIndex)
+
+
+    @staticmethod
+    def findAll(tree:ParseTree, xpath:str, parser:Parser):
+        p = XPath(parser, xpath)
+        return p.evaluate(tree)
+
+    #
+    # Return a list of all nodes starting at {@code t} as root that satisfy the
+    # path. The root {@code /} is relative to the node passed to
+    # {@link #evaluate}.
+    #
+    def evaluate(self, t:ParseTree):
+        dummyRoot = ParserRuleContext()
+        dummyRoot.children = [t] # don't set t's parent.
+
+        work = [dummyRoot]
+        for element in self.elements:
+            work_next = list()
+            for node in work:
+                if not isinstance(node, TerminalNode) and node.children:
+                    # only try to match next element if it has children
+                    # e.g., //func/*/stat might have a token node for which
+                    # we can't go looking for stat nodes.
+                    matching = element.evaluate(node)
+
+                    # See issue antlr#370 - Prevents XPath from returning the
+                    # same node multiple times
+                    matching = filter(lambda m: m not in work_next, matching)
+
+                    work_next.extend(matching)
+            work = work_next
+
+        return work
+
+
+class XPathElement(object):
+
+    def __init__(self, nodeName:str):
+        self.nodeName = nodeName
+        self.invert = False
+
+    def __str__(self):
+        return type(self).__name__ + "[" + ("!" if self.invert else "") + self.nodeName + "]"
+
+
+
+#
+# Either {@code ID} at start of path or {@code ...//ID} in middle of path.
+#
+class XPathRuleAnywhereElement(XPathElement):
+
+    def __init__(self, ruleName:str, ruleIndex:int):
+        super().__init__(ruleName)
+        self.ruleIndex = ruleIndex
+
+    def evaluate(self, t:ParseTree):
+        # return all ParserRuleContext descendants of t that match ruleIndex (or do not match if inverted)
+        return filter(lambda c: isinstance(c, ParserRuleContext) and (self.invert ^ (c.getRuleIndex() == self.ruleIndex)), Trees.descendants(t))
+
+class XPathRuleElement(XPathElement):
+
+    def __init__(self, ruleName:str, ruleIndex:int):
+        super().__init__(ruleName)
+        self.ruleIndex = ruleIndex
+
+    def evaluate(self, t:ParseTree):
+        # return all ParserRuleContext children of t that match ruleIndex (or do not match if inverted)
+        return filter(lambda c: isinstance(c, ParserRuleContext) and (self.invert ^ (c.getRuleIndex() == self.ruleIndex)), Trees.getChildren(t))
+
+class XPathTokenAnywhereElement(XPathElement):
+
+    def __init__(self, ruleName:str, tokenType:int):
+        super().__init__(ruleName)
+        self.tokenType = tokenType
+
+    def evaluate(self, t:ParseTree):
+        # return all TerminalNode descendants of t that match tokenType (or do not match if inverted)
+        return filter(lambda c: isinstance(c, TerminalNode) and (self.invert ^ (c.symbol.type == self.tokenType)), Trees.descendants(t))
+
+class XPathTokenElement(XPathElement):
+
+    def __init__(self, ruleName:str, tokenType:int):
+        super().__init__(ruleName)
+        self.tokenType = tokenType
+
+    def evaluate(self, t:ParseTree):
+        # return all TerminalNode children of t that match tokenType (or do not match if inverted)
+        return filter(lambda c: isinstance(c, TerminalNode) and (self.invert ^ (c.symbol.type == self.tokenType)), Trees.getChildren(t))
+
+
+class XPathWildcardAnywhereElement(XPathElement):
+
+    def __init__(self):
+        super().__init__(XPath.WILDCARD)
+
+    def evaluate(self, t:ParseTree):
+        if self.invert:
+            return list() # !* is weird but valid (empty)
+        else:
+            return Trees.descendants(t)
+
+
+class XPathWildcardElement(XPathElement):
+
+    def __init__(self):
+        super().__init__(XPath.WILDCARD)
+
+
+    def evaluate(self, t:ParseTree):
+        if self.invert:
+            return list() # !* is weird but valid (empty)
+        else:
+            return Trees.getChildren(t)

omextra/text/antlr/_runtime/xpath/XPathLexer.py

@@ -0,0 +1,98 @@
+# type: ignore
+# ruff: noqa
+# flake8: noqa
+# Generated from XPathLexer.g4 by ANTLR 4.11.2-SNAPSHOT
+from .._all import *
+from io import StringIO
+import sys
+if sys.version_info[1] > 5:
+    from typing import TextIO
+else:
+    from typing.io import TextIO
+
+
+def serializedATN():
+    return [
+        4,0,8,50,6,-1,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,4,2,5,7,5,2,
+        6,7,6,2,7,7,7,1,0,1,0,1,0,1,1,1,1,1,2,1,2,1,3,1,3,1,4,1,4,5,4,29,
+        8,4,10,4,12,4,32,9,4,1,4,1,4,1,5,1,5,3,5,38,8,5,1,6,1,6,1,7,1,7,
+        5,7,44,8,7,10,7,12,7,47,9,7,1,7,1,7,1,45,0,8,1,3,3,4,5,5,7,6,9,7,
+        11,0,13,0,15,8,1,0,2,5,0,48,57,95,95,183,183,768,879,8255,8256,13,
+        0,65,90,97,122,192,214,216,246,248,767,880,893,895,8191,8204,8205,
+        8304,8591,11264,12271,12289,55295,63744,64975,65008,65533,50,0,1,
+        1,0,0,0,0,3,1,0,0,0,0,5,1,0,0,0,0,7,1,0,0,0,0,9,1,0,0,0,0,15,1,0,
+        0,0,1,17,1,0,0,0,3,20,1,0,0,0,5,22,1,0,0,0,7,24,1,0,0,0,9,26,1,0,
+        0,0,11,37,1,0,0,0,13,39,1,0,0,0,15,41,1,0,0,0,17,18,5,47,0,0,18,
+        19,5,47,0,0,19,2,1,0,0,0,20,21,5,47,0,0,21,4,1,0,0,0,22,23,5,42,
+        0,0,23,6,1,0,0,0,24,25,5,33,0,0,25,8,1,0,0,0,26,30,3,13,6,0,27,29,
+        3,11,5,0,28,27,1,0,0,0,29,32,1,0,0,0,30,28,1,0,0,0,30,31,1,0,0,0,
+        31,33,1,0,0,0,32,30,1,0,0,0,33,34,6,4,0,0,34,10,1,0,0,0,35,38,3,
+        13,6,0,36,38,7,0,0,0,37,35,1,0,0,0,37,36,1,0,0,0,38,12,1,0,0,0,39,
+        40,7,1,0,0,40,14,1,0,0,0,41,45,5,39,0,0,42,44,9,0,0,0,43,42,1,0,
+        0,0,44,47,1,0,0,0,45,46,1,0,0,0,45,43,1,0,0,0,46,48,1,0,0,0,47,45,
+        1,0,0,0,48,49,5,39,0,0,49,16,1,0,0,0,4,0,30,37,45,1,1,4,0
+    ]
+
+class XPathLexer(Lexer):
+
+    atn = ATNDeserializer().deserialize(serializedATN())
+
+    decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ]
+
+    TOKEN_REF = 1
+    RULE_REF = 2
+    ANYWHERE = 3
+    ROOT = 4
+    WILDCARD = 5
+    BANG = 6
+    ID = 7
+    STRING = 8
+
+    channelNames = [ u"DEFAULT_TOKEN_CHANNEL", u"HIDDEN" ]
+
+    modeNames = [ "DEFAULT_MODE" ]
+
+    literalNames = [ "<INVALID>",
+            "'//'", "'/'", "'*'", "'!'" ]
+
+    symbolicNames = [ "<INVALID>",
+            "TOKEN_REF", "RULE_REF", "ANYWHERE", "ROOT", "WILDCARD", "BANG", 
+            "ID", "STRING" ]
+
+    ruleNames = [ "ANYWHERE", "ROOT", "WILDCARD", "BANG", "ID", "NameChar", 
+                  "NameStartChar", "STRING" ]
+
+    grammarFileName = "XPathLexer.g4"
+
+    def __init__(self, input=None, output:TextIO = sys.stdout):
+        super().__init__(input, output)
+        self.checkVersion("4.11.2-SNAPSHOT")
+        self._interp = LexerATNSimulator(self, self.atn, self.decisionsToDFA, PredictionContextCache())
+        self._actions = None
+        self._predicates = None
+
+
+    def action(self, localctx:RuleContext, ruleIndex:int, actionIndex:int):
+        if self._actions is None:
+            actions = dict()
+            actions[4] = self.ID_action 
+            self._actions = actions
+        action = self._actions.get(ruleIndex, None)
+        if action is not None:
+            action(localctx, actionIndex)
+        else:
+            raise Exception("No registered action for:" + str(ruleIndex))
+
+
+    def ID_action(self, localctx:RuleContext , actionIndex:int):
+        if actionIndex == 0:
+
+                            char = self.text[0]
+                            if char.isupper():
+                                self.type = XPathLexer.TOKEN_REF
+                            else:
+                                self.type = XPathLexer.RULE_REF
+            				
+     
+
+

omextra/text/antlr/_runtime/xpath/__init__.py

@@ -0,0 +1,4 @@
+# type: ignore
+# ruff: noqa
+# flake8: noqa
+__author__ = 'ericvergnaud'

omextra/text/antlr/cli/consts.py

@@ -4,4 +4,4 @@ ANTLR_JAR_URL = f'https://www.antlr.org/download/{ANTLR_JAR_NAME}'
 ANTLR_RUNTIME_PACKAGE = 'antlr4-python3-runtime'
 ANTLR_GITHUB_REPO = 'antlr/antlr4'
 
-ANTLR_RUNTIME_VENDOR = 'omlish.text.antlr._runtime._all'
+ANTLR_RUNTIME_VENDOR = 'omextra.text.antlr._runtime._all'

omextra/text/antlr/delimit.py

@@ -0,0 +1,110 @@
+# ruff: noqa: N802 N815
+import io
+import typing as ta
+
+from omlish 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

omextra/text/antlr/dot.py

@@ -0,0 +1,42 @@
+import typing as ta
+
+from omlish.graphs import dot
+
+from . import runtime as antlr4
+from .utils import yield_contexts
+
+
+##
+
+
+def dot_ctx(
+        root: antlr4.ParserRuleContext,
+        *,
+        left_to_right: bool = False,
+) -> dot.Graph:
+    stmts: list[dot.Stmt] = []
+
+    if left_to_right:
+        stmts.append(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, **kwargs: ta.Any) -> None:
+    dot.open_dot(dot.render(dot_ctx(root)), **kwargs)

omextra/text/antlr/errors.py

@@ -0,0 +1,14 @@
+# 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)