omlish 0.0.0.dev212__py3-none-any.whl → 0.0.0.dev214__py3-none-any.whl

omlish/asyncs/ioproxy/proxy.py

@@ -0,0 +1,141 @@
+# ruff: noqa: UP006 UP007
+import dataclasses as dc
+import functools
+import inspect
+import typing as ta
+
+from ...lite.check import check
+
+
+AsyncIoProxyRunner = ta.Callable[[ta.Callable], ta.Awaitable]  # ta.TypeAlias
+
+
+##
+
+
+_ASYNC_IO_PROXY_WRAPPER_NAME_ATTRS = ('__name__', '__qualname__')
+_ASYNC_IO_PROXY_WRAPPER_ASSIGNMENTS = tuple(
+    a
+    for a in functools.WRAPPER_ASSIGNMENTS
+    if a not in _ASYNC_IO_PROXY_WRAPPER_NAME_ATTRS
+)
+
+
+def async_io_proxy_fn(fn, runner, *, result_wrapper=None):
+    @functools.wraps(fn, assigned=_ASYNC_IO_PROXY_WRAPPER_ASSIGNMENTS)
+    async def run(*args, **kwargs):
+        ret = await runner(functools.partial(fn, *args, **kwargs))
+        if result_wrapper is not None:
+            ret = result_wrapper(ret)
+        return ret
+
+    for na in _ASYNC_IO_PROXY_WRAPPER_NAME_ATTRS:
+        setattr(run, na, f'{getattr(run, na)}:{getattr(fn, na)}')
+
+    return run
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class AsyncIoProxyTarget:
+    obj: ta.Any
+    runner: AsyncIoProxyRunner
+
+
+class AsyncIoProxy:
+    def __init__(self, target: AsyncIoProxyTarget) -> None:
+        super().__init__()
+
+        self._target = check.isinstance(target, AsyncIoProxyTarget)
+
+    #
+
+    class _Descriptor:
+        def __init__(self, name) -> None:
+            super().__init__()
+
+            self._name = name
+
+        def __get__(self, instance, owner=None):
+            if instance is None:
+                return self
+
+            target: AsyncIoProxyTarget = instance._target  # noqa
+            v = self._get(target, instance)
+
+            setattr(instance, self._name, v)
+            return v
+
+        def _get(self, target: AsyncIoProxyTarget, instance: ta.Any) -> ta.Any:
+            raise NotImplementedError
+
+    class _Property(_Descriptor):
+        def _get(self, target: AsyncIoProxyTarget, instance: ta.Any) -> ta.Any:
+            return getattr(target.obj, self._name)
+
+    class _Method(_Descriptor):
+        def __call__(self, instance, *args, **kwargs):
+            return self.__get__(instance)(*args, **kwargs)
+
+    class _SyncMethod(_Method):
+        def _get(self, target: AsyncIoProxyTarget, instance: ta.Any) -> ta.Any:
+            return getattr(target.obj, self._name)
+
+    class _AsyncMethod(_Method):
+        SPECIAL_METHOD_NAMES: ta.ClassVar[ta.Mapping[str, str]] = {
+            '__aenter__': '__enter__',
+            '__aexit__': '__exit__',
+        }
+
+        def _get(self, target: AsyncIoProxyTarget, instance: ta.Any) -> ta.Any:
+            fa = self.SPECIAL_METHOD_NAMES.get(self._name, self._name)
+            fn = getattr(target.obj, fa)
+            if fa == '__enter__':
+                result_wrapper = lambda _: instance
+            else:
+                result_wrapper = None
+            run = async_io_proxy_fn(fn, target.runner, result_wrapper=result_wrapper)
+            return run
+
+    #
+
+    __proxied_cls__: ta.ClassVar[type]
+
+    def __init_subclass__(cls, *, proxied_cls=None, **kwargs):  # noqa
+        super().__init_subclass__()
+
+        cls.__proxied_cls__ = check.isinstance(proxied_cls, (type, None))
+
+        for n, v in dict(cls.__dict__).items():
+            if n.startswith('_') and n not in cls._AsyncMethod.SPECIAL_METHOD_NAMES:
+                continue
+
+            if isinstance(v, property):
+                setattr(cls, n, cls._Property(n))
+
+            elif callable(v):
+                if inspect.iscoroutinefunction(v):
+                    setattr(cls, n, cls._AsyncMethod(n))
+                else:
+                    setattr(cls, n, cls._SyncMethod(n))
+
+            else:
+                raise TypeError(v)
+
+
+##
+
+
+@functools.singledispatch
+def async_io_proxy_cls_for(obj: ta.Any) -> ta.Optional[ta.Type[AsyncIoProxy]]:
+    return None
+
+
+def _register_async_io_proxy_cls(cls):
+    async_io_proxy_cls_for.register(
+        check.isinstance(cls.__dict__['__proxied_cls__'], type),
+        lambda obj: cls,
+    )
+    return cls

