Upgrade yapf to 0.20.0

Upgrade yapf version to 0.20.0 and reformat Python files.

55 files changed, 884 insertions, 558 deletions

diff --git a/src/python/grpcio_tests/setup.py b/src/python/grpcio_tests/setup.py
index aeb4ea9c53..250df65803 100644
--- a/src/python/grpcio_tests/setup.py
+++ b/src/python/grpcio_tests/setup.py
@@ -99,4 +99,5 @@ setuptools.setup(
     tests_require=TESTS_REQUIRE,
     test_suite=TEST_SUITE,
     test_loader=TEST_LOADER,
-    test_runner=TEST_RUNNER,)
+    test_runner=TEST_RUNNER,
+)
diff --git a/src/python/grpcio_tests/tests/_loader.py b/src/python/grpcio_tests/tests/_loader.py
index 281a23c16e..31680916b4 100644
--- a/src/python/grpcio_tests/tests/_loader.py
+++ b/src/python/grpcio_tests/tests/_loader.py
@@ -101,5 +101,5 @@ def iterate_suite_cases(suite):
         elif isinstance(item, unittest.TestCase):
             yield item
         else:
-            raise ValueError(
-                'unexpected suite item of type {}'.format(type(item)))
+            raise ValueError('unexpected suite item of type {}'.format(
+                type(item)))
diff --git a/src/python/grpcio_tests/tests/_result.py b/src/python/grpcio_tests/tests/_result.py
index f26fdefc97..9907c4e1f9 100644
--- a/src/python/grpcio_tests/tests/_result.py
+++ b/src/python/grpcio_tests/tests/_result.py
@@ -215,7 +215,8 @@ class AugmentedResult(unittest.TestResult):
     Args:
       filter (callable): A unary predicate to filter over CaseResult objects.
     """
-        return (self.cases[case_id] for case_id in self.cases
+        return (self.cases[case_id]
+                for case_id in self.cases
                 if filter(self.cases[case_id]))
 
 
@@ -285,8 +286,8 @@ class TerminalResult(CoverageResult):
     def startTestRun(self):
         """See unittest.TestResult.startTestRun."""
         super(TerminalResult, self).startTestRun()
-        self.out.write(_Colors.HEADER + 'Testing gRPC Python...\n' +
-                       _Colors.END)
+        self.out.write(
+            _Colors.HEADER + 'Testing gRPC Python...\n' + _Colors.END)
 
     def stopTestRun(self):
         """See unittest.TestResult.stopTestRun."""
@@ -297,43 +298,43 @@ class TerminalResult(CoverageResult):
     def addError(self, test, error):
         """See unittest.TestResult.addError."""
         super(TerminalResult, self).addError(test, error)
-        self.out.write(_Colors.FAIL + 'ERROR         {}\n'.format(test.id()) +
-                       _Colors.END)
+        self.out.write(
+            _Colors.FAIL + 'ERROR         {}\n'.format(test.id()) + _Colors.END)
         self.out.flush()
 
     def addFailure(self, test, error):
         """See unittest.TestResult.addFailure."""
         super(TerminalResult, self).addFailure(test, error)
-        self.out.write(_Colors.FAIL + 'FAILURE       {}\n'.format(test.id()) +
-                       _Colors.END)
+        self.out.write(
+            _Colors.FAIL + 'FAILURE       {}\n'.format(test.id()) + _Colors.END)
         self.out.flush()
 
     def addSuccess(self, test):
         """See unittest.TestResult.addSuccess."""
         super(TerminalResult, self).addSuccess(test)
-        self.out.write(_Colors.OK + 'SUCCESS       {}\n'.format(test.id()) +
-                       _Colors.END)
+        self.out.write(
+            _Colors.OK + 'SUCCESS       {}\n'.format(test.id()) + _Colors.END)
         self.out.flush()
 
     def addSkip(self, test, reason):
         """See unittest.TestResult.addSkip."""
         super(TerminalResult, self).addSkip(test, reason)
-        self.out.write(_Colors.INFO + 'SKIP          {}\n'.format(test.id()) +
-                       _Colors.END)
+        self.out.write(
+            _Colors.INFO + 'SKIP          {}\n'.format(test.id()) + _Colors.END)
         self.out.flush()
 
     def addExpectedFailure(self, test, error):
         """See unittest.TestResult.addExpectedFailure."""
         super(TerminalResult, self).addExpectedFailure(test, error)
-        self.out.write(_Colors.INFO + 'FAILURE_OK    {}\n'.format(test.id()) +
-                       _Colors.END)
+        self.out.write(
+            _Colors.INFO + 'FAILURE_OK    {}\n'.format(test.id()) + _Colors.END)
         self.out.flush()
 
     def addUnexpectedSuccess(self, test):
         """See unittest.TestResult.addUnexpectedSuccess."""
         super(TerminalResult, self).addUnexpectedSuccess(test)
-        self.out.write(_Colors.INFO + 'UNEXPECTED_OK {}\n'.format(test.id()) +
-                       _Colors.END)
+        self.out.write(
+            _Colors.INFO + 'UNEXPECTED_OK {}\n'.format(test.id()) + _Colors.END)
         self.out.flush()
 
 
diff --git a/src/python/grpcio_tests/tests/_runner.py b/src/python/grpcio_tests/tests/_runner.py
index 8fb4a0e09b..8e27dc6c6d 100644
--- a/src/python/grpcio_tests/tests/_runner.py
+++ b/src/python/grpcio_tests/tests/_runner.py
@@ -181,8 +181,8 @@ class Runner(object):
         # Run the tests
         result.startTestRun()
         for augmented_case in augmented_cases:
-            sys.stdout.write(
-                'Running       {}\n'.format(augmented_case.case.id()))
+            sys.stdout.write('Running       {}\n'.format(
+                augmented_case.case.id()))
             sys.stdout.flush()
             case_thread = threading.Thread(
                 target=augmented_case.case.run, args=(result,))
@@ -196,8 +196,8 @@ class Runner(object):
             except:
                 # re-raise the exception after forcing the with-block to end
                 raise
-            result.set_output(augmented_case.case,
-                              stdout_pipe.output(), stderr_pipe.output())
+            result.set_output(augmented_case.case, stdout_pipe.output(),
+                              stderr_pipe.output())
             sys.stdout.write(result_out.getvalue())
             sys.stdout.flush()
             result_out.truncate(0)
diff --git a/src/python/grpcio_tests/tests/http2/negative_http2_client.py b/src/python/grpcio_tests/tests/http2/negative_http2_client.py
index 8dab5b67f1..e4076827b6 100644
--- a/src/python/grpcio_tests/tests/http2/negative_http2_client.py
+++ b/src/python/grpcio_tests/tests/http2/negative_http2_client.py
@@ -32,14 +32,14 @@ def _validate_payload_type_and_length(response, expected_type, expected_length):
 
 def _expect_status_code(call, expected_code):
     if call.code() != expected_code:
-        raise ValueError('expected code %s, got %s' %
-                         (expected_code, call.code()))
+        raise ValueError('expected code %s, got %s' % (expected_code,
+                                                       call.code()))
 
 
 def _expect_status_details(call, expected_details):
     if call.details() != expected_details:
-        raise ValueError('expected message %s, got %s' %
-                         (expected_details, call.details()))
+        raise ValueError('expected message %s, got %s' % (expected_details,
+                                                          call.details()))
 
 
 def _validate_status_code_and_details(call, expected_code, expected_details):
diff --git a/src/python/grpcio_tests/tests/interop/_intraop_test_case.py b/src/python/grpcio_tests/tests/interop/_intraop_test_case.py
index ce456a679b..007db7ab41 100644
--- a/src/python/grpcio_tests/tests/interop/_intraop_test_case.py
+++ b/src/python/grpcio_tests/tests/interop/_intraop_test_case.py
@@ -39,8 +39,8 @@ class IntraopTestCase(object):
         methods.TestCase.PING_PONG.test_interoperability(self.stub, None)
 
     def testCancelAfterBegin(self):
-        methods.TestCase.CANCEL_AFTER_BEGIN.test_interoperability(self.stub,
-                                                                  None)
+        methods.TestCase.CANCEL_AFTER_BEGIN.test_interoperability(
+            self.stub, None)
 
     def testCancelAfterFirstResponse(self):
         methods.TestCase.CANCEL_AFTER_FIRST_RESPONSE.test_interoperability(
diff --git a/src/python/grpcio_tests/tests/interop/_secure_intraop_test.py b/src/python/grpcio_tests/tests/interop/_secure_intraop_test.py
index 6ce8b3715b..c89135998d 100644
--- a/src/python/grpcio_tests/tests/interop/_secure_intraop_test.py
+++ b/src/python/grpcio_tests/tests/interop/_secure_intraop_test.py
@@ -34,15 +34,16 @@ class SecureIntraopTest(_intraop_test_case.IntraopTestCase, unittest.TestCase):
                                                         self.server)
         port = self.server.add_secure_port(
             '[::]:0',
-            grpc.ssl_server_credentials(
-                [(resources.private_key(), resources.certificate_chain())]))
+            grpc.ssl_server_credentials([(resources.private_key(),
+                                          resources.certificate_chain())]))
         self.server.start()
         self.stub = test_pb2_grpc.TestServiceStub(
             grpc.secure_channel('localhost:{}'.format(port),
                                 grpc.ssl_channel_credentials(
-                                    resources.test_root_certificates()), (
-                                        ('grpc.ssl_target_name_override',
-                                         _SERVER_HOST_OVERRIDE,),)))
+                                    resources.test_root_certificates()), ((
+                                        'grpc.ssl_target_name_override',
+                                        _SERVER_HOST_OVERRIDE,
+                                    ),)))
 
 
 if __name__ == '__main__':
diff --git a/src/python/grpcio_tests/tests/interop/client.py b/src/python/grpcio_tests/tests/interop/client.py
index 383b5f033d..3780ed9020 100644
--- a/src/python/grpcio_tests/tests/interop/client.py
+++ b/src/python/grpcio_tests/tests/interop/client.py
@@ -104,8 +104,10 @@ def _stub(args):
             channel_credentials = grpc.composite_channel_credentials(
                 channel_credentials, call_credentials)
 
-        channel = grpc.secure_channel(target, channel_credentials, (
-            ('grpc.ssl_target_name_override', args.server_host_override,),))
+        channel = grpc.secure_channel(target, channel_credentials, ((
+            'grpc.ssl_target_name_override',
+            args.server_host_override,
+        ),))
     else:
         channel = grpc.insecure_channel(target)
     if args.test_case == "unimplemented_service":
diff --git a/src/python/grpcio_tests/tests/interop/methods.py b/src/python/grpcio_tests/tests/interop/methods.py
index ae9a50dd9b..b728ffd704 100644
--- a/src/python/grpcio_tests/tests/interop/methods.py
+++ b/src/python/grpcio_tests/tests/interop/methods.py
@@ -62,9 +62,10 @@ class TestService(test_pb2_grpc.TestServiceServicer):
     def UnaryCall(self, request, context):
         _maybe_echo_metadata(context)
         _maybe_echo_status_and_message(request, context)
-        return messages_pb2.SimpleResponse(payload=messages_pb2.Payload(
-            type=messages_pb2.COMPRESSABLE,
-            body=b'\x00' * request.response_size))
+        return messages_pb2.SimpleResponse(
+            payload=messages_pb2.Payload(
+                type=messages_pb2.COMPRESSABLE,
+                body=b'\x00' * request.response_size))
 
     def StreamingOutputCall(self, request, context):
         _maybe_echo_status_and_message(request, context)
@@ -100,14 +101,14 @@ class TestService(test_pb2_grpc.TestServiceServicer):
 
 def _expect_status_code(call, expected_code):
     if call.code() != expected_code:
-        raise ValueError('expected code %s, got %s' %
-                         (expected_code, call.code()))
+        raise ValueError('expected code %s, got %s' % (expected_code,
+                                                       call.code()))
 
 
 def _expect_status_details(call, expected_details):
     if call.details() != expected_details:
-        raise ValueError('expected message %s, got %s' %
-                         (expected_details, call.details()))
+        raise ValueError('expected message %s, got %s' % (expected_details,
+                                                          call.details()))
 
 
 def _validate_status_code_and_details(call, expected_code, expected_details):
@@ -152,26 +153,38 @@ def _large_unary(stub):
 
 
 def _client_streaming(stub):
-    payload_body_sizes = (27182, 8, 1828, 45904,)
+    payload_body_sizes = (
+        27182,
+        8,
+        1828,
+        45904,
+    )
     payloads = (messages_pb2.Payload(body=b'\x00' * size)
                 for size in payload_body_sizes)
     requests = (messages_pb2.StreamingInputCallRequest(payload=payload)
                 for payload in payloads)
     response = stub.StreamingInputCall(requests)
     if response.aggregated_payload_size != 74922:
-        raise ValueError('incorrect size %d!' %
-                         response.aggregated_payload_size)
+        raise ValueError(
+            'incorrect size %d!' % response.aggregated_payload_size)
 
 
 def _server_streaming(stub):
-    sizes = (31415, 9, 2653, 58979,)
+    sizes = (
+        31415,
+        9,
+        2653,
+        58979,
+    )
 
     request = messages_pb2.StreamingOutputCallRequest(
         response_type=messages_pb2.COMPRESSABLE,
-        response_parameters=(messages_pb2.ResponseParameters(size=sizes[0]),
-                             messages_pb2.ResponseParameters(size=sizes[1]),
-                             messages_pb2.ResponseParameters(size=sizes[2]),
-                             messages_pb2.ResponseParameters(size=sizes[3]),))
+        response_parameters=(
+            messages_pb2.ResponseParameters(size=sizes[0]),
+            messages_pb2.ResponseParameters(size=sizes[1]),
+            messages_pb2.ResponseParameters(size=sizes[2]),
+            messages_pb2.ResponseParameters(size=sizes[3]),
+        ))
     response_iterator = stub.StreamingOutputCall(request)
     for index, response in enumerate(response_iterator):
         _validate_payload_type_and_length(response, messages_pb2.COMPRESSABLE,
@@ -218,8 +231,18 @@ class _Pipe(object):
 
 
 def _ping_pong(stub):
-    request_response_sizes = (31415, 9, 2653, 58979,)
-    request_payload_sizes = (27182, 8, 1828, 45904,)
+    request_response_sizes = (
+        31415,
+        9,
+        2653,
+        58979,
+    )
+    request_payload_sizes = (
+        27182,
+        8,
+        1828,
+        45904,
+    )
 
     with _Pipe() as pipe:
         response_iterator = stub.FullDuplexCall(pipe)
@@ -247,8 +270,18 @@ def _cancel_after_begin(stub):
 
 
 def _cancel_after_first_response(stub):
-    request_response_sizes = (31415, 9, 2653, 58979,)
-    request_payload_sizes = (27182, 8, 1828, 45904,)
+    request_response_sizes = (
+        31415,
+        9,
+        2653,
+        58979,
+    )
+    request_payload_sizes = (
+        27182,
+        8,
+        1828,
+        45904,
+    )
     with _Pipe() as pipe:
         response_iterator = stub.FullDuplexCall(pipe)
 
@@ -331,14 +364,14 @@ def _status_code_and_message(stub):
 
 
 def _unimplemented_method(test_service_stub):
-    response_future = (
-        test_service_stub.UnimplementedCall.future(empty_pb2.Empty()))
+    response_future = (test_service_stub.UnimplementedCall.future(
+        empty_pb2.Empty()))
     _expect_status_code(response_future, grpc.StatusCode.UNIMPLEMENTED)
 
 
 def _unimplemented_service(unimplemented_service_stub):
-    response_future = (
-        unimplemented_service_stub.UnimplementedCall.future(empty_pb2.Empty()))
+    response_future = (unimplemented_service_stub.UnimplementedCall.future(
+        empty_pb2.Empty()))
     _expect_status_code(response_future, grpc.StatusCode.UNIMPLEMENTED)
 
 
@@ -392,11 +425,12 @@ def _oauth2_auth_token(stub, args):
     wanted_email = json.load(open(json_key_filename, 'rb'))['client_email']
     response = _large_unary_common_behavior(stub, True, True, None)
     if wanted_email != response.username:
-        raise ValueError('expected username %s, got %s' %
-                         (wanted_email, response.username))
+        raise ValueError('expected username %s, got %s' % (wanted_email,
+                                                           response.username))
     if args.oauth_scope.find(response.oauth_scope) == -1:
-        raise ValueError('expected to find oauth scope "{}" in received "{}"'.
-                         format(response.oauth_scope, args.oauth_scope))
+        raise ValueError(
+            'expected to find oauth scope "{}" in received "{}"'.format(
+                response.oauth_scope, args.oauth_scope))
 
 
 def _jwt_token_creds(stub, args):
@@ -404,8 +438,8 @@ def _jwt_token_creds(stub, args):
     wanted_email = json.load(open(json_key_filename, 'rb'))['client_email']
     response = _large_unary_common_behavior(stub, True, False, None)
     if wanted_email != response.username:
-        raise ValueError('expected username %s, got %s' %
-                         (wanted_email, response.username))
+        raise ValueError('expected username %s, got %s' % (wanted_email,
+                                                           response.username))
 
 
 def _per_rpc_creds(stub, args):
@@ -419,8 +453,8 @@ def _per_rpc_creds(stub, args):
             request=google_auth_transport_requests.Request()))
     response = _large_unary_common_behavior(stub, True, False, call_credentials)
     if wanted_email != response.username:
-        raise ValueError('expected username %s, got %s' %
-                         (wanted_email, response.username))
+        raise ValueError('expected username %s, got %s' % (wanted_email,
+                                                           response.username))
 
 
 @enum.unique
@@ -479,5 +513,5 @@ class TestCase(enum.Enum):
         elif self is TestCase.PER_RPC_CREDS:
             _per_rpc_creds(stub, args)
         else:
-            raise NotImplementedError('Test case "%s" not implemented!' %
-                                      self.name)
+            raise NotImplementedError(
+                'Test case "%s" not implemented!' % self.name)
diff --git a/src/python/grpcio_tests/tests/interop/server.py b/src/python/grpcio_tests/tests/interop/server.py
index dd4f5146e9..0810de2394 100644
--- a/src/python/grpcio_tests/tests/interop/server.py
+++ b/src/python/grpcio_tests/tests/interop/server.py
@@ -45,8 +45,8 @@ def serve():
     if args.use_tls:
         private_key = resources.private_key()
         certificate_chain = resources.certificate_chain()
-        credentials = grpc.ssl_server_credentials((
-            (private_key, certificate_chain),))
+        credentials = grpc.ssl_server_credentials(((private_key,
+                                                    certificate_chain),))
         server.add_secure_port('[::]:{}'.format(args.port), credentials)
     else:
         server.add_insecure_port('[::]:{}'.format(args.port))
diff --git a/src/python/grpcio_tests/tests/protoc_plugin/_python_plugin_test.py b/src/python/grpcio_tests/tests/protoc_plugin/_python_plugin_test.py
index 8fc539e641..6d85f43130 100644
--- a/src/python/grpcio_tests/tests/protoc_plugin/_python_plugin_test.py
+++ b/src/python/grpcio_tests/tests/protoc_plugin/_python_plugin_test.py
@@ -119,8 +119,11 @@ class _ServicerMethods(object):
 
 
 class _Service(
-        collections.namedtuple('_Service', ('servicer_methods', 'server',
-                                            'stub',))):
+        collections.namedtuple('_Service', (
+            'servicer_methods',
+            'server',
+            'stub',
+        ))):
     """A live and running service.
 
   Attributes:
