From fcfe88c49034e4f5e6316a581ac57aaaf9613346 Mon Sep 17 00:00:00 2001 From: Bert JW Regeer Date: Mon, 7 Sep 2020 11:59:22 -0700 Subject: Black formatting update --- src/waitress/adjustments.py | 9 +++---- src/waitress/channel.py | 4 +-- src/waitress/proxy_headers.py | 18 ++++++------- src/waitress/server.py | 6 ++++- src/waitress/task.py | 9 +++---- tests/fixtureapps/echo.py | 13 +++++++-- tests/fixtureapps/nocl.py | 3 +-- tests/test_adjustments.py | 24 ++++++++++++++--- tests/test_functional.py | 27 ++++++++----------- tests/test_parser.py | 13 +++++++-- tests/test_proxy_headers.py | 63 ++++++++++++++++++++++++++++++++++--------- tests/test_regression.py | 3 +-- tests/test_task.py | 5 +++- tests/test_wasyncore.py | 2 +- 14 files changed, 132 insertions(+), 67 deletions(-) diff --git a/src/waitress/adjustments.py b/src/waitress/adjustments.py index 145ac86..45ac41b 100644 --- a/src/waitress/adjustments.py +++ b/src/waitress/adjustments.py @@ -28,7 +28,7 @@ KNOWN_PROXY_HEADERS = frozenset( def asbool(s): - """ Return the boolean value ``True`` if the case-lowered value of string + """Return the boolean value ``True`` if the case-lowered value of string input ``s`` is any of ``t``, ``true``, ``y``, ``on``, or ``1``, otherwise return the boolean value ``False``. If ``s`` is the value ``None``, return ``False``. If ``s`` is already one of the boolean values ``True`` @@ -53,7 +53,7 @@ def aslist_cronly(value): def aslist(value): - """ Return a list of strings, separating the input based on newlines + """Return a list of strings, separating the input based on newlines and, if flatten=True (the default), also split on spaces within each line.""" values = aslist_cronly(value) @@ -100,8 +100,7 @@ class _bool_marker: class Adjustments: - """This class contains tunable parameters. - """ + """This class contains tunable parameters.""" _params = ( ("host", str), @@ -303,7 +302,7 @@ class Adjustments: if "send_bytes" in kw: warnings.warn( - "send_bytes will be removed in a future release", DeprecationWarning, + "send_bytes will be removed in a future release", DeprecationWarning ) for k, v in kw.items(): diff --git a/src/waitress/channel.py b/src/waitress/channel.py index d756b96..65bc87f 100644 --- a/src/waitress/channel.py +++ b/src/waitress/channel.py @@ -53,9 +53,7 @@ class HTTPChannel(wasyncore.dispatcher): # ASYNCHRONOUS METHODS (including __init__) # - def __init__( - self, server, sock, addr, adj, map=None, - ): + def __init__(self, server, sock, addr, adj, map=None): self.server = server self.adj = adj self.outbufs = [OverflowableBuffer(adj.outbuf_overflow)] diff --git a/src/waitress/proxy_headers.py b/src/waitress/proxy_headers.py index 13cb2ed..5d61646 100644 --- a/src/waitress/proxy_headers.py +++ b/src/waitress/proxy_headers.py @@ -58,7 +58,7 @@ def proxy_headers_middleware( # Clear out the untrusted proxy headers if clear_untrusted: clear_untrusted_headers( - environ, untrusted_headers, log_warning=log_untrusted, logger=logger, + environ, untrusted_headers, log_warning=log_untrusted, logger=logger ) return app(environ, start_response) @@ -67,7 +67,7 @@ def proxy_headers_middleware( def parse_proxy_headers( - environ, trusted_proxy_count, trusted_proxy_headers, logger=logger, + environ, trusted_proxy_count, trusted_proxy_headers, logger=logger ): if trusted_proxy_headers is None: trusted_proxy_headers = set() @@ -78,7 +78,7 @@ def parse_proxy_headers( untrusted_headers = set(PROXY_HEADERS) def raise_for_multiple_values(): - raise ValueError("Unspecified behavior for multiple values found in header",) + raise ValueError("Unspecified behavior for multiple values found in header") if "x-forwarded-for" in trusted_proxy_headers and "HTTP_X_FORWARDED_FOR" in environ: try: @@ -105,7 +105,7 @@ def parse_proxy_headers( untrusted_headers.remove("X_FORWARDED_FOR") except Exception as ex: raise MalformedProxyHeader( - "X-Forwarded-For", str(ex), environ["HTTP_X_FORWARDED_FOR"], + "X-Forwarded-For", str(ex), environ["HTTP_X_FORWARDED_FOR"] ) if ( @@ -126,7 +126,7 @@ def parse_proxy_headers( untrusted_headers.remove("X_FORWARDED_HOST") except Exception as ex: raise MalformedProxyHeader( - "X-Forwarded-Host", str(ex), environ["HTTP_X_FORWARDED_HOST"], + "X-Forwarded-Host", str(ex), environ["HTTP_X_FORWARDED_HOST"] ) if "x-forwarded-proto" in trusted_proxy_headers: @@ -137,7 +137,7 @@ def parse_proxy_headers( untrusted_headers.remove("X_FORWARDED_PROTO") except Exception as ex: raise MalformedProxyHeader( - "X-Forwarded-Proto", str(ex), environ["HTTP_X_FORWARDED_PROTO"], + "X-Forwarded-Proto", str(ex), environ["HTTP_X_FORWARDED_PROTO"] ) if "x-forwarded-port" in trusted_proxy_headers: @@ -148,7 +148,7 @@ def parse_proxy_headers( untrusted_headers.remove("X_FORWARDED_PORT") except Exception as ex: raise MalformedProxyHeader( - "X-Forwarded-Port", str(ex), environ["HTTP_X_FORWARDED_PORT"], + "X-Forwarded-Port", str(ex), environ["HTTP_X_FORWARDED_PORT"] ) if "x-forwarded-by" in trusted_proxy_headers: @@ -210,9 +210,7 @@ def parse_proxy_headers( ) ) except Exception as ex: - raise MalformedProxyHeader( - "Forwarded", str(ex), environ["HTTP_FORWARDED"], - ) + raise MalformedProxyHeader("Forwarded", str(ex), environ["HTTP_FORWARDED"]) proxies = proxies[-trusted_proxy_count:] diff --git a/src/waitress/server.py b/src/waitress/server.py index 06bb957..85e3217 100644 --- a/src/waitress/server.py +++ b/src/waitress/server.py @@ -138,7 +138,11 @@ class MultiSocketServer: asyncore = wasyncore # test shim def __init__( - self, map=None, adj=None, effective_listen=None, dispatcher=None, + self, + map=None, + adj=None, + effective_listen=None, + dispatcher=None, ): self.adj = adj self.map = map diff --git a/src/waitress/task.py b/src/waitress/task.py index 1bcc540..3a7cf17 100644 --- a/src/waitress/task.py +++ b/src/waitress/task.py @@ -41,8 +41,7 @@ hop_by_hop = frozenset( class ThreadedTaskDispatcher: - """A Task Dispatcher that creates a thread for each task. - """ + """A Task Dispatcher that creates a thread for each task.""" stop_count = 0 # Number of threads that will stop soon. active_count = 0 # Number of currently active threads @@ -341,8 +340,7 @@ class Task: class ErrorTask(Task): - """ An error task produces an error response - """ + """An error task produces an error response""" complete = True @@ -361,8 +359,7 @@ class ErrorTask(Task): class WSGITask(Task): - """A WSGI task produces a response from a WSGI application. - """ + """A WSGI task produces a response from a WSGI application.""" environ = None diff --git a/tests/fixtureapps/echo.py b/tests/fixtureapps/echo.py index 813bdac..8497562 100644 --- a/tests/fixtureapps/echo.py +++ b/tests/fixtureapps/echo.py @@ -8,7 +8,13 @@ def app_body_only(environ, start_response): # pragma: no cover cl = int(cl) body = environ["wsgi.input"].read(cl) cl = str(len(body)) - start_response("200 OK", [("Content-Length", cl), ("Content-Type", "text/plain"),]) + start_response( + "200 OK", + [ + ("Content-Length", cl), + ("Content-Type", "text/plain"), + ], + ) return [body] @@ -36,7 +42,10 @@ def app(environ, start_response): # pragma: no cover response = json.dumps(meta).encode("utf8") + b"\r\n\r\n" + request_body start_response( "200 OK", - [("Content-Length", str(len(response))), ("Content-Type", "text/plain"),], + [ + ("Content-Length", str(len(response))), + ("Content-Type", "text/plain"), + ], ) return [response] diff --git a/tests/fixtureapps/nocl.py b/tests/fixtureapps/nocl.py index c95a4f5..8948422 100644 --- a/tests/fixtureapps/nocl.py +++ b/tests/fixtureapps/nocl.py @@ -1,6 +1,5 @@ def chunks(l, n): # pragma: no cover - """ Yield successive n-sized chunks from l. - """ + """Yield successive n-sized chunks from l.""" for i in range(0, len(l), n): yield l[i : i + n] diff --git a/tests/test_adjustments.py b/tests/test_adjustments.py index 420ee4c..69cdf51 100644 --- a/tests/test_adjustments.py +++ b/tests/test_adjustments.py @@ -220,7 +220,9 @@ class TestAdjustments(unittest.TestCase): if WIN: # pragma: no cover # On Windows this is broken, so we raise a ValueError self.assertRaises( - ValueError, self._makeOne, listen="127.0.0.1:http", + ValueError, + self._makeOne, + listen="127.0.0.1:http", ) return @@ -442,18 +444,32 @@ class TestCLI(unittest.TestCase): ["--host=localhost", "--port=80", "--unix-socket-perms=777"] ) self.assertDictContainsSubset( - {"host": "localhost", "port": "80", "unix_socket_perms": "777",}, opts + { + "host": "localhost", + "port": "80", + "unix_socket_perms": "777", + }, + opts, ) self.assertSequenceEqual(args, []) def test_listen_params(self): - opts, args = self.parse(["--listen=test:80",]) + opts, args = self.parse( + [ + "--listen=test:80", + ] + ) self.assertDictContainsSubset({"listen": " test:80"}, opts) self.assertSequenceEqual(args, []) def test_multiple_listen_params(self): - opts, args = self.parse(["--listen=test:80", "--listen=test:8080",]) + opts, args = self.parse( + [ + "--listen=test:80", + "--listen=test:8080", + ] + ) self.assertDictContainsSubset({"listen": " test:80 test:8080"}, opts) self.assertSequenceEqual(args, []) diff --git a/tests/test_functional.py b/tests/test_functional.py index c99876d..a52d256 100644 --- a/tests/test_functional.py +++ b/tests/test_functional.py @@ -19,16 +19,14 @@ here = dn(__file__) class NullHandler(logging.Handler): # pragma: no cover - """A logging handler that swallows all emitted messages. - """ + """A logging handler that swallows all emitted messages.""" def emit(self, record): pass def start_server(app, svr, queue, **kwargs): # pragma: no cover - """Run a fixture application. - """ + """Run a fixture application.""" logging.getLogger("waitress").addHandler(NullHandler()) try_register_coverage() svr(app, queue, **kwargs).run() @@ -47,8 +45,7 @@ def try_register_coverage(): # pragma: no cover class FixtureTcpWSGIServer(server.TcpWSGIServer): - """A version of TcpWSGIServer that relays back what it's bound to. - """ + """A version of TcpWSGIServer that relays back what it's bound to.""" family = socket.AF_INET # Testing @@ -80,7 +77,9 @@ class SubprocessTests: os.environ["COVERAGE_PROCESS_START"] = os.environ["COVERAGE_RCFILE"] self.proc = multiprocessing.Process( - target=start_server, args=(target, self.server, self.queue), kwargs=kw, + target=start_server, + args=(target, self.server, self.queue), + kwargs=kw, ) self.proc.start() @@ -1472,8 +1471,7 @@ class TcpFileWrapperTests(FileWrapperTests, TcpTests, unittest.TestCase): if hasattr(socket, "AF_UNIX"): class FixtureUnixWSGIServer(server.UnixWSGIServer): - """A version of UnixWSGIServer that relays back what it's bound to. - """ + """A version of UnixWSGIServer that relays back what it's bound to.""" family = socket.AF_UNIX # Testing @@ -1537,8 +1535,7 @@ if hasattr(socket, "AF_UNIX"): def parse_headers(fp): - """Parses only RFC2822 headers from a file pointer. - """ + """Parses only RFC2822 headers from a file pointer.""" headers = {} while True: @@ -1554,8 +1551,7 @@ def parse_headers(fp): class UnixHTTPConnection(httplib.HTTPConnection): - """Patched version of HTTPConnection that uses Unix domain sockets. - """ + """Patched version of HTTPConnection that uses Unix domain sockets.""" def __init__(self, path): httplib.HTTPConnection.__init__(self, "localhost") @@ -1629,7 +1625,7 @@ def read_http(fp): # pragma: no cover # stolen from gevent def get_errno(exc): # pragma: no cover - """ Get the error code out of socket.error objects. + """Get the error code out of socket.error objects. socket.error in <2.5 does not have errno attribute socket.error in 3.x does not allow indexing access e.args[0] works for all. @@ -1649,8 +1645,7 @@ def get_errno(exc): # pragma: no cover def chunks(l, n): - """ Yield successive n-sized chunks from l. - """ + """Yield successive n-sized chunks from l.""" for i in range(0, len(l), n): yield l[i : i + n] diff --git a/tests/test_parser.py b/tests/test_parser.py index eace4af..0a68a66 100644 --- a/tests/test_parser.py +++ b/tests/test_parser.py @@ -572,7 +572,11 @@ class TestHTTPRequestParserIntegration(unittest.TestCase): self.assertFalse(parser.empty) self.assertEqual( parser.headers, - {"FIRSTNAME": "mickey", "LASTNAME": "Mouse", "CONTENT_LENGTH": "6",}, + { + "FIRSTNAME": "mickey", + "LASTNAME": "Mouse", + "CONTENT_LENGTH": "6", + }, ) self.assertEqual(parser.path, "/foobar") self.assertEqual(parser.command, "GET") @@ -662,7 +666,12 @@ class TestHTTPRequestParserIntegration(unittest.TestCase): ) self.feed(data) self.assertTrue(self.parser.completed) - self.assertEqual(self.parser.headers, {"CONTENT_LENGTH": "6",}) + self.assertEqual( + self.parser.headers, + { + "CONTENT_LENGTH": "6", + }, + ) class Test_unquote_bytes_to_wsgi(unittest.TestCase): diff --git a/tests/test_proxy_headers.py b/tests/test_proxy_headers.py index e6f0ed6..9ed131e 100644 --- a/tests/test_proxy_headers.py +++ b/tests/test_proxy_headers.py @@ -23,7 +23,11 @@ class TestProxyHeadersMiddleware(unittest.TestCase): inner = DummyApp() app = self._makeOne(inner) response = self._callFUT( - app, headers={"X_FOO": "BAR", "X_FORWARDED_PROTO": "https",} + app, + headers={ + "X_FOO": "BAR", + "X_FORWARDED_PROTO": "https", + }, ) self.assertEqual(response.status, "200 OK") self.assertEqual(inner.environ["wsgi.url_scheme"], "http") @@ -38,7 +42,10 @@ class TestProxyHeadersMiddleware(unittest.TestCase): response = self._callFUT( app, addr=["192.168.1.1", 8080], - headers={"X_FOO": "BAR", "X_FORWARDED_PROTO": "https",}, + headers={ + "X_FOO": "BAR", + "X_FORWARDED_PROTO": "https", + }, ) environ = inner.environ @@ -113,7 +120,9 @@ class TestProxyHeadersMiddleware(unittest.TestCase): "X_FORWARDED_HOST": "example.org", } response = self._callFUT( - app, addr=["192.168.1.1", 80], headers=headers_orig.copy(), + app, + addr=["192.168.1.1", 80], + headers=headers_orig.copy(), ) self.assertEqual(response.status, "200 OK") environ = inner.environ @@ -178,7 +187,9 @@ class TestProxyHeadersMiddleware(unittest.TestCase): def test_parse_proxy_headers_forwarded_for(self): inner = DummyApp() app = self._makeOne( - inner, trusted_proxy="*", trusted_proxy_headers={"x-forwarded-for"}, + inner, + trusted_proxy="*", + trusted_proxy_headers={"x-forwarded-for"}, ) response = self._callFUT(app, headers={"X_FORWARDED_FOR": "192.0.2.1"}) self.assertEqual(response.status, "200 OK") @@ -189,7 +200,9 @@ class TestProxyHeadersMiddleware(unittest.TestCase): def test_parse_proxy_headers_forwarded_for_v6_missing_brackets(self): inner = DummyApp() app = self._makeOne( - inner, trusted_proxy="*", trusted_proxy_headers={"x-forwarded-for"}, + inner, + trusted_proxy="*", + trusted_proxy_headers={"x-forwarded-for"}, ) response = self._callFUT(app, headers={"X_FORWARDED_FOR": "2001:db8::0"}) self.assertEqual(response.status, "200 OK") @@ -473,7 +486,10 @@ class TestProxyHeadersMiddleware(unittest.TestCase): trusted_proxy_headers={"forwarded"}, ) response = self._callFUT( - app, headers={"FORWARDED": "For=198.51.100.2;;proto=https;by=_unused",} + app, + headers={ + "FORWARDED": "For=198.51.100.2;;proto=https;by=_unused", + }, ) self.assertEqual(response.status, "200 OK") @@ -489,7 +505,10 @@ class TestProxyHeadersMiddleware(unittest.TestCase): trusted_proxy_headers={"forwarded"}, ) response = self._callFUT( - app, headers={"FORWARDED": "For=198.51.100.2; proto =https",} + app, + headers={ + "FORWARDED": "For=198.51.100.2; proto =https", + }, ) self.assertEqual(response.status, "400 Bad Request") self.assertIn(b'Header "Forwarded" malformed', response.body) @@ -503,7 +522,10 @@ class TestProxyHeadersMiddleware(unittest.TestCase): trusted_proxy_headers={"forwarded"}, ) response = self._callFUT( - app, headers={"FORWARDED": 'For= "198.51.100.2"; proto =https',} + app, + headers={ + "FORWARDED": 'For= "198.51.100.2"; proto =https', + }, ) self.assertEqual(response.status, "400 Bad Request") self.assertIn(b'Header "Forwarded" malformed', response.body) @@ -553,7 +575,11 @@ class TestProxyHeadersMiddleware(unittest.TestCase): def test_parse_no_valid_proxy_headers(self): inner = DummyApp() - app = self._makeOne(inner, trusted_proxy="*", trusted_proxy_count=1,) + app = self._makeOne( + inner, + trusted_proxy="*", + trusted_proxy_count=1, + ) response = self._callFUT( app, headers={ @@ -580,7 +606,12 @@ class TestProxyHeadersMiddleware(unittest.TestCase): trusted_proxy_headers={"x-forwarded-proto"}, logger=logger, ) - response = self._callFUT(app, headers={"X_FORWARDED_PROTO": "http, https",}) + response = self._callFUT( + app, + headers={ + "X_FORWARDED_PROTO": "http, https", + }, + ) self.assertEqual(response.status, "400 Bad Request") self.assertIn(b'Header "X-Forwarded-Proto" malformed', response.body) @@ -594,7 +625,12 @@ class TestProxyHeadersMiddleware(unittest.TestCase): trusted_proxy_headers={"x-forwarded-port"}, logger=logger, ) - response = self._callFUT(app, headers={"X_FORWARDED_PORT": "443, 80",}) + response = self._callFUT( + app, + headers={ + "X_FORWARDED_PORT": "443, 80", + }, + ) self.assertEqual(response.status, "400 Bad Request") self.assertIn(b'Header "X-Forwarded-Port" malformed', response.body) @@ -701,7 +737,10 @@ class DummyResponse: def DummyEnviron( - addr=("127.0.0.1", 8080), scheme="http", server="localhost", headers=None, + addr=("127.0.0.1", 8080), + scheme="http", + server="localhost", + headers=None, ): environ = { "REMOTE_ADDR": addr[0], diff --git a/tests/test_regression.py b/tests/test_regression.py index 3c4c6c2..840e599 100644 --- a/tests/test_regression.py +++ b/tests/test_regression.py @@ -139,8 +139,7 @@ def zombies_test(): >>> channel4.last_activity != last_active True - -""" + """ def test_suite(): diff --git a/tests/test_task.py b/tests/test_task.py index 0965bf5..de800fb 100644 --- a/tests/test_task.py +++ b/tests/test_task.py @@ -85,7 +85,10 @@ class TestThreadedTaskDispatcher(unittest.TestCase): self.assertEqual(inst.shutdown(timeout=0.01), True) self.assertEqual( inst.logger.logged, - ["1 thread(s) still running", "Canceling 1 pending task(s)",], + [ + "1 thread(s) still running", + "Canceling 1 pending task(s)", + ], ) self.assertEqual(task.cancelled, True) diff --git a/tests/test_wasyncore.py b/tests/test_wasyncore.py index 970e993..9f075e5 100644 --- a/tests/test_wasyncore.py +++ b/tests/test_wasyncore.py @@ -44,7 +44,7 @@ class DummyLogger: # pragma: no cover class WarningsRecorder: # pragma: no cover """Convenience wrapper for the warnings list returned on - entry to the warnings.catch_warnings() context manager. + entry to the warnings.catch_warnings() context manager. """ def __init__(self, warnings_list): -- cgit v1.2.1