Blacken

Makefile

@@ -11,6 +11,7 @@ test:
 	$(PYTHON) -m pytest --cov=trio_websocket --no-cov-on-fail
 
 lint:
+	$(PYTHON) -m black trio_websocket/ tests/ autobahn/ examples/
 	$(PYTHON) -m pylint trio_websocket/ tests/ autobahn/ examples/
 
 publish:

autobahn/client.py

@@ -1,7 +1,7 @@
-'''
+"""
 This test client runs against the Autobahn test server. It is based on the
 test_client.py in wsproto.
-'''
+"""
 import argparse
 import json
 import logging
@@ -11,28 +11,28 @@
 from trio_websocket import open_websocket_url, ConnectionClosed
 
 
-AGENT = 'trio-websocket'
+AGENT = "trio-websocket"
 MAX_MESSAGE_SIZE = 16 * 1024 * 1024
 logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger('client')
+logger = logging.getLogger("client")
 
 
 async def get_case_count(url):
-    url = url + '/getCaseCount'
+    url = url + "/getCaseCount"
     async with open_websocket_url(url) as conn:
         case_count = await conn.get_message()
-        logger.info('Case count=%s', case_count)
+        logger.info("Case count=%s", case_count)
     return int(case_count)
 
 
 async def get_case_info(url, case):
-    url = f'{url}/getCaseInfo?case={case}'
+    url = f"{url}/getCaseInfo?case={case}"
     async with open_websocket_url(url) as conn:
         return json.loads(await conn.get_message())
 
 
 async def run_case(url, case):
-    url = f'{url}/runCase?case={case}&agent={AGENT}'
+    url = f"{url}/runCase?case={case}&agent={AGENT}"
     try:
         async with open_websocket_url(url, max_message_size=MAX_MESSAGE_SIZE) as conn:
             while True:
@@ -43,15 +43,15 @@ async def run_case(url, case):
 
 
 async def update_reports(url):
-    url = f'{url}/updateReports?agent={AGENT}'
+    url = f"{url}/updateReports?agent={AGENT}"
     async with open_websocket_url(url) as conn:
         # This command runs as soon as we connect to it, so we don't need to
         # send any messages.
         pass
 
 
 async def run_tests(args):
-    logger = logging.getLogger('trio-websocket')
+    logger = logging.getLogger("trio-websocket")
     if args.debug_cases:
         # Don't fetch case count when debugging a subset of test cases. It adds
         # noise to the debug logging.
@@ -62,7 +62,7 @@ async def run_tests(args):
         test_cases = list(range(1, case_count + 1))
     exception_cases = []
     for case in test_cases:
-        case_id = (await get_case_info(args.url, case))['id']
+        case_id = (await get_case_info(args.url, case))["id"]
         if case_count:
             logger.info("Running test case %s (%d of %d)", case_id, case, case_count)
         else:
@@ -71,28 +71,39 @@ async def run_tests(args):
         try:
             await run_case(args.url, case)
         except Exception:  # pylint: disable=broad-exception-caught
-            logger.exception('  runtime exception during test case %s (%d)', case_id, case)
+            logger.exception(
+                "  runtime exception during test case %s (%d)", case_id, case
+            )
             exception_cases.append(case_id)
         logger.setLevel(logging.INFO)
-    logger.info('Updating report')
+    logger.info("Updating report")
     await update_reports(args.url)
     if exception_cases:
-        logger.error('Runtime exception in %d of %d test cases: %s',
-                     len(exception_cases), len(test_cases), exception_cases)
+        logger.error(
+            "Runtime exception in %d of %d test cases: %s",
+            len(exception_cases),
+            len(test_cases),
+            exception_cases,
+        )
         sys.exit(1)
 
 
 def parse_args():
-    ''' Parse command line arguments. '''
-    parser = argparse.ArgumentParser(description='Autobahn client for'
-        ' trio-websocket')
-    parser.add_argument('url', help='WebSocket URL for server')
+    """Parse command line arguments."""
+    parser = argparse.ArgumentParser(
+        description="Autobahn client for" " trio-websocket"
+    )
+    parser.add_argument("url", help="WebSocket URL for server")
     # TODO: accept case ID's rather than indices
-    parser.add_argument('debug_cases', type=int, nargs='*', help='Run'
-        ' individual test cases with debug logging (optional)')
+    parser.add_argument(
+        "debug_cases",
+        type=int,
+        nargs="*",
+        help="Run" " individual test cases with debug logging (optional)",
+    )
     return parser.parse_args()
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     args = parse_args()
     trio.run(run_tests, args)

autobahn/server.py

@@ -1,4 +1,4 @@
-'''
+"""
 This simple WebSocket server responds to text messages by reversing each
 message string and sending it back.
 