@@ -297,8 +300,8 @@ class PythonPluginTest(unittest.TestCase):
         responses = service.stub.StreamingOutputCall(request)
         expected_responses = service.servicer_methods.StreamingOutputCall(
             request, 'not a real RpcContext!')
-        for expected_response, response in moves.zip_longest(expected_responses,
-                                                             responses):
+        for expected_response, response in moves.zip_longest(
+                expected_responses, responses):
             self.assertEqual(expected_response, response)
 
     def testStreamingOutputCallExpired(self):
@@ -388,8 +391,8 @@ class PythonPluginTest(unittest.TestCase):
         responses = service.stub.FullDuplexCall(_full_duplex_request_iterator())
         expected_responses = service.servicer_methods.FullDuplexCall(
             _full_duplex_request_iterator(), 'not a real RpcContext!')
-        for expected_response, response in moves.zip_longest(expected_responses,
-                                                             responses):
+        for expected_response, response in moves.zip_longest(
+                expected_responses, responses):
             self.assertEqual(expected_response, response)
 
     def testFullDuplexCallExpired(self):
@@ -439,8 +442,8 @@ class PythonPluginTest(unittest.TestCase):
         responses = service.stub.HalfDuplexCall(half_duplex_request_iterator())
         expected_responses = service.servicer_methods.HalfDuplexCall(
             half_duplex_request_iterator(), 'not a real RpcContext!')
-        for expected_response, response in moves.zip_longest(expected_responses,
-                                                             responses):
+        for expected_response, response in moves.zip_longest(
+                expected_responses, responses):
             self.assertEqual(expected_response, response)
 
     def testHalfDuplexCallWedged(self):
diff --git a/src/python/grpcio_tests/tests/protoc_plugin/_split_definitions_test.py b/src/python/grpcio_tests/tests/protoc_plugin/_split_definitions_test.py
index c732e55108..ab33775ad3 100644
--- a/src/python/grpcio_tests/tests/protoc_plugin/_split_definitions_test.py
+++ b/src/python/grpcio_tests/tests/protoc_plugin/_split_definitions_test.py
@@ -64,8 +64,8 @@ def _massage_proto_content(proto_content, test_name_bytes,
                            messages_proto_relative_file_name_bytes):
     package_substitution = (b'package grpc_protoc_plugin.invocation_testing.' +
                             test_name_bytes + b';')
-    common_namespace_substituted = proto_content.replace(_COMMON_NAMESPACE,
-                                                         package_substitution)
+    common_namespace_substituted = proto_content.replace(
+        _COMMON_NAMESPACE, package_substitution)
     split_namespace_substituted = common_namespace_substituted.replace(
         _SPLIT_NAMESPACE, package_substitution)
     message_import_replaced = split_namespace_substituted.replace(
@@ -163,8 +163,12 @@ class _GrpcBeforeProtoProtocStyle(object):
         return pb2_grpc_protoc_exit_code, pb2_protoc_exit_code,
 
 
-_PROTOC_STYLES = (_Mid2016ProtocStyle(), _SingleProtocExecutionProtocStyle(),
-                  _ProtoBeforeGrpcProtocStyle(), _GrpcBeforeProtoProtocStyle(),)
+_PROTOC_STYLES = (
+    _Mid2016ProtocStyle(),
+    _SingleProtocExecutionProtocStyle(),
+    _ProtoBeforeGrpcProtocStyle(),
+    _GrpcBeforeProtoProtocStyle(),
+)
 
 
 @unittest.skipIf(platform.python_implementation() == 'PyPy',
@@ -180,18 +184,22 @@ class _Test(six.with_metaclass(abc.ABCMeta, unittest.TestCase)):
         os.makedirs(self._python_out)
 
         proto_directories_and_names = {
-            (self.MESSAGES_PROTO_RELATIVE_DIRECTORY_NAMES,
-             self.MESSAGES_PROTO_FILE_NAME,),
-            (self.SERVICES_PROTO_RELATIVE_DIRECTORY_NAMES,
-             self.SERVICES_PROTO_FILE_NAME,),
+            (
+                self.MESSAGES_PROTO_RELATIVE_DIRECTORY_NAMES,
+                self.MESSAGES_PROTO_FILE_NAME,
+            ),
+            (
+                self.SERVICES_PROTO_RELATIVE_DIRECTORY_NAMES,
+                self.SERVICES_PROTO_FILE_NAME,
+            ),
         }
         messages_proto_relative_file_name_forward_slashes = '/'.join(
-            self.MESSAGES_PROTO_RELATIVE_DIRECTORY_NAMES + (
-                self.MESSAGES_PROTO_FILE_NAME,))
-        _create_directory_tree(self._proto_path, (
-            relative_proto_directory_names
-            for relative_proto_directory_names, _ in proto_directories_and_names
-        ))
+            self.MESSAGES_PROTO_RELATIVE_DIRECTORY_NAMES +
+            (self.MESSAGES_PROTO_FILE_NAME,))
+        _create_directory_tree(self._proto_path,
+                               (relative_proto_directory_names
+                                for relative_proto_directory_names, _ in
+                                proto_directories_and_names))
         self._absolute_proto_file_names = set()
         for relative_directory_names, file_name in proto_directories_and_names:
             absolute_proto_file_name = path.join(
@@ -200,8 +208,7 @@ class _Test(six.with_metaclass(abc.ABCMeta, unittest.TestCase)):
                 'tests.protoc_plugin.protos.invocation_testing',
                 path.join(*relative_directory_names + (file_name,)))
             massaged_proto_content = _massage_proto_content(
-                raw_proto_content,
-                self.NAME.encode(),
+                raw_proto_content, self.NAME.encode(),
                 messages_proto_relative_file_name_forward_slashes.encode())
             with open(absolute_proto_file_name, 'wb') as proto_file:
                 proto_file.write(massaged_proto_content)
@@ -275,7 +282,9 @@ def _create_test_case_class(split_proto, protoc_style):
 
     if split_proto:
         attributes['MESSAGES_PROTO_RELATIVE_DIRECTORY_NAMES'] = (
-            'split_messages', 'sub',)
+            'split_messages',
+            'sub',
+        )
         attributes['MESSAGES_PROTO_FILE_NAME'] = 'messages.proto'
         attributes['SERVICES_PROTO_RELATIVE_DIRECTORY_NAMES'] = (
             'split_services',)
@@ -301,7 +310,10 @@ def _create_test_case_class(split_proto, protoc_style):
 
 
 def _create_test_case_classes():
-    for split_proto in (False, True,):
+    for split_proto in (
+            False,
+            True,
+    ):
         for protoc_style in _PROTOC_STYLES:
             yield _create_test_case_class(split_proto, protoc_style)
 
diff --git a/src/python/grpcio_tests/tests/protoc_plugin/beta_python_plugin_test.py b/src/python/grpcio_tests/tests/protoc_plugin/beta_python_plugin_test.py
index 424b153ff8..ad0ecf0079 100644
--- a/src/python/grpcio_tests/tests/protoc_plugin/beta_python_plugin_test.py
+++ b/src/python/grpcio_tests/tests/protoc_plugin/beta_python_plugin_test.py
@@ -36,10 +36,28 @@ _RELATIVE_PROTO_PATH = 'relative_proto_path'
 _RELATIVE_PYTHON_OUT = 'relative_python_out'
 
 _PROTO_FILES_PATH_COMPONENTS = (
-    ('beta_grpc_plugin_test', 'payload', 'test_payload.proto',),
-    ('beta_grpc_plugin_test', 'requests', 'r', 'test_requests.proto',),
-    ('beta_grpc_plugin_test', 'responses', 'test_responses.proto',),
-    ('beta_grpc_plugin_test', 'service', 'test_service.proto',),)
+    (
+        'beta_grpc_plugin_test',
+        'payload',
+        'test_payload.proto',
+    ),
+    (
+        'beta_grpc_plugin_test',
+        'requests',
+        'r',
+        'test_requests.proto',
+    ),
+    (
+        'beta_grpc_plugin_test',
+        'responses',
+        'test_responses.proto',
+    ),
+    (
+        'beta_grpc_plugin_test',
+        'service',
+        'test_service.proto',
+    ),
+)
 
 _PAYLOAD_PB2 = 'beta_grpc_plugin_test.payload.test_payload_pb2'
 _REQUESTS_PB2 = 'beta_grpc_plugin_test.requests.r.test_requests_pb2'
diff --git a/src/python/grpcio_tests/tests/qps/benchmark_client.py b/src/python/grpcio_tests/tests/qps/benchmark_client.py
index 17fa61ea36..e6392a8b8c 100644
--- a/src/python/grpcio_tests/tests/qps/benchmark_client.py
+++ b/src/python/grpcio_tests/tests/qps/benchmark_client.py
@@ -155,7 +155,8 @@ class _SyncStream(object):
                                                    _TIMEOUT)
         for _ in response_stream:
             self._handle_response(
-                self, time.time() - self._send_time_queue.get_nowait())
+                self,
+                time.time() - self._send_time_queue.get_nowait())
 
     def stop(self):
         self._is_streaming = False
diff --git a/src/python/grpcio_tests/tests/qps/worker_server.py b/src/python/grpcio_tests/tests/qps/worker_server.py
index fef4fb0459..41e2403c8f 100644
--- a/src/python/grpcio_tests/tests/qps/worker_server.py
+++ b/src/python/grpcio_tests/tests/qps/worker_server.py
@@ -72,8 +72,8 @@ class WorkerServer(services_pb2_grpc.WorkerServiceServicer):
         server = test_common.test_server(max_workers=server_threads)
         if config.server_type == control_pb2.ASYNC_SERVER:
             servicer = benchmark_server.BenchmarkServer()
-            services_pb2_grpc.add_BenchmarkServiceServicer_to_server(servicer,
-                                                                     server)
+            services_pb2_grpc.add_BenchmarkServiceServicer_to_server(
+                servicer, server)
         elif config.server_type == control_pb2.ASYNC_GENERIC_SERVER:
             resp_size = config.payload_config.bytebuf_params.resp_size
             servicer = benchmark_server.GenericBenchmarkServer(resp_size)
@@ -87,12 +87,12 @@ class WorkerServer(services_pb2_grpc.WorkerServiceServicer):
                 'grpc.testing.BenchmarkService', method_implementations)
             server.add_generic_rpc_handlers((handler,))
         else:
-            raise Exception(
-                'Unsupported server type {}'.format(config.server_type))
+            raise Exception('Unsupported server type {}'.format(
+                config.server_type))
 
         if config.HasField('security_params'):  # Use SSL
-            server_creds = grpc.ssl_server_credentials((
-                (resources.private_key(), resources.certificate_chain()),))
+            server_creds = grpc.ssl_server_credentials(
+                ((resources.private_key(), resources.certificate_chain()),))
             port = server.add_secure_port('[::]:{}'.format(config.port),
                                           server_creds)
         else:
@@ -156,8 +156,8 @@ class WorkerServer(services_pb2_grpc.WorkerServiceServicer):
             else:
                 raise Exception('Async streaming client not supported')
         else:
-            raise Exception(
-                'Unsupported client type {}'.format(config.client_type))
+            raise Exception('Unsupported client type {}'.format(
+                config.client_type))
 
         # In multi-channel tests, we split the load across all channels
         load_factor = float(config.client_channels)
diff --git a/src/python/grpcio_tests/tests/reflection/_reflection_servicer_test.py b/src/python/grpcio_tests/tests/reflection/_reflection_servicer_test.py
index 86037e258a..7ffdba6a67 100644
--- a/src/python/grpcio_tests/tests/reflection/_reflection_servicer_test.py
+++ b/src/python/grpcio_tests/tests/reflection/_reflection_servicer_test.py
@@ -33,7 +33,13 @@ _EMPTY_PROTO_SYMBOL_NAME = 'grpc.testing.Empty'
 _SERVICE_NAMES = ('Angstrom', 'Bohr', 'Curie', 'Dyson', 'Einstein', 'Feynman',
                   'Galilei')
 _EMPTY_EXTENSIONS_SYMBOL_NAME = 'grpc.testing.proto2.EmptyWithExtensions'
-_EMPTY_EXTENSIONS_NUMBERS = (124, 125, 126, 127, 128,)
+_EMPTY_EXTENSIONS_NUMBERS = (
+    124,
+    125,
+    126,
+    127,
+    128,
+)
 
 
 def _file_descriptor_to_proto(descriptor):
@@ -54,10 +60,12 @@ class ReflectionServicerTest(unittest.TestCase):
         self._stub = reflection_pb2_grpc.ServerReflectionStub(channel)
 
     def testFileByName(self):
-        requests = (reflection_pb2.ServerReflectionRequest(
-            file_by_filename=_EMPTY_PROTO_FILE_NAME),
-                    reflection_pb2.ServerReflectionRequest(
-                        file_by_filename='i-donut-exist'),)
+        requests = (
+            reflection_pb2.ServerReflectionRequest(
+                file_by_filename=_EMPTY_PROTO_FILE_NAME),
+            reflection_pb2.ServerReflectionRequest(
+                file_by_filename='i-donut-exist'),
+        )
         responses = tuple(self._stub.ServerReflectionInfo(iter(requests)))
         expected_responses = (
             reflection_pb2.ServerReflectionResponse(
@@ -70,14 +78,18 @@ class ReflectionServicerTest(unittest.TestCase):
                 error_response=reflection_pb2.ErrorResponse(
                     error_code=grpc.StatusCode.NOT_FOUND.value[0],
                     error_message=grpc.StatusCode.NOT_FOUND.value[1].encode(),
-                )),)
+                )),
+        )
         self.assertSequenceEqual(expected_responses, responses)
 
     def testFileBySymbol(self):
-        requests = (reflection_pb2.ServerReflectionRequest(
-            file_containing_symbol=_EMPTY_PROTO_SYMBOL_NAME
-        ), reflection_pb2.ServerReflectionRequest(
-            file_containing_symbol='i.donut.exist.co.uk.org.net.me.name.foo'),)
+        requests = (
+            reflection_pb2.ServerReflectionRequest(
+                file_containing_symbol=_EMPTY_PROTO_SYMBOL_NAME),
+            reflection_pb2.ServerReflectionRequest(
+                file_containing_symbol='i.donut.exist.co.uk.org.net.me.name.foo'
+            ),
+        )
         responses = tuple(self._stub.ServerReflectionInfo(iter(requests)))
         expected_responses = (
             reflection_pb2.ServerReflectionResponse(
@@ -90,18 +102,23 @@ class ReflectionServicerTest(unittest.TestCase):
                 error_response=reflection_pb2.ErrorResponse(
                     error_code=grpc.StatusCode.NOT_FOUND.value[0],
                     error_message=grpc.StatusCode.NOT_FOUND.value[1].encode(),
-                )),)
+                )),
+        )
         self.assertSequenceEqual(expected_responses, responses)
 
     def testFileContainingExtension(self):
-        requests = (reflection_pb2.ServerReflectionRequest(
-            file_containing_extension=reflection_pb2.ExtensionRequest(
-                containing_type=_EMPTY_EXTENSIONS_SYMBOL_NAME,
-                extension_number=125,),
-        ), reflection_pb2.ServerReflectionRequest(
-            file_containing_extension=reflection_pb2.ExtensionRequest(
-                containing_type='i.donut.exist.co.uk.org.net.me.name.foo',
-                extension_number=55,),),)
+        requests = (
+            reflection_pb2.ServerReflectionRequest(
+                file_containing_extension=reflection_pb2.ExtensionRequest(
+                    containing_type=_EMPTY_EXTENSIONS_SYMBOL_NAME,
+                    extension_number=125,
+                ),),
+            reflection_pb2.ServerReflectionRequest(
+                file_containing_extension=reflection_pb2.ExtensionRequest(
+                    containing_type='i.donut.exist.co.uk.org.net.me.name.foo',
+                    extension_number=55,
+                ),),
+        )
         responses = tuple(self._stub.ServerReflectionInfo(iter(requests)))
         expected_responses = (
             reflection_pb2.ServerReflectionResponse(
@@ -114,14 +131,18 @@ class ReflectionServicerTest(unittest.TestCase):
                 error_response=reflection_pb2.ErrorResponse(
                     error_code=grpc.StatusCode.NOT_FOUND.value[0],
                     error_message=grpc.StatusCode.NOT_FOUND.value[1].encode(),
-                )),)
+                )),
+        )
         self.assertSequenceEqual(expected_responses, responses)
 
     def testExtensionNumbersOfType(self):
