Group parameters more logically.

Author: aaugustin

src/websockets/asyncio/client.py

@@ -200,14 +200,14 @@ class connect:
             should be negotiated and run.
         subprotocols: List of supported subprotocols, in order of decreasing
             preference.
+        compression: The "permessage-deflate" extension is enabled by default.
+            Set ``compression`` to :obj:`None` to disable it. See the
+            :doc:`compression guide <../../topics/compression>` for details.
         additional_headers (HeadersLike | None): Arbitrary HTTP headers to add
             to the handshake request.
         user_agent_header: Value of  the ``User-Agent`` request header.
             It defaults to ``"Python/x.y.z websockets/X.Y"``.
             Setting it to :obj:`None` removes the header.
-        compression: The "permessage-deflate" extension is enabled by default.
-            Set ``compression`` to :obj:`None` to disable it. See the
-            :doc:`compression guide <../../topics/compression>` for details.
         process_exception: When reconnecting automatically, tell whether an
             error is transient or fatal. The default behavior is defined by
             :func:`process_exception`. Refer to its documentation for details.
@@ -275,9 +275,10 @@ def __init__(
         origin: Origin | None = None,
         extensions: Sequence[ClientExtensionFactory] | None = None,
         subprotocols: Sequence[Subprotocol] | None = None,
+        compression: str | None = "deflate",
+        # HTTP
         additional_headers: HeadersLike | None = None,
         user_agent_header: str | None = USER_AGENT,
-        compression: str | None = "deflate",
         process_exception: Callable[[Exception], Exception | None] = process_exception,
         # Timeouts
         open_timeout: float | None = 10,

src/websockets/asyncio/server.py

@@ -617,6 +617,9 @@ def handler(websocket):
             it has the same behavior as the
             :meth:`ServerProtocol.select_subprotocol
             <websockets.server.ServerProtocol.select_subprotocol>` method.
+        compression: The "permessage-deflate" extension is enabled by default.
+            Set ``compression`` to :obj:`None` to disable it. See the
+            :doc:`compression guide <../../topics/compression>` for details.
         process_request: Intercept the request during the opening handshake.
             Return an HTTP response to force the response or :obj:`None` to
             continue normally. When you force an HTTP 101 Continue response, the
@@ -630,9 +633,6 @@ def handler(websocket):
         server_header: Value of  the ``Server`` response header.
             It defaults to ``"Python/x.y.z websockets/X.Y"``. Setting it to
             :obj:`None` removes the header.
-        compression: The "permessage-deflate" extension is enabled by default.
-            Set ``compression`` to :obj:`None` to disable it. See the
-            :doc:`compression guide <../../topics/compression>` for details.
         open_timeout: Timeout for opening connections in seconds.
             :obj:`None` disables the timeout.
         ping_interval: Interval between keepalive pings in seconds.
@@ -694,6 +694,8 @@ def __init__(
             ]
             | None
         ) = None,
