Rename the wsuri variable.

The name looked confusing.

Author: aaugustin

docs/howto/sansio.rst

@@ -28,16 +28,16 @@ If you're building a client, parse the URI you'd like to connect to::
 
     from websockets.uri import parse_uri
 
-    wsuri = parse_uri("ws://example.com/")
+    uri = parse_uri("ws://example.com/")
 
-Open a TCP connection to ``(wsuri.host, wsuri.port)`` and perform a TLS
-handshake if ``wsuri.secure`` is :obj:`True`.
+Open a TCP connection to ``(uri.host, uri.port)`` and perform a TLS handshake
+if ``uri.secure`` is :obj:`True`.
 
 Initialize a :class:`~client.ClientProtocol`::
 
     from websockets.client import ClientProtocol
 
-    protocol = ClientProtocol(wsuri)
+    protocol = ClientProtocol(uri)
 
 Create a WebSocket handshake request
 with :meth:`~client.ClientProtocol.connect` and send it

src/websockets/asyncio/client.py

@@ -311,10 +311,10 @@ def __init__(
         if create_connection is None:
             create_connection = ClientConnection
 
-        def protocol_factory(wsuri: WebSocketURI) -> ClientConnection:
+        def protocol_factory(uri: WebSocketURI) -> ClientConnection:
             # This is a protocol in the Sans-I/O implementation of websockets.
             protocol = ClientProtocol(
-                wsuri,
+                uri,
                 origin=origin,
                 extensions=extensions,
                 subprotocols=subprotocols,
@@ -346,15 +346,15 @@ async def create_connection(self) -> ClientConnection:
         """Create TCP or Unix connection."""
         loop = asyncio.get_running_loop()
 
-        wsuri = parse_uri(self.uri)
+        ws_uri = parse_uri(self.uri)
         kwargs = self.connection_kwargs.copy()
 
         def factory() -> ClientConnection:
-            return self.protocol_factory(wsuri)
+            return self.protocol_factory(ws_uri)
 
-        if wsuri.secure:
+        if ws_uri.secure:
             kwargs.setdefault("ssl", True)
-            kwargs.setdefault("server_hostname", wsuri.host)
+            kwargs.setdefault("server_hostname", ws_uri.host)
             if kwargs.get("ssl") is None:
                 raise ValueError("ssl=None is incompatible with a wss:// URI")
         else:
@@ -365,8 +365,8 @@ def factory() -> ClientConnection:
             _, connection = await loop.create_unix_connection(factory, **kwargs)
         else:
             if kwargs.get("sock") is None:
-                kwargs.setdefault("host", wsuri.host)
-                kwargs.setdefault("port", wsuri.port)
+                kwargs.setdefault("host", ws_uri.host)
+                kwargs.setdefault("port", ws_uri.port)
             _, connection = await loop.create_connection(factory, **kwargs)
         return connection
 
@@ -392,9 +392,9 @@ def process_redirect(self, exc: Exception) -> Exception | str:
         ):
             return exc
 
-        old_wsuri = parse_uri(self.uri)
+        old_ws_uri = parse_uri(self.uri)
         new_uri = urllib.parse.urljoin(self.uri, exc.response.headers["Location"])
-        new_wsuri = parse_uri(new_uri)
+        new_ws_uri = parse_uri(new_uri)
 
         # If connect() received a socket, it is closed and cannot be reused.
         if self.connection_kwargs.get("sock") is not None:
@@ -403,14 +403,14 @@ def process_redirect(self, exc: Exception) -> Exception | str:
             )
 
         # TLS downgrade is forbidden.
-        if old_wsuri.secure and not new_wsuri.secure:
+        if old_ws_uri.secure and not new_ws_uri.secure:
             return SecurityError(f"cannot follow redirect to non-secure URI {new_uri}")
 
         # Apply restrictions to cross-origin redirects.
         if (
-            old_wsuri.secure != new_wsuri.secure
-            or old_wsuri.host != new_wsuri.host
-            or old_wsuri.port != new_wsuri.port
+            old_ws_uri.secure != new_ws_uri.secure
+            or old_ws_uri.host != new_ws_uri.host
+            or old_ws_uri.port != new_ws_uri.port
         ):
             # Cross-origin redirects on Unix sockets don't quite make sense.
             if self.connection_kwargs.get("unix", False):

src/websockets/client.py

