Fixing flake8 warnings and errors

flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics --exclude benchmark

Excluding the benchmark directory (due to protobuf generated files)
Also removing some Python2 specific code

examples/addressbook.py

@@ -1,6 +1,5 @@
 from __future__ import print_function
-import os
-import capnp
+import capnp # noqa: F401
 
 import addressbook_capnp
 

examples/async_client.py

@@ -4,7 +4,6 @@ from __future__ import print_function
 
 import asyncio
 import argparse
-import threading
 import time
 import capnp
 import socket
@@ -16,15 +15,14 @@ capnp.create_event_loop(threaded=True)
 
 
 def parse_args():
-  parser = argparse.ArgumentParser(usage='Connects to the Example thread server \
+    parser = argparse.ArgumentParser(usage='Connects to the Example thread server \
 at the given address and does some RPCs')
-  parser.add_argument("host", help="HOST:PORT")
+    parser.add_argument("host", help="HOST:PORT")
 
-  return parser.parse_args()
+    return parser.parse_args()
 
 
 class StatusSubscriber(thread_capnp.Example.StatusSubscriber.Server):
-
     '''An implementation of the StatusSubscriber interface'''
 
     def status(self, value, **kwargs):
@@ -32,61 +30,61 @@ class StatusSubscriber(thread_capnp.Example.StatusSubscriber.Server):
 
 
 async def myreader(client, reader):
-  while True:
-    data = await reader.read(4096)
-    client.write(data)
+    while True:
+        data = await reader.read(4096)
+        client.write(data)
 
 
 async def mywriter(client, writer):
-  while True:
-    data = await client.read(4096)
-    writer.write(data.tobytes())
-    await writer.drain()
+    while True:
+        data = await client.read(4096)
+        writer.write(data.tobytes())
+        await writer.drain()
 
 
 async def background(cap):
-  subscriber = StatusSubscriber()
-  promise = cap.subscribeStatus(subscriber)
-  await promise.a_wait()
+    subscriber = StatusSubscriber()
+    promise = cap.subscribeStatus(subscriber)
+    await promise.a_wait()
 
 
 async def main(host):
-  host = host.split(':')
-  addr = host[0]
-  port = host[1]
-  # Handle both IPv4 and IPv6 cases
-  try:
-    print("Try IPv4")
-    reader, writer = await asyncio.open_connection(
-      addr, port,
-    )
-  except:
-    print("Try IPv6")
-    reader, writer = await asyncio.open_connection(
-      addr, port,
-      family=socket.AF_INET6
-    )
+    host = host.split(':')
+    addr = host[0]
+    port = host[1]
+    # Handle both IPv4 and IPv6 cases
+    try:
+        print("Try IPv4")
+        reader, writer = await asyncio.open_connection(
+            addr, port,
+        )
+    except Exception:
+        print("Try IPv6")
+        reader, writer = await asyncio.open_connection(
+            addr, port,
+            family=socket.AF_INET6
+        )
 
-  # Start TwoPartyClient using TwoWayPipe (takes no arguments in this mode)
-  client = capnp.TwoPartyClient()
-  cap = client.bootstrap().cast_as(thread_capnp.Example)
+    # Start TwoPartyClient using TwoWayPipe (takes no arguments in this mode)
+    client = capnp.TwoPartyClient()
+    cap = client.bootstrap().cast_as(thread_capnp.Example)
 
-  # Assemble reader and writer tasks, run in the background
-  coroutines = [myreader(client, reader), mywriter(client, writer)]
-  asyncio.gather(*coroutines, return_exceptions=True)
+    # Assemble reader and writer tasks, run in the background
+    coroutines = [myreader(client, reader), mywriter(client, writer)]
+    asyncio.gather(*coroutines, return_exceptions=True)
 
-  # Start background task for subscriber
-  tasks = [background(cap)]
-  asyncio.gather(*tasks, return_exceptions=True)
+    # Start background task for subscriber
+    tasks = [background(cap)]
+    asyncio.gather(*tasks, return_exceptions=True)
 
-  # Run blocking tasks
-  print('main: {}'.format(time.time()))
-  await cap.longRunning().a_wait()
-  print('main: {}'.format(time.time()))
-  await cap.longRunning().a_wait()
-  print('main: {}'.format(time.time()))
-  await cap.longRunning().a_wait()
-  print('main: {}'.format(time.time()))
+    # Run blocking tasks
+    print('main: {}'.format(time.time()))
+    await cap.longRunning().a_wait()
+    print('main: {}'.format(time.time()))
+    await cap.longRunning().a_wait()
+    print('main: {}'.format(time.time()))
+    await cap.longRunning().a_wait()
+    print('main: {}'.format(time.time()))
 
 if __name__ == '__main__':
     asyncio.run(main(parse_args().host))

examples/async_server.py

@@ -72,7 +72,7 @@ async def main():
             myserver,
             addr, port,
         )
