Reformat example with Black

To be consistent with the rest of the project. Also checked in CI.

Author: bluetech

example/synchronous_client.py

@@ -1,37 +1,44 @@
-'''
+"""
 The client reads a line from stdin, sends it to the server, then prints the
 response. This is a poor implementation of a client. It is only intended to
 demonstrate how to use wsproto.
-'''
+"""
 
 import socket
 import sys
 
 from wsproto import WSConnection
 from wsproto.connection import ConnectionType
-from wsproto.events import AcceptConnection, CloseConnection, Message, Ping, Pong, Request, TextMessage
-
+from wsproto.events import (
+    AcceptConnection,
+    CloseConnection,
+    Message,
+    Ping,
+    Pong,
+    Request,
+    TextMessage,
+)
 
 RECEIVE_BYTES = 4096
 
 
 def main():
-    ''' Run the client. '''
+    """Run the client."""
     try:
         host = sys.argv[1]
         port = int(sys.argv[2])
     except (IndexError, ValueError):
-        print('Usage: {} <HOST> <PORT>'.format(sys.argv[0]))
+        print("Usage: {} <HOST> <PORT>".format(sys.argv[0]))
         sys.exit(1)
 
     try:
         wsproto_demo(host, port)
     except KeyboardInterrupt:
-        print('\nReceived SIGINT: shutting down…')
+        print("\nReceived SIGINT: shutting down…")
 
 
 def wsproto_demo(host, port):
-    '''
+    """
     Demonstrate wsproto:
 
     0) Open TCP connection
@@ -41,39 +48,39 @@ def wsproto_demo(host, port):
     4) Negotiate WebSocket closing handshake
 
     :param stream: a socket stream
-    '''
+    """
 
     # 0) Open TCP connection
-    print('Connecting to {}:{}'.format(host, port))
+    print("Connecting to {}:{}".format(host, port))
     conn = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
     conn.connect((host, port))
 
     # 1) Negotiate WebSocket opening handshake
-    print('Opening WebSocket')
+    print("Opening WebSocket")
     ws = WSConnection(ConnectionType.CLIENT)
     # Because this is a client WebSocket, we need to initiate the connection
     # handshake by sending a Request event.
-    net_send(ws.send(Request(host=host, target='server')), conn)
+    net_send(ws.send(Request(host=host, target="server")), conn)
     net_recv(ws, conn)
     handle_events(ws)
 
     # 2) Send a message and display response
     message = "wsproto is great"
-    print('Sending message: {}'.format(message))
+    print("Sending message: {}".format(message))
     net_send(ws.send(Message(data=message)), conn)
     net_recv(ws, conn)
     handle_events(ws)
 
     # 3) Send ping and display pong
     payload = b"table tennis"
-    print('Sending ping: {}'.format(payload))
+    print("Sending ping: {}".format(payload))
     net_send(ws.send(Ping(payload=payload)), conn)
     net_recv(ws, conn)
     handle_events(ws)
 
     # 4) Negotiate WebSocket closing handshake
-    print('Closing WebSocket')
-    net_send(ws.send(CloseConnection(code=1000, reason='sample reason')), conn)
+    print("Closing WebSocket")
+    net_send(ws.send(CloseConnection(code=1000, reason="sample reason")), conn)
     # After sending the closing frame, we won't get any more events. The server
     # should send a reply and then close the connection, so we need to receive
     # twice:
@@ -83,35 +90,35 @@ def wsproto_demo(host, port):
 
 
 def net_send(out_data, conn):
-    ''' Write pending data from websocket to network. '''
-    print('Sending {} bytes'.format(len(out_data)))
+    """ Write pending data from websocket to network. """
+    print("Sending {} bytes".format(len(out_data)))
     conn.send(out_data)
 
 
 def net_recv(ws, conn):
-    ''' Read pending data from network into websocket. '''
+    """ Read pending data from network into websocket. """
     in_data = conn.recv(RECEIVE_BYTES)
     if not in_data:
         # A receive of zero bytes indicates the TCP socket has been closed. We
         # need to pass None to wsproto to update its internal state.
-        print('Received 0 bytes (connection closed)')
+        print("Received 0 bytes (connection closed)")
         ws.receive_data(None)
     else:
-        print('Received {} bytes'.format(len(in_data)))
+        print("Received {} bytes".format(len(in_data)))
         ws.receive_data(in_data)
 
 
 def handle_events(ws):
     for event in ws.events():
         if isinstance(event, AcceptConnection):
-            print('WebSocket negotiation complete')
+            print("WebSocket negotiation complete")
         elif isinstance(event, TextMessage):
-            print('Received message: {}'.format(event.data))
+            print("Received message: {}".format(event.data))
         elif isinstance(event, Pong):
-            print('Received pong: {}'.format(event.payload))
+            print("Received pong: {}".format(event.payload))
         else:
-            raise Exception('Do not know how to handle event: ' + str(event))
+            raise Exception("Do not know how to handle event: " + str(event))
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()

example/synchronous_server.py

@@ -1,27 +1,34 @@
-'''
+"""
 This server reads a message from a WebSocket, and sends the reverse string in a
 response message. It can only handle one client at a time. This is a very bad
 implementation of a server! It is only intended to demonstrate how to use
 wsproto.
-'''
+"""
 
 import socket
 import sys
 
 from wsproto import ConnectionType, WSConnection