-        requests = (reflection_pb2.ServerReflectionRequest(
-            all_extension_numbers_of_type=_EMPTY_EXTENSIONS_SYMBOL_NAME
-        ), reflection_pb2.ServerReflectionRequest(
-            all_extension_numbers_of_type='i.donut.exist.co.uk.net.name.foo'),)
+        requests = (
+            reflection_pb2.ServerReflectionRequest(
+                all_extension_numbers_of_type=_EMPTY_EXTENSIONS_SYMBOL_NAME),
+            reflection_pb2.ServerReflectionRequest(
+                all_extension_numbers_of_type='i.donut.exist.co.uk.net.name.foo'
+            ),
+        )
         responses = tuple(self._stub.ServerReflectionInfo(iter(requests)))
         expected_responses = (
             reflection_pb2.ServerReflectionResponse(
@@ -135,12 +156,12 @@ class ReflectionServicerTest(unittest.TestCase):
                 error_response=reflection_pb2.ErrorResponse(
                     error_code=grpc.StatusCode.NOT_FOUND.value[0],
                     error_message=grpc.StatusCode.NOT_FOUND.value[1].encode(),
-                )),)
+                )),
+        )
         self.assertSequenceEqual(expected_responses, responses)
 
     def testListServices(self):
-        requests = (reflection_pb2.ServerReflectionRequest(
-            list_services='',),)
+        requests = (reflection_pb2.ServerReflectionRequest(list_services='',),)
         responses = tuple(self._stub.ServerReflectionInfo(iter(requests)))
         expected_responses = (reflection_pb2.ServerReflectionResponse(
             valid_host='',
diff --git a/src/python/grpcio_tests/tests/stress/client.py b/src/python/grpcio_tests/tests/stress/client.py
index 40caa3926a..41f2e1b6c2 100644
--- a/src/python/grpcio_tests/tests/stress/client.py
+++ b/src/python/grpcio_tests/tests/stress/client.py
@@ -102,8 +102,10 @@ def _get_channel(target, args):
             root_certificates = None  # will load default roots.
         channel_credentials = grpc.ssl_channel_credentials(
             root_certificates=root_certificates)
-        options = (('grpc.ssl_target_name_override',
-                    args.server_host_override,),)
+        options = ((
+            'grpc.ssl_target_name_override',
+            args.server_host_override,
+        ),)
         channel = grpc.secure_channel(
             target, channel_credentials, options=options)
     else:
diff --git a/src/python/grpcio_tests/tests/testing/_client_application.py b/src/python/grpcio_tests/tests/testing/_client_application.py
index aff32fb4dc..7d0d74c8c4 100644
--- a/src/python/grpcio_tests/tests/testing/_client_application.py
+++ b/src/python/grpcio_tests/tests/testing/_client_application.py
@@ -235,8 +235,8 @@ def run(scenario, channel):
         elif scenario is Scenario.INFINITE_REQUEST_STREAM:
             return _run_infinite_request_stream(stub)
     except grpc.RpcError as rpc_error:
-        return Outcome(Outcome.Kind.RPC_ERROR,
-                       rpc_error.code(), rpc_error.details())
+        return Outcome(Outcome.Kind.RPC_ERROR, rpc_error.code(),
+                       rpc_error.details())
 
 
 _IMPLEMENTATIONS = {
@@ -256,5 +256,5 @@ def run(scenario, channel):
     try:
         return _IMPLEMENTATIONS[scenario](stub)
     except grpc.RpcError as rpc_error:
-        return Outcome(Outcome.Kind.RPC_ERROR,
-                       rpc_error.code(), rpc_error.details())
+        return Outcome(Outcome.Kind.RPC_ERROR, rpc_error.code(),
+                       rpc_error.details())
diff --git a/src/python/grpcio_tests/tests/testing/_client_test.py b/src/python/grpcio_tests/tests/testing/_client_test.py
index 172f386d7b..5b051c3939 100644
--- a/src/python/grpcio_tests/tests/testing/_client_test.py
+++ b/src/python/grpcio_tests/tests/testing/_client_test.py
@@ -193,8 +193,10 @@ class ClientTest(unittest.TestCase):
             rpc.take_request()
             rpc.take_request()
             rpc.requests_closed()
-            rpc.send_initial_metadata((
-                ('my_metadata_key', 'My Metadata Value!',),))
+            rpc.send_initial_metadata(((
+                'my_metadata_key',
+                'My Metadata Value!',
+            ),))
         for rpc in rpcs[:-1]:
             rpc.terminate(_application_common.STREAM_UNARY_RESPONSE, (),
                           grpc.StatusCode.OK, '')
diff --git a/src/python/grpcio_tests/tests/testing/_server_application.py b/src/python/grpcio_tests/tests/testing/_server_application.py
index 06f09c8cb4..02769ca68d 100644
--- a/src/python/grpcio_tests/tests/testing/_server_application.py
+++ b/src/python/grpcio_tests/tests/testing/_server_application.py
@@ -41,8 +41,10 @@ class FirstServiceServicer(services_pb2_grpc.FirstServiceServicer):
         yield services_pb2.Strange()
 
     def StreUn(self, request_iterator, context):
-        context.send_initial_metadata((
-            ('server_application_metadata_key', 'Hi there!',),))
+        context.send_initial_metadata(((
+            'server_application_metadata_key',
+            'Hi there!',
+        ),))
         for request in request_iterator:
             if request != _application_common.STREAM_UNARY_REQUEST:
                 context.set_code(grpc.StatusCode.INVALID_ARGUMENT)
diff --git a/src/python/grpcio_tests/tests/testing/_server_test.py b/src/python/grpcio_tests/tests/testing/_server_test.py
index 7897bcce01..4f4abd7708 100644
--- a/src/python/grpcio_tests/tests/testing/_server_test.py
+++ b/src/python/grpcio_tests/tests/testing/_server_test.py
@@ -110,14 +110,19 @@ class FirstServiceServicerTest(unittest.TestCase):
         second_termination = rpc.termination()
         third_termination = rpc.termination()
 
-        for later_initial_metadata in (second_initial_metadata,
-                                       third_initial_metadata,):
+        for later_initial_metadata in (
+                second_initial_metadata,
+                third_initial_metadata,
+        ):
             self.assertEqual(first_initial_metadata, later_initial_metadata)
         response = first_termination[0]
         terminal_metadata = first_termination[1]
         code = first_termination[2]
         details = first_termination[3]
-        for later_termination in (second_termination, third_termination,):
+        for later_termination in (
+                second_termination,
+                third_termination,
+        ):
             self.assertEqual(response, later_termination[0])
             self.assertEqual(terminal_metadata, later_termination[1])
             self.assertIs(code, later_termination[2])
diff --git a/src/python/grpcio_tests/tests/testing/_time_test.py b/src/python/grpcio_tests/tests/testing/_time_test.py
index 797394ae20..9dfe36fb83 100644
--- a/src/python/grpcio_tests/tests/testing/_time_test.py
+++ b/src/python/grpcio_tests/tests/testing/_time_test.py
@@ -105,8 +105,8 @@ class TimeTest(object):
                 test_event.set, _QUANTUM * (2 + random.random()))
         for _ in range(_MANY):
             background_noise_futures.append(
-                self._time.call_in(threading.Event().set, _QUANTUM * 1000 *
-                                   random.random()))
+                self._time.call_in(threading.Event().set,
+                                   _QUANTUM * 1000 * random.random()))
         self._time.sleep_for(_QUANTUM)
         cancelled = set()
         for test_event, test_future in possibly_cancelled_futures.items():
diff --git a/src/python/grpcio_tests/tests/unit/_api_test.py b/src/python/grpcio_tests/tests/unit/_api_test.py
index d6f4447532..f6245be77d 100644
--- a/src/python/grpcio_tests/tests/unit/_api_test.py
+++ b/src/python/grpcio_tests/tests/unit/_api_test.py
@@ -26,28 +26,57 @@ class AllTest(unittest.TestCase):
 
     def testAll(self):
         expected_grpc_code_elements = (
-            'FutureTimeoutError', 'FutureCancelledError', 'Future',
-            'ChannelConnectivity', 'StatusCode', 'RpcError', 'RpcContext',
-            'Call', 'ChannelCredentials', 'CallCredentials',
-            'AuthMetadataContext', 'AuthMetadataPluginCallback',
-            'AuthMetadataPlugin', 'ServerCertificateConfiguration',
-            'ServerCredentials', 'UnaryUnaryMultiCallable',
-            'UnaryStreamMultiCallable', 'StreamUnaryMultiCallable',
-            'StreamStreamMultiCallable', 'UnaryUnaryClientInterceptor',
-            'UnaryStreamClientInterceptor', 'StreamUnaryClientInterceptor',
-            'StreamStreamClientInterceptor', 'Channel', 'ServicerContext',
-            'RpcMethodHandler', 'HandlerCallDetails', 'GenericRpcHandler',
-            'ServiceRpcHandler', 'Server', 'ServerInterceptor',
-            'unary_unary_rpc_method_handler', 'unary_stream_rpc_method_handler',
-            'stream_unary_rpc_method_handler', 'ClientCallDetails',
+            'FutureTimeoutError',
+            'FutureCancelledError',
+            'Future',
+            'ChannelConnectivity',
+            'StatusCode',
+            'RpcError',
+            'RpcContext',
+            'Call',
+            'ChannelCredentials',
+            'CallCredentials',
+            'AuthMetadataContext',
+            'AuthMetadataPluginCallback',
+            'AuthMetadataPlugin',
+            'ServerCertificateConfiguration',
+            'ServerCredentials',
+            'UnaryUnaryMultiCallable',
+            'UnaryStreamMultiCallable',
+            'StreamUnaryMultiCallable',
+            'StreamStreamMultiCallable',
+            'UnaryUnaryClientInterceptor',
+            'UnaryStreamClientInterceptor',
+            'StreamUnaryClientInterceptor',
+            'StreamStreamClientInterceptor',
+            'Channel',
+            'ServicerContext',
+            'RpcMethodHandler',
+            'HandlerCallDetails',
+            'GenericRpcHandler',
+            'ServiceRpcHandler',
+            'Server',
+            'ServerInterceptor',
+            'unary_unary_rpc_method_handler',
+            'unary_stream_rpc_method_handler',
+            'stream_unary_rpc_method_handler',
+            'ClientCallDetails',
             'stream_stream_rpc_method_handler',
-            'method_handlers_generic_handler', 'ssl_channel_credentials',
-            'metadata_call_credentials', 'access_token_call_credentials',
-            'composite_call_credentials', 'composite_channel_credentials',
-            'ssl_server_credentials', 'ssl_server_certificate_configuration',
-            'dynamic_ssl_server_credentials', 'channel_ready_future',
-            'insecure_channel', 'secure_channel', 'intercept_channel',
-            'server',)
+            'method_handlers_generic_handler',
+            'ssl_channel_credentials',
+            'metadata_call_credentials',
+            'access_token_call_credentials',
+            'composite_call_credentials',
+            'composite_channel_credentials',
+            'ssl_server_credentials',
+            'ssl_server_certificate_configuration',
+            'dynamic_ssl_server_credentials',
+            'channel_ready_future',
+            'insecure_channel',
+            'secure_channel',
+            'intercept_channel',
+            'server',
+        )
 
         six.assertCountEqual(self, expected_grpc_code_elements,
                              _from_grpc_import_star.GRPC_ELEMENTS)
@@ -56,12 +85,13 @@ class AllTest(unittest.TestCase):
 class ChannelConnectivityTest(unittest.TestCase):
 
     def testChannelConnectivity(self):
-        self.assertSequenceEqual(
-            (grpc.ChannelConnectivity.IDLE, grpc.ChannelConnectivity.CONNECTING,
-             grpc.ChannelConnectivity.READY,
-             grpc.ChannelConnectivity.TRANSIENT_FAILURE,
-             grpc.ChannelConnectivity.SHUTDOWN,),
-            tuple(grpc.ChannelConnectivity))
+        self.assertSequenceEqual((
+            grpc.ChannelConnectivity.IDLE,
+            grpc.ChannelConnectivity.CONNECTING,
+            grpc.ChannelConnectivity.READY,
+            grpc.ChannelConnectivity.TRANSIENT_FAILURE,
+            grpc.ChannelConnectivity.SHUTDOWN,
+        ), tuple(grpc.ChannelConnectivity))
 
 
 class ChannelTest(unittest.TestCase):
diff --git a/src/python/grpcio_tests/tests/unit/_auth_context_test.py b/src/python/grpcio_tests/tests/unit/_auth_context_test.py
index ebc04a71e0..468869a03e 100644
--- a/src/python/grpcio_tests/tests/unit/_auth_context_test.py
+++ b/src/python/grpcio_tests/tests/unit/_auth_context_test.py
@@ -29,8 +29,12 @@ _RESPONSE = b'\x00\x00\x00'
 _UNARY_UNARY = '/test/UnaryUnary'
 
 _SERVER_HOST_OVERRIDE = 'foo.test.google.fr'
-_CLIENT_IDS = (b'*.test.google.fr', b'waterzooi.test.google.be',
-               b'*.test.youtube.com', b'192.168.1.3',)
+_CLIENT_IDS = (
+    b'*.test.google.fr',
+    b'waterzooi.test.google.be',
+    b'*.test.youtube.com',
+    b'192.168.1.3',
+)
 _ID = 'id'
 _ID_KEY = 'id_key'
 _AUTH_CTX = 'auth_ctx'
@@ -39,7 +43,10 @@ _PRIVATE_KEY = resources.private_key()
 _CERTIFICATE_CHAIN = resources.certificate_chain()
 _TEST_ROOT_CERTIFICATES = resources.test_root_certificates()
 _SERVER_CERTS = ((_PRIVATE_KEY, _CERTIFICATE_CHAIN),)
-_PROPERTY_OPTIONS = (('grpc.ssl_target_name_override', _SERVER_HOST_OVERRIDE,),)
+_PROPERTY_OPTIONS = ((
+    'grpc.ssl_target_name_override',
+    _SERVER_HOST_OVERRIDE,
+),)
 
 
 def handle_unary_unary(request, servicer_context):
diff --git a/src/python/grpcio_tests/tests/unit/_channel_args_test.py b/src/python/grpcio_tests/tests/unit/_channel_args_test.py
index 0a6b512866..1a2d2c0117 100644
--- a/src/python/grpcio_tests/tests/unit/_channel_args_test.py
+++ b/src/python/grpcio_tests/tests/unit/_channel_args_test.py
@@ -24,8 +24,13 @@ class TestPointerWrapper(object):
         return 123456
 
 
-TEST_CHANNEL_ARGS = (('arg1', b'bytes_val'), ('arg2', 'str_val'), ('arg3', 1),
-                     (b'arg4', 'str_val'), ('arg6', TestPointerWrapper()),)
+TEST_CHANNEL_ARGS = (
+    ('arg1', b'bytes_val'),
+    ('arg2', 'str_val'),
+    ('arg3', 1),
+    (b'arg4', 'str_val'),
+    ('arg6', TestPointerWrapper()),
+)
 
 
 class ChannelArgsTest(unittest.TestCase):
diff --git a/src/python/grpcio_tests/tests/unit/_compression_test.py b/src/python/grpcio_tests/tests/unit/_compression_test.py
index 93e599d8f8..7550cd39ba 100644
--- a/src/python/grpcio_tests/tests/unit/_compression_test.py
+++ b/src/python/grpcio_tests/tests/unit/_compression_test.py
@@ -26,16 +26,16 @@ _STREAM_STREAM = '/test/StreamStream'
 
 
 def handle_unary(request, servicer_context):
-    servicer_context.send_initial_metadata(
-        [('grpc-internal-encoding-request', 'gzip')])
+    servicer_context.send_initial_metadata([('grpc-internal-encoding-request',
+                                             'gzip')])
     return request
 
 
 def handle_stream(request_iterator, servicer_context):
     # TODO(issue:#6891) We should be able to remove this loop,
     # and replace with return; yield
-    servicer_context.send_initial_metadata(
-        [('grpc-internal-encoding-request', 'gzip')])
+    servicer_context.send_initial_metadata([('grpc-internal-encoding-request',
+                                             'gzip')])
     for request in request_iterator:
         yield request
 
diff --git a/src/python/grpcio_tests/tests/unit/_credentials_test.py b/src/python/grpcio_tests/tests/unit/_credentials_test.py
index 097898b987..f487fe66a2 100644
--- a/src/python/grpcio_tests/tests/unit/_credentials_test.py
+++ b/src/python/grpcio_tests/tests/unit/_credentials_test.py
@@ -26,8 +26,8 @@ class CredentialsTest(unittest.TestCase):
         third = grpc.access_token_call_credentials('ghi')
 
         first_and_second = grpc.composite_call_credentials(first, second)
-        first_second_and_third = grpc.composite_call_credentials(first, second,
-                                                                 third)
+        first_second_and_third = grpc.composite_call_credentials(
+            first, second, third)
 
         self.assertIsInstance(first_and_second, grpc.CallCredentials)
         self.assertIsInstance(first_second_and_third, grpc.CallCredentials)
diff --git a/src/python/grpcio_tests/tests/unit/_cython/_cancel_many_calls_test.py b/src/python/grpcio_tests/tests/unit/_cython/_cancel_many_calls_test.py
index cdb3572453..b81d6fbc61 100644
--- a/src/python/grpcio_tests/tests/unit/_cython/_cancel_many_calls_test.py
+++ b/src/python/grpcio_tests/tests/unit/_cython/_cancel_many_calls_test.py
@@ -81,7 +81,8 @@ class _Handler(object):
                     cygrpc.SendMessageOperation(b'\x79\x57', _EMPTY_FLAGS),
                     cygrpc.SendStatusFromServerOperation(
                         _EMPTY_METADATA, cygrpc.StatusCode.ok, b'test details!',
-                        _EMPTY_FLAGS),)
+                        _EMPTY_FLAGS),
+                )
                 self._call.start_server_batch(operations,
                                               _SERVER_COMPLETE_CALL_TAG)
             self._completion_queue.poll()
@@ -151,8 +152,12 @@ class CancelManyCallsTest(unittest.TestCase):
 
         state = _State()
 
-        server_thread_args = (state, server, server_completion_queue,
-                              server_thread_pool,)
+        server_thread_args = (
+            state,
+            server,
+            server_completion_queue,
+            server_thread_pool,
+        )
         server_thread = threading.Thread(target=_serve, args=server_thread_args)
         server_thread.start()
 
@@ -176,7 +181,8 @@ class CancelManyCallsTest(unittest.TestCase):
                     cygrpc.SendCloseFromClientOperation(_EMPTY_FLAGS),
                     cygrpc.ReceiveInitialMetadataOperation(_EMPTY_FLAGS),
                     cygrpc.ReceiveMessageOperation(_EMPTY_FLAGS),
