omextra 0.0.0.dev423__py3-none-any.whl → 0.0.0.dev425__py3-none-any.whl

omextra/.omlish-manifests.json

@@ -0,0 +1,14 @@
+[
+  {
+    "module": ".text.antlr.cli.__main__",
+    "attr": "_CLI_MODULE",
+    "file": "omextra/text/antlr/cli/__main__.py",
+    "line": 4,
+    "value": {
+      "!omdev.cli.types.CliModule": {
+        "name": "antlr",
+        "module": "omextra.text.antlr.cli.__main__"
+      }
+    }
+  }
+]

omextra/__about__.py

@@ -8,7 +8,9 @@ class Project(ProjectBase):
     description = 'omextra'
 
     dependencies = [
-        f'omdev == {__version__}',
+        # FIXME: text.antlr.cli deps omdev.cache.data, yet this lib is 'under' omdev.
+        # f'omdev == {__version__}',
+
         f'omlish == {__version__}',
     ]
 

omextra/defs.py

@@ -0,0 +1,216 @@
+"""
+A self-awarely unpythonic set of helpers for defining common boilerplate methods (repr, hash_eq, delegates, etc) in
+class definitions. Should be used sparingly for methods not directly used by humans (like repr) - @property's should
+remain @property's for type annotation, tool assistance, debugging, and otherwise, but these are still nice to have in
+certain circumstances (the real-world alternative usually being simply not adding them).
+"""
+# ruff: noqa: ANN201
+import abc
+import functools
+import operator
+import threading
+
+from omlish import lang
+
+
+##
+
+
+_repr = repr
+
+BASICS = {}
+
+
+def _basic(fn):
+    if fn.__name__ in BASICS:
+        raise NameError(fn.__name__)
+
+    BASICS[fn.__name__] = fn
+    return fn
+
+
+@lang.cls_dct_fn()
+def basic(cls_dct, *attrs, basics=None):
+    if basics is None:
+        basics = BASICS.keys()
+
+    for k in basics:
+        fn = BASICS[k]
+        fn(*attrs, cls_dct=cls_dct)
+
+
+_REPR_SEEN = threading.local()
+
+
+def _repr_guard(fn):
+    @functools.wraps(fn)
+    def inner(obj, *args, **kwargs):
+        try:
+            ids = _REPR_SEEN.ids
+
+        except AttributeError:
+            ids = _REPR_SEEN.ids = set()
+            try:
+                ids.add(id(obj))
+                return fn(obj, *args, **kwargs)
+            finally:
+                del _REPR_SEEN.ids
+
+        else:
+            if id(obj) in ids:
+                return f'<seen:{type(obj).__name__}@{hex(id(obj))[2:]}>'
+            ids.add(id(obj))
+            return fn(obj, *args, **kwargs)
+
+    return inner
+
+
+@_repr_guard
+def build_attr_repr(obj, *, mro=False):
+    if mro:
+        attrs = [
+            attr
+            for ty in sorted(  # noqa
+                reversed(type(obj).__mro__),
+                key=lambda _ty: _ty.__dict__.get('__repr_priority__', 0),
+            )
+            for attr in ty.__dict__.get('__repr_attrs__', [])
+        ]
+
+    else:
+        attrs = obj.__repr_attrs__
+
+    s = ', '.join(f'{a}={"<self>" if v is obj else _repr(v)}' for a in attrs for v in [getattr(obj, a)])
+    return f'{type(obj).__name__}@{hex(id(obj))[2:]}({s})'
+
+
+@_repr_guard
+def build_repr(obj, *attrs):
+    return (
+        f'{type(obj).__name__}'
+        f'@{hex(id(obj))[2:]}'
+        f'({", ".join(f"{attr}={getattr(obj, attr)!r}" for attr in attrs)})'
+    )
+
+
+@_basic
+@lang.cls_dct_fn()
+def repr(cls_dct, *attrs, mro=False, priority=None):  # noqa
+    def __repr__(self):  # noqa
+        return build_attr_repr(self, mro=mro)
+
+    cls_dct['__repr_attrs__'] = attrs
+    if priority is not None:
+        cls_dct['__repr_priority__'] = priority
+
+    cls_dct['__repr__'] = __repr__
+
+
+@lang.cls_dct_fn()
+def bare_repr(cls_dct, *attrs):
+    def __repr__(self):  # noqa
+        return lang.attr_repr(self, *attrs)
+
+    cls_dct['__repr__'] = __repr__
+
+
+@lang.cls_dct_fn()
+def name_repr(cls_dct):
+    def __repr__(self):  # noqa
+        return self.__name__
+
+    cls_dct['__repr__'] = __repr__
+
+
+@lang.cls_dct_fn()
+def ne(cls_dct):
+    def __ne__(self, other):  # noqa
+        return not (self == other)
+
+    cls_dct['__ne__'] = __ne__
+
+
+@lang.cls_dct_fn()
+def no_order(cls_dct, *, raise_=None):
+    def fn(self, other):
+        if raise_ is None:
+            return NotImplemented
+        else:
+            raise raise_
+
+    for att in [
+        '__lt__',
+        '__le__',
+        '__gt__',
+        '__ge__',
+    ]:
+        cls_dct[att] = fn
+
+
+@_basic
+@lang.cls_dct_fn()
+def hash_eq(cls_dct, *attrs):
+    def __hash__(self):  # noqa
+        return hash(tuple(getattr(self, attr) for attr in attrs))
+
+    cls_dct['__hash__'] = __hash__
+
+    def __eq__(self, other):  # noqa
+        if type(other) is not type(self):
+            return False
+
+        for attr in attrs:  # noqa
+            if getattr(self, attr) != getattr(other, attr):
+                return False
+
+        return True
+
+    cls_dct['__eq__'] = __eq__
+
+    ne(cls_dct=cls_dct)
+
+
+@lang.cls_dct_fn()
+def getter(cls_dct, *attrs):
+    for attr in attrs:
+        cls_dct[attr] = property(operator.attrgetter('_' + attr))
+
+
+@lang.cls_dct_fn()
+def not_implemented(cls_dct, *names, **kwargs):
+    wrapper = kwargs.pop('wrapper', lambda _: _)
+    if kwargs:
+        raise TypeError(kwargs)
+
+    ret = []
+    for name in names:
+        @wrapper
+        def not_implemented(self, *args, **kwargs):
+            raise NotImplementedError
+
+        not_implemented.__name__ = name
+        cls_dct[name] = not_implemented
+        ret.append(not_implemented)
+
+    return tuple(ret)
+
+
+@lang.cls_dct_fn()
+def abstract_method(cls_dct, *names):
+    return not_implemented(cls_dct, *names, wrapper=abc.abstractmethod)
+
+
+@lang.cls_dct_fn()
+def abstract_property(cls_dct, *names):
+    return not_implemented(cls_dct, *names, wrapper=lambda o: property(abc.abstractmethod(o)))
+
+
+@lang.cls_dct_fn()
+def abstract_hash_eq(cls_dct):
+    return not_implemented(
+        cls_dct,
+        '__hash__',
+        '__eq__',
+        '__ne__',
+        wrapper=abc.abstractmethod,
+    )

