jsonrpcserver 5.0.10__tar.gz → 5.2.0__tar.gz

{jsonrpcserver-5.0.10 → jsonrpcserver-5.2.0}/CHANGELOG.md

@@ -1,5 +1,39 @@
 # Changelog
 
+## 5.2.0 (2026-11-06)
+
+Warnings about what 6.0 changes, so an upgrade doesn't surprise you. Nothing
+else changes. Each is a `FutureWarning`, which Python shows by default.
+
+- `serve()` without a host warns. From 6.0 it listens on localhost only.
+  `serve("", port)` keeps every network interface, quietly.
+- A request with `NaN`, `Infinity`, `-Infinity` or a number too big for a float
+  warns. 6.0 rejects them with a Parse error. `deserializer=json.loads` accepts
+  them quietly. `dispatch_to_response` now uses the same default deserializer
+  as the other dispatch functions.
+- A batch of more than 100 requests without `max_batch_size` warns. 6.0 limits
+  batches to 100 by default. Passing `max_batch_size` turns the warning off.
+
+The [6.0 plan](https://github.com/bensynapse/jsonrpcserver/blob/main/plans/6.0.md)
+lists everything else that changes, such as results and responses without
+oslash.
+
+## 5.1.0 (2026-11-06)
+
+### Added
+
+- A method can return a plain value. `return "pong"` sends the same response as
+  `return Success("pong")`, as in 4.x (#285). Before, a plain value gave the
+  client an Internal error. `Success` and `Error` work as before.
+
+### Changed
+
+- A method that returns an oslash `Left` or `Right` not made by `Success` or
+  `Error`, or a bare `SuccessResult` or `ErrorResult`, still gets an Internal
+  error. Its log line and `InvalidResultError` message now say "Return a value,
+  Success(value) or Error(code, message)", and the log line links the Methods
+  page.
+
 ## 5.0.10 (2026-11-06)
 
 The first release since the project moved to

{jsonrpcserver-5.0.10 → jsonrpcserver-5.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: jsonrpcserver
-Version: 5.0.10
+Version: 5.2.0
 Summary: Process incoming JSON-RPC 2.0 requests in Python
 Keywords: json-rpc,jsonrpc,json-rpc-2.0,rpc,server
 Author-email: Beau Barker <beau@explodinglabs.com>
@@ -143,8 +143,8 @@ explains why.
   framework examples and the
   [API reference](https://bensynapse.github.io/jsonrpcserver/reference/).
 - [Migrating from 4.x](https://bensynapse.github.io/jsonrpcserver/migration/):
-  methods must now return `Success(value)`. A 4.x method that returns a plain
-  value still runs, but the client gets an Internal error.
+  methods return `Success(value)` or `Error(...)`. From 5.1.0 a method can also
+  return a plain value, as in 4.x.
 - [Contributing](https://github.com/bensynapse/jsonrpcserver/blob/main/CONTRIBUTING.md)
   and the
   [security policy](https://github.com/bensynapse/jsonrpcserver/blob/main/SECURITY.md).

{jsonrpcserver-5.0.10 → jsonrpcserver-5.2.0}/README.md

@@ -101,8 +101,8 @@ explains why.
   framework examples and the
   [API reference](https://bensynapse.github.io/jsonrpcserver/reference/).
 - [Migrating from 4.x](https://bensynapse.github.io/jsonrpcserver/migration/):
-  methods must now return `Success(value)`. A 4.x method that returns a plain
-  value still runs, but the client gets an Internal error.
+  methods return `Success(value)` or `Error(...)`. From 5.1.0 a method can also
+  return a plain value, as in 4.x.
 - [Contributing](https://github.com/bensynapse/jsonrpcserver/blob/main/CONTRIBUTING.md)
   and the
   [security policy](https://github.com/bensynapse/jsonrpcserver/blob/main/SECURITY.md).

{jsonrpcserver-5.0.10 → jsonrpcserver-5.2.0}/RELEASING.md

@@ -35,7 +35,8 @@ Settings → Environments → pypi.
      yet": `## 5.0.10 (2026-10-20)`.
    - The `unreleased` and `pypi_version` lines under `extra` in mkdocs.yml are
      deleted. They show the "not on PyPI yet" banner on every docs page.
-     Merging this redeploys the docs, so merge it just before you tag.
+     The docs deploy when you push the tag, so merging this changes nothing
+     users see until then.
    - The paragraph under "Install" in README.md that says the version isn't
      released yet is deleted. The README becomes the PyPI page.
    - For 5.0.10 only: shorten the "If you are on 5.0.9" section of
@@ -89,7 +90,8 @@ whose version reached PyPI.
 
 ## Docs
 
-The docs site deploys itself from main through `.github/workflows/docs.yml`,
-so it changes when the docs change, not at release time. While main is ahead
-of PyPI, the `unreleased` setting in mkdocs.yml shows a banner that says so.
+The docs site deploys from `.github/workflows/docs.yml` when a release tag is
+pushed, so it always describes the version on PyPI. To publish a docs-only fix
+between releases, run the Docs workflow by hand on main. If main is ahead of
+PyPI by then, set `unreleased` in mkdocs.yml first, so a banner says so.
 The docs also mark features with "New in" or "Changed in" notes.

{jsonrpcserver-5.0.10 → jsonrpcserver-5.2.0}/docs/errors.md

@@ -153,19 +153,22 @@ logging.basicConfig(
 To change only jsonrpcserver's messages, set the level or add a handler on
 the parent logger: `logging.getLogger("jsonrpcserver")`.
 
-This is what a method that returns a plain value, as it would in 4.x, looks
-like in the log:
+A method can return a plain value, a `Success` or an `Error`. What it can't
+return is a result object that `Success` or `Error` didn't make, such as a bare
+`SuccessResult`. This is what that looks like in the log:
 
 ```python
 import sys
 
+from jsonrpcserver.result import SuccessResult
+
 handler = logging.StreamHandler(sys.stdout)
 handler.setFormatter(logging.Formatter("%(name)s %(levelname)s: %(message)s"))
 logging.getLogger("jsonrpcserver").addHandler(handler)
 
 
-def ping() -> str:
-    return "pong"  # Should be Success("pong")
+def ping() -> SuccessResult:
+    return SuccessResult("pong")  # Should be Success("pong"), or just "pong"
 
 
 dispatch('{"jsonrpc": "2.0", "method": "ping", "id": 1}', {"ping": ping})
@@ -173,11 +176,11 @@ logging.getLogger("jsonrpcserver").removeHandler(handler)
 ```
 
 ```text title="Output"
-jsonrpcserver.dispatcher ERROR: Method 'ping' returned 'pong', which is not a Result, so the client got an Internal error. Return Success(value) or Error(code, message). Since 5.0 a plain return value is not enough: https://bensynapse.github.io/jsonrpcserver/migration/
+jsonrpcserver.dispatcher ERROR: Method 'ping' returned SuccessResult('pong'), which is not a valid Result, so the client got an Internal error. Return a value, Success(value) or Error(code, message): https://bensynapse.github.io/jsonrpcserver/methods/
 ```
 
-!!! info "New in 5.0.10"
+!!! info "New in 5.0.10, changed in 5.1.0"
     The `jsonrpcserver.main` messages and this one. Before 5.0.10, a
-    serializer failure raised out of `dispatch`. A plain return value was
+    serializer failure raised out of `dispatch`. An invalid return value was
     logged with a traceback, and its explanation was also sent to the client
-    in `data`.
+    in `data`. Before 5.1.0, a plain return value was invalid too.

{jsonrpcserver-5.0.10 → jsonrpcserver-5.2.0}/docs/methods.md

@@ -47,11 +47,18 @@ A method returns `Success` or `Error`. They are the `result` and `error` parts
 of a [JSON-RPC response](https://www.jsonrpc.org/specification#response_object).
 jsonrpcserver adds the `jsonrpc` and `id` parts.
 
-!!! warning "Return `Success(value)`, not the value"
-    In 4.x a method returned its result directly. In 5.x, `return "pong"`
-    sends the client a -32603 "Internal error". From 5.0.10 the response
-    has no details, and the log says what went wrong. See
-    [Migration](migration.md).
+A method can also return its value directly. `return "pong"` sends the same
+response as `return Success("pong")`:
+
+```pycon
+>>> dispatch('{"jsonrpc": "2.0", "method": "count", "id": 1}', {"count": lambda: 3})
+'{"jsonrpc": "2.0", "result": 3, "id": 1}'
+```
+
+!!! info "New in 5.1.0"
+    Plain return values. From 5.0.0 to 5.0.10, `return "pong"` sent the client
+    a -32603 "Internal error". If your code has to run on those versions too,
+    return `Success(value)`. See [Migration](migration.md).
 
 `Success` takes the result value. If there's nothing to return, call it with
 no argument and the result is `null`:

{jsonrpcserver-5.0.10 → jsonrpcserver-5.2.0}/docs/migration.md

@@ -1,5 +1,5 @@
 ---
-description: Upgrade jsonrpcserver from 4.x to 5.x, and from 5.0.9 to 5.0.10. Side-by-side examples, removed options, and the plain return value that silently becomes an Internal error.
+description: Upgrade jsonrpcserver from 4.x to 5.x, from 5.0.9 to 5.0.10, and to 5.1.0. Side-by-side examples, removed options, and plain return values, which work again from 5.1.0.
 ---
 
 # Migration
@@ -9,9 +9,10 @@ description: Upgrade jsonrpcserver from 4.x to 5.x, and from 5.0.9 to 5.0.10. Si
 Version 5 changed how methods report their result. Most other code needs only
 small changes.
 
-!!! danger "Old methods fail with no details"
-    In 4.x a method returned its result directly. In 5.x it must return
-    `Success(result)`. A 4.x method such as
+!!! danger "Old methods fail with no details before 5.1.0"
+    In 4.x a method returned its result directly. In 5.0.x it must return
+    `Success(result)`. From 5.1.0 a plain return value works again, and
+    becomes `Success(value)`. On 5.0.x, a 4.x method such as
 
     <!-- skip: 4.x code -->
     ```python
@@ -28,6 +29,9 @@ small changes.
     Method 'ping' returned 'pong', which is not a Result, so the client got an Internal error. Return Success(value) or Error(code, message). ...
     ```
 
+    That's the 5.0.10 message. Upgrading to 5.1.0 fixes these methods
+    without a code change.
+
     If you don't see that line, configure logging (see
     [Errors and logging](errors.md#logging)). Then search your code for
     `return` statements in methods. mypy and pyright catch them too, once
@@ -85,7 +89,7 @@ print(response, 200 if response else 204)
 
 | 4.x | 5.x |
 |---|---|
-| `return value` | `return Success(value)` |
+| `return value` | `return Success(value)`. From 5.1.0 `return value` works too |
 | `raise ApiError(message, code=1, data=...)` | `return Error(code, message, data)`, or `raise JsonRpcError(code, message, data)`. Note the order: code first. |
 | `raise InvalidParamsError(...)` | `return InvalidParams(data)` |
 | `raise MethodNotFoundError` | there's no equivalent. jsonrpcserver sends "Method not found" itself |
@@ -103,7 +107,7 @@ print(response, 200 if response else 204)
 Code written for 4.x that 5.x can't run gives clear errors in most cases. The
 removed keywords raise `TypeError`, and `response.wanted` raises
 `AttributeError: 'str' object has no attribute 'wanted'`. The plain return
-value above is the one that fails quietly, and `str(response)` still works but
+value above is the one that fails quietly before 5.1.0, and `str(response)` still works but
 is no longer needed.
 
 The 4.x documentation is no longer online. The [changelog](changelog.md)

{jsonrpcserver-5.0.10 → jsonrpcserver-5.2.0}/docs/roadmap.md

@@ -6,6 +6,8 @@ description: The plan for jsonrpcserver 6.0. Results without oslash, safer defau
 
 This is the plan for the next major version. Nothing here is released yet, and
 it may change. 5.x keeps its current API, and gets bug and security fixes.
+5.1.0 took one idea from this list early: a method can return a plain value
+(#285).
 
 Discussion happens in the
 [issues](https://github.com/bensynapse/jsonrpcserver/issues) and
@@ -51,7 +53,6 @@ five request fields would be faster and lighter.
 
 **Ideas under discussion.**
 
-- Let a method return a plain value instead of `Success(value)` (#285).
 - Middleware around method calls (#126). Decorators on your own functions
   already cover most uses.
 - OpenRPC schema generation (#156), probably as a separate package.

{jsonrpcserver-5.0.10 → jsonrpcserver-5.2.0}/jsonrpcserver/__init__.py

@@ -38,5 +38,5 @@ from .methods import method
 from .result import Error, InvalidParams, Result, Success
 from .server import serve
 
-__version__ = "5.0.10"
+__version__ = "5.2.0"
 """The version of jsonrpcserver, as a string. Added in 5.0.10."""

{jsonrpcserver-5.0.10 → jsonrpcserver-5.2.0}/jsonrpcserver/async_dispatcher.py

@@ -25,9 +25,10 @@ from .dispatcher import (
     member_id,
     not_notification,
     to_response,
+    to_result,
     validate_args,
     validate_request,
-    validate_result,
+    warn_if_over_6_0_batch_limit,
 )
 from .exceptions import JsonRpcError
 from .methods import AnyMethod, MethodsArgument
@@ -51,7 +52,8 @@ async def call(
         # Plain (sync) methods work too. Their result is used as it is.
         if isawaitable(result):
             result = await result
-        validate_result(result)
+        # A plain value becomes Success(value) (5.1.0).
+        result = to_result(result)
     except JsonRpcError as exc:
         return Left(ErrorResult(code=exc.code, message=exc.message, data=exc.data))
     except InvalidResultError as exc:
@@ -61,8 +63,7 @@ async def call(
         # Other error inside method - Internal error
         logger.exception("Method %r raised an exception", request.method)
         return Left(InternalErrorResult(exception_data(exc, debug)))
-    # validate_result has checked it.
-    return cast(Result, result)
+    return result
 
 
 async def dispatch_request(
@@ -161,6 +162,7 @@ async def dispatch_to_response_pure(
             return post_process(Left(parsed._error))
         deserialized = unwrap(parsed)
         if isinstance(deserialized, list) and deserialized:
+            warn_if_over_6_0_batch_limit(len(deserialized), max_batch_size)
             if max_batch_size is not None and len(deserialized) > max_batch_size:
                 return post_process(
                     Left(BatchTooLargeResponse(len(deserialized), max_batch_size))

{jsonrpcserver-5.0.10 → jsonrpcserver-5.2.0}/jsonrpcserver/dispatcher.py

@@ -4,6 +4,7 @@ requests, providing responses.
 
 import logging
 import reprlib
+import warnings
 from functools import partial
 from inspect import iscoroutine, signature
 from itertools import starmap
@@ -32,6 +33,7 @@ from .result import (
     InvalidParamsResult,
     MethodNotFoundResult,
     Result,
+    Success,
     SuccessResult,
 )
 from .sentinels import NOCONTEXT, NODATA, NOID, Sentinel
@@ -114,12 +116,13 @@ def extract_kwargs(request: Request) -> Dict[str, Any]:
 
 
 class InvalidResultError(AssertionError):
-    """A method returned something other than Success(...) or Error(...)."""
+    """A method returned an oslash `Left` or `Right`, or a result object, that isn't a
+    Result made by Success(...) or Error(...)."""
 
     def __init__(self, result: object):
         super().__init__(
             f"The method did not return a valid Result (returned {result!r}). "
-            "Return Success(value) or Error(code, message)."
+            "Return a value, Success(value) or Error(code, message)."
         )
         self.result = result
 
@@ -143,19 +146,36 @@ def validate_result(result: object) -> None:
         raise InvalidResultError(returned)
 
 
+def to_result(result: object) -> Result:
+    """The Result for what a method returned.
+
+    A plain value becomes `Success(value)`, so `return "pong"` and
+    `return Success("pong")` send the same response. A Result made by `Success` or
+    `Error` is used as it is. An oslash `Left` or `Right` that holds something else,
+    or a bare `SuccessResult` or `ErrorResult`, raises InvalidResultError, because
+    it is nearly always a mistake, not a value meant for the client.
+
+    New in 5.1.0. Before it, any plain value gave the client an Internal error.
+    """
+    returned = result  # Not narrowed: oslash's Left and Right are generic.
+    if isinstance(result, (Left, Right, SuccessResult, ErrorResult)):
+        validate_result(returned)
+        return cast(Result, returned)
+    return Success(result)
+
+
 def log_invalid_result(
     method_name: str, exc: InvalidResultError, log: logging.Logger
 ) -> None:
-    """Log a method that returned a plain value, which 4.x allowed, without a traceback.
+    """Log a method that returned an invalid Result, without a traceback.
 
     The traceback would only point into jsonrpcserver, so the message says what to
     change instead.
     """
     log.error(
-        "Method %r returned %s, which is not a Result, so the client got an "
-        "Internal error. Return Success(value) or Error(code, message). Since 5.0 a "
-        "plain return value is not enough: "
-        "https://bensynapse.github.io/jsonrpcserver/migration/",
+        "Method %r returned %s, which is not a valid Result, so the client got an "
+        "Internal error. Return a value, Success(value) or Error(code, message): "
+        "https://bensynapse.github.io/jsonrpcserver/methods/",
         method_name,
         reprlib.repr(exc.result),
     )
@@ -188,10 +208,10 @@ def call(
                 f"Method {request.method!r} is async. Use async_dispatch to call "
                 "async methods."
             )
-        # validate_result raises AssertionError if the return value is not a valid
-        # Result, which should respond with Internal Error because its a problem in the
-        # method.
-        validate_result(result)
+        # A plain value becomes Success(value). to_result raises InvalidResultError,
+        # an AssertionError, for an invalid Result, which gets an Internal error
+        # because it's a problem in the method.
+        result = to_result(result)
     # Raising JsonRpcError inside the method is an alternative way of returning an error
     # response.
     except JsonRpcError as exc:
@@ -203,8 +223,7 @@ def call(
     except Exception as exc:
         logger.exception("Method %r raised an exception", request.method)
         return Left(InternalErrorResult(exception_data(exc, debug)))
-    # validate_result has checked it.
-    return cast(Result, result)
+    return result
 
 
 def validate_args(
@@ -369,6 +388,17 @@ def check_max_batch_size(max_batch_size: object) -> None:
         )
 
 
+def warn_if_over_6_0_batch_limit(size: int, max_batch_size: Optional[int]) -> None:
+    """Warn when a batch would get an error under 6.0's default limit of 100."""
+    if max_batch_size is None and size > 100:
+        warnings.warn(
+            f"This batch has {size} requests. 6.0 limits batches to 100 by default. "
+            "Pass max_batch_size=None to keep no limit, or set the limit you want.",
+            FutureWarning,
+            stacklevel=2,
+        )
+
+
 def member_id(member: Any) -> Any:
     """The id of a batch member, or None if it has none we can use.
 
@@ -435,6 +465,7 @@ def dispatch_to_response_pure(
             return post_process(Left(parsed._error))
         deserialized = unwrap(parsed)
         if isinstance(deserialized, list) and deserialized:
+            warn_if_over_6_0_batch_limit(len(deserialized), max_batch_size)
             if max_batch_size is not None and len(deserialized) > max_batch_size:
                 return post_process(
                     Left(BatchTooLargeResponse(len(deserialized), max_batch_size))

{jsonrpcserver-5.0.10 → jsonrpcserver-5.2.0}/jsonrpcserver/main.py

@@ -12,7 +12,9 @@ They differ only in the form of the response:
 
 import json
 import logging
+import math
 import pkgutil
+import warnings
 from typing import Any, Callable, Dict, List, Optional, Union, cast
 
 from jsonschema.validators import validator_for
@@ -41,7 +43,42 @@ from .utils import identity
 
 logger = logging.getLogger(__name__)
 
-default_deserializer = json.loads
+_CONSTANTS = {"NaN": math.nan, "Infinity": math.inf, "-Infinity": -math.inf}
+
+
+def _future_constant(constant: str) -> float:
+    warnings.warn(
+        f"{constant} in a request isn't valid JSON. 5.x accepts it, but 6.0 will "
+        "reject it with a Parse error.",
+        FutureWarning,
+        stacklevel=2,
+    )
+    return _CONSTANTS[constant]
+
+
+def _future_float(text: str) -> float:
+    number = float(text)
+    if math.isinf(number):
+        warnings.warn(
+            f"{text} in a request is too big for a float. 5.x reads it as infinity, "
+            "but 6.0 will reject it with a Parse error.",
+            FutureWarning,
+            stacklevel=2,
+        )
+    return number
+
+
+def default_deserializer(request: str) -> Any:
+    """json.loads, which warns about input 6.0 will reject.
+
+    `NaN`, `Infinity`, `-Infinity` and numbers too big for a float are accepted, as
+    in every 5.x release, with a `FutureWarning`: 6.0's default rejects them with a
+    Parse error. Pass `deserializer=json.loads` to accept them without a warning.
+    New in 5.2.0.
+    """
+    return json.loads(
+        request, parse_constant=_future_constant, parse_float=_future_float
+    )
 
 
 def default_serializer(response: Any) -> str:
@@ -121,7 +158,7 @@ def dispatch_to_response(
     methods: Optional[MethodsArgument] = None,
     *,
     context: Any = NOCONTEXT,
-    deserializer: Callable[[str], Deserialized] = json.loads,
+    deserializer: Callable[[str], Deserialized] = default_deserializer,
     validator: Callable[[Deserialized], object] = default_validator,
     post_process: Callable[[Response], Any] = identity,
     debug: bool = False,

{jsonrpcserver-5.0.10 → jsonrpcserver-5.2.0}/jsonrpcserver/methods.py

@@ -7,7 +7,8 @@ your own dict instead, pass it as the methods argument:
     dispatch(request)  # the functions registered with @method
     dispatch(request, methods={"ping": ping})  # only the functions in this dict
 
-Either way, a method returns Success(...) or Error(...), not a plain value.
+Either way, a method returns Success(...) or Error(...). From 5.1.0 it can also
+return a plain value, which becomes Success(value).
 
 A request's params are either a list (positional arguments) or an object (named
 arguments), not both. That's a JSON-RPC rule.

{jsonrpcserver-5.0.10 → jsonrpcserver-5.2.0}/jsonrpcserver/server.py

@@ -7,8 +7,9 @@ server or framework.
 import json
 import logging
 import sys
+import warnings
 from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
-from typing import Any
+from typing import Any, Optional
 
 from .main import dispatch
 from .response import ParseErrorResponse, to_error_dict
@@ -71,7 +72,7 @@ def listening_message(name: str, port: int) -> str:
     return f" * Listening on http://{name}:{port}/. This is a development server."
 
 
-def serve(name: str = "", port: int = 5000) -> None:
+def serve(name: Optional[str] = None, port: int = 5000) -> None:
     """Serve the methods registered with `@method` over HTTP. For development only.
 
     It answers POST requests on any path with `dispatch`, sends 204 No Content for a
@@ -87,9 +88,11 @@ def serve(name: str = "", port: int = 5000) -> None:
     production.
 
     Args:
-        name: The host name or address to listen on. The default, "", listens on
-            every network interface, so other machines can connect. Pass "localhost"
-            to accept only local connections.
+        name: The host name or address to listen on. Without one, it listens on
+            every network interface, so other machines can connect, and gives a
+            `FutureWarning` (5.2.0): 6.0 listens on localhost by default. Pass ""
+            to keep every interface, or "localhost" to accept only local
+            connections.
         port: The port to listen on.
 
     Example:
@@ -103,6 +106,15 @@ def serve(name: str = "", port: int = 5000) -> None:
         serve("localhost", 8000)
         ```
     """
+    if name is None:
+        warnings.warn(
+            "serve() without a host listens on every network interface. From 6.0 it "
+            'will listen on localhost only. Pass serve("", port) to keep listening '
+            'on every interface, or serve("localhost", port).',
+            FutureWarning,
+            stacklevel=2,
+        )
+        name = ""
     httpd = ThreadingHTTPServer((name, port), RequestHandler)
     try:
         message = listening_message(name, port)

{jsonrpcserver-5.0.10 → jsonrpcserver-5.2.0}/requirements/examples.txt

@@ -3,19 +3,19 @@ aiohttp==3.14.5
 django==6.1.2
 fastapi==0.162.0
 flask==3.1.3
-flask-socketio==5.7.0
+flask-socketio==5.7.2
 # FastAPI's test client, used on the Context page.
 httpx2==2.16.0
 # The quickstart calls the server with jsonrpcclient and requests.
 jsonrpcclient==4.0.3
 # The FAQ's orjson example.
 orjson==3.13.0
-python-socketio[client]==5.17.0
+python-socketio[client]==5.18.0
 pyzmq==27.2.0
 requests==2.34.2
 sanic==25.12.1
 tornado==6.6
 ujson==6.0.0
 uvicorn==0.54.0
-websockets==17.3
+websockets==17.4
 werkzeug==3.1.9

jsonrpcserver-5.2.0/requirements/lint.txt

@@ -0,0 +1,7 @@
+hypothesis==6.170.14
+mypy==2.4.1
+pyright==1.1.414
+pytest==9.2.0
+pytest-asyncio==1.4.1.post1
+ruff==0.17.3
+types-jsonschema==4.26.0.20261006

{jsonrpcserver-5.0.10 → jsonrpcserver-5.2.0}/tests/test_async_dispatcher.py

@@ -95,21 +95,29 @@ async def test_call_raising_exception_is_logged(
 
 
 @pytest.mark.asyncio
-async def test_plain_return_value_is_logged_with_a_hint(
-    caplog: pytest.LogCaptureFixture,
-) -> None:
+async def test_plain_return_value_becomes_success() -> None:
     async def method() -> str:
         return "pong"
 
+    assert await call(Request("ping", [], 1), NOCONTEXT, method) == Right(
+        SuccessResult("pong")
+    )
+
+
+@pytest.mark.asyncio
+async def test_invalid_result_is_logged_with_a_hint(
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    async def method() -> object:
+        return Right[str, Any]("pong")
+
     assert await call(Request("ping", [], 1), NOCONTEXT, method) == Left(
         ErrorResult(ERROR_INTERNAL_ERROR, "Internal error")
     )
     (record,) = caplog.records
     assert record.name == "jsonrpcserver.async_dispatcher"
     assert record.exc_info is None
-    assert record.getMessage().startswith(
-        "Method 'ping' returned 'pong', which is not a Result"
-    )
+    assert "which is not a valid Result" in record.getMessage()
 
 
 @pytest.mark.asyncio

{jsonrpcserver-5.0.10 → jsonrpcserver-5.2.0}/tests/test_batch_limit.py

@@ -47,7 +47,9 @@ def reset_calls() -> None:
 
 
 def test_no_limit_by_default() -> None:
-    assert len(json.loads(dispatch(batch(500), {"ping": ping}))) == 500
+    """5.x has no limit. From 5.2.0 a batch over 6.0's default of 100 warns."""
+    with pytest.warns(FutureWarning, match="6.0 limits batches to 100 by default"):
+        assert len(json.loads(dispatch(batch(500), {"ping": ping}))) == 500
 
 
 def test_at_the_limit() -> None:

{jsonrpcserver-5.0.10 → jsonrpcserver-5.2.0}/tests/test_dispatcher.py

@@ -49,6 +49,7 @@ from jsonrpcserver.response import (
 )
 from jsonrpcserver.result import (
     ErrorResult,
+    InternalErrorResult,
     InvalidParams,
     Result,
     Success,
@@ -512,10 +513,11 @@ def test_dispatch_to_response_pure_server_error(
 
 
 def test_dispatch_to_response_pure_invalid_result() -> None:
-    """Methods should return a Result, otherwise we get an Internal Error response."""
+    """A bare SuccessResult, not wrapped by Success(), gets an Internal Error
+    response. A plain value is fine from 5.1.0."""
 
-    def not_a_result() -> None:
-        return None
+    def not_a_result() -> object:
+        return SuccessResult(None)
 
     assert dispatch_to_response_pure(
         deserializer=default_deserializer,
@@ -529,21 +531,36 @@ def test_dispatch_to_response_pure_invalid_result() -> None:
         ErrorResponse(
             ERROR_INTERNAL_ERROR,
             "Internal error",
-            "The method did not return a valid Result (returned None). "
-            "Return Success(value) or Error(code, message).",
+            "The method did not return a valid Result "
+            "(returned SuccessResult(None)). "
+            "Return a value, Success(value) or Error(code, message).",
             1,
         )
     )
 
 
-def test_plain_return_value_is_logged_with_a_hint(
+@pytest.mark.parametrize("value", ["pong", None, 0, [1, 2], {"a": 1}, False])
+def test_plain_return_value_becomes_success(value: object) -> None:
+    """A method can return its value directly (5.1.0, #285)."""
+    response = dispatch_to_response_pure(
+        deserializer=default_deserializer,
+        validator=default_validator,
+        post_process=identity,
+        context=NOCONTEXT,
+        methods={"ping": lambda: value},
+        request='{"jsonrpc": "2.0", "method": "ping", "id": 1}',
+    )
+    assert response == Right(SuccessResponse(value, 1))
+
+
+def test_invalid_result_is_logged_with_a_hint(
     caplog: pytest.LogCaptureFixture,
 ) -> None:
-    """A 4.x-style method that returns a plain value gets a log line saying what to do,
-    not a traceback into jsonrpcserver."""
+    """An oslash Right that doesn't hold a SuccessResult is a mistake, not a value. It
+    gets a log line saying what to do, not a traceback into jsonrpcserver."""
 
-    def ping() -> str:
-        return "pong"
+    def ping() -> object:
+        return Right[str, Any]("pong")
 
     response = dispatch_to_response_pure(
         deserializer=default_deserializer,
@@ -559,9 +576,21 @@ def test_plain_return_value_is_logged_with_a_hint(
     (record,) = caplog.records
     assert record.levelname == "ERROR"
     assert record.exc_info is None
-    assert record.getMessage().startswith(
-        "Method 'ping' returned 'pong', which is not a Result, so the client got an "
-        "Internal error. Return Success(value) or Error(code, message)."
+    assert "which is not a valid Result, so the client got an Internal error. " in (
+        record.getMessage()
+    )
+    assert "Return a value, Success(value) or Error(code, message)" in (
+        record.getMessage()
+    )
+
+
+@pytest.mark.parametrize(
+    "returned",
+    [SuccessResult("pong"), ErrorResult(1, "x"), Left[Any, str]("oops")],
+)
+def test_bare_result_objects_are_invalid(returned: object) -> None:
+    assert call(Request("ping", [], 1), NOCONTEXT, lambda: returned) == Left(
+        InternalErrorResult(NODATA)
     )
 
 

jsonrpcserver-5.2.0/tests/test_future_warnings.py

@@ -0,0 +1,81 @@
+"""5.2.0 warns about the 5.x behaviour that 6.0 changes (plans/6.0.md, D12)."""
+
+import json
+import warnings
+from unittest.mock import Mock, patch
+
+import pytest
+
+from jsonrpcserver import Result, Success, dispatch, serve
+
+METHODS = {"ping": lambda: Success("pong")}
+
+
+def take_one(x: float) -> Result:
+    return Success()
+
+
+def take_two(a: float, b: float) -> Result:
+    return Success()
+
+
+def batch(size: int) -> str:
+    return json.dumps(
+        [{"jsonrpc": "2.0", "method": "ping", "id": n} for n in range(size)]
+    )
+
+
+@pytest.mark.parametrize("constant", ["NaN", "Infinity", "-Infinity"])
+def test_non_json_constants_warn(constant: str) -> None:
+    request = (
+        '{"jsonrpc": "2.0", "method": "ping", "params": [' + constant + '], "id": 1}'
+    )
+    with pytest.warns(FutureWarning, match=f"{constant} in a request isn't valid JSON"):
+        dispatch(request, {"ping": take_one})
+
+
+def test_json_loads_accepts_them_quietly() -> None:
+    request = '{"jsonrpc": "2.0", "method": "ping", "params": [NaN], "id": 1}'
+    with warnings.catch_warnings():
+        warnings.simplefilter("error")
+        dispatch(request, {"ping": take_one}, deserializer=json.loads)
+
+
+def test_ordinary_numbers_dont_warn() -> None:
+    request = '{"jsonrpc": "2.0", "method": "ping", "params": [1.5, 1e300], "id": 1}'
+    with warnings.catch_warnings():
+        warnings.simplefilter("error")
+        dispatch(request, {"ping": take_two})
+
+
+def test_batch_of_100_doesnt_warn() -> None:
+    with warnings.catch_warnings():
+        warnings.simplefilter("error")
+        dispatch(batch(100), METHODS)
+
+
+def test_batch_of_101_warns() -> None:
+    with pytest.warns(FutureWarning, match="This batch has 101 requests"):
+        dispatch(batch(101), METHODS)
+
+
+@pytest.mark.asyncio
+async def test_async_batch_of_101_warns() -> None:
+    from jsonrpcserver import async_dispatch
+
+    with pytest.warns(FutureWarning, match="This batch has 101 requests"):
+        await async_dispatch(batch(101), METHODS)
+
+
+def test_explicit_limit_doesnt_warn() -> None:
+    with warnings.catch_warnings():
+        warnings.simplefilter("error")
+        dispatch(batch(101), METHODS, max_batch_size=200)
+
+
+@patch("jsonrpcserver.server.ThreadingHTTPServer")
+def test_serve_with_a_host_doesnt_warn(server: Mock) -> None:
+    with warnings.catch_warnings():
+        warnings.simplefilter("error")
+        serve("", 5000)
+        serve("localhost", 5000)

{jsonrpcserver-5.0.10 → jsonrpcserver-5.2.0}/tests/test_robustness.py

@@ -134,7 +134,10 @@ def test_nan_allowed_with_plain_json_dumps() -> None:
 
 
 def test_infinite_id_gets_null_id() -> None:
-    response = dispatch('{"jsonrpc": "2.0", "method": "ping", "id": 1e400}', METHODS)
+    with pytest.warns(FutureWarning, match="too big for a float"):
+        response = dispatch(
+            '{"jsonrpc": "2.0", "method": "ping", "id": 1e400}', METHODS
+        )
     assert json.loads(response) == {
         "jsonrpc": "2.0",
         "error": INTERNAL_ERROR,
@@ -158,10 +161,11 @@ def test_serializer_that_always_fails() -> None:
 
 
 def test_builtin_without_signature() -> None:
-    """max has no signature inspect can read. It used to collapse the batch."""
+    """max has no signature inspect can read. It used to collapse the batch. From
+    5.1.0 its plain return value is the result."""
     batch = [{**request("max", 1), "params": [1, 2]}, request("ping", 2)]
     assert json.loads(dispatch(json.dumps(batch), METHODS)) == [
-        {"jsonrpc": "2.0", "error": INTERNAL_ERROR, "id": 1},
+        {"jsonrpc": "2.0", "result": 2, "id": 1},
         {"jsonrpc": "2.0", "result": "pong", "id": 2},
     ]
 
@@ -290,9 +294,10 @@ def test_invalid_result_under_optimize_flag() -> None:
         "import json, logging\n"
         "logging.disable(logging.CRITICAL)\n"
         "from jsonrpcserver import dispatch, Success\n"
+        "from oslash.either import Right\n"
         "batch = [{'jsonrpc': '2.0', 'method': 'none', 'id': 1},"
         " {'jsonrpc': '2.0', 'method': 'ping', 'id': 2}]\n"
-        "methods = {'none': lambda: None, 'ping': lambda: Success('pong')}\n"
+        "methods = {'none': lambda: Right(None), 'ping': lambda: Success('pong')}\n"
         "print(dispatch(json.dumps(batch), methods))\n"
     )
     output = subprocess.run(

{jsonrpcserver-5.0.10 → jsonrpcserver-5.2.0}/tests/test_server.py

@@ -18,7 +18,8 @@ from jsonrpcserver.server import RequestHandler, listening_message, serve
 
 @patch("jsonrpcserver.server.ThreadingHTTPServer")
 def test_serve(server: Mock) -> None:
-    serve()
+    with pytest.warns(FutureWarning, match="From 6.0 it will listen on localhost"):
+        serve()
     server.assert_called_once_with(("", 5000), RequestHandler)
     server.return_value.serve_forever.assert_called_once_with()
     server.return_value.server_close.assert_called_once_with()
@@ -34,7 +35,7 @@ def test_serve_name_and_port(server: Mock) -> None:
 def test_serve_closes_on_interrupt(server: Mock) -> None:
     server.return_value.serve_forever.side_effect = KeyboardInterrupt
     with pytest.raises(KeyboardInterrupt):
-        serve()
+        serve("", 5000)
     server.return_value.server_close.assert_called_once_with()
 
 

jsonrpcserver-5.0.10/requirements/lint.txt

@@ -1,7 +0,0 @@
-hypothesis==6.170.12
-mypy==2.4.0
-pyright==1.1.414
-pytest==9.1.1
-pytest-asyncio==1.4.1
-ruff==0.17.3
-types-jsonschema==4.26.0.20261006