robotcode-jsonrpc2 0.66.0__tar.gz → 0.67.0__tar.gz

{robotcode_jsonrpc2-0.66.0 → robotcode_jsonrpc2-0.67.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: robotcode-jsonrpc2
-Version: 0.66.0
+Version: 0.67.0
 Summary: JSONRPC Server for RobotCode
 Project-URL: Homepage, https://robotcode.io
 Project-URL: Donate, https://github.com/sponsors/d-biehl
@@ -25,7 +25,7 @@ Classifier: Programming Language :: Python :: Implementation :: PyPy
 Classifier: Topic :: Utilities
 Classifier: Typing :: Typed
 Requires-Python: >=3.8
-Requires-Dist: robotcode-core==0.66.0
+Requires-Dist: robotcode-core==0.67.0
 Description-Content-Type: text/markdown
 
 # robotcode-jsonrpc2

{robotcode_jsonrpc2-0.66.0 → robotcode_jsonrpc2-0.67.0}/pyproject.toml

@@ -25,7 +25,7 @@ classifiers = [
   "Framework :: Robot Framework",
   "Framework :: Robot Framework :: Tool",
 ]
-dependencies = ["robotcode-core==0.66.0"]
+dependencies = ["robotcode-core==0.67.0"]
 dynamic = ["version"]
 
 [project.urls]

robotcode_jsonrpc2-0.67.0/src/robotcode/jsonrpc2/__version__.py

@@ -0,0 +1 @@
+__version__ = "0.67.0"

{robotcode_jsonrpc2-0.66.0 → robotcode_jsonrpc2-0.67.0}/src/robotcode/jsonrpc2/protocol.py

@@ -144,12 +144,21 @@ class InvalidProtocolVersionError(JsonRPCParseError):
     pass
 
 
-class RpcMethodEntry(NamedTuple):
+@dataclass
+class RpcMethodEntry:
     name: str
     method: Callable[..., Any]
     param_type: Optional[Type[Any]]
     cancelable: bool
 
+    _is_coroutine: Optional[bool] = field(default=None, init=False)
+
+    @property
+    def is_coroutine(self) -> bool:
+        if self._is_coroutine is None:
+            self._is_coroutine = inspect.iscoroutinefunction(self.method)
+        return self._is_coroutine
+
 
 @runtime_checkable
 class RpcMethod(Protocol):
@@ -553,10 +562,10 @@ class JsonRPCProtocol(JsonRPCProtocolBase):
 
             self._sended_request[id] = SendedRequestEntry(result, return_type_or_converter)
 
-        request = JsonRPCRequest(id=id, method=method, params=params)
-        self.send_message(request)
+            request = JsonRPCRequest(id=id, method=method, params=params)
+            self.send_message(request)
 
-        return result
+            return result
 
     def send_request_async(
         self,
@@ -622,7 +631,7 @@ class JsonRPCProtocol(JsonRPCProtocolBase):
                     JsonRPCErrorException(message.error.code, message.error.message, message.error.data)
                 )
             else:
-                self.__logger.warning(lambda: f"Response for {message} is already done.")
+                self.__logger.warning(lambda: f"Error Response for {message} is already done.")
 
         except (SystemExit, KeyboardInterrupt):
             raise
@@ -707,53 +716,57 @@ class JsonRPCProtocol(JsonRPCProtocolBase):
 
         params = self._convert_params(e.method, e.param_type, message.params)
 
-        if (
-            isinstance(e.method, HasThreaded)
-            and e.method.__threaded__
-            or inspect.ismethod(e.method)
-            and isinstance(e.method.__func__, HasThreaded)
-            and e.method.__func__.__threaded__
-        ):
-            task = run_coroutine_in_thread(
-                ensure_coroutine(cast(Callable[..., Any], e.method)), *params[0], **params[1]
-            )
+        if not e.is_coroutine:
+            self.send_response(message.id, e.method(*params[0], **params[1]))
         else:
-            task = create_sub_task(
-                ensure_coroutine(e.method)(*params[0], **params[1]),
-                name=message.method,
-            )
+            if (
+                isinstance(e.method, HasThreaded)
+                and e.method.__threaded__
+                or inspect.ismethod(e.method)
+                and isinstance(e.method.__func__, HasThreaded)
+                and e.method.__func__.__threaded__
+            ):
+                task = run_coroutine_in_thread(
+                    ensure_coroutine(cast(Callable[..., Any], e.method)), *params[0], **params[1]
+                )
+            else:
+                task = create_sub_task(
+                    ensure_coroutine(e.method)(*params[0], **params[1]),
+                    name=message.method,
+                )
 
-        with self._received_request_lock:
-            self._received_request[message.id] = ReceivedRequestEntry(task, message, e.cancelable)
-
-        def done(t: asyncio.Future[Any]) -> None:
-            try:
-                if not t.cancelled():
-                    ex = t.exception()
-                    if ex is not None:
-                        self.__logger.exception(ex, exc_info=ex)
-                        raise JsonRPCErrorException(JsonRPCErrors.INTERNAL_ERROR, f"{type(ex).__name__}: {ex}") from ex
-
-                self.send_response(message.id, t.result())
-            except asyncio.CancelledError:
-                self.__logger.debug(lambda: f"request message {message!r} canceled")
-                self.send_error(JsonRPCErrors.REQUEST_CANCELLED, "Request canceled.", id=message.id)
-            except (SystemExit, KeyboardInterrupt):
-                raise
-            except JsonRPCErrorException as e:
-                self.send_error(e.code, e.message or f"{type(e).__name__}: {e}", id=message.id, data=e.data)
-            except BaseException as e:
-                self.__logger.exception(e)
-                self.send_error(JsonRPCErrors.INTERNAL_ERROR, f"{type(e).__name__}: {e}", id=message.id)
-            finally:
-                with self._received_request_lock:
-                    self._received_request.pop(message.id, None)
-
-        task.add_done_callback(done)
-
-        await task
+            with self._received_request_lock:
+                self._received_request[message.id] = ReceivedRequestEntry(task, message, e.cancelable)
+
+            def done(t: asyncio.Future[Any]) -> None:
+                try:
+                    if not t.cancelled():
+                        ex = t.exception()
+                        if ex is not None:
+                            self.__logger.exception(ex, exc_info=ex)
+                            raise JsonRPCErrorException(
+                                JsonRPCErrors.INTERNAL_ERROR, f"{type(ex).__name__}: {ex}"
+                            ) from ex
+
+                    self.send_response(message.id, t.result())
+                except asyncio.CancelledError:
+                    self.__logger.debug(lambda: f"request message {message!r} canceled")
+                    self.send_error(JsonRPCErrors.REQUEST_CANCELLED, "Request canceled.", id=message.id)
+                except (SystemExit, KeyboardInterrupt):
+                    raise
+                except JsonRPCErrorException as e:
+                    self.send_error(e.code, e.message or f"{type(e).__name__}: {e}", id=message.id, data=e.data)
+                except BaseException as e:
+                    self.__logger.exception(e)
+                    self.send_error(JsonRPCErrors.INTERNAL_ERROR, f"{type(e).__name__}: {e}", id=message.id)
+                finally:
+                    with self._received_request_lock:
+                        self._received_request.pop(message.id, None)
+
+            task.add_done_callback(done)
+
+            await task
 
-    @__logger.call
     def cancel_request(self, id: Union[int, str, None]) -> None:
         with self._received_request_lock:
             entry = self._received_request.get(id, None)
@@ -762,8 +775,7 @@ class JsonRPCProtocol(JsonRPCProtocolBase):
             self.__logger.debug(lambda: f"try to cancel request {entry.request if entry is not None else ''}")
             entry.future.cancel()
 
-    @__logger.call
-    async def cancel_all_received_request(self) -> None:
+    def cancel_all_received_request(self) -> None:
         for entry in self._received_request.values():
             if entry is not None and entry.cancelable and entry.future is not None and not entry.future.cancelled():
                 entry.future.cancel()
@@ -778,23 +790,26 @@ class JsonRPCProtocol(JsonRPCProtocolBase):
         try:
             params = self._convert_params(e.method, e.param_type, message.params)
 
-            if (
-                isinstance(e.method, HasThreaded)
-                and e.method.__threaded__
-                or inspect.ismethod(e.method)
-                and isinstance(e.method.__func__, HasThreaded)
-                and e.method.__func__.__threaded__
-            ):
-                task = run_coroutine_in_thread(
-                    ensure_coroutine(cast(Callable[..., Any], e.method)), *params[0], **params[1]
-                )
+            if not e.is_coroutine:
+                e.method(*params[0], **params[1])
             else:
-                task = create_sub_task(
-                    ensure_coroutine(e.method)(*params[0], **params[1]),
-                    name=message.method,
-                )
+                if (
+                    isinstance(e.method, HasThreaded)
+                    and e.method.__threaded__
+                    or inspect.ismethod(e.method)
+                    and isinstance(e.method.__func__, HasThreaded)
+                    and e.method.__func__.__threaded__
+                ):
+                    task = run_coroutine_in_thread(
+                        ensure_coroutine(cast(Callable[..., Any], e.method)), *params[0], **params[1]
+                    )
+                else:
+                    task = create_sub_task(
+                        ensure_coroutine(e.method)(*params[0], **params[1]),
+                        name=message.method,
+                    )
 
-            await task
+                await task
         except asyncio.CancelledError:
             pass
         except (SystemExit, KeyboardInterrupt):

robotcode_jsonrpc2-0.66.0/src/robotcode/jsonrpc2/__version__.py

@@ -1 +0,0 @@
-__version__ = "0.66.0"