omlish 0.0.0.dev306__py3-none-any.whl → 0.0.0.dev308__py3-none-any.whl

omlish/formats/json/__init__.py

@@ -35,11 +35,11 @@ from .json import (  # noqa
 )
 
 if _ta.TYPE_CHECKING:
-    from .render import (  # noqa
+    from .rendering import (  # noqa
         JsonRenderer,
     )
 else:
-    _lang.proxy_init(globals(), '.render', [
+    _lang.proxy_init(globals(), '.rendering', [
         'JsonRenderer',
     ])
 

omlish/formats/json/stream/{build.py → building.py}

@@ -1,13 +1,13 @@
 import typing as ta
 
-from .lex import SCALAR_VALUE_TYPES
-from .parse import BeginArray
-from .parse import BeginObject
-from .parse import EndArray
-from .parse import EndObject
-from .parse import JsonStreamObject
-from .parse import JsonStreamParserEvent
-from .parse import Key
+from .lexing import SCALAR_VALUE_TYPES
+from .parsing import BeginArray
+from .parsing import BeginObject
+from .parsing import EndArray
+from .parsing import EndObject
+from .parsing import JsonStreamObject
+from .parsing import JsonStreamParserEvent
+from .parsing import Key
 
 
 ##

omlish/formats/json/stream/{lex.py → 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/formats/json/stream/{parse.py → parsing.py}

@@ -4,11 +4,11 @@ import typing as ta
 from .... import lang
 from ....funcs.genmachine import GenMachine
 from .errors import JsonStreamError
-from .lex import SCALAR_VALUE_TYPES
-from .lex import VALUE_TOKEN_KINDS
-from .lex import Position
-from .lex import ScalarValue
-from .lex import Token
+from .lexing import SCALAR_VALUE_TYPES
+from .lexing import VALUE_TOKEN_KINDS
+from .lexing import Position
+from .lexing import ScalarValue
+from .lexing import Token
 
 
 ##
@@ -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/formats/json/stream/{render.py → rendering.py}

@@ -1,14 +1,14 @@
 import io
 import typing as ta
 
-from ..render import AbstractJsonRenderer
+from ..rendering import AbstractJsonRenderer
 from ..types import SCALAR_TYPES
-from .parse import BeginArray
-from .parse import BeginObject
-from .parse import EndArray
-from .parse import EndObject
-from .parse import JsonStreamParserEvent
-from .parse import Key
+from .parsing import BeginArray
+from .parsing import BeginObject
+from .parsing import EndArray
+from .parsing import EndObject
+from .parsing import JsonStreamParserEvent
+from .parsing import Key
 
 
 ##

omlish/formats/json/stream/utils.py

@@ -2,9 +2,9 @@ import dataclasses as dc
 import typing as ta
 
 from .... import lang
-from .build import JsonObjectBuilder
-from .lex import JsonStreamLexer
-from .parse import JsonStreamParser
+from .building import JsonObjectBuilder
+from .lexing import JsonStreamLexer
+from .parsing import JsonStreamParser
 
 
 ##

omlish/funcs/genmachine.py

@@ -34,7 +34,10 @@ class GenMachine(ta.Generic[I, O]):
             if initial is None:
                 raise TypeError('No initial state')
 
-        self._advance(initial)
+        self._gen = initial
+
+        if (n := next(self._gen)) is not None:  # noqa
+            raise GenMachine.NotStartedError
 
     def _initial_state(self) -> MachineGen | None:
         return None
@@ -74,33 +77,34 @@ class GenMachine(ta.Generic[I, O]):
     class Error(Exception):
         pass
 
-    class ClosedError(Exception):
+    class NotStartedError(Error):
         pass
 
-    class StateError(Exception):
+    class ClosedError(Error):
         pass
 
-    #
-
-    def _advance(self, gen: MachineGen) -> None:
-        self._gen = gen
+    class StateError(Error):
+        pass
 
-        if (n := next(self._gen)) is not None:  # noqa
-            raise GenMachine.ClosedError
+    #
 
     def __call__(self, i: I) -> ta.Iterable[O]:
         if self._gen is None:
             raise GenMachine.ClosedError
 
         gi: I | None = i
-        try:
-            while (o := self._gen.send(gi)) is not None:
-                gi = None
-                yield from o
+        while True:
+            try:
+                while (o := self._gen.send(gi)) is not None:  # type: ignore[union-attr]
+                    gi = None
+                    yield from o
 
-        except StopIteration as s:
-            if s.value is None:
-                self._gen = None
-                return None
+                break
 
-            self._advance(s.value)
+            except StopIteration as s:
+                if (sv := s.value) is None:
+                    self._gen = None
+                    return None
+
+                self._gen = sv
+                gi = None

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/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/specs/jsonrpc/__init__.py

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

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/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.dev306.dist-info → omlish-0.0.0.dev308.dist-info}/METADATA

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