omextra/dynamic.py

@@ -0,0 +1,219 @@
+"""
+Dynamically scoped variables (implemented by stackwalking). Unlike threadlocals these are generator-correct both in
+binding and retrieval, and unlike ContextVars they require no manual context management. They are however *slow* and
+should be used sparingly (once per sql statement executed not once per inner function call).
+
+TODO:
+ - clj-style binding conveyance
+ - contextvar/async interop
+ - 'partializer'
+"""
+import contextlib
+import functools
+import sys
+import types
+import typing as ta
+import weakref
+
+from omlish import lang
+
+
+T = ta.TypeVar('T')
+
+
+##
+
+
+_HOISTED_CODE_DEPTH: ta.MutableMapping[types.CodeType, int] = weakref.WeakKeyDictionary()
+_MAX_HOIST_DEPTH = 0
+
+
+def hoist(depth=0):  # noqa
+    def inner(fn):
+        _HOISTED_CODE_DEPTH[fn.__code__] = depth
+        global _MAX_HOIST_DEPTH
+        _MAX_HOIST_DEPTH = max(_MAX_HOIST_DEPTH, depth)
+        return fn
+    return inner
+
+
+hoist()(contextlib.ExitStack.enter_context)  # noqa
+
+
+class MISSING(lang.Marker):
+    pass
+
+
+class UnboundVarError(ValueError):
+    pass
+
+
+class Var(ta.Generic[T]):
+    def __init__(
+            self,
+            default: type[MISSING] | T = MISSING,
+            *,
+            new: ta.Callable[[], T] | type[MISSING] = MISSING,
+            validate: ta.Callable[[T], None] | None = None,
+    ) -> None:
+        super().__init__()
+
+        if default is not MISSING and new is not MISSING:
+            raise TypeError('Cannot set both default and new')
+        elif default is not MISSING:
+            new = lambda: default  # type: ignore
+        self._new: type[MISSING] | ta.Callable[[], T] = new
+        self._validate = validate
+        self._bindings_by_frame: ta.MutableMapping[types.FrameType, ta.MutableMapping[int, Binding]] = weakref.WeakValueDictionary()  # noqa
+
+    @ta.overload
+    def __call__(self) -> T:
+        ...
+
+    @ta.overload
+    def __call__(self, value: T, **kwargs: ta.Any) -> ta.ContextManager[T]:
+        ...
+
+    def __call__(self, *args, **kwargs):
+        if not args:
+            if kwargs:
+                raise TypeError(kwargs)
+            return self.value
+        elif len(args) == 1:
+            return self.binding(*args, **kwargs)
+        else:
+            raise TypeError(args)
+
+    def binding(self, value: T, *, offset: int = 0) -> ta.ContextManager[T]:
+        if self._validate is not None:
+            self._validate(self.value)
+        return Binding(self, value, offset=offset)
+
+    def with_binding(self, value):  # noqa
+        def outer(fn):
+            @functools.wraps(fn)
+            def inner(*args, **kwargs):
+                with self.binding(value):
+                    return fn(*args, **kwargs)
+            return inner
+        return outer
+
+    def with_binding_fn(self, binding_fn):  # noqa
+        this = self
+
+        def outer(fn):
+            class Descriptor:
+                @staticmethod
+                @functools.wraps(fn)
+                def __call__(*args, **kwargs):  # noqa
+                    with this.binding(binding_fn(*args, **kwargs)):
+                        return fn(*args, **kwargs)
+
+                def __get__(self, obj, cls=None):
+                    bound_binding_fn = binding_fn.__get__(obj, cls)
+                    bound_fn = fn.__get__(obj, cls)
+
+                    @functools.wraps(fn)
+                    def inner(*args, **kwargs):
+                        with this.binding(bound_binding_fn(*args, **kwargs)):
+                            return bound_fn(*args, **kwargs)
+
+                    return inner
+
+            dct: dict[str, ta.Any] = {k: getattr(fn, k) for k in functools.WRAPPER_ASSIGNMENTS}
+            return lang.new_type(fn.__name__, (Descriptor,), dct)()
+
+        return outer
+
+    @property
+    def values(self) -> ta.Iterator[T]:
+        frame = sys._getframe().f_back  # noqa
+        while frame:
+            try:
+                frame_bindings = self._bindings_by_frame[frame]
+            except KeyError:
+                pass
+            else:
+                for level, frame_binding in sorted(frame_bindings.items()):  # noqa
+                    yield frame_binding._value  # noqa
+            frame = frame.f_back
+
+        if self._new is not MISSING:
+            yield self._new()  # type: ignore
+
+    def __iter__(self) -> ta.Iterator[T]:
+        return self.values
+
+    @property
+    def value(self) -> T:
+        try:
+            return next(self.values)
+        except StopIteration:
+            raise UnboundVarError from None
+
+
+class Binding(ta.Generic[T]):
+    _frame: types.FrameType
+    _frame_bindings: ta.MutableMapping[int, 'Binding']
+    _level: int
+
+    def __init__(self, var: Var[T], value: T, *, offset: int = 0) -> None:
+        super().__init__()
+
+        self._var = var
+        self._value = value
+        self._offset = offset
+
+    def __enter__(self) -> T:
+        frame = sys._getframe(self._offset).f_back  # noqa
+        lag_frame: types.FrameType | None = frame
+        while lag_frame is not None:
+            for cur_depth in range(_MAX_HOIST_DEPTH + 1):
+                if lag_frame is None:
+                    break
+                try:
+                    lag_hoist = _HOISTED_CODE_DEPTH[lag_frame.f_code]
+                except KeyError:
+                    pass
+                else:
+                    if lag_hoist >= cur_depth:
+                        frame = lag_frame = lag_frame.f_back
+                        break
+                lag_frame = lag_frame.f_back
+            else:
+                break
+
+        if frame is None:
+            raise RuntimeError
+        self._frame = frame
+        try:
+            self._frame_bindings = self._var._bindings_by_frame[self._frame]  # noqa
+        except KeyError:
+            self._frame_bindings = self._var._bindings_by_frame[self._frame] = weakref.WeakValueDictionary()  # noqa
+            self._level = 0
+        else:
+            self._level = min(self._frame_bindings.keys() or [1]) - 1
+
+        self._frame_bindings[self._level] = self
+        return self._value
+
+    def __exit__(self, et, e, tb):
+        if self._frame_bindings[self._level] is not self:
+            raise TypeError
+
+        del self._frame_bindings[self._level]
+        del self._frame_bindings
+        del self._frame
+
+
+class _GeneratorContextManager(contextlib._GeneratorContextManager):  # noqa
+    @hoist(2)
+    def __enter__(self):
+        return super().__enter__()
+
+
+def contextmanager(fn):  # noqa
+    @functools.wraps(fn)
+    def helper(*args, **kwds):
+        return _GeneratorContextManager(fn, args, kwds)
+    return helper  # noqa