@@ -50,7 +50,7 @@ class ClientProtocol(Protocol):
     Sans-I/O implementation of a WebSocket client connection.
 
     Args:
-        wsuri: URI of the WebSocket server, parsed
+        uri: URI of the WebSocket server, parsed
             with :func:`~websockets.uri.parse_uri`.
         origin: Value of the ``Origin`` header. This is useful when connecting
             to a server that validates the ``Origin`` header to defend against
@@ -70,7 +70,7 @@ class ClientProtocol(Protocol):
 
     def __init__(
         self,
-        wsuri: WebSocketURI,
+        uri: WebSocketURI,
         *,
         origin: Origin | None = None,
         extensions: Sequence[ClientExtensionFactory] | None = None,
@@ -85,7 +85,7 @@ def __init__(
             max_size=max_size,
             logger=logger,
         )
-        self.wsuri = wsuri
+        self.uri = uri
         self.origin = origin
         self.available_extensions = extensions
         self.available_subprotocols = subprotocols
@@ -105,12 +105,10 @@ def connect(self) -> Request:
         """
         headers = Headers()
 
-        headers["Host"] = build_host(
-            self.wsuri.host, self.wsuri.port, self.wsuri.secure
-        )
+        headers["Host"] = build_host(self.uri.host, self.uri.port, self.uri.secure)
 
-        if self.wsuri.user_info:
-            headers["Authorization"] = build_authorization_basic(*self.wsuri.user_info)
+        if self.uri.user_info:
+            headers["Authorization"] = build_authorization_basic(*self.uri.user_info)
 
         if self.origin is not None:
             headers["Origin"] = self.origin
@@ -133,7 +131,7 @@ def connect(self) -> Request:
             protocol_header = build_subprotocol(self.available_subprotocols)
             headers["Sec-WebSocket-Protocol"] = protocol_header
 
-        return Request(self.wsuri.resource_name, headers)
+        return Request(self.uri.resource_name, headers)
 
     def process_response(self, response: Response) -> None:
         """

src/websockets/sync/client.py

@@ -230,8 +230,8 @@ def connect(
             DeprecationWarning,
         )
 
-    wsuri = parse_uri(uri)
-    if not wsuri.secure and ssl is not None:
+    ws_uri = parse_uri(uri)
+    if not ws_uri.secure and ssl is not None:
         raise ValueError("ssl argument is incompatible with a ws:// URI")
 
     # Private APIs for unix_connect()
@@ -271,7 +271,7 @@ def connect(
                 sock.connect(path)
             else:
                 kwargs.setdefault("timeout", deadline.timeout())
-                sock = socket.create_connection((wsuri.host, wsuri.port), **kwargs)
+                sock = socket.create_connection((ws_uri.host, ws_uri.port), **kwargs)
             sock.settimeout(None)
 
         # Disable Nagle algorithm
@@ -281,19 +281,19 @@ def connect(
 
         # Initialize TLS wrapper and perform TLS handshake
 
-        if wsuri.secure:
+        if ws_uri.secure:
             if ssl is None:
                 ssl = ssl_module.create_default_context()
             if server_hostname is None:
-                server_hostname = wsuri.host
+                server_hostname = ws_uri.host
             sock.settimeout(deadline.timeout())
             sock = ssl.wrap_socket(sock, server_hostname=server_hostname)
             sock.settimeout(None)
 
         # Initialize WebSocket protocol
 
         protocol = ClientProtocol(
-            wsuri,
+            ws_uri,
             origin=origin,
             extensions=extensions,
             subprotocols=subprotocols,

tests/asyncio/test_client.py

@@ -248,7 +248,7 @@ def redirect(connection, request):
 
         async with serve(*args, process_request=redirect) as server:
             async with connect(get_uri(server) + "/redirect") as client:
-                self.assertEqual(client.protocol.wsuri.path, "/")
+                self.assertEqual(client.protocol.uri.path, "/")
 
     async def test_cross_origin_redirect(self):
         """Client follows redirect to a secure URI on a different origin."""
@@ -297,7 +297,7 @@ def redirect(connection, request):
             async with connect(
                 "ws://overridden/redirect", host=host, port=port
             ) as client:
-                self.assertEqual(client.protocol.wsuri.path, "/")
+                self.assertEqual(client.protocol.uri.path, "/")
 
     async def test_cross_origin_redirect_with_explicit_host_port(self):
         """Client doesn't follow cross-origin redirect with an explicit host / port."""