-from wsproto.events import AcceptConnection, CloseConnection, Message, Ping, Request, TextMessage
-
+from wsproto.events import (
+    AcceptConnection,
+    CloseConnection,
+    Message,
+    Ping,
+    Request,
+    TextMessage,
+)
 
 MAX_CONNECTS = 5
 RECEIVE_BYTES = 4096
 
+
 def main():
-    ''' Run the server. '''
+    """Run the server."""
     try:
         ip = sys.argv[1]
         port = int(sys.argv[2])
     except (IndexError, ValueError):
-        print('Usage: {} <BIND_IP> <PORT>'.format(sys.argv[0]))
+        print("Usage: {} <BIND_IP> <PORT>".format(sys.argv[0]))
         sys.exit(1)
 
     server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
@@ -31,18 +38,18 @@ def main():
 
     try:
         while True:
-            print('Waiting for connection...')
+            print("Waiting for connection...")
             (stream, addr) = server.accept()
-            print('Client connected: {}:{}'.format(addr[0], addr[1]))
+            print("Client connected: {}:{}".format(addr[0], addr[1]))
             handle_connection(stream)
             stream.shutdown(socket.SHUT_WR)
             stream.close()
     except KeyboardInterrupt:
-        print('Received SIGINT: shutting down…')
+        print("Received SIGINT: shutting down…")
 
 
 def handle_connection(stream):
-    '''
+    """
     Handle a connection.
 
     The server operates a request/response cycle, so it performs a synchronous
@@ -53,46 +60,49 @@ def handle_connection(stream):
     3) Send data from wsproto to network
 
     :param stream: a socket stream
-    '''
+    """
     ws = WSConnection(ConnectionType.SERVER)
     running = True
 
     while running:
         # 1) Read data from network
         in_data = stream.recv(RECEIVE_BYTES)
-        print('Received {} bytes'.format(len(in_data)))
+        print("Received {} bytes".format(len(in_data)))
         ws.receive_data(in_data)
 
         # 2) Get new events and handle them
-        out_data = b''
+        out_data = b""
         for event in ws.events():
             if isinstance(event, Request):
                 # Negotiate new WebSocket connection
-                print('Accepting WebSocket upgrade')
+                print("Accepting WebSocket upgrade")
                 out_data += ws.send(AcceptConnection())
             elif isinstance(event, CloseConnection):
                 # Print log message and break out
-                print('Connection closed: code={}/{} reason={}'.format(
-                    event.code.value, event.code.name, event.reason))
+                print(
+                    "Connection closed: code={}/{} reason={}".format(
+                        event.code.value, event.code.name, event.reason
+                    )
+                )
                 out_data += ws.send(event.response())
                 running = False
             elif isinstance(event, TextMessage):
                 # Reverse text and send it back to wsproto
-                print('Received request and sending response')
+                print("Received request and sending response")
                 out_data += ws.send(Message(data=event.data[::-1]))
             elif isinstance(event, Ping):
                 # wsproto handles ping events for you by placing a pong frame in
                 # the outgoing buffer. You should not call pong() unless you want to
                 # send an unsolicited pong frame.
-                print('Received ping and sending pong')
+                print("Received ping and sending pong")
                 out_data += ws.send(event.response())
             else:
-                print('Unknown event: {!r}'.format(event))
+                print("Unknown event: {!r}".format(event))
 
         # 4) Send data from wsproto to network
-        print('Sending {} bytes'.format(len(out_data)))
+        print("Sending {} bytes".format(len(out_data)))
         stream.send(out_data)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()

tox.ini

@@ -29,8 +29,8 @@ deps =
     black
     isort
 commands =
-    black --check --diff wsproto/ test/
-    isort --dont-skip __init__.py --diff --check --settings-path setup.cfg --recursive wsproto test
+    black --check --diff wsproto/ test/ example/
+    isort --dont-skip __init__.py --diff --check --settings-path setup.cfg --recursive wsproto test example
 
 [testenv:mypy]
 basepython = python3.7