omlish 0.0.0.dev307__tar.gz → 0.0.0.dev308__tar.gz

{omlish-0.0.0.dev307/omlish.egg-info → omlish-0.0.0.dev308}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omlish
-Version: 0.0.0.dev307
+Version: 0.0.0.dev308
 Summary: omlish
 Author: wrmsr
 License: BSD-3-Clause

{omlish-0.0.0.dev307 → omlish-0.0.0.dev308}/omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev307'
-__revision__ = '7fd729bd16b72af663b113712ea301f150b2449d'
+__version__ = '0.0.0.dev308'
+__revision__ = '78cf17d1a6de1ee32440b0b62de28fdd17f9bedc'
 
 
 #

{omlish-0.0.0.dev307 → omlish-0.0.0.dev308}/omlish/asyncs/anyio/subprocesses.py

@@ -50,11 +50,11 @@ class AnyioSubprocesses(AbstractAsyncSubprocesses):
                         stderr = io.BytesIO()
                         tg.start_soon(read_output, proc.stderr, stderr)
 
-                if proc.stdin and run.input is not None:
-                    await proc.stdin.send(run.input)
-                    await proc.stdin.aclose()
+                    if proc.stdin and run.input is not None:
+                        await proc.stdin.send(run.input)
+                        await proc.stdin.aclose()
 
-                await proc.wait()
+                    await proc.wait()
 
         if run.check and proc.returncode != 0:
             raise subprocess.CalledProcessError(

{omlish-0.0.0.dev307 → omlish-0.0.0.dev308}/omlish/formats/edn/lexing.py

@@ -32,6 +32,8 @@ TokenKind: ta.TypeAlias = ta.Literal[
     'HASH_UNDERSCORE',
     'META',
     'QUOTE',
+
+    'SPACE',
 ]
 
 
@@ -88,7 +90,13 @@ class StreamLexError(Exception):
 
 
 class StreamLexer(GenMachine[str, Token]):
-    def __init__(self) -> None:
+    def __init__(
+            self,
+            *,
+            include_space: bool = False,
+    ) -> None:
+        self._include_space = include_space
+
         self._ofs = 0
         self._line = 1
         self._col = 0
@@ -155,6 +163,8 @@ class StreamLexer(GenMachine[str, Token]):
                 return None
 
             if c.isspace() or c == ',':
+                if self._include_space:
+                    yield self._make_tok('SPACE', c, self.pos)
                 continue
 
             if c in SINGLE_TOKENS:
@@ -303,23 +313,3 @@ class StreamLexer(GenMachine[str, Token]):
         src = self._flip_buf()
         yield self._make_tok('WORD', src, pos)
         return self._do_main(c)
-
-
-##
-
-
-def test_lex():
-    for s in [
-        '"abc"',
-        '{"a" "b"}',
-        '1',
-        '-1',
-        '{a :b c 420}',
-        '#{a}',
-    ]:
-        print(s)
-        with StreamLexer() as lex:
-            for c in [*s, '']:
-                for t in lex(c):
-                    print(t)
-        print()

{omlish-0.0.0.dev307 → omlish-0.0.0.dev308}/omlish/formats/edn/parsing.py

@@ -178,10 +178,15 @@ class StreamParser(GenMachine[Token, ta.Any]):
                 else:
                     raise
 
-            value: ta.Any
+            # ignored
+
+            if tok.kind in ('SPACE', 'COMMENT'):
+                continue
 
             # scalars
 
+            value: ta.Any
+
             if tok.kind == 'STRING':
                 value = self._parse_string(tok)
 
@@ -197,9 +202,6 @@ class StreamParser(GenMachine[Token, ta.Any]):
                 else:
                     value = self._parse_word(tok)
 
-            elif tok.kind == 'COMMENT':
-                continue
-
             # open
 
             elif tok.kind == 'LPAREN':
@@ -324,8 +326,7 @@ class StreamParser(GenMachine[Token, ta.Any]):
 
         return self._char_maker(c)
 
-    _INT_PAT = re.compile(r'[-+]?(0|[1-9][0-9]*)')
-    _BIGINT_PAT = re.compile(r'[-+]?(0|[1-9][0-9]*)N')
+    _INT_PAT = re.compile(r'[-+]?(0|[1-9][0-9]*)N?')
     _FLOAT_PAT = re.compile(r'[-+]?(0|[1-9][0-9]*)(\.[0-9]+)?([eE][+-]?(0|[1-9][0-9]*))?M?')
 
     def _parse_word(self, tok: Token) -> ta.Any:
@@ -345,10 +346,11 @@ class StreamParser(GenMachine[Token, ta.Any]):
             # 2r101010, 052, 8r52, 0x2a, 36r16, and 42 are all the same Long.
             # Floating point numbers are read as Doubles; with M suffix they are read as BigDecimals.
             # Ratios are supported, e.g. 22/7.
-            return int(src)
+            if src.endswith('N'):
+                return int(src[:-1])
 
-        elif self._BIGINT_PAT.fullmatch(src):
-            return int(src[:-1])
+            else:
+                return int(src)
 
         elif self._FLOAT_PAT.fullmatch(src):
             return float(src)
@@ -376,25 +378,3 @@ def parse(src: str, **kwargs: ta.Any) -> ta.Any | None:
     if not values:
         return None
     return check.single(values)
-
-
-##
-
-
-def test_parse():
-    for s in [
-        '"abc"',
-        '"a\\bc"',
-        '{"a" "b"}',
-        '1',
-        '-1',
-        '{a :b c 420}',
-        '#{a}',
-        '(1 #_ 2 3)',
-        '"foo\u1234bar"',
-        '\\x',
-        '\\u1234',
-    ]:
-        print(s)
-        print(parse(s))
-        print()

{omlish-0.0.0.dev307 → omlish-0.0.0.dev308}/omlish/formats/json/stream/lexing.py

@@ -40,7 +40,14 @@ ControlTokenKind: ta.TypeAlias = ta.Literal[
     'COLON',
 ]
 
-TokenKind: ta.TypeAlias = ValueTokenKind | ControlTokenKind
+SpaceTokenKind: ta.TypeAlias = ta.Literal['SPACE']
+
+TokenKind: ta.TypeAlias = ta.Union[  # noqa
+    ValueTokenKind,
+    ControlTokenKind,
+    SpaceTokenKind,
+]
+
 
 #
 
@@ -109,8 +116,10 @@ class JsonStreamLexer(GenMachine[str, Token]):
             self,
             *,
             include_raw: bool = False,
+            include_space: bool = False,
     ) -> None:
         self._include_raw = include_raw
+        self._include_space = include_space
 
         self._ofs = 0
         self._line = 1
@@ -174,6 +183,8 @@ class JsonStreamLexer(GenMachine[str, Token]):
                 return None
 
             if c.isspace():
+                if self._include_space:
+                    yield self._make_tok('SPACE', c, c, self.pos)
                 continue
 
             if c in CONTROL_TOKENS:
@@ -282,7 +293,11 @@ class JsonStreamLexer(GenMachine[str, Token]):
         if c in CONTROL_TOKENS:
             yield self._make_tok(CONTROL_TOKENS[c], c, c, pos)
 
-        elif not c.isspace():
+        elif c.isspace():
+            if self._include_space:
+                yield self._make_tok('SPACE', c, c, self.pos)
+
+        else:
             self._raise(f'Unexpected character after number: {c}')
 
         return self._do_main()

{omlish-0.0.0.dev307 → omlish-0.0.0.dev308}/omlish/formats/json/stream/parsing.py

@@ -102,6 +102,15 @@ class JsonStreamParser(GenMachine[Token, JsonStreamParserEvent]):
 
     #
 
+    def _next_tok(self):
+        while True:
+            tok = yield None
+
+            if tok.kind != 'SPACE':
+                return tok
+
+    #
+
     def _emit_event(self, v):
         if not self._stack:
             return ((v,), self._do_value())
@@ -129,7 +138,7 @@ class JsonStreamParser(GenMachine[Token, JsonStreamParserEvent]):
 
     def _do_value(self, *, must_be_present: bool = False):
         try:
-            tok = yield None
+            tok = yield from self._next_tok()
         except GeneratorExit:
             if self._stack:
                 raise JsonStreamParseError('Expected value') from None
@@ -180,7 +189,7 @@ class JsonStreamParser(GenMachine[Token, JsonStreamParserEvent]):
 
     def _do_object_body(self, *, must_be_present: bool = False):
         try:
-            tok = yield None
+            tok = yield from self._next_tok()
         except GeneratorExit:
             raise JsonStreamParseError('Expected object body') from None
 
@@ -188,7 +197,7 @@ class JsonStreamParser(GenMachine[Token, JsonStreamParserEvent]):
             k = tok.value
 
             try:
-                tok = yield None
+                tok = yield from self._next_tok()
             except GeneratorExit:
                 raise JsonStreamParseError('Expected key') from None
             if tok.kind != 'COLON':
@@ -211,7 +220,7 @@ class JsonStreamParser(GenMachine[Token, JsonStreamParserEvent]):
 
     def _do_after_pair(self):
         try:
-            tok = yield None
+            tok = yield from self._next_tok()
         except GeneratorExit:
             raise JsonStreamParseError('Expected continuation') from None
 
@@ -244,7 +253,7 @@ class JsonStreamParser(GenMachine[Token, JsonStreamParserEvent]):
 
     def _do_after_element(self):
         try:
-            tok = yield None
+            tok = yield from self._next_tok()
         except GeneratorExit:
             raise JsonStreamParseError('Expected continuation') from None
 

{omlish-0.0.0.dev307 → omlish-0.0.0.dev308}/omlish/lang/__init__.py

@@ -184,12 +184,11 @@ from .functions import (  # noqa
 )
 
 from .generators import (  # noqa
-    CoroutineGenerator,
-    Generator,
     GeneratorLike,
     GeneratorMappedIterator,
     autostart,
-    corogen,
+    capture_coroutine,
+    capture_generator,
     genmap,
     nextgen,
 )

{omlish-0.0.0.dev307 → omlish-0.0.0.dev308}/omlish/lang/generators.py

@@ -2,6 +2,7 @@ import abc
 import functools
 import typing as ta
 
+from .classes.restrict import Abstract
 from .maybes import Maybe
 from .maybes import empty
 from .maybes import just
@@ -79,15 +80,29 @@ def adapt_generator_like(gl):
 ##
 
 
-class Generator(ta.Generator[O, I, R]):
+class AbstractGeneratorCapture(Abstract, ta.Generic[O, I, R]):
     def __init__(self, g: ta.Generator[O, I, R]) -> None:
         super().__init__()
+
         self._g = g
 
     @property
     def g(self) -> ta.Generator[O, I, R]:
         return self._g
 
+    #
+
+    def close(self) -> None:
+        self._g.close()
+
+    def __enter__(self) -> ta.Self:
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self._g.close()
+
+
+class GeneratorCapture(AbstractGeneratorCapture[O, I, R], ta.Generator[O, I, R]):
     value: R
 
     def __iter__(self):
@@ -114,35 +129,11 @@ class Generator(ta.Generator[O, I, R]):
             self.value = e.value
             raise
 
-    def close(self):
-        self._g.close()
 
+capture_generator = GeneratorCapture
 
-##
-
-
-class CoroutineGenerator(ta.Generic[O, I, R]):
-    def __init__(self, g: ta.Generator[O, I, R]) -> None:
-        super().__init__()
-        self._g = g
-
-    @property
-    def g(self) -> ta.Generator[O, I, R]:
-        return self._g
-
-    #
-
-    def close(self) -> None:
-        self._g.close()
-
-    def __enter__(self) -> ta.Self:
-        return self
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        self._g.close()
-
-    #
 
+class CoroutineGeneratorCapture(AbstractGeneratorCapture[O, I, R]):
     class Output(ta.NamedTuple, ta.Generic[T]):
         v: T
 
@@ -192,7 +183,7 @@ class CoroutineGenerator(ta.Generic[O, I, R]):
             return self.Yield(o)
 
 
-corogen = CoroutineGenerator
+capture_coroutine = CoroutineGeneratorCapture
 
 
 ##

{omlish-0.0.0.dev307 → omlish-0.0.0.dev308}/omlish/specs/jsonrpc/__init__.py

