Merge pull request #93 from StephenBrown2/format_examples

Format bench, examples, fuzz

Author: pgjones

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