jsonrpcserver 5.0.10__tar.gz → 5.1.0__tar.gz

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

@@ -1,5 +1,21 @@
 # Changelog
 
+## 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.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: jsonrpcserver
-Version: 5.0.10
+Version: 5.1.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.1.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.1.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.1.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.1.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.1.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.1.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.1.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.1.0"
 """The version of jsonrpcserver, as a string. Added in 5.0.10."""

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

@@ -25,9 +25,9 @@ from .dispatcher import (
     member_id,
     not_notification,
     to_response,
+    to_result,
     validate_args,
     validate_request,
-    validate_result,
 )
 from .exceptions import JsonRpcError
 from .methods import AnyMethod, MethodsArgument
@@ -51,7 +51,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 +62,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(

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

@@ -32,6 +32,7 @@ from .result import (
     InvalidParamsResult,
     MethodNotFoundResult,
     Result,
+    Success,
     SuccessResult,
 )
 from .sentinels import NOCONTEXT, NODATA, NOID, Sentinel
@@ -114,12 +115,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 +145,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 +207,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 +222,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(

{jsonrpcserver-5.0.10 → jsonrpcserver-5.1.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.1.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.1.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.1.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.1.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.0.10 → jsonrpcserver-5.1.0}/tests/test_robustness.py

@@ -158,10 +158,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 +291,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/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