-                    cygrpc.ReceiveStatusOnClientOperation(_EMPTY_FLAGS),)
+                    cygrpc.ReceiveStatusOnClientOperation(_EMPTY_FLAGS),
+                )
                 tag = 'client_complete_call_{0:04d}_tag'.format(index)
                 client_call.start_client_batch(operations, tag)
                 client_due.add(tag)
@@ -193,8 +199,8 @@ class CancelManyCallsTest(unittest.TestCase):
                     state.condition.notify_all()
                     break
 
-        client_driver.events(test_constants.RPC_CONCURRENCY *
-                             _SUCCESS_CALL_FRACTION)
+        client_driver.events(
+            test_constants.RPC_CONCURRENCY * _SUCCESS_CALL_FRACTION)
         with client_condition:
             for client_call in client_calls:
                 client_call.cancel()
diff --git a/src/python/grpcio_tests/tests/unit/_cython/_channel_test.py b/src/python/grpcio_tests/tests/unit/_cython/_channel_test.py
index 1d57ea7ec1..4eeb34b92e 100644
--- a/src/python/grpcio_tests/tests/unit/_cython/_channel_test.py
+++ b/src/python/grpcio_tests/tests/unit/_cython/_channel_test.py
@@ -56,7 +56,10 @@ class ChannelTest(unittest.TestCase):
 
     def test_single_channel_lonely_connectivity(self):
         channel, completion_queue = _channel_and_completion_queue()
-        _in_parallel(_connectivity_loop, (channel, completion_queue,))
+        _in_parallel(_connectivity_loop, (
+            channel,
+            completion_queue,
+        ))
         completion_queue.shutdown()
 
     def test_multiple_channels_lonely_connectivity(self):
diff --git a/src/python/grpcio_tests/tests/unit/_cython/_common.py b/src/python/grpcio_tests/tests/unit/_cython/_common.py
index c5acd36bf2..ffd226fa95 100644
--- a/src/python/grpcio_tests/tests/unit/_cython/_common.py
+++ b/src/python/grpcio_tests/tests/unit/_cython/_common.py
@@ -23,14 +23,20 @@ RPC_COUNT = 4000
 INFINITE_FUTURE = cygrpc.Timespec(float('+inf'))
 EMPTY_FLAGS = 0
 
-INVOCATION_METADATA = (('client-md-key', 'client-md-key'),
-                       ('client-md-key-bin', b'\x00\x01' * 3000),)
+INVOCATION_METADATA = (
+    ('client-md-key', 'client-md-key'),
+    ('client-md-key-bin', b'\x00\x01' * 3000),
+)
 
-INITIAL_METADATA = (('server-initial-md-key', 'server-initial-md-value'),
-                    ('server-initial-md-key-bin', b'\x00\x02' * 3000),)
+INITIAL_METADATA = (
+    ('server-initial-md-key', 'server-initial-md-value'),
+    ('server-initial-md-key-bin', b'\x00\x02' * 3000),
+)
 
-TRAILING_METADATA = (('server-trailing-md-key', 'server-trailing-md-value'),
-                     ('server-trailing-md-key-bin', b'\x00\x03' * 3000),)
+TRAILING_METADATA = (
+    ('server-trailing-md-key', 'server-trailing-md-value'),
+    ('server-trailing-md-key-bin', b'\x00\x03' * 3000),
+)
 
 
 class QueueDriver(object):
@@ -76,7 +82,10 @@ def execute_many_times(behavior):
 
 class OperationResult(
         collections.namedtuple('OperationResult', (
-            'start_batch_result', 'completion_type', 'success',))):
+            'start_batch_result',
+            'completion_type',
+            'success',
+        ))):
     pass
 
 
diff --git a/src/python/grpcio_tests/tests/unit/_cython/_no_messages_server_completion_queue_per_call_test.py b/src/python/grpcio_tests/tests/unit/_cython/_no_messages_server_completion_queue_per_call_test.py
index 583136cf23..4ef4ad33e5 100644
--- a/src/python/grpcio_tests/tests/unit/_cython/_no_messages_server_completion_queue_per_call_test.py
+++ b/src/python/grpcio_tests/tests/unit/_cython/_no_messages_server_completion_queue_per_call_test.py
@@ -101,28 +101,29 @@ class Test(_common.RpcTest, unittest.TestCase):
         client_complete_rpc_event = self.client_driver.event_with_tag(
             client_complete_rpc_tag)
 
