Format bench, examples, fuzz

Author: StephenBrown2

CONTRIBUTING.md

@@ -47,8 +47,8 @@ other hand, the following are all very welcome:
  [isort](https://github.com/timothycrosley/isort) as configured in
  the project. With those projects installed the commands,
 
- black h11/
- isort --dont-skip __init__.py --apply --settings-path setup.cfg --recursive h11
+ black h11/ bench/ examples/ fuzz/
+ isort --dont-skip __init__.py --apply --settings-path setup.cfg --recursive h11 bench examples fuzz
 
  will format your code for you.
 

bench/benchmarks/__init__.py

@@ -1 +0,0 @@
-

bench/benchmarks/benchmarks.py

@@ -3,55 +3,65 @@
 
 import h11
 
+
 # Basic ASV benchmark of core functionality
 def time_server_basic_get_with_realistic_headers():
  c = h11.Connection(h11.SERVER)
- c.receive_data(b"GET / HTTP/1.1\r\n"
- b"Host: example.com\r\n"
- b"User-Agent: Mozilla/5.0 (X11; Linux x86_64; "
- b"rv:45.0) Gecko/20100101 Firefox/45.0\r\n"
- b"Accept: text/html,application/xhtml+xml,"
- b"application/xml;q=0.9,*/*;q=0.8\r\n"
- b"Accept-Language: en-US,en;q=0.5\r\n"
- b"Accept-Encoding: gzip, deflate, br\r\n"
- b"DNT: 1\r\n"
- b"Cookie: ID=AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
- b"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
- b"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
- b"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
- b"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\r\n"
- b"Connection: keep-alive\r\n\r\n")
+ c.receive_data(
+ b"GET / HTTP/1.1\r\n"
+ b"Host: example.com\r\n"
+ b"User-Agent: Mozilla/5.0 (X11; Linux x86_64; "
+ b"rv:45.0) Gecko/20100101 Firefox/45.0\r\n"
+ b"Accept: text/html,application/xhtml+xml,"
+ b"application/xml;q=0.9,*/*;q=0.8\r\n"
+ b"Accept-Language: en-US,en;q=0.5\r\n"
+ b"Accept-Encoding: gzip, deflate, br\r\n"
+ b"DNT: 1\r\n"
+ b"Cookie: ID=AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
+ b"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
+ b"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
+ b"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
+ b"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\r\n"
+ b"Connection: keep-alive\r\n\r\n"
+ )
  while True:
  event = c.next_event()
  if event is h11.NEED_DATA:
  break
 
- c.send(h11.Response(status_code=200,
- headers=[
- (b"Cache-Control", b"private, max-age=0"),
- (b"Content-Encoding", b"gzip"),
- (b"Content-Type", b"text/html; charset=UTF-8"),
- (b"Date", b"Fri, 20 May 2016 09:23:41 GMT"),
- (b"Expires", b"-1"),
- (b"Server", b"gws"),
- (b"X-Frame-Options", b"SAMEORIGIN"),
- (b"X-XSS-Protection", b"1; mode=block"),
- (b"Content-Length", b"1000"),
- ]))
+ c.send(
+ h11.Response(
+ status_code=200,
+ headers=[
+ (b"Cache-Control", b"private, max-age=0"),
+ (b"Content-Encoding", b"gzip"),
+ (b"Content-Type", b"text/html; charset=UTF-8"),
+ (b"Date", b"Fri, 20 May 2016 09:23:41 GMT"),
+ (b"Expires", b"-1"),
+ (b"Server", b"gws"),
+ (b"X-Frame-Options", b"SAMEORIGIN"),
+ (b"X-XSS-Protection", b"1; mode=block"),
+ (b"Content-Length", b"1000"),
+ ],
+ )
+ )
  c.send(h11.Data(data=b"x" * 1000))
  c.send(h11.EndOfMessage())
 
+
 # Useful for manual benchmarking, e.g. with vmprof or on PyPy
 def _run_basic_get_repeatedly():
  from timeit import default_timer
+
  REPEAT = 10000
- #while True:
+ # while True:
  for _ in range(7):
  start = default_timer()
  for _ in range(REPEAT):
  time_server_basic_get_with_realistic_headers()
  finish = default_timer()
  print("{:.1f} requests/sec".format(REPEAT / (finish - start)))
 
+
 if __name__ == "__main__":
  _run_basic_get_repeatedly()

examples/basic-client.py

@@ -1,5 +1,6 @@
 import socket
 import ssl
+
 import h11
 
 ################################################################
@@ -8,13 +9,15 @@
 
 conn = h11.Connection(our_role=h11.CLIENT)
 ctx = ssl.create_default_context()
-sock = ctx.wrap_socket(socket.create_connection(("httpbin.org", 443)),
- server_hostname="httpbin.org")
+sock = ctx.wrap_socket(
+ socket.create_connection(("httpbin.org", 443)), server_hostname="httpbin.org"
+)
 
 ################################################################
 # Sending a request
 ################################################################
 
+
 def send(event):
  print("Sending event:")
  print(event)
@@ -24,16 +27,21 @@ def send(event):
  # Send the resulting bytes on the wire
  sock.sendall(data)
 
-send(h11.Request(method="GET",
- target="/get",
- headers=[("Host", "httpbin.org"),
- ("Connection", "close")]))
+
+send(
+ h11.Request(
+ method="GET",
+ target="/get",
+ headers=[("Host", "httpbin.org"), ("Connection", "close")],
+ )
+)
 send(h11.EndOfMessage())
 
 ################################################################
 # Receiving the response
 ################################################################
 
+
 def next_event():
  while True:
  # Check if an event is already available
@@ -47,6 +55,7 @@ def next_event():
  continue
  return event
 
+
 while True:
  event = next_event()
  print("Received event:")

examples/trio-server.py

@@ -79,8 +79,8 @@
 from itertools import count
 from wsgiref.handlers import format_date_time
 
-import trio
 import h11
+import trio
 
 MAX_RECV = 2 ** 16
 TIMEOUT = 10
@@ -99,10 +99,9 @@ def __init__(self, stream):
  self.stream = stream
  self.conn = h11.Connection(h11.SERVER)
  # Our Server: header
- self.ident = " ".join([
- "h11-example-trio-server/{}".format(h11.__version__),
- h11.PRODUCT_ID,
- ]).encode("ascii")
+ self.ident = " ".join(
+ ["h11-example-trio-server/{}".format(h11.__version__), h11.PRODUCT_ID]
+ ).encode("ascii")
  # A unique id for this connection, to include in debugging output
  # (useful for understanding what's going on if there are multiple
  # simultaneous clients).
@@ -120,8 +119,8 @@ async def _read_from_peer(self):
  if self.conn.they_are_waiting_for_100_continue:
  self.info("Sending 100 Continue")
  go_ahead = h11.InformationalResponse(
- status_code=100,
-  headers=self.basic_headers())
+ status_code=100, headers=self.basic_headers()
+ )
  await self.send(go_ahead)
  try:
  data = await self.stream.receive_some(MAX_RECV)