omlish/asyncs/ioproxy/typing.py

@@ -0,0 +1,108 @@
+# ruff: noqa: UP006 UP007
+import typing as ta
+
+from .proxy import AsyncIoProxy
+from .proxy import _register_async_io_proxy_cls
+
+
+SelfT = ta.TypeVar('SelfT')
+
+AnyStrT = ta.TypeVar('AnyStrT', bytes, str)
+
+
+##
+
+
+@_register_async_io_proxy_cls
+class TypingIO_AsyncIoProxy(AsyncIoProxy, ta.Generic[AnyStrT], proxied_cls=ta.IO):  # noqa
+    @property
+    def mode(self) -> str:
+        raise TypeError
+
+    @property
+    def name(self) -> str:
+        raise TypeError
+
+    async def close(self) -> None:
+        raise TypeError
+
+    @property
+    def closed(self) -> bool:
+        raise TypeError
+
+    def fileno(self) -> int:
+        raise TypeError
+
+    async def flush(self) -> None:
+        raise TypeError
+
+    def isatty(self) -> bool:
+        raise TypeError
+
+    async def read(self, n: int = -1) -> AnyStrT:
+        raise TypeError
+
+    def readable(self) -> bool:
+        raise TypeError
+
+    async def readline(self, limit: int = -1) -> AnyStrT:
+        raise TypeError
+
+    async def readlines(self, hint: int = -1) -> ta.List[AnyStrT]:
+        raise TypeError
+
+    async def seek(self, offset: int, whence: int = 0) -> int:
+        raise TypeError
+
+    def seekable(self) -> bool:
+        raise TypeError
+
+    async def tell(self) -> int:
+        raise TypeError
+
+    async def truncate(self, size: ta.Optional[int] = None) -> int:
+        raise TypeError
+
+    def writable(self) -> bool:
+        raise TypeError
+
+    async def write(self, s: AnyStrT) -> int:
+        raise TypeError
+
+    async def writelines(self, lines: ta.List[AnyStrT]) -> None:
+        raise TypeError
+
+    async def __aenter__(self: SelfT) -> SelfT:
+        raise TypeError
+
+    async def __aexit__(self, exc_type, exc_value, exc_tb):
+        raise TypeError
+
+
+@_register_async_io_proxy_cls
+class TypingBinaryIO_AsyncIoProxy(TypingIO_AsyncIoProxy[bytes], proxied_cls=ta.BinaryIO):  # noqa
+    def write(self, s: ta.Union[bytes, bytearray]) -> int:  # type: ignore[override]
+        raise TypeError
+
+
+@_register_async_io_proxy_cls
+class TypingTextIO_AsyncIoProxy(TypingIO_AsyncIoProxy[str], proxied_cls=ta.TextIO):  # noqa
+    # @property
+    # def buffer(self) -> BinaryIO:
+    #     pass
+
+    @property
+    def encoding(self) -> str:
+        raise TypeError
+
+    @property
+    def errors(self) -> ta.Optional[str]:
+        raise TypeError
+
+    @property
+    def line_buffering(self) -> bool:
+        raise TypeError
+
+    @property
+    def newlines(self) -> ta.Any:
+        raise TypeError

omlish/check.py

@@ -85,6 +85,7 @@ not_none = check.not_none
 #
 
 equal = check.equal
+not_equal = check.not_equal
 is_ = check.is_
 is_not = check.is_not
 callable = check.callable  # noqa

omlish/configs/processing/matching.py

@@ -29,8 +29,16 @@ class MatchingConfigRewriter(ConfigRewriter):
         self._paths = frozenset(check.isinstance(p, tuple) for p in paths)
         self._recurse = recurse
 
+    def match_path(self, path: ConfigRewriterPath) -> bool:
+        for test in self._paths:
+            if len(test) != len(path):
+                continue
+            if all(t is None or p == t for p, t in zip(path, test)):
+                return True
+        return False
+
     def rewrite(self, ctx: ConfigRewriter.Context[T]) -> T:
-        if ctx.path in self._paths:
+        if self.match_path(ctx.path):
             no = self._fn(ctx.obj)
             if not self._recurse:
                 return no

omlish/formats/json/stream/lex.py