@@ -16,6 +16,7 @@ from .types import (  # noqa
 
     NotSpecified,
     is_not_specified,
+    check_not_not_specified,
 
     Request,
     request,

omlish-0.0.0.dev308/omlish/specs/jsonrpc/conns.py

@@ -0,0 +1,222 @@
+"""
+TODO:
+ - kill receive loop on __aexit__
+"""
+import builtins
+import json
+import typing as ta
+import uuid
+
+import anyio.abc
+
+from ... import lang
+from ... import marshal as msh
+from ...asyncs import anyio as aiu
+from ...io.buffers import DelimitingBuffer
+from .types import Error
+from .types import Id
+from .types import Message
+from .types import NotSpecified
+from .types import Object
+from .types import Request
+from .types import Response
+from .types import detect_message_type
+from .types import notification
+from .types import request
+
+
+##
+
+
+@lang.cached_function
+def _create_id() -> str:
+    return str(uuid.uuid4())
+
+
+class JsonrpcConnection:
+    def __init__(
+            self,
+            tg: anyio.abc.TaskGroup,
+            stream: anyio.abc.ByteStream,
+            *,
+            request_handler: ta.Callable[['JsonrpcConnection', Request], ta.Awaitable[None]] | None = None,
+            notification_handler: ta.Callable[['JsonrpcConnection', Request], ta.Awaitable[None]] | None = None,
+            default_timeout: float | None = 30.,
+    ) -> None:
+        super().__init__()
+
+        self._tg = tg
+        self._stream = stream
+        self._request_handler = request_handler
+        self._notification_handler = notification_handler
+        self._default_timeout = default_timeout
+
+        self._buf = DelimitingBuffer(b'\n')
+        self._response_futures_by_id: dict[Id, aiu.Future[Response]] = {}
+        self._send_lock = anyio.Lock()
+        self._received_eof = False
+        self._running = True
+
+    #
+
+    class Error(Exception):
+        """Base class for JSON-RPC related errors."""
+
+    class TimeoutError(Error, builtins.TimeoutError):  # noqa
+        """Raised when a request times out."""
+
+    class ConnectionError(Error, builtins.ConnectionError):  # noqa
+        """Raised when there are connection-related issues."""
+
+    class ProtocolError(Error):
+        """Raised when there are protocol-related issues."""
+
+    #
+
+    async def __aenter__(self) -> 'JsonrpcConnection':
+        await self._tg.start(self._receive_loop)
+        return self
+
+    async def __aexit__(self, exc_type: type[BaseException] | None, *_: object) -> None:
+        self._running = False
+
+    ##
+
+    async def _handle_message(self, msg: Message) -> None:
+        if isinstance(msg, Response):
+            msg_id = msg.id
+            try:
+                resp_fut = self._response_futures_by_id[msg_id]
+            except KeyError:
+                raise NotImplementedError from None
+            resp_fut.set_value(msg)
+
+        elif isinstance(msg, Request):
+            if msg.is_notification:
+                if (mh := self._notification_handler) is not None:
+                    await mh(self, msg)
+
+            else:  # noqa
+                if (rh := self._request_handler) is not None:
+                    await rh(self, msg)
+
+        else:
+            raise TypeError(msg)
+
+    #
+
+    CLOSED_EXCEPTIONS: ta.ClassVar[tuple[type[Exception], ...]] = (
+        anyio.ClosedResourceError,
+        anyio.EndOfStream,
+    )
+
+    ERROR_EXCEPTIONS: ta.ClassVar[tuple[type[Exception], ...]] = (
+        OSError,
+        anyio.BrokenResourceError,
+    )
+
+    async def _receive_message_batch(self) -> list[Message] | None:
+        if self._received_eof:
+            return None
+
+        while True:
+            try:
+                data = await self._stream.receive()
+            except self.CLOSED_EXCEPTIONS:
+                data = b''
+            except self.ERROR_EXCEPTIONS as e:
+                raise JsonrpcConnection.ConnectionError('Failed to receive message') from e
+
+            if not data:
+                self._received_eof = True
+
+            lines = list(self._buf.feed(data))
+            if lines:
+                break
+
+            if not data:
+                return None
+
+        msgs: list[Message] = []
+        for line in lines:
+            if isinstance(line, DelimitingBuffer.Incomplete):
+                raise ConnectionError('Received incomplete message')
+
+            try:
+                dct = json.loads(line.decode('utf-8'))
+            except (UnicodeDecodeError, json.JSONDecodeError) as e:
+                raise JsonrpcConnection.ProtocolError from e
+
+            mcls = detect_message_type(dct)
+            try:
+                msg = msh.unmarshal(dct, mcls)
+            except Exception as e:
+                raise JsonrpcConnection.ProtocolError from e
+
+            msgs.append(msg)
+
+        return msgs
+
+    async def _receive_loop(
+            self,
+            *,
+            task_status: anyio.abc.TaskStatus[ta.Any] = anyio.TASK_STATUS_IGNORED,
+    ) -> None:
+        task_status.started()
+
+        while self._running:
+            msgs = await self._receive_message_batch()
+            if msgs is None:
+                break
+
+            for msg in msgs:
+                await self._handle_message(msg)
+
+    ##
+
+    async def send_message(self, msg: Message) -> None:
+        async with self._send_lock:
+            try:
+                await self._stream.send(json.dumps(msh.marshal(msg)).encode() + b'\n')
+            except self.ERROR_EXCEPTIONS as e:
+                raise ConnectionError('Failed to send message') from e
+
+    #
+
+    async def request(
+            self,
+            method: str,
+            params: Object | None = None,
+            *,
+            timeout: float | None = None,
+    ) -> ta.Any:
+        msg_id = _create_id()
+        req = request(msg_id, method, params)
+
+        fut = aiu.create_future[Response]()
+        self._response_futures_by_id[msg_id] = fut
+
+        try:
+            await self.send_message(req)
+
+            timeout_val = timeout if timeout is not None else self._default_timeout
+            try:
+                with anyio.fail_after(timeout_val):
+                    await fut
+            except TimeoutError as e:
+                raise JsonrpcConnection.TimeoutError(f'Request timed out after {timeout_val} seconds') from e
+
+            response = fut.outcome.must().unwrap()
+
+            if response.error is not NotSpecified:
+                error = ta.cast(Error, response.error)
+                raise JsonrpcConnection.Error(f'Error {error.code}: {error.message}')
+
+            return response.result
+
+        finally:
+            self._response_futures_by_id.pop(msg_id, None)  # noqa
+
+    async def notify(self, method: str, params: Object | None = None) -> None:
+        msg = notification(method, params)
+        await self.send_message(msg)

{omlish-0.0.0.dev307 → omlish-0.0.0.dev308}/omlish/specs/jsonrpc/types.py

@@ -18,6 +18,8 @@ from ... import lang
 from ... import marshal as msh
 
 
+T = ta.TypeVar('T')
+
 NUMBER_TYPES: tuple[type, ...] = (int, float)
 Number: ta.TypeAlias = int | float
 
@@ -44,6 +46,11 @@ def is_not_specified(v: ta.Any) -> bool:
     return v is NotSpecified
 
 
+def check_not_not_specified(v: T | type[NotSpecified]) -> T:
+    check.arg(not is_not_specified(v))
+    return ta.cast(T, v)
+
+
 ##
 
 
@@ -87,10 +94,22 @@ class Response(lang.Final):
 
     _: dc.KW_ONLY
 
+    #
+
     result: ta.Any = dc.field(default=NotSpecified)
     error: ta.Union['Error', type[NotSpecified]] = dc.field(default=NotSpecified)
     dc.validate(lambda self: is_not_specified(self.result) ^ is_not_specified(self.error))
 
+    @property
+    def is_result(self) -> bool:
+        return not is_not_specified(self.result)
+
+    @property
+    def is_error(self) -> bool:
+        return not is_not_specified(self.error)
+
+    #
+
     jsonrpc: str = dc.field(default=VERSION)
     dc.validate(lambda self: self.jsonrpc == VERSION)
 

{omlish-0.0.0.dev307 → omlish-0.0.0.dev308/omlish.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omlish
-Version: 0.0.0.dev307
+Version: 0.0.0.dev308
 Summary: omlish
 Author: wrmsr
 License: BSD-3-Clause

{omlish-0.0.0.dev307 → omlish-0.0.0.dev308}/omlish.egg-info/SOURCES.txt

@@ -699,6 +699,7 @@ omlish/specs/jmespath/parser.py
 omlish/specs/jmespath/scope.py
 omlish/specs/jmespath/visitor.py
 omlish/specs/jsonrpc/__init__.py
+omlish/specs/jsonrpc/conns.py
 omlish/specs/jsonrpc/errors.py
 omlish/specs/jsonrpc/marshal.py
 omlish/specs/jsonrpc/types.py

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