jsonrpcserver 5.1.0__tar.gz → 5.2.0__tar.gz

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

@@ -1,5 +1,23 @@
 # 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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: jsonrpcserver
-Version: 5.1.0
+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>

{jsonrpcserver-5.1.0 → 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.1.0"
+__version__ = "5.2.0"
 """The version of jsonrpcserver, as a string. Added in 5.0.10."""

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

@@ -28,6 +28,7 @@ from .dispatcher import (
     to_result,
     validate_args,
     validate_request,
+    warn_if_over_6_0_batch_limit,
 )
 from .exceptions import JsonRpcError
 from .methods import AnyMethod, MethodsArgument
@@ -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.1.0 → 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
@@ -387,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.
 
@@ -453,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.1.0 → 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.1.0 → 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.1.0 → 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.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.1.0 → 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,

{jsonrpcserver-5.1.0 → 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()