@@ -7,34 +7,35 @@
 
 To use SSL/TLS: install the `trustme` package from PyPI and run the
 `generate-cert.py` script in this directory.
-'''
+"""
 import argparse
 import logging
 
 import trio
 from trio_websocket import serve_websocket, ConnectionClosed, WebSocketRequest
 
-BIND_IP = '0.0.0.0'
+BIND_IP = "0.0.0.0"
 BIND_PORT = 9000
 MAX_MESSAGE_SIZE = 16 * 1024 * 1024
 logging.basicConfig()
-logger = logging.getLogger('client')
+logger = logging.getLogger("client")
 logger.setLevel(logging.INFO)
 connection_count = 0
 
 
 async def main():
-    ''' Main entry point. '''
-    logger.info('Starting websocket server on ws://%s:%d', BIND_IP, BIND_PORT)
-    await serve_websocket(handler, BIND_IP, BIND_PORT, ssl_context=None,
-                          max_message_size=MAX_MESSAGE_SIZE)
+    """Main entry point."""
+    logger.info("Starting websocket server on ws://%s:%d", BIND_IP, BIND_PORT)
+    await serve_websocket(
+        handler, BIND_IP, BIND_PORT, ssl_context=None, max_message_size=MAX_MESSAGE_SIZE
+    )
 
 
 async def handler(request: WebSocketRequest):
-    ''' Reverse incoming websocket messages and send them back. '''
+    """Reverse incoming websocket messages and send them back."""
     global connection_count  # pylint: disable=global-statement
     connection_count += 1
-    logger.info('Connection #%d', connection_count)
+    logger.info("Connection #%d", connection_count)
     ws = await request.accept()
     while True:
         try:
@@ -43,20 +44,24 @@ async def handler(request: WebSocketRequest):
         except ConnectionClosed:
             break
         except Exception:  # pylint: disable=broad-exception-caught
-            logger.exception('  runtime exception handling connection #%d', connection_count)
+            logger.exception(
+                "  runtime exception handling connection #%d", connection_count
+            )
 
 
 def parse_args():
-    ''' Parse command line arguments. '''
-    parser = argparse.ArgumentParser(description='Autobahn server for'
-        ' trio-websocket')
-    parser.add_argument('-d', '--debug', action='store_true',
-        help='WebSocket URL for server')
+    """Parse command line arguments."""
+    parser = argparse.ArgumentParser(
+        description="Autobahn server for" " trio-websocket"
+    )
+    parser.add_argument(
+        "-d", "--debug", action="store_true", help="WebSocket URL for server"
+    )
     return parser.parse_args()
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     args = parse_args()
     if args.debug:
-        logging.getLogger('trio-websocket').setLevel(logging.DEBUG)
+        logging.getLogger("trio-websocket").setLevel(logging.DEBUG)
     trio.run(main)

examples/client.py

@@ -1,10 +1,10 @@
-'''
+"""
 This interactive WebSocket client allows the user to send frames to a WebSocket
 server, including text message, ping, and close frames.
 
 To use SSL/TLS: install the `trustme` package from PyPI and run the
 `generate-cert.py` script in this directory.
-'''
+"""
 import argparse
 import logging
 import pathlib
@@ -21,62 +21,64 @@
 
 
 def commands():
-    ''' Print the supported commands. '''
-    print('Commands: ')
-    print('send <MESSAGE>   -> send message')
-    print('ping <PAYLOAD>   -> send ping with payload')
-    print('close [<REASON>] -> politely close connection with optional reason')
+    """Print the supported commands."""
+    print("Commands: ")
+    print("send <MESSAGE>   -> send message")
+    print("ping <PAYLOAD>   -> send ping with payload")
+    print("close [<REASON>] -> politely close connection with optional reason")
     print()
 
 
 def parse_args():