@@ -185,6 +184,7 @@ def info(self, *args):
  # Little debugging method
  print("{}:".format(self._obj_id), *args)
 
+
 ################################################################
 # Server main loop
 ################################################################
@@ -218,8 +218,7 @@ async def http_serve(stream):
  wrapper = TrioHTTPWrapper(stream)
  wrapper.info("Got new connection")
  while True:
- assert wrapper.conn.states == {
- h11.CLIENT: h11.IDLE, h11.SERVER: h11.IDLE}
+ assert wrapper.conn.states == {h11.CLIENT: h11.IDLE, h11.SERVER: h11.IDLE}
 
  try:
  with trio.fail_after(TIMEOUT):
@@ -244,19 +243,19 @@ async def http_serve(stream):
  states = wrapper.conn.states
  wrapper.info("unexpected state", states, "-- bailing out")
  await maybe_send_error_response(
- wrapper,
-  RuntimeError("unexpected state {}".format(states)))
+ wrapper, RuntimeError("unexpected state {}".format(states))
+ )
  await wrapper.shutdown_and_clean_up()
  return
 
+
 ################################################################
 # Actual response handlers
 ################################################################
 
 # Helper function
 async def send_simple_response(wrapper, status_code, content_type, body):
- wrapper.info("Sending", status_code,
- "response with", len(body), "bytes")
+ wrapper.info("Sending", status_code, "response with", len(body), "bytes")
  headers = wrapper.basic_headers()
  headers.append(("Content-Type", content_type))
  headers.append(("Content-Length", str(len(body))))
@@ -265,12 +264,12 @@ async def send_simple_response(wrapper, status_code, content_type, body):
  await wrapper.send(h11.Data(data=body))
  await wrapper.send(h11.EndOfMessage())
 
+
 async def maybe_send_error_response(wrapper, exc):
  # If we can't send an error, oh well, nothing to be done
  wrapper.info("trying to send error response...")
  if wrapper.conn.our_state not in {h11.IDLE, h11.SEND_RESPONSE}:
- wrapper.info("...but I can't, because our state is",
- wrapper.conn.our_state)
+ wrapper.info("...but I can't, because our state is", wrapper.conn.our_state)
  return
  try:
  if isinstance(exc, h11.RemoteProtocolError):
@@ -280,13 +279,13 @@ async def maybe_send_error_response(wrapper, exc):
  else:
  status_code = 500
  body = str(exc).encode("utf-8")
- await send_simple_response(wrapper,
- status_code,
- "text/plain; charset=utf-8",
- body)
+ await send_simple_response(
+ wrapper, status_code, "text/plain; charset=utf-8", body
+ )
  except Exception as exc:
  wrapper.info("error while sending error response:", exc)
 
+
 async def send_echo_response(wrapper, request):
  wrapper.info("Preparing echo response")
  if request.method not in {b"GET", b"POST"}:
@@ -296,8 +295,10 @@ async def send_echo_response(wrapper, request):
  response_json = {
  "method": request.method.decode("ascii"),
  "target": request.target.decode("ascii"),
- "headers": [(name.decode("ascii"), value.decode("ascii"))
- for (name, value) in request.headers],
+ "headers": [
+ (name.decode("ascii"), value.decode("ascii"))
+ for (name, value) in request.headers
+ ],
  "body": "",
  }
  while True:
@@ -306,15 +307,14 @@ async def send_echo_response(wrapper, request):
  break
  assert type(event) is h11.Data
  response_json["body"] += event.data.decode("ascii")
- response_body_unicode = json.dumps(response_json,
- sort_keys=True,
- indent=4,
- separators=(",", ": "))
+ response_body_unicode = json.dumps(
+ response_json, sort_keys=True, indent=4, separators=(",", ": ")
+ )
  response_body_bytes = response_body_unicode.encode("utf-8")
- await send_simple_response(wrapper,
-  200,
-  "application/json; charset=utf-8",
- response_body_bytes)
+ await send_simple_response(
+ wrapper, 200, "application/json; charset=utf-8", response_body_bytes
+ )
+
 
 async def serve(port):
  print("listening on http://localhost:{}".format(port))
@@ -323,6 +323,7 @@ async def serve(port):
  except KeyboardInterrupt:
  print("KeyboardInterrupt - shutting down")
 
+
 ################################################################
 # Run the server
 ################################################################

fuzz/afl-server.py

@@ -2,18 +2,18 @@
 # either successfully parse it, or else throw a RemoteProtocolError, never any
 # other error.
 
-import sys
 import os
+import sys
 
 import afl
-
 import h11
 
 if sys.version_info[0] >= 3:
  in_file = sys.stdin.detach()
 else:
  in_file = sys.stdin
 
+
 def process_all(c):
  while True:
  event = c.next_event()
@@ -22,6 +22,7 @@ def process_all(c):
  if type(event) is h11.ConnectionClosed:
  break
 
+
 afl.init()
 
 data = in_file.read()
@@ -40,7 +41,7 @@ def process_all(c):
 server2 = h11.Connection(h11.SERVER)
 try:
  for i in range(len(data)):
- server2.receive_data(data[i:i + 1])
+ server2.receive_data(data[i : i + 1])
  process_all(server2)
  server2.receive_data(b"")
  process_all(server2)

tox.ini

@@ -11,5 +11,5 @@ deps =
  black
  isort
 commands =
- black --check --diff h11/
- isort --dont-skip __init__.py --diff --check --settings-path setup.cfg --recursive h11
+ black --check --diff h11/ bench/ examples/ fuzz/
+ isort --dont-skip __init__.py --diff --check --settings-path setup.cfg --recursive h11 bench examples fuzz