@@ -4,6 +4,7 @@ TODO:
  - max recursion depth
  - mark start pos of tokens, currently returning end
  - _do_string inner loop optimization somehow
+ - json5 mode
 """
 import dataclasses as dc
 import io

omlish/formats/json5/Json5.g4

@@ -0,0 +1,172 @@
+// Student Main
+// 2020-07-22
+// Public domain
+
+// JSON5 is a superset of JSON, it included some feature from ES5.1
+// See https://json5.org/
+// Derived from ../json/JSON.g4 which original derived from http://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 Json5;
+
+json5
+    : value? EOF
+    ;
+
+obj
+    : '{' pair (',' pair)* ','? '}'
+    | '{' '}'
+    ;
+
+pair
+    : key ':' value
+    ;
+
+key
+    : STRING
+    | IDENTIFIER
+    | LITERAL
+    | NUMERIC_LITERAL
+    ;
+
+value
+    : STRING
+    | number
+    | obj
+    | arr
+    | LITERAL
+    ;
+
+arr
+    : '[' value (',' value)* ','? ']'
+    | '[' ']'
+    ;
+
+number
+    : SYMBOL? (NUMERIC_LITERAL | NUMBER)
+    ;
+
+// Lexer
+
+SINGLE_LINE_COMMENT
+    : '//' .*? (NEWLINE | EOF) -> skip
+    ;
+
+MULTI_LINE_COMMENT
+    : '/*' .*? '*/' -> skip
+    ;
+
+LITERAL
+    : 'true'
+    | 'false'
+    | 'null'
+    ;
+
+STRING
+    : '"' DOUBLE_QUOTE_CHAR* '"'
+    | '\'' SINGLE_QUOTE_CHAR* '\''
+    ;
+
+fragment DOUBLE_QUOTE_CHAR
+    : ~["\\\r\n]
+    | ESCAPE_SEQUENCE
+    ;
+
+fragment SINGLE_QUOTE_CHAR
+    : ~['\\\r\n]
+    | ESCAPE_SEQUENCE
+    ;
+
+fragment ESCAPE_SEQUENCE
+    : '\\' (
+        NEWLINE
+        | UNICODE_SEQUENCE       // \u1234
+        | ['"\\/bfnrtv]          // single escape char
+        | ~['"\\bfnrtv0-9xu\r\n] // non escape char
+        | '0'                    // \0
+        | 'x' HEX HEX            // \x3a
+    )
+    ;
+
+NUMBER
+    : INT ('.' [0-9]*)? EXP? // +1.e2, 1234, 1234.5
+    | '.' [0-9]+ EXP?        // -.2e3
+    | '0' [xX] HEX+          // 0x12345678
+    ;
+
+NUMERIC_LITERAL
+    : 'Infinity'
+    | 'NaN'
+    ;
+
+SYMBOL
+    : '+'
+    | '-'
+    ;
+
+fragment HEX
+    : [0-9a-fA-F]
+    ;
+
+fragment INT
+    : '0'
+    | [1-9] [0-9]*
+    ;
+
+fragment EXP
+    : [Ee] SYMBOL? [0-9]*
+    ;
+
+IDENTIFIER
+    : IDENTIFIER_START IDENTIFIER_PART*
+    ;
+
+fragment IDENTIFIER_START
+    : [\p{L}]
+    | '$'
+    | '_'
+    | '\\' UNICODE_SEQUENCE
+    ;
+
+fragment IDENTIFIER_PART
+    : IDENTIFIER_START
+    | [\p{M}]
+    | [\p{N}]
+    | [\p{Pc}]
+    | '\u200C'
+    | '\u200D'
+    ;
+
+fragment UNICODE_SEQUENCE
+    : 'u' HEX HEX HEX HEX
+    ;
+
+fragment NEWLINE
+    : '\r\n'
+    | [\r\n\u2028\u2029]
+    ;
+
+fragment WS1
+    : '\u0009'
+    | '\u000A'
+    | '\u000B'
+    | '\u000C'
+    | '\u000D'
+    | '\u0020'
+    | '\u00A0'
+    | '\u2028'
+    | '\u2029'
+    | '\uFEFF'
+
+    | '\u1680'
+    | '\u2000' ..'\u200A'
+    | '\u202F'
+    | '\u205F'
+    | '\u3000'
+    ;
+
+WS
+    : WS1+ -> skip
+    ;

omlish/formats/json5/__init__.py

@@ -0,0 +1,8 @@
+from .codec import (  # noqa
+    dumps,
+    loads,
+)
+
+from .errors import (  # noqa
+    Json5Error,
+)