-    except:
+    except Exception:
         print("Try IPv6")
         server = await asyncio.start_server(
             myserver,
@@ -83,5 +83,6 @@ async def main():
     async with server:
         await server.serve_forever()
 
+
 if __name__ == '__main__':
     asyncio.run(main())

examples/async_ssl_client.py

@@ -4,7 +4,6 @@ from __future__ import print_function
 
 import asyncio
 import argparse
-import threading
 import time
 import capnp
 import socket
@@ -17,87 +16,86 @@ capnp.create_event_loop(threaded=True)
 
 
 def parse_args():
-  parser = argparse.ArgumentParser(usage='Connects to the Example thread server \
+    parser = argparse.ArgumentParser(usage='Connects to the Example thread server \
 at the given address and does some RPCs')
-  parser.add_argument("host", help="HOST:PORT")
+    parser.add_argument("host", help="HOST:PORT")
 
-  return parser.parse_args()
+    return parser.parse_args()
 
 
 class StatusSubscriber(thread_capnp.Example.StatusSubscriber.Server):
+    '''An implementation of the StatusSubscriber interface'''
 
-  '''An implementation of the StatusSubscriber interface'''
-
-  def status(self, value, **kwargs):
-      print('status: {}'.format(time.time()))
+    def status(self, value, **kwargs):
+        print('status: {}'.format(time.time()))
 
 
 async def myreader(client, reader):
-  while True:
-    data = await reader.read(4096)
-    client.write(data)
+    while True:
+        data = await reader.read(4096)
+        client.write(data)
 
 
 async def mywriter(client, writer):
-  while True:
-    data = await client.read(4096)
-    writer.write(data.tobytes())
-    await writer.drain()
+    while True:
+        data = await client.read(4096)
+        writer.write(data.tobytes())
+        await writer.drain()
 
 
 async def background(cap):
-  subscriber = StatusSubscriber()
-  promise = cap.subscribeStatus(subscriber)
-  await promise.a_wait()
+    subscriber = StatusSubscriber()
+    promise = cap.subscribeStatus(subscriber)
+    await promise.a_wait()
 
 
 async def main(host):
-  host = host.split(':')
-  addr = host[0]
-  port = host[1]
+    host = host.split(':')
+    addr = host[0]
+    port = host[1]
 
-  # Setup SSL context
-  ctx = ssl.create_default_context(ssl.Purpose.SERVER_AUTH, cafile='selfsigned.cert')
+    # Setup SSL context
+    ctx = ssl.create_default_context(ssl.Purpose.SERVER_AUTH, cafile='selfsigned.cert')
 
-  # Handle both IPv4 and IPv6 cases
-  try:
-    print("Try IPv4")
-    reader, writer = await asyncio.open_connection(
-      addr, port,
-      ssl=ctx,
-    )
-  except:
-    print("Try IPv6")
-    reader, writer = await asyncio.open_connection(
-      addr, port,
-      ssl=ctx,
-      family=socket.AF_INET6
-    )
+    # Handle both IPv4 and IPv6 cases
+    try:
+        print("Try IPv4")
+        reader, writer = await asyncio.open_connection(
+            addr, port,
+            ssl=ctx,
+        )
+    except Exception:
+        print("Try IPv6")
+        reader, writer = await asyncio.open_connection(
+            addr, port,
+            ssl=ctx,
+            family=socket.AF_INET6
+        )
 
-  # Start TwoPartyClient using TwoWayPipe (takes no arguments in this mode)
-  client = capnp.TwoPartyClient()
-  cap = client.bootstrap().cast_as(thread_capnp.Example)
+    # Start TwoPartyClient using TwoWayPipe (takes no arguments in this mode)
+    client = capnp.TwoPartyClient()
+    cap = client.bootstrap().cast_as(thread_capnp.Example)
 
-  # Assemble reader and writer tasks, run in the background
-  coroutines = [myreader(client, reader), mywriter(client, writer)]
-  asyncio.gather(*coroutines, return_exceptions=True)
+    # Assemble reader and writer tasks, run in the background
+    coroutines = [myreader(client, reader), mywriter(client, writer)]
+    asyncio.gather(*coroutines, return_exceptions=True)
 
-  # Start background task for subscriber
-  tasks = [background(cap)]
-  asyncio.gather(*tasks, return_exceptions=True)
+    # Start background task for subscriber
+    tasks = [background(cap)]
+    asyncio.gather(*tasks, return_exceptions=True)
 
-  # Run blocking tasks
-  print('main: {}'.format(time.time()))
-  await cap.longRunning().a_wait()
-  print('main: {}'.format(time.time()))
-  await cap.longRunning().a_wait()
-  print('main: {}'.format(time.time()))
-  await cap.longRunning().a_wait()
-  print('main: {}'.format(time.time()))
+    # Run blocking tasks
+    print('main: {}'.format(time.time()))
+    await cap.longRunning().a_wait()
+    print('main: {}'.format(time.time()))
+    await cap.longRunning().a_wait()
+    print('main: {}'.format(time.time()))
+    await cap.longRunning().a_wait()
+    print('main: {}'.format(time.time()))
 
 if __name__ == '__main__':
-  # Using asyncio.run hits an asyncio ssl bug
-  # https://bugs.python.org/issue36709
-  #asyncio.run(main(parse_args().host), loop=loop, debug=True)
-  loop = asyncio.get_event_loop()
-  loop.run_until_complete(main(parse_args().host))
+    # Using asyncio.run hits an asyncio ssl bug
+    # https://bugs.python.org/issue36709
+    # asyncio.run(main(parse_args().host), loop=loop, debug=True)
+    loop = asyncio.get_event_loop()
+    loop.run_until_complete(main(parse_args().host))

examples/async_ssl_server.py

@@ -78,7 +78,7 @@ async def main():
             addr, port,
             ssl=ctx,
         )
-    except:
+    except Exception:
         print("Try IPv6")
         server = await asyncio.start_server(
             myserver,

examples/calculator_client.py

@@ -2,7 +2,6 @@
 
 from __future__ import print_function
 import argparse
-import socket
 import capnp
 
 import calculator_capnp
@@ -302,5 +301,6 @@ def main(host):
 
     print("PASS")
 
+
 if __name__ == '__main__':
     main(parse_args().host)

examples/calculator_server.py

@@ -2,8 +2,6 @@
 
 from __future__ import print_function
 import argparse
-import socket
-import random
 import capnp
 
 import calculator_capnp
@@ -136,5 +134,6 @@ def main():
     server = capnp.TwoPartyServer(address, bootstrap=CalculatorImpl())
     server.run_forever()
 
+
 if __name__ == '__main__':
     main()

examples/thread_client.py

@@ -14,11 +14,11 @@ capnp.create_event_loop(threaded=True)
 
 
 def parse_args():
-  parser = argparse.ArgumentParser(usage='Connects to the Example thread server \
+    parser = argparse.ArgumentParser(usage='Connects to the Example thread server \
 at the given address and does some RPCs')
-  parser.add_argument("host", help="HOST:PORT")
+    parser.add_argument("host", help="HOST:PORT")
 
-  return parser.parse_args()
+    return parser.parse_args()
 
 
 class StatusSubscriber(thread_capnp.Example.StatusSubscriber.Server):
@@ -30,29 +30,30 @@ class StatusSubscriber(thread_capnp.Example.StatusSubscriber.Server):
 
 
 def start_status_thread(host):
-  client = capnp.TwoPartyClient(host)
-  cap = client.bootstrap().cast_as(thread_capnp.Example)
+    client = capnp.TwoPartyClient(host)
+    cap = client.bootstrap().cast_as(thread_capnp.Example)
 
-  subscriber = StatusSubscriber()
-  promise = cap.subscribeStatus(subscriber)
-  promise.wait()
+    subscriber = StatusSubscriber()
+    promise = cap.subscribeStatus(subscriber)
+    promise.wait()
 
 
 def main(host):
-  client = capnp.TwoPartyClient(host)
-  cap = client.bootstrap().cast_as(thread_capnp.Example)
+    client = capnp.TwoPartyClient(host)
+    cap = client.bootstrap().cast_as(thread_capnp.Example)
 
-  status_thread = threading.Thread(target=start_status_thread, args=(host,))
-  status_thread.daemon = True
-  status_thread.start()
+    status_thread = threading.Thread(target=start_status_thread, args=(host,))
+    status_thread.daemon = True
+    status_thread.start()
+
+    print('main: {}'.format(time.time()))
+    cap.longRunning().wait()
+    print('main: {}'.format(time.time()))
+    cap.longRunning().wait()
+    print('main: {}'.format(time.time()))
+    cap.longRunning().wait()
+    print('main: {}'.format(time.time()))
 
-  print('main: {}'.format(time.time()))
-  cap.longRunning().wait()
-  print('main: {}'.format(time.time()))
-  cap.longRunning().wait()
-  print('main: {}'.format(time.time()))
-  cap.longRunning().wait()
-  print('main: {}'.format(time.time()))
 
 if __name__ == '__main__':
     main(parse_args().host)

examples/thread_server.py

@@ -37,5 +37,6 @@ def main():
     server = capnp.TwoPartyServer(address, bootstrap=ExampleImpl())
     server.run_forever()
 
+
 if __name__ == '__main__':
     main()