omlish 0.0.0.dev57__py3-none-any.whl → 0.0.0.dev59__py3-none-any.whl

omlish/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

omlish/antlr/_runtime/tree/__init__.py

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

omlish/antlr/_runtime/xpath/XPath.py

@@ -0,0 +1,272 @@
+# 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 .. import CommonTokenStream, DFA, PredictionContextCache, Lexer, LexerATNSimulator, ParserRuleContext, 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)

omlish/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 .. 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
+            				
+     
+
+

omlish/antlr/_runtime/xpath/__init__.py

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

omlish/marshal/__init__.py

@@ -39,11 +39,6 @@ from .forbidden import (  # noqa
     ForbiddenTypeUnmarshalerFactory,
 )
 
-from .naming import (  # noqa
-    Naming,
-    translate_name,
-)
-
 from .global_ import (  # noqa
     GLOBAL_REGISTRY,
 
@@ -57,6 +52,16 @@ from .helpers import (  # noqa
     update_object_metadata,
 )
 
+from .naming import (  # noqa
+    Naming,
+    translate_name,
+)
+
+from .nop import (  # noqa
+    NOP_MARSHALER_UNMARSHALER,
+    NopMarshalerUnmarshaler,
+)
+
 from .objects import (  # noqa
     FieldInfo,
     FieldInfos,

omlish/marshal/nop.py

@@ -0,0 +1,18 @@
+import typing as ta
+
+from .base import MarshalContext
+from .base import Marshaler
+from .base import UnmarshalContext
+from .base import Unmarshaler
+from .values import Value
+
+
+class NopMarshalerUnmarshaler(Marshaler, Unmarshaler):
+    def marshal(self, ctx: MarshalContext, o: ta.Any) -> Value:
+        return o  # noqa
+
+    def unmarshal(self, ctx: UnmarshalContext, v: Value) -> ta.Any:
+        return v
+
+
+NOP_MARSHALER_UNMARSHALER = NopMarshalerUnmarshaler()

omlish/marshal/primitives.py

@@ -1,5 +1,10 @@
+"""
+TODO:
+ - field-configurable coercion
+"""
 import typing as ta
 
+from .. import dataclasses as dc
 from .base import MarshalContext
 from .base import Marshaler
 from .base import TypeMapMarshalerFactory
@@ -25,24 +30,29 @@ PRIMITIVE_TYPES: tuple[type, ...] = (
 ##
 
 
+@dc.dataclass(frozen=True)
 class PrimitiveMarshalerUnmarshaler(Marshaler, Unmarshaler):
+    ty: type
+
     def marshal(self, ctx: MarshalContext, o: ta.Any) -> Value:
-        if isinstance(o, PRIMITIVE_TYPES):
+        if isinstance(o, self.ty):
             return o  # type: ignore
+        if isinstance(o, PRIMITIVE_TYPES):
+            return self.ty(o)
         raise TypeError(o)
 
     def unmarshal(self, ctx: UnmarshalContext, v: Value) -> ta.Any:
-        if isinstance(v, PRIMITIVE_TYPES):
+        if isinstance(v, self.ty):
             return v
+        if isinstance(v, PRIMITIVE_TYPES):
+            return self.ty(v)
         raise TypeError(v)
 
 
-PRIMITIVE_MARSHALER_UNMARSHALER = PrimitiveMarshalerUnmarshaler()
-
 PRIMITIVE_MARSHALER_FACTORY = TypeMapMarshalerFactory({  # noqa
-    t: PRIMITIVE_MARSHALER_UNMARSHALER for t in PRIMITIVE_TYPES
+    t: PrimitiveMarshalerUnmarshaler(t) for t in PRIMITIVE_TYPES
 })
 
 PRIMITIVE_UNMARSHALER_FACTORY = TypeMapUnmarshalerFactory({  # noqa
-    t: PRIMITIVE_MARSHALER_UNMARSHALER for t in PRIMITIVE_TYPES
+    t: PrimitiveMarshalerUnmarshaler(t) for t in PRIMITIVE_TYPES
 })

{omlish-0.0.0.dev57.dist-info → omlish-0.0.0.dev59.dist-info}/METADATA

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