-        return (_common.OperationResult(
-            server_request_call_start_batch_result,
-            server_request_call_event.completion_type,
-            server_request_call_event.success), _common.OperationResult(
+        return (
+            _common.OperationResult(server_request_call_start_batch_result,
+                                    server_request_call_event.completion_type,
+                                    server_request_call_event.success),
+            _common.OperationResult(
                 client_receive_initial_metadata_start_batch_result,
                 client_receive_initial_metadata_event.completion_type,
                 client_receive_initial_metadata_event.success),
-                _common.OperationResult(
-                    client_complete_rpc_start_batch_result,
-                    client_complete_rpc_event.completion_type,
-                    client_complete_rpc_event.success), _common.OperationResult(
-                        server_send_initial_metadata_start_batch_result,
-                        server_send_initial_metadata_event.completion_type,
-                        server_send_initial_metadata_event.success),
-                _common.OperationResult(
-                    server_complete_rpc_start_batch_result,
-                    server_complete_rpc_event.completion_type,
-                    server_complete_rpc_event.success),)
+            _common.OperationResult(client_complete_rpc_start_batch_result,
+                                    client_complete_rpc_event.completion_type,
+                                    client_complete_rpc_event.success),
+            _common.OperationResult(
+                server_send_initial_metadata_start_batch_result,
+                server_send_initial_metadata_event.completion_type,
+                server_send_initial_metadata_event.success),
+            _common.OperationResult(server_complete_rpc_start_batch_result,
+                                    server_complete_rpc_event.completion_type,
+                                    server_complete_rpc_event.success),
+        )
 
     def test_rpcs(self):
-        expecteds = [(_common.SUCCESSFUL_OPERATION_RESULT,) *
-                     5] * _common.RPC_COUNT
+        expecteds = [(
+            _common.SUCCESSFUL_OPERATION_RESULT,) * 5] * _common.RPC_COUNT
         actuallys = _common.execute_many_times(self._do_rpcs)
         self.assertSequenceEqual(expecteds, actuallys)
 
diff --git a/src/python/grpcio_tests/tests/unit/_cython/_no_messages_single_server_completion_queue_test.py b/src/python/grpcio_tests/tests/unit/_cython/_no_messages_single_server_completion_queue_test.py
index c5cf606c90..85395c9680 100644
--- a/src/python/grpcio_tests/tests/unit/_cython/_no_messages_single_server_completion_queue_test.py
+++ b/src/python/grpcio_tests/tests/unit/_cython/_no_messages_single_server_completion_queue_test.py
@@ -92,28 +92,29 @@ class Test(_common.RpcTest, unittest.TestCase):
         client_complete_rpc_event = self.client_driver.event_with_tag(
             client_complete_rpc_tag)
 
-        return (_common.OperationResult(
-            server_request_call_start_batch_result,
-            server_request_call_event.completion_type,
-            server_request_call_event.success), _common.OperationResult(
+        return (
+            _common.OperationResult(server_request_call_start_batch_result,
+                                    server_request_call_event.completion_type,
+                                    server_request_call_event.success),
+            _common.OperationResult(
                 client_receive_initial_metadata_start_batch_result,
                 client_receive_initial_metadata_event.completion_type,
                 client_receive_initial_metadata_event.success),
-                _common.OperationResult(
-                    client_complete_rpc_start_batch_result,
-                    client_complete_rpc_event.completion_type,
-                    client_complete_rpc_event.success), _common.OperationResult(
-                        server_send_initial_metadata_start_batch_result,
-                        server_send_initial_metadata_event.completion_type,
-                        server_send_initial_metadata_event.success),
-                _common.OperationResult(
-                    server_complete_rpc_start_batch_result,
-                    server_complete_rpc_event.completion_type,
-                    server_complete_rpc_event.success),)
+            _common.OperationResult(client_complete_rpc_start_batch_result,
+                                    client_complete_rpc_event.completion_type,
+                                    client_complete_rpc_event.success),
+            _common.OperationResult(
+                server_send_initial_metadata_start_batch_result,
+                server_send_initial_metadata_event.completion_type,
+                server_send_initial_metadata_event.success),
+            _common.OperationResult(server_complete_rpc_start_batch_result,
+                                    server_complete_rpc_event.completion_type,
+                                    server_complete_rpc_event.success),
+        )
 
     def test_rpcs(self):
-        expecteds = [(_common.SUCCESSFUL_OPERATION_RESULT,) *
-                     5] * _common.RPC_COUNT
+        expecteds = [(
+            _common.SUCCESSFUL_OPERATION_RESULT,) * 5] * _common.RPC_COUNT
         actuallys = _common.execute_many_times(self._do_rpcs)
         self.assertSequenceEqual(expecteds, actuallys)
 
diff --git a/src/python/grpcio_tests/tests/unit/_cython/_read_some_but_not_all_responses_test.py b/src/python/grpcio_tests/tests/unit/_cython/_read_some_but_not_all_responses_test.py
index a5ec54ee59..82ef25b2a7 100644
--- a/src/python/grpcio_tests/tests/unit/_cython/_read_some_but_not_all_responses_test.py
+++ b/src/python/grpcio_tests/tests/unit/_cython/_read_some_but_not_all_responses_test.py
@@ -137,9 +137,12 @@ class ReadSomeButNotAllResponsesTest(unittest.TestCase):
         server_send_first_message_tag = 'server_send_first_message_tag'
         server_send_second_message_tag = 'server_send_second_message_tag'
         server_complete_rpc_tag = 'server_complete_rpc_tag'
-        server_call_due = set(
-            (server_send_initial_metadata_tag, server_send_first_message_tag,
-             server_send_second_message_tag, server_complete_rpc_tag,))
+        server_call_due = set((
+            server_send_initial_metadata_tag,
+            server_send_first_message_tag,
+            server_send_second_message_tag,
+            server_complete_rpc_tag,
+        ))
         server_call_completion_queue = cygrpc.CompletionQueue()
         server_call_driver = _QueueDriver(server_call_condition,
                                           server_call_completion_queue,
diff --git a/src/python/grpcio_tests/tests/unit/_cython/cygrpc_test.py b/src/python/grpcio_tests/tests/unit/_cython/cygrpc_test.py
index 5453735f11..5f9b74ba98 100644
--- a/src/python/grpcio_tests/tests/unit/_cython/cygrpc_test.py
+++ b/src/python/grpcio_tests/tests/unit/_cython/cygrpc_test.py
@@ -29,8 +29,10 @@ _EMPTY_FLAGS = 0
 
 
 def _metadata_plugin(context, callback):
-    callback(((_CALL_CREDENTIALS_METADATA_KEY,
-               _CALL_CREDENTIALS_METADATA_VALUE,),), cygrpc.StatusCode.ok, b'')
+    callback(((
+        _CALL_CREDENTIALS_METADATA_KEY,
+        _CALL_CREDENTIALS_METADATA_VALUE,
+    ),), cygrpc.StatusCode.ok, b'')
 
 
 class TypeSmokeTest(unittest.TestCase):
@@ -113,13 +115,12 @@ class ServerClientMixin(object):
                 cygrpc.ChannelArg(cygrpc.ChannelArgKey.ssl_target_name_override,
                                   host_override)
             ])
-            self.client_channel = cygrpc.Channel(
-                'localhost:{}'.format(self.port).encode(),
-                client_channel_arguments, client_credentials)
+            self.client_channel = cygrpc.Channel('localhost:{}'.format(
+                self.port).encode(), client_channel_arguments,
+                                                 client_credentials)
         else:
-            self.client_channel = cygrpc.Channel(
-                'localhost:{}'.format(self.port).encode(),
-                cygrpc.ChannelArgs([]))
+            self.client_channel = cygrpc.Channel('localhost:{}'.format(
+                self.port).encode(), cygrpc.ChannelArgs([]))
         if host_override:
             self.host_argument = None  # default host
             self.expected_host = host_override
@@ -152,8 +153,8 @@ class ServerClientMixin(object):
                 self.assertTrue(event.success)
                 self.assertIs(tag, event.tag)
             except Exception as error:
-                raise Exception(
-                    "Error in '{}': {}".format(description, error.message))
+                raise Exception("Error in '{}': {}".format(
+                    description, error.message))
             return event
 
         return test_utilities.SimpleFuture(performer)
@@ -189,8 +190,15 @@ class ServerClientMixin(object):
             None, 0, self.client_completion_queue, METHOD, self.host_argument,
             cygrpc_deadline)
         client_initial_metadata = (
-            (CLIENT_METADATA_ASCII_KEY, CLIENT_METADATA_ASCII_VALUE,),
-            (CLIENT_METADATA_BIN_KEY, CLIENT_METADATA_BIN_VALUE,),)
+            (
+                CLIENT_METADATA_ASCII_KEY,
+                CLIENT_METADATA_ASCII_VALUE,
+            ),
+            (
+                CLIENT_METADATA_BIN_KEY,
+                CLIENT_METADATA_BIN_VALUE,
+            ),
+        )
         client_start_batch_result = client_call.start_client_batch([
             cygrpc.SendInitialMetadataOperation(client_initial_metadata,
                                                 _EMPTY_FLAGS),
@@ -220,14 +228,18 @@ class ServerClientMixin(object):
 
         server_call_tag = object()
         server_call = request_event.call
-        server_initial_metadata = (
-            (SERVER_INITIAL_METADATA_KEY, SERVER_INITIAL_METADATA_VALUE,),)
-        server_trailing_metadata = (
-            (SERVER_TRAILING_METADATA_KEY, SERVER_TRAILING_METADATA_VALUE,),)
+        server_initial_metadata = ((
+            SERVER_INITIAL_METADATA_KEY,
+            SERVER_INITIAL_METADATA_VALUE,
+        ),)
+        server_trailing_metadata = ((
+            SERVER_TRAILING_METADATA_KEY,
+            SERVER_TRAILING_METADATA_VALUE,
+        ),)
         server_start_batch_result = server_call.start_server_batch([
-            cygrpc.SendInitialMetadataOperation(
-                server_initial_metadata,
-                _EMPTY_FLAGS), cygrpc.ReceiveMessageOperation(_EMPTY_FLAGS),
+            cygrpc.SendInitialMetadataOperation(server_initial_metadata,
+                                                _EMPTY_FLAGS),
+            cygrpc.ReceiveMessageOperation(_EMPTY_FLAGS),
             cygrpc.SendMessageOperation(RESPONSE, _EMPTY_FLAGS),
             cygrpc.ReceiveCloseOnServerOperation(_EMPTY_FLAGS),
             cygrpc.SendStatusFromServerOperation(
@@ -377,10 +389,11 @@ class InsecureServerInsecureClient(unittest.TestCase, ServerClientMixin):
 class SecureServerSecureClient(unittest.TestCase, ServerClientMixin):
 
     def setUp(self):
-        server_credentials = cygrpc.server_credentials_ssl(None, [
-            cygrpc.SslPemKeyCertPair(resources.private_key(),
-                                     resources.certificate_chain())
-        ], False)
+        server_credentials = cygrpc.server_credentials_ssl(
+            None, [
+                cygrpc.SslPemKeyCertPair(resources.private_key(),
+                                         resources.certificate_chain())
+            ], False)
         client_credentials = cygrpc.SSLChannelCredentials(
             resources.test_root_certificates(), None, None)
         self.setUpMixin(server_credentials, client_credentials,
diff --git a/src/python/grpcio_tests/tests/unit/_empty_message_test.py b/src/python/grpcio_tests/tests/unit/_empty_message_test.py
index 14695bc13f..c55ef61c13 100644
--- a/src/python/grpcio_tests/tests/unit/_empty_message_test.py
+++ b/src/python/grpcio_tests/tests/unit/_empty_message_test.py
@@ -106,13 +106,13 @@ class EmptyMessageTest(unittest.TestCase):
                                  list(response_iterator))
 
     def testStreamUnary(self):
-        response = self._channel.stream_unary(_STREAM_UNARY)(
-            iter([_REQUEST] * test_constants.STREAM_LENGTH))
+        response = self._channel.stream_unary(_STREAM_UNARY)(iter(
+            [_REQUEST] * test_constants.STREAM_LENGTH))
         self.assertEqual(_RESPONSE, response)
 
     def testStreamStream(self):
-        response_iterator = self._channel.stream_stream(_STREAM_STREAM)(
-            iter([_REQUEST] * test_constants.STREAM_LENGTH))
+        response_iterator = self._channel.stream_stream(_STREAM_STREAM)(iter(
+            [_REQUEST] * test_constants.STREAM_LENGTH))
         self.assertSequenceEqual([_RESPONSE] * test_constants.STREAM_LENGTH,
                                  list(response_iterator))
 
diff --git a/src/python/grpcio_tests/tests/unit/_interceptor_test.py b/src/python/grpcio_tests/tests/unit/_interceptor_test.py
index 2aee298df2..3d547b71cd 100644
--- a/src/python/grpcio_tests/tests/unit/_interceptor_test.py
+++ b/src/python/grpcio_tests/tests/unit/_interceptor_test.py
@@ -65,7 +65,10 @@ class _Handler(object):
     def handle_unary_unary(self, request, servicer_context):
         self._control.control()
         if servicer_context is not None:
-            servicer_context.set_trailing_metadata((('testkey', 'testvalue',),))
+            servicer_context.set_trailing_metadata(((
+                'testkey',
+                'testvalue',
+            ),))
         return request
 
     def handle_unary_stream(self, request, servicer_context):
@@ -74,7 +77,10 @@ class _Handler(object):
             yield request
         self._control.control()
         if servicer_context is not None:
-            servicer_context.set_trailing_metadata((('testkey', 'testvalue',),))
+            servicer_context.set_trailing_metadata(((
+                'testkey',
+                'testvalue',
+            ),))
 
     def handle_stream_unary(self, request_iterator, servicer_context):
         if servicer_context is not None:
@@ -86,13 +92,19 @@ class _Handler(object):
             response_elements.append(request)
         self._control.control()
         if servicer_context is not None:
-            servicer_context.set_trailing_metadata((('testkey', 'testvalue',),))
+            servicer_context.set_trailing_metadata(((
+                'testkey',
+                'testvalue',
+            ),))
         return b''.join(response_elements)
 
     def handle_stream_stream(self, request_iterator, servicer_context):
         self._control.control()
         if servicer_context is not None:
-            servicer_context.set_trailing_metadata((('testkey', 'testvalue',),))
+            servicer_context.set_trailing_metadata(((
+                'testkey',
+                'testvalue',
+            ),))
         for request in request_iterator:
             self._control.control()
             yield request
@@ -162,9 +174,10 @@ def _stream_stream_multi_callable(channel):
 
 
 class _ClientCallDetails(
-        collections.namedtuple('_ClientCallDetails',
-                               ('method', 'timeout', 'metadata',
-                                'credentials')), grpc.ClientCallDetails):
+        collections.namedtuple(
+            '_ClientCallDetails',
+            ('method', 'timeout', 'metadata', 'credentials')),
+        grpc.ClientCallDetails):
     pass
 
 
@@ -262,7 +275,10 @@ def _append_request_header_interceptor(header, value):
         metadata = []
         if client_call_details.metadata:
             metadata = list(client_call_details.metadata)
-        metadata.append((header, value,))
+        metadata.append((
+            header,
+            value,
+        ))
         client_call_details = _ClientCallDetails(
             client_call_details.method, client_call_details.timeout, metadata,
             client_call_details.credentials)
@@ -306,9 +322,11 @@ class InterceptorTest(unittest.TestCase):
         self._server = grpc.server(
             self._server_pool,
             options=(('grpc.so_reuseport', 0),),
-            interceptors=(_LoggingInterceptor('s1', self._record),
-                          conditional_interceptor,
-                          _LoggingInterceptor('s2', self._record),))
+            interceptors=(
+                _LoggingInterceptor('s1', self._record),
+                conditional_interceptor,
+                _LoggingInterceptor('s2', self._record),
+            ))
         port = self._server.add_insecure_port('[::]:0')
         self._server.add_generic_rpc_handlers((_GenericHandler(self._handler),))
         self._server.start()
@@ -333,8 +351,8 @@ class InterceptorTest(unittest.TestCase):
 
         interceptor = _wrap_request_iterator_stream_interceptor(triple)
         channel = grpc.intercept_channel(self._channel, interceptor)
-        requests = tuple(b'\x07\x08'
-                         for _ in range(test_constants.STREAM_LENGTH))
+        requests = tuple(
+            b'\x07\x08' for _ in range(test_constants.STREAM_LENGTH))
 
         multi_callable = _stream_stream_multi_callable(channel)
         response_iterator = multi_callable(
@@ -365,8 +383,8 @@ class InterceptorTest(unittest.TestCase):
         multi_callable = _unary_unary_multi_callable(defective_channel)
         call_future = multi_callable.future(
             request,
-            metadata=(
-                ('test', 'InterceptedUnaryRequestBlockingUnaryResponse'),))
+            metadata=(('test',
+                       'InterceptedUnaryRequestBlockingUnaryResponse'),))
 
         self.assertIsNotNone(call_future.exception())
         self.assertEqual(call_future.code(), grpc.StatusCode.INTERNAL)
@@ -374,12 +392,14 @@ class InterceptorTest(unittest.TestCase):
     def testInterceptedHeaderManipulationWithServerSideVerification(self):
         request = b'\x07\x08'
 
-        channel = grpc.intercept_channel(
-            self._channel, _append_request_header_interceptor('secret', '42'))
-        channel = grpc.intercept_channel(
-            channel,
-            _LoggingInterceptor('c1', self._record),
-            _LoggingInterceptor('c2', self._record))
+        channel = grpc.intercept_channel(self._channel,
+                                         _append_request_header_interceptor(
+                                             'secret', '42'))
+        channel = grpc.intercept_channel(channel,
+                                         _LoggingInterceptor(
+                                             'c1', self._record),
+                                         _LoggingInterceptor(
+                                             'c2', self._record))
 
         self._record[:] = []
 
@@ -401,16 +421,17 @@ class InterceptorTest(unittest.TestCase):
 
         self._record[:] = []
 
-        channel = grpc.intercept_channel(
-            self._channel,
-            _LoggingInterceptor('c1', self._record),
-            _LoggingInterceptor('c2', self._record))
+        channel = grpc.intercept_channel(self._channel,
+                                         _LoggingInterceptor(
+                                             'c1', self._record),
+                                         _LoggingInterceptor(
+                                             'c2', self._record))
 
         multi_callable = _unary_unary_multi_callable(channel)
         multi_callable(
             request,
-            metadata=(
-                ('test', 'InterceptedUnaryRequestBlockingUnaryResponse'),))
+            metadata=(('test',
+                       'InterceptedUnaryRequestBlockingUnaryResponse'),))
 
         self.assertSequenceEqual(self._record, [
             'c1:intercept_unary_unary', 'c2:intercept_unary_unary',
@@ -420,10 +441,11 @@ class InterceptorTest(unittest.TestCase):
     def testInterceptedUnaryRequestBlockingUnaryResponseWithCall(self):
         request = b'\x07\x08'
 
-        channel = grpc.intercept_channel(
-            self._channel,
-            _LoggingInterceptor('c1', self._record),
-            _LoggingInterceptor('c2', self._record))
+        channel = grpc.intercept_channel(self._channel,
+                                         _LoggingInterceptor(
+                                             'c1', self._record),
+                                         _LoggingInterceptor(
+                                             'c2', self._record))
 
         self._record[:] = []
 
@@ -443,10 +465,11 @@ class InterceptorTest(unittest.TestCase):
         request = b'\x07\x08'
 
         self._record[:] = []
-        channel = grpc.intercept_channel(
-            self._channel,
-            _LoggingInterceptor('c1', self._record),
-            _LoggingInterceptor('c2', self._record))
+        channel = grpc.intercept_channel(self._channel,
+                                         _LoggingInterceptor(
+                                             'c1', self._record),
+                                         _LoggingInterceptor(
+                                             'c2', self._record))
 
         multi_callable = _unary_unary_multi_callable(channel)
         response_future = multi_callable.future(
@@ -463,10 +486,11 @@ class InterceptorTest(unittest.TestCase):
         request = b'\x37\x58'
 
         self._record[:] = []
-        channel = grpc.intercept_channel(
-            self._channel,
-            _LoggingInterceptor('c1', self._record),
-            _LoggingInterceptor('c2', self._record))
+        channel = grpc.intercept_channel(self._channel,
+                                         _LoggingInterceptor(
+                                             'c1', self._record),
+                                         _LoggingInterceptor(
+                                             'c2', self._record))
 
         multi_callable = _unary_stream_multi_callable(channel)
         response_iterator = multi_callable(
@@ -480,21 +504,22 @@ class InterceptorTest(unittest.TestCase):
         ])
 
     def testInterceptedStreamRequestBlockingUnaryResponse(self):
-        requests = tuple(b'\x07\x08'
-                         for _ in range(test_constants.STREAM_LENGTH))
+        requests = tuple(
+            b'\x07\x08' for _ in range(test_constants.STREAM_LENGTH))
         request_iterator = iter(requests)
 
         self._record[:] = []
-        channel = grpc.intercept_channel(
-            self._channel,
-            _LoggingInterceptor('c1', self._record),
-            _LoggingInterceptor('c2', self._record))
+        channel = grpc.intercept_channel(self._channel,
+                                         _LoggingInterceptor(
+                                             'c1', self._record),
+                                         _LoggingInterceptor(
+                                             'c2', self._record))
 
         multi_callable = _stream_unary_multi_callable(channel)
         multi_callable(
             request_iterator,
-            metadata=(
-                ('test', 'InterceptedStreamRequestBlockingUnaryResponse'),))
+            metadata=(('test',
+                       'InterceptedStreamRequestBlockingUnaryResponse'),))
 
         self.assertSequenceEqual(self._record, [
             'c1:intercept_stream_unary', 'c2:intercept_stream_unary',
@@ -502,15 +527,16 @@ class InterceptorTest(unittest.TestCase):
         ])
 
     def testInterceptedStreamRequestBlockingUnaryResponseWithCall(self):
-        requests = tuple(b'\x07\x08'
-                         for _ in range(test_constants.STREAM_LENGTH))
+        requests = tuple(
+            b'\x07\x08' for _ in range(test_constants.STREAM_LENGTH))
         request_iterator = iter(requests)
 
         self._record[:] = []
-        channel = grpc.intercept_channel(
-            self._channel,
-            _LoggingInterceptor('c1', self._record),
-            _LoggingInterceptor('c2', self._record))
+        channel = grpc.intercept_channel(self._channel,
+                                         _LoggingInterceptor(
+                                             'c1', self._record),
+                                         _LoggingInterceptor(
+                                             'c2', self._record))
 
         multi_callable = _stream_unary_multi_callable(channel)
         multi_callable.with_call(
@@ -525,15 +551,16 @@ class InterceptorTest(unittest.TestCase):
         ])
 
     def testInterceptedStreamRequestFutureUnaryResponse(self):
-        requests = tuple(b'\x07\x08'
-                         for _ in range(test_constants.STREAM_LENGTH))
+        requests = tuple(
+            b'\x07\x08' for _ in range(test_constants.STREAM_LENGTH))
         request_iterator = iter(requests)
 
         self._record[:] = []
-        channel = grpc.intercept_channel(
-            self._channel,
-            _LoggingInterceptor('c1', self._record),
-            _LoggingInterceptor('c2', self._record))
+        channel = grpc.intercept_channel(self._channel,
+                                         _LoggingInterceptor(
+                                             'c1', self._record),
+                                         _LoggingInterceptor(
+                                             'c2', self._record))
 
         multi_callable = _stream_unary_multi_callable(channel)
         response_future = multi_callable.future(
@@ -547,15 +574,16 @@ class InterceptorTest(unittest.TestCase):
         ])
 
     def testInterceptedStreamRequestStreamResponse(self):
-        requests = tuple(b'\x77\x58'
-                         for _ in range(test_constants.STREAM_LENGTH))
+        requests = tuple(
+            b'\x77\x58' for _ in range(test_constants.STREAM_LENGTH))
         request_iterator = iter(requests)
 
         self._record[:] = []
-        channel = grpc.intercept_channel(
-            self._channel,
-            _LoggingInterceptor('c1', self._record),
-            _LoggingInterceptor('c2', self._record))
+        channel = grpc.intercept_channel(self._channel,
+                                         _LoggingInterceptor(
+                                             'c1', self._record),
+                                         _LoggingInterceptor(
+                                             'c2', self._record))
 
         multi_callable = _stream_stream_multi_callable(channel)
         response_iterator = multi_callable(
diff --git a/src/python/grpcio_tests/tests/unit/_invalid_metadata_test.py b/src/python/grpcio_tests/tests/unit/_invalid_metadata_test.py
index 8f4c075e2c..4edf0fc4ad 100644
--- a/src/python/grpcio_tests/tests/unit/_invalid_metadata_test.py
+++ b/src/python/grpcio_tests/tests/unit/_invalid_metadata_test.py
@@ -106,8 +106,8 @@ class InvalidMetadataTest(unittest.TestCase):
         self.assertEqual(response_iterator.code(), grpc.StatusCode.INTERNAL)
 
     def testStreamRequestBlockingUnaryResponse(self):
-        request_iterator = (b'\x07\x08'
-                            for _ in range(test_constants.STREAM_LENGTH))
+        request_iterator = (
+            b'\x07\x08' for _ in range(test_constants.STREAM_LENGTH))
         metadata = (('InVaLiD', 'StreamRequestBlockingUnaryResponse'),)
         expected_error_details = "metadata was invalid: %s" % metadata
         with self.assertRaises(ValueError) as exception_context:
@@ -115,8 +115,8 @@ class InvalidMetadataTest(unittest.TestCase):
         self.assertIn(expected_error_details, str(exception_context.exception))
 
     def testStreamRequestBlockingUnaryResponseWithCall(self):
-        request_iterator = (b'\x07\x08'
-                            for _ in range(test_constants.STREAM_LENGTH))
+        request_iterator = (
+            b'\x07\x08' for _ in range(test_constants.STREAM_LENGTH))
         metadata = (('InVaLiD', 'StreamRequestBlockingUnaryResponseWithCall'),)
         expected_error_details = "metadata was invalid: %s" % metadata
         multi_callable = _stream_unary_multi_callable(self._channel)
@@ -125,8 +125,8 @@ class InvalidMetadataTest(unittest.TestCase):
         self.assertIn(expected_error_details, str(exception_context.exception))
 
     def testStreamRequestFutureUnaryResponse(self):
-        request_iterator = (b'\x07\x08'
-                            for _ in range(test_constants.STREAM_LENGTH))
+        request_iterator = (
+            b'\x07\x08' for _ in range(test_constants.STREAM_LENGTH))
         metadata = (('InVaLiD', 'StreamRequestFutureUnaryResponse'),)
         expected_error_details = "metadata was invalid: %s" % metadata
         response_future = self._stream_unary.future(
@@ -141,8 +141,8 @@ class InvalidMetadataTest(unittest.TestCase):
         self.assertEqual(response_future.code(), grpc.StatusCode.INTERNAL)
 
     def testStreamRequestStreamResponse(self):
-        request_iterator = (b'\x07\x08'
-                            for _ in range(test_constants.STREAM_LENGTH))
+        request_iterator = (
+            b'\x07\x08' for _ in range(test_constants.STREAM_LENGTH))
         metadata = (('InVaLiD', 'StreamRequestStreamResponse'),)
         expected_error_details = "metadata was invalid: %s" % metadata
         response_iterator = self._stream_stream(
diff --git a/src/python/grpcio_tests/tests/unit/_invocation_defects_test.py b/src/python/grpcio_tests/tests/unit/_invocation_defects_test.py
index b46d176d04..e40cca8b24 100644
--- a/src/python/grpcio_tests/tests/unit/_invocation_defects_test.py
+++ b/src/python/grpcio_tests/tests/unit/_invocation_defects_test.py
@@ -62,7 +62,10 @@ class _Handler(object):
     def handle_unary_unary(self, request, servicer_context):
         self._control.control()
         if servicer_context is not None:
-            servicer_context.set_trailing_metadata((('testkey', 'testvalue',),))
+            servicer_context.set_trailing_metadata(((
+                'testkey',
+                'testvalue',
+            ),))
         return request
 
     def handle_unary_stream(self, request, servicer_context):
@@ -71,7 +74,10 @@ class _Handler(object):
             yield request
         self._control.control()
         if servicer_context is not None:
-            servicer_context.set_trailing_metadata((('testkey', 'testvalue',),))
+            servicer_context.set_trailing_metadata(((
+                'testkey',
+                'testvalue',
+            ),))
 
     def handle_stream_unary(self, request_iterator, servicer_context):
         if servicer_context is not None:
@@ -83,13 +89,19 @@ class _Handler(object):
             response_elements.append(request)
         self._control.control()
         if servicer_context is not None:
-            servicer_context.set_trailing_metadata((('testkey', 'testvalue',),))
+            servicer_context.set_trailing_metadata(((
+                'testkey',
+                'testvalue',
+            ),))
         return b''.join(response_elements)
 
     def handle_stream_stream(self, request_iterator, servicer_context):
         self._control.control()
         if servicer_context is not None:
-            servicer_context.set_trailing_metadata((('testkey', 'testvalue',),))
+            servicer_context.set_trailing_metadata(((
+                'testkey',
+                'testvalue',
+            ),))
         for request in request_iterator:
             self._control.control()
             yield request
@@ -208,8 +220,8 @@ class InvocationDefectsTest(unittest.TestCase):
         with self.assertRaises(grpc.RpcError):
             response = multi_callable(
                 requests,
-                metadata=(
-                    ('test', 'IterableStreamRequestBlockingUnaryResponse'),))
+                metadata=(('test',
+                           'IterableStreamRequestBlockingUnaryResponse'),))
 
     def testIterableStreamRequestFutureUnaryResponse(self):
         requests = [b'\x07\x08' for _ in range(test_constants.STREAM_LENGTH)]
diff --git a/src/python/grpcio_tests/tests/unit/_metadata_code_details_test.py b/src/python/grpcio_tests/tests/unit/_metadata_code_details_test.py
index ec67f99fbc..bb6ac70497 100644
--- a/src/python/grpcio_tests/tests/unit/_metadata_code_details_test.py
+++ b/src/python/grpcio_tests/tests/unit/_metadata_code_details_test.py
@@ -36,16 +36,16 @@ _UNARY_STREAM = 'UnaryStream'
 _STREAM_UNARY = 'StreamUnary'
 _STREAM_STREAM = 'StreamStream'
 
-_CLIENT_METADATA = (('client-md-key', 'client-md-key'),
-                    ('client-md-key-bin', b'\x00\x01'))
+_CLIENT_METADATA = (('client-md-key', 'client-md-key'), ('client-md-key-bin',
+                                                         b'\x00\x01'))
 
-_SERVER_INITIAL_METADATA = (
-    ('server-initial-md-key', 'server-initial-md-value'),
-    ('server-initial-md-key-bin', b'\x00\x02'))
+_SERVER_INITIAL_METADATA = (('server-initial-md-key',
+                             'server-initial-md-value'),
+                            ('server-initial-md-key-bin', b'\x00\x02'))
 
-_SERVER_TRAILING_METADATA = (
-    ('server-trailing-md-key', 'server-trailing-md-value'),
-    ('server-trailing-md-key-bin', b'\x00\x03'))
+_SERVER_TRAILING_METADATA = (('server-trailing-md-key',
+                              'server-trailing-md-value'),
+                             ('server-trailing-md-key-bin', b'\x00\x03'))
 
 _NON_OK_CODE = grpc.StatusCode.NOT_FOUND
 _DETAILS = 'Test details!'
@@ -193,17 +193,33 @@ class MetadataCodeDetailsTest(unittest.TestCase):
 
         channel = grpc.insecure_channel('localhost:{}'.format(port))
         self._unary_unary = channel.unary_unary(
-            '/'.join(('', _SERVICE, _UNARY_UNARY,)),
+            '/'.join((
+                '',
+                _SERVICE,
+                _UNARY_UNARY,
+            )),
             request_serializer=_REQUEST_SERIALIZER,
-            response_deserializer=_RESPONSE_DESERIALIZER,)
-        self._unary_stream = channel.unary_stream(
-            '/'.join(('', _SERVICE, _UNARY_STREAM,)),)
-        self._stream_unary = channel.stream_unary(
-            '/'.join(('', _SERVICE, _STREAM_UNARY,)),)
+            response_deserializer=_RESPONSE_DESERIALIZER,
+        )
+        self._unary_stream = channel.unary_stream('/'.join((
+            '',
+            _SERVICE,
+            _UNARY_STREAM,
+        )),)
+        self._stream_unary = channel.stream_unary('/'.join((
+            '',
+            _SERVICE,
+            _STREAM_UNARY,
+        )),)
         self._stream_stream = channel.stream_stream(
-            '/'.join(('', _SERVICE, _STREAM_STREAM,)),
+            '/'.join((
+                '',
+                _SERVICE,
+                _STREAM_STREAM,
+            )),
             request_serializer=_REQUEST_SERIALIZER,
-            response_deserializer=_RESPONSE_DESERIALIZER,)
+            response_deserializer=_RESPONSE_DESERIALIZER,
+        )
 
     def testSuccessfulUnaryUnary(self):
         self._servicer.set_details(_DETAILS)
diff --git a/src/python/grpcio_tests/tests/unit/_metadata_test.py b/src/python/grpcio_tests/tests/unit/_metadata_test.py
index f2dac7bdc5..a918066ea4 100644
--- a/src/python/grpcio_tests/tests/unit/_metadata_test.py
+++ b/src/python/grpcio_tests/tests/unit/_metadata_test.py
@@ -33,18 +33,50 @@ _UNARY_STREAM = '/test/UnaryStream'
 _STREAM_UNARY = '/test/StreamUnary'
 _STREAM_STREAM = '/test/StreamStream'
 
-_INVOCATION_METADATA = ((b'invocation-md-key', u'invocation-md-value',),
-                        (u'invocation-md-key-bin', b'\x00\x01',),)
-_EXPECTED_INVOCATION_METADATA = (('invocation-md-key', 'invocation-md-value',),
-                                 ('invocation-md-key-bin', b'\x00\x01',),)
+_INVOCATION_METADATA = (
+    (
+        b'invocation-md-key',
+        u'invocation-md-value',
+    ),
+    (
+        u'invocation-md-key-bin',
+        b'\x00\x01',
+    ),
+)
+_EXPECTED_INVOCATION_METADATA = (
+    (
+        'invocation-md-key',
+        'invocation-md-value',
+    ),
+    (
+        'invocation-md-key-bin',
+        b'\x00\x01',
+    ),
+)
 
 _INITIAL_METADATA = ((b'initial-md-key', u'initial-md-value'),
                      (u'initial-md-key-bin', b'\x00\x02'))
-_EXPECTED_INITIAL_METADATA = (('initial-md-key', 'initial-md-value',),
-                              ('initial-md-key-bin', b'\x00\x02',),)
-
-_TRAILING_METADATA = (('server-trailing-md-key', 'server-trailing-md-value',),
-                      ('server-trailing-md-key-bin', b'\x00\x03',),)
+_EXPECTED_INITIAL_METADATA = (
+    (
+        'initial-md-key',
+        'initial-md-value',
+    ),
+    (
+        'initial-md-key-bin',
+        b'\x00\x02',
+    ),
+)
+
+_TRAILING_METADATA = (
+    (
+        'server-trailing-md-key',
+        'server-trailing-md-value',
+    ),
+    (
+        'server-trailing-md-key-bin',
+        b'\x00\x03',
+    ),
+)
 _EXPECTED_TRAILING_METADATA = _TRAILING_METADATA
 
 
@@ -146,8 +178,8 @@ class MetadataTest(unittest.TestCase):
 
     def setUp(self):
         self._server = test_common.test_server()
-        self._server.add_generic_rpc_handlers(
-            (_GenericHandler(weakref.proxy(self)),))
+        self._server.add_generic_rpc_handlers((_GenericHandler(
+            weakref.proxy(self)),))
         port = self._server.add_insecure_port('[::]:0')
         self._server.start()
         self._channel = grpc.insecure_channel(
diff --git a/src/python/grpcio_tests/tests/unit/_rpc_test.py b/src/python/grpcio_tests/tests/unit/_rpc_test.py
index 1515a87d93..54f01d9f8d 100644
--- a/src/python/grpcio_tests/tests/unit/_rpc_test.py
+++ b/src/python/grpcio_tests/tests/unit/_rpc_test.py
@@ -64,7 +64,10 @@ class _Handler(object):
     def handle_unary_unary(self, request, servicer_context):
         self._control.control()
         if servicer_context is not None:
-            servicer_context.set_trailing_metadata((('testkey', 'testvalue',),))
+            servicer_context.set_trailing_metadata(((
+                'testkey',
+                'testvalue',
+            ),))
             # TODO(https://github.com/grpc/grpc/issues/8483): test the values
             # returned by these methods rather than only "smoke" testing that
             # the return after having been called.
@@ -78,7 +81,10 @@ class _Handler(object):
             yield request
         self._control.control()
         if servicer_context is not None:
-            servicer_context.set_trailing_metadata((('testkey', 'testvalue',),))
+            servicer_context.set_trailing_metadata(((
+                'testkey',
+                'testvalue',
+            ),))
 
     def handle_stream_unary(self, request_iterator, servicer_context):
         if servicer_context is not None:
@@ -90,13 +96,19 @@ class _Handler(object):
             response_elements.append(request)
         self._control.control()
         if servicer_context is not None:
-            servicer_context.set_trailing_metadata((('testkey', 'testvalue',),))
+            servicer_context.set_trailing_metadata(((
+                'testkey',
+                'testvalue',
+            ),))
         return b''.join(response_elements)
 
     def handle_stream_stream(self, request_iterator, servicer_context):
         self._control.control()
         if servicer_context is not None:
-            servicer_context.set_trailing_metadata((('testkey', 'testvalue',),))
+            servicer_context.set_trailing_metadata(((
+                'testkey',
+                'testvalue',
+            ),))
         for request in request_iterator:
             self._control.control()
             yield request
@@ -244,8 +256,8 @@ class RPCTest(unittest.TestCase):
         self.assertSequenceEqual(expected_responses, responses)
 
     def testSuccessfulStreamRequestBlockingUnaryResponse(self):
-        requests = tuple(b'\x07\x08'
-                         for _ in range(test_constants.STREAM_LENGTH))
+        requests = tuple(
+            b'\x07\x08' for _ in range(test_constants.STREAM_LENGTH))
         expected_response = self._handler.handle_stream_unary(
             iter(requests), None)
         request_iterator = iter(requests)
@@ -253,14 +265,14 @@ class RPCTest(unittest.TestCase):
         multi_callable = _stream_unary_multi_callable(self._channel)
         response = multi_callable(
             request_iterator,
-            metadata=(
-                ('test', 'SuccessfulStreamRequestBlockingUnaryResponse'),))
+            metadata=(('test',
+                       'SuccessfulStreamRequestBlockingUnaryResponse'),))
 
         self.assertEqual(expected_response, response)
 
     def testSuccessfulStreamRequestBlockingUnaryResponseWithCall(self):
-        requests = tuple(b'\x07\x08'
-                         for _ in range(test_constants.STREAM_LENGTH))
+        requests = tuple(
+            b'\x07\x08' for _ in range(test_constants.STREAM_LENGTH))
         expected_response = self._handler.handle_stream_unary(
             iter(requests), None)
         request_iterator = iter(requests)
@@ -276,8 +288,8 @@ class RPCTest(unittest.TestCase):
         self.assertIs(grpc.StatusCode.OK, call.code())
 
     def testSuccessfulStreamRequestFutureUnaryResponse(self):
-        requests = tuple(b'\x07\x08'
-                         for _ in range(test_constants.STREAM_LENGTH))
+        requests = tuple(
+            b'\x07\x08' for _ in range(test_constants.STREAM_LENGTH))
         expected_response = self._handler.handle_stream_unary(
             iter(requests), None)
         request_iterator = iter(requests)
@@ -293,8 +305,8 @@ class RPCTest(unittest.TestCase):
         self.assertIsNone(response_future.traceback())
 
     def testSuccessfulStreamRequestStreamResponse(self):
-        requests = tuple(b'\x77\x58'
-                         for _ in range(test_constants.STREAM_LENGTH))
+        requests = tuple(
+            b'\x77\x58' for _ in range(test_constants.STREAM_LENGTH))
         expected_responses = tuple(
             self._handler.handle_stream_stream(iter(requests), None))
         request_iterator = iter(requests)
@@ -326,8 +338,8 @@ class RPCTest(unittest.TestCase):
 
     def testConcurrentBlockingInvocations(self):
         pool = logging_pool.pool(test_constants.THREAD_CONCURRENCY)
-        requests = tuple(b'\x07\x08'
-                         for _ in range(test_constants.STREAM_LENGTH))
+        requests = tuple(
+            b'\x07\x08' for _ in range(test_constants.STREAM_LENGTH))
         expected_response = self._handler.handle_stream_unary(
             iter(requests), None)
         expected_responses = [expected_response
@@ -342,15 +354,15 @@ class RPCTest(unittest.TestCase):
                 request_iterator,
                 metadata=(('test', 'ConcurrentBlockingInvocations'),))
             response_futures[index] = response_future
-        responses = tuple(response_future.result()
-                          for response_future in response_futures)
+        responses = tuple(
+            response_future.result() for response_future in response_futures)
 
         pool.shutdown(wait=True)
         self.assertSequenceEqual(expected_responses, responses)
 
     def testConcurrentFutureInvocations(self):
-        requests = tuple(b'\x07\x08'
-                         for _ in range(test_constants.STREAM_LENGTH))
+        requests = tuple(
+            b'\x07\x08' for _ in range(test_constants.STREAM_LENGTH))
         expected_response = self._handler.handle_stream_unary(
             iter(requests), None)
         expected_responses = [expected_response
@@ -364,8 +376,8 @@ class RPCTest(unittest.TestCase):
                 request_iterator,
                 metadata=(('test', 'ConcurrentFutureInvocations'),))
             response_futures[index] = response_future
-        responses = tuple(response_future.result()
-                          for response_future in response_futures)
+        responses = tuple(
+            response_future.result() for response_future in response_futures)
 
         self.assertSequenceEqual(expected_responses, responses)
 
@@ -424,14 +436,14 @@ class RPCTest(unittest.TestCase):
         multi_callable = _unary_stream_multi_callable(self._channel)
         response_iterator = multi_callable(
             request,
-            metadata=(
-                ('test', 'ConsumingSomeButNotAllStreamResponsesUnaryRequest'),))
+            metadata=(('test',
+                       'ConsumingSomeButNotAllStreamResponsesUnaryRequest'),))
         for _ in range(test_constants.STREAM_LENGTH // 2):
             next(response_iterator)
 
     def testConsumingSomeButNotAllStreamResponsesStreamRequest(self):
-        requests = tuple(b'\x67\x88'
-                         for _ in range(test_constants.STREAM_LENGTH))
+        requests = tuple(
+            b'\x67\x88' for _ in range(test_constants.STREAM_LENGTH))
         request_iterator = iter(requests)
 
         multi_callable = _stream_stream_multi_callable(self._channel)
@@ -443,15 +455,15 @@ class RPCTest(unittest.TestCase):
             next(response_iterator)
 
     def testConsumingTooManyStreamResponsesStreamRequest(self):
-        requests = tuple(b'\x67\x88'
-                         for _ in range(test_constants.STREAM_LENGTH))
+        requests = tuple(
+            b'\x67\x88' for _ in range(test_constants.STREAM_LENGTH))
         request_iterator = iter(requests)
 
         multi_callable = _stream_stream_multi_callable(self._channel)
         response_iterator = multi_callable(
             request_iterator,
-            metadata=(
-                ('test', 'ConsumingTooManyStreamResponsesStreamRequest'),))
+            metadata=(('test',
+                       'ConsumingTooManyStreamResponsesStreamRequest'),))
         for _ in range(test_constants.STREAM_LENGTH):
             next(response_iterator)
         for _ in range(test_constants.STREAM_LENGTH):