-    ''' Parse command line arguments. '''
-    parser = argparse.ArgumentParser(description='Example trio-websocket client')
-    parser.add_argument('--heartbeat', action='store_true',
-        help='Create a heartbeat task')
-    parser.add_argument('url', help='WebSocket URL to connect to')
+    """Parse command line arguments."""
+    parser = argparse.ArgumentParser(description="Example trio-websocket client")
+    parser.add_argument(
+        "--heartbeat", action="store_true", help="Create a heartbeat task"
+    )
+    parser.add_argument("url", help="WebSocket URL to connect to")
     return parser.parse_args()
 
 
 async def main(args):
-    ''' Main entry point, returning False in the case of logged error. '''
-    if urllib.parse.urlsplit(args.url).scheme == 'wss':
+    """Main entry point, returning False in the case of logged error."""
+    if urllib.parse.urlsplit(args.url).scheme == "wss":
         # Configure SSL context to handle our self-signed certificate. Most
         # clients won't need to do this.
         try:
             ssl_context = ssl.create_default_context()
-            ssl_context.load_verify_locations(here / 'fake.ca.pem')
+            ssl_context.load_verify_locations(here / "fake.ca.pem")
         except FileNotFoundError:
-            logging.error('Did not find file "fake.ca.pem". You need to run'
-                ' generate-cert.py')
+            logging.error(
+                'Did not find file "fake.ca.pem". You need to run generate-cert.py'
+            )
             return False
     else:
         ssl_context = None
     try:
-        logging.debug('Connecting to WebSocket…')
+        logging.debug("Connecting to WebSocket…")
         async with open_websocket_url(args.url, ssl_context) as conn:
             await handle_connection(conn, args.heartbeat)
     except HandshakeError as e:
-        logging.error('Connection attempt failed: %s', e)
+        logging.error("Connection attempt failed: %s", e)
         return False
 
 
 async def handle_connection(ws, use_heartbeat):
-    ''' Handle the connection. '''
-    logging.debug('Connected!')
+    """Handle the connection."""
+    logging.debug("Connected!")
     try:
         async with trio.open_nursery() as nursery:
             if use_heartbeat:
                 nursery.start_soon(heartbeat, ws, 1, 15)
             nursery.start_soon(get_commands, ws)
             nursery.start_soon(get_messages, ws)
     except ConnectionClosed as cc:
-        reason = '<no reason>' if cc.reason.reason is None else f'"{cc.reason.reason}"'
-        print(f'Closed: {cc.reason.code}/{cc.reason.name} {reason}')
+        reason = "<no reason>" if cc.reason.reason is None else f'"{cc.reason.reason}"'
+        print(f"Closed: {cc.reason.code}/{cc.reason.name} {reason}")
 
 
 async def heartbeat(ws, timeout, interval):
-    '''
+    """
     Send periodic pings on WebSocket ``ws``.
 
     Wait up to ``timeout`` seconds to send a ping and receive a pong. Raises
@@ -92,28 +94,27 @@ async def heartbeat(ws, timeout, interval):
     :raises: ``ConnectionClosed`` if ``ws`` is closed.
     :raises: ``TooSlowError`` if the timeout expires.
     :returns: This function runs until cancelled.
-    '''
+    """
     while True:
         with trio.fail_after(timeout):
             await ws.ping()
         await trio.sleep(interval)
 
 
 async def get_commands(ws):
-    ''' In a loop: get a command from the user and execute it. '''
+    """In a loop: get a command from the user and execute it."""
     while True:
-        cmd = await trio.to_thread.run_sync(input, 'cmd> ',
-            cancellable=True)
-        if cmd.startswith('ping'):
-            payload = cmd[5:].encode('utf8') or None
+        cmd = await trio.to_thread.run_sync(input, "cmd> ", cancellable=True)
+        if cmd.startswith("ping"):
+            payload = cmd[5:].encode("utf8") or None
             await ws.ping(payload)
-        elif cmd.startswith('send'):
+        elif cmd.startswith("send"):
             message = cmd[5:] or None
             if message is None:
                 logging.error('The "send" command requires a message.')
             else:
                 await ws.send_message(message)
-        elif cmd.startswith('close'):
+        elif cmd.startswith("close"):
             reason = cmd[6:] or None
             await ws.aclose(code=1000, reason=reason)
             break
@@ -124,13 +125,13 @@ async def get_commands(ws):
 
 
 async def get_messages(ws):
-    ''' In a loop: get a WebSocket message and print it out. '''
+    """In a loop: get a WebSocket message and print it out."""
     while True:
         message = await ws.get_message()
-        print(f'message: {message}')
+        print(f"message: {message}")
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     try:
         if not trio.run(main, parse_args()):
             sys.exit(1)