serverwamp 1.2.0__tar.gz → 2.0.0__tar.gz

{serverwamp-1.2.0 → serverwamp-2.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: serverwamp
-Version: 1.2.0
+Version: 2.0.0
 Summary: Components that add Web Application Messaging Protocol features to WebSocket servers.
 Project-URL: Homepage, https://github.com/JustinTArthur/serverwamp
 Project-URL: Documentation, https://serverwamp.readthedocs.io/
@@ -14,11 +14,6 @@ Classifier: Framework :: Trio
 Classifier: Intended Audience :: Developers
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.6
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
@@ -26,11 +21,14 @@ Classifier: Programming Language :: Python :: 3.14
 Classifier: Programming Language :: Python :: 3.15
 Classifier: Topic :: Internet
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Python: >=3.6
-Requires-Dist: dataclasses~=0.6; python_version < '3.7'
+Requires-Python: >=3.11
 Requires-Dist: msgpack<2,>=1.0.0
+Provides-Extra: anyio
+Requires-Dist: anyio>=4.0; extra == 'anyio'
 Provides-Extra: docs
-Requires-Dist: sphinx<10,>=9.1; extra == 'docs'
+Requires-Dist: sphinx<10,>=5.3; extra == 'docs'
+Provides-Extra: trio
+Requires-Dist: trio>=0.25.0; extra == 'trio'
 Description-Content-Type: text/markdown
 
 # serverwamp
@@ -70,7 +68,6 @@ async def delete_doc(document_id):
 @docs_events.route('docs.changes')
 async def subscribe_to_doc_changes(session, changes_subscribers):
     changes_subscribers.add(session)
-    session.send_event(args=('Thanks for subscribing!',))
     yield
     changes_subscribers.remove(session)
 
@@ -79,8 +76,12 @@ async def server_context(app):
 
     async def watch_for_docs_changes():
         async for event in my_db.watch_changes():
-            for session in app['changes_subscribers']:
-                await session.send_event(f'Document changed: {event}')
+            # A copy, as sessions can unsubscribe while events are sent.
+            for session in list(app['changes_subscribers']):
+                await session.send_event(
+                    'docs.changes',
+                    args=(f'Document changed: {event}',)
+                )
 
     watcher = asyncio.create_task(watch_for_docs_changes())
     try:
@@ -113,3 +114,8 @@ Unit tests can be run with:
 
     pip install -e . --group ci
     pytest
+
+Linting and type checking can be run with:
+
+    ruff check serverwamp tests examples
+    mypy serverwamp

{serverwamp-1.2.0 → serverwamp-2.0.0}/README.md

@@ -35,7 +35,6 @@ async def delete_doc(document_id):
 @docs_events.route('docs.changes')
 async def subscribe_to_doc_changes(session, changes_subscribers):
     changes_subscribers.add(session)
-    session.send_event(args=('Thanks for subscribing!',))
     yield
     changes_subscribers.remove(session)
 
@@ -44,8 +43,12 @@ async def server_context(app):
 
     async def watch_for_docs_changes():
         async for event in my_db.watch_changes():
-            for session in app['changes_subscribers']:
-                await session.send_event(f'Document changed: {event}')
+            # A copy, as sessions can unsubscribe while events are sent.
+            for session in list(app['changes_subscribers']):
+                await session.send_event(
+                    'docs.changes',
+                    args=(f'Document changed: {event}',)
+                )
 
     watcher = asyncio.create_task(watch_for_docs_changes())
     try:
@@ -78,3 +81,8 @@ Unit tests can be run with:
 
     pip install -e . --group ci
     pytest
+
+Linting and type checking can be run with:
+
+    ruff check serverwamp tests examples
+    mypy serverwamp

serverwamp-2.0.0/docs/changelog.rst

@@ -0,0 +1,264 @@
+Changelog
+=========
+
+.. _serverwamp-changelog-2.0.0:
+
+2.0.0
+-----
+
+* Rename session state handlers to session lifespan handlers
+  (``add_session_lifespan_handler()``, ``SessionLifespanHandler``,
+  ``Realm.session_lifespan_handlers`` and
+  ``authed_session_lifespan_handlers``). The old names are deprecated.
+* Fix session lifespan and subscription handlers getting arguments in the wrong
+  parameters when one isn't ``session``, a default arg, or a subscription
+  handler's ``topic_uri``. Such a parameter now keeps its default value, or the
+  handler fails with a ``TypeError`` naming it.
+* Answer subscription handler errors with ``wamp.error.runtime_error``, and end
+  sessions whose session lifespan handlers fail to start with that reason,
+  instead of failing the connection without a reply. Errors are logged, and no
+  longer stop other teardown.
+* Send events for a subscription only after its SUBSCRIBED. Events sent while
+  its handler runs, such as a first event from the handler, are held until
+  then.
+* Add ``serverwamp.SubscribeError`` for subscription handlers to raise to
+  answer a SUBSCRIBE with an error, such as ``wamp.error.not_authorized``.
+* Require Python 3.11 or newer. ``serverwamp.context``, a backport of
+  ``contextlib.asynccontextmanager`` for older Pythons, is removed.
+* Build the asyncio support on ``asyncio.TaskGroup``. As with Trio and AnyIO,
+  task group failures, including unhandled errors while handling a connection,
+  are raised as an ``ExceptionGroup`` instead of the first error alone, and a
+  failing task interrupts the code that started the group.
+* Support current AnyIO and Trio releases, now requiring AnyIO 4 or newer and
+  Trio 0.25 or newer. They can be installed with serverwamp's ``anyio`` and
+  ``trio`` extras.
+* Abort sessions for protocol errors with ``wamp.error.protocol_violation``,
+  per WAMP spec, instead of ``wamp.error.protocol_error``.
+* Handle these client mistakes instead of failing in the connection handler:
+
+  * WebSocket messages that aren't valid JSON or MessagePack, WAMP messages
+    that are too short or have fields of the wrong type, and HELLO after the
+    session is established abort the session with a protocol violation. Message
+    types must be integers, so ``1.0`` and ``true`` are no longer accepted as
+    HELLO.
+  * UNSUBSCRIBE for a subscription the session doesn't have is answered with
+    ``wamp.error.no_such_subscription``.
+  * SUBSCRIBE for a topic without a route is answered with
+    ``wamp.error.invalid_uri``.
+  * HELLO with a null ``authmethods`` that no transport authenticator
+    identifies is aborted with ``wamp.error.authentication_failed``.
+
+* Fix GOODBYE details and reason being read from the wrong fields.
+  ``WAMPGoodbyeRequest`` no longer has a ``request_id``.
+* Give GOODBYE messages a reason instead of none. Replies to a client's GOODBYE
+  and ``WAMPSession.close()`` without a reason use
+  ``wamp.close.goodbye_and_out``, and ``Application.close_sessions()`` uses
+  ``wamp.close.system_shutdown``.
+* End sessions once GOODBYE has been exchanged, instead of when the client
+  disconnects. Subscription and session lifespan handler teardown run then, and
+  the client can start a new session on the same connection with HELLO, as the
+  WAMP spec allows.
+
+  * After the session sends GOODBYE, messages from the client other than its
+    GOODBYE in reply are ignored, per WAMP spec.
+  * Sending for a session that has ended raises
+    ``serverwamp.ConnectionClosed``, including from call handlers still running
+    and from ``send_event()``.
+  * ``Application.handle_session()`` returns whether the session ended with
+    GOODBYE.
+
+* Fix prefix and regex routes handling URIs they don't match. A call or
+  subscription for a URI without an exact route went to the first prefix or
+  regex route added.
+
+  * Applications relying on this should add a catch-all route such as
+    ``prefix_route('')`` after their other prefix and regex routes.
+
+* Answer SUBSCRIBE for a topic the session is already subscribed to with the
+  existing subscription, without running the subscription handler again.
+* Fix RPCs that finish after their client disconnected logging errors,
+  cancelling the session's other calls, and keeping the session in memory.
+
+  * Sends to a disconnected client raise ``serverwamp.ConnectionClosed``, a
+    ``ConnectionError``, instead of the transport's own exception.
+  * ``WAMPSession.close()`` and ``abort()`` succeed when the client already
+    left.
+  * Unhandled exceptions from a session's tasks are logged. With Trio or AnyIO,
+    they no longer end the session.
+
+* Run progressive RPC handlers' ``finally`` blocks as soon as their call is
+  handled, instead of at garbage collection.
+* Wait for tasks started with ``WAMPSession.spawn_task()`` while a session
+  ends, instead of cancelling them.
+* Fix sessions never being cleaned up with Trio. Teardown after ``yield`` in
+  subscription and session lifespan handlers now runs, and ended sessions are
+  no longer kept in memory.
+* Fix ASGI apps failing on anything other than a WebSocket. HTTP requests are
+  answered with 426 Upgrade Required without an error, and lifespan startup and
+  shutdown are acknowledged, so an app from ``asgi_application()`` can be
+  served directly.
+* Rename ``serverwamp.adapters.asgi.ASGIWebSocketConection`` to
+  ``ASGIWebSocketConnection``.
+* Reject WebSocket connections that offer none of the supported WAMP
+  subprotocols, with 400 Bad Request with aiohttp and 403 Forbidden from ASGI
+  servers. aiohttp upgraded them and then failed in the request handler, and
+  ASGI accepted them with ``wamp.2.msgpack.batched``, which the client hadn't
+  offered.
+* Fix how RPC handlers' parameters are filled:
+
+  * Handlers given to ``set_rpc_handler()`` failed on every call unless their
+    parameter was named ``rpc_request``.
+  * Route handlers with keyword-only parameters failed on every call. ``*args``
+    and ``**kwargs`` now get the call's leftover arguments.
+  * Callers could override default args. Parameters named for a default arg now
+    always get its value.
+
+* Answer RPC arguments that can't be converted to their parameter's annotated
+  type with ``wamp.error.invalid_argument``, per WAMP spec, instead of
+  ``wamp.error.runtime_error``. Only class annotations are converted to, so
+  parameters annotated like ``int | None`` get arguments as they are instead of
+  failing, and parameters' own default values are no longer converted.
+
+.. _serverwamp-changelog-1.2.0:
+
+1.2.0
+-----
+
+* Fix the default realm never being used. Sessions requesting a realm that
+  wasn't added with ``add_realm`` now join the default realm as documented
+  instead of being aborted with ``wamp.error.no_such_realm``.
+
+  * To reject realms that weren't added, use
+    ``Application(allow_default_realm=False)``. Configuring the default realm
+    through the application (e.g. ``add_rpc_routes``) then raises a
+    ``RuntimeError`` instead of an ``AttributeError``.
+
+* Fix single RPC return values (e.g. ``return 'hello'``) being sent as the
+  result arguments themselves instead of as a single-element argument list.
+
+  * Returning ``None`` still sends a result without arguments. Return ``None,``
+    to send ``None`` as the single argument.
+
+* Support Python 3.14 and 3.15, and allow msgpack 1.x releases newer than 1.0.
+* Package with pyproject.toml and hatchling.
+* Fix aiohttp logging request handler errors when the server ended a
+  connection.
+* Fix ``wamp.2.json.batched`` sessions being aborted with a protocol error, and
+  batched JSON messages containing line breaks being dropped.
+* Fix ASGI ``wamp.2.json`` sessions failing on the first message sent to the
+  client.
+* Fix ``Application(synchronize_requests=True)`` failing every session on its
+  first request after the welcome.
+* Fix messages batched in the same WebSocket message as a client's HELLO being
+  dropped.
+* Declare public names in ``__all__`` so strict type checkers accept imports
+  such as ``serverwamp.Application``.
+
+.. _serverwamp-changelog-1.1.2:
+
+1.1.2
+-----
+
+* Fix standard library json support.
+
+.. _serverwamp-changelog-1.1.1:
+
+1.1.1
+-----
+
+* Support session close goodbye message.
+
+.. _serverwamp-changelog-1.0.7:
+
+1.0.7
+-----
+
+* Fix using deprecated collections.Sequence.
+* WAMP-compliant msgpack batch processing
+
+  * Fixes Autobahn|Python out-of-box compatibility.
+
+* Allow unauthenticated sessions if no authenticators configured.
+
+  * ``session.identity`` is ``None`` in this case.
+
+.. _serverwamp-changelog-1.0.6:
+
+1.0.6
+-----
+
+* Server now responds with error when unsubscribing from non-subscribed topic.
+* Temporarily synchronize subscribe/unsubscribe messages.
+
+  * Synchronization will be made configurable by request type in a future
+    version.
+
+* Fix for exception raised in trying to process protocol messages from a
+  canceled connection.
+
+.. _serverwamp-changelog-1.0.5:
+
+1.0.5
+-----
+
+* Fix error in SCRAM nonce generation
+* Fix lack of response to clients' unsubscribe requests
+* Fix for exception raised in trying to process protocol messages from a
+  canceled connection.
+
+.. _serverwamp-changelog-1.0.4:
+
+1.0.4
+-----
+
+* aiohttp sessions now cancellable by server shutdown
+* Session cleanup operations specifically shielded from cancellation
+* Added Application.close_sessions method (undocumented)
+
+.. _serverwamp-changelog-1.0.3:
+
+1.0.3
+-----
+
+* Fix for plain topic routes raising exception during registration. `Issue #4
+  <https://github.com/JustinTArthur/serverwamp/issues/4>`_
+* Exceptions in user-supplied RPC code no longer crash the app, but instead
+  return a wamp.error.runtime_error to the caller like Crossbar.io's toolchain.
+
+.. _serverwamp-changelog-1.0.2:
+
+1.0.2
+-----
+
+* Add "http_headers_raw" transport_info item for aiohttp and ASGI connections.
+
+.. _serverwamp-changelog-1.0.1:
+
+1.0.1
+-----
+
+* Fix stopasynciteration exception on session close with outstanding
+  subscriptions.
+
+.. _serverwamp-changelog-1.0.0:
+
+1.0.0
+-----
+
+Brand new API with…
+
+* Support for multiple realms w/ separate handlers
+* Context-manager-friendly subscription handlers
+* Session state handlers.
+* Routes configuration for topics similar to RPC.
+* Slightly more structured concurrency on the asyncio side.
+* Transport authenticators, ticket authenticators, and CRA auth.
+
+Released 2020-05-07 alongside new documentation.
+
+.. _serverwamp-changelog-0.2.3:
+
+0.2.3
+-----
+
+Transport auth, RPC and subscriptions now working.

{serverwamp-1.2.0 → serverwamp-2.0.0}/pyproject.toml

@@ -4,11 +4,11 @@ build-backend = "hatchling.build"
 
 [project]
 name = "serverwamp"
-version = "1.2.0"
+version = "2.0.0"
 description = "Components that add Web Application Messaging Protocol features to WebSocket servers."
 readme = "README.md"
 license = "MIT"
-requires-python = ">=3.6"
+requires-python = ">=3.11"
 authors = [
     { name = "Justin Turner Arthur", email = "justinarthur@gmail.com" },
 ]
@@ -19,11 +19,6 @@ keywords = [
 classifiers = [
     "Programming Language :: Python",
     "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.6",
-    "Programming Language :: Python :: 3.7",
-    "Programming Language :: Python :: 3.8",
-    "Programming Language :: Python :: 3.9",
-    "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
@@ -37,13 +32,18 @@ classifiers = [
     "Framework :: Trio",
 ]
 dependencies = [
-    "dataclasses~=0.6;python_version<'3.7'",
     "msgpack>=1.0.0,<2",
 ]
 
 [project.optional-dependencies]
+anyio = [
+    "anyio>=4.0",
+]
+trio = [
+    "trio>=0.25.0",
+]
 docs = [
-    "Sphinx>=9.1,<10",
+    "Sphinx>=5.3,<10",
 ]
 
 [project.urls]
@@ -53,15 +53,32 @@ Documentation = "https://serverwamp.readthedocs.io/"
 [dependency-groups]
 ci = [
     "aiohttp>=3.0.0",
+    "anyio>=4.0",
+    "msgpack-types>=0.8.0",
     "mypy>=0.770",
-    "pytest>=5.4.1",
-    "trio>=0.12.0",
+    "pytest>=8.0",
+    "ruff>=0.17.1,<0.18",
+    "trio>=0.25.0",
 ]
 
+[tool.ruff]
+line-length = 99
+
+[tool.ruff.lint]
+# Ruff's default rules, as of 0.17, are far broader than these.
+select = ["E4", "E7", "E9", "F", "E501", "I", "Q", "UP"]
+
+[tool.ruff.lint.flake8-quotes]
+inline-quotes = "single"
+
+[tool.ruff.lint.isort]
+# Helper modules the tests import from their own directory.
+known-local-folder = ["memory_connection", "stream_connection"]
+
 [tool.hatch.build.targets.sdist]
 include = [
     "/serverwamp",
-    "/CHANGELOG.md",
+    "/docs/changelog.rst",
     "/LICENSE.md",
     "/README.md",
 ]

serverwamp-2.0.0/serverwamp/__init__.py

@@ -0,0 +1,17 @@
+from serverwamp.application import Application, Realm
+from serverwamp.connection import ConnectionClosed
+from serverwamp.events import SubscribeError, TopicRouteSet
+from serverwamp.rpc import RPCErrorResult, RPCProgressReport, RPCRequest, RPCResult, RPCRouteSet
+
+__all__ = (
+    'Application',
+    'ConnectionClosed',
+    'Realm',
+    'RPCErrorResult',
+    'RPCProgressReport',
+    'RPCRequest',
+    'RPCResult',
+    'RPCRouteSet',
+    'SubscribeError',
+    'TopicRouteSet',
+)

{serverwamp-1.2.0 → serverwamp-2.0.0}/serverwamp/adapters/aiohttp.py

@@ -1,16 +1,15 @@
 from abc import ABCMeta
+from collections.abc import Mapping
 from ssl import SSLObject
-from typing import Optional
 
 import aiohttp
 import msgpack
 from aiohttp import WSMsgType, web
 
-from serverwamp.connection import Connection
-from serverwamp.helpers import objects_from_msgpack_batch, pack_uint32_be
-from serverwamp.json import JSON_BATCH_SPLITTER
-from serverwamp.json import deserialize as deserialize_json
-from serverwamp.json import objects_from_json_batch
+from serverwamp.connection import Connection, ConnectionClosed
+from serverwamp.helpers import object_from_msgpack, objects_from_msgpack_batch, pack_uint32_be
+from serverwamp.json import JSON_BATCH_SPLITTER, objects_from_json_batch
+from serverwamp.json import deserialize_msg as deserialize_json
 from serverwamp.json import serialize as serialize_json
 
 SUPPORTED_WS_PROTOCOLS = (
@@ -23,9 +22,15 @@ SUPPORTED_WS_PROTOCOLS = (
 
 async def connection_for_aiohttp_request(request: aiohttp.web.Request):
     ws = web.WebSocketResponse(protocols=SUPPORTED_WS_PROTOCOLS)
+    ws_protocol = ws.can_prepare(request).protocol
+    if ws_protocol is None:
+        # WAMP must be negotiated as a WebSocket subprotocol.
+        raise web.HTTPBadRequest(
+            text='A supported WAMP WebSocket subprotocol is required.'
+        )
     await ws.prepare(request)
 
-    construct_connection = ws_protocol_connection_classes[ws.ws_protocol]
+    construct_connection = ws_protocol_connection_classes[ws_protocol]
     connection = construct_connection(ws, request)
     return connection
 
@@ -51,7 +56,7 @@ class AiohttpWebSocketConnection(Connection, metaclass=ABCMeta):
             self.transport_info['peer_certificate'] = (
                 request.transport.get_extra_info('peercert')
             )
-            ssl_obj: Optional[SSLObject] = (
+            ssl_obj: SSLObject | None = (
                 request.transport.get_extra_info('ssl_object')
             )
             if ssl_obj:
@@ -75,10 +80,11 @@ class AiohttpJSONWebSocketConnection(AiohttpWebSocketConnection):
                 yield deserialize_json(ws_msg.data)
 
     async def send_msg(self, msg):
-        await self._ws.send_json(
-            msg,
-            compress=self._compress_outbound
-        )
+        try:
+            await self._ws.send_json(msg, compress=self._compress_outbound)
+        except ConnectionResetError:
+            # aiohttp raises this when writing to a closing transport.
+            raise ConnectionClosed() from None
 
 
 class AiohttpBatchedJSONWebSocketConnection(AiohttpWebSocketConnection):
@@ -89,32 +95,41 @@ class AiohttpBatchedJSONWebSocketConnection(AiohttpWebSocketConnection):
                     yield msg
 
     async def send_msg(self, msg):
-        await self._ws.send_str(
-            serialize_json(msg) + JSON_BATCH_SPLITTER,
-            compress=self._compress_outbound
-        )
+        try:
+            await self._ws.send_str(
+                serialize_json(msg) + JSON_BATCH_SPLITTER,
+                compress=self._compress_outbound
+            )
+        except ConnectionResetError:
+            raise ConnectionClosed() from None
 
     async def send_msgs(self, msgs):
-        await self._ws.send_str(
-            JSON_BATCH_SPLITTER.join(
-                [serialize_json(msg) for msg in msgs]
-            ) + JSON_BATCH_SPLITTER,
-            compress=self._compress_outbound
-        )
+        try:
+            await self._ws.send_str(
+                JSON_BATCH_SPLITTER.join(
+                    [serialize_json(msg) for msg in msgs]
+                ) + JSON_BATCH_SPLITTER,
+                compress=self._compress_outbound
+            )
+        except ConnectionResetError:
+            raise ConnectionClosed() from None
 
 
 class AiohttpMsgPackWebSocketConnection(AiohttpWebSocketConnection):
     async def iterate_msgs(self):
         async for ws_msg in self._ws:
             if ws_msg.type == WSMsgType.BINARY:
-                yield msgpack.unpackb(ws_msg.data, use_list=False)
+                yield object_from_msgpack(ws_msg.data)
 
     async def send_msg(self, msg):
         msg_bytes = msgpack.packb(msg)
-        await self._ws.send_bytes(
-            msg_bytes,
-            compress=self._compress_outbound
-        )
+        try:
+            await self._ws.send_bytes(
+                msg_bytes,
+                compress=self._compress_outbound
+            )
+        except ConnectionResetError:
+            raise ConnectionClosed() from None
 
 
 class AiohttpBatchedMsgPackWebSocketConnection(AiohttpWebSocketConnection):
@@ -129,10 +144,13 @@ class AiohttpBatchedMsgPackWebSocketConnection(AiohttpWebSocketConnection):
     async def send_msg(self, msg):
         msg_bytes = msgpack.packb(msg)
         msg_len_bytes = pack_uint32_be(len(msg_bytes))
-        await self._ws.send_bytes(
-            msg_len_bytes + msg_bytes,
-            compress=self._compress_outbound
-        )
+        try:
+            await self._ws.send_bytes(
+                msg_len_bytes + msg_bytes,
+                compress=self._compress_outbound
+            )
+        except ConnectionResetError:
+            raise ConnectionClosed() from None
 
     async def send_msgs(self, msgs):
         batch_bytes = bytearray()
@@ -141,13 +159,18 @@ class AiohttpBatchedMsgPackWebSocketConnection(AiohttpWebSocketConnection):
             msg_len_bytes = pack_uint32_be(len(msg_bytes))
             batch_bytes += msg_len_bytes
             batch_bytes += msg_bytes
-        await self._ws.send_bytes(
-            batch_bytes,
-            compress=self._compress_outbound
-        )
+        try:
+            await self._ws.send_bytes(
+                batch_bytes,
+                compress=self._compress_outbound
+            )
+        except ConnectionResetError:
+            raise ConnectionClosed() from None
 
 
-ws_protocol_connection_classes = {
+ws_protocol_connection_classes: Mapping[
+    str, type[AiohttpWebSocketConnection]
+] = {
     'wamp.2.msgpack': AiohttpMsgPackWebSocketConnection,
     'wamp.2.msgpack.batched': AiohttpBatchedMsgPackWebSocketConnection,
     'wamp.2.json': AiohttpJSONWebSocketConnection,

{serverwamp-1.2.0 → serverwamp-2.0.0}/serverwamp/adapters/anyio.py

@@ -1,9 +1,10 @@
+from contextlib import asynccontextmanager
 from functools import partial
 
 import anyio
+import anyio.abc
 
 from serverwamp.adapters.async_base import AsyncSupport, AsyncTaskGroup
-from serverwamp.context import asynccontextmanager
 
 
 class AnyioAsyncSupport(AsyncSupport):
@@ -15,30 +16,26 @@ class AnyioAsyncSupport(AsyncSupport):
             yield task_group
 
     @classmethod
-    @asynccontextmanager
     async def shield(
         cls,
         callback,
         *callback_args,
         **callback_kwargs
     ):
-        async with anyio.open_cancel_scope(shield=True):
-            await callback(*callback_args, **callback_kwargs)
+        with anyio.CancelScope(shield=True):
+            return await callback(*callback_args, **callback_kwargs)
 
 
 class AnyioTaskGroup(AsyncTaskGroup):
     """In anyio's case, this is just a light wrapper around its own TaskGroup.
     """
-    def __init__(self, anyio_task_group: anyio.TaskGroup):
+    def __init__(self, anyio_task_group: anyio.abc.TaskGroup):
         self._anyio_task_group = anyio_task_group
 
     async def spawn(self, callback, *callback_args, **callback_kwargs):
         if callback_kwargs:
             callback = partial(callback, **callback_kwargs)
-
-        await self._anyio_task_group.spawn(
-            callback, *callback_args, **callback_kwargs
-        )
+        self._anyio_task_group.start_soon(callback, *callback_args)
 
     async def cancel(self):
-        await self._anyio_task_group.cancel_scope.cancel()
+        self._anyio_task_group.cancel_scope.cancel()