@@ -503,8 +515,8 @@ class RPCTest(unittest.TestCase):
         self.assertIsNotNone(response_iterator.trailing_metadata())
 
     def testCancelledStreamRequestUnaryResponse(self):
-        requests = tuple(b'\x07\x08'
-                         for _ in range(test_constants.STREAM_LENGTH))
+        requests = tuple(
+            b'\x07\x08' for _ in range(test_constants.STREAM_LENGTH))
         request_iterator = iter(requests)
 
         multi_callable = _stream_unary_multi_callable(self._channel)
@@ -528,8 +540,8 @@ class RPCTest(unittest.TestCase):
         self.assertIsNotNone(response_future.trailing_metadata())
 
     def testCancelledStreamRequestStreamResponse(self):
-        requests = tuple(b'\x07\x08'
-                         for _ in range(test_constants.STREAM_LENGTH))
+        requests = tuple(
+            b'\x07\x08' for _ in range(test_constants.STREAM_LENGTH))
         request_iterator = iter(requests)
 
         multi_callable = _stream_stream_multi_callable(self._channel)
@@ -555,8 +567,8 @@ class RPCTest(unittest.TestCase):
                 multi_callable.with_call(
                     request,
                     timeout=test_constants.SHORT_TIMEOUT,
-                    metadata=(
-                        ('test', 'ExpiredUnaryRequestBlockingUnaryResponse'),))
+                    metadata=(('test',
+                               'ExpiredUnaryRequestBlockingUnaryResponse'),))
 
         self.assertIsInstance(exception_context.exception, grpc.Call)
         self.assertIsNotNone(exception_context.exception.initial_metadata())
@@ -610,8 +622,8 @@ class RPCTest(unittest.TestCase):
                       response_iterator.code())
 
     def testExpiredStreamRequestBlockingUnaryResponse(self):
-        requests = tuple(b'\x07\x08'
-                         for _ in range(test_constants.STREAM_LENGTH))
+        requests = tuple(
+            b'\x07\x08' for _ in range(test_constants.STREAM_LENGTH))
         request_iterator = iter(requests)
 
         multi_callable = _stream_unary_multi_callable(self._channel)
@@ -620,8 +632,8 @@ class RPCTest(unittest.TestCase):
                 multi_callable(
                     request_iterator,
                     timeout=test_constants.SHORT_TIMEOUT,
-                    metadata=(
-                        ('test', 'ExpiredStreamRequestBlockingUnaryResponse'),))
+                    metadata=(('test',
+                               'ExpiredStreamRequestBlockingUnaryResponse'),))
 
         self.assertIsInstance(exception_context.exception, grpc.RpcError)
         self.assertIsInstance(exception_context.exception, grpc.Call)
@@ -632,8 +644,8 @@ class RPCTest(unittest.TestCase):
         self.assertIsNotNone(exception_context.exception.trailing_metadata())
 
     def testExpiredStreamRequestFutureUnaryResponse(self):
-        requests = tuple(b'\x07\x18'
-                         for _ in range(test_constants.STREAM_LENGTH))
+        requests = tuple(
+            b'\x07\x18' for _ in range(test_constants.STREAM_LENGTH))
         request_iterator = iter(requests)
         callback = _Callback()
 
@@ -644,8 +656,8 @@ class RPCTest(unittest.TestCase):
                 timeout=test_constants.SHORT_TIMEOUT,
                 metadata=(('test', 'ExpiredStreamRequestFutureUnaryResponse'),))
             with self.assertRaises(grpc.FutureTimeoutError):
-                response_future.result(timeout=test_constants.SHORT_TIMEOUT /
-                                       2.0)
+                response_future.result(
+                    timeout=test_constants.SHORT_TIMEOUT / 2.0)
             response_future.add_done_callback(callback)
             value_passed_to_callback = callback.value()
 
@@ -663,8 +675,8 @@ class RPCTest(unittest.TestCase):
         self.assertIsNotNone(response_future.trailing_metadata())
 
     def testExpiredStreamRequestStreamResponse(self):
-        requests = tuple(b'\x67\x18'
-                         for _ in range(test_constants.STREAM_LENGTH))
+        requests = tuple(
+            b'\x67\x18' for _ in range(test_constants.STREAM_LENGTH))
         request_iterator = iter(requests)
 
         multi_callable = _stream_stream_multi_callable(self._channel)
@@ -689,8 +701,8 @@ class RPCTest(unittest.TestCase):
             with self.assertRaises(grpc.RpcError) as exception_context:
                 multi_callable.with_call(
                     request,
-                    metadata=(
-                        ('test', 'FailedUnaryRequestBlockingUnaryResponse'),))
+                    metadata=(('test',
+                               'FailedUnaryRequestBlockingUnaryResponse'),))
 
         self.assertIs(grpc.StatusCode.UNKNOWN,
                       exception_context.exception.code())
@@ -734,8 +746,8 @@ class RPCTest(unittest.TestCase):
                       exception_context.exception.code())
 
     def testFailedStreamRequestBlockingUnaryResponse(self):
-        requests = tuple(b'\x47\x58'
-                         for _ in range(test_constants.STREAM_LENGTH))
+        requests = tuple(
+            b'\x47\x58' for _ in range(test_constants.STREAM_LENGTH))
         request_iterator = iter(requests)
 
         multi_callable = _stream_unary_multi_callable(self._channel)
@@ -743,15 +755,15 @@ class RPCTest(unittest.TestCase):
             with self.assertRaises(grpc.RpcError) as exception_context:
                 multi_callable(
                     request_iterator,
-                    metadata=(
-                        ('test', 'FailedStreamRequestBlockingUnaryResponse'),))
+                    metadata=(('test',
+                               'FailedStreamRequestBlockingUnaryResponse'),))
 
         self.assertIs(grpc.StatusCode.UNKNOWN,
                       exception_context.exception.code())
 
     def testFailedStreamRequestFutureUnaryResponse(self):
-        requests = tuple(b'\x07\x18'
-                         for _ in range(test_constants.STREAM_LENGTH))
+        requests = tuple(
+            b'\x07\x18' for _ in range(test_constants.STREAM_LENGTH))
         request_iterator = iter(requests)
         callback = _Callback()
 