+        compression: str | None = "deflate",
+        # HTTP
         process_request: (
             Callable[
                 [ServerConnection, Request],
@@ -709,7 +711,6 @@ def __init__(
             | None
         ) = None,
         server_header: str | None = SERVER,
-        compression: str | None = "deflate",
         # Timeouts
         open_timeout: float | None = 10,
         ping_interval: float | None = 20,

src/websockets/sync/client.py

@@ -135,9 +135,10 @@ def connect(
     origin: Origin | None = None,
     extensions: Sequence[ClientExtensionFactory] | None = None,
     subprotocols: Sequence[Subprotocol] | None = None,
+    compression: str | None = "deflate",
+    # HTTP
     additional_headers: HeadersLike | None = None,
     user_agent_header: str | None = USER_AGENT,
-    compression: str | None = "deflate",
     # Timeouts
     open_timeout: float | None = 10,
     ping_interval: float | None = 20,
@@ -180,14 +181,14 @@ def connect(
             should be negotiated and run.
         subprotocols: List of supported subprotocols, in order of decreasing
             preference.
+        compression: The "permessage-deflate" extension is enabled by default.
+            Set ``compression`` to :obj:`None` to disable it. See the
+            :doc:`compression guide <../../topics/compression>` for details.
         additional_headers (HeadersLike | None): Arbitrary HTTP headers to add
             to the handshake request.
         user_agent_header: Value of  the ``User-Agent`` request header.
             It defaults to ``"Python/x.y.z websockets/X.Y"``.
             Setting it to :obj:`None` removes the header.
-        compression: The "permessage-deflate" extension is enabled by default.
-            Set ``compression`` to :obj:`None` to disable it. See the
-            :doc:`compression guide <../../topics/compression>` for details.
         open_timeout: Timeout for opening the connection in seconds.
             :obj:`None` disables the timeout.
         ping_interval: Interval between keepalive pings in seconds.

src/websockets/sync/server.py

@@ -340,6 +340,8 @@ def serve(
         ]
         | None
     ) = None,
+    compression: str | None = "deflate",
+    # HTTP
     process_request: (
         Callable[
             [ServerConnection, Request],
@@ -355,7 +357,6 @@ def serve(
         | None
     ) = None,
     server_header: str | None = SERVER,
-    compression: str | None = "deflate",
     # Timeouts
     open_timeout: float | None = 10,
     ping_interval: float | None = 20,
@@ -423,6 +424,9 @@ def handler(websocket):
             it has the same behavior as the
             :meth:`ServerProtocol.select_subprotocol
             <websockets.server.ServerProtocol.select_subprotocol>` method.
+        compression: The "permessage-deflate" extension is enabled by default.
+            Set ``compression`` to :obj:`None` to disable it. See the
+            :doc:`compression guide <../../topics/compression>` for details.
         process_request: Intercept the request during the opening handshake.
             Return an HTTP response to force the response. Return :obj:`None` to
             continue normally. When you force an HTTP 101 Continue response, the
@@ -435,9 +439,6 @@ def handler(websocket):
         server_header: Value of  the ``Server`` response header.
             It defaults to ``"Python/x.y.z websockets/X.Y"``. Setting it to
             :obj:`None` removes the header.
-        compression: The "permessage-deflate" extension is enabled by default.
-            Set ``compression`` to :obj:`None` to disable it. See the
-            :doc:`compression guide <../../topics/compression>` for details.
         open_timeout: Timeout for opening connections in seconds.
             :obj:`None` disables the timeout.
         ping_interval: Interval between keepalive pings in seconds.

tests/asyncio/test_client.py

@@ -76,6 +76,21 @@ async def test_existing_socket(self):
                 async with connect("ws://invalid/", sock=sock) as client:
                     self.assertEqual(client.protocol.state.name, "OPEN")
 
+    async def test_compression_is_enabled(self):
+        """Client enables compression by default."""
+        async with serve(*args) as server:
+            async with connect(get_uri(server)) as client:
+                self.assertEqual(
+                    [type(ext) for ext in client.protocol.extensions],
+                    [PerMessageDeflate],
+                )
+
+    async def test_disable_compression(self):
+        """Client disables compression."""
+        async with serve(*args) as server:
+            async with connect(get_uri(server), compression=None) as client:
+                self.assertEqual(client.protocol.extensions, [])
+
     async def test_additional_headers(self):
         """Client can set additional headers with additional_headers."""
         async with serve(*args) as server:
@@ -96,21 +111,6 @@ async def test_remove_user_agent(self):
             async with connect(get_uri(server), user_agent_header=None) as client:
                 self.assertNotIn("User-Agent", client.request.headers)
 
-    async def test_compression_is_enabled(self):
-        """Client enables compression by default."""
-        async with serve(*args) as server:
-            async with connect(get_uri(server)) as client:
-                self.assertEqual(
-                    [type(ext) for ext in client.protocol.extensions],
-                    [PerMessageDeflate],
-                )
-
-    async def test_disable_compression(self):
-        """Client disables compression."""
-        async with serve(*args) as server:
-            async with connect(get_uri(server), compression=None) as client:
-                self.assertEqual(client.protocol.extensions, [])
-
     async def test_keepalive_is_enabled(self):
         """Client enables keepalive and measures latency by default."""
         async with serve(*args) as server:

tests/asyncio/test_server.py

@@ -117,6 +117,22 @@ def select_subprotocol(ws, subprotocols):
                 "server rejected WebSocket connection: HTTP 500",
             )
 
+    async def test_compression_is_enabled(self):
+        """Server enables compression by default."""
+        async with serve(*args) as server:
+            async with connect(get_uri(server)) as client:
+                await self.assertEval(
+                    client,
+                    "[type(ext).__name__ for ext in ws.protocol.extensions]",
+                    "['PerMessageDeflate']",
+                )
+
+    async def test_disable_compression(self):
+        """Server disables compression."""
+        async with serve(*args, compression=None) as server:
+            async with connect(get_uri(server)) as client:
+                await self.assertEval(client, "ws.protocol.extensions", "[]")
+
     async def test_process_request_returns_none(self):
         """Server runs process_request and continues the handshake."""
 
@@ -359,22 +375,6 @@ async def test_remove_server(self):
                     client, "'Server' in ws.response.headers", "False"
                 )
 
-    async def test_compression_is_enabled(self):
-        """Server enables compression by default."""
-        async with serve(*args) as server:
-            async with connect(get_uri(server)) as client:
-                await self.assertEval(
-                    client,
-                    "[type(ext).__name__ for ext in ws.protocol.extensions]",
-                    "['PerMessageDeflate']",
-                )
-
-    async def test_disable_compression(self):
-        """Server disables compression."""
-        async with serve(*args, compression=None) as server:
-            async with connect(get_uri(server)) as client:
-                await self.assertEval(client, "ws.protocol.extensions", "[]")
-
     async def test_keepalive_is_enabled(self):
         """Server enables keepalive and measures latency."""
         async with serve(*args, ping_interval=MS) as server:

tests/sync/test_client.py

@@ -41,6 +41,21 @@ def test_existing_socket(self):
                 with connect("ws://invalid/", sock=sock) as client:
                     self.assertEqual(client.protocol.state.name, "OPEN")
 
+    def test_compression_is_enabled(self):
+        """Client enables compression by default."""
+        with run_server() as server:
+            with connect(get_uri(server)) as client:
+                self.assertEqual(
+                    [type(ext) for ext in client.protocol.extensions],
+                    [PerMessageDeflate],
+                )
+
+    def test_disable_compression(self):
+        """Client disables compression."""
+        with run_server() as server:
+            with connect(get_uri(server), compression=None) as client:
+                self.assertEqual(client.protocol.extensions, [])
+
     def test_additional_headers(self):
         """Client can set additional headers with additional_headers."""
         with run_server() as server:
@@ -61,21 +76,6 @@ def test_remove_user_agent(self):
             with connect(get_uri(server), user_agent_header=None) as client:
                 self.assertNotIn("User-Agent", client.request.headers)
 
-    def test_compression_is_enabled(self):
-        """Client enables compression by default."""
-        with run_server() as server:
-            with connect(get_uri(server)) as client:
-                self.assertEqual(
-                    [type(ext) for ext in client.protocol.extensions],
-                    [PerMessageDeflate],
-                )
-
-    def test_disable_compression(self):
-        """Client disables compression."""
-        with run_server() as server:
-            with connect(get_uri(server), compression=None) as client:
-                self.assertEqual(client.protocol.extensions, [])
-
     def test_keepalive_is_enabled(self):
         """Client enables keepalive and measures latency by default."""
         with run_server() as server:

tests/sync/test_server.py

@@ -115,6 +115,22 @@ def select_subprotocol(ws, subprotocols):
                 "server rejected WebSocket connection: HTTP 500",
             )
 
+    def test_compression_is_enabled(self):
+        """Server enables compression by default."""
+        with run_server() as server:
+            with connect(get_uri(server)) as client:
+                self.assertEval(
+                    client,
+                    "[type(ext).__name__ for ext in ws.protocol.extensions]",
+                    "['PerMessageDeflate']",
+                )
+
+    def test_disable_compression(self):
+        """Server disables compression."""
+        with run_server(compression=None) as server:
+            with connect(get_uri(server)) as client:
+                self.assertEval(client, "ws.protocol.extensions", "[]")
+
     def test_process_request_returns_none(self):
         """Server runs process_request and continues the handshake."""
 
@@ -220,22 +236,6 @@ def test_remove_server(self):
             with connect(get_uri(server)) as client:
                 self.assertEval(client, "'Server' in ws.response.headers", "False")
 
-    def test_compression_is_enabled(self):
-        """Server enables compression by default."""
-        with run_server() as server:
-            with connect(get_uri(server)) as client:
-                self.assertEval(
-                    client,
-                    "[type(ext).__name__ for ext in ws.protocol.extensions]",
-                    "['PerMessageDeflate']",
-                )
-
-    def test_disable_compression(self):
-        """Server disables compression."""
-        with run_server(compression=None) as server:
-            with connect(get_uri(server)) as client:
-                self.assertEval(client, "ws.protocol.extensions", "[]")
-
     def test_keepalive_is_enabled(self):
         """Server enables keepalive and measures latency."""
         with run_server(ping_interval=MS) as server: