Adopt black and isort to autoformat the files

This removes any need to figure out how to style the code for h11,
instead allowing these two commands to do it instead,

    black h11/
    isort --dont-skip __init__.py --apply --settings-path setup.cfg --recursive h11

In addition a format stage has been added to the tox setup to enforce
this styling.

This is the same styling as used by the wsproto project.

Author: pgjones

CONTRIBUTING.md

@@ -42,15 +42,15 @@ other hand, the following are all very welcome:
 
 * Code should work across all currently supported Python releases.
 
-* Code should follow
-  [PEP 8](https://www.python.org/dev/peps/pep-0008/) style. We aren't
-  blind sticklers for this though (in fact,
-  [not being a blind stickler for PEP 8](https://www.python.org/dev/peps/pep-0008/#a-foolish-consistency-is-the-hobgoblin-of-little-minds)
-  is one of the requirements in PEP 8!). If you run
-  [pycodestyle](https://github.com/PyCQA/pycodestyle) over the code
-  base then it complains about lots of things, but these are generally
-  places where "fixing the problem" would make the code less
-  readable. Still, though, when in doubt: PEP 8.
+* Code must be formatted using
+  [black](https://github.com/python/black) and
+  [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
+
+  will format your code for you.
 
 * If you change the code, then you have to also add or fix at least
   one test. (See below for how to run the test suite.) This helps us

h11/__init__.py

@@ -6,13 +6,14 @@
 # semantics to check that what you're asking to write to the wire is sensible,
 # but at least it gets you out of dealing with the wire itself.
 
+from ._connection import *
+from ._events import *
+from ._state import *
+from ._util import LocalProtocolError, ProtocolError, RemoteProtocolError
 from ._version import __version__
+
 PRODUCT_ID = "python-h11/" + __version__
 
-from ._util import ProtocolError, LocalProtocolError, RemoteProtocolError
-from ._events import *
-from ._connection import *
-from ._state import *
 
 __all__ = ["ProtocolError", "LocalProtocolError", "RemoteProtocolError"]
 __all__ += _events.__all__

h11/_abnf.py

@@ -66,8 +66,8 @@
     r":"
     r"{OWS}"
     r"(?P<field_value>{field_value})"
-    r"{OWS}"
-    .format(**globals()))
+    r"{OWS}".format(**globals())
+)
 
 # https://svn.tools.ietf.org/svn/wg/httpbis/specs/rfc7230.html#request.line
 #
@@ -87,8 +87,8 @@
     r" "
     r"(?P<target>{request_target})"
     r" "
-    r"{http_version}"
-    .format(**globals()))
+    r"{http_version}".format(**globals())
+)
 
 # https://svn.tools.ietf.org/svn/wg/httpbis/specs/rfc7230.html#status.line
 #
@@ -106,8 +106,8 @@
     #   https://github.com/scrapy/scrapy/issues/345#issuecomment-281756036
     #   https://github.com/seanmonstar/httparse/issues/29
     # so make it optional. ?: is a non-capturing group.
-    r"(?: (?P<reason>{reason_phrase}))?"
-    .format(**globals()))
+    r"(?: (?P<reason>{reason_phrase}))?".format(**globals())
+)
 
 HEXDIG = r"[0-9A-Fa-f]"
 # Actually
@@ -125,5 +125,5 @@
 chunk_header = (
     r"(?P<chunk_size>{chunk_size})"
     r"(?P<chunk_ext>{chunk_ext})?"
-    r"\r\n"
-    .format(**globals()))
+    r"\r\n".format(**globals())
+)

h11/_connection.py

@@ -1,18 +1,17 @@
 # This contains the main Connection class. Everything in h11 revolves around
 # this.
 
-# Import all event types
-from ._events import *
-# Import all state sentinels
-from ._state import *
-# Import the internal things we need
-from ._util import LocalProtocolError, RemoteProtocolError, make_sentinel
-from ._state import ConnectionState, _SWITCH_UPGRADE, _SWITCH_CONNECT
-from ._headers import (
-    get_comma_header, set_comma_header, has_expect_100_continue,
-)
-from ._receivebuffer import ReceiveBuffer
+from ._events import *  # Import all event types
+from ._headers import get_comma_header, has_expect_100_continue, set_comma_header
 from ._readers import READERS
+from ._receivebuffer import ReceiveBuffer
+from ._state import *  # Import all state sentinels
+from ._state import _SWITCH_CONNECT, _SWITCH_UPGRADE, ConnectionState
+from ._util import (  # Import the internal things we need
+    LocalProtocolError,
+    make_sentinel,
+    RemoteProtocolError,
+)
 from ._writers import WRITERS
 
 # Everything in __all__ gets re-exported as part of the h11 public API.
@@ -53,6 +52,7 @@ def _keep_alive(event):
         return False
     return True
 
+
 def _body_framing(request_method, event):
     # Called when we enter SEND_BODY to figure out framing information for
     # this body.
@@ -73,10 +73,11 @@ def _body_framing(request_method, event):
     # Step 1: some responses always have an empty body, regardless of what the
     # headers say.
     if type(event) is Response:
-        if (event.status_code in (204, 304)
+        if (
+            event.status_code in (204, 304)
             or request_method == b"HEAD"
-            or (request_method == b"CONNECT"
-                and 200 <= event.status_code < 300)):
+            or (request_method == b"CONNECT" and 200 <= event.status_code < 300)
+        ):
             return ("content-length", (0,))
         # Section 3.3.3 also lists another case -- responses with status_code
         # < 200. For us these are InformationalResponses, not Responses, so
@@ -100,12 +101,14 @@ def _body_framing(request_method, event):
     else:
         return ("http/1.0", ())
 
+
 ################################################################
 #
 # The main Connection class
 #
 ################################################################
 
+
 class Connection(object):
     """An object encapsulating the state of an HTTP connection.
 
@@ -121,14 +124,14 @@ class Connection(object):
             :exc:`RemoteProtocolError`.
 
     """
-    def __init__(self,
-                 our_role,
-                 max_incomplete_event_size=DEFAULT_MAX_INCOMPLETE_EVENT_SIZE):
+
+    def __init__(
+        self, our_role, max_incomplete_event_size=DEFAULT_MAX_INCOMPLETE_EVENT_SIZE
+    ):
         self._max_incomplete_event_size = max_incomplete_event_size
         # State and role tracking
         if our_role not in (CLIENT, SERVER):
-            raise ValueError(
-                "expected CLIENT or SERVER, not {!r}".format(our_role))
+            raise ValueError("expected CLIENT or SERVER, not {!r}".format(our_role))
         self.our_role = our_role
         if our_role is CLIENT:
             self.their_role = SERVER
@@ -185,8 +188,7 @@ def their_state(self):
 
     @property
     def they_are_waiting_for_100_continue(self):
-        return (self.their_role is CLIENT
-                and self.client_is_waiting_for_100_continue)
+        return self.their_role is CLIENT and self.client_is_waiting_for_100_continue
 
     def start_next_cycle(self):
         """Attempt to reset our connection state for a new request/response
@@ -217,8 +219,10 @@ def _server_switch_event(self, event):
         if type(event) is InformationalResponse and event.status_code == 101:
             return _SWITCH_UPGRADE
         if type(event) is Response:
-            if (_SWITCH_CONNECT in self._cstate.pending_switch_proposals
-                and 200 <= event.status_code < 300):
+            if (
+                _SWITCH_CONNECT in self._cstate.pending_switch_proposals
+                and 200 <= event.status_code < 300
+            ):
                 return _SWITCH_CONNECT
         return None
 
@@ -244,8 +248,11 @@ def _process_event(self, role, event):
             self._request_method = event.method
 
         # self.their_http_version
-        if (role is self.their_role
-            and type(event) in (Request, Response, InformationalResponse)):
+        if role is self.their_role and type(event) in (
+            Request,
+            Response,
+            InformationalResponse,
+        ):
             self.their_http_version = event.http_version
 
         # Keep alive handling
@@ -341,8 +348,7 @@ def receive_data(self, data):
         """
         if data:
             if self._receive_buffer_closed:
-                raise RuntimeError(
-                    "received close, then received more data?")
+                raise RuntimeError("received close, then received more data?")
             self._receive_buffer += data
         else:
             self._receive_buffer_closed = True
@@ -414,8 +420,7 @@ def next_event(self):
         """
 
         if self.their_state is ERROR:
-            raise RemoteProtocolError(
-                "Can't receive data when peer state is ERROR")
+            raise RemoteProtocolError("Can't receive data when peer state is ERROR")
         try:
             event = self._extract_next_receive_event()
             if event not in [NEED_DATA, PAUSED]:
@@ -425,13 +430,13 @@ def next_event(self):
                 if len(self._receive_buffer) > self._max_incomplete_event_size:
                     # 431 is "Request header fields too large" which is pretty
                     # much the only situation where we can get here
-                    raise RemoteProtocolError("Receive buffer too long",
-                                              error_status_hint=431)
+                    raise RemoteProtocolError(
+                        "Receive buffer too long", error_status_hint=431
+                    )
                 if self._receive_buffer_closed:
                     # We're still trying to complete some event, but that's
                     # never going to happen because no more data is coming
-                    raise RemoteProtocolError(
-                        "peer unexpectedly closed connection")
+                    raise RemoteProtocolError("peer unexpectedly closed connection")
             return event
         except BaseException as exc:
             self._process_error(self.their_role)
@@ -476,8 +481,7 @@ def send_with_data_passthrough(self, event):
 
         """
         if self.our_state is ERROR:
-            raise LocalProtocolError(
-                "Can't send data when our state is ERROR")
+            raise LocalProtocolError("Can't send data when our state is ERROR")
         try:
             if type(event) is Response:
                 self._clean_up_response_headers_for_sending(event)
@@ -557,8 +561,7 @@ def _clean_up_response_headers_for_sending(self, response):
             # to fix it instead of erroring out, so we'll accord the user the
             # same respect).
             set_comma_header(headers, b"content-length", [])
-            if (self.their_http_version is None
-                or self.their_http_version < b"1.1"):
+            if self.their_http_version is None or self.their_http_version < b"1.1":
                 # Either we never got a valid request and are sending back an
                 # error (their_http_version is None), so we assume the worst;
                 # or else we did get a valid HTTP/1.0 request, so we know that