@@ -773,8 +785,8 @@ class RPCTest(unittest.TestCase):
         self.assertIs(response_future, value_passed_to_callback)
 
     def testFailedStreamRequestStreamResponse(self):
-        requests = tuple(b'\x67\x88'
-                         for _ in range(test_constants.STREAM_LENGTH))
+        requests = tuple(
+            b'\x67\x88' for _ in range(test_constants.STREAM_LENGTH))
         request_iterator = iter(requests)
 
         multi_callable = _stream_stream_multi_callable(self._channel)
@@ -805,8 +817,8 @@ class RPCTest(unittest.TestCase):
             request, metadata=(('test', 'IgnoredUnaryRequestStreamResponse'),))
 
     def testIgnoredStreamRequestFutureUnaryResponse(self):
-        requests = tuple(b'\x07\x18'
-                         for _ in range(test_constants.STREAM_LENGTH))
+        requests = tuple(
+            b'\x07\x18' for _ in range(test_constants.STREAM_LENGTH))
         request_iterator = iter(requests)
 
         multi_callable = _stream_unary_multi_callable(self._channel)
@@ -815,8 +827,8 @@ class RPCTest(unittest.TestCase):
             metadata=(('test', 'IgnoredStreamRequestFutureUnaryResponse'),))
 
     def testIgnoredStreamRequestStreamResponse(self):
-        requests = tuple(b'\x67\x88'
-                         for _ in range(test_constants.STREAM_LENGTH))
+        requests = tuple(
+            b'\x67\x88' for _ in range(test_constants.STREAM_LENGTH))
         request_iterator = iter(requests)
 
         multi_callable = _stream_stream_multi_callable(self._channel)
diff --git a/src/python/grpcio_tests/tests/unit/_server_ssl_cert_config_test.py b/src/python/grpcio_tests/tests/unit/_server_ssl_cert_config_test.py
index 2c513da5d0..0d78034b7b 100644
--- a/src/python/grpcio_tests/tests/unit/_server_ssl_cert_config_test.py
+++ b/src/python/grpcio_tests/tests/unit/_server_ssl_cert_config_test.py
@@ -74,7 +74,8 @@ def _create_client_stub(
         expect_success,
         root_certificates=None,
         private_key=None,
-        certificate_chain=None,):
+        certificate_chain=None,
+):
     channel = grpc.secure_channel('localhost:{}'.format(port),
                                   grpc.ssl_channel_credentials(
                                       root_certificates=root_certificates,
diff --git a/src/python/grpcio_tests/tests/unit/_thread_cleanup_test.py b/src/python/grpcio_tests/tests/unit/_thread_cleanup_test.py
index fe3e71d686..18f5af058a 100644
--- a/src/python/grpcio_tests/tests/unit/_thread_cleanup_test.py
+++ b/src/python/grpcio_tests/tests/unit/_thread_cleanup_test.py
@@ -52,7 +52,9 @@ class CleanupThreadTest(unittest.TestCase):
             target=target,
             name='test-name',
             args=('arg1', 'arg2'),
-            kwargs={'arg3': 'arg3'})
+            kwargs={
+                'arg3': 'arg3'
+            })
         cleanup_thread.start()
         cleanup_thread.join()
         self.assertEqual(cleanup_thread.name, 'test-name')
diff --git a/src/python/grpcio_tests/tests/unit/beta/_beta_features_test.py b/src/python/grpcio_tests/tests/unit/beta/_beta_features_test.py
index eb8dc80a6e..61c03f64ba 100644
--- a/src/python/grpcio_tests/tests/unit/beta/_beta_features_test.py
+++ b/src/python/grpcio_tests/tests/unit/beta/_beta_features_test.py
@@ -163,7 +163,10 @@ class BetaFeaturesTest(unittest.TestCase):
         self._server = implementations.server(
             method_implementations, options=server_options)
         server_credentials = implementations.ssl_server_credentials([
-            (resources.private_key(), resources.certificate_chain(),),
+            (
+                resources.private_key(),
+                resources.certificate_chain(),
+            ),
         ])
         port = self._server.add_secure_port('[::]:0', server_credentials)
         self._server.start()
@@ -289,7 +292,10 @@ class ContextManagementAndLifecycleTest(unittest.TestCase):
         self._server_options = implementations.server_options(
             thread_pool_size=test_constants.POOL_SIZE)
         self._server_credentials = implementations.ssl_server_credentials([
-            (resources.private_key(), resources.certificate_chain(),),
+            (
+                resources.private_key(),
+                resources.certificate_chain(),
+            ),
         ])
         self._channel_credentials = implementations.ssl_channel_credentials(
             resources.test_root_certificates())
diff --git a/src/python/grpcio_tests/tests/unit/beta/_face_interface_test.py b/src/python/grpcio_tests/tests/unit/beta/_face_interface_test.py
index e4b81e7e78..c99738e085 100644
--- a/src/python/grpcio_tests/tests/unit/beta/_face_interface_test.py
+++ b/src/python/grpcio_tests/tests/unit/beta/_face_interface_test.py
@@ -32,8 +32,11 @@ _SERVER_HOST_OVERRIDE = 'foo.test.google.fr'
 
 class _SerializationBehaviors(
         collections.namedtuple('_SerializationBehaviors', (
-            'request_serializers', 'request_deserializers',
-            'response_serializers', 'response_deserializers',))):
+            'request_serializers',
+            'request_deserializers',
+            'response_serializers',
+            'response_deserializers',
+        ))):
     pass
 
 
@@ -73,7 +76,10 @@ class _Implementation(test_interfaces.Implementation):
         server = implementations.server(
             method_implementations, options=server_options)
         server_credentials = implementations.ssl_server_credentials([
-            (resources.private_key(), resources.certificate_chain(),),
+            (
+                resources.private_key(),
+                resources.certificate_chain(),
+            ),
         ])
         port = server.add_secure_port('[::]:0', server_credentials)
         server.start()
@@ -116,9 +122,10 @@ class _Implementation(test_interfaces.Implementation):
 
 
 def load_tests(loader, tests, pattern):
-    return unittest.TestSuite(tests=tuple(
-        loader.loadTestsFromTestCase(test_case_class)
-        for test_case_class in test_cases.test_cases(_Implementation())))
+    return unittest.TestSuite(
+        tests=tuple(
+            loader.loadTestsFromTestCase(test_case_class)
+            for test_case_class in test_cases.test_cases(_Implementation())))
 
 
 if __name__ == '__main__':
diff --git a/src/python/grpcio_tests/tests/unit/beta/_implementations_test.py b/src/python/grpcio_tests/tests/unit/beta/_implementations_test.py
index 75a615eeff..5a53766d29 100644
--- a/src/python/grpcio_tests/tests/unit/beta/_implementations_test.py
+++ b/src/python/grpcio_tests/tests/unit/beta/_implementations_test.py
@@ -41,8 +41,8 @@ class CallCredentialsTest(unittest.TestCase):
     def test_google_call_credentials(self):
         creds = oauth2client_client.GoogleCredentials(
             'token', 'client_id', 'secret', 'refresh_token',
-            datetime.datetime(2008, 6, 24), 'https://refresh.uri.com/',
-            'user_agent')
+            datetime.datetime(2008, 6,
+                              24), 'https://refresh.uri.com/', 'user_agent')
         call_creds = implementations.google_call_credentials(creds)
         self.assertIsInstance(call_creds, implementations.CallCredentials)
 