omextra/formats/json/Json.g4

@@ -0,0 +1,77 @@
+// Taken from "The Definitive ANTLR 4 Reference" by Terence Parr
+
+// Derived from https://json.org
+
+// $antlr-format alignTrailingComments true, columnLimit 150, minEmptyLines 1, maxEmptyLinesToKeep 1, reflowComments false, useTab false
+// $antlr-format allowShortRulesOnASingleLine false, allowShortBlocksOnASingleLine true, alignSemicolons hanging, alignColons hanging
+
+grammar Json;
+
+json
+    : value EOF
+    ;
+
+obj
+    : '{' pair (',' pair)* '}'
+    | '{' '}'
+    ;
+
+pair
+    : STRING ':' value
+    ;
+
+arr
+    : '[' value (',' value)* ']'
+    | '[' ']'
+    ;
+
+value
+    : STRING
+    | NUMBER
+    | obj
+    | arr
+    | 'true'
+    | 'false'
+    | 'null'
+    ;
+
+// Lexer
+
+STRING
+    : '"' (ESC | SAFECODEPOINT)* '"'
+    ;
+
+fragment ESC
+    : '\\' (["\\/bfnrt] | UNICODE)
+    ;
+
+fragment UNICODE
+    : 'u' HEX HEX HEX HEX
+    ;
+
+fragment HEX
+    : [0-9a-fA-F]
+    ;
+
+fragment SAFECODEPOINT
+    : ~ ["\\\u0000-\u001F]
+    ;
+
+NUMBER
+    : '-'? INT ('.' [0-9]+)? EXP?
+    ;
+
+fragment INT
+    // integer part forbids leading 0s (e.g. `01`)
+    : '0'
+    | [1-9] [0-9]*
+    ;
+
+fragment EXP
+    // exponent number permits leading 0s (e.g. `1e01`)
+    : [Ee] [+-]? [0-9]+
+    ;
+
+WS
+    : [ \t\n\r]+ -> skip
+    ;

omextra/formats/json/_antlr/JsonLexer.py

@@ -0,0 +1,109 @@
+# type: ignore
+# ruff: noqa
+# flake8: noqa
+# @omlish-generated
+# Generated from Json.g4 by ANTLR 4.13.2
+from omlish.text.antlr._runtime._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,12,131,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,2,8,7,8,2,9,7,9,2,10,7,10,2,11,7,11,2,12,7,12,2,
+        13,7,13,2,14,7,14,2,15,7,15,2,16,7,16,2,17,7,17,1,0,1,0,1,1,1,1,
+        1,2,1,2,1,3,1,3,1,4,1,4,1,5,1,5,1,6,1,6,1,6,1,6,1,6,1,7,1,7,1,7,
+        1,7,1,7,1,7,1,8,1,8,1,8,1,8,1,8,1,9,1,9,1,9,5,9,69,8,9,10,9,12,9,
+        72,9,9,1,9,1,9,1,10,1,10,1,10,3,10,79,8,10,1,11,1,11,1,11,1,11,1,
+        11,1,11,1,12,1,12,1,13,1,13,1,14,3,14,92,8,14,1,14,1,14,1,14,4,14,
+        97,8,14,11,14,12,14,98,3,14,101,8,14,1,14,3,14,104,8,14,1,15,1,15,
+        1,15,5,15,109,8,15,10,15,12,15,112,9,15,3,15,114,8,15,1,16,1,16,
+        3,16,118,8,16,1,16,4,16,121,8,16,11,16,12,16,122,1,17,4,17,126,8,
+        17,11,17,12,17,127,1,17,1,17,0,0,18,1,1,3,2,5,3,7,4,9,5,11,6,13,
+        7,15,8,17,9,19,10,21,0,23,0,25,0,27,0,29,11,31,0,33,0,35,12,1,0,
+        8,8,0,34,34,47,47,92,92,98,98,102,102,110,110,114,114,116,116,3,
+        0,48,57,65,70,97,102,3,0,0,31,34,34,92,92,1,0,48,57,1,0,49,57,2,
+        0,69,69,101,101,2,0,43,43,45,45,3,0,9,10,13,13,32,32,136,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,11,1,0,0,0,
+        0,13,1,0,0,0,0,15,1,0,0,0,0,17,1,0,0,0,0,19,1,0,0,0,0,29,1,0,0,0,
+        0,35,1,0,0,0,1,37,1,0,0,0,3,39,1,0,0,0,5,41,1,0,0,0,7,43,1,0,0,0,
+        9,45,1,0,0,0,11,47,1,0,0,0,13,49,1,0,0,0,15,54,1,0,0,0,17,60,1,0,
+        0,0,19,65,1,0,0,0,21,75,1,0,0,0,23,80,1,0,0,0,25,86,1,0,0,0,27,88,
+        1,0,0,0,29,91,1,0,0,0,31,113,1,0,0,0,33,115,1,0,0,0,35,125,1,0,0,
+        0,37,38,5,123,0,0,38,2,1,0,0,0,39,40,5,44,0,0,40,4,1,0,0,0,41,42,
+        5,125,0,0,42,6,1,0,0,0,43,44,5,58,0,0,44,8,1,0,0,0,45,46,5,91,0,
+        0,46,10,1,0,0,0,47,48,5,93,0,0,48,12,1,0,0,0,49,50,5,116,0,0,50,
+        51,5,114,0,0,51,52,5,117,0,0,52,53,5,101,0,0,53,14,1,0,0,0,54,55,
+        5,102,0,0,55,56,5,97,0,0,56,57,5,108,0,0,57,58,5,115,0,0,58,59,5,
+        101,0,0,59,16,1,0,0,0,60,61,5,110,0,0,61,62,5,117,0,0,62,63,5,108,
+        0,0,63,64,5,108,0,0,64,18,1,0,0,0,65,70,5,34,0,0,66,69,3,21,10,0,
+        67,69,3,27,13,0,68,66,1,0,0,0,68,67,1,0,0,0,69,72,1,0,0,0,70,68,
+        1,0,0,0,70,71,1,0,0,0,71,73,1,0,0,0,72,70,1,0,0,0,73,74,5,34,0,0,
+        74,20,1,0,0,0,75,78,5,92,0,0,76,79,7,0,0,0,77,79,3,23,11,0,78,76,
+        1,0,0,0,78,77,1,0,0,0,79,22,1,0,0,0,80,81,5,117,0,0,81,82,3,25,12,
+        0,82,83,3,25,12,0,83,84,3,25,12,0,84,85,3,25,12,0,85,24,1,0,0,0,
+        86,87,7,1,0,0,87,26,1,0,0,0,88,89,8,2,0,0,89,28,1,0,0,0,90,92,5,
+        45,0,0,91,90,1,0,0,0,91,92,1,0,0,0,92,93,1,0,0,0,93,100,3,31,15,
+        0,94,96,5,46,0,0,95,97,7,3,0,0,96,95,1,0,0,0,97,98,1,0,0,0,98,96,
+        1,0,0,0,98,99,1,0,0,0,99,101,1,0,0,0,100,94,1,0,0,0,100,101,1,0,
+        0,0,101,103,1,0,0,0,102,104,3,33,16,0,103,102,1,0,0,0,103,104,1,
+        0,0,0,104,30,1,0,0,0,105,114,5,48,0,0,106,110,7,4,0,0,107,109,7,
+        3,0,0,108,107,1,0,0,0,109,112,1,0,0,0,110,108,1,0,0,0,110,111,1,
+        0,0,0,111,114,1,0,0,0,112,110,1,0,0,0,113,105,1,0,0,0,113,106,1,
+        0,0,0,114,32,1,0,0,0,115,117,7,5,0,0,116,118,7,6,0,0,117,116,1,0,
+        0,0,117,118,1,0,0,0,118,120,1,0,0,0,119,121,7,3,0,0,120,119,1,0,
+        0,0,121,122,1,0,0,0,122,120,1,0,0,0,122,123,1,0,0,0,123,34,1,0,0,
+        0,124,126,7,7,0,0,125,124,1,0,0,0,126,127,1,0,0,0,127,125,1,0,0,
+        0,127,128,1,0,0,0,128,129,1,0,0,0,129,130,6,17,0,0,130,36,1,0,0,
+        0,13,0,68,70,78,91,98,100,103,110,113,117,122,127,1,6,0,0
+    ]
+
+class JsonLexer(Lexer):
+
+    atn = ATNDeserializer().deserialize(serializedATN())
+
+    decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ]
+
+    T__0 = 1
+    T__1 = 2
+    T__2 = 3
+    T__3 = 4
+    T__4 = 5
+    T__5 = 6
+    T__6 = 7
+    T__7 = 8
+    T__8 = 9
+    STRING = 10
+    NUMBER = 11
+    WS = 12
+
+    channelNames = [ u"DEFAULT_TOKEN_CHANNEL", u"HIDDEN" ]
+
+    modeNames = [ "DEFAULT_MODE" ]
+
+    literalNames = [ "<INVALID>",
+            "'{'", "','", "'}'", "':'", "'['", "']'", "'true'", "'false'", 
+            "'null'" ]
+
+    symbolicNames = [ "<INVALID>",
+            "STRING", "NUMBER", "WS" ]
+
+    ruleNames = [ "T__0", "T__1", "T__2", "T__3", "T__4", "T__5", "T__6", 
+                  "T__7", "T__8", "STRING", "ESC", "UNICODE", "HEX", "SAFECODEPOINT", 
+                  "NUMBER", "INT", "EXP", "WS" ]
+
+    grammarFileName = "Json.g4"
+
+    def __init__(self, input=None, output:TextIO = sys.stdout):
+        super().__init__(input, output)
+        self.checkVersion("4.13.2")
+        self._interp = LexerATNSimulator(self, self.atn, self.decisionsToDFA, PredictionContextCache())
+        self._actions = None
+        self._predicates = None
+
+