diff --git a/src/python/grpcio_tests/tests/unit/beta/test_utilities.py b/src/python/grpcio_tests/tests/unit/beta/test_utilities.py
index 65da0f2020..c8d920d35e 100644
--- a/src/python/grpcio_tests/tests/unit/beta/test_utilities.py
+++ b/src/python/grpcio_tests/tests/unit/beta/test_utilities.py
@@ -33,6 +33,8 @@ def not_really_secure_channel(host, port, channel_credentials,
       conducted.
   """
     target = '%s:%d' % (host, port)
-    channel = grpc.secure_channel(target, channel_credentials, (
-        ('grpc.ssl_target_name_override', server_host_override,),))
+    channel = grpc.secure_channel(target, channel_credentials, ((
+        'grpc.ssl_target_name_override',
+        server_host_override,
+    ),))
     return implementations.Channel(channel)
diff --git a/src/python/grpcio_tests/tests/unit/framework/interfaces/face/_blocking_invocation_inline_service.py b/src/python/grpcio_tests/tests/unit/framework/interfaces/face/_blocking_invocation_inline_service.py
index 45fd321ed6..5d8679aa62 100644
--- a/src/python/grpcio_tests/tests/unit/framework/interfaces/face/_blocking_invocation_inline_service.py
+++ b/src/python/grpcio_tests/tests/unit/framework/interfaces/face/_blocking_invocation_inline_service.py
@@ -70,8 +70,8 @@ class TestCase(
         self.implementation.destantiate(self._memo)
 
     def testSuccessfulUnaryRequestUnaryResponse(self):
-        for (group, method), test_messages_sequence in (
-                six.iteritems(self._digest.unary_unary_messages_sequences)):
+        for (group, method), test_messages_sequence in (six.iteritems(
+                self._digest.unary_unary_messages_sequences)):
             for test_messages in test_messages_sequence:
                 request = test_messages.request()
 
@@ -81,8 +81,8 @@ class TestCase(
                 test_messages.verify(request, response, self)
 
     def testSuccessfulUnaryRequestStreamResponse(self):
-        for (group, method), test_messages_sequence in (
-                six.iteritems(self._digest.unary_stream_messages_sequences)):
+        for (group, method), test_messages_sequence in (six.iteritems(
+                self._digest.unary_stream_messages_sequences)):
             for test_messages in test_messages_sequence:
                 request = test_messages.request()
 
@@ -93,8 +93,8 @@ class TestCase(
                 test_messages.verify(request, responses, self)
 
     def testSuccessfulStreamRequestUnaryResponse(self):
-        for (group, method), test_messages_sequence in (
-                six.iteritems(self._digest.stream_unary_messages_sequences)):
+        for (group, method), test_messages_sequence in (six.iteritems(
+                self._digest.stream_unary_messages_sequences)):
             for test_messages in test_messages_sequence:
                 requests = test_messages.requests()
 
@@ -104,8 +104,8 @@ class TestCase(
                 test_messages.verify(requests, response, self)
 
     def testSuccessfulStreamRequestStreamResponse(self):
-        for (group, method), test_messages_sequence in (
-                six.iteritems(self._digest.stream_stream_messages_sequences)):
+        for (group, method), test_messages_sequence in (six.iteritems(
+                self._digest.stream_stream_messages_sequences)):
             for test_messages in test_messages_sequence:
                 requests = test_messages.requests()
 
@@ -116,8 +116,8 @@ class TestCase(
                 test_messages.verify(requests, responses, self)
 
     def testSequentialInvocations(self):
-        for (group, method), test_messages_sequence in (
-                six.iteritems(self._digest.unary_unary_messages_sequences)):
+        for (group, method), test_messages_sequence in (six.iteritems(
+                self._digest.unary_unary_messages_sequences)):
             for test_messages in test_messages_sequence:
                 first_request = test_messages.request()
                 second_request = test_messages.request()
@@ -134,8 +134,8 @@ class TestCase(
 
     def testParallelInvocations(self):
         pool = logging_pool.pool(test_constants.THREAD_CONCURRENCY)
-        for (group, method), test_messages_sequence in (
-                six.iteritems(self._digest.unary_unary_messages_sequences)):
+        for (group, method), test_messages_sequence in (six.iteritems(
+                self._digest.unary_unary_messages_sequences)):
             for test_messages in test_messages_sequence:
                 requests = []
                 response_futures = []
@@ -158,8 +158,8 @@ class TestCase(
 
     def testWaitingForSomeButNotAllParallelInvocations(self):
         pool = logging_pool.pool(test_constants.THREAD_CONCURRENCY)
-        for (group, method), test_messages_sequence in (
-                six.iteritems(self._digest.unary_unary_messages_sequences)):
+        for (group, method), test_messages_sequence in (six.iteritems(
+                self._digest.unary_unary_messages_sequences)):
             for test_messages in test_messages_sequence:
                 requests = []
                 response_futures_to_indices = {}
@@ -197,8 +197,8 @@ class TestCase(
         raise NotImplementedError()
 
     def testExpiredUnaryRequestUnaryResponse(self):
-        for (group, method), test_messages_sequence in (
-                six.iteritems(self._digest.unary_unary_messages_sequences)):
+        for (group, method), test_messages_sequence in (six.iteritems(
+                self._digest.unary_unary_messages_sequences)):
             for test_messages in test_messages_sequence:
                 request = test_messages.request()
 
@@ -208,8 +208,8 @@ class TestCase(
                         request, _3069_test_constant.REALLY_SHORT_TIMEOUT)
 
     def testExpiredUnaryRequestStreamResponse(self):
-        for (group, method), test_messages_sequence in (
-                six.iteritems(self._digest.unary_stream_messages_sequences)):
+        for (group, method), test_messages_sequence in (six.iteritems(
+                self._digest.unary_stream_messages_sequences)):
             for test_messages in test_messages_sequence:
                 request = test_messages.request()
 
@@ -220,33 +220,33 @@ class TestCase(
                     list(response_iterator)
 
     def testExpiredStreamRequestUnaryResponse(self):
-        for (group, method), test_messages_sequence in (
-                six.iteritems(self._digest.stream_unary_messages_sequences)):
+        for (group, method), test_messages_sequence in (six.iteritems(
+                self._digest.stream_unary_messages_sequences)):
             for test_messages in test_messages_sequence:
                 requests = test_messages.requests()
 
                 with self._control.pause(), self.assertRaises(
                         face.ExpirationError):
-                    self._invoker.blocking(group, method)(
-                        iter(requests),
-                        _3069_test_constant.REALLY_SHORT_TIMEOUT)
+                    self._invoker.blocking(
+                        group, method)(iter(requests),
+                                       _3069_test_constant.REALLY_SHORT_TIMEOUT)
 
     def testExpiredStreamRequestStreamResponse(self):
-        for (group, method), test_messages_sequence in (
-                six.iteritems(self._digest.stream_stream_messages_sequences)):
+        for (group, method), test_messages_sequence in (six.iteritems(
+                self._digest.stream_stream_messages_sequences)):
             for test_messages in test_messages_sequence:
                 requests = test_messages.requests()
 
                 with self._control.pause(), self.assertRaises(
                         face.ExpirationError):
-                    response_iterator = self._invoker.blocking(group, method)(
-                        iter(requests),
-                        _3069_test_constant.REALLY_SHORT_TIMEOUT)
+                    response_iterator = self._invoker.blocking(
+                        group, method)(iter(requests),
+                                       _3069_test_constant.REALLY_SHORT_TIMEOUT)
                     list(response_iterator)
 
     def testFailedUnaryRequestUnaryResponse(self):
-        for (group, method), test_messages_sequence in (
-                six.iteritems(self._digest.unary_unary_messages_sequences)):
+        for (group, method), test_messages_sequence in (six.iteritems(
+                self._digest.unary_unary_messages_sequences)):
             for test_messages in test_messages_sequence:
                 request = test_messages.request()
 
@@ -255,8 +255,8 @@ class TestCase(
                         request, test_constants.LONG_TIMEOUT)
 
     def testFailedUnaryRequestStreamResponse(self):
-        for (group, method), test_messages_sequence in (
-                six.iteritems(self._digest.unary_stream_messages_sequences)):
+        for (group, method), test_messages_sequence in (six.iteritems(
+                self._digest.unary_stream_messages_sequences)):
             for test_messages in test_messages_sequence:
                 request = test_messages.request()
 
@@ -266,8 +266,8 @@ class TestCase(
                     list(response_iterator)
 
     def testFailedStreamRequestUnaryResponse(self):
-        for (group, method), test_messages_sequence in (
-                six.iteritems(self._digest.stream_unary_messages_sequences)):
+        for (group, method), test_messages_sequence in (six.iteritems(
+                self._digest.stream_unary_messages_sequences)):
             for test_messages in test_messages_sequence:
                 requests = test_messages.requests()
 
@@ -276,8 +276,8 @@ class TestCase(
                         iter(requests), test_constants.LONG_TIMEOUT)
 
     def testFailedStreamRequestStreamResponse(self):
-        for (group, method), test_messages_sequence in (
-                six.iteritems(self._digest.stream_stream_messages_sequences)):
+        for (group, method), test_messages_sequence in (six.iteritems(
+                self._digest.stream_stream_messages_sequences)):
             for test_messages in test_messages_sequence:
                 requests = test_messages.requests()
 
diff --git a/src/python/grpcio_tests/tests/unit/framework/interfaces/face/_digest.py b/src/python/grpcio_tests/tests/unit/framework/interfaces/face/_digest.py
index 0e399c4bc4..b1c33da43a 100644
--- a/src/python/grpcio_tests/tests/unit/framework/interfaces/face/_digest.py
+++ b/src/python/grpcio_tests/tests/unit/framework/interfaces/face/_digest.py
@@ -34,11 +34,15 @@ _IDENTITY = lambda x: x
 
 class TestServiceDigest(
         collections.namedtuple('TestServiceDigest', (
-            'methods', 'inline_method_implementations',
-            'event_method_implementations', 'multi_method_implementation',
-            'unary_unary_messages_sequences', 'unary_stream_messages_sequences',
+            'methods',
+            'inline_method_implementations',
+            'event_method_implementations',
+            'multi_method_implementation',
+            'unary_unary_messages_sequences',
+            'unary_stream_messages_sequences',
             'stream_unary_messages_sequences',
-            'stream_stream_messages_sequences',))):
+            'stream_stream_messages_sequences',
+        ))):
     """A transformation of a service.TestService.
 
   Attributes:
@@ -421,8 +425,8 @@ def digest(service, control, pool):
     events.update(stream_unary.events)
     events.update(stream_stream.events)
 
-    return TestServiceDigest(
-        methods, inlines, events,
-        _MultiMethodImplementation(adaptations, control, pool),
-        unary_unary.messages, unary_stream.messages, stream_unary.messages,
-        stream_stream.messages)
+    return TestServiceDigest(methods, inlines, events,
+                             _MultiMethodImplementation(adaptations, control,
+                                                        pool),
+                             unary_unary.messages, unary_stream.messages,
+                             stream_unary.messages, stream_stream.messages)
diff --git a/src/python/grpcio_tests/tests/unit/framework/interfaces/face/_future_invocation_asynchronous_event_service.py b/src/python/grpcio_tests/tests/unit/framework/interfaces/face/_future_invocation_asynchronous_event_service.py
index bc65bf4c80..3d9b2816aa 100644
--- a/src/python/grpcio_tests/tests/unit/framework/interfaces/face/_future_invocation_asynchronous_event_service.py
+++ b/src/python/grpcio_tests/tests/unit/framework/interfaces/face/_future_invocation_asynchronous_event_service.py
@@ -134,8 +134,8 @@ class TestCase(
         self._digest_pool.shutdown(wait=True)
 
     def testSuccessfulUnaryRequestUnaryResponse(self):
-        for (group, method), test_messages_sequence in (
-                six.iteritems(self._digest.unary_unary_messages_sequences)):
+        for (group, method), test_messages_sequence in (six.iteritems(
+                self._digest.unary_unary_messages_sequences)):
             for test_messages in test_messages_sequence:
                 request = test_messages.request()
                 callback = _Callback()
@@ -151,8 +151,8 @@ class TestCase(
                 self.assertIsNone(response_future.traceback())
 
     def testSuccessfulUnaryRequestStreamResponse(self):
-        for (group, method), test_messages_sequence in (
-                six.iteritems(self._digest.unary_stream_messages_sequences)):
+        for (group, method), test_messages_sequence in (six.iteritems(
+                self._digest.unary_stream_messages_sequences)):
             for test_messages in test_messages_sequence:
                 request = test_messages.request()
 
@@ -163,8 +163,8 @@ class TestCase(
                 test_messages.verify(request, responses, self)
 
     def testSuccessfulStreamRequestUnaryResponse(self):
-        for (group, method), test_messages_sequence in (
-                six.iteritems(self._digest.stream_unary_messages_sequences)):
+        for (group, method), test_messages_sequence in (six.iteritems(
+                self._digest.stream_unary_messages_sequences)):
             for test_messages in test_messages_sequence:
                 requests = test_messages.requests()
                 request_iterator = _PauseableIterator(iter(requests))
@@ -185,8 +185,8 @@ class TestCase(
                 self.assertIsNone(response_future.traceback())
 
     def testSuccessfulStreamRequestStreamResponse(self):
-        for (group, method), test_messages_sequence in (
-                six.iteritems(self._digest.stream_stream_messages_sequences)):
+        for (group, method), test_messages_sequence in (six.iteritems(
+                self._digest.stream_stream_messages_sequences)):
             for test_messages in test_messages_sequence:
                 requests = test_messages.requests()
                 request_iterator = _PauseableIterator(iter(requests))
@@ -201,8 +201,8 @@ class TestCase(
                 test_messages.verify(requests, responses, self)
 
     def testSequentialInvocations(self):
-        for (group, method), test_messages_sequence in (
-                six.iteritems(self._digest.unary_unary_messages_sequences)):
+        for (group, method), test_messages_sequence in (six.iteritems(
+                self._digest.unary_unary_messages_sequences)):
             for test_messages in test_messages_sequence:
                 first_request = test_messages.request()
                 second_request = test_messages.request()
@@ -220,8 +220,8 @@ class TestCase(
                 test_messages.verify(second_request, second_response, self)
 
     def testParallelInvocations(self):
-        for (group, method), test_messages_sequence in (
-                six.iteritems(self._digest.unary_unary_messages_sequences)):
+        for (group, method), test_messages_sequence in (six.iteritems(
+                self._digest.unary_unary_messages_sequences)):
             for test_messages in test_messages_sequence:
                 first_request = test_messages.request()
                 second_request = test_messages.request()
@@ -236,8 +236,8 @@ class TestCase(
                 test_messages.verify(first_request, first_response, self)
                 test_messages.verify(second_request, second_response, self)
 
-        for (group, method), test_messages_sequence in (
-                six.iteritems(self._digest.unary_unary_messages_sequences)):
+        for (group, method), test_messages_sequence in (six.iteritems(
+                self._digest.unary_unary_messages_sequences)):
             for test_messages in test_messages_sequence:
                 requests = []
                 response_futures = []
@@ -258,8 +258,8 @@ class TestCase(
 
     def testWaitingForSomeButNotAllParallelInvocations(self):
         pool = logging_pool.pool(test_constants.THREAD_CONCURRENCY)
-        for (group, method), test_messages_sequence in (
-                six.iteritems(self._digest.unary_unary_messages_sequences)):
+        for (group, method), test_messages_sequence in (six.iteritems(
+                self._digest.unary_unary_messages_sequences)):
             for test_messages in test_messages_sequence:
                 requests = []
                 response_futures_to_indices = {}
@@ -282,8 +282,8 @@ class TestCase(
         pool.shutdown(wait=True)
 
     def testCancelledUnaryRequestUnaryResponse(self):
-        for (group, method), test_messages_sequence in (
-                six.iteritems(self._digest.unary_unary_messages_sequences)):
+        for (group, method), test_messages_sequence in (six.iteritems(
+                self._digest.unary_unary_messages_sequences)):
             for test_messages in test_messages_sequence:
                 request = test_messages.request()
                 callback = _Callback()
@@ -305,8 +305,8 @@ class TestCase(
                     response_future.traceback()
 
     def testCancelledUnaryRequestStreamResponse(self):
-        for (group, method), test_messages_sequence in (
-                six.iteritems(self._digest.unary_stream_messages_sequences)):
+        for (group, method), test_messages_sequence in (six.iteritems(
+                self._digest.unary_stream_messages_sequences)):
             for test_messages in test_messages_sequence:
                 request = test_messages.request()
 
@@ -319,8 +319,8 @@ class TestCase(
                     next(response_iterator)
 
     def testCancelledStreamRequestUnaryResponse(self):
-        for (group, method), test_messages_sequence in (
-                six.iteritems(self._digest.stream_unary_messages_sequences)):
+        for (group, method), test_messages_sequence in (six.iteritems(
+                self._digest.stream_unary_messages_sequences)):
             for test_messages in test_messages_sequence:
                 requests = test_messages.requests()
                 callback = _Callback()
@@ -342,8 +342,8 @@ class TestCase(
                     response_future.traceback()
 
     def testCancelledStreamRequestStreamResponse(self):
-        for (group, method), test_messages_sequence in (
-                six.iteritems(self._digest.stream_stream_messages_sequences)):
+        for (group, method), test_messages_sequence in (six.iteritems(
+                self._digest.stream_stream_messages_sequences)):
             for test_messages in test_messages_sequence:
                 requests = test_messages.requests()
 
@@ -356,8 +356,8 @@ class TestCase(
                     next(response_iterator)
 
     def testExpiredUnaryRequestUnaryResponse(self):
-        for (group, method), test_messages_sequence in (
-                six.iteritems(self._digest.unary_unary_messages_sequences)):
+        for (group, method), test_messages_sequence in (six.iteritems(
+                self._digest.unary_unary_messages_sequences)):
             for test_messages in test_messages_sequence:
                 request = test_messages.request()
                 callback = _Callback()
@@ -376,8 +376,8 @@ class TestCase(
                     self.assertIsNotNone(response_future.traceback())
 
     def testExpiredUnaryRequestStreamResponse(self):
-        for (group, method), test_messages_sequence in (
-                six.iteritems(self._digest.unary_stream_messages_sequences)):
+        for (group, method), test_messages_sequence in (six.iteritems(
+                self._digest.unary_stream_messages_sequences)):
             for test_messages in test_messages_sequence:
                 request = test_messages.request()
 
@@ -388,16 +388,16 @@ class TestCase(
                         list(response_iterator)
 
     def testExpiredStreamRequestUnaryResponse(self):
-        for (group, method), test_messages_sequence in (
-                six.iteritems(self._digest.stream_unary_messages_sequences)):
+        for (group, method), test_messages_sequence in (six.iteritems(
+                self._digest.stream_unary_messages_sequences)):
             for test_messages in test_messages_sequence:
                 requests = test_messages.requests()
                 callback = _Callback()
 
                 with self._control.pause():
-                    response_future = self._invoker.future(group, method)(
-                        iter(requests),
-                        _3069_test_constant.REALLY_SHORT_TIMEOUT)
+                    response_future = self._invoker.future(
+                        group, method)(iter(requests),
+                                       _3069_test_constant.REALLY_SHORT_TIMEOUT)
                     response_future.add_done_callback(callback)
                     self.assertIs(callback.future(), response_future)
                     self.assertIsInstance(response_future.exception(),
@@ -409,21 +409,21 @@ class TestCase(
                     self.assertIsNotNone(response_future.traceback())
 
     def testExpiredStreamRequestStreamResponse(self):
-        for (group, method), test_messages_sequence in (
-                six.iteritems(self._digest.stream_stream_messages_sequences)):
+        for (group, method), test_messages_sequence in (six.iteritems(
+                self._digest.stream_stream_messages_sequences)):
             for test_messages in test_messages_sequence:
                 requests = test_messages.requests()
 
                 with self._control.pause():
-                    response_iterator = self._invoker.future(group, method)(
-                        iter(requests),
-                        _3069_test_constant.REALLY_SHORT_TIMEOUT)
+                    response_iterator = self._invoker.future(
+                        group, method)(iter(requests),
+                                       _3069_test_constant.REALLY_SHORT_TIMEOUT)
                     with self.assertRaises(face.ExpirationError):
                         list(response_iterator)
 
     def testFailedUnaryRequestUnaryResponse(self):
-        for (group, method), test_messages_sequence in (
-                six.iteritems(self._digest.unary_unary_messages_sequences)):
+        for (group, method), test_messages_sequence in (six.iteritems(
+                self._digest.unary_unary_messages_sequences)):
             for test_messages in test_messages_sequence:
                 request = test_messages.request()
                 callback = _Callback()
@@ -448,8 +448,8 @@ class TestCase(
                     self.assertIsNotNone(abortion_callback.future())
 
     def testFailedUnaryRequestStreamResponse(self):
-        for (group, method), test_messages_sequence in (
-                six.iteritems(self._digest.unary_stream_messages_sequences)):
+        for (group, method), test_messages_sequence in (six.iteritems(
+                self._digest.unary_stream_messages_sequences)):
             for test_messages in test_messages_sequence:
                 request = test_messages.request()
 
@@ -464,17 +464,17 @@ class TestCase(
                     list(response_iterator)
 
     def testFailedStreamRequestUnaryResponse(self):
-        for (group, method), test_messages_sequence in (
-                six.iteritems(self._digest.stream_unary_messages_sequences)):
+        for (group, method), test_messages_sequence in (six.iteritems(
+                self._digest.stream_unary_messages_sequences)):
             for test_messages in test_messages_sequence:
                 requests = test_messages.requests()
                 callback = _Callback()
                 abortion_callback = _Callback()
 
                 with self._control.fail():
-                    response_future = self._invoker.future(group, method)(
-                        iter(requests),
-                        _3069_test_constant.REALLY_SHORT_TIMEOUT)
+                    response_future = self._invoker.future(
+                        group, method)(iter(requests),
+                                       _3069_test_constant.REALLY_SHORT_TIMEOUT)
                     response_future.add_done_callback(callback)
                     response_future.add_abortion_callback(abortion_callback)
 
@@ -491,8 +491,8 @@ class TestCase(
                     self.assertIsNotNone(abortion_callback.future())
 
     def testFailedStreamRequestStreamResponse(self):
-        for (group, method), test_messages_sequence in (
-                six.iteritems(self._digest.stream_stream_messages_sequences)):
+        for (group, method), test_messages_sequence in (six.iteritems(
+                self._digest.stream_stream_messages_sequences)):
             for test_messages in test_messages_sequence:
                 requests = test_messages.requests()
 
@@ -502,7 +502,7 @@ class TestCase(
                 # expiration of the RPC.
                 with self._control.fail(), self.assertRaises(
                         face.ExpirationError):
-                    response_iterator = self._invoker.future(group, method)(
-                        iter(requests),
-                        _3069_test_constant.REALLY_SHORT_TIMEOUT)
+                    response_iterator = self._invoker.future(
+                        group, method)(iter(requests),
+                                       _3069_test_constant.REALLY_SHORT_TIMEOUT)
                     list(response_iterator)
diff --git a/src/python/grpcio_tests/tests/unit/framework/interfaces/face/_invocation.py b/src/python/grpcio_tests/tests/unit/framework/interfaces/face/_invocation.py
index fd55f4e09f..efc93d56b0 100644
--- a/src/python/grpcio_tests/tests/unit/framework/interfaces/face/_invocation.py
+++ b/src/python/grpcio_tests/tests/unit/framework/interfaces/face/_invocation.py
@@ -191,5 +191,8 @@ def invoker_constructors():
   Returns:
     A sequence of InvokerConstructors.
   """
-    return (_GenericInvokerConstructor(), _MultiCallableInvokerConstructor(),
-            _DynamicInvokerConstructor(),)
+    return (
+        _GenericInvokerConstructor(),
+        _MultiCallableInvokerConstructor(),
+        _DynamicInvokerConstructor(),
+    )
diff --git a/src/python/grpcio_tests/tests/unit/framework/interfaces/face/_stock_service.py b/src/python/grpcio_tests/tests/unit/framework/interfaces/face/_stock_service.py
index 69c7ac2d73..a84e02a79a 100644
--- a/src/python/grpcio_tests/tests/unit/framework/interfaces/face/_stock_service.py
+++ b/src/python/grpcio_tests/tests/unit/framework/interfaces/face/_stock_service.py
@@ -33,8 +33,8 @@ def _get_last_trade_price(stock_request, stock_reply_callback, control, active):
     if active():
         stock_reply_callback(
             stock_pb2.StockReply(
-                symbol=stock_request.symbol, price=_price(
-                    stock_request.symbol)))
+                symbol=stock_request.symbol,
+                price=_price(stock_request.symbol)))
     else:
         raise abandonment.Abandoned()
 
diff --git a/src/python/grpcio_tests/tests/unit/framework/interfaces/face/test_cases.py b/src/python/grpcio_tests/tests/unit/framework/interfaces/face/test_cases.py
index d1c5b8f76b..cff4b7cdea 100644
--- a/src/python/grpcio_tests/tests/unit/framework/interfaces/face/test_cases.py
+++ b/src/python/grpcio_tests/tests/unit/framework/interfaces/face/test_cases.py
@@ -24,7 +24,8 @@ from tests.unit.framework.interfaces.face import test_interfaces  # pylint: disa
 
 _TEST_CASE_SUPERCLASSES = (
     _blocking_invocation_inline_service.TestCase,
-    _future_invocation_asynchronous_event_service.TestCase,)
+    _future_invocation_asynchronous_event_service.TestCase,
+)
 
 
 def test_cases(implementation):
@@ -42,8 +43,9 @@ def test_cases(implementation):
     for invoker_constructor in _invocation.invoker_constructors():
         for super_class in _TEST_CASE_SUPERCLASSES:
             test_case_classes.append(
-                type(invoker_constructor.name() + super_class.NAME, (
-                    super_class,), {
+                type(
+                    invoker_constructor.name() + super_class.NAME,
+                    (super_class,), {
                         'implementation': implementation,
                         'invoker_constructor': invoker_constructor,
                         '__module__': implementation.__module__,
diff --git a/src/python/grpcio_tests/tests/unit/resources.py b/src/python/grpcio_tests/tests/unit/resources.py
index 11ef9e8565..51a8979f58 100644
--- a/src/python/grpcio_tests/tests/unit/resources.py
+++ b/src/python/grpcio_tests/tests/unit/resources.py
@@ -58,7 +58,8 @@ def cert_hier_1_client_1_key():
 def cert_hier_1_client_1_cert():
     return pkg_resources.resource_string(
         __name__,
-        'credentials/certificate_hierarchy_1/intermediate/certs/client.cert.pem')
+        'credentials/certificate_hierarchy_1/intermediate/certs/client.cert.pem'
+    )
 
 
 def cert_hier_1_server_1_key():
@@ -97,7 +98,8 @@ def cert_hier_2_client_1_key():
 def cert_hier_2_client_1_cert():
     return pkg_resources.resource_string(
         __name__,
-        'credentials/certificate_hierarchy_2/intermediate/certs/client.cert.pem')
+        'credentials/certificate_hierarchy_2/intermediate/certs/client.cert.pem'
+    )
 
 
 def cert_hier_2_server_1_key():
diff --git a/src/python/grpcio_tests/tests/unit/test_common.py b/src/python/grpcio_tests/tests/unit/test_common.py
index 6334a32b0e..61717ae135 100644
--- a/src/python/grpcio_tests/tests/unit/test_common.py
+++ b/src/python/grpcio_tests/tests/unit/test_common.py
@@ -19,9 +19,21 @@ from concurrent import futures
 import grpc
 import six
 
-INVOCATION_INITIAL_METADATA = (('0', 'abc'), ('1', 'def'), ('2', 'ghi'),)
-SERVICE_INITIAL_METADATA = (('3', 'jkl'), ('4', 'mno'), ('5', 'pqr'),)
-SERVICE_TERMINAL_METADATA = (('6', 'stu'), ('7', 'vwx'), ('8', 'yza'),)
+INVOCATION_INITIAL_METADATA = (
+    ('0', 'abc'),
+    ('1', 'def'),
+    ('2', 'ghi'),
+)
+SERVICE_INITIAL_METADATA = (
+    ('3', 'jkl'),
+    ('4', 'mno'),
+    ('5', 'pqr'),
+)
+SERVICE_TERMINAL_METADATA = (
+    ('6', 'stu'),
+    ('7', 'vwx'),
+    ('8', 'yza'),
+)
 DETAILS = 'test details'
 
 
@@ -80,8 +92,10 @@ def test_secure_channel(target, channel_credentials, server_host_override):
     An implementations.Channel to the remote host through which RPCs may be
       conducted.
   """
-    channel = grpc.secure_channel(target, channel_credentials, (
-        ('grpc.ssl_target_name_override', server_host_override,),))
+    channel = grpc.secure_channel(target, channel_credentials, ((
+        'grpc.ssl_target_name_override',
+        server_host_override,
+    ),))
     return channel